glib/gio/gicon.c
Ryan Lortie b941139254 free the tokens when done with them
2008-12-12  Ryan Lortie  <desrt@desrt.ca>

        * gio/gicon.c (g_icon_to_string_tokenized): free the tokens when done
        with them


svn path=/trunk/; revision=7743
2008-12-12 20:59:54 +00:00

495 lines
12 KiB
C

/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2006-2007 Red Hat, Inc.
*
* 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, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Author: Alexander Larsson <alexl@redhat.com>
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include "gicon.h"
#include "gthemedicon.h"
#include "gfileicon.h"
#include "gemblemedicon.h"
#include "gfile.h"
#include "gioerror.h"
#include "glibintl.h"
#include "gioalias.h"
/* There versioning of this is implicit, version 1 would be ".1 " */
#define G_ICON_SERIALIZATION_MAGIC0 ". "
/**
* SECTION:gicon
* @short_description: Interface for icons
* @include: gio/gio.h
*
* #GIcon is a very minimal interface for icons. It provides functions
* for checking the equality of two icons, hashing of icons and
* serializing an icon to and from strings.
*
* #GIcon does not provide the actual pixmap for the icon as this is out
* of GIO's scope, however implementations of #GIcon may contain the name
* of an icon (see #GThemedIcon), or the path to an icon (see #GLoadableIcon).
*
* To obtain a hash of a #GIcon, see g_icon_hash().
*
* To check if two #GIcons are equal, see g_icon_equal().
*
* For serializing a #GIcon, use g_icon_to_string() and
* g_icon_new_for_string().
*
* If your application or library provides one or more #GIcon
* implementations you need to ensure that each #GType is registered
* with the type system prior to calling g_icon_new_for_string().
**/
static void g_icon_base_init (gpointer g_class);
static void g_icon_class_init (gpointer g_class,
gpointer class_data);
GType
g_icon_get_type (void)
{
static volatile gsize g_define_type_id__volatile = 0;
if (g_once_init_enter (&g_define_type_id__volatile))
{
const GTypeInfo icon_info =
{
sizeof (GIconIface), /* class_size */
g_icon_base_init, /* base_init */
NULL, /* base_finalize */
g_icon_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
0,
0, /* n_preallocs */
NULL
};
GType g_define_type_id =
g_type_register_static (G_TYPE_INTERFACE, I_("GIcon"),
&icon_info, 0);
g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
}
return g_define_type_id__volatile;
}
static void
g_icon_class_init (gpointer g_class,
gpointer class_data)
{
}
static void
g_icon_base_init (gpointer g_class)
{
}
/**
* g_icon_hash:
* @icon: #gconstpointer to an icon object.
*
* Gets a hash for an icon.
*
* Returns: a #guint containing a hash for the @icon, suitable for
* use in a #GHashTable or similar data structure.
**/
guint
g_icon_hash (gconstpointer icon)
{
GIconIface *iface;
g_return_val_if_fail (G_IS_ICON (icon), 0);
iface = G_ICON_GET_IFACE (icon);
return (* iface->hash) ((GIcon *)icon);
}
/**
* g_icon_equal:
* @icon1: pointer to the first #GIcon.
* @icon2: pointer to the second #GIcon.
*
* Checks if two icons are equal.
*
* Returns: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
**/
gboolean
g_icon_equal (GIcon *icon1,
GIcon *icon2)
{
GIconIface *iface;
if (icon1 == NULL && icon2 == NULL)
return TRUE;
if (icon1 == NULL || icon2 == NULL)
return FALSE;
if (G_TYPE_FROM_INSTANCE (icon1) != G_TYPE_FROM_INSTANCE (icon2))
return FALSE;
iface = G_ICON_GET_IFACE (icon1);
return (* iface->equal) (icon1, icon2);
}
static gboolean
g_icon_to_string_tokenized (GIcon *icon, GString *s)
{
char *ret;
GPtrArray *tokens;
gint version;
GIconIface *icon_iface;
int i;
g_return_val_if_fail (icon != NULL, FALSE);
g_return_val_if_fail (G_IS_ICON (icon), FALSE);
ret = NULL;
icon_iface = G_ICON_GET_IFACE (icon);
if (icon_iface->to_tokens == NULL)
return FALSE;
tokens = g_ptr_array_new ();
if (!icon_iface->to_tokens (icon, tokens, &version))
{
g_ptr_array_free (tokens, TRUE);
return FALSE;
}
/* format: TypeName[.Version] <token_0> .. <token_N-1>
version 0 is implicit and can be omitted
all the tokens are url escaped to ensure they have no spaces in them */
g_string_append (s, g_type_name_from_instance ((GTypeInstance *)icon));
if (version != 0)
g_string_append_printf (s, ".%d", version);
for (i = 0; i < tokens->len; i++)
{
char *token;
token = g_ptr_array_index (tokens, i);
g_string_append_c (s, ' ');
/* We really only need to escape spaces here, so allow lots of otherwise reserved chars */
g_string_append_uri_escaped (s, token,
G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE);
g_free (token);
}
g_ptr_array_free (tokens, TRUE);
return TRUE;
}
/**
* g_icon_to_string:
* @icon: a #GIcon.
*
* Generates a textual representation of @icon that can be used for
* serialization such as when passing @icon to a different process or
* saving it to persistent storage. Use g_icon_new_for_string() to
* get @icon back from the returned string.
*
* The encoding of the returned string is proprietary to #GIcon except
* in the following two cases
*
* <itemizedlist>
* <listitem><para>
* If @icon is a #GFileIcon, the returned string is a native path
* (such as <literal>/path/to/my icon.png</literal>) without escaping
* if the #GFile for @icon is a native file. If the file is not
* native, the returned string is the result of g_file_get_uri()
* (such as <literal>sftp://path/to/my%%20icon.png</literal>).
* </para></listitem>
* <listitem><para>
* If @icon is a #GThemedIcon with exactly one name, the encoding is
* simply the name (such as <literal>network-server</literal>).
* </para></listitem>
* </itemizedlist>
*
* Returns: An allocated NUL-terminated UTF8 string or %NULL if @icon can't
* be serialized. Use g_free() to free.
*
* Since: 2.20
*/
gchar *
g_icon_to_string (GIcon *icon)
{
gchar *ret;
g_return_val_if_fail (icon != NULL, NULL);
g_return_val_if_fail (G_IS_ICON (icon), NULL);
ret = NULL;
if (G_IS_FILE_ICON (icon))
{
GFile *file;
file = g_file_icon_get_file (G_FILE_ICON (icon));
if (g_file_is_native (file))
{
ret = g_file_get_path (file);
if (!g_utf8_validate (ret, -1, NULL))
{
g_free (ret);
ret = NULL;
}
}
else
ret = g_file_get_uri (file);
}
else if (G_IS_THEMED_ICON (icon))
{
const char * const *names;
names = g_themed_icon_get_names (G_THEMED_ICON (icon));
if (names != NULL &&
names[0] != NULL &&
names[0][0] != '.' && /* Allowing icons starting with dot would break G_ICON_SERIALIZATION_MAGIC0 */
g_utf8_validate (names[0], -1, NULL) && /* Only return utf8 strings */
names[1] == NULL)
ret = g_strdup (names[0]);
}
if (ret == NULL)
{
GString *s;
s = g_string_new (G_ICON_SERIALIZATION_MAGIC0);
if (g_icon_to_string_tokenized (icon, s))
ret = g_string_free (s, FALSE);
else
g_string_free (s, TRUE);
}
return ret;
}
static GIcon *
g_icon_new_from_tokens (char **tokens,
GError **error)
{
GIcon *icon;
char *typename, *version_str;
GType type;
gpointer klass;
GIconIface *icon_iface;
gint version;
char *endp;
int num_tokens;
int i;
icon = NULL;
klass = NULL;
num_tokens = g_strv_length (tokens);
if (num_tokens < 1)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Wrong number of tokens (%d)"),
num_tokens);
goto out;
}
typename = tokens[0];
version_str = strchr (typename, '.');
if (version_str)
{
*version_str = 0;
version_str += 1;
}
type = g_type_from_name (tokens[0]);
if (type == 0)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("No type for class name %s"),
tokens[0]);
goto out;
}
if (!g_type_is_a (type, G_TYPE_ICON))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Type %s does not implement the GIcon interface"),
tokens[0]);
goto out;
}
klass = g_type_class_ref (type);
if (klass == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Type %s is not classed"),
tokens[0]);
goto out;
}
version = 0;
if (version_str)
{
version = strtol (version_str, &endp, 10);
if (endp == NULL || *endp != '\0')
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Malformed version number: %s"),
version_str);
goto out;
}
}
icon_iface = g_type_interface_peek (klass, G_TYPE_ICON);
g_assert (icon_iface != NULL);
if (icon_iface->from_tokens == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Type %s does not implement from_tokens() on the GIcon interface"),
tokens[0]);
goto out;
}
for (i = 1; i < num_tokens; i++)
{
char *escaped;
escaped = tokens[i];
tokens[i] = g_uri_unescape_string (escaped, NULL);
g_free (escaped);
}
icon = icon_iface->from_tokens (tokens + 1, num_tokens - 1, version, error);
out:
if (klass != NULL)
g_type_class_unref (klass);
return icon;
}
static void
ensure_builtin_icon_types (void)
{
static volatile GType t;
t = g_themed_icon_get_type ();
t = g_file_icon_get_type ();
t = g_emblemed_icon_get_type ();
t = g_emblem_get_type ();
}
/**
* g_icon_new_for_string:
* @str: A string obtained via g_icon_to_string().
* @error: Return location for error.
*
* Generate a #GIcon instance from @str. This function can fail if
* @str is not valid - see g_icon_to_string() for discussion.
*
* If your application or library provides one or more #GIcon
* implementations you need to ensure that each #GType is registered
* with the type system prior to calling g_icon_new_for_string().
*
* Returns: An object implementing the #GIcon interface or %NULL if
* @error is set.
*
* Since: 2.20
**/
GIcon *
g_icon_new_for_string (const gchar *str,
GError **error)
{
GIcon *icon;
g_return_val_if_fail (str != NULL, NULL);
ensure_builtin_icon_types ();
icon = NULL;
if (*str == '.')
{
if (g_str_has_prefix (str, G_ICON_SERIALIZATION_MAGIC0))
{
gchar **tokens;
/* handle tokenized encoding */
tokens = g_strsplit (str + sizeof (G_ICON_SERIALIZATION_MAGIC0) - 1, " ", 0);
icon = g_icon_new_from_tokens (tokens, error);
g_strfreev (tokens);
}
else
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Can't handle the supplied version the icon encoding"));
}
else
{
gchar *scheme;
/* handle special GFileIcon and GThemedIcon cases */
scheme = g_uri_parse_scheme (str);
if (scheme != NULL || str[0] == '/')
{
GFile *location;
location = g_file_new_for_commandline_arg (str);
icon = g_file_icon_new (location);
g_object_unref (location);
}
else
icon = g_themed_icon_new (str);
g_free (scheme);
}
return icon;
}
#define __G_ICON_C__
#include "gioaliasdef.c"