← Back to branch summary

~ubuntu-branches/ubuntu/precise/indicator-sound/precise-201111281906

« back to all changes in this revision

Viewing changes to src/settings-manager.c

Tags: upstream-0.5.3
Import upstream version 0.5.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/settings-manager.c
 
1
/* settings-manager.c generated by valac 0.11.2, the Vala compiler
 
2
 * generated from settings-manager.vala, do not modify */
 
3
 
 
4
/*
 
5
Copyright 2010 Canonical Ltd.
 
6
 
 
7
Authors:
 
8
    Conor Curran <conor.curran@canonical.com>
 
9
 
 
10
This program is free software: you can redistribute it and/or modify it 
 
11
under the terms of the GNU General Public License version 3, as published 
 
12
by the Free Software Foundation.
 
13
 
 
14
This program is distributed in the hope that it will be useful, but 
 
15
WITHOUT ANY WARRANTY; without even the implied warranties of 
 
16
MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
 
17
PURPOSE.  See the GNU General Public License for more details.
 
18
 
 
19
You should have received a copy of the GNU General Public License along 
 
20
with this program.  If not, see <http://www.gnu.org/licenses/>.
 
21
*/
 
22
 
 
23
#include <glib.h>
 
24
#include <glib-object.h>
 
25
#include <gio/gio.h>
 
26
#include <stdlib.h>
 
27
#include <string.h>
 
28
 
 
29
 
 
30
#define TYPE_SETTINGS_MANAGER (settings_manager_get_type ())
 
31
#define SETTINGS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SETTINGS_MANAGER, SettingsManager))
 
32
#define SETTINGS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SETTINGS_MANAGER, SettingsManagerClass))
 
33
#define IS_SETTINGS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SETTINGS_MANAGER))
 
34
#define IS_SETTINGS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SETTINGS_MANAGER))
 
35
#define SETTINGS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SETTINGS_MANAGER, SettingsManagerClass))
 
36
 
 
37
typedef struct _SettingsManager SettingsManager;
 
38
typedef struct _SettingsManagerClass SettingsManagerClass;
 
39
typedef struct _SettingsManagerPrivate SettingsManagerPrivate;
 
40
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
41
 
 
42
struct _SettingsManager {
 
43
        GObject parent_instance;
 
44
        SettingsManagerPrivate * priv;
 
45
};
 
46
 
 
47
struct _SettingsManagerClass {
 
48
        GObjectClass parent_class;
 
49
};
 
50
 
 
51
struct _SettingsManagerPrivate {
 
52
        GSettings* settings;
 
53
};
 
54
 
 
55
 
 
56
static gpointer settings_manager_parent_class = NULL;
 
57
 
 
58
GType settings_manager_get_type (void) G_GNUC_CONST;
 
59
#define SETTINGS_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SETTINGS_MANAGER, SettingsManagerPrivate))
 
60
enum  {
 
61
        SETTINGS_MANAGER_DUMMY_PROPERTY
 
62
};
 
63
SettingsManager* settings_manager_new (void);
 
64
SettingsManager* settings_manager_construct (GType object_type);
 
65
gchar** settings_manager_fetch_blacklist (SettingsManager* self, int* result_length1);
 
66
gchar** settings_manager_fetch_interested (SettingsManager* self, int* result_length1);
 
67
gboolean settings_manager_add_interested (SettingsManager* self, const gchar* app_desktop_name);
 
68
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value);
 
69
static void settings_manager_on_blacklist_event (SettingsManager* self);
 
70
static void g_cclosure_user_marshal_VOID__BOXED_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 
71
static GObject * settings_manager_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 
72
static void _settings_manager_on_blacklist_event_g_settings_changed (GSettings* _sender, const gchar* key, gpointer self);
 
73
static void settings_manager_finalize (GObject* obj);
 
74
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
75
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
76
static gint _vala_array_length (gpointer array);
 
77
 
 
78
 
 
79
SettingsManager* settings_manager_construct (GType object_type) {
 
80
        SettingsManager * self = NULL;
 
81
        self = (SettingsManager*) g_object_new (object_type, NULL);
 
82
        return self;
 
83
}
 
84
 
 
85
 
 
86
SettingsManager* settings_manager_new (void) {
 
87
        return settings_manager_construct (TYPE_SETTINGS_MANAGER);
 
88
}
 
