← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/core/gimpparamspecs.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/core/gimpparamspecs.h
 
1
/* GIMP - The GNU Image Manipulation Program
 
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; either version 2 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
17
 */
 
18
 
 
19
#ifndef __GIMP_PARAM_SPECS_H__
 
20
#define __GIMP_PARAM_SPECS_H__
 
21
 
 
22
 
 
23
/*
 
24
 * Keep in sync with libgimpconfig/gimpconfig-params.h
 
25
 */
 
26
#define GIMP_PARAM_NO_VALIDATE (1 << (6 + G_PARAM_USER_SHIFT))
 
27
 
 
28
 
 
29
/*
 
30
 * GIMP_TYPE_INT32
 
31
 */
 
32
 
 
33
#define GIMP_TYPE_INT32               (gimp_int32_get_type ())
 
34
#define GIMP_VALUE_HOLDS_INT32(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
35
                                       GIMP_TYPE_INT32))
 
36
 
 
37
GType   gimp_int32_get_type           (void) G_GNUC_CONST;
 
38
 
 
39
 
 
40
/*
 
41
 * GIMP_TYPE_PARAM_INT32
 
42
 */
 
43
 
 
44
#define GIMP_TYPE_PARAM_INT32           (gimp_param_int32_get_type ())
 
45
#define GIMP_PARAM_SPEC_INT32(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT32, GimpParamSpecInt32))
 
46
#define GIMP_IS_PARAM_SPEC_INT32(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT32))
 
47
 
 
48
typedef struct _GimpParamSpecInt32 GimpParamSpecInt32;
 
49
 
 
50
struct _GimpParamSpecInt32
 
51
{
 
52
  GParamSpecInt parent_instance;
 
53
};
 
54
 
 
55
GType        gimp_param_int32_get_type (void) G_GNUC_CONST;
 
56
 
 
57
GParamSpec * gimp_param_spec_int32     (const gchar *name,
 
58
                                        const gchar *nick,
 
59
                                        const gchar *blurb,
 
60
                                        gint         minimum,
 
61
                                        gint         maximum,
 
62
                                        gint         default_value,
 
63
                                        GParamFlags  flags);
 
64
 
 
65
 
 
66
/*
 
67
 * GIMP_TYPE_INT16
 
68
 */
 
69
 
 
70
#define GIMP_TYPE_INT16               (gimp_int16_get_type ())
 
71
#define GIMP_VALUE_HOLDS_INT16(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
72
                                       GIMP_TYPE_INT16))
 
73
 
 
74
GType   gimp_int16_get_type           (void) G_GNUC_CONST;
 
75
 
 
76
 
 
77
/*
 
78
 * GIMP_TYPE_PARAM_INT16
 
79
 */
 
80
 
 
81
#define GIMP_TYPE_PARAM_INT16           (gimp_param_int16_get_type ())
 
82
#define GIMP_PARAM_SPEC_INT16(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT16, GimpParamSpecInt16))
 
83
#define GIMP_IS_PARAM_SPEC_INT16(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT16))
 
84
 
 
85
typedef struct _GimpParamSpecInt16 GimpParamSpecInt16;
 
86
 
 
87
struct _GimpParamSpecInt16
 
88
{
 
89
  GParamSpecInt parent_instance;
 
90
};
 
91
 
 
92
GType        gimp_param_int16_get_type (void) G_GNUC_CONST;
 
93
 
 
94
GParamSpec * gimp_param_spec_int16     (const gchar *name,
 
95
                                        const gchar *nick,
 
96
                                        const gchar *blurb,
 
97
                                        gint         minimum,
 
98
                                        gint         maximum,
 
99
                                        gint         default_value,
 
100
                                        GParamFlags  flags);
 
101
 
 
102
 
 
103
/*
 
104
 * GIMP_TYPE_INT8
 
105
 */
 
106
 
 
107
#define GIMP_TYPE_INT8               (gimp_int8_get_type ())
 
108
#define GIMP_VALUE_HOLDS_INT8(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
109
                                      GIMP_TYPE_INT8))
 
110
 
 
111
GType   gimp_int8_get_type           (void) G_GNUC_CONST;
 
112
 
 
113
 
 
114
/*
 
115
 * GIMP_TYPE_PARAM_INT8
 
116
 */
 
117
 
 
118
#define GIMP_TYPE_PARAM_INT8           (gimp_param_int8_get_type ())
 
119
#define GIMP_PARAM_SPEC_INT8(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT8, GimpParamSpecInt8))
 
120
#define GIMP_IS_PARAM_SPEC_INT8(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT8))
 
121
 
 
122
typedef struct _GimpParamSpecInt8 GimpParamSpecInt8;
 
123
 
 
124
struct _GimpParamSpecInt8
 
125
{
 
126
  GParamSpecUInt parent_instance;
 
127
};
 
128
 
 
129
GType        gimp_param_int8_get_type (void) G_GNUC_CONST;
 
