← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libgimp/gimpdrawabletransform_pdb.c

  • 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:
libgimp/gimpdrawabletransform_pdb.c
19
19
 * Boston, MA 02111-1307, USA.
20
20
 */
21
21
 
22
 
/* NOTE: This file is autogenerated by pdbgen.pl */
 
22
/* NOTE: This file is auto-generated by pdbgen.pl */
23
23
 
24
24
#include "config.h"
25
25
 
38
38
 * This procedure flips the specified drawable if no selection exists.
39
39
 * If a selection exists, the portion of the drawable which lies under
40
40
 * the selection is cut from the drawable and made into a floating
41
 
 * selection which is then flipped. If auto_center is set to true, the
 
41
 * selection which is then flipped. If auto_center is set to TRUE, the
42
42
 * flip is around the selection's center. Otherwise, the coordinate of
43
43
 * the axis needs to be specified. The return value is the ID of the
44
44
 * flipped drawable. If there was no selection, this will be equal to
51
51
 */
52
52
gint32
53
53
gimp_drawable_transform_flip_simple (gint32              drawable_ID,
54
 
                                     GimpOrientationType flip_type,
55
 
                                     gboolean            auto_center,
56
 
                                     gdouble             axis,
57
 
                                     gboolean            clip_result)
 
54
                                     GimpOrientationType flip_type,
 
55
                                     gboolean            auto_center,
 
56
                                     gdouble             axis,
 
57
                                     gboolean            clip_result)
58
58
{
59
59
  GimpParam *return_vals;
60
60
  gint nreturn_vals;
61
61
  gint32 ret_drawable_ID = -1;
62
62
 
63
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_flip_simple",
64
 
                                    &nreturn_vals,
65
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
66
 
                                    GIMP_PDB_INT32, flip_type,
67
 
                                    GIMP_PDB_INT32, auto_center,
68
 
                                    GIMP_PDB_FLOAT, axis,
69
 
                                    GIMP_PDB_INT32, clip_result,
70
 
                                    GIMP_PDB_END);
 
63
  return_vals = gimp_run_procedure ("gimp-drawable-transform-flip-simple",
 
64
                                    &nreturn_vals,
 
65
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
66
                                    GIMP_PDB_INT32, flip_type,
 
67
                                    GIMP_PDB_INT32, auto_center,
 
68
                                    GIMP_PDB_FLOAT, axis,
 
69
                                    GIMP_PDB_INT32, clip_result,
 
70
                                    GIMP_PDB_END);
71
71
 
72
72
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
73
73
    ret_drawable_ID = return_vals[1].data.d_drawable;
84
84
 * @y0: vert. coord. of one end of axis.
85
85
 * @x1: horz. coord. of other end of axis.
86
86
 * @y1: vert. coord. of other end of axis.
87
 
 * @transform_direction: Direction of Transformation.
 
87
 * @transform_direction: Direction of transformation.
88
88
 * @interpolation: Type of interpolation.
89
89
 * @supersample: Whether to perform supersample.
90
90
 * @recursion_level: Level of recursion (3 is a nice default).
109
109
 */
110
110
gint32
111
111
gimp_drawable_transform_flip (gint32                 drawable_ID,
112
 
                              gdouble                x0,
113
 
                              gdouble                y0,
114
 
                              gdouble                x1,
115
 
                              gdouble                y1,
116
 
                              GimpTransformDirection transform_direction,
117
 
                              GimpInterpolationType  interpolation,
118
 
                              gboolean               supersample,
119
 
                              gint                   recursion_level,
120
 
                              gboolean               clip_result)
 
112
                              gdouble                x0,
 
113
                              gdouble                y0,
 
114
                              gdouble                x1,
 
115
                              gdouble                y1,
 
116
                              GimpTransformDirection transform_direction,
 
117
                              GimpInterpolationType  interpolation,
 
118
                              gboolean               supersample,
 
119
                              gint                   recursion_level,
 
120
                              gboolean               clip_result)
121
121
{
122
122
  GimpParam *return_vals;
123
123
  gint nreturn_vals;
124
124
  gint32 ret_drawable_ID = -1;
125
125
 
126
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_flip",
127
 
                                    &nreturn_vals,
128
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
129
 
                                    GIMP_PDB_FLOAT, x0,
130
 
                                    GIMP_PDB_FLOAT, y0,
131
 
                                    GIMP_PDB_FLOAT, x1,
132
 
                                    GIMP_PDB_FLOAT, y1,
133
 
                                    GIMP_PDB_INT32, transform_direction,
134
 
                                    GIMP_PDB_INT32, interpolation,
135
 
                                    GIMP_PDB_INT32, supersample,
136
 
                                    GIMP_PDB_INT32, recursion_level,
137
 
                                    GIMP_PDB_INT32, clip_result,
138
 
                                    GIMP_PDB_END);
 
126
  return_vals = gimp_run_procedure ("gimp-drawable-transform-flip",
 
127
                                    &nreturn_vals,
 
128
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
129
                                    GIMP_PDB_FLOAT, x0,
 
130
                                    GIMP_PDB_FLOAT, y0,
 
131
                                    GIMP_PDB_FLOAT, x1,
 
132
                                    GIMP_PDB_FLOAT, y1,
 
133
                                    GIMP_PDB_INT32, transform_direction,
 
134
                                    GIMP_PDB_INT32, interpolation,
 
135
                                    GIMP_PDB_INT32, supersample,
 
136
                                    GIMP_PDB_INT32, recursion_level,
 
137
                                    GIMP_PDB_INT32, clip_result,
 
138
                                    GIMP_PDB_END);
139
139
 
140
140
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
141
141
    ret_drawable_ID = return_vals[1].data.d_drawable;
167
167
 */
168
168
gint32
169
169
gimp_drawable_transform_flip_default (gint32   drawable_ID,
170
 
                                      gdouble  x0,
171
 
                                      gdouble  y0,
172
 
                                      gdouble  x1,
173
 
                                      gdouble  y1,
174
 
                                      gboolean interpolate,
175
 
                                      gboolean clip_result)
 
170
                                      gdouble  x0,
 
171
                                      gdouble  y0,
 
172
                                      gdouble  x1,
 
173
                                      gdouble  y1,
 
174
                                      gboolean interpolate,
 
175
                                      gboolean clip_result)
