← Back to branch summary

~midori/midori/trunk

« back to all changes in this revision

Viewing changes to katze/katze-array.c

  • Committer: Tarmac
  • Author(s): André Auzi
  • Date: 2013-09-18 16:20:51 UTC
  • mfrom: (6319.3.4 fix-1179200-5)
  • Revision ID: tarmac-20130918162051-n73z21hwk1dju69u
Introduces KatzeArray::update-item to handle metadata changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
katze/katze-array.c
25
25
 * #KatzeArray is a type aware container for items.
26
26
 */
27
27
 
28
 
struct _KatzeArray
 
28
G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
 
29
 
 
30
struct _KatzeArrayPrivate
29
31
{
30
 
    KatzeItem parent_instance;
31
 
 
32
32
    GType type;
33
33
    GList* items;
34
34
};
35
35
 
36
 
struct _KatzeArrayClass
37
 
{
38
 
    KatzeItemClass parent_class;
39
 
 
40
 
    /* Signals */
41
 
    void
42
 
    (*add_item)               (KatzeArray* array,
43
 
                               gpointer    item);
44
 
    void
45
 
    (*remove_item)            (KatzeArray* array,
46
 
                               gpointer    item);
47
 
    void
48
 
    (*move_item)              (KatzeArray* array,
49
 
                               gpointer    item,
50
 
                               gint        index);
51
 
    void
52
 
    (*clear)                  (KatzeArray* array);
53
 
 
54
 
    void
55
 
    (*update)                 (KatzeArray* array);
56
 
};
57
 
 
58
 
G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
59
 
 
60
36
enum {
61
37
    ADD_ITEM,
62
38
    REMOVE_ITEM,
90
66
    if (g_type_is_a (type, KATZE_TYPE_ITEM))
91
67
        katze_item_set_parent (item, array);
92
68
 
93
 
    array->items = g_list_append (array->items, item);
 
69
    array->priv->items = g_list_append (array->priv->items, item);
94
70
    _katze_array_update (array);
95
71
}
96
72
 
98
74
_katze_array_remove_item (KatzeArray* array,
99
75
                          gpointer   item)
100
76
{
101
 
    array->items = g_list_remove (array->items, item);
 
77
    array->priv->items = g_list_remove (array->priv->items, item);
102
78
 
103
79
    if (KATZE_IS_ITEM (item))
104
80
        katze_item_set_parent (item, NULL);
111
87
                        gpointer    item,
112
88
                        gint        position)
113
89
{
114
 
    array->items = g_list_remove (array->items, item);
115
 
    array->items = g_list_insert (array->items, item, position);
 
90
    array->priv->items = g_list_remove (array->priv->items, item);
 
91
    array->priv->items = g_list_insert (array->priv->items, item, position);
116
92
    _katze_array_update (array);
117
93
}
118
94
 
121
97
{
122
98
    GObject* item;
123
99
 
124
 
    while ((item = g_list_nth_data (array->items, 0)))
 
100
    while ((item = g_list_nth_data (array->priv->items, 0)))
125
101
        g_signal_emit (array, signals[REMOVE_ITEM], 0, item);
126
 
    g_list_free (array->items);
127
 
    array->items = NULL;
 
102
    g_list_free (array->priv->items);
 
103
    array->priv->items = NULL;
128
104
    _katze_array_update (array);
129
105
}
130
106
 
217
193
    class->move_item = _katze_array_move_item;
218
194
    class->clear = _katze_array_clear;
219
195
    class->update = _katze_array_update;
 
196
 
 
197
    g_type_class_add_private (class, sizeof (KatzeArrayPrivate));
220
198
}
221
199
 
222
200
static void
223
201
katze_array_init (KatzeArray* array)
224
202
{
225
 
    array->type = G_TYPE_OBJECT;
226
 
    array->items = NULL;
 
203
    array->priv = G_TYPE_INSTANCE_GET_PRIVATE (array,
 
204
        KATZE_TYPE_ARRAY, KatzeArrayPrivate);
 
205
 
 
206
    array->priv->type = G_TYPE_OBJECT;
 
207
    array->priv->items = NULL;
227
208
}
228
209
 
229
210
static void
232
213
    KatzeArray* array = KATZE_ARRAY (object);
233
214
    GList* items;
234
215
 
235
 
    for (items = array->items; items; items = g_list_next (items))
 
216
    for (items = array->priv->items; items; items = g_list_next (items))
236
217
        g_object_unref (items->data);
237
 
    g_list_free (array->items);
 
218
    g_list_free (array->priv->items);
238
219
 
239
220
    G_OBJECT_CLASS (katze_array_parent_class)->finalize (object);
240
221
}
258
239
    g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
259
240
 
260
241
    array = g_object_new (KATZE_TYPE_ARRAY, NULL);
261
 
    array->type = type;
 
242
    array->priv->type = type;
262
243
 
263
244
    return array;
264
245
}
279
260
{
280
261
    g_return_val_if_fail (KATZE_IS_ARRAY (array), FALSE);
281
262
 
282
 
    return g_type_is_a (array->type, is_a_type);
 
263
    return g_type_is_a (array->priv->type, is_a_type);
283
264
}
284
265
 
285
266
/**
333
314
{
334
315
    g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
335
316
 
336
 
    return g_list_nth_data (array->items, n);
 
317
    return g_list_nth_data (array->priv->items, n);
337
318
}
338
319
 
339
320
/**
349
330
{
350
331
    g_return_val_if_fail (KATZE_IS_ARRAY (array), TRUE);
351
332
 
352
 
    return !g_list_nth_data (array->items, 0);
 
333
    return !g_list_nth_data (array->priv->items, 0);
353
334
}
354
335
 
355
336
/**
367
348
{
368
349
    g_return_val_if_fail (KATZE_IS_ARRAY (array), -1);
369
350
 
370
 
    return g_list_index (array->items, item);
 
351
    return g_list_index (array->priv->items, item);
371
352
}
372
353
 
373
354
/**
401
382
    if (token_length < 1)
402
383
        token_length = strlen (token);
403
384
 
404
 
    for (items = array->items; items; items = g_list_next (items))
 
385
    for (items = array->priv->items; items; items = g_list_next (items))
405
386
    {
406
387
        const gchar* found_token = ((KatzeItem*)items->data)->token;
407
388
        if (found_token != NULL)
439
420
    g_return_val_if_fail (katze_array_is_a (array, KATZE_TYPE_ITEM), NULL);
440
421
    g_return_val_if_fail (uri != NULL, NULL);
441
422
 
442
 
    for (items = array->items; items; items = g_list_next (items))
 
423
    for (items = array->priv->items; items; items = g_list_next (items))
443
424
    {
444
425
        const gchar* found_uri = ((KatzeItem*)items->data)->uri;
445
426
        if (found_uri != NULL && !strcmp (found_uri, uri))
461
442
{
462
443
    g_return_val_if_fail (KATZE_IS_ARRAY (array), 0);
463
444
 
464
 
    return g_list_length (array->items);
 
445
    return g_list_length (array->priv->items);
465
446
}
466
447
 
467
448
/**
499
480
{
500
481
    g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
501
482
 
502
 
    return g_list_copy (array->items);
 
483
    return g_list_copy (array->priv->items);
503
484
}
504
485
 
505
486
GList*
507
488
{
508
489
    g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
509
490
 
510
 
    return array->items;
 
491
    return array->priv->items;
511
492
}
512
493
 
513
494
/**