gio/gbytesicon.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright © 2013 Canonical Limited
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: Ryan Lortie <desrt@desrt.ca>
  19  */
  20
  21 #include "config.h"
  22
  23 #include "gbytesicon.h"
  24 #include "gbytes.h"
  25 #include "gicon.h"
  26 #include "glibintl.h"
  27 #include "gloadableicon.h"
  28 #include "gmemoryinputstream.h"
  29 #include "gtask.h"
  30 #include "gioerror.h"
  31
  32
  33 /**
  34  * SECTION:gbytesicon
  35  * @short_description: An icon stored in memory as a GBytes
  36  * @include: gio/gio.h
  37  * @see_also: #GIcon, #GLoadableIcon, #GBytes
  38  *
  39  * #GBytesIcon specifies an image held in memory in a common format (usually
  40  * png) to be used as icon.
  41  *
  42  * Since: 2.38
  43  **/
  44
  45 typedef GObjectClass GBytesIconClass;
  46
  47 struct _GBytesIcon
  48 {
  49   GObject parent_instance;
  50
  51   GBytes *bytes;
  52 };
  53
  54 enum
  55 {
  56   PROP_0,
  57   PROP_BYTES
  58 };
  59
  60 static void g_bytes_icon_icon_iface_init          (GIconIface          *iface);
  61 static void g_bytes_icon_loadable_icon_iface_init (GLoadableIconIface  *iface);
  62 G_DEFINE_TYPE_WITH_CODE (GBytesIcon, g_bytes_icon, G_TYPE_OBJECT,
  63                          G_IMPLEMENT_INTERFACE (G_TYPE_ICON, g_bytes_icon_icon_iface_init)
  64                          G_IMPLEMENT_INTERFACE (G_TYPE_LOADABLE_ICON, g_bytes_icon_loadable_icon_iface_init))
  65
  66 static void
  67 g_bytes_icon_get_property (GObject    *object,
  68                            guint       prop_id,
  69                            GValue     *value,
  70                            GParamSpec *pspec)
  71 {
  72   GBytesIcon *icon = G_BYTES_ICON (object);
  73
  74   switch (prop_id)
  75     {
  76       case PROP_BYTES:
  77         g_value_set_boxed (value, icon->bytes);
  78         break;
  79
  80       default:
  81         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  82     }
  83 }
  84
  85 static void
  86 g_bytes_icon_set_property (GObject      *object,
  87                           guint         prop_id,
  88                           const GValue *value,
  89                           GParamSpec   *pspec)
  90 {
  91   GBytesIcon *icon = G_BYTES_ICON (object);
  92
  93   switch (prop_id)
  94     {
  95       case PROP_BYTES:
  96         icon->bytes = g_value_dup_boxed (value);
  97         break;
  98
  99       default:
 100         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 101     }
 102 }
 103
 104 static void
 105 g_bytes_icon_finalize (GObject *object)
 106 {
 107   GBytesIcon *icon;
 108
 109   icon = G_BYTES_ICON (object);
 110
 111   g_bytes_unref (icon->bytes);
 112
 113   G_OBJECT_CLASS (g_bytes_icon_parent_class)->finalize (object);
 114 }
 115
 116 static void
 117 g_bytes_icon_class_init (GBytesIconClass *klass)
 118 {
 119   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 120
 121   gobject_class->get_property = g_bytes_icon_get_property;
 122   gobject_class->set_property = g_bytes_icon_set_property;
 123   gobject_class->finalize = g_bytes_icon_finalize;
 124
 125   /**
 126    * GBytesIcon:bytes:
 127    *
 128    * The bytes containing the icon.
 129    */
 130   g_object_class_install_property (gobject_class, PROP_BYTES,
 131                                    g_param_spec_boxed ("bytes",
 132                                                        P_("bytes"),
 133                                                        P_("The bytes containing the icon"),
 134                                                        G_TYPE_BYTES,
 135                                                        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 136 }
 137
 138 static void
 139 g_bytes_icon_init (GBytesIcon *bytes)
 140 {
 141 }
 142
 143 /**
 144  * g_bytes_icon_new:
 145  * @bytes: a #GBytes.
 146  *
 147  * Creates a new icon for a bytes.
 148  *
 149  * Returns: (transfer full) (type GBytesIcon): a #GIcon for the given
 150  *   @bytes, or %NULL on error.
 151  *
 152  * Since: 2.38
 153  **/
 154 GIcon *
 155 g_bytes_icon_new (GBytes *bytes)
 156 {
 157   g_return_val_if_fail (bytes != NULL, NULL);
 158
 159   return g_object_new (G_TYPE_BYTES_ICON, "bytes", bytes, NULL);
 160 }
 161
 162 /**
 163  * g_bytes_icon_get_bytes:
 164  * @icon: a #GIcon.
 165  *
 166  * Gets the #GBytes associated with the given @icon.
 167  *
 168  * Returns: (transfer none): a #GBytes, or %NULL.
 169  *
 170  * Since: 2.38
 171  **/
 172 GBytes *
 173 g_bytes_icon_get_bytes (GBytesIcon *icon)
 174 {
 175   g_return_val_if_fail (G_IS_BYTES_ICON (icon), NULL);
 176
 177   return icon->bytes;
 178 }
 179
 180 static guint
 181 g_bytes_icon_hash (GIcon *icon)
 182 {
 183   GBytesIcon *bytes_icon = G_BYTES_ICON (icon);
 184
 185   return g_bytes_hash (bytes_icon->bytes);
 186 }
 187
 188 static gboolean
 189 g_bytes_icon_equal (GIcon *icon1,
 190                     GIcon *icon2)
 191 {
 192   GBytesIcon *bytes1 = G_BYTES_ICON (icon1);
 193   GBytesIcon *bytes2 = G_BYTES_ICON (icon2);
 194
 195   return g_bytes_equal (bytes1->bytes, bytes2->bytes);
 196 }
 197
 198 static GVariant *
 199 g_bytes_icon_serialize (GIcon *icon)
 200 {
 201   GBytesIcon *bytes_icon = G_BYTES_ICON (icon);
 202
 203   return g_variant_new ("(sv)", "bytes",
 204                         g_variant_new_from_bytes (G_VARIANT_TYPE_BYTESTRING, bytes_icon->bytes, TRUE));
 205 }
 206
 207 static void
 208 g_bytes_icon_icon_iface_init (GIconIface *iface)
 209 {
 210   iface->hash = g_bytes_icon_hash;
 211   iface->equal = g_bytes_icon_equal;
 212   iface->serialize = g_bytes_icon_serialize;
 213 }
 214
 215 static GInputStream *
 216 g_bytes_icon_load (GLoadableIcon  *icon,
 217                    int            size,
 218                    char          **type,
 219                    GCancellable   *cancellable,
 220                    GError        **error)
 221 {
 222   GBytesIcon *bytes_icon = G_BYTES_ICON (icon);
 223
 224   if (type)
 225     *type = NULL;
 226
 227   return g_memory_input_stream_new_from_bytes (bytes_icon->bytes);
 228 }
 229
 230 static void
 231 g_bytes_icon_load_async (GLoadableIcon       *icon,
 232                          int                  size,
 233                          GCancellable        *cancellable,
 234                          GAsyncReadyCallback  callback,
 235                          gpointer             user_data)
 236 {
 237   GBytesIcon *bytes_icon = G_BYTES_ICON (icon);
 238   GTask *task;
 239
 240   task = g_task_new (icon, cancellable, callback, user_data);
 241   g_task_set_source_tag (task, g_bytes_icon_load_async);
 242   g_task_return_pointer (task, g_memory_input_stream_new_from_bytes (bytes_icon->bytes), g_object_unref);
 243   g_object_unref (task);
 244 }
 245
 246 static GInputStream *
 247 g_bytes_icon_load_finish (GLoadableIcon  *icon,
 248                           GAsyncResult   *res,
 249                           char          **type,
 250                           GError        **error)
 251 {
 252   g_return_val_if_fail (g_task_is_valid (res, icon), NULL);
 253
 254   if (type)
 255     *type = NULL;
 256
 257   return g_task_propagate_pointer (G_TASK (res), error);
 258 }
 259
 260 static void
 261 g_bytes_icon_loadable_icon_iface_init (GLoadableIconIface *iface)
 262 {
 263   iface->load = g_bytes_icon_load;
 264   iface->load_async = g_bytes_icon_load_async;
 265   iface->load_finish = g_bytes_icon_load_finish;
 266 }