← Back to branch summary

~ubuntu-branches/debian/sid/cheese/sid

« back to all changes in this revision

Viewing changes to src/cheese-effects-manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2011-07-17 21:04:16 UTC
  • mfrom: (15.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110717210416-nt5qi659qei7a2yy
Tags: 3.0.1-2
* debian/control.in:
  - Change gir1.2-cheese-3.0 Section to libs
  - Make library packages depend against cheese-common package
  - Make cheese package recommends against hicolor-icon-theme
  - Move gst Dependency to libcheese package
* debian/patches/0002-fix-linking.patch: Add missing library to fix linking
* debian/watch:
  - Switch to .bz2 tarballs.
  - Bump version to 3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cheese-effects-manager.c
 
1
/* cheese-effects-manager.c generated by valac 0.12.0, the Vala compiler
 
2
 * generated from cheese-effects-manager.vala, do not modify */
 
3
 
 
4
/*
 
5
 * Copyright © 2010 Yuvaraj Pandian T <yuvipanda@yuvi.in>
 
6
 * Copyright © 2010 daniel g. siegel <dgsiegel@gnome.org>
 
7
 * Copyright © 2008 Filippo Argiolas <filippo.argiolas@gmail.com>
 
8
 *
 
9
 * Licensed under the GNU General Public License Version 2
 
10
 *
 
11
 * This program is free software; you can redistribute it and/or modify
 
12
 * it under the terms of the GNU General Public License as published by
 
13
 * the Free Software Foundation; either version 2 of the License, or
 
14
 * (at your option) any later version.
 
15
 *
 
16
 * This program is distributed in the hope that it will be useful,
 
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
19
 * GNU General Public License for more details.
 
20
 *
 
21
 * You should have received a copy of the GNU General Public License
 
22
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
23
 */
 
24
 
 
25
#include <glib.h>
 
26
#include <glib-object.h>
 
27
#include <stdlib.h>
 
28
#include <string.h>
 
29
#include <gee.h>
 
30
#include <cheese-effect.h>
 
31
#include <locale.h>
 
32
#include <glib/gstdio.h>
 
33
#include <glib/gi18n-lib.h>
 
34
 
 
35
 
 
36
#define CHEESE_TYPE_EFFECTS_MANAGER (cheese_effects_manager_get_type ())
 
37
#define CHEESE_EFFECTS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CHEESE_TYPE_EFFECTS_MANAGER, CheeseEffectsManager))
 
38
#define CHEESE_EFFECTS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CHEESE_TYPE_EFFECTS_MANAGER, CheeseEffectsManagerClass))
 
39
#define CHEESE_IS_EFFECTS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CHEESE_TYPE_EFFECTS_MANAGER))
 
40
#define CHEESE_IS_EFFECTS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CHEESE_TYPE_EFFECTS_MANAGER))
 
41
#define CHEESE_EFFECTS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CHEESE_TYPE_EFFECTS_MANAGER, CheeseEffectsManagerClass))
 
42
 
 
43
typedef struct _CheeseEffectsManager CheeseEffectsManager;
 
44
typedef struct _CheeseEffectsManagerClass CheeseEffectsManagerClass;
 
45
typedef struct _CheeseEffectsManagerPrivate CheeseEffectsManagerPrivate;
 
46
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
47
#define _g_free0(var) (var = (g_free (var), NULL))
 
48
#define _g_key_file_free0(var) ((var == NULL) ? NULL : (var = (g_key_file_free (var), NULL)))
 
49
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
50
#define _g_dir_close0(var) ((var == NULL) ? NULL : (var = (g_dir_close (var), NULL)))
 
51
 
 
52
struct _CheeseEffectsManager {
 
53
        GObject parent_instance;
 
54
        CheeseEffectsManagerPrivate * priv;
 
55
        GeeArrayList* effects;
 
56
};
 
57
 
 
58
struct _CheeseEffectsManagerClass {
 
59
        GObjectClass parent_class;
 
60
};
 
61
 
 
62
 
 
63
static gpointer cheese_effects_manager_parent_class = NULL;
 
64
 
 
65
#define GROUP_NAME "Effect"
 
66
GType cheese_effects_manager_get_type (void) G_GNUC_CONST;
 
67
enum  {
 
68
        CHEESE_EFFECTS_MANAGER_DUMMY_PROPERTY
 
69
};
 
70
CheeseEffect* cheese_effects_manager_parse_effect_file (const gchar* filename);
 
71
static GeeArrayList* cheese_effects_manager_load_effects_from_directory (CheeseEffectsManager* self, const gchar* directory);
 
72
CheeseEffectsManager* cheese_effects_manager_new (void);
 
73
CheeseEffectsManager* cheese_effects_manager_construct (GType object_type);
 
74
static gboolean cheese_effects_manager_cmp_value (CheeseEffect* a, CheeseEffect* b);
 
75
void cheese_effects_manager_load_effects (CheeseEffectsManager* self);
 
76
static gint cheese_effects_manager_sort_value (CheeseEffect* a, CheeseEffect* b);
 
77
CheeseEffect* cheese_effects_manager_get_effect (CheeseEffectsManager* self, const gchar* name);
 
78
static void cheese_effects_manager_finalize (GObject* obj);
 
79
static gint _vala_array_length (gpointer array);
 
80
 
 
81
 
 
82
CheeseEffect* cheese_effects_manager_parse_effect_file (const gchar* filename) {
 
83
        CheeseEffect* result = NULL;
 
84
        GKeyFile* _tmp0_ = NULL;
 
85
        GKeyFile* kf;
 
86
        CheeseEffect* _tmp1_ = NULL;
 
87
        CheeseEffect* eff;
 
88
        const gchar* _tmp2_ = NULL;
 
89
        gchar* _tmp3_;
 
90
        gchar* locale;
 
91
        gchar* _tmp4_ = NULL;
 
92
        gchar* _tmp5_;
 
93
        gchar* _tmp6_;
 
94
        gchar* _tmp7_ = NULL;
 
95
        gchar* _tmp8_;
 
96
        gchar* _tmp9_;
 
97
        GError * _inner_error_ = NULL;
 
98
        g_return_val_if_fail (filename != NULL, NULL);
 
99
        _tmp0_ = g_key_file_new ();
 
100
        kf = _tmp0_;
 
101
        _tmp1_ = cheese_effect_new ();
 
102
        eff = _tmp1_;
 
103
        _tmp2_ = setlocale (LC_ALL, "");
 
104
        _tmp3_ = g_strdup (_tmp2_);
 
105
        locale = _tmp3_;
 
106
        g_key_file_load_from_file (kf, filename, G_KEY_FILE_NONE, &_inner_error_);
 
107
        if (_inner_error_ != NULL) {
 
108
                if (_inner_error_->domain == G_KEY_FILE_ERROR) {
 
109
                        goto __catch11_g_key_file_error;
 
110
                }
 
111
                if (_inner_error_->domain == G_FILE_ERROR) {
 
112
                        goto __catch11_g_file_error;
 
113
                }
 
114
                _g_free0 (locale);
 
115
                _g_object_unref0 (eff);
 
116
                _g_key_file_free0 (kf);
 
117
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
118
                g_clear_error (&_inner_error_);
 
119
                return NULL;
 
120
        }
 
121
        _tmp4_ = g_key_file_get_locale_string (kf, GROUP_NAME, "Name", locale, &_inner_error_);
 
122
        _tmp5_ = _tmp4_;
 
123
        if (_inner_error_ != NULL) {
 
124
                if (_inner_error_->domain == G_KEY_FILE_ERROR) {
 
125
                        goto __catch11_g_key_file_error;
 
126
                }
 
127
                if (_inner_error_->domain == G_FILE_ERROR) {
 
128
                        goto __catch11_g_file_error;
 
129
                }
 
130
                _g_free0 (locale);
 
131
                _g_object_unref0 (eff);
 
132
                _g_key_file_free0 (kf);
 
133
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
134
                g_clear_error (&_inner_error_);
 
135
                return NULL;
 
136
        }
 
137
        _tmp6_ = _tmp5_;
 
138
        g_object_set (eff, "name", _tmp6_, NULL);
 
139
        _g_free0 (_tmp6_);
 
140
        _tmp7_ = g_key_file_get_string (kf, GROUP_NAME, "PipelineDescription", &_inner_error_);
 
141
        _tmp8_ = _tmp7_;
 
142
        if (_inner_error_ != NULL) {
 
143
                if (_inner_error_->domain == G_KEY_FILE_ERROR) {
 
144
                        goto __catch11_g_key_file_error;
 
145
                }
 
146
                if (_inner_error_->domain == G_FILE_ERROR) {
 
147
                        goto __catch11_g_file_error;
 
148
                }
 
149
                _g_free0 (locale);
 
150
                _g_object_unref0 (eff);
 
151
                _g_key_file_free0 (kf);
 
152
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
153
                g_clear_error (&_inner_error_);
 
154
                return NULL;
 
155
        }
 
156
        _tmp9_ = _tmp8_;
 
157
        g_object_set (eff, "pipeline-desc", _tmp9_, NULL);
 
158
        _g_free0 (_tmp9_);
 
159
        goto __finally11;
 
160
        __catch11_g_key_file_error:
 
161
        {
 
162
                GError * err;
 
163
                err = _inner_error_;
 
164
                _inner_error_ = NULL;
 
165
                g_warning ("cheese-effects-manager.vala:43: Error: %s\n", err->message);
 
166
                result = NULL;
 
167
                _g_error_free0 (err);
 
168
                _g_free0 (locale);
 
169
                _g_object_unref0 (eff);
 
170
                _g_key_file_free0 (kf);
 
171
                return result;
 
172
        }
 
173
        goto __finally11;
 
174
        __catch11_g_file_error:
 
175
        {
 
176
                GError * err;
 
177
                err = _inner_error_;
 
178
                _inner_error_ = NULL;
 
179
                g_warning ("cheese-effects-manager.vala:48: Error: %s\n", err->message);
 
180
                result = NULL;
 
181
                _g_error_free0 (err);
 
182
                _g_free0 (locale);
 
183
                _g_object_unref0 (eff);
 
184
                _g_key_file_free0 (kf);
 
185
                return result;
 
186
        }
 
187
        __finally11:
 
188
        if (_inner_error_ != NULL) {
 
189
                _g_free0 (locale);
 
190
                _g_object_unref0 (eff);
 
191
                _g_key_file_free0 (kf);
 
192
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
193
                g_clear_error (&_inner_error_);
 
194
                return NULL;
 
195
        }
 
196
        result = eff;
 
197
        _g_free0 (locale);
 
198
        _g_key_file_free0 (kf);
 
199
        return result;
 
200
}
 
201
 
 
202
 
 
203
static GeeArrayList* cheese_effects_manager_load_effects_from_directory (CheeseEffectsManager* self, const gchar* directory) {
 
204
        GeeArrayList* result = NULL;
 
205
        GeeArrayList* _tmp0_ = NULL;
 
206
        GeeArrayList* list;
 
207
        gboolean _tmp1_;
 
208
        GError * _inner_error_ = NULL;
 
209
        g_return_val_if_fail (self != NULL, NULL);
 
210
        g_return_val_if_fail (directory != NULL, NULL);
 
211
        _tmp0_ = gee_array_list_new (CHEESE_TYPE_EFFECT, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
 
212
        list = _tmp0_;
 
213
        _tmp1_ = g_file_test (directory, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR);
 
214
        if (_tmp1_) {
 
215
                GDir* dir = NULL;
 
216
                gchar* cur_file = NULL;
 
217
                GDir* _tmp2_ = NULL;
 
218
                GDir* _tmp3_;
 
219
                const gchar* _tmp4_ = NULL;
 
220
                gchar* _tmp5_;
 
221
                _tmp2_ = g_dir_open (directory, (guint) 0, &_inner_error_);
 
222
                _tmp3_ = _tmp2_;
 
223
                if (_inner_error_ != NULL) {
 
224
                        if (_inner_error_->domain == G_FILE_ERROR) {
 
225
                                goto __catch12_g_file_error;
 
226
                        }
 
227
                        _g_free0 (cur_file);
 
228
                        _g_dir_close0 (dir);
 
229
                        _g_object_unref0 (list);
 
230
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
231
                        g_clear_error (&_inner_error_);
 
232
                        return NULL;
 
233
                }
 
234
                _g_dir_close0 (dir);
 
235
                dir = _tmp3_;
 
236
                goto __finally12;
 
237
                __catch12_g_file_error:
 
238
                {
 
239
                        GError * err;
 
240
                        err = _inner_error_;
 
241
                        _inner_error_ = NULL;
 
242
                        g_warning ("cheese-effects-manager.vala:71: Error: %s\n", err->message);
 
243
                        result = NULL;
 
244
                        _g_error_free0 (err);
 
245
                        _g_free0 (cur_file);
 
246
                        _g_dir_close0 (dir);
 
247
                        _g_object_unref0 (list);
 
248
                        return result;
 
249
                }
 
250
                __finally12:
 
251
                if (_inner_error_ != NULL) {
 
252
                        _g_free0 (cur_file);
 
253
                        _g_dir_close0 (dir);
 
254
                        _g_object_unref0 (list);
 
255
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
256
                        g_clear_error (&_inner_error_);
 
257
                        return NULL;
 
258
                }
 
259
                _tmp4_ = g_dir_read_name (dir);
 
260
                _tmp5_ = g_strdup (_tmp4_);
 
261
                _g_free0 (cur_file);
 
262
                cur_file = _tmp5_;
 
263
                while (TRUE) {
 
264
                        gboolean _tmp6_;
 
265
                        const gchar* _tmp16_ = NULL;
 
266
                        gchar* _tmp17_;
 
267
                        if (!(cur_file != NULL)) {
 
268
                                break;
 
269
                        }
 
270
                        _tmp6_ = g_str_has_suffix (cur_file, ".effect");
 
271
                        if (_tmp6_) {
 
272
                                gchar* _tmp7_ = NULL;
 
273
                                gchar* _tmp8_;
 
274
                                CheeseEffect* _tmp9_ = NULL;
 
275
                                CheeseEffect* _tmp10_;
 
276
                                CheeseEffect* effect;
 
277
                                gboolean _tmp11_;
 
278
                                _tmp7_ = g_build_filename (directory, cur_file, NULL);
 
279
                                _tmp8_ = _tmp7_;
 
280
                                _tmp9_ = cheese_effects_manager_parse_effect_file (_tmp8_);
 
281
                                _tmp10_ = _tmp9_;
 
282
                                _g_free0 (_tmp8_);
 
283
                                effect = _tmp10_;
 
284
                                _tmp11_ = gee_abstract_collection_contains ((GeeAbstractCollection*) self->effects, effect);
 
285
                                if (!_tmp11_) {
 
286
                                        gchar* _tmp12_ = NULL;
 
287
                                        gchar* _tmp13_;
 
288
                                        gchar* _tmp14_ = NULL;
 
289
                                        gchar* _tmp15_;
 
290
                                        g_object_get (effect, "name", &_tmp12_, NULL);
 
291
                                        _tmp13_ = _tmp12_;
 
292
                                        g_object_get (effect, "pipeline-desc", &_tmp14_, NULL);
 
293
                                        _tmp15_ = _tmp14_;
 
294
                                        g_message ("cheese-effects-manager.vala:84: Found %s (%s)", _tmp13_, _tmp15_);
 
295
                                        _g_free0 (_tmp15_);
 
296
                                        _g_free0 (_tmp13_);
 
297
                                        gee_abstract_collection_add ((GeeAbstractCollection*) list, effect);
 
298
                                }
 
299
                                _g_object_unref0 (effect);
 
300
                        }
 
301
                        _tmp16_ = g_dir_read_name (dir);
 
302
                        _tmp17_ = g_strdup (_tmp16_);
 
303
                        _g_free0 (cur_file);
 
304
                        cur_file = _tmp17_;
 
305
                }
 
306
                _g_free0 (cur_file);
 
307
                _g_dir_close0 (dir);
 
308
        }
 
309
        result = list;
 
310
        return result;
 
311
}
 
312
 
 
313
 
 
314
CheeseEffectsManager* cheese_effects_manager_construct (GType object_type) {
 
315
        CheeseEffectsManager * self = NULL;
 
316
        GeeArrayList* _tmp0_ = NULL;
 
317
        self = (CheeseEffectsManager*) g_object_new (object_type, NULL);
 
318
        _tmp0_ = gee_array_list_new (CHEESE_TYPE_EFFECT, (GBoxedCopyFunc) g_object_ref, g_object_unref, (GEqualFunc) cheese_effects_manager_cmp_value);
 
319
        _g_object_unref0 (self->effects);
 
320
        self->effects = _tmp0_;
 
321
        return self;
 
322
}
 
323
 
 
324
 
 
325
CheeseEffectsManager* cheese_effects_manager_new (void) {
 
326
        return cheese_effects_manager_construct (CHEESE_TYPE_EFFECTS_MANAGER);
 
327
}
 
328
 
 
329
 
 
330
void cheese_effects_manager_load_effects (CheeseEffectsManager* self) {
 
331
        gchar* system_effects = NULL;
 
332
        gchar** _tmp0_;
 
333
        gchar** _tmp1_ = NULL;
 
334
        const gchar* _tmp6_ = NULL;
 
335
        gchar* _tmp7_ = NULL;
 
336
        gchar* user_effects;
 
337
        GeeArrayList* _tmp8_ = NULL;
 
338
        GeeArrayList* _tmp9_;
 
339
        gint _tmp10_;
 
340
        g_return_if_fail (self != NULL);
 
341
        _tmp1_ = _tmp0_ = g_get_system_data_dirs ();
 
342
        {
 
343
                gchar** dir_collection;
 
344
                int dir_collection_length1;
 
345
                int dir_it;
 
346
                dir_collection = _tmp1_;
 
347
                dir_collection_length1 = _vala_array_length (_tmp0_);
 
348
                for (dir_it = 0; dir_it < _vala_array_length (_tmp0_); dir_it = dir_it + 1) {
 
349
                        gchar* _tmp2_;
 
350
                        gchar* dir;
 
351
                        _tmp2_ = g_strdup (dir_collection[dir_it]);
 
352
                        dir = _tmp2_;
 
353
                        {
 
354
                                gchar* _tmp3_ = NULL;
 
355
                                GeeArrayList* _tmp4_ = NULL;
 
356
                                GeeArrayList* _tmp5_;
 
357
                                _tmp3_ = g_build_filename (dir, "gnome-video-effects", NULL);
 
358
                                _g_free0 (system_effects);
 
359
                                system_effects = _tmp3_;
 
360
                                _tmp4_ = cheese_effects_manager_load_effects_from_directory (self, system_effects);
 
361
                                _tmp5_ = _tmp4_;
 
362
                                gee_abstract_collection_add_all ((GeeAbstractCollection*) self->effects, (GeeCollection*) _tmp5_);
 
363
                                _g_object_unref0 (_tmp5_);
 
364
                                _g_free0 (dir);
 
365
                        }
 
366
                }
 
367
        }
 
368
        _tmp6_ = g_get_user_data_dir ();
 
369
        _tmp7_ = g_build_filename (_tmp6_, "gnome-video-effects", NULL);
 
370
        user_effects = _tmp7_;
 
371
        _tmp8_ = cheese_effects_manager_load_effects_from_directory (self, user_effects);
 
372
        _tmp9_ = _tmp8_;
 
373
        gee_abstract_collection_add_all ((GeeAbstractCollection*) self->effects, (GeeCollection*) _tmp9_);
 
374
        _g_object_unref0 (_tmp9_);
 
375
        gee_list_sort ((GeeList*) self->effects, (GCompareFunc) cheese_effects_manager_sort_value);
 
376
        _tmp10_ = gee_collection_get_size ((GeeCollection*) self->effects);
 
377
        if (_tmp10_ > 0) {
 
378
                CheeseEffect* _tmp11_ = NULL;
 
379
                CheeseEffect* e;
 
380
                const gchar* _tmp12_ = NULL;
 
381
                _tmp11_ = cheese_effect_new ();
 
382
                e = _tmp11_;
 
383
                _tmp12_ = _ ("No Effect");
 
384
                g_object_set (e, "name", _tmp12_, NULL);
 
385
                g_object_set (e, "pipeline-desc", "identity", NULL);
 
386
                gee_abstract_list_insert ((GeeAbstractList*) self->effects, 0, e);
 
387
                _g_object_unref0 (e);
 
388
        }
 
389
        _g_free0 (user_effects);
 
390
        _g_free0 (system_effects);
 
391
}
 
392
 
 
393
 
 
394
static gpointer _g_object_ref0 (gpointer self) {
 
395
        return self ? g_object_ref (self) : NULL;
 
396
}
 
397
 
 
398
 
 
399
CheeseEffect* cheese_effects_manager_get_effect (CheeseEffectsManager* self, const gchar* name) {
 
400
        CheeseEffect* result = NULL;
 
401
        g_return_val_if_fail (self != NULL, NULL);
 
402
        g_return_val_if_fail (name != NULL, NULL);
 
403
        {
 
404
                GeeArrayList* _tmp0_;
 
405
                GeeArrayList* _eff_list;
 
406
                gint _tmp1_;
 
407
                gint _eff_size;
 
408
                gint _eff_index;
 
409
                _tmp0_ = _g_object_ref0 (self->effects);
 
410
                _eff_list = _tmp0_;
 
411
                _tmp1_ = gee_collection_get_size ((GeeCollection*) _eff_list);
 
412
                _eff_size = _tmp1_;
 
413
                _eff_index = -1;
 
414
                while (TRUE) {
 
415
                        gpointer _tmp2_ = NULL;
 
416
                        CheeseEffect* eff;
 
417
                        gchar* _tmp3_ = NULL;
 
418
                        gchar* _tmp4_;
 
419
                        gboolean _tmp5_;
 
420
                        _eff_index = _eff_index + 1;
 
421
                        if (!(_eff_index < _eff_size)) {
 
422
                                break;
 
423
                        }
 
424
                        _tmp2_ = gee_abstract_list_get ((GeeAbstractList*) _eff_list, _eff_index);
 
425
                        eff = (CheeseEffect*) _tmp2_;
 
426
                        g_object_get (eff, "name", &_tmp3_, NULL);
 
427
                        _tmp4_ = _tmp3_;
 
428
                        _tmp5_ = g_strcmp0 (_tmp4_, name) == 0;
 
429
                        _g_free0 (_tmp4_);
 
430
                        if (_tmp5_) {
 
431
                                result = eff;
 
432
                                _g_object_unref0 (_eff_list);
 
433
                                return result;
 
434
                        }
 
435
                        _g_object_unref0 (eff);
 
436
                }
 
437
                _g_object_unref0 (_eff_list);
 
438
        }
 
439
        result = NULL;
 
440
        return result;
 
441
}
 
442
 
 
443
 
 
444
static gboolean cheese_effects_manager_cmp_value (CheeseEffect* a, CheeseEffect* b) {
 
445
        gboolean result = FALSE;
 
446
        gchar* _tmp0_ = NULL;
 
447
        gchar* _tmp1_;
 
448
        gchar* _tmp2_ = NULL;
 
449
        gchar* _tmp3_;
 
450
        gboolean _tmp4_;
 
451
        g_return_val_if_fail (a != NULL, FALSE);
 
452
        g_return_val_if_fail (b != NULL, FALSE);
 
453
        g_object_get (a, "pipeline-desc", &_tmp0_, NULL);
 
454
        _tmp1_ = _tmp0_;
 
455
        g_object_get (b, "pipeline-desc", &_tmp2_, NULL);
 
456
        _tmp3_ = _tmp2_;
 
457
        _tmp4_ = g_strcmp0 (_tmp1_, _tmp3_) == 0;
 
458
        _g_free0 (_tmp3_);
 
459
        _g_free0 (_tmp1_);
 
460
        result = _tmp4_;
 
461
        return result;
 
462
}
 
463
 
 
464
 
 
465
static gint cheese_effects_manager_sort_value (CheeseEffect* a, CheeseEffect* b) {
 
466
        gint result = 0;
 
467
        gchar* _tmp0_ = NULL;
 
468
        gchar* _tmp1_;
 
469
        gchar* _tmp2_ = NULL;
 
470
        gchar* _tmp3_;
 
471
        gchar* _tmp4_ = NULL;
 
472
        gchar* _tmp5_;
 
473
        gchar* _tmp6_ = NULL;
 
474
        gchar* _tmp7_;
 
475
        gboolean _tmp8_;
 
476
        g_return_val_if_fail (a != NULL, 0);
 
477
        g_return_val_if_fail (b != NULL, 0);
 
478
        g_object_get (a, "name", &_tmp0_, NULL);
 
479
        _tmp1_ = _tmp0_;
 
480
        _tmp2_ = g_utf8_strdown (_tmp1_, (gssize) (-1));
 
481
        _tmp3_ = _tmp2_;
 
482
        g_object_get (b, "name", &_tmp4_, NULL);
 
483
        _tmp5_ = _tmp4_;
 
484
        _tmp6_ = g_utf8_strdown (_tmp5_, (gssize) (-1));
 
485
        _tmp7_ = _tmp6_;
 
486
        _tmp8_ = g_strcmp0 (_tmp3_, _tmp7_) < 0;
 
487
        _g_free0 (_tmp7_);
 
488
        _g_free0 (_tmp5_);
 
489
        _g_free0 (_tmp3_);
 
490
        _g_free0 (_tmp1_);
 
491
        if (_tmp8_) {
 
492
                result = -1;
 
493
                return result;
 
494
        } else {
 
495
                gchar* _tmp9_ = NULL;
 
496
                gchar* _tmp10_;
 
497
                gchar* _tmp11_ = NULL;
 
498
                gchar* _tmp12_;
 
499
                gchar* _tmp13_ = NULL;
 
500
                gchar* _tmp14_;
 
501
                gchar* _tmp15_ = NULL;
 
502
                gchar* _tmp16_;
 
503
                gboolean _tmp17_;
 
504
                g_object_get (a, "name", &_tmp9_, NULL);
 
505
                _tmp10_ = _tmp9_;
 
506
                _tmp11_ = g_utf8_strdown (_tmp10_, (gssize) (-1));
 
507
                _tmp12_ = _tmp11_;
 
508
                g_object_get (b, "name", &_tmp13_, NULL);
 
509
                _tmp14_ = _tmp13_;
 
510
                _tmp15_ = g_utf8_strdown (_tmp14_, (gssize) (-1));
 
511
                _tmp16_ = _tmp15_;
 
512
                _tmp17_ = g_strcmp0 (_tmp12_, _tmp16_) > 0;
 
513
                _g_free0 (_tmp16_);
 
514
                _g_free0 (_tmp14_);
 
515
                _g_free0 (_tmp12_);
 
516
                _g_free0 (_tmp10_);
 
517
                if (_tmp17_) {
 
518
                        result = 1;
 
519
                        return result;
 
520
                } else {
 
521
                        result = 0;
 
522
                        return result;
 
523
                }
 
524
        }
 
525
}
 
526
 
 
527
 
 
528
static void cheese_effects_manager_class_init (CheeseEffectsManagerClass * klass) {
 
529
        cheese_effects_manager_parent_class = g_type_class_peek_parent (klass);
 
530
        G_OBJECT_CLASS (klass)->finalize = cheese_effects_manager_finalize;
 
531
}
 
532
 
 
533
 
 
534
static void cheese_effects_manager_instance_init (CheeseEffectsManager * self) {
 
535
}
 
536
 
 
537
 
 
538
static void cheese_effects_manager_finalize (GObject* obj) {
 
539
        CheeseEffectsManager * self;
 
540
        self = CHEESE_EFFECTS_MANAGER (obj);
 
541
        _g_object_unref0 (self->effects);
 
542
        G_OBJECT_CLASS (cheese_effects_manager_parent_class)->finalize (obj);
 
543
}
 
544
 
 
545
 
 
546
GType cheese_effects_manager_get_type (void) {
 
547
        static volatile gsize cheese_effects_manager_type_id__volatile = 0;
 
548
        if (g_once_init_enter (&cheese_effects_manager_type_id__volatile)) {
 
549
                static const GTypeInfo g_define_type_info = { sizeof (CheeseEffectsManagerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) cheese_effects_manager_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (CheeseEffectsManager), 0, (GInstanceInitFunc) cheese_effects_manager_instance_init, NULL };
 
550
                GType cheese_effects_manager_type_id;
 
551
                cheese_effects_manager_type_id = g_type_register_static (G_TYPE_OBJECT, "CheeseEffectsManager", &g_define_type_info, 0);
 
552
                g_once_init_leave (&cheese_effects_manager_type_id__volatile, cheese_effects_manager_type_id);
 
553
        }
 
554
        return cheese_effects_manager_type_id__volatile;
 
555
}
 
556
 
 
557
 
 
558
static gint _vala_array_length (gpointer array) {
 
559
        int length;
 
560
        length = 0;
 
561
        if (array) {
 
562
                while (((gpointer*) array)[length]) {
 
563
                        length++;
 
564
                }
 
565
        }
 
566
        return length;
 
567
}
 
568
 
 
569
 
 
570