89
 
 
90
 
 
91
gchar** settings_manager_fetch_blacklist (SettingsManager* self, int* result_length1) {
 
92
        gchar** result = NULL;
 
93
        gchar** _tmp0_;
 
94
        gchar** _tmp1_ = NULL;
 
95
        gchar** _tmp2_;
 
96
        g_return_val_if_fail (self != NULL, NULL);
 
97
        _tmp1_ = _tmp0_ = g_settings_get_strv (self->priv->settings, "blacklisted-media-players");
 
98
        _tmp2_ = _tmp1_;
 
99
        *result_length1 = _vala_array_length (_tmp0_);
 
100
        result = _tmp2_;
 
101
        return result;
 
102
}
 
103
 
 
104
 
 
105
gchar** settings_manager_fetch_interested (SettingsManager* self, int* result_length1) {
 
106
        gchar** result = NULL;
 
107
        gchar** _tmp0_;
 
108
        gchar** _tmp1_ = NULL;
 
109
        gchar** _tmp2_;
 
110
        g_return_val_if_fail (self != NULL, NULL);
 
111
        _tmp1_ = _tmp0_ = g_settings_get_strv (self->priv->settings, "interested-media-players");
 
112
        _tmp2_ = _tmp1_;
 
113
        *result_length1 = _vala_array_length (_tmp0_);
 
114
        result = _tmp2_;
 
115
        return result;
 
116
}
 
117
 
 
118
 
 
119
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value) {
 
120
        if ((*length) == (*size)) {
 
121
                *size = (*size) ? (2 * (*size)) : 4;
 
122
                *array = g_renew (gchar*, *array, (*size) + 1);
 
123
        }
 
124
        (*array)[(*length)++] = value;
 
125
        (*array)[*length] = NULL;
 
126
}
 
127
 
 
128
 
 
129
gboolean settings_manager_add_interested (SettingsManager* self, const gchar* app_desktop_name) {
 
130
        gboolean result = FALSE;
 
131
        gint _tmp0_;
 
132
        gchar** _tmp1_ = NULL;
 
133
        gint already_interested_length1;
 
134
        gint _already_interested_size_;
 
135
        gchar** _tmp2_;
 
136
        gchar** already_interested;
 
137
        gchar* _tmp3_;
 
138
        gboolean _tmp4_;
 
139
        g_return_val_if_fail (self != NULL, FALSE);
 
140
        g_return_val_if_fail (app_desktop_name != NULL, FALSE);
 
141
        _tmp1_ = settings_manager_fetch_interested (self, &_tmp0_);
 
142
        _tmp2_ = _tmp1_;
 
143
        already_interested_length1 = _tmp0_;
 
144
        _already_interested_size_ = already_interested_length1;
 
145
        already_interested = _tmp2_;
 
146
        _tmp3_ = g_strdup (app_desktop_name);
 
147
        _vala_array_add1 (&already_interested, &already_interested_length1, &_already_interested_size_, _tmp3_);
 
148
        _tmp4_ = g_settings_set_strv (self->priv->settings, "interested-media-players", already_interested);
 
149
        result = _tmp4_;
 
150
        already_interested = (_vala_array_free (already_interested, already_interested_length1, (GDestroyNotify) g_free), NULL);
 
151
        return result;
 
152
}
 
153
 
 
154
 
 
155
static void settings_manager_on_blacklist_event (SettingsManager* self) {
 
156
        gchar** _tmp0_;
 
157
        gchar** _tmp1_ = NULL;
 
158
        gchar** _tmp2_;
 
159
        gint _tmp2__length1;
 
160
        g_return_if_fail (self != NULL);
 
161
        _tmp1_ = _tmp0_ = g_settings_get_strv (self->priv->settings, "blacklisted-media-players");
 
162
        _tmp2_ = _tmp1_;
 
163
        _tmp2__length1 = _vala_array_length (_tmp0_);
 
164
        g_signal_emit_by_name (self, "blacklist-updates", _tmp2_, _vala_array_length (_tmp0_));
 
165
        _tmp2_ = (_vala_array_free (_tmp2_, _tmp2__length1, (GDestroyNotify) g_free), NULL);
 
166
}
 
167
 
 
168
 
 
169
static void g_cclosure_user_marshal_VOID__BOXED_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
 
170
        typedef void (*GMarshalFunc_VOID__BOXED_INT) (gpointer data1, gpointer arg_1, gint arg_2, gpointer data2);
 
171
        register GMarshalFunc_VOID__BOXED_INT callback;
 
172
        register GCClosure * cc;
 
173
        register gpointer data1, data2;
 
174
        cc = (GCClosure *) closure;
 
175
        g_return_if_fail (n_param_values == 3);
 