176
176
{
177
177
  GimpParam *return_vals;
178
178
  gint nreturn_vals;
179
179
  gint32 ret_drawable_ID = -1;
180
180
 
181
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_flip_default",
182
 
                                    &nreturn_vals,
183
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
184
 
                                    GIMP_PDB_FLOAT, x0,
185
 
                                    GIMP_PDB_FLOAT, y0,
186
 
                                    GIMP_PDB_FLOAT, x1,
187
 
                                    GIMP_PDB_FLOAT, y1,
188
 
                                    GIMP_PDB_INT32, interpolate,
189
 
                                    GIMP_PDB_INT32, clip_result,
190
 
                                    GIMP_PDB_END);
 
181
  return_vals = gimp_run_procedure ("gimp-drawable-transform-flip-default",
 
182
                                    &nreturn_vals,
 
183
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
184
                                    GIMP_PDB_FLOAT, x0,
 
185
                                    GIMP_PDB_FLOAT, y0,
 
186
                                    GIMP_PDB_FLOAT, x1,
 
187
                                    GIMP_PDB_FLOAT, y1,
 
188
                                    GIMP_PDB_INT32, interpolate,
 
189
                                    GIMP_PDB_INT32, clip_result,
 
190
                                    GIMP_PDB_END);
191
191
 
192
192
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
193
193
    ret_drawable_ID = return_vals[1].data.d_drawable;
208
208
 * @y2: The new y coordinate of lower-left corner of original bounding box.
209
209
 * @x3: The new x coordinate of lower-right corner of original bounding box.
210
210
 * @y3: The new y coordinate of lower-right corner of original bounding box.
211
 
 * @transform_direction: Direction of Transformation.
 
211
 * @transform_direction: Direction of transformation.
212
212
 * @interpolation: Type of interpolation.
213
213
 * @supersample: Whether to perform supersample.
214
214
 * @recursion_level: Level of recursion (3 is a nice default).
215
 
 * @clip_result: Whether to clip results.
 
215
 * @clip_result: How to clip results.
216
216
 *
217
217
 * Perform a possibly non-affine transformation on the specified
218
218
 * drawable, with extra parameters.
239
239
 */
240
240
gint32
241
241
gimp_drawable_transform_perspective (gint32                 drawable_ID,
242
 
                                     gdouble                x0,
243
 
                                     gdouble                y0,
244
 
                                     gdouble                x1,
245
 
                                     gdouble                y1,
246
 
                                     gdouble                x2,
247
 
                                     gdouble                y2,
248
 
                                     gdouble                x3,
249
 
                                     gdouble                y3,
250
 
                                     GimpTransformDirection transform_direction,
251
 
                                     GimpInterpolationType  interpolation,
252
 
                                     gboolean               supersample,
253
 
                                     gint                   recursion_level,
254
 
                                     gboolean               clip_result)
 
242
                                     gdouble                x0,
 
243
                                     gdouble                y0,
 
244
                                     gdouble                x1,
 
245
                                     gdouble                y1,
 
246
                                     gdouble                x2,
 
247
                                     gdouble                y2,
 
248
                                     gdouble                x3,
 
249
                                     gdouble                y3,
 
250
                                     GimpTransformDirection transform_direction,
 
251
                                     GimpInterpolationType  interpolation,
 
252
                                     gboolean               supersample,
 
253
                                     gint                   recursion_level,
 
254
                                     GimpTransformResize    clip_result)
255
255
{
256
256
  GimpParam *return_vals;
257
257
  gint nreturn_vals;
258
258
  gint32 ret_drawable_ID = -1;
259
259
 
260
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_perspective",
261
 
                                    &nreturn_vals,
262
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
263
 
                                    GIMP_PDB_FLOAT, x0,
264
 
                                    GIMP_PDB_FLOAT, y0,
265
 
                                    GIMP_PDB_FLOAT, x1,
266
 
                                    GIMP_PDB_FLOAT, y1,
267
 
                                    GIMP_PDB_FLOAT, x2,
268
 
                                    GIMP_PDB_FLOAT, y2,
269
 
                                    GIMP_PDB_FLOAT, x3,
270
 
                                    GIMP_PDB_FLOAT, y3,
271
 
                                    GIMP_PDB_INT32, transform_direction,
272
 
                                    GIMP_PDB_INT32, interpolation,
273
 
                                    GIMP_PDB_INT32, supersample,
274
 
                                    GIMP_PDB_INT32, recursion_level,
275
 
                                    GIMP_PDB_INT32, clip_result,
276
 
                                    GIMP_PDB_END);
 
260
  return_vals = gimp_run_procedure ("gimp-drawable-transform-perspective",
 
261
                                    &nreturn_vals,
 
262
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
263
                                    GIMP_PDB_FLOAT, x0,
 
264
                                    GIMP_PDB_FLOAT, y0,
 
265
                                    GIMP_PDB_FLOAT, x1,
 
266
                                    GIMP_PDB_FLOAT, y1,
 
267
                                    GIMP_PDB_FLOAT, x2,
 
268
                                    GIMP_PDB_FLOAT, y2,
 
269
                                    GIMP_PDB_FLOAT, x3,
 
270
                                    GIMP_PDB_FLOAT, y3,
 
271
                                    GIMP_PDB_INT32, transform_direction,
 
272
                                    GIMP_PDB_INT32, interpolation,
 
273
                                    GIMP_PDB_INT32, supersample,
 
274
                                    GIMP_PDB_INT32, recursion_level,
 
275
                                    GIMP_PDB_INT32, clip_result,
 
276
                                    GIMP_PDB_END);
277
277
 
278
278
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
279
279
    ret_drawable_ID = return_vals[1].data.d_drawable;
295
295
 * @x3: The new x coordinate of lower-right corner of original bounding box.
296
296
 * @y3: The new y coordinate of lower-right corner of original bounding box.
297
297
 * @interpolate: Whether to use interpolation and supersampling.
298
 
 * @clip_result: Whether to clip results.
 
298
 * @clip_result: How to clip results.
299
299
 *
300
300
 * Perform a possibly non-affine transformation on the specified
301
301
 * drawable, with extra parameters.
309
309
 * Since: GIMP 2.2
310
310
 */
311
311
gint32
312
 
gimp_drawable_transform_perspective_default (gint32   drawable_ID,
313
 
                                             gdouble  x0,
314
 
                                             gdouble  y0,
315
 
                                             gdouble  x1,
316
 
                                             gdouble  y1,
317
 
                                             gdouble  x2,
318
 
                                             gdouble  y2,
319
 
                                             gdouble  x3,
320
 
                                             gdouble  y3,
321
 
                                             gboolean interpolate,
322
 
                                             gboolean clip_result)
 
