From b25395fab6fe9ee38bc0cd359941d0a825d88451 Mon Sep 17 00:00:00 2001 From: Denis Gorodnichev Date: Thu, 24 Jul 2014 10:37:41 +0400 Subject: merge metacity(gtk3) changes merge metacity(gtk3) changes fix warnings clean up unused variables replace UNUSED_VARIABLE by G_GNUC_UNUSED --- src/ui/draw-workspace.c | 60 +++++- src/ui/fixedtip.c | 2 +- src/ui/fixedtip.h | 3 +- src/ui/frames.c | 49 +++-- src/ui/gradient.c | 174 ++++++++++++++++- src/ui/gradient.h | 20 ++ src/ui/menu.c | 15 +- src/ui/preview-widget.c | 120 ++++++------ src/ui/resizepopup.c | 2 +- src/ui/tabpopup.c | 60 +++++- src/ui/testgradient.c | 117 ++++++++--- src/ui/theme-parser.c | 12 +- src/ui/theme.c | 511 ++++++++++++++++++++++++++++++++++-------------- src/ui/theme.h | 74 +++++-- src/ui/tile-preview.c | 74 ++++++- src/ui/ui.c | 8 +- 16 files changed, 985 insertions(+), 316 deletions(-) (limited to 'src/ui') diff --git a/src/ui/draw-workspace.c b/src/ui/draw-workspace.c index 1831b46c..a40579db 100644 --- a/src/ui/draw-workspace.c +++ b/src/ui/draw-workspace.c @@ -27,6 +27,11 @@ #include "draw-workspace.h" +#if GTK_CHECK_VERSION (3, 0, 0) +#define MATE_DESKTOP_USE_UNSTABLE_API +#include +#endif + static void get_window_rect (const WnckWindowDisplayInfo *win, @@ -83,13 +88,18 @@ draw_window (GtkWidget *widget, GdkPixbuf *icon; int icon_x, icon_y, icon_w, icon_h; gboolean is_active; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; + GtkStyleContext *style; +#else GdkColor *color; GtkStyle *style; +#endif is_active = win->is_active; #if GTK_CHECK_VERSION(3, 0, 0) - cairo_save(cr); + cairo_save (cr); #else cr = gdk_cairo_create (drawable); #endif @@ -97,6 +107,14 @@ draw_window (GtkWidget *widget, cairo_rectangle (cr, winrect->x, winrect->y, winrect->width, winrect->height); cairo_clip (cr); +#if GTK_CHECK_VERSION (3, 0, 0) + style = gtk_widget_get_style_context (widget); + if (is_active) + mate_desktop_gtk_style_get_light_color (style, state, &color); + else + gtk_style_context_get_background_color (style, state, &color); + gdk_cairo_set_source_rgba (cr, &color); +#else style = gtk_widget_get_style (widget); if (is_active) color = &style->light[state]; @@ -106,6 +124,7 @@ draw_window (GtkWidget *widget, color->red / 65535., color->green / 65535., color->blue / 65535.); +#endif cairo_rectangle (cr, winrect->x + 1, winrect->y + 1, @@ -156,15 +175,17 @@ draw_window (GtkWidget *widget, cairo_restore (cr); } - if (is_active) - color = &style->fg[state]; - else - color = &style->fg[state]; +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_style_context_get_color (style, state, &color); + gdk_cairo_set_source_rgba (cr, &color); +#else + color = &style->fg[state]; cairo_set_source_rgb (cr, color->red / 65535., color->green / 65535., color->blue / 65535.); +#endif cairo_set_line_width (cr, 1.0); cairo_rectangle (cr, winrect->x + 0.5, winrect->y + 0.5, @@ -198,10 +219,13 @@ wnck_draw_workspace (GtkWidget *widget, { int i; GdkRectangle workspace_rect; +#if GTK_CHECK_VERSION(3, 0, 0) + GtkStateFlags state; + GtkStyleContext *style; +#else GtkStateType state; - #if !GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr; - #endif +#endif workspace_rect.x = x; workspace_rect.y = y; @@ -209,14 +233,27 @@ wnck_draw_workspace (GtkWidget *widget, workspace_rect.height = height; if (is_active) +#if GTK_CHECK_VERSION (3, 0, 0) + state = GTK_STATE_FLAG_SELECTED; +#else state = GTK_STATE_SELECTED; +#endif else if (workspace_background) +#if GTK_CHECK_VERSION (3, 0, 0) + state = GTK_STATE_FLAG_PRELIGHT; +#else state = GTK_STATE_PRELIGHT; +#endif else +#if GTK_CHECK_VERSION (3, 0, 0) + state = GTK_STATE_FLAG_NORMAL; +#else state = GTK_STATE_NORMAL; +#endif #if GTK_CHECK_VERSION(3, 0, 0) - cairo_save(cr); + style = gtk_widget_get_style_context (widget); + cairo_save (cr); #else cr = gdk_cairo_create (drawable); #endif @@ -228,7 +265,14 @@ wnck_draw_workspace (GtkWidget *widget, } else { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; + + mate_desktop_gtk_style_get_dark_color (style,state, &color); + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, >k_widget_get_style (widget)->dark[state]); +#endif cairo_rectangle (cr, x, y, width, height); cairo_fill (cr); } diff --git a/src/ui/fixedtip.c b/src/ui/fixedtip.c index 6f07c6bb..fc1be2af 100644 --- a/src/ui/fixedtip.c +++ b/src/ui/fixedtip.c @@ -84,7 +84,7 @@ expose_handler (GtkTooltips *tooltips) #endif void -meta_fixed_tip_show (Display *xdisplay, int screen_number, +meta_fixed_tip_show (int screen_number, int root_x, int root_y, const char *markup_text) { diff --git a/src/ui/fixedtip.h b/src/ui/fixedtip.h index e3eac8f5..f20f0d2c 100644 --- a/src/ui/fixedtip.h +++ b/src/ui/fixedtip.h @@ -49,13 +49,12 @@ * displayed, but if it is the window will be reused rather than destroyed * and recreated. * - * \param xdisplay An X display. * \param screen_number The number of the screen. * \param root_x The X coordinate where the tooltip should appear * \param root_y The Y coordinate where the tooltip should appear * \param markup_text Text to display in the tooltip; can contain markup */ -void meta_fixed_tip_show (Display *xdisplay, int screen_number, +void meta_fixed_tip_show (int screen_number, int root_x, int root_y, const char *markup_text); diff --git a/src/ui/frames.c b/src/ui/frames.c index 60e09ea3..099c5052 100644 --- a/src/ui/frames.c +++ b/src/ui/frames.c @@ -1099,16 +1099,14 @@ meta_frames_move_resize_frame (MetaFrames *frames, int height) { MetaUIFrame *frame = meta_frames_lookup_window (frames, xwindow); - int old_x, old_y, old_width, old_height; + int old_width, old_height; - #if GTK_CHECK_VERSION(3, 0, 0) - old_width = gdk_window_get_width(GDK_WINDOW(frame->window)); - old_height = gdk_window_get_height(GDK_WINDOW(frame->window)); - #else - gdk_drawable_get_size(frame->window, &old_width, &old_height); - #endif - - gdk_window_get_position (frame->window, &old_x, &old_y); +#if GTK_CHECK_VERSION(3, 0, 0) + old_width = gdk_window_get_width (frame->window); + old_height = gdk_window_get_height (frame->window); +#else + gdk_drawable_get_size(frame->window, &old_width, &old_height); +#endif gdk_window_move_resize (frame->window, x, y, width, height); @@ -1270,8 +1268,7 @@ show_tip_now (MetaFrames *frames) screen_number = gdk_screen_get_number (gtk_widget_get_screen (GTK_WIDGET (frames))); - meta_fixed_tip_show (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), - screen_number, + meta_fixed_tip_show (screen_number, rect->x + dx, rect->y + rect->height + 2 + dy, tiptext); @@ -2580,7 +2577,6 @@ meta_frames_paint_to_drawable (MetaFrames *frames, int y_offset) #endif { - GtkWidget *widget; MetaFrameFlags flags; MetaFrameType type; GdkPixbuf *mini_icon; @@ -2592,8 +2588,6 @@ meta_frames_paint_to_drawable (MetaFrames *frames, MetaButtonLayout button_layout; MetaGrabOp grab_op; - widget = GTK_WIDGET (frames); - for (i = 0; i < META_BUTTON_TYPE_LAST; i++) button_states[i] = META_BUTTON_STATE_NORMAL; @@ -2694,7 +2688,6 @@ meta_frames_paint_to_drawable (MetaFrames *frames, meta_theme_draw_frame_with_style (meta_theme_get_current (), frame->style, - widget, cr, type, flags, @@ -2767,8 +2760,11 @@ meta_frames_paint_to_drawable (MetaFrames *frames, gdk_window_begin_paint_rect (drawable, &areas[i]); meta_theme_draw_frame_with_style (meta_theme_get_current (), +#if GTK_CHECK_VERSION (3, 0, 0) frame->style, - widget, +#else + GTK_WIDGET(frames), +#endif drawable, NULL, /* &areas[i], */ x_offset, y_offset, @@ -2793,8 +2789,11 @@ meta_frames_paint_to_drawable (MetaFrames *frames, /* Not a window; happens about 1/3 of the time */ meta_theme_draw_frame_with_style (meta_theme_get_current (), +#if GTK_CHECK_VERSION (3, 0, 0) frame->style, - widget, +#else + GTK_WIDGET(frames), +#endif drawable, NULL, x_offset, y_offset, @@ -2835,23 +2834,35 @@ meta_frames_set_window_background (MetaFrames *frames, if (frame_exists && style->window_background_color != NULL) { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif GdkVisual *visual; meta_color_spec_render (style->window_background_color, - GTK_WIDGET (frames), + frame->style, &color); /* Set A in ARGB to window_background_alpha, if we have ARGB */ visual = gtk_widget_get_visual (GTK_WIDGET (frames)); - if (gdk_visual_get_depth(visual) == 32) /* we have ARGB */ + if (gdk_visual_get_depth (visual) == 32) /* we have ARGB */ + #if GTK_CHECK_VERSION(3, 0, 0) + { + color.alpha = style->window_background_alpha / 255.0; + } + + gdk_window_set_background_rgba (frame->window, &color); + #else { color.pixel = (color.pixel & 0xffffff) & style->window_background_alpha << 24; } gdk_window_set_background (frame->window, &color); + #endif } else { diff --git a/src/ui/gradient.c b/src/ui/gradient.c index 78a5a9eb..dfdb2fa1 100644 --- a/src/ui/gradient.c +++ b/src/ui/gradient.c @@ -26,9 +26,37 @@ #include "util.h" #include +#include + /* This is all Alfredo's and Dan's usual very nice WindowMaker code, * slightly GTK-ized */ +#if GTK_CHECK_VERSION (3, 0, 0) +static GdkPixbuf* meta_gradient_create_horizontal (int width, + int height, + const GdkRGBA *from, + const GdkRGBA *to); +static GdkPixbuf* meta_gradient_create_vertical (int width, + int height, + const GdkRGBA *from, + const GdkRGBA *to); +static GdkPixbuf* meta_gradient_create_diagonal (int width, + int height, + const GdkRGBA *from, + const GdkRGBA *to); +static GdkPixbuf* meta_gradient_create_multi_horizontal (int width, + int height, + const GdkRGBA *colors, + int count); +static GdkPixbuf* meta_gradient_create_multi_vertical (int width, + int height, + const GdkRGBA *colors, + int count); +static GdkPixbuf* meta_gradient_create_multi_diagonal (int width, + int height, + const GdkRGBA *colors, + int count); +#else static GdkPixbuf* meta_gradient_create_horizontal (int width, int height, const GdkColor *from, @@ -53,6 +81,7 @@ static GdkPixbuf* meta_gradient_create_multi_diagonal (int width, int height, const GdkColor *colors, int count); +#endif /* Used as the destroy notification function for gdk_pixbuf_new() */ @@ -87,12 +116,21 @@ blank_pixbuf (int width, int height, gboolean no_padding) free_buffer, NULL); } +#if GTK_CHECK_VERSION (3, 0, 0) +GdkPixbuf* +meta_gradient_create_simple (int width, + int height, + const GdkRGBA *from, + const GdkRGBA *to, + MetaGradientType style) +#else GdkPixbuf* meta_gradient_create_simple (int width, int height, const GdkColor *from, const GdkColor *to, MetaGradientType style) +#endif { switch (style) { @@ -113,12 +151,21 @@ meta_gradient_create_simple (int width, return NULL; } +#if GTK_CHECK_VERSION (3, 0, 0) +GdkPixbuf* +meta_gradient_create_multi (int width, + int height, + const GdkRGBA *colors, + int n_colors, + MetaGradientType style) +#else GdkPixbuf* meta_gradient_create_multi (int width, int height, const GdkColor *colors, int n_colors, MetaGradientType style) +#endif { if (n_colors > 2) @@ -155,6 +202,15 @@ meta_gradient_create_multi (int width, * are alternated. I'm not sure what it's good for, just copied since * WindowMaker had it. */ +#if GTK_CHECK_VERSION (3, 0, 0) +GdkPixbuf* +meta_gradient_create_interwoven (int width, + int height, + const GdkRGBA colors1[2], + int thickness1, + const GdkRGBA colors2[2], + int thickness2) +#else GdkPixbuf* meta_gradient_create_interwoven (int width, int height, @@ -162,6 +218,7 @@ meta_gradient_create_interwoven (int width, int thickness1, const GdkColor colors2[2], int thickness2) +#endif { int i, j, k, l, ll; @@ -179,6 +236,23 @@ meta_gradient_create_interwoven (int width, pixels = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); +#if GTK_CHECK_VERSION (3, 0, 0) + r1 = (long)(colors1[0].red*0xffffff); + g1 = (long)(colors1[0].green*0xffffff); + b1 = (long)(colors1[0].blue*0xffffff); + + r2 = (long)(colors2[0].red*0xffffff); + g2 = (long)(colors2[0].green*0xffffff); + b2 = (long)(colors2[0].blue*0xffffff); + + dr1 = ((colors1[1].red-colors1[0].red)*0xffffff)/(int)height; + dg1 = ((colors1[1].green-colors1[0].green)*0xffffff)/(int)height; + db1 = ((colors1[1].blue-colors1[0].blue)*0xffffff)/(int)height; + + dr2 = ((colors2[1].red-colors2[0].red)*0xffffff)/(int)height; + dg2 = ((colors2[1].green-colors2[0].green)*0xffffff)/(int)height; + db2 = ((colors2[1].blue-colors2[0].blue)*0xffffff)/(int)height; +#else r1 = colors1[0].red<<8; g1 = colors1[0].green<<8; b1 = colors1[0].blue<<8; @@ -194,6 +268,7 @@ meta_gradient_create_interwoven (int width, dr2 = ((colors2[1].red-colors2[0].red)<<8)/(int)height; dg2 = ((colors2[1].green-colors2[0].green)<<8)/(int)height; db2 = ((colors2[1].blue-colors2[0].blue)<<8)/(int)height; +#endif for (i=0,k=0,l=0,ll=thickness1; ired * 0xff); + g0 = (guchar) (from->green * 0xff); + b0 = (guchar) (from->blue * 0xff); + rf = (guchar) (to->red * 0xff); + gf = (guchar) (to->green * 0xff); + bf = (guchar) (to->blue * 0xff); +#else r0 = (guchar) (from->red / 256.0); g0 = (guchar) (from->green / 256.0); b0 = (guchar) (from->blue / 256.0); rf = (guchar) (to->red / 256.0); gf = (guchar) (to->green / 256.0); bf = (guchar) (to->blue / 256.0); +#endif r = r0 << 16; g = g0 << 16; @@ -323,10 +414,17 @@ meta_gradient_create_horizontal (int width, int height, * None *---------------------------------------------------------------------- */ +#if GTK_CHECK_VERSION (3, 0, 0) +static GdkPixbuf* +meta_gradient_create_vertical (int width, int height, + const GdkRGBA *from, + const GdkRGBA *to) +#else static GdkPixbuf* meta_gradient_create_vertical (int width, int height, const GdkColor *from, const GdkColor *to) +#endif { int i, j; long r, g, b, dr, dg, db; @@ -344,12 +442,21 @@ meta_gradient_create_vertical (int width, int height, pixels = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); +#if GTK_CHECK_VERSION (3, 0, 0) + r0 = (guchar) (from->red * 0xff); + g0 = (guchar) (from->green * 0xff); + b0 = (guchar) (from->blue * 0xff); + rf = (guchar) (to->red * 0xff); + gf = (guchar) (to->green * 0xff); + bf = (guchar) (to->blue * 0xff); +#else r0 = (guchar) (from->red / 256.0); g0 = (guchar) (from->green / 256.0); b0 = (guchar) (from->blue / 256.0); rf = (guchar) (to->red / 256.0); gf = (guchar) (to->green / 256.0); bf = (guchar) (to->blue / 256.0); +#endif r = r0<<16; g = g0<<16; @@ -393,11 +500,17 @@ meta_gradient_create_vertical (int width, int height, *---------------------------------------------------------------------- */ - +#if GTK_CHECK_VERSION (3, 0, 0) +static GdkPixbuf* +meta_gradient_create_diagonal (int width, int height, + const GdkRGBA *from, + const GdkRGBA *to) +#else static GdkPixbuf* meta_gradient_create_diagonal (int width, int height, const GdkColor *from, const GdkColor *to) +#endif { GdkPixbuf *pixbuf, *tmp; int j; @@ -441,11 +554,17 @@ meta_gradient_create_diagonal (int width, int height, return pixbuf; } - +#if GTK_CHECK_VERSION (3, 0, 0) +static GdkPixbuf* +meta_gradient_create_multi_horizontal (int width, int height, + const GdkRGBA *colors, + int count) +#else static GdkPixbuf* meta_gradient_create_multi_horizontal (int width, int height, const GdkColor *colors, int count) +#endif { int i, j, k; long r, g, b, dr, dg, db; @@ -475,16 +594,28 @@ meta_gradient_create_multi_horizontal (int width, int height, k = 0; +#if GTK_CHECK_VERSION (3, 0, 0) + r = (long)(colors[0].red * 0xffffff); + g = (long)(colors[0].green * 0xffffff); + b = (long)(colors[0].blue * 0xffffff); +#else r = colors[0].red << 8; g = colors[0].green << 8; b = colors[0].blue << 8; +#endif /* render the first line */ for (i=1; i>16); @@ -495,9 +626,15 @@ meta_gradient_create_multi_horizontal (int width, int height, b += db; k++; } +#if GTK_CHECK_VERSION (3, 0, 0) + r = (long)(colors[i].red * 0xffffff); + g = (long)(colors[i].green * 0xffffff); + b = (long)(colors[i].blue * 0xffffff); +#else r = colors[i].red << 8; g = colors[i].green << 8; b = colors[i].blue << 8; +#endif } for (j=k; j #include +#include typedef enum { @@ -35,6 +36,24 @@ typedef enum META_GRADIENT_LAST } MetaGradientType; +#if GTK_CHECK_VERSION (3, 0 ,0) +GdkPixbuf* meta_gradient_create_simple (int width, + int height, + const GdkRGBA *from, + const GdkRGBA *to, + MetaGradientType style); +GdkPixbuf* meta_gradient_create_multi (int width, + int height, + const GdkRGBA *colors, + int n_colors, + MetaGradientType style); +GdkPixbuf* meta_gradient_create_interwoven (int width, + int height, + const GdkRGBA colors1[2], + int thickness1, + const GdkRGBA colors2[2], + int thickness2); +#else GdkPixbuf* meta_gradient_create_simple (int width, int height, const GdkColor *from, @@ -51,6 +70,7 @@ GdkPixbuf* meta_gradient_create_interwoven (int width, int thickness1, const GdkColor colors2[2], int thickness2); +#endif /* Generate an alpha gradient and multiply it with the existing alpha diff --git a/src/ui/menu.c b/src/ui/menu.c index 41abc441..1dfc7140 100644 --- a/src/ui/menu.c +++ b/src/ui/menu.c @@ -106,7 +106,11 @@ static void popup_position_func(GtkMenu* menu, gint* x, gint* y, gboolean* push_ pos = user_data; +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL); +#else gtk_widget_size_request(GTK_WIDGET(menu), &req); +#endif *x = pos->x; *y = pos->y; @@ -148,7 +152,7 @@ static void activate_cb(GtkWidget* menuitem, gpointer data) md = data; - meta_frames_notify_menu_hide(md->menu->frames); + meta_frames_notify_menu_hide (md->menu->frames); (*md->menu->func)( md->menu, @@ -159,7 +163,7 @@ static void activate_cb(GtkWidget* menuitem, gpointer data) GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), "workspace")), md->menu->data); - /* menu may now be freed */ + /* menu may now be freed */ } /* @@ -389,7 +393,7 @@ meta_window_menu_new (MetaFrames *frames, meta_verbose ("Creating %d-workspace menu current space %lu\n", n_workspaces, active_workspace); - GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(frames)); + GdkWindow* window = gtk_widget_get_window (GTK_WIDGET (frames)); display = GDK_WINDOW_XDISPLAY (window); @@ -497,9 +501,10 @@ meta_window_menu_new (MetaFrames *frames, } } - g_signal_connect (menu->menu, "selection_done", G_CALLBACK(menu_closed), menu); + g_signal_connect (menu->menu, "selection_done", + G_CALLBACK (menu_closed), menu); - return menu; + return menu; } void meta_window_menu_popup(MetaWindowMenu* menu, int root_x, int root_y, int button, guint32 timestamp) diff --git a/src/ui/preview-widget.c b/src/ui/preview-widget.c index 0bc6b42a..58122706 100644 --- a/src/ui/preview-widget.c +++ b/src/ui/preview-widget.c @@ -253,6 +253,66 @@ ensure_info (MetaPreview *preview) } #if GTK_CHECK_VERSION(3, 0, 0) +static gboolean +meta_preview_draw (GtkWidget *widget, + cairo_t *cr) +{ + MetaPreview *preview; + GtkAllocation allocation; + int border_width; + int client_width; + int client_height; + MetaButtonState button_states[META_BUTTON_TYPE_LAST] = + { + META_BUTTON_STATE_NORMAL, + META_BUTTON_STATE_NORMAL, + META_BUTTON_STATE_NORMAL, + META_BUTTON_STATE_NORMAL + }; + + g_return_val_if_fail (META_IS_PREVIEW (widget), FALSE); + + preview = META_PREVIEW (widget); + + ensure_info (preview); + + cairo_save (cr); + + border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); + + gtk_widget_get_allocation (widget, &allocation); + client_width = allocation.width - preview->left_width - preview->right_width - border_width * 2; + client_height = allocation.height - preview->top_height - preview->bottom_height - border_width * 2; + + if (client_width < 0) + client_width = 1; + if (client_height < 0) + client_height = 1; + + if (preview->theme) + { + border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); + + meta_theme_draw_frame (preview->theme, + widget, + cr, + preview->type, + preview->flags, + client_width, client_height, + preview->layout, + preview->text_height, + &preview->button_layout, + button_states, + meta_preview_get_mini_icon (), + meta_preview_get_icon ()); + } + + cairo_restore (cr); + + /* draw child */ + return GTK_WIDGET_CLASS (meta_preview_parent_class)->draw (widget, cr); +} + static void meta_preview_get_preferred_width (GtkWidget *widget, gint *minimum, @@ -325,66 +385,6 @@ meta_preview_get_preferred_height (GtkWidget *widget, *natural += border_width * 2; } -static gboolean -meta_preview_draw(GtkWidget *widget, - cairo_t *cr) -{ - MetaPreview *preview; - GtkAllocation allocation; - int border_width; - int client_width; - int client_height; - MetaButtonState button_states[META_BUTTON_TYPE_LAST] = - { - META_BUTTON_STATE_NORMAL, - META_BUTTON_STATE_NORMAL, - META_BUTTON_STATE_NORMAL, - META_BUTTON_STATE_NORMAL - }; - - g_return_val_if_fail (META_IS_PREVIEW (widget), FALSE); - - preview = META_PREVIEW (widget); - - ensure_info (preview); - - cairo_save (cr); - - border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); - - gtk_widget_get_allocation (widget, &allocation); - client_width = allocation.width - preview->left_width - preview->right_width - border_width * 2; - client_height = allocation.height - preview->top_height - preview->bottom_height - border_width * 2; - - if (client_width < 0) - client_width = 1; - if (client_height < 0) - client_height = 1; - - if (preview->theme) - { - border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); - - meta_theme_draw_frame (preview->theme, - widget, - cr, - preview->type, - preview->flags, - client_width, client_height, - preview->layout, - preview->text_height, - &preview->button_layout, - button_states, - meta_preview_get_mini_icon (), - meta_preview_get_icon ()); - } - - cairo_restore (cr); - - /* draw child */ - return GTK_WIDGET_CLASS (meta_preview_parent_class)->draw (widget, cr); -} - #else static gboolean diff --git a/src/ui/resizepopup.c b/src/ui/resizepopup.c index 7dc6ec5a..977b196b 100644 --- a/src/ui/resizepopup.c +++ b/src/ui/resizepopup.c @@ -126,7 +126,7 @@ update_size_window (MetaResizePopup *popup) if (gtk_widget_get_realized (popup->size_window)) { /* using move_resize to avoid jumpiness */ - gdk_window_move_resize (gtk_widget_get_window(GTK_WIDGET(popup->size_window)), + gdk_window_move_resize (gtk_widget_get_window (popup->size_window), x, y, width, height); } diff --git a/src/ui/tabpopup.c b/src/ui/tabpopup.c index 4c4cf308..dfbdf1a4 100644 --- a/src/ui/tabpopup.c +++ b/src/ui/tabpopup.c @@ -81,15 +81,23 @@ static void select_workspace (GtkWidget *widget); static void unselect_workspace (GtkWidget *widget); static gboolean +#if GTK_CHECK_VERSION (3, 0, 0) +outline_window_draw (GtkWidget *widget, + cairo_t *cr, + gpointer data) +#else outline_window_expose (GtkWidget *widget, GdkEventExpose *event, gpointer data) +#endif { MetaTabPopup *popup; TabEntry *te; +#if !GTK_CHECK_VERSION (3, 0, 0) GtkStyle *style; GdkWindow *window; cairo_t *cr; +#endif popup = data; @@ -97,12 +105,18 @@ outline_window_expose (GtkWidget *widget, return FALSE; te = popup->current_selected_entry; +#if !GTK_CHECK_VERSION (3, 0, 0) window = gtk_widget_get_window (widget); style = gtk_widget_get_style (widget); cr = gdk_cairo_create (window); +#endif cairo_set_line_width (cr, 1.0); +#if GTK_CHECK_VERSION (3, 0, 0) + cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); +#else gdk_cairo_set_source_color (cr, &style->white); +#endif cairo_rectangle (cr, 0.5, 0.5, @@ -116,7 +130,9 @@ outline_window_expose (GtkWidget *widget, te->inner_rect.height + 1); cairo_stroke (cr); +#if !GTK_CHECK_VERSION (3, 0, 0) cairo_destroy (cr); +#endif return FALSE; } @@ -236,7 +252,11 @@ meta_ui_tab_popup_new (const MetaTabEntry *entries, MetaTabPopup *popup; int i, left, right, top, bottom; int height; +#if GTK_CHECK_VERSION (3, 0, 0) + GtkWidget *grid; +#else GtkWidget *table; +#endif GtkWidget *vbox; GtkWidget *align; GList *tmp; @@ -258,8 +278,13 @@ meta_ui_tab_popup_new (const MetaTabEntry *entries, gtk_widget_set_app_paintable (popup->outline_window, TRUE); gtk_widget_realize (popup->outline_window); +#if GTK_CHECK_VERSION (3, 0, 0) + g_signal_connect (G_OBJECT (popup->outline_window), "draw", + G_CALLBACK (outline_window_draw), popup); +#else g_signal_connect (G_OBJECT (popup->outline_window), "expose_event", G_CALLBACK (outline_window_expose), popup); +#endif popup->window = gtk_window_new (GTK_WINDOW_POPUP); @@ -290,12 +315,21 @@ meta_ui_tab_popup_new (const MetaTabEntry *entries, if (i % width) height += 1; - table = gtk_table_new (height, width, FALSE); vbox = gtk_vbox_new (FALSE, 0); +#if GTK_CHECK_VERSION (3, 0, 0) + grid = gtk_grid_new (); +#else + table = gtk_table_new (height, width, FALSE); +#endif + frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_container_set_border_width (GTK_CONTAINER (grid), 1); +#else gtk_container_set_border_width (GTK_CONTAINER (table), 1); +#endif gtk_container_add (GTK_CONTAINER (popup->window), frame); gtk_container_add (GTK_CONTAINER (frame), @@ -305,8 +339,13 @@ meta_ui_tab_popup_new (const MetaTabEntry *entries, gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_container_add (GTK_CONTAINER (align), + grid); +#else gtk_container_add (GTK_CONTAINER (align), table); +#endif popup->label = gtk_label_new (""); @@ -368,16 +407,24 @@ meta_ui_tab_popup_new (const MetaTabEntry *entries, te->widget = image; +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_grid_attach (GTK_GRID (grid), te->widget, left, top, 1, 1); +#else gtk_table_attach (GTK_TABLE (table), te->widget, left, right, top, bottom, 0, 0, 0, 0); +#endif /* Efficiency rules! */ gtk_label_set_markup (GTK_LABEL (popup->label), te->title); +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_widget_get_preferred_size (popup->label, &req, NULL); +#else gtk_widget_size_request (popup->label, &req); +#endif max_label_width = MAX (max_label_width, req.width); tmp = tmp->next; @@ -431,7 +478,8 @@ meta_ui_tab_popup_free (MetaTabPopup *popup) { meta_verbose ("Destroying tab popup window\n"); - gtk_widget_destroy (popup->outline_window); + if (popup->outline_window != NULL) + gtk_widget_destroy (popup->outline_window); gtk_widget_destroy (popup->window); g_list_foreach (popup->entries, free_tab_entry, NULL); @@ -736,7 +784,11 @@ meta_select_image_draw (GtkWidget *widget, misc = GTK_MISC (widget); +#if GTK_CHECK_VERSION (3, 0, 0) + gtk_widget_get_preferred_size (widget, &requisition, NULL); +#else gtk_widget_get_requisition (widget, &requisition); +#endif gtk_misc_get_alignment (misc, &xalign, &yalign); gtk_misc_get_padding (misc, &xpad, &ypad); @@ -895,8 +947,8 @@ unselect_workspace (GtkWidget *widget) static void meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass); #if GTK_CHECK_VERSION(3, 0, 0) -static gboolean meta_select_workspace_draw (GtkWidget *widget, - cairo_t *cr); +static gboolean meta_select_workspace_draw (GtkWidget *widget, + cairo_t *cr); #else static gboolean meta_select_workspace_expose_event (GtkWidget *widget, GdkEventExpose *event); diff --git a/src/ui/testgradient.c b/src/ui/testgradient.c index 8f8cd6a5..8875452d 100644 --- a/src/ui/testgradient.c +++ b/src/ui/testgradient.c @@ -23,12 +23,6 @@ #include "gradient.h" #include -#ifdef __GNUC__ -#define UNUSED_VARIABLE __attribute__ ((unused)) -#else -#define UNUSED_VARIABLE -#endif - typedef void (* RenderGradientFunc) ( #if !GTK_CHECK_VERSION (3, 0, 0) GdkDrawable *drawable, @@ -47,14 +41,27 @@ draw_checkerboard (GdkDrawable *drawable, int height) { gint i, j, xcount, ycount; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color1, color2; +#else GdkColor color1, color2; -#if !GTK_CHECK_VERSION (3, 0, 0) cairo_t *cr; #endif #define CHECK_SIZE 10 #define SPACING 2 +#if GTK_CHECK_VERSION (3, 0, 0) + color1.red = 30000. / 65535.; + color1.green = 30000. / 65535.; + color1.blue = 30000. / 65535.; + color1.alpha = 1.0; + + color2.red = 50000. / 65535.; + color2.green = 50000. / 65535.; + color2.blue = 50000. / 65535.; + color2.alpha = 1.0; +#else color1.red = 30000; color1.green = 30000; color1.blue = 30000; @@ -63,7 +70,6 @@ draw_checkerboard (GdkDrawable *drawable, color2.green = 50000; color2.blue = 50000; -#if !GTK_CHECK_VERSION (3, 0, 0) cr = gdk_cairo_create (drawable); #endif @@ -76,9 +82,17 @@ draw_checkerboard (GdkDrawable *drawable, while (j < height) { if (ycount % 2) +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color1); +#else gdk_cairo_set_source_color (cr, &color1); +#endif else +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color2); +#else gdk_cairo_set_source_color (cr, &color2); +#endif /* If we're outside event->area, this will do nothing. * It might be mildly more efficient if we handled @@ -111,10 +125,17 @@ render_simple ( gboolean with_alpha) { GdkPixbuf *pixbuf; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA from, to; + + gdk_rgba_parse (&from, "blue"); + gdk_rgba_parse (&to, "green"); +#else GdkColor from, to; gdk_color_parse ("blue", &from); gdk_color_parse ("green", &to); +#endif pixbuf = meta_gradient_create_simple (width, height, &from, &to, @@ -138,7 +159,7 @@ render_simple ( META_GRADIENT_HORIZONTAL); #if GTK_CHECK_VERSION (3, 0, 0) - draw_checkerboard (cr , width, height); + draw_checkerboard (cr, width, height); #else draw_checkerboard (drawable, width, height); #endif @@ -222,6 +243,16 @@ render_multi ( { GdkPixbuf *pixbuf; #define N_COLORS 5 + +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA colors[N_COLORS]; + + gdk_rgba_parse (&colors[0], "red"); + gdk_rgba_parse (&colors[1], "blue"); + gdk_rgba_parse (&colors[2], "orange"); + gdk_rgba_parse (&colors[3], "pink"); + gdk_rgba_parse (&colors[4], "green"); +#else GdkColor colors[N_COLORS]; gdk_color_parse ("red", &colors[0]); @@ -229,6 +260,7 @@ render_multi ( gdk_color_parse ("orange", &colors[2]); gdk_color_parse ("pink", &colors[3]); gdk_color_parse ("green", &colors[4]); +#endif pixbuf = meta_gradient_create_multi (width, height, colors, N_COLORS, @@ -297,12 +329,22 @@ render_interwoven_func ( { GdkPixbuf *pixbuf; #define N_COLORS 4 + +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA colors[N_COLORS]; + + gdk_rgba_parse (&colors[0], "red"); + gdk_rgba_parse (&colors[1], "blue"); + gdk_rgba_parse (&colors[2], "pink"); + gdk_rgba_parse (&colors[3], "green"); +#else GdkColor colors[N_COLORS]; gdk_color_parse ("red", &colors[0]); gdk_color_parse ("blue", &colors[1]); gdk_color_parse ("pink", &colors[2]); gdk_color_parse ("green", &colors[3]); +#endif pixbuf = meta_gradient_create_interwoven (width, height, colors, height / 10, @@ -327,21 +369,34 @@ expose_callback (GtkWidget *widget, #endif { RenderGradientFunc func = data; - GdkWindow *window; GtkAllocation allocation; +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStyleContext *style; + GdkRGBA color; + + style = gtk_widget_get_style_context (widget); + + gtk_style_context_save (style); + gtk_style_context_set_state (style, gtk_widget_get_state_flags (widget)); + gtk_style_context_lookup_color (style, "foreground-color", &color); + gtk_style_context_restore (style); +#else + GdkWindow *window; GtkStyle *style; -#if !GTK_CHECK_VERSION (3, 0, 0) cairo_t *cr; -#endif style = gtk_widget_get_style (widget); +#endif + gtk_widget_get_allocation (widget, &allocation); +#if GTK_CHECK_VERSION (3, 0, 0) + cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); +#else window = gtk_widget_get_window (widget); -#if !GTK_CHECK_VERSION (3, 0, 0) cr = gdk_cairo_create (window); -#endif gdk_cairo_set_source_color (cr, &style->fg[gtk_widget_get_state (widget)]); +#endif (* func) ( #if !GTK_CHECK_VERSION (3, 0, 0) @@ -399,31 +454,29 @@ create_gradient_window (const char *title, static void meta_gradient_test (void) { - GtkWidget UNUSED_VARIABLE *window; - - window = create_gradient_window ("Simple vertical", - render_vertical_func); + create_gradient_window ("Simple vertical", + render_vertical_func); - window = create_gradient_window ("Simple horizontal", - render_horizontal_func); + create_gradient_window ("Simple horizontal", + render_horizontal_func); - window = create_gradient_window ("Simple diagonal", - render_diagonal_func); + create_gradient_window ("Simple diagonal", + render_diagonal_func); - window = create_gradient_window ("Multi vertical", - render_vertical_multi_func); + create_gradient_window ("Multi vertical", + render_vertical_multi_func); - window = create_gradient_window ("Multi horizontal", - render_horizontal_multi_func); + create_gradient_window ("Multi horizontal", + render_horizontal_multi_func); - window = create_gradient_window ("Multi diagonal", - render_diagonal_multi_func); + create_gradient_window ("Multi diagonal", + render_diagonal_multi_func); - window = create_gradient_window ("Interwoven", - render_interwoven_func); + create_gradient_window ("Interwoven", + render_interwoven_func); - window = create_gradient_window ("Simple diagonal with horizontal multi alpha", - render_diagonal_alpha_func); + create_gradient_window ("Simple diagonal with horizontal multi alpha", + render_diagonal_alpha_func); } diff --git a/src/ui/theme-parser.c b/src/ui/theme-parser.c index dccb47ad..f60c7619 100644 --- a/src/ui/theme-parser.c +++ b/src/ui/theme-parser.c @@ -190,12 +190,12 @@ static void parse_shadow_element (GMarkupParseContext *context, ParseInfo *info, GError **error); -static void parse_padding_element (GMarkupParseContext *context, - const gchar *element_name, - const gchar **attribute_names, - const gchar **attribute_values, - ParseInfo *info, - GError **error); +static void parse_padding_element (GMarkupParseContext *context, + const gchar *element_name, + const gchar **attribute_names, + const gchar **attribute_values, + ParseInfo *info, + GError **error); #endif static void parse_menu_icon_element (GMarkupParseContext *context, const gchar *element_name, diff --git a/src/ui/theme.c b/src/ui/theme.c index 2e13fd25..a7dc8d08 100644 --- a/src/ui/theme.c +++ b/src/ui/theme.c @@ -63,6 +63,23 @@ #define __USE_XOPEN #include +#if GTK_CHECK_VERSION (3, 0, 0) +#define MATE_DESKTOP_USE_UNSTABLE_API +#include +#endif + +#if GTK_CHECK_VERSION (3, 0, 0) +#define GDK_COLOR_RGBA(color) \ + ((guint32) (0xff | \ + ((int)((color).red * 255) << 24) | \ + ((int)((color).green * 255) << 16) | \ + ((int)((color).blue * 255) << 8))) + +#define GDK_COLOR_RGB(color) \ + ((guint32) (((int)((color).red * 255) << 16) | \ + ((int)((color).green * 255) << 8) | \ + ((int)((color).blue * 255)))) +#else #define GDK_COLOR_RGBA(color) \ ((guint32) (0xff | \ (((color).red / 256) << 24) | \ @@ -73,6 +90,7 @@ ((guint32) ((((color).red / 256) << 16) | \ (((color).green / 256) << 8) | \ (((color).blue / 256)))) +#endif #define ALPHA_TO_UCHAR(d) ((unsigned char) ((d) * 255)) @@ -80,9 +98,15 @@ #define CLAMP_UCHAR(v) ((guchar) (CLAMP (((int)v), (int)0, (int)255))) #define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11) +#if GTK_CHECK_VERSION (3, 0, 0) +static void gtk_style_shade (GdkRGBA *a, + GdkRGBA *b, + gdouble k); +#else static void gtk_style_shade (GdkColor *a, GdkColor *b, gdouble k); +#endif static void rgb_to_hls (gdouble *r, gdouble *g, gdouble *b); @@ -95,9 +119,15 @@ static void hls_to_rgb (gdouble *h, */ static MetaTheme *meta_current_theme = NULL; +#if GTK_CHECK_VERSION (3, 0, 0) +static GdkPixbuf * +colorize_pixbuf (GdkPixbuf *orig, + GdkRGBA *new_color) +#else static GdkPixbuf * colorize_pixbuf (GdkPixbuf *orig, GdkColor *new_color) +#endif { GdkPixbuf *pixbuf; double intensity; @@ -140,16 +170,28 @@ colorize_pixbuf (GdkPixbuf *orig, if (intensity <= 0.5) { /* Go from black at intensity = 0.0 to new_color at intensity = 0.5 */ +#if GTK_CHECK_VERSION (3, 0, 0) + dr = new_color->red * intensity * 2.0; + dg = new_color->green * intensity * 2.0; + db = new_color->blue * intensity * 2.0; +#else dr = (new_color->red * intensity * 2.0) / 65535.0; dg = (new_color->green * intensity * 2.0) / 65535.0; db = (new_color->blue * intensity * 2.0) / 65535.0; +#endif } else { /* Go from new_color at intensity = 0.5 to white at intensity = 1.0 */ +#if GTK_CHECK_VERSION (3, 0, 0) + dr = new_color->red + (1.0 - new_color->red) * (intensity - 0.5) * 2.0; + dg = new_color->green + (1.0 - new_color->green) * (intensity - 0.5) * 2.0; + db = new_color->blue + (1.0 - new_color->blue) * (intensity - 0.5) * 2.0; +#else dr = (new_color->red + (65535 - new_color->red) * (intensity - 0.5) * 2.0) / 65535.0; dg = (new_color->green + (65535 - new_color->green) * (intensity - 0.5) * 2.0) / 65535.0; db = (new_color->blue + (65535 - new_color->blue) * (intensity - 0.5) * 2.0) / 65535.0; +#endif } dest[0] = CLAMP_UCHAR (255 * dr); @@ -173,6 +215,19 @@ colorize_pixbuf (GdkPixbuf *orig, return pixbuf; } +#if GTK_CHECK_VERSION (3, 0, 0) +static void +color_composite (const GdkRGBA *bg, + const GdkRGBA *fg, + double alpha, + GdkRGBA *color) +{ + *color = *bg; + color->red = color->red + (fg->red - color->red) * alpha; + color->green = color->green + (fg->green - color->green) * alpha; + color->blue = color->blue + (fg->blue - color->blue) * alpha; +} +#else static void color_composite (const GdkColor *bg, const GdkColor *fg, @@ -187,6 +242,7 @@ color_composite (const GdkColor *bg, color->green = color->green + (((fg->green - color->green) * alpha + 0x8000) >> 16); color->blue = color->blue + (((fg->blue - color->blue) * alpha + 0x8000) >> 16); } +#endif /** * Sets all the fields of a border to dummy values. @@ -939,7 +995,6 @@ meta_frame_layout_calc_geometry (const MetaFrameLayout *layout, else g_memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable)); - x = rect->visible.x + rect->visible.width + layout->button_border.right; if (left_buttons_has_spacer[i]) x += (button_width * 0.75); @@ -1015,14 +1070,26 @@ meta_gradient_spec_free (MetaGradientSpec *spec) g_free (spec); } +#if GTK_CHECK_VERSION (3, 0, 0) +GdkPixbuf* +meta_gradient_spec_render (const MetaGradientSpec *spec, + GtkStyleContext *style, + int width, + int height) +#else GdkPixbuf* meta_gradient_spec_render (const MetaGradientSpec *spec, - GtkWidget *widget, + GtkStyle *style, int width, int height) +#endif { int n_colors; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA *colors; +#else GdkColor *colors; +#endif GSList *tmp; int i; GdkPixbuf *pixbuf; @@ -1032,13 +1099,17 @@ meta_gradient_spec_render (const MetaGradientSpec *spec, if (n_colors == 0) return NULL; +#if GTK_CHECK_VERSION (3, 0, 0) + colors = g_new (GdkRGBA, n_colors); +#else colors = g_new (GdkColor, n_colors); +#endif i = 0; tmp = spec->color_specs; while (tmp != NULL) { - meta_color_spec_render (tmp->data, widget, &colors[i]); + meta_color_spec_render (tmp->data, style, &colors[i]); tmp = tmp->next; ++i; @@ -1178,7 +1249,11 @@ meta_color_spec_new_from_string (const char *str, const char *bracket; const char *end_bracket; char *tmp; +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStateFlags state; +#else GtkStateType state; +#endif MetaGtkColorComponent component; bracket = str; @@ -1371,7 +1446,11 @@ meta_color_spec_new_from_string (const char *str, { spec = meta_color_spec_new (META_COLOR_SPEC_BASIC); +#if GTK_CHECK_VERSION (3, 0, 0) + if (!gdk_rgba_parse (&spec->data.basic.color, str)) +#else if (!gdk_color_parse (str, &spec->data.basic.color)) +#endif { g_set_error (err, META_THEME_ERROR, META_THEME_ERROR_FAILED, @@ -1387,9 +1466,15 @@ meta_color_spec_new_from_string (const char *str, return spec; } +#if GTK_CHECK_VERSION (3, 0, 0) +MetaColorSpec* +meta_color_spec_new_gtk (MetaGtkColorComponent component, + GtkStateFlags state) +#else MetaColorSpec* meta_color_spec_new_gtk (MetaGtkColorComponent component, GtkStateType state) +#endif { MetaColorSpec *spec; @@ -1401,18 +1486,111 @@ meta_color_spec_new_gtk (MetaGtkColorComponent component, return spec; } +#if GTK_CHECK_VERSION (3, 0, 0) +static void +meta_set_color_from_style (GdkRGBA *color, + GtkStyleContext *context, + GtkStateFlags state, + MetaGtkColorComponent component) +{ + GdkRGBA other; + + switch (component) + { + case META_GTK_COLOR_BG: + case META_GTK_COLOR_BASE: + gtk_style_context_get_background_color (context, state, color); + break; + case META_GTK_COLOR_FG: + case META_GTK_COLOR_TEXT: + gtk_style_context_get_color (context, state, color); + break; + case META_GTK_COLOR_TEXT_AA: + gtk_style_context_get_color (context, state, color); + meta_set_color_from_style (&other, context, state, META_GTK_COLOR_BASE); + + color->red = (color->red + other.red) / 2; + color->green = (color->green + other.green) / 2; + color->blue = (color->blue + other.blue) / 2; + break; + case META_GTK_COLOR_MID: + mate_desktop_gtk_style_get_light_color (context, state, color); + mate_desktop_gtk_style_get_dark_color (context, state, &other); + + color->red = (color->red + other.red) / 2; + color->green = (color->green + other.green) / 2; + color->blue = (color->blue + other.blue) / 2; + break; + case META_GTK_COLOR_LIGHT: + mate_desktop_gtk_style_get_light_color (context, state, color); + break; + case META_GTK_COLOR_DARK: + mate_desktop_gtk_style_get_dark_color (context, state, color); + break; + case META_GTK_COLOR_LAST: + g_assert_not_reached (); + break; + } +} +#else +static void +meta_set_color_from_style (GdkColor *color, + GtkStyle *widget_style, + GtkStateType state, + MetaGtkColorComponent component) +{ + switch (component) + { + case META_GTK_COLOR_BG: + *color = widget_style->bg[state]; + break; + case META_GTK_COLOR_FG: + *color = widget_style->fg[state]; + break; + case META_GTK_COLOR_BASE: + *color = widget_style->base[state]; + break; + case META_GTK_COLOR_TEXT: + *color = widget_style->text[state]; + break; + case META_GTK_COLOR_LIGHT: + *color = widget_style->light[state]; + break; + case META_GTK_COLOR_DARK: + *color = widget_style->dark[state]; + break; + case META_GTK_COLOR_MID: + *color = widget_style->mid[state]; + break; + case META_GTK_COLOR_TEXT_AA: + *color = widget_style->text_aa[state]; + break; + case META_GTK_COLOR_LAST: + g_assert_not_reached (); + break; + } +} +#endif + +#if GTK_CHECK_VERSION (3, 0, 0) +void +meta_color_spec_render (MetaColorSpec *spec, + GtkStyleContext *style, + GdkRGBA *color) +#else void meta_color_spec_render (MetaColorSpec *spec, - GtkWidget *widget, + GtkStyle *style, GdkColor *color) +#endif { - GtkStyle *widget_style; - g_return_if_fail (spec != NULL); - g_return_if_fail (GTK_IS_WIDGET (widget)); - widget_style = gtk_widget_get_style (widget); - g_return_if_fail (widget_style != NULL); +#if GTK_CHECK_VERSION (3, 0, 0) + g_return_if_fail (GTK_IS_STYLE_CONTEXT (style)); +#else + g_return_if_fail (style != NULL); +#endif switch (spec->type) { @@ -1421,44 +1599,22 @@ meta_color_spec_render (MetaColorSpec *spec, break; case META_COLOR_SPEC_GTK: - switch (spec->data.gtk.component) - { - case META_GTK_COLOR_BG: - *color = widget_style->bg[spec->data.gtk.state]; - break; - case META_GTK_COLOR_FG: - *color = widget_style->fg[spec->data.gtk.state]; - break; - case META_GTK_COLOR_BASE: - *color = widget_style->base[spec->data.gtk.state]; - break; - case META_GTK_COLOR_TEXT: - *color = widget_style->text[spec->data.gtk.state]; - break; - case META_GTK_COLOR_LIGHT: - *color = widget_style->light[spec->data.gtk.state]; - break; - case META_GTK_COLOR_DARK: - *color = widget_style->dark[spec->data.gtk.state]; - break; - case META_GTK_COLOR_MID: - *color = widget_style->mid[spec->data.gtk.state]; - break; - case META_GTK_COLOR_TEXT_AA: - *color = widget_style->text_aa[spec->data.gtk.state]; - break; - case META_GTK_COLOR_LAST: - g_assert_not_reached (); - break; - } + meta_set_color_from_style (color, + style, + spec->data.gtk.state, + spec->data.gtk.component); break; case META_COLOR_SPEC_BLEND: { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA bg, fg; +#else GdkColor bg, fg; +#endif - meta_color_spec_render (spec->data.blend.background, widget, &bg); - meta_color_spec_render (spec->data.blend.foreground, widget, &fg); + meta_color_spec_render (spec->data.blend.background, style, &bg); + meta_color_spec_render (spec->data.blend.foreground, style, &fg); color_composite (&bg, &fg, spec->data.blend.alpha, &spec->data.blend.color); @@ -1469,7 +1625,7 @@ meta_color_spec_render (MetaColorSpec *spec, case META_COLOR_SPEC_SHADE: { - meta_color_spec_render (spec->data.shade.base, widget, + meta_color_spec_render (spec->data.shade.base, style, &spec->data.shade.color); gtk_style_shade (&spec->data.shade.color, @@ -3215,7 +3371,11 @@ scale_and_alpha_pixbuf (GdkPixbuf *src, static GdkPixbuf* draw_op_as_pixbuf (const MetaDrawOp *op, - GtkWidget *widget, +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStyleContext *style, +#else + GtkStyle *style, +#endif const MetaDrawInfo *info, int width, int height) @@ -3236,10 +3396,14 @@ draw_op_as_pixbuf (const MetaDrawOp *op, case META_DRAW_RECTANGLE: if (op->data.rectangle.filled) { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif meta_color_spec_render (op->data.rectangle.color_spec, - widget, + style, &color); pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, @@ -3258,12 +3422,16 @@ draw_op_as_pixbuf (const MetaDrawOp *op, case META_DRAW_TINT: { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif guint32 rgba; gboolean has_alpha; meta_color_spec_render (op->data.rectangle.color_spec, - widget, + style, &color); has_alpha = @@ -3306,7 +3474,7 @@ draw_op_as_pixbuf (const MetaDrawOp *op, case META_DRAW_GRADIENT: { pixbuf = meta_gradient_spec_render (op->data.gradient.gradient_spec, - widget, width, height); + style, width, height); pixbuf = apply_alpha (pixbuf, op->data.gradient.alpha_spec, @@ -3319,10 +3487,14 @@ draw_op_as_pixbuf (const MetaDrawOp *op, { if (op->data.image.colorize_spec) { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif meta_color_spec_render (op->data.image.colorize_spec, - widget, &color); + style, &color); if (op->data.image.colorize_cache_pixbuf == NULL || op->data.image.colorize_cache_pixel != GDK_COLOR_RGB (color)) @@ -3430,31 +3602,6 @@ fill_env (MetaPositionExprEnv *env, env->theme = meta_current_theme; } -#if GTK_CHECK_VERSION (3, 0, 0) -static GtkStateFlags -state_flags_from_gtk_state (GtkStateType state) -{ - switch (state) - { - case GTK_STATE_NORMAL: - return 0; - case GTK_STATE_PRELIGHT: - return GTK_STATE_FLAG_PRELIGHT; - case GTK_STATE_ACTIVE: - return GTK_STATE_FLAG_ACTIVE; - case GTK_STATE_SELECTED: - return GTK_STATE_FLAG_SELECTED; - case GTK_STATE_INSENSITIVE: - return GTK_STATE_FLAG_INSENSITIVE; - case GTK_STATE_INCONSISTENT: - return GTK_STATE_FLAG_INCONSISTENT; - case GTK_STATE_FOCUSED: - return GTK_STATE_FLAG_FOCUSED; - } - return 0; -} -#endif - /* This code was originally rendering anti-aliased using X primitives, and * now has been switched to draw anti-aliased using cairo. In general, the * closest correspondence between X rendering and cairo rendering is given @@ -3470,13 +3617,9 @@ static void meta_draw_op_draw_with_env (const MetaDrawOp *op, #if GTK_CHECK_VERSION(3, 0, 0) GtkStyleContext *style_gtk, - #else - GtkStyle *style_gtk, - #endif - GtkWidget *widget, - #if GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, #endif @@ -3484,12 +3627,15 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, MetaRectangle rect, MetaPositionExprEnv *env) { - GdkColor color; - #if GTK_CHECK_VERSION(3, 0, 0) - cairo_save(cr); - gtk_style_context_save(style_gtk); + GdkRGBA color; + + cairo_save (cr); + gtk_style_context_save (style_gtk); #else + GdkColor color; + GtkStyle *style_gtk = gtk_widget_get_style (widget); + cairo_t *cr; cr = gdk_cairo_create (drawable); #endif @@ -3510,8 +3656,12 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, { int x1, x2, y1, y2; - meta_color_spec_render (op->data.line.color_spec, widget, &color); + meta_color_spec_render (op->data.line.color_spec, style_gtk, &color); +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, &color); +#endif if (op->data.line.width > 0) cairo_set_line_width (cr, op->data.line.width); @@ -3598,8 +3748,12 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, { int rx, ry, rwidth, rheight; - meta_color_spec_render (op->data.rectangle.color_spec, widget, &color); + meta_color_spec_render (op->data.rectangle.color_spec, style_gtk, &color); +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, &color); +#endif rx = parse_x_position_unchecked (op->data.rectangle.x, env); ry = parse_y_position_unchecked (op->data.rectangle.y, env); @@ -3628,8 +3782,12 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, double start_angle, end_angle; double center_x, center_y; - meta_color_spec_render (op->data.arc.color_spec, widget, &color); + meta_color_spec_render (op->data.arc.color_spec, style_gtk, &color); +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, &color); +#endif rx = parse_x_position_unchecked (op->data.arc.x, env); ry = parse_y_position_unchecked (op->data.arc.y, env); @@ -3683,8 +3841,12 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, if (!needs_alpha) { - meta_color_spec_render (op->data.tint.color_spec, widget, &color); + meta_color_spec_render (op->data.tint.color_spec, style_gtk, &color); +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, &color); +#endif cairo_rectangle (cr, rx, ry, rwidth, rheight); cairo_fill (cr); @@ -3693,7 +3855,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, { GdkPixbuf *pixbuf; - pixbuf = draw_op_as_pixbuf (op, widget, info, + pixbuf = draw_op_as_pixbuf (op, style_gtk, info, rwidth, rheight); if (pixbuf) @@ -3717,7 +3879,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rwidth = parse_size_unchecked (op->data.gradient.width, env); rheight = parse_size_unchecked (op->data.gradient.height, env); - pixbuf = draw_op_as_pixbuf (op, widget, info, + pixbuf = draw_op_as_pixbuf (op, style_gtk, info, rwidth, rheight); if (pixbuf) @@ -3744,7 +3906,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rwidth = parse_size_unchecked (op->data.image.width, env); rheight = parse_size_unchecked (op->data.image.height, env); - pixbuf = draw_op_as_pixbuf (op, widget, info, + pixbuf = draw_op_as_pixbuf (op, style_gtk, info, rwidth, rheight); if (pixbuf) @@ -3791,8 +3953,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, return; } - gtk_style_context_set_state (style_gtk, - state_flags_from_gtk_state (op->data.gtk_arrow.state)); + gtk_style_context_set_state (style_gtk, op->data.gtk_arrow.state); gtk_render_arrow (style_gtk, cr, angle, rx, ry, size); #else @@ -3821,8 +3982,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rheight = parse_size_unchecked (op->data.gtk_box.height, env); #if GTK_CHECK_VERSION(3, 0, 0) - gtk_style_context_set_state (style_gtk, - state_flags_from_gtk_state (op->data.gtk_box.state)); + gtk_style_context_set_state (style_gtk, op->data.gtk_box.state); gtk_render_background (style_gtk, cr, rx, ry, rwidth, rheight); gtk_render_frame (style_gtk, cr, rx, ry, rwidth, rheight); #else @@ -3847,8 +4007,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, ry2 = parse_y_position_unchecked (op->data.gtk_vline.y2, env); #if GTK_CHECK_VERSION(3, 0, 0) - gtk_style_context_set_state (style_gtk, - state_flags_from_gtk_state (op->data.gtk_vline.state)); + gtk_style_context_set_state (style_gtk, op->data.gtk_vline.state); gtk_render_line (style_gtk, cr, rx, ry1, rx, ry2); #else gtk_paint_vline (style_gtk, @@ -3870,7 +4029,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rwidth = parse_size_unchecked (op->data.icon.width, env); rheight = parse_size_unchecked (op->data.icon.height, env); - pixbuf = draw_op_as_pixbuf (op, widget, info, + pixbuf = draw_op_as_pixbuf (op, style_gtk, info, rwidth, rheight); if (pixbuf) @@ -3891,8 +4050,12 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, { int rx, ry; - meta_color_spec_render (op->data.title.color_spec, widget, &color); + meta_color_spec_render (op->data.title.color_spec, style_gtk, &color); +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, &color); +#endif rx = parse_x_position_unchecked (op->data.title.x, env); ry = parse_y_position_unchecked (op->data.title.y, env); @@ -3908,6 +4071,20 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, cairo_pattern_t *linpat; linpat = cairo_pattern_create_linear (rx, ry, text_space, env->title_height); +#if GTK_CHECK_VERSION (3, 0, 0) + cairo_pattern_add_color_stop_rgba (linpat, 0, color.red, + color.green, + color.blue, + color.alpha); + cairo_pattern_add_color_stop_rgba (linpat, startalpha, + color.red, + color.green, + color.blue, + color.alpha); + cairo_pattern_add_color_stop_rgba (linpat, 1, color.red, + color.green, + color.blue, 0); +#else cairo_pattern_add_color_stop_rgb (linpat, 0, color.red/65535.0, color.green/65535.0, color.blue/65535.0); @@ -3918,10 +4095,15 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, cairo_pattern_add_color_stop_rgba (linpat, 1, color.red/65535.0, color.green/65535.0, color.blue/65535.0, 0); +#endif cairo_set_source(cr, linpat); cairo_pattern_destroy(linpat); } else { +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &color); +#else gdk_cairo_set_source_color (cr, &color); +#endif } cairo_move_to (cr, rx, ry); @@ -3939,10 +4121,11 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, d_rect.height = parse_size_unchecked (op->data.op_list.height, env); meta_draw_op_list_draw_with_style (op->data.op_list.op_list, - style_gtk, widget, #if GTK_CHECK_VERSION(3, 0, 0) + style_gtk, cr, #else + widget, drawable, clip, #endif info, d_rect); @@ -3986,7 +4169,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, while (tile.y < (ry + rheight)) { meta_draw_op_list_draw_with_style (op->data.tile.op_list, - style_gtk, widget, cr, info, + style_gtk, cr, info, tile); tile.y += tile.height; @@ -4023,7 +4206,11 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, while (tile.y < (ry + rheight)) { meta_draw_op_list_draw_with_style (op->data.tile.op_list, - style_gtk, widget, drawable, &new_clip, info, +#if GTK_CHECK_VERSION (3, 0, 0) + style_gtk, drawable, &new_clip, info, +#else + widget, drawable, &new_clip, info, +#endif tile); tile.y += tile.height; @@ -4047,11 +4234,11 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, void meta_draw_op_draw_with_style (const MetaDrawOp *op, - GtkStyle *style_gtk, - GtkWidget *widget, #if GTK_CHECK_VERSION(3, 0, 0) + GtkStyleContext *style_gtk, cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, #endif @@ -4060,16 +4247,14 @@ meta_draw_op_draw_with_style (const MetaDrawOp *op, { MetaPositionExprEnv env; - #if !GTK_CHECK_VERSION(3, 0, 0) - g_return_if_fail (style_gtk->colormap == gdk_drawable_get_colormap (drawable)); - #endif - fill_env (&env, info, logical_region); - meta_draw_op_draw_with_env (op, style_gtk, widget, + meta_draw_op_draw_with_env (op, #if GTK_CHECK_VERSION(3, 0, 0) + style_gtk, cr, #else + widget, drawable, clip, #endif info, logical_region, @@ -4089,10 +4274,12 @@ meta_draw_op_draw (const MetaDrawOp *op, const MetaDrawInfo *info, MetaRectangle logical_region) { - meta_draw_op_draw_with_style (op, gtk_widget_get_style (widget), widget, + meta_draw_op_draw_with_style (op, #if GTK_CHECK_VERSION(3, 0, 0) + gtk_widget_get_style_context (widget), cr, #else + widget, drawable, clip, #endif info, logical_region); @@ -4147,11 +4334,11 @@ meta_draw_op_list_unref (MetaDrawOpList *op_list) void meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, - GtkStyle *style_gtk, - GtkWidget *widget, #if GTK_CHECK_VERSION(3, 0, 0) + GtkStyleContext *style_gtk, cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, #endif @@ -4167,10 +4354,6 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, #endif MetaPositionExprEnv env; - #if !GTK_CHECK_VERSION(3, 0, 0) - g_return_if_fail (style_gtk->colormap == gdk_drawable_get_colormap (drawable)); - #endif - if (op_list->n_ops == 0) return; @@ -4189,7 +4372,7 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, */ #if GTK_CHECK_VERSION(3, 0, 0) - cairo_save(cr); + cairo_save (cr); #else if (clip) { @@ -4226,10 +4409,7 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, } else if (gdk_cairo_get_clip_rectangle (cr, NULL)) { - meta_draw_op_draw_with_env (op, - style_gtk, widget, cr, info, - rect, - &env); + meta_draw_op_draw_with_env (op, style_gtk, cr, info, rect, &env); } #else @@ -4247,7 +4427,7 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, active_clip.height > 0) { meta_draw_op_draw_with_env (op, - style_gtk, widget, drawable, &active_clip, info, + widget, drawable, &active_clip, info, rect, &env); } @@ -4255,7 +4435,7 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, } #if GTK_CHECK_VERSION(3, 0, 0) - cairo_restore(cr); + cairo_restore (cr); #endif } @@ -4272,10 +4452,12 @@ meta_draw_op_list_draw (const MetaDrawOpList *op_list, MetaRectangle rect) { - meta_draw_op_list_draw_with_style (op_list, gtk_widget_get_style (widget), widget, + meta_draw_op_list_draw_with_style (op_list, #if GTK_CHECK_VERSION(3, 0, 0) + gtk_widget_get_style_context (widget), cr, #else + widget, drawable, clip, #endif info, rect); @@ -4644,13 +4826,9 @@ void meta_frame_style_draw_with_style (MetaFrameStyle *style, #if GTK_CHECK_VERSION(3, 0, 0) GtkStyleContext *style_gtk, - #else - GtkStyle *style_gtk, - #endif - GtkWidget *widget, - #if GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, int x_offset, int y_offset, @@ -4676,10 +4854,6 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, PangoRectangle extents; MetaDrawInfo draw_info; - #if !GTK_CHECK_VERSION(3, 0, 0) - g_return_if_fail (style_gtk->colormap == gdk_drawable_get_colormap (drawable)); - #endif - titlebar_rect.x = 0; titlebar_rect.y = 0; titlebar_rect.width = fgeom->width; @@ -4831,7 +5005,6 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, m_rect = meta_rect (rect.x, rect.y, rect.width, rect.height); meta_draw_op_list_draw_with_style (op_list, style_gtk, - widget, cr, &draw_info, m_rect); @@ -4870,7 +5043,6 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, MetaRectangle m_rect; m_rect = meta_rect (rect.x, rect.y, rect.width, rect.height); meta_draw_op_list_draw_with_style (op_list, - style_gtk, widget, drawable, &combined_clip, @@ -4916,7 +5088,6 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, meta_draw_op_list_draw_with_style (op_list, style_gtk, - widget, cr, &draw_info, m_rect); @@ -4978,7 +5149,6 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, m_rect = meta_rect (rect.x, rect.y, rect.width, rect.height); meta_draw_op_list_draw_with_style (op_list, - style_gtk, widget, drawable, &combined_clip, @@ -5031,13 +5201,9 @@ meta_frame_style_draw (MetaFrameStyle *style, meta_frame_style_draw_with_style (style, #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_get_style_context (widget), - #else - gtk_widget_get_style (widget), - #endif - widget, - #if GTK_CHECK_VERSION(3, 0, 0) cr, #else + widget, drawable, x_offset, y_offset, clip, #endif fgeom, client_width, client_height, @@ -5636,13 +5802,9 @@ void meta_theme_draw_frame_with_style (MetaTheme *theme, #if GTK_CHECK_VERSION(3, 0, 0) GtkStyleContext *style_gtk, - #else - GtkStyle *style_gtk, - #endif - GtkWidget *widget, - #if GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, @@ -5679,11 +5841,11 @@ meta_theme_draw_frame_with_style (MetaTheme *theme, theme); meta_frame_style_draw_with_style (style, - style_gtk, - widget, #if GTK_CHECK_VERSION(3, 0, 0) + style_gtk, cr, #else + widget, drawable, x_offset, y_offset, clip, #endif &fgeom, @@ -5719,13 +5881,9 @@ meta_theme_draw_frame (MetaTheme *theme, meta_theme_draw_frame_with_style (theme, #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_get_style_context (widget), - #else - gtk_widget_get_style (widget), - #endif - widget, - #if GTK_CHECK_VERSION(3, 0, 0) cr, #else + widget, drawable, clip, x_offset, y_offset, #endif type, flags, client_width, client_height, @@ -6128,7 +6286,14 @@ meta_gtk_widget_get_font_desc (GtkWidget *widget, g_return_val_if_fail (gtk_widget_get_realized (widget), NULL); +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStyleContext *style = gtk_widget_get_style_context (widget); + GtkStateFlags state = gtk_widget_get_state_flags (widget); + gtk_style_context_get(style, state, GTK_STYLE_PROPERTY_FONT, &font_desc, NULL); + font_desc = pango_font_description_copy (font_desc); +#else font_desc = pango_font_description_copy (gtk_widget_get_style (widget)->font_desc); +#endif if (override) pango_font_description_merge (font_desc, override, TRUE); @@ -6596,6 +6761,30 @@ meta_gradient_type_to_string (MetaGradientType type) return ""; } +#if GTK_CHECK_VERSION (3, 0, 0) +GtkStateFlags +meta_gtk_state_from_string (const char *str) +{ + if (g_ascii_strcasecmp ("normal", str) == 0) + return GTK_STATE_FLAG_NORMAL; + else if (g_ascii_strcasecmp ("prelight", str) == 0) + return GTK_STATE_FLAG_PRELIGHT; + else if (g_ascii_strcasecmp ("active", str) == 0) + return GTK_STATE_FLAG_ACTIVE; + else if (g_ascii_strcasecmp ("selected", str) == 0) + return GTK_STATE_FLAG_SELECTED; + else if (g_ascii_strcasecmp ("insensitive", str) == 0) + return GTK_STATE_FLAG_INSENSITIVE; + else if (g_ascii_strcasecmp ("inconsistent", str) == 0) + return GTK_STATE_FLAG_INCONSISTENT; + else if (g_ascii_strcasecmp ("focused", str) == 0) + return GTK_STATE_FLAG_FOCUSED; + else if (g_ascii_strcasecmp ("backdrop", str) == 0) + return GTK_STATE_FLAG_BACKDROP; + else + return -1; /* hack */ +} +#else GtkStateType meta_gtk_state_from_string (const char *str) { @@ -6632,6 +6821,7 @@ meta_gtk_state_to_string (GtkStateType state) return ""; } +#endif GtkShadowType meta_gtk_shadow_from_string (const char *str) @@ -6755,18 +6945,31 @@ meta_image_fill_type_to_string (MetaImageFillType fill_type) * \param b [out] the resulting colour * \param k amount to scale lightness and saturation by */ +#if GTK_CHECK_VERSION (3, 0, 0) +static void +gtk_style_shade (GdkRGBA *a, + GdkRGBA *b, + gdouble k) +#else static void gtk_style_shade (GdkColor *a, GdkColor *b, gdouble k) +#endif { gdouble red; gdouble green; gdouble blue; +#if GTK_CHECK_VERSION (3, 0, 0) + red = a->red; + green = a->green; + blue = a->blue; +#else red = (gdouble) a->red / 65535.0; green = (gdouble) a->green / 65535.0; blue = (gdouble) a->blue / 65535.0; +#endif rgb_to_hls (&red, &green, &blue); @@ -6784,9 +6987,15 @@ gtk_style_shade (GdkColor *a, hls_to_rgb (&red, &green, &blue); +#if GTK_CHECK_VERSION (3, 0, 0) + b->red = red; + b->green = green; + b->blue = blue; +#else b->red = red * 65535.0; b->green = green * 65535.0; b->blue = blue * 65535.0; +#endif } /** diff --git a/src/ui/theme.h b/src/ui/theme.h index a4ddb5f6..66996d89 100644 --- a/src/ui/theme.h +++ b/src/ui/theme.h @@ -255,24 +255,40 @@ struct _MetaColorSpec union { struct { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif } basic; struct { MetaGtkColorComponent component; +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStateFlags state; +#else GtkStateType state; +#endif } gtk; struct { MetaColorSpec *foreground; MetaColorSpec *background; double alpha; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif } blend; struct { MetaColorSpec *base; double factor; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA color; +#else GdkColor color; +#endif } shade; } data; }; @@ -501,7 +517,11 @@ struct _MetaDrawOp } image; struct { +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStateFlags state; +#else GtkStateType state; +#endif GtkShadowType shadow; GtkArrowType arrow; gboolean filled; @@ -513,7 +533,11 @@ struct _MetaDrawOp } gtk_arrow; struct { +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStateFlags state; +#else GtkStateType state; +#endif GtkShadowType shadow; MetaDrawSpec *x; MetaDrawSpec *y; @@ -522,7 +546,11 @@ struct _MetaDrawOp } gtk_box; struct { +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStateFlags state; +#else GtkStateType state; +#endif MetaDrawSpec *x; MetaDrawSpec *y1; MetaDrawSpec *y2; @@ -898,12 +926,23 @@ void meta_draw_spec_free (MetaDrawSpec *spec); MetaColorSpec* meta_color_spec_new (MetaColorSpecType type); MetaColorSpec* meta_color_spec_new_from_string (const char *str, GError **err); +#if GTK_CHECK_VERSION (3, 0, 0) +MetaColorSpec* meta_color_spec_new_gtk (MetaGtkColorComponent component, + GtkStateFlags state); +#else MetaColorSpec* meta_color_spec_new_gtk (MetaGtkColorComponent component, GtkStateType state); +#endif void meta_color_spec_free (MetaColorSpec *spec); +#if GTK_CHECK_VERSION (3, 0, 0) +void meta_color_spec_render (MetaColorSpec *spec, + GtkStyleContext *style_gtk, + GdkRGBA *color); +#else void meta_color_spec_render (MetaColorSpec *spec, - GtkWidget *widget, + GtkStyle *style_gtk, GdkColor *color); +#endif MetaDrawOp* meta_draw_op_new (MetaDrawType type); @@ -921,11 +960,11 @@ void meta_draw_op_draw (const MetaDrawOp *op, MetaRectangle logical_region); void meta_draw_op_draw_with_style (const MetaDrawOp *op, - GtkStyle *style_gtk, - GtkWidget *widget, #if GTK_CHECK_VERSION(3, 0, 0) + GtkStyleContext *style_gtk, cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, #endif @@ -947,11 +986,11 @@ void meta_draw_op_list_draw (const MetaDrawOpList *op_list, const MetaDrawInfo *info, MetaRectangle rect); void meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, - GtkStyle *style_gtk, - GtkWidget *widget, #if GTK_CHECK_VERSION(3, 0, 0) + GtkStyleContext *style_gtk, cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, #endif @@ -966,10 +1005,17 @@ gboolean meta_draw_op_list_contains (MetaDrawOpList *op_list, MetaGradientSpec* meta_gradient_spec_new (MetaGradientType type); void meta_gradient_spec_free (MetaGradientSpec *desc); +#if GTK_CHECK_VERSION (3, 0, 0) GdkPixbuf* meta_gradient_spec_render (const MetaGradientSpec *desc, - GtkWidget *widget, + GtkStyleContext *style_gtk, int width, int height); +#else +GdkPixbuf* meta_gradient_spec_render (const MetaGradientSpec *desc, + GtkStyle *style_gtk, + int width, + int height); +#endif gboolean meta_gradient_spec_validate (MetaGradientSpec *spec, GError **error); @@ -1005,13 +1051,9 @@ void meta_frame_style_draw (MetaFrameStyle *style, void meta_frame_style_draw_with_style (MetaFrameStyle *style, #if GTK_CHECK_VERSION(3, 0, 0) GtkStyleContext *style_gtk, - #else - GtkStyle *style_gtk, - #endif - GtkWidget *widget, - #if GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, int x_offset, int y_offset, @@ -1104,13 +1146,9 @@ void meta_theme_draw_frame_by_name (MetaTheme *theme, void meta_theme_draw_frame_with_style (MetaTheme *theme, #if GTK_CHECK_VERSION(3, 0, 0) GtkStyleContext *style_gtk, - #else - GtkStyle *style_gtk, - #endif - GtkWidget *widget, - #if GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr, #else + GtkWidget *widget, GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, @@ -1221,8 +1259,12 @@ MetaFrameType meta_frame_type_from_string (const char *s const char* meta_frame_type_to_string (MetaFrameType type); MetaGradientType meta_gradient_type_from_string (const char *str); const char* meta_gradient_type_to_string (MetaGradientType type); +#if GTK_CHECK_VERSION (3, 0, 0) +GtkStateFlags meta_gtk_state_from_string (const char *str); +#else GtkStateType meta_gtk_state_from_string (const char *str); const char* meta_gtk_state_to_string (GtkStateType state); +#endif GtkShadowType meta_gtk_shadow_from_string (const char *str); const char* meta_gtk_shadow_to_string (GtkShadowType shadow); GtkArrowType meta_gtk_arrow_from_string (const char *str); diff --git a/src/ui/tile-preview.c b/src/ui/tile-preview.c index d5a68846..71b2e297 100644 --- a/src/ui/tile-preview.c +++ b/src/ui/tile-preview.c @@ -35,8 +35,12 @@ struct _MetaTilePreview { GtkWidget *preview_window; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA *preview_color; +#else GdkColor *preview_color; guchar preview_alpha; +#endif MetaRectangle tile_rect; @@ -45,13 +49,14 @@ struct _MetaTilePreview { static gboolean #if GTK_CHECK_VERSION (3, 0, 0) -meta_tile_preview_draw (GtkWidget *widget, - cairo_t *cr, +meta_tile_preview_draw (GtkWidget *widget, + cairo_t *cr, + gpointer user_data) #else meta_tile_preview_expose (GtkWidget *widget, GdkEventExpose *event, -#endif gpointer user_data) +#endif { MetaTilePreview *preview = user_data; #if !GTK_CHECK_VERSION (3, 0, 0) @@ -66,25 +71,42 @@ meta_tile_preview_expose (GtkWidget *widget, if (preview->has_alpha) { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA preview_color = *preview->preview_color; +#endif /* Fill the preview area with a transparent color */ +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &preview_color); +#else cairo_set_source_rgba (cr, (double)preview->preview_color->red / 0xFFFF, (double)preview->preview_color->green / 0xFFFF, (double)preview->preview_color->blue / 0xFFFF, (double)preview->preview_alpha / 0xFF); +#endif cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_paint (cr); /* Use the opaque color for the border */ +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_cairo_set_source_rgba (cr, &preview_color); +#else gdk_cairo_set_source_color (cr, preview->preview_color); +#endif } else { +#if GTK_CHECK_VERSION (3, 0, 0) + GdkRGBA white = {1.0, 1.0, 1.0, 1.0}; + + gdk_cairo_set_source_rgba (cr, &white); +#else GtkStyle *style = gtk_widget_get_style (preview->preview_window); gdk_cairo_set_source_color (cr, &style->white); +#endif cairo_rectangle (cr, OUTLINE_WIDTH - 0.5, OUTLINE_WIDTH - 0.5, @@ -112,6 +134,22 @@ on_preview_window_style_set (GtkWidget *widget, gpointer user_data) { MetaTilePreview *preview = user_data; +#if GTK_CHECK_VERSION (3, 0, 0) + GtkStyleContext *context = gtk_style_context_new (); + GtkWidgetPath *path = gtk_widget_path_new (); + guchar alpha = 0xFF; + + gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW); + gtk_style_context_set_path (context, path); + + gtk_style_context_get (context, GTK_STATE_FLAG_SELECTED, "background-color", &preview->preview_color, NULL); + gtk_style_context_get_style (context, "selection-box-alpha", &alpha, NULL); + + preview->preview_color->alpha = (double)alpha / 0xFF; + + gtk_widget_path_free (path); + g_object_unref (context); +#else GtkStyle *style; style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), @@ -135,6 +173,7 @@ on_preview_window_style_set (GtkWidget *widget, } g_object_unref (style); +#endif } MetaTilePreview * @@ -160,7 +199,9 @@ meta_tile_preview_new (int screen_number, gtk_widget_set_app_paintable (preview->preview_window, TRUE); preview->preview_color = NULL; +#if !GTK_CHECK_VERSION (3, 0, 0) preview->preview_alpha = 0xFF; +#endif preview->tile_rect.x = preview->tile_rect.y = 0; preview->tile_rect.width = preview->tile_rect.height = 0; @@ -207,7 +248,11 @@ meta_tile_preview_free (MetaTilePreview *preview) gtk_widget_destroy (preview->preview_window); if (preview->preview_color) +#if GTK_CHECK_VERSION (3, 0, 0) + gdk_rgba_free (preview->preview_color); +#else gdk_color_free (preview->preview_color); +#endif g_free (preview); } @@ -250,12 +295,20 @@ meta_tile_preview_show (MetaTilePreview *preview, if (!preview->has_alpha) { - GdkRectangle outer_rect, inner_rect; +#if GTK_CHECK_VERSION (3, 0, 0) + cairo_rectangle_int_t outer_rect, inner_rect; cairo_region_t *outer_region, *inner_region; + GdkRGBA black = {.0, .0, .0, 1.0}; + + gdk_window_set_background_rgba (window, &black); +#else + GdkRectangle outer_rect, inner_rect; + GdkRegion *outer_region, *inner_region; GdkColor black; black = gtk_widget_get_style (preview->preview_window)->black; gdk_window_set_background (window, &black); +#endif outer_rect.x = outer_rect.y = 0; outer_rect.width = preview->tile_rect.width; @@ -266,14 +319,25 @@ meta_tile_preview_show (MetaTilePreview *preview, inner_rect.width = outer_rect.width - 2 * OUTLINE_WIDTH; inner_rect.height = outer_rect.height - 2 * OUTLINE_WIDTH; +#if GTK_CHECK_VERSION (3, 0, 0) outer_region = cairo_region_create_rectangle (&outer_rect); inner_region = cairo_region_create_rectangle (&inner_rect); cairo_region_subtract (outer_region, inner_region); cairo_region_destroy (inner_region); - gdk_window_shape_combine_region (window, outer_region, 0, 0); + gtk_widget_shape_combine_region (preview->preview_window, outer_region); cairo_region_destroy (outer_region); +#else + outer_region = gdk_region_rectangle (&outer_rect); + inner_region = gdk_region_rectangle (&inner_rect); + + gdk_region_subtract (outer_region, inner_region); + gdk_region_destroy (inner_region); + + gdk_window_shape_combine_region (window, outer_region, 0, 0); + gdk_region_destroy (outer_region); +#endif } } diff --git a/src/ui/ui.c b/src/ui/ui.c index b187f8cb..226e3c24 100644 --- a/src/ui/ui.c +++ b/src/ui/ui.c @@ -134,8 +134,8 @@ maybe_redirect_mouse_event (XEvent *xevent) return FALSE; #if GTK_CHECK_VERSION (3, 0, 0) - gmanager = gdk_display_get_device_manager (gdisplay); - gdevice = gdk_device_manager_get_client_pointer (gmanager); + gmanager = gdk_display_get_device_manager (gdisplay); + gdevice = gdk_device_manager_get_client_pointer (gmanager); #endif /* If GDK already thinks it has a grab, we better let it see events; this @@ -256,6 +256,7 @@ maybe_redirect_mouse_event (XEvent *xevent) /* If we've gotten here, we've filled in the gdk_event and should send it on */ #if GTK_CHECK_VERSION (3, 0, 0) gdk_event_set_device (gevent, gdevice); + gtk_main_do_event (gevent); gdk_event_free (gevent); #else gtk_main_do_event (&gevent); @@ -978,7 +979,6 @@ meta_ui_theme_get_frame_borders (MetaUI *ui, #endif PangoContext *context; const PangoFontDescription *font_desc; - GtkStyle *default_style; if (meta_ui_have_a_theme ()) { @@ -1002,6 +1002,8 @@ meta_ui_theme_get_frame_borders (MetaUI *ui, gtk_style_context_get (style, GTK_STATE_FLAG_NORMAL, "font", &free_font_desc, NULL); font_desc = (const PangoFontDescription *) free_font_desc; #else + GtkStyle *default_style; + default_style = gtk_widget_get_default_style (); font_desc = default_style->font_desc; #endif -- cgit v1.2.1