← Back to branch summary

~ubuntu-branches/ubuntu/hardy/vala/hardy

« back to all changes in this revision

Viewing changes to vala/valasignal.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge, Marc-Andre Lureau, Sebastian Dröge
  • Date: 2007-10-15 14:37:51 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071015143751-zy7hqcyjutdyfkg3
Tags: 0.1.4-1
[ Marc-Andre Lureau ]
* New Upstream Version
* debian/patches:
  + Remove patch no longer needed in 0.1.4
* debian/rules
  + Add xsltproc build dependency for the Vala manual.
  + Add libenchant-dev build dependency for enchant test case.
* debian/control, debian/vala-doc.install:
  + Add a "vala-doc" documentation package.

[ Sebastian Dröge ]
* debian/control:
  + Let vala-doc suggest valac/devhelp and don't depend on libvala0.
* debian/libvala-dev.install:
  + Add the new vapicheck utility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vala/valasignal.c
5
5
 * This library is free software; you can redistribute it and/or
6
6
 * modify it under the terms of the GNU Lesser General Public
7
7
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
 
8
 * version 2.1 of the License, or (at your option) any later version.
9
9
 
10
10
 * This library is distributed in the hope that it will be useful,
11
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
20
 *      Jürg Billeter <j@bitron.ch>
21
21
 */
22
22
 
23
 
#include "valasignal.h"
 
23
#include <vala/valasignal.h>
24
24
#include <gee/arraylist.h>
25
25
#include <gee/list.h>
26
26
#include <gee/readonlycollection.h>
28
28
#include <vala/valacallback.h>
29
29
#include <vala/valasourcereference.h>
30
30
#include <vala/valasymbol.h>
31
 
#include <vala/valasignal.h>
32
31
#include <vala/valaformalparameter.h>
33
32
#include <vala/valascope.h>
34
33
#include <vala/valadatatype.h>
37
36
 
38
37
struct _ValaSignalPrivate {
39
38
        ValaTypeReference* _return_type;
40
 
        ValaMemberAccessibility _access;
41
39
        gboolean _has_emitter;
42
40
        GeeList* parameters;
43
41
        ValaCallback* generated_callback;
48
46
enum  {
49
47
        VALA_SIGNAL_DUMMY_PROPERTY,
50
48
        VALA_SIGNAL_RETURN_TYPE,
51
 
        VALA_SIGNAL_ACCESS,
52
49
        VALA_SIGNAL_HAS_EMITTER
53
50
};
54
51
static GeeCollection* vala_signal_real_get_parameters (ValaInvokable* base);
72
69
 * @param source      reference to source code
73
70
 * @return            newly created signal
74
71
 */
75
 
ValaSignal* vala_signal_new (const char* name, ValaTypeReference* return_type, ValaSourceReference* source_reference)
76
 
{
 
72
ValaSignal* vala_signal_new (const char* name, ValaTypeReference* return_type, ValaSourceReference* source_reference) {
77
73
        ValaSignal * self;
78
74
        g_return_val_if_fail (name != NULL, NULL);
79
75
        g_return_val_if_fail (VALA_IS_TYPE_REFERENCE (return_type), NULL);
91
87
 *
92
88
 * @param param a formal parameter
93
89
 */
94
 
void vala_signal_add_parameter (ValaSignal* self, ValaFormalParameter* param)
95
 
{
 
90
void vala_signal_add_parameter (ValaSignal* self, ValaFormalParameter* param) {
96
91
        g_return_if_fail (VALA_IS_SIGNAL (self));
97
92
        g_return_if_fail (VALA_IS_FORMAL_PARAMETER (param));
98
93
        gee_collection_add (GEE_COLLECTION (self->priv->parameters), param);
99
 
        vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) self)), vala_symbol_get_name (((ValaSymbol*) param)), VALA_SYMBOL (param));
 
94
        vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (self)), vala_symbol_get_name (VALA_SYMBOL (param)), VALA_SYMBOL (param));
100
95
}
101
96
 
102
97
 
103
 
static GeeCollection* vala_signal_real_get_parameters (ValaInvokable* base)
104
 
{
 
98
static GeeCollection* vala_signal_real_get_parameters (ValaInvokable* base) {
105
99
        ValaSignal * self;
106
 
        self = ((ValaSignal*) base);
 
100
        self = VALA_SIGNAL (base);
107
101
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->parameters)));
108
102
}
109
103
 