312
gimp_drawable_transform_perspective_default (gint32              drawable_ID,
 
313
                                             gdouble             x0,
 
314
                                             gdouble             y0,
 
315
                                             gdouble             x1,
 
316
                                             gdouble             y1,
 
317
                                             gdouble             x2,
 
318
                                             gdouble             y2,
 
319
                                             gdouble             x3,
 
320
                                             gdouble             y3,
 
321
                                             gboolean            interpolate,
 
322
                                             GimpTransformResize clip_result)
323
323
{
324
324
  GimpParam *return_vals;
325
325
  gint nreturn_vals;
326
326
  gint32 ret_drawable_ID = -1;
327
327
 
328
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_perspective_default",
329
 
                                    &nreturn_vals,
330
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
331
 
                                    GIMP_PDB_FLOAT, x0,
332
 
                                    GIMP_PDB_FLOAT, y0,
333
 
                                    GIMP_PDB_FLOAT, x1,
334
 
                                    GIMP_PDB_FLOAT, y1,
335
 
                                    GIMP_PDB_FLOAT, x2,
336
 
                                    GIMP_PDB_FLOAT, y2,
337
 
                                    GIMP_PDB_FLOAT, x3,
338
 
                                    GIMP_PDB_FLOAT, y3,
339
 
                                    GIMP_PDB_INT32, interpolate,
340
 
                                    GIMP_PDB_INT32, clip_result,
341
 
                                    GIMP_PDB_END);
 
328
  return_vals = gimp_run_procedure ("gimp-drawable-transform-perspective-default",
 
329
                                    &nreturn_vals,
 
330
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
331
                                    GIMP_PDB_FLOAT, x0,
 
332
                                    GIMP_PDB_FLOAT, y0,
 
333
                                    GIMP_PDB_FLOAT, x1,
 
334
                                    GIMP_PDB_FLOAT, y1,
 
335
                                    GIMP_PDB_FLOAT, x2,
 
336
                                    GIMP_PDB_FLOAT, y2,
 
337
                                    GIMP_PDB_FLOAT, x3,
 
338
                                    GIMP_PDB_FLOAT, y3,
 
339
                                    GIMP_PDB_INT32, interpolate,
 
340
                                    GIMP_PDB_INT32, clip_result,
 
341
                                    GIMP_PDB_END);
342
342
 
343
343
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
344
344
    ret_drawable_ID = return_vals[1].data.d_drawable;
374
374
 */
375
375
gint32
376
376
gimp_drawable_transform_rotate_simple (gint32           drawable_ID,
377
 
                                       GimpRotationType rotate_type,
378
 
                                       gboolean         auto_center,
379
 
                                       gint             center_x,
380
 
                                       gint             center_y,
381
 
                                       gboolean         clip_result)
 
377
                                       GimpRotationType rotate_type,
 
378
                                       gboolean         auto_center,
 
379
                                       gint             center_x,
 
380
                                       gint             center_y,
 
381
                                       gboolean         clip_result)
382
382
{
383
383
  GimpParam *return_vals;
384
384
  gint nreturn_vals;
385
385
  gint32 ret_drawable_ID = -1;
386
386
 
387
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_rotate_simple",
388
 
                                    &nreturn_vals,
389
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
390
 
                                    GIMP_PDB_INT32, rotate_type,
391
 
                                    GIMP_PDB_INT32, auto_center,
392
 
                                    GIMP_PDB_INT32, center_x,
393
 
                                    GIMP_PDB_INT32, center_y,
394
 
                                    GIMP_PDB_INT32, clip_result,
395
 
                                    GIMP_PDB_END);
 
387
  return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate-simple",
 
388
                                    &nreturn_vals,
 
389
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
390
                                    GIMP_PDB_INT32, rotate_type,
 
391
                                    GIMP_PDB_INT32, auto_center,
 
392
                                    GIMP_PDB_INT32, center_x,
 
393
                                    GIMP_PDB_INT32, center_y,
 
394
                                    GIMP_PDB_INT32, clip_result,
 
395
                                    GIMP_PDB_END);
396
396
 
397
397
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
398
398
    ret_drawable_ID = return_vals[1].data.d_drawable;
409
409
 * @auto_center: Whether to automatically rotate around the selection center.
410
410
 * @center_x: The hor. coordinate of the center of rotation.
411
411
 * @center_y: The vert. coordinate of the center of rotation.
412
 
 * @transform_direction: Direction of Transformation.
 
412
 * @transform_direction: Direction of transformation.
413
413
 * @interpolation: Type of interpolation.
414
414
 * @supersample: Whether to perform supersample.
415
415
 * @recursion_level: Level of recursion (3 is a nice default).
416
 
 * @clip_result: Whether to clip results.
 
416
 * @clip_result: How to clip results.
417
417
 *
418
418
 * Rotate the specified drawable about given coordinates through the
419
419
 * specified angle.
432
432
 */
433
433
gint32
434
434
gimp_drawable_transform_rotate (gint32                 drawable_ID,
435
 
                                gdouble                angle,
436
 
                                gboolean               auto_center,
437
 
                                gint                   center_x,
438
 
                                gint                   center_y,
439
 
                                GimpTransformDirection transform_direction,
440
 
                                GimpInterpolationType  interpolation,
441
 
                                gboolean               supersample,
442
 
                                gint                   recursion_level,
443
 
                                gboolean               clip_result)
 
435
                                gdouble                angle,
 
436
                                gboolean               auto_center,
 
437
                                gint                   center_x,
 
438
                                gint                   center_y,
 
439
                                GimpTransformDirection transform_direction,
 
440
                                GimpInterpolationType  interpolation,
 
441
                                gboolean               supersample,
 
442
                                gint                   recursion_level,
 
443
                                GimpTransformResize    clip_result)
444
444
{
445
445
  GimpParam *return_vals;
446
446
  gint nreturn_vals;
447
447
  gint32 ret_drawable_ID = -1;
448
448
 
449
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_rotate",
450
 
                                    &nreturn_vals,
451
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
452
 
                                    GIMP_PDB_FLOAT, angle,
453
 
                                    GIMP_PDB_INT32, auto_center,
454
 
                                    GIMP_PDB_INT32, center_x,
455
 
                                    GIMP_PDB_INT32, center_y,
456
 
                                    GIMP_PDB_INT32, transform_direction,
457
 
                                    GIMP_PDB_INT32, interpolation,
458
 
                                    GIMP_PDB_INT32, supersample,
459
 
                                    GIMP_PDB_INT32, recursion_level,
460
 
                                    GIMP_PDB_INT32, clip_result,
461
 
                                    GIMP_PDB_END);
 
