← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tools/pdbgen/pdb/palette.pdb

  • 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:
tools/pdbgen/pdb/palette.pdb
1
 
# The GIMP -- an image manipulation program
 
1
# GIMP - The GNU Image Manipulation Program
2
2
# Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 
4
4
# This program is free software; you can redistribute it and/or modify
17
17
 
18
18
# "Perlized" from C source by Manish Singh <yosh@gimp.org>
19
19
 
20
 
sub mitch_misc {
21
 
    $author = 'Michael Natterer <mitch@gimp.org>';
22
 
    $copyright = 'Michael Natterer';
23
 
    $date = '2004';
24
 
    $since = '2.2';
25
 
}
26
 
 
27
 
sub palette_arg () {{
28
 
    name => 'name',
29
 
    type => 'string',
30
 
    desc => 'The palette name.'
31
 
}}
32
 
 
33
 
my $get_palette_from_name = <<'CODE';
34
 
if (name && strlen (name))
35
 
  {
36
 
    palette = (GimpPalette *)
37
 
      gimp_container_get_child_by_name (gimp->palette_factory->container,
38
 
                                        name);
39
 
  }
40
 
else
41
 
  {
42
 
    palette = gimp_context_get_palette (context);
43
 
  }
44
 
CODE
45
 
 
46
 
 
47
 
