nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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 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;
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: (allow-none): 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 *
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: (allow-none): 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
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 *
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
162 load_data_free (LoadData *data)
163 {
164 g_free (data->type);
165 g_free (data);
166 }
167  
168 static void
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
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 data = g_new0 (LoadData, 1);
204 g_task_set_task_data (task, data, (GDestroyNotify) load_data_free);
205 g_task_run_in_thread (task, load_async_thread);
206 g_object_unref (task);
207 }
208  
209 static GInputStream *
210 g_loadable_icon_real_load_finish (GLoadableIcon *icon,
211 GAsyncResult *res,
212 char **type,
213 GError **error)
214 {
215 GTask *task;
216 LoadData *data;
217 GInputStream *stream;
218  
219 g_return_val_if_fail (g_task_is_valid (res, icon), NULL);
220  
221 task = G_TASK (res);
222 data = g_task_get_task_data (task);
223  
224 stream = g_task_propagate_pointer (task, error);
225 if (stream && type)
226 {
227 *type = data->type;
228 data->type = NULL;
229 }
230  
231 return stream;
232 }