449
  return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate",
 
450
                                    &nreturn_vals,
 
451
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
452
                                    GIMP_PDB_FLOAT, angle,
 
453
                                    GIMP_PDB_INT32, auto_center,
 
454
                                    GIMP_PDB_INT32, center_x,
 
455
                                    GIMP_PDB_INT32, center_y,
 
456
                                    GIMP_PDB_INT32, transform_direction,
 
457
                                    GIMP_PDB_INT32, interpolation,
 
458
                                    GIMP_PDB_INT32, supersample,
 
459
                                    GIMP_PDB_INT32, recursion_level,
 
460
                                    GIMP_PDB_INT32, clip_result,
 
461
                                    GIMP_PDB_END);
462
462
 
463
463
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
464
464
    ret_drawable_ID = return_vals[1].data.d_drawable;
476
476
 * @center_x: The hor. coordinate of the center of rotation.
477
477
 * @center_y: The vert. coordinate of the center of rotation.
478
478
 * @interpolate: Whether to use interpolation and supersampling.
479
 
 * @clip_result: Whether to clip results.
 
479
 * @clip_result: How to clip results.
480
480
 *
481
481
 * Rotate the specified drawable about given coordinates through the
482
482
 * specified angle.
490
490
 * Since: GIMP 2.2
491
491
 */
492
492
gint32
493
 
gimp_drawable_transform_rotate_default (gint32   drawable_ID,
494
 
                                        gdouble  angle,
495
 
                                        gboolean auto_center,
496
 
                                        gint     center_x,
497
 
                                        gint     center_y,
498
 
                                        gboolean interpolate,
499
 
                                        gboolean clip_result)
 
493
gimp_drawable_transform_rotate_default (gint32              drawable_ID,
 
494
                                        gdouble             angle,
 
495
                                        gboolean            auto_center,
 
496
                                        gint                center_x,
 
497
                                        gint                center_y,
 
498
                                        gboolean            interpolate,
 
499
                                        GimpTransformResize clip_result)
500
500
{
501
501
  GimpParam *return_vals;
502
502
  gint nreturn_vals;
503
503
  gint32 ret_drawable_ID = -1;
504
504
 
505
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_rotate_default",
506
 
                                    &nreturn_vals,
507
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
508
 
                                    GIMP_PDB_FLOAT, angle,
509
 
                                    GIMP_PDB_INT32, auto_center,
510
 
                                    GIMP_PDB_INT32, center_x,
511
 
                                    GIMP_PDB_INT32, center_y,
512
 
                                    GIMP_PDB_INT32, interpolate,
513
 
                                    GIMP_PDB_INT32, clip_result,
514
 
                                    GIMP_PDB_END);
 
505
  return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate-default",
 
506
                                    &nreturn_vals,
 
507
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
508
                                    GIMP_PDB_FLOAT, angle,
 
509
                                    GIMP_PDB_INT32, auto_center,
 
510
                                    GIMP_PDB_INT32, center_x,
 
511
                                    GIMP_PDB_INT32, center_y,
 
512
                                    GIMP_PDB_INT32, interpolate,
 
513
                                    GIMP_PDB_INT32, clip_result,
 
514
                                    GIMP_PDB_END);
515
515
 
516
516
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
517
517
    ret_drawable_ID = return_vals[1].data.d_drawable;
524
524
/**
525
525
 * gimp_drawable_transform_scale:
526
526
 * @drawable_ID: The affected drawable.
527
 
 * @x0: The new x coordinate of upper-left corner of newly scaled region.
528
 
 * @y0: The new y coordinate of upper-left corner of newly scaled region.
529
 
 * @x1: The new x coordinate of lower-right corner of newly scaled region.
530
 
 * @y1: The new y coordinate of lower-right corner of newly scaled region.
531
 
 * @transform_direction: Direction of Transformation.
 
527
 * @x0: The new x coordinate of the upper-left corner of the scaled region.
 
528
 * @y0: The new y coordinate of the upper-left corner of the scaled region.
 
529
 * @x1: The new x coordinate of the lower-right corner of the scaled region.
 
530
 * @y1: The new y coordinate of the lower-right corner of the scaled region.
 
531
 * @transform_direction: Direction of transformation.
532
532
 * @interpolation: Type of interpolation.
533
533
 * @supersample: Whether to perform supersample.
534
534
 * @recursion_level: Level of recursion (3 is a nice default).
535
 
 * @clip_result: Whether to clip results.
 
535
 * @clip_result: How to clip results.
536
536
 *
537
537
 * Scale the specified drawable with extra parameters
538
538
 *
550
550
 */
551
551
gint32
552
552
gimp_drawable_transform_scale (gint32                 drawable_ID,
553
 
                               gdouble                x0,
554
 
                               gdouble                y0,
555
 
                               gdouble                x1,
556
 
                               gdouble                y1,
557
 
                               GimpTransformDirection transform_direction,
558
 
                               GimpInterpolationType  interpolation,
559
 
                               gboolean               supersample,
560
 
                               gint                   recursion_level,
561
 
                               gboolean               clip_result)
 
553
                               gdouble                x0,
 
554
                               gdouble                y0,
 
555
                               gdouble                x1,
 
556
                               gdouble                y1,
 
557
                               GimpTransformDirection transform_direction,
 
558
                               GimpInterpolationType  interpolation,
 
559
                               gboolean               supersample,
 
560
                               gint                   recursion_level,
 
561
                               GimpTransformResize    clip_result)
562
562
{
563
563
  GimpParam *return_vals;
564
564
  gint nreturn_vals;
565
565
  gint32 ret_drawable_ID = -1;
566
566
 
567
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_scale",
568
 
                                    &nreturn_vals,
569
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
570
 
                                    GIMP_PDB_FLOAT, x0,
571
 
                                    GIMP_PDB_FLOAT, y0,
572
 
                                    GIMP_PDB_FLOAT, x1,
573
 
                                    GIMP_PDB_FLOAT, y1,
574
 
                                    GIMP_PDB_INT32, transform_direction,
575
 
                                    GIMP_PDB_INT32, interpolation,
576
 
                                    GIMP_PDB_INT32, supersample,
577
 
                                    GIMP_PDB_INT32, recursion_level,
578
 
                                    GIMP_PDB_INT32, clip_result,
579
 
                                    GIMP_PDB_END);
 
