1/* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright (C) 2006-2007 Red Hat, Inc.
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.1 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: Alexander Larsson <alexl@redhat.com>
19 */
20
21#include "config.h"
22#include "gicon.h"
23#include "gloadableicon.h"
24#include "gasyncresult.h"
25#include "gtask.h"
26#include "glibintl.h"
27
28
29/**
30 * SECTION:gloadableicon
31 * @short_description: Loadable Icons
32 * @include: gio/gio.h
33 * @see_also: #GIcon, #GThemedIcon
34 *
35 * Extends the #GIcon interface and adds the ability to
36 * load icons from streams.
37 **/
38
39static void g_loadable_icon_real_load_async (GLoadableIcon *icon,
40 int size,
41 GCancellable *cancellable,
42 GAsyncReadyCallback callback,
43 gpointer user_data);
44static GInputStream *g_loadable_icon_real_load_finish (GLoadableIcon *icon,
45 GAsyncResult *res,
46 char **type,
47 GError **error);
48
49typedef GLoadableIconIface GLoadableIconInterface;
50G_DEFINE_INTERFACE(GLoadableIcon, g_loadable_icon, G_TYPE_ICON)
51
52static void
53g_loadable_icon_default_init (GLoadableIconIface *iface)
54{
55 iface->load_async = g_loadable_icon_real_load_async;
56 iface->load_finish = g_loadable_icon_real_load_finish;
57}
58
59/**
60 * g_loadable_icon_load:
61 * @icon: a #GLoadableIcon.
62 * @size: an integer.
63 * @type: (out) (optional): a location to store the type of the loaded
64 * icon, %NULL to ignore.
65 * @cancellable: (nullable): optional #GCancellable object, %NULL to
66 * ignore.
67 * @error: a #GError location to store the error occurring, or %NULL
68 * to ignore.
69 *
70 * Loads a loadable icon. For the asynchronous version of this function,
71 * see g_loadable_icon_load_async().
72 *
73 * Returns: (transfer full): a #GInputStream to read the icon from.
74 **/
75GInputStream *
76g_loadable_icon_load (GLoadableIcon *icon,
77 int size,
78 char **type,
79 GCancellable *cancellable,
80 GError **error)
81{
82 GLoadableIconIface *iface;
83
84 g_return_val_if_fail (G_IS_LOADABLE_ICON (icon), NULL);
85
86 iface = G_LOADABLE_ICON_GET_IFACE (icon);
87
88 return (* iface->load) (icon, size, type, cancellable, error);
89}
90
91/**
92 * g_loadable_icon_load_async:
93 * @icon: a #GLoadableIcon.
94 * @size: an integer.
95 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
96 * @callback: (scope async): a #GAsyncReadyCallback to call when the
97 * request is satisfied
98 * @user_data: (closure): the data to pass to callback function
99 *
100 * Loads an icon asynchronously. To finish this function, see
101 * g_loadable_icon_load_finish(). For the synchronous, blocking
102 * version of this function, see g_loadable_icon_load().
103 **/
104void
105g_loadable_icon_load_async (GLoadableIcon *icon,
106 int size,
107 GCancellable *cancellable,
108 GAsyncReadyCallback callback,
109 gpointer user_data)
110{
111 GLoadableIconIface *iface;
112
113 g_return_if_fail (G_IS_LOADABLE_ICON (icon));
114
115 iface = G_LOADABLE_ICON_GET_IFACE (icon);
116
117 (* iface->load_async) (icon, size, cancellable, callback, user_data);
118}
119
120/**
121 * g_loadable_icon_load_finish:
122 * @icon: a #GLoadableIcon.
123 * @res: a #GAsyncResult.
124 * @type: (out) (optional): a location to store the type of the loaded
125 * icon, %NULL to ignore.
126 * @error: a #GError location to store the error occurring, or %NULL to
127 * ignore.
128 *
129 * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
130 *
131 * Returns: (transfer full): a #GInputStream to read the icon from.
132 **/
133GInputStream *
134g_loadable_icon_load_finish (GLoadableIcon *icon,
135 GAsyncResult *res,
136 char **type,
137 GError **error)
138{
139 GLoadableIconIface *iface;
140
141 g_return_val_if_fail (G_IS_LOADABLE_ICON (icon), NULL);
142 g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
143
144 if (g_async_result_legacy_propagate_error (res, error))
145 return NULL;
146
147 iface = G_LOADABLE_ICON_GET_IFACE (icon);
148
149 return (* iface->load_finish) (icon, res, type, error);
150}
151
152/********************************************
153 * Default implementation of async load *
154 ********************************************/
155
156typedef struct {
157 int size;
158 char *type;
159} LoadData;
160
161static void
162load_data_free (LoadData *data)
163{
164 g_free (mem: data->type);
165 g_free (mem: data);
166}
167
168static void
169load_async_thread (GTask *task,
170 gpointer source_object,
171 gpointer task_data,
172 GCancellable *cancellable)
173{
174 GLoadableIcon *icon = source_object;
175 LoadData *data = task_data;
176 GLoadableIconIface *iface;
177 GInputStream *stream;
178 GError *error = NULL;
179
180 iface = G_LOADABLE_ICON_GET_IFACE (icon);
181 stream = iface->load (icon, data->size, &data->type,
182 cancellable, &error);
183
184 if (stream)
185 g_task_return_pointer (task, result: stream, result_destroy: g_object_unref);
186 else
187 g_task_return_error (task, error);
188}
189
190
191
192static void
193g_loadable_icon_real_load_async (GLoadableIcon *icon,
194 int size,
195 GCancellable *cancellable,
196 GAsyncReadyCallback callback,
197 gpointer user_data)
198{
199 GTask *task;
200 LoadData *data;
201
202 task = g_task_new (source_object: icon, cancellable, callback, callback_data: user_data);
203 g_task_set_source_tag (task, g_loadable_icon_real_load_async);
204 data = g_new0 (LoadData, 1);
205 g_task_set_task_data (task, task_data: data, task_data_destroy: (GDestroyNotify) load_data_free);
206 g_task_run_in_thread (task, task_func: load_async_thread);
207 g_object_unref (object: task);
208}
209
210static GInputStream *
211g_loadable_icon_real_load_finish (GLoadableIcon *icon,
212 GAsyncResult *res,
213 char **type,
214 GError **error)
215{
216 GTask *task;
217 LoadData *data;
218 GInputStream *stream;
219
220 g_return_val_if_fail (g_task_is_valid (res, icon), NULL);
221
222 task = G_TASK (res);
223 data = g_task_get_task_data (task);
224
225 stream = g_task_propagate_pointer (task, error);
226 if (stream && type)
227 {
228 *type = data->type;
229 data->type = NULL;
230 }
231
232 return stream;
233}
234

source code of gtk/subprojects/glib/gio/gloadableicon.c