QGtkStyle refactoring

The QGtk class has been refactored into a private d class for QGtkStyle.
This allows us to re-use a lot of code for the Maemo5 style without changing
a single line in QGtkStyle itself plus we can easily add virtual functions
where the two styles need to behave different.
There shouldn't be any new functionality added (or old functionality lost) by
this commit.

Reviewed-By: jbache
Reviewed-By: Ralf Engels

13 files changed, 1455 insertions, 1350 deletions

diff --git a/src/gui/image/qiconloader.cpp b/src/gui/image/qiconloader.cpp
index 234f271f67..15af7a2e4b 100644
--- a/src/gui/image/qiconloader.cpp
+++ b/src/gui/image/qiconloader.cpp
@@ -61,7 +61,6 @@
 
 #ifdef Q_WS_X11
 #include <private/qt_x11_p.h>
-#include <private/gtksymbols_p.h>
 #endif
 
 QT_BEGIN_NAMESPACE
diff --git a/src/gui/itemviews/qfileiconprovider.cpp b/src/gui/itemviews/qfileiconprovider.cpp
index e3d17ade04..631679713e 100644
--- a/src/gui/itemviews/qfileiconprovider.cpp
+++ b/src/gui/itemviews/qfileiconprovider.cpp
@@ -47,24 +47,24 @@
 #include <qdir.h>
 #include <qpixmapcache.h>
 #if defined(Q_WS_WIN)
-#define _WIN32_IE 0x0500
-#include <qt_windows.h>
-#include <commctrl.h>
-#include <objbase.h>
+#  define _WIN32_IE 0x0500
+#  include <qt_windows.h>
+#  include <commctrl.h>
+#  include <objbase.h>
 #elif defined(Q_WS_MAC)
-#include <private/qt_cocoa_helpers_mac_p.h>
-#endif
-
-#if defined(Q_WS_X11) && !defined(Q_NO_STYLE_GTK)
-#include <private/qt_x11_p.h>
-#include <private/gtksymbols_p.h>
+#  include <private/qt_cocoa_helpers_mac_p.h>
 #endif
 
 #include <private/qfunctions_p.h>
 #include <private/qguiplatformplugin_p.h>
 
+#if defined(Q_WS_X11) && !defined(Q_NO_STYLE_GTK)
+#  include <private/qgtkstyle_p.h>
+#  include <private/qt_x11_p.h>
+#endif
+
 #ifndef SHGFI_ADDOVERLAYS
-#define SHGFI_ADDOVERLAYS 0x000000020
+#  define SHGFI_ADDOVERLAYS 0x000000020
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -392,7 +392,7 @@ QIcon QFileIconProvider::icon(const QFileInfo &info) const
 
 #if defined(Q_WS_X11) && !defined(QT_NO_STYLE_GTK)
     if (X11->desktopEnvironment == DE_GNOME) {
-        QIcon gtkIcon = QGtk::getFilesystemIcon(info);
+        QIcon gtkIcon = QGtkStylePrivate::getFilesystemIcon(info);
         if (!gtkIcon.isNull())
             return gtkIcon;
     }
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index b0ab760f20..b71ae73a46 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -79,7 +79,7 @@
 #include <private/qcolor_p.h>
 #include <private/qcursor_p.h>
 #include <private/qiconloader_p.h>
-#include <private/gtksymbols_p.h>
+#include <qgtkstyle.h>
 #include "qstyle.h"
 #include "qmetaobject.h"
 #include "qtimer.h"
