← Back to branch summary

~ubuntu-branches/ubuntu/precise/inkscape/precise-updates

« back to all changes in this revision

Viewing changes to src/helper/sp-marshal.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alex Valavanis
  • Date: 2010-09-12 19:44:58 UTC
  • mfrom: (1.1.12 upstream) (45.1.3 maverick)
  • Revision ID: james.westby@ubuntu.com-20100912194458-4sjwmbl7dlsrk5dc
Tags: 0.48.0-1ubuntu1
https://launchpad.net/bugs/628048
https://launchpad.net/bugs/401567
https://launchpad.net/bugs/456248
https://launchpad.net/bugs/463602
https://launchpad.net/bugs/591986
https://launchpad.net/bugs/513319
* Merge with Debian unstable (LP: #628048, LP: #401567, LP: #456248, 
  LP: #463602, LP: #591986)
* debian/control: 
  - Ubuntu maintainers
  - Promote python-lxml, python-numpy, python-uniconvertor to Recommends.
  - Demote pstoedit to Suggests (universe package).
  - Suggests ttf-dejavu instead of ttf-bitstream-vera (LP: #513319)
* debian/rules:
  - Run intltool-update on build (Ubuntu-specific).
  - Add translation domain to .desktop files (Ubuntu-specific).
* debian/dirs:
  - Add usr/share/pixmaps.  Allow inkscape.xpm installation
* drop 50-poppler-API.dpatch (now upstream)
* drop 51-paste-in-unwritable-directory.dpatch (now upstream) 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/helper/sp-marshal.cpp
48
48
#endif /* !G_ENABLE_DEBUG */
49
49
 
50
50
 
51
 
/* NONE:NONE (./helper/sp-marshal.list:2) */
52
 
 
53
 
/* NONE:UINT (./helper/sp-marshal.list:3) */
54
 
 
55
 
/* NONE:POINTER (./helper/sp-marshal.list:4) */
56
 
 
57
 
/* NONE:POINTER,BOOLEAN (./helper/sp-marshal.list:5) */
58
 
void
59
 
sp_marshal_VOID__POINTER_BOOLEAN (GClosure     *closure,
60
 
                                  GValue       *return_value G_GNUC_UNUSED,
61
 
                                  guint         n_param_values,
62
 
                                  const GValue *param_values,
63
 
                                  gpointer      invocation_hint G_GNUC_UNUSED,
64
 
                                  gpointer      marshal_data)
65
 
{
66
 
  typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer     data1,
67
 
                                                      gpointer     arg_1,
68
 
                                                      gboolean     arg_2,
69
 
                                                      gpointer     data2);
70
 
  register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
71
 
  register GCClosure *cc = (GCClosure*) closure;
72
 
  register gpointer data1, data2;
73
 
 
74
 
  g_return_if_fail (n_param_values == 3);
75
 
 
76
 
  if (G_CCLOSURE_SWAP_DATA (closure))
77
 
    {
78
 
      data1 = closure->data;
79
 
      data2 = g_value_peek_pointer (param_values + 0);
80
 
    }
81
 
  else
82
 
    {
83
 
      data1 = g_value_peek_pointer (param_values + 0);
84
 
      data2 = closure->data;
85
 
    }
86
 
  callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
87
 
 
88
 
  callback (data1,
89
 
            g_marshal_value_peek_pointer (param_values + 1),
90
 
            g_marshal_value_peek_boolean (param_values + 2),
91
 
            data2);
92
 
}
93
 
 
94
 
/* NONE:POINTER,UINT (./helper/sp-marshal.list:6) */
 
51
/* NONE:POINTER,UINT (./helper/sp-marshal.list:2) */
95
52
void
96
53
sp_marshal_VOID__POINTER_UINT (GClosure     *closure,
97
54
                               GValue       *return_value G_GNUC_UNUSED,
128
85
            data2);
129
86
}
130
87
 
131
 
/* NONE:POINTER,DOUBLE (./helper/sp-marshal.list:7) */
132
 
void
133
 
sp_marshal_VOID__POINTER_DOUBLE (GClosure     *closure,
134
 
                                 GValue       *return_value G_GNUC_UNUSED,
135
 
                                 guint         n_param_values,
136
 
                                 const GValue *param_values,
137
 
                                 gpointer      invocation_hint G_GNUC_UNUSED,
138
 
                                 gpointer      marshal_data)
139
 