567
  return_vals = gimp_run_procedure ("gimp-drawable-transform-scale",
 
568
                                    &nreturn_vals,
 
569
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
570
                                    GIMP_PDB_FLOAT, x0,
 
571
                                    GIMP_PDB_FLOAT, y0,
 
572
                                    GIMP_PDB_FLOAT, x1,
 
573
                                    GIMP_PDB_FLOAT, y1,
 
574
                                    GIMP_PDB_INT32, transform_direction,
 
575
                                    GIMP_PDB_INT32, interpolation,
 
576
                                    GIMP_PDB_INT32, supersample,
 
577
                                    GIMP_PDB_INT32, recursion_level,
 
578
                                    GIMP_PDB_INT32, clip_result,
 
579
                                    GIMP_PDB_END);
580
580
 
581
581
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
582
582
    ret_drawable_ID = return_vals[1].data.d_drawable;
589
589
/**
590
590
 * gimp_drawable_transform_scale_default:
591
591
 * @drawable_ID: The affected drawable.
592
 
 * @x0: The new x coordinate of upper-left corner of newly scaled region.
593
 
 * @y0: The new y coordinate of upper-left corner of newly scaled region.
594
 
 * @x1: The new x coordinate of lower-right corner of newly scaled region.
595
 
 * @y1: The new y coordinate of lower-right corner of newly scaled region.
 
592
 * @x0: The new x coordinate of the upper-left corner of the scaled region.
 
593
 * @y0: The new y coordinate of the upper-left corner of the scaled region.
 
594
 * @x1: The new x coordinate of the lower-right corner of the scaled region.
 
595
 * @y1: The new y coordinate of the lower-right corner of the scaled region.
596
596
 * @interpolate: Whether to use interpolation and supersampling.
597
 
 * @clip_result: Whether to clip results.
 
597
 * @clip_result: How to clip results.
598
598
 *
599
599
 * Scale the specified drawable with extra parameters
600
600
 *
607
607
 * Since: GIMP 2.2
608
608
 */
609
609
gint32
610
 
gimp_drawable_transform_scale_default (gint32   drawable_ID,
611
 
                                       gdouble  x0,
612
 
                                       gdouble  y0,
613
 
                                       gdouble  x1,
614
 
                                       gdouble  y1,
615
 
                                       gboolean interpolate,
616
 
                                       gboolean clip_result)
 
610
gimp_drawable_transform_scale_default (gint32              drawable_ID,
 
611
                                       gdouble             x0,
 
612
                                       gdouble             y0,
 
613
                                       gdouble             x1,
 
614
                                       gdouble             y1,
 
615
                                       gboolean            interpolate,
 
616
                                       GimpTransformResize clip_result)
617
617
{
618
618
  GimpParam *return_vals;
619
619
  gint nreturn_vals;
620
620
  gint32 ret_drawable_ID = -1;
621
621
 
622
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_scale_default",
623
 
                                    &nreturn_vals,
624
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
625
 
                                    GIMP_PDB_FLOAT, x0,
626
 
                                    GIMP_PDB_FLOAT, y0,
627
 
                                    GIMP_PDB_FLOAT, x1,
628
 
                                    GIMP_PDB_FLOAT, y1,
629
 
                                    GIMP_PDB_INT32, interpolate,
630
 
                                    GIMP_PDB_INT32, clip_result,
631
 
                                    GIMP_PDB_END);
 
622
  return_vals = gimp_run_procedure ("gimp-drawable-transform-scale-default",
 
623
                                    &nreturn_vals,
 
624
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
625
                                    GIMP_PDB_FLOAT, x0,
 
626
                                    GIMP_PDB_FLOAT, y0,
 
627
                                    GIMP_PDB_FLOAT, x1,
 
628
                                    GIMP_PDB_FLOAT, y1,
 
629
                                    GIMP_PDB_INT32, interpolate,
 
630
                                    GIMP_PDB_INT32, clip_result,
 
631
                                    GIMP_PDB_END);
632
632
 
633
633
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
634
634
    ret_drawable_ID = return_vals[1].data.d_drawable;
643
643
 * @drawable_ID: The affected drawable.
644
644
 * @shear_type: Type of shear.
645
645
 * @magnitude: The magnitude of the shear.
646
 
 * @transform_direction: Direction of Transformation.
 
646
 * @transform_direction: Direction of transformation.
647
647
 * @interpolation: Type of interpolation.
648
648
 * @supersample: Whether to perform supersample.
649
649
 * @recursion_level: Level of recursion (3 is a nice default).
650
 
 * @clip_result: Whether to clip results.
 
650
 * @clip_result: How to clip results.
651
651
 *
652
652
 * Shear the specified drawable about its center by the specified
653
653
 * magnitude, with extra parameters.
669
669
 */
670
670
gint32
671
671
gimp_drawable_transform_shear (gint32                 drawable_ID,
672
 
                               GimpOrientationType    shear_type,
673
 
                               gdouble                magnitude,
674
 
                               GimpTransformDirection transform_direction,
675
 
                               GimpInterpolationType  interpolation,
676
 
                               gboolean               supersample,
677
 
                               gint                   recursion_level,
678
 
                               gboolean               clip_result)
 
672
                               GimpOrientationType    shear_type,
 
673
                               gdouble                magnitude,
 
674
                               GimpTransformDirection transform_direction,
 
675
                               GimpInterpolationType  interpolation,
 
676
                               gboolean               supersample,
 
677
                               gint                   recursion_level,
 
678
                               GimpTransformResize    clip_result)
679
679
{
680
680
  GimpParam *return_vals;
681
681
  gint nreturn_vals;
682
682
  gint32 ret_drawable_ID = -1;
683
683
 
684
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_shear",
685
 
                                    &nreturn_vals,
686
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
687
 
                                    GIMP_PDB_INT32, shear_type,
688
 
                                    GIMP_PDB_FLOAT, magnitude,
689
 
                                    GIMP_PDB_INT32, transform_direction,
690
 
                                    GIMP_PDB_INT32, interpolation,
691
 
                                    GIMP_PDB_INT32, supersample,
692
 
                                    GIMP_PDB_INT32, recursion_level,
693
 
                                    GIMP_PDB_INT32, clip_result,
694
 
                                    GIMP_PDB_END);
 