130
 
 
131
GParamSpec * gimp_param_spec_int8     (const gchar *name,
 
132
                                       const gchar *nick,
 
133
                                       const gchar *blurb,
 
134
                                       guint        minimum,
 
135
                                       guint        maximum,
 
136
                                       guint        default_value,
 
137
                                       GParamFlags  flags);
 
138
 
 
139
 
 
140
/*
 
141
 * GIMP_TYPE_PARAM_STRING
 
142
 */
 
143
 
 
144
#define GIMP_TYPE_PARAM_STRING           (gimp_param_string_get_type ())
 
145
#define GIMP_PARAM_SPEC_STRING(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_STRING, GimpParamSpecString))
 
146
#define GIMP_IS_PARAM_SPEC_STRING(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_STRING))
 
147
 
 
148
typedef struct _GimpParamSpecString GimpParamSpecString;
 
149
 
 
150
struct _GimpParamSpecString
 
151
{
 
152
  GParamSpecString parent_instance;
 
153
 
 
154
  guint            no_validate : 1;
 
155
  guint            null_ok     : 1;
 
156
};
 
157
 
 
158
GType        gimp_param_string_get_type (void) G_GNUC_CONST;
 
159
 
 
160
GParamSpec * gimp_param_spec_string     (const gchar *name,
 
161
                                         const gchar *nick,
 
162
                                         const gchar *blurb,
 
163
                                         gboolean     no_validate,
 
164
                                         gboolean     null_ok,
 
165
                                         const gchar *default_value,
 
166
                                         GParamFlags  flags);
 
167
 
 
168
 
 
169
/*
 
170
 * GIMP_TYPE_PARAM_ENUM
 
171
 */
 
172
 
 
173
#define GIMP_TYPE_PARAM_ENUM           (gimp_param_enum_get_type ())
 
174
#define GIMP_PARAM_SPEC_ENUM(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_ENUM, GimpParamSpecEnum))
 
175
 
 
176
#define GIMP_IS_PARAM_SPEC_ENUM(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_ENUM))
 
177
 
 
178
typedef struct _GimpParamSpecEnum GimpParamSpecEnum;
 
179
 
 
180
struct _GimpParamSpecEnum
 
181
{
 
182
  GParamSpecEnum  parent_instance;
 
183
 
 
184
  GSList         *excluded_values;
 
185
};
 
186
 
 
187
GType        gimp_param_enum_get_type     (void) G_GNUC_CONST;
 
188
 
 
189
GParamSpec * gimp_param_spec_enum         (const gchar       *name,
 
190
                                           const gchar       *nick,
 
191
                                           const gchar       *blurb,
 
192
                                           GType              enum_type,
 
193
                                           gint               default_value,
 
194
                                           GParamFlags        flags);
 
195
 
 
196
void   gimp_param_spec_enum_exclude_value (GimpParamSpecEnum *espec,
 
197
                                           gint               value);
 
198
 
 
199
 
 
200
/*
 
201
 * GIMP_TYPE_IMAGE_ID
 
202
 */
 
203
 
 
204
#define GIMP_TYPE_IMAGE_ID               (gimp_image_id_get_type ())
 
205
#define GIMP_VALUE_HOLDS_IMAGE_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
206
                                          GIMP_TYPE_IMAGE_ID))
 
207
 
 
208
GType   gimp_image_id_get_type           (void) G_GNUC_CONST;
 
209
 
 
210
 
 
211
/*
 
212
 * GIMP_TYPE_PARAM_IMAGE_ID
 
213
 */
 
214
 
 
215
#define GIMP_TYPE_PARAM_IMAGE_ID           (gimp_param_image_id_get_type ())
 
216
#define GIMP_PARAM_SPEC_IMAGE_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_IMAGE_ID, GimpParamSpecImageID))
 
217
#define GIMP_IS_PARAM_SPEC_IMAGE_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_IMAGE_ID))
 
218
 
 
219
typedef struct _GimpParamSpecImageID GimpParamSpecImageID;
 
220
 
 
221
struct _GimpParamSpecImageID
 
222
{
 
223
  GParamSpecInt  parent_instance;
 
224
 
 
225
  Gimp          *gimp;
 
226
  gboolean       none_ok;
 
227
};
 
228
 
 
229
GType        gimp_param_image_id_get_type (void) G_GNUC_CONST;
 
230
 
 
231
GParamSpec * gimp_param_spec_image_id     (const gchar  *name,
 
232
                                           const gchar  *nick,
 
233
                                           const gchar  *blurb,
 
234
                                           Gimp         *gimp,
 
235
                                           gboolean      none_ok,
 
236
                                           GParamFlags   flags);
 
237
 
 
238
GimpImage  * gimp_value_get_image         (const GValue *value,
 
239
                                           Gimp         *gimp);
 
240
void         gimp_value_set_image         (GValue       *value,
 
241
                                           GimpImage    *image);
 
