| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2008 Clemens N. Buss <cebuzz@gmail.com> |
| * |
| * 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.1 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 <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include <config.h> |
| |
| #include "gicon.h" |
| #include "gemblem.h" |
| #include "glibintl.h" |
| #include "gioenums.h" |
| #include "gioenumtypes.h" |
| #include "gioerror.h" |
| #include <stdlib.h> |
| #include <string.h> |
| |
| |
| /** |
| * SECTION:gemblem |
| * @short_description: An object for emblems |
| * @include: gio/gio.h |
| * @see_also: #GIcon, #GEmblemedIcon, #GLoadableIcon, #GThemedIcon |
| * |
| * #GEmblem is an implementation of #GIcon that supports |
| * having an emblem, which is an icon with additional properties. |
| * It can than be added to a #GEmblemedIcon. |
| * |
| * Currently, only metainformation about the emblem's origin is |
| * supported. More may be added in the future. |
| */ |
| |
| static void g_emblem_iface_init (GIconIface *iface); |
| |
| struct _GEmblem |
| { |
| GObject parent_instance; |
| |
| GIcon *icon; |
| GEmblemOrigin origin; |
| }; |
| |
| struct _GEmblemClass |
| { |
| GObjectClass parent_class; |
| }; |
| |
| enum |
| { |
| PROP_0_GEMBLEM, |
| PROP_ICON, |
| PROP_ORIGIN |
| }; |
| |
| G_DEFINE_TYPE_WITH_CODE (GEmblem, g_emblem, G_TYPE_OBJECT, |
| G_IMPLEMENT_INTERFACE (G_TYPE_ICON, g_emblem_iface_init)) |
| |
| static void |
| g_emblem_get_property (GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| GEmblem *emblem = G_EMBLEM (object); |
| |
| switch (prop_id) |
| { |
| case PROP_ICON: |
| g_value_set_object (value, emblem->icon); |
| break; |
| |
| case PROP_ORIGIN: |
| g_value_set_enum (value, emblem->origin); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| g_emblem_set_property (GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| GEmblem *emblem = G_EMBLEM (object); |
| |
| switch (prop_id) |
| { |
| case PROP_ICON: |
| emblem->icon = g_value_dup_object (value); |
| break; |
| |
| case PROP_ORIGIN: |
| emblem->origin = g_value_get_enum (value); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| g_emblem_finalize (GObject *object) |
| { |
| GEmblem *emblem = G_EMBLEM (object); |
| |
| if (emblem->icon) |
| g_object_unref (emblem->icon); |
| |
| (*G_OBJECT_CLASS (g_emblem_parent_class)->finalize) (object); |
| } |
| |
| static void |
| g_emblem_class_init (GEmblemClass *klass) |
| { |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
| |
| gobject_class->finalize = g_emblem_finalize; |
| gobject_class->set_property = g_emblem_set_property; |
| gobject_class->get_property = g_emblem_get_property; |
| |
| g_object_class_install_property (gobject_class, |
| PROP_ORIGIN, |
| g_param_spec_enum ("origin", |
| P_("GEmblem’s origin"), |
| P_("Tells which origin the emblem is derived from"), |
| G_TYPE_EMBLEM_ORIGIN, |
| G_EMBLEM_ORIGIN_UNKNOWN, |
| G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); |
| |
| g_object_class_install_property (gobject_class, |
| PROP_ICON, |
| g_param_spec_object ("icon", |
| P_("The icon of the emblem"), |
| P_("The actual icon of the emblem"), |
| G_TYPE_OBJECT, |
| G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); |
| |
| } |
| |
| static void |
| g_emblem_init (GEmblem *emblem) |
| { |
| } |
| |
| /** |
| * g_emblem_new: |
| * @icon: a GIcon containing the icon. |
| * |
| * Creates a new emblem for @icon. |
| * |
| * Returns: a new #GEmblem. |
| * |
| * Since: 2.18 |
| */ |
| GEmblem * |
| g_emblem_new (GIcon *icon) |
| { |
| GEmblem* emblem; |
| |
| g_return_val_if_fail (icon != NULL, NULL); |
| g_return_val_if_fail (G_IS_ICON (icon), NULL); |
| g_return_val_if_fail (!G_IS_EMBLEM (icon), NULL); |
| |
| emblem = g_object_new (G_TYPE_EMBLEM, NULL); |
| emblem->icon = g_object_ref (icon); |
| emblem->origin = G_EMBLEM_ORIGIN_UNKNOWN; |
| |
| return emblem; |
| } |
| |
| /** |
| * g_emblem_new_with_origin: |
| * @icon: a GIcon containing the icon. |
| * @origin: a GEmblemOrigin enum defining the emblem's origin |
| * |
| * Creates a new emblem for @icon. |
| * |
| * Returns: a new #GEmblem. |
| * |
| * Since: 2.18 |
| */ |
| GEmblem * |
| g_emblem_new_with_origin (GIcon *icon, |
| GEmblemOrigin origin) |
| { |
| GEmblem* emblem; |
| |
| g_return_val_if_fail (icon != NULL, NULL); |
| g_return_val_if_fail (G_IS_ICON (icon), NULL); |
| g_return_val_if_fail (!G_IS_EMBLEM (icon), NULL); |
| |
| emblem = g_object_new (G_TYPE_EMBLEM, NULL); |
| emblem->icon = g_object_ref (icon); |
| emblem->origin = origin; |
| |
| return emblem; |
| } |
| |
| /** |
| * g_emblem_get_icon: |
| * @emblem: a #GEmblem from which the icon should be extracted. |
| * |
| * Gives back the icon from @emblem. |
| * |
| * Returns: (transfer none): a #GIcon. The returned object belongs to |
| * the emblem and should not be modified or freed. |
| * |
| * Since: 2.18 |
| */ |
| GIcon * |
| g_emblem_get_icon (GEmblem *emblem) |
| { |
| g_return_val_if_fail (G_IS_EMBLEM (emblem), NULL); |
| |
| return emblem->icon; |
| } |
| |
| |
| /** |
| * g_emblem_get_origin: |
| * @emblem: a #GEmblem |
| * |
| * Gets the origin of the emblem. |
| * |
| * Returns: (transfer none): the origin of the emblem |
| * |
| * Since: 2.18 |
| */ |
| GEmblemOrigin |
| g_emblem_get_origin (GEmblem *emblem) |
| { |
| g_return_val_if_fail (G_IS_EMBLEM (emblem), G_EMBLEM_ORIGIN_UNKNOWN); |
| |
| return emblem->origin; |
| } |
| |
| static guint |
| g_emblem_hash (GIcon *icon) |
| { |
| GEmblem *emblem = G_EMBLEM (icon); |
| guint hash; |
| |
| hash = g_icon_hash (g_emblem_get_icon (emblem)); |
| hash ^= emblem->origin; |
| |
| return hash; |
| } |
| |
| static gboolean |
| g_emblem_equal (GIcon *icon1, |
| GIcon *icon2) |
| { |
| GEmblem *emblem1 = G_EMBLEM (icon1); |
| GEmblem *emblem2 = G_EMBLEM (icon2); |
| |
| return emblem1->origin == emblem2->origin && |
| g_icon_equal (emblem1->icon, emblem2->icon); |
| } |
| |
| static gboolean |
| g_emblem_to_tokens (GIcon *icon, |
| GPtrArray *tokens, |
| gint *out_version) |
| { |
| GEmblem *emblem = G_EMBLEM (icon); |
| char *s; |
| |
| /* GEmblem are encoded as |
| * |
| * <origin> <icon> |
| */ |
| |
| g_return_val_if_fail (out_version != NULL, FALSE); |
| |
| *out_version = 0; |
| |
| s = g_icon_to_string (emblem->icon); |
| if (s == NULL) |
| return FALSE; |
| |
| g_ptr_array_add (tokens, s); |
| |
| s = g_strdup_printf ("%d", emblem->origin); |
| g_ptr_array_add (tokens, s); |
| |
| return TRUE; |
| } |
| |
| static GIcon * |
| g_emblem_from_tokens (gchar **tokens, |
| gint num_tokens, |
| gint version, |
| GError **error) |
| { |
| GEmblem *emblem; |
| GIcon *icon; |
| GEmblemOrigin origin; |
| |
| emblem = NULL; |
| |
| if (version != 0) |
| { |
| g_set_error (error, |
| G_IO_ERROR, |
| G_IO_ERROR_INVALID_ARGUMENT, |
| _("Can’t handle version %d of GEmblem encoding"), |
| version); |
| return NULL; |
| } |
| |
| if (num_tokens != 2) |
| { |
| g_set_error (error, |
| G_IO_ERROR, |
| G_IO_ERROR_INVALID_ARGUMENT, |
| _("Malformed number of tokens (%d) in GEmblem encoding"), |
| num_tokens); |
| return NULL; |
| } |
| |
| icon = g_icon_new_for_string (tokens[0], error); |
| |
| if (icon == NULL) |
| return NULL; |
| |
| origin = atoi (tokens[1]); |
| |
| emblem = g_emblem_new_with_origin (icon, origin); |
| g_object_unref (icon); |
| |
| return G_ICON (emblem); |
| } |
| |
| static GVariant * |
| g_emblem_serialize (GIcon *icon) |
| { |
| GEmblem *emblem = G_EMBLEM (icon); |
| GVariant *icon_data; |
| GEnumValue *origin; |
| GVariant *result; |
| |
| icon_data = g_icon_serialize (emblem->icon); |
| if (!icon_data) |
| return NULL; |
| |
| origin = g_enum_get_value (g_type_class_peek (G_TYPE_EMBLEM_ORIGIN), emblem->origin); |
| result = g_variant_new_parsed ("('emblem', <(%v, {'origin': <%s>})>)", |
| icon_data, origin ? origin->value_nick : "unknown"); |
| g_variant_unref (icon_data); |
| |
| return result; |
| } |
| |
| static void |
| g_emblem_iface_init (GIconIface *iface) |
| { |
| iface->hash = g_emblem_hash; |
| iface->equal = g_emblem_equal; |
| iface->to_tokens = g_emblem_to_tokens; |
| iface->from_tokens = g_emblem_from_tokens; |
| iface->serialize = g_emblem_serialize; |
| } |