Deal with property encoding functions

Move everything dealing with compound text to be X11 specific
Only gdk_text_property_to_utf8_list and gdk_utf8_to_string_target
are kept across backends, so add vfuncs for these.

Also, remove the non-multihead-safe variants of all these.

9 files changed, 445 insertions, 536 deletions

diff --git a/gdk/gdk.symbols b/gdk/gdk.symbols
index 15f28c24cd..77db64cb2c 100644
--- a/gdk/gdk.symbols
+++ b/gdk/gdk.symbols
@@ -197,8 +197,6 @@ gdk_event_type_get_type G_GNUC_CONST
 gdk_extension_mode_get_type G_GNUC_CONST
 gdk_filter_return_get_type G_GNUC_CONST
 gdk_flush
-gdk_free_compound_text
-gdk_free_text_list
 gdk_get_default_root_window
 gdk_get_display
 gdk_get_display_arg_name
@@ -323,15 +321,10 @@ gdk_set_show_events
 gdk_setting_action_get_type G_GNUC_CONST
 gdk_setting_get
 gdk_status_get_type G_GNUC_CONST
-gdk_string_to_compound_text
-gdk_string_to_compound_text_for_display
 gdk_synthesize_window_state
 gdk_test_render_sync
 gdk_test_simulate_button
 gdk_test_simulate_key
-gdk_text_property_to_text_list
-gdk_text_property_to_text_list_for_display
-gdk_text_property_to_utf8_list
 gdk_text_property_to_utf8_list_for_display
 gdk_threads_add_idle
 gdk_threads_add_idle_full
@@ -344,8 +337,6 @@ gdk_threads_init
 gdk_threads_leave
 gdk_threads_set_lock_functions
 gdk_unicode_to_keyval G_GNUC_CONST
-gdk_utf8_to_compound_text
-gdk_utf8_to_compound_text_for_display
 gdk_utf8_to_string_target
 gdk_visibility_state_get_type G_GNUC_CONST
 gdk_visual_get_best
@@ -539,7 +530,12 @@ gdk_x11_display_get_xdisplay
 gdk_x11_display_grab
 gdk_x11_display_set_cursor_theme
 gdk_x11_display_set_startup_notification_id
+gdk_x11_display_string_to_compound_text
+gdk_x11_display_text_property_to_text_list
 gdk_x11_display_ungrab
+gdk_x11_display_utf8_to_compound_text
+gdk_x11_free_compound_text
+gdk_x11_free_text_list
 gdk_x11_get_default_root_xwindow
 gdk_x11_get_default_screen
 gdk_x11_get_default_xdisplay
diff --git a/gdk/gdkdisplayprivate.h b/gdk/gdkdisplayprivate.h
index f589581d7e..4885b18a46 100644
--- a/gdk/gdkdisplayprivate.h
+++ b/gdk/gdkdisplayprivate.h
@@ -220,6 +220,15 @@ struct _GdkDisplayClass
                                                         GdkAtom      target,
                                                         guint32      time);
 
+  gint                   (*text_property_to_utf8_list) (GdkDisplay     *display,
+                                                        GdkAtom         encoding,
+                                                        gint            format,
+                                                        const guchar   *text,
+                                                        gint            length,
+                                                        gchar        ***list);
+  gchar *                (*utf8_to_string_target)      (GdkDisplay     *display,
+                                                        const gchar    *text);
+
   /* Signals */
   void (*closed) (GdkDisplay *display,
                   gboolean    is_error);
diff --git a/gdk/gdkproperty.h b/gdk/gdkproperty.h
index 4ea6f8153d..014234e983 100644
--- a/gdk/gdkproperty.h
+++ b/gdk/gdkproperty.h
@@ -54,83 +54,39 @@ typedef enum
 
 
 GdkAtom gdk_atom_intern (const gchar *atom_name,
-			 gboolean     only_if_exists);
+                         gboolean     only_if_exists);
 GdkAtom gdk_atom_intern_static_string (const gchar *atom_name);
 gchar*  gdk_atom_name   (GdkAtom      atom);
 
 
 gboolean gdk_property_get    (GdkWindow     *window,
-			      GdkAtom        property,
-			      GdkAtom        type,
-			      gulong         offset,
-			      gulong         length,
-			      gint           pdelete,
-			      GdkAtom       *actual_property_type,
-			      gint          *actual_format,
-			      gint          *actual_length,
-			      guchar       **data);
+                              GdkAtom        property,
+                              GdkAtom        type,
+                              gulong         offset,
+                              gulong         length,
+                              gint           pdelete,
+                              GdkAtom       *actual_property_type,
+                              gint          *actual_format,
+                              gint          *actual_length,
+                              guchar       **data);
 void     gdk_property_change (GdkWindow     *window,
-			      GdkAtom        property,
-			      GdkAtom        type,
-			      gint           format,
-			      GdkPropMode    mode,
-			      const guchar  *data,
-			      gint           nelements);
+                              GdkAtom        property,
+                              GdkAtom        type,
+                              gint           format,
+                              GdkPropMode    mode,
+                              const guchar  *data,
+                              gint           nelements);
 void     gdk_property_delete (GdkWindow     *window,
-			      GdkAtom        property);
+                              GdkAtom        property);
 