242
 
 
243
 
 
244
 
 
245
/*
 
246
 * GIMP_TYPE_ITEM_ID
 
247
 */
 
248
 
 
249
#define GIMP_TYPE_ITEM_ID               (gimp_item_id_get_type ())
 
250
#define GIMP_VALUE_HOLDS_ITEM_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
251
                                         GIMP_TYPE_ITEM_ID))
 
252
 
 
253
GType   gimp_item_id_get_type           (void) G_GNUC_CONST;
 
254
 
 
255
 
 
256
/*
 
257
 * GIMP_TYPE_PARAM_ITEM_ID
 
258
 */
 
259
 
 
260
#define GIMP_TYPE_PARAM_ITEM_ID           (gimp_param_item_id_get_type ())
 
261
#define GIMP_PARAM_SPEC_ITEM_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_ITEM_ID, GimpParamSpecItemID))
 
262
#define GIMP_IS_PARAM_SPEC_ITEM_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_ITEM_ID))
 
263
 
 
264
typedef struct _GimpParamSpecItemID GimpParamSpecItemID;
 
265
 
 
266
struct _GimpParamSpecItemID
 
267
{
 
268
  GParamSpecInt  parent_instance;
 
269
 
 
270
  Gimp          *gimp;
 
271
  GType          item_type;
 
272
  gboolean       none_ok;
 
273
};
 
274
 
 
275
GType        gimp_param_item_id_get_type (void) G_GNUC_CONST;
 
276
 
 
277
GParamSpec * gimp_param_spec_item_id     (const gchar  *name,
 
278
                                          const gchar  *nick,
 
279
                                          const gchar  *blurb,
 
280
                                          Gimp         *gimp,
 
281
                                          GType         item_type,
 
282
                                          gboolean      none_ok,
 
283
                                          GParamFlags   flags);
 
284
 
 
285
GimpItem   * gimp_value_get_item         (const GValue *value,
 
286
                                          Gimp         *gimp,
 
287
                                          GType         item_type);
 
288
void         gimp_value_set_item         (GValue       *value,
 
289
                                          GimpItem     *item);
 
290
 
 
291
 
 
292
/*
 
293
 * GIMP_TYPE_DRAWABLE_ID
 
294
 */
 
295
 
 
296
#define GIMP_TYPE_DRAWABLE_ID               (gimp_drawable_id_get_type ())
 
297
#define GIMP_VALUE_HOLDS_DRAWABLE_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
298
                                             GIMP_TYPE_DRAWABLE_ID))
 
299
 
 
300
GType   gimp_drawable_id_get_type           (void) G_GNUC_CONST;
 
301
 
 
302
 
 
303
/*
 
304
 * GIMP_TYPE_PARAM_DRAWABLE_ID
 
305
 */
 
306
 
 
307
#define GIMP_TYPE_PARAM_DRAWABLE_ID           (gimp_param_drawable_id_get_type ())
 
308
#define GIMP_PARAM_SPEC_DRAWABLE_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_DRAWABLE_ID, GimpParamSpecDrawableID))
 
309
#define GIMP_IS_PARAM_SPEC_DRAWABLE_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_DRAWABLE_ID))
 
310
 
 
311
typedef struct _GimpParamSpecDrawableID GimpParamSpecDrawableID;
 
312
 
 
313
struct _GimpParamSpecDrawableID
 
314
{
 
315
  GimpParamSpecItemID parent_instance;
 
316
};
 
317
 
 
318
GType         gimp_param_drawable_id_get_type (void) G_GNUC_CONST;
 
319
 
 
320
GParamSpec  * gimp_param_spec_drawable_id     (const gchar  *name,
 
321
                                               const gchar  *nick,
 
322
                                               const gchar  *blurb,
 
323
                                               Gimp         *gimp,
 
324
                                               gboolean      none_ok,
 
325
                                               GParamFlags   flags);
 
326
 
 
327
GimpDrawable * gimp_value_get_drawable        (const GValue *value,
 
328
                                               Gimp         *gimp);
 
329
void           gimp_value_set_drawable        (GValue       *value,
 
330
                                               GimpDrawable *drawable);
 
331
 
 
332
 
 
333
/*
 
334
 * GIMP_TYPE_LAYER_ID
 
335
 */
 
336
 
 
337
#define GIMP_TYPE_LAYER_ID               (gimp_layer_id_get_type ())
 
338
#define GIMP_VALUE_HOLDS_LAYER_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
339
                                          GIMP_TYPE_LAYER_ID))
 
340
 
 
341
GType   gimp_layer_id_get_type           (void) G_GNUC_CONST;
 
342
 
 
343
 
 
344
/*
 
345
 * GIMP_TYPE_PARAM_LAYER_ID
 
346
 */
 
347
 
 
348
#define GIMP_TYPE_PARAM_LAYER_ID           (gimp_param_layer_id_get_type ())
 
