mate-panel: Add GTK3 support

author: Stefano Karapetsas <[email protected]> 2013-10-26 14:34:04 +0200
committer: Stefano Karapetsas <[email protected]> 2013-10-26 14:34:04 +0200
commit: a6efbbceb5b1122512cd01609eab99fe522d8435 (patch)
tree: 43a85aa03fce3f022c5db5f60579daea90cecae3
parent: fa97943c56e331668aff4b3587fe70c5edcd36b2 (diff)
download: mate-panel-a6efbbceb5b1122512cd01609eab99fe522d8435.tar.bz2
mate-panel-a6efbbceb5b1122512cd01609eab99fe522d8435.tar.xz
39 files changed, 1708 insertions, 116 deletions
diff --git a/mate-panel/button-widget.c b/mate-panel/button-widget.c
index 7748a821..2d3c29b3 100644
--- a/mate-panel/button-widget.c
+++ b/mate-panel/button-widget.c
@@ -115,6 +115,7 @@ make_hc_pixbuf (GdkPixbuf *pb)
 static void
 button_widget_realize(GtkWidget *widget)
 {
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GtkAllocation allocation;
 GdkWindowAttr attributes;
 gint attributes_mask;
@@ -153,12 +154,23 @@ button_widget_realize(GtkWidget *widget)
 gdk_window_set_user_data (button->event_window, widget);
 
 widget->style = gtk_style_attach (widget->style, gtk_widget_get_window (widget));
+#else
+ gtk_widget_add_events (widget, GDK_POINTER_MOTION_MASK |
+ GDK_POINTER_MOTION_HINT_MASK |
+ GDK_KEY_PRESS_MASK);
+
+ GTK_WIDGET_CLASS (button_widget_parent_class)->realize (widget);
+#endif
 
 BUTTON_WIDGET (widget)->priv->icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
 g_signal_connect_object (BUTTON_WIDGET (widget)->priv->icon_theme,
 "changed",
 G_CALLBACK (button_widget_icon_theme_changed),
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget,
+#else
 button,
+#endif
 G_CONNECT_SWAPPED);
 
 button_widget_reload_pixbuf (BUTTON_WIDGET (widget));
@@ -167,6 +179,11 @@ button_widget_realize(GtkWidget *widget)
 static void
 button_widget_unrealize (GtkWidget *widget)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ g_signal_handlers_disconnect_by_func (BUTTON_WIDGET (widget)->priv->icon_theme,
+ G_CALLBACK (button_widget_icon_theme_changed),
+ widget);
+#else
 GtkButton *button;
 
 g_return_if_fail (widget != NULL);
@@ -179,6 +196,7 @@ button_widget_unrealize (GtkWidget *widget)
 gdk_window_destroy (button->event_window);
 button->event_window = NULL;
 }
+#endif
 
 GTK_WIDGET_CLASS (button_widget_parent_class)->unrealize (widget);
 }
@@ -367,13 +385,24 @@ calc_arrow (PanelOrientation orientation,
 }
 
 static gboolean
+#if GTK_CHECK_VERSION (3, 0, 0)
+button_widget_draw (GtkWidget *widget,
+ cairo_t *cr)
+#else
 button_widget_expose (GtkWidget *widget,
 GdkEventExpose *event)
+#endif
 {
 ButtonWidget *button_widget;
 GtkButton *button;
 GdkWindow *window;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GtkStateFlags state_flags;
+ int width;
+ int height;
+#else
 GtkAllocation allocation;
+#endif
 GdkRectangle area, image_bound;
 GtkStyle *style;
 int off;
@@ -381,10 +410,12 @@ button_widget_expose (GtkWidget *widget,
 GdkPixbuf *pb = NULL;
 
 g_return_val_if_fail (BUTTON_IS_WIDGET (widget), FALSE);
+#if !GTK_CHECK_VERSION (3, 0, 0)
 g_return_val_if_fail (event != NULL, FALSE);
 
 if (!gtk_widget_get_visible (widget) || !gtk_widget_get_mapped (widget))
 return FALSE;
+#endif
 
 button_widget = BUTTON_WIDGET (widget);
 
@@ -393,12 +424,23 @@ button_widget_expose (GtkWidget *widget,
 
 button = GTK_BUTTON (widget);
 window = gtk_widget_get_window (widget);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ state_flags = gtk_widget_get_state_flags (widget);
+ width = gtk_widget_get_allocated_width (widget);
+ height = gtk_widget_get_allocated_height (widget);
+#else
 gtk_widget_get_allocation (widget, &allocation);
+#endif
 
 /* offset for pressed buttons */
 off = (button_widget->priv->activatable &&
- button->in_button && button->button_down) ?
+#if GTK_CHECK_VERSION (3, 0, 0)
+ (state_flags & GTK_STATE_FLAG_PRELIGHT) && (state_flags & GTK_STATE_FLAG_ACTIVE)) ?
+ BUTTON_WIDGET_DISPLACEMENT * height / 48.0 : 0;
+#else
+ button->in_button && button->button_down) ?
 BUTTON_WIDGET_DISPLACEMENT * allocation.height / 48.0 : 0;
+#endif
 
 if (!button_widget->priv->activatable) {
 pb = gdk_pixbuf_copy (button_widget->priv->pixbuf);
@@ -407,7 +449,11 @@ button_widget_expose (GtkWidget *widget,
 0.8,
 TRUE);
 } else if (panel_global_config_get_highlight_when_over () && 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ (state_flags & GTK_STATE_FLAG_PRELIGHT || gtk_widget_has_focus (widget)))
+#else
 (button->in_button || gtk_widget_has_focus (widget)))
+#endif
 pb = g_object_ref (button_widget->priv->pixbuf_hc);
 else
 pb = g_object_ref (button_widget->priv->pixbuf);