# The defs
48
 
 
49
20
sub palette_new {
50
21
    $blurb = "Creates a new palette";
51
22
    $help  = "This procedure creates a new, uninitialized palette";
52
23
 
53
 
    &mitch_misc;
 
24
    &mitch_pdb_misc('2004', '2.2');
54
25
 
55
26
    @inargs = (
56
27
        { name => 'name', type => 'string',
58
29
    );
59
30
 
60
31
    @outargs = (
61
 
        { name => 'name', type => 'string',
62
 
          desc => 'The actual new palette name',
63
 
          alias => 'g_strdup (GIMP_OBJECT (data)->name)', no_declare => 1 },
 
32
        { name => 'actual_name', type => 'string',
 
33
          desc => 'The actual new palette name' }
64
34
    );
65
35
 
66
36
    %invoke = (
67
 
        vars => [ 'GimpData *data = NULL'],
68
37
        code => <<'CODE'
69
38
{
70
39
  if (strlen (name))
71
 
    data = gimp_data_factory_data_new (gimp->palette_factory, name);
72
 
 
73
 
  success = (data != NULL);
 
40
    {
 
41
      GimpData *data = gimp_data_factory_data_new (gimp->palette_factory, name);
 
42
 
 
43
      if (data)
 
44
        actual_name = g_strdup (gimp_object_get_name (GIMP_OBJECT (data)));
 
45
      else
 
46
        success = FALSE;
 
47
    }
 
48
  else
 
49
    success = FALSE;
 
50
}
 
51
CODE
 
52
    );
 
53
}
 
54
 
 
55
sub palette_is_editable {
 
56
    $blurb = "Tests if palette can be edited";
 
57
    $help  = "Returns TRUE if you have permission to change the palette";
 
58
 
 
59
    &bill_pdb_misc('2004', '2.4');
 
60
 
 
61
    @inargs = (
 
62
        { name => 'name', type => 'string',
 
63
          desc => 'The palette name' }
 
64
    );
 
65
 
 
66
    @outargs = (
 
67
        { name => 'editable', type => 'boolean',
 
68
          desc => "TRUE if the palette can be edited" }
 
69
    );
 
70
 
 
71
    %invoke = (
 
72
        code => <<'CODE'
 
73
{
 
74
  GimpPalette *palette = (GimpPalette *)
 
75
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
 
76
 
 
77
  if (palette)
 
78
    editable = GIMP_DATA (palette)->writable;
 
79
  else
 
80
    success = FALSE;
74
81
}
75
82
CODE
76
83
    );
80
87
    $blurb = "Duplicates a palette";
81
88
    $help  = "This procedure creates an identical palette by a different name";
82
89
 
83
 
    &mitch_misc;
 
90
    &mitch_pdb_misc('2004', '2.2');
84
91
 
85
92
    @inargs = (
86
 
        &palette_arg
 
93
        { name => 'name', type => 'string',
 
94
          desc => 'The palette name' }
87
95
    );
88
96
 
89
97
    @outargs = (
90
 
        { name => 'name', type => 'string',
91
 
          desc => "The name of the palette's copy",
92
 
          alias => 'g_strdup (GIMP_OBJECT (palette_copy)->name)',
93
 
          no_declare => 1 }
 
98
        { name => 'copy_name', type => 'string',
 
99
          desc => "The name of the palette's copy" }
94
100
    );
95
101
 
96
102
    %invoke = (
97
 
        vars => [ 'GimpPalette *palette = NULL',
98
 
                  'GimpPalette *palette_copy = NULL' ],
99
103
        code => <<'CODE'
100
104
{
101
 
  palette = (GimpPalette *)
 
105
  GimpPalette *palette = (GimpPalette *)
102
106
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
103
107
 
104
108
  if (palette)
105
109
    {
106
 
      palette_copy = (GimpPalette *)
 
110
      GimpPalette *palette_copy = (GimpPalette *)
107
111
        gimp_data_factory_data_duplicate (gimp->palette_factory,
108
112
                                          GIMP_DATA (palette));
109
113
 
110
 
      success = (palette_copy != NULL);
 
114
      if (palette_copy)
 
115
        copy_name = g_strdup (gimp_object_get_name (GIMP_OBJECT (palette_copy)));
 
116
      else
 
117
        success = FALSE;
111
118
    }
112
119
  else
113
120
    success = FALSE;
120
127
    $blurb = "Rename a palette";
121
128
    $help  = "This procedure renames a palette";
122
129
 
123
 
    &mitch_misc;
 
130
    &mitch_pdb_misc('2004', '2.2');
124
131
 
125
132
    @inargs = (
126
 
        &palette_arg,
 
133
        { name => 'name', type => 'string',
 
134
          desc => 'The palette name' },
127
135
        { name => 'new_name', type => 'string',
128
136
          desc => "The new name of the palette" }
129
137
    );
130
138
 
131
139
    @outargs = (
132
 
        { name => 'name', type => 'string',
133
 
          desc => "The actual new name of the palette",
134
 
          alias => 'g_strdup (GIMP_OBJECT (palette)->name)', no_declare => 1 },
 
140
        { name => 'actual_name', type => 'string',
 
141
          desc => "The actual new name of the palette" }
135
142
    );
136
143
 
137
144
    %invoke = (
138
 
        vars => [ 'GimpPalette *palette = NULL' ],
139
145
        code => <<'CODE'
140
146
{
141
 
  palette = (GimpPalette *)
 
147
  GimpPalette *palette = (GimpPalette *)
142
148
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
143
149
 
144
 
  if (palette && GIMP_DATA (palette)->writable)
145
 
    gimp_object_set_name (GIMP_OBJECT (palette), new_name);
 
150
  if (palette && GIMP_DATA (palette)->writable && strlen (new_name))
 
151
    {
 
152
      gimp_object_set_name (GIMP_OBJECT (palette), new_name);
 
153
      actual_name = g_strdup (gimp_object_get_name (GIMP_OBJECT (palette)));
 
154
    }
146
155
  else
147
156
    success = FALSE;
148
157
}
154
163
    $blurb = "Deletes a palette";
155
164
    $help  = "This procedure deletes a palette";
156
165
 
157
 
    &mitch_misc;
 
166
    &mitch_pdb_misc('2004', '2.2');
158
167
 
159
168
    @inargs = (
160
 
        &palette_arg
 
169
        { name => 'name', type => 'string',
 
170
          desc => 'The palette name' }
161
171
    );
162
172
 
163
173
    %invoke = (
164
 
        vars => [ 'GimpPalette *palette = NULL' ],
165
174
        code => <<'CODE'
166
175
{
167
 
  palette = (GimpPalette *)
 
176
  GimpPalette *palette = (GimpPalette *)
168
177
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
169
178
 
170
179
  if (palette && GIMP_DATA (palette)->deletable)
177
186
 
178
187
      if (! success)
179
188
        {
180
 
          g_message (error->message);
 
189
          gimp_message (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR,
 
190
                        "%s", error->message);
181
191
          g_clear_error (&error);
182
192
        }
183
193
    }
196
206
includes the name, and the number of colors.
197
207
HELP
198
208
 
199
 
    &mitch_misc;
200
 
 
201
 
    @inargs = (
202
 
        &palette_arg
203
 
    );
204
 
 
205
 
    @outargs = (
206
 
        { name => 'num_colors', type => 'int32', no_declare => '1',
207
 
          alias => 'palette->n_colors', void_ret => '1',
208
 
          desc => "The number of colors in the palette" }
209
 
    );
210
 
 
211
 
    %invoke = (
212
 
        vars => [ 'GimpPalette *palette = NULL' ],
213
 
        code => <<'CODE'
214
 
{
215
 
  palette = (GimpPalette *)
216
 
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
217
 
 
218
 
  success = (palette != NULL);
 
209
    &mitch_pdb_misc('2004', '2.2');
 
210
 
 
211
    @inargs = (
 
212
        { name => 'name', type => 'string',
 
213
          desc => 'The palette name' }
 
214
    );
 
215
 
 
216
    @outargs = (
 
217
        { name => 'num_colors', type => 'int32', void_ret => '1',
 
218
          desc => 'The number of colors in the palette' }
 
219
    );
 
220
 
 
221
    %invoke = (
 
222
        code => <<'CODE'
 
223
{
 
224
  GimpPalette *palette = (GimpPalette *)
 
225
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
 
226
 
 
227
  if (palette)
 
228
    num_colors = palette->n_colors;
 
229
  else
 
230
    success = FALSE;
 
231
}
 
232
CODE
 
233
    );
 
234
}
 
235
 
 
236
sub palette_get_columns {
 
237
    $blurb = "Retrieves the number of columns to use to display this palette";
 
238
    $help = <<'HELP';
 
239
This procedures retrieves the prefered number of columns to use when the
 
240
palette is being displayed.
 
241
HELP
 
242
 
 
243
    &neo_pdb_misc('2005', '2.4');
 
244
 
 
245
    @inargs = (
 
246
        { name => 'name', type => 'string',
 
247
          desc => 'The palette name' }
 
248
    );
 
249
 
 
250
    @outargs = (
 
251
        { name => 'num_columns', type => 'int32',
 
252
          desc => "The number of columns used to display this palette" }
 
253
    );
 
254
 
 
255
    %invoke = (
 
256
        code => <<'CODE'
 
257
{
 
258
  GimpPalette *palette = (GimpPalette *)
 
259
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
 
260
 
 
261
  if (palette)
 
262
    num_columns = palette->n_columns;
 
263
  else
 
264
    success = FALSE;
 
265
}
 
266
CODE
 
267
    );
 
268
}
 
269
 
 
270
sub palette_set_columns {
 
271
    $blurb = "Sets the number of columns to use when displaying the palette";
 
272
    $help = <<'HELP';
 
273
This procedures allows to control how many colors are shown per row when the
 
274
palette is being displayed. This value can only be changed if the palette
 
275
is writable. The maximum allowed value is 64.
 
276
HELP
 
277
 
 
278
    &neo_pdb_misc('2005', '2.4');
 
279
 
 
280
    @inargs = (
 
281
        { name => 'name', type => 'string',
 
282
          desc => 'The palette name' },
 
283
        { name => 'columns', type => '0 <= int32 <= 64',
 
284
          desc => "The new number of columns" }
 
285
    );
 
286
 
 
287
    %invoke = (
 
288
        code => <<'CODE'
 
289
{
 
290
  GimpPalette *palette = (GimpPalette *)
 
291
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
 
292
 
 
293
  if (palette && GIMP_DATA (palette)->writable)
 
294
    gimp_palette_set_columns (palette, columns);
 
295
  else
 
296
    success = FALSE;
219
297
}
220
298
CODE
221
299
    );
229
307
It returns an error if the entry palette does not exist.
230
308
HELP
231
309
 
232
 
    &mitch_misc;
 
310
    &mitch_pdb_misc('2004', '2.2');
233
311
 
234
312
    @inargs = (
235
 
        &palette_arg,
 
313
        { name => 'name', type => 'string',
 
314
          desc => 'The palette name' },
236
315
        { name => 'entry_name', type => 'string', null_ok => '1',
237
316
          desc => 'The name of the entry' },
238
317
        { name => 'color', type => 'color',
241
320
 
242
321
    @outargs = (
243
322
        { name => 'entry_num', type => 'int32', void_ret => '1',
244
 
          alias => 'entry->position', no_declare => '1',
245
323
          desc => 'The index of the added entry' }
246
324
    );
247
325
 
248
326
    %invoke = (
249
 
        vars => [ 'GimpPalette *palette = NULL',
250
 
                  'GimpPaletteEntry *entry = NULL' ],
251
327
        code => <<'CODE'
252
328
{
253
 
  palette = (GimpPalette *)
 
329
  GimpPalette *palette = (GimpPalette *)
254
330
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
255
331
 
256
332
  if (palette && GIMP_DATA (palette)->writable)
257
 
    entry = gimp_palette_add_entry (palette, entry_name, &color);
 
333
    {
 
334
      GimpPaletteEntry *entry =
 
335
        gimp_palette_add_entry (palette, -1, entry_name, &color);
 
336
 
 
337
      entry_num = entry->position;
 
338
    }
258
339
  else
259
340
    success = FALSE;
260
341
}
270
351
It returns an error if the entry palette does not exist.
271
352
HELP
272
353
 
273
 
    &mitch_misc;
 
354
    &mitch_pdb_misc('2004', '2.2');
274
355
 
275
356
    @inargs = (
276
 
        &palette_arg,
 
357
        { name => 'name', type => 'string',
 
358
          desc => 'The palette name' },
277
359
        { name => 'entry_num', type => 'int32',
278
360
          desc => 'The index of the added entry' }
279
361
    );
280
362
 
281
363
    %invoke = (
282
 
        vars => [ 'GimpPalette *palette = NULL',
283
 
                  'GimpPaletteEntry *entry = NULL' ],
284
364
        code => <<'CODE'
285
365
{
286
 
  palette = (GimpPalette *)
 
366
  GimpPalette *palette = (GimpPalette *)
287
367
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
288
368
 
289
369
  if (palette && GIMP_DATA (palette)->writable)
290
370
    {
291
371
      if (entry_num >= 0 && entry_num < palette->n_colors)
292
372
        {
293
 
          entry = g_list_nth_data (palette->colors, entry_num);
 
373
          GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num);
294
374
 
295
375
          gimp_palette_delete_entry (palette, entry);
296
376
        }
312
392
specified palette. It returns an error if the entry does not exist.
313
393
HELP
314
394
 
315
 
    &mitch_misc;
 
395
    &mitch_pdb_misc('2004', '2.2');
316
396
 
317
397
    @inargs = (
318
 
        &palette_arg,
 
398
        { name => 'name', type => 'string',
 
399
          desc => 'The palette name' },
319
400
        { name => 'entry_num', type => 'int32',
320
401
          desc => 'The entry to retrieve' }
321
402
    );
326
407
    );
327
408
 
328
409
    %invoke = (
329
 
        vars => [ 'GimpPalette *palette = NULL',
330
 
                  'GimpPaletteEntry *entry = NULL' ],
331
410
        code => <<'CODE'
332
411
{
333
 
  palette = (GimpPalette *)
 
412
  GimpPalette *palette = (GimpPalette *)
334
413
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
335
414
 
336
415
  if (palette)
337
416
    {
338
417
      if (entry_num >= 0 && entry_num < palette->n_colors)
339
418
        {
340
 
          entry = g_list_nth_data (palette->colors, entry_num);
 
419
          GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num);
341
420
 
342
421
          color = entry->color;
343
422
        }
359
438
specified palette. It returns an error if the entry does not exist.
360
439
HELP
361
440
 
362
 
    &mitch_misc;
 
441
    &mitch_pdb_misc('2004', '2.2');
363
442
 
364
443
    @inargs = (
365
 
        &palette_arg,
 
444
        { name => 'name', type => 'string',
 
445
          desc => 'The palette name' },
366
446
        { name => 'entry_num', type => 'int32',
367
447
          desc => 'The entry to retrieve' },
368
448
        { name => 'color', type => 'color',
370
450
    );
371
451
 
372
452
    %invoke = (
373
 
        vars => [ 'GimpPalette *palette = NULL',
374
 
                  'GimpPaletteEntry *entry = NULL' ],
375
453
        code => <<'CODE'
376
454
{
377
 
  palette = (GimpPalette *)
 
455
  GimpPalette *palette = (GimpPalette *)
378
456
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
379
457
 
380
458
  if (palette && GIMP_DATA (palette)->writable)
381
459
    {
382
460
      if (entry_num >= 0 && entry_num < palette->n_colors)
383
461
        {
384
 
          entry = g_list_nth_data (palette->colors, entry_num);
 
462
          GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num);
385
463
 
386
464
          entry->color = color;
387
465
 
405
483
specified palette. It returns an error if the entry does not exist.
406
484
HELP
407
485
 
408
 
    &mitch_misc;
 
486
    &mitch_pdb_misc('2004', '2.2');
409
487
 
410
488
    @inargs = (
411
 
        &palette_arg,
 
489
        { name => 'name', type => 'string',
 
490
          desc => 'The palette name' },
412
491
        { name => 'entry_num', type => 'int32',
413
492
          desc => 'The entry to retrieve' }
414
493
    );
415
494
 
416
495
    @outargs = (
417
496
        { name => 'entry_name', type => 'string', void_ret => 1,
418
 
          no_declare => '1', alias => 'g_strdup (entry->name)',
419
497
          desc => 'The name requested' }
420
498
    );
421
499
 
422
500
    %invoke = (
423
 
        vars => [ 'GimpPalette *palette = NULL',
424
 
                  'GimpPaletteEntry *entry = NULL' ],
425
501
        code => <<'CODE'
426
502
{
427
 
  palette = (GimpPalette *)
 
503
  GimpPalette *palette = (GimpPalette *)
428
504
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
429
505
 
430
506
  if (palette)
431
507
    {
432
508
      if (entry_num >= 0 && entry_num < palette->n_colors)
433
 
        entry = g_list_nth_data (palette->colors, entry_num);
 
509
        {
 
510
          GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num);
 
511
 
 
512
          entry_name = g_strdup (entry->name);
 
513
        }
434
514
      else
435
515
        success = FALSE;
436
516
    }
449
529
specified palette. It returns an error if the entry does not exist.
450
530
HELP
451
531
 
452
 
    &mitch_misc;
 
532
    &mitch_pdb_misc('2004', '2.2');
453
533
 
454
534
    @inargs = (
455
 
        &palette_arg,
 
535
        { name => 'name', type => 'string',
 
536
          desc => 'The palette name' },
456
537
        { name => 'entry_num', type => 'int32',
457
538
          desc => 'The entry to retrieve' },
458
539
        { name => 'entry_name', type => 'string', null_ok => '1',
460
541
    );
461
542
 
462
543
    %invoke = (
463
 
        vars => [ 'GimpPalette *palette = NULL',
464
 
                  'GimpPaletteEntry *entry = NULL' ],
465
544
        code => <<'CODE'
466
545
{
467
 
  palette = (GimpPalette *)
 
546
  GimpPalette *palette = (GimpPalette *)
468
547
    gimp_container_get_child_by_name (gimp->palette_factory->container, name);
469
548
 
470
549
  if (palette && GIMP_DATA (palette)->writable)
471
550
    {
472
551
      if (entry_num >= 0 && entry_num < palette->n_colors)
473
552
        {
474
 
          entry = g_list_nth_data (palette->colors, entry_num);
 
553
          GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num);
475
554
 
476
555
          g_free (entry->name);
477
556
          entry->name = g_strdup (entry_name);
493
572
              "core/gimpdatafactory.h" "core/gimppalette.h");
494
573
 
495
574
@procs = qw(palette_new palette_duplicate palette_rename palette_delete
496
 
            palette_get_info palette_add_entry palette_delete_entry
 
575
            palette_is_editable palette_get_info
 
576
            palette_get_columns palette_set_columns
 
577
            palette_add_entry palette_delete_entry
497
578
            palette_entry_get_color palette_entry_set_color
498
579
            palette_entry_get_name palette_entry_set_name);
 
580
 
499
581
%exports = (app => [@procs], lib => [@procs]);
500
582
 
501
583
$desc = 'Palette';