349
#define GIMP_PARAM_SPEC_LAYER_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_LAYER_ID, GimpParamSpecLayerID))
 
350
#define GIMP_IS_PARAM_SPEC_LAYER_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_LAYER_ID))
 
351
 
 
352
typedef struct _GimpParamSpecLayerID GimpParamSpecLayerID;
 
353
 
 
354
struct _GimpParamSpecLayerID
 
355
{
 
356
  GimpParamSpecDrawableID parent_instance;
 
357
};
 
358
 
 
359
GType        gimp_param_layer_id_get_type (void) G_GNUC_CONST;
 
360
 
 
361
GParamSpec * gimp_param_spec_layer_id     (const gchar  *name,
 
362
                                           const gchar  *nick,
 
363
                                           const gchar  *blurb,
 
364
                                           Gimp         *gimp,
 
365
                                           gboolean      none_ok,
 
366
                                           GParamFlags   flags);
 
367
 
 
368
GimpLayer  * gimp_value_get_layer         (const GValue *value,
 
369
                                           Gimp         *gimp);
 
370
void         gimp_value_set_layer         (GValue       *value,
 
371
                                           GimpLayer    *layer);
 
372
 
 
373
 
 
374
/*
 
375
 * GIMP_TYPE_CHANNEL_ID
 
376
 */
 
377
 
 
378
#define GIMP_TYPE_CHANNEL_ID               (gimp_channel_id_get_type ())
 
379
#define GIMP_VALUE_HOLDS_CHANNEL_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
380
                                            GIMP_TYPE_CHANNEL_ID))
 
381
 
 
382
GType   gimp_channel_id_get_type           (void) G_GNUC_CONST;
 
383
 
 
384
 
 
385
/*
 
386
 * GIMP_TYPE_PARAM_CHANNEL_ID
 
387
 */
 
388
 
 
389
#define GIMP_TYPE_PARAM_CHANNEL_ID           (gimp_param_channel_id_get_type ())
 
390
#define GIMP_PARAM_SPEC_CHANNEL_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_CHANNEL_ID, GimpParamSpecChannelID))
 
391
#define GIMP_IS_PARAM_SPEC_CHANNEL_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_CHANNEL_ID))
 
392
 
 
393
typedef struct _GimpParamSpecChannelID GimpParamSpecChannelID;
 
394
 
 
395
struct _GimpParamSpecChannelID
 
396
{
 
397
  GimpParamSpecDrawableID parent_instance;
 
398
};
 
399
 
 
400
GType         gimp_param_channel_id_get_type (void) G_GNUC_CONST;
 
401
 
 
402
GParamSpec  * gimp_param_spec_channel_id     (const gchar  *name,
 
403
                                              const gchar  *nick,
 
404
                                              const gchar  *blurb,
 
405
                                              Gimp         *gimp,
 
406
                                              gboolean      none_ok,
 
407
                                              GParamFlags   flags);
 
408
 
 
409
GimpChannel * gimp_value_get_channel         (const GValue *value,
 
410
                                              Gimp         *gimp);
 
411
void          gimp_value_set_channel         (GValue       *value,
 
412
                                              GimpChannel  *channel);
 
413
 
 
414
 
 
415
/*
 
416
 * GIMP_TYPE_LAYER_MASK_ID
 
417
 */
 
418
 
 
419
#define GIMP_TYPE_LAYER_MASK_ID               (gimp_layer_mask_id_get_type ())
 
420
#define GIMP_VALUE_HOLDS_LAYER_MASK_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
421
                                               GIMP_TYPE_LAYER_MASK_ID))
 
422
 
 
423
GType   gimp_layer_mask_id_get_type           (void) G_GNUC_CONST;
 
424
 
 
425
 
 
426
/*
 
427
 * GIMP_TYPE_PARAM_LAYER_MASK_ID
 
428
 */
 
429
 
 
430
#define GIMP_TYPE_PARAM_LAYER_MASK_ID           (gimp_param_layer_mask_id_get_type ())
 
431
#define GIMP_PARAM_SPEC_LAYER_MASK_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_LAYER_MASK_ID, GimpParamSpecLayerMaskID))
 
432
#define GIMP_IS_PARAM_SPEC_LAYER_MASK_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_LAYER_MASK_ID))
 
433
 
 
434
typedef struct _GimpParamSpecLayerMaskID GimpParamSpecLayerMaskID;
 
435
 
 
436
struct _GimpParamSpecLayerMaskID
 
437
{
 
438
  GimpParamSpecChannelID parent_instance;
 
439
};
 
440
 
 
441
GType           gimp_param_layer_mask_id_get_type (void) G_GNUC_CONST;
 
442
 
 
443
GParamSpec    * gimp_param_spec_layer_mask_id     (const gchar   *name,
 
444
                                                   const gchar   *nick,
 
445
                                                   const gchar   *blurb,
 
446
                                                   Gimp          *gimp,
 
447
                                                   gboolean       none_ok,
 
448
                                                   GParamFlags    flags);
 
