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
39 static void g_loadable_icon_real_load_async (GLoadableIcon *icon,
40 int size,
41 GCancellable *cancellable,
42 GAsyncReadyCallback callback,
43 gpointer user_data);
44 static GInputStream *g_loadable_icon_real_load_finish (GLoadableIcon *icon,
45 GAsyncResult *res,
46 char **type,
47 GError **error);
48
49 typedef GLoadableIconIface GLoadableIconInterface;
G_DEFINE_INTERFACE(GLoadableIcon,g_loadable_icon,G_TYPE_ICON)50 G_DEFINE_INTERFACE(GLoadableIcon, g_loadable_icon, G_TYPE_ICON)
51
52 static void
53 g_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 **/
75 GInputStream *
g_loadable_icon_load(GLoadableIcon * icon,int size,char ** type,GCancellable * cancellable,GError ** error)76 g_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 **/
104 void
g_loadable_icon_load_async(GLoadableIcon * icon,int size,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)105 g_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 **/
133 GInputStream *
g_loadable_icon_load_finish(GLoadableIcon * icon,GAsyncResult * res,char ** type,GError ** error)134 g_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
156 typedef struct {
157 int size;
158 char *type;
159 } LoadData;
160
161 static void
load_data_free(LoadData * data)162 load_data_free (LoadData *data)
163 {
164 g_free (data->type);
165 g_free (data);
166 }
167
168 static void
load_async_thread(GTask * task,gpointer source_object,gpointer task_data,GCancellable * cancellable)169 load_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, stream, g_object_unref);
186 else
187 g_task_return_error (task, error);
188 }
189
190
191
192 static void
g_loadable_icon_real_load_async(GLoadableIcon * icon,int size,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)193 g_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 (icon, cancellable, callback, 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, data, (GDestroyNotify) load_data_free);
206 g_task_run_in_thread (task, load_async_thread);
207 g_object_unref (task);
208 }
209
210 static GInputStream *
g_loadable_icon_real_load_finish(GLoadableIcon * icon,GAsyncResult * res,char ** type,GError ** error)211 g_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