moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 1117 insertions, 0 deletions

diff --git a/src/ui/ui.c b/src/ui/ui.c
new file mode 100644
index 00000000..c41bc891
--- /dev/null
+++ b/src/ui/ui.c
@@ -0,0 +1,1117 @@
+/* Marco interface for talking to GTK+ UI module */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ * stock icon code Copyright (C) 2002 Jorn Baayen <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "prefs.h"
+#include "ui.h"
+#include "frames.h"
+#include "util.h"
+#include "menu.h"
+#include "core.h"
+#include "theme.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+static void meta_ui_accelerator_parse(const char* accel, guint* keysym, guint* keycode, GdkModifierType* keymask);
+
+struct _MetaUI {
+	Display* xdisplay;
+	Screen* xscreen;
+	MetaFrames* frames;
+
+	/* For double-click tracking */
+	guint button_click_number;
+	Window button_click_window;
+	int button_click_x;
+	int button_click_y;
+	guint32 button_click_time;
+};
+
+void meta_ui_init(int* argc, char*** argv)
+{
+	if (!gtk_init_check (argc, argv))
+	{
+		meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL));
+	}
+}
+
+Display* meta_ui_get_display(void)
+{
+	return GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+}
+
+/* We do some of our event handling in frames.c, which expects
+ * GDK events delivered by GTK+.  However, since the transition to
+ * client side windows, we can't let GDK see button events, since the
+ * client-side tracking of implicit and explicit grabs it does will
+ * get confused by our direct use of X grabs in the core code.
+ *
+ * So we do a very minimal GDK => GTK event conversion here and send on the
+ * events we care about, and then filter them out so they don't go
+ * through the normal GDK event handling.
+ *
+ * To reduce the amount of code, the only events fields filled out
+ * below are the ones that frames.c uses. If frames.c is modified to
+ * use more fields, more fields need to be filled out below.
+ */
+
+static gboolean
+maybe_redirect_mouse_event (XEvent *xevent)
+{
+  GdkDisplay *gdisplay;
+  MetaUI *ui;
+  GdkEvent gevent;
+  GdkWindow *gdk_window;
+  Window window;
+
+  switch (xevent->type)
+    {
+    case ButtonPress:
+    case ButtonRelease:
+      window = xevent->xbutton.window;
+      break;
+    case MotionNotify:
+      window = xevent->xmotion.window;
+      break;
+    case EnterNotify:
+    case LeaveNotify:
+      window = xevent->xcrossing.window;
+      break;
+    default:
+      return FALSE;
+    }
+
+  gdisplay = gdk_x11_lookup_xdisplay (xevent->xany.display);
+  ui = g_object_get_data (G_OBJECT (gdisplay), "meta-ui");
+  if (!ui)
+    return FALSE;
+
+  gdk_window = gdk_window_lookup_for_display (gdisplay, window);
+  if (gdk_window == NULL)
+    return FALSE;
+
+  /* If GDK already thinks it has a grab, we better let it see events; this
+   * is the menu-navigation case and events need to get sent to the appropriate
+   * (client-side) subwindow for individual menu items.
+   */
+  if (gdk_display_pointer_is_grabbed (gdisplay))
+    return FALSE;
+
+  memset (&gevent, 0, sizeof (gevent));
+
+  switch (xevent->type)
+    {
+    case ButtonPress:
+    case ButtonRelease:
+      if (xevent->type == ButtonPress)
+        {
+          GtkSettings *settings = gtk_settings_get_default ();
+          int double_click_time;
+          int double_click_distance;
+
+          g_object_get (settings,
+                        "gtk-double-click-time", &double_click_time,
+                        "gtk-double-click-distance", &double_click_distance,
+                        NULL);
+
+          if (xevent->xbutton.button == ui->button_click_number &&
+              xevent->xbutton.window == ui->button_click_window &&
+              xevent->xbutton.time < ui->button_click_time + double_click_time &&
+              ABS (xevent->xbutton.x - ui->button_click_x) <= double_click_distance &&
+              ABS (xevent->xbutton.y - ui->button_click_y) <= double_click_distance)
+            {
+              gevent.button.type = GDK_2BUTTON_PRESS;
+
+              ui->button_click_number = 0;
+            }
+          else
+            {
+              gevent.button.type = GDK_BUTTON_PRESS;
+              ui->button_click_number = xevent->xbutton.button;
+              ui->button_click_window = xevent->xbutton.window;
+              ui->button_click_time = xevent->xbutton.time;
+              ui->button_click_x = xevent->xbutton.x;
+              ui->button_click_y = xevent->xbutton.y;
+            }
+        }
+      else
+        {
+          gevent.button.type = GDK_BUTTON_RELEASE;
+        }
+
+      gevent.button.window = gdk_window;
+      gevent.button.button = xevent->xbutton.button;
+      gevent.button.time = xevent->xbutton.time;
+      gevent.button.x = xevent->xbutton.x;
+      gevent.button.y = xevent->xbutton.y;
+      gevent.button.x_root = xevent->xbutton.x_root;
+      gevent.button.y_root = xevent->xbutton.y_root;
+
+      break;
+    case MotionNotify:
+      gevent.motion.type = GDK_MOTION_NOTIFY;
+      gevent.motion.window = gdk_window;
+      break;
+    case EnterNotify:
+    case LeaveNotify:
+      gevent.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
+      gevent.crossing.window = gdk_window;
+      gevent.crossing.x = xevent->xcrossing.x;
+      gevent.crossing.y = xevent->xcrossing.y;
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  /* If we've gotten here, we've filled in the gdk_event and should send it on */
+  gtk_main_do_event (&gevent);
+
+  return TRUE;
+}
+
+typedef struct _EventFunc EventFunc;
+
+struct _EventFunc
+{
+  MetaEventFunc func;
+  gpointer data;
+};
+
+static EventFunc *ef = NULL;
+
+static GdkFilterReturn
+filter_func (GdkXEvent *xevent,
+             GdkEvent *event,
+             gpointer data)
+{
+  g_return_val_if_fail (ef != NULL, GDK_FILTER_CONTINUE);
+
+  if ((* ef->func) (xevent, ef->data) ||
+      maybe_redirect_mouse_event (xevent))
+    return GDK_FILTER_REMOVE;
+  else
+    return GDK_FILTER_CONTINUE;
+}
+
+void
+meta_ui_add_event_func (Display       *xdisplay,
+                        MetaEventFunc  func,
+                        gpointer       data)
+{
+  g_return_if_fail (ef == NULL);
+
+  ef = g_new (EventFunc, 1);
+  ef->func = func;
+  ef->data = data;
+
+  gdk_window_add_filter (NULL, filter_func, ef);
+}
+
+/* removal is by data due to proxy function */
+void
+meta_ui_remove_event_func (Display       *xdisplay,
+                           MetaEventFunc  func,
+                           gpointer       data)
+{
+  g_return_if_fail (ef != NULL);
+
+  gdk_window_remove_filter (NULL, filter_func, ef);
+
+  g_free (ef);
+  ef = NULL;
+}
+
+MetaUI*
+meta_ui_new (Display *xdisplay,
+             Screen  *screen)
+{
+  GdkDisplay *gdisplay;
+  MetaUI *ui;
+
+  ui = g_new0 (MetaUI, 1);
+  ui->xdisplay = xdisplay;
+  ui->xscreen = screen;
+
+  gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
+  g_assert (gdisplay == gdk_display_get_default ());
+
+  g_assert (xdisplay == GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
+  gtk_widget_realize (GTK_WIDGET (ui->frames));
+
+  g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
+
+  return ui;
+}
+
+void
+meta_ui_free (MetaUI *ui)
+{
+  GdkDisplay *gdisplay;
+
+  gtk_widget_destroy (GTK_WIDGET (ui->frames));
+
+  gdisplay = gdk_x11_lookup_xdisplay (ui->xdisplay);
+  g_object_set_data (G_OBJECT (gdisplay), "meta-ui", NULL);
+
+  g_free (ui);
+}
+
+void
+meta_ui_get_frame_geometry (MetaUI *ui,
+                            Window frame_xwindow,
+                            int *top_height, int *bottom_height,
+                            int *left_width, int *right_width)
+{
+  meta_frames_get_geometry (ui->frames, frame_xwindow,
+                            top_height, bottom_height,
+                            left_width, right_width);
+}
+
+Window
+meta_ui_create_frame_window (MetaUI *ui,
+                             Display *xdisplay,
+                             Visual *xvisual,
+			     gint x,
+			     gint y,
+			     gint width,
+			     gint height,
+			     gint screen_no)
+{
+  GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
+  GdkScreen *screen = gdk_display_get_screen (display, screen_no);
+  GdkWindowAttr attrs;
+  gint attributes_mask;
+  GdkWindow *window;
+  GdkVisual *visual;
+  GdkColormap *cmap = gdk_screen_get_default_colormap (screen);
+
+  /* Default depth/visual handles clients with weird visuals; they can
+   * always be children of the root depth/visual obviously, but
+   * e.g. DRI games can't be children of a parent that has the same
+   * visual as the client.
+   */
+  if (!xvisual)
+    visual = gdk_screen_get_system_visual (screen);
+  else
+    {
+      visual = gdk_x11_screen_lookup_visual (screen,
+                                             XVisualIDFromVisual (xvisual));
+      cmap = gdk_colormap_new (visual, FALSE);
+    }
+
+  attrs.title = NULL;
+
+  /* frame.c is going to replace the event mask immediately, but
+   * we still have to set it here to let GDK know what it is.
+   */
+  attrs.event_mask =
+    GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+    GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
+    GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK;
+  attrs.x = x;
+  attrs.y = y;
+  attrs.wclass = GDK_INPUT_OUTPUT;
+  attrs.visual = visual;
+  attrs.colormap = cmap;
+  attrs.window_type = GDK_WINDOW_CHILD;
+  attrs.cursor = NULL;
+  attrs.wmclass_name = NULL;
+  attrs.wmclass_class = NULL;
+  attrs.override_redirect = FALSE;
+
+  attrs.width  = width;
+  attrs.height = height;
+
+  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+  window =
+    gdk_window_new (gdk_screen_get_root_window(screen),
+		    &attrs, attributes_mask);
+
+  gdk_window_resize (window, width, height);
+
+  meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window);
+
+  return GDK_WINDOW_XID (window);
+}
+
+void
+meta_ui_destroy_frame_window (MetaUI *ui,
+			      Window  xwindow)
+{
+  meta_frames_unmanage_window (ui->frames, xwindow);
+}
+
+void
+meta_ui_move_resize_frame (MetaUI *ui,
+			   Window frame,
+			   int x,
+			   int y,
+			   int width,
+			   int height)
+{
+  meta_frames_move_resize_frame (ui->frames, frame, x, y, width, height);
+}
+
+void
+meta_ui_map_frame   (MetaUI *ui,
+                     Window  xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  if (window)
+    gdk_window_show_unraised (window);
+}
+
+void
+meta_ui_unmap_frame (MetaUI *ui,
+                     Window  xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  if (window)
+    gdk_window_hide (window);
+}
+
+void
+meta_ui_unflicker_frame_bg (MetaUI *ui,
+                            Window  xwindow,
+                            int     target_width,
+                            int     target_height)
+{
+  meta_frames_unflicker_bg (ui->frames, xwindow,
+                            target_width, target_height);
+}
+
+void
+meta_ui_repaint_frame (MetaUI *ui,
+                       Window xwindow)
+{
+  meta_frames_repaint_frame (ui->frames, xwindow);
+}
+
+void
+meta_ui_reset_frame_bg (MetaUI *ui,
+                        Window xwindow)
+{
+  meta_frames_reset_bg (ui->frames, xwindow);
+}
+
+void
+meta_ui_apply_frame_shape  (MetaUI  *ui,
+                            Window   xwindow,
+                            int      new_window_width,
+                            int      new_window_height,
+                            gboolean window_has_shape)
+{
+  meta_frames_apply_shapes (ui->frames, xwindow,
+                            new_window_width, new_window_height,
+                            window_has_shape);
+}
+
+void
+meta_ui_queue_frame_draw (MetaUI *ui,
+                          Window xwindow)
+{
+  meta_frames_queue_draw (ui->frames, xwindow);
+}
+
+
+void
+meta_ui_set_frame_title (MetaUI     *ui,
+                         Window      xwindow,
+                         const char *title)
+{
+  meta_frames_set_title (ui->frames, xwindow, title);
+}
+
+MetaWindowMenu*
+meta_ui_window_menu_new  (MetaUI             *ui,
+                          Window              client_xwindow,
+                          MetaMenuOp          ops,
+                          MetaMenuOp          insensitive,
+                          unsigned long       active_workspace,
+                          int                 n_workspaces,
+                          MetaWindowMenuFunc  func,
+                          gpointer            data)
+{
+  return meta_window_menu_new (ui->frames,
+                               ops, insensitive,
+                               client_xwindow,
+                               active_workspace,
+                               n_workspaces,
+                               func, data);
+}
+
+void
+meta_ui_window_menu_popup (MetaWindowMenu     *menu,
+                           int                 root_x,
+                           int                 root_y,
+                           int                 button,
+                           guint32             timestamp)
+{
+  meta_window_menu_popup (menu, root_x, root_y, button, timestamp);
+}
+
+void
+meta_ui_window_menu_free (MetaWindowMenu *menu)
+{
+  meta_window_menu_free (menu);
+}
+
+struct _MetaImageWindow
+{
+  GtkWidget *window;
+  GdkPixmap *pixmap;
+};
+
+MetaImageWindow*
+meta_image_window_new (Display *xdisplay,
+                       int      screen_number,
+                       int      max_width,
+                       int      max_height)
+{
+  MetaImageWindow *iw;
+  GdkDisplay *gdisplay;
+  GdkScreen *gscreen;
+
+  iw = g_new (MetaImageWindow, 1);
+  iw->window = gtk_window_new (GTK_WINDOW_POPUP);
+
+  gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
+  gscreen = gdk_display_get_screen (gdisplay, screen_number);
+
+  gtk_window_set_screen (GTK_WINDOW (iw->window), gscreen);
+
+  gtk_widget_realize (iw->window);
+  iw->pixmap = gdk_pixmap_new (iw->window->window,
+                               max_width, max_height,
+                               -1);
+
+  gtk_widget_set_size_request (iw->window, 1, 1);
+  gtk_widget_set_double_buffered (iw->window, FALSE);
+  gtk_widget_set_app_paintable (iw->window, TRUE);
+
+  return iw;
+}
+
+void
+meta_image_window_free (MetaImageWindow *iw)
+{
+  gtk_widget_destroy (iw->window);
+  g_object_unref (G_OBJECT (iw->pixmap));
+  g_free (iw);
+}
+
+void
+meta_image_window_set_showing  (MetaImageWindow *iw,
+                                gboolean         showing)
+{
+  if (showing)
+    gtk_widget_show_all (iw->window);
+  else
+    {
+      gtk_widget_hide (iw->window);
+      meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+    }
+}
+
+void
+meta_image_window_set (MetaImageWindow *iw,
+                       GdkPixbuf       *pixbuf,
+                       int              x,
+                       int              y)
+{
+  cairo_t *cr;
+
+  /* We use a back pixmap to avoid having to handle exposes, because
+   * it's really too slow for large clients being minimized, etc.
+   * and this way flicker is genuinely zero.
+   */
+
+  gdk_draw_pixbuf (iw->pixmap,
+                   iw->window->style->black_gc,
+		   pixbuf,
+                   0, 0,
+                   0, 0,
+                   gdk_pixbuf_get_width (pixbuf),
+                   gdk_pixbuf_get_height (pixbuf),
+                   GDK_RGB_DITHER_NORMAL,
+                   0, 0);
+  cr = gdk_cairo_create (iw->pixmap);
+  gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+  gdk_window_set_back_pixmap (iw->window->window,
+                              iw->pixmap,
+                              FALSE);
+
+  gdk_window_move_resize (iw->window->window,
+                          x, y,
+                          gdk_pixbuf_get_width (pixbuf),
+                          gdk_pixbuf_get_height (pixbuf));
+
+  gdk_window_clear (iw->window->window);
+}
+
+static GdkColormap*
+get_cmap (GdkPixmap *pixmap)
+{
+  GdkColormap *cmap;
+
+  cmap = gdk_drawable_get_colormap (pixmap);
+  if (cmap)
+    g_object_ref (G_OBJECT (cmap));
+
+  if (cmap == NULL)
+    {
+      if (gdk_drawable_get_depth (pixmap) == 1)
+        {
+          meta_verbose ("Using NULL colormap for snapshotting bitmap\n");
+          cmap = NULL;
+        }
+      else
+        {
+          meta_verbose ("Using system cmap to snapshot pixmap\n");
+          cmap = gdk_screen_get_system_colormap (gdk_drawable_get_screen (pixmap));
+
+          g_object_ref (G_OBJECT (cmap));
+        }
+    }
+
+  /* Be sure we aren't going to blow up due to visual mismatch */
+  if (cmap &&
+      (gdk_colormap_get_visual (cmap)->depth !=
+       gdk_drawable_get_depth (pixmap)))
+    {
+      cmap = NULL;
+      meta_verbose ("Switching back to NULL cmap because of depth mismatch\n");
+    }
+
+  return cmap;
+}
+
+GdkPixbuf*
+meta_gdk_pixbuf_get_from_window (GdkPixbuf   *dest,
+                                 Window       xwindow,
+                                 int          src_x,
+                                 int          src_y,
+                                 int          dest_x,
+                                 int          dest_y,
+                                 int          width,
+                                 int          height)
+{
+  GdkDrawable *drawable;
+  GdkPixbuf *retval;
+  GdkColormap *cmap;
+
+  retval = NULL;
+
+  drawable = gdk_xid_table_lookup (xwindow);
+
+  if (drawable)
+    g_object_ref (G_OBJECT (drawable));
+  else
+    drawable = gdk_window_foreign_new (xwindow);
+
+  cmap = get_cmap (drawable);
+
+  retval = gdk_pixbuf_get_from_drawable (dest,
+                                         drawable,
+                                         cmap,
+                                         src_x, src_y,
+                                         dest_x, dest_y,
+                                         width, height);
+
+  if (cmap)
+    g_object_unref (G_OBJECT (cmap));
+  g_object_unref (G_OBJECT (drawable));
+
+  return retval;
+}
+
+GdkPixbuf*
+meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf   *dest,
+                                 Pixmap       xpixmap,
+                                 int          src_x,
+                                 int          src_y,
+                                 int          dest_x,
+                                 int          dest_y,
+                                 int          width,
+                                 int          height)
+{
+  GdkDrawable *drawable;
+  GdkPixbuf *retval;
+  GdkColormap *cmap;
+
+  retval = NULL;
+  cmap = NULL;
+
+  drawable = gdk_xid_table_lookup (xpixmap);
+
+  if (drawable)
+    g_object_ref (G_OBJECT (drawable));
+  else
+    drawable = gdk_pixmap_foreign_new (xpixmap);
+
+  if (drawable)
+    {
+      cmap = get_cmap (drawable);
+
+      retval = gdk_pixbuf_get_from_drawable (dest,
+                                             drawable,
+                                             cmap,
+                                             src_x, src_y,
+                                             dest_x, dest_y,
+                                             width, height);
+    }
+  if (cmap)
+    g_object_unref (G_OBJECT (cmap));
+  if (drawable)
+    g_object_unref (G_OBJECT (drawable));
+
+  return retval;
+}
+
+void
+meta_ui_push_delay_exposes (MetaUI *ui)
+{
+  meta_frames_push_delay_exposes (ui->frames);
+}
+
+void
+meta_ui_pop_delay_exposes  (MetaUI *ui)
+{
+  meta_frames_pop_delay_exposes (ui->frames);
+}
+
+GdkPixbuf*
+meta_ui_get_default_window_icon (MetaUI *ui)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "gtk-missing-image",
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+
+  g_object_ref (G_OBJECT (default_icon));
+
+  return default_icon;
+}
+
+GdkPixbuf*
+meta_ui_get_default_mini_icon (MetaUI *ui)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "gtk-missing-image",
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+
+  g_object_ref (G_OBJECT (default_icon));
+
+  return default_icon;
+}
+
+gboolean
+meta_ui_window_should_not_cause_focus (Display *xdisplay,
+                                       Window   xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  /* we shouldn't cause focus if we're an override redirect
+   * toplevel which is not foreign
+   */
+  if (window && gdk_window_get_window_type (window) == GDK_WINDOW_TEMP)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+char*
+meta_text_property_to_utf8 (Display             *xdisplay,
+                            const XTextProperty *prop)
+{
+  char **list;
+  int count;
+  char *retval;
+
+  list = NULL;
+
+  count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (prop->encoding),
+                                          prop->format,
+                                          prop->value,
+                                          prop->nitems,
+                                          &list);
+
+  if (count == 0)
+    retval = NULL;
+  else
+    {
+      retval = list[0];
+      list[0] = g_strdup (""); /* something to free */
+    }
+
+  g_strfreev (list);
+
+  return retval;
+}
+
+void
+meta_ui_theme_get_frame_borders (MetaUI *ui,
+                                 MetaFrameType      type,
+                                 MetaFrameFlags     flags,
+                                 int               *top_height,
+                                 int               *bottom_height,
+                                 int               *left_width,
+                                 int               *right_width)
+{
+  int text_height;
+  PangoContext *context;
+  const PangoFontDescription *font_desc;
+  GtkStyle *default_style;
+
+  if (meta_ui_have_a_theme ())
+    {
+      context = gtk_widget_get_pango_context (GTK_WIDGET (ui->frames));
+      font_desc = meta_prefs_get_titlebar_font ();
+
+      if (!font_desc)
+        {
+          default_style = gtk_widget_get_default_style ();
+          font_desc = default_style->font_desc;
+        }
+
+      text_height = meta_pango_font_desc_get_text_height (font_desc, context);
+
+      meta_theme_get_frame_borders (meta_theme_get_current (),
+                                    type, text_height, flags,
+                                    top_height, bottom_height,
+                                    left_width, right_width);
+    }
+  else
+    {
+      *top_height = *bottom_height = *left_width = *right_width = 0;
+    }
+}
+
+void
+meta_ui_set_current_theme (const char *name,
+                           gboolean    force_reload)
+{
+  meta_theme_set_current (name, force_reload);
+  meta_invalidate_default_icons ();
+}
+
+gboolean
+meta_ui_have_a_theme (void)
+{
+  return meta_theme_get_current () != NULL;
+}
+
+static void
+meta_ui_accelerator_parse (const char      *accel,
+                           guint           *keysym,
+                           guint           *keycode,
+                           GdkModifierType *keymask)
+{
+  if (accel[0] == '0' && accel[1] == 'x')
+    {
+      *keysym = 0;
+      *keycode = (guint) strtoul (accel, NULL, 16);
+      *keymask = 0;
+    }
+  else
+    gtk_accelerator_parse (accel, keysym, keymask);
+}
+
+gboolean
+meta_ui_parse_accelerator (const char          *accel,
+                           unsigned int        *keysym,
+                           unsigned int        *keycode,
+                           MetaVirtualModifier *mask)
+{
+  GdkModifierType gdk_mask = 0;
+  guint gdk_sym = 0;
+  guint gdk_code = 0;
+
+  *keysym = 0;
+  *keycode = 0;
+  *mask = 0;
+
+  if (strcmp (accel, "disabled") == 0)
+    return TRUE;
+
+  meta_ui_accelerator_parse (accel, &gdk_sym, &gdk_code, &gdk_mask);
+  if (gdk_mask == 0 && gdk_sym == 0 && gdk_code == 0)
+    return FALSE;
+
+  if (gdk_sym == None && gdk_code == 0)
+    return FALSE;
+
+  if (gdk_mask & GDK_RELEASE_MASK) /* we don't allow this */
+    return FALSE;
+
+  *keysym = gdk_sym;
+  *keycode = gdk_code;
+
+  if (gdk_mask & GDK_SHIFT_MASK)
+    *mask |= META_VIRTUAL_SHIFT_MASK;
+  if (gdk_mask & GDK_CONTROL_MASK)
+    *mask |= META_VIRTUAL_CONTROL_MASK;
+  if (gdk_mask & GDK_MOD1_MASK)
+    *mask |= META_VIRTUAL_ALT_MASK;
+  if (gdk_mask & GDK_MOD2_MASK)
+    *mask |= META_VIRTUAL_MOD2_MASK;
+  if (gdk_mask & GDK_MOD3_MASK)
+    *mask |= META_VIRTUAL_MOD3_MASK;
+  if (gdk_mask & GDK_MOD4_MASK)
+    *mask |= META_VIRTUAL_MOD4_MASK;
+  if (gdk_mask & GDK_MOD5_MASK)
+    *mask |= META_VIRTUAL_MOD5_MASK;
+  if (gdk_mask & GDK_SUPER_MASK)
+    *mask |= META_VIRTUAL_SUPER_MASK;
+  if (gdk_mask & GDK_HYPER_MASK)
+    *mask |= META_VIRTUAL_HYPER_MASK;
+  if (gdk_mask & GDK_META_MASK)
+    *mask |= META_VIRTUAL_META_MASK;
+
+  return TRUE;
+}
+
+/* Caller responsible for freeing return string of meta_ui_accelerator_name! */
+gchar*
+meta_ui_accelerator_name  (unsigned int        keysym,
+                           MetaVirtualModifier mask)
+{
+  GdkModifierType mods = 0;
+
+  if (keysym == 0 && mask == 0)
+    {
+      return g_strdup ("disabled");
+    }
+
+  if (mask & META_VIRTUAL_SHIFT_MASK)
+    mods |= GDK_SHIFT_MASK;
+  if (mask & META_VIRTUAL_CONTROL_MASK)
+    mods |= GDK_CONTROL_MASK;
+  if (mask & META_VIRTUAL_ALT_MASK)
+    mods |= GDK_MOD1_MASK;
+  if (mask & META_VIRTUAL_MOD2_MASK)
+    mods |= GDK_MOD2_MASK;
+  if (mask & META_VIRTUAL_MOD3_MASK)
+    mods |= GDK_MOD3_MASK;
+  if (mask & META_VIRTUAL_MOD4_MASK)
+    mods |= GDK_MOD4_MASK;
+  if (mask & META_VIRTUAL_MOD5_MASK)
+    mods |= GDK_MOD5_MASK;
+  if (mask & META_VIRTUAL_SUPER_MASK)
+    mods |= GDK_SUPER_MASK;
+  if (mask & META_VIRTUAL_HYPER_MASK)
+    mods |= GDK_HYPER_MASK;
+  if (mask & META_VIRTUAL_META_MASK)
+    mods |= GDK_META_MASK;
+
+  return gtk_accelerator_name (keysym, mods);
+
+}
+
+gboolean
+meta_ui_parse_modifier (const char          *accel,
+                        MetaVirtualModifier *mask)
+{
+  GdkModifierType gdk_mask = 0;
+  guint gdk_sym = 0;
+  guint gdk_code = 0;
+
+  *mask = 0;
+
+  if (accel == NULL || strcmp (accel, "disabled") == 0)
+    return TRUE;
+
+  meta_ui_accelerator_parse (accel, &gdk_sym, &gdk_code, &gdk_mask);
+  if (gdk_mask == 0 && gdk_sym == 0 && gdk_code == 0)
+    return FALSE;
+
+  if (gdk_sym != None || gdk_code != 0)
+    return FALSE;
+
+  if (gdk_mask & GDK_RELEASE_MASK) /* we don't allow this */
+    return FALSE;
+
+  if (gdk_mask & GDK_SHIFT_MASK)
+    *mask |= META_VIRTUAL_SHIFT_MASK;
+  if (gdk_mask & GDK_CONTROL_MASK)
+    *mask |= META_VIRTUAL_CONTROL_MASK;
+  if (gdk_mask & GDK_MOD1_MASK)
+    *mask |= META_VIRTUAL_ALT_MASK;
+  if (gdk_mask & GDK_MOD2_MASK)
+    *mask |= META_VIRTUAL_MOD2_MASK;
+  if (gdk_mask & GDK_MOD3_MASK)
+    *mask |= META_VIRTUAL_MOD3_MASK;
+  if (gdk_mask & GDK_MOD4_MASK)
+    *mask |= META_VIRTUAL_MOD4_MASK;
+  if (gdk_mask & GDK_MOD5_MASK)
+    *mask |= META_VIRTUAL_MOD5_MASK;
+  if (gdk_mask & GDK_SUPER_MASK)
+    *mask |= META_VIRTUAL_SUPER_MASK;
+  if (gdk_mask & GDK_HYPER_MASK)
+    *mask |= META_VIRTUAL_HYPER_MASK;
+  if (gdk_mask & GDK_META_MASK)
+    *mask |= META_VIRTUAL_META_MASK;
+
+  return TRUE;
+}
+
+gboolean
+meta_ui_window_is_widget (MetaUI *ui,
+                          Window  xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  if (window)
+    {
+      void *user_data = NULL;
+      gdk_window_get_user_data (window, &user_data);
+      return user_data != NULL && user_data != ui->frames;
+    }
+  else
+    return FALSE;
+}
+
+/* stock icon code Copyright (C) 2002 Jorn Baayen <[email protected]> */
+
+typedef struct {
+	char* stock_id;
+	const guint8* icon_data;
+} MetaStockIcon;
+
+int meta_ui_get_drag_threshold(MetaUI* ui)
+{
+	int threshold = 8;
+	GtkSettings* settings = gtk_widget_get_settings(GTK_WIDGET(ui->frames));
+
+	g_object_get(G_OBJECT(settings), "gtk-dnd-drag-threshold", &threshold, NULL);
+
+	return threshold;
+}
+
+MetaUIDirection meta_ui_get_direction(void)
+{
+	if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL)
+	{
+		return META_UI_DIRECTION_RTL;
+	}
+
+	return META_UI_DIRECTION_LTR;
+}
+
+GdkPixbuf* meta_ui_get_pixbuf_from_pixmap(Pixmap pmap)
+{
+	GdkPixmap* gpmap;
+	GdkScreen* screen;
+	GdkPixbuf* pixbuf;
+	GdkColormap* cmap;
+	int width;
+	int height;
+	int depth;
+
+	gpmap = gdk_pixmap_foreign_new(pmap);
+	screen = gdk_drawable_get_screen(gpmap);
+
+	#if GTK_CHECK_VERSION(3, 0, 0)
+		width = gdk_window_get_width(GDK_WINDOW(gpmap));
+		height = gdk_window_get_height(GDK_WINDOW(gpmap));
+	#else
+		gdk_drawable_get_size(GDK_DRAWABLE(gpmap), &width, &height);
+	#endif
+
+	depth = gdk_drawable_get_depth(GDK_DRAWABLE(gpmap));
+
+	if (depth <= 24)
+	{
+		cmap = gdk_screen_get_system_colormap(screen);
+	}
+	else
+	{
+		cmap = gdk_screen_get_rgba_colormap(screen);
+	}
+
+	pixbuf = gdk_pixbuf_get_from_drawable(NULL, gpmap, cmap, 0, 0, 0, 0, width, height);
+
+	g_object_unref(gpmap);
+
+	return pixbuf;
+}