Added GTK+2.0 engine

Ia Ora was created by Mandriva so that Qt and GTK applications could have a uniform
look. It only seems fair to include the GTK style with the TDE style.

Source: https://distrib-coffee.ipsl.jussieu.fr/pub/linux/Mageia/distrib/cauldron/SRPMS/core/release/ia_ora-gnome-1.0.25-12.mga9.src.rpm
Licence: GNU GPL v2 or later

Signed-off-by: Mavridis Philippe <mavridisf@gmail.com>

18 files changed, 5133 insertions, 0 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fe2acac..6d75449 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,6 +51,7 @@ option( WITH_GCC_VISIBILITY "Enable fvisibility and fvisibility-inlines-hidden"
 
 option( BUILD_ALL          "Build all" ON )
 option( BUILD_TRANSLATIONS "Build translations" ${BUILD_ALL} )
+option( BUILD_GTK_ENGINE   "Build GTK+2.0 engine" ${BUILD_ALL} )
 
 
 ##### configure checks
diff --git a/ConfigureChecks.cmake b/ConfigureChecks.cmake
index d1e3778..63bda27 100644
--- a/ConfigureChecks.cmake
+++ b/ConfigureChecks.cmake
@@ -23,3 +23,19 @@ tde_setup_largefiles( )
 if( WITH_GCC_VISIBILITY )
   tde_setup_gcc_visibility( )
 endif( WITH_GCC_VISIBILITY )
+
+if( BUILD_GTK_ENGINE )
+  pkg_search_module( GTK gtk+-2.0 )
+  if( NOT GTK_FOUND )
+    tde_message_fatal( "The GTK+2 engine was selected for build, but GTK+2 headers were not found on your system." )
+  endif( )
+
+  pkg_get_variable( GTK_BIN_VERSION gtk+-2.0 gtk_binary_version )
+  set( INSTALL_PATH_GTK_ENGINES "${GTK_LIBDIR}/gtk-2.0/${GTK_BIN_VERSION}/engines"
+       CACHE PATH "The directory in which to install the theme engine library" )
+  message( STATUS "  theme engine lib directory: ${INSTALL_PATH_GTK_ENGINES}" )
+  set( INSTALL_PATH_GTK_THEMES "${GTK_PREFIX}/share/themes"
+       CACHE PATH "The directory in which to install the theme data" )
+  message( STATUS "  theme engine data directory: ${INSTALL_PATH_GTK_THEMES}" )
+
+endif( BUILD_GTK_ENGINE )
\ No newline at end of file
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index fcca24d..af31fb6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,2 +1,3 @@
 add_subdirectory( widget )
 add_subdirectory( twin )
+tde_conditional_add_subdirectory( BUILD_GTK_ENGINE gtk )
diff --git a/src/gtk/CMakeLists.txt b/src/gtk/CMakeLists.txt
new file mode 100644
index 0000000..555b42b
--- /dev/null
+++ b/src/gtk/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(engine)
+add_subdirectory(styles)
\ No newline at end of file
diff --git a/src/gtk/engine/CMakeLists.txt b/src/gtk/engine/CMakeLists.txt
new file mode 100644
index 0000000..cbc3625
--- /dev/null
+++ b/src/gtk/engine/CMakeLists.txt
@@ -0,0 +1,21 @@
+include_directories(
+  ${CMAKE_BINARY_DIR}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${GTK_INCLUDE_DIRS}
+)
+
+link_directories(
+  ${GTK_LIBDIR}
+)
+
+tde_add_library(ia_ora SHARED
+  SOURCES
+    ia_ora_theme_draw.c
+    ia_ora_theme_main.c
+    ia_ora_rc_style.c
+
+  LINK ${GTK_LIBRARIES}
+
+  DESTINATION ${INSTALL_PATH_GTK_ENGINES}
+)
\ No newline at end of file
diff --git a/src/gtk/engine/ia_ora_rc_style.c b/src/gtk/engine/ia_ora_rc_style.c
new file mode 100644
index 0000000..46f6c05
--- /dev/null
+++ b/src/gtk/engine/ia_ora_rc_style.c
@@ -0,0 +1,217 @@
+/*  Ia Ora theme
+ *  Copyright (C) 2006 Frederic Crozat - Mandriva
+ *  1999 Olivier Fourdan (fourdan@xfce.org) for XFCE code
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "ia_ora_rc_style.h"
+#include "ia_ora_style.h"
+
+static void ia_ora_rc_style_init(Ia_OraRcStyle * style);
+static void ia_ora_rc_style_class_init(Ia_OraRcStyleClass * klass);
+static void ia_ora_rc_style_finalize(GObject * object);
+static guint ia_ora_rc_style_parse(GtkRcStyle * rc_style, GtkSettings * settings, GScanner * scanner);
+static void ia_ora_rc_style_merge(GtkRcStyle * dest, GtkRcStyle * src);
+
+static GtkStyle *ia_ora_rc_style_create_style(GtkRcStyle * rc_style);
+
+static GtkRcStyleClass *ia_ora_parent_rc_class;
+
+GType ia_ora_type_rc_style = 0;
+
+enum
+{
+    TOKEN_GRADIENT = G_TOKEN_LAST + 1,
+    TOKEN_CROSS,
+    TOKEN_BLACK_CHECK,
+    TOKEN_TRUE,
+    TOKEN_FALSE,
+};
+
+static struct
+{
+  const gchar *name;
+  guint        token;
+}
+ia_ora_rc_symbols[] =
+{
+  { "enable_gradient", TOKEN_GRADIENT },
+  { "use_cross", TOKEN_CROSS},
+  { "black_check", TOKEN_BLACK_CHECK},
+  { "TRUE",            TOKEN_TRUE},
+  { "FALSE",           TOKEN_FALSE},
+};
+
+void ia_ora_rc_style_register_type(GTypeModule * module)
+{
+    static const GTypeInfo object_info = {
+        sizeof(Ia_OraRcStyleClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) ia_ora_rc_style_class_init,
+        NULL,                   /* class_finalize */
+        NULL,                   /* class_data */
+        sizeof(Ia_OraRcStyle),
+        0,                      /* n_preallocs */
+        (GInstanceInitFunc) ia_ora_rc_style_init,
+	NULL
+    };
+
+    ia_ora_type_rc_style = g_type_module_register_type(module, 
+						       GTK_TYPE_RC_STYLE, 
+						       "Ia_OraRcStyle", 
+						       &object_info, 0);
+}
+
+static void ia_ora_rc_style_init(Ia_OraRcStyle * ia_ora_rc_style)
+{
+  ia_ora_rc_style->enable_gradient = TRUE;
+  ia_ora_rc_style->use_cross = FALSE;
+  ia_ora_rc_style->black_check = FALSE;
+}
+
+static void ia_ora_rc_style_class_init(Ia_OraRcStyleClass * klass)
+{
+    GtkRcStyleClass *rc_style_class = GTK_RC_STYLE_CLASS(klass);
+    GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+    ia_ora_parent_rc_class = g_type_class_peek_parent(klass);
+
+    rc_style_class->parse = ia_ora_rc_style_parse;
+    rc_style_class->merge = ia_ora_rc_style_merge;
+    rc_style_class->create_style = ia_ora_rc_style_create_style;
+}
+
+static guint ia_ora_parse_boolean(GScanner * scanner, GTokenType wanted_token, guint * retval)
+{
+    guint token;
+
+    token = g_scanner_get_next_token(scanner);
+    if(token != wanted_token)
+        return wanted_token;
+
+    token = g_scanner_get_next_token(scanner);
+    if(token != G_TOKEN_EQUAL_SIGN)
+        return G_TOKEN_EQUAL_SIGN;
+
+    token = g_scanner_get_next_token(scanner);
+    if(token == TOKEN_TRUE)
+        *retval = TRUE;
+    else if(token == TOKEN_FALSE)
+        *retval = FALSE;
+    else
+        return TOKEN_TRUE;
+
+    return G_TOKEN_NONE;
+}
+
+
+static guint ia_ora_rc_style_parse(GtkRcStyle * rc_style, GtkSettings * settings, GScanner * scanner)
+{
+    static GQuark scope_id = 0;
+    Ia_OraRcStyle *ia_ora_rc_style = IA_ORA_RC_STYLE(rc_style);
+    guint old_scope;
+    guint token;
+    guint i;
+
+    /* Set up a new scope in this scanner. */
+
+    if(!scope_id)
+        scope_id = g_quark_from_string("ia_ora_theme_engine");
+
+    /* If we bail out due to errors, we *don't* reset the scope, so the
+     * error messaging code can make sense of our tokens.
+     */
+    old_scope = g_scanner_set_scope(scanner, scope_id);
+
+  /* Now check if we already added our symbols to this scope
+   * (in some previous call to clearlooks_rc_style_parse for the
+   * same scanner.
+   */
+
+    if(!g_scanner_lookup_symbol(scanner, ia_ora_rc_symbols[0].name)) {
+        for(i = 0; i < G_N_ELEMENTS (ia_ora_rc_symbols); i++)
+        {
+            g_scanner_scope_add_symbol(scanner, scope_id, ia_ora_rc_symbols[i].name, 
+				       GINT_TO_POINTER(ia_ora_rc_symbols[i].token));
+        }
+    }
+
+  /* We're ready to go, now parse the top level */
+
+    token = g_scanner_peek_next_token(scanner);
+    while(token != G_TOKEN_RIGHT_CURLY)
+    {
+      switch (token)
+        {
+            case TOKEN_GRADIENT:
+                token = ia_ora_parse_boolean(scanner, TOKEN_GRADIENT, &ia_ora_rc_style->enable_gradient);
+                break;
+            case TOKEN_CROSS:
+                token = ia_ora_parse_boolean(scanner, TOKEN_CROSS, &ia_ora_rc_style->use_cross);
+                break;
+            case TOKEN_BLACK_CHECK:
+                token = ia_ora_parse_boolean(scanner, TOKEN_BLACK_CHECK, &ia_ora_rc_style->black_check);
+		break;
+            default:
+                g_scanner_get_next_token(scanner);
+                token = G_TOKEN_RIGHT_CURLY;
+                break;
+        }
+
+
+        if(token != G_TOKEN_NONE)
+            return token;
+
+        token = g_scanner_peek_next_token(scanner);
+    }
+
+    g_scanner_get_next_token(scanner);
+
+    g_scanner_set_scope(scanner, old_scope);
+
+    return G_TOKEN_NONE;
+}
+
+static void ia_ora_rc_style_merge(GtkRcStyle * dest, GtkRcStyle * src)
+{
+	Ia_OraRcStyle *dest_w, *src_w;
+	
+	ia_ora_parent_rc_class->merge (dest, src);
+	
+	if (!IA_ORA_IS_RC_STYLE (src))
+		return;
+	
+	src_w = IA_ORA_RC_STYLE (src);
+	dest_w = IA_ORA_RC_STYLE (dest);
+
+	dest_w->enable_gradient = src_w->enable_gradient;
+	dest_w->use_cross = src_w->use_cross;
+	dest_w->black_check= src_w->black_check;
+
+
+}
+
+/* Create an empty style suitable to this RC style
+ */
+static GtkStyle *ia_ora_rc_style_create_style(GtkRcStyle * rc_style)
+{
+    return GTK_STYLE(g_object_new(IA_ORA_TYPE_STYLE, NULL));
+}
diff --git a/src/gtk/engine/ia_ora_rc_style.h b/src/gtk/engine/ia_ora_rc_style.h
new file mode 100644
index 0000000..db53c91
--- /dev/null
+++ b/src/gtk/engine/ia_ora_rc_style.h
@@ -0,0 +1,51 @@
+/*  Ia Ora
+ *  Copyright (C) 2006 Frederic Crozat - Mandriva
+ *  1999 Olivier Fourdan (fourdan@xfce.org) for XFCE code
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#include <gtk/gtkrc.h>
+
+typedef struct _Ia_OraRcStyle Ia_OraRcStyle;
+typedef struct _Ia_OraRcStyleClass Ia_OraRcStyleClass;
+
+__attribute__((__visibility__("internal"))) extern GType ia_ora_type_rc_style;
+
+#define IA_ORA_TYPE_RC_STYLE              ia_ora_type_rc_style
+#define IA_ORA_RC_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), IA_ORA_TYPE_RC_STYLE, Ia_OraRcStyle))
+#define IA_ORA_RC_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), IA_ORA_TYPE_RC_STYLE, Ia_OraRcStyleClass))
+#define IA_ORA_IS_RC_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), IA_ORA_TYPE_RC_STYLE))
+#define IA_ORA_IS_RC_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), IA_ORA_TYPE_RC_STYLE))
+#define IA_ORA_RC_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), IA_ORA_TYPE_RC_STYLE, Ia_OraRcStyleClass))
+
+struct _Ia_OraRcStyle
+{
+  GtkRcStyle parent_instance;
+
+  gboolean enable_gradient;
+
+  gboolean use_cross;
+
+  gboolean black_check;
+
+};
+
+struct _Ia_OraRcStyleClass
+{
+    GtkRcStyleClass parent_class;
+};
+
+__attribute__((__visibility__("internal"))) void ia_ora_rc_style_register_type(GTypeModule * module);
diff --git a/src/gtk/engine/ia_ora_style.h b/src/gtk/engine/ia_ora_style.h
new file mode 100644
index 0000000..5c07190
--- /dev/null
+++ b/src/gtk/engine/ia_ora_style.h
@@ -0,0 +1,59 @@
+/*  Ia Ora
+ *  Copyright (C) 2003 Frederic Crozat - Mandriva
+ *                1999 Olivier Fourdan (fourdan@xfce.org) for XFCE code
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#include <gtk/gtkstyle.h>
+
+typedef struct _Ia_OraStyle Ia_OraStyle;
+typedef struct _Ia_OraStyleClass Ia_OraStyleClass;
+
+__attribute__((__visibility__("internal"))) extern GType ia_ora_type_style;
+
+#define IA_ORA_TYPE_STYLE              ia_ora_type_style
+#define IA_ORA_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), IA_ORA_TYPE_STYLE, Ia_OraStyle))
+#define IA_ORA_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), IA_ORA_TYPE_STYLE, Ia_OraStyleClass))
+#define IA_ORA_IS_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), IA_ORA_TYPE_STYLE))
+#define IA_ORA_IS_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), IA_ORA_TYPE_STYLE))
+#define IA_ORA_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), IA_ORA_TYPE_STYLE, Ia_OraStyleClass))
+
+#define N_BLUE_COLORS 5
+#define N_GRAY_COLORS 7
+
+struct _Ia_OraStyle
+{
+  GtkStyle parent_instance;
+  GdkColor gray[N_GRAY_COLORS]; /* from light to dark */
+  GdkColor blue[N_BLUE_COLORS]; /* from light to dark */
+  GdkColor check_color;
+  
+  GdkGC *gray_gc[N_GRAY_COLORS]; /* from light to dark */
+  GdkGC *blue_gc[N_BLUE_COLORS]; /* from light to dark */
+
+  GdkGC *check_gc;
+
+  GdkPixmap *radio_pixmap_circle[5];
+  GdkBitmap *radio_pixmap_mask; /* All masks are the same */
+
+};
+
+struct _Ia_OraStyleClass
+{
+    GtkStyleClass parent_class;
+};
+
+__attribute__((__visibility__("internal"))) void ia_ora_style_register_type(GTypeModule * module);
diff --git a/src/gtk/engine/ia_ora_theme_draw.c b/src/gtk/engine/ia_ora_theme_draw.c
new file mode 100644
index 0000000..83b77e8
--- /dev/null
+++ b/src/gtk/engine/ia_ora_theme_draw.c
@@ -0,0 +1,3531 @@
+/*  Ia Ora theme
+ *  Copyright (C) 2003 Frederic Crozat - Mandriva
+ *                1999 Olivier Fourdan (fourdan@xfce.org) for XFCE code
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include <string.h>
+
+#include "ia_ora_style.h"
+#include "ia_ora_rc_style.h"
+
+#define DETAIL(s)   ((detail) && (!strcmp(s, detail)))
+
+#define M_PI 3.14159265358979323846
+
+
+/* 
+  Port to GTK+-2.0 based on Thinice port by Tim Gerla <timg@rrv.net>
+      Tomas Ögren <stric@ing.umu.se> and  Richard Hult <rhult@codefactory.se>
+  Portions based on BlueCurve by Alexander Larsson
+  Portions based on Raleigh theme by Owen Taylor
+  Portions based on Notif theme
+  Portions based on Notif2 theme
+  Portions based on original GTK theme
+ */
+
+static GtkStyleClass *ia_ora_parent_class;
+
+#define RADIO_SIZE 13
+#define PART_SIZE 13
+#define SCALE_SIZE 5
+#define RANGE_TROUGH_SIZE 6
+#define SCALE_INCREMENT 12
+
+static const char top_half_cross_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x0c, 0x06, 0x1c, 0x07, 0xb8, 0x03, 0xf0, 0x01,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00 };
+
+static const char bottom_half_cross_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0xf0, 0x01, 0xb8, 0x03, 0x1c, 0x07, 0x0c, 0x06, 0x00, 0x00, 0x00, 0x00 };
+
+static const char * menu_check_xpm[] = {
+"9 9 3 1",
+"       c None",
+".      c #344351",
+"+      c #000000",
+"        .",
+"       ..",
+"      ...",
+".    ....",
+"..  .... ",
+".......  ",
+"++++++   ",
+" ++++    ",
+"  ++     "};
+
+static const char * menu_check_active_xpm[] = {
+"9 9 3 1",
+"       c None",
+".      c #FFFFFF",
+"+      c #D3DCE3",
+"        .",
+"       ..",
+"      ...",
+".    ....",
+"..  .... ",
+".......  ",
+"++++++   ",
+" ++++    ",
+"  ++     "};
+
+
+static const char check_top_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x06, 0x00, 0x07, 0x84, 0x03,
+   0xcc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static const char check_bottom_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0xfc, 0x00, 0x78, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00};
+
+static const char radio_up_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0xf0, 0x01, 0xf8, 0x03,
+   0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00 };
+
+static const char radio_down_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00 };
+
+static const char circle_alpha[] = {
+0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+0x00,0x00,0x00,0x23,0x62,0x92,0xb3,0xb2,0x95,0x2b,0x00,0x00,0x00,
+0x00,0x00,0x3e,0xab,0xc9,0xeb,0xf9,0xf5,0xfd,0xff,0x57,0x00,0x00,
+0x00,0x1f,0xb5,0xd8,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0x2b,0x00,
+0x00,0x67,0xb9,0xf2,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x9c,0x00,
+0x00,0x9a,0xe2,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe5,0x00,
+0x00,0xba,0xeb,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,
+0x00,0xc0,0xfa,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe5,0x00,
+0x00,0x9b,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x9c,0x00,
+0x00,0x2b,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x2b,0x00,
+0x00,0x00,0x57,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x57,0x00,0x00,
+0x00,0x00,0x00,0x2b,0x9c,0xe5,0xff,0xe5,0x9c,0x2b,0x00,0x00,0x00,
+0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+};
+static const char outline_alpha[] = {
+0x00,0x00,0x00,0x4a,0xac,0xe9,0xff,0xe9,0xac,0x4a,0x00,0x00,0x00,
+0x00,0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,0x00,
+0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,
+0x4a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x4a,
+0xac,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xac,
+0xe9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe9,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xe9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe9,
+0xac,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xac,
+0x4a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x4a,
+0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,
+0x00,0x00,0x98,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98,0x00,0x00,
+0x00,0x00,0x00,0x4a,0xac,0xe9,0xff,0xe9,0xac,0x4a,0x00,0x00,0x00,
+};
+
+/* internal functions */
+static void draw_hline(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x1, gint x2, gint y);
+static void draw_vline(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint y1, gint y2, gint x);
+static void draw_shadow(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height);
+
+static void draw_box(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height);
+static void draw_check(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height);
+static void draw_option(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height);
+static void draw_shadow_gap(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width);
+static void draw_box_gap(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width);
+static void draw_extension(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side);
+static void draw_slider(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkOrientation orientation);
+static void draw_handle(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkOrientation orientation);
+static void draw_tab(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height);
+
+static void ensure_radio_pixmaps (GtkStyle  *style, GtkStateType state, GtkWidget *widget);
+
+static gboolean
+ia_ora_object_is_a (const GObject * object, const gchar * type_name)
+{
+  gboolean result = FALSE;
+ 
+  if ((object))
+    {
+      GType tmp = g_type_from_name (type_name);
+
+      if (tmp)
+        result = g_type_check_instance_is_a ((GTypeInstance *) object, tmp);
+    }
+ 
+  return result;
+}
+
+
+
+static gboolean 
+sanitize_size (GdkWindow      *window,
+	       gint           *width,
+	       gint           *height)
+{
+  gboolean set_bg = FALSE;
+
+  if ((*width == -1) && (*height == -1))
+    {
+      set_bg = GDK_IS_WINDOW (window);
+      gdk_drawable_get_size (window, width, height);
+    }
+  else if (*width == -1)
+    gdk_drawable_get_size (window, width, NULL);
+  else if (*height == -1)
+    gdk_drawable_get_size (window, NULL, height);
+
+  return set_bg;
+}
+
+
+static GdkPixbuf *
+generate_bit (const char alpha[], GdkColor *color, double mult)
+{
+  guint r, g, b;
+  GdkPixbuf *pixbuf;
+  unsigned char *pixels;
+  int w, h, rs;
+  int x, y;
+  
+  r = (color->red >> 8) * mult;
+  r = MIN(r, 255);
+  g = (color->green >> 8) * mult;
+  g = MIN(g, 255);
+  b = (color->blue >> 8) * mult;
+  b = MIN(b, 255);
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, RADIO_SIZE, RADIO_SIZE);
+
+  w = gdk_pixbuf_get_width (pixbuf);
+  h = gdk_pixbuf_get_height (pixbuf);
+  rs = gdk_pixbuf_get_rowstride (pixbuf);
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+
+
+  for (y=0; y < h; y++)
+    {
+      for (x=0; x < w; x++)
+	{
+	  pixels[y*rs + x*4 + 0] = r;
+	  pixels[y*rs + x*4 + 1] = g;
+	  pixels[y*rs + x*4 + 2] = b;
+	  if (alpha)
+	    pixels[y*rs + x*4 + 3] = alpha[y*w + x];
+	  else
+	    pixels[y*rs + x*4 + 3] = 255;
+	}
+    }
+
+  return pixbuf;
+}
+
+static void
+rgb_to_hls (gdouble *r,
+            gdouble *g,
+            gdouble *b)
+{
+  gdouble min;
+  gdouble max;
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  gdouble h, l, s;
+  gdouble delta;
+  
+  red = *r;
+  green = *g;
+  blue = *b;
+  
+  if (red > green)
+    {
+      if (red > blue)
+        max = red;
+      else
+        max = blue;
+      
+      if (green < blue)
+        min = green;
+      else
+        min = blue;
+    }
+  else
+    {
+      if (green > blue)
+        max = green;
+      else
+        max = blue;
+      
+      if (red < blue)
+        min = red;
+      else
+        min = blue;
+    }
+  
+  l = (max + min) / 2;
+  s = 0;
+  h = 0;
+  
+  if (max != min)
+    {
+      if (l <= 0.5)
+        s = (max - min) / (max + min);
+      else
+        s = (max - min) / (2 - max - min);
+      
+      delta = max -min;
+      if (red == max)
+        h = (green - blue) / delta;
+      else if (green == max)
+        h = 2 + (blue - red) / delta;
+      else if (blue == max)
+        h = 4 + (red - green) / delta;
+      
+      h *= 60;
+      if (h < 0.0)
+        h += 360;
+    }
+  
+  *r = h;
+  *g = l;
+  *b = s;
+}
+
+static void
+hls_to_rgb (gdouble *h,
+            gdouble *l,
+            gdouble *s)
+{
+  gdouble hue;
+  gdouble lightness;
+  gdouble saturation;
+  gdouble m1, m2;
+  gdouble r, g, b;
+  
+  lightness = *l;
+  saturation = *s;
+  
+  if (lightness <= 0.5)
+    m2 = lightness * (1 + saturation);
+  else
+    m2 = lightness + saturation - lightness * saturation;
+  m1 = 2 * lightness - m2;
+  
+  if (saturation == 0)
+    {
+      *h = lightness;
+      *l = lightness;
+      *s = lightness;
+    }
+  else
+    {
+      hue = *h + 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        r = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        r = m2;
+      else if (hue < 240)
+        r = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        r = m1;
+      
+      hue = *h;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        g = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        g = m2;
+      else if (hue < 240)
+        g = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        g = m1;
+      
+      hue = *h - 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        b = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        b = m2;
+      else if (hue < 240)
+        b = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        b = m1;
+      
+      *h = r;
+      *l = g;
+      *s = b;
+    }
+}
+
+static void
+shade (GdkColor * a, GdkColor * b, float k)
+{
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  
+  red = (gdouble) a->red / 65535.0;
+  green = (gdouble) a->green / 65535.0;
+  blue = (gdouble) a->blue / 65535.0;
+  
+  rgb_to_hls (&red, &green, &blue);
+
+  green *= k;
+  if (green > 1.0)
+    green = 1.0;
+  else if (green < 0.0)
+    green = 0.0;
+  
+  blue *= k;
+  if (blue > 1.0)
+    blue = 1.0;
+  else if (blue < 0.0)
+    blue = 0.0;
+
+  hls_to_rgb (&red, &green, &blue);
+  
+  b->red = red * 65535.0;
+  b->green = green * 65535.0;
+  b->blue = blue * 65535.0;
+}
+
+static GtkRequisition default_option_indicator_size = { 7, 13 };
+static GtkBorder default_option_indicator_spacing = { 7, 5, 2, 2 };
+
+static void
+option_menu_get_props (GtkWidget      *widget,
+		       GtkRequisition *indicator_size,
+		       GtkBorder      *indicator_spacing)
+{
+  GtkRequisition *tmp_size = NULL;
+  GtkBorder *tmp_spacing = NULL;
+  
+  if (widget)
+    gtk_widget_style_get (widget, 
+			  "indicator_size", &tmp_size,
+			  "indicator_spacing", &tmp_spacing,
+			  NULL);
+
+  if (tmp_size)
+    {
+      *indicator_size = *tmp_size;
+      gtk_requisition_free (tmp_size);
+    }
+  else
+    *indicator_size = default_option_indicator_size;
+
+  if (tmp_spacing)
+    {
+      *indicator_spacing = *tmp_spacing;
+      gtk_border_free (tmp_spacing);
+    }
+  else
+    *indicator_spacing = default_option_indicator_spacing;
+}
+
+static void
+ia_ora_draw_vgradient (GdkDrawable *drawable, GdkGC *gc, GdkColormap *colormap,
+		int x, int y, int width, int height,
+		GdkColor *top_color, GdkColor *bottom_color)
+{
+  int i;
+  GdkColor col;
+  int dr, dg, db;
+  GdkGCValues old_values;
+
+  if (height <= 1)
+    return;
+
+  col = *top_color;
+  dr = (bottom_color->red - top_color->red) / (height-1);
+  dg = (bottom_color->green - top_color->green) / (height-1);
+  db = (bottom_color->blue - top_color->blue) / (height-1);
+  
+  gdk_gc_get_values (gc, &old_values);
+  
+  for (i = 0; i < height; i++)
+    {
+      gdk_rgb_find_color (colormap,
+			  &col);
+      
+      gdk_gc_set_foreground (gc, &col);
+      
+      gdk_draw_line (drawable, gc,
+		     x, y + i,
+		     x + width - 1, y + i);
+					   
+      col.red += dr;
+      col.green += dg;
+      col.blue += db;
+    }
+  gdk_gc_set_foreground (gc, &old_values.foreground);
+
+}
+
+static void
+ia_ora_draw_hgradient (GdkDrawable *drawable, GdkGC *gc, GdkColormap *colormap,
+		int x, int y, int width, int height,
+		GdkColor *left_color, GdkColor *right_color)
+{
+  int i;
+  GdkColor col;
+  int dr, dg, db;
+  GdkGCValues old_values;
+
+  if (width <= 1)
+    return;
+
+  col = *left_color;
+  dr = (right_color->red - left_color->red) / (width-1);
+  dg = (right_color->green - left_color->green) / (width-1);
+  db = (right_color->blue - left_color->blue) / (width-1);
+  
+  gdk_gc_get_values (gc, &old_values);
+  
+  for (i = 0; i < width; i++)
+    {
+      gdk_rgb_find_color (colormap,
+			  &col);
+      
+      gdk_gc_set_foreground (gc, &col);
+      gdk_draw_line (drawable, gc,
+		     x + i, y,
+		     x + i, y + height - 1);
+					   
+      col.red += dr;
+      col.green += dg;
+      col.blue += db;
+    }
+
+  gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void ia_ora_print_path (GtkWidget *widget) {
+	char *path, *class_path;
+
+	gtk_widget_path (widget, NULL, &path, NULL);
+	gtk_widget_class_path (widget, NULL, &class_path, NULL);
+
+	g_print("%s %s\n",path, class_path);
+}
+
+static void ia_ora_draw_point (Ia_OraStyle * ia_ora_style, GdkWindow * window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gint x, gint y, gboolean bicolor, gboolean vertical) {
+    GdkGC *top_right_color_gc, *top_left_color_gc, *bottom_left_color_gc, *bottom_right_color_gc;
+    int color;
+
+    if (state_type == GTK_STATE_INSENSITIVE) {
+	    top_left_color_gc = top_right_color_gc = ia_ora_style->gray_gc[5];
+	    bottom_left_color_gc = ia_ora_style->gray_gc[2];
+	    bottom_right_color_gc = ia_ora_style->gray_gc[2];
+    }
+    else {
+	    if (bicolor) {
+		    if (state_type == GTK_STATE_PRELIGHT) {
+			    color = 3;
+		    } else {
+			    color = 2;
+		    }
+
+		    top_left_color_gc = ia_ora_style->blue_gc[4];
+		    bottom_right_color_gc = ia_ora_style->blue_gc[color];
+		    if (vertical) {
+			    top_right_color_gc = ia_ora_style->blue_gc[color];
+			    bottom_left_color_gc = ia_ora_style->blue_gc[4];
+
+		    } else {
+			    top_right_color_gc = ia_ora_style->blue_gc[4];
+			    bottom_left_color_gc = ia_ora_style->blue_gc[color];
+		    }
+	    }
+	    else {
+		    color = 2;
+	    	    top_left_color_gc = top_right_color_gc = ia_ora_style->blue_gc[4];
+		    bottom_right_color_gc = ia_ora_style->blue_gc[2];
+	    	    bottom_left_color_gc = ia_ora_style->blue_gc[1];
+	    }
+    }
+
+    if (area) {
+	    if (state_type == GTK_STATE_INSENSITIVE) {
+    		gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], area);
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[5], area);
+	    } else {
+    		gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[1], area);
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[color], area);
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[4], area);
+	    }
+    }
+
+    if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) {
+	    GdkGC *tmp_gc;
+	    tmp_gc = bottom_right_color_gc;
+	    bottom_right_color_gc = bottom_left_color_gc;
+	    bottom_left_color_gc = tmp_gc;
+	    tmp_gc = top_right_color_gc;
+	    top_right_color_gc = top_left_color_gc;
+	    top_left_color_gc = tmp_gc;
+    }
+
+    gdk_draw_point (window, top_left_color_gc, x+1, y);
+    gdk_draw_line (window, top_left_color_gc, x, y+1, x+1, y+1);
+
+    gdk_draw_point (window, top_right_color_gc, x+2, y);
+    gdk_draw_line (window, top_right_color_gc, x+2, y+1, x+3, y+1);
+
+    gdk_draw_line (window, bottom_left_color_gc, x, y+2, x+1, y+2);
+    gdk_draw_point (window, bottom_left_color_gc, x+1, y+3);
+
+    gdk_draw_line (window, bottom_right_color_gc, x+2, y+2, x+3, y+2);
+    gdk_draw_point (window,bottom_right_color_gc, x+2, y+3);
+
+    if (area) {
+	    if (state_type == GTK_STATE_INSENSITIVE) {
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], NULL);
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[5], NULL);
+	    } else {
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[1], NULL);
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[color], NULL);
+	    	gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[4], NULL);
+	    }
+    }
+}
+
+
+static void ia_ora_draw_handlers(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GdkRectangle * area, GtkWidget * widget, gint x, gint y, gint width, gint height, GtkOrientation orientation)
+{
+    Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+
+    int i;
+    int delta;
+
+    sanitize_size (window, &width, &height);
+
+    if(orientation == GTK_ORIENTATION_HORIZONTAL) {
+        if(width > 32)
+        {
+            delta = x + (width/2) - 11;
+            for(i = 0; i < 3; i++) {
+	      ia_ora_draw_point (ia_ora_style, window, state_type, area, widget, delta + 9*i,
+				 y + MAX((height-4)/2,0), FALSE, FALSE);
+            }
+        }
+	else {
+	  ia_ora_draw_point (ia_ora_style, window,  state_type, area, widget, x + (width-4)/2,
+				 y + MAX((height-4)/2,0), FALSE, FALSE);
+	}
+    }
+    else {
+        if(height > 32) {
+	  delta = y + (height / 2) - 11;
+            for(i = 0; i < 3; i++) {
+	      ia_ora_draw_point (ia_ora_style, window, state_type, area, widget, x + MAX((width-4)/2,0), 
+				 delta+9*i, FALSE, FALSE);
+            }
+        }
+	else {
+	  ia_ora_draw_point (ia_ora_style, window, state_type, area, widget, x + MAX((width-4)/2,0), 
+			      y + (height-4) / 2, FALSE, FALSE);
+	}
+    }
+}
+
+
+static void draw_hline(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x1, gint x2, gint y)
+{
+    Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    if (area) {
+        gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], area);
+        gdk_gc_set_clip_rectangle(style->white_gc, area);
+    }
+
+    gdk_draw_line(window, ia_ora_style->gray_gc[2], x1, y, x2, y);
+    gdk_draw_line(window, style->white_gc, x1, y + 1, x2, y+1);
+
+    if(area) {
+        gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], NULL);
+        gdk_gc_set_clip_rectangle(style->white_gc, NULL);
+    }
+}
+
+
+static void draw_vline(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint y1, gint y2, gint x)
+{
+    Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+    GdkGC *gc1, *gc2;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    if(area)
+    {
+        gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], area);
+        gdk_gc_set_clip_rectangle(style->white_gc, area);
+    }
+
+    if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) {
+	    gc1 = ia_ora_style->gray_gc[2];
+	    gc2 = style->white_gc;
+    }
+    else {
+	  gc1 = style->white_gc;
+	  gc2 = ia_ora_style->gray_gc[2];
+
+    }
+    gdk_draw_line(window, gc1, x, y1, x, y2);
+    gdk_draw_line(window, gc2, x+1, y1, x+1, y2);
+
+    if(area)
+    {
+        gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], NULL);
+        gdk_gc_set_clip_rectangle(style->white_gc, NULL);
+    }
+}
+
+static void ia_ora_draw_round_rectangle(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  int color1, color2;
+  gboolean is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+
+     if (state_type == GTK_STATE_INSENSITIVE || (widget && (GTK_IS_SPIN_BUTTON (widget) || GTK_IS_ENTRY (widget)) && GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE )) {
+	color1 = color2 = 4;
+     }
+     else {
+	color1 = 5;
+	color2 = 4;
+     }
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color1], area);
+	if (color1 != color2) 
+		gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color2], area);
+	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+      }
+
+    gdk_draw_line(window, ia_ora_style->gray_gc[color1], x+1, y, x+width-2, y);
+    gdk_draw_line(window, ia_ora_style->gray_gc[is_ltr ? color1 : color2], x, y+1, x, y+height-2);
+
+    gdk_draw_line(window, ia_ora_style->gray_gc[color2], x+1, y+height-1, x+width-2, y+height-1);
+    gdk_draw_line(window, ia_ora_style->gray_gc[is_ltr ? color2 : color1], x+width-1, y+1, x+width-1, y+height-2);
+
+    if (GTK_IS_ENTRY (widget)) {
+    	gdk_draw_point(window, style->bg_gc[state_type],x,y);
+    	gdk_draw_point(window, style->bg_gc[state_type],x+width-1,y);
+    	gdk_draw_point(window, style->bg_gc[state_type],x,y+height-1);
+    	gdk_draw_point(window, style->bg_gc[state_type],x+width-1,y+height-1);
+    }
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color1], NULL);
+	if (color1 != color2) 
+		gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color2], NULL);
+	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+      }
+}
+
+static void ia_ora_draw_half_round_rectangle (GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  gboolean is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+	int color1, color2;
+
+     if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE) {
+	color1 = color2 = 4;
+     }
+     else {
+	color1 = 5;
+	color2 = 4;
+     }
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color1], area);
+	if (color1 != color2) 
+		gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color2], area);
+      }
+
+    x += !is_ltr;
+
+    gdk_draw_line(window, ia_ora_style->gray_gc[color1], x+!is_ltr, y, x+width-(1+is_ltr), y);
+    gdk_draw_line(window, ia_ora_style->gray_gc[is_ltr ? color1 : color2], x, y+1, x, y+height-2);
+
+    gdk_draw_line(window, ia_ora_style->gray_gc[color2], x+!is_ltr, y+height-1, x+width-(1+is_ltr), y+height-1);
+    gdk_draw_line(window, ia_ora_style->gray_gc[is_ltr ? color2 : color1], x+width-1, y+1, x+width-1, y+height-2);
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color1], NULL);
+	if (color1 != color2) 
+		gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color2], NULL);
+      }
+}
+
+static void ia_ora_draw_double_gradient_bar (GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkOrientation orientation, gboolean round_beginning, gboolean round_end)
+{
+	  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+	  GdkColor *top_color1, *bottom_color1,*top_color2, *bottom_color2;
+	  GdkGC *top_gc, *bottom_gc;
+
+	  if (!DETAIL("bar") && !DETAIL("menuitem") && state_type == GTK_STATE_PRELIGHT) {
+	    top_color1 = &ia_ora_style->blue[0];
+	    bottom_color1 = &ia_ora_style->blue[2];
+	    top_color2 = &ia_ora_style->blue[4];
+	    bottom_color2 = &ia_ora_style->blue[2];
+	  }
+	  else if (state_type == GTK_STATE_INSENSITIVE) {
+	    top_color1 = &ia_ora_style->gray[1];
+	    bottom_color1 = &ia_ora_style->gray[3];
+	    top_color2 = &ia_ora_style->gray[4];
+	    bottom_color2 = &ia_ora_style->gray[2];
+	  }
+	  else {
+	    top_color1 = &ia_ora_style->blue[1];
+	    bottom_color1 = &ia_ora_style->blue[3];
+	    top_color2 = &ia_ora_style->blue[4];
+	    bottom_color2 = &ia_ora_style->blue[2];
+	  }
+
+	if (DETAIL("hscale") || (DETAIL("vscale"))) {
+	      top_gc = ia_ora_style->gray_gc[5];
+	      bottom_gc = ia_ora_style->gray_gc[4];
+	}
+	else {
+	  top_gc = bottom_gc = ia_ora_style->gray_gc[0];
+	}
+
+	if (area) {
+		gdk_gc_set_clip_rectangle (style->base_gc[state_type], area);
+		gdk_gc_set_clip_rectangle (top_gc, area);
+		if (bottom_gc != top_gc) 
+			gdk_gc_set_clip_rectangle (bottom_gc, area);
+
+	}
+	      switch (orientation) {
+		      case GTK_ORIENTATION_HORIZONTAL:
+			ia_ora_draw_vgradient (window, style->base_gc[state_type], style->colormap,
+			        x, y, width, height/2,
+		       		top_color1, bottom_color1);
+			ia_ora_draw_vgradient (window, style->base_gc[state_type], style->colormap,
+			        x, y+height/2, width, height/2+height % 2,
+		       		top_color2, bottom_color2);
+			break;
+	              case GTK_ORIENTATION_VERTICAL:
+	      		if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) {
+			  /* inverse gradient */
+			  GdkColor *tmp_color;
+			  tmp_color = top_color1;
+			  top_color1 = bottom_color2;
+			  bottom_color2 = tmp_color;
+			  tmp_color = top_color2;
+			  top_color2 = bottom_color1;
+			  bottom_color1 = tmp_color;
+			  }
+
+			ia_ora_draw_hgradient (window, style->base_gc[state_type], style->colormap,
+			       x, y, width/2, height,
+			       top_color1, bottom_color1);
+			ia_ora_draw_hgradient (window, style->base_gc[state_type], style->colormap,
+			       x+width/2, y, width/2 + width % 2, height,
+			       top_color2, bottom_color2);
+			break;
+		      default:
+		      break;
+	      }
+	if (round_beginning) {
+	      gdk_draw_point (window, top_gc,x,y);
+
+		switch (orientation) {
+		      case GTK_ORIENTATION_HORIZONTAL:
+			      gdk_draw_point (window, bottom_gc,x,y+height-1);
+			      break;
+		      case GTK_ORIENTATION_VERTICAL:
+			      gdk_draw_point (window, bottom_gc,x+width-1,y);
+			      break;
+		}
+	}
+
+	if (round_end) {
+	      gdk_draw_point (window, bottom_gc,x+width-1,y+height-1);
+
+		switch (orientation) {
+		      case GTK_ORIENTATION_HORIZONTAL:
+			      gdk_draw_point (window, top_gc,x+width-1,y);
+			      break;
+		      case GTK_ORIENTATION_VERTICAL:
+			      gdk_draw_point (window, top_gc,x,y+height-1);
+			      break;
+		}
+	}
+
+	if (area) {
+		gdk_gc_set_clip_rectangle (style->base_gc[state_type], NULL);
+		gdk_gc_set_clip_rectangle (top_gc, NULL);
+		if (bottom_gc != top_gc) 
+			gdk_gc_set_clip_rectangle (bottom_gc, NULL);
+	}
+}
+
+static
+void ia_ora_treeview_get_header_index (GtkTreeView *tv, GtkWidget *header,
+                                    gint *column_index, gint *columns,
+                                    gboolean *resizable)
+{
+        GList *list, *list_start;
+        *column_index = *columns = 0;
+        list_start = list = gtk_tree_view_get_columns (tv);
+
+        do
+        {
+                GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(list->data);
+                if ( column->button == header )
+                {
+                        *column_index = *columns;
+                        *resizable = column->resizable;
+                }
+                if ( column->visible )
+                        (*columns)++;
+        } while ((list = g_list_next(list)));
+
+        g_list_free (list_start);
+}
+
+static
+void ia_ora_clist_get_header_index (GtkCList *clist, GtkWidget *button,
+                                 gint *column_index, gint *columns)
+{
+	int i;
+	*columns = clist->columns;
+	
+	for (i=0; i<*columns; i++)
+	{
+		if (clist->column[i].button == button)
+		{
+			*column_index = i;
+			break;
+		}
+	}
+}
+
+
+
+static void ia_ora_draw_button (GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+
+	Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  	int xthick, ythick;
+	gboolean is_combo_button, is_in_tree;
+	int color1, color2;
+	gboolean disable_gradient = FALSE;
+	gboolean is_ltr;
+
+    xthick = style->xthickness;
+    ythick = style->ythickness;
+
+    /* workaround for mozilla */
+    if (width < 20) {
+	xthick = ythick = 1;
+    }
+
+    is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+ 
+    is_combo_button = (DETAIL("button") 
+			&& (GTK_IS_COMBO(gtk_widget_get_parent(widget))
+			   || GTK_IS_COMBO_BOX_ENTRY(gtk_widget_get_parent(widget))));
+
+    if ((is_in_tree = (DETAIL ("button") && (GTK_IS_TREE_VIEW(gtk_widget_get_parent(widget)) ||
+                  GTK_IS_CLIST (gtk_widget_get_parent(widget)) || ia_ora_object_is_a (G_OBJECT(widget), "ECanvas"))))) {
+	xthick = ythick = 0;
+    }
+
+
+      if ((((width > 2*xthick) && (height > 2*ythick)  
+	   && IA_ORA_RC_STYLE(style->rc_style)->enable_gradient))
+      	&& !(GTK_IS_BUTTON(widget) && GTK_BUTTON (widget)->relief == GTK_RELIEF_NONE && state_type == GTK_STATE_NORMAL)
+	&& (disable_gradient = gdk_color_equal(&style->bg[GTK_STATE_NORMAL],&ia_ora_style->gray[0]))) {
+	  GdkColor top_color, bottom_color;
+	  int is_big = (height > 38);
+
+	  switch (state_type) {
+	   case GTK_STATE_PRELIGHT:
+	    top_color = style->white;
+	    bottom_color = ia_ora_style->gray[1+is_big];
+	    break;
+	   case GTK_STATE_SELECTED:
+	    top_color = ia_ora_style->blue[0];
+	    bottom_color = ia_ora_style->blue[3+is_big];
+	    break;
+	   case GTK_STATE_INSENSITIVE:
+	   case GTK_STATE_ACTIVE:
+	   default:
+	    top_color = ia_ora_style->gray[0];
+	    bottom_color = ia_ora_style->gray[2+is_big];
+	    break;
+	  }
+
+	  if (shadow_type == GTK_SHADOW_IN) {
+		/* swap colors, to inverse gradient in this case */
+		GdkColor tmp_color;
+		
+		tmp_color = top_color;
+		top_color = bottom_color;
+		bottom_color = tmp_color;
+	  }
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (style->base_gc[state_type], area);
+      }
+	  ia_ora_draw_vgradient (window, style->base_gc[state_type], style->colormap, 
+			  x+xthick,y+ythick, 
+			  width-2*xthick, 
+			  height-2*ythick, 
+			  &top_color, 
+			  &bottom_color);
+      if (area) { 
+	gdk_gc_set_clip_rectangle (style->base_gc[state_type], NULL);
+      }
+	}
+      else {
+	gtk_style_apply_default_background(style, window, TRUE, state_type, 
+					   area, x+xthick, 
+					   y+ythick, 
+					   width-2*xthick, 
+					   height-2*ythick);
+      }
+
+     if (state_type == GTK_STATE_INSENSITIVE) {
+	color1 = color2 = 4;
+     }
+     else {
+	color1 = 5;
+	color2 = 4;
+     }
+
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (style->white_gc, area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[1], area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[2], area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[4], area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], area);
+      }
+
+      if (xthick > 1 && !is_in_tree) {
+	GdkGC *color_gc;
+
+	if ((state_type == GTK_STATE_ACTIVE) || (state_type == GTK_STATE_INSENSITIVE && shadow_type == GTK_SHADOW_IN )) {
+		color_gc = ia_ora_style->gray_gc[2];
+	}
+	else {
+		color_gc = style->white_gc;
+	}
+	gdk_draw_line (window, ia_ora_style->gray_gc[color1],
+			 x+!(is_combo_button && is_ltr)*xthick-(is_combo_button && !is_ltr),y,
+			 x+width-1-xthick+is_combo_button+(is_combo_button && !is_ltr),y);
+	gdk_draw_line (window, color_gc,
+			x+xthick-(is_combo_button && is_ltr), y+1,x+width-1-xthick,y+1);
+	if (!is_combo_button) {
+		gdk_draw_point (window, ia_ora_style->gray_gc[is_ltr ? color1 : color2],
+			x+1, y+1);
+	}
+	gdk_draw_line (window, ia_ora_style->gray_gc[is_ltr ? color1 : color2],
+			x, y+xthick-is_combo_button, x, y+height-1-ythick+is_combo_button);
+	gdk_draw_line (window, is_ltr ? color_gc : ia_ora_style->gray_gc[1],
+			x+1, y+xthick-(is_combo_button && !is_ltr),x+1,y+height-1-ythick);
+	if (!is_combo_button) {
+		gdk_draw_point (window, ia_ora_style->gray_gc[color2],
+			x+1, y+height-2);
+	}
+	gdk_draw_line (window, ia_ora_style->gray_gc[1],
+			x+(is_combo_button ? 1 : xthick),y+height-2,x+width-1 - (is_combo_button ? 1 : xthick), y+height-2);
+	gdk_draw_line (window, ia_ora_style->gray_gc[color2],
+			 x+!(is_combo_button && is_ltr)*xthick-(is_combo_button && !is_ltr),y+height-1,
+			 x+width-xthick-1+is_combo_button+(is_combo_button && !is_ltr),y+height-1);
+	gdk_draw_line (window, is_ltr ? ia_ora_style->gray_gc[1] : color_gc,
+			x+width-2,y+2-is_combo_button,x+width-2,y+height-ythick-1);
+	gdk_draw_line (window, ia_ora_style->gray_gc[is_ltr ? color2 : color1],
+			x+width-1, y+ythick-is_combo_button, x+width-1, y+height-ythick-1+is_combo_button);
+	if (!is_combo_button) {
+		gdk_draw_point (window, ia_ora_style->gray_gc[is_ltr ? color2 : color1],
+			x+width-2, y+1);
+		gdk_draw_point (window, ia_ora_style->gray_gc[color2],
+			x+width-2, y+height-2);
+	}
+      }
+
+      	if (DETAIL ("optionmenu")) {
+	  GtkRequisition indicator_size;
+	  GtkBorder indicator_spacing;
+	  gint vline_x;
+	  
+	  option_menu_get_props (widget, &indicator_size, &indicator_spacing);
+	  sanitize_size (window, &width, &height);
+
+	  if (!is_ltr) {
+	    vline_x = x + indicator_size.width + indicator_spacing.left 
+	      + indicator_spacing.right;
+	  }
+	  else {
+	    vline_x = x + width - (indicator_size.width + indicator_spacing.left
+				   + indicator_spacing.right 
+				   + xthick );
+	  }
+	  
+	  gdk_draw_line (window, is_ltr ? ia_ora_style->gray_gc[2] : style->white_gc,
+			 vline_x,y+4,
+			 vline_x,y+height-5);
+	  gdk_draw_line (window, is_ltr ? style->white_gc : ia_ora_style->gray_gc[2],
+			 vline_x+1, y+4,
+			 vline_x+1, y+height-5);
+	}
+
+
+      if (is_in_tree) {
+		gint columns, column_index;
+		gboolean resizable = TRUE;
+		columns =  column_index = 1;
+
+		if (GTK_IS_TREE_VIEW (widget->parent))
+		{
+			ia_ora_treeview_get_header_index (GTK_TREE_VIEW(widget->parent),
+							   widget, &column_index, &columns,
+							   &resizable);
+		}
+		else if (GTK_IS_CLIST (widget->parent))
+		{
+			ia_ora_clist_get_header_index (GTK_CLIST(widget->parent),
+							widget, &column_index, &columns);
+		}
+
+		if ((is_ltr && (column_index != columns -1)) || (!is_ltr && (column_index != 0))) { /* not the last one */
+			gdk_draw_line (window, is_ltr ? ia_ora_style->gray_gc[2] : style->white_gc,
+					x+width-1, y, x+width-1, y+height-2);
+		}
+
+		if (((is_ltr && (column_index != 0))) || (!is_ltr && (column_index != columns -1))) { /* not the first one */
+			gdk_draw_line (window, is_ltr ? style->white_gc : ia_ora_style->gray_gc[2],
+					x, y, x, y+height-2);
+		}
+		gdk_draw_line (window, ia_ora_style->gray_gc[5],
+				x, y+height-1, x+width-1, y+height-1);
+      }
+
+      if (area) { 
+	gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[1], NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[2], NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[4], NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], NULL);
+      }
+
+      if (xthick == 1) {
+	      ia_ora_draw_round_rectangle(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+	      if (disable_gradient) {
+	      	if (area) {
+			gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	      	}
+	        gdk_draw_point(window, style->bg_gc[state_type],x,y);
+		gdk_draw_point(window, style->bg_gc[state_type],x+width-1,y);
+		gdk_draw_point(window, style->bg_gc[state_type],x,y+height-1);
+		gdk_draw_point(window, style->bg_gc[state_type],x+width-1,y+height-1);
+		if (area) {
+			gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+		}
+	      }
+
+      }
+
+}
+
+static void ia_ora_draw_spinbutton (GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  int xthick, ythick, color;
+  GdkColor top_color, bottom_color;
+
+  if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) {
+	      x += 1;
+    }
+
+    xthick = ythick = 1;
+    if (DETAIL ("spinbutton_down") ) {
+     if (state_type == GTK_STATE_INSENSITIVE) {
+	color = 4;
+     }
+     else {
+	color = 5;
+     }
+	if (area) 
+		gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color], area);
+
+	  gdk_draw_line (window, ia_ora_style->gray_gc[color], x+1,y,x+width-2,y);
+
+	if (area) 
+		gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[color], NULL);
+      }
+	  /* Make the top button overlap the first line of the bottom button */
+	  if (DETAIL ("spinbutton_up")) {
+		  	height += 1;
+		  }
+
+	  switch (state_type) {
+		  case GTK_STATE_PRELIGHT:
+	    top_color = style->white;
+	    bottom_color = ia_ora_style->gray[1];
+	    break;
+		  case GTK_STATE_ACTIVE:
+	      top_color = ia_ora_style->gray[2];
+	      bottom_color = ia_ora_style->gray[0];
+	      break;
+		  case GTK_STATE_INSENSITIVE:
+	    top_color = ia_ora_style->gray[1];
+	    bottom_color = ia_ora_style->gray[2];
+	    break;
+		  default: 
+	    top_color = ia_ora_style->gray[0];
+	    bottom_color = ia_ora_style->gray[2];
+	    break;
+	    }
+
+	if (area) 
+		gdk_gc_set_clip_rectangle (style->base_gc[state_type], area);
+
+	  ia_ora_draw_vgradient (window, style->base_gc[state_type], style->colormap, 
+			  x+xthick,y+xthick,
+			  width-2*xthick,
+			  height-2*ythick, 
+			  &top_color, 
+			  &bottom_color);
+	if (area) 
+		gdk_gc_set_clip_rectangle (style->base_gc[state_type], NULL);
+
+}
+
+static void draw_shadow(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  GdkGC *gc1, *gc2;
+  int xthick, ythick;
+  gboolean is_ltr;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    if (shadow_type == GTK_SHADOW_NONE) {
+      return;
+    }
+
+    xthick = style->xthickness;
+    ythick = style->ythickness;
+
+    sanitize_size (window, &width, &height);
+
+    if (widget) {
+	    is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+    }
+    else {
+	    is_ltr = TRUE;
+    }
+
+    if ((shadow_type == GTK_SHADOW_ETCHED_IN) || 
+	(shadow_type == GTK_SHADOW_ETCHED_OUT)) {
+
+      if (area) {
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[3], area);
+        gdk_gc_set_clip_rectangle (style->white_gc, area);
+      }
+
+      if (shadow_type == GTK_SHADOW_ETCHED_IN) {
+	gc1 = ia_ora_style->gray_gc[3];
+	gc2 = style->white_gc;
+      }
+      else { /*GTK_SHADOW_ETCHED_OUT */
+	gc1 = style->white_gc;
+	gc2 = ia_ora_style->gray_gc[3];
+      }
+      gdk_draw_line (window, gc1, x+1+(!is_ltr && (shadow_type == GTK_SHADOW_ETCHED_IN)),y,
+		      x+width-2-(is_ltr && shadow_type == GTK_SHADOW_ETCHED_IN),y);
+      gdk_draw_line (window, is_ltr ? gc1 : gc2, x,y+1,x,y+height-2);
+      gdk_draw_line (window, is_ltr ? gc1 : gc2, x+width-2,y+1,x+width-2,y+height-2);
+      gdk_draw_line (window, gc1, x+1,y+height-2,x+width-2,y+height-2);
+      
+      gdk_draw_line (window, gc2, x+2,y+1,x+width-3,y+1);
+      gdk_draw_line (window, is_ltr ? gc2 : gc1, x+width-1,y+1,x+width-1,y+height-2);
+      gdk_draw_line (window, gc2, x+1,y+height-1,x+width-2,y+height-1);
+      gdk_draw_line (window, is_ltr ? gc2 : gc1, x+1,y+1,x+1,y+height-3);
+      if (area) {
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[3], NULL);
+        gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+      }
+    }
+    if (DETAIL("entry") || (DETAIL("frame") && GTK_IS_MENU(widget->parent)))
+    {
+  	int adjust_entry = 0;
+
+	  	if (widget && (GTK_IS_COMBO (widget->parent) ||
+		               GTK_IS_COMBO_BOX_ENTRY(widget->parent) ||
+		               GTK_IS_SPIN_BUTTON (widget)))
+		{
+			if (is_ltr)
+				width += xthick;
+			else {
+				x -= 1;
+				width +=1;
+				adjust_entry = 1;
+			}
+		}
+	    ia_ora_draw_round_rectangle (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+
+	    if (widget && DETAIL("entry") && GTK_WIDGET_HAS_FOCUS (widget)) {
+      		if (area) {
+			gdk_gc_set_clip_rectangle (ia_ora_style->blue_gc[2], area);
+		}
+		gdk_draw_rectangle (window, ia_ora_style->blue_gc[2], FALSE, x + 1 - 2*adjust_entry,y + 1,width-3 + adjust_entry,height-3);
+      		if (area) {
+			gdk_gc_set_clip_rectangle (ia_ora_style->blue_gc[2], NULL);
+		}
+	    }
+    } else {
+
+    if (area) {
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[1], area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[2], area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], area);
+    }
+    
+    switch (shadow_type) {
+        case GTK_SHADOW_IN:
+	      if (widget && widget->parent && (GTK_IS_STATUSBAR (widget->parent))) {
+		      draw_hline(style, window, state_type, area, widget, detail, x, x+width,  y);
+
+	      }
+	      else {
+	  	if (DETAIL("scrolled_window")) 
+			gc1 = ia_ora_style->gray_gc[5];
+		else
+			gc1 = ia_ora_style->gray_gc[2];
+
+
+	      gdk_draw_line (window, gc1, x+1,y,x+width-2,y);
+	      gdk_draw_line (window, gc1, x,y+1,x,y+height-2);
+	      gdk_draw_line (window, gc1, x+1,y+height-1,x+width-2,y+height-1);
+	      gdk_draw_line (window, gc1, x+width-1,y+1,x+width-1,y+height-2);
+	      if (xthick > 1 || ythick > 1) {
+		      if (area) {
+        		gdk_gc_set_clip_rectangle (style->white_gc, area);
+		      }
+
+		      gdk_draw_line (window, style->white_gc, x+1,y+height-2,x+width-2,y+height-2);
+		      gdk_draw_line (window, is_ltr ? style->white_gc : ia_ora_style->gray_gc[1], x+width-2,y+2,x+width-2,y+height-3);
+  
+		      gdk_draw_line (window, ia_ora_style->gray_gc[1], x+1,y+1,x+width-2,y+1);
+		      gdk_draw_line (window, is_ltr ? ia_ora_style->gray_gc[1] : style->white_gc, x+1,y+2,x+1,y+height-3);
+
+		      if (area) {
+        		gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+		      }
+	          }
+	      }
+	  break;
+        case GTK_SHADOW_OUT:
+		gc1 = ia_ora_style->gray_gc[2];
+
+	      gdk_draw_line (window, gc1, x+1,y,x+width-2,y);
+	      gdk_draw_line (window, gc1, x,y+1,x,y+height-2);
+	      gdk_draw_line (window, gc1, x+1,y+height-1,x+width-2,y+height-1);
+	      gdk_draw_line (window, gc1, x+width-1,y+1,x+width-1,y+height-2);
+	      if (xthick > 1 || ythick > 1) {
+		if (area) {
+        		gdk_gc_set_clip_rectangle (style->white_gc, area);
+		}
+
+		      gdk_draw_line (window, ia_ora_style->gray_gc[1], x+1,y+height-2,x+width-2,y+height-2);
+		      gdk_draw_line (window, is_ltr ? ia_ora_style->gray_gc[1] : style->white_gc, x+width-2,y+2,x+width-2,y+height-3);
+  
+		      gdk_draw_line (window, style->white_gc, x+1,y+1,x+width-2,y+1);
+		      gdk_draw_line (window, is_ltr ? style->white_gc :ia_ora_style->gray_gc[1], x+1,y+2,x+1,y+height-3);
+		if (area) {
+        		gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+		}
+	      }
+
+            break;
+    default:
+      break;
+    }
+    
+      if (area) {
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[1], NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[2], NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], NULL);
+      }
+    }
+}
+
+static void ia_ora_draw_scale (GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkOrientation orientation, gboolean inverted, gboolean is_progressbar)
+{
+
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+	int i;
+	GdkGC *color_gc;
+
+      if (is_progressbar) {
+	     color_gc = ia_ora_style->blue_gc[2];
+      } else {
+	     color_gc = ia_ora_style->gray_gc[1];
+      }
+
+      if (area) {
+	gdk_gc_set_clip_rectangle (color_gc, area);
+      }
+
+      if (!inverted) {
+	switch (orientation) {
+		case GTK_ORIENTATION_HORIZONTAL:
+			for (i = x + SCALE_INCREMENT; i < x + width-1 ; i += SCALE_INCREMENT) {
+				gdk_draw_line (window, color_gc, i,y+1,i,y+height-2);
+			}
+		break;
+		case GTK_ORIENTATION_VERTICAL:
+			for (i = y + SCALE_INCREMENT; i < y + height-1; i += SCALE_INCREMENT) {
+				gdk_draw_line (window, color_gc, x+1,i,x+width-2,i);
+			}
+			break;
+	}
+      } else {
+	switch (orientation) {
+		case GTK_ORIENTATION_HORIZONTAL:
+			for (i = x + width - SCALE_INCREMENT; i > x+1 ; i -= SCALE_INCREMENT) {
+				gdk_draw_line (window, color_gc, i,y+1,i,y+height-2);
+			}
+		break;
+		case GTK_ORIENTATION_VERTICAL:
+			for (i = y + height - SCALE_INCREMENT; i > y+1 ; i -= SCALE_INCREMENT) {
+				gdk_draw_line (window, color_gc, x+1,i,x+width-2,i);
+			}
+			break;
+	}
+      }
+
+      if (area) {
+	gdk_gc_set_clip_rectangle (color_gc, NULL);
+      }
+}
+
+static void draw_flat_box(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+
+     ia_ora_parent_class->draw_flat_box (style, window, state_type, shadow_type, area,
+			      widget, detail, x, y, width, height);
+
+    if (state_type == GTK_STATE_PRELIGHT) {
+      if(area) {
+	gdk_gc_set_clip_rectangle (style->bg_gc[GTK_STATE_NORMAL], area);
+      }
+    gdk_draw_point(window, style->bg_gc[GTK_STATE_NORMAL],x,y);
+    gdk_draw_point(window, style->bg_gc[GTK_STATE_NORMAL],x+width-1,y);
+    gdk_draw_point(window, style->bg_gc[GTK_STATE_NORMAL],x,y+height-1);
+    gdk_draw_point(window, style->bg_gc[GTK_STATE_NORMAL],x+width-1,y+height-1);
+      if(area) {
+	gdk_gc_set_clip_rectangle (style->bg_gc[GTK_STATE_NORMAL], NULL);
+      }
+     }
+
+}
+  
+
+static void draw_box(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+  
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  int xthick, ythick;
+
+  xthick = style->xthickness;
+  ythick = style->ythickness;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    sanitize_size(window, &width, &height);
+
+	if (widget && DETAIL("buttondefault")) {
+          if(area) {
+	    gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[4], area);
+           }
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+			      x+xthick+1, y,x+width-2-xthick,y);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+			      x+xthick+1, y+height-1,x+width-2-xthick,y+height-1);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+			      x,y+ythick+1,x,y-2*ythick+height);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+			      x+width-1,y+ythick+1,x+width-1,y-2*ythick+height);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+				x+1,y+2,x+2,y+1);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+				x+1,y+height-3,x+2,y+height-2);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+				x+width-3,y+1,x+width-2,y+2);
+		gdk_draw_line(window, ia_ora_style->blue_gc[4],
+				x+width-3,y+height-2,x+width-2,y+height-3);
+
+          if(area) {
+	    gdk_gc_set_clip_rectangle(ia_ora_style->blue_gc[4], NULL);
+           }
+	}
+ 
+	else if (widget && 
+	(DETAIL ("button")  ||
+	 DETAIL ("togglebutton") ||
+	 DETAIL("optionmenu"))) /* Button, ComboBox */ {
+
+	    ia_ora_draw_button (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+      }
+    else if (widget && 
+	 (DETAIL ("spinbutton_up") || 
+	 DETAIL ("spinbutton_down"))) {
+	    ia_ora_draw_spinbutton(style, window, state_type, shadow_type, area, widget, detail, x, y, width-1, height);
+    }
+    else if (widget && 
+	 (DETAIL ("spinbutton"))) {
+	    ia_ora_draw_half_round_rectangle (style, window, state_type, shadow_type, area, widget, detail, x, y, width-1, height);
+    }
+    else if (widget &&  
+	     (DETAIL ("menubar") || 
+	      DETAIL ("toolbar") || 
+	      DETAIL ("dockitem_bin")) ) {
+      
+        gtk_style_apply_default_background (style, window,
+				widget && !GTK_WIDGET_NO_WINDOW (widget),
+				state_type, area, x, y, width, height);
+	if (shadow_type == GTK_SHADOW_OUT) {
+          if(area) {
+	    gdk_gc_set_clip_rectangle(style->white_gc, area);
+	    gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], area);
+          }
+	  gdk_draw_line (window,style->white_gc,x,y,x+width-1,y);
+	  gdk_draw_line (window,ia_ora_style->gray_gc[2],x,y+height-1,x+width-1,y+height-1);	
+          if(area) {
+	    gdk_gc_set_clip_rectangle(style->white_gc, NULL);
+	    gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[2], NULL);
+          }
+	}
+
+    }
+    else if (widget && (DETAIL ("trough-upper") || DETAIL("trough-lower"))) {
+	    int color;
+
+	    if DETAIL ("trough-upper")
+		    color = 0;
+	    else
+		    color = 3;
+
+	    if GTK_IS_HSCALE (widget)
+		{
+		  y += (height - RANGE_TROUGH_SIZE) / 2;
+		  height = RANGE_TROUGH_SIZE;
+		}
+      
+	      if GTK_IS_VSCALE (widget)
+		{
+		  x += (width - RANGE_TROUGH_SIZE) / 2;
+		  width = RANGE_TROUGH_SIZE;
+		}
+
+
+	    if (area) {
+		  gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[color], area);
+	    }
+
+		gdk_draw_rectangle (window, ia_ora_style->gray_gc[color], TRUE, x+1, y+1, width-2, height -2);
+	    if (area) {
+		  gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[color], NULL);
+	    }
+		ia_ora_draw_scale (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, GTK_RANGE (widget)->orientation,DETAIL ("trough-upper") ^ gtk_range_get_inverted(GTK_RANGE(widget)), FALSE );
+
+
+	  ia_ora_draw_round_rectangle (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+
+    }
+    else if (widget && DETAIL ("trough")) {
+      /* this is the trough used for scrollbar and slider*/
+      if GTK_IS_HSCALE (widget)
+	{
+	  y += (height - SCALE_SIZE) / 2;
+	  height = SCALE_SIZE;
+	}
+      
+      if GTK_IS_VSCALE (widget)
+	{
+	  x += (width - SCALE_SIZE) / 2;
+	  width = SCALE_SIZE;
+	}
+
+
+      if (area) {
+	  gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[0], area);
+	}
+
+	gdk_draw_rectangle (window, ia_ora_style->gray_gc[0],TRUE,
+			    x+1,y+1,width-2,height-2);
+	if (area) {
+	  gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[0], NULL);
+	}
+      
+      if (!GTK_IS_RANGE (widget)) {
+	      GtkOrientation orientation;
+	      gboolean inverted = FALSE;
+
+	switch (gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR(widget))) {
+	      case GTK_PROGRESS_RIGHT_TO_LEFT:
+		      inverted = TRUE;
+	      case GTK_PROGRESS_LEFT_TO_RIGHT:
+		      orientation = GTK_ORIENTATION_HORIZONTAL;
+		break;
+	
+	        case GTK_PROGRESS_BOTTOM_TO_TOP:
+			inverted = TRUE;
+		case GTK_PROGRESS_TOP_TO_BOTTOM:
+		      orientation = GTK_ORIENTATION_VERTICAL;
+		break;
+
+	}
+	      ia_ora_draw_scale (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height,orientation, inverted, FALSE);
+      }
+	  ia_ora_draw_round_rectangle (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+
+    } 
+    else if (widget && (DETAIL ("hscrollbar") || DETAIL ("vscrollbar"))) {
+      /* draw steppers, buttons used for scrollbar */
+	 GdkColor top_color, bottom_color;
+
+	 if (area) {
+	   gdk_gc_set_clip_rectangle (style->base_gc[state_type], area);
+	   gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[4], area);
+	   gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[5], area);
+	 }
+
+	 switch (state_type) {
+		 case GTK_STATE_PRELIGHT:
+            bottom_color = ia_ora_style->gray[1];
+            top_color = style->white;
+	    break;
+		 case GTK_STATE_ACTIVE:
+            bottom_color = ia_ora_style->gray[0];
+            top_color = ia_ora_style->gray[1];
+	    break;
+		 default:
+            bottom_color = ia_ora_style->gray[2];
+            top_color = ia_ora_style->gray[0];
+	    break;
+          }
+
+         if (DETAIL ("hscrollbar")) {
+	   int color1, color2;
+
+           ia_ora_draw_vgradient (window, style->base_gc[state_type], style->colormap,
+                           x+1, y+1, width-2, height-2,
+                           &top_color,
+                           &bottom_color);
+
+	   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) {
+		  color1= 4;
+		  color2= 5;
+	   }  else {
+		  color1= 5;
+		  color2= 4;
+	   }
+
+	   gdk_draw_line (window, ia_ora_style->gray_gc[color1],x,y+1,x,y+height-2);
+	   gdk_draw_line (window, ia_ora_style->gray_gc[color2],x+width-1,y+1,x+width-1,y+height-2);
+
+	 } else {
+
+	  if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) {
+		  /* inverse gradient */
+		  GdkColor tmp_color;
+		  tmp_color = top_color;
+		  top_color = bottom_color;
+		  bottom_color = tmp_color;
+
+	  }
+          ia_ora_draw_hgradient (window, style->base_gc[state_type], style->colormap,
+                           x+1, y+1, width-2, height-2,
+                           &top_color,
+                           &bottom_color);
+	  gdk_draw_line (window, ia_ora_style->gray_gc[4],x+1,y,x+width-2,y);
+	  gdk_draw_line (window, ia_ora_style->gray_gc[5],x+1,y+height-1,x+width-2,y+height-1);
+         }
+
+	 if (area) {
+	   gdk_gc_set_clip_rectangle (style->base_gc[state_type], NULL);
+	   gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[4], NULL);
+	   gdk_gc_set_clip_rectangle(ia_ora_style->gray_gc[5], NULL);
+	 }
+       }
+    else if (widget && DETAIL ("bar")) { /* progress bar */
+      if ((height > 2 ) && (width > 2)) {
+	 gboolean round_beginning, round_end;
+	 gboolean inversed = FALSE;
+	 gboolean is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+	 GtkOrientation orientation;
+	 int processed_width = width, processed_height = height;
+
+	 round_beginning = round_end = GTK_PROGRESS(widget)->activity_mode;
+
+	 switch (gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget))) {
+		      case GTK_PROGRESS_RIGHT_TO_LEFT:
+			      inversed = TRUE;
+		      case GTK_PROGRESS_LEFT_TO_RIGHT:
+			      orientation = GTK_ORIENTATION_HORIZONTAL;
+			      if (!inversed) {
+				      processed_width += (!GTK_PROGRESS(widget)->activity_mode) && (((x + width - 2)  % SCALE_INCREMENT) == 0) && (gtk_progress_get_current_percentage (GTK_PROGRESS (widget)) < 1.0);
+			      }
+			      break;
+		        case GTK_PROGRESS_BOTTOM_TO_TOP:
+			      inversed = TRUE;
+			case GTK_PROGRESS_TOP_TO_BOTTOM:
+			      is_ltr = TRUE; /* LTR doesn't matter for vertical */
+			      orientation = GTK_ORIENTATION_VERTICAL;
+			      if (!inversed) {
+				      processed_height += (!GTK_PROGRESS(widget)->activity_mode) && (((y + height - 2)  % SCALE_INCREMENT) == 0) && (gtk_progress_get_current_percentage (GTK_PROGRESS (widget)) < 1.0);
+			      }
+			      break;
+			
+			default: /* never reached */
+			      break;
+        }
+
+	round_end |= (gtk_progress_get_current_percentage (GTK_PROGRESS (widget)) < 1.0) && !inversed;
+	round_beginning |= (gtk_progress_get_current_percentage (GTK_PROGRESS (widget)) < 1.0) && inversed;
+
+	ia_ora_draw_double_gradient_bar (style, window, state_type, shadow_type, area, widget, detail, x+1, y+1, processed_width-2, processed_height-2, orientation, is_ltr ? round_beginning : round_end, is_ltr ? round_end : round_beginning);
+
+	if (!GTK_PROGRESS(widget)->activity_mode) {
+	      ia_ora_draw_scale (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation, inversed, TRUE);
+        }
+      }
+    }  
+    else if (widget && DETAIL ("menuitem")) {
+      ia_ora_draw_double_gradient_bar (style, window, state_type, shadow_type,area,widget,
+		      detail, x, y, width, height,GTK_ORIENTATION_HORIZONTAL, TRUE, TRUE);
+    } 
+    else { /* everything else */
+       ia_ora_parent_class->draw_box (style, window, state_type, shadow_type, area,
+			      widget, detail, x, y, width, height);	      
+    }
+}
+
+static void draw_inconsistent_bits(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+    Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+    GdkGC *lower_gc, *top_gc;
+
+    if (state_type == GTK_STATE_INSENSITIVE) {
+	    top_gc = ia_ora_style->gray_gc[3];
+	    lower_gc = ia_ora_style->gray_gc[4];
+    }
+    else {
+	    	if (IA_ORA_RC_STYLE(style->rc_style)->black_check) {
+		    top_gc = ia_ora_style->gray_gc[5];
+		    lower_gc = ia_ora_style->gray_gc[6];
+		}
+		else {
+		    top_gc = ia_ora_style->blue_gc[3];
+		    lower_gc = ia_ora_style->blue_gc[4];
+			}
+    }
+    if(area) {
+	gdk_gc_set_clip_rectangle(top_gc, area);
+	gdk_gc_set_clip_rectangle(lower_gc, area);
+    }
+
+    gdk_draw_line (window, top_gc, x+4, y+4, x +PART_SIZE-5, y+4);
+    gdk_draw_line (window, top_gc, x+3, y+5,x +PART_SIZE-4, y+5);
+    gdk_draw_line (window, lower_gc, x+4, y+6,x +PART_SIZE-5, y+6);
+    if(area) {
+   	gdk_gc_set_clip_rectangle(top_gc, NULL);
+    	gdk_gc_set_clip_rectangle(lower_gc, NULL);
+    }
+}
+
+
+static void draw_check(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  static GdkBitmap* button_bmap1 = NULL, *button_bmap2 = NULL;
+  static GdkPixbuf* menu_pixbuf= NULL, *menu_active_pixbuf = NULL;
+  GdkBitmap* bmap1 = NULL, *bmap2 = NULL;
+
+
+  x -= (1 + PART_SIZE - width) / 2;
+  y -= (PART_SIZE - 2  - height) / 2 ;
+  
+  if (!DETAIL ("check")) {
+  if(area) {
+    gdk_gc_set_clip_rectangle(style->base_gc[state_type], area);
+  }
+    gdk_draw_rectangle(window, style->base_gc[state_type == GTK_STATE_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL], TRUE, 
+		       x+1, y+1, PART_SIZE-2, PART_SIZE-2-1);
+  if(area) {
+    gdk_gc_set_clip_rectangle(style->base_gc[state_type], NULL);
+  }
+    
+    ia_ora_draw_round_rectangle (style, window, state_type,shadow_type,area,widget,detail,
+		 x,y,PART_SIZE,PART_SIZE-1); 
+
+    if (shadow_type == GTK_SHADOW_IN) {
+      if (button_bmap1 == NULL) {
+   	if (IA_ORA_RC_STYLE(style->rc_style)->use_cross) {
+		button_bmap1 = gdk_bitmap_create_from_data(window, top_half_cross_bits,
+							  PART_SIZE, PART_SIZE);
+	} else {
+		button_bmap1 = gdk_bitmap_create_from_data(window, check_top_bits,
+							  PART_SIZE, PART_SIZE);
+	}
+      }
+      bmap1 = button_bmap1;
+	if (button_bmap2 == NULL) {
+   	   if (IA_ORA_RC_STYLE(style->rc_style)->use_cross) {
+		button_bmap2 = gdk_bitmap_create_from_data(window, bottom_half_cross_bits,
+							  PART_SIZE, PART_SIZE);
+	   }
+	   else {
+		button_bmap2 = gdk_bitmap_create_from_data(window, check_bottom_bits,
+							  PART_SIZE, PART_SIZE);
+	   }
+	}
+      bmap2 = button_bmap2;
+      }
+
+  }
+  else {
+     if (menu_pixbuf == NULL) {
+	     menu_pixbuf = gdk_pixbuf_new_from_xpm_data (menu_check_xpm);
+     }
+     if (menu_active_pixbuf == NULL) {
+	     menu_active_pixbuf = gdk_pixbuf_new_from_xpm_data (menu_check_active_xpm);
+     }
+     y += 2;
+  }
+  
+  if (shadow_type == GTK_SHADOW_IN) {
+      
+  	if(area) {
+ 	   	gdk_gc_set_clip_rectangle(ia_ora_style->check_gc, area);
+  	}
+
+	  if (DETAIL ("check")) {
+		  if ((state_type == GTK_STATE_SELECTED) || (state_type == GTK_STATE_ACTIVE)
+		     || (state_type == GTK_STATE_PRELIGHT)) {
+			  gdk_draw_pixbuf (window, ia_ora_style->check_gc, menu_active_pixbuf, 0,0, x, y, -1, -1,GDK_RGB_DITHER_MAX,0,0);
+		  } else {
+		  gdk_draw_pixbuf (window, ia_ora_style->check_gc, menu_pixbuf, 0,0, x, y, -1, -1,GDK_RGB_DITHER_MAX,0,0);
+		  }
+  	}  else {
+
+		gdk_gc_set_stipple(ia_ora_style->check_gc, bmap1);
+		gdk_gc_set_ts_origin(ia_ora_style->check_gc, x, y);
+		gdk_gc_set_fill(ia_ora_style->check_gc, GDK_STIPPLED);
+		if (state_type == GTK_STATE_INSENSITIVE) {
+			gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[3]);
+		} else {
+			if (IA_ORA_RC_STYLE(style->rc_style)->black_check) {
+				gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[5]);
+			}
+			else {
+				gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->blue[3]);
+			}
+		}
+
+		gdk_draw_rectangle(window, ia_ora_style->check_gc, TRUE, x, y, 
+				   PART_SIZE, PART_SIZE);
+
+		if (bmap2) {
+			gdk_gc_set_stipple(ia_ora_style->check_gc, bmap2);
+			if (state_type == GTK_STATE_INSENSITIVE) {
+				gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[4]);
+			} else {
+				if (IA_ORA_RC_STYLE(style->rc_style)->black_check) {
+					gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[6]);
+				}
+				else {
+					gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->blue[4]);
+				}
+			}
+			gdk_draw_rectangle(window, ia_ora_style->check_gc, TRUE, x, y, 
+				   PART_SIZE, PART_SIZE);
+		}
+
+		gdk_gc_set_fill(ia_ora_style->check_gc, GDK_SOLID);
+	  }
+
+  	if(area) {
+	    gdk_gc_set_clip_rectangle(ia_ora_style->check_gc, NULL);
+	  }
+      }
+  else if (shadow_type == GTK_SHADOW_ETCHED_IN) {
+	  draw_inconsistent_bits(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+
+}
+
+static void 
+draw_option (GtkStyle      *style,
+	     GdkWindow     *window,
+	     GtkStateType   state_type,
+	     GtkShadowType  shadow_type,
+	     GdkRectangle  *area,
+	     GtkWidget     *widget,
+	     const gchar   *detail,
+	     gint           x,
+	     gint           y,
+	     gint           width,
+	     gint           height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  static GdkBitmap *radio_up_bmap = NULL, *radio_down_bmap = NULL;
+
+  if (DETAIL ("option")) /* Menu item */
+    {
+      ia_ora_parent_class->draw_option (style, window, state_type, shadow_type, area,
+				 widget, detail, x, y, width, height);
+      return;
+    }
+    
+  if (area) {
+    gdk_gc_set_clip_rectangle (style->base_gc[state_type], area);
+  }
+
+
+  ensure_radio_pixmaps(style, state_type, widget);
+
+  x += (width - RADIO_SIZE)/2;
+  y += (height - RADIO_SIZE + 2 ) / 2 ;
+
+  gdk_gc_set_clip_mask (style->base_gc[state_type],
+			ia_ora_style->radio_pixmap_mask);
+  gdk_gc_set_clip_origin (style->base_gc[state_type], x, y);
+
+  gdk_draw_drawable (window, style->base_gc[state_type],
+		     ia_ora_style->radio_pixmap_circle[state_type],
+		     0, 0,
+		     x, y,
+		     RADIO_SIZE, RADIO_SIZE);
+
+  gdk_gc_set_clip_origin (style->base_gc[state_type], 0, 0);
+  gdk_gc_set_clip_mask (style->base_gc[state_type], NULL);
+
+  if (area) {
+    gdk_gc_set_clip_rectangle (style->base_gc[state_type], NULL);
+  }
+
+
+  if (shadow_type == GTK_SHADOW_IN) { /* active*/
+   if (radio_up_bmap == NULL) {
+	radio_up_bmap = gdk_bitmap_create_from_data(window, radio_up_bits,
+						  RADIO_SIZE, RADIO_SIZE);
+      }
+
+   if (radio_down_bmap == NULL) {
+	radio_down_bmap = gdk_bitmap_create_from_data(window, radio_down_bits,
+						  RADIO_SIZE, RADIO_SIZE);
+      }
+
+  if(area) {
+    gdk_gc_set_clip_rectangle(ia_ora_style->check_gc, area);
+  }
+
+	gdk_gc_set_stipple(ia_ora_style->check_gc, radio_up_bmap);
+	gdk_gc_set_ts_origin(ia_ora_style->check_gc, x, y);
+	gdk_gc_set_fill(ia_ora_style->check_gc, GDK_STIPPLED);
+	if (state_type == GTK_STATE_INSENSITIVE) {
+		gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[3]);
+	} else {
+		if (IA_ORA_RC_STYLE(style->rc_style)->black_check) {
+			gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[5]);
+		}
+		else {
+			gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->blue[3]);
+		}
+	}
+
+
+       	gdk_draw_rectangle(window, ia_ora_style->check_gc, TRUE, x, y, 
+			   RADIO_SIZE, RADIO_SIZE);
+
+	gdk_gc_set_stipple(ia_ora_style->check_gc, radio_down_bmap);
+	if (state_type == GTK_STATE_INSENSITIVE) {
+		gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[4]);
+	} else {
+		if (IA_ORA_RC_STYLE(style->rc_style)->black_check) {
+			gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->gray[6]);
+		}
+		else {
+			gdk_gc_set_foreground(ia_ora_style->check_gc, &ia_ora_style->blue[4]);
+		}
+	}
+	gdk_draw_rectangle(window, ia_ora_style->check_gc, TRUE, x, y, 
+			   RADIO_SIZE, RADIO_SIZE);
+
+	gdk_gc_set_fill(ia_ora_style->check_gc, GDK_SOLID);
+
+  if(area) {
+    gdk_gc_set_clip_rectangle(ia_ora_style->check_gc, area);
+  }
+  } else if (shadow_type == GTK_SHADOW_ETCHED_IN) {
+	  draw_inconsistent_bits(style, window, state_type, shadow_type, area, widget, detail, x, y+1, width, height);
+  }
+}
+
+
+static void draw_shadow_gap(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+    GdkRectangle rect;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    draw_shadow(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+
+    switch (gap_side)
+    {
+        case GTK_POS_TOP:
+            rect.x = x + gap_x;
+            rect.y = y;
+            rect.width = gap_width;
+            rect.height = 2;
+            break;
+        case GTK_POS_BOTTOM:
+            rect.x = x + gap_x;
+            rect.y = y + height - 2;
+            rect.width = gap_width;
+            rect.height = 2;
+            break;
+        case GTK_POS_LEFT:
+            rect.x = x;
+            rect.y = y + gap_x;
+            rect.width = 2;
+            rect.height = gap_width;
+            break;
+        case GTK_POS_RIGHT:
+            rect.x = x + width - 2;
+            rect.y = y + gap_x;
+            rect.width = 2;
+            rect.height = gap_width;
+            break;
+    }
+
+    gtk_style_apply_default_background(style, window, TRUE, state_type, area, rect.x, rect.y, rect.width, rect.height);
+}
+
+static void draw_box_gap(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+    Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+    gboolean is_ltr;
+
+    GdkGC *gc1 = NULL;
+    GdkGC *gc2 = NULL;
+    GdkGC *gc3 = NULL;
+    GdkGC *gc4 = NULL;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    gtk_style_apply_default_background(style, window, widget && !GTK_WIDGET_NO_WINDOW(widget), state_type, area, x, y, width, height);
+
+    is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+
+    sanitize_size(window, &width, &height);
+
+    switch (shadow_type)
+    {
+        case GTK_SHADOW_NONE:
+            return;
+        case GTK_SHADOW_IN:
+            gc1 = style->bg_gc[state_type];
+            gc2 = style->dark_gc[state_type];;
+            gc3 = style->bg_gc[state_type];
+            gc4 = style->light_gc[state_type];
+            break;
+        case GTK_SHADOW_ETCHED_IN:
+            gc1 = style->dark_gc[state_type];
+            gc2 = style->light_gc[state_type];
+            gc3 = style->dark_gc[state_type];
+            gc4 = style->light_gc[state_type];
+            break;
+        case GTK_SHADOW_OUT:
+            gc1 = ia_ora_style->gray_gc[4];
+            gc2 = style->bg_gc[state_type];
+            gc3 = style->bg_gc[state_type];
+            gc4 = ia_ora_style->gray_gc[4];
+            break;
+        case GTK_SHADOW_ETCHED_OUT:
+            gc1 = style->light_gc[state_type];
+            gc2 = style->dark_gc[state_type];
+            gc3 = style->light_gc[state_type];
+            gc4 = style->dark_gc[state_type];
+            break;
+    }
+
+    if(area)
+    {
+        gdk_gc_set_clip_rectangle(gc1, area);
+        gdk_gc_set_clip_rectangle(gc2, area);
+        gdk_gc_set_clip_rectangle(gc3, area);
+        gdk_gc_set_clip_rectangle(gc4, area);
+    }
+
+    switch (shadow_type)
+    {
+        case GTK_SHADOW_NONE:
+        case GTK_SHADOW_IN:
+        case GTK_SHADOW_OUT:
+        case GTK_SHADOW_ETCHED_IN:
+        case GTK_SHADOW_ETCHED_OUT:
+            switch (gap_side)
+            {
+                case GTK_POS_TOP:
+                    gdk_draw_line(window, gc1, x, y+!is_ltr, x, y + height - 2);
+                    gdk_draw_line(window, gc2, x + 1, y, x + 1, y + height - 2);
+
+                    gdk_draw_line(window, gc3, x + 1, y + height - 2, x + width - 2, y + height - 2);
+                    gdk_draw_line(window, gc3, x + width - 2, y, x + width - 2, y + height - 2);
+                    gdk_draw_line(window, gc4, x+1, y + height - 1, x + width - 2, y + height - 1);
+                    gdk_draw_line(window, gc4, x + width - 1, y +is_ltr, x + width - 1, y + height - 2);
+                    if(gap_x > 0)
+                    {
+                        gdk_draw_line(window, gc1, x + 1, y, x + gap_x - 1, y);
+                        gdk_draw_line(window, gc2, x + 1, y + 1, x + gap_x - 1, y + 1);
+                        gdk_draw_line(window, gc2, x + gap_x, y, x + gap_x, y);
+                    }
+                    if((width - (gap_x + gap_width)) > 0)
+                    {
+                        gdk_draw_line(window, gc1, x + gap_x + gap_width, y, x + width - 2, y);
+                        gdk_draw_line(window, gc2, x + gap_x + gap_width, y + 1, x + width - 2, y + 1);
+                        gdk_draw_line(window, gc2, x + gap_x + gap_width - 1, y, x + gap_x + gap_width - 1, y);
+                    }
+                    break;
+                case GTK_POS_BOTTOM:
+                    gdk_draw_line(window, gc1, x+1, y, x + width - 2, y);
+                    gdk_draw_line(window, gc1, x, y+1, x, y + height - 1 - !is_ltr);
+                    gdk_draw_line(window, gc2, x + 1, y + 1, x + width - 2, y + 1);
+                    gdk_draw_line(window, gc2, x + 1, y + 1, x + 1, y + height - 1);
+
+                    gdk_draw_line(window, gc3, x + width - 2, y + 1, x + width - 2, y + height - 1);
+                    gdk_draw_line(window, gc4, x + width - 1, y + 1, x + width - 1, y + height - 1 - is_ltr);
+                    if(gap_x > 0)
+                    {
+                        gdk_draw_line(window, gc4, x+1, y + height - 1, x + gap_x - 1, y + height - 1);
+                        gdk_draw_line(window, gc3, x + 1, y + height - 2, x + gap_x - 1, y + height - 2);
+                        gdk_draw_line(window, gc3, x + gap_x, y + height - 1, x + gap_x, y + height - 1);
+                    }
+                    if((width - (gap_x + gap_width)) > 0)
+                    {
+                        gdk_draw_line(window, gc4, x + gap_x + gap_width, y + height - 1, x + width - 2, y + height - 1);
+                        gdk_draw_line(window, gc3, x + gap_x + gap_width, y + height - 2, x + width - 2, y + height - 2);
+                        gdk_draw_line(window, gc3, x + gap_x + gap_width - 1, y + height - 1, x + gap_x + gap_width - 1, y + height - 1);
+                    }
+                    break;
+                case GTK_POS_LEFT:
+                    gdk_draw_line(window, gc1, x, y, x + width - 2, y);
+                    gdk_draw_line(window, gc2, x, y + 1, x + width - 2, y + 1);
+
+                    gdk_draw_line(window, gc3, x, y + height - 2, x + width - 2, y + height - 2);
+                    gdk_draw_line(window, gc3, x + width - 2, y + 1, x + width - 2, y + height - 2);
+                    gdk_draw_line(window, gc4, x+1, y + height - 1, x + width - 2, y + height - 1);
+                    gdk_draw_line(window, gc4, x + width - 1, y+1, x + width - 1, y + height - 2);
+                    if(gap_x > 0)
+                    {
+                        gdk_draw_line(window, gc1, x, y, x, y + gap_x - 1);
+                        gdk_draw_line(window, gc2, x + 1, y + 1, x + 1, y + gap_x - 1);
+                        gdk_draw_line(window, gc2, x, y + gap_x, x, y + gap_x);
+                    }
+                    if((width - (gap_x + gap_width)) > 0)
+                    {
+                        gdk_draw_line(window, gc1, x, y + gap_x + gap_width, x, y + height - 2);
+                        gdk_draw_line(window, gc2, x + 1, y + gap_x + gap_width, x + 1, y + height - 2);
+                        gdk_draw_line(window, gc2, x, y + gap_x + gap_width - 1, x, y + gap_x + gap_width - 1);
+                    }
+                    break;
+                case GTK_POS_RIGHT:
+                    gdk_draw_line(window, gc1, x+1, y, x + width - 1, y);
+                    gdk_draw_line(window, gc1, x, y+1, x, y + height - 2);
+                    gdk_draw_line(window, gc2, x + 1, y + 1, x + width - 1, y + 1);
+                    gdk_draw_line(window, gc2, x + 1, y + 1, x + 1, y + height - 2);
+
+                    gdk_draw_line(window, gc3, x + 1, y + height - 2, x + width - 1, y + height - 2);
+                    gdk_draw_line(window, gc4, x+1, y + height - 1, x + width - 2, y + height - 1);
+                    if(gap_x > 0)
+                    {
+                        gdk_draw_line(window, gc4, x + width - 1, y, x + width - 1, y + gap_x - 1);
+                        gdk_draw_line(window, gc3, x + width - 2, y + 1, x + width - 2, y + gap_x - 1);
+                        gdk_draw_line(window, gc3, x + width - 1, y + gap_x, x + width - 1, y + gap_x);
+                    }
+                    if((width - (gap_x + gap_width)) > 0)
+                    {
+                        gdk_draw_line(window, gc4, x + width - 1, y + gap_x + gap_width, x + width - 1, y + height - 2);
+                        gdk_draw_line(window, gc3, x + width - 2, y + gap_x + gap_width, x + width - 2, y + height - 2);
+                        gdk_draw_line(window, gc3, x + width - 1, y + gap_x + gap_width - 1, x + width - 1, y + gap_x + gap_width - 1);
+                    }
+                    break;
+            }
+    }
+
+    if(area)
+    {
+        gdk_gc_set_clip_rectangle(gc1, NULL);
+        gdk_gc_set_clip_rectangle(gc2, NULL);
+        gdk_gc_set_clip_rectangle(gc3, NULL);
+        gdk_gc_set_clip_rectangle(gc4, NULL);
+    }
+}
+
+static void draw_extension(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side)
+{ 
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  
+    GdkGC *gc1 = NULL;
+    gint dx = 0, dy = 0;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+    gtk_style_apply_default_background (style, window,
+					widget && !GTK_WIDGET_NO_WINDOW (widget),
+					GTK_STATE_NORMAL, area, x, y, width, height);
+    sanitize_size(window, &width, &height);
+
+    switch (shadow_type) {
+
+    case GTK_SHADOW_NONE:
+      return;
+
+    case GTK_SHADOW_IN:
+    case GTK_SHADOW_ETCHED_IN:
+      gc1 = ia_ora_style->gray_gc[5];
+      break;
+
+    case GTK_SHADOW_OUT:
+    case GTK_SHADOW_ETCHED_OUT:
+      if (state_type == GTK_STATE_NORMAL) { /* we draw current page */
+	gc1 = ia_ora_style->gray_gc[4] ;
+      } else {
+	gc1 = ia_ora_style->gray_gc[5];
+      }
+      break;
+    }
+
+    if(area)
+    {
+        gdk_gc_set_clip_rectangle(gc1, area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->blue_gc[3], area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->blue_gc[4], area);
+    }
+
+    //Unselected tab should be drawn 2 pixels lower than selected tab
+    if (state_type == GTK_STATE_ACTIVE)
+    {
+      dx = 2;
+      dy = 2;
+    }
+    switch (shadow_type)
+    {
+        case GTK_SHADOW_NONE:
+        case GTK_SHADOW_IN:
+        case GTK_SHADOW_OUT:
+        case GTK_SHADOW_ETCHED_IN:
+        case GTK_SHADOW_ETCHED_OUT:
+            switch (gap_side)
+            {
+                case GTK_POS_TOP:
+		  gtk_style_apply_default_background (style, window,
+						      widget && !GTK_WIDGET_NO_WINDOW (widget),
+						      state_type, area,
+						      x + style->xthickness + dx, 
+						      y, 
+						      width - 1 - style->xthickness - dx, 
+						      height - style->ythickness - dy);
+						      
+                    gdk_draw_line (window, gc1, x + dx, y, x + dx, y + height - 3 - dy);
+                    gdk_draw_line (window, gc1, x + width - 1, y, x + width - 1, y + height - 3 - dy);
+		    
+		    if (state_type == GTK_STATE_NORMAL) {
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[4] , x + 2 + dx , y + height + dy-1, x + width - 3, y + dy + height-1);
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[4] , x + 1 + dx , y + dy+height - 2, x + width - 2, y + dy + height -2);
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[3] , x + dx , y + dy + height - 3, x + width - 1, y + dy + height-3);
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[3] , x + dx , y + dy + height - 4, x + width - 1, y + dy + height-4);
+		 }
+		 else {
+		    gdk_draw_point (window, gc1, x+1 + dx, y+height-2 - dy);
+                    gdk_draw_line(window, gc1, x + 2 + dx, y + height - 1 - dy, x + width - 3, y + height - 1 - dy);
+		    gdk_draw_point (window, gc1, x+width-2,y+height-2 - dy);
+		 }
+
+                    break;
+                case GTK_POS_BOTTOM:
+		  gtk_style_apply_default_background (style, window,
+						      widget && !GTK_WIDGET_NO_WINDOW (widget),
+						      state_type, area,
+						      x + style->ythickness + dx,
+						      y + style->ythickness + dy,
+						      width - 1 - style->xthickness - dx,
+						      height - style->ythickness - dy);
+		  gdk_draw_line (window, gc1, x + dx, y + 2 + dy, x + dx, y + height - 1 );
+
+		  gdk_draw_line (window, gc1, x + width - 1, y + 2 + dy, 
+				 x + width - 1, y + height - 1);
+		 if (state_type == GTK_STATE_NORMAL) {
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[3] , x + 2 + dx , y + dy, x + width - 3, y + dy);
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[3] , x + 1 + dx , y + dy+1, x + width - 2, y + dy+1);
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[4] , x + dx , y + dy+2, x + width - 1, y + dy+2);
+		  	gdk_draw_line (window,ia_ora_style->blue_gc[4] , x + dx , y + dy+3, x + width - 1, y + dy+3);
+
+
+		 }
+		 else {
+
+		  gdk_draw_point (window, gc1, x + 1 + dx, y+1+dy);
+		  gdk_draw_line (window, gc1, x + 2 + dx , y + dy, x + width - 3, y + dy);
+		    
+		  gdk_draw_point (window, gc1, x + width-2, y + 1 + dy);
+		  }
+		  break;
+                case GTK_POS_LEFT:
+		  gtk_style_apply_default_background (style, window,
+						      widget && !GTK_WIDGET_NO_WINDOW (widget),
+						      state_type, area,
+						      x, 
+						      y + style->ythickness + dx,
+						      width - style->xthickness - dy,
+						      height - style->ythickness - dx);
+                    gdk_draw_line (window, gc1, x, y + dx, x + width - 3 - dy, y+ dx);
+                    gdk_draw_line (window, gc1, x, y + height - 1, x + width - 3 - dy, y + height - 1);
+
+  			if (state_type == GTK_STATE_NORMAL) {
+                    		gdk_draw_line (window, ia_ora_style->blue_gc[4], x + width - 1 - dy, y + 2 + dx, x + width - 1 - dy, y + height - 3);
+                    		gdk_draw_line (window, ia_ora_style->blue_gc[4], x + width - 2 - dy, y + 1 + dx, x + width - 2 - dy, y + height - 2);
+                    		gdk_draw_line (window, ia_ora_style->blue_gc[3], x + width - 3 - dy, y + dx, x + width - 3 - dy, y + height - 1);
+                    		gdk_draw_line (window, ia_ora_style->blue_gc[3], x + width - 4 - dy, y + dx, x + width - 4 - dy, y + height - 1);
+			}		    
+			else {
+		    		gdk_draw_point (window, gc1, x+width-2 - dy,y+1 + dx);
+		                gdk_draw_point (window, gc1, x + width - 2 - dy, y + height - 2);
+                    		gdk_draw_line (window, gc1, x + width - 1 - dy, y + 2 + dx, x + width - 1 - dy, y + height - 3);
+			}
+                    break;
+                case GTK_POS_RIGHT:
+		  gtk_style_apply_default_background (style, window,
+						      widget && !GTK_WIDGET_NO_WINDOW (widget),
+						      state_type, area,
+						      x + style->xthickness + dy,
+						      y + style->ythickness + dx,
+						      width  - style->xthickness - dy,
+						      height - style->ythickness - dx);
+
+                    gdk_draw_line (window, gc1, x + 2 + dy, y + dx, x + width - 1, y + dx);
+                    gdk_draw_line (window, gc1, x+ 2 + dy, y + height - 1, x + width - 1, y + height - 1);
+ 	  	if (state_type == GTK_STATE_NORMAL) {
+                    gdk_draw_line (window, ia_ora_style->blue_gc[3], x + dy, y + 2 + dx, x + dy, y + height - 3);
+                    gdk_draw_line (window, ia_ora_style->blue_gc[3], x + dy+1, y + 1 + dx, x + dy+1, y + height - 2);
+                    gdk_draw_line (window, ia_ora_style->blue_gc[4], x + dy+2, y + dx, x + dy+2, y + height - 1);
+                    gdk_draw_line (window, ia_ora_style->blue_gc[4], x + dy+3, y + dx, x + dy+3, y + height - 1);
+		} else {
+		    gdk_draw_point (window, gc1, x+1 + dy, y+1 + dx);
+                    gdk_draw_line (window, gc1, x + dy, y + 2 + dx, x + dy, y + height - 3);
+                    gdk_draw_point (window, gc1, x+1 + dy, y +height-2);
+		}
+                    break;
+            }
+    }
+
+    if(area)
+    {
+        gdk_gc_set_clip_rectangle(gc1, NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->blue_gc[3], NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->blue_gc[4], NULL);
+    }
+}
+
+static void draw_slider(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkOrientation orientation)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  GtkAdjustment *adj; 
+  gboolean is_horizontal;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    sanitize_size(window, &width, &height);
+
+    orientation = GTK_ORIENTATION_HORIZONTAL;
+    if(height > width)
+        orientation = GTK_ORIENTATION_VERTICAL;
+    
+
+    /* Make sure stepper and slider outlines "overlap" */
+      if (widget && GTK_IS_RANGE (widget))
+    {
+      adj = GTK_RANGE (widget)->adjustment;
+
+      if (adj->value <= adj->lower &&
+	  (GTK_RANGE (widget)->has_stepper_a ||
+	   GTK_RANGE (widget)->has_stepper_b))
+	{
+	  if (GTK_IS_VSCROLLBAR (widget))
+	    {
+	      height += 1;
+	      y -= 1;
+	    }
+	  else if (GTK_IS_HSCROLLBAR (widget))
+	    {
+	      width += 1;
+	      x -= 1;
+	    }
+	}
+      if (adj->value >= adj->upper - adj->page_size &&
+	  (GTK_RANGE (widget)->has_stepper_c ||
+	   GTK_RANGE (widget)->has_stepper_d))
+	{
+	  if (GTK_IS_VSCROLLBAR (widget))
+	    {
+	      height += 1;
+	    }
+	  else if (GTK_IS_HSCROLLBAR (widget))
+	    {
+	      width += 1;
+	    }
+	}
+    }
+
+    is_horizontal = orientation == GTK_ORIENTATION_HORIZONTAL;
+
+
+    if (DETAIL ("slider")) { /* this is for scrollbar */
+     adj = GTK_RANGE (widget)->adjustment;
+    	ia_ora_draw_double_gradient_bar(style, window, state_type, shadow_type, area, widget, detail, x+1, y+1, width-1-!is_horizontal, height-1-is_horizontal, orientation, adj->value > adj->lower, adj->value < adj->upper - adj->page_size);
+    } 
+    else { if (DETAIL("hscale") || DETAIL("vscale")) {
+  	GdkGC *top_gc, *bottom_gc;
+	gboolean is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+
+    	if (state_type == GTK_STATE_PRELIGHT) {
+		top_gc = ia_ora_style->blue_gc[1];
+		bottom_gc = ia_ora_style->blue_gc[2];
+	    }
+	    else {
+		top_gc = ia_ora_style->blue_gc[2];
+		bottom_gc = ia_ora_style->blue_gc[4];
+	    }
+
+        if (area) {
+	      gdk_gc_set_clip_rectangle (top_gc, area);
+	      gdk_gc_set_clip_rectangle (bottom_gc, area);
+	}
+
+	    if (is_horizontal) {
+		    gdk_draw_rectangle (window, top_gc, TRUE, x+1, y+1, width-1, (height-1)/2);
+		    gdk_draw_rectangle (window, bottom_gc, TRUE, x+1, y+(height+1)/2, width-1, (height-1)/2);
+	    } else {
+		    gdk_draw_rectangle (window, is_ltr ? top_gc : bottom_gc , TRUE, x+1, y+1, (width-1) / 2, height-1);
+		    gdk_draw_rectangle (window, is_ltr ? bottom_gc : top_gc, TRUE, x+(width+1)/2, y+1, (width-1)/2, height-1);
+	    }
+
+        if (area) {
+	      gdk_gc_set_clip_rectangle (top_gc, NULL);
+	      gdk_gc_set_clip_rectangle (bottom_gc, NULL);
+	}
+
+    if (area) {
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[4],area);
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5],area);
+    }
+		switch (orientation) {
+		      case GTK_ORIENTATION_HORIZONTAL:
+			      gdk_draw_point (window, ia_ora_style->gray_gc[4],x+1,y+height-2);
+			      gdk_draw_point (window, ia_ora_style->gray_gc[4],x+width-1,y+height-2);
+			      gdk_draw_point (window, ia_ora_style->gray_gc[5],x+1,y+1);
+			      gdk_draw_point (window, ia_ora_style->gray_gc[5],x+width-1,y+1);
+			      break;
+		      case GTK_ORIENTATION_VERTICAL:
+			      gdk_draw_point (window, ia_ora_style->gray_gc[is_ltr ? 5 : 4],x+1,y+1);
+			      gdk_draw_point (window, ia_ora_style->gray_gc[is_ltr ? 4 : 5],x+width-2,y+1);
+			      gdk_draw_point (window, ia_ora_style->gray_gc[is_ltr ? 5 : 4],x+1,y+height-1);
+			      gdk_draw_point (window, ia_ora_style->gray_gc[is_ltr ? 4 : 5],x+width-2,y+height-1);
+			      break;
+		}
+    if (area) {
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[4],NULL);
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5],NULL);
+    }
+
+	    if (DETAIL ("hscale"))  {
+     		ia_ora_draw_point(ia_ora_style, window, state_type, area, widget, x+width/2-1,y+2, TRUE, FALSE);
+    		}
+	    else if (DETAIL ("vscale")) { 
+     		ia_ora_draw_point(ia_ora_style, window, state_type, area, widget, x+2,y+height/2-1, TRUE, TRUE);
+    		}
+    	}
+    }
+
+}
+
+static void draw_handle(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height, GtkOrientation orientation)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  gboolean is_panel_applet_frame;
+
+    g_return_if_fail(style != NULL);
+    g_return_if_fail(window != NULL);
+
+    sanitize_size(window, &width, &height);
+
+    is_panel_applet_frame = widget && strcmp (g_type_name (G_TYPE_FROM_INSTANCE (widget)), "PanelAppletFrame") == 0;
+
+    if (DETAIL ("dockitem") || is_panel_applet_frame) {
+      /* Work around orientation bugs */
+      if (orientation == GTK_ORIENTATION_VERTICAL) {
+	orientation = GTK_ORIENTATION_HORIZONTAL;
+      }
+      else {
+	orientation = GTK_ORIENTATION_VERTICAL;
+      }
+    }
+
+    if (DETAIL ("paned") || is_panel_applet_frame) {
+      gtk_style_apply_default_background(style, window, TRUE, state_type, 
+					 area, x, 
+					 y, 
+					 width, 
+					 height);
+    }
+    else if (DETAIL("handlebox")) {
+    if(area) {
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[0], area);
+      }
+
+	gdk_draw_rectangle (window, ia_ora_style->gray_gc[0], TRUE, x, y, width, height);
+    if(area) {
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[0], NULL);
+      }
+
+    }
+    else {
+      }
+
+  if (is_panel_applet_frame) {
+	  ia_ora_draw_round_rectangle(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+  else
+if (!DETAIL ("paned")) {
+    if(area) {
+	gdk_gc_set_clip_rectangle (style->white_gc, area);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[3], area);
+      }
+      gdk_draw_line (window, ia_ora_style->gray_gc[3], x,y+height-1,
+		     x+width-1,y+height-1);
+      gdk_draw_line (window, style->white_gc, x,y,x+width-1,y);
+
+      if(area) {
+	gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+	gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[3], NULL);
+      }
+    }
+    ia_ora_draw_handlers(style, window, state_type, area, widget, x, y, width, height, orientation);
+
+}
+
+
+static void
+draw_resize_grip (GtkStyle       *style,
+		  GdkWindow      *window,
+		  GtkStateType    state_type,
+		  GdkRectangle   *area,
+		  GtkWidget      *widget,
+		  const gchar    *detail,
+		  GdkWindowEdge   edge,
+		  gint            x,
+		  gint            y,
+		  gint            width,
+		  gint            height)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  cairo_t *cr;
+  cairo_matrix_t matrix;
+  gboolean drawn = FALSE;
+
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (window != NULL);
+
+  width -= 1;
+  height -= 1;
+
+
+  switch (edge) {
+   case GDK_WINDOW_EDGE_NORTH_WEST:
+      /* make it square */
+      if (width < height)
+	{
+	  height = width;
+	}
+      else if (height < width)
+	{
+	  width = height;
+	}
+      break;
+    case GDK_WINDOW_EDGE_NORTH:
+      if (width < height)
+	{
+	  height = width;
+	}
+      break;
+    case GDK_WINDOW_EDGE_NORTH_EAST:
+      /* make it square, aligning to top right */
+      if (width < height)
+	{
+	  height = width;
+	}
+      else if (height < width)
+	{
+	  x += (width - height);
+	  width = height;
+	}
+      break;
+    case GDK_WINDOW_EDGE_WEST:
+      if (height < width)
+	{
+	   width = height;
+	}
+      break;
+    case GDK_WINDOW_EDGE_EAST:
+      /* aligning to right */
+      if (height < width)
+	{
+	  x += (width - height);
+	  width = height;
+	}
+      break;
+    case GDK_WINDOW_EDGE_SOUTH_WEST:
+      /* make it square, aligning to bottom left */
+      if (width < height)
+	{
+	  y += (height - width);
+	  height = width;
+	}
+      else if (height < width)
+	{
+	  width = height;
+	}
+      break;
+    case GDK_WINDOW_EDGE_SOUTH:
+      /* align to bottom */
+      if (width < height)
+	{
+	  y += (height - width);
+	  height = width;
+	}
+      break;
+    case GDK_WINDOW_EDGE_SOUTH_EAST:
+      /* make it square, aligning to bottom right */
+      if (width < height)
+	{
+	  y += (height - width);
+	  height = width;
+	}
+      else if (height < width)
+	{
+	  x += (width - height);
+	  width = height;
+	}
+      x+=3;
+      y+=2;
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+
+  /* Clear background */
+  gtk_style_apply_default_background (style, window, FALSE,
+				      state_type, area,
+				      x, y, width, height);   
+
+  cr = gdk_cairo_create (window);
+
+   cairo_set_line_width (cr, 1);
+  cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+
+
+	cairo_matrix_init_translate(&matrix, 0, 0.5);
+       cairo_transform (cr, &matrix);
+
+
+  switch (edge) {
+    case GDK_WINDOW_EDGE_WEST:
+    case GDK_WINDOW_EDGE_EAST:
+      {
+	gint xi;
+
+	xi = x;
+
+  if (area)
+    {
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], area);
+      gdk_gc_set_clip_rectangle (style->white_gc, area);
+    }
+	while (xi < x + width)
+	  {
+	    gdk_draw_line (window,
+			   style->white_gc,
+			   xi, y,
+			   xi, y + height);
+
+	    xi++;
+	    gdk_draw_line (window,
+			   ia_ora_style->gray_gc[5],
+			   xi, y,
+			   xi, y + height);
+
+	    xi += 2;
+	  }
+	drawn = TRUE;
+      }
+      break;
+    case GDK_WINDOW_EDGE_NORTH:
+    case GDK_WINDOW_EDGE_SOUTH:
+      {
+	gint yi;
+
+	yi = y;
+
+  if (area)
+    {
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], area);
+      gdk_gc_set_clip_rectangle (style->white_gc, area);
+    }
+	while (yi < y + height)
+	  {
+	    gdk_draw_line (window,
+			   style->white_gc,
+			   x, yi,
+			   x + width, yi);
+
+	    yi++;
+	    gdk_draw_line (window,
+			   ia_ora_style->gray_gc[5],
+			   x, yi,
+			   x + width, yi);
+
+	    yi+= 2;
+	  }
+	drawn = TRUE;
+      }
+      break;
+    case GDK_WINDOW_EDGE_SOUTH_EAST:
+      break;
+    case GDK_WINDOW_EDGE_SOUTH_WEST:
+      cairo_matrix_init(&matrix, -1,0,0,1,2*x+width-0.5-1,2);
+      cairo_transform (cr, &matrix);
+      break; 
+    case GDK_WINDOW_EDGE_NORTH_WEST:
+      cairo_matrix_init(&matrix, -1,0,0,-1,2*x+width,2*y+height);
+      cairo_transform (cr, &matrix);
+      break; 
+    case GDK_WINDOW_EDGE_NORTH_EAST:
+      cairo_matrix_init(&matrix, 1,0,0,-1,0,2*y+height);
+      cairo_transform (cr, &matrix);
+      break; 
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+   if (!drawn) {
+  if (area)
+    {
+      gdk_cairo_rectangle (cr, area);
+      cairo_clip (cr);
+    }
+
+   gdk_cairo_set_source_color (cr, &ia_ora_style->blue[3]);
+      cairo_move_to (cr, x,              y + height);
+      cairo_line_to (cr, x + width,      y);
+      cairo_line_to (cr, x + width,      y+height);
+  cairo_close_path (cr);
+  cairo_fill (cr);
+   gdk_cairo_set_source_color (cr, &ia_ora_style->blue[2]);
+      cairo_move_to (cr, x+width,              y);
+      cairo_line_to (cr, x + 3,      y+height-3);
+      cairo_line_to (cr, x + 6,      y+height-3);
+      cairo_line_to (cr, x+6,              y+height-4);
+      cairo_line_to (cr, x + 9,      y+height-4);
+      cairo_line_to (cr, x+ 10,              y+height-5);
+      cairo_line_to (cr, x + 11,      y+height-5);
+      cairo_line_to (cr, x + width - 1,      y+height-9);
+      cairo_line_to (cr, x + width - 1,      y+1);
+  cairo_fill (cr);
+  
+      cairo_move_to (cr, x + width-1 , y+1);
+      cairo_line_to (cr, x + width , y+1);
+      cairo_stroke_preserve(cr);
+      cairo_move_to (cr, x+width-3, y+height);
+      cairo_line_to (cr, x+width, y+height-3);
+      cairo_line_to (cr, x+width, y+height);
+      cairo_line_to (cr, x+width-3, y+height);
+      cairo_fill (cr);
+
+  cairo_destroy (cr);
+    }
+   else {
+
+    if (area) {
+      gdk_gc_set_clip_rectangle (ia_ora_style->gray_gc[5], NULL);
+      gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+    }
+  }
+}
+
+static gboolean
+is_combo_box_entry (GtkWidget * widget)
+{
+	gboolean result = FALSE;
+	
+	if (widget && widget->parent)
+	{
+		if (GTK_IS_COMBO_BOX_ENTRY (widget))
+			result = TRUE;
+		else
+			result = is_combo_box_entry(widget->parent);
+	}
+	
+	return result;
+}
+
+static gboolean
+is_combo_box (GtkWidget * widget)
+{
+	gboolean result = FALSE;
+	
+	if (widget && widget->parent)
+	{
+		if (GTK_IS_COMBO_BOX (widget))
+			result = TRUE;
+		else
+			result = is_combo_box (widget->parent);
+	}
+	
+	return result;
+}
+
+static gboolean
+is_deprecated_combo(GtkWidget * widget)
+{
+	gboolean result = FALSE;
+	
+	if (widget && widget->parent)
+	{
+		if (GTK_IS_COMBO(widget))
+			result = TRUE;
+		else
+			result = is_deprecated_combo(widget->parent);
+	}
+	
+	return result;
+}
+
+static void
+calculate_arrow_geometry (GtkArrowType  arrow_type,
+			  gint         *x,
+			  gint         *y,
+			  gint         *width,
+			  gint         *height)
+{
+  gint w = *width;
+  gint h = *height;
+  
+  switch (arrow_type)
+    {
+    case GTK_ARROW_UP:
+    case GTK_ARROW_DOWN:
+      w += (w % 2) - 1;
+      h = (w / 2 + 1);
+      
+      if (h > *height)
+	{
+	  h = *height;
+	  w = 2 * h - 1;
+	}
+      
+      if (arrow_type == GTK_ARROW_DOWN)
+	{
+	  if (*height % 2 == 1 || h % 2 == 0)
+	    *height += 1;
+	}
+      else
+	{
+	  if (*height % 2 == 0 || h % 2 == 0)
+	    *height -= 1;
+	}
+      break;
+
+    case GTK_ARROW_RIGHT:
+    case GTK_ARROW_LEFT:
+      h += (h % 2) - 1;
+      w = (h / 2 + 1);
+      
+      if (w > *width)
+	{
+	  w = *width;
+	  h = 2 * w - 1;
+	}
+      
+      if (arrow_type == GTK_ARROW_RIGHT)
+	{
+	  if (*width % 2 == 1 || w % 2 == 0)
+	    *width += 1;
+	}
+      else
+	{
+	  if (*width % 2 == 0 || w % 2 == 0)
+	    *width -= 1;
+	}
+      break;
+      
+    default:
+      /* should not be reached */
+      break;
+    }
+
+  *x += (*width - w) / 2;
+  *y += (*height - h) / 2;
+  *height = h;
+  *width = w;
+}
+
+static void draw_arrow (GtkStyle      *style,
+			GdkWindow     *window,
+			GtkStateType   state,
+			GtkShadowType  shadow,
+			GdkRectangle  *area,
+			GtkWidget     *widget,
+			const gchar   *detail,
+			GtkArrowType   arrow_type,
+			gboolean       fill,
+			gint           x,
+			gint           y,
+			gint           width,
+			gint           height) {
+  gboolean combo_box, combo_box_entry, is_deprecated;
+  gint i, j;
+  gboolean is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+
+    if (area) {
+      gdk_gc_set_clip_rectangle (style->fg_gc[state], area);
+    }
+
+  if (DETAIL ("spinbutton")) {
+	 width += 1;
+	 height += 1;
+	 if (arrow_type == GTK_ARROW_DOWN)
+ 	    y +=1;
+
+  }
+  combo_box_entry = is_combo_box_entry(widget);
+  combo_box = is_combo_box(widget);
+  is_deprecated = is_deprecated_combo (widget);
+
+  if (combo_box_entry) {
+	  width += 3;
+	  y -= 1;
+	  x -= 1;
+  }
+
+  if (combo_box || combo_box_entry || is_deprecated) {
+    if (combo_box || is_deprecated) {
+	  width -= 1;
+	  height-= 1;
+    }
+
+    if (combo_box && !combo_box_entry) {
+	if (is_ltr) {
+		x += 1;
+	 }
+	else {
+		x -= 1;
+	}
+    }
+    /* same design as KDE arrow, add a line */
+    x += 1;
+    y += 2;
+    gdk_draw_line (window, style->fg_gc[state],x,y,x+width-(2-width%2),y);
+    if (combo_box_entry || combo_box) {
+	y += 1;
+    }
+  }
+
+
+  sanitize_size (window, &width, &height);
+
+  calculate_arrow_geometry (arrow_type, &x, &y, &width, &height);
+
+  if (detail && strcmp (detail, "menu_scroll_arrow_up") == 0)
+    y++;
+
+  if (arrow_type == GTK_ARROW_DOWN)
+    {
+      for (i = 0, j = 0; i < height; i++, j++)
+	gdk_draw_line (window, style->fg_gc[state], x + j, y + i, x + width - j - 1, y + i);
+    }
+  else if (arrow_type == GTK_ARROW_UP)
+    {
+      for (i = height - 1, j = 0; i >= 0; i--, j++)
+	gdk_draw_line (window, style->fg_gc[state], x + j, y + i, x + width - j - 1, y + i);
+    }
+  else if (arrow_type == GTK_ARROW_LEFT)
+    {
+      for (i = width - 1, j = 0; i >= 0; i--, j++)
+	gdk_draw_line (window, style->fg_gc[state], x + i, y + j, x + i, y + height - j - 1);
+    }
+  else if (arrow_type == GTK_ARROW_RIGHT)
+    {
+      for (i = 0, j = 0; i < width; i++, j++)
+	gdk_draw_line (window, style->fg_gc[state], x + i, y + j, x + i, y + height - j - 1);
+    }
+
+
+    if (area) {
+      gdk_gc_set_clip_rectangle (style->fg_gc[state], NULL);
+    }
+
+}
+
+
+static void 
+draw_tab (GtkStyle      *style,
+	     GdkWindow     *window,
+	     GtkStateType   state_type,
+	     GtkShadowType  shadow_type,
+	     GdkRectangle  *area,
+	     GtkWidget     *widget,
+	     const gchar   *detail,
+	     gint           x,
+	     gint           y,
+	     gint           width,
+	     gint           height)
+{
+
+  if (DETAIL ("optionmenutab")) {
+      y += 1;
+  }
+  ia_ora_parent_class->draw_tab (style, window, state_type, shadow_type, area,
+			  widget, detail, x, y, width, height);
+    
+}
+
+static void
+draw_expander (GtkStyle        *style,
+               GdkWindow       *window,
+               GtkStateType     state_type,
+               GdkRectangle    *area,
+               GtkWidget       *widget,
+               const gchar     *detail,
+               gint             x,
+               gint             y,
+	       GtkExpanderStyle expander_style) 
+{
+  GtkStyle *style_copy;
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+
+  style_copy = gtk_style_copy (style);
+
+  style_copy->fg[GTK_STATE_NORMAL] = style_copy->bg[GTK_STATE_SELECTED];
+  style_copy->fg[GTK_STATE_PRELIGHT] = style_copy->bg[GTK_STATE_SELECTED];
+  style_copy->light[GTK_STATE_ACTIVE] = ia_ora_style->blue[4];
+  style_copy->fg[GTK_STATE_ACTIVE] = ia_ora_style->blue[4];
+
+  ia_ora_parent_class->draw_expander (style_copy, window, state_type, area,
+			  widget, detail, x, y, expander_style);
+
+  gtk_style_unref (style_copy);
+    
+}
+
+
+
+static GdkPixbuf*
+scale_or_ref (GdkPixbuf *src,
+              int width,
+              int height)
+{
+	if (width == gdk_pixbuf_get_width (src) &&
+	    height == gdk_pixbuf_get_height (src)) {
+		return g_object_ref (src);
+	} else {
+		return gdk_pixbuf_scale_simple (src,
+						width, height,
+						GDK_INTERP_BILINEAR);
+	}
+}
+
+static GdkPixbuf *
+set_transparency (const GdkPixbuf *pixbuf, gdouble alpha_percent)
+{
+	GdkPixbuf *target;
+	guchar *data, *current;
+	guint x, y, rowstride, height, width;
+
+	g_return_val_if_fail (pixbuf != NULL, NULL);
+	g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
+
+	/* Returns a copy of pixbuf with it's non-completely-transparent pixels to
+	   have an alpha level "alpha_percent" of their original value. */
+
+	target = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+
+	if (alpha_percent == 1.0)
+		return target;
+	width = gdk_pixbuf_get_width (target);
+	height = gdk_pixbuf_get_height (target);
+	rowstride = gdk_pixbuf_get_rowstride (target);
+	data = gdk_pixbuf_get_pixels (target);
+
+	for (y = 0; y < height; y++) {
+		for (x = 0; x < width; x++) {
+			/* The "4" is the number of chars per pixel, in this case, RGBA,
+			   the 3 means "skip to the alpha" */
+			current = data + (y * rowstride) + (x * 4) + 3; 
+			*(current) = (guchar) (*(current) * alpha_percent);
+		}
+	}
+
+	return target;
+}
+
+
+static GdkPixbuf *
+render_icon (GtkStyle            *style,
+	     const GtkIconSource *source,
+	     GtkTextDirection     direction,
+	     GtkStateType         state,
+	     GtkIconSize          size,
+	     GtkWidget           *widget,
+	     const char          *detail)
+{
+	int width = 1;
+	int height = 1;
+	GdkPixbuf *scaled;
+	GdkPixbuf *stated;
+	GdkPixbuf *base_pixbuf;
+	GdkScreen *screen;
+	GtkSettings *settings;
+	
+	/* Oddly, style can be NULL in this function, because
+	 * GtkIconSet can be used without a style and if so
+	 * it uses this function.
+	 */
+	
+	base_pixbuf = gtk_icon_source_get_pixbuf (source);
+	
+	g_return_val_if_fail (base_pixbuf != NULL, NULL);
+	
+	if (widget && gtk_widget_has_screen (widget)) {
+		screen = gtk_widget_get_screen (widget);
+		settings = gtk_settings_get_for_screen (screen);
+	} else if (style->colormap) {
+		screen = gdk_colormap_get_screen (style->colormap);
+		settings = gtk_settings_get_for_screen (screen);
+	} else {
+		settings = gtk_settings_get_default ();
+		GTK_NOTE (MULTIHEAD,
+			  g_warning ("Using the default screen for gtk_default_render_icon()"));
+	}
+	
+  
+	if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
+		g_warning (G_STRLOC ": invalid icon size '%d'", size);
+		return NULL;
+	}
+
+	/* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
+	 * leave it alone.
+	 */
+	if (size != (GtkIconSize)-1 && gtk_icon_source_get_size_wildcarded (source))
+		scaled = scale_or_ref (base_pixbuf, width, height);
+	else
+		scaled = g_object_ref (base_pixbuf);
+	
+	/* If the state was wildcarded, then generate a state. */
+	if (gtk_icon_source_get_state_wildcarded (source)) {
+		if (state == GTK_STATE_INSENSITIVE) {
+			stated = set_transparency (scaled, 0.3);
+			gdk_pixbuf_saturate_and_pixelate (stated, stated,
+							  0.1, FALSE);
+			
+			g_object_unref (scaled);
+		} else if (state == GTK_STATE_PRELIGHT) {
+			stated = gdk_pixbuf_copy (scaled);      
+			
+			gdk_pixbuf_saturate_and_pixelate (scaled, stated,
+							  1.2, FALSE);
+			
+			g_object_unref (scaled);
+		} else {
+			stated = scaled;
+		}
+	}
+	else
+		stated = scaled;
+  
+  return stated;
+}
+
+
+static GdkGC *
+realize_color (GtkStyle * style,
+	       GdkColor * color)
+{
+  GdkGCValues gc_values;
+
+  gdk_colormap_alloc_color (style->colormap, color,
+			    FALSE, TRUE);
+
+  gc_values.foreground = *color;
+
+  return gtk_gc_get (style->depth, style->colormap,
+		     &gc_values, GDK_GC_FOREGROUND);
+}
+static GdkPixmap *
+pixbuf_to_pixmap (GtkStyle * style, GdkPixbuf *pixbuf, GdkScreen *screen)
+{
+  GdkGC *tmp_gc;
+  GdkPixmap *pixmap;
+  
+  pixmap = gdk_pixmap_new (gdk_screen_get_root_window (screen),
+			   gdk_pixbuf_get_width (pixbuf),
+			   gdk_pixbuf_get_height (pixbuf),
+			   style->depth);
+  gdk_drawable_set_colormap (pixmap, style->colormap);
+
+  tmp_gc = gdk_gc_new (pixmap);
+  
+  gdk_pixbuf_render_to_drawable (pixbuf, pixmap, tmp_gc, 0, 0, 0, 0,
+				 gdk_pixbuf_get_width (pixbuf),
+				 gdk_pixbuf_get_height (pixbuf),
+				 GDK_RGB_DITHER_NORMAL, 0, 0);
+  g_object_unref (tmp_gc);
+
+  return pixmap;
+}
+
+static
+void ensure_radio_pixmaps (GtkStyle     *style,
+			   GtkStateType  state,
+			   GtkWidget *widget)
+{ 
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  GdkPixbuf *circle, *outline, *composite;
+  GdkColor *composite_color;  
+  GdkScreen *screen;
+  unsigned int i;
+  gboolean is_ltr;
+
+  if (ia_ora_style->radio_pixmap_circle[state] != NULL)
+    return;
+
+  screen = gtk_widget_get_screen (widget);
+  is_ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR;
+
+  outline = generate_bit (outline_alpha, &ia_ora_style->gray[4], 1.0);
+
+  if (!is_ltr) {
+	  GdkPixbuf *tmp_pixbuf;
+
+	  tmp_pixbuf = gdk_pixbuf_flip (outline, TRUE);
+	  g_object_unref (outline);
+	  outline = tmp_pixbuf;
+  }
+
+  if (ia_ora_style->radio_pixmap_mask == NULL) {
+    gdk_pixbuf_render_pixmap_and_mask (outline,
+   				       NULL,
+				       &ia_ora_style->radio_pixmap_mask,
+				       1);
+  }
+  
+  for (i = 0; i < G_N_ELEMENTS(ia_ora_style->radio_pixmap_circle); i++)
+    {
+      if (i == GTK_STATE_ACTIVE)
+	{
+	  composite_color = &style->bg[GTK_STATE_PRELIGHT];
+	  circle = generate_bit (circle_alpha, &style->bg[i], 1.0);
+	}   
+      else
+	{
+	  composite_color = &style->bg[i];
+	  circle = generate_bit (circle_alpha, &style->white, 1.0);
+	}
+
+      composite = generate_bit (NULL, composite_color, 1.0);
+      if (!is_ltr) {
+	  GdkPixbuf *tmp_pixbuf;
+
+	  tmp_pixbuf = gdk_pixbuf_flip (circle, TRUE);
+	  g_object_unref (circle);
+	  circle = tmp_pixbuf;
+
+	  tmp_pixbuf = gdk_pixbuf_flip (composite, TRUE);
+	  g_object_unref (composite);
+	  composite = tmp_pixbuf;
+      }
+
+
+      gdk_pixbuf_composite (outline, composite,
+			    0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
+			    1.0, 1.0, GDK_INTERP_NEAREST, 255);
+      gdk_pixbuf_composite (circle, composite,
+			    0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
+			    1.0, 1.0, GDK_INTERP_NEAREST, 255);
+
+      ia_ora_style->radio_pixmap_circle[i] = pixbuf_to_pixmap (style, composite, screen);
+      
+      g_object_unref (composite);
+      g_object_unref (circle);
+    }
+  g_object_unref (outline);
+	
+}
+
+static void ia_ora_style_init_from_rc (GtkStyle* style, GtkRcStyle * rc_style)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  char *colorname;
+  unsigned int i;
+ /*double shading[] = {1.036875969, 1.0 , 0.893708749, 0.822125139,
+		      0.74403433, 0.71800443, 0.646420819,0.587006644};*/
+  ia_ora_parent_class->init_from_rc (style, rc_style);
+
+  for (i=0 ; i<G_N_ELEMENTS(ia_ora_style->gray); i++) {
+   colorname = g_strdup_printf("gray%d",i);
+   gtk_style_lookup_color (style, colorname, &ia_ora_style->gray[i]);
+   g_free (colorname);
+  }
+   
+
+  for (i=0 ; i<G_N_ELEMENTS(ia_ora_style->blue); i++) {
+   colorname = g_strdup_printf("blue%d",i);
+   gtk_style_lookup_color (style, colorname, &ia_ora_style->blue[i]);
+   g_free (colorname);
+  }
+
+/*  for (i=0; i<G_N_ELEMENTS (ia_ora_style->gray); i++) {
+    shade(&style->bg[GTK_STATE_NORMAL],&ia_ora_style->gray[i],shading[i]);
+  }*/
+
+
+
+/*
+  ia_ora_style->blue[2].red = style->base[GTK_STATE_SELECTED].red;
+  ia_ora_style->blue[2].green = style->base[GTK_STATE_SELECTED].green;
+  ia_ora_style->blue[2].blue = style->base[GTK_STATE_SELECTED].blue;
+
+  ia_ora_style->blue[0].red = style->base[GTK_STATE_ACTIVE].red;
+  ia_ora_style->blue[0].green = style->base[GTK_STATE_ACTIVE].green;
+  ia_ora_style->blue[0].blue = style->base[GTK_STATE_ACTIVE].blue;
+
+
+  shade(&style->base[GTK_STATE_SELECTED],&ia_ora_style->blue[1],1.204945256);*/
+
+  shade(&style->white,&ia_ora_style->check_color,0.2);
+
+}
+
+static void ia_ora_style_realize(GtkStyle * style)
+{
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+ 
+  unsigned int i;
+
+  ia_ora_parent_class->realize (style);
+
+  ia_ora_style->check_gc = realize_color (style, &ia_ora_style->check_color);
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_style->gray_gc) ; i++) {
+    ia_ora_style->gray_gc[i] = realize_color (style, &ia_ora_style->gray[i]);
+  }
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_style->blue_gc) ; i++) {
+    ia_ora_style->blue_gc[i] = realize_color (style, &ia_ora_style->blue[i]);
+  }
+}
+
+static void
+ia_ora_style_copy (GtkStyle * style, GtkStyle * src)
+{
+  Ia_OraStyle * ia_ora_style = IA_ORA_STYLE (style);
+  Ia_OraStyle * ia_ora_src = IA_ORA_STYLE (src);
+  unsigned int i;
+
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_src->gray) ; i++) {
+    ia_ora_style->gray[i] = ia_ora_src->gray[i];
+  }
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_src->blue) ; i++) {
+    ia_ora_style->blue[i] = ia_ora_src->blue[i];
+  }
+
+  ia_ora_style->check_color = ia_ora_src->check_color;
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_src->gray_gc) ; i++) {
+    if (ia_ora_src->gray_gc[i]) {
+      ia_ora_style->gray_gc[i] = g_object_ref (ia_ora_src->gray_gc[i]);
+    }
+  }
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_src->blue_gc) ; i++) {
+    if (ia_ora_src->blue_gc[i]) {
+      ia_ora_style->blue_gc[i] = g_object_ref (ia_ora_src->blue_gc[i]);
+    }
+  }
+
+  if (ia_ora_src->check_gc) {
+    ia_ora_style->check_gc = g_object_ref (ia_ora_src->check_gc);
+  }
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_src->radio_pixmap_circle) ; i++) {
+	  if (ia_ora_src->radio_pixmap_circle[i])
+    		ia_ora_style->radio_pixmap_circle[i] = g_object_ref (ia_ora_src->radio_pixmap_circle[i]);
+  }
+
+  if (ia_ora_src->radio_pixmap_mask)
+	  ia_ora_style->radio_pixmap_mask = g_object_ref (ia_ora_src->radio_pixmap_mask);
+
+  ia_ora_parent_class->copy (style, src);
+}
+
+
+static void ia_ora_style_unrealize(GtkStyle * style)
+{  
+  Ia_OraStyle *ia_ora_style = IA_ORA_STYLE (style);
+  unsigned int i;
+
+  /* We don't free the colors, because we don't know if
+   * gtk_gc_release() actually freed the GC. FIXME - need
+   * a way of ref'ing colors explicitely so GtkGC can
+   * handle things properly.
+   */
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_style->gray_gc) ; i++) {
+    gtk_gc_release (ia_ora_style->gray_gc[i]);
+  }
+
+  for (i=0; i < G_N_ELEMENTS(ia_ora_style->blue_gc) ; i++) {
+    gtk_gc_release (ia_ora_style->blue_gc[i]);
+  }
+
+  for (i = 0; i < G_N_ELEMENTS(ia_ora_style->radio_pixmap_circle); i++) {
+    if (ia_ora_style->radio_pixmap_circle[i] != NULL) {
+      g_object_unref (ia_ora_style->radio_pixmap_circle[i]);
+      ia_ora_style->radio_pixmap_circle[i] = NULL;
+    }
+  }
+
+  gtk_gc_release (ia_ora_style->check_gc);
+
+  if (ia_ora_style->radio_pixmap_mask != NULL) {
+    g_object_unref (ia_ora_style->radio_pixmap_mask);
+  }
+  ia_ora_style->radio_pixmap_mask = NULL;
+
+  ia_ora_parent_class->unrealize (style);
+}
+
+static void ia_ora_style_class_init(Ia_OraStyleClass * klass)
+{
+    GtkStyleClass *style_class = GTK_STYLE_CLASS(klass);
+
+    ia_ora_parent_class = g_type_class_peek_parent(klass);
+
+    style_class->init_from_rc = ia_ora_style_init_from_rc;
+    style_class->realize = ia_ora_style_realize;
+    style_class->copy = ia_ora_style_copy;
+    style_class->unrealize = ia_ora_style_unrealize;
+
+    style_class->draw_hline = draw_hline;
+    style_class->draw_vline = draw_vline;
+    style_class->draw_shadow = draw_shadow;
+    style_class->draw_box = draw_box;
+    style_class->draw_flat_box = draw_flat_box;
+    style_class->draw_check = draw_check;
+    style_class->draw_option = draw_option;
+    style_class->draw_shadow_gap = draw_shadow_gap;
+    style_class->draw_box_gap = draw_box_gap;
+    style_class->draw_extension = draw_extension;
+    style_class->draw_slider = draw_slider;
+    style_class->draw_handle = draw_handle;
+    style_class->draw_resize_grip = draw_resize_grip;
+    style_class->draw_arrow = draw_arrow;
+    style_class->draw_tab = draw_tab;
+    style_class->draw_expander = draw_expander;
+    style_class->render_icon = render_icon;
+}
+
+
+static void
+ia_ora_style_init (Ia_OraStyle * style)
+{
+}
+
+GType ia_ora_type_style = 0;
+
+void ia_ora_style_register_type(GTypeModule * module)
+{
+    static const GTypeInfo object_info = {
+        sizeof(Ia_OraStyleClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) ia_ora_style_class_init,
+        NULL,                   /* class_finalize */
+        NULL,                   /* class_data */
+        sizeof(Ia_OraStyle),
+        0,                      /* n_preallocs */
+        (GInstanceInitFunc) ia_ora_style_init,
+	NULL
+    };
+
+    ia_ora_type_style = g_type_module_register_type(module, GTK_TYPE_STYLE, 
+						    "Ia_OraStyle", 
+						    &object_info, 0);
+}
+
diff --git a/src/gtk/engine/ia_ora_theme_main.c b/src/gtk/engine/ia_ora_theme_main.c
new file mode 100644
index 0000000..5840187
--- /dev/null
+++ b/src/gtk/engine/ia_ora_theme_main.c
@@ -0,0 +1,54 @@
+/*  Ia Ora theme
+ *  Copyright (C) 2006 Frederic Crozat - Mandriva
+ *  1999 Olivier Fourdan (fourdan@xfce.org) for XFCE code
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#include <gmodule.h>
+#include <gtk/gtk.h>
+#include "ia_ora_rc_style.h"
+#include "ia_ora_style.h"
+
+
+G_MODULE_EXPORT void theme_init(GTypeModule * module)
+{
+    ia_ora_rc_style_register_type(module);
+    ia_ora_style_register_type(module);
+}
+
+G_MODULE_EXPORT void theme_exit(void)
+{
+}
+
+G_MODULE_EXPORT GtkRcStyle *theme_create_rc_style(void)
+{
+    return GTK_RC_STYLE(g_object_new(IA_ORA_TYPE_RC_STYLE, NULL));
+}
+
+/* The following function will be called by GTK+ when the module
+ * is loaded and checks to see if we are compatible with the
+ * version of GTK+ that loads us.
+ */
+/*
+G_MODULE_EXPORT const gchar* g_module_check_init (GModule *module);
+const gchar*
+g_module_check_init (GModule *module)
+{
+  return gtk_check_version (GTK_MAJOR_VERSION,
+			    GTK_MINOR_VERSION,
+			    GTK_MICRO_VERSION - GTK_INTERFACE_AGE);
+}
+*/
diff --git a/src/gtk/styles/CMakeLists.txt b/src/gtk/styles/CMakeLists.txt
new file mode 100644
index 0000000..954d2eb
--- /dev/null
+++ b/src/gtk/styles/CMakeLists.txt
@@ -0,0 +1,6 @@
+foreach( THEME orange blue gray arctic smooth night steel )
+  install(
+    FILES "${THEME}/gtkrc"
+    DESTINATION "${INSTALL_PATH_GTK_THEMES}/Ia Ora ${THEME}/gtk-2.0"
+  )
+endforeach()
\ No newline at end of file
diff --git a/src/gtk/styles/arctic/gtkrc b/src/gtk/styles/arctic/gtkrc
new file mode 100644
index 0000000..cced838
--- /dev/null
+++ b/src/gtk/styles/arctic/gtkrc
@@ -0,0 +1,169 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#8EC7FF\nselected_fg_color:#000\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# arctic
+    color["blue0"]= mix(0.1, @selected_bg_color, "#F8F8F8") # "#EFF7FF"
+    color["blue1"]= mix(0.4, @selected_bg_color, "#E8ECF8") # "#C7DFFF"
+    color["blue2"]= @selected_bg_color # "#8EC7FF"
+    color["blue3"]= mix(0.5, @selected_bg_color, "#70B0F8")  # "#79BEFF"
+    color["blue4"]= mix(0.5, @selected_bg_color, "#50A0F8") # "#69B6FF"
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {
+       black_check=TRUE
+    }
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"
diff --git a/src/gtk/styles/blue/gtkrc b/src/gtk/styles/blue/gtkrc
new file mode 100644
index 0000000..9d8e458
--- /dev/null
+++ b/src/gtk/styles/blue/gtkrc
@@ -0,0 +1,166 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#4965AE\nselected_fg_color:#fff\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# blue
+    color["blue0"]= mix(0.3, @selected_bg_color, "#C8D8F8") # "#A6B6E7" 
+    color["blue1"]= mix(0.5, @selected_bg_color, "#C8E0E8") #"#8EA2CF"
+    color["blue2"]= @selected_bg_color # "#4965AE"
+    color["blue3"]= mix(0.5, @selected_bg_color, "#405595")  #"#415DA6"
+    color["blue4"]= mix(0.5, @selected_bg_color, "#012888") #"#21459C"
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {}
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"
diff --git a/src/gtk/styles/gray/gtkrc b/src/gtk/styles/gray/gtkrc
new file mode 100644
index 0000000..3fb5d76
--- /dev/null
+++ b/src/gtk/styles/gray/gtkrc
@@ -0,0 +1,169 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#C7D3DF\nselected_fg_color:#000\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# pwp+
+    color["blue0"]= mix(0.3, @selected_bg_color, "#E8ECF0") # gray1 #DFE7EF
+    color["blue1"]= mix(0.5, @selected_bg_color, "#C8D8D0") # gray2 #CFD7DF
+    color["blue2"]= @selected_bg_color # gray3 #C7D3DF
+    color["blue3"]= mix(0.5, @selected_bg_color, "#8090A0") # gray5 #A6B2C7 
+    color["blue4"]= mix(0.5, @selected_bg_color, "#405060") # gray6 #8692A6
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {
+       black_check=TRUE
+    }
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"
diff --git a/src/gtk/styles/night/gtkrc b/src/gtk/styles/night/gtkrc
new file mode 100644
index 0000000..a691366
--- /dev/null
+++ b/src/gtk/styles/night/gtkrc
@@ -0,0 +1,166 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#5D658E\nselected_fg_color:#fff\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# night
+    color["blue0"]= mix(0.1, @selected_bg_color, "#B5C2F4") # "#ACB9EA" 
+    color["blue1"]= mix(0.5, @selected_bg_color, "#A3B5F3") #"#808DC6"
+    color["blue2"]= @selected_bg_color # "#5D658E"
+    color["blue3"]= mix(0.5, @selected_bg_color, "#1E2440")  #"#3D4467"
+    color["blue4"]= mix(0.3, @selected_bg_color, "#101834") #"#272F4F"
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {}
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"
diff --git a/src/gtk/styles/orange/gtkrc b/src/gtk/styles/orange/gtkrc
new file mode 100644
index 0000000..aa6fe9a
--- /dev/null
+++ b/src/gtk/styles/orange/gtkrc
@@ -0,0 +1,169 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#F7B610\nselected_fg_color:#000\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# orange
+    color["blue0"]= mix(0.3, @selected_bg_color, "#FFF018") # "#FFDF10" 
+    color["blue1"]= mix(0.5, @selected_bg_color, "#FFE018") #"#FFCB10"
+    color["blue2"]= @selected_bg_color # "#F7B610"
+    color["blue3"]= mix(0.5, @selected_bg_color, "#FF9008")  # "#FFA208"
+    color["blue4"]= mix(0.1, @selected_bg_color, "#EF9000") # "#F79600"
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {
+	black_check=TRUE
+    }
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"
diff --git a/src/gtk/styles/smooth/gtkrc b/src/gtk/styles/smooth/gtkrc
new file mode 100644
index 0000000..8ef1b53
--- /dev/null
+++ b/src/gtk/styles/smooth/gtkrc
@@ -0,0 +1,168 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#7BAAE7\nselected_fg_color:#fff\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# smooth
+    color["blue0"] = mix(0.3, @selected_bg_color, "#E8F8FF") # "#cee3ff"
+    color["blue1"] = mix(0.3, @selected_bg_color, "#C0DAFF") # "#adcfff"
+    color["blue2"] = @selected_bg_color # "#7BAAE7"
+    color["blue3"] = mix(0.5, @selected_bg_color, "#396AC5" ) # "#5A8AD6"
+    color["blue4"] = mix(0.5, @selected_bg_color, "#0C50a0") # "#427dc6"
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {
+       black_check=TRUE
+    }
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"
diff --git a/src/gtk/styles/steel/gtkrc b/src/gtk/styles/steel/gtkrc
new file mode 100644
index 0000000..775efe7
--- /dev/null
+++ b/src/gtk/styles/steel/gtkrc
@@ -0,0 +1,167 @@
+# Set GtkSettings color scheme property.
+# This can be overriden (via an xsetting) with eg. the gnome-appearance-properties.
+gtk_color_scheme = "fg_color:#000\nbg_color:#EFF3F7\nbase_color:#fff\ntext_color:#000\nselected_bg_color:#158CCD\nselected_fg_color:#fff\ntooltip_fg_color:#000\ntooltip_bg_color:#FFFF94"
+gtk-auto-mnemonics = 1
+
+style "ia_ora-default"
+{
+
+    color["gray0"]= @bg_color # "#EFF3F7"
+    color["gray1"]= mix(0.5,@bg_color, "#C8D8D8") #"#DFE7EF"
+    color["gray2"]= mix(0.5,@bg_color, "#A8B8B8") #"#CFD7DF"
+    color["gray3"]= mix(0.5,@bg_color, "#90B0B8") # "#C7D3DF"
+    color["gray4"]= mix(0.5,@bg_color, "#709098") # "#B6C3CF"
+    color["gray5"]= mix(0.5,@bg_color, "#507088") # "#A6B2C7"
+    color["gray6"]= mix(0.5,@bg_color, "#183050") #"#8692A6"
+
+# steel
+    color["blue0"]= mix(0.3, @selected_bg_color, "#DEFCEC") # "#A2DBE3"
+    color["blue1"]= mix(0.4, @selected_bg_color, "#55DFD0") # "#3BBECF"
+    color["blue2"]= @selected_bg_color # "#158CCD"
+    color["blue3"]= mix(0.1, @selected_bg_color, "#046B9E")  # "#056EA3"
+    color["blue4"]= mix(0.1, @selected_bg_color, "#092A46") # "#0A3453"
+
+    GtkButton::default-border         = {1, 1, 1, 1}
+    GtkWidget::interior-focus         = 1
+    GtkButton::default-spacing        = 6
+    GtkCheckButton::indicator-size    = 13
+    GtkPaned::handle-size             = 6
+    GtkRange::trough-border           = 0
+    GtkRange::slider-width            = 8
+    GtkRange::stepper-size            = 15
+    GtkRange::stepper-spacing         = 0
+    GtkRange::trough-side-details     = 1
+    GtkScrollbar::min-slider-length   = 20
+    GtkScrollbar::slider-width        = 15
+    GtkScrollbar::trough-side-details     = 0
+    GtkTreeView::even-row-color       = @base_color
+    GtkTreeView::odd-row-color        = @bg_color
+
+    # Glow the tasklist by changing the color, instead of overlaying it with a rectangle
+    WnckTasklist   ::fade-overlay-rect    = 0
+
+
+    fg[NORMAL]        = @fg_color
+    fg[ACTIVE]        = @fg_color
+    fg[INSENSITIVE]   = @gray4
+    fg[PRELIGHT]      = @fg_color
+    fg[SELECTED]      = @selected_fg_color
+
+    bg[NORMAL]        = @bg_color
+    bg[ACTIVE]        = @gray1
+    bg[INSENSITIVE]   = @gray2
+    bg[PRELIGHT]      = @gray1
+    bg[SELECTED]      = @selected_bg_color
+
+    base[NORMAL]      = @base_color
+    base[ACTIVE]      = @blue1
+    base[INSENSITIVE] = @bg_color
+    base[PRELIGHT]    = @base_color
+    base[SELECTED]    = @selected_bg_color
+
+    text[NORMAL]      = @text_color
+    text[ACTIVE]      = @selected_fg_color
+    text[INSENSITIVE] = @gray4
+    text[PRELIGHT]    = @fg_color
+    text[SELECTED]    = @selected_fg_color
+
+    engine "ia_ora" {
+    }
+}
+
+style "ia_ora-button" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+}
+
+style "ia_ora-thin" = "ia_ora-default"
+{
+  xthickness = 1
+  ythickness = 1
+}
+
+style "ia_ora-treeview-header" = "ia_ora-default"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-menu" = "ia_ora-default"
+{
+  fg[PRELIGHT]=@selected_fg_color
+  text[PRELIGHT]=@selected_fg_color
+}
+
+style "ia_ora-bar" = "ia_ora-menu"
+{
+  xthickness = 0
+  ythickness = 0
+}
+
+
+style "ia_ora-tasklist" = "ia_ora-default"
+{
+  xthickness = 2
+  ythickness = 2
+  GtkWidget::focus-line-width = 0
+  GtkWidget::focus-padding = 0
+}
+
+style "ia_ora-comboboxtext" = "ia_ora-default"
+{
+  text[PRELIGHT] = @fg_color
+ # Work around for http://bugzilla.gnome.org/show_bug.cgi?id=382646
+  text[NORMAL]       = @fg_color
+}
+
+style "ia_ora-tooltips" = "ia_ora-default"
+{
+  bg[NORMAL] = @tooltip_bg_color
+  fg[NORMAL] = @tooltip_fg_color
+  bg[SELECTED] = darker(@tooltip_bg_color)
+  GtkWidget::new-tooltip-style = 1
+  xthickness = 8
+  ythickness = 4
+}
+
+style "ia_ora-tree" = "ia_ora-default"
+{
+  bg[ACTIVE] = @blue1
+}
+
+style "ia_ora-menubar" = "ia_ora-default"
+{
+  GtkWidget::window-dragging = 1
+}
+
+class "GtkWidget" style "ia_ora-default"
+class "ECanvas" style "ia_ora-thin"
+class "GtkButton" style "ia_ora-button"
+class "EComboButton" style "ia_ora-thin"
+widget_class "*Item.GtkAccelLabel" style "ia_ora-menu"
+widget_class "*GtkComboBox.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*BaconCdSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*NautilusBurnDriveSelection.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*Gimp*Combo*.GtkCellView" style "ia_ora-comboboxtext"
+widget_class "*.EShortcutsView.GtkButton" style "ia_ora-thin"
+widget_class "*.GtkHTMLEmbedded.*GtkButton" style "ia_ora-thin"
+
+# Treeview header
+widget_class "*.<GtkTreeView>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCList>.<GtkButton>" style "ia_ora-treeview-header"
+widget_class "*.<GtkCTree>.<GtkButton>" style "ia_ora-treeview-header"
+
+class "GtkScrolledWindow" style "ia_ora-thin"
+class "GtkProgressBar" style "ia_ora-bar"
+widget_class "*<GtkMenuBar>*" style "ia_ora-menubar"
+widget_class "*MenuItem*" style "ia_ora-menu"
+widget_class "*.PanelApplet.*" style "ia_ora-tasklist"
+widget "*.tasklist-button" style "ia_ora-tasklist"
+class "GtkNotebook" style "ia_ora-thin"
+widget "gtk-tooltip*" style "ia_ora-tooltips"
+widget_class "*GtkPathBar*" style "ia_ora-thin"
+widget_class "*Tree*" style "ia_ora-tree"
+widget_class "*ETable*" style "ia_ora-tree"