110
104
 
111
 
static ValaTypeReference* vala_signal_real_get_return_type (ValaInvokable* base)
112
 
{
 
105
static ValaTypeReference* vala_signal_real_get_return_type (ValaInvokable* base) {
113
106
        ValaSignal * self;
114
 
        self = ((ValaSignal*) base);
 
107
        self = VALA_SIGNAL (base);
115
108
        return g_object_ref (vala_signal_get_return_type (self));
116
109
}
117
110
 
118
111
 
119
 
static gboolean vala_signal_real_is_invokable (ValaInvokable* base)
120
 
{
 
112
static gboolean vala_signal_real_is_invokable (ValaInvokable* base) {
121
113
        ValaSignal * self;
122
 
        self = ((ValaSignal*) base);
 
114
        self = VALA_SIGNAL (base);
123
115
        return TRUE;
124
116
}
125
117
 
129
121
 *
130
122
 * @return callback
131
123
 */
132
 
ValaCallback* vala_signal_get_callback (ValaSignal* self)
133
 
{
134
 
        ValaCallback* __temp4;
 
124
ValaCallback* vala_signal_get_callback (ValaSignal* self) {
 
125
        ValaCallback* _tmp1;
135
126
        g_return_val_if_fail (VALA_IS_SIGNAL (self), NULL);
136
127
        if (self->priv->generated_callback == NULL) {
137
 
                ValaCallback* __temp3;
 
128
                ValaCallback* _tmp0;
138
129
                ValaTypeReference* sender_type;
139
130
                ValaFormalParameter* sender_param;
140
 
                __temp3 = NULL;
141
 
                self->priv->generated_callback = (__temp3 = vala_callback_new (NULL, vala_signal_get_return_type (self), NULL), (self->priv->generated_callback == NULL ? NULL : (self->priv->generated_callback = (g_object_unref (self->priv->generated_callback), NULL))), __temp3);
 
131
                _tmp0 = NULL;
 
132
                self->priv->generated_callback = (_tmp0 = vala_callback_new (NULL, vala_signal_get_return_type (self), NULL), (self->priv->generated_callback == NULL ? NULL : (self->priv->generated_callback = (g_object_unref (self->priv->generated_callback), NULL))), _tmp0);
142
133
                vala_callback_set_instance (self->priv->generated_callback, TRUE);
143
134
                sender_type = vala_type_reference_new ();
144
 
                vala_type_reference_set_data_type (sender_type, VALA_DATA_TYPE (vala_symbol_get_parent_symbol (((ValaSymbol*) self))));
 
135
                vala_type_reference_set_data_type (sender_type, VALA_DATA_TYPE (vala_symbol_get_parent_symbol (VALA_SYMBOL (self))));
145
136
                sender_param = vala_formal_parameter_new ("sender", sender_type, NULL);
146
137
                vala_callback_add_parameter (self->priv->generated_callback, sender_param);
147
138
                {
162
153
                (sender_type == NULL ? NULL : (sender_type = (g_object_unref (sender_type), NULL)));
163
154
                (sender_param == NULL ? NULL : (sender_param = (g_object_unref (sender_param), NULL)));
164
155
        }
165
 
        __temp4 = NULL;
166
 
        return (__temp4 = self->priv->generated_callback, (__temp4 == NULL ? NULL : g_object_ref (__temp4)));
 
156
        _tmp1 = NULL;
 
157
        return (_tmp1 = self->priv->generated_callback, (_tmp1 == NULL ? NULL : g_object_ref (_tmp1)));
167
158
}
168
159
 
169
160
 
172
163
 *
173
164
 * @return the name to be used in C code
174
165
 */
175
 
char* vala_signal_get_cname (ValaSignal* self)
176
 
{
177
 
        const char* __temp8;
 
166
char* vala_signal_get_cname (ValaSignal* self) {
 
167
        const char* _tmp2;
178
168
        g_return_val_if_fail (VALA_IS_SIGNAL (self), NULL);
179
169
        if (self->priv->cname == NULL) {
180
 
                char* __temp7;
181
 
                const char* __temp6;
182
 
                __temp7 = NULL;
183
 
                __temp6 = NULL;
184
 
                self->priv->cname = (__temp7 = (__temp6 = vala_symbol_get_name (((ValaSymbol*) self)), (__temp6 == NULL ? NULL : g_strdup (__temp6))), (self->priv->cname = (g_free (self->priv->cname), NULL)), __temp7);
 
170
                char* _tmp1;
 
171
                const char* _tmp0;
 
172
                _tmp1 = NULL;
 
173
                _tmp0 = NULL;
 
174
                self->priv->cname = (_tmp1 = (_tmp0 = vala_symbol_get_name (VALA_SYMBOL (self)), (_tmp0 == NULL ? NULL : g_strdup (_tmp0))), (self->priv->cname = (g_free (self->priv->cname), NULL)), _tmp1);
185
175
        }
186
 
        __temp8 = NULL;
187
 
        return (__temp8 = self->priv->cname, (__temp8 == NULL ? NULL : g_strdup (__temp8)));
 
176
        _tmp2 = NULL;
 
177
        return (_tmp2 = self->priv->cname, (_tmp2 == NULL ? NULL : g_strdup (_tmp2)));
188
178
}
189
179
 
190
180
 
191
 
void vala_signal_set_cname (ValaSignal* self, const char* cname)
192
 
{
193
 
        char* __temp11;
194
 
        const char* __temp10;
 
181
void vala_signal_set_cname (ValaSignal* self, const char* cname) {
 
182
        char* _tmp1;
 
183
        const char* _tmp0;
195
184
        g_return_if_fail (VALA_IS_SIGNAL (self));
196
 
        __temp11 = NULL;
197
 
        __temp10 = NULL;
198
 
        self->priv->cname = (__temp11 = (__temp10 = cname, (__temp10 == NULL ? NULL : g_strdup (__temp10))), (self->priv->cname = (g_free (self->priv->cname), NULL)), __temp11);
 
185
        _tmp1 = NULL;
 
186
        _tmp0 = NULL;
 
187
        self->priv->cname = (_tmp1 = (_tmp0 = cname, (_tmp0 == NULL ? NULL : g_strdup (_tmp0))), (self->priv->cname = (g_free (self->priv->cname), NULL)), _tmp1);
199
188
}
200
189
 
201
190
 
204
193
 *
205
194
 * @return string literal to be used in C code
206
195
 */
207
 
ValaCCodeConstant* vala_signal_get_canonical_cconstant (ValaSignal* self)
208
 
{
 
196
ValaCCodeConstant* vala_signal_get_canonical_cconstant (ValaSignal* self) {
209
197
        GString* str;
210
 
        const char* __temp12;
 
198
        const char* _tmp0;
211
199
        char* i;
212
 
        ValaCCodeConstant* __temp15;
 
200
        ValaCCodeConstant* _tmp3;
213
201
        g_return_val_if_fail (VALA_IS_SIGNAL (self), NULL);
214
202
        str = g_string_new ("\"");
215
 
        __temp12 = NULL;
216
 
        i = (__temp12 = vala_symbol_get_name (((ValaSymbol*) self)), (__temp12 == NULL ? NULL : g_strdup (__temp12)));
 
203
        _tmp0 = NULL;
 
204
        i = (_tmp0 = vala_symbol_get_name (VALA_SYMBOL (self)), (_tmp0 == NULL ? NULL : g_strdup (_tmp0)));
217
205
        while (g_utf8_strlen (i, -1) > 0) {
218
206
                gunichar c;
219
 
                char* __temp14;
220
 
                const char* __temp13;
 
207
                char* _tmp2;
 
208
                const char* _tmp1;
221
209
                c = g_utf8_get_char (i);
222
210
                if (c == '_') {
223
211
                        g_string_append_c (str, '-');
224
212
                } else {
225
213
                        g_string_append_unichar (str, c);
226
214
                }
227
 
                __temp14 = NULL;
228
 
                __temp13 = NULL;
229
 
                i = (__temp14 = (__temp13 = g_utf8_next_char (i), (__temp13 == NULL ? NULL : g_strdup (__temp13))), (i = (g_free (i), NULL)), __temp14);
 
215
                _tmp2 = NULL;
 
216
                _tmp1 = NULL;
 
217
                i = (_tmp2 = (_tmp1 = g_utf8_next_char (i), (_tmp1 == NULL ? NULL : g_strdup (_tmp1))), (i = (g_free (i), NULL)), _tmp2);
230
218
        }
231
219
        g_string_append_c (str, '"');
232
 
        __temp15 = NULL;
233
 
        return (__temp15 = vala_ccode_constant_new (str->str), (str == NULL ? NULL : (str = (g_string_free (str, TRUE), NULL))), (i = (g_free (i), NULL)), __temp15);
 
220
        _tmp3 = NULL;
 
221
        return (_tmp3 = vala_ccode_constant_new (str->str), (str == NULL ? NULL : (str = (g_string_free (str, TRUE), NULL))), (i = (g_free (i), NULL)), _tmp3);
234
222
        (str == NULL ? NULL : (str = (g_string_free (str, TRUE), NULL)));
235
223
        (i = (g_free (i), NULL));
236
224
}
237
225
 
238
226
 
239
 
static void vala_signal_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor)
240
 
{
 
227
static void vala_signal_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor) {
241
228
        ValaSignal * self;
242
 
        self = ((ValaSignal*) base);
 
229
        self = VALA_SIGNAL (base);
243
230
        g_return_if_fail (VALA_IS_CODE_VISITOR (visitor));
244
231
        vala_code_visitor_visit_member (visitor, VALA_MEMBER (self));
245
232
        vala_code_visitor_visit_signal (visitor, self);
246
233
}
247
234
 
248
235
 
249
 
static void vala_signal_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor)
250
 
{
 
236
static void vala_signal_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor) {
251
237
        ValaSignal * self;
252
 
        self = ((ValaSignal*) base);
 
238
        self = VALA_SIGNAL (base);
253
239
        g_return_if_fail (VALA_IS_CODE_VISITOR (visitor));
254
240
        vala_code_node_accept (VALA_CODE_NODE (vala_signal_get_return_type (self)), visitor);
255
241
        {
273
259
/**
274
260
 * Process all associated attributes.
275
261
 */
276
 
void vala_signal_process_attributes (ValaSignal* self)
277
 
{
 
262
void vala_signal_process_attributes (ValaSignal* self) {
278
263
        g_return_if_fail (VALA_IS_SIGNAL (self));
279
264
        {
280
265
                GList* a_collection;
281
266
                GList* a_it;
282
 
                a_collection = ((ValaCodeNode*) self)->attributes;
 
267
                a_collection = VALA_CODE_NODE (self)->attributes;
283
268
                for (a_it = a_collection; a_it != NULL; a_it = a_it->next) {
284
 
                        ValaAttribute* __temp16;
 
269
                        ValaAttribute* _tmp0;
285
270
                        ValaAttribute* a;
286
 
                        __temp16 = NULL;
287
 
                        a = (__temp16 = a_it->data, (__temp16 == NULL ? NULL : g_object_ref (__temp16)));
 
271
                        _tmp0 = NULL;
 
272
                        a = (_tmp0 = a_it->data, (_tmp0 == NULL ? NULL : g_object_ref (_tmp0)));
288
273
                        {
289
274
                                if (g_utf8_collate (vala_attribute_get_name (a), "HasEmitter") == 0) {
290
275
                                        vala_signal_set_has_emitter (self, TRUE);
296
281
}
297
282
 
298
283
 
299
 
static gboolean vala_signal_real_get_lock_used (ValaLockable* base)
300
 
{
 
284
static gboolean vala_signal_real_get_lock_used (ValaLockable* base) {
301
285
        ValaSignal * self;
302
 
        self = ((ValaSignal*) base);
 
286
        self = VALA_SIGNAL (base);
303
287
        return self->priv->lock_used;
304
288
}
305
289
 
306
290
 
307
 
static void vala_signal_real_set_lock_used (ValaLockable* base, gboolean used)
308
 
{
 
291
static void vala_signal_real_set_lock_used (ValaLockable* base, gboolean used) {
309
292
        ValaSignal * self;
310
 
        self = ((ValaSignal*) base);
 
293
        self = VALA_SIGNAL (base);
311
294
        self->priv->lock_used = used;
312
295
}
313
296
 
314
297
 
315
 
ValaTypeReference* vala_signal_get_return_type (ValaSignal* self)
316
 
{
 
298
ValaTypeReference* vala_signal_get_return_type (ValaSignal* self) {
317
299
        g_return_val_if_fail (VALA_IS_SIGNAL (self), NULL);
318
300
        return self->priv->_return_type;
319
301
}
320
302
 
321
303
 
322
 
void vala_signal_set_return_type (ValaSignal* self, ValaTypeReference* value)
323
 
{
324
 
        ValaTypeReference* __temp19;
325
 
        g_return_if_fail (VALA_IS_SIGNAL (self));
326
 
        __temp19 = NULL;
327
 
        self->priv->_return_type = (__temp19 = g_object_ref (value), (self->priv->_return_type == NULL ? NULL : (self->priv->_return_type = (g_object_unref (self->priv->_return_type), NULL))), __temp19);
328
 
}
329
 
 
330
 
 
331
 
ValaMemberAccessibility vala_signal_get_access (ValaSignal* self)
332
 
{
333
 
        g_return_val_if_fail (VALA_IS_SIGNAL (self), 0);
334
 
        return self->priv->_access;
335
 
}
336
 
 
337
 
 
338
 
void vala_signal_set_access (ValaSignal* self, ValaMemberAccessibility value)
339
 
{
340
 
        g_return_if_fail (VALA_IS_SIGNAL (self));
341
 
        self->priv->_access = value;
342
 
}
343
 
 
344
 
 
345
 
gboolean vala_signal_get_has_emitter (ValaSignal* self)
346
 
{
 
304
void vala_signal_set_return_type (ValaSignal* self, ValaTypeReference* value) {
 
305
        ValaTypeReference* _tmp1;
 
306
        g_return_if_fail (VALA_IS_SIGNAL (self));
 
307
        _tmp1 = NULL;
 
308
        self->priv->_return_type = (_tmp1 = g_object_ref (value), (self->priv->_return_type == NULL ? NULL : (self->priv->_return_type = (g_object_unref (self->priv->_return_type), NULL))), _tmp1);
 
309
}
 
310
 
 
311
 
 
312
gboolean vala_signal_get_has_emitter (ValaSignal* self) {
347
313
        g_return_val_if_fail (VALA_IS_SIGNAL (self), FALSE);
348
314
        return self->priv->_has_emitter;
349
315
}
350
316
 
351
317
 
352
 
void vala_signal_set_has_emitter (ValaSignal* self, gboolean value)
353
 
{
 
318
void vala_signal_set_has_emitter (ValaSignal* self, gboolean value) {
354
319
        g_return_if_fail (VALA_IS_SIGNAL (self));
355
320
        self->priv->_has_emitter = value;
356
321
}
357
322
 
358
323
 
359
 
static void vala_signal_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
360
 
{
 
324
static void vala_signal_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
361
325
        ValaSignal * self;
362
326
        self = VALA_SIGNAL (object);
363
327
        switch (property_id) {
364
328
                case VALA_SIGNAL_RETURN_TYPE:
365
329
                g_value_set_object (value, vala_signal_get_return_type (self));
366
330
                break;
367
 
                case VALA_SIGNAL_ACCESS:
368
 
                g_value_set_int (value, vala_signal_get_access (self));
369
 
                break;
370
331
                case VALA_SIGNAL_HAS_EMITTER:
371
332
                g_value_set_boolean (value, vala_signal_get_has_emitter (self));
372
333
                break;
 
334
                default:
 
335
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
336
                break;
373
337
        }
374
338
}
375
339
 
376
340
 
377
 
static void vala_signal_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
378
 
{
 
341
static void vala_signal_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
379
342
        ValaSignal * self;
380
343
        self = VALA_SIGNAL (object);
381
344
        switch (property_id) {
382
345
                case VALA_SIGNAL_RETURN_TYPE:
383
346
                vala_signal_set_return_type (self, g_value_get_object (value));
384
347
                break;
385
 
                case VALA_SIGNAL_ACCESS:
386
 
                vala_signal_set_access (self, g_value_get_int (value));
387
 
                break;
388
348
                case VALA_SIGNAL_HAS_EMITTER:
389
349
                vala_signal_set_has_emitter (self, g_value_get_boolean (value));
390
350
                break;
 
351
                default:
 
352
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
353
                break;
391
354
        }
392
355
}
393
356
 
394
357
 
395
 
static void vala_signal_class_init (ValaSignalClass * klass)
396
 
{
 
358
static void vala_signal_class_init (ValaSignalClass * klass) {
397
359
        vala_signal_parent_class = g_type_class_peek_parent (klass);
398
360
        g_type_class_add_private (klass, sizeof (ValaSignalPrivate));
399
361
        G_OBJECT_CLASS (klass)->get_property = vala_signal_get_property;
401
363
        G_OBJECT_CLASS (klass)->dispose = vala_signal_dispose;
402
364
        VALA_CODE_NODE_CLASS (klass)->accept = vala_signal_real_accept;
403
365
        VALA_CODE_NODE_CLASS (klass)->accept_children = vala_signal_real_accept_children;
404
 
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_SIGNAL_RETURN_TYPE, g_param_spec_object ("return-type", "foo", "bar", VALA_TYPE_TYPE_REFERENCE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
405
 
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_SIGNAL_ACCESS, g_param_spec_int ("access", "foo", "bar", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
406
 
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_SIGNAL_HAS_EMITTER, g_param_spec_boolean ("has-emitter", "foo", "bar", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
366
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_SIGNAL_RETURN_TYPE, g_param_spec_object ("return-type", "return-type", "return-type", VALA_TYPE_TYPE_REFERENCE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
367
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_SIGNAL_HAS_EMITTER, g_param_spec_boolean ("has-emitter", "has-emitter", "has-emitter", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
407
368
}
408
369
 
409
370
 
410
 
static void vala_signal_vala_invokable_interface_init (ValaInvokableIface * iface)
411
 
{
 
371
static void vala_signal_vala_invokable_interface_init (ValaInvokableIface * iface) {
412
372
        vala_signal_vala_invokable_parent_iface = g_type_interface_peek_parent (iface);
413
373
        iface->get_parameters = vala_signal_real_get_parameters;
414
374
        iface->get_return_type = vala_signal_real_get_return_type;
416
376
}
417
377
 
418
378
 
419
 
static void vala_signal_vala_lockable_interface_init (ValaLockableIface * iface)
420
 
{
 
379
static void vala_signal_vala_lockable_interface_init (ValaLockableIface * iface) {
421
380
        vala_signal_vala_lockable_parent_iface = g_type_interface_peek_parent (iface);
422
381
        iface->get_lock_used = vala_signal_real_get_lock_used;
423
382
        iface->set_lock_used = vala_signal_real_set_lock_used;
424
383
}
425
384
 
426
385
 
427
 
static void vala_signal_init (ValaSignal * self)
428
 
{
 
386
static void vala_signal_init (ValaSignal * self) {
429
387
        self->priv = VALA_SIGNAL_GET_PRIVATE (self);
430
388
        self->priv->parameters = GEE_LIST (gee_array_list_new (g_object_ref, g_object_unref, g_direct_equal));
431
389
        self->priv->lock_used = FALSE;
432
390
}
433
391
 
434
392
 
435
 
static void vala_signal_dispose (GObject * obj)
436
 
{
 
393
static void vala_signal_dispose (GObject * obj) {
437
394
        ValaSignal * self;
438
 
        ValaSignalClass * klass;
439
 
        GObjectClass * parent_class;
440
395
        self = VALA_SIGNAL (obj);
441
396
        (self->priv->_return_type == NULL ? NULL : (self->priv->_return_type = (g_object_unref (self->priv->_return_type), NULL)));
442
397
        (self->priv->parameters == NULL ? NULL : (self->priv->parameters = (g_object_unref (self->priv->parameters), NULL)));
443
398
        (self->priv->generated_callback == NULL ? NULL : (self->priv->generated_callback = (g_object_unref (self->priv->generated_callback), NULL)));
444
399
        (self->priv->cname = (g_free (self->priv->cname), NULL));
445
 
        klass = VALA_SIGNAL_CLASS (g_type_class_peek (VALA_TYPE_SIGNAL));
446
 
        parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
447
 
        parent_class->dispose (obj);
 
400
        G_OBJECT_CLASS (vala_signal_parent_class)->dispose (obj);
448
401
}
449
402
 
450
403
 
451
 
GType vala_signal_get_type (void)
452
 
{
 
404
GType vala_signal_get_type (void) {
453
405
        static GType vala_signal_type_id = 0;
454
406
        if (G_UNLIKELY (vala_signal_type_id == 0)) {
455
407
                static const GTypeInfo g_define_type_info = { sizeof (ValaSignalClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_signal_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaSignal), 0, (GInstanceInitFunc) vala_signal_init };