-#ifndef GDK_MULTIHEAD_SAFE
-gint gdk_text_property_to_text_list (GdkAtom        encoding,
-				     gint           format,
-				     const guchar  *text,
-				     gint           length,
-				     gchar       ***list);
-gint gdk_text_property_to_utf8_list (GdkAtom        encoding,
-				     gint           format,
-				     const guchar  *text,
-				     gint           length,
-				     gchar       ***list);
-gboolean gdk_utf8_to_compound_text (const gchar *str,
-				    GdkAtom     *encoding,
-				    gint        *format,
-				    guchar     **ctext,
-				    gint        *length);
-gint gdk_string_to_compound_text    (const gchar   *str,
-				     GdkAtom       *encoding,
-				     gint          *format,
-				     guchar       **ctext,
-				     gint          *length);
-#endif /* GDK_MULTIHEAD_SAFE */
+gint   gdk_text_property_to_utf8_list_for_display (GdkDisplay     *display,
+                                                   GdkAtom         encoding,
+                                                   gint            format,
+                                                   const guchar   *text,
+                                                   gint            length,
+                                                   gchar        ***list);
 
-gint gdk_text_property_to_text_list_for_display (GdkDisplay     *display,
-						 GdkAtom         encoding,
-						 gint            format,
-						 const guchar   *text,
-						 gint            length,
-						 gchar        ***list);
-gint gdk_text_property_to_utf8_list_for_display (GdkDisplay     *display,
-						 GdkAtom         encoding,
-						 gint            format,
-						 const guchar   *text,
-						 gint            length,
-						 gchar        ***list);
-  
-gchar   *gdk_utf8_to_string_target   (const gchar *str);
-gint     gdk_string_to_compound_text_for_display (GdkDisplay   *display,
-						  const gchar  *str,
-						  GdkAtom      *encoding,
-						  gint         *format,
-						  guchar      **ctext,
-						  gint         *length);
-gboolean gdk_utf8_to_compound_text_for_display   (GdkDisplay   *display,
-						  const gchar  *str,
-						  GdkAtom      *encoding,
-						  gint         *format,
-						  guchar      **ctext,
-						  gint         *length);
-
-void gdk_free_text_list             (gchar        **list);
-void gdk_free_compound_text         (guchar        *ctext);
+gchar *gdk_utf8_to_string_target                  (const gchar    *str);
 
 G_END_DECLS
 
diff --git a/gdk/gdkselection.c b/gdk/gdkselection.c
index c50a3f70d3..27adfdf7d5 100644
--- a/gdk/gdkselection.c
+++ b/gdk/gdkselection.c
@@ -138,116 +138,6 @@ gdk_selection_send_notify (GdkNativeWindow requestor,
 }
 
 /**
- * gdk_text_property_to_text_list:
- * @encoding: an atom representing the encoding. The most common
- *   values for this are <literal>STRING</literal>,
- *   or <literal>COMPOUND_TEXT</literal>. This is
- *   value used as the type for the property.
- * @format: the format of the property.
- * @text: the text data.
- * @length: the length of the property, in items.
- * @list: location to store a terminated array of strings
- *   in the encoding of the current locale. This
- *   array should be freed using gdk_free_text_list().
- *
- * Converts a text string from the encoding as it is stored in
- * a property into an array of strings in the encoding of
- * the current local. (The elements of the array represent
- * the nul-separated elements of the original text string.)
- *
- * Returns: the number of strings stored in @list, or 0,
- *   if the conversion failed.
- */
-gint
-gdk_text_property_to_text_list (GdkAtom       encoding,
-				gint          format, 
-				const guchar *text,
-				gint          length,
-				gchar      ***list)
-{
-  return gdk_text_property_to_text_list_for_display (gdk_display_get_default (),
-						     encoding, format, text, length, list);
-}
-
-/**
- * gdk_text_property_to_utf8_list:
- * @encoding: an atom representing the encoding of the text
- * @format:   the format of the property
- * @text:     the text to convert
- * @length:   the length of @text, in bytes
- * @list: (allow-none):     location to store the list of strings or %NULL. The
- *            list should be freed with g_strfreev().
- * 
- * Convert a text property in the giving encoding to
- * a list of UTF-8 strings. 
- * 
- * Return value: the number of strings in the resulting
- *               list.
- **/
-gint 
-gdk_text_property_to_utf8_list (GdkAtom        encoding,
-				gint           format,
-				const guchar  *text,
-				gint           length,
-				gchar       ***list)
-{
-  return gdk_text_property_to_utf8_list_for_display (gdk_display_get_default (),
-						     encoding, format, text, length, list);
-}
-
-/**
- * gdk_string_to_compound_text:
- * @str: a nul-terminated string.
- * @encoding: location to store the encoding atom (to be used as
- *   the type for the property).
- * @format: location to store the format for the property.
- * @ctext: location to store newly allocated data for the property.
- * @length: location to store the length of @ctext in items.
- *
- * Converts a string from the encoding of the current locale
- * into a form suitable for storing in a window property.
- *
- * Returns: 0 upon sucess, non-zero upon failure.
- */
-gint
-gdk_string_to_compound_text (const gchar *str,
-			     GdkAtom     *encoding,
-			     gint        *format,
-			     guchar     **ctext,
-			     gint        *length)
-{
-  return gdk_string_to_compound_text_for_display (gdk_display_get_default (),
-						  str, encoding, format, 
-						  ctext, length);
-}
-
-/**
- * gdk_utf8_to_compound_text:
- * @str:      a UTF-8 string
- * @encoding: location to store resulting encoding
- * @format:   location to store format of the result
- * @ctext:    location to store the data of the result
- * @length:   location to store the length of the data
- *            stored in @ctext
- * 
- * Convert from UTF-8 to compound text. 
- * 
- * Return value: %TRUE if the conversion succeeded, otherwise
- *               false.
- **/
-gboolean
-gdk_utf8_to_compound_text (const gchar *str,
-			   GdkAtom     *encoding,
-			   gint        *format,
-			   guchar     **ctext,
-			   gint        *length)
-{
-  return gdk_utf8_to_compound_text_for_display (gdk_display_get_default (),
-						str, encoding, format, 
-						ctext, length);
-}
-
-/**
  * gdk_selection_owner_set_for_display:
  * @display: the #GdkDisplay
  * @owner: a #GdkWindow or %NULL to indicate that the owner for
@@ -386,3 +276,58 @@ gdk_selection_convert (GdkWindow *requestor,
   GDK_DISPLAY_GET_CLASS (display)
     ->convert_selection (display, requestor, selection, target, time);
 }
+
+/**
+ * gdk_text_property_to_utf8_list_for_display:
+ * @display:  a #GdkDisplay
+ * @encoding: an atom representing the encoding of the text
+ * @format:   the format of the property
+ * @text:     the text to convert
+ * @length:   the length of @text, in bytes
+ * @list:     location to store the list of strings or %NULL. The
+ *            list should be freed with g_strfreev().
+ *
+ * Converts a text property in the given encoding to
+ * a list of UTF-8 strings.
+ *
+ * Return value: the number of strings in the resulting list
+ *
+ * Since: 2.2
+ */
+gint
+gdk_text_property_to_utf8_list_for_display (GdkDisplay     *display,
+                                            GdkAtom         encoding,
+                                            gint            format,
+                                            const guchar   *text,
+                                            gint            length,
+                                            gchar        ***list)
+{
+  g_return_val_if_fail (text != NULL, 0);
+  g_return_val_if_fail (length >= 0, 0);
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
+
+  return GDK_DISPLAY_GET_CLASS (display)
+           ->text_property_to_utf8_list (display, encoding, format, text, length, list);
+}
+
+/**
+ * gdk_utf8_to_string_target:
+ * @str: a UTF-8 string
+ *
+ * Converts an UTF-8 string into the best possible representation
+ * as a STRING. The representation of characters not in STRING
+ * is not specified; it may be as pseudo-escape sequences
+ * \x{ABCD}, or it may be in some other form of approximation.
+ *
+ * Return value: the newly-allocated string, or %NULL if the
+ *               conversion failed. (It should not fail for
+ *               any properly formed UTF-8 string unless system
+ *               limits like memory or file descriptors are exceeded.)
+ **/
+gchar *
+gdk_utf8_to_string_target (const gchar *str)
+{
+  GdkDisplay *display = gdk_display_get_default ();
+
+  return GDK_DISPLAY_GET_CLASS (display)->utf8_to_string_target (display, str);
+}
diff --git a/gdk/x11/gdkdisplay-x11.c b/gdk/x11/gdkdisplay-x11.c
index cbba5aaae1..cdf2b5cc26 100644
--- a/gdk/x11/gdkdisplay-x11.c
+++ b/gdk/x11/gdkdisplay-x11.c
@@ -2765,4 +2765,6 @@ _gdk_display_x11_class_init (GdkDisplayX11Class * class)
   display_class->send_selection_notify = _gdk_x11_display_send_selection_notify;
   display_class->get_selection_property = _gdk_x11_display_get_selection_property;
   display_class->convert_selection = _gdk_x11_display_convert_selection;
