← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gimp/vivid

« back to all changes in this revision

Viewing changes to tools/pdbgen/pdb.pl

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-08 18:50:03 UTC
  • mto: (1.1.26) (0.5.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 71.
  • Revision ID: package-import@ubuntu.com-20120508185003-tltkvbaysf8d2426
Import upstream version 2.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/pdbgen/pdb.pl
1
1
# GIMP - The GNU Image Manipulation Program
2
2
# Copyright (C) 1998-2003 Manish Singh <yosh@gimp.org>
3
3
 
4
 
# This program is free software; you can redistribute it and/or modify
 
4
# This program is free software: you can redistribute it and/or modify
5
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
 
6
# the Free Software Foundation; either version 3 of the License, or
7
7
# (at your option) any later version.
8
8
 
9
9
# This program is distributed in the hope that it will be useful,
12
12
# GNU General Public License for more details.
13
13
 
14
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.
 
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
16
 
18
17
package Gimp::CodeGen::pdb;
19
18
 
20
19
%arg_types = (
21
 
    int32  => { name           => 'INT32',
22
 
                type           => 'gint32 ',
23
 
                const_type     => 'gint32 ',
24
 
                init_value     => '0',
25
 
                get_value_func => '$var = g_value_get_int ($value)',
26
 
                set_value_func => 'g_value_set_int ($value, $var)' },
27
 
    int16  => { name           => 'INT16',
28
 
                type           => 'gint16 ',
29
 
                const_type     => 'gint16 ',
30
 
                init_value     => '0',
31
 
                get_value_func => '$var = g_value_get_int ($value)',
32
 
                set_value_func => 'g_value_set_int ($value, $var)' },
33
 
    int8   => { name           => 'INT8' ,
34
 
                type           => 'guint8 ',
35
 
                const_type     => 'guint8 ',
36
 
                init_value     => '0',
37
 
                get_value_func => '$var = g_value_get_uint ($value)',
38
 
                set_value_func => 'g_value_set_uint ($value, $var)' },
39
 
 
40
 
    float  => { name           => 'FLOAT',
41
 
                type           => 'gdouble ',
42
 
                const_type     => 'gdouble ',
43
 
                init_value     => '0.0',
44
 
                get_value_func => '$var = g_value_get_double ($value)',
45
 
                set_value_func => 'g_value_set_double ($value, $var)' },
46
 
    string => { name           => 'STRING',
47
 
                type           => 'gchar *',
48
 
                const_type     => 'const gchar *',
49
 
                init_value     => 'NULL',
50
 
                get_value_func => '$var = g_value_get_string ($value)',
51
 
                set_value_func => 'g_value_take_string ($value, $var)' },
 
20
    int32       => { name           => 'INT32',
 
21
                     type           => 'gint32 ',
 
22
                     const_type     => 'gint32 ',
 
23
                     init_value     => '0',
 
24
                     get_value_func => '$var = g_value_get_int ($value)',
 
25
                     set_value_func => 'g_value_set_int ($value, $var)' },
 
26
 
 
27
    int16       => { name           => 'INT16',
 
28
                     type           => 'gint16 ',
 
29
                     const_type     => 'gint16 ',
 
30
                     init_value     => '0',
 
31
                     get_value_func => '$var = g_value_get_int ($value)',
 
32
                     set_value_func => 'g_value_set_int ($value, $var)' },
 
33
 
 
34
    int8        => { name           => 'INT8' ,
 
35
                     type           => 'guint8 ',
 
36
                     const_type     => 'guint8 ',
 
37
                     init_value     => '0',
 
38
                     get_value_func => '$var = g_value_get_uint ($value)',
 
39
                     set_value_func => 'g_value_set_uint ($value, $var)' },
 
40
 
 
41
    float       => { name           => 'FLOAT',
 
42
                     type           => 'gdouble ',
 
43
                     const_type     => 'gdouble ',
 
44
                     init_value     => '0.0',
 
45
                     get_value_func => '$var = g_value_get_double ($value)',
 
46
                     set_value_func => 'g_value_set_double ($value, $var)' },
 
47
 
 
48
    string      => { name           => 'STRING',
 
49
                     type           => 'gchar *',
 
50
                     const_type     => 'const gchar *',
 
51
                     init_value     => 'NULL',
 
52
                     get_value_func => '$var = g_value_get_string ($value)',
 
53
                     set_value_func => 'g_value_take_string ($value, $var)' },
52
54
 
53
55
    int32array  => { name           => 'INT32ARRAY',
54
56
                     type           => 'gint32 *',
57
59
                     init_value     => 'NULL',
58
60
                     get_value_func => '$var = gimp_value_get_int32array ($value)',
59
61
                     set_value_func => 'gimp_value_take_int32array ($value, $var, $var_len)' },
 
62
 
60
63
    int16array  => { name           => 'INT16ARRAY',
61
64
                     type           => 'gint16 *',
62
65
                     const_type     => 'const gint16 *',
64
67
                     init_value     => 'NULL',
65
68
                     get_value_func => '$var = gimp_value_get_int16array ($value)',
66
69
                     set_value_func => 'gimp_value_take_int16array ($value, $var, $var_len)' },
 
70
 
67
71
    int8array   => { name           => 'INT8ARRAY',
68
72
                     type           => 'guint8 *',
69
73
                     const_type     => 'const guint8 *',
71
75
                     init_value     => 'NULL',
72
76
                     get_value_func => '$var = gimp_value_get_int8array ($value)',
73
77
                     set_value_func => 'gimp_value_take_int8array ($value, $var, $var_len)' },
 
78
 
74
79
    floatarray  => { name           => 'FLOATARRAY',
75
80
                     type           => 'gdouble *',
76
81
                     const_type     => 'const gdouble *',
78
83
                     init_value     => 'NULL',
79
84
                     get_value_func => '$var = gimp_value_get_floatarray ($value)',
80
85
                     set_value_func => 'gimp_value_take_floatarray ($value, $var, $var_len)' },
 
86
 
81
87
    stringarray => { name           => 'STRINGARRAY',
82
88
                     type           => 'gchar **',
83
89
                     const_type     => 'const gchar **',
85
91
                     init_value     => 'NULL',
86
92
                     get_value_func => '$var = gimp_value_get_stringarray ($value)',
87
93
                     set_value_func => 'gimp_value_take_stringarray ($value, $var, $var_len)' },
 
94
 
88
95
    colorarray  => { name           => 'COLORARRAY',
89
96
                     type           => 'GimpRGB *',
90
97
                     const_type     => 'const GimpRGB *',
93
100
                     get_value_func => '$var = gimp_value_get_colorarray ($value)',
94
101
                     set_value_func => 'gimp_value_take_colorarray ($value, $var, $var_len)' },
95
102
 
96
 
    color => { name           => 'COLOR' , 
97
 
               type           => 'GimpRGB ',
98
 
               const_type     => 'GimpRGB ',
99
 
               struct         => 1,
100
 
               init_value     => '{ 0.0, 0.0, 0.0, 1.0 }',
101
 
               get_value_func => 'gimp_value_get_rgb ($value, &$var)',
102
 
               set_value_func => 'gimp_value_set_rgb ($value, &$var)',
103
 
               headers        => [ qw("libgimpcolor/gimpcolor.h") ] },
104
 
 
105
 
    display    => { name           => 'DISPLAY',
106
 
                    type           => 'GimpObject *',
107
 
                    const_type     => 'GimpObject *',
108
 
                    id             => 1,
109
 
                    init_value     => 'NULL',
110
 
                    get_value_func => '$var = gimp_value_get_display ($value, gimp)',
111
 
                    set_value_func => 'gimp_value_set_display ($value, $var)' },
112
 
    image      => { name           => 'IMAGE',
113
 
                    type           => 'GimpImage *', 
114
 
                    const_type     => 'GimpImage *', 
115
 
                    id             => 1,
116
 
                    init_value     => 'NULL',
117
 
                    get_value_func => '$var = gimp_value_get_image ($value, gimp)',
118
 
                    set_value_func => 'gimp_value_set_image ($value, $var)',
119
 
                    headers        => [ qw("core/gimpimage.h") ] },
120
 
    layer      => { name           => 'LAYER',
121
 
                    type           => 'GimpLayer *', 
122
 
                    const_type     => 'GimpLayer *', 
123
 
                    id             => 1,
124
 
                    init_value     => 'NULL',
125
 
                    get_value_func => '$var = gimp_value_get_layer ($value, gimp)',
126
 
                    set_value_func => 'gimp_value_set_layer ($value, $var)',
127
 
                    headers        => [ qw("core/gimplayer.h") ] },
128
 
    channel    => { name           => 'CHANNEL',
129
 
                    type           => 'GimpChannel *',
130
 
                    const_type     => 'GimpChannel *',
131
 
                    id             => 1,
132
 
                    init_value     => 'NULL',
133
 
                    get_value_func => '$var = gimp_value_get_channel ($value, gimp)',
134
 
                    set_value_func => 'gimp_value_set_channel ($value, $var)',
135
 
                    headers        => [ qw("core/gimpchannel.h") ] },
136
 
    drawable   => { name           => 'DRAWABLE',
137
 
                    type           => 'GimpDrawable *',
138
 
                    const_type     => 'GimpDrawable *',
139
 
                    id             => 1,
140
 
                    init_value     => 'NULL',
141
 
                    get_value_func => '$var = gimp_value_get_drawable ($value, gimp)',
142
 
                    set_value_func => 'gimp_value_set_drawable ($value, $var)',
143
 
                    headers        => [ qw("core/gimpdrawable.h") ] },
144
 
    selection  => { name           => 'SELECTION',
145
 
                    type           => 'GimpSelection *',
146
 
                    const_type     => 'GimpSelection *',
147
 
                    id             => 1,
148
 
                    init_value     => 'NULL',
149
 
                    get_value_func => '$var = gimp_value_get_selection ($value, gimp)',
150
 
                    set_value_func => 'gimp_value_set_selection ($value, $var)',
151
 
                    headers        => [ qw("core/gimpselection.h") ] },
152
 
    layer_mask => { name           => 'CHANNEL',
153
 
                    type           => 'GimpLayerMask *', 
154
 
                    const_type     => 'GimpLayerMask *', 
155
 
                    id             => 1,
156
 
                    init_value     => 'NULL',
157
 
                    get_value_func => '$var = gimp_value_get_layer_mask ($value, gimp)',
158
 
                    set_value_func => 'gimp_value_set_layer_mask ($value, $var)',
159
 
                    headers        => [ qw("core/gimplayermask.h") ] },
160
 
    vectors    => { name           => 'VECTORS',
161
 
                    type           => 'GimpVectors *', 
162
 
                    const_type     => 'GimpVectors *', 
163
 
                    id             => 1,
164
 
                    init_value     => 'NULL',
165
 
                    get_value_func => '$var = gimp_value_get_vectors ($value, gimp)',
166
 
                    set_value_func => 'gimp_value_set_vectors ($value, $var)',
167
 
                    headers        => [ qw("vectors/gimpvectors.h") ] },
168
 
 
169
 
    parasite => { name           => 'PARASITE',
170
 
                  type           => 'GimpParasite *',
171
 
                  const_type     => 'const GimpParasite *',
172
 
                  init_value     => 'NULL',
173
 
                  get_value_func => '$var = g_value_get_boxed ($value)',
174
 
                  set_value_func => 'g_value_take_boxed ($value, $var)',
175
 
                  headers => [ qw("libgimpbase/gimpbase.h") ] },
176
 
 
177
 
    boundary => { name => 'BOUNDARY', type => 'gpointer ' }, # ??? FIXME
178
 
    status   => { name => 'STATUS'  , type => 'gpointer ' }, # ??? FIXME
 
103
    color       => { name           => 'COLOR' , 
 
104
                     type           => 'GimpRGB ',
 
105
                     const_type     => 'GimpRGB ',
 
106
                     struct         => 1,
 
107
                     init_value     => '{ 0.0, 0.0, 0.0, 1.0 }',
 
108
                     get_value_func => 'gimp_value_get_rgb ($value, &$var)',
 
109
                     set_value_func => 'gimp_value_set_rgb ($value, &$var)',
 
110
                     headers        => [ qw(<cairo.h> "libgimpcolor/gimpcolor.h") ] },
 
111
 
 
112
    display     => { name           => 'DISPLAY',
 
113
                     type           => 'GimpObject *',
 
114
                     const_type     => 'GimpObject *',
 
115
                     id             => 1,
 
116
                     init_value     => 'NULL',
 
117
                     get_value_func => '$var = gimp_value_get_display ($value, gimp)',
 
118
                     set_value_func => 'gimp_value_set_display ($value, $var)' },
 
119
 
 
120
    image       => { name           => 'IMAGE',
 
121
                     type           => 'GimpImage *', 
 
122
                     const_type     => 'GimpImage *', 
 
123
                     id             => 1,
 
124
                     init_value     => 'NULL',
 
125
                     get_value_func => '$var = gimp_value_get_image ($value, gimp)',
 
126
                     set_value_func => 'gimp_value_set_image ($value, $var)',
 
127
                     headers        => [ qw("core/gimpimage.h") ] },
 
128
 
 
129
    item        => { name           => 'ITEM',
 
130
                     type           => 'GimpItem *', 
 
131
                     const_type     => 'GimpItem *', 
 
132
                     id             => 1,
 
133
                     init_value     => 'NULL',
 
134
                     get_value_func => '$var = gimp_value_get_item ($value, gimp)',
 
135
                     set_value_func => 'gimp_value_set_item ($value, $var)',
 
136
                     headers        => [ qw("core/gimpitem.h") ] },
 
137
 
 
138
    layer       => { name           => 'LAYER',
 
139
                     type           => 'GimpLayer *', 
 
140
                     const_type     => 'GimpLayer *', 
 
141
                     id             => 1,
 
142
                     init_value     => 'NULL',
 
143
                     get_value_func => '$var = gimp_value_get_layer ($value, gimp)',
 
144
                     set_value_func => 'gimp_value_set_layer ($value, $var)',
 
145
                     headers        => [ qw("core/gimplayer.h") ] },
 
146
 
 
147
    channel     => { name           => 'CHANNEL',
 
148
                     type           => 'GimpChannel *',
 
149
                     const_type     => 'GimpChannel *',
 
150
                     id             => 1,
 
151
                     init_value     => 'NULL',
 
152
                     get_value_func => '$var = gimp_value_get_channel ($value, gimp)',
 
153
                     set_value_func => 'gimp_value_set_channel ($value, $var)',
 
154
                     headers        => [ qw("core/gimpchannel.h") ] },
 
155
 
 
156
    drawable    => { name           => 'DRAWABLE',
 
157
                     type           => 'GimpDrawable *',
 
158
                     const_type     => 'GimpDrawable *',
 
159
                     id             => 1,
 
160
                     init_value     => 'NULL',
 
161
                     get_value_func => '$var = gimp_value_get_drawable ($value, gimp)',
 
162
                     set_value_func => 'gimp_value_set_drawable ($value, $var)',
 
163
                     headers        => [ qw("core/gimpdrawable.h") ] },
 
164
 
 
165
    selection   => { name           => 'SELECTION',
 
166
                     type           => 'GimpSelection *',
 
167
                     const_type     => 'GimpSelection *',
 
168
                     id             => 1,
 
169
                     init_value     => 'NULL',
 
170
                     get_value_func => '$var = gimp_value_get_selection ($value, gimp)',
 
171
                     set_value_func => 'gimp_value_set_selection ($value, $var)',
 
172
                     headers        => [ qw("core/gimpselection.h") ] },
 
173
 
 
174
    layer_mask  => { name           => 'CHANNEL',
 
175
                     type           => 'GimpLayerMask *', 
 
176
                     const_type     => 'GimpLayerMask *', 
 
177
                     id             => 1,
 
178
                     init_value     => 'NULL',
 
179
                     get_value_func => '$var = gimp_value_get_layer_mask ($value, gimp)',
 
180
                     set_value_func => 'gimp_value_set_layer_mask ($value, $var)',
 
181
                     headers        => [ qw("core/gimplayermask.h") ] },
 
182
 
 
183
    vectors     => { name           => 'VECTORS',
 
184
                     type           => 'GimpVectors *', 
 
185
                     const_type     => 'GimpVectors *', 
 
186
                     id             => 1,
 
187
                     init_value     => 'NULL',
 
188
                     get_value_func => '$var = gimp_value_get_vectors ($value, gimp)',
 
189
                     set_value_func => 'gimp_value_set_vectors ($value, $var)',
 
190
                     headers        => [ qw("vectors/gimpvectors.h") ] },
 
191
 
 
192
    parasite    => { name           => 'PARASITE',
 
193
                     type           => 'GimpParasite *',
 
194
                     const_type     => 'const GimpParasite *',
 
195
                     init_value     => 'NULL',
 
196
                     get_value_func => '$var = g_value_get_boxed ($value)',
 
197
                     set_value_func => 'g_value_take_boxed ($value, $var)',
 
198
                     headers => [ qw("libgimpbase/gimpbase.h") ] },
179
199
 
180
200
    # Special cases
181
 
    enum    => { name           => 'INT32',
182
 
                 type           => 'gint32 ',
183
 
                 const_type     => 'gint32 ',
184
 
                 init_value     => '0',
185
 
                 get_value_func => '$var = g_value_get_enum ($value)',
186
 
                 set_value_func => 'g_value_set_enum ($value, $var)' },
187
 
    boolean => { name           => 'INT32',
188
 
                 type           => 'gboolean ',
189
 
                 const_type     => 'gboolean ',
190
 
                 init_value     => 'FALSE',
191
 
                 get_value_func => '$var = g_value_get_boolean ($value)',
192
 
                 set_value_func => 'g_value_set_boolean ($value, $var)' },
193
 
    tattoo  => { name           => 'INT32',
194
 
                 type           => 'gint32 ',
195
 
                 const_type     => 'gint32 ',
196
 
                 init_value     => '0',
197
 
                 get_value_func => '$var = g_value_get_uint ($value)',
198
 
                 set_value_func => 'g_value_set_uint ($value, $var)' },
199
 
    guide   => { name           => 'INT32',
200
 
                 type           => 'gint32 ',
201
 
                 const_type     => 'gint32 ',
202
 
                 id             => 1,
203
 
                 init_value     => '0',
204
 
                 get_value_func => '$var = g_value_get_uint ($value)',
205
 
                 set_value_func => 'g_value_set_uint ($value, $var)' },
206
 
    unit    => { name           => 'INT32',
207
 
                 type           => 'GimpUnit ',
208
 
                 const_type     => 'GimpUnit ',
209
 
                 init_value     => '0',
210
 
                 get_value_func => '$var = g_value_get_int ($value)',
211
 
                 set_value_func => 'g_value_set_int ($value, $var)' },
212
 
 
213
 
    region => { name => 'REGION', type => 'gpointer ' } # not supported
 
201
    enum        => { name           => 'INT32',
 
202
                     type           => 'gint32 ',
 
203
                     const_type     => 'gint32 ',
 
204
                     init_value     => '0',
 
205
                     get_value_func => '$var = g_value_get_enum ($value)',
 
206
                     set_value_func => 'g_value_set_enum ($value, $var)' },
 
207
 
 
208
    boolean     => { name           => 'INT32',
 
209
                     type           => 'gboolean ',
 
210
                     const_type     => 'gboolean ',
 
211
                     init_value     => 'FALSE',
 
212
                     get_value_func => '$var = g_value_get_boolean ($value)',
 
213
                     set_value_func => 'g_value_set_boolean ($value, $var)' },
 
214
 
 
215
    tattoo      => { name           => 'INT32',
 
216
                     type           => 'gint32 ',
 
217
                     const_type     => 'gint32 ',
 
218
                     init_value     => '0',
 
219
                     get_value_func => '$var = g_value_get_uint ($value)',
 
220
                     set_value_func => 'g_value_set_uint ($value, $var)' },
 
221
 
 
222
    guide       => { name           => 'INT32',
 
223
                     type           => 'gint32 ',
 
224
                     const_type     => 'gint32 ',
 
225
                     id             => 1,
 
226
                     init_value     => '0',
 
227
                     get_value_func => '$var = g_value_get_uint ($value)',
 
228
                     set_value_func => 'g_value_set_uint ($value, $var)' },
 
229
 
 
230
    unit        => { name           => 'INT32',
 
231
                     type           => 'GimpUnit ',
 
232
                     const_type     => 'GimpUnit ',
 
233
                     init_value     => '0',
 
234
                     get_value_func => '$var = g_value_get_int ($value)',
 
235
                     set_value_func => 'g_value_set_int ($value, $var)' }
214
236
);
215
237
 
216
238
# Split out the parts of an arg constraint