← Back to branch summary

~ubuntu-branches/ubuntu/wily/xmms2/wily

« back to all changes in this revision

Viewing changes to src/xmms/object.c

  • Committer: Bazaar Package Importer
  • Author(s): Benjamin Drung
  • Date: 2008-07-04 16:23:34 UTC
  • mfrom: (1.1.5 upstream) (6.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080704162334-b3esbkcapt8wbrk4
Tags: 0.5DrLecter-2ubuntu1
https://launchpad.net/bugs/241098
https://launchpad.net/bugs/212566
https://launchpad.net/bugs/222341
* Merge from debian unstable (LP: #241098), remaining changes:
  + debian/control:
    + Update Maintainer field
    + add lpia to xmms2-plugin-alsa supported architectures
    + Added liba52-0.7.4-dev to build depends
  + debian/rules: Added patch, patch-stamp and unpatch
  + changed 01_gcc4.3.patch:
    + src/include/xmmsclient/xmmsclient++/helpers.h: Added #include <climits>
* New upstream relase fixes LP: #212566, #222341

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xmms/object.c
1
1
/*  XMMS2 - X Music Multiplexer System
2
 
 *  Copyright (C) 2003-2007 XMMS2 Team
 
2
 *  Copyright (C) 2003-2008 XMMS2 Team
3
3
 *
4
4
 *  PLUGINS ARE NOT CONSIDERED TO BE DERIVED WORK !!!
5
5
 *
51
51
        for (i = 0; i < XMMS_IPC_SIGNAL_END; i++) {
52
52
                if (object->signals[i]) {
53
53
                        GList *list = object->signals[i];
54
 
                        GList *node;
55
54
 
56
 
                        for (node = list; node; node = g_list_next (node)) {
57
 
                                if (node->data)
58
 
                                        g_free (node->data);
 
55
                        while (list) {
 
56
                                g_free (list->data);
 
57
                                list = g_list_delete_link (list, list);
59
58
                        }
60
 
                        if (list)
61
 
                                g_list_free (list);
62
59
                }
63
60
        }
64
61
 
170
167
 
171
168
        g_mutex_unlock (object->mutex);
172
169
 
173
 
        for (node = list2; node; node = g_list_next (node)) {
174
 
                entry = node->data;
 
170
        while (list2) {
 
171
                entry = list2->data;
175
172
 
176
173
                if (entry && entry->handler)
177
174
                        entry->handler (object, data, entry->userdata);
 
175
 
 
176
                list2 = g_list_delete_link (list2, list2);
178
177
        }
179
 
        g_list_free (list2);
180
 
 
181
178
}
182
179
 
183
180
xmms_object_cmd_value_t *
187
184
        val = g_new0 (xmms_object_cmd_value_t, 1);
188
185
        val->value.bin = bin;
189
186
        val->type = XMMS_OBJECT_CMD_ARG_BIN;
 
187
        val->refcount = 1;
190
188
        return val;
191
189
 
192
190
}
198
196
        val = g_new0 (xmms_object_cmd_value_t, 1);
199
197
        val->value.string = g_strdup (string);
200
198
        val->type = XMMS_OBJECT_CMD_ARG_STRING;
 
199
        val->refcount = 1;
201
200
        return val;
202
201
}
203
202
 
208
207
        val = g_new0 (xmms_object_cmd_value_t, 1);
209
208
        val->value.uint32 = uint;
210
209
        val->type = XMMS_OBJECT_CMD_ARG_UINT32;
 
210
        val->refcount = 1;
211
211
        return val;
212
212
}
213
213
 
218
218
        val = g_new0 (xmms_object_cmd_value_t, 1);
219
219
        val->value.int32 = i;
220
220
        val->type = XMMS_OBJECT_CMD_ARG_INT32;
 
221
        val->refcount = 1;
221
222
        return val;
222
223
}
223
224
 
224
225
xmms_object_cmd_value_t *
225
 
xmms_object_cmd_value_dict_new (GHashTable *dict)
 
226
xmms_object_cmd_value_dict_new (GTree *dict)
226
227
{
227
228
        xmms_object_cmd_value_t *val;
228
229
        val = g_new0 (xmms_object_cmd_value_t, 1);
229
230
        val->value.dict = dict;
230
231
        val->type = XMMS_OBJECT_CMD_ARG_DICT;
 
232
        val->refcount = 1;
 
233
        return val;
 
234
}
 
235
 
 
236
xmms_object_cmd_value_t *
 
237
xmms_object_cmd_value_hash_table_new (GHashTable *hash)
 
238
{
 
239
        xmms_object_cmd_value_t *val;
 
240
        val = g_new0 (xmms_object_cmd_value_t, 1);
 
241
        val->value.hash = hash;
 
242
        val->type = XMMS_OBJECT_CMD_ARG_HASH_TABLE;
 
243
        val->refcount = 1;
231
244
        return val;
232
245
}
233
246
 
238
251
        val = g_new0 (xmms_object_cmd_value_t, 1);
239
252
        val->value.list = list;
240
253
        val->type = XMMS_OBJECT_CMD_ARG_PROPDICT;
 
254
        val->refcount = 1;
241
255
        return val;
242
256
}
243
257
 
248
262
        val = g_new0 (xmms_object_cmd_value_t, 1);
249
263
        val->value.list = list;
250
264
        val->type = XMMS_OBJECT_CMD_ARG_LIST;
 
265
        val->refcount = 1;
251
266
        return val;
252
267
}
253
268
 
258
273
        val = g_new0 (xmms_object_cmd_value_t, 1);
259
274
        val->value.coll = coll;
260
275
        val->type = XMMS_OBJECT_CMD_ARG_COLL;
 
276
        val->refcount = 1;
261
277
        return val;
262
278
}
263
279
 
267
283
        xmms_object_cmd_value_t *val;
268
284
        val = g_new0 (xmms_object_cmd_value_t, 1);
269
285
        val->type = XMMS_OBJECT_CMD_ARG_NONE;
 
286
        val->refcount = 1;
270
287
        return val;
271
288
}
272
289
 
273
 
xmms_object_cmd_value_t *
274
 
xmms_object_cmd_value_copy (xmms_object_cmd_value_t *val)
275
 
{
276
 
        xmms_object_cmd_value_t *ret = NULL;
277
 
 
278
 
        g_return_val_if_fail (val, NULL);
279
 
 
280
 
        switch (val->type) {
281
 
                case XMMS_OBJECT_CMD_ARG_BIN:
282
 
                        ret = xmms_object_cmd_value_bin_new (val->value.bin);
283
 
                        break;
284
 
                case XMMS_OBJECT_CMD_ARG_STRING:
285
 
                        ret = xmms_object_cmd_value_str_new (val->value.string);
286
 
                        break;
287
 
                case XMMS_OBJECT_CMD_ARG_UINT32:
288
 
                        ret = xmms_object_cmd_value_uint_new (val->value.uint32);
289
 
                        break;
290
 
                case XMMS_OBJECT_CMD_ARG_INT32:
291
 
                        ret = xmms_object_cmd_value_int_new (val->value.int32);
292
 
                        break;
293
 
                case XMMS_OBJECT_CMD_ARG_NONE:
294
 
                        ret = xmms_object_cmd_value_none_new ();
295
 
                        break;
296
 
                case XMMS_OBJECT_CMD_ARG_DICT:
297
 
                case XMMS_OBJECT_CMD_ARG_LIST:
298
 
                case XMMS_OBJECT_CMD_ARG_PROPDICT:
299
 
                case XMMS_OBJECT_CMD_ARG_STRINGLIST:
300
 
                case XMMS_OBJECT_CMD_ARG_COLL:
301
 
                        /** Unsupported for now */
302
 
                        XMMS_DBG ("Unsupported value passed to value_copy()");
303
 
                        break;
304
 
        }
305
 
 
306
 
        return ret;
307
 
}
308
 
 
309
 
