gimppainttools_pdb.c 27.4 KB
Newer Older
1
/* LIBGIMP - The GIMP Library
2
 * Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
3
 *
Michael Natterer's avatar
Michael Natterer committed
4
 * gimppainttools_pdb.c
5
 *
6
 * This library is free software: you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
9
 * version 3 of the License, or (at your option) any later version.
10 11 12 13 14 15 16
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17 18
 * License along with this library.  If not, see
 * <http://www.gnu.org/licenses/>.
19 20
 */

21
/* NOTE: This file is auto-generated by pdbgen.pl */
22

Sven Neumann's avatar
Sven Neumann committed
23 24
#include "config.h"

25 26
#include "gimp.h"

27 28 29 30 31 32 33 34 35 36

/**
 * SECTION: gimppainttools
 * @title: gimppainttools
 * @short_description: Access to toolbox paint tools.
 *
 * Functions giving access to toolbox paint tools.
 **/


37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
/**
 * gimp_airbrush:
 * @drawable_ID: The affected drawable.
 * @pressure: The pressure of the airbrush strokes.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Paint in the current brush with varying pressure. Paint application
 * is time-dependent.
 *
 * This tool simulates the use of an airbrush. Paint pressure
 * represents the relative intensity of the paint application. High
 * pressure results in a thicker layer of paint while low pressure
 * results in a thinner layer.
 *
 * Returns: TRUE on success.
53
 **/
54
gboolean
55
gimp_airbrush (gint32         drawable_ID,
56 57 58
               gdouble        pressure,
               gint           num_strokes,
               const gdouble *strokes)