449
 
 
450
GimpLayerMask * gimp_value_get_layer_mask         (const GValue  *value,
 
451
                                                   Gimp          *gimp);
 
452
void            gimp_value_set_layer_mask         (GValue        *value,
 
453
                                                   GimpLayerMask *layer_mask);
 
454
 
 
455
 
 
456
/*
 
457
 * GIMP_TYPE_SELECTION_ID
 
458
 */
 
459
 
 
460
#define GIMP_TYPE_SELECTION_ID               (gimp_selection_id_get_type ())
 
461
#define GIMP_VALUE_HOLDS_SELECTION_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
462
                                              GIMP_TYPE_SELECTION_ID))
 
463
 
 
464
GType   gimp_selection_id_get_type           (void) G_GNUC_CONST;
 
465
 
 
466
 
 
467
/*
 
468
 * GIMP_TYPE_PARAM_SELECTION_ID
 
469
 */
 
470
 
 
471
#define GIMP_TYPE_PARAM_SELECTION_ID           (gimp_param_selection_id_get_type ())
 
472
#define GIMP_PARAM_SPEC_SELECTION_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_SELECTION_ID, GimpParamSpecSelectionID))
 
473
#define GIMP_IS_PARAM_SPEC_SELECTION_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_SELECTION_ID))
 
474
 
 
475
typedef struct _GimpParamSpecSelectionID GimpParamSpecSelectionID;
 
476
 
 
477
struct _GimpParamSpecSelectionID
 
478
{
 
479
  GimpParamSpecChannelID parent_instance;
 
480
};
 
481
 
 
482
GType           gimp_param_selection_id_get_type (void) G_GNUC_CONST;
 
483
 
 
484
GParamSpec    * gimp_param_spec_selection_id     (const gchar   *name,
 
485
                                                  const gchar   *nick,
 
486
                                                  const gchar   *blurb,
 
487
                                                  Gimp          *gimp,
 
488
                                                  gboolean       none_ok,
 
489
                                                  GParamFlags    flags);
 
490
 
 
491
GimpSelection * gimp_value_get_selection         (const GValue  *value,
 
492
                                                  Gimp          *gimp);
 
493
void            gimp_value_set_selection         (GValue        *value,
 
494
                                                  GimpSelection *selection);
 
495
 
 
496
 
 
497
/*
 
498
 * GIMP_TYPE_VECTORS_ID
 
499
 */
 
500
 
 
501
#define GIMP_TYPE_VECTORS_ID               (gimp_vectors_id_get_type ())
 
502
#define GIMP_VALUE_HOLDS_VECTORS_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
503
                                            GIMP_TYPE_VECTORS_ID))
 
504
 
 
505
GType   gimp_vectors_id_get_type           (void) G_GNUC_CONST;
 
506
 
 
507
 
 
508
/*
 
509
 * GIMP_TYPE_PARAM_VECTORS_ID
 
510
 */
 
511
 
 
512
#define GIMP_TYPE_PARAM_VECTORS_ID           (gimp_param_vectors_id_get_type ())
 
513
#define GIMP_PARAM_SPEC_VECTORS_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_VECTORS_ID, GimpParamSpecVectorsID))
 
514
#define GIMP_IS_PARAM_SPEC_VECTORS_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_VECTORS_ID))
 
515
 
 
516
typedef struct _GimpParamSpecVectorsID GimpParamSpecVectorsID;
 
517
 
 
518
struct _GimpParamSpecVectorsID
 
519
{
 
520
  GimpParamSpecItemID parent_instance;
 
521
};
 
522
 
 
523
GType         gimp_param_vectors_id_get_type (void) G_GNUC_CONST;
 
524
 
 
525
GParamSpec  * gimp_param_spec_vectors_id     (const gchar  *name,
 
526
                                              const gchar  *nick,
 
527
                                              const gchar  *blurb,
 
528
                                              Gimp         *gimp,
 
529
                                              gboolean      none_ok,
 
530
                                              GParamFlags   flags);
 
531
 
 
532
GimpVectors * gimp_value_get_vectors         (const GValue *value,
 
533
                                              Gimp         *gimp);
 
534
void          gimp_value_set_vectors         (GValue       *value,
 
535
                                              GimpVectors  *vectors);
 
536
 
 
537
 
 
538
/*
 
539
 * GIMP_TYPE_DISPLAY_ID
 
540
 */
 
541
 
 
542
#define GIMP_TYPE_DISPLAY_ID               (gimp_display_id_get_type ())
 
543
#define GIMP_VALUE_HOLDS_DISPLAY_ID(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\
 
544
                                            GIMP_TYPE_DISPLAY_ID))
 
545
 
 
546
GType   gimp_display_id_get_type           (void) G_GNUC_CONST;
 
547
 
 
548
 
 
549
/*
 
550
 * GIMP_TYPE_PARAM_DISPLAY_ID
 
551
 */
 