@@ -2299,7 +2299,7 @@ void qt_init(QApplicationPrivate *priv, int,
 
 #if !defined(QT_NO_STYLE_GTK)
         if (X11->desktopEnvironment == DE_GNOME) {
-            static bool menusHaveIcons = QGtk::getGConfBool(QLatin1String("/desktop/gnome/interface/menus_have_icons"), true);
+            static bool menusHaveIcons = QGtkStyle::getGConfBool(QLatin1String("/desktop/gnome/interface/menus_have_icons"), true);
             QApplication::setAttribute(Qt::AA_DontShowIconsInMenus, !menusHaveIcons);
         }
 #endif
diff --git a/src/gui/kernel/qguiplatformplugin.cpp b/src/gui/kernel/qguiplatformplugin.cpp
index b01d40fe63..e6efec1bf9 100644
--- a/src/gui/kernel/qguiplatformplugin.cpp
+++ b/src/gui/kernel/qguiplatformplugin.cpp
@@ -59,9 +59,9 @@ extern bool qt_wince_is_pocket_pc();  //qguifunctions_wince.cpp
 
 
 #if defined(Q_WS_X11)
-#include "qkde_p.h"
-#include "qt_x11_p.h"
-#include <private/gtksymbols_p.h>
+#include <private/qkde_p.h>
+#include <private/qgtkstyle_p.h>
+#include <private/qt_x11_p.h>
 #endif
 
 
@@ -206,7 +206,7 @@ QString QGuiPlatformPlugin::systemIconThemeName()
     if (X11->desktopEnvironment == DE_GNOME) {
         result = QString::fromLatin1("gnome");
 #ifndef QT_NO_STYLE_GTK
-        result = QGtk::getGConfString(QLatin1String("/desktop/gnome/interface/icon_theme"), result);
+        result = QGtkStylePrivate::getGConfString(QLatin1String("/desktop/gnome/interface/icon_theme"), result);
 #endif
     } else if (X11->desktopEnvironment == DE_KDE) {
         result =  X11->desktopVersion >= 4 ? QString::fromLatin1("oxygen") : QString::fromLatin1("crystalsvg");
diff --git a/src/gui/styles/gtksymbols.cpp b/src/gui/styles/gtksymbols.cpp
deleted file mode 100644
index 32fde628d5..0000000000
--- a/src/gui/styles/gtksymbols.cpp
+++ /dev/null
@@ -1,1008 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the QtGui module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights.  These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "gtksymbols_p.h"
-
-// This file is responsible for resolving all GTK functions we use
-// dynamically. This is done to avoid link-time dependancy on GTK
-// as well as crashes occurring due to usage of the GTK_QT engines
-//
-// Additionally we create a map of common GTK widgets that we can pass
-// to the GTK theme engine as many engines resort to querying the
-// actual widget pointers for details that are not covered by the
-// state flags
-
-#include <QtCore/qglobal.h>
-#if !defined(QT_NO_STYLE_GTK)
-
-#include <QtCore/QEvent>
-#include <QtCore/QFile>
-#include <QtCore/QStringList>
-#include <QtCore/QTextStream>
-#include <QtCore/QHash>
-#include <QtCore/QUrl>
-
-#include <private/qapplication_p.h>
-#include <private/qiconloader_p.h>
-
-#include <QtGui/QMenu>
-#include <QtGui/QStyle>
-#include <QtGui/QApplication>
-#include <QtGui/QPixmapCache>
-#include <QtGui/QStatusBar>
-#include <QtGui/QMenuBar>
-#include <QtGui/QToolBar>
-#include <QtGui/QToolButton>
-#include <QtGui/QX11Info>
-
-#include <X11/Xlib.h>
-
-QT_BEGIN_NAMESPACE
-
-static bool displayDepth  =  -1;
-Q_GLOBAL_STATIC(QGtkStyleUpdateScheduler, styleScheduler)
-
-typedef QHash<QString, GtkWidget*> WidgetMap;
-Q_GLOBAL_STATIC(WidgetMap, gtkWidgetMap)
-
-Ptr_gtk_container_forall QGtk::gtk_container_forall = 0;
-Ptr_gtk_init QGtk::gtk_init = 0;
-Ptr_gtk_style_attach QGtk::gtk_style_attach = 0;
-Ptr_gtk_window_new QGtk::gtk_window_new = 0;
-Ptr_gtk_widget_destroy QGtk::gtk_widget_destroy = 0;
-Ptr_gtk_widget_realize QGtk::gtk_widget_realize = 0;
-Ptr_gtk_widget_set_default_direction QGtk::gtk_widget_set_default_direction = 0;
-Ptr_gtk_widget_modify_color QGtk::gtk_widget_modify_fg = 0;
-Ptr_gtk_widget_modify_color QGtk::gtk_widget_modify_bg = 0;
-Ptr_gtk_arrow_new QGtk::gtk_arrow_new = 0;
-Ptr_gtk_menu_item_new QGtk::gtk_menu_item_new = 0;
-Ptr_gtk_check_menu_item_new QGtk::gtk_check_menu_item_new = 0;
-Ptr_gtk_menu_bar_new QGtk::gtk_menu_bar_new = 0;
-Ptr_gtk_menu_new QGtk::gtk_menu_new = 0;
-Ptr_gtk_button_new QGtk::gtk_button_new = 0;
-Ptr_gtk_tool_button_new QGtk::gtk_tool_button_new = 0;
-Ptr_gtk_hbutton_box_new QGtk::gtk_hbutton_box_new = 0;
-Ptr_gtk_check_button_new QGtk::gtk_check_button_new = 0;
-Ptr_gtk_radio_button_new QGtk::gtk_radio_button_new = 0;
-Ptr_gtk_spin_button_new QGtk::gtk_spin_button_new = 0;
-Ptr_gtk_frame_new QGtk::gtk_frame_new = 0;
-Ptr_gtk_expander_new QGtk::gtk_expander_new = 0;
-Ptr_gtk_statusbar_new QGtk::gtk_statusbar_new = 0;
-Ptr_gtk_entry_new QGtk::gtk_entry_new = 0;
-Ptr_gtk_hscale_new QGtk::gtk_hscale_new = 0;
-Ptr_gtk_vscale_new QGtk::gtk_vscale_new = 0;
-Ptr_gtk_hscrollbar_new QGtk::gtk_hscrollbar_new = 0;
-Ptr_gtk_vscrollbar_new QGtk::gtk_vscrollbar_new = 0;
-Ptr_gtk_scrolled_window_new QGtk::gtk_scrolled_window_new = 0;
-Ptr_gtk_notebook_new QGtk::gtk_notebook_new = 0;
-Ptr_gtk_toolbar_new QGtk::gtk_toolbar_new = 0;
-Ptr_gtk_toolbar_insert QGtk::gtk_toolbar_insert = 0;
-Ptr_gtk_separator_tool_item_new QGtk::gtk_separator_tool_item_new = 0;
-Ptr_gtk_tree_view_new QGtk::gtk_tree_view_new = 0;
-Ptr_gtk_combo_box_new QGtk::gtk_combo_box_new = 0;
-Ptr_gtk_combo_box_entry_new QGtk::gtk_combo_box_entry_new = 0;
-Ptr_gtk_progress_bar_new QGtk::gtk_progress_bar_new = 0;
-Ptr_gtk_container_add QGtk::gtk_container_add = 0;
-Ptr_gtk_menu_shell_append QGtk::gtk_menu_shell_append = 0;
-Ptr_gtk_progress_set_adjustment QGtk::gtk_progress_set_adjustment = 0;
-Ptr_gtk_range_set_adjustment QGtk::gtk_range_set_adjustment = 0;
-Ptr_gtk_range_set_inverted QGtk::gtk_range_set_inverted = 0;
-Ptr_gtk_icon_factory_lookup_default QGtk::gtk_icon_factory_lookup_default = 0;
-Ptr_gtk_icon_theme_get_default QGtk::gtk_icon_theme_get_default = 0;
-Ptr_gtk_widget_style_get QGtk::gtk_widget_style_get = 0;
-Ptr_gtk_icon_set_render_icon QGtk::gtk_icon_set_render_icon = 0;
-Ptr_gtk_fixed_new QGtk::gtk_fixed_new = 0;
-Ptr_gtk_tree_view_column_new QGtk::gtk_tree_view_column_new = 0;
-Ptr_gtk_tree_view_get_column QGtk::gtk_tree_view_get_column = 0;
-Ptr_gtk_tree_view_append_column QGtk::gtk_tree_view_append_column = 0;
-Ptr_gtk_paint_check QGtk::gtk_paint_check = 0;
-Ptr_gtk_paint_box QGtk::gtk_paint_box = 0;
-Ptr_gtk_paint_box_gap QGtk::gtk_paint_box_gap = 0;
-Ptr_gtk_paint_flat_box QGtk::gtk_paint_flat_box = 0;
-Ptr_gtk_paint_option QGtk::gtk_paint_option = 0;
-Ptr_gtk_paint_extension QGtk::gtk_paint_extension = 0;
-Ptr_gtk_paint_slider QGtk::gtk_paint_slider = 0;
-Ptr_gtk_paint_shadow QGtk::gtk_paint_shadow = 0;
-Ptr_gtk_paint_resize_grip QGtk::gtk_paint_resize_grip = 0;
-Ptr_gtk_paint_focus QGtk::gtk_paint_focus = 0;
-Ptr_gtk_paint_arrow QGtk::gtk_paint_arrow = 0;
-Ptr_gtk_paint_handle QGtk::gtk_paint_handle = 0;
-Ptr_gtk_paint_expander QGtk::gtk_paint_expander = 0;
-Ptr_gtk_adjustment_new QGtk::gtk_adjustment_new = 0;
-Ptr_gtk_paint_hline QGtk::gtk_paint_hline = 0;
-Ptr_gtk_paint_vline QGtk::gtk_paint_vline = 0;
-Ptr_gtk_menu_item_set_submenu QGtk::gtk_menu_item_set_submenu = 0;
-Ptr_gtk_settings_get_default QGtk::gtk_settings_get_default = 0;
-Ptr_gtk_separator_menu_item_new QGtk::gtk_separator_menu_item_new = 0;
-Ptr_gtk_widget_size_allocate QGtk::gtk_widget_size_allocate = 0;
-Ptr_gtk_widget_set_direction QGtk::gtk_widget_set_direction = 0;
-Ptr_gtk_widget_path QGtk::gtk_widget_path = 0;
-Ptr_gtk_container_get_type QGtk::gtk_container_get_type = 0;
-Ptr_gtk_window_get_type QGtk::gtk_window_get_type = 0;
-Ptr_gtk_widget_get_type QGtk::gtk_widget_get_type = 0;
-Ptr_gtk_rc_get_style_by_paths QGtk::gtk_rc_get_style_by_paths = 0;
-Ptr_gtk_check_version QGtk::gtk_check_version = 0;
-
-Ptr_pango_font_description_get_size QGtk::pango_font_description_get_size = 0;
-Ptr_pango_font_description_get_weight QGtk::pango_font_description_get_weight = 0;
-Ptr_pango_font_description_get_family QGtk::pango_font_description_get_family = 0;
-Ptr_pango_font_description_get_style QGtk::pango_font_description_get_style = 0;
-
-Ptr_gtk_file_filter_new QGtk::gtk_file_filter_new = 0;
-Ptr_gtk_file_filter_set_name QGtk::gtk_file_filter_set_name = 0;
-Ptr_gtk_file_filter_add_pattern QGtk::gtk_file_filter_add_pattern = 0;
-Ptr_gtk_file_chooser_add_filter QGtk::gtk_file_chooser_add_filter = 0;
-Ptr_gtk_file_chooser_set_filter QGtk::gtk_file_chooser_set_filter = 0;
-Ptr_gtk_file_chooser_get_filter QGtk::gtk_file_chooser_get_filter = 0;
-Ptr_gtk_file_chooser_dialog_new QGtk::gtk_file_chooser_dialog_new = 0;
-Ptr_gtk_file_chooser_set_current_folder QGtk::gtk_file_chooser_set_current_folder = 0;
-Ptr_gtk_file_chooser_get_filename QGtk::gtk_file_chooser_get_filename = 0;
-Ptr_gtk_file_chooser_get_filenames QGtk::gtk_file_chooser_get_filenames = 0;
-Ptr_gtk_file_chooser_set_current_name QGtk::gtk_file_chooser_set_current_name = 0;
-Ptr_gtk_dialog_run QGtk::gtk_dialog_run = 0;
-Ptr_gtk_file_chooser_set_filename QGtk::gtk_file_chooser_set_filename = 0;
-
-Ptr_gdk_pixbuf_get_pixels QGtk::gdk_pixbuf_get_pixels = 0;
-Ptr_gdk_pixbuf_get_width QGtk::gdk_pixbuf_get_width = 0;
-Ptr_gdk_pixbuf_get_height QGtk::gdk_pixbuf_get_height = 0;
-Ptr_gdk_pixmap_new QGtk::gdk_pixmap_new = 0;
-Ptr_gdk_pixbuf_new QGtk::gdk_pixbuf_new = 0;
-Ptr_gdk_pixbuf_get_from_drawable QGtk::gdk_pixbuf_get_from_drawable = 0;
-Ptr_gdk_draw_rectangle QGtk::gdk_draw_rectangle = 0;
-Ptr_gdk_pixbuf_unref QGtk::gdk_pixbuf_unref = 0;
-Ptr_gdk_drawable_unref QGtk::gdk_drawable_unref = 0;
-Ptr_gdk_drawable_get_depth QGtk::gdk_drawable_get_depth = 0;
-Ptr_gdk_color_free QGtk::gdk_color_free = 0;
-Ptr_gdk_x11_window_set_user_time QGtk::gdk_x11_window_set_user_time = 0;
-Ptr_gdk_x11_drawable_get_xid QGtk::gdk_x11_drawable_get_xid = 0;
-Ptr_gdk_x11_drawable_get_xdisplay QGtk::gdk_x11_drawable_get_xdisplay = 0;
-
-Ptr_gconf_client_get_default QGtk::gconf_client_get_default = 0;
-Ptr_gconf_client_get_string QGtk::gconf_client_get_string = 0;
-Ptr_gconf_client_get_bool QGtk::gconf_client_get_bool = 0;
-
-Ptr_gnome_icon_lookup_sync QGtk::gnome_icon_lookup_sync = 0;
-Ptr_gnome_vfs_init QGtk::gnome_vfs_init = 0;
-
-static QString classPath(GtkWidget *widget)
-{
-    char* class_path;
-    QGtk::gtk_widget_path (widget, NULL, &class_path, NULL);
-    QString path = QLS(class_path);
-    g_free(class_path);
-
-    // Remove the prefixes
-    path.remove(QLS("GtkWindow."));
-    path.remove(QLS("GtkFixed."));
-    return path;
-}
-
-static void resolveGtk()
-{
-    // enforce the "0" suffix, so we'll open libgtk-x11-2.0.so.0
-    QLibrary libgtk(QLS("gtk-x11-2.0"), 0, 0);
-    QGtk::gtk_init = (Ptr_gtk_init)libgtk.resolve("gtk_init");
-    QGtk::gtk_window_new = (Ptr_gtk_window_new)libgtk.resolve("gtk_window_new");
-    QGtk::gtk_style_attach = (Ptr_gtk_style_attach)libgtk.resolve("gtk_style_attach");
-    QGtk::gtk_widget_destroy = (Ptr_gtk_widget_destroy)libgtk.resolve("gtk_widget_destroy");
-    QGtk::gtk_widget_realize = (Ptr_gtk_widget_realize)libgtk.resolve("gtk_widget_realize");
-
-    QGtk::gtk_file_chooser_set_current_folder = (Ptr_gtk_file_chooser_set_current_folder)libgtk.resolve("gtk_file_chooser_set_current_folder");
-    QGtk::gtk_file_filter_new = (Ptr_gtk_file_filter_new)libgtk.resolve("gtk_file_filter_new");
-    QGtk::gtk_file_filter_set_name = (Ptr_gtk_file_filter_set_name)libgtk.resolve("gtk_file_filter_set_name");
-    QGtk::gtk_file_filter_add_pattern = (Ptr_gtk_file_filter_add_pattern)libgtk.resolve("gtk_file_filter_add_pattern");
-    QGtk::gtk_file_chooser_add_filter = (Ptr_gtk_file_chooser_add_filter)libgtk.resolve("gtk_file_chooser_add_filter");
-    QGtk::gtk_file_chooser_set_filter = (Ptr_gtk_file_chooser_set_filter)libgtk.resolve("gtk_file_chooser_set_filter");
-    QGtk::gtk_file_chooser_get_filter = (Ptr_gtk_file_chooser_get_filter)libgtk.resolve("gtk_file_chooser_get_filter");
-    QGtk::gtk_file_chooser_dialog_new = (Ptr_gtk_file_chooser_dialog_new)libgtk.resolve("gtk_file_chooser_dialog_new");
-    QGtk::gtk_file_chooser_set_current_folder = (Ptr_gtk_file_chooser_set_current_folder)libgtk.resolve("gtk_file_chooser_set_current_folder");
-    QGtk::gtk_file_chooser_get_filename = (Ptr_gtk_file_chooser_get_filename)libgtk.resolve("gtk_file_chooser_get_filename");
-    QGtk::gtk_file_chooser_get_filenames = (Ptr_gtk_file_chooser_get_filenames)libgtk.resolve("gtk_file_chooser_get_filenames");
-    QGtk::gtk_file_chooser_set_current_name = (Ptr_gtk_file_chooser_set_current_name)libgtk.resolve("gtk_file_chooser_set_current_name");
-    QGtk::gtk_dialog_run = (Ptr_gtk_dialog_run)libgtk.resolve("gtk_dialog_run");
-    QGtk::gtk_file_chooser_set_filename = (Ptr_gtk_file_chooser_set_filename)libgtk.resolve("gtk_file_chooser_set_filename");
-
-    QGtk::gdk_pixbuf_get_pixels = (Ptr_gdk_pixbuf_get_pixels)libgtk.resolve("gdk_pixbuf_get_pixels");
-    QGtk::gdk_pixbuf_get_width = (Ptr_gdk_pixbuf_get_width)libgtk.resolve("gdk_pixbuf_get_width");
-    QGtk::gdk_pixbuf_get_height = (Ptr_gdk_pixbuf_get_height)libgtk.resolve("gdk_pixbuf_get_height");
-    QGtk::gdk_pixmap_new = (Ptr_gdk_pixmap_new)libgtk.resolve("gdk_pixmap_new");
-    QGtk::gdk_pixbuf_new = (Ptr_gdk_pixbuf_new)libgtk.resolve("gdk_pixbuf_new");
-    QGtk::gdk_pixbuf_get_from_drawable = (Ptr_gdk_pixbuf_get_from_drawable)libgtk.resolve("gdk_pixbuf_get_from_drawable");
-    QGtk::gdk_draw_rectangle = (Ptr_gdk_draw_rectangle)libgtk.resolve("gdk_draw_rectangle");
-    QGtk::gdk_pixbuf_unref = (Ptr_gdk_pixbuf_unref)libgtk.resolve("gdk_pixbuf_unref");
-    QGtk::gdk_drawable_unref = (Ptr_gdk_drawable_unref)libgtk.resolve("gdk_drawable_unref");
-    QGtk::gdk_drawable_get_depth = (Ptr_gdk_drawable_get_depth)libgtk.resolve("gdk_drawable_get_depth");
-    QGtk::gdk_color_free = (Ptr_gdk_color_free)libgtk.resolve("gdk_color_free");
-    QGtk::gdk_x11_window_set_user_time = (Ptr_gdk_x11_window_set_user_time)libgtk.resolve("gdk_x11_window_set_user_time");
-    QGtk::gdk_x11_drawable_get_xid = (Ptr_gdk_x11_drawable_get_xid)libgtk.resolve("gdk_x11_drawable_get_xid");
-    QGtk::gdk_x11_drawable_get_xdisplay = (Ptr_gdk_x11_drawable_get_xdisplay)libgtk.resolve("gdk_x11_drawable_get_xdisplay");
-
-    QGtk::gtk_widget_set_default_direction = (Ptr_gtk_widget_set_default_direction)libgtk.resolve("gtk_widget_set_default_direction");
-    QGtk::gtk_widget_modify_fg = (Ptr_gtk_widget_modify_color)libgtk.resolve("gtk_widget_modify_fg");
-    QGtk::gtk_widget_modify_bg = (Ptr_gtk_widget_modify_color)libgtk.resolve("gtk_widget_modify_bg");
-    QGtk::gtk_arrow_new = (Ptr_gtk_arrow_new)libgtk.resolve("gtk_arrow_new");
-    QGtk::gtk_menu_item_new = (Ptr_gtk_menu_item_new)libgtk.resolve("gtk_menu_item_new");
-    QGtk::gtk_check_menu_item_new = (Ptr_gtk_check_menu_item_new)libgtk.resolve("gtk_check_menu_item_new");
-    QGtk::gtk_menu_bar_new = (Ptr_gtk_menu_bar_new)libgtk.resolve("gtk_menu_bar_new");
-    QGtk::gtk_menu_new = (Ptr_gtk_menu_new)libgtk.resolve("gtk_menu_new");
-    QGtk::gtk_toolbar_new = (Ptr_gtk_toolbar_new)libgtk.resolve("gtk_toolbar_new");
-    QGtk::gtk_separator_tool_item_new = (Ptr_gtk_separator_tool_item_new)libgtk.resolve("gtk_separator_tool_item_new");
-    QGtk::gtk_toolbar_insert = (Ptr_gtk_toolbar_insert)libgtk.resolve("gtk_toolbar_insert");
-    QGtk::gtk_button_new = (Ptr_gtk_button_new)libgtk.resolve("gtk_button_new");
-    QGtk::gtk_tool_button_new = (Ptr_gtk_tool_button_new)libgtk.resolve("gtk_tool_button_new");
-    QGtk::gtk_hbutton_box_new = (Ptr_gtk_hbutton_box_new)libgtk.resolve("gtk_hbutton_box_new");
-    QGtk::gtk_check_button_new = (Ptr_gtk_check_button_new)libgtk.resolve("gtk_check_button_new");
-    QGtk::gtk_radio_button_new = (Ptr_gtk_radio_button_new)libgtk.resolve("gtk_radio_button_new");
-    QGtk::gtk_notebook_new = (Ptr_gtk_notebook_new)libgtk.resolve("gtk_notebook_new");
-    QGtk::gtk_progress_bar_new = (Ptr_gtk_progress_bar_new)libgtk.resolve("gtk_progress_bar_new");
-    QGtk::gtk_spin_button_new = (Ptr_gtk_spin_button_new)libgtk.resolve("gtk_spin_button_new");
-    QGtk::gtk_hscale_new = (Ptr_gtk_hscale_new)libgtk.resolve("gtk_hscale_new");
-    QGtk::gtk_vscale_new = (Ptr_gtk_vscale_new)libgtk.resolve("gtk_vscale_new");
-    QGtk::gtk_hscrollbar_new = (Ptr_gtk_hscrollbar_new)libgtk.resolve("gtk_hscrollbar_new");
-    QGtk::gtk_vscrollbar_new = (Ptr_gtk_vscrollbar_new)libgtk.resolve("gtk_vscrollbar_new");
-    QGtk::gtk_scrolled_window_new = (Ptr_gtk_scrolled_window_new)libgtk.resolve("gtk_scrolled_window_new");
-    QGtk::gtk_menu_shell_append = (Ptr_gtk_menu_shell_append)libgtk.resolve("gtk_menu_shell_append");
-    QGtk::gtk_entry_new = (Ptr_gtk_entry_new)libgtk.resolve("gtk_entry_new");
-    QGtk::gtk_tree_view_new = (Ptr_gtk_tree_view_new)libgtk.resolve("gtk_tree_view_new");
-    QGtk::gtk_combo_box_new = (Ptr_gtk_combo_box_new)libgtk.resolve("gtk_combo_box_new");
-    QGtk::gtk_progress_set_adjustment = (Ptr_gtk_progress_set_adjustment)libgtk.resolve("gtk_progress_set_adjustment");
-    QGtk::gtk_range_set_adjustment = (Ptr_gtk_range_set_adjustment)libgtk.resolve("gtk_range_set_adjustment");
-    QGtk::gtk_range_set_inverted = (Ptr_gtk_range_set_inverted)libgtk.resolve("gtk_range_set_inverted");
-    QGtk::gtk_container_add = (Ptr_gtk_container_add)libgtk.resolve("gtk_container_add");
-    QGtk::gtk_icon_factory_lookup_default = (Ptr_gtk_icon_factory_lookup_default)libgtk.resolve("gtk_icon_factory_lookup_default");
-    QGtk::gtk_icon_theme_get_default = (Ptr_gtk_icon_theme_get_default)libgtk.resolve("gtk_icon_theme_get_default");
-    QGtk::gtk_widget_style_get = (Ptr_gtk_widget_style_get)libgtk.resolve("gtk_widget_style_get");
-    QGtk::gtk_icon_set_render_icon = (Ptr_gtk_icon_set_render_icon)libgtk.resolve("gtk_icon_set_render_icon");
-    QGtk::gtk_fixed_new = (Ptr_gtk_fixed_new)libgtk.resolve("gtk_fixed_new");
-    QGtk::gtk_tree_view_column_new = (Ptr_gtk_tree_view_column_new)libgtk.resolve("gtk_tree_view_column_new");
-    QGtk::gtk_tree_view_append_column= (Ptr_gtk_tree_view_append_column )libgtk.resolve("gtk_tree_view_append_column");
-    QGtk::gtk_tree_view_get_column = (Ptr_gtk_tree_view_get_column )libgtk.resolve("gtk_tree_view_get_column");
-    QGtk::gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
-    QGtk::gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
-    QGtk::gtk_paint_flat_box = (Ptr_gtk_paint_flat_box)libgtk.resolve("gtk_paint_flat_box");
-    QGtk::gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
-    QGtk::gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
-    QGtk::gtk_paint_resize_grip = (Ptr_gtk_paint_resize_grip)libgtk.resolve("gtk_paint_resize_grip");
-    QGtk::gtk_paint_focus = (Ptr_gtk_paint_focus)libgtk.resolve("gtk_paint_focus");
-    QGtk::gtk_paint_shadow = (Ptr_gtk_paint_shadow)libgtk.resolve("gtk_paint_shadow");
-    QGtk::gtk_paint_slider = (Ptr_gtk_paint_slider)libgtk.resolve("gtk_paint_slider");
-    QGtk::gtk_paint_expander = (Ptr_gtk_paint_expander)libgtk.resolve("gtk_paint_expander");
-    QGtk::gtk_paint_handle = (Ptr_gtk_paint_handle)libgtk.resolve("gtk_paint_handle");
-    QGtk::gtk_paint_option = (Ptr_gtk_paint_option)libgtk.resolve("gtk_paint_option");
-    QGtk::gtk_paint_arrow = (Ptr_gtk_paint_arrow)libgtk.resolve("gtk_paint_arrow");
-    QGtk::gtk_paint_box_gap = (Ptr_gtk_paint_box_gap)libgtk.resolve("gtk_paint_box_gap");
-    QGtk::gtk_paint_extension = (Ptr_gtk_paint_extension)libgtk.resolve("gtk_paint_extension");
-    QGtk::gtk_paint_hline = (Ptr_gtk_paint_hline)libgtk.resolve("gtk_paint_hline");
-    QGtk::gtk_paint_vline = (Ptr_gtk_paint_vline)libgtk.resolve("gtk_paint_vline");
-    QGtk::gtk_adjustment_new = (Ptr_gtk_adjustment_new)libgtk.resolve("gtk_adjustment_new");
-    QGtk::gtk_menu_item_set_submenu = (Ptr_gtk_menu_item_set_submenu)libgtk.resolve("gtk_menu_item_set_submenu");
-    QGtk::gtk_settings_get_default = (Ptr_gtk_settings_get_default)libgtk.resolve("gtk_settings_get_default");
-    QGtk::gtk_separator_menu_item_new = (Ptr_gtk_separator_menu_item_new)libgtk.resolve("gtk_separator_menu_item_new");
-    QGtk::gtk_frame_new = (Ptr_gtk_frame_new)libgtk.resolve("gtk_frame_new");
-    QGtk::gtk_expander_new = (Ptr_gtk_expander_new)libgtk.resolve("gtk_expander_new");
-    QGtk::gtk_statusbar_new = (Ptr_gtk_statusbar_new)libgtk.resolve("gtk_statusbar_new");
-    QGtk::gtk_combo_box_entry_new = (Ptr_gtk_combo_box_entry_new)libgtk.resolve("gtk_combo_box_entry_new");
-    QGtk::gtk_container_forall = (Ptr_gtk_container_forall)libgtk.resolve("gtk_container_forall");
-    QGtk::gtk_widget_size_allocate =(Ptr_gtk_widget_size_allocate)libgtk.resolve("gtk_widget_size_allocate");
-    QGtk::gtk_widget_set_direction =(Ptr_gtk_widget_set_direction)libgtk.resolve("gtk_widget_set_direction");
-    QGtk::gtk_widget_path =(Ptr_gtk_widget_path)libgtk.resolve("gtk_widget_path");
-    QGtk::gtk_container_get_type =(Ptr_gtk_container_get_type)libgtk.resolve("gtk_container_get_type");
-    QGtk::gtk_window_get_type =(Ptr_gtk_window_get_type)libgtk.resolve("gtk_window_get_type");
-    QGtk::gtk_widget_get_type =(Ptr_gtk_widget_get_type)libgtk.resolve("gtk_widget_get_type");
-    QGtk::gtk_rc_get_style_by_paths =(Ptr_gtk_rc_get_style_by_paths)libgtk.resolve("gtk_rc_get_style_by_paths");
-    QGtk::gtk_check_version =(Ptr_gtk_check_version)libgtk.resolve("gtk_check_version");
-    QGtk::pango_font_description_get_size = (Ptr_pango_font_description_get_size)libgtk.resolve("pango_font_description_get_size");
-    QGtk::pango_font_description_get_weight = (Ptr_pango_font_description_get_weight)libgtk.resolve("pango_font_description_get_weight");
-    QGtk::pango_font_description_get_family = (Ptr_pango_font_description_get_family)libgtk.resolve("pango_font_description_get_family");
-    QGtk::pango_font_description_get_style = (Ptr_pango_font_description_get_style)libgtk.resolve("pango_font_description_get_style");
-
-    QGtk::gnome_icon_lookup_sync = (Ptr_gnome_icon_lookup_sync)QLibrary::resolve( QLS("gnomeui-2"), 0, "gnome_icon_lookup_sync");
-    QGtk::gnome_vfs_init= (Ptr_gnome_vfs_init)QLibrary::resolve( QLS("gnomevfs-2"), 0, "gnome_vfs_init");
-}
-
-void QGtk::cleanup_gtk_widgets()
-{
-    if (gtkWidgetMap()->contains(QLS("GtkWindow"))) // Gtk will destroy all children
-        QGtk::gtk_widget_destroy(gtkWidgetMap()->value(QLS("GtkWindow")));
-}
-
-static bool resolveGConf()
-{
-    if (!QGtk::gconf_client_get_default) {
-        QGtk::gconf_client_get_default = (Ptr_gconf_client_get_default)QLibrary::resolve(QLS("gconf-2"), 4, "gconf_client_get_default");
-        QGtk::gconf_client_get_string =  (Ptr_gconf_client_get_string)QLibrary::resolve(QLS("gconf-2"), 4, "gconf_client_get_string");
-        QGtk::gconf_client_get_bool =  (Ptr_gconf_client_get_bool)QLibrary::resolve(QLS("gconf-2"), 4, "gconf_client_get_bool");
-    }
-    return (QGtk::gconf_client_get_default !=0);
-}
-
-typedef int (*x11ErrorHandler)(Display*, XErrorEvent*);
-
-QString QGtk::getGConfString(const QString &value, const QString &fallback)
-{
-    QString retVal = fallback;
-    if (resolveGConf()) {
-        g_type_init();
-        GConfClient* client = QGtk::gconf_client_get_default();
-        GError *err = 0;
-        char *str = QGtk::gconf_client_get_string(client, qPrintable(value), &err);
-        if (!err) {
-            retVal = QString::fromUtf8(str);
-            g_free(str);
-        }
-        g_object_unref(client);
-        if (err)
-            g_error_free (err);
-    }
-    return retVal;
-}
-
-bool QGtk::getGConfBool(const QString &key, bool fallback)
-{
-    bool retVal = fallback;
-    if (resolveGConf()) {
-        g_type_init();
-        GConfClient* client = QGtk::gconf_client_get_default();
-        GError *err = 0;
-        bool result = QGtk::gconf_client_get_bool(client, qPrintable(key), &err);
-        g_object_unref(client);
-        if (!err)
-            retVal = result;
-        else
-            g_error_free (err);
-    }
-    return retVal;
-}
-
-static QString getThemeName()
-{
-    QString themeName;
-    // We try to parse the gtkrc file first
-    // primarily to avoid resolving Gtk functions if
-    // the KDE 3 "Qt" style is currently in use
-    QString rcPaths = QString::fromLocal8Bit(qgetenv("GTK2_RC_FILES"));
-    if (!rcPaths.isEmpty()) {
-        QStringList paths = rcPaths.split(QLS(":"));
-        foreach (const QString &rcPath, paths) {
-            if (!rcPath.isEmpty()) {
-                QFile rcFile(rcPath);
-                if (rcFile.exists() && rcFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
-                    QTextStream in(&rcFile);
-                    while(!in.atEnd()) {
-                        QString line = in.readLine();
-                        if (line.contains(QLS("gtk-theme-name"))) {
-                            line = line.right(line.length() - line.indexOf(QLatin1Char('=')) - 1);
-                            line.remove(QLatin1Char('\"'));
-                            line = line.trimmed();
-                            themeName = line;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!themeName.isEmpty())
-                break;
-        }
-    }
-
-    // Fall back to gconf
-    if (themeName.isEmpty() && resolveGConf())
-        themeName = QGtk::getGConfString(QLS("/desktop/gnome/interface/gtk_theme"));
-
-    return themeName;
-}
-
-static void init_gtk_window()
-{
-    static QString themeName;
-    if (!gtkWidgetMap()->contains(QLS("GtkWindow")) && themeName.isEmpty()) {
-        themeName = getThemeName();
-
-        if (themeName.isEmpty()) {
-            qWarning("QGtkStyle was unable to detect the current GTK+ theme.");
-            return;
-        } else if (themeName == QLS("Qt") || themeName == QLS("Qt4")) {
-            // Due to namespace conflicts with Qt3 and obvious recursion with Qt4,
-            // we cannot support the GTK_Qt Gtk engine
-            qWarning("QGtkStyle cannot be used together with the GTK_Qt engine.");
-            return;
-        }
-
-        resolveGtk();
-
-        if (QGtk::gtk_init) {
-            // Gtk will set the Qt error handler so we have to reset it afterwards
-            x11ErrorHandler qt_x_errhandler = XSetErrorHandler(0);
-            QGtk::gtk_init (NULL, NULL);
-            XSetErrorHandler(qt_x_errhandler);
-
-            GtkWidget* gtkWindow = QGtk::gtk_window_new(GTK_WINDOW_POPUP);
-            QGtk::gtk_widget_realize(gtkWindow);
-            if (displayDepth == -1)
-                displayDepth = QGtk::gdk_drawable_get_depth(gtkWindow->window);
-            gtkWidgetMap()->insert(QLS("GtkWindow"), gtkWindow);
-        } else {
-            qWarning("QGtkStyle could not resolve GTK. Make sure you have installed the proper libraries.");
-        }
-    }
-}
-
-static void setup_gtk_widget(GtkWidget* widget)
-{
-    if (Q_GTK_IS_WIDGET(widget)) {
-        static GtkWidget* protoLayout = 0;
-        if (!protoLayout) {
-            protoLayout = QGtk::gtk_fixed_new();
-            QGtk::gtk_container_add((GtkContainer*)(gtkWidgetMap()->value(QLS("GtkWindow"))), protoLayout);
-        }
-        Q_ASSERT(protoLayout);
-
-        QGtk::gtk_container_add((GtkContainer*)(protoLayout), widget);
-        QGtk::gtk_widget_realize(widget);
-    }
-}
-
-static void add_widget_to_map(GtkWidget *widget)
-{
-    if (Q_GTK_IS_WIDGET(widget)) {
-       QGtk::gtk_widget_realize(widget);
-       gtkWidgetMap()->insert(classPath(widget), widget);
-    }
- }
-
-static void add_all_sub_widgets(GtkWidget *widget, gpointer v = 0)
-{
-    Q_UNUSED(v);
-    add_widget_to_map(widget);
-    if (GTK_CHECK_TYPE ((widget), Q_GTK_TYPE_CONTAINER))
-        QGtk::gtk_container_forall((GtkContainer*)widget, add_all_sub_widgets, NULL);
-}
-
-static void init_gtk_menu()
-{
-    // Create menubar
-    GtkWidget *gtkMenuBar = QGtk::gtk_menu_bar_new();
-    setup_gtk_widget(gtkMenuBar);
-
-    GtkWidget *gtkMenuBarItem = QGtk::gtk_menu_item_new();
-    QGtk::gtk_menu_shell_append((GtkMenuShell*)(gtkMenuBar), gtkMenuBarItem);
-    QGtk::gtk_widget_realize(gtkMenuBarItem);
-
-    // Create menu
-    GtkWidget *gtkMenu = QGtk::gtk_menu_new();
-    QGtk::gtk_menu_item_set_submenu((GtkMenuItem*)(gtkMenuBarItem), gtkMenu);
-    QGtk::gtk_widget_realize(gtkMenu);
-
-    GtkWidget *gtkMenuItem = QGtk::gtk_menu_item_new();
-    QGtk::gtk_menu_shell_append((GtkMenuShell*)gtkMenu, gtkMenuItem);
-    QGtk::gtk_widget_realize(gtkMenuItem);
-
-    GtkWidget *gtkCheckMenuItem = QGtk::gtk_check_menu_item_new();
-    QGtk::gtk_menu_shell_append((GtkMenuShell*)gtkMenu, gtkCheckMenuItem);
-    QGtk::gtk_widget_realize(gtkCheckMenuItem);
-
-    GtkWidget *gtkMenuSeparator = QGtk::gtk_separator_menu_item_new();
-    QGtk::gtk_menu_shell_append((GtkMenuShell*)gtkMenu, gtkMenuSeparator);
-
-    add_all_sub_widgets(gtkMenuBar);
-    add_all_sub_widgets(gtkMenu);
-}
-
-// Updates window/windowtext palette based on the indicated gtk widget
-static QPalette gtkWidgetPalette(const QString &gtkWidgetName)
-{
-    GtkWidget *gtkWidget = QGtk::gtkWidget(gtkWidgetName);
-    Q_ASSERT(gtkWidget);
-    QPalette pal = QApplication::palette();
-    GdkColor gdkBg = gtkWidget->style->bg[GTK_STATE_NORMAL];
-    GdkColor gdkText = gtkWidget->style->fg[GTK_STATE_NORMAL];
-    GdkColor gdkDisabledText = gtkWidget->style->fg[GTK_STATE_INSENSITIVE];
-    QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
-    QColor textColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
-    QColor disabledTextColor(gdkDisabledText.red>>8, gdkDisabledText.green>>8, gdkDisabledText.blue>>8);
-    pal.setBrush(QPalette::Window, bgColor);
-    pal.setBrush(QPalette::Button, bgColor);
-    pal.setBrush(QPalette::All, QPalette::WindowText, textColor);
-    pal.setBrush(QPalette::Disabled, QPalette::WindowText, disabledTextColor);
-    pal.setBrush(QPalette::All, QPalette::ButtonText, textColor);
-    pal.setBrush(QPalette::Disabled, QPalette::ButtonText, disabledTextColor);
-    return pal;
-}
-
-bool QGtk::isKDE4Session()
-{
-    static int version = -1;
-    if (version == -1)
-        version = qgetenv("KDE_SESSION_VERSION").toInt();
-    return (version == 4);
-}
-
-void QGtk::applyCustomPaletteHash()
-{
-    QPalette menuPal = gtkWidgetPalette(QLS("GtkMenu"));
-    GdkColor gdkBg = QGtk::gtkWidget(QLS("GtkMenu"))->style->bg[GTK_STATE_NORMAL];
-    QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
-    menuPal.setBrush(QPalette::Base, bgColor);
-    menuPal.setBrush(QPalette::Window, bgColor);
-    qApp->setPalette(menuPal, "QMenu");
-
-    QPalette toolbarPal = gtkWidgetPalette(QLS("GtkToolbar"));
-    qApp->setPalette(toolbarPal, "QToolBar");
-
-    QPalette menuBarPal = gtkWidgetPalette(QLS("GtkMenuBar"));
-    qApp->setPalette(menuBarPal, "QMenuBar");
-}
-
-static void gtkStyleSetCallback(GtkWidget*, GtkStyle*, void*)
-{
-    // We have to let this function return and complete the event
-    // loop to ensure that all gtk widgets have been styled before
-    // updating
-    QMetaObject::invokeMethod(styleScheduler(), "updateTheme", Qt::QueuedConnection);
-}
-
-void QGtkStyleUpdateScheduler::updateTheme()
-{
-    static QString oldTheme(QLS("qt_not_set"));
-    QPixmapCache::clear();
-
-    QFont font = QGtk::getThemeFont();
-    if (QApplication::font() != font)
-        qApp->setFont(font);
-
-    if (oldTheme != getThemeName()) {
-        oldTheme = getThemeName();
-        QPalette newPalette = qApp->style()->standardPalette();
-        QApplicationPrivate::setSystemPalette(newPalette);
-        QApplication::setPalette(newPalette);
-        QGtk::initGtkWidgets();
-        QGtk::applyCustomPaletteHash();
-        QList<QWidget*> widgets = QApplication::allWidgets();
-        // Notify all widgets that size metrics might have changed
-        foreach (QWidget *widget, widgets) {
-            QEvent e(QEvent::StyleChange);
-            QApplication::sendEvent(widget, &e);
-        }
-    }
-    QIconLoader::instance()->updateSystemTheme();
-}
-
-static void add_widget(GtkWidget *widget)
-{
-    if (widget) {
-        setup_gtk_widget(widget);
-        add_all_sub_widgets(widget);
-    }
-}
-
-static void init_gtk_treeview()
-{
-    GtkWidget *gtkTreeView = QGtk::gtk_tree_view_new();
-    QGtk::gtk_tree_view_append_column((GtkTreeView*)gtkTreeView, QGtk::gtk_tree_view_column_new());
-    QGtk::gtk_tree_view_append_column((GtkTreeView*)gtkTreeView, QGtk::gtk_tree_view_column_new());
-    QGtk::gtk_tree_view_append_column((GtkTreeView*)gtkTreeView, QGtk::gtk_tree_view_column_new());
-    add_widget(gtkTreeView);
-}
-
-
-// Fetch the application font from the pango font description
-// contained in the theme.
-QFont QGtk::getThemeFont()
-{
-    QFont font;
-    GtkStyle *style = gtkStyle();
-    if (style && qApp->desktopSettingsAware())
-    {
-        PangoFontDescription *gtk_font = style->font_desc;
-        font.setPointSizeF((float)(pango_font_description_get_size(gtk_font))/PANGO_SCALE);
-
-        QString family = QString::fromLatin1(pango_font_description_get_family(gtk_font));
-        if (!family.isEmpty())
-            font.setFamily(family);
-
-        int weight = pango_font_description_get_weight(gtk_font);
-        if (weight >= PANGO_WEIGHT_HEAVY)
-            font.setWeight(QFont::Black);
-        else if (weight >= PANGO_WEIGHT_BOLD)
-            font.setWeight(QFont::Bold);
-        else if (weight >= PANGO_WEIGHT_SEMIBOLD)
-            font.setWeight(QFont::DemiBold);
-        else if (weight >= PANGO_WEIGHT_NORMAL)
-            font.setWeight(QFont::Normal);
-        else
-            font.setWeight(QFont::Light);
-
-        PangoStyle fontstyle = pango_font_description_get_style(gtk_font);
-        if (fontstyle == PANGO_STYLE_ITALIC)
-            font.setStyle(QFont::StyleItalic);
-        else if (fontstyle == PANGO_STYLE_OBLIQUE)
-            font.setStyle(QFont::StyleOblique);
-        else
-            font.setStyle(QFont::StyleNormal);
-    }
-    return font;
-}
-
-GtkWidget* QGtk::gtkWidget(const QString &path)
-{
-    GtkWidget *widget = gtkWidgetMap()->value(path);
-    if (!widget) {
-        // Theme might have rearranged widget internals
-        widget = gtkWidgetMap()->value(path);
-    }
-    return widget;
-}
-
-GtkStyle* QGtk::gtkStyle(const QString &path)
-{
-    if (gtkWidgetMap()->contains(path))
-        return gtkWidgetMap()->value(path)->style;
-    return 0;
-}
-
-static void update_toolbar_style(GtkWidget *gtkToolBar, GParamSpec *, gpointer)
-{
-    GtkToolbarStyle toolbar_style = GTK_TOOLBAR_ICONS;
-    g_object_get(gtkToolBar, "toolbar-style", &toolbar_style, NULL);
-    QWidgetList widgets = QApplication::allWidgets();
-    for (int i = 0; i < widgets.size(); ++i) {
-        QWidget *widget = widgets.at(i);
-        if (qobject_cast<QToolButton*>(widget)) {
-            QEvent event(QEvent::StyleChange);
-            QApplication::sendEvent(widget, &event);
-        }
-    }
-}
-
-void QGtk::initGtkWidgets()
-{
-    // From gtkmain.c
-    uid_t ruid = getuid ();
-    uid_t rgid = getgid ();
-    uid_t euid = geteuid ();
-    uid_t egid = getegid ();
-    if (ruid != euid || rgid != egid) {
-        qWarning("\nThis process is currently running setuid or setgid.\nGTK+ does not allow this "
-                 "therefore Qt cannot use the GTK+ integration.\nTry launching your app using \'gksudo\', "
-                 "\'kdesudo\' or a similar tool.\n\n"
-                 "See http://www.gtk.org/setuid.html for more information.\n");
-        return;
-    }
-
-    init_gtk_window();
-
-    if (QGtk::gtk_init) {
-
-        // Make all widgets respect the text direction
-        if (qApp->layoutDirection() == Qt::RightToLeft)
-            QGtk::gtk_widget_set_default_direction(GTK_TEXT_DIR_RTL);
-
-        if (!gtkWidgetMap()->contains(QLS("GtkButton"))) {
-            GtkWidget *gtkButton = QGtk::gtk_button_new();
-            add_widget(gtkButton);
-            g_signal_connect(gtkButton, "style-set", G_CALLBACK(gtkStyleSetCallback), NULL);
-            add_widget(QGtk::gtk_tool_button_new(NULL, NULL));
-            add_widget(QGtk::gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE));
-            add_widget(QGtk::gtk_hbutton_box_new());
-            add_widget(QGtk::gtk_check_button_new());
-            add_widget(QGtk::gtk_radio_button_new(NULL));
-            add_widget(QGtk::gtk_combo_box_new());
-            add_widget(QGtk::gtk_combo_box_entry_new());
-            add_widget(QGtk::gtk_entry_new());
-            add_widget(QGtk::gtk_frame_new(NULL));
-            add_widget(QGtk::gtk_expander_new(""));
-            add_widget(QGtk::gtk_statusbar_new());
-            add_widget(QGtk::gtk_hscale_new((GtkAdjustment*)(QGtk::gtk_adjustment_new(1, 0, 1, 0, 0, 0))));
-            add_widget(QGtk::gtk_hscrollbar_new(NULL));
-            add_widget(QGtk::gtk_scrolled_window_new(NULL, NULL));
-            init_gtk_menu();
-            add_widget(QGtk::gtk_notebook_new());
-            add_widget(QGtk::gtk_progress_bar_new());
-            add_widget(QGtk::gtk_spin_button_new((GtkAdjustment*)
-                                             (QGtk::gtk_adjustment_new(1, 0, 1, 0, 0, 0)), 0.1, 3));
-            GtkWidget *toolbar = QGtk::gtk_toolbar_new();
-            g_signal_connect (toolbar, "notify::toolbar-style", G_CALLBACK (update_toolbar_style), toolbar);
-            QGtk::gtk_toolbar_insert((GtkToolbar*)toolbar, QGtk::gtk_separator_tool_item_new(), -1);
-            add_widget(toolbar);
-            init_gtk_treeview();
-            add_widget(QGtk::gtk_vscale_new((GtkAdjustment*)(QGtk::gtk_adjustment_new(1, 0, 1, 0, 0, 0))));
-            add_widget(QGtk::gtk_vscrollbar_new(NULL));
-        }
-        else // Rebuild map
-        {
-            // When styles change subwidgets can get rearranged
-            // as with the combo box. We need to update the widget map
-            // to reflect this;
-            QHash<QString, GtkWidget*> oldMap = *gtkWidgetMap();
-            gtkWidgetMap()->clear();
-            QHashIterator<QString, GtkWidget*> it(oldMap);
-            while (it.hasNext()) {
-                it.next();
-                if (!it.key().contains(QLatin1Char('.'))) {
-                    add_all_sub_widgets(it.value());
-                }
-            }
-        }
-    }
-}
-
-// ----------- Native file dialogs -----------
-
-// Extract filter list from expressions of type: foo (*.a *.b *.c)"
-static QStringList extract_filter(const QString &rawFilter)
-{
-    QString result = rawFilter;
-    QRegExp r(QString::fromLatin1("^([^()]*)\\(([a-zA-Z0-9_.*? +;#\\-\\[\\]@\\{\\}/!<>\\$%&=^~:\\|]*)\\)$"));
-    int index = r.indexIn(result);
-    if (index >= 0)
-        result = r.cap(2);
-    return result.split(QLatin1Char(' '));
-}
-
-extern QStringList qt_make_filter_list(const QString &filter);
-
-static void setupGtkFileChooser(GtkWidget* gtkFileChooser, QWidget *parent,
-                                const QString &dir, const QString &filter, QString *selectedFilter,
-                                QFileDialog::Options options, bool isSaveDialog = false,
-                                QMap<GtkFileFilter *, QString> *filterMap = 0)
-{
-    g_object_set(gtkFileChooser, "do-overwrite-confirmation", gboolean(!(options & QFileDialog::DontConfirmOverwrite)), NULL);
-    g_object_set(gtkFileChooser, "local_only", gboolean(true), NULL);
-    if (!filter.isEmpty()) {
-        QStringList filters = qt_make_filter_list(filter);
-        foreach (const QString &rawfilter, filters) {
-            GtkFileFilter *gtkFilter = QGtk::gtk_file_filter_new ();
-            QString name = rawfilter.left(rawfilter.indexOf(QLatin1Char('(')));
-            QStringList extensions = extract_filter(rawfilter);
-            QGtk::gtk_file_filter_set_name(gtkFilter, qPrintable(name.isEmpty() ? extensions.join(QLS(", ")) : name));
-
-            foreach (const QString &fileExtension, extensions) {
-                // Note Gtk file dialogs are by default case sensitive
-                // and only supports basic glob syntax so we
-                // rewrite .xyz to .[xX][yY][zZ]
-                QString caseInsensitive;
-                for (int i = 0 ; i < fileExtension.length() ; ++i) {
-                    QChar ch = fileExtension.at(i);
-                    if (ch.isLetter()) {
-                        caseInsensitive.append(
-                                QLatin1Char('[') +
-                                ch.toLower() +
-                                ch.toUpper() +
-                                QLatin1Char(']'));
-                    } else {
-                        caseInsensitive.append(ch);
-                    }
-                }
-                QGtk::gtk_file_filter_add_pattern (gtkFilter, qPrintable(caseInsensitive));
-
-            }
-            if (filterMap)
-                filterMap->insert(gtkFilter, rawfilter);
-            QGtk::gtk_file_chooser_add_filter((GtkFileChooser*)gtkFileChooser, gtkFilter);
-            if (selectedFilter && (rawfilter == *selectedFilter))
-                QGtk::gtk_file_chooser_set_filter((GtkFileChooser*)gtkFileChooser, gtkFilter);
-        }
-    }
-
-    // Using the currently active window is not entirely correct, however
-    // it gives more sensible behavior for applications that do not provide a
-    // parent
-    QWidget *modalFor = parent ? parent->window() : qApp->activeWindow();
-    if (modalFor) {
-        QGtk::gtk_widget_realize(gtkFileChooser); // Creates X window
-        XSetTransientForHint(QGtk::gdk_x11_drawable_get_xdisplay(gtkFileChooser->window),
-                             QGtk::gdk_x11_drawable_get_xid(gtkFileChooser->window),
-                             modalFor->winId());
-        QGtk::gdk_x11_window_set_user_time (gtkFileChooser->window, QX11Info::appUserTime());
-
-    }
-
-    QFileInfo fileinfo(dir);
-    if (dir.isEmpty())
-        fileinfo.setFile(QDir::currentPath());
-    fileinfo.makeAbsolute();
-    if (fileinfo.isDir()) {
-        QGtk::gtk_file_chooser_set_current_folder((GtkFileChooser*)gtkFileChooser, qPrintable(dir));
-    } else if (isSaveDialog) {
-        QGtk::gtk_file_chooser_set_current_folder((GtkFileChooser*)gtkFileChooser, qPrintable(fileinfo.absolutePath()));
-        QGtk::gtk_file_chooser_set_current_name((GtkFileChooser*)gtkFileChooser, qPrintable(fileinfo.fileName()));
-    } else {
-        QGtk::gtk_file_chooser_set_filename((GtkFileChooser*)gtkFileChooser, qPrintable(dir));
-    }
-}
-
-QString QGtk::openFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
-                            QString *selectedFilter, QFileDialog::Options options)
-{
-    QMap<GtkFileFilter *, QString> filterMap;
-    GtkWidget *gtkFileChooser = QGtk::gtk_file_chooser_dialog_new (qPrintable(caption),
-                                                             NULL,
-                                                             GTK_FILE_CHOOSER_ACTION_OPEN,
-                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                                             NULL);
-
-    setupGtkFileChooser(gtkFileChooser, parent, dir, filter, selectedFilter, options, false, &filterMap);
-
-    QWidget modal_widget;
-    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
-    modal_widget.setParent(parent, Qt::Window);
-    QApplicationPrivate::enterModal(&modal_widget);
-
-    QString filename;
-    if (QGtk::gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
-        char *gtk_filename = QGtk::gtk_file_chooser_get_filename ((GtkFileChooser*)gtkFileChooser);
-        filename = QString::fromUtf8(gtk_filename);
-        g_free (gtk_filename);
-        if (selectedFilter) {
-            GtkFileFilter *gtkFilter = QGtk::gtk_file_chooser_get_filter ((GtkFileChooser*)gtkFileChooser);
-            *selectedFilter = filterMap.value(gtkFilter);
-        }
-    }
-
-    QApplicationPrivate::leaveModal(&modal_widget);
-    gtk_widget_destroy (gtkFileChooser);
-    return filename;
-}
-
-
-QString QGtk::openDirectory(QWidget *parent, const QString &caption, const QString &dir, QFileDialog::Options options)
-{
-    QMap<GtkFileFilter *, QString> filterMap;
-    GtkWidget *gtkFileChooser = QGtk::gtk_file_chooser_dialog_new (qPrintable(caption),
-                                                             NULL,
-                                                             GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
-                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                                             NULL);
-
-    setupGtkFileChooser(gtkFileChooser, parent, dir, QString(), 0, options);
-    QWidget modal_widget;
-    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
-    modal_widget.setParent(parent, Qt::Window);
-    QApplicationPrivate::enterModal(&modal_widget);
-
-    QString filename;
-    if (QGtk::gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
-        char *gtk_filename = QGtk::gtk_file_chooser_get_filename ((GtkFileChooser*)gtkFileChooser);
-        filename = QString::fromUtf8(gtk_filename);
-        g_free (gtk_filename);
-    }
-
-    QApplicationPrivate::leaveModal(&modal_widget);
-    gtk_widget_destroy (gtkFileChooser);
-    return filename;
-}
-
-QStringList QGtk::openFilenames(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
-                                 QString *selectedFilter, QFileDialog::Options options)
-{
-    QStringList filenames;
-    QMap<GtkFileFilter *, QString> filterMap;
-    GtkWidget *gtkFileChooser = QGtk::gtk_file_chooser_dialog_new (qPrintable(caption),
-                                                             NULL,
-                                                             GTK_FILE_CHOOSER_ACTION_OPEN,
-                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                                             NULL);
-
-    setupGtkFileChooser(gtkFileChooser, parent, dir, filter, selectedFilter, options, false, &filterMap);
-    g_object_set(gtkFileChooser, "select-multiple", gboolean(true), NULL);
-
-    QWidget modal_widget;
-    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
-    modal_widget.setParent(parent, Qt::Window);
-    QApplicationPrivate::enterModal(&modal_widget);
-
-    if (gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
-        GSList *gtk_file_names = QGtk::gtk_file_chooser_get_filenames((GtkFileChooser*)gtkFileChooser);
-        for (GSList *iterator  = gtk_file_names ; iterator; iterator = iterator->next)
-            filenames << QString::fromUtf8((const char*)iterator->data);
-        g_slist_free(gtk_file_names);
-        if (selectedFilter) {
-            GtkFileFilter *gtkFilter = QGtk::gtk_file_chooser_get_filter ((GtkFileChooser*)gtkFileChooser);
-            *selectedFilter = filterMap.value(gtkFilter);
-        }
-    }
-
-    QApplicationPrivate::leaveModal(&modal_widget);
-    gtk_widget_destroy (gtkFileChooser);
-    return filenames;
-}
-
-QString QGtk::saveFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
-                           QString *selectedFilter, QFileDialog::Options options)
-{
-    QMap<GtkFileFilter *, QString> filterMap;
-    GtkWidget *gtkFileChooser = QGtk::gtk_file_chooser_dialog_new (qPrintable(caption),
-                                                             NULL,
-                                                             GTK_FILE_CHOOSER_ACTION_SAVE,
-                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                                             GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
-                                                             NULL);
-    setupGtkFileChooser(gtkFileChooser, parent, dir, filter, selectedFilter, options, true, &filterMap);
-
-    QWidget modal_widget;
-    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
-    modal_widget.setParent(parent, Qt::Window);
-    QApplicationPrivate::enterModal(&modal_widget);
-
-    QString filename;
-    if (QGtk::gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
-        char *gtk_filename = QGtk::gtk_file_chooser_get_filename ((GtkFileChooser*)gtkFileChooser);
-        filename = QString::fromUtf8(gtk_filename);
-        g_free (gtk_filename);
-        if (selectedFilter) {
-            GtkFileFilter *gtkFilter = QGtk::gtk_file_chooser_get_filter ((GtkFileChooser*)gtkFileChooser);
-            *selectedFilter = filterMap.value(gtkFilter);
-        }
-    }
-
-    QApplicationPrivate::leaveModal(&modal_widget);
-    gtk_widget_destroy (gtkFileChooser);
-    return filename;
-}
-
-QIcon QGtk::getFilesystemIcon(const QFileInfo &info)
-{
-    QIcon icon;
-    if (QGtk::gnome_vfs_init && QGtk::gnome_icon_lookup_sync) {
-        QGtk::gnome_vfs_init();
-        GtkIconTheme *theme = QGtk::gtk_icon_theme_get_default();
-        QByteArray fileurl = QUrl::fromLocalFile(info.absoluteFilePath()).toEncoded();
-        char * icon_name = QGtk::gnome_icon_lookup_sync(theme,
-                                                        NULL,
-                                                        fileurl.data(),
-                                                        NULL,
-                                                        GNOME_ICON_LOOKUP_FLAGS_NONE,
-                                                        NULL);
-        QString iconName = QString::fromUtf8(icon_name);
-        g_free(icon_name);
-        if (iconName.startsWith(QLatin1Char('/')))
-            return QIcon(iconName);
-        return QIcon::fromTheme(iconName);
-    }
-    return icon;
-}
-
-QT_END_NAMESPACE
-
-#endif // !defined(QT_NO_STYLE_GTK)
diff --git a/src/gui/styles/qcommonstyle_p.h b/src/gui/styles/qcommonstyle_p.h
index a90560164f..6122f814d2 100644
--- a/src/gui/styles/qcommonstyle_p.h
+++ b/src/gui/styles/qcommonstyle_p.h
@@ -62,25 +62,6 @@ QT_BEGIN_NAMESPACE
 
 class QStringList;
 
-#ifdef Q_WS_X11
-class QIconTheme
-{
-public:
-    QIconTheme(QHash <int, QString> dirList, QStringList parents) :
-          _dirList(dirList), _parents(parents), _valid(true){ }
-    QIconTheme() : _valid(false){ }
-
-    QHash <int, QString> dirList() {return _dirList;}
-    QStringList parents() {return _parents;}
-    bool isValid() {return _valid;}
-
-private:
-    QHash <int, QString> _dirList;
-    QStringList _parents;
-    bool _valid;
-};
-#endif
-
 // Private class
 class QCommonStylePrivate : public QStylePrivate
 {
diff --git a/src/gui/styles/qgtkpainter.cpp b/src/gui/styles/qgtkpainter.cpp
index 05c5804274..aaa029ab78 100644
--- a/src/gui/styles/qgtkpainter.cpp
+++ b/src/gui/styles/qgtkpainter.cpp
@@ -108,41 +108,41 @@ QPixmap QGtkPainter::renderTheme(uchar *bdata, uchar *wdata, const QRect &rect)
         return;                                                                                    \
     QRect pixmapRect(0, 0, rect.width(), rect.height());                                           \
     {                                                                                              \
-        GdkPixmap *pixmap = QGtk::gdk_pixmap_new((GdkDrawable*)(m_window->window),                    \
+        GdkPixmap *pixmap = QGtkStylePrivate::gdk_pixmap_new((GdkDrawable*)(m_window->window),                    \
                                             rect.width(), rect.height(), -1);                      \
         if (!pixmap)                                                                               \
             return;                                                                                \
-        style = QGtk::gtk_style_attach (style, m_window->window);                                  \
-        QGtk::gdk_draw_rectangle(pixmap, m_alpha ? style->black_gc : *style->bg_gc, true,                \
+        style = QGtkStylePrivate::gtk_style_attach (style, m_window->window);                                  \
+        QGtkStylePrivate::gdk_draw_rectangle(pixmap, m_alpha ? style->black_gc : *style->bg_gc, true,                \
                            0, 0, rect.width(), rect.height());                                     \
         draw_func;                                                                                 \
-        GdkPixbuf *imgb = QGtk::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, rect.width(), rect.height());\
+        GdkPixbuf *imgb = QGtkStylePrivate::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, rect.width(), rect.height());\
         if (!imgb)                                                                                 \
             return;                                                                                \
-        imgb = QGtk::gdk_pixbuf_get_from_drawable(imgb, pixmap, NULL, 0, 0, 0, 0,                  \
+        imgb = QGtkStylePrivate::gdk_pixbuf_get_from_drawable(imgb, pixmap, NULL, 0, 0, 0, 0,                  \
                                             rect.width(), rect.height());                          \
-        uchar* bdata = (uchar*)QGtk::gdk_pixbuf_get_pixels(imgb);                                  \
+        uchar* bdata = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(imgb);                                  \
         if (m_alpha) {                                                                             \
-            QGtk::gdk_draw_rectangle(pixmap, style->white_gc, true, 0, 0, rect.width(), rect.height());  \
+            QGtkStylePrivate::gdk_draw_rectangle(pixmap, style->white_gc, true, 0, 0, rect.width(), rect.height());  \
             draw_func;                                                                             \
-            GdkPixbuf *imgw = QGtk::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, rect.              \
+            GdkPixbuf *imgw = QGtkStylePrivate::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, rect.              \
                                              width(), rect.height());                              \
             if (!imgw)                                                                             \
                 return;                                                                            \
-            imgw = QGtk::gdk_pixbuf_get_from_drawable(imgw, pixmap, NULL, 0, 0, 0, 0,              \
+            imgw = QGtkStylePrivate::gdk_pixbuf_get_from_drawable(imgw, pixmap, NULL, 0, 0, 0, 0,              \
                                                 rect.width(), rect.height());                      \
-            uchar* wdata = (uchar*)QGtk::gdk_pixbuf_get_pixels(imgw);                                    \
+            uchar* wdata = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(imgw);                                    \
             cache = renderTheme(bdata, wdata, rect);                                               \
-            QGtk::gdk_pixbuf_unref(imgw);                                                          \
+            QGtkStylePrivate::gdk_pixbuf_unref(imgw);                                                          \
         } else {                                                                                   \
             cache = renderTheme(bdata, 0, rect);                                                   \
         }                                                                                          \
-        QGtk::gdk_drawable_unref(pixmap);                                                          \
-        QGtk::gdk_pixbuf_unref(imgb);                                                              \
+        QGtkStylePrivate::gdk_drawable_unref(pixmap);                                                          \
+        QGtkStylePrivate::gdk_pixbuf_unref(imgb);                                                              \
     }
 
 QGtkPainter::QGtkPainter(QPainter *_painter)
-        : m_window(QGtk::gtkWidget(QLatin1String("GtkWindow")))
+        : m_window(QGtkStylePrivate::gtkWidget(QLatin1String("GtkWindow")))
         , m_painter(_painter)
         , m_alpha(true)
         , m_hflipped(false)
@@ -185,18 +185,18 @@ GtkStyle* QGtkPainter::getStyle(GtkWidget *gtkWidget)
 
 QPixmap QGtkPainter::getIcon(const char* iconName, GtkIconSize size)
 {
-    GtkStyle *style = QGtk::gtkStyle();
-    GtkIconSet* iconSet  = QGtk::gtk_icon_factory_lookup_default (iconName);
-    GdkPixbuf* icon = QGtk::gtk_icon_set_render_icon(iconSet,
+    GtkStyle *style = QGtkStylePrivate::gtkStyle();
+    GtkIconSet* iconSet  = QGtkStylePrivate::gtk_icon_factory_lookup_default (iconName);
+    GdkPixbuf* icon = QGtkStylePrivate::gtk_icon_set_render_icon(iconSet,
                                                  style,
                                                  GTK_TEXT_DIR_LTR,
                                                  GTK_STATE_NORMAL,
                                                  size,
                                                  NULL,
                                                  "button");
-    uchar* data = (uchar*)QGtk::gdk_pixbuf_get_pixels(icon);
-    int width = QGtk::gdk_pixbuf_get_width(icon);
-    int height = QGtk::gdk_pixbuf_get_height(icon);
+    uchar* data = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(icon);
+    int width = QGtkStylePrivate::gdk_pixbuf_get_width(icon);
+    int height = QGtkStylePrivate::gdk_pixbuf_get_height(icon);
     QImage converted(width, height, QImage::Format_ARGB32);
     uchar* tdata = (uchar*)converted.bits();
 
@@ -208,7 +208,7 @@ QPixmap QGtkPainter::getIcon(const char* iconName, GtkIconSize size)
         tdata[index + QT_ALPHA] = data[index + GTK_ALPHA];
     }
 
-    QGtk::gdk_pixbuf_unref(icon);
+    QGtkStylePrivate::gdk_pixbuf_unref(icon);
 
     // should we free iconset?
     return QPixmap::fromImage(converted);
@@ -240,7 +240,7 @@ void QGtkPainter::paintBoxGap(GtkWidget *gtkWidget, const gchar* part,
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) + gapExtras;
 
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_box_gap (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_box_gap (style,
                                            pixmap,
                                            state,
                                            shadow,
@@ -305,7 +305,7 @@ void QGtkPainter::paintBox(GtkWidget *gtkWidget, const gchar* part,
                                     rect.size(), gtkWidget) + pmKey;
 
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_box (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_box (style,
                                            pixmap,
                                            state,
                                            shadow,
@@ -356,7 +356,7 @@ void QGtkPainter::paintHline(GtkWidget *gtkWidget, const gchar* part,
     QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
                          + hLineExtras + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_hline (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_hline (style,
                                          pixmap,
                                          state,
                                          NULL,
@@ -383,7 +383,7 @@ void QGtkPainter::paintVline(GtkWidget *gtkWidget, const gchar* part,
     QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(),
                                     gtkWidget) + vLineExtras +pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_vline (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_vline (style,
                                          pixmap,
                                          state,
                                          NULL,
@@ -410,7 +410,7 @@ void QGtkPainter::paintExpander(GtkWidget *gtkWidget,
     QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(),
                                     gtkWidget) + QString::number(expander_state) + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_expander (style, pixmap,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_expander (style, pixmap,
                                             state, NULL,
                                             gtkWidget, part,
                                             rect.width()/2,
@@ -433,7 +433,7 @@ void QGtkPainter::paintFocus(GtkWidget *gtkWidget, const gchar* part,
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget) + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_focus (style, pixmap, state, NULL,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_focus (style, pixmap, state, NULL,
                                          gtkWidget,
                                          part,
                                          0, 0,
@@ -458,7 +458,7 @@ void QGtkPainter::paintResizeGrip(GtkWidget *gtkWidget, const gchar* part,
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_resize_grip (style, pixmap, state,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_resize_grip (style, pixmap, state,
                                                NULL, gtkWidget,
                                                part, edge, 0, 0,
                                                rect.width(),
@@ -488,7 +488,7 @@ void QGtkPainter::paintArrow(GtkWidget *gtkWidget, const gchar* part,
     int xOffset = m_cliprect.isValid() ? arrowrect.x() - m_cliprect.x() : 0;
     int yOffset = m_cliprect.isValid() ? arrowrect.y() - m_cliprect.y() : 0;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_arrow (style, pixmap, state, shadow,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_arrow (style, pixmap, state, shadow,
                                          &gtkCliprect,
                                          gtkWidget,
                                          part,
@@ -515,7 +515,7 @@ void QGtkPainter::paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRe
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
                          + QString::number(orientation);
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_handle (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_handle (style,
                                           pixmap,
                                           state,
                                           shadow,
@@ -543,7 +543,7 @@ void QGtkPainter::paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRe
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_slider (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_slider (style,
                                           pixmap,
                                           state,
                                           shadow,
@@ -574,7 +574,7 @@ void QGtkPainter::paintShadow(GtkWidget *gtkWidget, const gchar* part,
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_shadow(style, pixmap, state, shadow, NULL,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_shadow(style, pixmap, state, shadow, NULL,
                                          gtkWidget, part, 0, 0, rect.width(), rect.height()));
         if (m_usePixmapCache)
             QPixmapCache::insert(pixmapName, cache);
@@ -593,7 +593,7 @@ void QGtkPainter::paintFlatBox(GtkWidget *gtkWidget, const gchar* part,
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) + pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_flat_box (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_flat_box (style,
                                             pixmap,
                                             state,
                                             shadow,
@@ -622,7 +622,7 @@ void QGtkPainter::paintExtention(GtkWidget *gtkWidget,
     pixmapName += QString::number(gap_pos);
 
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_extension (style, pixmap, state, shadow,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_extension (style, pixmap, state, shadow,
                                              NULL, gtkWidget,
                                              (gchar*)part, 0, 0,
                                              rect.width(),
@@ -651,7 +651,7 @@ void QGtkPainter::paintOption(GtkWidget *gtkWidget, const QRect &radiorect,
     int xOffset = m_cliprect.isValid() ? radiorect.x() - m_cliprect.x() : 0;
     int yOffset = m_cliprect.isValid() ? radiorect.y() - m_cliprect.y() : 0;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_option(style, pixmap,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_option(style, pixmap,
                                          state, shadow,
                                          &gtkCliprect,
                                          gtkWidget,
@@ -683,7 +683,7 @@ void QGtkPainter::paintCheckbox(GtkWidget *gtkWidget, const QRect &checkrect,
     int xOffset = m_cliprect.isValid() ? checkrect.x() - m_cliprect.x() : 0;
     int yOffset = m_cliprect.isValid() ? checkrect.y() - m_cliprect.y() : 0;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
-        DRAW_TO_CACHE(QGtk::gtk_paint_check (style,
+        DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_check (style,
                                          pixmap,
                                          state,
                                          shadow,
diff --git a/src/gui/styles/qgtkpainter_p.h b/src/gui/styles/qgtkpainter_p.h
index 0e8ffe2341..cbc96c0623 100644
--- a/src/gui/styles/qgtkpainter_p.h
+++ b/src/gui/styles/qgtkpainter_p.h
@@ -56,11 +56,11 @@
 #include <QtCore/qglobal.h>
 #if !defined(QT_NO_STYLE_GTK)
 
-#include "gtksymbols_p.h"
 #include <QtGui/QCleanlooksStyle>
 #include <QtGui/QPainter>
 #include <QtGui/QPalette>
 #include <QtGui/QFont>
+#include <private/qgtkstyle_p.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index ab0ab3a5b4..1c78a4731c 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -69,28 +69,14 @@
 #include <QtGui/QTreeView>
 #include <qpixmapcache.h>
 #undef signals // Collides with GTK stymbols
-#include "qgtkpainter_p.h"
-#include "qstylehelper_p.h"
-
+#include <private/qgtkpainter_p.h>
+#include <private/qstylehelper_p.h>
+#include <private/qgtkstyle_p.h>
 #include <private/qcleanlooksstyle_p.h>
 
 
 QT_BEGIN_NAMESPACE
 
-typedef QStringList (*_qt_filedialog_open_filenames_hook)(QWidget * parent, const QString &caption, const QString &dir,
-                                                          const QString &filter, QString *selectedFilter, QFileDialog::Options options);
-typedef QString (*_qt_filedialog_open_filename_hook)     (QWidget * parent, const QString &caption, const QString &dir,
-                                                          const QString &filter, QString *selectedFilter, QFileDialog::Options options);
-typedef QString (*_qt_filedialog_save_filename_hook)     (QWidget * parent, const QString &caption, const QString &dir,
-                                                          const QString &filter, QString *selectedFilter, QFileDialog::Options options);
-typedef QString (*_qt_filedialog_existing_directory_hook)(QWidget *parent, const QString &caption, const QString &dir,
-                                                          QFileDialog::Options options);
-
-extern Q_GUI_EXPORT _qt_filedialog_open_filename_hook qt_filedialog_open_filename_hook;
-extern Q_GUI_EXPORT _qt_filedialog_open_filenames_hook qt_filedialog_open_filenames_hook;
-extern Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook;
-extern Q_GUI_EXPORT _qt_filedialog_existing_directory_hook qt_filedialog_existing_directory_hook;
-
 static const char * const dock_widget_close_xpm[] =
     {
         "11 13 5 1",
@@ -137,57 +123,18 @@ static const char * const dock_widget_restore_xpm[] =
         "           "
     };
 
-
-class QGtkStyleFilter : public QObject
-{
-public:
-    QGtkStyleFilter() {}
-private:
-    bool eventFilter(QObject *obj, QEvent *e);
-};
-
-bool QGtkStyleFilter::eventFilter(QObject *obj, QEvent *e)
-{
-    if (e->type() == QEvent::ApplicationPaletteChange) {
-        // Only do this the first time since this will also
-        // generate applicationPaletteChange events
-        if (!qt_app_palettes_hash() ||  qt_app_palettes_hash()->isEmpty()) {
-            QGtk::applyCustomPaletteHash();
-        }
-    }
-    return QObject::eventFilter(obj, e);
-}
-
-class QGtkStylePrivate : public QCleanlooksStylePrivate
-{
-    Q_DECLARE_PUBLIC(QGtkStyle)
-public:
-    QGtkStylePrivate()
-            : QCleanlooksStylePrivate()
-    {
-        QGtk::initGtkWidgets();
-        if (QGtk::isThemeAvailable())
-            qApp->installEventFilter(&filter);
-
-    }
-    QGtkStyleFilter filter;
-};
-
 static const int groupBoxBottomMargin    =  2;  // space below the groupbox
 static const int groupBoxTitleMargin     =  6;  // space between contents and title
 static const int groupBoxTopMargin       =  2;
 
-// Get size of the arrow controls in a GtkSpinButton
-static int spinboxArrowSize()
+QString QGtkStyle::getGConfString(const QString &value, const QString &fallback)
 {
-    const int MIN_ARROW_WIDTH = 6;
-    GtkWidget *spinButton = QGtk::gtkWidget(QLS("GtkSpinButton"));
-    GtkStyle *style = spinButton->style;
-    gint size = QGtk::pango_font_description_get_size (style->font_desc);
-    gint arrow_size;
-    arrow_size = qMax(PANGO_PIXELS (size), MIN_ARROW_WIDTH) + style->xthickness;
-    arrow_size += arrow_size%2 + 1;
-    return arrow_size;
+    return QGtkStylePrivate::getGConfString(value, fallback);
+}
+
+bool QGtkStyle::getGConfBool(const QString &key, bool fallback)
+{
+    return QGtkStylePrivate::getGConfBool(key, fallback);
 }
 
 static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor = 50)
@@ -233,8 +180,23 @@ static GdkColor fromQColor(const QColor &color)
 QGtkStyle::QGtkStyle()
     : QCleanlooksStyle(*new QGtkStylePrivate)
 {
+    Q_D(QGtkStyle);
+    d->init();
+}
+
+/*!
+    \internal
+
+    Constructs a QGtkStyle object.
+*/
+QGtkStyle::QGtkStyle(QGtkStylePrivate &dd)
+     : QCleanlooksStyle(dd)
+{
+    Q_D(QGtkStyle);
+    d->init();
 }
 
+
 /*!
     Destroys the QGtkStyle object.
 */
@@ -247,11 +209,13 @@ QGtkStyle::~QGtkStyle()
 */
 QPalette QGtkStyle::standardPalette() const
 {
+    Q_D(const QGtkStyle);
+
     QPalette palette = QCleanlooksStyle::standardPalette();
-    if (QGtk::isThemeAvailable()) {
-        GtkStyle *style = QGtk::gtkStyle();
-        GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
-        GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+    if (d->isThemeAvailable()) {
+        GtkStyle *style = d->gtkStyle();
+        GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
+        GtkWidget *gtkEntry = d->getTextColorWidget();
 
         GdkColor gdkBg, gdkBase, gdkText, gdkForeground, gdkSbg, gdkSfg;
         QColor bg, base, text, fg, highlight, highlightText;
@@ -281,12 +245,12 @@ QPalette QGtkStyle::standardPalette() const
         palette.setColor(QPalette::Base, base);
 
         QColor alternateRowColor = palette.base().color().lighter(93); // ref gtkstyle.c draw_flat_box
-        GtkWidget *gtkTreeView = QGtk::gtkWidget(QLS("GtkTreeView"));
+        GtkWidget *gtkTreeView = d->gtkWidget(QLS("GtkTreeView"));
         GdkColor *gtkAltBase = NULL;
-        QGtk::gtk_widget_style_get(gtkTreeView, "odd-row-color", &gtkAltBase, NULL);
+        d->gtk_widget_style_get(gtkTreeView, "odd-row-color", &gtkAltBase, NULL);
         if (gtkAltBase) {
             alternateRowColor = QColor(gtkAltBase->red>>8, gtkAltBase->green>>8, gtkAltBase->blue>>8);
-            QGtk::gdk_color_free(gtkAltBase);
+            d->gdk_color_free(gtkAltBase);
         }
         palette.setColor(QPalette::AlternateBase, alternateRowColor);
 
@@ -306,7 +270,8 @@ QPalette QGtkStyle::standardPalette() const
         highlightText.setHsv(highlightText.hue(), 0, highlightText.value(), highlightText.alpha());
         palette.setColor(QPalette::Disabled, QPalette::Highlight, highlight);
         palette.setColor(QPalette::Disabled, QPalette::HighlightedText, highlightText);
-        style = QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(), "gtk-tooltips", "GtkWindow", Q_GTK_TYPE_WINDOW);
+        style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), "gtk-tooltips", "GtkWindow",
+                d->gtk_window_get_type());
         if (style) {
             gdkText = style->fg[GTK_STATE_NORMAL];
             text = QColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
@@ -321,10 +286,12 @@ QPalette QGtkStyle::standardPalette() const
 */
 void QGtkStyle::polish(QPalette &palette)
 {
+    Q_D(QGtkStyle);
+
     // QCleanlooksStyle will alter the palette, hence we do
     // not want to polish the palette unless we are using it as
     // the fallback
-    if (!QGtk::isThemeAvailable())
+    if (!d->isThemeAvailable())
         QCleanlooksStyle::polish(palette);
     else
         palette = palette.resolve(standardPalette());
@@ -335,19 +302,21 @@ void QGtkStyle::polish(QPalette &palette)
 */
 void QGtkStyle::polish(QApplication *app)
 {
+    Q_D(QGtkStyle);
+
     QCleanlooksStyle::polish(app);
     // Custom fonts and palettes with QtConfig are intentionally 
     // not supported as these should be entirely determined by
     // current Gtk settings
-    if (app->desktopSettingsAware() && QGtk::isThemeAvailable()) {
+    if (app->desktopSettingsAware() && d->isThemeAvailable()) {
         QApplicationPrivate::setSystemPalette(standardPalette());
-        QApplicationPrivate::setSystemFont(QGtk::getThemeFont());
-        QGtk::applyCustomPaletteHash();
-        if (!QGtk::isKDE4Session()) {
-            qt_filedialog_open_filename_hook = &QGtk::openFilename;
-            qt_filedialog_save_filename_hook = &QGtk::saveFilename;
-            qt_filedialog_open_filenames_hook = &QGtk::openFilenames;
-            qt_filedialog_existing_directory_hook = &QGtk::openDirectory;
+        QApplicationPrivate::setSystemFont(d->getThemeFont());
+        d->applyCustomPaletteHash();
+        if (!d->isKDE4Session()) {
+            qt_filedialog_open_filename_hook = &QGtkStylePrivate::openFilename;
+            qt_filedialog_save_filename_hook = &QGtkStylePrivate::saveFilename;
+            qt_filedialog_open_filenames_hook = &QGtkStylePrivate::openFilenames;
+            qt_filedialog_existing_directory_hook = &QGtkStylePrivate::openDirectory;
         }
     }
 }
@@ -357,11 +326,13 @@ void QGtkStyle::polish(QApplication *app)
 */
 void QGtkStyle::unpolish(QApplication *app)
 {
+    Q_D(QGtkStyle);
+
     QCleanlooksStyle::unpolish(app);
     QPixmapCache::clear();
 
-    if (app->desktopSettingsAware() && QGtk::isThemeAvailable()
-        && !QGtk::isKDE4Session()) {
+    if (app->desktopSettingsAware() && d->isThemeAvailable()
+        && !d->isKDE4Session()) {
         qt_filedialog_open_filename_hook = 0;
         qt_filedialog_save_filename_hook = 0;
         qt_filedialog_open_filenames_hook = 0;
@@ -375,8 +346,10 @@ void QGtkStyle::unpolish(QApplication *app)
 
 void QGtkStyle::polish(QWidget *widget)
 {
+    Q_D(QGtkStyle);
+
     QCleanlooksStyle::polish(widget);
-    if (!QGtk::isThemeAvailable())
+    if (!d->isThemeAvailable())
         return;
     if (qobject_cast<QAbstractButton*>(widget)
             || qobject_cast<QToolButton*>(widget)
@@ -404,21 +377,22 @@ void QGtkStyle::unpolish(QWidget *widget)
     \reimp
 */
 int QGtkStyle::pixelMetric(PixelMetric metric,
-
                            const QStyleOption *option,
                            const QWidget *widget) const
 {
-    if (!QGtk::isThemeAvailable())
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable())
         return QCleanlooksStyle::pixelMetric(metric, option, widget);
 
     switch (metric) {
     case PM_DefaultFrameWidth:
         if (qobject_cast<const QFrame*>(widget)) {
             if (GtkStyle *style =
-                QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(),
+                d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(),
                                                 "*.GtkScrolledWindow",
                                                 "*.GtkScrolledWindow",
-                                                Q_GTK_TYPE_WINDOW))
+                                                d->gtk_window_get_type()))
                 return qMax(style->xthickness, style->ythickness);
         }
         return 2;
@@ -439,16 +413,16 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
         return 0;
 
     case PM_ButtonShiftHorizontal: {
-        GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+        GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
         guint horizontal_shift;
-        QGtk::gtk_widget_style_get(gtkButton, "child-displacement-x", &horizontal_shift, NULL);
+        d->gtk_widget_style_get(gtkButton, "child-displacement-x", &horizontal_shift, NULL);
         return horizontal_shift;
     }
 
     case PM_ButtonShiftVertical: {
-        GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+        GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
         guint vertical_shift;
-        QGtk::gtk_widget_style_get(gtkButton, "child-displacement-y", &vertical_shift, NULL);
+        d->gtk_widget_style_get(gtkButton, "child-displacement-y", &vertical_shift, NULL);
         return vertical_shift;
     }
 
@@ -456,18 +430,18 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
         return 0;
 
     case PM_MenuPanelWidth: {
-        GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
+        GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
         guint horizontal_padding = 0;
         // horizontal-padding is used by Maemo to get thicker borders
-        if (!QGtk::gtk_check_version(2, 10, 0))
-            QGtk::gtk_widget_style_get(gtkMenu, "horizontal-padding", &horizontal_padding, NULL);
+        if (!d->gtk_check_version(2, 10, 0))
+            d->gtk_widget_style_get(gtkMenu, "horizontal-padding", &horizontal_padding, NULL);
         int padding = qMax<int>(gtkMenu->style->xthickness, horizontal_padding);
         return padding;
     }
 
     case PM_ButtonIconSize: {
         int retVal = 24;
-        GtkSettings *settings = QGtk::gtk_settings_get_default();
+        GtkSettings *settings = d->gtk_settings_get_default();
         gchararray icon_sizes;
         g_object_get(settings, "gtk-icon-sizes", &icon_sizes, NULL);
         QStringList values = QString(QLS(icon_sizes)).split(QLatin1Char(':'));
@@ -513,9 +487,9 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
 
     case PM_SliderThickness:
     case PM_SliderControlThickness: {
-        GtkWidget *gtkScale = QGtk::gtkWidget(QLS("GtkHScale"));
+        GtkWidget *gtkScale = d->gtkWidget(QLS("GtkHScale"));
         gint val;
-        QGtk::gtk_widget_style_get(gtkScale, "slider-width", &val, NULL);
+        d->gtk_widget_style_get(gtkScale, "slider-width", &val, NULL);
         if (metric == PM_SliderControlThickness)
             return val + 2*gtkScale->style->ythickness;
         return val;
@@ -524,8 +498,8 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
     case PM_ScrollBarExtent: {
         gint sliderLength;
         gint trough_border;
-        GtkWidget *hScrollbar = QGtk::gtkWidget(QLS("GtkHScrollbar"));
-        QGtk::gtk_widget_style_get(hScrollbar,
+        GtkWidget *hScrollbar = d->gtkWidget(QLS("GtkHScrollbar"));
+        d->gtk_widget_style_get(hScrollbar,
                                "trough-border",   &trough_border,
                                "slider-width",    &sliderLength,
                                NULL);
@@ -537,35 +511,35 @@ int QGtkStyle::pixelMetric(PixelMetric metric,
 
     case PM_SliderLength:
         gint val;
-        QGtk::gtk_widget_style_get(QGtk::gtkWidget(QLS("GtkHScale")), "slider-length", &val, NULL);
+        d->gtk_widget_style_get(d->gtkWidget(QLS("GtkHScale")), "slider-length", &val, NULL);
         return val;
 
     case PM_ExclusiveIndicatorWidth:
     case PM_ExclusiveIndicatorHeight:
     case PM_IndicatorWidth:
     case PM_IndicatorHeight: {
-        GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+        GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
         gint size, spacing;
-        QGtk::gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, "indicator-size", &size, NULL);
+        d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, "indicator-size", &size, NULL);
         return size + 2 * spacing;
     }
 
     case PM_MenuBarVMargin: {
-        GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+        GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
         return  qMax(0, gtkMenubar->style->ythickness);
     }
     case PM_ScrollView_ScrollBarSpacing:
     {
         gint spacing = 3;
-        GtkWidget *gtkScrollWindow = QGtk::gtkWidget(QLS("GtkScrolledWindow"));
+        GtkWidget *gtkScrollWindow = d->gtkWidget(QLS("GtkScrolledWindow"));
         Q_ASSERT(gtkScrollWindow);
-        QGtk::gtk_widget_style_get(gtkScrollWindow, "scrollbar-spacing", &spacing, NULL);
+        d->gtk_widget_style_get(gtkScrollWindow, "scrollbar-spacing", &spacing, NULL);
         return spacing;
     }
     case PM_SubMenuOverlap: {
         gint offset = 0;
-        GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
-        QGtk::gtk_widget_style_get(gtkMenu, "horizontal-offset", &offset, NULL);
+        GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
+        d->gtk_widget_style_get(gtkMenu, "horizontal-offset", &offset, NULL);
         return offset;
     }
     default:
@@ -580,7 +554,9 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
 
                          QStyleHintReturn *returnData = 0) const
 {
-    if (!QGtk::isThemeAvailable())
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable())
         return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
 
     switch (hint) {
@@ -588,7 +564,7 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
     case SH_DialogButtonLayout: {
         int ret = QDialogButtonBox::GnomeLayout;
         gboolean alternateOrder = 0;
-        GtkSettings *settings = QGtk::gtk_settings_get_default();
+        GtkSettings *settings = d->gtk_settings_get_default();
         g_object_get(settings, "gtk-alternative-button-order", &alternateOrder, NULL);
 
         if (alternateOrder)
@@ -601,9 +577,9 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
 
     case SH_ToolButtonStyle:
     {
-        if (QGtk::isKDE4Session())
+        if (d->isKDE4Session())
             return QCleanlooksStyle::styleHint(hint, option, widget, returnData);
-        GtkWidget *gtkToolbar = QGtk::gtkWidget(QLS("GtkToolbar"));
+        GtkWidget *gtkToolbar = d->gtkWidget(QLS("GtkToolbar"));
         GtkToolbarStyle toolbar_style = GTK_TOOLBAR_ICONS;
         g_object_get(gtkToolbar, "toolbar-style", &toolbar_style, NULL);
         switch (toolbar_style) {
@@ -626,9 +602,9 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
         return int(false);
 
     case SH_ComboBox_Popup: {
-        GtkWidget *gtkComboBox = QGtk::gtkWidget(QLS("GtkComboBox"));
+        GtkWidget *gtkComboBox = d->gtkWidget(QLS("GtkComboBox"));
         gboolean appears_as_list;
-        QGtk::gtk_widget_style_get((GtkWidget*)gtkComboBox, "appears-as-list", &appears_as_list, NULL);
+        d->gtk_widget_style_get((GtkWidget*)gtkComboBox, "appears-as-list", &appears_as_list, NULL);
         return appears_as_list ? 0 : 1;
     }
 
@@ -640,7 +616,7 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
 
     case SH_Menu_SubMenuPopupDelay: {
         gint delay = 225;
-        GtkSettings *settings = QGtk::gtk_settings_get_default();
+        GtkSettings *settings = d->gtk_settings_get_default();
         g_object_get(settings, "gtk-menu-popup-delay", &delay, NULL);
         return delay;
     }
@@ -649,15 +625,15 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
         gboolean scrollbars_within_bevel = false;
         if (widget && widget->isWindow())
             scrollbars_within_bevel = true;
-        else if (!QGtk::gtk_check_version(2, 12, 0)) {
-            GtkWidget *gtkScrollWindow = QGtk::gtkWidget(QLS("GtkScrolledWindow"));
-            QGtk::gtk_widget_style_get(gtkScrollWindow, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
+        else if (!d->gtk_check_version(2, 12, 0)) {
+            GtkWidget *gtkScrollWindow = d->gtkWidget(QLS("GtkScrolledWindow"));
+            d->gtk_widget_style_get(gtkScrollWindow, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
         }
         return !scrollbars_within_bevel;
     }
 
     case SH_DialogButtonBox_ButtonsHaveIcons: {
-        static bool buttonsHaveIcons = QGtk::getGConfBool(QLS("/desktop/gnome/interface/buttons_have_icons"));
+        static bool buttonsHaveIcons = d->getGConfBool(QLS("/desktop/gnome/interface/buttons_have_icons"));
         return buttonsHaveIcons;
     }
 
@@ -670,17 +646,18 @@ int QGtkStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidg
     \reimp
 */
 void QGtkStyle::drawPrimitive(PrimitiveElement element,
-
                               const QStyleOption *option,
                               QPainter *painter,
                               const QWidget *widget) const
 {
-    if (!QGtk::isThemeAvailable()) {
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable()) {
         QCleanlooksStyle::drawPrimitive(element, option, painter, widget);
         return;
     }
 
-    GtkStyle* style = QGtk::gtkStyle();
+    GtkStyle* style = d->gtkStyle();
     QGtkPainter gtkPainter(painter);
 
     switch (element) {
@@ -715,10 +692,10 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
             else if (option->state & State_Raised)
                 shadow_type = GTK_SHADOW_OUT;
 
-            GtkStyle *style = QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(),
-                                     "*.GtkScrolledWindow", "*.GtkScrolledWindow", Q_GTK_TYPE_WINDOW);
+            GtkStyle *style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(),
+                                     "*.GtkScrolledWindow", "*.GtkScrolledWindow", d->gtk_window_get_type());
             if (style)
-                gtkFramePainter.paintShadow(QGtk::gtkWidget(QLS("GtkFrame")), "viewport", pmRect,
+                gtkFramePainter.paintShadow(d->gtkWidget(QLS("GtkFrame")), "viewport", pmRect,
                                          option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
                                          shadow_type, style);
             QPixmapCache::insert(pmKey, pixmap);
@@ -745,8 +722,9 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
     break;
 
     case PE_PanelTipLabel: {
-        GtkWidget *gtkWindow = QGtk::gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
-        style = QGtk::gtk_rc_get_style_by_paths(QGtk::gtk_settings_get_default(), "gtk-tooltips", "GtkWindow", Q_GTK_TYPE_WINDOW);
+        GtkWidget *gtkWindow = d->gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
+        style = d->gtk_rc_get_style_by_paths(d->gtk_settings_get_default(), "gtk-tooltips", "GtkWindow",
+                d->gtk_window_get_type());
         gtkPainter.paintFlatBox(gtkWindow, "tooltip", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_NONE, style);
     }
     break;
@@ -759,8 +737,8 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
             break;
         }
         GtkShadowType shadow_type;
-        GtkWidget *gtkStatusbarFrame = QGtk::gtkWidget(QLS("GtkStatusbar.GtkFrame"));
-        QGtk::gtk_widget_style_get(gtkStatusbarFrame->parent, "shadow-type", &shadow_type, NULL);
+        GtkWidget *gtkStatusbarFrame = d->gtkWidget(QLS("GtkStatusbar.GtkFrame"));
+        d->gtk_widget_style_get(gtkStatusbarFrame->parent, "shadow-type", &shadow_type, NULL);
         gtkPainter.paintShadow(gtkStatusbarFrame, "frame", option->rect, GTK_STATE_NORMAL,
                                shadow_type, gtkStatusbarFrame->style);
     }
@@ -768,7 +746,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
 
     case PE_IndicatorHeaderArrow:
         if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
-            GtkWidget *gtkTreeHeader = QGtk::gtkWidget(QLS("GtkTreeView.GtkButton"));
+            GtkWidget *gtkTreeHeader = d->gtkWidget(QLS("GtkTreeView.GtkButton"));
             GtkStateType state = gtkPainter.gtkState(option);
             style = gtkTreeHeader->style;
             GtkArrowType type = GTK_ARROW_UP;
@@ -806,7 +784,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
             rect.translate(2, 0);
             GtkExpanderStyle openState = GTK_EXPANDER_EXPANDED;
             GtkExpanderStyle closedState = GTK_EXPANDER_COLLAPSED;
-            GtkWidget *gtkTreeView = QGtk::gtkWidget(QLS("GtkTreeView"));
+            GtkWidget *gtkTreeView = d->gtkWidget(QLS("GtkTreeView"));
 
             GtkStateType state = GTK_STATE_NORMAL;
             if (!(option->state & State_Enabled))
@@ -842,7 +820,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
     case PE_IndicatorToolBarSeparator:
         {
             const int margin = 6;
-            GtkWidget *gtkSeparator = QGtk::gtkWidget(QLS("GtkToolbar.GtkSeparatorToolItem"));
+            GtkWidget *gtkSeparator = d->gtkWidget(QLS("GtkToolbar.GtkSeparatorToolItem"));
             if (option->state & State_Horizontal) {
                 const int offset = option->rect.width()/2;
                 QRect rect = option->rect.adjusted(offset, margin, 0, -margin);
@@ -862,9 +840,9 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
        break;
 
     case PE_IndicatorToolBarHandle: {
-        GtkWidget *gtkToolbar = QGtk::gtkWidget(QLS("GtkToolbar"));
+        GtkWidget *gtkToolbar = d->gtkWidget(QLS("GtkToolbar"));
         GtkShadowType shadow_type;
-        QGtk::gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
+        d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
         //Note when the toolbar is horizontal, the handle is vertical
         painter->setClipRect(option->rect);
         gtkPainter.paintHandle(gtkToolbar, "toolbar", option->rect.adjusted(-1, -1 ,0 ,1),
@@ -910,14 +888,14 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
         GtkStateType state = gtkPainter.gtkState(option);
 
         QColor arrowColor = option->palette.buttonText().color();
-        GtkWidget *gtkArrow = QGtk::gtkWidget(QLS("GtkArrow"));
+        GtkWidget *gtkArrow = d->gtkWidget(QLS("GtkArrow"));
         GdkColor color = fromQColor(arrowColor);
-        QGtk::gtk_widget_modify_fg (gtkArrow, state, &color);
+        d->gtk_widget_modify_fg (gtkArrow, state, &color);
         gtkPainter.paintArrow(gtkArrow, "button", arrowRect,
                               type, state, shadow, FALSE, gtkArrow->style,
                               QString::number(arrowColor.rgba(), 16));
         // Passing NULL will revert the color change
-        QGtk::gtk_widget_modify_fg (gtkArrow, state, NULL);
+        d->gtk_widget_modify_fg (gtkArrow, state, NULL);
     }
     break;
 
@@ -926,7 +904,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
         break;
 
     case PE_PanelMenu: {
-            GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
+            GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
             gtkPainter.setAlphaSupport(false); // Note, alpha disabled for performance reasons
             gtkPainter.paintBox(gtkMenu, "menu", option->rect, GTK_STATE_NORMAL, GTK_SHADOW_OUT, gtkMenu->style, QString());
         }
@@ -938,7 +916,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
 
         // This is only used by floating tool bars
         if (qobject_cast<const QToolBar *>(widget)) {
-            GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+            GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
             gtkPainter.paintBox( gtkMenubar, "toolbar",  option->rect,
                                  GTK_STATE_NORMAL, GTK_SHADOW_OUT, style);
             gtkPainter.paintBox( gtkMenubar, "menu",  option->rect,
@@ -947,13 +925,13 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
         break;
 
     case PE_FrameLineEdit: {
-        GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+        GtkWidget *gtkEntry = d->gtkWidget(QLS("GtkEntry"));
 
 
         gboolean interior_focus;
         gint focus_line_width;
         QRect rect = option->rect;
-        QGtk::gtk_widget_style_get(gtkEntry,
+        d->gtk_widget_style_get(gtkEntry,
                                "interior-focus", &interior_focus,
                                "focus-line-width", &focus_line_width, NULL);
 
@@ -981,7 +959,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
 
     case PE_PanelLineEdit:
         if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
-            GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+            GtkWidget *gtkEntry = d->gtkWidget(QLS("GtkEntry"));
             if (panel->lineWidth > 0)
                 proxy()->drawPrimitive(PE_FrameLineEdit, option, painter, widget);
             uint resolve_mask = option->palette.resolve();
@@ -999,13 +977,13 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
 
     case PE_FrameTabWidget:
         if (const QStyleOptionTabWidgetFrame *frame = qstyleoption_cast<const QStyleOptionTabWidgetFrame*>(option)) {
-            GtkWidget *gtkNotebook = QGtk::gtkWidget(QLS("GtkNotebook"));
+            GtkWidget *gtkNotebook = d->gtkWidget(QLS("GtkNotebook"));
             style = gtkPainter.getStyle(gtkNotebook);
             gtkPainter.setAlphaSupport(false);
             GtkShadowType shadow = GTK_SHADOW_OUT;
             GtkStateType state = GTK_STATE_NORMAL; // Only state supported by gtknotebook
             bool reverse = (option->direction == Qt::RightToLeft);
-            QGtk::gtk_widget_set_direction(gtkNotebook, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+            QGtkStylePrivate::gtk_widget_set_direction(gtkNotebook, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
             if (const QStyleOptionTabWidgetFrameV2 *tabframe = qstyleoption_cast<const QStyleOptionTabWidgetFrameV2*>(option)) {
                 GtkPositionType frameType = GTK_POS_TOP;
                 QTabBar::Shape shape = frame->shape;
@@ -1047,10 +1025,10 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
         GtkStateType state = gtkPainter.gtkState(option);
         if (option->state & State_On || option->state & State_Sunken)
             state = GTK_STATE_ACTIVE;
-        GtkWidget *gtkButton = QGtk::gtkWidget(isTool ? QLS("GtkToolButton.GtkButton") : QLS("GtkButton"));
+        GtkWidget *gtkButton = d->gtkWidget(isTool ? QLS("GtkToolButton.GtkButton") : QLS("GtkButton"));
         gint focusWidth, focusPad;
         gboolean interiorFocus = false;
-        QGtk::gtk_widget_style_get (gtkButton,
+        d->gtk_widget_style_get (gtkButton,
                                 "focus-line-width", &focusWidth,
                                 "focus-padding", &focusPad,
                                 "interior-focus", &interiorFocus, NULL);
@@ -1103,14 +1081,14 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
         else
             shadow = GTK_SHADOW_OUT;
 
-        GtkWidget *gtkRadioButton = QGtk::gtkWidget(QLS("GtkRadioButton"));
+        GtkWidget *gtkRadioButton = d->gtkWidget(QLS("GtkRadioButton"));
         gint spacing;
-        QGtk::gtk_widget_style_get(gtkRadioButton, "indicator-spacing", &spacing, NULL);
+        d->gtk_widget_style_get(gtkRadioButton, "indicator-spacing", &spacing, NULL);
         QRect buttonRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
         gtkPainter.setClipRect(option->rect);
         // ### Note: Ubuntulooks breaks when the proper widget is passed
         //           Murrine engine requires a widget not to get RGBA check - warnings
-        GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+        GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
         gtkPainter.paintOption(gtkCheckButton , buttonRect, state, shadow, gtkRadioButton->style, QLS("radiobutton"));
 
     }
@@ -1132,12 +1110,12 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
 
         int spacing;
 
-        GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+        GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
 
         // Some styles such as aero-clone assume they can paint in the spacing area
         gtkPainter.setClipRect(option->rect);
 
-        QGtk::gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, NULL);
+        d->gtk_widget_style_get(gtkCheckButton, "indicator-spacing", &spacing, NULL);
 
         QRect checkRect = option->rect.adjusted(spacing, spacing, -spacing, -spacing);
 
@@ -1204,12 +1182,14 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
                                    QPainter *painter, const QWidget *widget) const
 {
-    if (!QGtk::isThemeAvailable()) {
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable()) {
         QCleanlooksStyle::drawComplexControl(control, option, painter, widget);
         return;
     }
 
-    GtkStyle* style = QGtk::gtkStyle();
+    GtkStyle* style = d->gtkStyle();
     QGtkPainter gtkPainter(painter);
     QColor button = option->palette.button().color();
     QColor dark;
@@ -1264,7 +1244,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
             if ((groupBox->subControls & QStyle::SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {
                 // Draw prelight background
-                GtkWidget *gtkCheckButton = QGtk::gtkWidget(QLS("GtkCheckButton"));
+                GtkWidget *gtkCheckButton = d->gtkWidget(QLS("GtkCheckButton"));
 
                 if (option->state & State_MouseOver) {
                     QRect bgRect = textRect | checkBoxRect;
@@ -1340,14 +1320,14 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
             QString comboBoxPath = QLS(comboBox->editable ? "GtkComboBoxEntry" : "GtkComboBox");
 
             // We use the gtk widget to position arrows and separators for us
-            GtkWidget *gtkCombo = QGtk::gtkWidget(comboBoxPath);
+            GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath);
             GtkAllocation geometry = {0, 0, option->rect.width(), option->rect.height()};
-            QGtk::gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
-            QGtk::gtk_widget_size_allocate(gtkCombo, &geometry);
+            d->gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+            d->gtk_widget_size_allocate(gtkCombo, &geometry);
 
             QString buttonPath = comboBoxPath + QLS(".GtkToggleButton");
-            GtkWidget *gtkToggleButton = QGtk::gtkWidget(buttonPath);
-            QGtk::gtk_widget_set_direction(gtkToggleButton, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+            GtkWidget *gtkToggleButton = d->gtkWidget(buttonPath);
+            d->gtk_widget_set_direction(gtkToggleButton, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
             if (gtkToggleButton && (appears_as_list || comboBox->editable)) {
                 if (focus)
                     GTK_WIDGET_SET_FLAGS(gtkToggleButton, GTK_HAS_FOCUS);
@@ -1355,8 +1335,8 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 if (comboBox->editable || appears_as_list) {
                     GtkStateType frameState = (state == GTK_STATE_PRELIGHT) ? GTK_STATE_NORMAL : state;
                     QString entryPath = QLS(comboBox->editable ? "GtkComboBoxEntry.GtkEntry" : "GtkComboBox.GtkFrame");
-                    GtkWidget *gtkEntry = QGtk::gtkWidget(entryPath);
-                    QGtk::gtk_widget_set_direction(gtkEntry, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+                    GtkWidget *gtkEntry = d->gtkWidget(entryPath);
+                    d->gtk_widget_set_direction(gtkEntry, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
                     QRect frameRect = option->rect;
 
                     if (reverse)
@@ -1425,7 +1405,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 // Draw the separator between label and arrows
                 QString vSeparatorPath = buttonPath + QLS(".GtkHBox.GtkVSeparator");
 
-                if (GtkWidget *gtkVSeparator = QGtk::gtkWidget(vSeparatorPath)) {
+                if (GtkWidget *gtkVSeparator = d->gtkWidget(vSeparatorPath)) {
                     QRect vLineRect(gtkVSeparator->allocation.x,
                                     gtkVSeparator->allocation.y,
                                     gtkVSeparator->allocation.width,
@@ -1437,7 +1417,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
 
                     gint interiorFocus = true;
-                    QGtk::gtk_widget_style_get(gtkToggleButton, "interior-focus", &interiorFocus, NULL);
+                    d->gtk_widget_style_get(gtkToggleButton, "interior-focus", &interiorFocus, NULL);
                     int xt = interiorFocus ? gtkToggleButton->style->xthickness : 0;
                     int yt = interiorFocus ? gtkToggleButton->style->ythickness : 0;
                     if (focus && ((option->state & State_KeyboardFocusChange) || styleHint(SH_UnderlineShortcut, option, widget)))
@@ -1461,14 +1441,14 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 QString arrowPath = comboBoxPath + QLS(appears_as_list ? ".GtkToggleButton.GtkArrow"
                                                     : ".GtkToggleButton.GtkHBox.GtkArrow");
 
-                GtkWidget *gtkArrow = QGtk::gtkWidget(arrowPath);
+                GtkWidget *gtkArrow = d->gtkWidget(arrowPath);
                 gfloat scale = 0.7;
                 gint minSize = 15;
                 QRect arrowWidgetRect;
 
-                if (gtkArrow && !QGtk::gtk_check_version(2, 12, 0)) {
-                    QGtk::gtk_widget_style_get(gtkArrow, "arrow-scaling", &scale, NULL);
-                    QGtk::gtk_widget_style_get(gtkCombo, "arrow-size", &minSize, NULL);
+                if (gtkArrow && !d->gtk_check_version(2, 12, 0)) {
+                    d->gtk_widget_style_get(gtkArrow, "arrow-scaling", &scale, NULL);
+                    d->gtk_widget_style_get(gtkCombo, "arrow-size", &minSize, NULL);
                 }
                 if (gtkArrow) {
                     arrowWidgetRect = QRect(gtkArrow->allocation.x, gtkArrow->allocation.y,
@@ -1486,9 +1466,9 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
                 if (sunken) {
                     int xoff, yoff;
-                    GtkWidget *gtkButton = QGtk::gtkWidget(comboBoxPath + QLS(".GtkToggleButton"));
-                    QGtk::gtk_widget_style_get(gtkButton, "child-displacement-x", &xoff, NULL);
-                    QGtk::gtk_widget_style_get(gtkButton, "child-displacement-y", &yoff, NULL);
+                    GtkWidget *gtkButton = d->gtkWidget(comboBoxPath + QLS(".GtkToggleButton"));
+                    d->gtk_widget_style_get(gtkButton, "child-displacement-x", &xoff, NULL);
+                    d->gtk_widget_style_get(gtkButton, "child-displacement-y", &yoff, NULL);
                     arrowRect = arrowRect.adjusted(xoff, yoff, xoff, yoff);
                 }
 
@@ -1559,7 +1539,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
             QStyleOptionToolButton label = *toolbutton;
             label.state = bflags;
-            GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkToolButton.GtkButton"));
+            GtkWidget *gtkButton = d->gtkWidget(QLS("GtkToolButton.GtkButton"));
             QPalette pal = toolbutton->palette;
             if (option->state & State_Enabled && 
                 option->state & State_MouseOver && !(widget && widget->testAttribute(Qt::WA_SetPalette))) {
@@ -1594,8 +1574,8 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
     case CC_ScrollBar:
         if (const QStyleOptionSlider *scrollBar = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
-            GtkWidget *gtkHScrollBar = QGtk::gtkWidget(QLS("GtkHScrollbar"));
-            GtkWidget *gtkVScrollBar = QGtk::gtkWidget(QLS("GtkVScrollbar"));
+            GtkWidget *gtkHScrollBar = d->gtkWidget(QLS("GtkHScrollbar"));
+            GtkWidget *gtkVScrollBar = d->gtkWidget(QLS("GtkVScrollbar"));
 
             // Fill background in case the scrollbar is partially transparent
             painter->fillRect(option->rect, option->palette.background());
@@ -1612,8 +1592,8 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
             gboolean trough_side_details = false;
             gboolean stepper_size = 14;
             gint trough_border = 1;
-            if (!QGtk::gtk_check_version(2, 10, 0)) {
-                QGtk::gtk_widget_style_get((GtkWidget*)(scrollbarWidget),
+            if (!d->gtk_check_version(2, 10, 0)) {
+                d->gtk_widget_style_get((GtkWidget*)(scrollbarWidget),
                                            "trough-border",   &trough_border,
                                            "trough-side-details",   &trough_side_details,
                                            "trough-under-steppers", &trough_under_steppers,
@@ -1637,12 +1617,12 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 fakePos = maximum;
             else if (scrollBar->sliderPosition > scrollBar->minimum)
                 fakePos = maximum - 1;
-            GtkObject *adjustment =  QGtk::gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
+            GtkObject *adjustment =  d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
 
             if (horizontal)
-                QGtk::gtk_range_set_adjustment((GtkRange*)(gtkHScrollBar), (GtkAdjustment*)(adjustment));
+                d->gtk_range_set_adjustment((GtkRange*)(gtkHScrollBar), (GtkAdjustment*)(adjustment));
             else
-                QGtk::gtk_range_set_adjustment((GtkRange*)(gtkVScrollBar), (GtkAdjustment*)(adjustment));
+                d->gtk_range_set_adjustment((GtkRange*)(gtkVScrollBar), (GtkAdjustment*)(adjustment));
 
             if (scrollBar->subControls & SC_ScrollBarGroove) {
                 GtkStateType state = GTK_STATE_ACTIVE;
@@ -1739,7 +1719,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
     case CC_SpinBox:
         if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
-            GtkWidget *gtkSpinButton = QGtk::gtkWidget(QLS("GtkSpinButton"));
+            GtkWidget *gtkSpinButton = d->gtkWidget(QLS("GtkSpinButton"));
             bool isEnabled = (spinBox->state & State_Enabled);
             bool hover = isEnabled && (spinBox->state & State_MouseOver);
             bool sunken = (spinBox->state & State_Sunken);
@@ -1854,7 +1834,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 }
 
             } else {
-                int size = spinboxArrowSize();
+                int size = d->getSpinboxArrowSize();
                 int w = size / 2 - 1;
                 w -= w % 2 - 1; // force odd
                 int h = (w + 1)/2;
@@ -1886,8 +1866,8 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
     case CC_Slider:
         if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
-            GtkWidget *hScaleWidget = QGtk::gtkWidget(QLS("GtkHScale"));
-            GtkWidget *vScaleWidget = QGtk::gtkWidget(QLS("GtkVScale"));
+            GtkWidget *hScaleWidget = d->gtkWidget(QLS("GtkHScale"));
+            GtkWidget *vScaleWidget = d->gtkWidget(QLS("GtkVScale"));
 
             QRect groove = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget);
             QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget);
@@ -1911,16 +1891,16 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
             style = scaleWidget->style;
 
             if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
-                GtkObject *adjustment =  QGtk::gtk_adjustment_new(slider->sliderPosition,
+                GtkObject *adjustment =  d->gtk_adjustment_new(slider->sliderPosition,
                                          slider->minimum,
                                          slider->maximum,
                                          slider->singleStep,
                                          slider->singleStep,
                                          slider->pageStep);
                 int outerSize;
-                QGtk::gtk_range_set_adjustment ((GtkRange*)(scaleWidget), (GtkAdjustment*)(adjustment));
-                QGtk::gtk_range_set_inverted((GtkRange*)(scaleWidget), !horizontal);
-                QGtk::gtk_widget_style_get(scaleWidget, "trough-border", &outerSize, NULL);
+                d->gtk_range_set_adjustment ((GtkRange*)(scaleWidget), (GtkAdjustment*)(adjustment));
+                d->gtk_range_set_inverted((GtkRange*)(scaleWidget), !horizontal);
+                d->gtk_widget_style_get(scaleWidget, "trough-border", &outerSize, NULL);
                 outerSize++;
 
                 GtkStateType state = gtkPainter.gtkState(option);
@@ -1929,8 +1909,8 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                                    -focusFrameMargin, -outerSize - focusFrameMargin);
 
                 gboolean trough_side_details = false; // Indicates if the upper or lower scale background differs
-                if (!QGtk::gtk_check_version(2, 10, 0))
-                    QGtk::gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details",   &trough_side_details, NULL);
+                if (!d->gtk_check_version(2, 10, 0))
+                    d->gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details",   &trough_side_details, NULL);
 
                 if (!trough_side_details) {
                     gtkPainter.paintBox( scaleWidget, "trough", grooveRect, state,
@@ -2064,18 +2044,20 @@ void QGtkStyle::drawControl(ControlElement element,
                             QPainter *painter,
                             const QWidget *widget) const
 {
-    if (!QGtk::isThemeAvailable()) {
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable()) {
         QCleanlooksStyle::drawControl(element, option, painter, widget);
         return;
     }
 
-    GtkStyle* style = QGtk::gtkStyle();
+    GtkStyle* style = d->gtkStyle();
     QGtkPainter gtkPainter(painter);
 
     switch (element) {
     case CE_ProgressBarLabel:
         if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
-            GtkWidget *gtkProgressBar = QGtk::gtkWidget(QLS("GtkProgressBar"));
+            GtkWidget *gtkProgressBar = d->gtkWidget(QLS("GtkProgressBar"));
             if (!gtkProgressBar)
                 return;
 
@@ -2178,7 +2160,7 @@ void QGtkStyle::drawControl(ControlElement element,
             if (button->features & QStyleOptionButton::HasMenu)
                 ir = ir.adjusted(0, 0, -pixelMetric(PM_MenuButtonIndicator, button, widget), 0);
 
-            GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+            GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
             QPalette pal = button->palette;
             int labelState = GTK_STATE_INSENSITIVE;
             if (option->state & State_Enabled)
@@ -2199,7 +2181,7 @@ void QGtkStyle::drawControl(ControlElement element,
             bool isRadio = (element == CE_RadioButton);
 
             // Draw prelight background
-            GtkWidget *gtkRadioButton = QGtk::gtkWidget(QLS("GtkRadioButton"));
+            GtkWidget *gtkRadioButton = d->gtkWidget(QLS("GtkRadioButton"));
 
             if (option->state & State_MouseOver) {
                 gtkPainter.paintFlatBox(gtkRadioButton, "checkbutton", option->rect,
@@ -2267,7 +2249,7 @@ void QGtkStyle::drawControl(ControlElement element,
             }
 
             if (!cb->currentText.isEmpty() && !cb->editable) {
-                GtkWidget *gtkCombo = QGtk::gtkWidget(QLS("GtkComboBox"));
+                GtkWidget *gtkCombo = d->gtkWidget(QLS("GtkComboBox"));
                 QPalette pal = cb->palette;
                 int labelState = GTK_STATE_INSENSITIVE;
 
@@ -2344,9 +2326,9 @@ void QGtkStyle::drawControl(ControlElement element,
         // Draws the header in tables.
         if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
             Q_UNUSED(header);
-            GtkWidget *gtkTreeView = QGtk::gtkWidget(QLS("GtkTreeView"));
+            GtkWidget *gtkTreeView = d->gtkWidget(QLS("GtkTreeView"));
             // Get the middle column
-            GtkTreeViewColumn *column = QGtk::gtk_tree_view_get_column((GtkTreeView*)gtkTreeView, 1);
+            GtkTreeViewColumn *column = d->gtk_tree_view_get_column((GtkTreeView*)gtkTreeView, 1);
             Q_ASSERT(column);
 
             GtkWidget *gtkTreeHeader = column->button;
@@ -2365,7 +2347,7 @@ void QGtkStyle::drawControl(ControlElement element,
 #ifndef QT_NO_SIZEGRIP
 
     case CE_SizeGrip: {
-        GtkWidget *gtkStatusbar = QGtk::gtkWidget(QLS("GtkStatusbar.GtkFrame"));
+        GtkWidget *gtkStatusbar = d->gtkWidget(QLS("GtkStatusbar.GtkFrame"));
         QRect gripRect = option->rect.adjusted(0, 0, -gtkStatusbar->style->xthickness, -gtkStatusbar->style->ythickness);
         gtkPainter.paintResizeGrip( gtkStatusbar, "statusbar", gripRect, GTK_STATE_NORMAL,
                                     GTK_SHADOW_OUT, QApplication::isRightToLeft() ?
@@ -2377,7 +2359,7 @@ void QGtkStyle::drawControl(ControlElement element,
 #endif // QT_NO_SIZEGRIP
 
     case CE_MenuBarEmptyArea: {
-        GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+        GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
         GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
         painter->fillRect(option->rect, QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8));
         if (widget) { // See CE_MenuBarItem
@@ -2387,7 +2369,7 @@ void QGtkStyle::drawControl(ControlElement element,
             QPainter pmPainter(&pixmap);
             QGtkPainter gtkMenuBarPainter(&pmPainter);
             GtkShadowType shadow_type;
-            QGtk::gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
+            d->gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
             gtkMenuBarPainter.paintBox( gtkMenubar, "menubar",  menuBarRect,
                                         GTK_STATE_NORMAL, shadow_type, gtkMenubar->style);
             pmPainter.end();
@@ -2400,8 +2382,8 @@ void QGtkStyle::drawControl(ControlElement element,
         painter->save();
 
         if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
-            GtkWidget *gtkMenubarItem = QGtk::gtkWidget(QLS("GtkMenuBar.GtkMenuItem"));
-            GtkWidget *gtkMenubar = QGtk::gtkWidget(QLS("GtkMenuBar"));
+            GtkWidget *gtkMenubarItem = d->gtkWidget(QLS("GtkMenuBar.GtkMenuItem"));
+            GtkWidget *gtkMenubar = d->gtkWidget(QLS("GtkMenuBar"));
 
             style = gtkMenubarItem->style;
 
@@ -2416,7 +2398,7 @@ void QGtkStyle::drawControl(ControlElement element,
                 QPainter pmPainter(&pixmap);
                 QGtkPainter menubarPainter(&pmPainter);
                 GtkShadowType shadow_type;
-                QGtk::gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
+                d->gtk_widget_style_get(gtkMenubar, "shadow-type", &shadow_type, NULL);
                 GdkColor gdkBg = gtkMenubar->style->bg[GTK_STATE_NORMAL]; // Theme can depend on transparency
                 painter->fillRect(option->rect, QColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8));
                 menubarPainter.paintBox(gtkMenubar, "menubar",  menuBarRect,
@@ -2440,7 +2422,7 @@ void QGtkStyle::drawControl(ControlElement element,
 
             if (act) {
                 GtkShadowType shadowType = GTK_SHADOW_NONE;
-                QGtk::gtk_widget_style_get (gtkMenubarItem, "selected-shadow-type", &shadowType, NULL);
+                d->gtk_widget_style_get (gtkMenubarItem, "selected-shadow-type", &shadowType, NULL);
                 gtkPainter.paintBox(gtkMenubarItem, "menuitem",  option->rect.adjusted(0, 0, 0, 3),
                                     GTK_STATE_PRELIGHT, shadowType, gtkMenubarItem->style);
                 //draw text
@@ -2457,7 +2439,7 @@ void QGtkStyle::drawControl(ControlElement element,
         break;
 
     case CE_Splitter: {
-        GtkWidget *gtkWindow = QGtk::gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
+        GtkWidget *gtkWindow = d->gtkWidget(QLS("GtkWindow")); // The Murrine Engine currently assumes a widget is passed
         gtkPainter.paintHandle(gtkWindow, "splitter", option->rect, gtkPainter.gtkState(option), GTK_SHADOW_NONE,
                                 !(option->state & State_Horizontal) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL,
                                 style);
@@ -2477,9 +2459,9 @@ void QGtkStyle::drawControl(ControlElement element,
             if (toolbar->positionWithinLine != QStyleOptionToolBar::End)
                 rect.adjust(0, 0, 1, 0);
 
-            GtkWidget *gtkToolbar = QGtk::gtkWidget(QLS("GtkToolbar"));
+            GtkWidget *gtkToolbar = d->gtkWidget(QLS("GtkToolbar"));
             GtkShadowType shadow_type = GTK_SHADOW_NONE;
-            QGtk::gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
+            d->gtk_widget_style_get(gtkToolbar, "shadow-type", &shadow_type, NULL);
             gtkPainter.paintBox( gtkToolbar, "toolbar",  rect,
                                  GTK_STATE_NORMAL, shadow_type, gtkToolbar->style);
         }
@@ -2496,22 +2478,22 @@ void QGtkStyle::drawControl(ControlElement element,
             const int windowsItemHMargin      =  3; // menu item hor text margin
             const int windowsItemVMargin      = 26; // menu item ver text margin
             const int windowsRightBorder      = 15; // right border on windows
-            GtkWidget *gtkMenu = QGtk::gtkWidget(QLS("GtkMenu"));
-            GtkWidget *gtkMenuItem = menuItem->checked ? QGtk::gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")) :
-                                     QGtk::gtkWidget(QLS("GtkMenu.GtkMenuItem"));
+            GtkWidget *gtkMenu = d->gtkWidget(QLS("GtkMenu"));
+            GtkWidget *gtkMenuItem = menuItem->checked ? d->gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")) :
+                                     d->gtkWidget(QLS("GtkMenu.GtkMenuItem"));
 
             style = gtkPainter.getStyle(gtkMenuItem);
             QColor borderColor = option->palette.background().color().darker(160);
             QColor shadow = option->palette.dark().color();
 
             if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
-                GtkWidget *gtkMenuSeparator = QGtk::gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
+                GtkWidget *gtkMenuSeparator = d->gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
                 painter->setPen(shadow.lighter(106));
                 gboolean wide_separators = 0;
                 gint     separator_height = 0;
                 guint    horizontal_padding = 3;
-                if (!QGtk::gtk_check_version(2, 10, 0)) {
-                    QGtk::gtk_widget_style_get(gtkMenuSeparator,
+                if (!d->gtk_check_version(2, 10, 0)) {
+                    d->gtk_widget_style_get(gtkMenuSeparator,
                                            "wide-separators",    &wide_separators,
                                            "separator-height",   &separator_height,
                                            "horizontal-padding", &horizontal_padding,
@@ -2545,7 +2527,7 @@ void QGtkStyle::drawControl(ControlElement element,
             bool ignoreCheckMark = false;
 
             gint checkSize;
-            QGtk::gtk_widget_style_get(QGtk::gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
+            d->gtk_widget_style_get(d->gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
 
             int checkcol = qMax(menuItem->maxIconWidth, qMax(20, checkSize));
 
@@ -2732,7 +2714,7 @@ void QGtkStyle::drawControl(ControlElement element,
                 // "arrow-scaling" is actually hardcoded and fails on hardy (see gtk+-2.12/gtkmenuitem.c)
                 // though the current documentation states otherwise
                 int horizontal_padding;
-                QGtk::gtk_widget_style_get(gtkMenuItem, "horizontal-padding", &horizontal_padding, NULL);
+                d->gtk_widget_style_get(gtkMenuItem, "horizontal-padding", &horizontal_padding, NULL);
 
                 const int dim = static_cast<int>(arrow_size * arrow_scaling);
                 int xpos = menuItem->rect.left() + menuItem->rect.width() - horizontal_padding - dim;
@@ -2750,12 +2732,12 @@ void QGtkStyle::drawControl(ControlElement element,
 
     case CE_PushButton:
         if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
-            GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+            GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
             proxy()->drawControl(CE_PushButtonBevel, btn, painter, widget);
             QStyleOptionButton subopt = *btn;
             subopt.rect = subElementRect(SE_PushButtonContents, btn, widget);
             gint interiorFocus = true;
-            QGtk::gtk_widget_style_get(gtkButton, "interior-focus", &interiorFocus, NULL);
+            d->gtk_widget_style_get(gtkButton, "interior-focus", &interiorFocus, NULL);
             int xt = interiorFocus ? gtkButton->style->xthickness : 0;
             int yt = interiorFocus ? gtkButton->style->ythickness : 0;
 
@@ -2776,7 +2758,7 @@ void QGtkStyle::drawControl(ControlElement element,
 
     case CE_TabBarTabShape:
         if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
-            GtkWidget *gtkNotebook = QGtk::gtkWidget(QLS("GtkNotebook"));
+            GtkWidget *gtkNotebook = d->gtkWidget(QLS("GtkNotebook"));
             style = gtkPainter.getStyle(gtkNotebook);
 
             QRect rect = option->rect;
@@ -2843,7 +2825,7 @@ void QGtkStyle::drawControl(ControlElement element,
     case CE_ProgressBarGroove:
         if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
             Q_UNUSED(bar);
-            GtkWidget *gtkProgressBar = QGtk::gtkWidget(QLS("GtkProgressBar"));
+            GtkWidget *gtkProgressBar = d->gtkWidget(QLS("GtkProgressBar"));
             GtkStateType state = gtkPainter.gtkState(option);
             gtkPainter.paintBox( gtkProgressBar, "trough",  option->rect, state, GTK_SHADOW_IN, gtkProgressBar->style);
         }
@@ -2853,7 +2835,7 @@ void QGtkStyle::drawControl(ControlElement element,
     case CE_ProgressBarContents:
         if (const QStyleOptionProgressBar *bar = qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
             GtkStateType state = option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE;
-            GtkWidget *gtkProgressBar = QGtk::gtkWidget(QLS("GtkProgressBar"));
+            GtkWidget *gtkProgressBar = d->gtkWidget(QLS("GtkProgressBar"));
             style = gtkProgressBar->style;
             gtkPainter.paintBox( gtkProgressBar, "trough",  option->rect, state, GTK_SHADOW_IN, style);
             int xt = style->xthickness;
@@ -2901,8 +2883,8 @@ void QGtkStyle::drawControl(ControlElement element,
             else if (bar->progress > bar->minimum)
                 fakePos = maximum - 1;
 
-            GtkObject *adjustment =  QGtk::gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
-            QGtk::gtk_progress_set_adjustment((GtkProgress*)(gtkProgressBar), (GtkAdjustment*)(adjustment));
+            GtkObject *adjustment =  d->gtk_adjustment_new(fakePos, 0, maximum, 0, 0, 0);
+            d->gtk_progress_set_adjustment((GtkProgress*)(gtkProgressBar), (GtkAdjustment*)(adjustment));
 
             QRect progressBar;
 
@@ -2942,8 +2924,10 @@ void QGtkStyle::drawControl(ControlElement element,
 QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComplex *option,
                                 SubControl subControl, const QWidget *widget) const
 {
+    Q_D(const QGtkStyle);
+
     QRect rect = QWindowsStyle::subControlRect(control, option, subControl, widget);
-    if (!QGtk::isThemeAvailable())
+    if (!d->isThemeAvailable())
         return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
 
     switch (control) {
@@ -3009,7 +2993,7 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
 
     case CC_SpinBox:
         if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
-            GtkWidget *gtkSpinButton = QGtk::gtkWidget(QLS("GtkSpinButton"));
+            GtkWidget *gtkSpinButton = d->gtkWidget(QLS("GtkSpinButton"));
             int center = spinbox->rect.height() / 2;
             int xt = spinbox->frame ? gtkSpinButton->style->xthickness : 0;
             int yt = spinbox->frame ? gtkSpinButton->style->ythickness : 0;
@@ -3017,7 +3001,7 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
 
             QSize bs;
             bs.setHeight(qMax(8, spinbox->rect.height()/2 - y));
-            bs.setWidth(spinboxArrowSize());
+            bs.setWidth(d->getSpinboxArrowSize());
             int x, lx, rx;
             x = spinbox->rect.width() - y - bs.width() + 2;
             lx = xt;
@@ -3063,17 +3047,17 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
         if (const QStyleOptionComboBox *box = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
             // We employ the gtk widget to position arrows and separators for us
             QString comboBoxPath = box->editable ? QLS("GtkComboBoxEntry") : QLS("GtkComboBox");
-            GtkWidget *gtkCombo = QGtk::gtkWidget(comboBoxPath);
-            QGtk::gtk_widget_set_direction(gtkCombo, (option->direction == Qt::RightToLeft) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+            GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath);
+            d->gtk_widget_set_direction(gtkCombo, (option->direction == Qt::RightToLeft) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
             GtkAllocation geometry = {0, 0, qMax(0, option->rect.width()), qMax(0, option->rect.height())};
-            QGtk::gtk_widget_size_allocate(gtkCombo, &geometry);
+            d->gtk_widget_size_allocate(gtkCombo, &geometry);
             int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, option, widget);
             QString arrowPath = comboBoxPath + QLS(".GtkToggleButton");
 
             if (!box->editable && !appears_as_list)
                 arrowPath += QLS(".GtkHBox.GtkArrow");
 
-            GtkWidget *arrowWidget = QGtk::gtkWidget(arrowPath);
+            GtkWidget *arrowWidget = d->gtkWidget(arrowPath);
             if (!arrowWidget)
                 return QCleanlooksStyle::subControlRect(control, option, subControl, widget);
 
@@ -3118,19 +3102,19 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
   \reimp
 */
 QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
-
                                   const QSize &size, const QWidget *widget) const
 {
+    Q_D(const QGtkStyle);
 
     QSize newSize = QCleanlooksStyle::sizeFromContents(type, option, size, widget);
-    if (!QGtk::isThemeAvailable())
+    if (!d->isThemeAvailable())
         return newSize;
 
     switch (type) {
 
     case CT_ToolButton:
         if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
-            GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkToolButton.GtkButton"));
+            GtkWidget *gtkButton = d->gtkWidget(QLS("GtkToolButton.GtkButton"));
             newSize = size + QSize(2 * gtkButton->style->xthickness, 1 + 2 * gtkButton->style->ythickness);
             if (widget && qobject_cast<QToolBar *>(widget->parentWidget())) {
                 QSize minSize(0, 25);
@@ -3138,7 +3122,7 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
                     minSize = toolbutton->iconSize + QSize(12, 12);
                 newSize = newSize.expandedTo(minSize);
             }
-            
+
             if (toolbutton->features & QStyleOptionToolButton::HasMenu)
                 newSize += QSize(6, 0);
         }
@@ -3149,10 +3133,10 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
             int textMargin = 8;
 
             if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
-                GtkWidget *gtkMenuSeparator = QGtk::gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
+                GtkWidget *gtkMenuSeparator = d->gtkWidget(QLS("GtkMenu.GtkSeparatorMenuItem"));
                 gboolean wide_separators;
                 gint     separator_height;
-                QGtk::gtk_widget_style_get(gtkMenuSeparator,
+                d->gtk_widget_style_get(gtkMenuSeparator,
                                        "wide-separators",    &wide_separators,
                                        "separator-height",   &separator_height,
                                        NULL);
@@ -3161,14 +3145,14 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
                 break;
             }
 
-            GtkWidget *gtkMenuItem = QGtk::gtkWidget(QLS("GtkMenu.GtkMenuItem"));
+            GtkWidget *gtkMenuItem = d->gtkWidget(QLS("GtkMenu.GtkMenuItem"));
             GtkStyle* style = gtkMenuItem->style;
             newSize += QSize(textMargin + style->xthickness - 2, style->ythickness - 4);
 
             // Cleanlooks assumes a check column of 20 pixels so we need to
             // expand it a bit
             gint checkSize;
-            QGtk::gtk_widget_style_get(QGtk::gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
+            d->gtk_widget_style_get(d->gtkWidget(QLS("GtkMenu.GtkCheckMenuItem")), "indicator-size", &checkSize, NULL);
             newSize.setHeight(qMax(newSize.height(), checkSize + 2));
             newSize.setWidth(newSize.width() + qMax(0, checkSize - 20));
         }
@@ -3183,22 +3167,22 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
 
     case CT_SpinBox:
         // QSpinBox does some nasty things that depends on CT_LineEdit
-        newSize = size + QSize(0, -QGtk::gtkWidget(QLS("GtkSpinButton"))->style->ythickness * 2 + 2);
+        newSize = size + QSize(0, -d->gtkWidget(QLS("GtkSpinButton"))->style->ythickness * 2 + 2);
         break;
 
     case CT_PushButton:
         if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
-            GtkWidget *gtkButton = QGtk::gtkWidget(QLS("GtkButton"));
+            GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton"));
             gint focusPadding, focusWidth;
-            QGtk::gtk_widget_style_get(gtkButton, "focus-padding", &focusPadding, NULL);
-            QGtk::gtk_widget_style_get(gtkButton, "focus-line-width", &focusWidth, NULL);
+            d->gtk_widget_style_get(gtkButton, "focus-padding", &focusPadding, NULL);
+            d->gtk_widget_style_get(gtkButton, "focus-line-width", &focusWidth, NULL);
             newSize = size;
             newSize += QSize(2*gtkButton->style->xthickness + 4, 2*gtkButton->style->ythickness);
             newSize += QSize(2*(focusWidth + focusPadding + 2), 2*(focusWidth + focusPadding));
 
-            GtkWidget *gtkButtonBox = QGtk::gtkWidget(QLS("GtkHButtonBox"));
+            GtkWidget *gtkButtonBox = d->gtkWidget(QLS("GtkHButtonBox"));
             gint minWidth = 85, minHeight = 0;
-            QGtk::gtk_widget_style_get(gtkButtonBox, "child-min-width", &minWidth,
+            d->gtk_widget_style_get(gtkButtonBox, "child-min-width", &minWidth,
                                    "child-min-height", &minHeight, NULL);
             if (!btn->text.isEmpty() && newSize.width() < minWidth)
                 newSize.setWidth(minWidth);
@@ -3209,7 +3193,7 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
         break;
 
     case CT_Slider: {
-        GtkWidget *gtkSlider = QGtk::gtkWidget(QLS("GtkHScale"));
+        GtkWidget *gtkSlider = d->gtkWidget(QLS("GtkHScale"));
         newSize = size + QSize(2*gtkSlider->style->xthickness, 2*gtkSlider->style->ythickness);
     }
     break;
@@ -3219,7 +3203,7 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
         break;
 
     case CT_LineEdit: {
-        GtkWidget *gtkEntry = QGtk::gtkWidget(QLS("GtkEntry"));
+        GtkWidget *gtkEntry = d->gtkWidget(QLS("GtkEntry"));
         newSize = size + QSize(2*gtkEntry->style->xthickness, 2*gtkEntry->style->ythickness);
     }
     break;
@@ -3230,7 +3214,7 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
 
     case CT_ComboBox:
         if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
-            GtkWidget *gtkCombo = QGtk::gtkWidget(QLS("GtkComboBox"));
+            GtkWidget *gtkCombo = d->gtkWidget(QLS("GtkComboBox"));
             QRect arrowButtonRect = proxy()->subControlRect(CC_ComboBox, combo, SC_ComboBoxArrow, widget);
             newSize = size + QSize(12 + arrowButtonRect.width() + 2*gtkCombo->style->xthickness, 4 + 2*gtkCombo->style->ythickness);
 
@@ -3263,7 +3247,9 @@ QSize QGtkStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
 QPixmap QGtkStyle::standardPixmap(StandardPixmap sp, const QStyleOption *option,
                                   const QWidget *widget) const
 {
-    if (!QGtk::isThemeAvailable())
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable())
         return QCleanlooksStyle::standardPixmap(sp, option, widget);
 
     QPixmap pixmap;
@@ -3330,7 +3316,9 @@ QIcon QGtkStyle::standardIconImplementation(StandardPixmap standardIcon,
                                                   const QStyleOption *option,
                                                   const QWidget *widget) const
 {
-    if (!QGtk::isThemeAvailable())
+    Q_D(const QGtkStyle);
+
+    if (!d->isThemeAvailable())
         return QCleanlooksStyle::standardIconImplementation(standardIcon, option, widget);
     switch (standardIcon) {
     case SP_DialogDiscardButton:
diff --git a/src/gui/styles/qgtkstyle.h b/src/gui/styles/qgtkstyle.h
index 20c2b52b83..5c3bad18c8 100644
--- a/src/gui/styles/qgtkstyle.h
+++ b/src/gui/styles/qgtkstyle.h
@@ -45,6 +45,7 @@
 #include <QtGui/QCleanlooksStyle>
 #include <QtGui/QPalette>
 #include <QtGui/QFont>
+#include <QtGui/QFileDialog>
 
 QT_BEGIN_HEADER
 
@@ -64,6 +65,8 @@ class Q_GUI_EXPORT QGtkStyle : public QCleanlooksStyle
 
 public:
     QGtkStyle();
+    QGtkStyle(QGtkStylePrivate &dd);
+
     ~QGtkStyle();
 
     QPalette standardPalette() const;
@@ -107,12 +110,15 @@ public:
     void unpolish(QWidget *widget);
     void unpolish(QApplication *app);
 
+    static bool getGConfBool(const QString &key, bool fallback = 0);
+    static QString getGConfString(const QString &key, const QString &fallback = QString());
+
+
 protected Q_SLOTS:
     QIcon standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *option,
                                      const QWidget *widget = 0) const;
 };
 
-
 #endif //!defined(QT_NO_STYLE_QGTK)
 
 QT_END_NAMESPACE
diff --git a/src/gui/styles/qgtkstyle_p.cpp b/src/gui/styles/qgtkstyle_p.cpp
new file mode 100644
index 0000000000..7119a4ff80
--- /dev/null
+++ b/src/gui/styles/qgtkstyle_p.cpp
@@ -0,0 +1,1069 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgtkstyle_p.h"
+
+// This file is responsible for resolving all GTK functions we use
+// dynamically. This is done to avoid link-time dependancy on GTK
+// as well as crashes occurring due to usage of the GTK_QT engines
+//
+// Additionally we create a map of common GTK widgets that we can pass
+// to the GTK theme engine as many engines resort to querying the
+// actual widget pointers for details that are not covered by the
+// state flags
+
+#include <QtCore/qglobal.h>
+#if !defined(QT_NO_STYLE_GTK)
+
+#include <QtCore/QEvent>
+#include <QtCore/QFile>
+#include <QtCore/QStringList>
+#include <QtCore/QTextStream>
+#include <QtCore/QHash>
+#include <QtCore/QUrl>
+#include <QtCore/QLibrary>
+
+#include <private/qapplication_p.h>
+#include <private/qiconloader_p.h>
+
+#include <QtGui/QMenu>
+#include <QtGui/QStyle>
+#include <QtGui/QApplication>
+#include <QtGui/QPixmapCache>
+#include <QtGui/QStatusBar>
+#include <QtGui/QMenuBar>
+#include <QtGui/QToolBar>
+#include <QtGui/QToolButton>
+#include <QtGui/QX11Info>
+
+#include <private/qt_x11_p.h>
+
+QT_BEGIN_NAMESPACE
+
+static bool displayDepth  =  -1;
+Q_GLOBAL_STATIC(QGtkStyleUpdateScheduler, styleScheduler)
+
+Ptr_gtk_container_forall QGtkStylePrivate::gtk_container_forall = 0;
+Ptr_gtk_init QGtkStylePrivate::gtk_init = 0;
+Ptr_gtk_style_attach QGtkStylePrivate::gtk_style_attach = 0;
+Ptr_gtk_window_new QGtkStylePrivate::gtk_window_new = 0;
+Ptr_gtk_widget_destroy QGtkStylePrivate::gtk_widget_destroy = 0;
+Ptr_gtk_widget_realize QGtkStylePrivate::gtk_widget_realize = 0;
+Ptr_gtk_widget_set_default_direction QGtkStylePrivate::gtk_widget_set_default_direction = 0;
+Ptr_gtk_widget_modify_color QGtkStylePrivate::gtk_widget_modify_fg = 0;
+Ptr_gtk_widget_modify_color QGtkStylePrivate::gtk_widget_modify_bg = 0;
+Ptr_gtk_arrow_new QGtkStylePrivate::gtk_arrow_new = 0;
+Ptr_gtk_menu_item_new QGtkStylePrivate::gtk_menu_item_new = 0;
+Ptr_gtk_check_menu_item_new QGtkStylePrivate::gtk_check_menu_item_new = 0;
+Ptr_gtk_menu_bar_new QGtkStylePrivate::gtk_menu_bar_new = 0;
+Ptr_gtk_menu_new QGtkStylePrivate::gtk_menu_new = 0;
+Ptr_gtk_button_new QGtkStylePrivate::gtk_button_new = 0;
+Ptr_gtk_tool_button_new QGtkStylePrivate::gtk_tool_button_new = 0;
+Ptr_gtk_hbutton_box_new QGtkStylePrivate::gtk_hbutton_box_new = 0;
+Ptr_gtk_check_button_new QGtkStylePrivate::gtk_check_button_new = 0;
+Ptr_gtk_radio_button_new QGtkStylePrivate::gtk_radio_button_new = 0;
+Ptr_gtk_spin_button_new QGtkStylePrivate::gtk_spin_button_new = 0;
+Ptr_gtk_frame_new QGtkStylePrivate::gtk_frame_new = 0;
+Ptr_gtk_expander_new QGtkStylePrivate::gtk_expander_new = 0;
+Ptr_gtk_statusbar_new QGtkStylePrivate::gtk_statusbar_new = 0;
+Ptr_gtk_entry_new QGtkStylePrivate::gtk_entry_new = 0;
+Ptr_gtk_hscale_new QGtkStylePrivate::gtk_hscale_new = 0;
+Ptr_gtk_vscale_new QGtkStylePrivate::gtk_vscale_new = 0;
+Ptr_gtk_hscrollbar_new QGtkStylePrivate::gtk_hscrollbar_new = 0;
+Ptr_gtk_vscrollbar_new QGtkStylePrivate::gtk_vscrollbar_new = 0;
+Ptr_gtk_scrolled_window_new QGtkStylePrivate::gtk_scrolled_window_new = 0;
+Ptr_gtk_notebook_new QGtkStylePrivate::gtk_notebook_new = 0;
+Ptr_gtk_toolbar_new QGtkStylePrivate::gtk_toolbar_new = 0;
+Ptr_gtk_toolbar_insert QGtkStylePrivate::gtk_toolbar_insert = 0;
+Ptr_gtk_separator_tool_item_new QGtkStylePrivate::gtk_separator_tool_item_new = 0;
+Ptr_gtk_tree_view_new QGtkStylePrivate::gtk_tree_view_new = 0;
+Ptr_gtk_combo_box_new QGtkStylePrivate::gtk_combo_box_new = 0;
+Ptr_gtk_combo_box_entry_new QGtkStylePrivate::gtk_combo_box_entry_new = 0;
+Ptr_gtk_progress_bar_new QGtkStylePrivate::gtk_progress_bar_new = 0;
+Ptr_gtk_container_add QGtkStylePrivate::gtk_container_add = 0;
+Ptr_gtk_menu_shell_append QGtkStylePrivate::gtk_menu_shell_append = 0;
+Ptr_gtk_progress_set_adjustment QGtkStylePrivate::gtk_progress_set_adjustment = 0;
+Ptr_gtk_range_set_adjustment QGtkStylePrivate::gtk_range_set_adjustment = 0;
+Ptr_gtk_range_set_inverted QGtkStylePrivate::gtk_range_set_inverted = 0;
+Ptr_gtk_icon_factory_lookup_default QGtkStylePrivate::gtk_icon_factory_lookup_default = 0;
+Ptr_gtk_icon_theme_get_default QGtkStylePrivate::gtk_icon_theme_get_default = 0;
+Ptr_gtk_widget_style_get QGtkStylePrivate::gtk_widget_style_get = 0;
+Ptr_gtk_icon_set_render_icon QGtkStylePrivate::gtk_icon_set_render_icon = 0;
+Ptr_gtk_fixed_new QGtkStylePrivate::gtk_fixed_new = 0;
+Ptr_gtk_tree_view_column_new QGtkStylePrivate::gtk_tree_view_column_new = 0;
+Ptr_gtk_tree_view_get_column QGtkStylePrivate::gtk_tree_view_get_column = 0;
+Ptr_gtk_tree_view_append_column QGtkStylePrivate::gtk_tree_view_append_column = 0;
+Ptr_gtk_paint_check QGtkStylePrivate::gtk_paint_check = 0;
+Ptr_gtk_paint_box QGtkStylePrivate::gtk_paint_box = 0;
+Ptr_gtk_paint_box_gap QGtkStylePrivate::gtk_paint_box_gap = 0;
+Ptr_gtk_paint_flat_box QGtkStylePrivate::gtk_paint_flat_box = 0;
+Ptr_gtk_paint_option QGtkStylePrivate::gtk_paint_option = 0;
+Ptr_gtk_paint_extension QGtkStylePrivate::gtk_paint_extension = 0;
+Ptr_gtk_paint_slider QGtkStylePrivate::gtk_paint_slider = 0;
+Ptr_gtk_paint_shadow QGtkStylePrivate::gtk_paint_shadow = 0;
+Ptr_gtk_paint_resize_grip QGtkStylePrivate::gtk_paint_resize_grip = 0;
+Ptr_gtk_paint_focus QGtkStylePrivate::gtk_paint_focus = 0;
+Ptr_gtk_paint_arrow QGtkStylePrivate::gtk_paint_arrow = 0;
+Ptr_gtk_paint_handle QGtkStylePrivate::gtk_paint_handle = 0;
+Ptr_gtk_paint_expander QGtkStylePrivate::gtk_paint_expander = 0;
+Ptr_gtk_adjustment_new QGtkStylePrivate::gtk_adjustment_new = 0;
+Ptr_gtk_paint_hline QGtkStylePrivate::gtk_paint_hline = 0;
+Ptr_gtk_paint_vline QGtkStylePrivate::gtk_paint_vline = 0;
+Ptr_gtk_menu_item_set_submenu QGtkStylePrivate::gtk_menu_item_set_submenu = 0;
+Ptr_gtk_settings_get_default QGtkStylePrivate::gtk_settings_get_default = 0;
+Ptr_gtk_separator_menu_item_new QGtkStylePrivate::gtk_separator_menu_item_new = 0;
+Ptr_gtk_widget_size_allocate QGtkStylePrivate::gtk_widget_size_allocate = 0;
+Ptr_gtk_widget_set_direction QGtkStylePrivate::gtk_widget_set_direction = 0;
+Ptr_gtk_widget_path QGtkStylePrivate::gtk_widget_path = 0;
+Ptr_gtk_container_get_type QGtkStylePrivate::gtk_container_get_type = 0;
+Ptr_gtk_window_get_type QGtkStylePrivate::gtk_window_get_type = 0;
+Ptr_gtk_widget_get_type QGtkStylePrivate::gtk_widget_get_type = 0;
+Ptr_gtk_rc_get_style_by_paths QGtkStylePrivate::gtk_rc_get_style_by_paths = 0;
+Ptr_gtk_check_version QGtkStylePrivate::gtk_check_version = 0;
+
+Ptr_pango_font_description_get_size QGtkStylePrivate::pango_font_description_get_size = 0;
+Ptr_pango_font_description_get_weight QGtkStylePrivate::pango_font_description_get_weight = 0;
+Ptr_pango_font_description_get_family QGtkStylePrivate::pango_font_description_get_family = 0;
+Ptr_pango_font_description_get_style QGtkStylePrivate::pango_font_description_get_style = 0;
+
+Ptr_gtk_file_filter_new QGtkStylePrivate::gtk_file_filter_new = 0;
+Ptr_gtk_file_filter_set_name QGtkStylePrivate::gtk_file_filter_set_name = 0;
+Ptr_gtk_file_filter_add_pattern QGtkStylePrivate::gtk_file_filter_add_pattern = 0;
+Ptr_gtk_file_chooser_add_filter QGtkStylePrivate::gtk_file_chooser_add_filter = 0;
+Ptr_gtk_file_chooser_set_filter QGtkStylePrivate::gtk_file_chooser_set_filter = 0;
+Ptr_gtk_file_chooser_get_filter QGtkStylePrivate::gtk_file_chooser_get_filter = 0;
+Ptr_gtk_file_chooser_dialog_new QGtkStylePrivate::gtk_file_chooser_dialog_new = 0;
+Ptr_gtk_file_chooser_set_current_folder QGtkStylePrivate::gtk_file_chooser_set_current_folder = 0;
+Ptr_gtk_file_chooser_get_filename QGtkStylePrivate::gtk_file_chooser_get_filename = 0;
+Ptr_gtk_file_chooser_get_filenames QGtkStylePrivate::gtk_file_chooser_get_filenames = 0;
+Ptr_gtk_file_chooser_set_current_name QGtkStylePrivate::gtk_file_chooser_set_current_name = 0;
+Ptr_gtk_dialog_run QGtkStylePrivate::gtk_dialog_run = 0;
+Ptr_gtk_file_chooser_set_filename QGtkStylePrivate::gtk_file_chooser_set_filename = 0;
+
+Ptr_gdk_pixbuf_get_pixels QGtkStylePrivate::gdk_pixbuf_get_pixels = 0;
+Ptr_gdk_pixbuf_get_width QGtkStylePrivate::gdk_pixbuf_get_width = 0;
+Ptr_gdk_pixbuf_get_height QGtkStylePrivate::gdk_pixbuf_get_height = 0;
+Ptr_gdk_pixmap_new QGtkStylePrivate::gdk_pixmap_new = 0;
+Ptr_gdk_pixbuf_new QGtkStylePrivate::gdk_pixbuf_new = 0;
+Ptr_gdk_pixbuf_get_from_drawable QGtkStylePrivate::gdk_pixbuf_get_from_drawable = 0;
+Ptr_gdk_draw_rectangle QGtkStylePrivate::gdk_draw_rectangle = 0;
+Ptr_gdk_pixbuf_unref QGtkStylePrivate::gdk_pixbuf_unref = 0;
+Ptr_gdk_drawable_unref QGtkStylePrivate::gdk_drawable_unref = 0;
+Ptr_gdk_drawable_get_depth QGtkStylePrivate::gdk_drawable_get_depth = 0;
+Ptr_gdk_color_free QGtkStylePrivate::gdk_color_free = 0;
+Ptr_gdk_x11_window_set_user_time QGtkStylePrivate::gdk_x11_window_set_user_time = 0;
+Ptr_gdk_x11_drawable_get_xid QGtkStylePrivate::gdk_x11_drawable_get_xid = 0;
+Ptr_gdk_x11_drawable_get_xdisplay QGtkStylePrivate::gdk_x11_drawable_get_xdisplay = 0;
+
+Ptr_gconf_client_get_default QGtkStylePrivate::gconf_client_get_default = 0;
+Ptr_gconf_client_get_string QGtkStylePrivate::gconf_client_get_string = 0;
+Ptr_gconf_client_get_bool QGtkStylePrivate::gconf_client_get_bool = 0;
+
+Ptr_gnome_icon_lookup_sync QGtkStylePrivate::gnome_icon_lookup_sync = 0;
+Ptr_gnome_vfs_init QGtkStylePrivate::gnome_vfs_init = 0;
+
+typedef int (*x11ErrorHandler)(Display*, XErrorEvent*);
+
+static void gtkStyleSetCallback(GtkWidget*, QGtkStylePrivate* stylePrivate)
+{
+    // We have to let this function return and complete the event
+    // loop to ensure that all gtk widgets have been styled before
+    // updating
+    QMetaObject::invokeMethod(styleScheduler(), "updateTheme", Qt::QueuedConnection, Q_ARG(QGtkStylePrivate*, stylePrivate));
+}
+
+static void update_toolbar_style(GtkWidget *gtkToolBar, GParamSpec *, gpointer)
+{
+    GtkToolbarStyle toolbar_style = GTK_TOOLBAR_ICONS;
+    g_object_get(gtkToolBar, "toolbar-style", &toolbar_style, NULL);
+    QWidgetList widgets = QApplication::allWidgets();
+    for (int i = 0; i < widgets.size(); ++i) {
+        QWidget *widget = widgets.at(i);
+        if (qobject_cast<QToolButton*>(widget)) {
+            QEvent event(QEvent::StyleChange);
+            QApplication::sendEvent(widget, &event);
+        }
+    }
+}
+
+static QString classPath(GtkWidget *widget)
+{
+    char* class_path;
+    QGtkStylePrivate::gtk_widget_path (widget, NULL, &class_path, NULL);
+    QString path = QLS(class_path);
+    g_free(class_path);
+
+    // Remove the prefixes
+    path.remove(QLS("GtkWindow."));
+    path.remove(QLS("GtkFixed."));
+    return path;
+}
+
+
+
+bool QGtkStyleFilter::eventFilter(QObject *obj, QEvent *e)
+{
+    if (e->type() == QEvent::ApplicationPaletteChange) {
+        // Only do this the first time since this will also
+        // generate applicationPaletteChange events
+        if (!qt_app_palettes_hash() ||  qt_app_palettes_hash()->isEmpty()) {
+            stylePrivate->applyCustomPaletteHash();
+        }
+    }
+    return QObject::eventFilter(obj, e);
+}
+
+QGtkStylePrivate::QGtkStylePrivate()
+  : QCleanlooksStylePrivate()
+  , filter(this)
+{
+}
+
+void QGtkStylePrivate::init()
+{
+    resolveGtk();
+    initGtkWidgets();
+    if (isThemeAvailable())
+        qApp->installEventFilter(&filter);
+}
+
+GtkWidget* QGtkStylePrivate::gtkWidget(const QString &path)
+{
+    GtkWidget *widget = gtkWidgetMap()->value(path);
+    if (!widget) {
+        // Theme might have rearranged widget internals
+        widget = gtkWidgetMap()->value(path);
+    }
+    return widget;
+}
+
+GtkStyle* QGtkStylePrivate::gtkStyle(const QString &path)
+{
+    if (gtkWidgetMap()->contains(path))
+        return gtkWidgetMap()->value(path)->style;
+    return 0;
+}
+
+/*! \internal
+ *  Get references to gtk functions after we dynamically load the library.
+ */
+void QGtkStylePrivate::resolveGtk()
+{
+    // enforce the "0" suffix, so we'll open libgtk-x11-2.0.so.0
+    QLibrary libgtk(QLS("gtk-x11-2.0"), 0, 0);
+
+    gtk_init = (Ptr_gtk_init)libgtk.resolve("gtk_init");
+    gtk_window_new = (Ptr_gtk_window_new)libgtk.resolve("gtk_window_new");
+    gtk_style_attach = (Ptr_gtk_style_attach)libgtk.resolve("gtk_style_attach");
+    gtk_widget_destroy = (Ptr_gtk_widget_destroy)libgtk.resolve("gtk_widget_destroy");
+    gtk_widget_realize = (Ptr_gtk_widget_realize)libgtk.resolve("gtk_widget_realize");
+
+    gtk_file_chooser_set_current_folder = (Ptr_gtk_file_chooser_set_current_folder)libgtk.resolve("gtk_file_chooser_set_current_folder");
+    gtk_file_filter_new = (Ptr_gtk_file_filter_new)libgtk.resolve("gtk_file_filter_new");
+    gtk_file_filter_set_name = (Ptr_gtk_file_filter_set_name)libgtk.resolve("gtk_file_filter_set_name");
+    gtk_file_filter_add_pattern = (Ptr_gtk_file_filter_add_pattern)libgtk.resolve("gtk_file_filter_add_pattern");
+    gtk_file_chooser_add_filter = (Ptr_gtk_file_chooser_add_filter)libgtk.resolve("gtk_file_chooser_add_filter");
+    gtk_file_chooser_set_filter = (Ptr_gtk_file_chooser_set_filter)libgtk.resolve("gtk_file_chooser_set_filter");
+    gtk_file_chooser_get_filter = (Ptr_gtk_file_chooser_get_filter)libgtk.resolve("gtk_file_chooser_get_filter");
+    gtk_file_chooser_dialog_new = (Ptr_gtk_file_chooser_dialog_new)libgtk.resolve("gtk_file_chooser_dialog_new");
+    gtk_file_chooser_set_current_folder = (Ptr_gtk_file_chooser_set_current_folder)libgtk.resolve("gtk_file_chooser_set_current_folder");
+    gtk_file_chooser_get_filename = (Ptr_gtk_file_chooser_get_filename)libgtk.resolve("gtk_file_chooser_get_filename");
+    gtk_file_chooser_get_filenames = (Ptr_gtk_file_chooser_get_filenames)libgtk.resolve("gtk_file_chooser_get_filenames");
+    gtk_file_chooser_set_current_name = (Ptr_gtk_file_chooser_set_current_name)libgtk.resolve("gtk_file_chooser_set_current_name");
+    gtk_dialog_run = (Ptr_gtk_dialog_run)libgtk.resolve("gtk_dialog_run");
+    gtk_file_chooser_set_filename = (Ptr_gtk_file_chooser_set_filename)libgtk.resolve("gtk_file_chooser_set_filename");
+
+    gdk_pixbuf_get_pixels = (Ptr_gdk_pixbuf_get_pixels)libgtk.resolve("gdk_pixbuf_get_pixels");
+    gdk_pixbuf_get_width = (Ptr_gdk_pixbuf_get_width)libgtk.resolve("gdk_pixbuf_get_width");
+    gdk_pixbuf_get_height = (Ptr_gdk_pixbuf_get_height)libgtk.resolve("gdk_pixbuf_get_height");
+    gdk_pixmap_new = (Ptr_gdk_pixmap_new)libgtk.resolve("gdk_pixmap_new");
+    gdk_pixbuf_new = (Ptr_gdk_pixbuf_new)libgtk.resolve("gdk_pixbuf_new");
+    gdk_pixbuf_get_from_drawable = (Ptr_gdk_pixbuf_get_from_drawable)libgtk.resolve("gdk_pixbuf_get_from_drawable");
+    gdk_draw_rectangle = (Ptr_gdk_draw_rectangle)libgtk.resolve("gdk_draw_rectangle");
+    gdk_pixbuf_unref = (Ptr_gdk_pixbuf_unref)libgtk.resolve("gdk_pixbuf_unref");
+    gdk_drawable_unref = (Ptr_gdk_drawable_unref)libgtk.resolve("gdk_drawable_unref");
+    gdk_drawable_get_depth = (Ptr_gdk_drawable_get_depth)libgtk.resolve("gdk_drawable_get_depth");
+    gdk_color_free = (Ptr_gdk_color_free)libgtk.resolve("gdk_color_free");
+    gdk_x11_window_set_user_time = (Ptr_gdk_x11_window_set_user_time)libgtk.resolve("gdk_x11_window_set_user_time");
+    gdk_x11_drawable_get_xid = (Ptr_gdk_x11_drawable_get_xid)libgtk.resolve("gdk_x11_drawable_get_xid");
+    gdk_x11_drawable_get_xdisplay = (Ptr_gdk_x11_drawable_get_xdisplay)libgtk.resolve("gdk_x11_drawable_get_xdisplay");
+
+    gtk_widget_set_default_direction = (Ptr_gtk_widget_set_default_direction)libgtk.resolve("gtk_widget_set_default_direction");
+    gtk_widget_modify_fg = (Ptr_gtk_widget_modify_color)libgtk.resolve("gtk_widget_modify_fg");
+    gtk_widget_modify_bg = (Ptr_gtk_widget_modify_color)libgtk.resolve("gtk_widget_modify_bg");
+    gtk_arrow_new = (Ptr_gtk_arrow_new)libgtk.resolve("gtk_arrow_new");
+    gtk_menu_item_new = (Ptr_gtk_menu_item_new)libgtk.resolve("gtk_menu_item_new");
+    gtk_check_menu_item_new = (Ptr_gtk_check_menu_item_new)libgtk.resolve("gtk_check_menu_item_new");
+    gtk_menu_bar_new = (Ptr_gtk_menu_bar_new)libgtk.resolve("gtk_menu_bar_new");
+    gtk_menu_new = (Ptr_gtk_menu_new)libgtk.resolve("gtk_menu_new");
+    gtk_toolbar_new = (Ptr_gtk_toolbar_new)libgtk.resolve("gtk_toolbar_new");
+    gtk_separator_tool_item_new = (Ptr_gtk_separator_tool_item_new)libgtk.resolve("gtk_separator_tool_item_new");
+    gtk_toolbar_insert = (Ptr_gtk_toolbar_insert)libgtk.resolve("gtk_toolbar_insert");
+    gtk_button_new = (Ptr_gtk_button_new)libgtk.resolve("gtk_button_new");
+    gtk_tool_button_new = (Ptr_gtk_tool_button_new)libgtk.resolve("gtk_tool_button_new");
+    gtk_hbutton_box_new = (Ptr_gtk_hbutton_box_new)libgtk.resolve("gtk_hbutton_box_new");
+    gtk_check_button_new = (Ptr_gtk_check_button_new)libgtk.resolve("gtk_check_button_new");
+    gtk_radio_button_new = (Ptr_gtk_radio_button_new)libgtk.resolve("gtk_radio_button_new");
+    gtk_notebook_new = (Ptr_gtk_notebook_new)libgtk.resolve("gtk_notebook_new");
+    gtk_progress_bar_new = (Ptr_gtk_progress_bar_new)libgtk.resolve("gtk_progress_bar_new");
+    gtk_spin_button_new = (Ptr_gtk_spin_button_new)libgtk.resolve("gtk_spin_button_new");
+    gtk_hscale_new = (Ptr_gtk_hscale_new)libgtk.resolve("gtk_hscale_new");
+    gtk_vscale_new = (Ptr_gtk_vscale_new)libgtk.resolve("gtk_vscale_new");
+    gtk_hscrollbar_new = (Ptr_gtk_hscrollbar_new)libgtk.resolve("gtk_hscrollbar_new");
+    gtk_vscrollbar_new = (Ptr_gtk_vscrollbar_new)libgtk.resolve("gtk_vscrollbar_new");
+    gtk_scrolled_window_new = (Ptr_gtk_scrolled_window_new)libgtk.resolve("gtk_scrolled_window_new");
+    gtk_menu_shell_append = (Ptr_gtk_menu_shell_append)libgtk.resolve("gtk_menu_shell_append");
+    gtk_entry_new = (Ptr_gtk_entry_new)libgtk.resolve("gtk_entry_new");
+    gtk_tree_view_new = (Ptr_gtk_tree_view_new)libgtk.resolve("gtk_tree_view_new");
+    gtk_combo_box_new = (Ptr_gtk_combo_box_new)libgtk.resolve("gtk_combo_box_new");
+    gtk_progress_set_adjustment = (Ptr_gtk_progress_set_adjustment)libgtk.resolve("gtk_progress_set_adjustment");
+    gtk_range_set_adjustment = (Ptr_gtk_range_set_adjustment)libgtk.resolve("gtk_range_set_adjustment");
+    gtk_range_set_inverted = (Ptr_gtk_range_set_inverted)libgtk.resolve("gtk_range_set_inverted");
+    gtk_container_add = (Ptr_gtk_container_add)libgtk.resolve("gtk_container_add");
+    gtk_icon_factory_lookup_default = (Ptr_gtk_icon_factory_lookup_default)libgtk.resolve("gtk_icon_factory_lookup_default");
+    gtk_icon_theme_get_default = (Ptr_gtk_icon_theme_get_default)libgtk.resolve("gtk_icon_theme_get_default");
+    gtk_widget_style_get = (Ptr_gtk_widget_style_get)libgtk.resolve("gtk_widget_style_get");
+    gtk_icon_set_render_icon = (Ptr_gtk_icon_set_render_icon)libgtk.resolve("gtk_icon_set_render_icon");
+    gtk_fixed_new = (Ptr_gtk_fixed_new)libgtk.resolve("gtk_fixed_new");
+    gtk_tree_view_column_new = (Ptr_gtk_tree_view_column_new)libgtk.resolve("gtk_tree_view_column_new");
+    gtk_tree_view_append_column= (Ptr_gtk_tree_view_append_column )libgtk.resolve("gtk_tree_view_append_column");
+    gtk_tree_view_get_column = (Ptr_gtk_tree_view_get_column )libgtk.resolve("gtk_tree_view_get_column");
+    gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
+    gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
+    gtk_paint_flat_box = (Ptr_gtk_paint_flat_box)libgtk.resolve("gtk_paint_flat_box");
+    gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
+    gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
+    gtk_paint_resize_grip = (Ptr_gtk_paint_resize_grip)libgtk.resolve("gtk_paint_resize_grip");
+    gtk_paint_focus = (Ptr_gtk_paint_focus)libgtk.resolve("gtk_paint_focus");
+    gtk_paint_shadow = (Ptr_gtk_paint_shadow)libgtk.resolve("gtk_paint_shadow");
+    gtk_paint_slider = (Ptr_gtk_paint_slider)libgtk.resolve("gtk_paint_slider");
+    gtk_paint_expander = (Ptr_gtk_paint_expander)libgtk.resolve("gtk_paint_expander");
+    gtk_paint_handle = (Ptr_gtk_paint_handle)libgtk.resolve("gtk_paint_handle");
+    gtk_paint_option = (Ptr_gtk_paint_option)libgtk.resolve("gtk_paint_option");
+    gtk_paint_arrow = (Ptr_gtk_paint_arrow)libgtk.resolve("gtk_paint_arrow");
+    gtk_paint_box_gap = (Ptr_gtk_paint_box_gap)libgtk.resolve("gtk_paint_box_gap");
+    gtk_paint_extension = (Ptr_gtk_paint_extension)libgtk.resolve("gtk_paint_extension");
+    gtk_paint_hline = (Ptr_gtk_paint_hline)libgtk.resolve("gtk_paint_hline");
+    gtk_paint_vline = (Ptr_gtk_paint_vline)libgtk.resolve("gtk_paint_vline");
+    gtk_adjustment_new = (Ptr_gtk_adjustment_new)libgtk.resolve("gtk_adjustment_new");
+    gtk_menu_item_set_submenu = (Ptr_gtk_menu_item_set_submenu)libgtk.resolve("gtk_menu_item_set_submenu");
+    gtk_settings_get_default = (Ptr_gtk_settings_get_default)libgtk.resolve("gtk_settings_get_default");
+    gtk_separator_menu_item_new = (Ptr_gtk_separator_menu_item_new)libgtk.resolve("gtk_separator_menu_item_new");
+    gtk_frame_new = (Ptr_gtk_frame_new)libgtk.resolve("gtk_frame_new");
+    gtk_expander_new = (Ptr_gtk_expander_new)libgtk.resolve("gtk_expander_new");
+    gtk_statusbar_new = (Ptr_gtk_statusbar_new)libgtk.resolve("gtk_statusbar_new");
+    gtk_combo_box_entry_new = (Ptr_gtk_combo_box_entry_new)libgtk.resolve("gtk_combo_box_entry_new");
+    gtk_container_forall = (Ptr_gtk_container_forall)libgtk.resolve("gtk_container_forall");
+    gtk_widget_size_allocate =(Ptr_gtk_widget_size_allocate)libgtk.resolve("gtk_widget_size_allocate");
+    gtk_widget_set_direction =(Ptr_gtk_widget_set_direction)libgtk.resolve("gtk_widget_set_direction");
+    gtk_widget_path =(Ptr_gtk_widget_path)libgtk.resolve("gtk_widget_path");
+    gtk_container_get_type =(Ptr_gtk_container_get_type)libgtk.resolve("gtk_container_get_type");
+    gtk_window_get_type =(Ptr_gtk_window_get_type)libgtk.resolve("gtk_window_get_type");
+    gtk_widget_get_type =(Ptr_gtk_widget_get_type)libgtk.resolve("gtk_widget_get_type");
+    gtk_rc_get_style_by_paths =(Ptr_gtk_rc_get_style_by_paths)libgtk.resolve("gtk_rc_get_style_by_paths");
+    gtk_check_version =(Ptr_gtk_check_version)libgtk.resolve("gtk_check_version");
+    pango_font_description_get_size = (Ptr_pango_font_description_get_size)libgtk.resolve("pango_font_description_get_size");
+    pango_font_description_get_weight = (Ptr_pango_font_description_get_weight)libgtk.resolve("pango_font_description_get_weight");
+    pango_font_description_get_family = (Ptr_pango_font_description_get_family)libgtk.resolve("pango_font_description_get_family");
+    pango_font_description_get_style = (Ptr_pango_font_description_get_style)libgtk.resolve("pango_font_description_get_style");
+
+    gnome_icon_lookup_sync = (Ptr_gnome_icon_lookup_sync)QLibrary::resolve(QLS("gnomeui-2"), 0, "gnome_icon_lookup_sync");
+    gnome_vfs_init= (Ptr_gnome_vfs_init)QLibrary::resolve(QLS("gnomevfs-2"), 0, "gnome_vfs_init");
+}
+
+/* \internal
+ * Initializes a number of gtk menu widgets.
+ * The widgets are cached.
+ */
+void QGtkStylePrivate::initGtkMenu()
+{
+    // Create menubar
+    GtkWidget *gtkMenuBar = QGtkStylePrivate::gtk_menu_bar_new();
+    setupGtkWidget(gtkMenuBar);
+
+    GtkWidget *gtkMenuBarItem = QGtkStylePrivate::gtk_menu_item_new();
+    gtk_menu_shell_append((GtkMenuShell*)(gtkMenuBar), gtkMenuBarItem);
+    gtk_widget_realize(gtkMenuBarItem);
+
+    // Create menu
+    GtkWidget *gtkMenu = QGtkStylePrivate::gtk_menu_new();
+    gtk_menu_item_set_submenu((GtkMenuItem*)(gtkMenuBarItem), gtkMenu);
+    gtk_widget_realize(gtkMenu);
+
+    GtkWidget *gtkMenuItem = QGtkStylePrivate::gtk_menu_item_new();
+    gtk_menu_shell_append((GtkMenuShell*)gtkMenu, gtkMenuItem);
+    gtk_widget_realize(gtkMenuItem);
+
+    GtkWidget *gtkCheckMenuItem = QGtkStylePrivate::gtk_check_menu_item_new();
+    gtk_menu_shell_append((GtkMenuShell*)gtkMenu, gtkCheckMenuItem);
+    gtk_widget_realize(gtkCheckMenuItem);
+
+    GtkWidget *gtkMenuSeparator = QGtkStylePrivate::gtk_separator_menu_item_new();
+    gtk_menu_shell_append((GtkMenuShell*)gtkMenu, gtkMenuSeparator);
+
+    addAllSubWidgets(gtkMenuBar);
+    addAllSubWidgets(gtkMenu);
+}
+
+
+void QGtkStylePrivate::initGtkTreeview()
+{
+    GtkWidget *gtkTreeView = gtk_tree_view_new();
+    gtk_tree_view_append_column((GtkTreeView*)gtkTreeView, gtk_tree_view_column_new());
+    gtk_tree_view_append_column((GtkTreeView*)gtkTreeView, gtk_tree_view_column_new());
+    gtk_tree_view_append_column((GtkTreeView*)gtkTreeView, gtk_tree_view_column_new());
+    addWidget(gtkTreeView);
+}
+
+
+/* \internal
+ * Initializes a number of gtk widgets that we can later on use to determine some of our styles.
+ * The widgets are cached.
+ */
+void QGtkStylePrivate::initGtkWidgets()
+{
+    // From gtkmain.c
+    uid_t ruid = getuid ();
+    uid_t rgid = getgid ();
+    uid_t euid = geteuid ();
+    uid_t egid = getegid ();
+    if (ruid != euid || rgid != egid) {
+        qWarning("\nThis process is currently running setuid or setgid.\nGTK+ does not allow this "
+                 "therefore Qt cannot use the GTK+ integration.\nTry launching your app using \'gksudo\', "
+                 "\'kdesudo\' or a similar tool.\n\n"
+                 "See http://www.gtk.org/setuid.html for more information.\n");
+        return;
+    }
+
+    static QString themeName;
+    if (!gtkWidgetMap()->contains(QLS("GtkWindow")) && themeName.isEmpty()) {
+        themeName = getThemeName();
+
+        if (themeName.isEmpty()) {
+            qWarning("QGtkStyle was unable to detect the current GTK+ theme.");
+            return;
+        } else if (themeName == QLS("Qt") || themeName == QLS("Qt4")) {
+            // Due to namespace conflicts with Qt3 and obvious recursion with Qt4,
+            // we cannot support the GTK_Qt Gtk engine
+            qWarning("QGtkStyle cannot be used together with the GTK_Qt engine.");
+            return;
+        }
+    }
+
+    if (QGtkStylePrivate::gtk_init) {
+        // Gtk will set the Qt error handler so we have to reset it afterwards
+        x11ErrorHandler qt_x_errhandler = XSetErrorHandler(0);
+        QGtkStylePrivate::gtk_init (NULL, NULL);
+        XSetErrorHandler(qt_x_errhandler);
+
+        // make a window
+        GtkWidget* gtkWindow = QGtkStylePrivate::gtk_window_new(GTK_WINDOW_POPUP);
+        QGtkStylePrivate::gtk_widget_realize(gtkWindow);
+        if (displayDepth == -1)
+            displayDepth = QGtkStylePrivate::gdk_drawable_get_depth(gtkWindow->window);
+        gtkWidgetMap()->insert(QLS("GtkWindow"), gtkWindow);
+
+
+        // Make all other widgets. respect the text direction
+        if (qApp->layoutDirection() == Qt::RightToLeft)
+            QGtkStylePrivate::gtk_widget_set_default_direction(GTK_TEXT_DIR_RTL);
+
+        if (!gtkWidgetMap()->contains(QLS("GtkButton"))) {
+            GtkWidget *gtkButton = QGtkStylePrivate::gtk_button_new();
+            addWidget(gtkButton);
+            g_signal_connect(gtkButton, "style-set", G_CALLBACK(gtkStyleSetCallback), this);
+            addWidget(QGtkStylePrivate::gtk_tool_button_new(NULL, NULL));
+            addWidget(QGtkStylePrivate::gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE));
+            addWidget(QGtkStylePrivate::gtk_hbutton_box_new());
+            addWidget(QGtkStylePrivate::gtk_check_button_new());
+            addWidget(QGtkStylePrivate::gtk_radio_button_new(NULL));
+            addWidget(QGtkStylePrivate::gtk_combo_box_new());
+            addWidget(QGtkStylePrivate::gtk_combo_box_entry_new());
+            addWidget(QGtkStylePrivate::gtk_entry_new());
+            addWidget(QGtkStylePrivate::gtk_frame_new(NULL));
+            addWidget(QGtkStylePrivate::gtk_expander_new(""));
+            addWidget(QGtkStylePrivate::gtk_statusbar_new());
+            addWidget(QGtkStylePrivate::gtk_hscale_new((GtkAdjustment*)(QGtkStylePrivate::gtk_adjustment_new(1, 0, 1, 0, 0, 0))));
+            addWidget(QGtkStylePrivate::gtk_hscrollbar_new(NULL));
+            addWidget(QGtkStylePrivate::gtk_scrolled_window_new(NULL, NULL));
+
+            initGtkMenu();
+            addWidget(QGtkStylePrivate::gtk_notebook_new());
+            addWidget(QGtkStylePrivate::gtk_progress_bar_new());
+            addWidget(QGtkStylePrivate::gtk_spin_button_new((GtkAdjustment*)
+                                             (QGtkStylePrivate::gtk_adjustment_new(1, 0, 1, 0, 0, 0)), 0.1, 3));
+            GtkWidget *toolbar = gtk_toolbar_new();
+            g_signal_connect (toolbar, "notify::toolbar-style", G_CALLBACK (update_toolbar_style), toolbar);
+            gtk_toolbar_insert((GtkToolbar*)toolbar, gtk_separator_tool_item_new(), -1);
+            addWidget(toolbar);
+            initGtkTreeview();
+            addWidget(gtk_vscale_new((GtkAdjustment*)(QGtkStylePrivate::gtk_adjustment_new(1, 0, 1, 0, 0, 0))));
+            addWidget(gtk_vscrollbar_new(NULL));
+        }
+        else // Rebuild map
+        {
+            // When styles change subwidgets can get rearranged
+            // as with the combo box. We need to update the widget map
+            // to reflect this;
+            QHash<QString, GtkWidget*> oldMap = *gtkWidgetMap();
+            gtkWidgetMap()->clear();
+            QHashIterator<QString, GtkWidget*> it(oldMap);
+            while (it.hasNext()) {
+                it.next();
+                if (!it.key().contains(QLatin1Char('.'))) {
+                    addAllSubWidgets(it.value());
+                }
+            }
+        }
+    } else {
+        qWarning("QGtkStyle could not resolve GTK. Make sure you have installed the proper libraries.");
+    }
+}
+
+/*! \internal
+ * destroys all previously buffered widgets.
+ */
+void QGtkStylePrivate::cleanupGtkWidgets()
+{
+    if (gtkWidgetMap()->contains(QLS("GtkWindow"))) // Gtk will destroy all children
+        gtk_widget_destroy(gtkWidgetMap()->value(QLS("GtkWindow")));
+}
+
+static bool resolveGConf()
+{
+    if (!QGtkStylePrivate::gconf_client_get_default) {
+        QGtkStylePrivate::gconf_client_get_default = (Ptr_gconf_client_get_default)QLibrary::resolve(QLS("gconf-2"), 4, "gconf_client_get_default");
+        QGtkStylePrivate::gconf_client_get_string =  (Ptr_gconf_client_get_string)QLibrary::resolve(QLS("gconf-2"), 4, "gconf_client_get_string");
+        QGtkStylePrivate::gconf_client_get_bool =  (Ptr_gconf_client_get_bool)QLibrary::resolve(QLS("gconf-2"), 4, "gconf_client_get_bool");
+    }
+    return (QGtkStylePrivate::gconf_client_get_default !=0);
+}
+
+QString QGtkStylePrivate::getGConfString(const QString &value, const QString &fallback)
+{
+    QString retVal = fallback;
+    if (resolveGConf()) {
+        g_type_init();
+        GConfClient* client = gconf_client_get_default();
+        GError *err = 0;
+        char *str = gconf_client_get_string(client, qPrintable(value), &err);
+        if (!err) {
+            retVal = QString::fromUtf8(str);
+            g_free(str);
+        }
+        g_object_unref(client);
+        if (err)
+            g_error_free (err);
+    }
+    return retVal;
+}
+
+bool QGtkStylePrivate::getGConfBool(const QString &key, bool fallback)
+{
+    bool retVal = fallback;
+    if (resolveGConf()) {
+        g_type_init();
+        GConfClient* client = gconf_client_get_default();
+        GError *err = 0;
+        bool result = gconf_client_get_bool(client, qPrintable(key), &err);
+        g_object_unref(client);
+        if (!err)
+            retVal = result;
+        else
+            g_error_free (err);
+    }
+    return retVal;
+}
+
+QString QGtkStylePrivate::getThemeName() const
+{
+    QString themeName;
+    // We try to parse the gtkrc file first
+    // primarily to avoid resolving Gtk functions if
+    // the KDE 3 "Qt" style is currently in use
+    QString rcPaths = QString::fromLocal8Bit(qgetenv("GTK2_RC_FILES"));
+    if (!rcPaths.isEmpty()) {
+        QStringList paths = rcPaths.split(QLS(":"));
+        foreach (const QString &rcPath, paths) {
+            if (!rcPath.isEmpty()) {
+                QFile rcFile(rcPath);
+                if (rcFile.exists() && rcFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                    QTextStream in(&rcFile);
+                    while(!in.atEnd()) {
+                        QString line = in.readLine();
+                        if (line.contains(QLS("gtk-theme-name"))) {
+                            line = line.right(line.length() - line.indexOf(QLatin1Char('=')) - 1);
+                            line.remove(QLatin1Char('\"'));
+                            line = line.trimmed();
+                            themeName = line;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!themeName.isEmpty())
+                break;
+        }
+    }
+
+    // Fall back to gconf
+    if (themeName.isEmpty() && resolveGConf())
+        themeName = getGConfString(QLS("/desktop/gnome/interface/gtk_theme"));
+
+    return themeName;
+}
+
+// Get size of the arrow controls in a GtkSpinButton
+int QGtkStylePrivate::getSpinboxArrowSize() const
+{
+    const int MIN_ARROW_WIDTH = 6;
+    GtkWidget *spinButton = gtkWidget(QLS("GtkSpinButton"));
+    GtkStyle *style = spinButton->style;
+    gint size = pango_font_description_get_size (style->font_desc);
+    gint arrow_size;
+    arrow_size = qMax(PANGO_PIXELS (size), MIN_ARROW_WIDTH) + style->xthickness;
+    arrow_size += arrow_size%2 + 1;
+    return arrow_size;
+}
+
+
+bool QGtkStylePrivate::isKDE4Session()
+{
+    static int version = -1;
+    if (version == -1)
+        version = qgetenv("KDE_SESSION_VERSION").toInt();
+    return (version == 4);
+}
+
+void QGtkStylePrivate::applyCustomPaletteHash()
+{
+    QPalette menuPal = gtkWidgetPalette(QLS("GtkMenu"));
+    GdkColor gdkBg = gtkWidget(QLS("GtkMenu"))->style->bg[GTK_STATE_NORMAL];
+    QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
+    menuPal.setBrush(QPalette::Base, bgColor);
+    menuPal.setBrush(QPalette::Window, bgColor);
+    qApp->setPalette(menuPal, "QMenu");
+
+    QPalette toolbarPal = gtkWidgetPalette(QLS("GtkToolbar"));
+    qApp->setPalette(toolbarPal, "QToolBar");
+
+    QPalette menuBarPal = gtkWidgetPalette(QLS("GtkMenuBar"));
+    qApp->setPalette(menuBarPal, "QMenuBar");
+}
+
+/*! \internal
+ *  Returns the gtk Widget that should be used to determine text foreground and background colors.
+*/
+GtkWidget* QGtkStylePrivate::getTextColorWidget() const
+{
+    return  gtkWidget(QLS("GtkEntry"));
+}
+
+void QGtkStylePrivate::setupGtkWidget(GtkWidget* widget)
+{
+    if (Q_GTK_IS_WIDGET(widget)) {
+        static GtkWidget* protoLayout = 0;
+        if (!protoLayout) {
+            protoLayout = QGtkStylePrivate::gtk_fixed_new();
+            QGtkStylePrivate::gtk_container_add((GtkContainer*)(gtkWidgetMap()->value(QLS("GtkWindow"))), protoLayout);
+        }
+        Q_ASSERT(protoLayout);
+
+        if (!widget->parent && !GTK_WIDGET_TOPLEVEL(widget))
+            QGtkStylePrivate::gtk_container_add((GtkContainer*)(protoLayout), widget);
+        QGtkStylePrivate::gtk_widget_realize(widget);
+    }
+}
+
+void QGtkStylePrivate::addWidgetToMap(GtkWidget *widget)
+{
+    if (Q_GTK_IS_WIDGET(widget)) {
+       gtk_widget_realize(widget);
+       gtkWidgetMap()->insert(classPath(widget), widget);
+    }
+ }
+
+void QGtkStylePrivate::addAllSubWidgets(GtkWidget *widget, gpointer v)
+{
+    Q_UNUSED(v);
+    addWidgetToMap(widget);
+    if (GTK_CHECK_TYPE ((widget), gtk_container_get_type()))
+        gtk_container_forall((GtkContainer*)widget, addAllSubWidgets, NULL);
+}
+
+// Updates window/windowtext palette based on the indicated gtk widget
+QPalette QGtkStylePrivate::gtkWidgetPalette(const QString &gtkWidgetName)
+{
+    GtkWidget *gtkWidget = QGtkStylePrivate::gtkWidget(gtkWidgetName);
+    Q_ASSERT(gtkWidget);
+    QPalette pal = QApplication::palette();
+    GdkColor gdkBg = gtkWidget->style->bg[GTK_STATE_NORMAL];
+    GdkColor gdkText = gtkWidget->style->fg[GTK_STATE_NORMAL];
+    GdkColor gdkDisabledText = gtkWidget->style->fg[GTK_STATE_INSENSITIVE];
+    QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
+    QColor textColor(gdkText.red>>8, gdkText.green>>8, gdkText.blue>>8);
+    QColor disabledTextColor(gdkDisabledText.red>>8, gdkDisabledText.green>>8, gdkDisabledText.blue>>8);
+    pal.setBrush(QPalette::Window, bgColor);
+    pal.setBrush(QPalette::Button, bgColor);
+    pal.setBrush(QPalette::All, QPalette::WindowText, textColor);
+    pal.setBrush(QPalette::Disabled, QPalette::WindowText, disabledTextColor);
+    pal.setBrush(QPalette::All, QPalette::ButtonText, textColor);
+    pal.setBrush(QPalette::Disabled, QPalette::ButtonText, disabledTextColor);
+    return pal;
+}
+
+
+void QGtkStyleUpdateScheduler::updateTheme( QGtkStylePrivate* stylePrivate )
+{
+    static QString oldTheme(QLS("qt_not_set"));
+    QPixmapCache::clear();
+
+    QFont font = QGtkStylePrivate::getThemeFont();
+    if (QApplication::font() != font)
+        qApp->setFont(font);
+
+    if (oldTheme != stylePrivate->getThemeName()) {
+        oldTheme = stylePrivate->getThemeName();
+        QPalette newPalette = qApp->style()->standardPalette();
+        QApplicationPrivate::setSystemPalette(newPalette);
+        QApplication::setPalette(newPalette);
+        stylePrivate->initGtkWidgets();
+        stylePrivate->applyCustomPaletteHash();
+        QList<QWidget*> widgets = QApplication::allWidgets();
+        // Notify all widgets that size metrics might have changed
+        foreach (QWidget *widget, widgets) {
+            QEvent e(QEvent::StyleChange);
+            QApplication::sendEvent(widget, &e);
+        }
+    }
+    QIconLoader::instance()->updateSystemTheme();
+}
+
+void QGtkStylePrivate::addWidget(GtkWidget *widget)
+{
+    if (widget) {
+        setupGtkWidget(widget);
+        addAllSubWidgets(widget);
+    }
+}
+
+
+// Fetch the application font from the pango font description
+// contained in the theme.
+QFont QGtkStylePrivate::getThemeFont()
+{
+    QFont font;
+    GtkStyle *style = gtkStyle();
+    if (style && qApp->desktopSettingsAware())
+    {
+        PangoFontDescription *gtk_font = style->font_desc;
+        font.setPointSizeF((float)(pango_font_description_get_size(gtk_font))/PANGO_SCALE);
+
+        QString family = QString::fromLatin1(pango_font_description_get_family(gtk_font));
+        if (!family.isEmpty())
+            font.setFamily(family);
+
+        int weight = pango_font_description_get_weight(gtk_font);
+        if (weight >= PANGO_WEIGHT_HEAVY)
+            font.setWeight(QFont::Black);
+        else if (weight >= PANGO_WEIGHT_BOLD)
+            font.setWeight(QFont::Bold);
+        else if (weight >= PANGO_WEIGHT_SEMIBOLD)
+            font.setWeight(QFont::DemiBold);
+        else if (weight >= PANGO_WEIGHT_NORMAL)
+            font.setWeight(QFont::Normal);
+        else
+            font.setWeight(QFont::Light);
+
+        PangoStyle fontstyle = pango_font_description_get_style(gtk_font);
+        if (fontstyle == PANGO_STYLE_ITALIC)
+            font.setStyle(QFont::StyleItalic);
+        else if (fontstyle == PANGO_STYLE_OBLIQUE)
+            font.setStyle(QFont::StyleOblique);
+        else
+            font.setStyle(QFont::StyleNormal);
+    }
+    return font;
+}
+
+
+// ----------- Native file dialogs -----------
+
+// Extract filter list from expressions of type: foo (*.a *.b *.c)"
+QStringList QGtkStylePrivate::extract_filter(const QString &rawFilter)
+{
+    QString result = rawFilter;
+    QRegExp r(QString::fromLatin1("^([^()]*)\\(([a-zA-Z0-9_.*? +;#\\-\\[\\]@\\{\\}/!<>\\$%&=^~:\\|]*)\\)$"));
+    int index = r.indexIn(result);
+    if (index >= 0)
+        result = r.cap(2);
+    return result.split(QLatin1Char(' '));
+}
+
+extern QStringList qt_make_filter_list(const QString &filter);
+
+void QGtkStylePrivate::setupGtkFileChooser(GtkWidget* gtkFileChooser, QWidget *parent,
+                                const QString &dir, const QString &filter, QString *selectedFilter,
+                                QFileDialog::Options options, bool isSaveDialog,
+                                QMap<GtkFileFilter *, QString> *filterMap)
+{
+    g_object_set(gtkFileChooser, "do-overwrite-confirmation", gboolean(!(options & QFileDialog::DontConfirmOverwrite)), NULL);
+    g_object_set(gtkFileChooser, "local_only", gboolean(true), NULL);
+    if (!filter.isEmpty()) {
+        QStringList filters = qt_make_filter_list(filter);
+        foreach (const QString &rawfilter, filters) {
+            GtkFileFilter *gtkFilter = QGtkStylePrivate::gtk_file_filter_new ();
+            QString name = rawfilter.left(rawfilter.indexOf(QLatin1Char('(')));
+            QStringList extensions = extract_filter(rawfilter);
+            QGtkStylePrivate::gtk_file_filter_set_name(gtkFilter, qPrintable(name.isEmpty() ? extensions.join(QLS(", ")) : name));
+
+            foreach (const QString &fileExtension, extensions) {
+                // Note Gtk file dialogs are by default case sensitive
+                // and only supports basic glob syntax so we
+                // rewrite .xyz to .[xX][yY][zZ]
+                QString caseInsensitive;
+                for (int i = 0 ; i < fileExtension.length() ; ++i) {
+                    QChar ch = fileExtension.at(i);
+                    if (ch.isLetter()) {
+                        caseInsensitive.append(
+                                QLatin1Char('[') +
+                                ch.toLower() +
+                                ch.toUpper() +
+                                QLatin1Char(']'));
+                    } else {
+                        caseInsensitive.append(ch);
+                    }
+                }
+                QGtkStylePrivate::gtk_file_filter_add_pattern (gtkFilter, qPrintable(caseInsensitive));
+
+            }
+            if (filterMap)
+                filterMap->insert(gtkFilter, rawfilter);
+            QGtkStylePrivate::gtk_file_chooser_add_filter((GtkFileChooser*)gtkFileChooser, gtkFilter);
+            if (selectedFilter && (rawfilter == *selectedFilter))
+                QGtkStylePrivate::gtk_file_chooser_set_filter((GtkFileChooser*)gtkFileChooser, gtkFilter);
+        }
+    }
+
+    // Using the currently active window is not entirely correct, however
+    // it gives more sensible behavior for applications that do not provide a
+    // parent
+    QWidget *modalFor = parent ? parent->window() : qApp->activeWindow();
+    if (modalFor) {
+        QGtkStylePrivate::gtk_widget_realize(gtkFileChooser); // Creates X window
+        XSetTransientForHint(QGtkStylePrivate::gdk_x11_drawable_get_xdisplay(gtkFileChooser->window),
+                             QGtkStylePrivate::gdk_x11_drawable_get_xid(gtkFileChooser->window),
+                             modalFor->winId());
+        QGtkStylePrivate::gdk_x11_window_set_user_time (gtkFileChooser->window, QX11Info::appUserTime());
+
+    }
+
+    QFileInfo fileinfo(dir);
+    if (dir.isEmpty())
+        fileinfo.setFile(QDir::currentPath());
+    fileinfo.makeAbsolute();
+    if (fileinfo.isDir()) {
+        QGtkStylePrivate::gtk_file_chooser_set_current_folder((GtkFileChooser*)gtkFileChooser, qPrintable(dir));
+    } else if (isSaveDialog) {
+        QGtkStylePrivate::gtk_file_chooser_set_current_folder((GtkFileChooser*)gtkFileChooser, qPrintable(fileinfo.absolutePath()));
+        QGtkStylePrivate::gtk_file_chooser_set_current_name((GtkFileChooser*)gtkFileChooser, qPrintable(fileinfo.fileName()));
+    } else {
+        QGtkStylePrivate::gtk_file_chooser_set_filename((GtkFileChooser*)gtkFileChooser, qPrintable(dir));
+    }
+}
+
+QString QGtkStylePrivate::openFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
+                            QString *selectedFilter, QFileDialog::Options options)
+{
+    QMap<GtkFileFilter *, QString> filterMap;
+    GtkWidget *gtkFileChooser = QGtkStylePrivate::gtk_file_chooser_dialog_new (qPrintable(caption),
+                                                             NULL,
+                                                             GTK_FILE_CHOOSER_ACTION_OPEN,
+                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+                                                             NULL);
+
+    setupGtkFileChooser(gtkFileChooser, parent, dir, filter, selectedFilter, options, false, &filterMap);
+
+    QWidget modal_widget;
+    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
+    modal_widget.setParent(parent, Qt::Window);
+    QApplicationPrivate::enterModal(&modal_widget);
+
+    QString filename;
+    if (QGtkStylePrivate::gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
+        char *gtk_filename = QGtkStylePrivate::gtk_file_chooser_get_filename ((GtkFileChooser*)gtkFileChooser);
+        filename = QString::fromUtf8(gtk_filename);
+        g_free (gtk_filename);
+        if (selectedFilter) {
+            GtkFileFilter *gtkFilter = QGtkStylePrivate::gtk_file_chooser_get_filter ((GtkFileChooser*)gtkFileChooser);
+            *selectedFilter = filterMap.value(gtkFilter);
+        }
+    }
+
+    QApplicationPrivate::leaveModal(&modal_widget);
+    gtk_widget_destroy (gtkFileChooser);
+    return filename;
+}
+
+
+QString QGtkStylePrivate::openDirectory(QWidget *parent, const QString &caption, const QString &dir, QFileDialog::Options options)
+{
+    QMap<GtkFileFilter *, QString> filterMap;
+    GtkWidget *gtkFileChooser = QGtkStylePrivate::gtk_file_chooser_dialog_new (qPrintable(caption),
+                                                             NULL,
+                                                             GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+                                                             NULL);
+
+    setupGtkFileChooser(gtkFileChooser, parent, dir, QString(), 0, options);
+    QWidget modal_widget;
+    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
+    modal_widget.setParent(parent, Qt::Window);
+    QApplicationPrivate::enterModal(&modal_widget);
+
+    QString filename;
+    if (QGtkStylePrivate::gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
+        char *gtk_filename = QGtkStylePrivate::gtk_file_chooser_get_filename ((GtkFileChooser*)gtkFileChooser);
+        filename = QString::fromUtf8(gtk_filename);
+        g_free (gtk_filename);
+    }
+
+    QApplicationPrivate::leaveModal(&modal_widget);
+    gtk_widget_destroy (gtkFileChooser);
+    return filename;
+}
+
+QStringList QGtkStylePrivate::openFilenames(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
+                                 QString *selectedFilter, QFileDialog::Options options)
+{
+    QStringList filenames;
+    QMap<GtkFileFilter *, QString> filterMap;
+    GtkWidget *gtkFileChooser = QGtkStylePrivate::gtk_file_chooser_dialog_new (qPrintable(caption),
+                                                             NULL,
+                                                             GTK_FILE_CHOOSER_ACTION_OPEN,
+                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+                                                             NULL);
+
+    setupGtkFileChooser(gtkFileChooser, parent, dir, filter, selectedFilter, options, false, &filterMap);
+    g_object_set(gtkFileChooser, "select-multiple", gboolean(true), NULL);
+
+    QWidget modal_widget;
+    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
+    modal_widget.setParent(parent, Qt::Window);
+    QApplicationPrivate::enterModal(&modal_widget);
+
+    if (gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
+        GSList *gtk_file_names = QGtkStylePrivate::gtk_file_chooser_get_filenames((GtkFileChooser*)gtkFileChooser);
+        for (GSList *iterator  = gtk_file_names ; iterator; iterator = iterator->next)
+            filenames << QString::fromUtf8((const char*)iterator->data);
+        g_slist_free(gtk_file_names);
+        if (selectedFilter) {
+            GtkFileFilter *gtkFilter = QGtkStylePrivate::gtk_file_chooser_get_filter ((GtkFileChooser*)gtkFileChooser);
+            *selectedFilter = filterMap.value(gtkFilter);
+        }
+    }
+
+    QApplicationPrivate::leaveModal(&modal_widget);
+    gtk_widget_destroy (gtkFileChooser);
+    return filenames;
+}
+
+QString QGtkStylePrivate::saveFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
+                           QString *selectedFilter, QFileDialog::Options options)
+{
+    QMap<GtkFileFilter *, QString> filterMap;
+    GtkWidget *gtkFileChooser = QGtkStylePrivate::gtk_file_chooser_dialog_new (qPrintable(caption),
+                                                             NULL,
+                                                             GTK_FILE_CHOOSER_ACTION_SAVE,
+                                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                                             GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+                                                             NULL);
+    setupGtkFileChooser(gtkFileChooser, parent, dir, filter, selectedFilter, options, true, &filterMap);
+
+    QWidget modal_widget;
+    modal_widget.setAttribute(Qt::WA_NoChildEventsForParent, true);
+    modal_widget.setParent(parent, Qt::Window);
+    QApplicationPrivate::enterModal(&modal_widget);
+
+    QString filename;
+    if (QGtkStylePrivate::gtk_dialog_run ((GtkDialog*)gtkFileChooser) == GTK_RESPONSE_ACCEPT) {
+        char *gtk_filename = QGtkStylePrivate::gtk_file_chooser_get_filename ((GtkFileChooser*)gtkFileChooser);
+        filename = QString::fromUtf8(gtk_filename);
+        g_free (gtk_filename);
+        if (selectedFilter) {
+            GtkFileFilter *gtkFilter = QGtkStylePrivate::gtk_file_chooser_get_filter ((GtkFileChooser*)gtkFileChooser);
+            *selectedFilter = filterMap.value(gtkFilter);
+        }
+    }
+
+    QApplicationPrivate::leaveModal(&modal_widget);
+    gtk_widget_destroy (gtkFileChooser);
+    return filename;
+}
+
+QIcon QGtkStylePrivate::getFilesystemIcon(const QFileInfo &info)
+{
+    QIcon icon;
+    if (gnome_vfs_init && gnome_icon_lookup_sync) {
+        gnome_vfs_init();
+        GtkIconTheme *theme = gtk_icon_theme_get_default();
+        QByteArray fileurl = QUrl::fromLocalFile(info.absoluteFilePath()).toEncoded();
+        char * icon_name = gnome_icon_lookup_sync(theme,
+                                                  NULL,
+                                                  fileurl.data(),
+                                                  NULL,
+                                                  GNOME_ICON_LOOKUP_FLAGS_NONE,
+                                                  NULL);
+        QString iconName = QString::fromUtf8(icon_name);
+        g_free(icon_name);
+        if (iconName.startsWith(QLatin1Char('/')))
+            return QIcon(iconName);
+        return QIcon::fromTheme(iconName);
+    }
+    return icon;
+}
+
+QT_END_NAMESPACE
+
+#endif // !defined(QT_NO_STYLE_GTK)
diff --git a/src/gui/styles/gtksymbols_p.h b/src/gui/styles/qgtkstyle_p.h
index 2cf21ce8cc..fa16769362 100644
--- a/src/gui/styles/gtksymbols_p.h
+++ b/src/gui/styles/qgtkstyle_p.h
@@ -39,8 +39,8 @@
 **
 ****************************************************************************/
 
-#ifndef GTKSYMBOLS_H
-#define GTKSYMBOLS_H
+#ifndef QGTKSTYLE_P_H
+#define QGTKSTYLE_P_H
 
 //
 //  W A R N I N G
@@ -56,19 +56,19 @@
 #include <QtCore/qglobal.h>
 #if !defined(QT_NO_STYLE_GTK)
 
+#include <QtGui/QFileDialog>
+
+#include <QtGui/QGtkStyle>
+#include <private/qcleanlooksstyle_p.h>
+
 #undef signals // Collides with GTK stymbols
 #include <gtk/gtk.h>
-#include <QtCore/QLibrary>
-#include <QtGui/QFont>
-#include <QtGui/QFileDialog>
+
 typedef unsigned long XID;
 
 #undef GTK_OBJECT_FLAGS
 #define GTK_OBJECT_FLAGS(obj)(((GtkObject*)(obj))->flags)
-#define Q_GTK_TYPE_WIDGET QGtk::gtk_widget_get_type()
-#define Q_GTK_IS_WIDGET(widget) widget && GTK_CHECK_TYPE ((widget), Q_GTK_TYPE_WIDGET)
-#define Q_GTK_TYPE_WINDOW QGtk::gtk_window_get_type()
-#define Q_GTK_TYPE_CONTAINER QGtk::gtk_container_get_type()
+#define Q_GTK_IS_WIDGET(widget) widget && GTK_CHECK_TYPE ((widget), QGtkStylePrivate::gtk_widget_get_type())
 
 #define QLS(x) QLatin1String(x)
 
@@ -198,6 +198,35 @@ typedef XID  (*Ptr_gdk_x11_drawable_get_xid) (GdkDrawable *);
 typedef Display* (*Ptr_gdk_x11_drawable_get_xdisplay) ( GdkDrawable *);
 
 
+QT_BEGIN_NAMESPACE
+
+typedef QStringList (*_qt_filedialog_open_filenames_hook)(QWidget * parent, const QString &caption, const QString &dir,
+                                                          const QString &filter, QString *selectedFilter, QFileDialog::Options options);
+typedef QString (*_qt_filedialog_open_filename_hook)     (QWidget * parent, const QString &caption, const QString &dir,
+                                                          const QString &filter, QString *selectedFilter, QFileDialog::Options options);
+typedef QString (*_qt_filedialog_save_filename_hook)     (QWidget * parent, const QString &caption, const QString &dir,
+                                                          const QString &filter, QString *selectedFilter, QFileDialog::Options options);
+typedef QString (*_qt_filedialog_existing_directory_hook)(QWidget *parent, const QString &caption, const QString &dir,
+                                                          QFileDialog::Options options);
+
+extern Q_GUI_EXPORT _qt_filedialog_open_filename_hook qt_filedialog_open_filename_hook;
+extern Q_GUI_EXPORT _qt_filedialog_open_filenames_hook qt_filedialog_open_filenames_hook;
+extern Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook;
+extern Q_GUI_EXPORT _qt_filedialog_existing_directory_hook qt_filedialog_existing_directory_hook;
+
+class QGtkStylePrivate;
+
+class QGtkStyleFilter : public QObject
+{
+public:
+    QGtkStyleFilter(QGtkStylePrivate* sp)
+        : stylePrivate(sp)
+    {}
+private:
+    QGtkStylePrivate* stylePrivate;
+    bool eventFilter(QObject *obj, QEvent *e);
+};
+
 typedef enum {
   GNOME_ICON_LOOKUP_FLAGS_NONE = 0,
   GNOME_ICON_LOOKUP_FLAGS_EMBEDDING_TEXT = 1<<0,
@@ -220,21 +249,41 @@ typedef char* (*Ptr_gnome_icon_lookup_sync)  (
         GnomeIconLookupFlags flags,
         GnomeIconLookupResultFlags *result);
 
-QT_BEGIN_NAMESPACE
 
-class QGtk
+class QGtkStylePrivate : public QCleanlooksStylePrivate
 {
+    Q_DECLARE_PUBLIC(QGtkStyle)
 public:
+    QGtkStylePrivate();
+
+    QGtkStyleFilter filter;
+
     static GtkWidget* gtkWidget(const QString &path);
     static GtkStyle* gtkStyle(const QString &path = QLatin1String("GtkWindow"));
 
-    static void cleanup_gtk_widgets();
-    static void initGtkWidgets();
+    virtual void resolveGtk();
+    virtual void initGtkMenu();
+    virtual void initGtkTreeview();
+    virtual void initGtkWidgets();
+
+    static void cleanupGtkWidgets();
+
     static bool isKDE4Session();
-    static void applyCustomPaletteHash();
+    void applyCustomPaletteHash();
     static QFont getThemeFont();
     static bool isThemeAvailable() { return gtkStyle() != 0; }
 
+    static bool getGConfBool(const QString &key, bool fallback = 0);
+    static QString getGConfString(const QString &key, const QString &fallback = QString());
+
+    virtual QString getThemeName() const;
+    virtual int getSpinboxArrowSize() const;
+
+    static void setupGtkFileChooser(GtkWidget* gtkFileChooser, QWidget *parent,
+            const QString &dir, const QString &filter, QString *selectedFilter,
+            QFileDialog::Options options, bool isSaveDialog = false,
+            QMap<GtkFileFilter *, QString> *filterMap = 0);
+
     static QString openFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
                                 QString *selectedFilter, QFileDialog::Options options);
     static QString saveFilename(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
@@ -242,8 +291,6 @@ public:
     static QString openDirectory(QWidget *parent, const QString &caption, const QString &dir, QFileDialog::Options options);
     static QStringList openFilenames(QWidget *parent, const QString &caption, const QString &dir, const QString &filter,
                                     QString *selectedFilter, QFileDialog::Options options);
-    static QString getGConfString(const QString &key, const QString &fallback = QString());
-    static bool getGConfBool(const QString &key, bool fallback = 0);
     static QIcon getFilesystemIcon(const QFileInfo &);
 
     static Ptr_gtk_container_forall gtk_container_forall;
@@ -364,6 +411,29 @@ public:
 
     static Ptr_gnome_icon_lookup_sync gnome_icon_lookup_sync;
     static Ptr_gnome_vfs_init gnome_vfs_init;
+
+    virtual QPalette gtkWidgetPalette(const QString &gtkWidgetName);
+
+protected:
+    typedef QHash<QString, GtkWidget*> WidgetMap;
+
+    static inline WidgetMap *gtkWidgetMap()
+    {
+        static WidgetMap *map = 0;
+        if (!map)
+            map = new WidgetMap();
+        return map;
+    }
+
+    static QStringList extract_filter(const QString &rawFilter);
+
+    virtual GtkWidget* getTextColorWidget() const;
+    static void setupGtkWidget(GtkWidget* widget);
+    static void addWidgetToMap(GtkWidget* widget);
+    static void addAllSubWidgets(GtkWidget *widget, gpointer v = 0);
+    static void addWidget(GtkWidget *widget);
+
+    virtual void init();
 };
 
 // Helper to ensure that we have polished all our gtk widgets
@@ -372,10 +442,10 @@ class QGtkStyleUpdateScheduler : public QObject
 {
     Q_OBJECT
 public slots:
-    void updateTheme();
+    void updateTheme( QGtkStylePrivate* stylePrivate );
 };
 
 QT_END_NAMESPACE
 
 #endif // !QT_NO_STYLE_GTK
-#endif // GTKSYMBOLS_H
+#endif // QGTKSTYLE_P_H
diff --git a/src/gui/styles/styles.pri b/src/gui/styles/styles.pri
index 767ade0ec9..88a2cce609 100644
--- a/src/gui/styles/styles.pri
+++ b/src/gui/styles/styles.pri
@@ -109,10 +109,10 @@ contains( styles, plastique ) {
 contains( styles, gtk ) {
         HEADERS += styles/qgtkstyle.h
         HEADERS += styles/qgtkpainter_p.h
-        HEADERS += styles/gtksymbols_p.h
+        HEADERS += styles/qgtkstyle_p.h
         SOURCES += styles/qgtkstyle.cpp
         SOURCES += styles/qgtkpainter.cpp
-        SOURCES += styles/gtksymbols.cpp
+        SOURCES += styles/qgtkstyle_p.cpp
 	!contains( styles, cleanlooks ) {
 		styles += cleanlooks
 		DEFINES+= QT_STYLE_CLEANLOOKS