{
140
 
  typedef void (*GMarshalFunc_VOID__POINTER_DOUBLE) (gpointer     data1,
141
 
                                                     gpointer     arg_1,
142
 
                                                     gdouble      arg_2,
143
 
                                                     gpointer     data2);
144
 
  register GMarshalFunc_VOID__POINTER_DOUBLE callback;
145
 
  register GCClosure *cc = (GCClosure*) closure;
146
 
  register gpointer data1, data2;
147
 
 
148
 
  g_return_if_fail (n_param_values == 3);
149
 
 
150
 
  if (G_CCLOSURE_SWAP_DATA (closure))
151
 
    {
152
 
      data1 = closure->data;
153
 
      data2 = g_value_peek_pointer (param_values + 0);
154
 
    }
155
 
  else
156
 
    {
157
 
      data1 = g_value_peek_pointer (param_values + 0);
158
 
      data2 = closure->data;
159
 
    }
160
 
  callback = (GMarshalFunc_VOID__POINTER_DOUBLE) (marshal_data ? marshal_data : cc->callback);
161
 
 
162
 
  callback (data1,
163
 
            g_marshal_value_peek_pointer (param_values + 1),
164
 
            g_marshal_value_peek_double (param_values + 2),
165
 
            data2);
166
 
}
167
 
 
168
 
/* NONE:DOUBLE,DOUBLE (./helper/sp-marshal.list:8) */
169
 
void
170
 
sp_marshal_VOID__DOUBLE_DOUBLE (GClosure     *closure,
171
 
                                GValue       *return_value G_GNUC_UNUSED,
172
 
                                guint         n_param_values,
173
 
                                const GValue *param_values,
174
 
                                gpointer      invocation_hint G_GNUC_UNUSED,
175
 
                                gpointer      marshal_data)
176
 
{
177
 
  typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer     data1,
178
 
                                                    gdouble      arg_1,
179
 
                                                    gdouble      arg_2,
180
 
                                                    gpointer     data2);
181
 
  register GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
182
 
  register GCClosure *cc = (GCClosure*) closure;
183
 
  register gpointer data1, data2;
184
 
 
185
 
  g_return_if_fail (n_param_values == 3);
186
 
 
187
 
  if (G_CCLOSURE_SWAP_DATA (closure))
188
 
    {
189
 
      data1 = closure->data;
190
 
      data2 = g_value_peek_pointer (param_values + 0);
191
 
    }
192
 
  else
193
 
    {
194
 
      data1 = g_value_peek_pointer (param_values + 0);
195
 
      data2 = closure->data;
196
 
    }
197
 
  callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
198
 
 
199
 
  callback (data1,
200
 
            g_marshal_value_peek_double (param_values + 1),
201
 
            g_marshal_value_peek_double (param_values + 2),
202
 
            data2);
203
 
}
204
 
 
205
 
/* NONE:STRING,BOOL (./helper/sp-marshal.list:9) */
206
 
void
207
 
sp_marshal_VOID__STRING_BOOLEAN (GClosure     *closure,
208
 
                                 GValue       *return_value G_GNUC_UNUSED,
209
 
                                 guint         n_param_values,
210
 
                                 const GValue *param_values,
211
 
                                 gpointer      invocation_hint G_GNUC_UNUSED,
212
 
                                 gpointer      marshal_data)
213
 
{
214
 
  typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer     data1,
215
 
                                                     gpointer     arg_1,
216
 
                                                     gboolean     arg_2,
217
 
                                                     gpointer     data2);
218
 
  register GMarshalFunc_VOID__STRING_BOOLEAN callback;
219
 
  register GCClosure *cc = (GCClosure*) closure;
220
 
  register gpointer data1, data2;
221
 
 
222
 
  g_return_if_fail (n_param_values == 3);
223
 
 
224
 
  if (G_CCLOSURE_SWAP_DATA (closure))
225
 
    {
226
 
      data1 = closure->data;
227
 
      data2 = g_value_peek_pointer (param_values + 0);
228
 
    }
229
 
  else
230
 
    {
231
 
      data1 = g_value_peek_pointer (param_values + 0);
232
 
      data2 = closure->data;
233
 
    }
234
 
  callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
235
 
 
236
 
  callback (data1,
237
 
            g_marshal_value_peek_string (param_values + 1),
238
 
            g_marshal_value_peek_boolean (param_values + 2),
239
 
            data2);
240
 
}
241
 
 
242
 
/* BOOLEAN:NONE (./helper/sp-marshal.list:10) */
243
 
void
244
 
sp_marshal_BOOLEAN__VOID (GClosure     *closure,
245
 
                          GValue       *return_value G_GNUC_UNUSED,
246
 
                          guint         n_param_values,
247
 
                          const GValue *param_values,
248
 
                          gpointer      invocation_hint G_GNUC_UNUSED,
249
 
                          gpointer      marshal_data)
250
 
{
251
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
252
 
                                                  gpointer     data2);
253
 
  register GMarshalFunc_BOOLEAN__VOID callback;