684
  return_vals = gimp_run_procedure ("gimp-drawable-transform-shear",
 
685
                                    &nreturn_vals,
 
686
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
687
                                    GIMP_PDB_INT32, shear_type,
 
688
                                    GIMP_PDB_FLOAT, magnitude,
 
689
                                    GIMP_PDB_INT32, transform_direction,
 
690
                                    GIMP_PDB_INT32, interpolation,
 
691
                                    GIMP_PDB_INT32, supersample,
 
692
                                    GIMP_PDB_INT32, recursion_level,
 
693
                                    GIMP_PDB_INT32, clip_result,
 
694
                                    GIMP_PDB_END);
695
695
 
696
696
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
697
697
    ret_drawable_ID = return_vals[1].data.d_drawable;
707
707
 * @shear_type: Type of shear.
708
708
 * @magnitude: The magnitude of the shear.
709
709
 * @interpolate: Whether to use interpolation and supersampling.
710
 
 * @clip_result: Whether to clip results.
 
710
 * @clip_result: How to clip results.
711
711
 *
712
712
 * Shear the specified drawable about its center by the specified
713
713
 * magnitude, with extra parameters.
722
722
 */
723
723
gint32
724
724
gimp_drawable_transform_shear_default (gint32              drawable_ID,
725
 
                                       GimpOrientationType shear_type,
726
 
                                       gdouble             magnitude,
727
 
                                       gboolean            interpolate,
728
 
                                       gboolean            clip_result)
 
725
                                       GimpOrientationType shear_type,
 
726
                                       gdouble             magnitude,
 
727
                                       gboolean            interpolate,
 
728
                                       GimpTransformResize clip_result)
729
729
{
730
730
  GimpParam *return_vals;
731
731
  gint nreturn_vals;
732
732
  gint32 ret_drawable_ID = -1;
733
733
 
734
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_shear_default",
735
 
                                    &nreturn_vals,
736
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
737
 
                                    GIMP_PDB_INT32, shear_type,
738
 
                                    GIMP_PDB_FLOAT, magnitude,
739
 
                                    GIMP_PDB_INT32, interpolate,
740
 
                                    GIMP_PDB_INT32, clip_result,
741
 
                                    GIMP_PDB_END);
 
734
  return_vals = gimp_run_procedure ("gimp-drawable-transform-shear-default",
 
735
                                    &nreturn_vals,
 
736
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
737
                                    GIMP_PDB_INT32, shear_type,
 
738
                                    GIMP_PDB_FLOAT, magnitude,
 
739
                                    GIMP_PDB_INT32, interpolate,
 
740
                                    GIMP_PDB_INT32, clip_result,
 
741
                                    GIMP_PDB_END);
742
742
 
743
743
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
744
744
    ret_drawable_ID = return_vals[1].data.d_drawable;
758
758
 * @angle: The angle of rotation (radians).
759
759
 * @dest_x: X coordinate of where the center goes.
760
760
 * @dest_y: Y coordinate of where the center goes.
761
 
 * @transform_direction: Direction of Transformation.
 
761
 * @transform_direction: Direction of transformation.
762
762
 * @interpolation: Type of interpolation.
763
763
 * @supersample: Whether to perform supersample.
764
764
 * @recursion_level: Level of recursion (3 is a nice default).
765
 
 * @clip_result: Whether to clip results.
 
765
 * @clip_result: How to clip results.
766
766
 *
767
767
 * Transform the specified drawable in 2d, with extra parameters.
768
768
 *
783
783
 */
784
784
gint32
785
785
gimp_drawable_transform_2d (gint32                 drawable_ID,
786
 
                            gdouble                source_x,
787
 
                            gdouble                source_y,
788
 
                            gdouble                scale_x,
789
 
                            gdouble                scale_y,
790
 
                            gdouble                angle,
791
 
                            gdouble                dest_x,
792
 
                            gdouble                dest_y,
793
 
                            GimpTransformDirection transform_direction,
794
 
                            GimpInterpolationType  interpolation,
795
 
                            gboolean               supersample,
796
 
                            gint                   recursion_level,
797
 
                            gboolean               clip_result)
 
786
                            gdouble                source_x,
 
787
                            gdouble                source_y,
 
788
                            gdouble                scale_x,
 
789
                            gdouble                scale_y,
 
790
                            gdouble                angle,
 
791
                            gdouble                dest_x,
 
792
                            gdouble                dest_y,
 
793
                            GimpTransformDirection transform_direction,
 
794
                            GimpInterpolationType  interpolation,
 
795
                            gboolean               supersample,
 
796
                            gint                   recursion_level,
 
797
                            GimpTransformResize    clip_result)
798
798
{
799
799
  GimpParam *return_vals;
800
800
  gint nreturn_vals;
801
801
  gint32 ret_drawable_ID = -1;
802
802
 
803
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_2d",
804
 
                                    &nreturn_vals,
805
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
806
 
                                    GIMP_PDB_FLOAT, source_x,
807
 
                                    GIMP_PDB_FLOAT, source_y,
808
 
                                    GIMP_PDB_FLOAT, scale_x,
809
 
                                    GIMP_PDB_FLOAT, scale_y,
810
 
                                    GIMP_PDB_FLOAT, angle,
811
 
                                    GIMP_PDB_FLOAT, dest_x,
812
 
                                    GIMP_PDB_FLOAT, dest_y,
813
 
                                    GIMP_PDB_INT32, transform_direction,
814
 
                                    GIMP_PDB_INT32, interpolation,
815
 
                                    GIMP_PDB_INT32, supersample,
816
 
                                    GIMP_PDB_INT32, recursion_level,
817
 
                                    GIMP_PDB_INT32, clip_result,
818
 
                                    GIMP_PDB_END);
 
803
  return_vals = gimp_run_procedure ("gimp-drawable-transform-2d",
 
804
                                    &nreturn_vals,
 
805
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
806
                                    GIMP_PDB_FLOAT, source_x,
 
807
                                    GIMP_PDB_FLOAT, source_y,
 
808
                                    GIMP_PDB_FLOAT, scale_x,
 
809
                                    GIMP_PDB_FLOAT, scale_y,
 
810
                                    GIMP_PDB_FLOAT, angle,
 
811
                                    GIMP_PDB_FLOAT, dest_x,
 
812
                                    GIMP_PDB_FLOAT, dest_y,
 
813
                                    GIMP_PDB_INT32, transform_direction,
 
814
                                    GIMP_PDB_INT32, interpolation,
 
815
                                    GIMP_PDB_INT32, supersample,
 
816
                                    GIMP_PDB_INT32, recursion_level,
 
817
                                    GIMP_PDB_INT32, clip_result,
 
818
                                    GIMP_PDB_END);
