← Back to branch summary

~noskcaj/ubuntu/trusty/gthumb/3.2.5

« back to all changes in this revision

Viewing changes to gthumb/gth-async-task.c

  • Committer: Package Import Robot
  • Author(s): David Paleino
  • Date: 2011-12-22 22:40:29 UTC
  • mfrom: (5.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20111222224029-l58g65u1nfa6ojtg
Tags: 3:2.14.1-1
http://bugs.debian.org/652692
* New upstream version (Closes: #652692)
* Patches refreshed
* Bump build-dependencies requirements
* Fix FTBFS, added missing #include
* debian/watch fixed to point to new location (.xz tarballs)

Show diffs side-by-side

added added

removed removed

Lines of Context:
gthumb/gth-async-task.c
33
33
        PROP_0,
34
34
        PROP_BEFORE_THREAD,
35
35
        PROP_THREAD_FUNC,
36
 
        PROP_AFTER_THREAD
 
36
        PROP_AFTER_THREAD,
 
37
        PROP_USER_DATA,
 
38
        PROP_USER_DATA_DESTROY_FUNC,
37
39
};
38
40
 
39
41
 
40
42
struct _GthAsyncTaskPrivate {
41
 
        DataFunc     before_func;
42
 
        GThreadFunc  exec_func;
43
 
        ReadyFunc    after_func;
44
 
        GMutex      *data_mutex;
45
 
        guint        progress_event;
46
 
        gboolean     cancelled;
47
 
        gboolean     terminated;
48
 
        double       progress;
 
43
        GthAsyncInitFunc    before_func;
 
44
        GthAsyncThreadFunc  exec_func;
 
45
        GthAsyncReadyFunc   after_func;
 
46
        gpointer            user_data;
 
47
        GDestroyNotify      user_data_destroy_func;
 
48
        GMutex             *data_mutex;
 
49
        guint               progress_event;
 
50
        gboolean            cancelled;
 
51
        gboolean            terminated;
 
52
        double              progress;
49
53
};
50
54
 
51
55
 
65
69
                self->priv->progress_event = 0;
66
70
        }
67
71
 
 
72
        if ((self->priv->user_data != NULL) && (self->priv->user_data_destroy_func))
 
73
                (*self->priv->user_data_destroy_func) (self->priv->user_data);
 
74
 
68
75
        g_mutex_free (self->priv->data_mutex);
69
76
 
70
77
        G_OBJECT_CLASS (parent_class)->finalize (object);
103
110
                        error = g_error_new_literal (GTH_TASK_ERROR, GTH_TASK_ERROR_CANCELLED, "");
104
111
 
105
112
                if (self->priv->after_func != NULL)
106
 
                        self->priv->after_func (error, self);
 
113
                        self->priv->after_func (self, error, self->priv->user_data);
107
114
 
108
115
                ready_with_error (task_completed, self, error);
109
116
 
126
133
        GthAsyncTask *self = user_data;
127
134
        gpointer      result;
128
135
 
129
 
        result = self->priv->exec_func (self);
 
136
        result = self->priv->exec_func (self, self->priv->user_data);
130
137
 
131
138
        g_mutex_lock (self->priv->data_mutex);
132
139
        self->priv->terminated = TRUE;
149
156
        g_mutex_unlock (self->priv->data_mutex);
150
157
 
151
158
        if (self->priv->before_func != NULL)
152
 
                self->priv->before_func (self);
 
159
                self->priv->before_func (self, self->priv->user_data);
153
160
        g_thread_create (exec_task, self, FALSE, NULL);
154
161
 
155
162
        if (self->priv->progress_event == 0)
192
199
        case PROP_AFTER_THREAD:
193
200
                self->priv->after_func = g_value_get_pointer (value);
194
201
                break;
 
202
        case PROP_USER_DATA:
 
203
                self->priv->user_data = g_value_get_pointer (value);
 
204
                break;
 
205
        case PROP_USER_DATA_DESTROY_FUNC:
 
206
                self->priv->user_data_destroy_func = g_value_get_pointer (value);
 
207
                break;
195
208
        default:
196
209
                break;
197
210
        }
218
231
        case PROP_AFTER_THREAD:
219
232
                g_value_set_pointer (value, self->priv->after_func);
220
233
                break;
 
234
        case PROP_USER_DATA:
 
235
                g_value_set_pointer (value, self->priv->user_data);
 
236
                break;
 
237
        case PROP_USER_DATA_DESTROY_FUNC:
 
238
                g_value_set_pointer (value, self->priv->user_data_destroy_func);
 
239
                break;
221
240
        default:
222
241
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
223
242
                break;
261
280
                                                               "After",
262
281
                                                               "The function to execute after the thread",
263
282
                                                               G_PARAM_READWRITE));
 
283
        g_object_class_install_property (object_class,
 
284
                                         PROP_USER_DATA,
 
285
                                         g_param_spec_pointer ("user-data",
 
286
                                                               "User Data",
 
287
                                                               "The extra data to pass to the functions",
 
288
                                                               G_PARAM_READWRITE));
 
289
        g_object_class_install_property (object_class,
 
290
                                         PROP_USER_DATA_DESTROY_FUNC,
 
291
                                         g_param_spec_pointer ("user-data-destroy-func",
 
292
                                                               "User data destroy function",
 
293
                                                               "The optional function to free the user data when no longer needed",
 
294
                                                               G_PARAM_READWRITE));
264
295
}
265
296
 
266
297
 
272
303
        self->priv->terminated = FALSE;
273
304
        self->priv->progress_event = 0;
274
305
        self->priv->data_mutex = g_mutex_new ();
 
306
        self->priv->user_data = NULL;
 
307
        self->priv->user_data_destroy_func = NULL;
275
308
}
276
309
 
277
310
 
303
336
}
304
337
 
305
338
 
 
339
GthTask *
 
340
gth_async_task_new (GthAsyncInitFunc    before_func,
 
341
                    GthAsyncThreadFunc  exec_func,
 
342
                    GthAsyncReadyFunc   after_func,
 
343
                    gpointer            user_data,
 
344
                    GDestroyNotify      user_data_destroy_func)
 
345
{
 
346
        return (GthTask *) g_object_new (GTH_TYPE_ASYNC_TASK,
 
347
                                         "before-thread", before_func,
 
348
                                         "thread-func", exec_func,
 
349
                                         "after-thread", after_func,
 
350
                                         "user-data", user_data,
 
351
                                         "user-data-destroy-func", user_data_destroy_func,
 
352
                                         NULL);
 
353
}
 
354
 
 
355
 
306
356
void
307
357
gth_async_task_set_data (GthAsyncTask *self,
308
358
                         gboolean     *terminated,