552
 
 
553
#define GIMP_TYPE_PARAM_DISPLAY_ID           (gimp_param_display_id_get_type ())
 
554
#define GIMP_PARAM_SPEC_DISPLAY_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_DISPLAY_ID, GimpParamSpecDisplayID))
 
555
#define GIMP_IS_PARAM_SPEC_DISPLAY_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_DISPLAY_ID))
 
556
 
 
557
typedef struct _GimpParamSpecDisplayID GimpParamSpecDisplayID;
 
558
 
 
559
struct _GimpParamSpecDisplayID
 
560
{
 
561
  GParamSpecInt  parent_instance;
 
562
 
 
563
  Gimp          *gimp;
 
564
  gboolean       none_ok;
 
565
};
 
566
 
 
567
GType        gimp_param_display_id_get_type (void) G_GNUC_CONST;
 
568
 
 
569
GParamSpec * gimp_param_spec_display_id     (const gchar  *name,
 
570
                                             const gchar  *nick,
 
571
                                             const gchar  *blurb,
 
572
                                             Gimp         *gimp,
 
573
                                             gboolean      none_ok,
 
574
                                             GParamFlags   flags);
 
575
 
 
576
GimpObject * gimp_value_get_display         (const GValue *value,
 
577
                                             Gimp         *gimp);
 
578
void         gimp_value_set_display         (GValue       *value,
 
579
                                             GimpObject   *display);
 
580
 
 
581
 
 
582
/*
 
583
 * GIMP_TYPE_ARRAY
 
584
 */
 
585
 
 
586
typedef struct _GimpArray GimpArray;
 
587
 
 
588
struct _GimpArray
 
589
{
 
590
  guint8   *data;
 
591
  gsize     length;
 
592
  gboolean  static_data;
 
593
};
 
594
 
 
595
GimpArray * gimp_array_new  (const guint8    *data,
 
596
                             gsize            length,
 
597
                             gboolean         static_data);
 
598
GimpArray * gimp_array_copy (const GimpArray *array);
 
599
void        gimp_array_free (GimpArray       *array);
 
600
 
 
601
#define GIMP_TYPE_ARRAY               (gimp_array_get_type ())
 
602
#define GIMP_VALUE_HOLDS_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_ARRAY))
 
603
 
 
604
GType   gimp_array_get_type           (void) G_GNUC_CONST;
 
605
 
 
606
 
 
607
/*
 
608
 * GIMP_TYPE_PARAM_ARRAY
 
609
 */
 
610
 
 
611
#define GIMP_TYPE_PARAM_ARRAY           (gimp_param_array_get_type ())
 
612
#define GIMP_PARAM_SPEC_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_ARRAY, GimpParamSpecArray))
 
613
#define GIMP_IS_PARAM_SPEC_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_ARRAY))
 
614
 
 
615
typedef struct _GimpParamSpecArray GimpParamSpecArray;
 
616
 
 
617
struct _GimpParamSpecArray
 
618
{
 
619
  GParamSpecBoxed parent_instance;
 
620
};
 
621
 
 
622
GType        gimp_param_array_get_type (void) G_GNUC_CONST;
 
623
 
 
624
GParamSpec * gimp_param_spec_array     (const gchar  *name,
 
625
                                        const gchar  *nick,
 
626
                                        const gchar  *blurb,
 
627
                                        GParamFlags   flags);
 
628
 
 
629
 
 
630
/*
 
631
 * GIMP_TYPE_INT8_ARRAY
 
632
 */
 
633
 
 
634
#define GIMP_TYPE_INT8_ARRAY               (gimp_int8_array_get_type ())
 
635
#define GIMP_VALUE_HOLDS_INT8_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT8_ARRAY))
 
636
 
 
637
GType   gimp_int8_array_get_type           (void) G_GNUC_CONST;
 
638
 
 
639
 
 
640
/*
 
641
 * GIMP_TYPE_PARAM_INT8_ARRAY
 
642
 */
 
643
 
 
644
#define GIMP_TYPE_PARAM_INT8_ARRAY           (gimp_param_int8_array_get_type ())
 
645
#define GIMP_PARAM_SPEC_INT8_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT8_ARRAY, GimpParamSpecInt8Array))
 
646
#define GIMP_IS_PARAM_SPEC_INT8_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT8_ARRAY))
 
647
 
 
648
typedef struct _GimpParamSpecInt8Array GimpParamSpecInt8Array;
 
649
 
 
650
struct _GimpParamSpecInt8Array
 
651
{
 
652
  GimpParamSpecArray parent_instance;
 
653
};
 
654
 
 
655
GType          gimp_param_int8_array_get_type  (void) G_GNUC_CONST;
 
656
 
 
657
GParamSpec   * gimp_param_spec_int8_array      (const gchar  *name,
 
658
                                                const gchar  *nick,
 
659
                                                const gchar  *blurb,
 
660
                                                GParamFlags   flags);
 