819
819
 
820
820
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
821
821
    ret_drawable_ID = return_vals[1].data.d_drawable;
836
836
 * @dest_x: X coordinate of where the center goes.
837
837
 * @dest_y: Y coordinate of where the center goes.
838
838
 * @interpolate: Whether to use interpolation and supersampling.
839
 
 * @clip_result: Whether to clip results.
 
839
 * @clip_result: How to clip results.
840
840
 *
841
841
 * Transform the specified drawable in 2d, with extra parameters.
842
842
 *
849
849
 * Since: GIMP 2.2
850
850
 */
851
851
gint32
852
 
gimp_drawable_transform_2d_default (gint32   drawable_ID,
853
 
                                    gdouble  source_x,
854
 
                                    gdouble  source_y,
855
 
                                    gdouble  scale_x,
856
 
                                    gdouble  scale_y,
857
 
                                    gdouble  angle,
858
 
                                    gdouble  dest_x,
859
 
                                    gdouble  dest_y,
860
 
                                    gboolean interpolate,
861
 
                                    gboolean clip_result)
 
852
gimp_drawable_transform_2d_default (gint32              drawable_ID,
 
853
                                    gdouble             source_x,
 
854
                                    gdouble             source_y,
 
855
                                    gdouble             scale_x,
 
856
                                    gdouble             scale_y,
 
857
                                    gdouble             angle,
 
858
                                    gdouble             dest_x,
 
859
                                    gdouble             dest_y,
 
860
                                    gboolean            interpolate,
 
861
                                    GimpTransformResize clip_result)
862
862
{
863
863
  GimpParam *return_vals;
864
864
  gint nreturn_vals;
865
865
  gint32 ret_drawable_ID = -1;
866
866
 
867
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_2d_default",
868
 
                                    &nreturn_vals,
869
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
870
 
                                    GIMP_PDB_FLOAT, source_x,
871
 
                                    GIMP_PDB_FLOAT, source_y,
872
 
                                    GIMP_PDB_FLOAT, scale_x,
873
 
                                    GIMP_PDB_FLOAT, scale_y,
874
 
                                    GIMP_PDB_FLOAT, angle,
875
 
                                    GIMP_PDB_FLOAT, dest_x,
876
 
                                    GIMP_PDB_FLOAT, dest_y,
877
 
                                    GIMP_PDB_INT32, interpolate,
878
 
                                    GIMP_PDB_INT32, clip_result,
879
 
                                    GIMP_PDB_END);
 
867
  return_vals = gimp_run_procedure ("gimp-drawable-transform-2d-default",
 
868
                                    &nreturn_vals,
 
869
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
870
                                    GIMP_PDB_FLOAT, source_x,
 
871
                                    GIMP_PDB_FLOAT, source_y,
 
872
                                    GIMP_PDB_FLOAT, scale_x,
 
873
                                    GIMP_PDB_FLOAT, scale_y,
 
874
                                    GIMP_PDB_FLOAT, angle,
 
875
                                    GIMP_PDB_FLOAT, dest_x,
 
876
                                    GIMP_PDB_FLOAT, dest_y,
 
877
                                    GIMP_PDB_INT32, interpolate,
 
878
                                    GIMP_PDB_INT32, clip_result,
 
879
                                    GIMP_PDB_END);
880
880
 
881
881
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
882
882
    ret_drawable_ID = return_vals[1].data.d_drawable;
898
898
 * @coeff_2_0: coefficient (2,0) of the transformation matrix.
899
899
 * @coeff_2_1: coefficient (2,1) of the transformation matrix.
900
900
 * @coeff_2_2: coefficient (2,2) of the transformation matrix.
901
 
 * @transform_direction: Direction of Transformation.
 
901
 * @transform_direction: Direction of transformation.
902
902
 * @interpolation: Type of interpolation.
903
903
 * @supersample: Whether to perform supersample.
904
904
 * @recursion_level: Level of recursion (3 is a nice default).
905
 
 * @clip_result: Whether to clip results.
 
905
 * @clip_result: How to clip results.
906
906
 *
907
907
 * Transform the specified drawable in 2d, with extra parameters.
908
908
 *
921
921
 */
922
922
gint32
923
923
gimp_drawable_transform_matrix (gint32                 drawable_ID,
924
 
                                gdouble                coeff_0_0,
925
 
                                gdouble                coeff_0_1,
926
 
                                gdouble                coeff_0_2,
927
 
                                gdouble                coeff_1_0,
928
 
                                gdouble                coeff_1_1,
929
 
                                gdouble                coeff_1_2,
930
 
                                gdouble                coeff_2_0,
931
 
                                gdouble                coeff_2_1,
932
 
                                gdouble                coeff_2_2,
933
 
                                GimpTransformDirection transform_direction,
934
 
                                GimpInterpolationType  interpolation,
935
 
                                gboolean               supersample,
936
 
                                gint                   recursion_level,
937
 
                                gboolean               clip_result)
 
924
                                gdouble                coeff_0_0,
 
925
                                gdouble                coeff_0_1,
 
926
                                gdouble                coeff_0_2,
 
927
                                gdouble                coeff_1_0,
 
928
                                gdouble                coeff_1_1,
 
929
                                gdouble                coeff_1_2,
 
930
                                gdouble                coeff_2_0,
 
931
                                gdouble                coeff_2_1,
 
932
                                gdouble                coeff_2_2,
 
933
                                GimpTransformDirection transform_direction,
 
934
                                GimpInterpolationType  interpolation,
 
935
                                gboolean               supersample,
 
936
                                gint                   recursion_level,
 
937
                                GimpTransformResize    clip_result)