@@ -416,6 +462,10 @@ button_widget_expose (GtkWidget *widget,
 
 w = gdk_pixbuf_get_width (pb);
 h = gdk_pixbuf_get_height (pb);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x = off + (width - w)/2;
+ y = off + (height - h)/2;
+#else
 x = allocation.x + off + (allocation.width - w)/2;
 y = allocation.y + off + (allocation.height - h)/2;
 
@@ -425,7 +475,14 @@ button_widget_expose (GtkWidget *widget,
 image_bound.height = h;
 
 area = event->area;
-
+#endif
+
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_save (cr);
+ gdk_cairo_set_source_pixbuf (cr, pb, x, y);
+ cairo_paint (cr);
+ cairo_restore (cr);
+#else
 if (gdk_rectangle_intersect (&area, &allocation, &area) &&
 gdk_rectangle_intersect (&image_bound, &area, &image_bound))
 gdk_draw_pixbuf (window, NULL, pb,
@@ -434,6 +491,7 @@ button_widget_expose (GtkWidget *widget,
 image_bound.width, image_bound.height,
 GDK_RGB_DITHER_NORMAL,
 0, 0);
+#endif
 
 g_object_unref (pb);
 
@@ -441,56 +499,97 @@ button_widget_expose (GtkWidget *widget,
 
 if (button_widget->priv->arrow) {
 GtkArrowType arrow_type;
- int x, y, width, height;
-
- x = y = width = height = -1;
 
 arrow_type = calc_arrow (button_widget->priv->orientation,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ width,
+ height,
+ &x,
+ &y,
+ &w,
+ &h);
+#else
 allocation.width,
 allocation.height,
 &x,
 &y,
 &width,
 &height);
+#endif
 
 gtk_paint_arrow (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
 window,
+#endif
 GTK_STATE_NORMAL,
 GTK_SHADOW_NONE,
+#if !GTK_CHECK_VERSION (3, 0, 0)
 NULL,
+#endif
 widget,
 "panel-button",
 arrow_type,
 TRUE,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x, y, w, h);
+#else
 allocation.x + x,
 allocation.y + y,
 width,
 height);
+#endif
 }
 
 if (button_widget->priv->dnd_highlight) {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_save (cr);
+ cairo_set_line_width (cr, 1);
+ gdk_cairo_set_source_color (cr, &style->black);
+ cairo_rectangle (cr, 0.5, 0.5, width - 1, height - 1);
+ cairo_stroke (cr);
+ cairo_restore (cr);
+#else
 gdk_draw_rectangle(window, style->black_gc, FALSE,
 allocation.x, allocation.y,
 allocation.width - 1,
 allocation.height - 1);
+#endif
 }
 
 if (gtk_widget_has_focus (widget)) {
 gint focus_width, focus_pad;
- gint x, y, width, height;
 
 gtk_widget_style_get (widget,
 "focus-line-width", &focus_width,
 "focus-padding", &focus_pad,
 NULL);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x = focus_pad;
+ y = focus_pad;
+ w= width - 2 * focus_pad;
+ h= height - 2 * focus_pad;
+#else
 x = allocation.x + focus_pad;
 y = allocation.y + focus_pad;
 width = allocation.width - 2 * focus_pad;
 height = allocation.height - 2 * focus_pad;
- gtk_paint_focus (style, window,
+#endif
+ gtk_paint_focus (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
 GTK_STATE_NORMAL,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget, "button",
+ x, y, w, h);
+#else
 &event->area, widget, "button",
 x, y, width, height);
+#endif
 }
 
 return FALSE;
@@ -508,6 +607,28 @@ button_widget_size_request (GtkWidget *widget,
 }
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void
+button_widget_get_preferred_width (GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ GtkRequisition req;
+ button_widget_size_request (widget, &req);
+ *minimum_width = *natural_width = req.width;
+}
+
+static void
+button_widget_get_preferred_height (GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ GtkRequisition req;
+ button_widget_size_request (widget, &req);
+ *minimum_height = *natural_height = req.height;
+}
+#endif
+
 static void
 button_widget_size_allocate (GtkWidget *widget,
 GtkAllocation *allocation)
@@ -516,6 +637,10 @@ button_widget_size_allocate (GtkWidget *widget,
 GtkButton *button = GTK_BUTTON (widget);
 int size;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GTK_WIDGET_CLASS (button_widget_parent_class)->size_allocate (widget, allocation);
+#endif
+
 if (button_widget->priv->orientation & PANEL_HORIZONTAL_MASK)
 size = allocation->height;
 else
@@ -538,6 +663,7 @@ button_widget_size_allocate (GtkWidget *widget,
 button_widget_reload_pixbuf (button_widget);
 }
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 gtk_widget_set_allocation (widget, allocation);
 
 if (gtk_widget_get_realized (widget)) {
@@ -547,6 +673,7 @@ button_widget_size_allocate (GtkWidget *widget,
 allocation->width,
 allocation->height);
 }
+#endif
 }
 
 static void
@@ -583,9 +710,19 @@ button_widget_enter_notify (GtkWidget *widget, GdkEventCrossing *event)
 
 g_return_val_if_fail (BUTTON_IS_WIDGET (widget), FALSE);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GtkStateFlags state_flags;
+ in_button = state_flags & GTK_STATE_FLAG_PRELIGHT;
+#else
 in_button = GTK_BUTTON (widget)->in_button;
+#endif
 GTK_WIDGET_CLASS (button_widget_parent_class)->enter_notify_event (widget, event);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ state_flags = gtk_widget_get_state_flags (widget);
+ if (in_button != (state_flags & GTK_STATE_FLAG_PRELIGHT) &&
+#else
 if (in_button != GTK_BUTTON (widget)->in_button &&
+#endif
 panel_global_config_get_highlight_when_over ())
 gtk_widget_queue_draw (widget);
 
@@ -599,9 +736,19 @@ button_widget_leave_notify (GtkWidget *widget, GdkEventCrossing *event)
 
 g_return_val_if_fail (BUTTON_IS_WIDGET (widget), FALSE);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GtkStateFlags state_flags;
+ in_button = state_flags & GTK_STATE_FLAG_PRELIGHT;
+#else
 in_button = GTK_BUTTON (widget)->in_button;
+#endif
 GTK_WIDGET_CLASS (button_widget_parent_class)->leave_notify_event (widget, event);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ state_flags = gtk_widget_get_state_flags (widget);
+ if (in_button != (state_flags & GTK_STATE_FLAG_PRELIGHT) &&
+#else
 if (in_button != GTK_BUTTON (widget)->in_button &&
+#endif
 panel_global_config_get_highlight_when_over ())
 gtk_widget_queue_draw (widget);
 
@@ -645,11 +792,20 @@ button_widget_class_init (ButtonWidgetClass *klass)
 widget_class->realize = button_widget_realize;
 widget_class->unrealize = button_widget_unrealize;
 widget_class->size_allocate = button_widget_size_allocate;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->get_preferred_width = button_widget_get_preferred_width;
+ widget_class->get_preferred_height = button_widget_get_preferred_height;
+#else
 widget_class->size_request = button_widget_size_request;
+#endif
 widget_class->button_press_event = button_widget_button_press;
 widget_class->enter_notify_event = button_widget_enter_notify;
 widget_class->leave_notify_event = button_widget_leave_notify;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->draw = button_widget_draw;
+#else
 widget_class->expose_event = button_widget_expose;
+#endif
 
 button_class->activate = button_widget_activate;
 
diff --git a/mate-panel/drawer.c b/mate-panel/drawer.c
index 727924b2..6961343f 100644
--- a/mate-panel/drawer.c
+++ b/mate-panel/drawer.c
@@ -16,7 +16,11 @@
 #include <string.h>
 
 #include <glib/gi18n.h>
+#include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gdk/gdkkeysyms-compat.h>
+#endif
 #include <gio/gio.h>
 
 #include "drawer.h"
diff --git a/mate-panel/libegg/eggsmclient-xsmp.c b/mate-panel/libegg/eggsmclient-xsmp.c
index 75fced19..b5f90cee 100644
--- a/mate-panel/libegg/eggsmclient-xsmp.c
+++ b/mate-panel/libegg/eggsmclient-xsmp.c
@@ -35,7 +35,11 @@
 #include <unistd.h>
 #include <X11/SM/SMlib.h>
 
+#include <gtk/gtk.h>
 #include <gdk/gdk.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gdk/gdkx.h>
+#endif
 
 #define EGG_TYPE_SM_CLIENT_XSMP (egg_sm_client_xsmp_get_type ())
 #define EGG_SM_CLIENT_XSMP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EGG_TYPE_SM_CLIENT_XSMP, EggSMClientXSMP))
@@ -367,7 +371,11 @@ sm_client_xsmp_startup (EggSMClient *client,
 free (ret_client_id);
 
 gdk_threads_enter ();
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdk_x11_set_sm_client_id (xsmp->client_id);
+#else
 gdk_set_sm_client_id (xsmp->client_id);
+#endif
 gdk_threads_leave ();
 
 g_debug ("Got client ID \"%s\"", xsmp->client_id);
diff --git a/mate-panel/libmate-panel-applet-private/mate-panel-applet-container.c b/mate-panel/libmate-panel-applet-private/mate-panel-applet-container.c
index 9eb7d897..e99c8cf8 100644
--- a/mate-panel/libmate-panel-applet-private/mate-panel-applet-container.c
+++ b/mate-panel/libmate-panel-applet-private/mate-panel-applet-container.c
@@ -21,6 +21,7 @@
 */
 
 #include <string.h>
+#include <gtk/gtkx.h>
 #include "mate-panel-applet-container.h"
 #include "panel-marshal.h"
 
diff --git a/mate-panel/libpanel-util/panel-icon-chooser.c b/mate-panel/libpanel-util/panel-icon-chooser.c
index 7cd56fb4..a24d425e 100644
--- a/mate-panel/libpanel-util/panel-icon-chooser.c
+++ b/mate-panel/libpanel-util/panel-icon-chooser.c
@@ -141,7 +141,11 @@ panel_icon_chooser_set_property (GObject *object,
 }
 
 static void
+#if GTK_CHECK_VERSION (3, 0, 0)
+panel_icon_chooser_dispose (GObject *object)
+#else
 panel_icon_chooser_destroy (GtkObject *object)
+#endif
 {
 PanelIconChooser *chooser;
 
@@ -166,14 +170,20 @@ panel_icon_chooser_destroy (GtkObject *object)
 g_free (chooser->priv->icon_theme_dir);
 chooser->priv->icon_theme_dir = NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ G_OBJECT_CLASS (panel_icon_chooser_parent_class)->dispose (object);
+#else
 GTK_OBJECT_CLASS (panel_icon_chooser_parent_class)->destroy (object);
+#endif
 }
 
 static void
 panel_icon_chooser_class_init (PanelIconChooserClass *class)
 {
 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (class);
+#endif
 GtkWidgetClass *gtkwidget_class = GTK_WIDGET_CLASS (class);
 GtkButtonClass *gtkbutton_class = GTK_BUTTON_CLASS (class);
 
@@ -181,7 +191,11 @@ panel_icon_chooser_class_init (PanelIconChooserClass *class)
 gobject_class->get_property = panel_icon_chooser_get_property;
 gobject_class->set_property = panel_icon_chooser_set_property;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gobject_class->dispose = panel_icon_chooser_dispose;
+#else
 gtkobject_class->destroy = panel_icon_chooser_destroy;
+#endif
 
 gtkwidget_class->style_set = _panel_icon_chooser_style_set;
 gtkwidget_class->screen_changed = _panel_icon_chooser_screen_changed;
@@ -422,7 +436,11 @@ _panel_icon_chooser_clicked (GtkButton *button)
 
 if (info) {
 path = g_strdup (gtk_icon_info_get_filename (info));
+#if GTK_CHECK_VERSION (3, 8, 0)
+ g_object_unref (info);
+#else
 gtk_icon_info_free (info);
+#endif
 }
 }
 
diff --git a/mate-panel/libpanel-util/panel-launch.c b/mate-panel/libpanel-util/panel-launch.c
index c332d09a..28824269 100644
--- a/mate-panel/libpanel-util/panel-launch.c
+++ b/mate-panel/libpanel-util/panel-launch.c
@@ -221,6 +221,15 @@ panel_launch_desktop_file (const char *desktop_file,
 return retval;
 }
 
+/*
+ * Set the DISPLAY variable, to be use by g_spawn_async.
+ */
+static void
+set_environment (gpointer display)
+{
+ g_setenv ("DISPLAY", display, TRUE);
+}
+
 gboolean
 panel_launch_desktop_file_with_fallback (const char *desktop_file,
 const char *fallback_exec,
@@ -231,6 +240,9 @@ panel_launch_desktop_file_with_fallback (const char *desktop_file,
 GError *local_error;
 gboolean retval;
 GPid pid;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ char *display;
+#endif
 
 g_return_val_if_fail (desktop_file != NULL, FALSE);
 g_return_val_if_fail (fallback_exec != NULL, FALSE);
@@ -247,9 +259,22 @@ panel_launch_desktop_file_with_fallback (const char *desktop_file,
 local_error = NULL;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ display = gdk_screen_make_display_name (screen);
+ retval = g_spawn_async (NULL, /* working directory */
+ argv,
+ NULL, /* envp */
+ G_SPAWN_SEARCH_PATH,
+ set_environment,
+ &display,
+ NULL,
+ &local_error);
+ g_free (display);
+#else
 retval = gdk_spawn_on_screen (screen, NULL, argv, NULL,
 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
 NULL, NULL, &pid, &local_error);
+#endif
 
 if (local_error == NULL && retval == TRUE) {
 g_child_watch_add (pid, dummy_child_watch, NULL);
diff --git a/mate-panel/mate-panel-applet-frame.c b/mate-panel/mate-panel-applet-frame.c
index 0a9990ab..bdabbc93 100644
--- a/mate-panel/mate-panel-applet-frame.c
+++ b/mate-panel/mate-panel-applet-frame.c
@@ -90,6 +90,64 @@ struct _MatePanelAppletFramePrivate {
 guint has_handle : 1;
 };
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static gboolean
+mate_panel_applet_frame_draw (GtkWidget *widget,
+ cairo_t *cr)
+{
+ MatePanelAppletFrame *frame = MATE_PANEL_APPLET_FRAME (widget);
+ GtkStyleContext *context;
+ GtkStateFlags state;
+ cairo_pattern_t *bg_pattern;
+ PanelBackground *background;
+
+ if (GTK_WIDGET_CLASS (mate_panel_applet_frame_parent_class)->draw)
+ GTK_WIDGET_CLASS (mate_panel_applet_frame_parent_class)->draw (widget, cr);
+
+ if (!frame->priv->has_handle)
+ return FALSE;
+
+ context = gtk_widget_get_style_context (widget);
+ state = gtk_widget_get_state_flags (widget);
+ gtk_style_context_save (context);
+ gtk_style_context_set_state (context, state);
+
+ cairo_save (cr);
+
+ /* Set the pattern transform so as to correctly render a patterned
+ * background with the handle */
+ gtk_style_context_get (context, state,
+ "background-image", &bg_pattern,
+ NULL);
+ background = &frame->priv->panel->background;
+
+ if (bg_pattern && (background->type == PANEL_BACK_IMAGE ||
+ (background->type == PANEL_BACK_COLOR && background->has_alpha))) {
+ cairo_matrix_t ptm;
+
+ cairo_matrix_init_translate (&ptm,
+ frame->priv->handle_rect.x,
+ frame->priv->handle_rect.y);
+ cairo_matrix_scale (&ptm,
+ frame->priv->handle_rect.width,
+ frame->priv->handle_rect.height);
+ cairo_pattern_set_matrix (bg_pattern, &ptm);
+ cairo_pattern_destroy (bg_pattern);
+ }
+
+ gtk_render_handle (context, cr,
+ frame->priv->handle_rect.x,
+ frame->priv->handle_rect.y,
+ frame->priv->handle_rect.width,
+ frame->priv->handle_rect.height);
+
+ cairo_restore (cr);
+
+ gtk_style_context_restore (context);
+
+ return FALSE;
+}
+#else
 static void
 mate_panel_applet_frame_paint (GtkWidget *widget,
 GdkRectangle *area)
@@ -142,6 +200,7 @@ static gboolean mate_panel_applet_frame_expose(GtkWidget* widget, GdkEventExpose
 
 return FALSE;
 }
+#endif
 
 static void
 mate_panel_applet_frame_update_background_size (MatePanelAppletFrame *frame,
@@ -165,6 +224,85 @@ mate_panel_applet_frame_update_background_size (MatePanelAppletFrame *frame,
 mate_panel_applet_frame_change_background (frame, background->type);
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void
+mate_panel_applet_frame_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+ MatePanelAppletFrame *frame;
+ GtkBin *bin;
+ GtkWidget *child;
+ guint border_width;
+
+ frame = MATE_PANEL_APPLET_FRAME (widget);
+ bin = GTK_BIN (widget);
+
+ if (!frame->priv->has_handle) {
+ GTK_WIDGET_CLASS (mate_panel_applet_frame_parent_class)->get_preferred_width (widget, minimal_width, natural_width);
+ return;
+ }
+
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
+ gtk_widget_get_preferred_width (child, minimal_width, natural_width);
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+ *minimal_width += border_width;
+ *natural_width += border_width;
+
+ switch (frame->priv->orientation) {
+ case PANEL_ORIENTATION_TOP:
+ case PANEL_ORIENTATION_BOTTOM:
+ *minimal_width += HANDLE_SIZE;
+ *natural_width += HANDLE_SIZE;
+ break;
+ case PANEL_ORIENTATION_LEFT:
+ case PANEL_ORIENTATION_RIGHT:
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+static void
+mate_panel_applet_frame_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+ MatePanelAppletFrame *frame;
+ GtkBin *bin;
+ GtkWidget *child;
+ guint border_width;
+
+ frame = MATE_PANEL_APPLET_FRAME (widget);
+ bin = GTK_BIN (widget);
+
+ if (!frame->priv->has_handle) {
+ GTK_WIDGET_CLASS (mate_panel_applet_frame_parent_class)->get_preferred_height (widget, minimal_height, natural_height);
+ return;
+ }
+
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
+ gtk_widget_get_preferred_height (child, minimal_height, natural_height);
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+ *minimal_height += border_width;
+ *natural_height += border_width;
+
+ switch (frame->priv->orientation) {
+ case PANEL_ORIENTATION_LEFT:
+ case PANEL_ORIENTATION_RIGHT:
+ *minimal_height += HANDLE_SIZE;
+ *natural_height += HANDLE_SIZE;
+ break;
+ case PANEL_ORIENTATION_TOP:
+ case PANEL_ORIENTATION_BOTTOM:
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+#else
 static void
 mate_panel_applet_frame_size_request (GtkWidget *widget,
 GtkRequisition *requisition)
@@ -209,6 +347,7 @@ mate_panel_applet_frame_size_request (GtkWidget *widget,
 break;
 }
 }
+#endif
 
 static void
 mate_panel_applet_frame_size_allocate (GtkWidget *widget,
@@ -401,8 +540,14 @@ mate_panel_applet_frame_class_init (MatePanelAppletFrameClass *klass)
 
 gobject_class->finalize = mate_panel_applet_frame_finalize;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->draw = mate_panel_applet_frame_draw;
+ widget_class->get_preferred_width = mate_panel_applet_frame_get_preferred_width;
+ widget_class->get_preferred_height = mate_panel_applet_frame_get_preferred_height;
+#else
 widget_class->expose_event = mate_panel_applet_frame_expose;
 widget_class->size_request = mate_panel_applet_frame_size_request;
+#endif
 widget_class->size_allocate = mate_panel_applet_frame_size_allocate;
 widget_class->button_press_event = mate_panel_applet_frame_button_changed;
 widget_class->button_release_event = mate_panel_applet_frame_button_changed;
diff --git a/mate-panel/menu.c b/mate-panel/menu.c
index 3e099cd2..55ec955c 100644
--- a/mate-panel/menu.c
+++ b/mate-panel/menu.c
@@ -28,7 +28,12 @@
 
 #include <glib/gi18n.h>
 #include <gio/gio.h>
+#include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gdk/gdkkeysyms-compat.h>
+#endif
+
 
 #include <libpanel-util/panel-keyfile.h>
 #include <libpanel-util/panel-xdg.h>
@@ -837,10 +842,16 @@ restore_grabs(GtkWidget *w, gpointer data)
 if (viewable)
 xgrab_shell = parent;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent));
+#else
 parent = GTK_MENU_SHELL (parent)->parent_menu_shell;
+#endif
 }
 
 /*only grab if this HAD a grab before*/
+ /* FIXME fix for GTK3 */
+#if !GTK_CHECK_VERSION (3, 0, 0)
 if (xgrab_shell && (GTK_MENU_SHELL (xgrab_shell)->have_xgrab))
 {
 GdkWindow *window = gtk_widget_get_window (xgrab_shell);
@@ -859,6 +870,7 @@ restore_grabs(GtkWidget *w, gpointer data)
 gdk_pointer_ungrab (GDK_CURRENT_TIME);
 }
 }
+#endif
 
 gtk_grab_add (GTK_WIDGET (menu));
 }
@@ -1052,7 +1064,11 @@ drag_end_menu_cb (GtkWidget *widget, GdkDragContext *context)
 if (viewable)
 xgrab_shell = parent;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent));
+#else
 parent = GTK_MENU_SHELL (parent)->parent_menu_shell;
+#endif
 }
 
 if (xgrab_shell && !gtk_menu_get_tearoff_state (GTK_MENU(xgrab_shell)))
@@ -1068,7 +1084,12 @@ drag_end_menu_cb (GtkWidget *widget, GdkDragContext *context)
 {
 if (gdk_keyboard_grab (window, TRUE,
 GDK_CURRENT_TIME) == 0)
- GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
+ {
+/* FIXME fix for GTK3 */
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
+#endif
+ }
 else
 {
 gdk_pointer_ungrab (GDK_CURRENT_TIME);
@@ -1103,11 +1124,18 @@ drag_data_get_menu_cb (GtkWidget *widget,
 }
 
 static void
+#if GTK_CHECK_VERSION (3, 0, 0)
+image_menuitem_set_size_request (GtkWidget *menuitem,
+ GtkIconSize icon_size)
+#else
 image_menuitem_size_request (GtkWidget *menuitem,
 GtkRequisition *requisition,
 gpointer data)
+#endif
 {
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GtkIconSize icon_size = (GtkIconSize) GPOINTER_TO_INT (data);
+#endif
 int icon_height;
 int req_height;
 
@@ -1123,7 +1151,12 @@ image_menuitem_size_request (GtkWidget *menuitem,
 req_height = icon_height;
 req_height += (gtk_container_get_border_width (GTK_CONTAINER (menuitem)) +
 (gtk_widget_get_style (menuitem))->ythickness) * 2;
+
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gtk_widget_set_size_request (menuitem, -1, req_height);
+#else
 requisition->height = MAX (requisition->height, req_height);
+#endif
 }
 
 static char *
@@ -1196,9 +1229,13 @@ setup_menuitem (GtkWidget *menuitem,
 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
 image);
 } else if (icon_size != GTK_ICON_SIZE_INVALID)
+#if GTK_CHECK_VERSION (3, 0, 0)
+ image_menuitem_set_size_request (menuitem, icon_size);
+#else
 g_signal_connect (menuitem, "size_request",
 G_CALLBACK (image_menuitem_size_request),
 GINT_TO_POINTER (icon_size));
+#endif
 
 gtk_widget_show (menuitem);
 }
@@ -1591,8 +1628,16 @@ handle_matemenu_tree_changed (MateMenuTree *tree,
 {
 guint idle_id;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GList *list, *l;
+ list = gtk_container_get_children (GTK_CONTAINER (menu));
+ for (l = list; l; l = l->next)
+ gtk_widget_destroy (l->data);
+ g_list_free (list);
+#else
 while (GTK_MENU_SHELL (menu)->children)
 gtk_widget_destroy (GTK_MENU_SHELL (menu)->children->data);
+#endif
 
 g_object_set_data_full (G_OBJECT (menu),
 "panel-menu-tree-directory",
@@ -1899,20 +1944,31 @@ panel_menu_key_press_handler (GtkWidget *widget,
 GdkEventKey *event)
 {
 gboolean retval = FALSE;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GtkWidget *active_menu_item = NULL;
+#endif
 
 if ((event->keyval == GDK_Menu) ||
 (event->keyval == GDK_F10 &&
 (event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_SHIFT_MASK)) {
 GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ active_menu_item = gtk_menu_shell_get_selected_item (menu_shell);
+ if (active_menu_item && gtk_menu_item_get_submenu (GTK_MENU_ITEM (active_menu_item)) == NULL) {
+#else
 if (menu_shell->active_menu_item &&
 GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu == NULL) {
+#endif
 GdkEventButton bevent;
 
 bevent.button = 3;
 bevent.time = GDK_CURRENT_TIME;
- retval = show_item_menu (menu_shell->active_menu_item,
- &bevent);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ retval = show_item_menu (active_menu_item, &bevent);
+#else
+ retval = show_item_menu (menu_shell->active_menu_item, &bevent);
+#endif
 }
 
 }
diff --git a/mate-panel/nothing.cP b/mate-panel/nothing.cP
index 4ce1f246..cfb935c5 100644
--- a/mate-panel/nothing.cP
+++ b/mate-panel/nothing.cP
@@ -4,7 +4,11 @@
 
 #include <X11/Xlib.h>
 #include <cairo.h>
+#include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gdk/gdkkeysyms-compat.h>
+#endif
 #include <canberra-gtk.h>
 
 #ifdef CA_CHECK_VERSION
@@ -16,6 +20,7 @@
 #include "panel-util.h"
 #include "nothing.h"
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 static void
 pixbuf_reverse (GdkPixbuf *gp)
 {
@@ -1566,3 +1571,4 @@ panel_dialog_window_event (GtkWidget *window,
 
 return FALSE;
 }
+#endif
+\ No newline at end of file
diff --git a/mate-panel/nothing.h b/mate-panel/nothing.h
index 1dc7f02f..2c8d8f79 100644
--- a/mate-panel/nothing.h
+++ b/mate-panel/nothing.h
@@ -7,6 +7,7 @@
 extern "C" {
 #endif
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 void start_screen_check (void);
 void start_geginv (void);
 gboolean panel_dialog_window_event (GtkWidget *window,
@@ -14,6 +15,7 @@ gboolean panel_dialog_window_event (GtkWidget *window,
 int config_event (GtkWidget *widget,
 GdkEvent *event,
 GtkNotebook *nbook);
+#endif
 
 #ifdef __cplusplus
 }
diff --git a/mate-panel/panel-action-button.c b/mate-panel/panel-action-button.c
index 6fc891e9..214fdf2a 100644
--- a/mate-panel/panel-action-button.c
+++ b/mate-panel/panel-action-button.c
@@ -33,6 +33,11 @@
 #include <glib/gi18n.h>
 #include <gio/gio.h>
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+#define MATE_DESKTOP_USE_UNSTABLE_API
+#include <libmate-desktop/mate-desktop-utils.h>
+#endif
+
 #include <libpanel-util/panel-error.h>
 #include <libpanel-util/panel-launch.h>
 #include <libpanel-util/panel-session-manager.h>
@@ -290,7 +295,11 @@ panel_action_connect_server (GtkWidget *widget)
 screen = gtk_widget_get_screen (GTK_WIDGET (widget));
 error = NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ mate_gdk_spawn_command_line_on_screen (screen, "caja-connect-server",
+#else
 gdk_spawn_command_line_on_screen (screen, "caja-connect-server",
+#endif
 &error);
 
 if (error) {
diff --git a/mate-panel/panel-action-protocol.c b/mate-panel/panel-action-protocol.c
index 10040478..6669f248 100644
--- a/mate-panel/panel-action-protocol.c
+++ b/mate-panel/panel-action-protocol.c
@@ -98,6 +98,9 @@ panel_action_protocol_filter (GdkXEvent *gdk_xevent,
 {
 GdkWindow *window;
 GdkScreen *screen;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkDisplay *display;
+#endif
 XEvent *xevent = (XEvent *) gdk_xevent;
 
 if (xevent->type != ClientMessage)
@@ -106,11 +109,21 @@ panel_action_protocol_filter (GdkXEvent *gdk_xevent,
 if (xevent->xclient.message_type != atom_mate_panel_action)
 return GDK_FILTER_CONTINUE;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ screen = gdk_event_get_screen (event);
+ display = gdk_screen_get_display (screen);
+ window = gdk_x11_window_lookup_for_display (display, xevent->xclient.window);
+#else
+ screen = gdk_drawable_get_screen (window);
 window = gdk_window_lookup (xevent->xclient.window);
+#endif
 if (!window)
 return GDK_FILTER_CONTINUE;
 
- screen = gdk_drawable_get_screen (window);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (window != gdk_screen_get_root_window (screen))
+ return GDK_FILTER_CONTINUE;
+#endif
 
 if (xevent->xclient.data.l [0] == atom_mate_panel_action_main_menu)
 panel_action_protocol_main_menu (screen, xevent->xclient.data.l [1]);
@@ -128,12 +141,16 @@ void
 panel_action_protocol_init (void)
 {
 GdkDisplay *display;
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GdkAtom gdk_atom_mate_panel_action;
+#endif
 
 display = gdk_display_get_default ();
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 gdk_atom_mate_panel_action =
 gdk_atom_intern_static_string ("_MATE_PANEL_ACTION");
+#endif
 
 atom_mate_panel_action =
 XInternAtom (GDK_DISPLAY_XDISPLAY (display),
@@ -152,7 +169,12 @@ panel_action_protocol_init (void)
 "_MATE_PANEL_ACTION_KILL_DIALOG",
 FALSE);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ /* We'll filter event sent on non-root windows later */
+ gdk_window_add_filter (NULL, panel_action_protocol_filter, NULL);
+#else
 gdk_display_add_client_message_filter (
 display, gdk_atom_mate_panel_action,
 panel_action_protocol_filter, NULL);
+#endif
 }
diff --git a/mate-panel/panel-addto.c b/mate-panel/panel-addto.c
index 77528feb..77e915e0 100644
--- a/mate-panel/panel-addto.c
+++ b/mate-panel/panel-addto.c
@@ -1258,8 +1258,10 @@ panel_addto_dialog_new (PanelWidget *panel_widget)
 GTK_STOCK_CLOSE,
 GTK_RESPONSE_CLOSE);
 gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE);
+#if !GTK_CHECK_VERSION (3, 0, 0)
 gtk_dialog_set_has_separator (GTK_DIALOG (dialog->addto_dialog),
 FALSE);
+#endif
 gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog),
 PANEL_ADDTO_RESPONSE_ADD);
 
diff --git a/mate-panel/panel-background-monitor.c b/mate-panel/panel-background-monitor.c
index 9a67c2b1..a7e67e05 100644
--- a/mate-panel/panel-background-monitor.c
+++ b/mate-panel/panel-background-monitor.c
@@ -28,9 +28,13 @@
 #include <glib-object.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
+#include <cairo-xlib.h>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 
+#define MATE_DESKTOP_USE_UNSTABLE_API
+#include <libmate-desktop/mate-bg.h>
+
 #include "panel-background-monitor.h"
 #include "panel-util.h"
 
@@ -61,7 +65,11 @@ struct _PanelBackgroundMonitor {
 Atom xatom;
 GdkAtom gdkatom;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_surface_t *surface;
+#else
 GdkPixmap *gdkpixmap;
+#endif
 GdkPixbuf *gdkpixbuf;
 
 int width;
@@ -88,9 +96,15 @@ panel_background_monitor_finalize (GObject *object)
 g_signal_handlers_disconnect_by_func (monitor->screen,
 panel_background_monitor_changed, monitor);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (monitor->surface)
+ cairo_surface_destroy (monitor->surface);
+ monitor->surface= NULL;
+#else
 if (monitor->gdkpixmap)
 g_object_unref (monitor->gdkpixmap);
 monitor->gdkpixmap = NULL;
+#endif
 
 if (monitor->gdkpixbuf)
 g_object_unref (monitor->gdkpixbuf);
@@ -127,7 +141,11 @@ panel_background_monitor_init (PanelBackgroundMonitor *monitor)
 monitor->gdkatom = gdk_atom_intern_static_string ("_XROOTPMAP_ID");
 monitor->xatom = gdk_x11_atom_to_xatom (monitor->gdkatom);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ monitor->surface = NULL;
+#else
 monitor->gdkpixmap = NULL;
+#endif
 monitor->gdkpixbuf = NULL;
 
 monitor->display_grabbed = FALSE;
@@ -148,7 +166,11 @@ panel_background_monitor_connect_to_screen (PanelBackgroundMonitor *monitor,
 G_CALLBACK (panel_background_monitor_changed), monitor);
 
 monitor->gdkwindow = gdk_screen_get_root_window (screen);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ monitor->xwindow = gdk_x11_window_get_xid (monitor->gdkwindow);
+#else
 monitor->xwindow = gdk_x11_drawable_get_xid (monitor->gdkwindow);
+#endif
 
 gdk_window_add_filter (
 monitor->gdkwindow, panel_background_monitor_xevent_filter, monitor);
@@ -202,9 +224,15 @@ panel_background_monitor_get_for_screen (GdkScreen *screen)
 static void
 panel_background_monitor_changed (PanelBackgroundMonitor *monitor)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (monitor->surface)
+ cairo_surface_destroy (monitor->surface);
+ monitor->surface = NULL;
+#else
 if (monitor->gdkpixmap)
 g_object_unref (monitor->gdkpixmap);
 monitor->gdkpixmap = NULL;
+#endif
 
 if (monitor->gdkpixbuf)
 g_object_unref (monitor->gdkpixbuf);
@@ -234,6 +262,7 @@ panel_background_monitor_xevent_filter (GdkXEvent *xevent,
 return GDK_FILTER_CONTINUE;
 }
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 static void
 panel_background_monitor_setup_pixmap (PanelBackgroundMonitor *monitor)
 {
@@ -264,6 +293,7 @@ panel_background_monitor_setup_pixmap (PanelBackgroundMonitor *monitor)
 
 g_free (prop_data);
 }
+#endif
 
 static GdkPixbuf *
 panel_background_monitor_tile_background (PanelBackgroundMonitor *monitor,
@@ -333,7 +363,9 @@ panel_background_monitor_tile_background (PanelBackgroundMonitor *monitor,
 static void
 panel_background_monitor_setup_pixbuf (PanelBackgroundMonitor *monitor)
 {
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GdkColormap *colormap = NULL;
+#endif
 GdkDisplay *display;
 int rwidth, rheight;
 int pwidth, pheight;
@@ -343,35 +375,58 @@ panel_background_monitor_setup_pixbuf (PanelBackgroundMonitor *monitor)
 gdk_x11_display_grab (display);
 monitor->display_grabbed = TRUE;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!monitor->surface)
+ monitor->surface = mate_bg_get_surface_from_root (monitor->screen);
+#else
 if (!monitor->gdkpixmap)
 panel_background_monitor_setup_pixmap (monitor);
+#endif
 
- if (!monitor->gdkpixmap) {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!monitor->surface)
+#else
+ if (!monitor->gdkpixmap)
+#endif
+ {
+ g_warning ("couldn't get background pixmap\n");
 gdk_x11_display_ungrab (display);
 monitor->display_grabbed = FALSE;
 return;
 }
 
- #if GTK_CHECK_VERSION(3, 0, 0)
- pwidth = gdk_window_get_width(monitor->gdkpixmap);
- pheight = gdk_window_get_height(monitor->gdkpixmap);
- #else
- gdk_drawable_get_size(GDK_DRAWABLE(monitor->gdkpixmap), &pwidth, &pheight);
- #endif
+#if GTK_CHECK_VERSION (3, 0, 0)
+ pwidth = cairo_xlib_surface_get_width (monitor->surface);
+ pheight = cairo_xlib_surface_get_height (monitor->surface);
+#else
+ gdk_drawable_get_size(GDK_DRAWABLE(monitor->gdkpixmap), &pwidth, &pheight);
+#endif
 
 gdk_window_get_geometry (monitor->gdkwindow,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ NULL, NULL, &rwidth, &rheight);
+#else
 NULL, NULL, &rwidth, &rheight, NULL);
+#endif
 
 monitor->width = MIN (pwidth, rwidth);
 monitor->height = MIN (pheight, rheight);
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 colormap = gdk_drawable_get_colormap (monitor->gdkwindow);
+#endif
 
 g_assert (monitor->gdkpixbuf == NULL);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ monitor->gdkpixbuf = gdk_pixbuf_get_from_surface (monitor->surface,
+ 0, 0,
+ monitor->width, monitor->height);
+#else
 monitor->gdkpixbuf = gdk_pixbuf_get_from_drawable (
 NULL, monitor->gdkpixmap, colormap,
 0, 0, 0, 0,
 monitor->width, monitor->height);
+#endif
 
 gdk_x11_display_ungrab (display);
 monitor->display_grabbed = FALSE;
diff --git a/mate-panel/panel-background.c b/mate-panel/panel-background.c
index 196a6a6b..eb2308e5 100644
--- a/mate-panel/panel-background.c
+++ b/mate-panel/panel-background.c
@@ -48,6 +48,10 @@ free_prepared_resources (PanelBackground *background)
 case PANEL_BACK_NONE:
 break;
 case PANEL_BACK_COLOR:
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!background->has_alpha)
+ background->color.red = background->color.green = background->color.blue = 0.;
+#else
 if (background->has_alpha) {
 if (background->pixmap)
 g_object_unref (background->pixmap);
@@ -59,11 +63,14 @@ free_prepared_resources (PanelBackground *background)
 &background->color.gdk, 1);
 background->color.gdk.pixel = 0;
 }
+#endif
 break;
 case PANEL_BACK_IMAGE:
+#if !GTK_CHECK_VERSION (3, 0, 0)
 if (background->pixmap)
 g_object_unref (background->pixmap);
 background->pixmap = NULL;
+#endif
 break;
 default:
 g_assert_not_reached ();
@@ -74,6 +81,11 @@ free_prepared_resources (PanelBackground *background)
 static void
 set_pixbuf_background (PanelBackground *background)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ g_assert (background->composited_pattern != NULL);
+
+ gdk_window_set_background_pattern (background->window, background->composited_pattern);
+#else
 g_assert (background->composited_image != NULL);
 
 gdk_pixbuf_render_pixmap_and_mask_for_colormap (
@@ -83,6 +95,7 @@ set_pixbuf_background (PanelBackground *background)
 
 gdk_window_set_back_pixmap (
 background->window, background->pixmap, FALSE);
+#endif
 }
 
 static gboolean
@@ -91,7 +104,11 @@ panel_background_prepare (PanelBackground *background)
 PanelBackgroundType effective_type;
 GtkWidget *widget = NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!background->transformed)
+#else
 if (!background->colormap || !background->transformed)
+#endif
 return FALSE;
 
 free_prepared_resources (background);
@@ -100,6 +117,24 @@ panel_background_prepare (PanelBackground *background)
 
 switch (effective_type) {
 case PANEL_BACK_NONE:
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->default_pattern) {
+ /* the theme background-image pattern must be scaled by
+ * the width & height of the panel so that when the
+ * backing region is cleared
+ * (gdk_window_clear_backing_region), the correctly
+ * scaled pattern is used */
+ cairo_matrix_t m;
+
+ cairo_matrix_init_translate (&m, 0, 0);
+ cairo_matrix_scale (&m,
+ 1.0 / background->region.width,
+ 1.0 / background->region.height);
+ cairo_pattern_set_matrix (background->default_pattern, &m);
+
+ gdk_window_set_background_pattern (background->window,
+ background->default_pattern);
+#else
 if (background->default_pixmap) {
 if (background->default_pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
 gdk_window_set_back_pixmap (background->window,
@@ -109,21 +144,31 @@ panel_background_prepare (PanelBackground *background)
 gdk_window_set_back_pixmap (background->window,
 NULL,
 TRUE);
+#endif
 } else
 gdk_window_set_background (
 background->window, &background->default_color);
 break;
 case PANEL_BACK_COLOR:
 if (background->has_alpha &&
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->composited_pattern)
+#else
 background->composited_image)
+#endif
 set_pixbuf_background (background);
 else {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdk_window_set_background_rgba (background->window,
+ &background->color);
+#else
 gdk_colormap_alloc_color (
 background->colormap,
 &background->color.gdk,
 FALSE, TRUE);
 gdk_window_set_background (
 background->window, &background->color.gdk);
+#endif
 }
 break;
 case PANEL_BACK_IMAGE:
@@ -138,7 +183,11 @@ panel_background_prepare (PanelBackground *background)
 * decide how to draw themselves. Therefore, we need to
 * make sure that all drawing has been completed before
 * the applet looks at the pixmap. */
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdk_display_sync (gdk_window_get_display (background->window));
+#else
 gdk_display_sync (gdk_drawable_get_display (background->window));
+#endif
 
 gdk_window_get_user_data (GDK_WINDOW (background->window),
 (gpointer) &widget);
@@ -160,9 +209,15 @@ free_composited_resources (PanelBackground *background)
 
 background->composited = FALSE;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->composited_pattern)
+ cairo_pattern_destroy (background->composited_pattern);
+ background->composited_pattern = NULL;
+#else
 if (background->composited_image)
 g_object_unref (background->composited_image);
 background->composited_image = NULL;
+#endif
 }
 
 static void
@@ -194,7 +249,11 @@ get_desktop_pixbuf (PanelBackground *background)
 if (!background->monitor) {
 background->monitor =
 panel_background_monitor_get_for_screen (
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdk_window_get_screen (background->window));
+#else
 gdk_drawable_get_screen (background->window));
+#endif
 
 background->monitor_signal =
 g_signal_connect (
@@ -212,12 +271,20 @@ get_desktop_pixbuf (PanelBackground *background)
 return desktop;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static cairo_pattern_t *
+#else
 static GdkPixbuf *
+#endif
 composite_image_onto_desktop (PanelBackground *background)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ static const cairo_user_data_key_t key;
+#else
 GdkPixbuf *retval;
- int width, height;
 unsigned char *data;
+#endif
+ int width, height;
 cairo_t *cr;
 cairo_surface_t *surface;
 cairo_pattern_t *pattern;
@@ -231,6 +298,15 @@ composite_image_onto_desktop (PanelBackground *background)
 width = gdk_pixbuf_get_width (background->desktop);
 height = gdk_pixbuf_get_height (background->desktop);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ surface = gdk_window_create_similar_surface (background->window,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ width, height);
+ if (cairo_surface_status (surface)) {
+ cairo_surface_destroy (surface);
+ return NULL;
+ }
+#else
 data = g_malloc (width * height * 4);
 if (!data)
 return NULL;
@@ -239,6 +315,8 @@ composite_image_onto_desktop (PanelBackground *background)
 CAIRO_FORMAT_RGB24,
 width, height,
 width * 4);
+#endif
+
 cr = cairo_create (surface);
 cairo_set_source_rgb (cr, 1, 1, 1);
 cairo_paint (cr);
@@ -247,26 +325,44 @@ composite_image_onto_desktop (PanelBackground *background)
 cairo_rectangle (cr, 0, 0, width, height);
 cairo_fill (cr);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_set_source (cr, background->transformed_pattern);
+#else
 gdk_cairo_set_source_pixbuf (cr, background->transformed_image, 0, 0);
 pattern = cairo_get_source (cr);
 cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+#endif
 cairo_rectangle (cr, 0, 0, width, height);
 cairo_fill (cr);
 
 cairo_destroy (cr);
- cairo_surface_destroy (surface);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ pattern = cairo_pattern_create_for_surface (surface);
+ cairo_surface_destroy (surface);
+ return pattern;
+#else
+ cairo_surface_destroy (surface);
 retval = panel_util_cairo_rgbdata_to_pixbuf (data, width, height);
-
 g_free (data);
-
 return retval;
+#endif
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static cairo_pattern_t *
+#else
 static GdkPixbuf *
+#endif
 composite_color_onto_desktop (PanelBackground *background)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_surface_t *surface;
+ cairo_pattern_t *pattern;
+ cairo_t *cr;
+#else
 guint32 color;
+#endif
 
 if (!background->desktop)
 background->desktop = get_desktop_pixbuf (background);
@@ -274,6 +370,30 @@ composite_color_onto_desktop (PanelBackground *background)
 if (!background->desktop)
 return NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ surface = gdk_window_create_similar_surface (background->window,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ background->region.width,
+ background->region.height);
+ if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) {
+ cairo_surface_destroy (surface);
+ return NULL;
+ }
+
+ cr = cairo_create (surface);
+ gdk_cairo_set_source_pixbuf (cr, background->desktop, 0, 0);
+ cairo_paint (cr);
+
+ gdk_cairo_set_source_rgba (cr, &background->color);
+ cairo_paint (cr);
+
+ cairo_destroy (cr);
+
+ pattern = cairo_pattern_create_for_surface (surface);
+ cairo_surface_destroy (surface);
+
+ return pattern;
+#else
 color = ((background->color.gdk.red & 0xff00) << 8) +
 (background->color.gdk.green & 0xff00) +
 (background->color.gdk.blue >> 8);
@@ -285,12 +405,22 @@ composite_color_onto_desktop (PanelBackground *background)
 GDK_INTERP_NEAREST,
 (255 - (background->color.alpha >> 8)),
 255, color, color);
+#endif
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static cairo_pattern_t *
+get_composited_pattern (PanelBackground *background)
+#else
 static GdkPixbuf *
 get_composited_pixbuf (PanelBackground *background)
+#endif
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_pattern_t *retval = NULL;
+#else
 GdkPixbuf *retval = NULL;
+#endif
 
 switch (background->type) {
 case PANEL_BACK_NONE:
@@ -300,8 +430,13 @@ get_composited_pixbuf (PanelBackground *background)
 break;
 case PANEL_BACK_IMAGE:
 retval = composite_image_onto_desktop (background);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!retval && background->transformed_pattern);
+ retval = cairo_pattern_reference (background->transformed_pattern);
+#else
 if (!retval)
 retval = g_object_ref (background->transformed_image);
+#endif
 break;
 default:
 g_assert_not_reached ();
@@ -324,10 +459,25 @@ panel_background_composite (PanelBackground *background)
 break;
 case PANEL_BACK_COLOR:
 if (background->has_alpha)
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->composited_pattern =
+ get_composited_pattern (background);
+#else
 background->composited_image =
 get_composited_pixbuf (background);
+#endif
 break;
 case PANEL_BACK_IMAGE:
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->transformed_pattern) {
+ if (background->has_alpha)
+ background->composited_pattern =
+ get_composited_pattern (background);
+ else
+ background->composited_pattern =
+ cairo_pattern_reference (background->transformed_pattern);
+ }
+#else
 if (background->transformed_image) {
 if (background->has_alpha)
 background->composited_image =
@@ -336,6 +486,7 @@ panel_background_composite (PanelBackground *background)
 background->composited_image =
 g_object_ref (background->transformed_image);
 }
+#endif
 break;
 default:
 g_assert_not_reached ();
@@ -359,14 +510,28 @@ free_transformed_resources (PanelBackground *background)
 if (background->type != PANEL_BACK_IMAGE)
 return;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->transformed_pattern)
+ cairo_pattern_destroy (background->transformed_pattern);
+ background->transformed_pattern = NULL;
+#else
 if (background->transformed_image)
 g_object_unref (background->transformed_image);
 background->transformed_image = NULL;
+#endif
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static cairo_pattern_t *
+get_scaled_and_rotated_pattern (PanelBackground *background)
+#else
 static GdkPixbuf *
 get_scaled_and_rotated_pixbuf (PanelBackground *background)
+#endif
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_pattern_t *pattern;
+#endif
 GdkPixbuf *scaled;
 GdkPixbuf *retval;
 int orig_width, orig_height;
@@ -484,7 +649,17 @@ get_scaled_and_rotated_pixbuf (PanelBackground *background)
 } else
 retval = scaled;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_t *cr = gdk_cairo_create (background->window ? background->window : gdk_get_default_root_window());
+ gdk_cairo_set_source_pixbuf (cr, retval, 0, 0);
+ g_object_unref (retval);
+ pattern = cairo_pattern_reference (cairo_get_source (cr));
+ cairo_destroy (cr);
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+ return pattern;
+#else
 return retval;
+#endif
 }
 
 static gboolean
@@ -496,8 +671,13 @@ panel_background_transform (PanelBackground *background)
 free_transformed_resources (background);
 
 if (background->type == PANEL_BACK_IMAGE)
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->transformed_pattern =
+ get_scaled_and_rotated_pattern (background);
+#else
 background->transformed_image =
 get_scaled_and_rotated_pixbuf (background);
+#endif
 
 background->transformed = TRUE;
 
@@ -578,6 +758,7 @@ panel_background_set_type (PanelBackground *background,
 panel_background_transform (background);
 }
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 static void
 panel_background_set_gdk_color_no_update (PanelBackground *background,
 GdkColor *gdk_color)
@@ -625,29 +806,50 @@ panel_background_set_opacity (PanelBackground *background,
 panel_background_set_opacity_no_update (background, opacity);
 panel_background_transform (background);
 }
+#endif
 
 static void
 panel_background_set_color_no_update (PanelBackground *background,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ const GdkRGBA *color)
+#else
 PanelColor *color)
+#endif
 {
 g_return_if_fail (color != NULL);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (gdk_rgba_equal (color, &background->color))
+ return;
+ background->color = *color;
+ panel_background_update_has_alpha (background);
+#else
 panel_background_set_gdk_color_no_update (background, &(color->gdk));
 panel_background_set_opacity_no_update (background, color->alpha);
+#endif
 }
 
 void
 panel_background_set_color (PanelBackground *background,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ const GdkRGBA *color)
+#else
 PanelColor *color)
+#endif
 {
 g_return_if_fail (color != NULL);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (gdk_rgba_equal (color, &background->color))
+#else
 if (background->color.gdk.red == color->gdk.red &&
 background->color.gdk.green == color->gdk.green &&
 background->color.gdk.blue == color->gdk.blue &&
 background->color.alpha == color->alpha)
+#endif
 return;
 
+
 free_transformed_resources (background);
 panel_background_set_color_no_update (background, color);
 panel_background_transform (background);
@@ -752,7 +954,11 @@ panel_background_set_rotate (PanelBackground *background,
 void
 panel_background_set (PanelBackground *background,
 PanelBackgroundType type,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ const GdkRGBA *color,
+#else
 PanelColor *color,
+#endif
 const char *image,
 gboolean fit_image,
 gboolean stretch_image,
@@ -769,12 +975,25 @@ panel_background_set (PanelBackground *background,
 void
 panel_background_set_default_style (PanelBackground *background,
 GdkColor *color,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_pattern_t *pattern)
+#else
 GdkPixmap *pixmap)
+#endif
 {
 g_return_if_fail (color != NULL);
 
 background->default_color = *color;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (pattern)
+ cairo_pattern_reference (pattern);
+
+ if (background->default_pattern)
+ cairo_pattern_destroy (background->default_pattern);
+
+ background->default_pattern = pattern;
+#else
 if (pixmap && pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
 g_object_ref (pixmap);
 
@@ -783,6 +1002,7 @@ panel_background_set_default_style (PanelBackground *background,
 g_object_unref (background->default_pixmap);
 
 background->default_pixmap = pixmap;
+#endif
 
 if (background->type == PANEL_BACK_NONE)
 panel_background_prepare (background);
@@ -794,9 +1014,16 @@ panel_background_realized (PanelBackground *background,
 {
 g_return_if_fail (window != NULL);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->window)
+#else
 if (background->window && background->colormap && background->gc)
+#endif
 return;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->window = g_object_ref (window);
+#else
 if (!background->window)
 background->window = g_object_ref (window);
 
@@ -806,6 +1033,7 @@ panel_background_realized (PanelBackground *background,
 
 if (!background->gc)
 background->gc = gdk_gc_new (window);
+#endif
 
 panel_background_prepare (background);
 }
@@ -819,6 +1047,7 @@ panel_background_unrealized (PanelBackground *background)
 g_object_unref (background->window);
 background->window = NULL;
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 if (background->colormap)
 g_object_unref (background->colormap);
 background->colormap = NULL;
@@ -826,6 +1055,7 @@ panel_background_unrealized (PanelBackground *background)
 if (background->gc)
 g_object_unref (background->gc);
 background->gc = NULL;
+#endif
 }
 
 void
@@ -905,11 +1135,18 @@ panel_background_init (PanelBackground *background,
 background->notify_changed = notify_changed;
 background->user_data = user_data;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->color.red = 0.;
+ background->color.blue = 0.;
+ background->color.green = 0.;
+ background->color.alpha = 1.;
+#else
 background->color.gdk.red = 0;
 background->color.gdk.blue = 0;
 background->color.gdk.green = 0;
 background->color.gdk.pixel = 0;
 background->color.alpha = 0xffff;
+#endif
 
 background->image = NULL;
 background->loaded_image = NULL;
@@ -919,19 +1156,30 @@ panel_background_init (PanelBackground *background,
 background->region.y = -1;
 background->region.width = -1;
 background->region.height = -1;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->transformed_pattern = NULL;
+ background->composited_pattern = NULL;
+#else
 background->transformed_image = NULL;
 background->composited_image = NULL;
+#endif
 
 background->monitor = NULL;
 background->desktop = NULL;
 background->monitor_signal = -1;
 
- background->pixmap = NULL;
 background->window = NULL;
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ background->pixmap = NULL;
 background->colormap = NULL;
 background->gc = NULL;
+#endif
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->default_pattern = NULL;
+#else
 background->default_pixmap = NULL;
+#endif
 background->default_color.red = 0;
 background->default_color.green = 0;
 background->default_color.blue = 0;
@@ -971,6 +1219,11 @@ panel_background_free (PanelBackground *background)
 g_object_unref (background->window);
 background->window = NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->default_pattern)
+ cairo_pattern_destroy (background->default_pattern);
+ background->default_pattern = NULL;
+#else
 if (background->colormap)
 g_object_unref (background->colormap);
 background->colormap = NULL;
@@ -983,6 +1236,7 @@ panel_background_free (PanelBackground *background)
 && background->default_pixmap != (GdkPixmap*) GDK_PARENT_RELATIVE)
 g_object_unref (background->default_pixmap);
 background->default_pixmap = NULL;
+#endif
 }
 
 char *
@@ -999,22 +1253,36 @@ panel_background_make_string (PanelBackground *background,
 
 if (effective_type == PANEL_BACK_IMAGE ||
 (effective_type == PANEL_BACK_COLOR && background->has_alpha)) {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ Window pixmap_xid;
+#else
 GdkNativeWindow pixmap_xid;
 
 if (!background->pixmap)
 return NULL;
+#endif
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ pixmap_xid = gdk_x11_window_get_xid (background->window);
+#else
 pixmap_xid = gdk_x11_drawable_get_xid (
 GDK_DRAWABLE (background->pixmap));
+#endif
 
 retval = g_strdup_printf ("pixmap:%d,%d,%d", pixmap_xid, x, y);
 
 } else if (effective_type == PANEL_BACK_COLOR)
 retval = g_strdup_printf (
 "color:%.4x%.4x%.4x",
+#if GTK_CHECK_VERSION (3, 0, 0)
+ background->color.red,
+ background->color.green,
+ background->color.blue);
+#else
 background->color.gdk.red,
 background->color.gdk.green,
 background->color.gdk.blue);
+#endif
 else
 retval = g_strdup ("none:");
 
@@ -1028,17 +1296,23 @@ panel_background_get_type (PanelBackground *background)
 return background->type;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+const GdkRGBA *
+#else
 const PanelColor *
+#endif
 panel_background_get_color (PanelBackground *background)
 {
 return &(background->color);
 }
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 const GdkPixmap *
 panel_background_get_pixmap (PanelBackground *background)
 {
 return background->pixmap;
 }
+#endif
 
 
 /* What are we actually rendering - e.g. if we're supposed to
@@ -1051,7 +1325,11 @@ panel_background_effective_type (PanelBackground *background)
 PanelBackgroundType retval;
 
 retval = background->type;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (background->type == PANEL_BACK_IMAGE && !background->composited_pattern)
+#else
 if (background->type == PANEL_BACK_IMAGE && !background->composited_image)
+#endif
 retval = PANEL_BACK_NONE;
 
 return retval;
@@ -1069,17 +1347,57 @@ panel_background_set_no_background_on_widget (PanelBackground *background,
 g_object_unref (rc_style);
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static cairo_pattern_t *
+panel_background_get_pattern_for_widget (PanelBackground *background,
+ GtkWidget *widget)
+#else
 static void
 panel_background_set_image_background_on_widget (PanelBackground *background,
+
 GtkWidget *widget)
+#endif
 {
- const GdkPixmap *bg_pixmap;
 GtkAllocation allocation;
- GdkPixmap *pixmap;
 cairo_t *cr;
 cairo_pattern_t *pattern;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_surface_t *surface;
+ cairo_surface_t *bg_surface;
+ cairo_matrix_t matrix;
+#else
+ const GdkPixmap *bg_pixmap;
+ GdkPixmap *pixmap;
 GtkStyle *style;
+#endif
+
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!background->composited_pattern)
+ return NULL;
+
+ if (cairo_pattern_get_surface (background->composited_pattern, &bg_surface) != CAIRO_STATUS_SUCCESS)
+ return NULL;
+
+ gtk_widget_get_allocation (widget, &allocation);
+ surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
+ allocation.width, allocation.height);
+
+ cr = cairo_create (surface);
+ cairo_set_source_surface (cr, bg_surface, -allocation.x, -allocation.y);
+ cairo_rectangle (cr, 0, 0, allocation.width, allocation.height);
+ cairo_fill (cr);
+ cairo_destroy (cr);
 
+ pattern = cairo_pattern_create_for_surface (surface);
+ cairo_matrix_init_translate (&matrix, 0, 0);
+ cairo_matrix_scale (&matrix, allocation.width, allocation.height);
+ cairo_pattern_set_matrix (pattern, &matrix);
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+
+ cairo_surface_destroy (surface);
+
+ return pattern;
+#else
 bg_pixmap = panel_background_get_pixmap (background);
 if (!bg_pixmap)
 return;
@@ -1111,28 +1429,119 @@ panel_background_set_image_background_on_widget (PanelBackground *background,
 g_object_unref (style);
 
 g_object_unref (pixmap);
+#endif
 }
 
 static void
 panel_background_set_color_background_on_widget (PanelBackground *background,
 GtkWidget *widget)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ const GdkRGBA *color;
+ GdkColor gdkcolor;
+#else
 const PanelColor *color;
+#endif
 
 color = panel_background_get_color (background);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (color->alpha < 1.) {
+#else
 if (color->alpha != 0xffff) {
+#endif
 panel_background_set_image_background_on_widget (background,
 widget);
 return;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdkcolor.red = color->red * 65535.;
+ gdkcolor.green = color->green * 65535.;
+ gdkcolor.blue = color->blue * 65535.;
+ gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &gdkcolor);
+#else
 gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &color->gdk);
+#endif
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static GtkStyleProperties *
+_panel_background_get_widget_style_properties (GtkWidget *widget, gboolean create_if_needed)
+{
+ GtkStyleProperties *properties;
+
+ properties = g_object_get_data (G_OBJECT (widget), "panel-object-style-props");
+ if (!properties && create_if_needed) {
+ properties = gtk_style_properties_new ();
+ g_object_set_data_full (G_OBJECT (widget), "panel-object-style-props",
+ properties, (GDestroyNotify) g_object_unref);
+ }
+ return properties;
+}
+
+static void
+_panel_background_reset_widget_style_properties (GtkWidget *widget)
+{
+ GtkStyleProperties *properties;
+
+ properties = _panel_background_get_widget_style_properties (widget, FALSE);
+
+ if (properties)
+ gtk_style_context_remove_provider (gtk_widget_get_style_context (widget),
+ GTK_STYLE_PROVIDER (properties));
+
+ g_object_set_data (G_OBJECT (widget), "panel-object-style-props", NULL);
+}
+#endif
+
 void
 panel_background_change_background_on_widget (PanelBackground *background,
 GtkWidget *widget)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GtkStyleProperties *properties;
+
+ gtk_widget_reset_style (widget);
+
+ switch (panel_background_get_type (background)) {
+ case PANEL_BACK_NONE:
+ _panel_background_reset_widget_style_properties (widget);
+ return;
+ case PANEL_BACK_COLOR:
+ if (!background->has_alpha) {
+ properties = _panel_background_get_widget_style_properties (widget, TRUE);
+ gtk_style_properties_set (properties, GTK_STATE_FLAG_NORMAL,
+ "background-color", &background->color,
+ "background-image", NULL,
+ NULL);
+ break;
+ }
+ // Color with alpha, fallback to image
+ case PANEL_BACK_IMAGE: {
+ cairo_pattern_t *pattern;
+
+ properties = _panel_background_get_widget_style_properties (widget, TRUE);
+ pattern = panel_background_get_pattern_for_widget (background, widget);
+ if (pattern) {
+ gtk_style_properties_set (properties, GTK_STATE_FLAG_NORMAL,
+ "background-image", pattern,
+ NULL);
+ cairo_pattern_destroy (pattern);
+ } else {
+ _panel_background_reset_widget_style_properties (widget);
+ return;
+ }
+ }
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ gtk_style_context_add_provider (gtk_widget_get_style_context (widget),
+ GTK_STYLE_PROVIDER (properties),
+ GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+#else
 PanelBackgroundType type;
 
 panel_background_set_no_background_on_widget (background, widget);
@@ -1154,4 +1563,6 @@ panel_background_change_background_on_widget (PanelBackground *background,
 g_assert_not_reached ();
 break;
 }
+#endif
 }
+
diff --git a/mate-panel/panel-background.h b/mate-panel/panel-background.h
index 59f6cfcd..e8491dda 100644
--- a/mate-panel/panel-background.h
+++ b/mate-panel/panel-background.h
@@ -44,30 +44,42 @@ struct _PanelBackground {
 PanelBackgroundChangedNotify notify_changed;
 gpointer user_data;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkRGBA color;
+#else
 PanelColor color;
+#endif
 char *image;
 GdkPixbuf *loaded_image; 
 
 GtkOrientation orientation;
 GdkRectangle region;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_pattern_t *transformed_pattern;
+ cairo_pattern_t *composited_pattern;
+#else
 GdkPixbuf *transformed_image;
 GdkPixbuf *composited_image;
+#endif
 
 PanelBackgroundMonitor *monitor;
 GdkPixbuf *desktop;
 gulong monitor_signal;
 
- GdkPixmap *pixmap;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_pattern_t *default_pattern;
 GdkWindow *window;
+#else
+ GdkPixmap *pixmap;
 GdkColormap *colormap;
 GdkGC *gc;
-
 GdkPixmap *default_pixmap;
+#endif
 GdkColor default_color;
 
- guint fit_image : 1;
- guint stretch_image : 1;
- guint rotate_image : 1;
+ guint fit_image : 1;
+ guint stretch_image : 1;
+ guint rotate_image : 1;
 
 guint has_alpha : 1;
 
@@ -83,19 +95,29 @@ void panel_background_init (PanelBackground *background,
 void panel_background_free (PanelBackground *background);
 void panel_background_set (PanelBackground *background,
 PanelBackgroundType type,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ const GdkRGBA *color,
+#else
 PanelColor *color,
+#endif
 const char *image,
 gboolean fit_image,
 gboolean stretch_image,
 gboolean rotate_image); 
 void panel_background_set_type (PanelBackground *background,
 PanelBackgroundType type);
+#if !GTK_CHECK_VERSION (3, 0, 0)
 void panel_background_set_gdk_color (PanelBackground *background,
 GdkColor *gdk_color);
 void panel_background_set_opacity (PanelBackground *background,
 guint16 opacity);
+#endif
 void panel_background_set_color (PanelBackground *background,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ const GdkRGBA *color);
+#else
 PanelColor *color);
+#endif
 void panel_background_set_image (PanelBackground *background,
 const char *image);
 void panel_background_set_fit (PanelBackground *background,
@@ -106,7 +128,11 @@ void panel_background_set_rotate (PanelBackground *background,
 gboolean rotate_image);
 void panel_background_set_default_style (PanelBackground *background,
 GdkColor *color,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_pattern_t *pattern);
+#else
 GdkPixmap *pixmap);
+#endif
 void panel_background_realized (PanelBackground *background,
 GdkWindow *window);
 void panel_background_unrealized (PanelBackground *background);
@@ -121,8 +147,12 @@ char *panel_background_make_string (PanelBackground *background,
 int y);
 
 PanelBackgroundType panel_background_get_type (PanelBackground *background);
+#if GTK_CHECK_VERSION (3, 0, 0)
+const GdkRGBA *panel_background_get_color (PanelBackground *background);
+#else
 const PanelColor *panel_background_get_color (PanelBackground *background);
 const GdkPixmap *panel_background_get_pixmap (PanelBackground *background);
+#endif
 
 PanelBackgroundType
 panel_background_effective_type (PanelBackground *background);
diff --git a/mate-panel/panel-bindings.c b/mate-panel/panel-bindings.c
index 8a737769..a5c2530b 100644
--- a/mate-panel/panel-bindings.c
+++ b/mate-panel/panel-bindings.c
@@ -30,6 +30,8 @@
 #include <glib/gi18n.h>
 #include <gio/gio.h>
 
+#include <libmate-desktop/mate-gsettings.h>
+
 #include "panel-schemas.h"
 #include "panel-profile.h"
 #include "panel-xutils.h"
@@ -187,6 +189,11 @@ panel_bindings_initialise (void)
 if (initialised)
 return;
 
+ if (!mate_gsettings_schema_exists (MARCO_SCHEMA)) {
+ initialised = TRUE;
+ return;
+ }
+
 marco_settings = g_settings_new (MARCO_SCHEMA);
 marco_keybindings_settings = g_settings_new (MARCO_KEYBINDINGS_SCHEMA);
 
diff --git a/mate-panel/panel-context-menu.c b/mate-panel/panel-context-menu.c
index a7c01774..41c61b93 100644
--- a/mate-panel/panel-context-menu.c
+++ b/mate-panel/panel-context-menu.c
@@ -65,12 +65,15 @@ panel_context_menu_check_for_screen (GtkWidget *w,
 static int times = 0;
 if (ev->type != GDK_KEY_PRESS)
 return FALSE;
- if (ev->key.keyval == GDK_f ||
- ev->key.keyval == GDK_F) {
+ if (ev->key.keyval == GDK_KEY_f ||
+ ev->key.keyval == GDK_KEY_F) {
 times++;
 if (times == 3) {
 times = 0;
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ /* FIXME re-add once GTK3 support is fixed */
 start_screen_check ();
+#endif
 }
 }
 return FALSE;
diff --git a/mate-panel/panel-ditem-editor.c b/mate-panel/panel-ditem-editor.c
index 9f7b4760..a7106b27 100644
--- a/mate-panel/panel-ditem-editor.c
+++ b/mate-panel/panel-ditem-editor.c
@@ -338,7 +338,11 @@ panel_ditem_editor_set_property (GObject *object,
 }
 
 static void
+#if GTK_CHECK_VERSION (3, 0, 0)
+panel_ditem_editor_dispose (GObject *object)
+#else
 panel_ditem_editor_destroy (GtkObject *object)
+#endif
 {
 PanelDItemEditor *dialog;
 
@@ -366,20 +370,30 @@ panel_ditem_editor_destroy (GtkObject *object)
 g_free (dialog->priv->uri);
 dialog->priv->uri = NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ G_OBJECT_CLASS (panel_ditem_editor_parent_class)->dispose (object);
+#else
 GTK_OBJECT_CLASS (panel_ditem_editor_parent_class)->destroy (object);
+#endif
 }
 
 static void
 panel_ditem_editor_class_init (PanelDItemEditorClass *class)
 {
 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (class);
+#endif
 
 gobject_class->constructor = panel_ditem_editor_constructor;
 gobject_class->get_property = panel_ditem_editor_get_property;
 gobject_class->set_property = panel_ditem_editor_set_property;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gobject_class->dispose = panel_ditem_editor_dispose;
+#else
 gtkobject_class->destroy = panel_ditem_editor_destroy;
+#endif
 
 g_type_class_add_private (class,
 sizeof (PanelDItemEditorPrivate));
@@ -608,7 +622,9 @@ panel_ditem_editor_make_ui (PanelDItemEditor *dialog)
 dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
 gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+#endif
 
 priv->table = gtk_table_new (4, 3, FALSE);
 gtk_container_set_border_width (GTK_CONTAINER (priv->table), 5);
diff --git a/mate-panel/panel-force-quit.c b/mate-panel/panel-force-quit.c
index 4b627e1f..b86517e4 100644
--- a/mate-panel/panel-force-quit.c
+++ b/mate-panel/panel-force-quit.c
@@ -251,7 +251,11 @@ handle_button_press_event (GtkWidget *popup,
 window = find_managed_window (event->display, event->subwindow);
 
 if (window != None) {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (event->display), window))
+#else
 if (!gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (event->display), window))
+#endif
 kill_window_question ((gpointer) window);
 }
 }
diff --git a/mate-panel/panel-frame.c b/mate-panel/panel-frame.c
index ab0cbc6a..7311e945 100644
--- a/mate-panel/panel-frame.c
+++ b/mate-panel/panel-frame.c
@@ -68,6 +68,28 @@ panel_frame_size_request (GtkWidget *widget,
 requisition->width += style->ythickness;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void
+panel_frame_get_preferred_width (GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ GtkRequisition req;
+ panel_frame_size_request (widget, &req);
+ *minimum_width = *natural_width = req.width;
+}
+
+static void
+panel_frame_get_preferred_height (GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ GtkRequisition req;
+ panel_frame_size_request (widget, &req);
+ *minimum_height = *natural_height = req.height;
+}
+#endif
+
 static void
 panel_frame_size_allocate (GtkWidget *widget,
 GtkAllocation *allocation)
@@ -122,13 +144,20 @@ panel_frame_size_allocate (GtkWidget *widget,
 
 void
 panel_frame_draw (GtkWidget *widget,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_t *cr,
+#endif
 PanelFrameEdge edges)
 {
 GdkWindow *window;
 GtkStyle *style;
 GtkStateType state;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkColor *dark, *light, *black;
+#else
 GtkAllocation allocation;
 GdkGC *dark, *light, *black;
+#endif
 int x, y, width, height;
 int xthickness, ythickness;
 
@@ -138,22 +167,103 @@ panel_frame_draw (GtkWidget *widget,
 window = gtk_widget_get_window (widget);
 style = gtk_widget_get_style (widget);
 state = gtk_widget_get_state (widget);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x = 0;
+ y = 0;
+ width = gtk_widget_get_allocated_width (widget);
+ height = gtk_widget_get_allocated_height (widget);
+#else
 gtk_widget_get_allocation (widget, &allocation);
+ x = allocation.x;
+ y = allocation.y;
+ width = allocation.width;
+ height = allocation.height;
+#endif
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ dark = &style->dark [state];
+ light = &style->light [state];
+ black = &style->black;
+#else
 dark = style->dark_gc [state];
 light = style->light_gc [state];
 black = style->black_gc;
+#endif
 
 xthickness = style->xthickness;
 ythickness = style->ythickness;
 
- x = allocation.x;
- y = allocation.y;
- width = allocation.width;
- height = allocation.height;
-
 /* Copied from gtk_default_draw_shadow() */
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_set_line_width (cr, 1);
+
+ if (edges & PANEL_EDGE_BOTTOM && ythickness > 0) {
+ if (ythickness > 1) {
+ gdk_cairo_set_source_color (cr, dark);
+ cairo_move_to (cr, x + .5, y + height - 2 + .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + height - 2 + .5);
+ cairo_stroke (cr);
+
+ gdk_cairo_set_source_color (cr, black);
+ cairo_move_to (cr, x + .5, y + height - 1 - .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+ } else {
+ gdk_cairo_set_source_color (cr, dark);
+ cairo_move_to (cr, x + .5, y + height - 1 - .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+ }
+ }
+
+ if (edges & PANEL_EDGE_RIGHT && xthickness > 0) {
+ if (xthickness > 1) {
+ gdk_cairo_set_source_color (cr, dark);
+ cairo_move_to (cr, x + width - 2 - .5, y + .5);
+ cairo_line_to (cr, x + width - 2 - .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+
+ gdk_cairo_set_source_color (cr, black);
+ cairo_move_to (cr, x + width - 1 - .5, y + .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+ } else {
+ gdk_cairo_set_source_color (cr, dark);
+ cairo_move_to (cr, x + width - 1 - .5, y + .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+ }
+ }
+
+ if (edges & PANEL_EDGE_TOP && ythickness > 0) {
+ gdk_cairo_set_source_color (cr, light);
+ cairo_move_to (cr, x + .5, y + .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + .5);
+ cairo_stroke (cr);
+
+ if (ythickness > 1) {
+ gdk_cairo_set_source_color (cr, &style->bg [state]);
+ cairo_move_to (cr, x + .5, y + 1 + .5);
+ cairo_line_to (cr, x + width - 1 - .5, y + 1 + .5);
+ cairo_stroke (cr);
+ }
+ }
+
+ if (edges & PANEL_EDGE_LEFT && xthickness > 0) {
+ gdk_cairo_set_source_color (cr, light);
+ cairo_move_to (cr, x + .5, y + .5);
+ cairo_line_to (cr, x + .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+
+ if (xthickness > 1) {
+ gdk_cairo_set_source_color (cr, &style->bg [state]);
+ cairo_move_to (cr, x + 1 + .5, y + .5);
+ cairo_line_to (cr, x + 1 + .5, y + height - 1 - .5);
+ cairo_stroke (cr);
+ }
+ }
+#else
 if (edges & PANEL_EDGE_BOTTOM && ythickness > 0) {
 if (ythickness > 1) {
 gdk_draw_line (window, dark,
@@ -202,9 +312,14 @@ panel_frame_draw (GtkWidget *widget,
 style->bg_gc [state],
 x + 1, y, x + 1, y + height - 1);
 }
+#endif
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static gboolean panel_frame_expose(GtkWidget* widget, cairo_t* cr)
+#else
 static gboolean panel_frame_expose(GtkWidget* widget, GdkEventExpose* event)
+#endif
 {
 PanelFrame *frame = (PanelFrame *) widget;
 gboolean retval = FALSE;
@@ -212,12 +327,19 @@ static gboolean panel_frame_expose(GtkWidget* widget, GdkEventExpose* event)
 if (!gtk_widget_is_drawable (widget))
 return retval;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (GTK_WIDGET_CLASS (panel_frame_parent_class)->draw)
+ retval = GTK_WIDGET_CLASS (panel_frame_parent_class)->draw (widget, cr);
+#else
 if (GTK_WIDGET_CLASS (panel_frame_parent_class)->expose_event)
- {
 retval = GTK_WIDGET_CLASS (panel_frame_parent_class)->expose_event (widget, event);
- }
+#endif
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ panel_frame_draw (widget, cr, frame->edges);
+#else
 panel_frame_draw (widget, frame->edges);
+#endif
 
 return retval;
 }
@@ -275,9 +397,15 @@ panel_frame_class_init (PanelFrameClass *klass)
 gobject_class->set_property = panel_frame_set_property;
 gobject_class->get_property = panel_frame_get_property;
 
- widget_class->size_request = panel_frame_size_request;
 widget_class->size_allocate = panel_frame_size_allocate;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->get_preferred_width = panel_frame_get_preferred_width;
+ widget_class->get_preferred_height = panel_frame_get_preferred_height;
+ widget_class->draw = panel_frame_expose;
+#else
+ widget_class->size_request = panel_frame_size_request;
 widget_class->expose_event = panel_frame_expose;
+#endif
 
 g_object_class_install_property (
 gobject_class,
diff --git a/mate-panel/panel-frame.h b/mate-panel/panel-frame.h
index b1286f2f..e5988ddb 100644
--- a/mate-panel/panel-frame.h
+++ b/mate-panel/panel-frame.h
@@ -60,6 +60,9 @@ void panel_frame_set_edges (PanelFrame *toplevel,
 PanelFrameEdge panel_frame_get_edges (PanelFrame *toplevel);
 
 void panel_frame_draw (GtkWidget *widget,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_t *cr,
+#endif
 PanelFrameEdge edges);
 
 #ifdef __cplusplus
diff --git a/mate-panel/panel-menu-bar.c b/mate-panel/panel-menu-bar.c
index c7995c3d..ab40b3b7 100644
--- a/mate-panel/panel-menu-bar.c
+++ b/mate-panel/panel-menu-bar.c
@@ -257,13 +257,37 @@ static void panel_menu_bar_class_init(PanelMenuBarClass* klass)
 "class \"PanelMenuBar\" style \"panel-menubar-style\"");
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static gboolean panel_menu_bar_on_draw(GtkWidget* widget, cairo_t* cr, gpointer data)
+#else
 static gboolean panel_menu_bar_on_expose(GtkWidget* widget, GdkEventExpose* event, gpointer data)
+#endif
 {
 PanelMenuBar* menubar = data;
 
 if (gtk_widget_has_focus(GTK_WIDGET(menubar)))
 {
- gtk_paint_focus(gtk_widget_get_style(widget), gtk_widget_get_window(widget), gtk_widget_get_state(GTK_WIDGET(menubar)), NULL, widget, "menubar-applet", 0, 0, -1, -1);
+ gtk_paint_focus(gtk_widget_get_style(widget),
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ gtk_widget_get_window(widget),
+#endif
+ gtk_widget_get_state(GTK_WIDGET(menubar)),
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ NULL,
+#endif
+ widget,
+ "menubar-applet",
+ 0,
+ 0,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
+#else
+ -1,
+ -1);
+#endif
 }
 
 return FALSE;
@@ -295,7 +319,11 @@ static void panel_menu_bar_load(PanelWidget* panel, gboolean locked, int positio
 
 g_signal_connect_after(menubar, "focus-in-event", G_CALLBACK(gtk_widget_queue_draw), menubar);
 g_signal_connect_after(menubar, "focus-out-event", G_CALLBACK(gtk_widget_queue_draw), menubar);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ g_signal_connect_after(menubar, "draw", G_CALLBACK(panel_menu_bar_on_draw), menubar);
+#else
 g_signal_connect_after(menubar, "expose-event", G_CALLBACK(panel_menu_bar_on_expose), menubar);
+#endif
 
 gtk_widget_set_can_focus(GTK_WIDGET(menubar), TRUE);
 
@@ -362,6 +390,7 @@ void panel_menu_bar_popup_menu(PanelMenuBar* menubar, guint32 activate_time)
 */
 menu_shell = GTK_MENU_SHELL(menubar);
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 if (!menu_shell->active)
 {
 gtk_grab_add(GTK_WIDGET(menu_shell));
@@ -369,6 +398,7 @@ void panel_menu_bar_popup_menu(PanelMenuBar* menubar, guint32 activate_time)
 menu_shell->have_grab = TRUE;
 menu_shell->active = TRUE;
 }
+#endif
 
 gtk_menu_shell_select_item(menu_shell, gtk_menu_get_attach_widget(menu));
 }
diff --git a/mate-panel/panel-menu-button.c b/mate-panel/panel-menu-button.c
index a4ce15ad..019173d4 100644
--- a/mate-panel/panel-menu-button.c
+++ b/mate-panel/panel-menu-button.c
@@ -359,7 +359,12 @@ panel_menu_button_menu_deactivated (PanelMenuButton *button)
 {
 panel_toplevel_pop_autohide_disabler (button->priv->toplevel);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gtk_widget_unset_state_flags (GTK_WIDGET (button),
+ GTK_STATE_FLAG_PRELIGHT);
+#else
 GTK_BUTTON (button)->in_button = FALSE;
+#endif
 button_widget_set_ignore_leave (BUTTON_WIDGET (button), FALSE);
 }
 
diff --git a/mate-panel/panel-menu-items.c b/mate-panel/panel-menu-items.c
index 85ee31ce..88a11eb4 100644
--- a/mate-panel/panel-menu-items.c
+++ b/mate-panel/panel-menu-items.c
@@ -39,6 +39,7 @@
 #include <string.h>
 #include <glib/gi18n.h>
 #include <gio/gio.h>
+#include <libmate-desktop/mate-gsettings.h>
 
 #include <libpanel-util/panel-error.h>
 #include <libpanel-util/panel-glib.h>
@@ -1047,7 +1048,8 @@ panel_place_menu_item_create_menu (PanelPlaceMenuItem *place_item)
 g_free (name);
 g_free (uri);
 
- if (!g_settings_get_boolean (place_item->priv->caja_prefs_settings,
+ if (!place_item->priv->caja_prefs_settings ||
+ !g_settings_get_boolean (place_item->priv->caja_prefs_settings,
 CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY)) {
 file = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP));
 uri = g_file_get_uri (file);
@@ -1070,14 +1072,16 @@ panel_place_menu_item_create_menu (PanelPlaceMenuItem *place_item)
 panel_place_menu_item_append_gtk_bookmarks (places_menu);
 add_menu_separator (places_menu);
 
- gsettings_name = g_settings_get_string (place_item->priv->caja_desktop_settings,
- CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY);
- panel_menu_items_append_from_desktop (places_menu,
- "caja-computer.desktop",
- gsettings_name,
- TRUE);
- if (gsettings_name)
+ if (place_item->priv->caja_desktop_settings != NULL) {
+ gsettings_name = g_settings_get_string (place_item->priv->caja_desktop_settings,
+ CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY);
+ panel_menu_items_append_from_desktop (places_menu,
+ "caja-computer.desktop",
+ gsettings_name,
+ TRUE);
+ if (gsettings_name)
 g_free (gsettings_name);
+ }
 
 panel_place_menu_item_append_local_gio (place_item, places_menu);
 add_menu_separator (places_menu);
@@ -1326,21 +1330,29 @@ panel_place_menu_item_init (PanelPlaceMenuItem *menuitem)
 
 menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem);
 
- menuitem->priv->caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA);
- menuitem->priv->caja_prefs_settings = g_settings_new (CAJA_PREFS_SCHEMA);
-
- g_signal_connect (menuitem->priv->caja_desktop_settings,
- "changed::" CAJA_DESKTOP_HOME_ICON_NAME_KEY,
- G_CALLBACK (panel_place_menu_item_key_changed),
- G_OBJECT (menuitem));
- g_signal_connect (menuitem->priv->caja_desktop_settings,
- "changed::" CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY,
- G_CALLBACK (panel_place_menu_item_key_changed),
- G_OBJECT (menuitem));
- g_signal_connect (menuitem->priv->caja_prefs_settings,
- "changed::" CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY,
- G_CALLBACK (panel_place_menu_item_key_changed),
- G_OBJECT (menuitem));
+ if (mate_gsettings_schema_exists (CAJA_DESKTOP_SCHEMA)) {
+ menuitem->priv->caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA);
+ g_signal_connect (menuitem->priv->caja_desktop_settings,
+ "changed::" CAJA_DESKTOP_HOME_ICON_NAME_KEY,
+ G_CALLBACK (panel_place_menu_item_key_changed),
+ G_OBJECT (menuitem));
+ g_signal_connect (menuitem->priv->caja_desktop_settings,
+ "changed::" CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY,
+ G_CALLBACK (panel_place_menu_item_key_changed),
+ G_OBJECT (menuitem));
+ }
+ else
+ menuitem->priv->caja_desktop_settings = NULL;
+
+ if (mate_gsettings_schema_exists (CAJA_PREFS_SCHEMA)) {
+ menuitem->priv->caja_prefs_settings = g_settings_new (CAJA_PREFS_SCHEMA);
+ g_signal_connect (menuitem->priv->caja_prefs_settings,
+ "changed::" CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY,
+ G_CALLBACK (panel_place_menu_item_key_changed),
+ G_OBJECT (menuitem));
+ }
+ else
+ menuitem->priv->caja_prefs_settings = NULL;
 
 menuitem->priv->recent_manager = gtk_recent_manager_get_default ();
 
diff --git a/mate-panel/panel-multiscreen.c b/mate-panel/panel-multiscreen.c
index 838ca526..27c29135 100644
--- a/mate-panel/panel-multiscreen.c
+++ b/mate-panel/panel-multiscreen.c
@@ -133,7 +133,11 @@ panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
 */
 
 xdisplay = GDK_SCREEN_XDISPLAY (screen);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
+#else
 xroot = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
+#endif
 
 #if (RANDR_MAJOR > 1 || (RANDR_MAJOR == 1 && RANDR_MINOR >= 3))
 if (have_randr_1_3) {
diff --git a/mate-panel/panel-profile.c b/mate-panel/panel-profile.c
index 57e11d00..2c5b328c 100644
--- a/mate-panel/panel-profile.c
+++ b/mate-panel/panel-profile.c
@@ -495,15 +495,27 @@ panel_profile_is_writable_attached_tooltip (PanelToplevel *toplevel)
 
 static void
 get_background_color (PanelToplevel *toplevel,
- PanelColor *color)
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkRGBA *color)
+#else
+ PanelColor *color)
+#endif
 {
 char *color_str;
 color_str = g_settings_get_string (toplevel->background_settings, "color");
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!color_str || !gdk_rgba_parse (color, color_str)) {
+ color->red = 0;
+ color->green = 0;
+ color->blue = 0;
+ }
+#else
 if (!color_str || !gdk_color_parse (color_str, &(color->gdk))) {
 color->gdk.red = 0;
 color->gdk.green = 0;
 color->gdk.blue = 0;
 }
+#endif
 g_free (color_str);
 
 color->alpha = g_settings_get_int (toplevel->background_settings, "opacity");
@@ -529,7 +541,11 @@ panel_profile_load_background (PanelToplevel *toplevel)
 PanelWidget *panel_widget;
 PanelBackground *background;
 PanelBackgroundType background_type;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkRGBA color;
+#else
 PanelColor color;
+#endif
 char *image;
 gboolean fit;
 gboolean stretch;
@@ -823,14 +839,26 @@ panel_profile_background_change_notify (GSettings *settings,
 panel_background_set_type (background, background_type);
 panel_toplevel_update_edges (toplevel);
 } else if (!strcmp (key, "color")) {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkRGBA color;
+ gchar *str;
+ str = g_settings_get_string (settings, key);
+ if (gdk_rgba_parse (&color, str))
+ panel_background_set_color (background, &color);
+ g_free (str);
+#else
 GdkColor gdk_color;
- const char *str;
+ gchar *str;
 str = g_settings_get_string (settings, key);
 if (gdk_color_parse (str, &gdk_color))
 panel_background_set_gdk_color (background, &gdk_color);
+ g_free (str);
+#endif
 } else if (!strcmp (key, "opacity")) {
+#if !GTK_CHECK_VERSION (3, 0, 0)
 panel_background_set_opacity (background,
 g_settings_get_int (settings, key));
+#endif
 } else if (!strcmp (key, "image")) {
 panel_background_set_image (background,
 g_settings_get_string (settings, key));
diff --git a/mate-panel/panel-properties-dialog.c b/mate-panel/panel-properties-dialog.c
index 596ab062..5818522f 100644
--- a/mate-panel/panel-properties-dialog.c
+++ b/mate-panel/panel-properties-dialog.c
@@ -922,9 +922,12 @@ panel_properties_dialog_new (PanelToplevel *toplevel,
 panel_widget_register_open_dialog (panel_toplevel_get_panel_widget (dialog->toplevel),
 dialog->properties_dialog);
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ /* FIXME re-add once GTK3 support is fixed */
 g_signal_connect (dialog->properties_dialog, "event",
 G_CALLBACK (config_event),
 PANEL_GTK_BUILDER_GET (gui, "notebook"));
+#endif
 
 gtk_widget_show (dialog->properties_dialog);
 
diff --git a/mate-panel/panel-run-dialog.c b/mate-panel/panel-run-dialog.c
index 339240d2..0299374f 100644
--- a/mate-panel/panel-run-dialog.c
+++ b/mate-panel/panel-run-dialog.c
@@ -43,7 +43,7 @@
 #include <matemenu-tree.h>
 
 #define MATE_DESKTOP_USE_UNSTABLE_API
-#include <libmate/mate-desktop-utils.h>
+#include <libmate-desktop/mate-desktop-utils.h>
 
 #include <libpanel-util/panel-error.h>
 #include <libpanel-util/panel-glib.h>
@@ -147,7 +147,7 @@ _panel_run_get_recent_programs_list (PanelRunDialog *dialog)
 
 static void
 _panel_run_save_recent_programs_list (PanelRunDialog *dialog,
- GtkComboBoxEntry *entry,
+ GtkComboBox *entry,
 char *lastcommand)
 {
 GtkTreeModel *model;
@@ -360,6 +360,17 @@ dummy_child_watch (GPid pid,
 */
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+/*
+ * Set the DISPLAY variable, to be use by g_spawn_async.
+ */
+static void
+set_environment (gpointer display)
+{
+ g_setenv ("DISPLAY", display, TRUE);
+}
+#endif
+
 static gboolean
 panel_run_dialog_launch_command (PanelRunDialog *dialog,
 const char *command,
@@ -371,6 +382,9 @@ panel_run_dialog_launch_command (PanelRunDialog *dialog,
 char **argv;
 int argc;
 GPid pid;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ char *display;
+#endif
 
 if (!command_is_executable (locale_command, &argc, &argv))
 return FALSE;
@@ -380,6 +394,20 @@ panel_run_dialog_launch_command (PanelRunDialog *dialog,
 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->terminal_checkbox)))
 mate_desktop_prepend_terminal_to_vector (&argc, &argv);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ display = gdk_screen_make_display_name (screen);
+
+ result = g_spawn_async (NULL, /* working directory */
+ argv,
+ NULL, /* envp */
+ G_SPAWN_SEARCH_PATH,
+ set_environment,
+ &display,
+ NULL,
+ &error);
+
+ g_free (display);
+#else
 result = gdk_spawn_on_screen (screen,
 NULL, /* working directory */
 argv,
@@ -389,6 +417,7 @@ panel_run_dialog_launch_command (PanelRunDialog *dialog,
 NULL, /* user data */
 &pid, /* child pid */
 &error);
+#endif
 
 if (!result) {
 char *primary;
@@ -419,7 +448,7 @@ panel_run_dialog_execute (PanelRunDialog *dialog)
 char *disk;
 char *scheme;
 
- command = gtk_combo_box_get_active_text (GTK_COMBO_BOX (dialog->combobox));
+ command = g_strdup (gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (dialog->combobox)))));
 command = g_strchug (command);
 
 if (!command || !command [0]) {
@@ -428,6 +457,8 @@ panel_run_dialog_execute (PanelRunDialog *dialog)
 }
 
 /* evil eggies, do not translate! */
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ /* FIXME re-add once GTK3 support is fixed */
 if (!strcmp (command, "free the fish")) {
 start_screen_check ();
 
@@ -441,6 +472,7 @@ panel_run_dialog_execute (PanelRunDialog *dialog)
 gtk_widget_destroy (dialog->run_dialog);
 return;
 }
+#endif
 
 error = NULL;
 disk = g_locale_from_utf8 (command, -1, NULL, NULL, &error);
@@ -486,7 +518,7 @@ panel_run_dialog_execute (PanelRunDialog *dialog)
 if (result) {
 /* only save working commands in history */
 _panel_run_save_recent_programs_list
- (dialog, GTK_COMBO_BOX_ENTRY (dialog->combobox), command);
+ (dialog, GTK_COMBO_BOX (dialog->combobox), command);
 
 /* only close the dialog if we successfully showed or launched
 * something */
@@ -545,7 +577,7 @@ static void
 panel_run_dialog_append_file_utf8 (PanelRunDialog *dialog,
 const char *file)
 {
- char *text;
+ const char *text;
 char *quoted, *temp;
 GtkWidget *entry;
 
@@ -555,7 +587,7 @@ panel_run_dialog_append_file_utf8 (PanelRunDialog *dialog,
 
 quoted = quote_string (file);
 entry = gtk_bin_get_child (GTK_BIN (dialog->combobox));
- text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (dialog->combobox));
+ text = gtk_entry_get_text (GTK_ENTRY (entry));
 if (text && text [0]) {
 temp = g_strconcat (text, " ", quoted, NULL);
 gtk_entry_set_text (GTK_ENTRY (entry), temp);
@@ -563,7 +595,6 @@ panel_run_dialog_append_file_utf8 (PanelRunDialog *dialog,
 } else
 gtk_entry_set_text (GTK_ENTRY (entry), quoted);
 
- g_free (text);
 g_free (quoted);
 }
 
@@ -671,7 +702,7 @@ panel_run_dialog_find_command_idle (PanelRunDialog *dialog)
 return FALSE;
 }
 
- text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (dialog->combobox));
+ text = g_strdup (gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (dialog->combobox)))));
 found_icon = NULL;
 found_name = NULL;
 fuzzy = FALSE;
@@ -1506,7 +1537,7 @@ entry_event (GtkEditable *entry,
 return FALSE;
 
 /* tab completion */
- if (event->keyval == GDK_Tab) {
+ if (event->keyval == GDK_KEY_Tab) {
 gtk_editable_get_selection_bounds (entry, &pos, &tmp);
 
 if (dialog->completion_started &&
@@ -1602,7 +1633,7 @@ combobox_changed (GtkComboBox *combobox,
 char *start;
 char *msg;
 
- text = gtk_combo_box_get_active_text (combobox);
+ text = g_strdup (gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combobox)))));
 
 start = text;
 while (*start != '\0' && g_ascii_isspace (*start))
@@ -1746,8 +1777,8 @@ panel_run_dialog_setup_entry (PanelRunDialog *dialog,
 
 gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox),
 _panel_run_get_recent_programs_list (dialog));
- gtk_combo_box_entry_set_text_column
- (GTK_COMBO_BOX_ENTRY (dialog->combobox), 0);
+ gtk_combo_box_set_entry_text_column
+ (GTK_COMBO_BOX (dialog->combobox), 0);
 
 screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog));
 
@@ -1787,7 +1818,7 @@ panel_run_dialog_create_desktop_file (PanelRunDialog *dialog)
 char *scheme;
 char *save_uri;
 
- text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (dialog->combobox));
+ text = g_strdup (gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (dialog->combobox)))));
 
 if (!text || !text [0]) {
 g_free (text);
diff --git a/mate-panel/panel-run-dialog.ui b/mate-panel/panel-run-dialog.ui
index d2bb2a86..04fa84f7 100644
--- a/mate-panel/panel-run-dialog.ui
+++ b/mate-panel/panel-run-dialog.ui
@@ -58,8 +58,9 @@
 <property name="orientation">vertical</property>
 <property name="spacing">6</property>
 <child>
- <object class="GtkComboBoxEntry" id="comboboxentry">
+ <object class="GtkComboBoxText" id="comboboxentry">
 <property name="visible">True</property>
+ <property name="has-entry">True</property>
 </object>
 <packing>
 <property name="position">0</property>
diff --git a/mate-panel/panel-separator.c b/mate-panel/panel-separator.c
index 0f286e5d..7cb378fd 100644
--- a/mate-panel/panel-separator.c
+++ b/mate-panel/panel-separator.c
@@ -43,43 +43,91 @@ G_DEFINE_TYPE (PanelSeparator, panel_separator, GTK_TYPE_EVENT_BOX)
 
 static void
 panel_separator_paint (GtkWidget *widget,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cairo_t *cr)
+#else
 GdkRectangle *area)
+#endif
 {
 PanelSeparator *separator;
 GdkWindow *window;
 GtkStyle *style;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ int width;
+ int height;
+#else
 GtkAllocation allocation;
+#endif
 
 separator = PANEL_SEPARATOR (widget);
 
 window = gtk_widget_get_window (widget);
 style = gtk_widget_get_style (widget);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ width = gtk_widget_get_allocated_width (widget);
+ height = gtk_widget_get_allocated_height (widget);
+#else
 gtk_widget_get_allocation (widget, &allocation);
+#endif
 
 if (separator->priv->orientation == GTK_ORIENTATION_HORIZONTAL) {
- gtk_paint_vline (style, window,
+ gtk_paint_vline (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
 gtk_widget_get_state (widget),
- area, widget, "separator",
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ area,
+#endif
+ widget, "separator",
 style->xthickness,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ height - style->xthickness,
+ (width - style->xthickness) / 2);
+#else
 allocation.height - style->xthickness,
 (allocation.width - style->xthickness) / 2);
+#endif
 } else {
- gtk_paint_hline (style, window,
+ gtk_paint_hline (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
 gtk_widget_get_state (widget),
- area, widget, "separator",
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ area,
+#endif
+ widget, "separator",
 style->ythickness,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ width - style->ythickness,
+ (height - style->ythickness) / 2);
+#else
 allocation.width - style->ythickness,
 (allocation.height - style->ythickness) / 2);
+#endif
 }
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static gboolean panel_separator_draw(GtkWidget* widget, cairo_t* cr)
+#else
 static gboolean panel_separator_expose_event(GtkWidget* widget, GdkEventExpose* event)
+#endif
 {
 if (gtk_widget_is_drawable(widget))
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GTK_WIDGET_CLASS(panel_separator_parent_class)->draw(widget, cr);
+ panel_separator_paint(widget, cr);
+#else
 GTK_WIDGET_CLASS(panel_separator_parent_class)->expose_event(widget, event);
-
 panel_separator_paint(widget, &event->area);
+#endif
 }
 
 return FALSE;
@@ -105,6 +153,28 @@ panel_separator_size_request (GtkWidget *widget,
 }
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void
+panel_separator_get_preferred_width (GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ GtkRequisition req;
+ panel_separator_size_request (widget, &req);
+ *minimum_width = *natural_width = req.width;
+}
+
+static void
+panel_separator_get_preferred_height (GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ GtkRequisition req;
+ panel_separator_size_request (widget, &req);
+ *minimum_height = *natural_height = req.height;
+}
+#endif
+
 static void
 panel_separator_size_allocate (GtkWidget *widget,
 GtkAllocation *allocation)
@@ -157,8 +227,14 @@ panel_separator_class_init (PanelSeparatorClass *klass)
 {
 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->draw = panel_separator_draw;
+ widget_class->get_preferred_width = panel_separator_get_preferred_width;
+ widget_class->get_preferred_height = panel_separator_get_preferred_height;
+#else
 widget_class->expose_event = panel_separator_expose_event;
 widget_class->size_request = panel_separator_size_request;
+#endif
 widget_class->size_allocate = panel_separator_size_allocate;
 widget_class->parent_set = panel_separator_parent_set;
 
diff --git a/mate-panel/panel-session.c b/mate-panel/panel-session.c
index dbfcebb5..5f43f3f4 100644
--- a/mate-panel/panel-session.c
+++ b/mate-panel/panel-session.c
@@ -26,7 +26,11 @@
 
 #include <stdlib.h>
 
+#include <gtk/gtk.h>
 #include <gdk/gdk.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gdk/gdkx.h>
+#endif
 
 #include <libegg/eggsmclient.h>
 
@@ -76,5 +80,9 @@ panel_session_init (void)
 
 /* We don't want the WM to try and save/restore our
 * window position */
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdk_x11_set_sm_client_id (NULL);
+#else
 gdk_set_sm_client_id (NULL);
+#endif
 }
diff --git a/mate-panel/panel-toplevel.c b/mate-panel/panel-toplevel.c
index 692ca441..0ea04bfd 100644
--- a/mate-panel/panel-toplevel.c
+++ b/mate-panel/panel-toplevel.c
@@ -33,6 +33,9 @@
 
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gdk/gdkkeysyms-compat.h>
+#endif
 #include <glib/gi18n.h>
 
 #include "panel-profile.h"
@@ -2940,7 +2943,11 @@ panel_toplevel_unrealize (GtkWidget *widget)
 }
 
 static void
+#if GTK_CHECK_VERSION (3, 0, 0)
+panel_toplevel_dispose (GObject *widget)
+#else
 panel_toplevel_destroy (GtkObject *widget)
+#endif
 {
 PanelToplevel *toplevel = (PanelToplevel *) widget;
 
@@ -2954,8 +2961,12 @@ panel_toplevel_destroy (GtkObject *widget)
 
 panel_toplevel_disconnect_timeouts (toplevel);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ G_OBJECT_CLASS (panel_toplevel_parent_class)->dispose (widget);
+#else
 if (GTK_OBJECT_CLASS (panel_toplevel_parent_class)->destroy)
 GTK_OBJECT_CLASS (panel_toplevel_parent_class)->destroy (widget);
+#endif
 }
 
 static void
@@ -3028,6 +3039,28 @@ panel_toplevel_size_request (GtkWidget *widget,
 panel_toplevel_move_resize_window (toplevel, position_changed, size_changed);
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void
+panel_toplevel_get_preferred_width (GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ GtkRequisition req;
+ panel_toplevel_size_request (widget, &req);
+ *minimum_width = *natural_width = req.width;
+}
+
+static void
+panel_toplevel_get_preferred_height (GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ GtkRequisition req;
+ panel_toplevel_size_request (widget, &req);
+ *minimum_height = *natural_height = req.height;
+}
+#endif
+
 static void
 panel_toplevel_size_allocate (GtkWidget *widget,
 GtkAllocation *allocation)
@@ -3098,7 +3131,11 @@ panel_toplevel_size_allocate (GtkWidget *widget,
 gtk_widget_size_allocate (child, &challoc);
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static gboolean panel_toplevel_draw(GtkWidget* widget, cairo_t* cr)
+#else
 static gboolean panel_toplevel_expose(GtkWidget* widget, GdkEventExpose* event)
+#endif
 {
 PanelToplevel* toplevel = (PanelToplevel*) widget;
 PanelFrameEdge edges;
@@ -3106,16 +3143,30 @@ static gboolean panel_toplevel_expose(GtkWidget* widget, GdkEventExpose* event)
 GdkWindow *window;
 GtkStyle *style;
 GtkStateType state;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ int awidth;
+ int aheight;
+#else
 GtkAllocation allocation;
+#endif
 
 if (!gtk_widget_is_drawable (widget))
 return retval;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (GTK_WIDGET_CLASS (panel_toplevel_parent_class)->draw)
+ retval = GTK_WIDGET_CLASS (panel_toplevel_parent_class)->draw (widget, cr);
+#else
 if (GTK_WIDGET_CLASS (panel_toplevel_parent_class)->expose_event)
 retval = GTK_WIDGET_CLASS (panel_toplevel_parent_class)->expose_event (widget, event);
+#endif
 
 edges = toplevel->priv->edges;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ panel_frame_draw (widget, cr, edges);
+#else
 panel_frame_draw (widget, edges);
+#endif
 
 if (toplevel->priv->expand ||
 toplevel->priv->buttons_enabled ||
@@ -3125,16 +3176,27 @@ static gboolean panel_toplevel_expose(GtkWidget* widget, GdkEventExpose* event)
 window = gtk_widget_get_window (widget);
 style = gtk_widget_get_style (widget);
 state = gtk_widget_get_state (widget);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ awidth = gtk_widget_get_allocated_width (widget);
+ aheight = gtk_widget_get_allocated_height (widget);
+#else
 gtk_widget_get_allocation (widget, &allocation);
+#endif
 
 if (toplevel->priv->orientation & PANEL_HORIZONTAL_MASK) {
 int x, y, width, height;
 int xthickness, ythickness;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x = 0;
+ y = 0;
+ height = height;
+#else
 x = allocation.x;
 y = allocation.y;
- width = HANDLE_SIZE;
 height = allocation.height;
+#endif
+ width = HANDLE_SIZE;
 
 xthickness = style->xthickness;
 ythickness = style->ythickness;
@@ -3148,28 +3210,56 @@ static gboolean panel_toplevel_expose(GtkWidget* widget, GdkEventExpose* event)
 if (edges & PANEL_EDGE_LEFT)
 x += xthickness;
 
- gtk_paint_handle (style, window, state,
+ gtk_paint_handle (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
+ state,
 GTK_SHADOW_OUT,
- &event->area, widget, "handlebox",
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ &event->area,
+#endif
+ widget, "handlebox",
 x, y, width, height,
 GTK_ORIENTATION_VERTICAL);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x = awidth - HANDLE_SIZE;
+#else
 x = allocation.width - HANDLE_SIZE;
+#endif
 if (edges & PANEL_EDGE_RIGHT)
 x -= xthickness;
 
- gtk_paint_handle (style, window, state,
+ gtk_paint_handle (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
+ state,
 GTK_SHADOW_OUT,
- &event->area, widget, "handlebox",
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ &event->area,
+#endif
+ widget, "handlebox",
 x, y, width, height,
 GTK_ORIENTATION_VERTICAL);
 } else {
 int x, y, width, height;
 int xthickness, ythickness;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ x = 0;
+ y = 0;
+ width = awidth;
+#else
 x = allocation.x;
 y = allocation.y;
 width = allocation.width;
+#endif
 height = HANDLE_SIZE;
 
 xthickness = style->xthickness;
@@ -3184,19 +3274,41 @@ static gboolean panel_toplevel_expose(GtkWidget* widget, GdkEventExpose* event)
 if (edges & PANEL_EDGE_TOP)
 y += ythickness;
 
- gtk_paint_handle (style, window, state,
+ gtk_paint_handle (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
+ state,
 GTK_SHADOW_OUT,
- &event->area, widget, "handlebox",
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ &event->area,
+#endif
+ widget, "handlebox",
 x, y, width, height,
 GTK_ORIENTATION_HORIZONTAL);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ y = aheight - HANDLE_SIZE;
+#else
 y = allocation.height - HANDLE_SIZE;
+#endif
 if (edges & PANEL_EDGE_BOTTOM)
 y -= ythickness;
 
- gtk_paint_handle (style, window, state,
+ gtk_paint_handle (style,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ cr,
+#else
+ window,
+#endif
+ state,
 GTK_SHADOW_OUT,
- &event->area, widget, "handlebox",
+#if !GTK_CHECK_VERSION (3, 0, 0)
+ &event->area,
+#endif
+ widget, "handlebox",
 x, y, width, height,
 GTK_ORIENTATION_HORIZONTAL);
 }
@@ -4040,7 +4152,9 @@ static void
 panel_toplevel_class_init (PanelToplevelClass *klass)
 {
 GObjectClass *gobject_class = (GObjectClass *) klass;
+#if !GTK_CHECK_VERSION (3, 0, 0)
 GtkObjectClass *gtkobject_class = (GtkObjectClass *) klass;
+#endif
 GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
 GtkContainerClass *container_class = (GtkContainerClass *) klass;
 GtkBindingSet *binding_set;
@@ -4051,13 +4165,23 @@ panel_toplevel_class_init (PanelToplevelClass *klass)
 gobject_class->get_property = panel_toplevel_get_property;
 gobject_class->finalize = panel_toplevel_finalize;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gobject_class->dispose = panel_toplevel_dispose;
+#else
 gtkobject_class->destroy = panel_toplevel_destroy;
+#endif
 
 widget_class->realize = panel_toplevel_realize;
 widget_class->unrealize = panel_toplevel_unrealize;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->draw = panel_toplevel_draw;
+ widget_class->get_preferred_width = panel_toplevel_get_preferred_width;
+ widget_class->get_preferred_height = panel_toplevel_get_preferred_height;
+#else
+ widget_class->expose_event = panel_toplevel_expose;
 widget_class->size_request = panel_toplevel_size_request;
+#endif
 widget_class->size_allocate = panel_toplevel_size_allocate;
- widget_class->expose_event = panel_toplevel_expose;
 widget_class->button_press_event = panel_toplevel_button_press_event;
 widget_class->button_release_event = panel_toplevel_button_release_event;
 widget_class->key_press_event = panel_toplevel_key_press_event;
diff --git a/mate-panel/panel-util.c b/mate-panel/panel-util.c
index 2259aff3..dd6ad79b 100644
--- a/mate-panel/panel-util.c
+++ b/mate-panel/panel-util.c
@@ -29,6 +29,12 @@
 #include <gio/gio.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+#define MATE_DESKTOP_USE_UNSTABLE_API
+#include <libmate-desktop/mate-desktop-utils.h>
+#endif
+#include <libmate-desktop/mate-gsettings.h>
+
 #include <libpanel-util/panel-error.h>
 #include <libpanel-util/panel-glib.h>
 #include <libpanel-util/panel-keyfile.h>
@@ -428,7 +434,11 @@ void panel_lock_screen_action(GdkScreen* screen, const char* action)
 return;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ if (!mate_gdk_spawn_command_line_on_screen(screen, command, &error))
+#else
 if (!gdk_spawn_command_line_on_screen(screen, command, &error))
+#endif
 {
 char* primary = g_strdup_printf(_("Could not execute '%s'"), command);
 panel_error_dialog (NULL, screen, "cannot_exec_screensaver", TRUE, primary, error->message);
@@ -830,14 +840,16 @@ panel_util_get_file_display_for_common_files (GFile *file)
 compare = g_file_new_for_path (g_get_home_dir ());
 if (g_file_equal (file, compare)) {
 GSettings *caja_desktop_settings;
- char *caja_home_icon_name;
+ char *caja_home_icon_name = NULL;
 
 g_object_unref (compare);
 
- caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA);
- caja_home_icon_name = g_settings_get_string (caja_desktop_settings,
- CAJA_DESKTOP_HOME_ICON_NAME_KEY);
- g_object_unref (caja_desktop_settings);
+ if (mate_gsettings_schema_exists (CAJA_DESKTOP_SCHEMA)) {
+ caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA);
+ caja_home_icon_name = g_settings_get_string (caja_desktop_settings,
+ CAJA_DESKTOP_HOME_ICON_NAME_KEY);
+ g_object_unref (caja_desktop_settings);
+ }
 if (PANEL_GLIB_STR_EMPTY (caja_home_icon_name)) {
 g_free (caja_home_icon_name);
 return g_strdup (_("Home Folder"));
diff --git a/mate-panel/panel-widget.c b/mate-panel/panel-widget.c
index 1800a7b5..969096b2 100644
--- a/mate-panel/panel-widget.c
+++ b/mate-panel/panel-widget.c
@@ -9,8 +9,12 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#if GTK_CHECK_VERSION (3, 0, 0)
+#include <gtk/gtkx.h> /* for GTK_IS_SOCKET */
+#include <gdk/gdkkeysyms-compat.h>
+#endif
 
 #include <libpanel-util/panel-list.h>
 
@@ -59,6 +63,14 @@ static guint panel_widget_signals [LAST_SIGNAL] = {0};
 static gboolean mate_panel_applet_in_drag = FALSE;
 static GtkWidget *saved_focus_widget = NULL;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void panel_widget_get_preferred_width (GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width);
+static void panel_widget_get_preferred_height (GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height);
+#endif
 static void panel_widget_size_request (GtkWidget *widget,
 GtkRequisition *requisition);
 static void panel_widget_size_allocate (GtkWidget *widget,
@@ -67,7 +79,11 @@ static void panel_widget_cadd (GtkContainer *container,
 GtkWidget *widget);
 static void panel_widget_cremove (GtkContainer *container,
 GtkWidget *widget);
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void panel_widget_dispose (GObject *obj);
+#else
 static void panel_widget_destroy (GtkObject *obj);
+#endif
 static void panel_widget_finalize (GObject *obj);
 static void panel_widget_realize (GtkWidget *widget);
 static void panel_widget_unrealize (GtkWidget *panel);
@@ -274,8 +290,12 @@ remove_all_move_bindings (PanelWidget *panel)
 static void
 panel_widget_class_init (PanelWidgetClass *class)
 {
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GObjectClass *object_class = (GObjectClass*) class;
+#else
 GtkObjectClass *object_class = (GtkObjectClass*) class;
 GObjectClass *gobject_class = (GObjectClass*) class;
+#endif
 GtkWidgetClass *widget_class = (GtkWidgetClass*) class;
 GtkContainerClass *container_class = (GtkContainerClass*) class;
 
@@ -407,10 +427,20 @@ panel_widget_class_init (PanelWidgetClass *class)
 class->tab_move = panel_widget_tab_move;
 class->end_move = panel_widget_end_move;
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ object_class->dispose = panel_widget_dispose;
+ object_class->finalize = panel_widget_finalize;
+#else
 object_class->destroy = panel_widget_destroy;
 gobject_class->finalize = panel_widget_finalize;
- 
+#endif
+
+#if GTK_CHECK_VERSION (3, 0, 0)
+ widget_class->get_preferred_width = panel_widget_get_preferred_width;
+ widget_class->get_preferred_height = panel_widget_get_preferred_height;
+#else
 widget_class->size_request = panel_widget_size_request;
+#endif
 widget_class->size_allocate = panel_widget_size_allocate;
 widget_class->realize = panel_widget_realize;
 widget_class->unrealize = panel_widget_unrealize;
@@ -1294,6 +1324,28 @@ panel_widget_size_request(GtkWidget *widget, GtkRequisition *requisition)
 }
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+static void
+panel_widget_get_preferred_width (GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ GtkRequisition req;
+ panel_widget_size_request (widget, &req);
+ *minimum_width = *natural_width = req.width;
+}
+
+static void
+panel_widget_get_preferred_height (GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ GtkRequisition req;
+ panel_widget_size_request (widget, &req);
+ *minimum_height = *natural_height = req.height;
+}
+#endif
+
 static void
 queue_resize_on_all_applets(PanelWidget *panel)
 {
@@ -1568,7 +1620,11 @@ panel_widget_style_set (GtkWidget *widget,
 panel_background_set_default_style (
 &PANEL_WIDGET (widget)->background,
 &style->bg [state],
+#if GTK_CHECK_VERSION (3, 0, 0)
+ style->background [state]);
+#else
 style->bg_pixmap [state]);
+#endif
 }
 }
 
@@ -1586,7 +1642,11 @@ panel_widget_state_changed (GtkWidget *widget,
 panel_background_set_default_style (
 &PANEL_WIDGET (widget)->background,
 &style->bg [state],
+#if GTK_CHECK_VERSION (3, 0, 0)
+ style->background [state]);
+#else
 style->bg_pixmap [state]);
+#endif
 }
 }
 
@@ -1624,7 +1684,11 @@ panel_widget_realize (GtkWidget *widget)
 panel_background_set_default_style (
 &panel->background,
 &style->bg [state],
+#if GTK_CHECK_VERSION (3, 0, 0)
+ style->background [state]);
+#else
 style->bg_pixmap [state]);
+#endif
 
 panel_background_realized (&panel->background, window);
 }
@@ -1694,7 +1758,11 @@ panel_widget_destroy_open_dialogs (PanelWidget *panel_widget)
 }
 
 static void
+#if GTK_CHECK_VERSION (3, 0, 0)
+panel_widget_dispose (GObject *obj)
+#else
 panel_widget_destroy (GtkObject *obj)
+#endif
 {
 PanelWidget *panel;
 
@@ -1715,8 +1783,12 @@ panel_widget_destroy (GtkObject *obj)
 panel->master_widget = NULL;
 }
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ G_OBJECT_CLASS (panel_widget_parent_class)->dispose (obj);
+#else
 if (GTK_OBJECT_CLASS (panel_widget_parent_class)->destroy)
 GTK_OBJECT_CLASS (panel_widget_parent_class)->destroy (obj);
+#endif
 }
 
 static void
@@ -2328,8 +2400,12 @@ panel_widget_applet_key_press_event (GtkWidget *widget,
 
 if (!mate_panel_applet_in_drag)
 return FALSE;
- 
+
+#if GTK_CHECK_VERSION (3, 0, 0)
+ return gtk_bindings_activate (G_OBJECT (panel),
+#else
 return gtk_bindings_activate (GTK_OBJECT (panel),
+#endif
 ((GdkEventKey *)event)->keyval, 
 ((GdkEventKey *)event)->state); 
 }
diff --git a/mate-panel/panel-xutils.c b/mate-panel/panel-xutils.c
index 14b57632..e970fb37 100644
--- a/mate-panel/panel-xutils.c
+++ b/mate-panel/panel-xutils.c
@@ -27,6 +27,7 @@
 #include "panel-xutils.h"
 
 #include <glib.h>
+#include <gtk/gtk.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/Xlib.h>
@@ -50,7 +51,11 @@ panel_xutils_set_window_type (GdkWindow *gdk_window,
 g_return_if_fail (GDK_IS_WINDOW (gdk_window));
 
 display = GDK_WINDOW_XDISPLAY (gdk_window);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ window = GDK_WINDOW_XID (gdk_window);
+#else
 window = GDK_WINDOW_XWINDOW (gdk_window);
+#endif
 
 if (net_wm_window_type == None)
 net_wm_window_type = XInternAtom (display,
@@ -113,7 +118,11 @@ panel_xutils_set_strut (GdkWindow *gdk_window,
 g_return_if_fail (GDK_IS_WINDOW (gdk_window));
 
 display = GDK_WINDOW_XDISPLAY (gdk_window);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ window = GDK_WINDOW_XID (gdk_window);
+#else
 window = GDK_WINDOW_XWINDOW (gdk_window);
+#endif
 
 if (net_wm_strut == None)
 net_wm_strut = XInternAtom (display, "_NET_WM_STRUT", False);
@@ -164,7 +173,11 @@ panel_warp_pointer (GdkWindow *gdk_window,
 g_return_if_fail (GDK_IS_WINDOW (gdk_window));
 
 display = GDK_WINDOW_XDISPLAY (gdk_window);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ window = GDK_WINDOW_XID (gdk_window);
+#else
 window = GDK_WINDOW_XWINDOW (gdk_window);
+#endif
 
 gdk_error_trap_push ();
 XWarpPointer (display, None, window, 0, 0, 0, 0, x, y);
diff --git a/mate-panel/panel.c b/mate-panel/panel.c
index 15719418..8ac44a88 100644
--- a/mate-panel/panel.c
+++ b/mate-panel/panel.c
@@ -20,6 +20,7 @@
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 #if GTK_CHECK_VERSION (3, 0, 0)
+#include <gtk/gtkx.h> /* for GTK_IS_SOCKET */
 #include <gdk/gdkkeysyms-compat.h>
 #endif
 
diff --git a/mate-panel/xstuff.c b/mate-panel/xstuff.c
index 6bcc3396..2b54e293 100644
--- a/mate-panel/xstuff.c
+++ b/mate-panel/xstuff.c
@@ -163,8 +163,11 @@ xstuff_is_compliant_wm (void)
 int size;
 
 xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
- root_window = GDK_WINDOW_XWINDOW (
- gdk_get_default_root_window ());
+#if GTK_CHECK_VERSION (3, 0, 0)
+ root_window = GDK_WINDOW_XID (gdk_get_default_root_window ());
+#else
+ root_window = GDK_WINDOW_XWINDOW (gdk_get_default_root_window ());
+#endif
 
 /* FIXME this is totally broken; should be using
 * gdk_net_wm_supports() on particular hints when we rely
@@ -183,12 +186,6 @@ xstuff_is_compliant_wm (void)
 return TRUE;
 }
 
-gboolean
-xstuff_net_wm_supports (const char *hint)
-{
- return gdk_net_wm_supports (gdk_atom_intern (hint, FALSE));
-}
-
 /* This is such a broken stupid function. */ 
 void
 xstuff_set_pos_size (GdkWindow *window, int x, int y, int w, int h)
@@ -218,7 +215,11 @@ xstuff_set_pos_size (GdkWindow *window, int x, int y, int w, int h)
 gdk_error_trap_push ();
 
 XSetWMNormalHints (GDK_WINDOW_XDISPLAY (window),
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GDK_WINDOW_XID (window),
+#else
 GDK_WINDOW_XWINDOW (window),
+#endif
 &size_hints);
 
 gdk_window_move_resize (window, x, y, w, h);
@@ -246,7 +247,11 @@ xstuff_set_wmspec_dock_hints (GdkWindow *window,
 }
 
 XChangeProperty (GDK_WINDOW_XDISPLAY (window),
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GDK_WINDOW_XID (window),
+#else
 GDK_WINDOW_XWINDOW (window),
+#endif
 panel_atom_get ("_NET_WM_WINDOW_TYPE"),
 XA_ATOM, 32, PropModeReplace,
 (unsigned char *) atoms, 
@@ -268,7 +273,11 @@ xstuff_set_wmspec_strut (GdkWindow *window,
 vals [3] = bottom;
 
 XChangeProperty (GDK_WINDOW_XDISPLAY (window),
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GDK_WINDOW_XID (window),
+#else
 GDK_WINDOW_XWINDOW (window),
+#endif
 panel_atom_get ("_NET_WM_STRUT"),
 XA_CARDINAL, 32, PropModeReplace,
 (unsigned char *) vals, 4);
@@ -278,7 +287,11 @@ void
 xstuff_delete_property (GdkWindow *window, const char *name)
 {
 Display *xdisplay = GDK_WINDOW_XDISPLAY (window);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ Window xwindow = GDK_WINDOW_XID (window);
+#else
 Window xwindow = GDK_WINDOW_XWINDOW (window);
+#endif
 
 XDeleteProperty (xdisplay, xwindow,
 panel_atom_get (name));
@@ -313,8 +326,13 @@ zoom_timeout (GtkWidget *window)
 }
 
 static gboolean
+#if GTK_CHECK_VERSION (3, 0, 0)
+zoom_draw (GtkWidget *widget,
+ cairo_t *cr,
+#else
 zoom_expose (GtkWidget *widget,
 GdkEventExpose *event,
+#endif
 gpointer user_data)
 {
 CompositedZoomData *zoom;
@@ -336,7 +354,9 @@ zoom_expose (GtkWidget *widget,
 GdkPixbuf *scaled;
 int width, height;
 int x = 0, y = 0;
+#if !GTK_CHECK_VERSION (3, 0, 0)
 cairo_t *cr;
+#endif
 
 gtk_window_get_size (GTK_WINDOW (widget), &width, &height);
 
@@ -369,8 +389,9 @@ zoom_expose (GtkWidget *widget,
 break;
 }
 
-
+#if !GTK_CHECK_VERSION (3, 0, 0)
 cr = gdk_cairo_create (gtk_widget_get_window (widget));
+#endif
 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 cairo_set_source_rgba (cr, 0, 0, 0, 0.0);
 cairo_rectangle (cr, 0, 0, width, height);
@@ -380,7 +401,9 @@ zoom_expose (GtkWidget *widget,
 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 cairo_paint_with_alpha (cr, MAX (zoom->opacity, 0));
 
+#if !GTK_CHECK_VERSION (3, 0, 0)
 cairo_destroy (cr);
+#endif
 g_object_unref (scaled);
 }
 
@@ -415,7 +438,11 @@ draw_zoom_animation_composited (GdkScreen *gscreen,
 gtk_window_set_keep_above (GTK_WINDOW (win), TRUE);
 gtk_window_set_decorated (GTK_WINDOW (win), FALSE);
 gtk_widget_set_app_paintable(win, TRUE);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gtk_widget_set_visual (win, gdk_screen_get_rgba_visual (gscreen));
+#else
 gtk_widget_set_colormap (win, gdk_screen_get_rgba_colormap (gscreen));
+#endif
 
 gtk_window_set_gravity (GTK_WINDOW (win), GDK_GRAVITY_STATIC);
 gtk_window_set_default_size (GTK_WINDOW (win),
@@ -445,12 +472,21 @@ draw_zoom_animation_composited (GdkScreen *gscreen,
 
 gtk_window_move (GTK_WINDOW (win), wx, wy);
 
+#if GTK_CHECK_VERSION (3, 0, 0)
+ g_signal_connect (G_OBJECT (win), "draw",
+ G_CALLBACK (zoom_draw), zoom);
+#else
 g_signal_connect (G_OBJECT (win), "expose-event",
 G_CALLBACK (zoom_expose), zoom);
+#endif
 
 /* see doc for gtk_widget_set_app_paintable() */
 gtk_widget_realize (win);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ gdk_window_set_background_pattern (gtk_widget_get_window (win), NULL);
+#else
 gdk_window_set_back_pixmap (gtk_widget_get_window (win), NULL, FALSE);
+#endif
 gtk_widget_show (win);
 
 zoom->timeout_id = g_timeout_add (ZOOM_DELAY,
@@ -478,13 +514,23 @@ draw_zoom_animation (GdkScreen *gscreen,
 int depth;
 
 dpy = gdk_x11_display_get_xdisplay (gdk_screen_get_display (gscreen));
+#if GTK_CHECK_VERSION (3, 0, 0)
+ root_win = GDK_WINDOW_XID (gdk_screen_get_root_window (gscreen));
+#else
 root_win = gdk_x11_drawable_get_xid (gdk_screen_get_root_window (gscreen));
+#endif
 screen = gdk_screen_get_number (gscreen);
+#if GTK_CHECK_VERSION (3, 0, 0)
+ depth = DefaultDepth(dpy,screen);
+#else
 depth = gdk_drawable_get_depth (gdk_screen_get_root_window (gscreen));
+#endif
 
 /* frame GC */
+#if !GTK_CHECK_VERSION (3, 0, 0)
 gdk_colormap_alloc_color (
 gdk_screen_get_system_colormap (gscreen), &color, FALSE, TRUE);
+#endif
 gcv.function = GXxor;
 /* this will raise the probability of the XORed color being different
 * of the original color in PseudoColor when not all color cells are
@@ -575,9 +621,10 @@ draw_zoom_animation (GdkScreen *gscreen,
 
 XUngrabServer(dpy);
 XFreeGC (dpy, frame_gc);
+#if !GTK_CHECK_VERSION (3, 0, 0)
 gdk_colormap_free_colors (gdk_screen_get_system_colormap (gscreen),
 &color, 1);
-
+#endif
 }
 #undef FRAMES
 
@@ -639,8 +686,11 @@ xstuff_get_current_workspace (GdkScreen *screen)
 int result;
 int retval;
 
- root_window = gdk_x11_drawable_get_xid (
- gdk_screen_get_root_window (screen));
+#if GTK_CHECK_VERSION (3, 0, 0)
+ root_window = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
+#else
+ root_window = gdk_x11_drawable_get_xid (gdk_screen_get_root_window (screen));
+#endif
 
 gdk_error_trap_push ();
 result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen)),
@@ -685,12 +735,20 @@ xstuff_grab_key_on_all_screens (int keycode,
 if (grab)
 XGrabKey (gdk_x11_display_get_xdisplay (display),
 keycode, modifiers,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GDK_WINDOW_XID (root),
+#else
 gdk_x11_drawable_get_xid (root),
+#endif
 True, GrabModeAsync, GrabModeAsync);
 else
 XUngrabKey (gdk_x11_display_get_xdisplay (display),
 keycode, modifiers,
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GDK_WINDOW_XID (root));
+#else
 gdk_x11_drawable_get_xid (root));
+#endif
 }
 }
 
diff --git a/mate-panel/xstuff.h b/mate-panel/xstuff.h
index 0bd5f92b..e441f182 100644
--- a/mate-panel/xstuff.h
+++ b/mate-panel/xstuff.h
@@ -7,7 +7,6 @@
 void xstuff_delete_property (GdkWindow *window,
 const char *name);
 gboolean xstuff_is_compliant_wm (void);
-gboolean xstuff_net_wm_supports (const char *hint);
 
 void xstuff_unsetup_desktop_area (void);
 void xstuff_set_pos_size (GdkWindow *window,
author	Stefano Karapetsas <[email protected]>	2013-10-26 14:34:04 +0200
committer	Stefano Karapetsas <[email protected]>	2013-10-26 14:34:04 +0200
commit	a6efbbceb5b1122512cd01609eab99fe522d8435 (patch)
tree	43a85aa03fce3f022c5db5f60579daea90cecae3
parent	fa97943c56e331668aff4b3587fe70c5edcd36b2 (diff)
download	mate-panel-a6efbbceb5b1122512cd01609eab99fe522d8435.tar.bz2 mate-panel-a6efbbceb5b1122512cd01609eab99fe522d8435.tar.xz