+  display_class->text_property_to_utf8_list = _gdk_x11_display_text_property_to_utf8_list;
+  display_class->utf8_to_string_target = _gdk_x11_display_utf8_to_string_target;
 }
diff --git a/gdk/x11/gdkprivate-x11.h b/gdk/x11/gdkprivate-x11.h
index c630c31706..a2f80dc01e 100644
--- a/gdk/x11/gdkprivate-x11.h
+++ b/gdk/x11/gdkprivate-x11.h
@@ -213,6 +213,15 @@ void        _gdk_x11_display_convert_selection      (GdkDisplay     *display,
                                                      GdkAtom         target,
                                                      guint32         time);
 
+gint        _gdk_x11_display_text_property_to_utf8_list (GdkDisplay     *display,
+                                                         GdkAtom         encoding,
+                                                         gint            format,
+                                                         const guchar   *text,
+                                                         gint            length,
+                                                         gchar        ***list);
+gchar *     _gdk_x11_display_utf8_to_string_target      (GdkDisplay     *displayt,
+                                                         const gchar    *str);
+
 void _gdk_x11_device_check_extension_events   (GdkDevice  *device);
 
 GdkDeviceManager *_gdk_x11_device_manager_new (GdkDisplay *display);
diff --git a/gdk/x11/gdkselection-x11.c b/gdk/x11/gdkselection-x11.c
index 4331258cc5..7b89105301 100644
--- a/gdk/x11/gdkselection-x11.c
+++ b/gdk/x11/gdkselection-x11.c
@@ -21,7 +21,7 @@
  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  * file for a list of people on the GTK+ Team.  See the ChangeLog
  * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  */
 
 #include "config.h"
@@ -61,12 +61,12 @@ _gdk_x11_selection_window_destroyed (GdkWindow *window)
     {
       OwnerInfo *info = tmp_list->data;
       tmp_list = tmp_list->next;
-      
+
       if (info->owner == window)
-	{
-	  owner_list = g_slist_remove (owner_list, info);
-	  g_free (info);
-	}
+        {
+          owner_list = g_slist_remove (owner_list, info);
+          g_free (info);
+        }
     }
 }
 
