/* GDK - The GIMP Drawing Kit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see . */ /* * 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/. */ #include "config.h" #include "gdkprivate-x11.h" #include "gdkdisplay-x11.h" #include #include #include /** * gdk_x11_display_text_property_to_text_list: * @display: (type GdkX11Display): The #GdkDisplay where the encoding is defined * @encoding: a string 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 an array of strings in * the encoding of the current locale. This array should be * freed using gdk_x11_free_text_list(). * * 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 */ int gdk_x11_display_text_property_to_text_list (GdkDisplay *display, const char *encoding, int format, const guchar *text, int length, char ***list) { XTextProperty property; int count = 0; int res; char **local_list; g_return_val_if_fail (GDK_IS_DISPLAY (display), 0); if (list) *list = NULL; if (gdk_display_is_closed (display)) return 0; property.value = (guchar *)text; property.encoding = gdk_x11_get_xatom_by_name_for_display (display, encoding); property.format = format; property.nitems = length; 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; else XFreeStringList (local_list); return count; } } /** * gdk_x11_free_text_list: * @list: the value stored in the @list parameter by * a call to gdk_x11_display_text_property_to_text_list(). * * Frees the array of strings created by * gdk_x11_display_text_property_to_text_list(). */ void gdk_x11_free_text_list (char **list) { g_return_if_fail (list != NULL); XFreeStringList (list); } static int make_list (const char *text, int length, gboolean latin1, char ***list) { GSList *strings = NULL; int n_strings = 0; int i; const char *p = text; const char *q; GSList *tmp_list; GError *error = NULL; while (p < text + length) { char *str; q = p; while (*q && q < text + length) 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); } } 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; } } if (str) { strings = g_slist_prepend (strings, str); n_strings++; } p = q + 1; } if (list) { *list = g_new (char *, n_strings + 1); (*list)[n_strings] = NULL; } i = n_strings; tmp_list = strings; while (tmp_list) { if (list) (*list)[--i] = tmp_list->data; else g_free (tmp_list->data); tmp_list = tmp_list->next; } g_slist_free (strings); return n_strings; } int _gdk_x11_display_text_property_to_utf8_list (GdkDisplay *display, const char *encoding, int format, const guchar *text, int length, char ***list) { if (g_str_equal (encoding, "STRING")) { return make_list ((char *)text, length, TRUE, list); } else if (g_str_equal (encoding, "UTF8_STRING")) { return make_list ((char *)text, length, FALSE, list); } else { char **local_list; int local_count; int i; const char *charset = NULL; gboolean need_conversion = !g_get_charset (&charset); int count = 0; GError *error = NULL; /* Probably COMPOUND text, we fall back to Xlib routines */ local_count = gdk_x11_display_text_property_to_text_list (display, encoding, format, text, length, &local_list); if (list) *list = g_new (char *, local_count + 1); for (i=0; imessage); 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_x11_free_text_list (local_list); if (list) (*list)[count] = NULL; return count; } } /** * gdk_x11_display_string_to_compound_text: * @display: (type GdkX11Display): the #GdkDisplay where the encoding is defined * @str: a nul-terminated string * @encoding: (out) (transfer none): location to store the encoding * (to be used as the type for the property) * @format: (out): location to store the format of the property * @ctext: (out) (array length=length): location to store newly * allocated data for the property * @length: the length of @ctext, 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 */ int gdk_x11_display_string_to_compound_text (GdkDisplay *display, const char *str, const char **encoding, int *format, guchar **ctext, int *length) { int res; XTextProperty property; g_return_val_if_fail (GDK_IS_DISPLAY (display), 0); if (gdk_display_is_closed (display)) res = XLocaleNotSupported; else res = XmbTextListToTextProperty (GDK_DISPLAY_XDISPLAY (display), (char **)&str, 1, XCompoundTextStyle, &property); if (res != Success) { property.encoding = None; property.format = None; property.value = NULL; property.nitems = 0; } if (encoding) *encoding = gdk_x11_get_xatom_name_for_display (display, property.encoding); if (format) *format = property.format; if (ctext) *ctext = property.value; if (length) *length = property.nitems; return res; } /** * gdk_x11_display_utf8_to_compound_text: * @display: (type GdkX11Display): a #GdkDisplay * @str: a UTF-8 string * @encoding: (out) (transfer none): location to store resulting encoding * @format: (out): location to store format of the result * @ctext: (out) (array length=length): 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. * * Returns: %TRUE if the conversion succeeded, * otherwise %FALSE */ gboolean gdk_x11_display_utf8_to_compound_text (GdkDisplay *display, const char *str, const char **encoding, int *format, guchar **ctext, int *length) { gboolean need_conversion; const char *charset; char *locale_str, *tmp_str; GError *error = NULL; gboolean result; g_return_val_if_fail (str != NULL, FALSE); g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); need_conversion = !g_get_charset (&charset); tmp_str = gdk_x11_utf8_to_string_target (str, FALSE); if (need_conversion) { locale_str = g_convert (tmp_str, -1, charset, "UTF-8", NULL, NULL, &error); g_free (tmp_str); if (!locale_str) { if (!g_error_matches (error, G_CONVERT_ERROR, 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 = NULL; if (format) *format = None; if (ctext) *ctext = NULL; if (length) *length = 0; return FALSE; } } else locale_str = tmp_str; 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_x11_free_compound_text: * @ctext: The pointer stored in @ctext from a call to * gdk_x11_display_string_to_compound_text(). * * Frees the data returned from gdk_x11_display_string_to_compound_text(). */ void gdk_x11_free_compound_text (guchar *ctext) { if (ctext) XFree (ctext); }