254
 
  register GCClosure *cc = (GCClosure*) closure;
255
 
  register gpointer data1, data2;
256
 
  gboolean v_return;
257
 
 
258
 
  g_return_if_fail (return_value != NULL);
259
 
  g_return_if_fail (n_param_values == 1);
260
 
 
261
 
  if (G_CCLOSURE_SWAP_DATA (closure))
262
 
    {
263
 
      data1 = closure->data;
264
 
      data2 = g_value_peek_pointer (param_values + 0);
265
 
    }
266
 
  else
267
 
    {
268
 
      data1 = g_value_peek_pointer (param_values + 0);
269
 
      data2 = closure->data;
270
 
    }
271
 
  callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
272
 
 
273
 
  v_return = callback (data1,
274
 
                       data2);
275
 
 
276
 
  g_value_set_boolean (return_value, v_return);
277
 
}
278
 
 
279
 
/* BOOLEAN:UINT (./helper/sp-marshal.list:11) */
280
 
void
281
 
sp_marshal_BOOLEAN__UINT (GClosure     *closure,
282
 
                          GValue       *return_value G_GNUC_UNUSED,
283
 
                          guint         n_param_values,
284
 
                          const GValue *param_values,
285
 
                          gpointer      invocation_hint G_GNUC_UNUSED,
286
 
                          gpointer      marshal_data)
287
 
{
288
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer     data1,
289
 
                                                  guint        arg_1,
290
 
                                                  gpointer     data2);
291
 
  register GMarshalFunc_BOOLEAN__UINT callback;
292
 
  register GCClosure *cc = (GCClosure*) closure;
293
 
  register gpointer data1, data2;
294
 
  gboolean v_return;
295
 
 
296
 
  g_return_if_fail (return_value != NULL);
297
 
  g_return_if_fail (n_param_values == 2);
298
 
 
299
 
  if (G_CCLOSURE_SWAP_DATA (closure))
300
 
    {
301
 
      data1 = closure->data;
302
 
      data2 = g_value_peek_pointer (param_values + 0);
303
 
    }
304
 
  else
305
 
    {
306
 
      data1 = g_value_peek_pointer (param_values + 0);
307
 
      data2 = closure->data;
308
 
    }
309
 
  callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
310
 
 
311
 
  v_return = callback (data1,
312
 
                       g_marshal_value_peek_uint (param_values + 1),
313
 
                       data2);
314
 
 
315
 
  g_value_set_boolean (return_value, v_return);
316
 
}
317
 
 
318
 
/* BOOLEAN:POINTER (./helper/sp-marshal.list:12) */
 
88
/* BOOLEAN:POINTER (./helper/sp-marshal.list:3) */
319
89
void
320
90
sp_marshal_BOOLEAN__POINTER (GClosure     *closure,
321
91
                             GValue       *return_value G_GNUC_UNUSED,
354
124
  g_value_set_boolean (return_value, v_return);
355
125
}
356
126
 
357
 
/* BOOLEAN:POINTER,UINT (./helper/sp-marshal.list:13) */
 
127
/* BOOLEAN:POINTER,UINT (./helper/sp-marshal.list:4) */
358
128
void
359
129
sp_marshal_BOOLEAN__POINTER_UINT (GClosure     *closure,
360
130
                                  GValue       *return_value G_GNUC_UNUSED,
395
165
  g_value_set_boolean (return_value, v_return);
396
166
}
397
167
 
398
 
/* BOOLEAN:POINTER,POINTER (./helper/sp-marshal.list:14) */
 
168
/* BOOLEAN:POINTER,POINTER (./helper/sp-marshal.list:5) */
399
169
void
400
170
sp_marshal_BOOLEAN__POINTER_POINTER (GClosure     *closure,
401
171
                                     GValue       *return_value G_GNUC_UNUSED,
436
206
  g_value_set_boolean (return_value, v_return);
437
207
}
438
208
 
439
 
/* INT:POINTER,POINTER (./helper/sp-marshal.list:15) */
 
209
/* INT:POINTER,POINTER (./helper/sp-marshal.list:6) */
440
210
void
441
211
sp_marshal_INT__POINTER_POINTER (GClosure     *closure,
442
212
                                 GValue       *return_value G_GNUC_UNUSED,
477
247
  g_value_set_int (return_value, v_return);
478
248
}
479
249
 
480
 
/* DOUBLE:POINTER,UINT (./helper/sp-marshal.list:16) */
 
250
/* DOUBLE:POINTER,UINT (./helper/sp-marshal.list:7) */
481
251
void
482
252
sp_marshal_DOUBLE__POINTER_UINT (GClosure     *closure,
483
253
                                 GValue       *return_value G_GNUC_UNUSED,