void
310
 
xmms_object_cmd_value_free (gpointer val)
311
 
{
312
 
        xmms_object_cmd_value_t *v = val;
313
 
        g_return_if_fail (v);
314
 
 
 
290
static void
 
291
xmms_object_cmd_value_free (xmms_object_cmd_value_t *v)
 
292
{
315
293
        switch (v->type) {
316
294
                case XMMS_OBJECT_CMD_ARG_STRING:
317
295
                        if (v->value.string)
324
302
                case XMMS_OBJECT_CMD_ARG_LIST:
325
303
                case XMMS_OBJECT_CMD_ARG_PROPDICT:
326
304
                        while (v->value.list) {
327
 
                                xmms_object_cmd_value_free (v->value.list->data);
 
305
                                xmms_object_cmd_value_unref (v->value.list->data);
328
306
                                v->value.list = g_list_delete_link (v->value.list,
329
307
                                                                    v->value.list);
330
308
                        }
338
316
                        break;
339
317
                case XMMS_OBJECT_CMD_ARG_DICT:
340
318
                        if (v->value.dict) {
341
 
                                g_hash_table_destroy (v->value.dict);
342
 
                        }
343
 
 
344
 
                        break;
 
319
                                g_tree_destroy (v->value.dict);
 
320
                        }
 
321
 
 
322
                        break;
 
323
                case XMMS_OBJECT_CMD_ARG_HASH_TABLE:
 
324
                        if (v->value.hash) {
 
325
                                g_hash_table_destroy (v->value.hash);
 
326
                        }
 
327
 
 
328
                        break;
 
329
 
345
330
                case XMMS_OBJECT_CMD_ARG_COLL:
346
331
                        if (v->value.coll) {
347
332
                                xmmsc_coll_unref (v->value.coll);
354
339
        g_free (v);
355
340
}
356
341
 
 
342
void
 
343
xmms_object_cmd_value_unref (xmms_object_cmd_value_t *val)
 
344
{
 
345
        g_return_if_fail (val);
 
346
 
 
347
        val->refcount--;
 
348
 
 
349
        if (!val->refcount) {
 
350
                xmms_object_cmd_value_free (val);
 
351
        }
 
352
}
 
353
 
 
354
xmms_object_cmd_value_t *
 
355
xmms_object_cmd_value_ref (xmms_object_cmd_value_t *val)
 
356
{
 
357
        g_return_val_if_fail (val, NULL);
 
358
 
 
359
        val->refcount++;
 
360
 
 
361
        return val;
 
362
}
 
363
 
357
364
/**
358
365
 * Initialize a command argument.
359
366
 */
400
407
                        arg.retval = xmms_object_cmd_value_str_new (va_arg (ap, gchar *));
401
408
                        break;
402
409
                case XMMS_OBJECT_CMD_ARG_BIN:
403
 
                        arg.retval = xmms_object_cmd_value_bin_new ((GString *) va_arg (ap, gpointer));
 
410
                        arg.retval = xmms_object_cmd_value_bin_new (va_arg (ap, GString *));
404
411
                        break;
405
412
                case XMMS_OBJECT_CMD_ARG_DICT:
406
 
                        arg.retval = xmms_object_cmd_value_dict_new ((GHashTable *) va_arg (ap, gpointer));
 
413
                        arg.retval = xmms_object_cmd_value_dict_new (va_arg (ap, GTree *));
 
414
                        break;
 
415
                case XMMS_OBJECT_CMD_ARG_HASH_TABLE:
 
416
                        arg.retval = xmms_object_cmd_value_hash_table_new (va_arg (ap, GHashTable *));
407
417
                        break;
408
418
                case XMMS_OBJECT_CMD_ARG_LIST:
409
419
                case XMMS_OBJECT_CMD_ARG_PROPDICT:
410
420
                case XMMS_OBJECT_CMD_ARG_STRINGLIST:
411
 
                        arg.retval = xmms_object_cmd_value_list_new ((GList *) va_arg (ap, gpointer));
 
421
                        arg.retval = xmms_object_cmd_value_list_new (va_arg (ap, GList *));
412
422
                        break;
413
423
                case XMMS_OBJECT_CMD_ARG_COLL:
414
 
                        arg.retval = xmms_object_cmd_value_coll_new ((xmmsc_coll_t *) va_arg (ap, gpointer));
 
424
                        arg.retval = xmms_object_cmd_value_coll_new (va_arg (ap, xmmsc_coll_t *));
415
425
                        break;
416
426
                case XMMS_OBJECT_CMD_ARG_NONE:
417
427
                        arg.retval = xmms_object_cmd_value_none_new ();
422
432
        xmms_object_emit (object, signalid, &arg);
423
433
 
424
434
        /*
425
 
         * Let's not use value_free since that will free whatever
426
 
         * is in the struct also. This should be owned by the
427
 
         * parent
 
435
         * We're only calling xmms_object_cmd_value_unref() here for
 
436
         * retvals that either hold no payload at all (_ARG_NONE) or that
 
437
         * have their own copy/reference in the payload (_ARG_STRING and
 
438
         * maybe more later).
428
439
         */
429
 
        if (type != XMMS_OBJECT_CMD_ARG_NONE)
430
 
                g_free (arg.retval);
431
 
 
 
440
        switch (type) {
 
441
                case XMMS_OBJECT_CMD_ARG_STRING:
 
442
                case XMMS_OBJECT_CMD_ARG_NONE:
 
443
                        xmms_object_cmd_value_unref (arg.retval);
 
444
                        break;
 
445
                default:
 
446
                        g_free (arg.retval);
 
447
        }
432
448
}
433
449
 
434
450