938
938
{
939
939
  GimpParam *return_vals;
940
940
  gint nreturn_vals;
941
941
  gint32 ret_drawable_ID = -1;
942
942
 
943
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_matrix",
944
 
                                    &nreturn_vals,
945
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
946
 
                                    GIMP_PDB_FLOAT, coeff_0_0,
947
 
                                    GIMP_PDB_FLOAT, coeff_0_1,
948
 
                                    GIMP_PDB_FLOAT, coeff_0_2,
949
 
                                    GIMP_PDB_FLOAT, coeff_1_0,
950
 
                                    GIMP_PDB_FLOAT, coeff_1_1,
951
 
                                    GIMP_PDB_FLOAT, coeff_1_2,
952
 
                                    GIMP_PDB_FLOAT, coeff_2_0,
953
 
                                    GIMP_PDB_FLOAT, coeff_2_1,
954
 
                                    GIMP_PDB_FLOAT, coeff_2_2,
955
 
                                    GIMP_PDB_INT32, transform_direction,
956
 
                                    GIMP_PDB_INT32, interpolation,
957
 
                                    GIMP_PDB_INT32, supersample,
958
 
                                    GIMP_PDB_INT32, recursion_level,
959
 
                                    GIMP_PDB_INT32, clip_result,
960
 
                                    GIMP_PDB_END);
 
943
  return_vals = gimp_run_procedure ("gimp-drawable-transform-matrix",
 
944
                                    &nreturn_vals,
 
945
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
946
                                    GIMP_PDB_FLOAT, coeff_0_0,
 
947
                                    GIMP_PDB_FLOAT, coeff_0_1,
 
948
                                    GIMP_PDB_FLOAT, coeff_0_2,
 
949
                                    GIMP_PDB_FLOAT, coeff_1_0,
 
950
                                    GIMP_PDB_FLOAT, coeff_1_1,
 
951
                                    GIMP_PDB_FLOAT, coeff_1_2,
 
952
                                    GIMP_PDB_FLOAT, coeff_2_0,
 
953
                                    GIMP_PDB_FLOAT, coeff_2_1,
 
954
                                    GIMP_PDB_FLOAT, coeff_2_2,
 
955
                                    GIMP_PDB_INT32, transform_direction,
 
956
                                    GIMP_PDB_INT32, interpolation,
 
957
                                    GIMP_PDB_INT32, supersample,
 
958
                                    GIMP_PDB_INT32, recursion_level,
 
959
                                    GIMP_PDB_INT32, clip_result,
 
960
                                    GIMP_PDB_END);
961
961
 
962
962
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
963
963
    ret_drawable_ID = return_vals[1].data.d_drawable;
980
980
 * @coeff_2_1: coefficient (2,1) of the transformation matrix.
981
981
 * @coeff_2_2: coefficient (2,2) of the transformation matrix.
982
982
 * @interpolate: Whether to use interpolation and supersampling.
983
 
 * @clip_result: Whether to clip results.
 
983
 * @clip_result: How to clip results.
984
984
 *
985
985
 * Transform the specified drawable in 2d, with extra parameters.
986
986
 *
993
993
 * Since: GIMP 2.2
994
994
 */
995
995
gint32
996
 
gimp_drawable_transform_matrix_default (gint32   drawable_ID,
997
 
                                        gdouble  coeff_0_0,
998
 
                                        gdouble  coeff_0_1,
999
 
                                        gdouble  coeff_0_2,
1000
 
                                        gdouble  coeff_1_0,
1001
 
                                        gdouble  coeff_1_1,
1002
 
                                        gdouble  coeff_1_2,
1003
 
                                        gdouble  coeff_2_0,
1004
 
                                        gdouble  coeff_2_1,
1005
 
                                        gdouble  coeff_2_2,
1006
 
                                        gboolean interpolate,
1007
 
                                        gboolean clip_result)
 
996
gimp_drawable_transform_matrix_default (gint32              drawable_ID,
 
997
                                        gdouble             coeff_0_0,
 
998
                                        gdouble             coeff_0_1,
 
999
                                        gdouble             coeff_0_2,
 
1000
                                        gdouble             coeff_1_0,
 
1001
                                        gdouble             coeff_1_1,
 
1002
                                        gdouble             coeff_1_2,
 
1003
                                        gdouble             coeff_2_0,
 
1004
                                        gdouble             coeff_2_1,
 
1005
                                        gdouble             coeff_2_2,
 
1006
                                        gboolean            interpolate,
 
1007
                                        GimpTransformResize clip_result)
1008
1008
{
1009
1009
  GimpParam *return_vals;
1010
1010
  gint nreturn_vals;
1011
1011
  gint32 ret_drawable_ID = -1;
1012
1012
 
1013
 
  return_vals = gimp_run_procedure ("gimp_drawable_transform_matrix_default",
1014
 
                                    &nreturn_vals,
1015
 
                                    GIMP_PDB_DRAWABLE, drawable_ID,
1016
 
                                    GIMP_PDB_FLOAT, coeff_0_0,
1017
 
                                    GIMP_PDB_FLOAT, coeff_0_1,
1018
 
                                    GIMP_PDB_FLOAT, coeff_0_2,
1019
 
                                    GIMP_PDB_FLOAT, coeff_1_0,
1020
 
                                    GIMP_PDB_FLOAT, coeff_1_1,
1021
 
                                    GIMP_PDB_FLOAT, coeff_1_2,
1022
 
                                    GIMP_PDB_FLOAT, coeff_2_0,
1023
 
                                    GIMP_PDB_FLOAT, coeff_2_1,
1024
 
                                    GIMP_PDB_FLOAT, coeff_2_2,
1025
 
                                    GIMP_PDB_INT32, interpolate,
1026
 
                                    GIMP_PDB_INT32, clip_result,
1027
 
                                    GIMP_PDB_END);
 
1013
  return_vals = gimp_run_procedure ("gimp-drawable-transform-matrix-default",
 
1014
                                    &nreturn_vals,
 
1015
                                    GIMP_PDB_DRAWABLE, drawable_ID,
 
1016
                                    GIMP_PDB_FLOAT, coeff_0_0,
 
1017
                                    GIMP_PDB_FLOAT, coeff_0_1,
 
1018
                                    GIMP_PDB_FLOAT, coeff_0_2,
 
1019
                                    GIMP_PDB_FLOAT, coeff_1_0,
 
1020
                                    GIMP_PDB_FLOAT, coeff_1_1,
 
1021
                                    GIMP_PDB_FLOAT, coeff_1_2,
 
1022
                                    GIMP_PDB_FLOAT, coeff_2_0,
 
1023
                                    GIMP_PDB_FLOAT, coeff_2_1,
 
1024
                                    GIMP_PDB_FLOAT, coeff_2_2,
 
1025
                                    GIMP_PDB_INT32, interpolate,
 
1026
                                    GIMP_PDB_INT32, clip_result,
 
1027
                                    GIMP_PDB_END);
1028
1028
 
1029
1029
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
1030
1030
    ret_drawable_ID = return_vals[1].data.d_drawable;