661
 
 
662
const guint8 * gimp_value_get_int8array        (const GValue *value);
 
663
guint8       * gimp_value_dup_int8array        (const GValue *value);
 
664
void           gimp_value_set_int8array        (GValue       *value,
 
665
                                                const guint8 *array,
 
666
                                                gsize         length);
 
667
void           gimp_value_set_static_int8array (GValue       *value,
 
668
                                                const guint8 *array,
 
669
                                                gsize         length);
 
670
void           gimp_value_take_int8array       (GValue       *value,
 
671
                                                guint8       *array,
 
672
                                                gsize         length);
 
673
 
 
674
 
 
675
/*
 
676
 * GIMP_TYPE_INT16_ARRAY
 
677
 */
 
678
 
 
679
#define GIMP_TYPE_INT16_ARRAY               (gimp_int16_array_get_type ())
 
680
#define GIMP_VALUE_HOLDS_INT16_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT16_ARRAY))
 
681
 
 
682
GType   gimp_int16_array_get_type           (void) G_GNUC_CONST;
 
683
 
 
684
 
 
685
/*
 
686
 * GIMP_TYPE_PARAM_INT16_ARRAY
 
687
 */
 
688
 
 
689
#define GIMP_TYPE_PARAM_INT16_ARRAY           (gimp_param_int16_array_get_type ())
 
690
#define GIMP_PARAM_SPEC_INT16_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT16_ARRAY, GimpParamSpecInt16Array))
 
691
#define GIMP_IS_PARAM_SPEC_INT16_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT16_ARRAY))
 
692
 
 
693
typedef struct _GimpParamSpecInt16Array GimpParamSpecInt16Array;
 
694
 
 
695
struct _GimpParamSpecInt16Array
 
696
{
 
697
  GimpParamSpecArray parent_instance;
 
698
};
 
699
 
 
700
GType          gimp_param_int16_array_get_type  (void) G_GNUC_CONST;
 
701
 
 
702
GParamSpec   * gimp_param_spec_int16_array      (const gchar  *name,
 
703
                                                 const gchar  *nick,
 
704
                                                 const gchar  *blurb,
 
705
                                                 GParamFlags   flags);
 
706
 
 
707
const gint16 * gimp_value_get_int16array        (const GValue *value);
 
708
gint16       * gimp_value_dup_int16array        (const GValue *value);
 
709
void           gimp_value_set_int16array        (GValue       *value,
 
710
                                                 const gint16 *array,
 
711
                                                 gsize         length);
 
712
void           gimp_value_set_static_int16array (GValue       *value,
 
713
                                                 const gint16 *array,
 
714
                                                 gsize         length);
 
715
void           gimp_value_take_int16array       (GValue       *value,
 
716
                                                 gint16       *array,
 
717
                                                 gsize         length);
 
718
 
 
719
 
 
720
/*
 
721
 * GIMP_TYPE_INT32_ARRAY
 
722
 */
 
723
 
 
724
#define GIMP_TYPE_INT32_ARRAY               (gimp_int32_array_get_type ())
 
725
#define GIMP_VALUE_HOLDS_INT32_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT32_ARRAY))
 
726
 
 
727
GType   gimp_int32_array_get_type           (void) G_GNUC_CONST;
 
728
 
 
729
 
 
730
/*
 
731
 * GIMP_TYPE_PARAM_INT32_ARRAY
 
732
 */
 
733
 
 
734
#define GIMP_TYPE_PARAM_INT32_ARRAY           (gimp_param_int32_array_get_type ())
 
735
#define GIMP_PARAM_SPEC_INT32_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT32_ARRAY, GimpParamSpecInt32Array))
 
736
#define GIMP_IS_PARAM_SPEC_INT32_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT32_ARRAY))
 
737
 
 
738
typedef struct _GimpParamSpecInt32Array GimpParamSpecInt32Array;
 
739
 
 
740
struct _GimpParamSpecInt32Array
 
741
{
 
742
  GimpParamSpecArray parent_instance;
 
743
};
 
744
 
 
745
GType          gimp_param_int32_array_get_type  (void) G_GNUC_CONST;
 
746
 
 
747
GParamSpec   * gimp_param_spec_int32_array      (const gchar  *name,
 
748
                                                 const gchar  *nick,
 
749
                                                 const gchar  *blurb,
 
750
                                                 GParamFlags   flags);
 
751
 
 
752
const gint32 * gimp_value_get_int32array        (const GValue *value);
 
753
gint32       * gimp_value_dup_int32array        (const GValue *value);
 
754
void           gimp_value_set_int32array        (GValue       *value,
 
755
                                                 const gint32 *array,
 
756
                                                 gsize         length);
 
757
void           gimp_value_set_static_int32array (GValue       *value,
 
758
                                                 const gint32 *array,
 
759
                                                 gsize         length);
 
760
void           gimp_value_take_int32array       (GValue       *value,
 
761
                                                 gint32       *array,
 
762
                                                 gsize         length);
 