@@ -78,24 +78,24 @@ _gdk_x11_selection_filter_clear_event (XSelectionClearEvent *event)
 {
   GSList *tmp_list = owner_list;
   GdkDisplay *display = gdk_x11_lookup_xdisplay (event->display);
-  
+
   while (tmp_list)
     {
       OwnerInfo *info = tmp_list->data;
 
       if (gdk_window_get_display (info->owner) == display &&
-	  info->selection == gdk_x11_xatom_to_atom_for_display (display, event->selection))
-	{
-	  if ((GDK_WINDOW_XID (info->owner) == event->window &&
-	       event->serial >= info->serial))
-	    {
-	      owner_list = g_slist_remove (owner_list, info);
-	      g_free (info);
-	      return TRUE;
-	    }
-	  else
-	    return FALSE;
-	}
+          info->selection == gdk_x11_xatom_to_atom_for_display (display, event->selection))
+        {
+          if ((GDK_WINDOW_XID (info->owner) == event->window &&
+               event->serial >= info->serial))
+            {
+              owner_list = g_slist_remove (owner_list, info);
+              g_free (info);
+              return TRUE;
+            }
+          else
+            return FALSE;
+        }
       tmp_list = tmp_list->next;
     }
 
@@ -127,24 +127,24 @@ _gdk_x11_display_set_selection_owner (GdkDisplay *display,
       xdisplay = GDK_WINDOW_XDISPLAY (owner);
       xwindow = GDK_WINDOW_XID (owner);
     }
-  else 
+  else
     {
       xdisplay = GDK_DISPLAY_XDISPLAY (display);
       xwindow = None;
     }
-  
+
   xselection = gdk_x11_atom_to_xatom_for_display (display, selection);
 
   tmp_list = owner_list;
   while (tmp_list)
     {
       info = tmp_list->data;
-      if (info->selection == selection) 
-	{
-	  owner_list = g_slist_remove (owner_list, info);
-	  g_free (info);
-	  break;
-	}
+      if (info->selection == selection)
+        {
+          owner_list = g_slist_remove (owner_list, info);
+          g_free (info);
+          break;
+        }
       tmp_list = tmp_list->next;
     }
 
@@ -173,8 +173,8 @@ _gdk_x11_display_get_selection_owner (GdkDisplay *display,
     return NULL;
 
   xwindow = XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display),
-				gdk_x11_atom_to_xatom_for_display (display, 
-								   selection));
+                                gdk_x11_atom_to_xatom_for_display (display,
+                                                                   selection));
   if (xwindow == None)
     return NULL;
 
@@ -232,66 +232,66 @@ _gdk_x11_display_get_selection_property (GdkDisplay  *display,
                           AnyPropertyType, &prop_type, &prop_format,
                           &nitems, &nbytes, &t) != Success)
     goto err;
