From 35d540dd3c9269ec39bf3bc10a98b9714963291b Mon Sep 17 00:00:00 2001 From: Laszlo Boros Date: Sat, 26 Oct 2013 14:27:58 +0200 Subject: Starting to add GTK3 support --- src/ui/draw-workspace.c | 38 +++++- src/ui/draw-workspace.h | 4 + src/ui/fixedtip.c | 24 ++++ src/ui/frames.c | 253 ++++++++++++++++++++++++++++++++++- src/ui/menu.c | 29 ++++ src/ui/metaaccellabel.c | 169 +++++++++++++++++++++++- src/ui/preview-widget.c | 132 +++++++++++++++++-- src/ui/preview-widget.h | 9 ++ src/ui/resizepopup.c | 14 ++ src/ui/tabpopup.c | 227 +++++++++++++++++++++++++++++--- src/ui/theme.c | 341 +++++++++++++++++++++++++++++++++++++++++++++--- src/ui/theme.h | 36 +++++ src/ui/themewidget.c | 129 +++++++++++++++++- src/ui/themewidget.h | 17 ++- 14 files changed, 1365 insertions(+), 57 deletions(-) (limited to 'src/ui') diff --git a/src/ui/draw-workspace.c b/src/ui/draw-workspace.c index 4008dc7c..2a6e7675 100644 --- a/src/ui/draw-workspace.c +++ b/src/ui/draw-workspace.c @@ -67,12 +67,19 @@ get_window_rect (const WnckWindowDisplayInfo *win, static void draw_window (GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, + #endif const WnckWindowDisplayInfo *win, const GdkRectangle *winrect, GtkStateType state) { + #if !GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr; + #endif + GdkPixbuf *icon; int icon_x, icon_y, icon_w, icon_h; gboolean is_active; @@ -80,8 +87,13 @@ draw_window (GtkWidget *widget, GtkStyle *style; is_active = win->is_active; - + + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_save(cr); + #else cr = gdk_cairo_create (drawable); + #endif + cairo_rectangle (cr, winrect->x, winrect->y, winrect->width, winrect->height); cairo_clip (cr); @@ -159,12 +171,20 @@ draw_window (GtkWidget *widget, MAX (0, winrect->width - 1), MAX (0, winrect->height - 1)); cairo_stroke (cr); + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_restore(cr); + #else cairo_destroy (cr); + #endif } void wnck_draw_workspace (GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, + #endif int x, int y, int width, @@ -179,7 +199,9 @@ wnck_draw_workspace (GtkWidget *widget, int i; GdkRectangle workspace_rect; GtkStateType state; + #if !GTK_CHECK_VERSION(3, 0, 0) cairo_t *cr; + #endif workspace_rect.x = x; workspace_rect.y = y; @@ -193,7 +215,11 @@ wnck_draw_workspace (GtkWidget *widget, else state = GTK_STATE_NORMAL; + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_save(cr); + #else cr = gdk_cairo_create (drawable); + #endif if (workspace_background) { @@ -207,7 +233,9 @@ wnck_draw_workspace (GtkWidget *widget, cairo_fill (cr); } + #if !GTK_CHECK_VERSION(3, 0, 0) cairo_destroy (cr); + #endif i = 0; while (i < n_windows) @@ -219,11 +247,19 @@ wnck_draw_workspace (GtkWidget *widget, screen_height, &workspace_rect, &winrect); draw_window (widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else drawable, + #endif win, &winrect, state); ++i; } + + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_save(cr); + #endif } diff --git a/src/ui/draw-workspace.h b/src/ui/draw-workspace.h index 5186d053..b1dabae3 100644 --- a/src/ui/draw-workspace.h +++ b/src/ui/draw-workspace.h @@ -46,7 +46,11 @@ typedef struct } WnckWindowDisplayInfo; void wnck_draw_workspace (GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, + #endif int x, int y, int width, diff --git a/src/ui/fixedtip.c b/src/ui/fixedtip.c index 707c461f..3d9aea06 100644 --- a/src/ui/fixedtip.c +++ b/src/ui/fixedtip.c @@ -50,6 +50,24 @@ static int screen_right_edge = 0; */ static int screen_bottom_edge = 0; +#if GTK_CHECK_VERSION(3, 0, 0) + +static gboolean +draw_handler (GtkWidget *tooltips, + cairo_t *cr, + gpointer user_data) +{ + gtk_render_background (gtk_widget_get_style_context (tooltips), + cr, + 0, 0, + gtk_widget_get_allocated_width (tooltips), + gtk_widget_get_allocated_height (tooltips)); + + return FALSE; +} + +#else + static gint expose_handler (GtkTooltips *tooltips) { @@ -60,6 +78,7 @@ expose_handler (GtkTooltips *tooltips) return FALSE; } +#endif void meta_fixed_tip_show (Display *xdisplay, int screen_number, @@ -93,8 +112,13 @@ meta_fixed_tip_show (Display *xdisplay, int screen_number, gtk_widget_set_name (tip, "gtk-tooltips"); gtk_container_set_border_width (GTK_CONTAINER (tip), 4); + #if GTK_CHECK_VERSION(3, 0, 0) + g_signal_connect (tip, "draw", + G_CALLBACK (draw_handler), NULL); + #else g_signal_connect_swapped (tip, "expose_event", G_CALLBACK (expose_handler), NULL); + #endif label = gtk_label_new (NULL); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); diff --git a/src/ui/frames.c b/src/ui/frames.c index 09bfcb61..7b9a94bc 100644 --- a/src/ui/frames.c +++ b/src/ui/frames.c @@ -39,6 +39,25 @@ #include #endif +#if GTK_CHECK_VERSION(3, 0, 0) + #include + #define GtkObject GtkWidget + #define GTK_OBJECT_CLASS GTK_WIDGET_CLASS + #define GdkRegion cairo_region_t + #define GdkRegion cairo_region_t + #define gdk_region_new cairo_region_create + #define gdk_region_subtract cairo_region_subtract + #define gdk_region_destroy cairo_region_destroy + #define gdk_region_union_with_rect cairo_region_union_rectangle + #define gdk_region_rectangle cairo_region_create_rectangle + #define gdk_region_offset cairo_region_translate + #define gdk_region_intersect cairo_region_intersect + #define gdk_region_copy cairo_region_copy + G_DEFINE_TYPE (MetaFrames, meta_frames, GTK_TYPE_WINDOW); + #define parent_class meta_frames_parent_class + #define GTK_WIDGET_REALIZED gtk_widget_get_realized +#endif + #define DEFAULT_INNER_BUTTON_BORDER 3 static void meta_frames_class_init (MetaFramesClass *klass); @@ -61,8 +80,13 @@ static gboolean meta_frames_motion_notify_event (GtkWidget *widget, GdkEventMotion *event); static gboolean meta_frames_destroy_event (GtkWidget *widget, GdkEventAny *event); +#if GTK_CHECK_VERSION(3, 0, 0) +static gboolean meta_frames_draw (GtkWidget *widget, + cairo_t *cr); +#else static gboolean meta_frames_expose_event (GtkWidget *widget, GdkEventExpose *event); +#endif static gboolean meta_frames_enter_notify_event (GtkWidget *widget, GdkEventCrossing *event); static gboolean meta_frames_leave_notify_event (GtkWidget *widget, @@ -73,10 +97,14 @@ static void meta_frames_attach_style (MetaFrames *frames, static void meta_frames_paint_to_drawable (MetaFrames *frames, MetaUIFrame *frame, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr); + #else GdkDrawable *drawable, GdkRegion *region, int x_offset, int y_offset); + #endif static void meta_frames_set_window_background (MetaFrames *frames, MetaUIFrame *frame); @@ -106,6 +134,28 @@ static void invalidate_all_caches (MetaFrames *frames); static void invalidate_whole_window (MetaFrames *frames, MetaUIFrame *frame); +#if GTK_CHECK_VERSION(3, 0, 0) + +static GObject * +meta_frames_constructor (GType gtype, + guint n_properties, + GObjectConstructParam *properties) +{ + GObject *object; + GObjectClass *gobject_class; + + gobject_class = G_OBJECT_CLASS (meta_frames_parent_class); + object = gobject_class->constructor (gtype, n_properties, properties); + + g_object_set (object, + "type", GTK_WINDOW_POPUP, + NULL); + + return object; +} + +#else + static GtkWidgetClass *parent_class = NULL; GType @@ -133,28 +183,40 @@ meta_frames_get_type (void) return frames_type; } +#endif + static void meta_frames_class_init (MetaFramesClass *class) { GObjectClass *gobject_class; + #if !GTK_CHECK_VERSION(3, 0, 0) GtkObjectClass *object_class; + #endif GtkWidgetClass *widget_class; gobject_class = G_OBJECT_CLASS (class); + #if !GTK_CHECK_VERSION(3, 0, 0) object_class = (GtkObjectClass*) class; + #endif widget_class = (GtkWidgetClass*) class; parent_class = g_type_class_peek_parent (class); gobject_class->finalize = meta_frames_finalize; + #if !GTK_CHECK_VERSION(3, 0, 0) object_class->destroy = meta_frames_destroy; + #endif widget_class->style_set = meta_frames_style_set; widget_class->realize = meta_frames_realize; widget_class->unrealize = meta_frames_unrealize; + #if GTK_CHECK_VERSION(3, 0, 0) + widget_class->draw = meta_frames_draw; + #else widget_class->expose_event = meta_frames_expose_event; + #endif widget_class->destroy_event = meta_frames_destroy_event; widget_class->button_press_event = meta_frames_button_press_event; widget_class->button_release_event = meta_frames_button_release_event; @@ -203,7 +265,9 @@ prefs_changed_callback (MetaPreference pref, static void meta_frames_init (MetaFrames *frames) { + #if !GTK_CHECK_VERSION(3, 0, 0) GTK_WINDOW (frames)->type = GTK_WINDOW_POPUP; + #endif frames->text_heights = g_hash_table_new (NULL, NULL); @@ -283,8 +347,13 @@ meta_frames_finalize (GObject *object) typedef struct { + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_rectangle_int_t rect; + cairo_surface_t *pixmap; + #else MetaRectangle rect; GdkPixmap *pixmap; + #endif } CachedFramePiece; typedef struct @@ -321,7 +390,11 @@ invalidate_cache (MetaFrames *frames, for (i = 0; i < 4; i++) if (pixels->piece[i].pixmap) + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_surface_destroy (pixels->piece[i].pixmap); + #else g_object_unref (pixels->piece[i].pixmap); + #endif g_free (pixels); g_hash_table_remove (frames->cache, frame); @@ -460,7 +533,7 @@ meta_frames_ensure_layout (MetaFrames *frames, MetaFrameType type; MetaFrameStyle *style; - g_return_if_fail (GTK_WIDGET_REALIZED (frames)); + g_return_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET(frames))); widget = GTK_WIDGET (frames); @@ -593,8 +666,12 @@ meta_frames_attach_style (MetaFrames *frames, gtk_style_detach (frame->style); /* Weirdly, gtk_style_attach() steals a reference count from the style passed in */ + #if GTK_CHECK_VERSION(3, 0, 0) + frame->style = g_object_ref (gtk_widget_get_style_context (GTK_WIDGET (frames))); + #else g_object_ref (GTK_WIDGET (frames)->style); frame->style = gtk_style_attach (GTK_WIDGET (frames)->style, frame->window); + #endif } void @@ -2113,6 +2190,7 @@ setup_bg_cr (cairo_t *cr, GdkWindow *window, int x_offset, int y_offset) } } +#if !GTK_CHECK_VERSION(3, 0, 0) static void clear_backing (GdkPixmap *pixmap, GdkWindow *window, @@ -2135,9 +2213,42 @@ clear_backing (GdkPixmap *pixmap, cairo_destroy (cr); } +#endif /* Returns a pixmap with a piece of the windows frame painted on it. */ +#if GTK_CHECK_VERSION(3, 0, 0) + +static cairo_surface_t * +generate_pixmap (MetaFrames *frames, + MetaUIFrame *frame, + cairo_rectangle_int_t *rect) +{ + cairo_surface_t *result; + cairo_t *cr; + + /* do not create a pixmap for nonexisting areas */ + if (rect->width <= 0 || rect->height <= 0) + return NULL; + + result = gdk_window_create_similar_surface (frame->window, + CAIRO_CONTENT_COLOR, + rect->width, rect->height); + + cr = cairo_create (result); + cairo_translate (cr, -rect->x, -rect->y); + + setup_bg_cr (cr, frame->window, 0, 0); + cairo_paint (cr); + + meta_frames_paint_to_drawable (frames, frame, cr); + + cairo_destroy (cr); + + return result; +} + +#else static GdkPixmap * generate_pixmap (MetaFrames *frames, @@ -2172,6 +2283,8 @@ generate_pixmap (MetaFrames *frames, return result; } +#endif + static void populate_cache (MetaFrames *frames, @@ -2237,7 +2350,7 @@ populate_cache (MetaFrames *frames, { CachedFramePiece *piece = &pixels->piece[i]; if (!piece->pixmap) - piece->pixmap = generate_pixmap (frames, frame, piece->rect); + piece->pixmap = generate_pixmap (frames, frame, &piece->rect); } if (frames->invalidate_cache_timeout_id) @@ -2279,6 +2392,8 @@ clip_to_screen (GdkRegion *region, MetaUIFrame *frame) gdk_region_offset (region, - frame_area.x, - frame_area.y); } +#if !GTK_CHECK_VERSION(3, 0, 0) + static void subtract_from_region (GdkRegion *region, GdkDrawable *drawable, gint x, gint y) @@ -2301,6 +2416,38 @@ subtract_from_region (GdkRegion *region, GdkDrawable *drawable, gdk_region_destroy (reg_rect); } +#endif + +#if GTK_CHECK_VERSION(3, 0, 0) + +static void +cached_pixels_draw (CachedPixels *pixels, + cairo_t *cr, + cairo_region_t *region) +{ + cairo_region_t *region_piece; + int i; + + for (i = 0; i < 4; i++) + { + CachedFramePiece *piece; + piece = &pixels->piece[i]; + + if (piece->pixmap) + { + cairo_set_source_surface (cr, piece->pixmap, + piece->rect.x, piece->rect.y); + cairo_paint (cr); + + region_piece = cairo_region_create_rectangle (&piece->rect); + cairo_region_subtract (region, region_piece); + cairo_region_destroy (region_piece); + } + } +} + +#else + static void cached_pixels_draw (CachedPixels *pixels, GdkWindow *window, @@ -2329,6 +2476,79 @@ cached_pixels_draw (CachedPixels *pixels, cairo_destroy (cr); } +#endif + +#if GTK_CHECK_VERSION(3, 0, 0) + +static gboolean +meta_frames_draw (GtkWidget *widget, + cairo_t *cr) +{ + MetaUIFrame *frame; + MetaFrames *frames; + CachedPixels *pixels; + cairo_region_t *region; + cairo_rectangle_int_t clip; + int i, n_areas; + cairo_surface_t *target; + + frames = META_FRAMES (widget); + target = cairo_get_target (cr); + gdk_cairo_get_clip_rectangle (cr, &clip); + + g_assert (cairo_surface_get_type (target) == CAIRO_SURFACE_TYPE_XLIB); + frame = meta_frames_lookup_window (frames, cairo_xlib_surface_get_drawable (target)); + if (frame == NULL) + return FALSE; + + if (frames->expose_delay_count > 0) + { + /* Redraw this entire frame later */ + frame->expose_delayed = TRUE; + return TRUE; + } + + populate_cache (frames, frame); + + region = cairo_region_create_rectangle (&clip); + + pixels = get_cache (frames, frame); + + cached_pixels_draw (pixels, cr, region); + + clip_to_screen (region, frame); + subtract_client_area (region, frame); + + n_areas = cairo_region_num_rectangles (region); + + for (i = 0; i < n_areas; i++) + { + cairo_rectangle_int_t area; + + cairo_region_get_rectangle (region, i, &area); + + cairo_save (cr); + + cairo_rectangle (cr, area.x, area.y, area.width, area.height); + cairo_clip (cr); + + cairo_push_group (cr); + + meta_frames_paint_to_drawable (frames, frame, cr); + + cairo_pop_group_to_source (cr); + cairo_paint (cr); + + cairo_restore (cr); + } + + cairo_region_destroy (region); + + return TRUE; +} + +#else + static gboolean meta_frames_expose_event (GtkWidget *widget, GdkEventExpose *event) @@ -2367,6 +2587,8 @@ meta_frames_expose_event (GtkWidget *widget, return TRUE; } +#endif + /* How far off the screen edge the window decorations should * be drawn. Used only in meta_frames_paint_to_drawable, below. */ @@ -2375,10 +2597,14 @@ meta_frames_expose_event (GtkWidget *widget, static void meta_frames_paint_to_drawable (MetaFrames *frames, MetaUIFrame *frame, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr) + #else GdkDrawable *drawable, GdkRegion *region, int x_offset, int y_offset) + #endif { GtkWidget *widget; MetaFrameFlags flags; @@ -2504,6 +2730,23 @@ meta_frames_paint_to_drawable (MetaFrames *frames, meta_prefs_get_button_layout (&button_layout); + #if GTK_CHECK_VERSION(3, 0, 0) + + meta_theme_draw_frame_with_style (meta_theme_get_current (), + frame->style, + widget, + cr, + type, + flags, + w, h, + frame->layout, + frame->text_height, + &button_layout, + button_states, + mini_icon, icon); + + #else + if (G_LIKELY (GDK_IS_WINDOW (drawable))) { /* A window; happens about 2/3 of the time */ @@ -2605,6 +2848,8 @@ meta_frames_paint_to_drawable (MetaFrames *frames, mini_icon, icon); } + #endif + } static void @@ -2640,7 +2885,11 @@ meta_frames_set_window_background (MetaFrames *frames, /* Set A in ARGB to window_background_alpha, if we have ARGB */ visual = gtk_widget_get_visual (GTK_WIDGET (frames)); + #if GTK_CHECK_VERSION(3, 0, 0) + if (gdk_visual_get_depth(visual) == 32) /* we have ARGB */ + #else if (visual->depth == 32) /* we have ARGB */ + #endif { color.pixel = (color.pixel & 0xffffff) & style->window_background_alpha << 24; diff --git a/src/ui/menu.c b/src/ui/menu.c index d98a33d3..2b6dfe83 100644 --- a/src/ui/menu.c +++ b/src/ui/menu.c @@ -390,10 +390,19 @@ meta_window_menu_new (MetaFrames *frames, meta_verbose ("Creating %d-workspace menu current space %lu\n", n_workspaces, active_workspace); + #if GTK_CHECK_VERSION(3, 0, 0) + GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(frames)); + + display = GDK_WINDOW_XDISPLAY (window); + + screen = gdk_window_get_screen (window); + xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen)); + #else display = gdk_x11_drawable_get_xdisplay (GTK_WIDGET (frames)->window); screen = gdk_drawable_get_screen (GTK_WIDGET (frames)->window); xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen)); + #endif submenu = gtk_menu_new (); @@ -435,12 +444,20 @@ meta_window_menu_new (MetaFrames *frames, "workspace", GINT_TO_POINTER (j)); + #if GTK_CHECK_VERSION(3, 0, 0) + g_signal_connect_data (G_OBJECT (submi), + "activate", + G_CALLBACK (activate_cb), + md, + (GClosureNotify) g_free, 0); + #else gtk_signal_connect_full (GTK_OBJECT (submi), "activate", G_CALLBACK (activate_cb), NULL, md, g_free, FALSE, FALSE); + #endif gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi); @@ -463,12 +480,20 @@ meta_window_menu_new (MetaFrames *frames, md->menu = menu; md->op = menuitem.op; + #if GTK_CHECK_VERSION(3, 0, 0) + g_signal_connect_data (G_OBJECT (mi), + "activate", + G_CALLBACK (activate_cb), + md, + (GClosureNotify) g_free, 0); + #else gtk_signal_connect_full (GTK_OBJECT (mi), "activate", G_CALLBACK (activate_cb), NULL, md, g_free, FALSE, FALSE); + #endif } if (mi) @@ -496,7 +521,11 @@ void meta_window_menu_popup(MetaWindowMenu* menu, int root_x, int root_y, int bu gtk_menu_popup(GTK_MENU (menu->menu), NULL, NULL, popup_position_func, pt, button, timestamp); + #if GTK_CHECK_VERSION(3, 0, 0) + if (!gtk_widget_get_visible (menu->menu)) + #else if (!GTK_MENU_SHELL(menu->menu)->have_xgrab) + #endif { meta_warning("GtkMenu failed to grab the pointer\n"); } diff --git a/src/ui/metaaccellabel.c b/src/ui/metaaccellabel.c index 88262d0f..829b8a75 100644 --- a/src/ui/metaaccellabel.c +++ b/src/ui/metaaccellabel.c @@ -37,21 +37,44 @@ #include #include "util.h" +#if GTK_CHECK_VERSION(3, 0, 0) + #define parent_class meta_accel_label_parent_class + #define GtkObject GtkWidget + #define GTK_OBJECT_CLASS GTK_WIDGET_CLASS +#endif + static void meta_accel_label_class_init (MetaAccelLabelClass *klass); static void meta_accel_label_init (MetaAccelLabel *accel_label); static void meta_accel_label_destroy (GtkObject *object); static void meta_accel_label_finalize (GObject *object); +static void meta_accel_label_update (MetaAccelLabel *accel_label); +static int meta_accel_label_get_accel_width (MetaAccelLabel *accel_label); + +#if GTK_CHECK_VERSION(3, 0, 0) +static void meta_accel_label_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural); +static void meta_accel_label_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural); +static gboolean meta_accel_label_draw (GtkWidget *widget, + cairo_t *cr); +#else static void meta_accel_label_size_request (GtkWidget *widget, GtkRequisition *requisition); static gboolean meta_accel_label_expose_event (GtkWidget *widget, GdkEventExpose *event); -static void meta_accel_label_update (MetaAccelLabel *accel_label); -static int meta_accel_label_get_accel_width (MetaAccelLabel *accel_label); +static GtkLabelClass *parent_class = NULL; +#endif -static GtkLabelClass *parent_class = NULL; +#if GTK_CHECK_VERSION(3, 0, 0) + +G_DEFINE_TYPE (MetaAccelLabel, meta_accel_label, GTK_TYPE_LABEL); + +#else GType meta_accel_label_get_type (void) @@ -78,9 +101,24 @@ meta_accel_label_get_type (void) return accel_label_type; } +#endif + static void meta_accel_label_class_init (MetaAccelLabelClass *class) { + + #if GTK_CHECK_VERSION(3, 0, 0) + GObjectClass *gobject_class = G_OBJECT_CLASS (class); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); + + gobject_class->finalize = meta_accel_label_finalize; + + widget_class->destroy = meta_accel_label_destroy; + + widget_class->get_preferred_width = meta_accel_label_get_preferred_width; + widget_class->get_preferred_height = meta_accel_label_get_preferred_height; + widget_class->draw = meta_accel_label_draw; + #else GObjectClass *gobject_class = G_OBJECT_CLASS (class); GtkObjectClass *object_class = GTK_OBJECT_CLASS (class); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); @@ -93,6 +131,7 @@ meta_accel_label_class_init (MetaAccelLabelClass *class) widget_class->size_request = meta_accel_label_size_request; widget_class->expose_event = meta_accel_label_expose_event; + #endif class->signal_quote1 = g_strdup ("<:"); class->signal_quote2 = g_strdup (":>"); @@ -236,6 +275,34 @@ meta_accel_label_get_accel_width (MetaAccelLabel *accel_label) (accel_label->accel_string_width ? accel_label->accel_padding : 0)); } +#if GTK_CHECK_VERSION(3, 0, 0) +static void +meta_accel_label_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + MetaAccelLabel *accel_label = META_ACCEL_LABEL (widget); + PangoLayout *layout; + gint width; + + GTK_WIDGET_CLASS (meta_accel_label_parent_class)->get_preferred_width (widget, minimum, natural); + + layout = gtk_widget_create_pango_layout (widget, accel_label->accel_string); + pango_layout_get_pixel_size (layout, &width, NULL); + accel_label->accel_string_width = width; + + g_object_unref (G_OBJECT (layout)); +} + +static void +meta_accel_label_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GTK_WIDGET_CLASS (meta_accel_label_parent_class)->get_preferred_height (widget, minimum, natural); +} +#else + static void meta_accel_label_size_request (GtkWidget *widget, GtkRequisition *requisition) @@ -254,6 +321,100 @@ meta_accel_label_size_request (GtkWidget *widget, g_object_unref (G_OBJECT (layout)); } +#endif + +#if GTK_CHECK_VERSION(3, 0, 0) + +static gboolean +meta_accel_label_draw (GtkWidget *widget, + cairo_t *cr) +{ + MetaAccelLabel *accel_label = META_ACCEL_LABEL (widget); + GtkMisc *misc = GTK_MISC (accel_label); + GtkTextDirection direction; + int ac_width; + GtkAllocation allocation; + GtkRequisition requisition; + + direction = gtk_widget_get_direction (widget); + ac_width = meta_accel_label_get_accel_width (accel_label); + gtk_widget_get_allocation (widget, &allocation); + gtk_widget_get_preferred_size (widget, + &requisition, NULL); + + if (allocation.width >= requisition.width + ac_width) + { + GtkStyleContext *style; + PangoLayout *label_layout; + PangoLayout *accel_layout; + GtkLabel *label = GTK_LABEL (widget); + gint x, y, xpad, ypad; + gfloat xalign, yalign; + + label_layout = gtk_label_get_layout (GTK_LABEL (accel_label)); + gtk_misc_get_alignment (misc, &xalign, &yalign); + + cairo_save (cr); + + /* XXX: Mad hack: We modify the label's width so it renders + * properly in its draw function that we chain to. */ + if (direction == GTK_TEXT_DIR_RTL) + cairo_translate (cr, ac_width, 0); + if (gtk_label_get_ellipsize (label)) + pango_layout_set_width (label_layout, + pango_layout_get_width (label_layout) + - ac_width * PANGO_SCALE); + + allocation.width -= ac_width; + gtk_widget_set_allocation (widget, &allocation); + if (GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw) + GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw (widget, + cr); + allocation.width += ac_width; + gtk_widget_set_allocation (widget, &allocation); + if (gtk_label_get_ellipsize (label)) + pango_layout_set_width (label_layout, + pango_layout_get_width (label_layout) + + ac_width * PANGO_SCALE); + + cairo_restore (cr); + + gtk_misc_get_padding (misc, &xpad, &ypad); + + if (direction == GTK_TEXT_DIR_RTL) + x = xpad; + else + x = gtk_widget_get_allocated_width (widget) - xpad - ac_width; + + gtk_label_get_layout_offsets (GTK_LABEL (accel_label), NULL, &y); + + accel_layout = gtk_widget_create_pango_layout (widget, accel_label->accel_string); + + y = (allocation.height - (requisition.height - ypad * 2)) * yalign + 1.5; + + 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_render_layout (gtk_widget_get_style_context (widget), + cr, + x, y, + accel_layout); + gtk_style_context_restore (style); + + g_object_unref (accel_layout); + } + else + { + if (GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw) + GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw (widget, cr); + } + + return FALSE; +} + +#else + static gboolean meta_accel_label_expose_event (GtkWidget *widget, GdkEventExpose *event) @@ -327,6 +488,8 @@ meta_accel_label_expose_event (GtkWidget *widget, return FALSE; } +#endif + static void meta_accel_label_update (MetaAccelLabel *accel_label) { diff --git a/src/ui/preview-widget.c b/src/ui/preview-widget.c index 0163c7f5..cb05c2f8 100644 --- a/src/ui/preview-widget.c +++ b/src/ui/preview-widget.c @@ -30,16 +30,39 @@ static void meta_preview_class_init (MetaPreviewClass *klass); static void meta_preview_init (MetaPreview *preview); + +#if GTK_CHECK_VERSION(3, 0, 0) + +static void meta_preview_get_preferred_width(GtkWidget *widget, + gint *minimal, gint *natural); +static void meta_preview_get_preferred_height(GtkWidget *widget, + gint *minimal, gint *natural); +#endif + static void meta_preview_size_request (GtkWidget *widget, GtkRequisition *req); static void meta_preview_size_allocate (GtkWidget *widget, GtkAllocation *allocation); +#if GTK_CHECK_VERSION(3, 0, 0) +static gboolean meta_preview_draw (GtkWidget *widget, + cairo_t *cr); +#else static gboolean meta_preview_expose (GtkWidget *widget, GdkEventExpose *event); +#endif static void meta_preview_finalize (GObject *object); + +#if GTK_CHECK_VERSION(3, 0, 0) + +G_DEFINE_TYPE (MetaPreview, meta_preview, GTK_TYPE_BIN); +#define parent_class meta_preview_parent_class + +#else + static GtkWidgetClass *parent_class; + GType meta_preview_get_type (void) { @@ -49,12 +72,12 @@ meta_preview_get_type (void) { static const GtkTypeInfo preview_info = { - "MetaPreview", - sizeof (MetaPreview), - sizeof (MetaPreviewClass), - (GtkClassInitFunc) meta_preview_class_init, - (GtkObjectInitFunc) meta_preview_init, - /* reserved_1 */ NULL, + "MetaPreview", + sizeof (MetaPreview), + sizeof (MetaPreviewClass), + (GtkClassInitFunc) meta_preview_class_init, + (GtkObjectInitFunc) meta_preview_init, + /* reserved_1 */ NULL, /* reserved_2 */ NULL, (GtkClassInitFunc) NULL, }; @@ -65,6 +88,8 @@ meta_preview_get_type (void) return preview_type; } +#endif + static void meta_preview_class_init (MetaPreviewClass *class) { @@ -76,8 +101,14 @@ meta_preview_class_init (MetaPreviewClass *class) gobject_class->finalize = meta_preview_finalize; + #if GTK_CHECK_VERSION(3, 0, 0) + widget_class->draw = meta_preview_draw; + widget_class->get_preferred_width = meta_preview_get_preferred_width; + widget_class->get_preferred_height = meta_preview_get_preferred_height; + #else widget_class->expose_event = meta_preview_expose; widget_class->size_request = meta_preview_size_request; + #endif widget_class->size_allocate = meta_preview_size_allocate; } @@ -125,7 +156,11 @@ meta_preview_new (void) { MetaPreview *preview; + #if GTK_CHECK_VERSION(3, 0, 0) + preview = g_object_new (META_TYPE_PREVIEW, NULL); + #else preview = gtk_type_new (META_TYPE_PREVIEW); + #endif return GTK_WIDGET (preview); } @@ -210,6 +245,75 @@ ensure_info (MetaPreview *preview) } } } +#if GTK_CHECK_VERSION(3, 0, 0) + +static void meta_preview_get_preferred_width(GtkWidget *widget, gint *minimal, gint *natural) +{ + GtkRequisition requisition; + meta_preview_size_request (widget, &requisition); + *minimal = *natural = requisition.width; +} + +static void meta_preview_get_preferred_height(GtkWidget *widget, gint *minimal, gint *natural) +{ + GtkRequisition requisition; + meta_preview_size_request (widget, &requisition); + *minimal = *natural = requisition.height; +} + + +static gboolean +meta_preview_draw(GtkWidget *widget, + cairo_t *cr) +{ + MetaPreview *preview = META_PREVIEW (widget); + GtkAllocation allocation; + + gtk_widget_get_allocation (widget, &allocation); + + if (preview->theme) + { + 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 + }; + + ensure_info (preview); + cairo_save (cr); + + client_width = allocation.width - preview->left_width - preview->right_width; + client_height = allocation.height - preview->top_height - preview->bottom_height; + + if (client_width < 0) + client_width = 1; + if (client_height < 0) + client_height = 1; + + 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); + } + + return GTK_WIDGET_CLASS (parent_class)->draw (widget, cr); +} + +#else static gboolean meta_preview_expose (GtkWidget *widget, @@ -271,6 +375,8 @@ meta_preview_expose (GtkWidget *widget, return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event); } +#endif + static void meta_preview_size_request (GtkWidget *widget, GtkRequisition *req) @@ -323,7 +429,9 @@ meta_preview_size_allocate (GtkWidget *widget, ensure_info (preview); + #if !GTK_CHECK_VERSION(3, 0, 0) widget->allocation = *allocation; + #endif border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); @@ -331,11 +439,11 @@ meta_preview_size_allocate (GtkWidget *widget, if (child && gtk_widget_get_visible (child)) { - child_allocation.x = widget->allocation.x + border_width + preview->left_width; - child_allocation.y = widget->allocation.y + border_width + preview->top_height; + child_allocation.x = allocation->x + border_width + preview->left_width; + child_allocation.y = allocation->y + border_width + preview->top_height; - child_allocation.width = MAX (1, widget->allocation.width - border_width * 2 - preview->left_width - preview->right_width); - child_allocation.height = MAX (1, widget->allocation.height - border_width * 2 - preview->top_height - preview->bottom_height); + child_allocation.width = MAX (1, allocation->width - border_width * 2 - preview->left_width - preview->right_width); + child_allocation.height = MAX (1, allocation->height - border_width * 2 - preview->top_height - preview->bottom_height); gtk_widget_size_allocate (gtk_bin_get_child (GTK_BIN (widget)), &child_allocation); } @@ -596,6 +704,4 @@ meta_preview_get_clip_region (MetaPreview *preview, gint new_window_width, gint gdk_region_destroy (corners_xregion); return window_xregion; -} - - +} \ No newline at end of file diff --git a/src/ui/preview-widget.h b/src/ui/preview-widget.h index e11a0b81..c19da7cc 100644 --- a/src/ui/preview-widget.h +++ b/src/ui/preview-widget.h @@ -24,6 +24,15 @@ #include "theme.h" #include +#if GTK_CHECK_VERSION(3, 0, 0) + #include + #define GdkRegion cairo_region_t + #define gdk_region_new cairo_region_create + #define gdk_region_subtract cairo_region_subtract + #define gdk_region_destroy cairo_region_destroy + #define gdk_region_union_with_rect cairo_region_union_rectangle +#endif + #ifndef META_PREVIEW_WIDGET_H #define META_PREVIEW_WIDGET_H diff --git a/src/ui/resizepopup.c b/src/ui/resizepopup.c index f740f236..06b8c5af 100644 --- a/src/ui/resizepopup.c +++ b/src/ui/resizepopup.c @@ -27,6 +27,10 @@ #include #include +#if GTK_CHECK_VERSION(3, 0, 0) + #define GTK_WIDGET_REALIZED gtk_widget_get_realized +#endif + struct _MetaResizePopup { GtkWidget *size_window; @@ -126,9 +130,15 @@ update_size_window (MetaResizePopup *popup) if (GTK_WIDGET_REALIZED (popup->size_window)) { /* using move_resize to avoid jumpiness */ + #if GTK_CHECK_VERSION(3, 0, 0) + gdk_window_move_resize (gtk_widget_get_window(GTK_WIDGET(popup->size_window)), + x, y, + width, height); + #else gdk_window_move_resize (popup->size_window->window, x, y, width, height); + #endif } else { @@ -146,7 +156,11 @@ sync_showing (MetaResizePopup *popup) gtk_widget_show (popup->size_window); if (popup->size_window && GTK_WIDGET_REALIZED (popup->size_window)) + #if GTK_CHECK_VERSION(3, 0, 0) + gdk_window_raise (gtk_widget_get_window(GTK_WIDGET(popup->size_window))); + #else gdk_window_raise (popup->size_window->window); + #endif } else { diff --git a/src/ui/tabpopup.c b/src/ui/tabpopup.c index 71319f16..76a299be 100644 --- a/src/ui/tabpopup.c +++ b/src/ui/tabpopup.c @@ -36,6 +36,14 @@ #include #include +#if GTK_CHECK_VERSION(3, 0, 0) + #define GTK_WIDGET_VISIBLE gtk_widget_get_visible + #define GdkRegion cairo_region_t + #define gdk_region_subtract cairo_region_subtract + #define gdk_region_destroy cairo_region_destroy + #define gdk_region_rectangle cairo_region_create_rectangle +#endif + #define OUTSIDE_SELECT_RECT 2 #define INSIDE_SELECT_RECT 2 @@ -458,6 +466,7 @@ display_entry (MetaTabPopup *popup, GdkRectangle rect; GdkRegion *region; GdkRegion *inner_region; + GdkWindow *window; if (popup->current_selected_entry) @@ -478,26 +487,33 @@ display_entry (MetaTabPopup *popup, if (popup->outline) { /* Do stuff behind gtk's back */ - gdk_window_hide (popup->outline_window->window); + gdk_window_hide (gtk_widget_get_window(popup->outline_window)); meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())); rect = te->rect; rect.x = 0; rect.y = 0; - gdk_window_move_resize (popup->outline_window->window, + window = gtk_widget_get_window(GTK_WIDGET(popup->outline_window)); + + gdk_window_move_resize (window, te->rect.x, te->rect.y, te->rect.width, te->rect.height); - gdk_window_set_background (popup->outline_window->window, + #if GTK_CHECK_VERSION(3, 0, 0) + GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 }; + gdk_window_set_background_rgba (window, &black); + #else + gdk_window_set_background (window, &popup->outline_window->style->black); + #endif region = gdk_region_rectangle (&rect); inner_region = gdk_region_rectangle (&te->inner_rect); gdk_region_subtract (region, inner_region); gdk_region_destroy (inner_region); - gdk_window_shape_combine_region (popup->outline_window->window, + gdk_window_shape_combine_region (window, region, 0, 0); @@ -508,8 +524,12 @@ display_entry (MetaTabPopup *popup, * we manually set the window as mapped and then manually map it * with gdk functions. */ + #if GTK_CHECK_VERSION(3, 0, 0) + gtk_widget_set_mapped (popup->outline_window, TRUE); + #else GTK_WIDGET_SET_FLAGS (popup->outline_window, GTK_MAPPED); - gdk_window_show_unraised (popup->outline_window->window); + #endif + gdk_window_show_unraised (window); } /* Must be before we handle an expose for the outline window */ @@ -645,8 +665,13 @@ unselect_image (GtkWidget *widget) } static void meta_select_image_class_init (MetaSelectImageClass *klass); +#if GTK_CHECK_VERSION(3, 0, 0) +static gboolean meta_select_image_draw (GtkWidget *widget, + cairo_t *cr); +#else static gboolean meta_select_image_expose_event (GtkWidget *widget, GdkEventExpose *event); +#endif static GtkImageClass *parent_class; @@ -684,10 +709,70 @@ meta_select_image_class_init (MetaSelectImageClass *klass) parent_class = g_type_class_peek (gtk_image_get_type ()); widget_class = GTK_WIDGET_CLASS (klass); - + + #if GTK_CHECK_VERSION(3, 0, 0) + widget_class->draw = meta_select_image_draw; + #else widget_class->expose_event = meta_select_image_expose_event; + #endif +} + +#if GTK_CHECK_VERSION(3, 0, 0) + +static gboolean +meta_select_image_draw (GtkWidget *widget, + cairo_t *cr) +{ + GtkAllocation allocation; + + gtk_widget_get_allocation (widget, &allocation); + + if (META_SELECT_IMAGE (widget)->selected) + { + GtkMisc *misc; + GtkRequisition requisition; + GtkStyleContext *context; + GdkRGBA color; + int x, y, w, h; + gint xpad, ypad; + gfloat xalign, yalign; + + misc = GTK_MISC (widget); + + gtk_widget_get_requisition (widget, &requisition); + gtk_misc_get_alignment (misc, &xalign, &yalign); + gtk_misc_get_padding (misc, &xpad, &ypad); + + x = (allocation.width - (requisition.width - xpad * 2)) * xalign + 0.5; + y = (allocation.height - (requisition.height - ypad * 2)) * yalign + 0.5; + + x -= INSIDE_SELECT_RECT + 1; + y -= INSIDE_SELECT_RECT + 1; + + w = requisition.width - OUTSIDE_SELECT_RECT * 2 - 1; + h = requisition.height - OUTSIDE_SELECT_RECT * 2 - 1; + + context = gtk_widget_get_style_context (widget); + + gtk_style_context_set_state (context, + gtk_widget_get_state_flags (widget)); + + gtk_style_context_lookup_color (context, "color", &color); + + cairo_set_line_width (cr, 2.0); + cairo_set_source_rgb (cr, color.red, color.green, color.blue); + + cairo_rectangle (cr, x, y, w + 1, h + 1); + cairo_stroke (cr); + + cairo_set_line_width (cr, 1.0); + } + + return GTK_WIDGET_CLASS (parent_class)->draw (widget, cr); } +#else + static gboolean meta_select_image_expose_event (GtkWidget *widget, GdkEventExpose *event) @@ -699,15 +784,18 @@ meta_select_image_expose_event (GtkWidget *widget, GtkStyle *style; GtkStateType state; cairo_t *cr; + GtkAllocation allocation; + + gtk_widgeT_get_allocation(widget, &allocation); misc = GTK_MISC (widget); - x = (widget->allocation.x * (1.0 - misc->xalign) + - (widget->allocation.x + widget->allocation.width + x = (allocation.x * (1.0 - misc->xalign) + + (allocation.x + allocation.width - (widget->requisition.width - misc->xpad * 2)) * misc->xalign) + 0.5; - y = (widget->allocation.y * (1.0 - misc->yalign) + - (widget->allocation.y + widget->allocation.height + y = (allocation.y * (1.0 - misc->yalign) + + (allocation.y + allocation.height - (widget->requisition.height - misc->ypad * 2)) * misc->yalign) + 0.5; @@ -719,7 +807,7 @@ meta_select_image_expose_event (GtkWidget *widget, style = gtk_widget_get_style (widget); state = gtk_widget_get_state (widget); - cr = gdk_cairo_create (widget->window); + cr = gdk_cairo_create (gtk_widget_get_window(widget)); cairo_set_line_width (cr, 2.0); gdk_cairo_set_source_color (cr, &style->fg[state]); @@ -746,6 +834,8 @@ meta_select_image_expose_event (GtkWidget *widget, return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event); } +#endif + #define META_TYPE_SELECT_WORKSPACE (meta_select_workspace_get_type ()) #define META_SELECT_WORKSPACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SELECT_WORKSPACE, MetaSelectWorkspace)) @@ -807,8 +897,13 @@ 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); +#else static gboolean meta_select_workspace_expose_event (GtkWidget *widget, GdkEventExpose *event); +#endif GType meta_select_workspace_get_type (void) @@ -846,7 +941,11 @@ meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass) widget_class = GTK_WIDGET_CLASS (klass); + #if GTK_CHECK_VERSION(3, 0, 0) + widget_class->draw = meta_select_workspace_draw; + #else widget_class->expose_event = meta_select_workspace_expose_event; + #endif } /** @@ -882,6 +981,96 @@ meta_convert_meta_to_wnck (MetaWindow *window, MetaScreen *screen) return wnck_window; } +#if GTK_CHECK_VERSION(3, 0, 0) + +static gboolean +meta_select_workspace_draw (GtkWidget *widget, + cairo_t *cr) +{ + MetaWorkspace *workspace; + WnckWindowDisplayInfo *windows; + GtkAllocation allocation; + int i, n_windows; + GList *tmp, *list; + + workspace = META_SELECT_WORKSPACE (widget)->workspace; + + list = meta_stack_list_windows (workspace->screen->stack, workspace); + n_windows = g_list_length (list); + windows = g_new (WnckWindowDisplayInfo, n_windows); + + tmp = list; + i = 0; + while (tmp != NULL) + { + MetaWindow *window; + gboolean ignoreable_sticky; + + window = tmp->data; + + ignoreable_sticky = window->on_all_workspaces && + workspace != workspace->screen->active_workspace; + + if (window->skip_pager || + !meta_window_showing_on_its_workspace (window) || + window->unmaps_pending || + ignoreable_sticky) + { + --n_windows; + } + else + { + windows[i] = meta_convert_meta_to_wnck (window, workspace->screen); + i++; + } + tmp = tmp->next; + } + + g_list_free (list); + + gtk_widget_get_allocation (widget, &allocation); + + wnck_draw_workspace (widget, + cr, + SELECT_OUTLINE_WIDTH, + SELECT_OUTLINE_WIDTH, + allocation.width - SELECT_OUTLINE_WIDTH * 2, + allocation.height - SELECT_OUTLINE_WIDTH * 2, + workspace->screen->rect.width, + workspace->screen->rect.height, + NULL, + (workspace->screen->active_workspace == workspace), + windows, + n_windows); + + g_free (windows); + + if (META_SELECT_WORKSPACE (widget)->selected) + { + GtkStyleContext *context; + GdkRGBA color; + + context = gtk_widget_get_style_context (widget); + + gtk_style_context_set_state (context, + gtk_widget_get_state_flags (widget)); + + gtk_style_context_lookup_color (context, "color", &color); + + cairo_set_line_width (cr, SELECT_OUTLINE_WIDTH); + cairo_set_source_rgb (cr, color.red, color.green, color.blue); + + cairo_rectangle (cr, + SELECT_OUTLINE_WIDTH / 2.0, SELECT_OUTLINE_WIDTH / 2.0, + allocation.width - SELECT_OUTLINE_WIDTH, + allocation.height - SELECT_OUTLINE_WIDTH); + cairo_stroke (cr); + } + + return TRUE; +} + +#else static gboolean meta_select_workspace_expose_event (GtkWidget *widget, @@ -893,6 +1082,9 @@ meta_select_workspace_expose_event (GtkWidget *widget, cairo_t *cr; int i, n_windows; GList *tmp, *list; + GtkAllocation allocation; + + gtk_widget_get_allocation(widget, &allocation); workspace = META_SELECT_WORKSPACE (widget)->workspace; @@ -930,11 +1122,11 @@ meta_select_workspace_expose_event (GtkWidget *widget, g_list_free (list); wnck_draw_workspace (widget, - widget->window, + gtk_widget_get_window(widget), SELECT_OUTLINE_WIDTH, SELECT_OUTLINE_WIDTH, - widget->allocation.width - SELECT_OUTLINE_WIDTH * 2, - widget->allocation.height - SELECT_OUTLINE_WIDTH * 2, + allocation.width - SELECT_OUTLINE_WIDTH * 2, + allocation.height - SELECT_OUTLINE_WIDTH * 2, workspace->screen->rect.width, workspace->screen->rect.height, NULL, @@ -947,7 +1139,7 @@ meta_select_workspace_expose_event (GtkWidget *widget, if (META_SELECT_WORKSPACE (widget)->selected) { style = gtk_widget_get_style (widget); - cr = gdk_cairo_create (widget->window); + cr = gdk_cairo_create (gtk_widget_get_window(widget)); gdk_cairo_set_source_color (cr, &style->fg[gtk_widget_get_state (widget)]); @@ -955,8 +1147,8 @@ meta_select_workspace_expose_event (GtkWidget *widget, cairo_rectangle (cr, SELECT_OUTLINE_WIDTH / 2.0, SELECT_OUTLINE_WIDTH / 2.0, - widget->allocation.width - SELECT_OUTLINE_WIDTH, - widget->allocation.height - SELECT_OUTLINE_WIDTH); + allocation.width - SELECT_OUTLINE_WIDTH, + allocation.height - SELECT_OUTLINE_WIDTH); cairo_stroke (cr); cairo_destroy (cr); @@ -965,3 +1157,4 @@ meta_select_workspace_expose_event (GtkWidget *widget, return TRUE; } +#endif \ No newline at end of file diff --git a/src/ui/theme.c b/src/ui/theme.c index d5efce8e..655c63f3 100644 --- a/src/ui/theme.c +++ b/src/ui/theme.c @@ -3402,25 +3402,36 @@ static void meta_draw_op_draw_with_env (const MetaDrawOp *op, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, MetaRectangle rect, MetaPositionExprEnv *env) { GdkColor color; - cairo_t *cr; + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_save(cr); + gtk_style_context_save(style_gtk); + #else + cairo_t *cr; cr = gdk_cairo_create (drawable); + #endif cairo_set_line_width (cr, 1.0); + #if !GTK_CHECK_VERSION(3, 0, 0) if (clip) { gdk_cairo_rectangle (cr, clip); cairo_clip (cr); } - + #endif + switch (op->type) { case META_DRAW_LINE: @@ -3686,6 +3697,34 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rwidth = parse_size_unchecked (op->data.gtk_arrow.width, env); rheight = parse_size_unchecked (op->data.gtk_arrow.height, env); + #if GTK_CHECK_VERSION(3, 0, 0) + + double size = MAX(rwidth, rheight), angle = 0; + + switch (op->data.gtk_arrow.arrow) + { + case GTK_ARROW_UP: + angle = 0; + break; + case GTK_ARROW_RIGHT: + angle = M_PI / 2; + break; + case GTK_ARROW_DOWN: + angle = M_PI; + break; + case GTK_ARROW_LEFT: + angle = 3 * M_PI / 2; + break; + case GTK_ARROW_NONE: + return; + } + + gtk_style_context_set_state (style_gtk, + state_flags_from_gtk_state (op->data.gtk_arrow.state)); + gtk_render_arrow (style_gtk, cr, angle, rx, ry, size); + + #else + gtk_paint_arrow (style_gtk, drawable, op->data.gtk_arrow.state, @@ -3696,6 +3735,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, op->data.gtk_arrow.arrow, op->data.gtk_arrow.filled, rx, ry, rwidth, rheight); + #endif } break; @@ -3708,6 +3748,12 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rwidth = parse_size_unchecked (op->data.gtk_box.width, env); 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_render_background (style_gtk, cr, rx, ry, rwidth, rheight); + gtk_render_frame (style_gtk, cr, rx, ry, rwidth, rheight); + #else gtk_paint_box (style_gtk, drawable, op->data.gtk_box.state, @@ -3716,6 +3762,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, widget, "marco", rx, ry, rwidth, rheight); + #endif } break; @@ -3727,6 +3774,11 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, ry1 = parse_y_position_unchecked (op->data.gtk_vline.y1, env); 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_render_line (style_gtk, cr, rx, ry1, rx, ry2); + #else gtk_paint_vline (style_gtk, drawable, op->data.gtk_vline.state, @@ -3734,6 +3786,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, widget, "marco", ry1, ry2, rx); + #endif } break; @@ -3787,8 +3840,13 @@ 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, drawable, clip, info, - d_rect); + style_gtk, widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, clip, + #endif + info, d_rect); } break; @@ -3796,7 +3854,9 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, { int rx, ry, rwidth, rheight; int tile_xoffset, tile_yoffset; + #if !GTK_CHECK_VERSION(3, 0, 0) GdkRectangle new_clip; + #endif MetaRectangle tile; rx = parse_x_position_unchecked (op->data.tile.x, env); @@ -3804,6 +3864,41 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, rwidth = parse_size_unchecked (op->data.tile.width, env); rheight = parse_size_unchecked (op->data.tile.height, env); + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_save (cr); + + cairo_rectangle (cr, rx, ry, rwidth, rheight); + cairo_clip (cr); + + tile_xoffset = parse_x_position_unchecked (op->data.tile.tile_xoffset, env); + tile_yoffset = parse_y_position_unchecked (op->data.tile.tile_yoffset, env); + /* tile offset should not include x/y */ + tile_xoffset -= rect.x; + tile_yoffset -= rect.y; + + tile.width = parse_size_unchecked (op->data.tile.tile_width, env); + tile.height = parse_size_unchecked (op->data.tile.tile_height, env); + + tile.x = rx - tile_xoffset; + + while (tile.x < (rx + rwidth)) + { + tile.y = ry - tile_yoffset; + while (tile.y < (ry + rheight)) + { + meta_draw_op_list_draw_with_style (op->data.tile.op_list, + style_gtk, widget, cr, info, + tile); + + tile.y += tile.height; + } + + tile.x += tile.width; + } + cairo_restore (cr); + + #else + new_clip.x = rx; new_clip.y = ry; new_clip.width = rwidth; @@ -3838,6 +3933,7 @@ meta_draw_op_draw_with_env (const MetaDrawOp *op, tile.x += tile.width; } } + #endif } break; } @@ -3849,18 +3945,29 @@ void meta_draw_op_draw_with_style (const MetaDrawOp *op, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, MetaRectangle logical_region) { 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, drawable, clip, + meta_draw_op_draw_with_env (op, style_gtk, widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, clip, + #endif info, logical_region, &env); @@ -3869,13 +3976,22 @@ meta_draw_op_draw_with_style (const MetaDrawOp *op, void meta_draw_op_draw (const MetaDrawOp *op, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, MetaRectangle logical_region) { meta_draw_op_draw_with_style (op, gtk_widget_get_style (widget), widget, - drawable, clip, info, logical_region); + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, clip, + #endif + info, logical_region); } MetaDrawOpList* @@ -3929,17 +4045,27 @@ void meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, MetaRectangle rect) { + /* BOOKMARK */ + int i; + #if !GTK_CHECK_VERSION(3, 0, 0) GdkRectangle active_clip; GdkRectangle orig_clip; + #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; @@ -3957,6 +4083,10 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, * evaluated), we make an array of those, and then fold * adjacent items when possible. */ + + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_save(cr); + #else if (clip) { orig_clip = *clip; @@ -3970,11 +4100,36 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, } active_clip = orig_clip; + #endif for (i = 0; i < op_list->n_ops; i++) { MetaDrawOp *op = op_list->ops[i]; + #if GTK_CHECK_VERSION(3, 0, 0) + if (op->type == META_DRAW_CLIP) + { + cairo_restore (cr); + + cairo_rectangle (cr, + parse_x_position_unchecked (op->data.clip.x, &env), + parse_y_position_unchecked (op->data.clip.y, &env), + parse_size_unchecked (op->data.clip.width, &env), + parse_size_unchecked (op->data.clip.height, &env)); + cairo_clip (cr); + + cairo_save (cr); + } + else if (gdk_cairo_get_clip_rectangle (cr, NULL)) + { + meta_draw_op_draw_with_env (op, + style_gtk, widget, cr, info, + rect, + &env); + } + + #else + if (op->type == META_DRAW_CLIP) { active_clip.x = parse_x_position_unchecked (op->data.clip.x, &env); @@ -3992,20 +4147,34 @@ meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list, rect, &env); } + #endif } + + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_restore(cr); + #endif } void meta_draw_op_list_draw (const MetaDrawOpList *op_list, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, MetaRectangle rect) { meta_draw_op_list_draw_with_style (op_list, gtk_widget_get_style (widget), widget, - drawable, clip, info, rect); + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, clip, + #endif + info, rect); } void @@ -4313,10 +4482,14 @@ void meta_frame_style_draw_with_style (MetaFrameStyle *style, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, int x_offset, int y_offset, const GdkRectangle *clip, + #endif const MetaFrameGeometry *fgeom, int client_width, int client_height, @@ -4326,6 +4499,7 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, GdkPixbuf *mini_icon, GdkPixbuf *icon) { + /* BOOKMARK */ int i, j; GdkRectangle titlebar_rect; GdkRectangle left_titlebar_edge; @@ -4336,7 +4510,9 @@ 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; @@ -4394,7 +4570,9 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, while (i < META_FRAME_PIECE_LAST) { GdkRectangle rect; + #if !GTK_CHECK_VERSION(3, 0, 0) GdkRectangle combined_clip; + #endif switch ((MetaFramePiece) i) { @@ -4461,6 +4639,43 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, break; } + #if GTK_CHECK_VERSION(3, 0, 0) + + cairo_save (cr); + + gdk_cairo_rectangle (cr, &rect); + cairo_clip (cr); + + if (gdk_cairo_get_clip_rectangle (cr, NULL)) + { + MetaDrawOpList *op_list; + MetaFrameStyle *parent; + + parent = style; + op_list = NULL; + while (parent && op_list == NULL) + { + op_list = parent->pieces[i]; + parent = parent->parent; + } + + if (op_list) + { + 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, + cr, + &draw_info, + m_rect); + } + } + + cairo_restore (cr); + + #else + rect.x += x_offset; rect.y += y_offset; @@ -4498,8 +4713,70 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, } } + #endif + /* Draw buttons just before overlay */ + #if GTK_CHECK_VERSION(3, 0, 0) + + if ((i + 1) == META_FRAME_PIECE_OVERLAY) + { + MetaDrawOpList *op_list; + int middle_bg_offset; + + middle_bg_offset = 0; + j = 0; + while (j < META_BUTTON_TYPE_LAST) + { + MetaButtonState button_state; + + button_rect (j, fgeom, middle_bg_offset, &rect); + + button_state = map_button_state (j, fgeom, middle_bg_offset, button_states); + + op_list = get_button (style, j, button_state); + + if (op_list) + { + cairo_save (cr); + gdk_cairo_rectangle (cr, &rect); + cairo_clip (cr); + + if (gdk_cairo_get_clip_rectangle (cr, NULL)) + { + 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, + cr, + &draw_info, + m_rect); + } + + cairo_restore (cr); + } + + /* MIDDLE_BACKGROUND type may get drawn more than once */ + if ((j == META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND || + j == META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND) && + middle_bg_offset < MAX_MIDDLE_BACKGROUNDS) + { + ++middle_bg_offset; + } + else + { + middle_bg_offset = 0; + ++j; + } + } + } + + #else + if ((i + 1) == META_FRAME_PIECE_OVERLAY) { int middle_bg_offset; @@ -4556,6 +4833,8 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, } } + #endif + ++i; } } @@ -4563,10 +4842,14 @@ meta_frame_style_draw_with_style (MetaFrameStyle *style, void meta_frame_style_draw (MetaFrameStyle *style, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, int x_offset, int y_offset, const GdkRectangle *clip, + #endif const MetaFrameGeometry *fgeom, int client_width, int client_height, @@ -4577,8 +4860,12 @@ meta_frame_style_draw (MetaFrameStyle *style, GdkPixbuf *icon) { meta_frame_style_draw_with_style (style, gtk_widget_get_style (widget), widget, - drawable, x_offset, y_offset, - clip, fgeom, client_width, client_height, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, x_offset, y_offset, clip, + #endif + fgeom, client_width, client_height, title_layout, text_height, button_states, mini_icon, icon); } @@ -5133,10 +5420,14 @@ void meta_theme_draw_frame_with_style (MetaTheme *theme, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, int y_offset, + #endif MetaFrameType type, MetaFrameFlags flags, int client_width, @@ -5170,9 +5461,11 @@ meta_theme_draw_frame_with_style (MetaTheme *theme, meta_frame_style_draw_with_style (style, style_gtk, widget, - drawable, - x_offset, y_offset, - clip, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, x_offset, y_offset, clip, + #endif &fgeom, client_width, client_height, title_layout, @@ -5184,10 +5477,14 @@ meta_theme_draw_frame_with_style (MetaTheme *theme, void meta_theme_draw_frame (MetaTheme *theme, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, int y_offset, + #endif MetaFrameType type, MetaFrameFlags flags, int client_width, @@ -5200,8 +5497,12 @@ meta_theme_draw_frame (MetaTheme *theme, GdkPixbuf *icon) { meta_theme_draw_frame_with_style (theme, gtk_widget_get_style (widget), widget, - drawable, clip, x_offset, y_offset, type,flags, - client_width, client_height, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, clip, x_offset, y_offset, + #endif + type, flags, client_width, client_height, title_layout, text_height, button_layout, button_states, mini_icon, icon); @@ -5210,10 +5511,14 @@ meta_theme_draw_frame (MetaTheme *theme, void meta_theme_draw_frame_by_name (MetaTheme *theme, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, int y_offset, + #endif const gchar *style_name, MetaFrameFlags flags, int client_width, @@ -5244,9 +5549,11 @@ meta_theme_draw_frame_by_name (MetaTheme *theme, meta_frame_style_draw (style, widget, - drawable, - x_offset, y_offset, - clip, + #if GTK_CHECK_VERSION(3, 0, 0) + cr, + #else + drawable, x_offset, y_offset, clip, + #endif &fgeom, client_width, client_height, title_layout, diff --git a/src/ui/theme.h b/src/ui/theme.h index f7214e9b..30cf7ade 100644 --- a/src/ui/theme.h +++ b/src/ui/theme.h @@ -897,8 +897,12 @@ MetaDrawOp* meta_draw_op_new (MetaDrawType type); void meta_draw_op_free (MetaDrawOp *op); void meta_draw_op_draw (const MetaDrawOp *op, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, /* logical region being drawn */ MetaRectangle logical_region); @@ -906,8 +910,12 @@ void meta_draw_op_draw (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) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, /* logical region being drawn */ MetaRectangle logical_region); @@ -917,15 +925,23 @@ void meta_draw_op_list_ref (MetaDrawOpList *op_list); void meta_draw_op_list_unref (MetaDrawOpList *op_list); void meta_draw_op_list_draw (const MetaDrawOpList *op_list, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif 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) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, + #endif const MetaDrawInfo *info, MetaRectangle rect); void meta_draw_op_list_append (MetaDrawOpList *op_list, @@ -955,10 +971,14 @@ void meta_frame_style_unref (MetaFrameStyle *style); void meta_frame_style_draw (MetaFrameStyle *style, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, int x_offset, int y_offset, const GdkRectangle *clip, + #endif const MetaFrameGeometry *fgeom, int client_width, int client_height, @@ -972,10 +992,14 @@ void meta_frame_style_draw (MetaFrameStyle *style, void meta_frame_style_draw_with_style (MetaFrameStyle *style, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, int x_offset, int y_offset, const GdkRectangle *clip, + #endif const MetaFrameGeometry *fgeom, int client_width, int client_height, @@ -1020,10 +1044,14 @@ double meta_theme_get_title_scale (MetaTheme *theme, void meta_theme_draw_frame (MetaTheme *theme, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, int y_offset, + #endif MetaFrameType type, MetaFrameFlags flags, int client_width, @@ -1037,10 +1065,14 @@ void meta_theme_draw_frame (MetaTheme *theme, void meta_theme_draw_frame_by_name (MetaTheme *theme, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, int y_offset, + #endif const gchar *style_name, MetaFrameFlags flags, int client_width, @@ -1055,10 +1087,14 @@ void meta_theme_draw_frame_by_name (MetaTheme *theme, void meta_theme_draw_frame_with_style (MetaTheme *theme, GtkStyle *style_gtk, GtkWidget *widget, + #if GTK_CHECK_VERSION(3, 0, 0) + cairo_t *cr, + #else GdkDrawable *drawable, const GdkRectangle *clip, int x_offset, int y_offset, + #endif MetaFrameType type, MetaFrameFlags flags, int client_width, diff --git a/src/ui/themewidget.c b/src/ui/themewidget.c index 3489618a..938248bd 100644 --- a/src/ui/themewidget.c +++ b/src/ui/themewidget.c @@ -34,11 +34,28 @@ static void meta_area_class_init (MetaAreaClass *klass); static void meta_area_init (MetaArea *area); static void meta_area_size_request (GtkWidget *widget, GtkRequisition *req); +#if GTK_CHECK_VERSION(3, 0, 0) +static gboolean meta_area_draw (GtkWidget *widget, + cairo_t *cr); +static void meta_area_get_preferred_height (GtkWidget *widget, + gint *minimal, + gint *natural); +static void meta_area_get_preferred_width (GtkWidget *widget, + gint *minimal, + gint *natural); +#else static gint meta_area_expose (GtkWidget *widget, GdkEventExpose *event); +#endif static void meta_area_finalize (GObject *object); +#if GTK_CHECK_VERSION(3, 0, 0) + +G_DEFINE_TYPE (MetaArea, meta_area, GTK_TYPE_MISC); + +#else + static GtkMiscClass *parent_class; GType @@ -66,35 +83,49 @@ meta_area_get_type (void) return area_type; } +#endif + static void meta_area_class_init (MetaAreaClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); - GtkObjectClass UNUSED_VARIABLE *object_class; GtkWidgetClass *widget_class; - object_class = (GtkObjectClass*) class; widget_class = (GtkWidgetClass*) class; parent_class = g_type_class_peek (gtk_misc_get_type ()); gobject_class->finalize = meta_area_finalize; + #if GTK_CHECK_VERSION(3, 0, 0) + widget_class->draw = meta_area_draw; + widget_class->get_preferred_width = meta_area_get_preferred_width; + widget_class->get_preferred_height = meta_area_get_preferred_height; + #else widget_class->expose_event = meta_area_expose; widget_class->size_request = meta_area_size_request; + #endif } static void meta_area_init (MetaArea *area) { + #if GTK_CHECK_VERSION(3, 0, 0) + gtk_widget_set_has_window (GTK_WIDGET(area), FALSE); + #else GTK_WIDGET_SET_FLAGS (area, GTK_NO_WINDOW); + #endif } GtkWidget* meta_area_new (void) { MetaArea *area; - + + #if GTK_CHECK_VERSION(3, 0, 0) + area = g_object_new (META_TYPE_AREA, NULL); + #else area = gtk_type_new (META_TYPE_AREA); + #endif return GTK_WIDGET (area); } @@ -112,6 +143,60 @@ meta_area_finalize (GObject *object) G_OBJECT_CLASS (parent_class)->finalize (object); } +#if GTK_CHECK_VERSION(3, 0, 0) + +static gboolean +meta_area_draw (GtkWidget *widget, + cairo_t *cr) +{ + MetaArea *area; + GtkMisc *misc; + gint x, y; + gfloat xalign, yalign; + gint xpad, ypad; + GtkAllocation allocation; + GtkRequisition req; + + g_return_val_if_fail (META_IS_AREA (widget), FALSE); + + if (gtk_widget_is_drawable (widget)) + { + area = META_AREA (widget); + misc = GTK_MISC (widget); + + gtk_widget_get_allocation(widget, &allocation); + gtk_widget_get_requisition(widget, &req); + + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) + gtk_misc_get_alignment(misc, &xalign, &yalign); + else + { + gtk_misc_get_alignment(misc, &xalign, &yalign); + xalign = 1.0 - xalign; + } + + gtk_misc_get_padding(misc, &xpad, &ypad); + + + x = floor (allocation.x + xpad + + ((allocation.width - req.width) * xalign) + + 0.5); + y = floor (allocation.y + ypad + + ((allocation.height - req.height) * yalign) + + 0.5); + + if (area->draw_func) + { + (* area->draw_func) (area, cr, + area->user_data); + } + } + + return FALSE; +} + +#else + static gint meta_area_expose (GtkWidget *widget, GdkEventExpose *event) @@ -151,6 +236,8 @@ meta_area_expose (GtkWidget *widget, return FALSE; } +#endif + static void meta_area_size_request (GtkWidget *widget, GtkRequisition *req) @@ -169,10 +256,42 @@ meta_area_size_request (GtkWidget *widget, } } +#if GTK_CHECK_VERSION(3, 0, 0) + +static void +meta_area_get_preferred_width (GtkWidget *widget, + gint *minimal, + gint *natural) +{ + GtkRequisition requisition; + + meta_area_size_request (widget, &requisition); + + *minimal = *natural = requisition.width; +} + +static void +meta_area_get_preferred_height (GtkWidget *widget, + gint *minimal, + gint *natural) +{ + GtkRequisition requisition; + + meta_area_size_request (widget, &requisition); + + *minimal = *natural = requisition.height; +} + +#endif + void meta_area_setup (MetaArea *area, MetaAreaSizeFunc size_func, + #if GTK_CHECK_VERSION(3, 0, 0) + MetaAreaDrawFunc draw_func, + #else MetaAreaExposeFunc expose_func, + #endif void *user_data, GDestroyNotify dnotify) { @@ -180,7 +299,11 @@ meta_area_setup (MetaArea *area, (* area->dnotify) (area->user_data); area->size_func = size_func; + #if GTK_CHECK_VERSION(3, 0, 0) + area->draw_func = draw_func; + #else area->expose_func = expose_func; + #endif area->user_data = user_data; area->dnotify = dnotify; diff --git a/src/ui/themewidget.h b/src/ui/themewidget.h index 79f10e65..940b44fc 100644 --- a/src/ui/themewidget.h +++ b/src/ui/themewidget.h @@ -42,19 +42,30 @@ typedef void (* MetaAreaSizeFunc) (MetaArea *area, int *width, int *height, void *user_data); - +#if GTK_CHECK_VERSION(3, 0, 0) +typedef void (* MetaAreaDrawFunc) (MetaArea *area, + cairo_t *cr, + void *user_data); +#else typedef void (* MetaAreaExposeFunc) (MetaArea *area, GdkEventExpose *event, int x_offset, int y_offset, void *user_data); +#endif + +#define parent_class meta_area_parent_class struct _MetaArea { GtkMisc misc; MetaAreaSizeFunc size_func; + #if GTK_CHECK_VERSION(3, 0, 0) + MetaAreaDrawFunc draw_func; + #else MetaAreaExposeFunc expose_func; + #endif void *user_data; GDestroyNotify dnotify; }; @@ -70,7 +81,11 @@ GtkWidget* meta_area_new (void); void meta_area_setup (MetaArea *area, MetaAreaSizeFunc size_func, + #if GTK_CHECK_VERSION(3, 0, 0) + MetaAreaDrawFunc draw_func, + #else MetaAreaExposeFunc expose_func, + #endif void *user_data, GDestroyNotify dnotify); -- cgit v1.2.1