diff options
Diffstat (limited to 'src/gtk/engine/ia_ora_theme_draw.c')
| -rw-r--r-- | src/gtk/engine/ia_ora_theme_draw.c | 3531 |
1 files changed, 3531 insertions, 0 deletions
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 ([email protected]) 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 <[email protected]> + Tomas �gren <[email protected]> and Richard Hult <[email protected]> + 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); +} + |