59
{
60
  GimpParam *return_vals;
61
  gint nreturn_vals;
62
  gboolean success = TRUE;
63

64
  return_vals = gimp_run_procedure ("gimp-airbrush",
65 66 67 68 69 70
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_FLOAT, pressure,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
71

72 73
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

74
  gimp_destroy_params (return_vals, nreturn_vals);
75 76

  return success;
77 78
}

79 80 81 82 83 84 85 86 87 88
/**
 * gimp_airbrush_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Paint in the current brush with varying pressure. Paint application
 * is time-dependent.
 *
 * This tool simulates the use of an airbrush. It is similar to
89 90 91
 * gimp_airbrush() except that the pressure is derived from the
 * airbrush tools options box. It the option has not been set the
 * default for the option will be used.
92 93
 *
 * Returns: TRUE on success.
94
 **/
95
gboolean
96
gimp_airbrush_default (gint32         drawable_ID,
97 98
                       gint           num_strokes,
                       const gdouble *strokes)
99
{
100
  GimpParam *return_vals;
101
  gint nreturn_vals;
102
  gboolean success = TRUE;
103

104
  return_vals = gimp_run_procedure ("gimp-airbrush-default",
105 106 107 108 109
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
110

111 112
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

113
  gimp_destroy_params (return_vals, nreturn_vals);
114 115

  return success;
116 117
}

118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
/**
 * gimp_clone:
 * @drawable_ID: The affected drawable.
 * @src_drawable_ID: The source drawable.
 * @clone_type: The type of clone.
 * @src_x: The x coordinate in the source image.
 * @src_y: The y coordinate in the source image.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Clone from the source to the dest drawable using the current brush
 *
 * This tool clones (copies) from the source drawable starting at the
 * specified source coordinates to the dest drawable. If the
 * \"clone_type\" argument is set to PATTERN-CLONE, then the current
 * pattern is used as the source and the \"src_drawable\" argument is
 * ignored. Pattern cloning assumes a tileable pattern and mods the sum
 * of the src coordinates and subsequent stroke offsets with the width
 * and height of the pattern. For image cloning, if the sum of the src
 * coordinates and subsequent stroke offsets exceeds the extents of the
 * src drawable, then no paint is transferred. The clone tool is
 * capable of transforming between any image types including
140
 * RGB-&gt;Indexed--although converting from any type to indexed is
141 142 143
 * significantly slower.
 *
 * Returns: TRUE on success.
144
 **/
145
gboolean
146
gimp_clone (gint32         drawable_ID,
147 148 149 150 151 152
            gint32         src_drawable_ID,
            GimpCloneType  clone_type,
            gdouble        src_x,
            gdouble        src_y,
            gint           num_strokes,
            const gdouble *strokes)
153
{
154
  GimpParam *return_vals;
155
  gint nreturn_vals;
156
  gboolean success = TRUE;
157

158
  return_vals = gimp_run_procedure ("gimp-clone",
159 160 161 162 163 164 165 166 167
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_DRAWABLE, src_drawable_ID,
                                    GIMP_PDB_INT32, clone_type,
                                    GIMP_PDB_FLOAT, src_x,
                                    GIMP_PDB_FLOAT, src_y,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
168

169 170
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

171
  gimp_destroy_params (return_vals, nreturn_vals);
172 173

  return success;
174 175
}

176 177 178 179 180 181 182 183 184 185
/**
 * gimp_clone_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Clone from the source to the dest drawable using the current brush
 *
 * This tool clones (copies) from the source drawable starting at the
 * specified source coordinates to the dest drawable. This function
186 187 188 189
 * performs exactly the same as the gimp_clone() function except that
 * the tools arguments are obtained from the clones option dialog. It
 * this dialog has not been activated then the dialogs default values
 * will be used.
190 191
 *
 * Returns: TRUE on success.
192
 **/
193
gboolean
194
gimp_clone_default (gint32         drawable_ID,
195 196
                    gint           num_strokes,
                    const gdouble *strokes)
197
{
198
  GimpParam *return_vals;
199
  gint nreturn_vals;
200
  gboolean success = TRUE;
201

202
  return_vals = gimp_run_procedure ("gimp-clone-default",
203 204 205 206 207
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
208

209 210
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

211
  gimp_destroy_params (return_vals, nreturn_vals);
212 213

  return success;
214 215
}

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
/**
 * gimp_convolve:
 * @drawable_ID: The affected drawable.
 * @pressure: The pressure.
 * @convolve_type: Convolve type.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Convolve (Blur, Sharpen) using the current brush.
 *
 * This tool convolves the specified drawable with either a sharpening
 * or blurring kernel. The pressure parameter controls the magnitude of
 * the operation. Like the paintbrush, this tool linearly interpolates
 * between the specified stroke coordinates.
 *
 * Returns: TRUE on success.
232
 **/
233
gboolean
234
gimp_convolve (gint32            drawable_ID,
235 236 237 238
               gdouble           pressure,
               GimpConvolveType  convolve_type,
               gint              num_strokes,
               const gdouble    *strokes)
239
{
240
  GimpParam *return_vals;
241
  gint nreturn_vals;
242
  gboolean success = TRUE;
243

244
  return_vals = gimp_run_procedure ("gimp-convolve",
245 246 247 248 249 250 251
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_FLOAT, pressure,
                                    GIMP_PDB_INT32, convolve_type,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
252

253 254
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

255
  gimp_destroy_params (return_vals, nreturn_vals);
256 257

  return success;
258 259
}

260 261 262 263 264 265 266 267 268 269
/**
 * gimp_convolve_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Convolve (Blur, Sharpen) using the current brush.
 *
 * This tool convolves the specified drawable with either a sharpening
 * or blurring kernel. This function performs exactly the same as the
270 271 272
 * gimp_convolve() function except that the tools arguments are
 * obtained from the convolve option dialog. It this dialog has not
 * been activated then the dialogs default values will be used.
273 274
 *
 * Returns: TRUE on success.
275
 **/
276
gboolean
277
gimp_convolve_default (gint32         drawable_ID,
278 279
                       gint           num_strokes,
                       const gdouble *strokes)
280
{
281
  GimpParam *return_vals;
282
  gint nreturn_vals;
283
  gboolean success = TRUE;
284

285
  return_vals = gimp_run_procedure ("gimp-convolve-default",
286 287 288 289 290
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
291

292 293
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

294
  gimp_destroy_params (return_vals, nreturn_vals);
295 296

  return success;
297 298
}

299 300 301
/**
 * gimp_dodgeburn:
 * @drawable_ID: The affected drawable.
302
 * @exposure: The exposure of the strokes.
303 304 305 306 307 308 309
 * @dodgeburn_type: The type either dodge or burn.
 * @dodgeburn_mode: The mode.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Dodgeburn image with varying exposure.
 *
Manish Singh's avatar
Manish Singh committed
310
 * Dodgeburn. More details here later.
311 312
 *
 * Returns: TRUE on success.
313
 **/
314
gboolean
315
gimp_dodgeburn (gint32             drawable_ID,
316 317 318 319 320
                gdouble            exposure,
                GimpDodgeBurnType  dodgeburn_type,
                GimpTransferMode   dodgeburn_mode,
                gint               num_strokes,
                const gdouble     *strokes)
321
{
322
  GimpParam *return_vals;
323
  gint nreturn_vals;
324
  gboolean success = TRUE;
325

326
  return_vals = gimp_run_procedure ("gimp-dodgeburn",
327 328 329 330 331 332 333 334
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_FLOAT, exposure,
                                    GIMP_PDB_INT32, dodgeburn_type,
                                    GIMP_PDB_INT32, dodgeburn_mode,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
335

336 337
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

338
  gimp_destroy_params (return_vals, nreturn_vals);
339 340

  return success;
341 342
}

343 344 345 346 347 348 349
/**
 * gimp_dodgeburn_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Dodgeburn image with varying exposure. This is the same as the
350 351
 * gimp_dodgeburn() function except that the exposure, type and mode
 * are taken from the tools option dialog. If the dialog has not been
352 353
 * activated then the defaults as used by the dialog will be used.
 *
354
 * Dodgeburn. More details here later.
355 356
 *
 * Returns: TRUE on success.
357
 **/
358
gboolean
359
gimp_dodgeburn_default (gint32         drawable_ID,
360 361
                        gint           num_strokes,
                        const gdouble *strokes)
362
{
363
  GimpParam *return_vals;
364
  gint nreturn_vals;
365
  gboolean success = TRUE;
366

367
  return_vals = gimp_run_procedure ("gimp-dodgeburn-default",
368 369 370 371 372
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
373

374 375
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

376
  gimp_destroy_params (return_vals, nreturn_vals);
377 378

  return success;
379 380
}

381 382 383 384 385
/**
 * gimp_eraser:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
386 387
 * @hardness: How to apply the brush.
 * @method: The paint method to use.
388 389 390 391 392 393 394 395 396 397
 *
 * Erase using the current brush.
 *
 * This tool erases using the current brush mask. If the specified
 * drawable contains an alpha channel, then the erased pixels will
 * become transparent. Otherwise, the eraser tool replaces the contents
 * of the drawable with the background color. Like paintbrush, this
 * tool linearly interpolates between the specified stroke coordinates.
 *
 * Returns: TRUE on success.
398
 **/
399
gboolean
400
gimp_eraser (gint32                    drawable_ID,
401 402 403 404
             gint                      num_strokes,
             const gdouble            *strokes,
             GimpBrushApplicationMode  hardness,
             GimpPaintApplicationMode  method)
405
{
406
  GimpParam *return_vals;
407
  gint nreturn_vals;
408
  gboolean success = TRUE;
409

410
  return_vals = gimp_run_procedure ("gimp-eraser",
411 412 413 414 415 416 417
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_INT32, hardness,
                                    GIMP_PDB_INT32, method,
                                    GIMP_PDB_END);
418

419 420
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

421
  gimp_destroy_params (return_vals, nreturn_vals);
422 423

  return success;
424 425
}

426 427 428 429 430 431 432 433 434
/**
 * gimp_eraser_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Erase using the current brush.
 *
 * This tool erases using the current brush mask. This function
435
 * performs exactly the same as the gimp_eraser() function except that
436 437 438 439 440
 * the tools arguments are obtained from the eraser option dialog. It
 * this dialog has not been activated then the dialogs default values
 * will be used.
 *
 * Returns: TRUE on success.
441
 **/
442
gboolean
443
gimp_eraser_default (gint32         drawable_ID,
444 445
                     gint           num_strokes,
                     const gdouble *strokes)
446
{
447
  GimpParam *return_vals;
448
  gint nreturn_vals;
449
  gboolean success = TRUE;
450

451
  return_vals = gimp_run_procedure ("gimp-eraser-default",
452 453 454 455 456
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
457

458 459
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

460
  gimp_destroy_params (return_vals, nreturn_vals);
461 462

  return success;
463 464
}

465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
/**
 * gimp_heal:
 * @drawable_ID: The affected drawable.
 * @src_drawable_ID: The source drawable.
 * @src_x: The x coordinate in the source image.
 * @src_y: The y coordinate in the source image.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Heal from the source to the dest drawable using the current brush
 *
 * This tool heals the source drawable starting at the specified source
 * coordinates to the dest drawable. For image healing, if the sum of
 * the src coordinates and subsequent stroke offsets exceeds the
 * extents of the src drawable, then no paint is transferred. The
 * healing tool is capable of transforming between any image types
 * except RGB-&gt;Indexed.
 *
 * Returns: TRUE on success.
 *
485
 * Since: 2.4
486
 **/
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
gboolean
gimp_heal (gint32         drawable_ID,
           gint32         src_drawable_ID,
           gdouble        src_x,
           gdouble        src_y,
           gint           num_strokes,
           const gdouble *strokes)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

  return_vals = gimp_run_procedure ("gimp-heal",
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_DRAWABLE, src_drawable_ID,
                                    GIMP_PDB_FLOAT, src_x,
                                    GIMP_PDB_FLOAT, src_y,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

/**
 * gimp_heal_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Heal from the source to the dest drawable using the current brush
 *
 * This tool heals from the source drawable starting at the specified
 * source coordinates to the dest drawable. This function performs
 * exactly the same as the gimp_heal() function except that the tools
 * arguments are obtained from the healing option dialog. It this
 * dialog has not been activated then the dialogs default values will
 * be used.
 *
 * Returns: TRUE on success.
 *
533
 * Since: 2.4
534
 **/
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
gboolean
gimp_heal_default (gint32         drawable_ID,
                   gint           num_strokes,
                   const gdouble *strokes)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

  return_vals = gimp_run_procedure ("gimp-heal-default",
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

558 559 560 561 562 563
/**
 * gimp_paintbrush:
 * @drawable_ID: The affected drawable.
 * @fade_out: Fade out parameter.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
564
 * @method: The paint method to use.
565 566 567 568 569 570 571 572
 * @gradient_length: Length of gradient to draw.
 *
 * Paint in the current brush with optional fade out parameter and pull
 * colors from a gradient.
 *
 * This tool is the standard paintbrush. It draws linearly interpolated
 * lines through the specified stroke coordinates. It operates on the
 * specified drawable in the foreground color with the active brush.
573 574 575 576 577 578
 * The 'fade-out' parameter is measured in pixels and allows the brush
 * stroke to linearly fall off. The pressure is set to the maximum at
 * the beginning of the stroke. As the distance of the stroke nears the
 * fade-out value, the pressure will approach zero. The gradient-length
 * is the distance to spread the gradient over. It is measured in
 * pixels. If the gradient-length is 0, no gradient is used.
579 580
 *
 * Returns: TRUE on success.
581
 **/
582
gboolean
583
gimp_paintbrush (gint32                    drawable_ID,
584 585 586 587 588
                 gdouble                   fade_out,
                 gint                      num_strokes,
                 const gdouble            *strokes,
                 GimpPaintApplicationMode  method,
                 gdouble                   gradient_length)
589
{
590
  GimpParam *return_vals;
591
  gint nreturn_vals;
592
  gboolean success = TRUE;
593

594
  return_vals = gimp_run_procedure ("gimp-paintbrush",
595 596 597 598 599 600 601 602
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_FLOAT, fade_out,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_INT32, method,
                                    GIMP_PDB_FLOAT, gradient_length,
                                    GIMP_PDB_END);
603

604 605
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

606
  gimp_destroy_params (return_vals, nreturn_vals);
607 608

  return success;
609 610
}

611 612 613 614 615 616 617 618 619 620 621 622 623 624
/**
 * gimp_paintbrush_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Paint in the current brush. The fade out parameter and pull colors
 * from a gradient parameter are set from the paintbrush options
 * dialog. If this dialog has not been activated then the dialog
 * defaults will be used.
 *
 * This tool is similar to the standard paintbrush. It draws linearly
 * interpolated lines through the specified stroke coordinates. It
 * operates on the specified drawable in the foreground color with the
625
 * active brush. The 'fade-out' parameter is measured in pixels and
626 627 628
 * allows the brush stroke to linearly fall off (value obtained from
 * the option dialog). The pressure is set to the maximum at the
 * beginning of the stroke. As the distance of the stroke nears the
629
 * fade-out value, the pressure will approach zero. The gradient-length
630
 * (value obtained from the option dialog) is the distance to spread
631
 * the gradient over. It is measured in pixels. If the gradient-length
632 633 634
 * is 0, no gradient is used.
 *
 * Returns: TRUE on success.
635
 **/
636
gboolean
637
gimp_paintbrush_default (gint32         drawable_ID,
638 639
                         gint           num_strokes,
                         const gdouble *strokes)
640
{
641
  GimpParam *return_vals;
642
  gint nreturn_vals;
643
  gboolean success = TRUE;
644

645
  return_vals = gimp_run_procedure ("gimp-paintbrush-default",
646 647 648 649 650
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
651

652 653
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

654
  gimp_destroy_params (return_vals, nreturn_vals);
655 656

  return success;
657 658
}

659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
/**
 * gimp_pencil:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Paint in the current brush without sub-pixel sampling.
 *
 * This tool is the standard pencil. It draws linearly interpolated
 * lines through the specified stroke coordinates. It operates on the
 * specified drawable in the foreground color with the active brush.
 * The brush mask is treated as though it contains only black and white
 * values. Any value below half is treated as black; any above half, as
 * white.
 *
 * Returns: TRUE on success.
675
 **/
676
gboolean
677
gimp_pencil (gint32         drawable_ID,
678 679
             gint           num_strokes,
             const gdouble *strokes)
680
{
681
  GimpParam *return_vals;
682
  gint nreturn_vals;
683
  gboolean success = TRUE;
684

685
  return_vals = gimp_run_procedure ("gimp-pencil",
686 687 688 689 690
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
691

692 693
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

694
  gimp_destroy_params (return_vals, nreturn_vals);
695 696

  return success;
697 698
}

699 700 701 702 703 704 705 706 707 708 709 710 711 712
/**
 * gimp_smudge:
 * @drawable_ID: The affected drawable.
 * @pressure: The pressure of the smudge strokes.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Smudge image with varying pressure.
 *
 * This tool simulates a smudge using the current brush. High pressure
 * results in a greater smudge of paint while low pressure results in a
 * lesser smudge.
 *
 * Returns: TRUE on success.
713
 **/
714
gboolean
715
gimp_smudge (gint32         drawable_ID,
716 717 718
             gdouble        pressure,
             gint           num_strokes,
             const gdouble *strokes)
719
{
720
  GimpParam *return_vals;
721
  gint nreturn_vals;
722
  gboolean success = TRUE;
723

724
  return_vals = gimp_run_procedure ("gimp-smudge",
725 726 727 728 729 730
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_FLOAT, pressure,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
731

732 733
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

734
  gimp_destroy_params (return_vals, nreturn_vals);
735 736

  return success;
737 738
}

739 740 741 742 743 744 745 746 747
/**
 * gimp_smudge_default:
 * @drawable_ID: The affected drawable.
 * @num_strokes: Number of stroke control points (count each coordinate as 2 points).
 * @strokes: Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
 *
 * Smudge image with varying pressure.
 *
 * This tool simulates a smudge using the current brush. It behaves
748
 * exactly the same as gimp_smudge() except that the pressure value is
749 750 751 752
 * taken from the smudge tool options or the options default if the
 * tools option dialog has not been activated.
 *
 * Returns: TRUE on success.
753
 **/
754
gboolean
755
gimp_smudge_default (gint32         drawable_ID,
756 757
                     gint           num_strokes,
                     const gdouble *strokes)
758
{
759
  GimpParam *return_vals;
760
  gint nreturn_vals;
761
  gboolean success = TRUE;
762

763
  return_vals = gimp_run_procedure ("gimp-smudge-default",
764 765 766 767 768
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_INT32, num_strokes,
                                    GIMP_PDB_FLOATARRAY, strokes,
                                    GIMP_PDB_END);
769

770 771
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

772
  gimp_destroy_params (return_vals, nreturn_vals);
773 774

  return success;
775
}