176
        if (G_CCLOSURE_SWAP_DATA (closure)) {
 
177
                data1 = closure->data;
 
178
                data2 = param_values->data[0].v_pointer;
 
179
        } else {
 
180
                data1 = param_values->data[0].v_pointer;
 
181
                data2 = closure->data;
 
182
        }
 
183
        callback = (GMarshalFunc_VOID__BOXED_INT) (marshal_data ? marshal_data : cc->callback);
 
184
        callback (data1, g_value_get_boxed (param_values + 1), g_value_get_int (param_values + 2), data2);
 
185
}
 
186
 
 
187
 
 
188
static void _settings_manager_on_blacklist_event_g_settings_changed (GSettings* _sender, const gchar* key, gpointer self) {
 
189
        settings_manager_on_blacklist_event (self);
 
190
}
 
191
 
 
192
 
 
193
static GObject * settings_manager_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 
194
        GObject * obj;
 
195
        GObjectClass * parent_class;
 
196
        SettingsManager * self;
 
197
        GSettings* _tmp0_ = NULL;
 
198
        GSettings* _tmp1_;
 
199
        parent_class = G_OBJECT_CLASS (settings_manager_parent_class);
 
200
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 
201
        self = SETTINGS_MANAGER (obj);
 
202
        _tmp0_ = g_settings_new ("com.canonical.indicators.sound");
 
203
        _tmp1_ = _tmp0_;
 
204
        _g_object_unref0 (self->priv->settings);
 
205
        self->priv->settings = _tmp1_;
 
206
        g_signal_connect_object (self->priv->settings, "changed::blacklisted-media-players", (GCallback) _settings_manager_on_blacklist_event_g_settings_changed, self, 0);
 
207
        return obj;
 
208
}
 
209
 
 
210
 
 
211
static void settings_manager_class_init (SettingsManagerClass * klass) {
 
212
        settings_manager_parent_class = g_type_class_peek_parent (klass);
 
213
        g_type_class_add_private (klass, sizeof (SettingsManagerPrivate));
 
214
        G_OBJECT_CLASS (klass)->constructor = settings_manager_constructor;
 
215
        G_OBJECT_CLASS (klass)->finalize = settings_manager_finalize;
 
216
        g_signal_new ("blacklist_updates", TYPE_SETTINGS_MANAGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__BOXED_INT, G_TYPE_NONE, 2, G_TYPE_STRV, G_TYPE_INT);
 
217
}
 
218
 
 
219
 
 
220
static void settings_manager_instance_init (SettingsManager * self) {
 
221
        self->priv = SETTINGS_MANAGER_GET_PRIVATE (self);
 
222
}
 
223
 
 
224
 
 
225
static void settings_manager_finalize (GObject* obj) {
 
226
        SettingsManager * self;
 
227
        self = SETTINGS_MANAGER (obj);
 
228
        _g_object_unref0 (self->priv->settings);
 
229
        G_OBJECT_CLASS (settings_manager_parent_class)->finalize (obj);
 
230
}
 
231
 
 
232
 
 
233
GType settings_manager_get_type (void) {
 
234
        static volatile gsize settings_manager_type_id__volatile = 0;
 
235
        if (g_once_init_enter (&settings_manager_type_id__volatile)) {
 
236
                static const GTypeInfo g_define_type_info = { sizeof (SettingsManagerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) settings_manager_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SettingsManager), 0, (GInstanceInitFunc) settings_manager_instance_init, NULL };
 
237
                GType settings_manager_type_id;
 
238
                settings_manager_type_id = g_type_register_static (G_TYPE_OBJECT, "SettingsManager", &g_define_type_info, 0);
 
239
                g_once_init_leave (&settings_manager_type_id__volatile, settings_manager_type_id);
 
240
        }
 
241
        return settings_manager_type_id__volatile;
 
242
}
 
243
 
 
244
 
 
245
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
246
        if ((array != NULL) && (destroy_func != NULL)) {
 
247
                int i;
 
248
                for (i = 0; i < array_length; i = i + 1) {
 
249
                        if (((gpointer*) array)[i] != NULL) {
 
250
                                destroy_func (((gpointer*) array)[i]);
 
251
                        }
 
252
                }
 
253
        }
 
254
}
 
255
 
 
256
 
 
257
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
258
        _vala_array_destroy (array, array_length, destroy_func);
 
259
        g_free (array);
 
260
}
 
261
 
 
262
 
 
263
static gint _vala_array_length (gpointer array) {
 
264
        int length;
 
265
        length = 0;
 
266
        if (array) {
 
267
                while (((gpointer*) array)[length]) {
 
268
                        length++;
 
269
                }
 
270
        }
 
271
        return length;
 
272
}
 
273
 
 
274
 
 
275