-    
+
   if (prop_type != None)
     {
       if (ret_type)
-	*ret_type = gdk_x11_xatom_to_atom_for_display (display, prop_type);
+        *ret_type = gdk_x11_xatom_to_atom_for_display (display, prop_type);
       if (ret_format)
-	*ret_format = prop_format;
+        *ret_format = prop_format;
 
       if (prop_type == XA_ATOM ||
-	  prop_type == gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
-	{
-	  Atom* atoms = (Atom*) t;
-	  GdkAtom* atoms_dest;
-	  gint num_atom, i;
-
-	  if (prop_format != 32)
-	    goto err;
-	  
-	  num_atom = nitems;
-	  length = sizeof (GdkAtom) * num_atom + 1;
-
-	  if (data)
-	    {
-	      *data = g_malloc (length);
-	      (*data)[length - 1] = '\0';
-	      atoms_dest = (GdkAtom *)(*data);
-	  
-	      for (i=0; i < num_atom; i++)
-		atoms_dest[i] = gdk_x11_xatom_to_atom_for_display (display, atoms[i]);
-	    }
-	}
+          prop_type == gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
+        {
+          Atom* atoms = (Atom*) t;
+          GdkAtom* atoms_dest;
+          gint num_atom, i;
+
+          if (prop_format != 32)
+            goto err;
+
+          num_atom = nitems;
+          length = sizeof (GdkAtom) * num_atom + 1;
+
+          if (data)
+            {
+              *data = g_malloc (length);
+              (*data)[length - 1] = '\0';
+              atoms_dest = (GdkAtom *)(*data);
+
+              for (i=0; i < num_atom; i++)
+                atoms_dest[i] = gdk_x11_xatom_to_atom_for_display (display, atoms[i]);
+            }
+        }
       else
-	{
-	  switch (prop_format)
-	    {
-	    case 8:
-	      length = nitems;
-	      break;
-	    case 16:
-	      length = sizeof(short) * nitems;
-	      break;
-	    case 32:
-	      length = sizeof(long) * nitems;
-	      break;
-	    default:
-	      g_assert_not_reached ();
-	      break;
-	    }
-	  
-	  /* Add on an extra byte to handle null termination.  X guarantees
-	     that t will be 1 longer than nitems and null terminated */
-	  length += 1;
-
-	  if (data)
-	    *data = g_memdup (t, length);
-	}
-      
+        {
+          switch (prop_format)
+            {
+            case 8:
+              length = nitems;
+              break;
+            case 16:
+              length = sizeof(short) * nitems;
+              break;
+            case 32:
+              length = sizeof(long) * nitems;
+              break;
+            default:
+              g_assert_not_reached ();
+              break;
+            }
+
+          /* Add on an extra byte to handle null termination.  X guarantees
+             that t will be 1 longer than nitems and null terminated */
+          length += 1;
+
+          if (data)
+            *data = g_memdup (t, length);
+        }
+
       if (t)
-	XFree (t);
-      
+        XFree (t);
+
       return length - 1;
     }
 
@@ -302,7 +302,7 @@ _gdk_x11_display_get_selection_property (GdkDisplay  *display,
     *ret_format = 0;
   if (data)
     *data = NULL;
-  
+
   return 0;
 }
 
@@ -332,35 +332,35 @@ _gdk_x11_display_send_selection_notify (GdkDisplay       *display,
 }
 
 /**
- * gdk_text_property_to_text_list_for_display:
- * @display: The #GdkDisplay where the encoding is defined.
- * @encoding: an atom representing the encoding. The most 
- *    common values for this are STRING, or COMPOUND_TEXT. 
- *    This is value used as the type for the property.
- * @format: the format of the property.
- * @text: The text data.
- * @length: The number of items to transform.
- * @list: location to store a terminated array of strings in 
- *    the encoding of the current locale. This array should be 
+ * gdk_x11_display_text_property_to_text_list:
+ * @display: The #GdkDisplay where the encoding is defined
+ * @encoding: an atom representing the encoding. The most
+ *    common values for this are STRING, or COMPOUND_TEXT.
+ *    This is value used as the type for the property
+ * @format: the format of the property
+ * @text: The text data
+ * @length: The number of items to transform
+ * @list: location to store a terminated array of strings in
+ *    the encoding of the current locale. This array should be
  *    freed using gdk_free_text_list().
  *
- * Convert a text string from the encoding as it is stored 
+ * Convert a text string from the encoding as it is stored
  * in a property into an array of strings in the encoding of
  * the current locale. (The elements of the array represent the
  * nul-separated elements of the original text string.)
  *
- * Returns: the number of strings stored in list, or 0, 
- * if the conversion failed. 
+ * Returns: the number of strings stored in list, or 0,
+ *     if the conversion failed
  *
- * Since: 2.2
+ * Since: 3.0
  */
 gint
-gdk_text_property_to_text_list_for_display (GdkDisplay   *display,
-					    GdkAtom       encoding,
-					    gint          format, 
-					    const guchar *text,
-					    gint          length,
-					    gchar      ***list)
+gdk_x11_display_text_property_to_text_list (GdkDisplay   *display,
+                                            GdkAtom       encoding,
+                                            gint          format,
+                                            const guchar *text,
+                                            gint          length,
+                                            gchar      ***list)
 {
   XTextProperty property;
   gint count = 0;
@@ -378,31 +378,31 @@ gdk_text_property_to_text_list_for_display (GdkDisplay   *display,
   property.encoding = gdk_x11_atom_to_xatom_for_display (display, encoding);
   property.format = format;
   property.nitems = length;
-  res = XmbTextPropertyToTextList (GDK_DISPLAY_XDISPLAY (display), &property, 
-				   &local_list, &count);
+  res = XmbTextPropertyToTextList (GDK_DISPLAY_XDISPLAY (display), &property,
+                                   &local_list, &count);
   if (res == XNoMemory || res == XLocaleNotSupported || res == XConverterNotFound)
     return 0;
   else
     {
       if (list)
-	*list = local_list;
+        *list = g_strdupv (local_list);
       else
-	XFreeStringList (local_list);
-      
+        XFreeStringList (local_list);
+
       return count;
     }
 }
 
 /**
- * gdk_free_text_list:
+ * gdk_x11_free_text_list:
  * @list: the value stored in the @list parameter by
- *   a call to gdk_text_property_to_text_list().
+ *   a call to gdk_x11_display_text_property_to_text_list().
  *
  * Frees the array of strings created by
- * gdk_text_property_to_text_list().
+ * gdk_x11_display_text_property_to_text_list().
  */
 void
-gdk_free_text_list (gchar **list)
+gdk_x11_free_text_list (gchar **list)
 {
   g_return_if_fail (list != NULL);
 
@@ -411,9 +411,9 @@ gdk_free_text_list (gchar **list)
 
 static gint
 make_list (const gchar  *text,
-	   gint          length,
-	   gboolean      latin1,
-	   gchar      ***list)
+           gint          length,
+           gboolean      latin1,
+           gchar      ***list)
 {
   GSList *strings = NULL;
   gint n_strings = 0;
@@ -426,40 +426,40 @@ make_list (const gchar  *text,
   while (p < text + length)
     {
       gchar *str;
-      
+
       q = p;
       while (*q && q < text + length)
-	q++;
+        q++;
 
       if (latin1)
-	{
-	  str = g_convert (p, q - p,
-			   "UTF-8", "ISO-8859-1",
-			   NULL, NULL, &error);
-
-	  if (!str)
-	    {
-	      g_warning ("Error converting selection from STRING: %s",
-			 error->message);
-	      g_error_free (error);
-	    }
-	}
+        {
+          str = g_convert (p, q - p,
+                           "UTF-8", "ISO-8859-1",
+                           NULL, NULL, &error);
+
+          if (!str)
+            {
+              g_warning ("Error converting selection from STRING: %s",
+                         error->message);
+              g_error_free (error);
+            }
+        }
       else
-	{
-	  str = g_strndup (p, q - p);
-	  if (!g_utf8_validate (str, -1, NULL))
-	    {
-	      g_warning ("Error converting selection from UTF8_STRING");
-	      g_free (str);
-	      str = NULL;
-	    }
-	}
+        {
+          str = g_strndup (p, q - p);
+          if (!g_utf8_validate (str, -1, NULL))
+            {
+              g_warning ("Error converting selection from UTF8_STRING");
+              g_free (str);
+              str = NULL;
+            }
+        }
 
       if (str)
-	{
-	  strings = g_slist_prepend (strings, str);
-	  n_strings++;
-	}
+        {
+          strings = g_slist_prepend (strings, str);
+          n_strings++;
+        }
 
       p = q + 1;
     }
@@ -469,54 +469,32 @@ make_list (const gchar  *text,
       *list = g_new (gchar *, n_strings + 1);
       (*list)[n_strings] = NULL;
     }
-     
+
   i = n_strings;
   tmp_list = strings;
   while (tmp_list)
     {
       if (list)
-	(*list)[--i] = tmp_list->data;
+        (*list)[--i] = tmp_list->data;
       else
-	g_free (tmp_list->data);
-      
+        g_free (tmp_list->data);
+
       tmp_list = tmp_list->next;
     }
-  
+
   g_slist_free (strings);
 
   return n_strings;
 }
 
-/**
- * gdk_text_property_to_utf8_list_for_display:
- * @display:  a #GdkDisplay
- * @encoding: an atom representing the encoding of the text
- * @format:   the format of the property
- * @text:     the text to convert
- * @length:   the length of @text, in bytes
- * @list:     location to store the list of strings or %NULL. The
- *            list should be freed with g_strfreev().
- * 
- * Converts a text property in the given encoding to
- * a list of UTF-8 strings. 
- * 
- * Return value: the number of strings in the resulting
- *               list.
- *
- * Since: 2.2
- **/
-gint 
-gdk_text_property_to_utf8_list_for_display (GdkDisplay    *display,
-					    GdkAtom        encoding,
-					    gint           format,
-					    const guchar  *text,
-					    gint           length,
-					    gchar       ***list)
+gint
+_gdk_x11_display_text_property_to_utf8_list (GdkDisplay    *display,
+                                             GdkAtom        encoding,
+                                             gint           format,
+                                             const guchar  *text,
+                                             gint           length,
+                                             gchar       ***list)
 {
-  g_return_val_if_fail (text != NULL, 0);
-  g_return_val_if_fail (length >= 0, 0);
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
-  
   if (encoding == GDK_TARGET_STRING)
     {
       return make_list ((gchar *)text, length, TRUE, list);
@@ -534,88 +512,88 @@ gdk_text_property_to_utf8_list_for_display (GdkDisplay    *display,
       gboolean need_conversion = !g_get_charset (&charset);
       gint count = 0;
       GError *error = NULL;
-      
+
       /* Probably COMPOUND text, we fall back to Xlib routines
        */
-      local_count = gdk_text_property_to_text_list_for_display (display,
-								encoding,
-								format, 
-								text,
-								length,
-								&local_list);
+      local_count = gdk_x11_display_text_property_to_text_list (display,
+                                                                encoding,
+                                                                format,
+                                                                text,
+                                                                length,
+                                                                &local_list);
       if (list)
-	*list = g_new (gchar *, local_count + 1);
-      
+        *list = g_new (gchar *, local_count + 1);
+
       for (i=0; i<local_count; i++)
-	{
-	  /* list contains stuff in our default encoding
-	   */
-	  if (need_conversion)
-	    {
-	      gchar *utf = g_convert (local_list[i], -1,
-				      "UTF-8", charset,
-				      NULL, NULL, &error);
-	      if (utf)
-		{
-		  if (list)
-		    (*list)[count++] = utf;
-		  else
-		    g_free (utf);
-		}
-	      else
-		{
-		  g_warning ("Error converting to UTF-8 from '%s': %s",
-			     charset, error->message);
-		  g_error_free (error);
-		  error = NULL;
-		}
-	    }
-	  else
-	    {
-	      if (list)
-		{
-		  if (g_utf8_validate (local_list[i], -1, NULL))
-		    (*list)[count++] = g_strdup (local_list[i]);
-		  else
-		    g_warning ("Error converting selection");
-		}
-	    }
-	}
+        {
+          /* list contains stuff in our default encoding
+           */
+          if (need_conversion)
+            {
+              gchar *utf = g_convert (local_list[i], -1,
+                                      "UTF-8", charset,
+                                      NULL, NULL, &error);
+              if (utf)
+                {
+                  if (list)
+                    (*list)[count++] = utf;
+                  else
+                    g_free (utf);
+                }
+              else
+                {
+                  g_warning ("Error converting to UTF-8 from '%s': %s",
+                             charset, error->message);
+                  g_error_free (error);
+                  error = NULL;
+                }
+            }
+          else
+            {
+              if (list)
+                {
+                  if (g_utf8_validate (local_list[i], -1, NULL))
+                    (*list)[count++] = g_strdup (local_list[i]);
+                  else
+                    g_warning ("Error converting selection");
+                }
+            }
+        }
 
       if (local_count)
-	gdk_free_text_list (local_list);
-      
+        gdk_x11_free_text_list (local_list);
+
       if (list)
-	(*list)[count] = NULL;
+        (*list)[count] = NULL;
 
       return count;
     }
 }
 
 /**
- * gdk_string_to_compound_text_for_display:
- * @display:  the #GdkDisplay where the encoding is defined.
- * @str:      a nul-terminated string.
- * @encoding: location to store the encoding atom 
- *	      (to be used as the type for the property).
- * @format:   location to store the format of the property
- * @ctext:    location to store newly allocated data for the property.
- * @length:   the length of @text, in bytes
- * 
- * Convert a string from the encoding of the current 
+ * gdk_x11_display_string_to_compound_text:
+ * @display: the #GdkDisplay where the encoding is defined
+ * @str: a nul-terminated string
+ * @encoding: location to store the encoding atom
+ *     (to be used as the type for the property)
+ * @format: location to store the format of the property
+ * @ctext: location to store newly allocated data for the property
+ * @length: the length of @text, in bytes
+ *
+ * Convert a string from the encoding of the current
  * locale into a form suitable for storing in a window property.
- * 
- * Returns: 0 upon success, non-zero upon failure. 
  *
- * Since: 2.2
- **/
+ * Returns: 0 upon success, non-zero upon failure
+ *
+ * Since: 3.0
+ */
 gint
-gdk_string_to_compound_text_for_display (GdkDisplay  *display,
-					 const gchar *str,
-					 GdkAtom     *encoding,
-					 gint        *format,
-					 guchar     **ctext,
-					 gint        *length)
+gdk_x11_display_string_to_compound_text (GdkDisplay  *display,
+                                         const gchar *str,
+                                         GdkAtom     *encoding,
+                                         gint        *format,
+                                         guchar     **ctext,
+                                         gint        *length)
 {
   gint res;
   XTextProperty property;
@@ -625,9 +603,9 @@ gdk_string_to_compound_text_for_display (GdkDisplay  *display,
   if (gdk_display_is_closed (display))
     res = XLocaleNotSupported;
   else
-    res = XmbTextListToTextProperty (GDK_DISPLAY_XDISPLAY (display), 
-				     (char **)&str, 1, XCompoundTextStyle,
-				     &property);
+    res = XmbTextListToTextProperty (GDK_DISPLAY_XDISPLAY (display),
+                                     (char **)&str, 1, XCompoundTextStyle,
+                                     &property);
   if (res != Success)
     {
       property.encoding = None;
@@ -655,9 +633,9 @@ gdk_string_to_compound_text_for_display (GdkDisplay  *display,
  * This routine strips out all non-allowed C0 and C1 characters
  * from the input string and also canonicalizes \r, and \r\n to \n
  */
-static gchar * 
+static gchar *
 sanitize_utf8 (const gchar *src,
-	       gboolean return_latin1)
+               gboolean return_latin1)
 {
   gint len = strlen (src);
   GString *result = g_string_sized_new (len);
@@ -666,89 +644,76 @@ sanitize_utf8 (const gchar *src,
   while (*p)
     {
       if (*p == '\r')
-	{
-	  p++;
-	  if (*p == '\n')
-	    p++;
+        {
+          p++;
+          if (*p == '\n')
+            p++;
 
-	  g_string_append_c (result, '\n');
-	}
+          g_string_append_c (result, '\n');
+        }
       else
-	{
-	  gunichar ch = g_utf8_get_char (p);
-	  
-	  if (!((ch < 0x20 && ch != '\t' && ch != '\n') || (ch >= 0x7f && ch < 0xa0)))
-	    {
-	      if (return_latin1)
-		{
-		  if (ch <= 0xff)
-		    g_string_append_c (result, ch);
-		  else
-		    g_string_append_printf (result,
-					    ch < 0x10000 ? "\\u%04x" : "\\U%08x",
-					    ch);
-		}
-	      else
-		{
-		  char buf[7];
-		  gint buflen;
-		  
-		  buflen = g_unichar_to_utf8 (ch, buf);
-		  g_string_append_len (result, buf, buflen);
-		}
-	    }
-
-	  p = g_utf8_next_char (p);
-	}
+        {
+          gunichar ch = g_utf8_get_char (p);
+
+          if (!((ch < 0x20 && ch != '\t' && ch != '\n') || (ch >= 0x7f && ch < 0xa0)))
+            {
+              if (return_latin1)
+                {
+                  if (ch <= 0xff)
+                    g_string_append_c (result, ch);
+                  else
+                    g_string_append_printf (result,
+                                            ch < 0x10000 ? "\\u%04x" : "\\U%08x",
+                                            ch);
+                }
+              else
+                {
+                  char buf[7];
+                  gint buflen;
+
+                  buflen = g_unichar_to_utf8 (ch, buf);
+                  g_string_append_len (result, buf, buflen);
+                }
+            }
+
+          p = g_utf8_next_char (p);
+        }
     }
 
   return g_string_free (result, FALSE);
 }
 
-/**
- * gdk_utf8_to_string_target:
- * @str: a UTF-8 string
- * 
- * Converts an UTF-8 string into the best possible representation
- * as a STRING. The representation of characters not in STRING
- * is not specified; it may be as pseudo-escape sequences
- * \x{ABCD}, or it may be in some other form of approximation.
- * 
- * Return value: the newly-allocated string, or %NULL if the
- *               conversion failed. (It should not fail for
- *               any properly formed UTF-8 string unless system
- *               limits like memory or file descriptors are exceeded.)
- **/
 gchar *
-gdk_utf8_to_string_target (const gchar *str)
+_gdk_x11_display_utf8_to_string_target (GdkDisplay  *display,
+                                        const gchar *str)
 {
   return sanitize_utf8 (str, TRUE);
 }
 
 /**
- * gdk_utf8_to_compound_text_for_display:
- * @display:  a #GdkDisplay
- * @str:      a UTF-8 string
+ * gdk_x11_display_utf8_to_compound_text:
+ * @display: a #GdkDisplay
+ * @str: a UTF-8 string
  * @encoding: location to store resulting encoding
- * @format:   location to store format of the result
- * @ctext:    location to store the data of the result
- * @length:   location to store the length of the data
- *            stored in @ctext
- * 
- * Converts from UTF-8 to compound text. 
- * 
- * Return value: %TRUE if the conversion succeeded, otherwise
- *               %FALSE.
+ * @format: location to store format of the result
+ * @ctext: location to store the data of the result
+ * @length: location to store the length of the data
+ *     stored in @ctext
+ *
+ * Converts from UTF-8 to compound text.
  *
- * Since: 2.2
- **/
+ * Return value: %TRUE if the conversion succeeded,
+ *     otherwise %FALSE
+ *
+ * Since: 3.0
+ */
 gboolean
-gdk_utf8_to_compound_text_for_display (GdkDisplay  *display,
-				       const gchar *str,
-				       GdkAtom     *encoding,
-				       gint        *format,
-				       guchar     **ctext,
-				       gint        *length)
+gdk_x11_display_utf8_to_compound_text (GdkDisplay  *display,
+                                       const gchar *str,
+                                       GdkAtom     *encoding,
+                                       gint        *format,
+                                       guchar     **ctext,
+                                       gint        *length)
 {
   gboolean need_conversion;
   const gchar *charset;
@@ -766,53 +731,56 @@ gdk_utf8_to_compound_text_for_display (GdkDisplay  *display,
   if (need_conversion)
     {
       locale_str = g_convert (tmp_str, -1,
-			      charset, "UTF-8",
-			      NULL, NULL, &error);
+                              charset, "UTF-8",
+                              NULL, NULL, &error);
       g_free (tmp_str);
 
       if (!locale_str)
-	{
-	  if (!(error->domain = G_CONVERT_ERROR &&
-		error->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
-	    {
-	      g_warning ("Error converting from UTF-8 to '%s': %s",
-			 charset, error->message);
-	    }
-	  g_error_free (error);
-
-	  if (encoding)
-	    *encoding = None;
-	  if (format)
-	    *format = None;
-	  if (ctext)
-	    *ctext = NULL;
-	  if (length)
-	    *length = 0;
-
-	  return FALSE;
-	}
+        {
+          if (!(error->domain = G_CONVERT_ERROR &&
+                error->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
+            {
+              g_warning ("Error converting from UTF-8 to '%s': %s",
+                         charset, error->message);
+            }
+          g_error_free (error);
+
+          if (encoding)
+            *encoding = None;
+          if (format)
+            *format = None;
+          if (ctext)
+            *ctext = NULL;
+          if (length)
+            *length = 0;
+
+          return FALSE;
+        }
     }
   else
     locale_str = tmp_str;
-    
-  result = gdk_string_to_compound_text_for_display (display, locale_str,
-						    encoding, format, 
-						    ctext, length);
+
+  result = gdk_x11_display_string_to_compound_text (display, locale_str,
+                                                    encoding, format,
+                                                    ctext, length);
   result = (result == Success? TRUE : FALSE);
-  
+
   g_free (locale_str);
 
   return result;
 }
 
 /**
- * gdk_free_compound_text:
+ * gdk_x11_free_compound_text:
  * @ctext: The pointer stored in @ctext from a call to
- *   gdk_string_to_compound_text().
+ *   gdk_x11_display_string_to_compound_text().
  *
- * Frees the data returned from gdk_string_to_compound_text().
+ * Frees the data returned from gdk_x11_display_string_to_compound_text().
+ *
+ * Since: 3.0
  */
-void gdk_free_compound_text (guchar *ctext)
+void
+gdk_x11_free_compound_text (guchar *ctext)
 {
   if (ctext)
     XFree (ctext);
diff --git a/gdk/x11/gdkwindow-x11.c b/gdk/x11/gdkwindow-x11.c
index b9d59fed0b..0c29ab90f8 100644
--- a/gdk/x11/gdkwindow-x11.c
+++ b/gdk/x11/gdkwindow-x11.c
@@ -2231,10 +2231,10 @@ set_text_property (GdkDisplay  *display,
   else
     {
       GdkAtom gdk_type;
-      
-      gdk_utf8_to_compound_text_for_display (display,
-					     utf8_str, &gdk_type, &prop_format,
-					     (guchar **)&prop_text, &prop_length);
+
+      gdk_x11_display_utf8_to_compound_text (display,
+                                             utf8_str, &gdk_type, &prop_format,
+                                             (guchar **)&prop_text, &prop_length);
       prop_type = gdk_x11_atom_to_xatom_for_display (display, gdk_type);
       is_compound_text = TRUE;
     }
@@ -2249,7 +2249,7 @@ set_text_property (GdkDisplay  *display,
 		       prop_length);
 
       if (is_compound_text)
-	gdk_free_compound_text ((guchar *)prop_text);
+	gdk_x11_free_compound_text ((guchar *)prop_text);
       else
 	g_free (prop_text);
     }
diff --git a/gdk/x11/gdkx.h b/gdk/x11/gdkx.h
index 1801b63f22..f9e24be8c9 100644
--- a/gdk/x11/gdkx.h
+++ b/gdk/x11/gdkx.h
@@ -231,6 +231,30 @@ GdkWindow  *gdk_x11_window_foreign_new_for_display (GdkDisplay *display,
 GdkWindow  *gdk_x11_window_lookup_for_display      (GdkDisplay *display,
                                                     Window      window);
 
+gint     gdk_x11_display_text_property_to_text_list (GdkDisplay   *display,
+                                                     GdkAtom       encoding,
+                                                     gint          format,
+                                                     const guchar *text,
+                                                     gint          length,
+                                                     gchar      ***list);
+void     gdk_x11_free_text_list                     (gchar       **list);
+gint     gdk_x11_display_string_to_compound_text    (GdkDisplay   *display,
+                                                     const gchar  *str,
+                                                     GdkAtom      *encoding,
+                                                     gint         *format,
+                                                     guchar      **ctext,
+                                                     gint         *length);
+gboolean gdk_x11_display_utf8_to_compound_text      (GdkDisplay   *display,
+                                                     const gchar  *str,
+                                                     GdkAtom      *encoding,
+                                                     gint         *format,
+                                                     guchar      **ctext,
+                                                     gint         *length);
+void     gdk_x11_free_compound_text                 (guchar       *ctext);
+
+
+
+
 G_END_DECLS
 
 #endif /* __GDK_X_H__ */