summaryrefslogtreecommitdiffstats
path: root/src/qt_theme_draw.c
diff options
context:
space:
mode:
authortpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2010-02-03 01:37:00 +0000
committertpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2010-02-03 01:37:00 +0000
commit0e865e2b7e566235912012e357111792f4e31d8c (patch)
treefd2d295c7beae0050cc8bd657f09ed294819eaf0 /src/qt_theme_draw.c
downloadgtk-qt-engine-0e865e2b7e566235912012e357111792f4e31d8c.tar.gz
gtk-qt-engine-0e865e2b7e566235912012e357111792f4e31d8c.zip
Added abandoned KDE3 version of the GTK Qt theme engine
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/gtk-qt-engine@1084394 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'src/qt_theme_draw.c')
-rw-r--r--src/qt_theme_draw.c1918
1 files changed, 1918 insertions, 0 deletions
diff --git a/src/qt_theme_draw.c b/src/qt_theme_draw.c
new file mode 100644
index 0000000..c67016c
--- /dev/null
+++ b/src/qt_theme_draw.c
@@ -0,0 +1,1918 @@
+#include <math.h>
+#include <string.h>
+#include <gtk/gtkprogressbar.h>
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#include <glib/glist.h>
+
+#ifdef HAVE_BONOBO
+#include <libbonobo.h>
+#include <libbonoboui.h>
+#endif
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "qt_style.h"
+#include "qt_rc_style.h"
+#include "qt_qt_wrapper.h"
+
+#define DETAIL(xx) ((detail) && (!strcmp(xx, detail)))
+#define DETAILHAS(xx) ((detail) && (strstr(detail, xx)))
+#define PARENT(xx) ((parent) && (!strcmp(xx, gtk_widget_get_name(parent))))
+#ifndef max
+#define max(x,y) ((x)>=(y)?(x):(y))
+#endif
+#ifndef min
+#define min(x,y) ((x)<=(y)?(x):(y))
+#endif
+
+static void qtengine_style_init (QtEngineStyle *style);
+static void qtengine_style_class_init (QtEngineStyleClass *klass);
+
+static GtkNotebook *notebook = NULL;
+static int nb_num_pages = 0;
+
+static GtkStyleClass *parent_class = NULL;
+
+static PangoLayout*
+get_insensitive_layout (GdkDrawable *drawable,
+ PangoLayout *layout);
+
+
+static GtkShadowType
+get_shadow_type (GtkStyle* style, const char *detail, GtkShadowType requested)
+{
+ GtkShadowType retval = GTK_SHADOW_NONE;
+
+ if (requested != GTK_SHADOW_NONE) {
+ retval = GTK_SHADOW_ETCHED_IN;
+ }
+
+ if (DETAIL ("dockitem") || DETAIL ("handlebox_bin") || DETAIL ("spinbutton_up") || DETAIL ("spinbutton_down")) {
+ retval = GTK_SHADOW_NONE;
+ } else if (DETAIL ("button") || DETAIL ("togglebutton") || DETAIL ("notebook") || DETAIL ("optionmenu")) {
+ retval = requested;
+ } else if (DETAIL ("menu")) {
+ retval = GTK_SHADOW_ETCHED_IN;
+ }
+
+ return retval;
+}
+
+static void sanitize_size(GdkWindow* window, gint* width, gint* height)
+{
+ if ((*width == -1) && (*height == -1))
+ gdk_window_get_size (window, width, height);
+ else if (*width == -1)
+ gdk_window_get_size (window, width, NULL);
+ else if (*height == -1)
+ gdk_window_get_size (window, NULL, height);
+}
+
+
+static void
+draw_hline(GtkStyle* style,
+ GdkWindow* window,
+ GtkStateType state_type,
+ GdkRectangle* area,
+ GtkWidget* widget,
+ const gchar* detail,
+ gint x1,
+ gint x2,
+ gint y)
+{
+ if (gtkQtDebug)
+ printf("HLINE (%d,%d,%d) Widget: %s Detail: %s\n",x1,y1,y,gtk_widget_get_name(widget),detail);
+
+ if (DETAIL("vscale"))
+ return;
+
+ drawHLine(window,style,state_type,y,x1,x2);
+}
+
+
+static void
+draw_vline(GtkStyle* style,
+ GdkWindow* window,
+ GtkStateType state_type,
+ GdkRectangle* area,
+ GtkWidget* widget,
+ const gchar* detail,
+ gint ySource,
+ gint yDest,
+ gint x)
+{
+ if (gtkQtDebug)
+ printf("VLINE (%d,%d,%d) Widget: %s Detail: %s\n",ySource ,yDest ,x,gtk_widget_get_name(widget),detail);
+
+
+ if (DETAIL("hscale"))
+ return;
+ drawVLine(window,style,state_type,x,ySource,yDest);
+}
+
+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)
+{
+ GdkGC *gc1 = NULL; /* Initialize to quiet GCC */
+ GdkGC *gc2 = NULL;
+ GdkGC *gc3 = NULL;
+ GdkGC *gc4 = NULL;
+
+ gint thickness_light;
+ gint thickness_dark;
+ gint i;
+
+ sanitize_size(window, &width, &height);
+
+ if (gtkQtDebug)
+ printf("Shadow (%d,%d,%d,%d) Widget: %s Detail: %s\n",x,y,width,height,gtk_widget_get_name(widget),detail);
+
+
+ if (DETAIL("menuitem"))
+ return;
+ if (DETAIL("menu"))
+ return;
+ if (DETAIL("entry"))
+ {
+ drawLineEdit(window,style,state_type,gtk_widget_is_focus(widget),x,y,width,height);
+ return;
+ }
+ if (DETAIL("frame") || DETAIL("trough") || DETAIL("viewport"))
+ {
+ if (!GTK_IS_SCALE(widget))
+ {
+ /*printf("Frame (%d,%d) %dx%d %d %d\n", x,y,width,height,state_type, shadow_type);*/
+ drawFrame(window,style,state_type,shadow_type,x,y,width,height);
+ return;
+ }
+ }
+
+ /* The remainder of this function was borrowed from the "Metal" theme/
+ I don't really want to use Qt to draw these frames as there are too
+ many of them (it would slow down the theme engine even more).
+ TODO: Make them use the Qt color palette */
+
+ switch (shadow_type)
+ {
+ case GTK_SHADOW_NONE:
+ case GTK_SHADOW_IN:
+ case GTK_SHADOW_ETCHED_IN:
+ gc1 = style->light_gc[state_type];
+ gc2 = style->dark_gc[state_type];
+ gc3 = style->black_gc;
+ gc4 = style->bg_gc[state_type];
+ break;
+ case GTK_SHADOW_OUT:
+ case GTK_SHADOW_ETCHED_OUT:
+ gc1 = style->dark_gc[state_type];
+ gc2 = style->light_gc[state_type];
+ gc3 = style->black_gc;
+ gc4 = style->bg_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:
+ break;
+ case GTK_SHADOW_IN:
+ gdk_draw_line (window, gc1,
+ x, y + height - 1, x + width - 1, y + height - 1);
+ gdk_draw_line (window, gc1,
+ x + width - 1, y, x + width - 1, y + height - 1);
+
+ gdk_draw_line (window, gc4,
+ x + 1, y + height - 2, x + width - 2, y + height - 2);
+ gdk_draw_line (window, gc4,
+ x + width - 2, y + 1, x + width - 2, y + height - 2);
+
+ gdk_draw_line (window, gc3,
+ x + 1, y + 1, x + width - 2, y + 1);
+ gdk_draw_line (window, gc3,
+ x + 1, y + 1, x + 1, y + height - 2);
+
+ gdk_draw_line (window, gc2,
+ x, y, x + width - 1, y);
+ gdk_draw_line (window, gc2,
+ x, y, x, y + height - 1);
+ break;
+
+ case GTK_SHADOW_OUT:
+ gdk_draw_line (window, gc1,
+ x + 1, y + height - 2, x + width - 2, y + height - 2);
+ gdk_draw_line (window, gc1,
+ x + width - 2, y + 1, x + width - 2, y + height - 2);
+
+ gdk_draw_line (window, gc2,
+ x, y, x + width - 1, y);
+ gdk_draw_line (window, gc2,
+ x, y, x, y + height - 1);
+
+ gdk_draw_line (window, gc4,
+ x + 1, y + 1, x + width - 2, y + 1);
+ gdk_draw_line (window, gc4,
+ x + 1, y + 1, x + 1, y + height - 2);
+
+ gdk_draw_line (window, gc3,
+ x, y + height - 1, x + width - 1, y + height - 1);
+ gdk_draw_line (window, gc3,
+ x + width - 1, y, x + width - 1, y + height - 1);
+ break;
+ case GTK_SHADOW_ETCHED_IN:
+ case GTK_SHADOW_ETCHED_OUT:
+ thickness_light = 1;
+ thickness_dark = 1;
+
+ for (i = 0; i < thickness_dark; i++)
+ {
+ gdk_draw_line (window, gc1,
+ x + i,
+ y + height - i - 1,
+ x + width - i - 1,
+ y + height - i - 1);
+ gdk_draw_line (window, gc1,
+ x + width - i - 1,
+ y + i,
+ x + width - i - 1,
+ y + height - i - 1);
+
+ gdk_draw_line (window, gc2,
+ x + i,
+ y + i,
+ x + width - i - 2,
+ y + i);
+ gdk_draw_line (window, gc2,
+ x + i,
+ y + i,
+ x + i,
+ y + height - i - 2);
+ }
+
+ for (i = 0; i < thickness_light; i++)
+ {
+ gdk_draw_line (window, gc1,
+ x + thickness_dark + i,
+ y + thickness_dark + i,
+ x + width - thickness_dark - i - 1,
+ y + thickness_dark + i);
+ gdk_draw_line (window, gc1,
+ x + thickness_dark + i,
+ y + thickness_dark + i,
+ x + thickness_dark + i,
+ y + height - thickness_dark - i - 1);
+
+ gdk_draw_line (window, gc2,
+ x + thickness_dark + i,
+ y + height - thickness_light - i - 1,
+ x + width - thickness_light - 1,
+ y + height - thickness_light - i - 1);
+ gdk_draw_line (window, gc2,
+ x + width - thickness_light - i - 1,
+ y + thickness_dark + i,
+ x + width - thickness_light - i - 1,
+ y + height - thickness_light - 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);
+ }
+
+ return;
+}
+
+static void
+draw_polygon(GtkStyle* style,
+ GdkWindow* window,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GdkRectangle* area,
+ GtkWidget* widget,
+ const gchar* detail,
+ GdkPoint* points,
+ gint npoints,
+ gint fill)
+{
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif /* M_PI */
+#ifndef M_PI_4
+#define M_PI_4 0.78539816339744830962
+#endif /* M_PI_4 */
+
+ static const gdouble pi_over_4 = M_PI_4;
+ static const gdouble pi_3_over_4 = M_PI_4 * 3;
+
+ GdkGC *gc1;
+ GdkGC *gc2;
+ GdkGC *gc3;
+ GdkGC *gc4;
+ gdouble angle;
+ gint xadjust;
+ gint yadjust;
+ gint i;
+
+ g_return_if_fail(style != NULL);
+ g_return_if_fail(window != NULL);
+ g_return_if_fail(points != NULL);
+
+ switch (shadow_type)
+ {
+ case GTK_SHADOW_IN:
+ 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;
+ case GTK_SHADOW_ETCHED_IN:
+ gc1 = style->light_gc[state_type];
+ gc2 = style->dark_gc[state_type];
+ gc3 = style->dark_gc[state_type];
+ gc4 = style->light_gc[state_type];
+ break;
+ case GTK_SHADOW_OUT:
+ 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_ETCHED_OUT:
+ gc1 = style->dark_gc[state_type];
+ gc2 = style->light_gc[state_type];
+ gc3 = style->light_gc[state_type];
+ gc4 = style->dark_gc[state_type];
+ break;
+ default:
+ return;
+ }
+
+ 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);
+ }
+
+ if (fill)
+ gdk_draw_polygon(window, style->bg_gc[state_type], TRUE, points, npoints);
+
+ npoints--;
+
+ for (i = 0; i < npoints; i++)
+ {
+ if ((points[i].x == points[i + 1].x) &&
+ (points[i].y == points[i + 1].y))
+ {
+ angle = 0;
+ }
+ else
+ {
+ angle = atan2(points[i + 1].y - points[i].y,
+ points[i + 1].x - points[i].x);
+ }
+
+ if ((angle > -pi_3_over_4) && (angle < pi_over_4))
+ {
+ if (angle > -pi_over_4)
+ {
+ xadjust = 0;
+ yadjust = 1;
+ }
+ else
+ {
+ xadjust = 1;
+ yadjust = 0;
+ }
+
+ gdk_draw_line(window, gc1,
+ points[i].x - xadjust, points[i].y - yadjust,
+ points[i + 1].x - xadjust, points[i + 1].y - yadjust);
+ gdk_draw_line(window, gc3,
+ points[i].x, points[i].y,
+ points[i + 1].x, points[i + 1].y);
+ }
+ else
+ {
+ if ((angle < -pi_3_over_4) || (angle > pi_3_over_4))
+ {
+ xadjust = 0;
+ yadjust = 1;
+ }
+ else
+ {
+ xadjust = 1;
+ yadjust = 0;
+ }
+
+ gdk_draw_line(window, gc4,
+ points[i].x + xadjust, points[i].y + yadjust,
+ points[i + 1].x + xadjust, points[i + 1].y + yadjust);
+ gdk_draw_line(window, gc2,
+ points[i].x, points[i].y,
+ points[i + 1].x, points[i + 1].y);
+ }
+ }
+ 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_arrow(GtkStyle* style,
+ GdkWindow* window,
+ GtkStateType state_type,
+ GtkShadowType shadow_type,
+ GdkRectangle* area,
+ GtkWidget* widget,
+ const gchar *detail,
+ GtkArrowType arrow_type,
+ gint fill, gint x, gint y, gint width, gint height)
+{
+ sanitize_size(window, &width, &height);
+
+ if (gtkQtDebug)
+ printf("Arrow (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ if (DETAIL("hscrollbar") || DETAIL("vscrollbar"))
+ return;
+ if (DETAIL("spinbutton"))
+ return;
+ if (DETAIL("notebook"))
+ {
+ drawArrow(window, style, state_type, arrow_type, x, y, width, height);
+ return;
+ }
+ if (DETAIL("arrow"))
+ {
+ GdkPixbuf *gpix;
+ GtkWidget* parent;
+ if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget)))
+ {
+ gpix = gdk_pixbuf_get_from_drawable(NULL, gtk_widget_get_parent_window(widget),NULL, x, y, 0, 0, width, height);
+ setFillPixmap(gpix);
+ g_object_unref(gpix);
+ }
+
+ parent = gtk_widget_get_parent(widget);
+ drawArrow(window,style, GTK_WIDGET_STATE(parent), arrow_type, x, y, width, height);
+ return;
+ }
+/* if (DETAIL("menuitem"))
+ {
+ GdkGC *gc1;
+ GdkGC *gc2;
+ GdkGC *gc3;
+ GdkGC *gc4;
+ gint half_width;
+ gint half_height;
+ gint ax, ay, aw, ah;
+
+ switch (shadow_type)
+ {
+ case GTK_SHADOW_IN:
+ gc1 = style->bg_gc[state_type];
+ gc2 = style->dark_gc[state_type];
+ gc3 = style->light_gc[state_type];
+ gc4 = style->black_gc;
+ break;
+ case GTK_SHADOW_OUT:
+ gc1 = style->dark_gc[state_type];
+ gc2 = style->light_gc[state_type];
+ gc3 = style->black_gc;
+ gc4 = style->bg_gc[state_type];
+ break;
+ case GTK_SHADOW_ETCHED_IN:
+ gc2 = style->light_gc[state_type];
+ gc1 = style->dark_gc[state_type];
+ gc3 = NULL;
+ gc4 = NULL;
+ break;
+ case GTK_SHADOW_ETCHED_OUT:
+ gc1 = style->dark_gc[state_type];
+ gc2 = style->light_gc[state_type];
+ gc3 = NULL;
+ gc4 = NULL;
+ break;
+ default:
+ return;
+ }
+
+ sanitize_size(window, &width, &height);
+ ax = x;
+ ay = y;
+ aw = width;
+ ah = height;
+ calculate_arrow_geometry (arrow_type, &ax, &ay, &aw, &ah);
+
+ half_width = width / 2;
+ half_height = height / 2;
+
+ if (area)
+ {
+ gdk_gc_set_clip_rectangle(gc1, area);
+ gdk_gc_set_clip_rectangle(gc2, area);
+ if ((gc3) && (gc4))
+ {
+ gdk_gc_set_clip_rectangle(gc3, area);
+ gdk_gc_set_clip_rectangle(gc4, area);
+ }
+ }
+
+ if (state_type == GTK_STATE_INSENSITIVE)
+ draw_black_arrow (window, style->white_gc, area, arrow_type, ax + 1, ay + 1, aw, ah);
+ draw_black_arrow (window, style->fg_gc[state_type], area, arrow_type, ax, ay, aw, ah);
+
+ if (area)
+ {
+ gdk_gc_set_clip_rectangle(gc1, NULL);
+ gdk_gc_set_clip_rectangle(gc2, NULL);
+ if (gc3)
+ {
+ gdk_gc_set_clip_rectangle(gc3, NULL);
+ gdk_gc_set_clip_rectangle(gc4, NULL);
+ }
+ }
+ }*/
+ else
+ {
+ GdkPixbuf *gpix;
+ if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget)))
+ {
+ gpix = gdk_pixbuf_get_from_drawable(NULL, gtk_widget_get_parent_window(widget),NULL, x, y, 0, 0, width, height);
+ setFillPixmap(gpix);
+ g_object_unref(gpix);
+ }
+
+ drawArrow(window, style, state_type, arrow_type, x, y, width, height);
+ return;
+ }
+}
+
+
+
+static void
+draw_diamond(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)
+{
+ GList *child1;
+ GtkWidget *child;
+ GtkNotebook *nb;
+ int nbpages;
+ sanitize_size(window, &width, &height);
+
+ if (gtkQtDebug)
+ printf("Box (%d,%d,%d,%d) Widget: %s Detail: %s\n",x,y,width,height,gtk_widget_get_name(widget),detail);
+
+ if (GTK_IS_SCROLLBAR(widget))
+ {
+ if (DETAIL("trough"))
+ {
+ GtkAdjustment* adj = (GtkAdjustment*)gtk_range_get_adjustment(GTK_RANGE(widget));
+ int orientation = ((width>height) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
+
+ drawScrollBar(window, style, state_type, orientation, adj, x, y, width, height);
+ }
+ return;
+ }
+ if (DETAIL("menuitem"))
+ {
+ /* Crude way of checking if it's a menu item, or a menubar item */
+ if (x != 0)
+ drawMenuBarItem(window,style,state_type,x,y,width,height);
+ else
+ drawMenuItem(window,style,state_type,x,y,width,height);
+ return;
+ }
+ if (DETAIL("menubar"))
+ {
+ if (openOfficeFix == 1)
+ parent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+ else
+ drawMenubar(window,style,state_type,x,y,width,height);
+ return;
+ }
+ if (DETAIL("menu"))
+ {
+ if (openOfficeFix == 1)
+ parent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+ else
+ {
+ if ((x >= 0) && (y >= 0)) /* Work around weirdness in firefox */
+ drawMenu(window,style,state_type,x,y,width,height);
+ }
+ return;
+ }
+ if (GTK_IS_PROGRESS(widget) && DETAIL("trough"))
+ {
+ double fraction = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(widget));
+ GtkProgressBarOrientation orientation = gtk_progress_bar_get_orientation(GTK_PROGRESS_BAR(widget));
+
+ drawProgressBar(window,style,state_type,orientation,fraction,x,y,width,height);
+ return;
+ }
+ if (GTK_IS_PROGRESS(widget) && DETAIL("bar"))
+ {
+ if (area) gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
+
+ drawProgressChunk(window,style,state_type,x,y,width,height);
+
+ if (area) gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
+ return;
+ }
+ if (GTK_IS_SCALE(widget) && DETAIL("trough"))
+ {
+ GtkAdjustment* adj;
+ int inverted;
+ GValue *val = (GValue*)g_malloc( sizeof(GValue) );
+ if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget)))
+ {
+ GdkPixbuf *gpix;
+ gpix = gdk_pixbuf_get_from_drawable(NULL, gtk_widget_get_parent_window(widget),NULL, x, y, 0, 0, width, height);
+ setFillPixmap(gpix);
+ g_object_unref(gpix);
+ }
+
+ memset( val, 0, sizeof(GValue) );
+ g_value_init( val, G_TYPE_BOOLEAN );
+ g_object_get_property(widget, "inverted", val);
+ inverted = g_value_get_boolean(val);
+ g_value_unset(val);
+ g_free(val);
+
+ adj = gtk_range_get_adjustment((GtkRange *) widget);
+ drawSlider(window,style,state_type,adj,x,y,width,height, (GTK_RANGE(widget))->orientation, inverted);
+ return;
+ }
+ if (DETAIL("button"))
+ {
+ GtkWidget *parent;
+ int toolbutton = 0;
+ parent = gtk_widget_get_parent(widget);
+
+ if (parent && (GTK_IS_CLIST(parent) || GTK_IS_LIST(parent) || GTK_IS_TREE_VIEW(parent)))
+ {
+ drawListHeader(window,style,state_type,x,y,width,height);
+ return;
+ }
+
+ /* this is a very very bad hack but there seems to be no way to find if a button is on a
+ * toolbar in gtk */
+ while (1)
+ {
+ if (GTK_IS_WIDGET(parent))
+ {
+#ifdef HAVE_BONOBO
+ if (GTK_IS_TOOLBAR(parent) || BONOBO_IS_UI_TOOLBAR(parent))
+#else
+ if (GTK_IS_TOOLBAR(parent))
+#endif
+ {
+ toolbutton = 1;
+ break;
+ }
+ }
+ else
+ break;
+ parent = gtk_widget_get_parent(parent);
+ }
+
+ parent = gtk_widget_get_parent(widget);
+
+ if (toolbutton)
+ drawToolButton(window,style,state_type,x,y,width,height);
+ else
+ {
+ /* Baghira hack -- rounded buttons really ugly when they are small like
+ on a dropdown entry box -- eg. search/replace in gedit */
+ /* Draw square buttons only if number of children in the hbox is 2 and
+ * the first child is a entry view (GtkEntry)*/
+ int defaultButton = GTK_WIDGET_HAS_FOCUS(widget);
+ GtkWindow* toplevel;
+
+ if (isBaghira && GTK_IS_BOX(parent) && (g_list_length(GTK_BOX(parent)->children) == 2))
+ {
+ child1 = g_list_first((GTK_BOX(parent)->children));
+ child = ((GtkBoxChild *)child1->data)->widget;
+ if (GTK_IS_ENTRY(child))
+ {
+ drawSquareButton(window,style,state_type,x,y,width,height);
+ return;
+ }
+
+ child1 = g_list_last((GTK_BOX(parent)->children));
+ child = ((GtkBoxChild *)child1->data)->widget;
+ if (GTK_IS_ENTRY(child))
+ {
+ drawSquareButton(window,style,state_type,x,y,width,height);
+ return;
+ }
+
+ }
+
+ toplevel = GTK_WINDOW(gtk_widget_get_toplevel(widget));
+ if (toplevel && toplevel->default_widget == widget)
+ defaultButton = 1;
+
+ drawButton(window,style,state_type,defaultButton,x,y,width,height);
+ }
+ return;
+ }
+ if (DETAIL("tab"))
+ {
+ if (GTK_IS_NOTEBOOK(widget))
+ {
+ nb = (GtkNotebook *)widget;
+ nbpages = g_list_length(nb->children);
+ /* THIS IS WHAT WORKS NOW --
+ Tabs and tabbarbase will be drawn properly according to the QT style
+ But the tabs won't be aligned according to QT. GTK+ does not have
+ an option for alignment of tabs. So if were to do this not only do we have to
+ calculate the x,y position of the tab ourselves, which is difficult in Qt unless
+ we are displaying the tab (can be done by subclassing QTabBar/QTabWidget)
+ but also have to position the tab bar label ourselves in gtk.
+ */
+
+ /* Check if we have seen this notebook before */
+ if ((nb != notebook) || (nbpages != nb_num_pages))
+ {
+ notebook = nb;
+ nb_num_pages = nbpages;
+ initDrawTabNG(nbpages);
+ }
+
+ /* Now draw the tab -- tab position is also calculated in this function
+ checkout drawTabFrame() for drawing tabbarbase. */
+ drawTabNG(window,style,state_type,x, y, width - 2, height, nb );
+ }
+ else
+ drawTab(window,style,state_type,x,y,width-2,height);
+ return;
+ }
+ if (DETAIL("optionmenu"))
+ {
+ drawComboBox(window,style,state_type,x,y,width,height);
+ return;
+ }
+ if (DETAIL("toolbar"))
+ {
+ if (openOfficeFix == 1)
+ parent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+ else
+ drawToolbar(window,style,state_type,x,y,width,height);
+ return;
+ }
+ if (DETAIL("spinbutton_up"))
+ {
+ drawSpinButton(window, style, state_type, 0, x, y, width, height);
+ return;
+ }
+ if (DETAIL("spinbutton_down"))
+ {
+ drawSpinButton(window, style, state_type, 1, x, y, width, height);
+ return;
+ }
+ if (DETAIL("spinbutton"))
+ return;
+
+ if (DETAIL("optionmenutab") || DETAIL("buttondefault"))
+ return;
+
+ drawFrame(window,style,state_type,shadow_type,x,y,width,height);
+}
+
+
+
+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)
+{
+ sanitize_size(window, &width, &height);
+
+ if (gtkQtDebug)
+ printf("Flat Box (%d,%d,%d,%d) Widget: %s Detail: %s %d %d\n",x,y,width,height,gtk_widget_get_name(widget),detail, state_type, GTK_STATE_SELECTED);
+
+ if (DETAIL("tooltip"))
+ {
+ GdkColor tooltipColor;
+ GdkGCValues gc_values;
+ GdkGCValuesMask gc_values_mask;
+ GdkGC* tooltipGc;
+ tooltipColor.red = 255*257;
+ tooltipColor.green = 255*257;
+ tooltipColor.blue = 220*257;
+ gdk_colormap_alloc_color(style->colormap, &tooltipColor, FALSE, TRUE);
+
+ gc_values_mask = GDK_GC_FOREGROUND;
+ gc_values.foreground = tooltipColor;
+
+ tooltipGc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+ gdk_draw_rectangle(window, tooltipGc, TRUE, x, y, width, height);
+ gdk_draw_rectangle(window, style->black_gc, FALSE, x, y, width - 1, height - 1);
+
+ gtk_gc_release(tooltipGc);
+ }
+
+ if ((DETAILHAS("cell_even") || DETAILHAS("cell_odd")) && (state_type == GTK_STATE_SELECTED))
+ {
+ drawListViewItem(window,style,state_type,x,y,width,height);
+ }
+ else if (DETAIL("listitem"))
+ {
+ drawListViewItem(window,style,state_type,x,y,width,height);
+ }
+ else if (DETAILHAS("cell_even"))
+ {
+ gdk_draw_rectangle(window, style->base_gc[GTK_STATE_NORMAL], TRUE, x, y, width, height);
+ }
+ else if (DETAILHAS("cell_odd"))
+ {
+ gdk_draw_rectangle(window, alternateBackgroundGc(style), TRUE, x, y, width, 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)
+{
+ if (gtkQtDebug)
+ printf("Check (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ if (GTK_IS_MENU_ITEM(widget))
+ {
+ if (shadow_type == GTK_SHADOW_IN)
+ {
+ if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget)))
+ {
+ GdkPixbuf *gpix;
+ gpix = gdk_pixbuf_get_from_drawable(NULL, gtk_widget_get_parent_window(widget), NULL, x, y, 0, 0, width, height);
+ setFillPixmap(gpix);
+ g_object_unref(gpix);
+ }
+
+ drawMenuCheck(window,style,state_type,x,y,width,height);
+ }
+ return;
+ }
+ drawCheckBox(window,style,state_type,(shadow_type==GTK_SHADOW_IN),x,y,width,height);
+}
+
+
+/* Thanks to Evan Lawrence */
+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)
+{
+ if (gtkQtDebug)
+ printf("Option (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget)))
+ {
+ GdkPixbuf *gpix;
+ gpix = gdk_pixbuf_get_from_drawable(NULL, gtk_widget_get_parent_window(widget),NULL, x, y, 0, 0, width, height);
+ setFillPixmap(gpix);
+ g_object_unref(gpix);
+ }
+
+ if (GTK_IS_MENU_ITEM(widget))
+ {
+ if (shadow_type == GTK_SHADOW_IN)
+ drawMenuCheck(window,style,state_type,x,y,width,height);
+ return;
+ }
+ drawRadioButton(window,style,state_type,(shadow_type==GTK_SHADOW_IN),x,y,width,height);
+}
+
+
+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 (gtkQtDebug)
+ printf("Tab (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail, x, y, 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)
+{
+ GdkGC *gc1 = NULL;
+ GdkGC *gc2 = NULL;
+
+ g_return_if_fail (window != NULL);
+
+ sanitize_size (window, &width, &height);
+ shadow_type = get_shadow_type (style, detail, shadow_type);
+
+ if (gtkQtDebug)
+ printf("Shadow_Gap (%d,%d,%d,%d) Widget: %s Detail: %s\n",x,y,width,height,gtk_widget_get_name(widget),detail);
+
+ switch (shadow_type) {
+ case GTK_SHADOW_NONE:
+ return;
+ case GTK_SHADOW_IN:
+ gc1 = style->dark_gc[state_type];
+ gc2 = style->light_gc[state_type];
+ break;
+ case GTK_SHADOW_OUT:
+ gc1 = style->light_gc[state_type];
+ gc2 = style->dark_gc[state_type];
+ break;
+ case GTK_SHADOW_ETCHED_IN:
+ case GTK_SHADOW_ETCHED_OUT:
+ gc1 = style->dark_gc[state_type];
+ gc2 = style->dark_gc[state_type];
+ }
+
+ if (area) {
+ gdk_gc_set_clip_rectangle (gc1, area);
+ gdk_gc_set_clip_rectangle (gc2, area);
+ }
+
+ switch (gap_side) {
+ case GTK_POS_TOP:
+ if (gap_x > 0) {
+ gdk_draw_line (window, gc1,
+ x, y,
+ x + gap_x, y);
+ }
+ if ((width - (gap_x + gap_width)) > 0) {
+ gdk_draw_line (window, gc1,
+ x + gap_x + gap_width - 1, y,
+ x + width - 1, y);
+ }
+ gdk_draw_line (window, gc1,
+ x, y,
+ x, y + height - 1);
+ gdk_draw_line (window, gc2,
+ x + width - 1, y,
+ x + width - 1, y + height - 1);
+ gdk_draw_line (window, gc2,
+ x, y + height - 1,
+ x + width - 1, y + height - 1);
+ break;
+ case GTK_POS_BOTTOM:
+ gdk_draw_line (window, gc1,
+ x, y,
+ x + width - 1, y);
+ gdk_draw_line (window, gc1,
+ x, y,
+ x, y + height - 1);
+ gdk_draw_line (window, gc2,
+ x + width - 1, y,
+ x + width - 1, y + height - 1);
+
+ if (gap_x > 0) {
+ gdk_draw_line (window, gc2,
+ x, y + height - 1,
+ x + gap_x, y + height - 1);
+ }
+ if ((width - (gap_x + gap_width)) > 0) {
+ gdk_draw_line (window, gc2,
+ x + gap_x + gap_width - 1, y + height - 1,
+ x + width - 1, y + height - 1);
+ }
+
+ break;
+ case GTK_POS_LEFT:
+ gdk_draw_line (window, gc1,
+ x, y,
+ x + width - 1, y);
+ if (gap_x > 0) {
+ gdk_draw_line (window, gc1,
+ x, y,
+ x, y + gap_x);
+ }
+ if ((height - (gap_x + gap_width)) > 0) {
+ gdk_draw_line (window, gc1,
+ x, y + gap_x + gap_width - 1,
+ x, y + height - 1);
+ }
+ gdk_draw_line (window, gc2,
+ x + width - 1, y,
+ x + width - 1, y + height - 1);
+ gdk_draw_line (window, gc2,
+ x, y + height - 1,
+ x + width - 1, y + height - 1);
+ break;
+ case GTK_POS_RIGHT:
+ gdk_draw_line (window, gc1,
+ x, y,
+ x + width - 1, y);
+ gdk_draw_line (window, gc1,
+ x, y,
+ x, y + height - 1);
+
+
+ if (gap_x > 0) {
+ gdk_draw_line (window, gc2,
+ x + width - 1, y,
+ x + width - 1, y + gap_x);
+ }
+ if ((height - (gap_x + gap_width)) > 0) {
+ gdk_draw_line (window, gc2,
+ x + width - 1, y + gap_x + gap_width - 1,
+ x + width - 1, y + height - 1);
+ }
+ gdk_draw_line (window, gc2,
+ x, y + height - 1,
+ x + width - 1, y + height - 1);
+
+ }
+
+ if (area) {
+ gdk_gc_set_clip_rectangle (gc1, NULL);
+ gdk_gc_set_clip_rectangle (gc2, NULL);
+ }
+}
+
+
+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)
+{
+ sanitize_size (window, &width, &height);
+
+ if (width<0 || height<0) return; /* Eclipse really can be this stupid! */
+
+ if (gtkQtDebug)
+ printf("Box_gap (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ if (DETAIL("notebook"))
+ drawTabFrame(window,style,state_type,x,y-2,width,height+2, gtk_notebook_get_tab_pos((GtkNotebook *)widget));
+}
+
+
+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)
+{
+ g_return_if_fail(style != NULL);
+ g_return_if_fail(window != NULL);
+
+ sanitize_size (window, &width, &height);
+
+ if (gtkQtDebug)
+ printf("Extension (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail,
+ x, y, width, height);
+}
+
+
+static void
+draw_focus (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type,
+ GdkRectangle *area,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ if (gtkQtDebug)
+ printf("Focus Rect (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ GtkWidget* parent = gtk_widget_get_parent(widget);
+
+ if (GTK_IS_CHECK_BUTTON(widget) ||
+ GTK_IS_RADIO_BUTTON(widget) ||
+ (parent && (GTK_IS_CLIST(parent) || GTK_IS_LIST(parent) || GTK_IS_TREE_VIEW(parent))))
+ {
+ drawFocusRect(window, style, x, y, width, height);
+ }
+ return;
+}
+
+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)
+{
+ if (gtkQtDebug)
+ printf("Slider (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail);
+
+ if (DETAIL("slider"))
+ {
+ GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(widget));
+ int widgetX, widgetY;
+
+ GtkWidget* parent = widget;
+ while (gtk_widget_get_parent(parent) != NULL)
+ parent = gtk_widget_get_parent(parent);
+
+ gtk_widget_translate_coordinates(widget, parent, 0, 0, &widgetX, &widgetY);
+
+ if (orientation == GTK_ORIENTATION_VERTICAL)
+ drawScrollBarSlider(window, style, state_type, orientation, adj, x-1, y, width+2, height, y-widgetY, widget->allocation.height);
+ else
+ drawScrollBarSlider(window, style, state_type, orientation, adj, x, y-1, width, height+2, x-widgetX, widget->allocation.width);
+ return;
+ }
+}
+
+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)
+{
+ g_return_if_fail(style != NULL);
+ g_return_if_fail(window != NULL);
+
+ sanitize_size(window, &width, &height);
+
+ if (gtkQtDebug)
+ printf("Handle (%d,%d,%d,%d) Widget: %s Detail: %s \n",x,y,width,height,gtk_widget_get_name(widget),detail, state_type);
+
+ drawSplitter(window,style,state_type,orientation,x,y,width,height);
+ return;
+}
+
+static
+void draw_layout (GtkStyle *style,
+ GdkWindow *window,
+ GtkStateType state_type,
+ gboolean use_text,
+ GdkRectangle *area,
+ GtkWidget *widget,
+ const gchar *detail,
+ gint x,
+ gint y,
+ PangoLayout *layout)
+{
+
+ GdkColor color;
+ GdkGC *gc;
+ getTextColor(&color, state_type);
+
+ if (gtkQtDebug)
+ printf("Layout (%d,%d) Widget: %s Detail: %s %d \n",x,y,gtk_widget_get_name(widget),detail, state_type);
+
+ if (DETAIL("accellabel") || DETAIL("label") || DETAIL("cellrenderertext"))
+ {
+
+ GtkWidget* parent = gtk_widget_get_parent(widget);
+ GtkWidget* parent1 = gtk_widget_get_parent(parent);
+
+ /* printf("parent's names are %s->%s->%s\n", gtk_widget_get_name(widget), gtk_widget_get_name(parent), gtk_widget_get_name(parent1)); */
+
+ /* In baghira -- even highlight the menu bar items */
+ if ((GTK_IS_MENU_ITEM(parent) && (!GTK_IS_MENU_BAR(parent1) || isBaghira || isPolyester)) || GTK_IS_TREE_VIEW(widget))
+ {
+ PangoAttrList *layoutattr;
+
+ const gchar *text;
+ gint text_length = 0;
+ gint text_bytelen = 0;
+ text = pango_layout_get_text (layout);
+ if (text != 0)
+ {
+ PangoAttribute *textcolorattr;
+ text_length = g_utf8_strlen (text, -1);
+ text_bytelen = strlen (text);
+
+ textcolorattr = pango_attr_foreground_new(color.red, color.green, color.blue);
+ textcolorattr->start_index = 0;
+ textcolorattr->end_index = text_bytelen;
+
+ layoutattr = pango_layout_get_attributes(layout);
+
+ if (layoutattr == NULL)
+ {
+ layoutattr = pango_attr_list_new();
+ pango_attr_list_insert(layoutattr, pango_attribute_copy(textcolorattr));
+ pango_layout_set_attributes(layout,layoutattr);
+ pango_attr_list_unref(layoutattr);
+ }
+ else
+ {
+ pango_attr_list_change(layoutattr, pango_attribute_copy(textcolorattr));
+ pango_layout_set_attributes(layout,layoutattr);
+ }
+ pango_attribute_destroy(textcolorattr);
+ }
+
+ }
+ /* printf("Drawing an label -- with state %d at %d %d\n", state_type, x, y); */
+ }
+
+ g_return_if_fail (window != NULL);
+
+ gc = use_text ? style->text_gc[state_type] : style->fg_gc[state_type];
+
+ if (area)
+ gdk_gc_set_clip_rectangle (gc, area);
+
+ if (state_type == GTK_STATE_INSENSITIVE)
+ {
+ PangoLayout *ins;
+ ins = get_insensitive_layout (window, layout);
+ gdk_draw_layout (window, gc, x, y, ins);
+ g_object_unref (ins);
+ }
+ else
+ {
+ gdk_draw_layout (window, gc, x, y, layout);
+ }
+
+ if (area)
+ gdk_gc_set_clip_rectangle (gc, NULL);
+}
+
+typedef struct _ByteRange ByteRange;
+
+struct _ByteRange
+{
+ guint start;
+ guint end;
+};
+
+static ByteRange*
+range_new (guint start,
+ guint end)
+{
+ ByteRange *br = g_new (ByteRange, 1);
+
+ br->start = start;
+ br->end = end;
+
+ return br;
+}
+
+static PangoLayout*
+get_insensitive_layout (GdkDrawable *drawable,
+ PangoLayout *layout)
+{
+ GSList *embossed_ranges = NULL;
+ GSList *stippled_ranges = NULL;
+ PangoLayoutIter *iter;
+ GSList *tmp_list = NULL;
+ PangoLayout *new_layout;
+ PangoAttrList *attrs;
+ GdkBitmap *stipple = NULL;
+
+ iter = pango_layout_get_iter (layout);
+
+ do
+ {
+ PangoLayoutRun *run;
+ PangoAttribute *attr;
+ gboolean need_stipple = FALSE;
+ ByteRange *br;
+
+ run = pango_layout_iter_get_run (iter);
+
+ if (run)
+ {
+ tmp_list = run->item->analysis.extra_attrs;
+
+ while (tmp_list != NULL)
+ {
+ attr = tmp_list->data;
+ switch (attr->klass->type)
+ {
+ case PANGO_ATTR_FOREGROUND:
+ case PANGO_ATTR_BACKGROUND:
+ need_stipple = TRUE;
+ break;
+
+ default:
+ break;
+ }
+
+ if (need_stipple)
+ break;
+
+ tmp_list = g_slist_next (tmp_list);
+ }
+
+ br = range_new (run->item->offset, run->item->offset + run->item->length);
+
+ if (need_stipple)
+ stippled_ranges = g_slist_prepend (stippled_ranges, br);
+ else
+ embossed_ranges = g_slist_prepend (embossed_ranges, br);
+ }
+ }
+ while (pango_layout_iter_next_run (iter));
+
+ pango_layout_iter_free (iter);
+
+ new_layout = pango_layout_copy (layout);
+
+ attrs = pango_layout_get_attributes (new_layout);
+
+ if (attrs == NULL)
+ {
+ /* Create attr list if there wasn't one */
+ attrs = pango_attr_list_new ();
+ pango_layout_set_attributes (new_layout, attrs);
+ pango_attr_list_unref (attrs);
+ }
+
+ tmp_list = embossed_ranges;
+ while (tmp_list != NULL)
+ {
+ PangoAttribute *attr;
+ ByteRange *br = tmp_list->data;
+
+ attr = gdk_pango_attr_embossed_new (TRUE);
+
+ attr->start_index = br->start;
+ attr->end_index = br->end;
+
+ pango_attr_list_change (attrs, attr);
+
+ g_free (br);
+
+ tmp_list = g_slist_next (tmp_list);
+ }
+
+ g_slist_free (embossed_ranges);
+
+ tmp_list = stippled_ranges;
+ while (tmp_list != NULL)
+ {
+ PangoAttribute *attr;
+ ByteRange *br = tmp_list->data;
+
+ if (stipple == NULL)
+ {
+#define gray50_width 2
+#define gray50_height 2
+ static const char gray50_bits[] = {
+ 0x02, 0x01
+ };
+
+ stipple = gdk_bitmap_create_from_data (drawable,
+ gray50_bits, gray50_width,
+ gray50_height);
+ }
+
+ attr = gdk_pango_attr_stipple_new (stipple);
+
+ attr->start_index = br->start;
+ attr->end_index = br->end;
+
+ pango_attr_list_change (attrs, attr);
+
+ g_free (br);
+
+ tmp_list = g_slist_next (tmp_list);
+ }
+
+ g_slist_free (stippled_ranges);
+
+ if (stipple)
+ g_object_unref (stipple);
+
+ return new_layout;
+}
+
+
+GType qtengine_type_style = 0;
+
+void
+qtengine_style_register_type (GTypeModule *module)
+{
+ static const GTypeInfo object_info =
+ {
+ sizeof (QtEngineStyleClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) qtengine_style_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (QtEngineStyle),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) qtengine_style_init,
+ };
+
+ qtengine_type_style = g_type_module_register_type (module,
+ GTK_TYPE_STYLE,
+ "QtEngineStyle",
+ &object_info, 0);
+}
+
+static void
+qtengine_style_init (QtEngineStyle *style)
+{
+}
+
+
+/* Copied these functions from gtkstyle.c
+ Evil, evil GTK... why isn't this stuff exported? */
+
+#define LIGHTNESS_MULT 1.3
+#define DARKNESS_MULT 0.7
+
+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
+gtk_style_shade (GdkColor *a,
+ GdkColor *b,
+ gdouble 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 void
+gtk_style_real_realize (GtkStyle *style)
+{
+ GdkGCValues gc_values;
+ GdkGCValuesMask gc_values_mask;
+
+ gint i;
+
+ for (i = 0; i < 5; i++)
+ {
+ gtk_style_shade (&style->bg[i], &style->light[i], LIGHTNESS_MULT);
+ gtk_style_shade (&style->bg[i], &style->dark[i], DARKNESS_MULT);
+
+ style->mid[i].red = (style->light[i].red + style->dark[i].red) / 2;
+ style->mid[i].green = (style->light[i].green + style->dark[i].green) / 2;
+ style->mid[i].blue = (style->light[i].blue + style->dark[i].blue) / 2;
+
+ style->text_aa[i].red = (style->text[i].red + style->base[i].red) / 2;
+ style->text_aa[i].green = (style->text[i].green + style->base[i].green) / 2;
+ style->text_aa[i].blue = (style->text[i].blue + style->base[i].blue) / 2;
+ }
+
+ style->black.red = 0x0000;
+ style->black.green = 0x0000;
+ style->black.blue = 0x0000;
+ gdk_colormap_alloc_color (style->colormap, &style->black, FALSE, TRUE);
+
+ style->white.red = 0xffff;
+ style->white.green = 0xffff;
+ style->white.blue = 0xffff;
+ gdk_colormap_alloc_color (style->colormap, &style->white, FALSE, TRUE);
+
+ gc_values_mask = GDK_GC_FOREGROUND;
+
+ gc_values.foreground = style->black;
+ style->black_gc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->white;
+ style->white_gc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ for (i = 0; i < 5; i++)
+ {
+
+ if (!gdk_colormap_alloc_color (style->colormap, &style->fg[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->fg[i].red, style->fg[i].green, style->fg[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->bg[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->bg[i].red, style->bg[i].green, style->bg[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->light[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->light[i].red, style->light[i].green, style->light[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->dark[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->dark[i].red, style->dark[i].green, style->dark[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->mid[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->mid[i].red, style->mid[i].green, style->mid[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->text[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->text[i].red, style->text[i].green, style->text[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->base[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->base[i].red, style->base[i].green, style->base[i].blue);
+ if (!gdk_colormap_alloc_color (style->colormap, &style->text_aa[i], FALSE, TRUE))
+ g_warning ("unable to allocate color: ( %d %d %d )",
+ style->text_aa[i].red, style->text_aa[i].green, style->text_aa[i].blue);
+
+ gc_values.foreground = style->fg[i];
+ style->fg_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->bg[i];
+ style->bg_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->light[i];
+ style->light_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->dark[i];
+ style->dark_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->mid[i];
+ style->mid_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->text[i];
+ style->text_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->base[i];
+ style->base_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+
+ gc_values.foreground = style->text_aa[i];
+ style->text_aa_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+ }
+}
+
+
+static void
+realize (GtkStyle* style)
+{
+ setColors(style);
+ gtk_style_real_realize(style);
+}
+
+static void
+set_background (GtkStyle *style, GdkWindow *window, GtkStateType state_type)
+{
+ GdkPixmap *pixmap;
+ gint parent_relative;
+ GdkPixmap* pix_test;
+
+ /* What kind of horrible person would store a pointer to a widget here... */
+ void* parent = 0;
+ gdk_window_get_user_data(window, &parent);
+ if (GTK_IS_MENU((GtkWidget*) parent))
+ {
+ pix_test = QTENGINE_STYLE(style)->menuBackground;
+ }
+ else
+ pix_test = style->bg_pixmap[state_type];
+
+ if (pix_test)
+ {
+ if (pix_test == (GdkPixmap*) GDK_PARENT_RELATIVE)
+ {
+ pixmap = NULL;
+ parent_relative = TRUE;
+ }
+ else
+ {
+ pixmap = pix_test;
+ parent_relative = FALSE;
+ gdk_drawable_set_colormap(pixmap, style->colormap);
+ }
+
+ if (pixmap && !gdk_drawable_get_colormap (pixmap)) gdk_drawable_set_colormap (pixmap, gdk_drawable_get_colormap (window));
+ gdk_window_set_back_pixmap (window, pixmap, parent_relative);
+ }
+ else
+ gdk_window_set_background (window, &style->bg[state_type]);
+}
+
+static void
+qtengine_style_class_init (QtEngineStyleClass *klass)
+{
+ GtkStyleClass *style_class = GTK_STYLE_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+
+ style_class->draw_hline = draw_hline;
+ style_class->draw_vline = draw_vline;
+ style_class->draw_shadow = draw_shadow;
+ style_class->draw_polygon = draw_polygon;
+ style_class->draw_arrow = draw_arrow;
+ style_class->draw_diamond = draw_diamond;
+ /*style_class->draw_string = draw_string;*/
+ 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_tab = draw_tab;
+ style_class->draw_shadow_gap = draw_shadow_gap;
+
+ /* box around notebooks */
+ style_class->draw_box_gap = draw_box_gap;
+ /* the tab */
+ style_class->draw_extension = draw_extension;
+
+ style_class->draw_focus = draw_focus;
+ style_class->draw_handle = draw_handle;
+ style_class->draw_layout = draw_layout;
+ style_class->draw_slider = draw_slider;
+
+ style_class->realize = realize;
+
+ /* style_class->set_background = set_background;*/
+}
+
+