763
 
 
764
 
 
765
/*
 
766
 * GIMP_TYPE_FLOAT_ARRAY
 
767
 */
 
768
 
 
769
#define GIMP_TYPE_FLOAT_ARRAY               (gimp_float_array_get_type ())
 
770
#define GIMP_VALUE_HOLDS_FLOAT_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_FLOAT_ARRAY))
 
771
 
 
772
GType   gimp_float_array_get_type           (void) G_GNUC_CONST;
 
773
 
 
774
 
 
775
/*
 
776
 * GIMP_TYPE_PARAM_FLOAT_ARRAY
 
777
 */
 
778
 
 
779
#define GIMP_TYPE_PARAM_FLOAT_ARRAY           (gimp_param_float_array_get_type ())
 
780
#define GIMP_PARAM_SPEC_FLOAT_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_FLOAT_ARRAY, GimpParamSpecFloatArray))
 
781
#define GIMP_IS_PARAM_SPEC_FLOAT_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_FLOAT_ARRAY))
 
782
 
 
783
typedef struct _GimpParamSpecFloatArray GimpParamSpecFloatArray;
 
784
 
 
785
struct _GimpParamSpecFloatArray
 
786
{
 
787
  GimpParamSpecArray parent_instance;
 
788
};
 
789
 
 
790
GType           gimp_param_float_array_get_type  (void) G_GNUC_CONST;
 
791
 
 
792
GParamSpec    * gimp_param_spec_float_array      (const gchar  *name,
 
793
                                                  const gchar  *nick,
 
794
                                                  const gchar  *blurb,
 
795
                                                  GParamFlags   flags);
 
796
 
 
797
const gdouble * gimp_value_get_floatarray        (const GValue  *value);
 
798
gdouble       * gimp_value_dup_floatarray        (const GValue  *value);
 
799
void            gimp_value_set_floatarray        (GValue        *value,
 
800
                                                  const gdouble *array,
 
801
                                                  gsize         length);
 
802
void            gimp_value_set_static_floatarray (GValue        *value,
 
803
                                                  const gdouble *array,
 
804
                                                  gsize         length);
 
805
void            gimp_value_take_floatarray       (GValue        *value,
 
806
                                                  gdouble       *array,
 
807
                                                  gsize         length);
 
808
 
 
809
 
 
810
/*
 
811
 * GIMP_TYPE_STRING_ARRAY
 
812
 */
 
813
 
 
814
GimpArray * gimp_string_array_new  (const gchar     **data,
 
815
                                    gsize             length,
 
816
                                    gboolean          static_data);
 
817
GimpArray * gimp_string_array_copy (const GimpArray  *array);
 
818
void        gimp_string_array_free (GimpArray        *array);
 
819
 
 
820
#define GIMP_TYPE_STRING_ARRAY               (gimp_string_array_get_type ())
 
821
#define GIMP_VALUE_HOLDS_STRING_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_STRING_ARRAY))
 
822
 
 
823
GType   gimp_string_array_get_type           (void) G_GNUC_CONST;
 
824
 
 
825
 
 
826
/*
 
827
 * GIMP_TYPE_PARAM_STRING_ARRAY
 
828
 */
 
829
 
 
830
#define GIMP_TYPE_PARAM_STRING_ARRAY           (gimp_param_string_array_get_type ())
 
831
#define GIMP_PARAM_SPEC_STRING_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_STRING_ARRAY, GimpParamSpecStringArray))
 
832
#define GIMP_IS_PARAM_SPEC_STRING_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_STRING_ARRAY))
 
833
 
 
834
typedef struct _GimpParamSpecStringArray GimpParamSpecStringArray;
 
835
 
 
836
struct _GimpParamSpecStringArray
 
837
{
 
838
  GParamSpecBoxed parent_instance;
 
839
};
 
840
 
 
841
GType          gimp_param_string_array_get_type  (void) G_GNUC_CONST;
 
842
 
 
843
GParamSpec   * gimp_param_spec_string_array      (const gchar  *name,
 
844
                                                  const gchar  *nick,
 
845
                                                  const gchar  *blurb,
 
846
                                                  GParamFlags   flags);
 
847
 
 
848
const gchar ** gimp_value_get_stringarray        (const GValue *value);
 
849
gchar       ** gimp_value_dup_stringarray        (const GValue *value);
 
850
void           gimp_value_set_stringarray        (GValue       *value,
 
851
                                                  const gchar **array,
 
852
                                                  gsize         length);
 
853
void           gimp_value_set_static_stringarray (GValue       *value,
 
854
                                                  const gchar **array,
 
855
                                                  gsize         length);
 
856
void           gimp_value_take_stringarray       (GValue       *value,
 
857
                                                  gchar       **array,
 
858
                                                  gsize         length);
 
859
 
 
860
 
 
861
#endif  /*  __GIMP_PARAM_SPECS_H__  */