This is Info file pdb.info, produced by Makeinfo-1.64 from the input
file pdb.texi.

   This file describes the GIMP procedural database.

   Copyright (C) 1995, 1996, 1997 by Spencer Kimball and Peter Mattis.
All rights reserved.

   We distribute GIMP under the terms of the GNU General Public
License, Version 2, which we have included with this release in the
file named `COPYING', and in the "Copying" section of this manual.  As
indicated in the License, we provide the program "as is" without
warranty of any kind, either expressed or implied, without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

   Elite Image Manipulation

   * GIMP!: (pdb).		The GIMP procedural database.   direntry


File: pdb.info,  Node: Commands,  Prev: Top,  Up: Top

Commands
********

 - Function: Rotate COLORS RUN_MODE, IMAGE, DRAWABLE
     Then something else here-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (used for indexed images)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Pavel Grinfeld (pavel@ml.com)*

 - Function: extension_script_fu
     More help here later-*GIMP Extension*
   *Spencer Kimball & Peter Mattis*

 - Function: extension_script_fu_console RUN_MODE
     Provides an interface which allows interactive scheme
     development.-*GIMP Extension*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, [non-interactive]
   *Spencer Kimball & Peter Mattis*

 - Function: extension_script_fu_server RUN_MODE, PORT, LOGFILE
     Provides a server for remote script-fu operation-*GIMP Extension*

     *Inputs*
        * *run_mode* (PDB_INT32)-[Interactive], non-interactive

        * *port* (PDB_INT32)-The port on which to listen for requests

        * *logfile* (PDB_STRING)-The file to log server activity to
   *Spencer Kimball & Peter Mattis*

 - Function: file_gbr_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Tim Newsome*

 - Function: file_gbr_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, SPACING, DESCRIPTION
     Yeah!-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *spacing* (PDB_INT32)-Spacing of the brush

        * *description* (PDB_STRING)-Short description of the brush
   *Tim Newsome*

 - Function: file_gicon_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball*

 - Function: file_gicon_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, ICON_NAME
     FIXME: write help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *icon_name* (PDB_STRING)-The name of the icon
   *Spencer Kimball*

 - Function: file_gif_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for gif_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name entered

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball, Peter Mattis, Adam Moss, David Koblas*

 - Function: file_gif_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, INTERLACE
     FIXME: write help for gif_save-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Image to save

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name entered

        * *interlace* (PDB_INT32)-Save with interlacing option enabled
   *Spencer Kimball, Peter Mattis, Adam Moss, David Koblas*

 - Function: file_header_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME
     FIXME: write help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in
   *Spencer Kimball & Peter Mattis*

 - Function: file_hrz_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for hrz_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Albert Cahalan*

 - Function: file_hrz_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME
     HRZ saving handles all image types except those with alpha
     channels.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in
   *Albert Cahalan*

 - Function: file_jpeg_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for jpeg_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball & Peter Mattis*

 - Function: file_jpeg_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, QUALITY, SMOOTHING
     FIXME: write help for jpeg_save-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *quality* (PDB_FLOAT)-Quality of saved image (0 <= quality <=
          1)

        * *smoothing* (PDB_FLOAT)-Smoothing factor for saved image (0
          <= smoothing <= 1)
   *Spencer Kimball & Peter Mattis*

 - Function: file_pat_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Tim Newsome*

 - Function: file_pat_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, DESCRIPTION
     Yeah!-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *description* (PDB_STRING)-Short description of the pattern
   *Tim Newsome*

 - Function: file_pcx_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for pcx_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name entered

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Francisco Bustamante*

 - Function: file_pcx_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME
     FIXME: write help for pcx_save-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name entered
   *Francisco Bustamante*

 - Function: file_pnm_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for pnm_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Erik Nygren*

 - Function: file_pnm_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, RAW
     PNM saving handles all image types except those with alpha
     channels.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw* (PDB_INT32)-Specify non-zero for raw output, zero for
          ascii output
   *Erik Nygren*

 - Function: file_ps_load RUN_MODE, FILENAME, RAW_FILENAME
     load file of PostScript/PDF file format-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Peter Kirchgessner*

 - Function: file_ps_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, WIDTH, HEIGHT, X_OFFSET, Y_OFFSET, UNIT,
          KEEP_RATIO, ROTATION
     PostScript saving handles all image types except those with alpha
     channels.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *width* (PDB_FLOAT)-Width of the image in PostScript file

        * *height* (PDB_FLOAT)-Height of image in PostScript file

        * *x_offset* (PDB_FLOAT)-X-offset to image from lower left
          corner

        * *y_offset* (PDB_FLOAT)-Y-offset to image from lower left
          corner

        * *unit* (PDB_INT32)-0: inches, 1: millimeters

        * *keep_ratio* (PDB_INT32)-0: use width/height, 1: keep aspect
          ratio

        * *rotation* (PDB_INT32)-0, 90, 180, 270
   *Peter Kirchgessner*

 - Function: file_sunras_load RUN_MODE, FILENAME, RAW_FILENAME
     load file of the SunRaster file format-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Peter Kirchgessner*

 - Function: file_sunras_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, RLE
     SUNRAS saving handles all image types except those with alpha
     channels.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *rle* (PDB_INT32)-Specify non-zero for rle output, zero for
          standard output
   *Peter Kirchgessner*

 - Function: file_tiff_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for tiff_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball & Peter Mattis*

 - Function: file_tiff_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME, COMPRESSION, FILLORDER
     FIXME: write help for tiff_save-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in

        * *compression* (PDB_INT32)-Compression type: { NONE (0), LZW
          (1), PACKBITS (2)

        * *fillorder* (PDB_INT32)-Fill Order: { MSB to LSB (0), LSB to
          MSB (1)
   *Spencer Kimball & Peter Mattis*

 - Function: file_url_load RUN_MODE, FILENAME, RAW_FILENAME
     You need to have GNU Wget installed.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name entered

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball & Peter Mattis*

 - Function: file_xpm_load RUN_MODE, FILENAME, RAW_FILENAME
     FIXME: write help for xpm_load-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name entered

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball & Peter Mattis*

 - Function: file_xwd_load RUN_MODE, FILENAME, RAW_FILENAME
     load file of the XWD file format-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Peter Kirchgessner*

 - Function: file_xwd_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME
     XWD saving handles all image types except those with alpha
     channels.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in
   *Peter Kirchgessner*

 - Function: gimp_airbrush IMAGE, DRAWABLE, PRESSURE, NUM_STROKES,
          STROKES
     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.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *pressure* (PDB_FLOAT)-The pressure of the airbrush strokes:
          0 <= pressure <= 100

        * *num_strokes* (PDB_INT32)-Number of stroke control points
          (count each coordinate as 2 points)

        * *strokes* (PDB_FLOATARRAY)-Array of stroke coordinates:
          {s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y}
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_blend IMAGE, DRAWABLE, BLEND_MODE, PAINT_MODE,
          GRADIENT_TYPE, OPACITY, OFFSET, REPEAT, SUPERSAMPLE,
          MAX_DEPTH, THRESHOLD, X1, Y1, X2, Y2
     This tool requires information on the paint application mode, the
     blend mode, and the gradient type.  It creates the specified
     variety of blend using the starting and ending coordinates as
     defined for each gradient type.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *blend_mode* (PDB_INT32)-The type of blend: { FG-BG-RGB (0),
          FG-BG-HSV (1), FG-TRANS (2), CUSTOM (3) }

        * *paint_mode* (PDB_INT32)-The paint application mode: { NORMAL
          (0), DISSOLVE (1), BEHIND (2), MULTIPLY (3), SCREEN (4),
          OVERLAY (5) DIFFERENCE (6), ADDITION (7), SUBTRACT (8),
          DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION
          (12), COLOR (13), VALUE (14) }

        * *gradient_type* (PDB_INT32)-The type of gradient: { LINEAR
          (0), BILINEAR (1), RADIAL (2), SQUARE (3), CONICAL-SYMMETRIC
          (4), CONICAL-ASYMMETRIC (5), SHAPEBURST-ANGULAR (6),
          SHAPEBURST-SPHERICAL (7), SHAPEBURST-DIMPLED (8) }

        * *opacity* (PDB_FLOAT)-The opacity of the final blend (0 <=
          opacity <= 100)

        * *offset* (PDB_FLOAT)-Offset relates to the starting and
          ending coordinates specified for the blend.  This parameter
          is mode depndent (0 <= offset)

        * *repeat* (PDB_INT32)-Repeat mode: { REPEAT-NONE (0),
          REPEAT-SAWTOOTH (1), REPEAT-TRIANGULAR (2) }

        * *supersample* (PDB_INT32)-Do adaptive supersampling (true /
          false)

        * *max_depth* (PDB_INT32)-Maximum recursion levels for
          supersampling

        * *threshold* (PDB_FLOAT)-Supersampling threshold

        * *x1* (PDB_FLOAT)-The x coordinate of this blend's starting
          point

        * *y1* (PDB_FLOAT)-The y coordinate of this blend's starting
          point

        * *x2* (PDB_FLOAT)-The x coordinate of this blend's ending point

        * *y2* (PDB_FLOAT)-The y coordinate of this blend's ending point
   *Spencer Kimball & Peter Mattis & Federico Mena Quintero*

 - Function: gimp_brightness_contrast IMAGE, DRAWABLE, BRIGHTNESS,
          CONTRAST
     This procedures allows the brightness and contrast of the
     specified drawable to be modified.  Both 'brightness' and
     'contrast' parameters are defined between -127 and 127.-*Internal
     GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *brightness* (PDB_INT32)-Brightness adjustment: (-127 <=
          brightness <= 127)

        * *contrast* (PDB_INT32)-Constrast adjustment: (-127 <=
          contrast <= 127)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_get_brush
     This procedure retrieves information about the currently active
     brush mask.  This includes the brush name, the width and height,
     and the brush spacing paramter.  All paint operations and stroke
     operations use this mask to control the application of paint to
     the image.-*Internal GIMP procedure*

     *Outputs*
        * *name* (PDB_STRING)-The brush name

        * *width* (PDB_INT32)-The brush width

        * *height* (PDB_INT32)-The brush height

        * *spacing* (PDB_INT32)-The brush spacing: (% of MAX [width,
          height])
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_get_opacity
     This procedure returns the opacity setting for brushes.  This
     value is set globally and will remain the same even if the brush
     mask is changed.  The return value is a floating point number
     between 0 and 100.-*Internal GIMP procedure*

     *Outputs*
        * *opacity* (PDB_FLOAT)-The brush opacity: 0 <= opacity <= 100
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_get_paint_mode
     This procedure returns the paint-mode setting for brushes.  This
     value is set globally and will not change if a different brush is
     selected.  The return value is an integer between 0 and 13 which
     corresponds to the values listed in the argument
     description.-*Internal GIMP procedure*

     *Outputs*
        * *paint_mode* (PDB_INT32)-The paint mode: { NORMAL (0),
          DISSOLVE (1), BEHIND (2), MULTIPLY (3), SCREEN (4), OVERLAY
          (5) DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY
          (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR
          (13), VALUE (14) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_get_spacing
     This procedure returns the spacing setting for brushes.  This
     value is set per brush and will change if a different brush is
     selected.  The return value is an integer between 0 and 1000 which
     represents percentage of the maximum of the width and height of
     the mask.-*Internal GIMP procedure*

     *Outputs*
        * *spacing* (PDB_INT32)-The brush spacing: 0 <= spacing <= 1000
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_list
     This procedure returns a complete listing of available GIMP
     brushes.  Each name returned can be used as input to the
     'gimp_brushes_set_brush'-*Internal GIMP procedure*

     *Outputs*
        * *num_brushes* (PDB_INT32)-The number of brushes in the brush
          list

        * *brush_list* (PDB_STRINGARRAY)-The list of brush names
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_set_brush NAME
     This procedure allows the active brush mask to be set by
     specifying its name.  The name is simply a string which
     corresponds to one of the names of the installed brushes.  If
     there is no matching brush found, this procedure will return an
     error.  Otherwise, the specified brush becomes active and will be
     used in all subsequent paint operations.-*Internal GIMP procedure*

     *Inputs*
        * *name* (PDB_STRING)-The brush name
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_set_opacity OPACITY
     This procedure modifies the opacity setting for brushes.  This
     value is set globally and will remain the same even if the brush
     mask is changed.  The value should be a floating point number
     between 0 and 100.-*Internal GIMP procedure*

     *Inputs*
        * *opacity* (PDB_FLOAT)-The brush opacity: 0 <= opacity <= 100
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_set_paint_mode PAINT_MODE
     This procedure modifies the paint_mode setting for the current
     brush.  This value is set globally and will not change if a
     different brush mask is selected.-*Internal GIMP procedure*

     *Inputs*
        * *paint_mode* (PDB_INT32)-The paint mode: { NORMAL (0),
          DISSOLVE (1), BEHIND (2), MULTIPLY (3), SCREEN (4), OVERLAY
          (5) DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY
          (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR
          (13), VALUE (14) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_brushes_set_spacing SPACING
     This procedure modifies the spacing setting for the current brush.
     This value is set on a per-brush basis and will change if a
     different brush mask is selected.  The value should be a integer
     between 0 and 1000.-*Internal GIMP procedure*

     *Inputs*
        * *spacing* (PDB_INT32)-The brush spacing: 0 <= spacing <= 1000
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_bucket_fill IMAGE, DRAWABLE, FILL_MODE, PAINT_MODE,
          OPACITY, THRESHOLD, SAMPLE_MERGED, X, Y
     This tool requires information on the paint application mode, and
     the fill mode, which can either be in the foreground color, or in
     the currently active pattern.  If there is no selection, a seed
     fill is executed at the specified coordinates and extends outward
     in keeping with the threshold parameter.  If there is a selection
     in the target image, the threshold, sample merged, x, and y
     arguments are unused.  If the sample_merged parameter is non-zero,
     the data of the composite image will be used instead of that for
     the specified drawable.  This is equivalent to sampling for colors
     after merging all visible layers.  In the case of merged sampling,
     the x,y coordinates are relative to the image's origin; otherwise,
     they are relative to the drawable's origin.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *fill_mode* (PDB_INT32)-The type of fill: { FG-BUCKET-FILL
          (0), BG-BUCKET-FILL (1), PATTERN-BUCKET-FILL (2) }

        * *paint_mode* (PDB_INT32)-The paint application mode: { NORMAL
          (0), DISSOLVE (1), BEHIND (2), MULTIPLY (3), SCREEN (4),
          OVERLAY (5) DIFFERENCE (6), ADDITION (7), SUBTRACT (8),
          DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION
          (12), COLOR (13), VALUE (14) }

        * *opacity* (PDB_FLOAT)-The opacity of the final bucket fill (0
          <= opacity <= 100)

        * *threshold* (PDB_FLOAT)-The threshold determines how
          extensive the seed fill will be.  It's value is specified in
          terms of intensity levels (0 <= threshold <= 255).  This
          parameter is only valid when there is no selection in the
          specified image.

        * *sample_merged* (PDB_INT32)-Use the composite image, not the
          drawable

        * *x* (PDB_FLOAT)-The x coordinate of this bucket fill's
          application.  This parameter is only valid when there is no
          selection in the specified image.

        * *y* (PDB_FLOAT)-The y coordinate of this bucket fill's
          application.  This parameter is only valid when there is no
          selection in the specified image.
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_by_color_select IMAGE, DRAWABLE, COLOR, THRESHOLD,
          OPERATION, ANTIALIAS, FEATHER, FEATHER_RADIUS, SAMPLE_MERGED
     This tool creates a selection over the specified image.  A
     by-color selection is determined by the supplied color under the
     constraints of the specified threshold.  Essentially, all pixels
     (in the drawable) that have color sufficiently close to the
     specified color (as determined by the threshold value) are
     included in the selection.  The antialiasing parameter allows the
     final selection mask to contain intermediate values based on close
     misses to the threshold bar.  Feathering can be enabled optionally
     and is controlled with the "feather_radius" paramter.  If the
     sample_merged parameter is non-zero, the data of the composite
     image will be used instead of that for the specified drawable.
     This is equivalent to sampling for colors after merging all
     visible layers.  In the case of a merged sampling, the supplied
     drawable is ignored.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *color* (PDB_COLOR)-The color to select

        * *threshold* (PDB_INT32)-Threshold in intensity levels: 0 <=
          threshold <= 255

        * *operation* (PDB_INT32)-The selection operation: { ADD (0),
          SUB (1), REPLACE (2), INTERSECT (3) }

        * *antialias* (PDB_INT32)-Antialiasing On/Off

        * *feather* (PDB_INT32)-Feather option for selections

        * *feather_radius* (PDB_FLOAT)-Radius for feather operation

        * *sample_merged* (PDB_INT32)-Use the composite image, not the
          drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_copy CHANNEL
     This procedure copies the specified channel and returns the
     copy.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel to copy

     *Outputs*
        * *channel_copy* (PDB_CHANNEL)-The newly copied channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_delete CHANNEL
     This procedure deletes the specified channel.  This does not need
     to be done if a gimage containing this channel was already
     deleted.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel to delete
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_get_color CHANNEL
     This procedure returns the specified channel's compositing
     color.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

     *Outputs*
        * *color* (PDB_COLOR)-The channel's composite color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_get_name CHANNEL
     This procedure returns the specified channel's name.-*Internal
     GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

     *Outputs*
        * *name* (PDB_STRING)-The channel name
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_get_opacity CHANNEL
     This procedure returns the specified channel's opacity.-*Internal
     GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

     *Outputs*
        * *opacity* (PDB_FLOAT)-The channel opacity
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_get_show_masked CHANNEL
     This procedure returns the specified channel's composite type.  If
     it is non-zero, then the channel is composited with the image so
     that masked regions are shown.  Otherwise, selected regions are
     shown.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

     *Outputs*
        * *show_masked* (PDB_INT32)-Composite method for channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_get_visible CHANNEL
     This procedure returns the specified channel's
     visibility.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

     *Outputs*
        * *visible* (PDB_INT32)-The channel visibility
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_new IMAGE, WIDTH, HEIGHT, NAME, OPACITY, COLOR
     This procedure creates a new channel with the specified width and
     height.  Name, opacity, and color are also supplied parameters.
     The new channel still needs to be added to the image, as this is
     not automatic.  Add the new channel with the
     'gimp_image_add_channel' command.  Other attributes such as
     channel show masked, should be set with explicit procedure calls.
     The channel's contents are undefined initially.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image to which to add the channel

        * *width* (PDB_INT32)-The channel width: (width > 0)

        * *height* (PDB_INT32)-The channel height: (height > 0)

        * *name* (PDB_STRING)-The channel name

        * *opacity* (PDB_FLOAT)-The channel opacity: (0 <= opacity <=
          100)

        * *color* (PDB_COLOR)-The channel compositing color

     *Outputs*
        * *channel* (PDB_CHANNEL)-The newly created channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_ops_duplicate IMAGE
     This procedure duplicates the specified image, copying all layers,
     channels, and image information.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *new_image* (PDB_IMAGE)-The new, duplicated image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_ops_offset IMAGE, DRAWABLE, WRAP_AROUND,
          FILL_TYPE, OFFSET_X, OFFSET_Y
     This procedure offsets the specified drawable by the amounts
     specified by 'offset_x' and 'offset_y'.  If 'wrap_around' is set
     to TRUE, then portions of the drawable which are offset out of
     bounds are wrapped around.  Alternatively, the undefined regions
     of the drawable can be filled with transparency or the background
     color, as specified by the 'fill_type' parameter.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to offset

        * *wrap_around* (PDB_INT32)-Wrap image around or fill vacated
          regions

        * *fill_type* (PDB_INT32)-Fill vacated regions of drawable with
          background or transparent: { OFFSET_BACKGROUND (0),
          OFFSET_TRANSPARENT (1) }

        * *offset_x* (PDB_INT32)-Offset by this amount in X direction

        * *offset_y* (PDB_INT32)-Offset by this amount in Y direction
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_set_color CHANNEL, COLOR
     This procedure sets the specified channel's compositing
     color.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

        * *color* (PDB_COLOR)-The composite color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_set_name CHANNEL, NAME
     This procedure sets the specified channel's name to the supplied
     name.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

        * *name* (PDB_STRING)-The new channel name
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_set_opacity CHANNEL, OPACITY
     This procedure sets the specified channel's opacity.-*Internal
     GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

        * *opacity* (PDB_FLOAT)-The new channel opacity: (0 <= opacity
          <= 100)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_set_show_masked CHANNEL, SHOW_MASKED
     This procedure sets the specified channel's composite type.  If it
     is non-zero, then the channel is composited with the image so that
     masked regions are shown.  Otherwise, selected regions are
     shown.-*Internal GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

        * *show_masked* (PDB_INT32)-The new channel show_masked value
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_channel_set_visible CHANNEL, VISIBLE
     This procedure sets the specified channel's visibility.-*Internal
     GIMP procedure*

     *Inputs*
        * *channel* (PDB_CHANNEL)-The channel

        * *visible* (PDB_INT32)-The new channel visibility
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_clone IMAGE, DRAWABLE, SRC_DRAWABLE, CLONE_TYPE,
          SRC_X, SRC_Y, NUM_STROKES, STROKES
     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 RGB->Indexed-although converting from any type to
     indexed is significantly slower.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *src_drawable* (PDB_DRAWABLE)-The source drawable

        * *clone_type* (PDB_INT32)-The type of clone: { IMAGE-CLONE
          (0), PATTERN-CLONE (1) }

        * *src_x* (PDB_FLOAT)-The x coordinate in the source image

        * *src_y* (PDB_FLOAT)-The y coordinate in the source image

        * *num_strokes* (PDB_INT32)-Number of stroke control points
          (count each coordinate as 2 points)

        * *strokes* (PDB_FLOATARRAY)-Array of stroke coordinates:
          {s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y}
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_color_balance IMAGE, DRAWABLE, TRANSFER_MODE,
          PRESERVE_LUM, CYAN_RED, MAGENTA_GREEN, YELLOW_BLUE
     Modify the color balance of the specified drawable.  There are
     three axis which can be modified: cyan-red, magenta-green, and
     yellow-blue.  Negative values increase the amount of the former,
     positive values increase the amount of the latter.  Color balance
     can be controlled with the 'transfer_mode' setting, which allows
     shadows, midtones, and highlights in an image to be affected
     differently.  The 'preserve_lum' parameter, if non-zero, ensures
     that the luminosity of each pixel remains fixed.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *transfer_mode* (PDB_INT32)-Transfer mode: { SHADOWS (0),
          MIDTONES (1), HIGHLIGHTS (2) }

        * *preserve_lum* (PDB_INT32)-Preserve luminosity values at each
          pixel

        * *cyan_red* (PDB_FLOAT)-Cyan-Red color balance: (-100 <=
          cyan_red <= 100)

        * *magenta_green* (PDB_FLOAT)-Magenta-Green color balance:
          (-100 <= magenta_green <= 100)

        * *yellow_blue* (PDB_FLOAT)-Yellow-Blue color balance: (-100 <=
          yellow_blue <= 100)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_color_picker IMAGE, DRAWABLE, X, Y, SAMPLE_MERGED,
          SAVE_COLOR
     This tool determines the color at the specified coordinates.  The
     returned color is an RGB triplet even for grayscale and indexed
     drawables.  If the coordinates lie outside of the extents of the
     specified drawable, then an error is returned.  If the drawable
     has an alpha channel, the algorithm examines the alpha value of
     the drawable at the coordinates.  If the alpha value is completely
     transparent (0), then an error is returned.  If the sample_merged
     parameter is non-zero, the data of the composite image will be
     used instead of that for the specified drawable.  This is
     equivalent to sampling for colors after merging all visible
     layers.  In the case of a merged sampling, the supplied drawable
     is ignored.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *x* (PDB_FLOAT)-X coordinate of upper-left corner of rectangle

        * *y* (PDB_FLOAT)-Y coordinate of upper-left corner of rectangle

        * *sample_merged* (PDB_INT32)-Use the composite image, not the
          drawable

        * *save_color* (PDB_INT32)-Save the color to the active palette

     *Outputs*
        * *color* (PDB_COLOR)-The return color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_convert_grayscale IMAGE
     This procedure converts the specified image to grayscale with 8
     bits per pixel (256 intensity levels).  This process requires an
     image of type RGB or INDEXED.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_convert_indexed IMAGE, DITHER, NUM_COLS
     This procedure converts the specified image to indexed color.
     This process requires an image of type GRAY or RGB.  The
     'num_cols' arguments specifies how many colors the resulting image
     should be quantized to (1-256).-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *dither* (PDB_INT32)-Floyd-Steinberg dithering

        * *num_cols* (PDB_INT32)-The number of colors to quantize to
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_convert_rgb IMAGE
     This procedure converts the specified image to RGB color.  This
     process requires an image of type GRAY or INDEXED.  No image
     content is lost in this process aside from the colormap for an
     indexed image.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_convolve IMAGE, DRAWABLE, PRESSURE, CONVOLVE_TYPE,
          NUM_STROKES, STROKES
     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.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *pressure* (PDB_FLOAT)-The pressure: 0 <= pressure <= 100

        * *convolve_type* (PDB_INT32)-Convolve type: { BLUR (0),
          SHARPEN (1) }

        * *num_strokes* (PDB_INT32)-Number of stroke control points
          (count each coordinate as 2 points)

        * *strokes* (PDB_FLOATARRAY)-Array of stroke coordinates:
          {s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y}
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_crop IMAGE, NEW_WIDTH, NEW_HEIGHT, OFFX, OFFY
     This procedure crops the image so that it's new width and height
     are equal to the supplied parameters.  Offsets are also provided
     which describe the position of the previous image's content.  All
     channels and layers within the image are cropped to the new image
     extents; this includes the image selection mask.  If any
     parameters are out of range, an error is returned.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *new_width* (PDB_INT32)-New image width: (0 < new_width <=
          width)

        * *new_height* (PDB_INT32)-New image height: (0 < new_height <=
          height)

        * *offx* (PDB_INT32)-X offset: (0 <= offx <= (width -
          new_width))

        * *offy* (PDB_INT32)-Y offset: (0 <= offy <= (height -
          new_height))
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_curves_explicit IMAGE, DRAWABLE, CHANNEL, NUM_BYTES,
          CURVE
     Modifies the intensity mapping for one channel in the specified
     drawable.  The drawable must be either grayscale or RGB, and the
     channel can be either an intensity component, or the value.  The
     'curve' parameter is an array of bytes which explicitly defines
     how each pixel value in the drawable will be modified.  Use the
     'gimp_curves_spline' function to modify intensity levels with
     Catmull Rom splines.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *channel* (PDB_INT32)-The channel to modify: { VALUE (0), RED
          (1), GREEN (2), BLUE (3), GRAY (0) }

        * *num_bytes* (PDB_INT32)-The number of bytes in the new curve
          (always 256)

        * *curve* (PDB_INT8ARRAY)-The explicit curve
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_curves_spline IMAGE, DRAWABLE, CHANNEL, NUM_POINTS,
          CONTROL_PTS
     Modifies the intensity mapping for one channel in the specified
     drawable.  The drawable must be either grayscale or RGB, and the
     channel can be either an intensity component, or the value.  The
     'control_pts' parameter is an array of integers which define a set
     of control points which describe a Catmull Rom spline which yields
     the final intensity curve.  Use the 'gimp_curves_explicit'
     function to explicitly modify intensity levels.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *channel* (PDB_INT32)-The channel to modify: { VALUE (0), RED
          (1), GREEN (2), BLUE (3), GRAY (0) }

        * *num_points* (PDB_INT32)-The number of values in the control
          point array ( 3 < num_points <= 32 )

        * *control_pts* (PDB_INT8ARRAY)-The spline control points: {
          cp1.x, cp1.y, cp2.x, cp2.y, ... }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_desaturate IMAGE, DRAWABLE
     This procedure desaturates the contents of the specified drawable.
     This procedure only works on drawables of type RGB
     color.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_display_delete DISPLAY
     This procedure removes the specified display.  If this is the last
     remaining display for the underlying image, then the image is
     deleted also.-*Internal GIMP procedure*

     *Inputs*
        * *display* (PDB_DISPLAY)-The display
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_display_new IMAGE
     Creates a new display for the specified image.  If the image
     already has a display, another is added.  Multiple displays are
     handled transparently by the GIMP.  The newly created display is
     returned and can be subsequently destroyed with a call to
     'gimp_display_delete'.  This procedure only makes sense for use
     with the GIMP UI.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *display* (PDB_DISPLAY)-The new display
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_displays_flush
     This procedure takes no arguments and returns nothing except a
     success status.  Its purpose is to flush all pending updates of
     image manipulations to the user interface.  It should be called
     whenever appropriate.-*Internal GIMP procedure*
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_bytes DRAWABLE
     This procedure returns the number of bytes per pixel (or the
     number of channels) for the specified drawable.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *bytes* (PDB_INT32)-Bytes per pixel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_channel DRAWABLE
     This procedure returns non-zero if the specified drawable is a
     channel.  Even though a layer mask is technically considered a
     channel, this call will return 0 on a layer mask.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *channel* (PDB_INT32)-Non-zero if the drawable is a channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_color DRAWABLE
     This procedure returns non-zero if the specified drawable is of
     type { RGB, RGBA }.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *color* (PDB_INT32)-Non-zero if the drawable is an RGB type
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_fill DRAWABLE, FILL_TYPE
     This procedure fills the drawable with the fill mode.  If the fill
     mode is background, the current background color is used.  If the
     fill type is white, then white is used.  Transparent fill only
     affects layers with an alpha channel, in which case the alpha
     channel is set to transparent.  If the drawable has no alpha
     channel, it is filled to white.  No fill leaves the drawable's
     contents undefined.  This procedure is unlike the bucket fill tool
     because it fills regardless of a selection-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

        * *fill_type* (PDB_INT32)-Type of fill: { BG-IMAGE-FILL (0),
          WHITE-IMAGE-FILL (1), TRANS-IMAGE-FILL (2) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_get_pixel DRAWABLE, X COORDINATE, Y
          COORDINATE
     This procedure gets the pixel value at the specified coordinates.
     The 'num_channels' argument must always be equal to the
     bytes-per-pixel value for the specified drawable.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

        * *x coordinate* (PDB_INT32)-The x coordinate

        * *y coordinate* (PDB_INT32)-The y coordinate

     *Outputs*
        * *num_channels* (PDB_INT32)-The number of channels for the
          pixel

        * *pixel* (PDB_INT8ARRAY)-The pixel value
   *Spencer Kimball & Peter Mattis & Josh MacDonald*

 - Function: gimp_drawable_gray DRAWABLE
     This procedure returns non-zero if the specified drawable is of
     type { Gray, GrayA }.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *gray* (PDB_INT32)-Non-zero if the drawable is a grayscale
          type
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_has_alpha DRAWABLE
     This procedure returns whether the specified drawable has an alpha
     channel.  This can only be true for layers, and the associated
     type will be one of: { RGBA, GRAYA, INDEXEDA }.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *has_alpha* (PDB_INT32)-Does the drawable have an alpha
          channel?
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_height DRAWABLE
     This procedure returns the height of the specified drawable in
     pixels-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *height* (PDB_INT32)-Height of drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_image DRAWABLE
     This procedure returns the drawable's image.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *image* (PDB_IMAGE)-The drawable's image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_indexed DRAWABLE
     This procedure returns non-zero if the specified drawable is of
     type { Indexed, IndexedA }.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *indexed* (PDB_INT32)-Non-zero if the drawable is a indexed
          type
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_layer DRAWABLE
     This procedure returns non-zero if the specified drawable is a
     layer.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *layer* (PDB_INT32)-Non-zero if the drawable is a layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_layer_mask DRAWABLE
     This procedure returns non-zero if the specified drawable is a
     layer mask.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *layer_mask* (PDB_INT32)-Non-zero if the drawable is a layer
          mask
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_mask_bounds DRAWABLE
     This procedure returns the whether there is a selection.  If there
     is one, the upper left and lower righthand corners of its bounding
     box are returned.  These coordinates are specified relative to the
     drawable's origin, and bounded by the drawable's
     extents.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *non-empty* (PDB_INT32)-True if there is a selection

        * *x1* (PDB_INT32)-X coordinate of upper left corner of
          selection bounds

        * *y1* (PDB_INT32)-Y coordinate of upper left corner of
          selection bounds

        * *x2* (PDB_INT32)-X coordinate of lower right corner of
          selection bounds

        * *y2* (PDB_INT32)-Y coordinate of lower right corner of
          selection bounds
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_merge_shadow DRAWABLE, UNDO
     This procedure combines the contents of the image's shadow buffer
     (for temporary processing) with the specified drawable.  The
     "undo" parameter specifies whether to add an undo step for the
     operation.  Requesting no undo is useful for such applications as
     'auto-apply'.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

        * *undo* (PDB_INT32)-Push merge to undo stack?
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_offsets DRAWABLE
     This procedure returns the specified drawable's offsets.  This
     only makes sense if the drawable is a layer since channels are
     anchored.  The offsets of a channel will be returned as
     0.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *offset_x* (PDB_INT32)-X offset of drawable

        * *offset_y* (PDB_INT32)-Y offset of drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_set_pixel DRAWABLE, X COORDINATE, Y
          COORDINATE, NUM_CHANNELS, PIXEL
     This procedure sets the pixel value at the specified coordinates.
     The 'num_channels' argument must always be equal to the
     bytes-per-pixel value for the specified drawable.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

        * *x coordinate* (PDB_INT32)-The x coordinate

        * *y coordinate* (PDB_INT32)-The y coordinate

        * *num_channels* (PDB_INT32)-The number of channels for the
          pixel

        * *pixel* (PDB_INT8ARRAY)-The pixel value
   *Spencer Kimball & Peter Mattis & Josh MacDonald*

 - Function: gimp_drawable_type DRAWABLE
     This procedure returns the drawable's type.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *type* (PDB_INT32)-The drawable's type: { RGB (0), RGBA (1),
          GRAY (2), GRAYA (3), INDEXED (4), INDEXEDA (5) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_type_with_alpha DRAWABLE
     This procedure returns the drawable's type if an alpha channel
     were added.  If the type is currently Gray, for instance, the
     returned type would be GrayA.  If the drawable already has an
     alpha channel, the drawable's type is simply returned.-*Internal
     GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *type_with_alpha* (PDB_INT32)-The drawable's type with alpha:
          { RGBA (0), GRAYA (1), INDEXEDA (2) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_update DRAWABLE, X, Y, W, H
     This procedure updates the specified region of the drawable.  The
     (x, y) coordinate pair is relative to the drawable's origin, not
     to the image origin.  Therefore, the entire drawable can be
     updated with: {x->0, y->0, w->width, h->height}.-*Internal GIMP
     procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

        * *x* (PDB_INT32)-X coordinate of upper left corner of update
          region

        * *y* (PDB_INT32)-Y coordinate of upper left corner of update
          region

        * *w* (PDB_INT32)-Width of update region

        * *h* (PDB_INT32)-Height of update region
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_drawable_width DRAWABLE
     This procedure returns the specified drawable's width in
     pixels.-*Internal GIMP procedure*

     *Inputs*
        * *drawable* (PDB_DRAWABLE)-The drawable

     *Outputs*
        * *width* (PDB_INT32)-Width of drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_edit_clear IMAGE, DRAWABLE
     This procedure clears the specified drawable.  If the drawable has
     an alpha channel, the cleared pixels will become transparent.  If
     the drawable does not have an alpha channel, cleared pixels will
     be set to the background color.  This procedure only affects
     regions within a selection if there is a selection
     active.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to clear from
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_edit_copy IMAGE, DRAWABLE
     If there is a selection in the image, then the area specified by
     the selection is copied from the specified drawable and placed in
     an internal GIMP edit buffer.  It can subsequently be retrieved
     using the 'gimp-edit-paste' command.  If there is no selection,
     then the specified drawable's contents will be stored in the
     internal GIMP edit buffer.  The drawable MUST belong to the
     specified image, or an error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to copy from
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_edit_cut IMAGE, DRAWABLE
     If there is a selection in the image, then the area specified by
     the selection is cut from the specified drawable and placed in an
     internal GIMP edit buffer.  It can subsequently be retrieved using
     the 'gimp-edit-paste' command.  If there is no selection, then the
     specified drawable will be removed and its contents stored in the
     internal GIMP edit buffer.  The drawable MUST belong to the
     specified image, or an error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to cut from
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_edit_fill IMAGE, DRAWABLE
     This procedure fills the specified drawable with the background
     color.  This procedure only affects regions within a selection if
     there is a selection active.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to fill from
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_edit_paste IMAGE, DRAWABLE, PASTE_INTO
     This procedure pastes a copy of the internal GIMP edit buffer to
     the specified drawable.  The GIMP edit buffer will be empty unless
     a call was previously made to either 'gimp-edit-cut' or
     'gimp-edit-copy'.  The "paste_into" option specifies whether to
     clear the current image selection, or to paste the buffer "behind"
     the selection.  This allows the selection to act as a mask for the
     pasted buffer.  Anywhere that the selection mask is non-zero, the
     pasted buffer will show through.  The pasted buffer will be a new
     layer in the image which is designated as the image floating
     selection.  If the image has a floating selection at the time of
     pasting, the old floating selection will be anchored to it's
     drawable before the new floating selection is added.  This
     procedure returns the new floating layer.  The resulting floating
     selection will already be attached to the specified drawable, and
     a subsequent call to floating_sel_attach is not needed.-*Internal
     GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to paste from

        * *paste_into* (PDB_INT32)-Clear selection, or paste behind it?

     *Outputs*
        * *floating_sel* (PDB_LAYER)-The new floating selection
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_edit_stroke IMAGE, DRAWABLE
     This procedure strokes the current selection, painting along the
     selection boundary with the active brush and foreground color.
     The paint is applied to the specified drawable regardless of the
     active selection.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable to stroke to
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_ellipse_select IMAGE, X, Y, WIDTH, HEIGHT, OPERATION,
          ANTIALIAS, FEATHER, FEATHER_RADIUS
     This tool creates an elliptical selection over the specified
     image.  The elliptical region can be either added to, subtracted
     from, or replace the contents of the previous selection mask.  If
     antialiasing is turned on, the edges of the elliptical region will
     contain intermediate values which give the appearance of a
     sharper, less pixelized edge.  This should be set as TRUE most of
     the time.  If the feather option is enabled, the resulting
     selection is blurred before combining.  The blur is a gaussian
     blur with the specified feather radius.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *x* (PDB_FLOAT)-X coordinate of upper-left corner of ellipse
          bounding box

        * *y* (PDB_FLOAT)-Y coordinate of upper-left corner of ellipse
          bounding box

        * *width* (PDB_FLOAT)-The width of the ellipse: width > 0

        * *height* (PDB_FLOAT)-The height of the ellipse: height > 0

        * *operation* (PDB_INT32)-The selection operation: { ADD (0),
          SUB (1), REPLACE (2), INTERSECT (3) }

        * *antialias* (PDB_INT32)-Antialiasing On/Off

        * *feather* (PDB_INT32)-Feather option for selections

        * *feather_radius* (PDB_FLOAT)-Radius for feather operation
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_equalize IMAGE, DRAWABLE, MASK_ONLY
     This procedure equalizes the contents of the specified drawable.
     Each intensity channel is equalizeed independently.  The
     equalizeed intensity is given as inten' = (255 - inten).  Indexed
     color drawables are not valid for this operation.  The 'mask_only'
     option specifies whether to adjust only the area of the image
     within the selection bounds, or the entire image based on the
     histogram of the selected area.  If there is no selection, the
     entire image is adjusted based on the histogram for the entire
     image.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *mask_only* (PDB_INT32)-Equalization option
   *Federico Mena Quintero & Spencer Kimball & Peter Mattis*

 - Function: gimp_eraser IMAGE, DRAWABLE, NUM_STROKES, STROKES
     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.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *num_strokes* (PDB_INT32)-Number of stroke control points
          (count each coordinate as 2 points)

        * *strokes* (PDB_FLOATARRAY)-Array of stroke coordinates:
          {s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y}
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_file_load RUN_MODE, FILENAME, RAW_FILENAME
     This procedure invokes the correct file load handler according to
     the file's extension and/or prefix.  The name of the file to load
     is typically a full pathname, and the name entered is what the
     user actually typed before prepending a directory path.  The
     reason for this is that if the user types http://www.xcf/~gimp he
     wants to fetch a URL, and the full pathname will not look like a
     URL.-*Internal GIMP procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive.

        * *filename* (PDB_STRING)-The name of the file to load.

        * *raw_filename* (PDB_STRING)-The name entered.

     *Outputs*
        * *image* (PDB_IMAGE)-Output image.
   *Josh MacDonald*

 - Function: gimp_file_save RUN_MODE, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME
     This procedure invokes the correct file save handler according to
     the file's extension and/or prefix.  The name of the file to save
     is typically a full pathname, and the name entered is what the
     user actually typed before prepending a directory path.  The
     reason for this is that if the user types http://www.xcf/~gimp he
     wants to fetch a URL, and the full pathname will not look like a
     URL.-*Internal GIMP procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Drawable to save

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to save the
          image in
   *Josh MacDonald*

 - Function: gimp_flip IMAGE, DRAWABLE, FLIP_TYPE
     This tool flips the specified drawable if no selection exists.  If
     a selection exists, the portion of the drawable which lies under
     the selection is cut from the drawable and made into a floating
     selection which is then flipd by the specified amount.  The return
     value is the ID of the flipped drawable.  If there was no
     selection, this will be equal to the drawable ID supplied as
     input.  Otherwise, this will be the newly created and flipd
     drawable.  The flip type parameter indicates whether the flip will
     be applied horizontally or vertically.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *flip_type* (PDB_INT32)-Type of flip: { HORIZONTAL (0),
          VERTICAL (1) }

     *Outputs*
        * *drawable* (PDB_DRAWABLE)-The flipped drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_floating_sel_anchor FLOATING_SEL
     This procedure anchors the floating selection to its associated
     drawable.  This is similar to merging with a merge type of
     ClipToBottomLayer.  The floating selection layer is no longer
     valid after this operation.-*Internal GIMP procedure*

     *Inputs*
        * *floating_sel* (PDB_LAYER)-The floating selection
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_floating_sel_remove FLOATING_SEL
     This procedure removes the floating selection completely, without
     any side effects.  The associated drawable is then set to
     active.-*Internal GIMP procedure*

     *Inputs*
        * *floating_sel* (PDB_LAYER)-The floating selection
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_floating_sel_to_layer FLOATING_SEL
     This procedure transforms the specified floating selection into a
     layer with the same offsets and extents.  The composited image
     will look precisely the same, but the floating selection layer
     will no longer be clipped to the extents of the drawable it was
     attached to.  The floating selection will become the active layer.
     This procedure will not work if the floating selection has a
     different base type from the underlying image.  This might be the
     case if the floating selection is above an auxillary channel or a
     layer mask.-*Internal GIMP procedure*

     *Inputs*
        * *floating_sel* (PDB_LAYER)-The floating selection
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_free_select IMAGE, NUM_PTS, SEGS, OPERATION,
          ANTIALIAS, FEATHER, FEATHER_RADIUS
     This tool creates a polygonal selection over the specified image.
     The polygonal region can be either added to, subtracted from, or
     replace the contents of the previous selection mask.  The polygon
     is specified through an array of floating point numbers.  The
     array must be 2n in length, where n is the number of points.  Each
     point is defined by 2 floating point values which correspond to
     the x and y coordinates.  If the final point does not connect to
     the starting point, a connecting segment is automatically added.
     If the feather option is enabled, the resulting selection is
     blurred before combining.  The blur is a gaussian blur with the
     specified feather radius.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *num_pts* (PDB_INT32)-Number of points (count 1 coordinate as
          two points)

        * *segs* (PDB_FLOATARRAY)-Array of points: { p1.x, p1.y, p2.x,
          p2.y, ..., pn.x, pn.y}

        * *operation* (PDB_INT32)-The selection operation: { ADD (0),
          SUB (1), REPLACE (2), INTERSECT (3) }

        * *antialias* (PDB_INT32)-Antialiasing option for selections

        * *feather* (PDB_INT32)-Feather option for selections

        * *feather_radius* (PDB_FLOAT)-Radius for feather operation
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_fuzzy_select IMAGE, DRAWABLE, X, Y, THRESHOLD,
          OPERATION, ANTIALIAS, FEATHER, FEATHER_RADIUS, SAMPLE_MERGED
     This tool creates a fuzzy selection over the specified image.  A
     fuzzy selection is determined by a seed fill under the constraints
     of the specified threshold.  Essentially, the color at the
     specified coordinates (in the drawable) is measured and the
     selection expands outwards from that point to any adjacent pixels
     which are not significantly different (as determined by the
     threshold value).  This process continues until no more expansion
     is possible.  The antialiasing parameter allows the final
     selection mask to contain intermediate values based on close
     misses to the threshold bar at pixels along the seed fill
     boundary.  Feathering can be enabled optionally and is controlled
     with the "feather_radius" paramter.  If the sample_merged
     parameter is non-zero, the data of the composite image will be
     used instead of that for the specified drawable.  This is
     equivalent to sampling for colors after merging all visible
     layers.  In the case of a merged sampling, the supplied drawable
     is ignored.  If the sample is merged, the specified coordinates
     are relative to the image origin; otherwise, they are relative to
     the drawable's origin.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *x* (PDB_FLOAT)-X coordinate of initial seed fill point:
          (image coordinates)

        * *y* (PDB_FLOAT)-Y coordinate of initial seed fill point:
          (image coordinates)

        * *threshold* (PDB_INT32)-Threshold in intensity levels: 0 <=
          threshold <= 255

        * *operation* (PDB_INT32)-The selection operation: { ADD (0),
          SUB (1), REPLACE (2), INTERSECT (3) }

        * *antialias* (PDB_INT32)-Antialiasing On/Off

        * *feather* (PDB_INT32)-Feather option for selections

        * *feather_radius* (PDB_FLOAT)-Radius for feather operation

        * *sample_merged* (PDB_INT32)-Use the composite image, not the
          drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_gimprc_query TOKEN
     This procedure is used to locate additional information contained
     in the gimprc file considered extraneous to the operation of the
     GIMP.  Plug-ins that need configuration information can expect it
     will be stored in the user's gimprc file and can use this
     procedure to retrieve it.  This query procedure will return the
     value associated with the specified token.  This corresponds
     _only_ to entries with the format: (<token> <value>).  The value
     must be a string.  Entries not corresponding to this format will
     cause warnings to be issued on gimprc parsing and will not be
     queryable.-*Internal GIMP procedure*

     *Inputs*
        * *token* (PDB_STRING)-The token to query for

     *Outputs*
        * *value* (PDB_STRING)-The value associated with the queried
          token
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_gradients_get_active
     This procedure returns the name of the active gradient in hte
     gradient editor.-*Internal GIMP procedure*

     *Outputs*
        * *name* (PDB_STRING)-The name of the active gradient
   *Federico Mena Quintero*

 - Function: gimp_gradients_get_list
     This procedure returns a list of the gradients that are currently
     loaded in the gradient editor.  You can later use the
     gimp_gradients_set_active function to set the active
     gradient.-*Internal GIMP procedure*

     *Outputs*
        * *num_gradients* (PDB_INT32)-The number of loaded gradients

        * *gradient_names* (PDB_STRINGARRAY)-The list of gradient names
   *Federico Mena Quintero*

 - Function: gimp_gradients_sample_custom NUM_SAMPLES, POSITIONS
     This procedure samples the active gradient from the gradient
     editor in the specified number of points.  The procedure will
     sample the gradient in the specified positions from the list.  The
     left endpoint of the gradient corresponds to position 0.0, and the
     right endpoint corresponds to 1.0.  The procedure returns a list
     of floating-point values which correspond to the RGBA values for
     each sample.-*Internal GIMP procedure*

     *Inputs*
        * *num_samples* (PDB_INT32)-The number of samples to take

        * *positions* (PDB_FLOATARRAY)-The list of positions to sample
          along the gradient

     *Outputs*
        * *array_length* (PDB_INT32)-Length of the color_samples array
          (4 * num_samples)

        * *color_samples* (PDB_FLOATARRAY)-Color samples: { R1, G1, B1,
          A1, ..., Rn, Gn, Bn, An }
   *Federico Mena Quintero*

 - Function: gimp_gradients_sample_uniform NUM_SAMPLES
     This procedure samples the active gradient from the gradient
     editor in the specified number of uniform parts.  It returns a
     list of floating-point values which correspond to the RGBA values
     for each sample.  The minimum number of samples to take is 2, in
     which case the returned colors will correspond to the { 0.0, 1.0 }
     positions in the gradient.  For example, if the number of samples
     is 3, the procedure will return the colors at positions { 0.0,
     0.5, 1.0 }.-*Internal GIMP procedure*

     *Inputs*
        * *num_samples* (PDB_INT32)-The number of samples to take

     *Outputs*
        * *array_length* (PDB_INT32)-Length of the color_samples array
          (4 * num_samples)

        * *color_samples* (PDB_FLOATARRAY)-Color samples: { R1, G1, B1,
          A1, ..., Rn, Gn, Bn, An }
   *Federico Mena Quintero*

 - Function: gimp_gradients_set_active NAME
     This procedure lets you set the specified gradient as the active
     or "current" one.  The name is simply a string which corresponds
     to one of the loaded gradients in the gradient editor.  If no
     matching gradient is found, this procedure will return an error.
     Otherwise, the specified gradient will become active and will be
     used for subsequent custom gradient operations.-*Internal GIMP
     procedure*

     *Inputs*
        * *name* (PDB_STRING)-The name of the gradient to set
   *Federico Mena Quintero*

 - Function: gimp_histogram IMAGE, DRAWABLE, CHANNEL, START_RANGE,
          END_RANGE
     This tool makes it possible to gather information about the
     intensity histogram of a drawable.  A channel to examine is first
     specified.  This can be either value, red, green, or blue,
     depending on whether the drawable is of type color or grayscale.
     The drawable may not be indexed.  Second, a range of intensities
     are specified.  The gimp_histogram function returns statistics
     based on the pixels in the drawable that fall under this range of
     values.  Mean, standard deviation, median, number of pixels, and
     percentile are all returned.  Additionally, the total count of
     pixels in the image is returned.  Counts of pixels are weighted by
     any associated alpha values and by the current selection mask.
     That is, pixels that lie outside an active selection mask will not
     be counted.  Similarly, pixels with transparent alpha values will
     not be counted.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *channel* (PDB_INT32)-The channel to modify: { VALUE (0), RED
          (1), GREEN (2), BLUE (3), GRAY (0) }

        * *start_range* (PDB_INT32)-Start of the intensity measurement
          range

        * *end_range* (PDB_INT32)-End of the intensity measurement range

     *Outputs*
        * *mean* (PDB_FLOAT)-Mean intensity value

        * *std_dev* (PDB_FLOAT)-Standard deviation of intensity values

        * *median* (PDB_FLOAT)-Median intensity value

        * *pixels* (PDB_FLOAT)-Alpha-weighted pixel count for entire
          image

        * *count* (PDB_FLOAT)-Alpha-weighted pixel count for range

        * *percentile* (PDB_FLOAT)-Percentile that range falls under
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_hue_saturation IMAGE, DRAWABLE, HUE_RANGE,
          HUE_OFFSET, LIGHTNESS, SATURATION
     This procedures allows the hue, lightness, and saturation in the
     specified drawable to be modified.  The 'hue_range' parameter
     provides the capability to limit range of affected hues.-*Internal
     GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *hue_range* (PDB_INT32)-Range of affected hues: { ALL_HUES
          (0), RED_HUES (1), YELLOW_HUES (2), GREEN_HUES (3), CYAN_HUES
          (4), BLUE_HUES (5), MAGENTA_HUES (6)

        * *hue_offset* (PDB_FLOAT)-Hue offset in degrees: (-180 <=
          hue_offset <= 180)

        * *lightness* (PDB_FLOAT)-Lightness modification: (-100 <=
          lightness <= 100)

        * *saturation* (PDB_FLOAT)-Saturation modification: (-100 <=
          saturation <= 100)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_active_drawable IMAGE
     This procedure returns the ID of the image's active drawable.
     This can be either a layer, a channel, or a layer mask.  The
     active drawable is specified by the active image channel.  If that
     is -1, then by the active image layer.  If the active image layer
     has a layer mask and the layer mask is in edit mode, then the
     layer mask is the active drawable.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *drawable* (PDB_DRAWABLE)-The active drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_add_channel IMAGE, CHANNEL, POSITION
     This procedure adds the specified channel to the gimage.  The
     position channel is not currently used, so the channel is always
     inserted at the top of the channel stack.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *channel* (PDB_CHANNEL)-The channel

        * *position* (PDB_INT32)-The channel position
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_add_layer IMAGE, LAYER, POSITION
     This procedure adds the specified layer to the gimage at the given
     position.  If the position is specified as -1, then the layer is
     inserted at the top of the layer stack.  If the layer to be added
     has no alpha channel, it must be added at position 0.  The layer
     type must be compatible with the image base type.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *layer* (PDB_LAYER)-The layer

        * *position* (PDB_INT32)-The layer position
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_add_layer_mask IMAGE, LAYER, MASK
     This procedure adds a layer mask to the specified layer.  Layer
     masks serve as an additional alpha channel for a layer.  This
     procedure will fail if a number of prerequisites aren't met.  The
     layer cannot already have a layer mask.  The specified mask must
     exist and have the same dimensions as the layer.  Both the mask
     and the layer must have been created for use with the specified
     image.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The layer's image

        * *layer* (PDB_LAYER)-The layer to receive the mask

        * *mask* (PDB_CHANNEL)-The mask to add to the layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_base_type IMAGE
     This procedure returns the image's base type, which is one of: {
     RGB-CHANNEL, GRAY-CHANNEL, INDEXED-CHANNEL }.  Layers in the image
     must be of this subtype, but can have an optional alpha
     channel.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *base_type* (PDB_INT32)-The image's base type: { RGB (0),
          GRAY (1), INDEXED (2) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_clean_all IMAGE
     This procedure sets the specified image's dirty count to 0,
     allowing operations to occur without having a 'dirtied' image.
     This is especially useful for creating and loading images which
     should not initially be considered dirty, even though layers must
     be created, filled, and installed in the image.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_delete IMAGE
     If there are no other references to this image it will be deleted.
     Other references are possible when more than one view to an image
     exists.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image ID
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_disable_undo IMAGE
     This procedure disables the image's undo stack, allowing
     subsequent operations to ignore their undo steps.  This is
     generally called in conjunction with 'gimp_image_enable_undo' to
     temporarily disable an image undo stack.  This is advantageous
     because saving undo steps can be time and memory
     intensive.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *disabled* (PDB_INT32)-True if the image undo has been
          disabled
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_enable_undo IMAGE
     This procedure enables the image's undo stack, allowing subsequent
     operations to store their undo steps.  This is generally called in
     conjunction with 'gimp_image_disable_undo' to temporarily disable
     an image undo stack.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *enabled* (PDB_INT32)-True if the image undo has been enabled
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_flatten IMAGE
     This procedure combines the visible layers in a manner analogous
     to merging with the ClipToImage merge type.  Non-visible layers
     are discarded, and the resulting image is stripped of its alpha
     channel.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *layer* (PDB_LAYER)-The resulting layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_floating_selection IMAGE
     This procedure returns the image's floating_sel, if it exists.  If
     it doesn't exist, -1 is returned as the layer ID.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *floating_sel* (PDB_LAYER)-The image's floating selection
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_free_shadow IMAGE
     This procedure is intended as a memory saving device.  If any
     shadow memory has been allocated, it will be freed automatically
     on a call to 'gimp_image_delete'.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image ID
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_active_channel IMAGE
     If there is an active channel, this will return the channel ID,
     otherwise, -1.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *channel ID* (PDB_CHANNEL)-The ID of the active channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_active_layer IMAGE
     If there is an active layer, its ID will be returned, otherwise,
     -1.  If a channel is currently active, then no layer will be.  If
     a layer mask is active, then this will return the associated
     layer.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *layer_ID* (PDB_LAYER)-The ID of the active layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_channels IMAGE
     This procedure returns the list of channels contained in the
     specified image.  This does not include the selection mask, or
     layer masks.  The order is from topmost to bottommost.-*Internal
     GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *num_channels* (PDB_INT32)-The number of channels contained
          in the image

        * *channel_ids* (PDB_INT32ARRAY)-The list of channels contained
          in the image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_cmap IMAGE
     This procedure returns an actual pointer to the image's colormap,
     as well as the number of bytes contained in the colormap.  The
     actual number of colors in the transmitted colormap will be
     "num_bytes" / 3.  If the image is not of base type INDEXED, this
     pointer will be NULL.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *num_bytes* (PDB_INT32)-Number of bytes in the colormap
          array: 0 <= num_bytes <= 768

        * *cmap* (PDB_INT8ARRAY)-The image's colormap
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_component_active IMAGE, COMPONENT
     This procedure returns information on whether the specified image
     component (ie. red, green, blue intensity channels in an RGB
     image) is active or inactive-whether or not it can be modified.
     If the specified component is not valid for the image type, an
     error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *component* (PDB_INT32)-The image component: { RED-CHANNEL
          (0), GREEN-CHANNEL (1), BLUE-CHANNEL (2), GRAY-CHANNEL (3),
          INDEXED-CHANNEL (4) }

     *Outputs*
        * *active* (PDB_INT32)-1 for active, 0 for inactive
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_component_visible IMAGE, COMPONENT
     This procedure returns information on whether the specified image
     component (ie. Red, Green, Blue intensity channels in an RGB
     image) is visible or invisible-whether or not it can be modified.
     If the specified component is not valid for the image type, an
     error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *component* (PDB_INT32)-The image component: {RED-CHANNEL
          (0), GREEN-CHANNEL (1), BLUE-CHANNEL (2), GRAY-CHANNEL (3),
          INDEXED-CHANNEL (4) }

     *Outputs*
        * *visible* (PDB_INT32)-1 for visible, 0 for invisible
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_filename IMAGE
     This procedure returns the image's filename-if it was loaded or
     has since been saved.  Otherwise, returns NULL.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *filename* (PDB_STRING)-The image's filename
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_layers IMAGE
     This procedure returns the list of layers contained in the
     specified image.  The order of layers is from topmost to
     bottommost.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *num_layers* (PDB_INT32)-The number of layers contained in
          the image

        * *layer_ids* (PDB_INT32ARRAY)-The list of layers contained in
          the image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_get_selection IMAGE
     This will always return a valid ID for a selection-which is
     represented as a channel internally.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *selection mask ID* (PDB_SELECTION)-The ID of the selection
          channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_height IMAGE
     This procedure returns the image's height.  This value is
     independent of any of the layers in this image.  This is the
     "canvas" height.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *height* (PDB_INT32)-The image's height
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_lower_channel IMAGE, CHANNEL
     This procedure lowers the specified channel one step in the
     existing channel stack.  It will not move the channel if there is
     no channel below it.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *channel* (PDB_CHANNEL)-The channel to lower
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_lower_layer IMAGE, LAYER
     This procedure lowers the specified layer one step in the existing
     layer stack.  It will not move the layer if there is no layer
     below it, or the layer has no alpha channel.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *layer* (PDB_LAYER)-The layer to lower
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_merge_visible_layers IMAGE, MERGE_TYPE
     This procedure combines the visible layers into a single layer
     using the specified merge type.  A merge type of
     EXPAND-AS-NECESSARY expands the final layer to encompass the areas
     of the visible layers.  A merge type of CLIP-TO-IMAGE clips the
     final layer to the extents of the image.  A merge type of
     CLIP-TO-BOTTOM-LAYER clips the final layer to the size of the
     bottommost layer.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *merge_type* (PDB_INT32)-The type of merge: {
          EXPAND-AS-NECESSARY (0), CLIP-TO-IMAGE (1),
          CLIP-TO-BOTTOM-LAYER (2) }

     *Outputs*
        * *layer* (PDB_LAYER)-The resulting layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_new WIDTH, HEIGHT, TYPE
     Creates a new image, undisplayed with the specified extents and
     type.  A layer should be created and added before this image is
     displayed, or subsequent calls to 'gimp_display_new' with this
     image as an argument will fail.  Layers can be created using the
     'gimp_layer_new' commands.  They can be added to an image using
     the 'gimp_image_add_layer' command.-*Internal GIMP procedure*

     *Inputs*
        * *width* (PDB_INT32)-The width of the image

        * *height* (PDB_INT32)-The height of the image

        * *type* (PDB_INT32)-The type of image: { RGB (0), GRAY (1),
          INDEXED (2) }

     *Outputs*
        * *image* (PDB_IMAGE)-The ID of the newly created image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_pick_correlate_layer IMAGE, X, Y
     This procedure finds the layer which is visible at the specified
     coordinates.  Layers which do not qualify are those whose extents
     do not pass within the specified coordinates, or which are
     transparent at the specified coordinates.  This procedure will
     return -1 if no layer is found.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *x* (PDB_INT32)-The x coordinate for the pick

        * *y* (PDB_INT32)-The y coordinate for the pick

     *Outputs*
        * *layer* (PDB_LAYER)-The layer found at the specified
          coordinates
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_raise_channel IMAGE, CHANNEL
     This procedure raises the specified channel one step in the
     existing channel stack.  It will not move the channel if there is
     no channel above it.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *channel* (PDB_CHANNEL)-The channel to raise
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_raise_layer IMAGE, LAYER
     This procedure raises the specified layer one step in the existing
     layer stack.  It will not move the layer if there is no layer
     above it, or the layer has no alpha channel.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *layer* (PDB_LAYER)-The layer to raise
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_remove_channel IMAGE, CHANNEL
     This procedure removes the specified channel from the image.  If
     the channel doesn't exist, an error is returned.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *channel* (PDB_CHANNEL)-The channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_remove_layer IMAGE, LAYER
     This procedure removes the specified layer from the image.  If the
     layer doesn't exist, an error is returned.  If there are no layers
     left in the image, this call will fail.  If this layer is the last
     layer remaining, the image will become empty and have no active
     layer.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *layer* (PDB_LAYER)-The layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_remove_layer_mask IMAGE, LAYER, MODE
     This procedure removes the specified layer mask from the layer.
     If the mask doesn't exist, an error is returned.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The layer's image

        * *layer* (PDB_LAYER)-The layer from which to remove mask

        * *mode* (PDB_INT32)-Removal mode: { APPLY (0), DISCARD (1) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_resize IMAGE, NEW_WIDTH, NEW_HEIGHT, OFFX, OFFY
     This procedure resizes the image so that it's new width and height
     are equal to the supplied parameters.  Offsets are also provided
     which describe the position of the previous image's content.  No
     bounds checking is currently provided, so don't supply parameters
     that are out of bounds.  All channels within the image are resized
     according to the specified parameters; this includes the image
     selection mask.  All layers within the image are repositioned
     according to the specified offsets.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *new_width* (PDB_INT32)-New image width: (new_width > 0)

        * *new_height* (PDB_INT32)-New image height: (new_height > 0)

        * *offx* (PDB_INT32)-X offset between upper left corner of old
          and new images: (new - old)

        * *offy* (PDB_INT32)-Y offset between upper left corner of old
          and new images: (new - old)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_scale IMAGE, NEW_WIDTH, NEW_HEIGHT
     This procedure scales the image so that it's new width and height
     are equal to the supplied parameters.  Offsets are also provided
     which describe the position of the previous image's content.  No
     bounds checking is currently provided, so don't supply parameters
     that are out of bounds.  All channels within the image are scaled
     according to the specified parameters; this includes the image
     selection mask.  All layers within the image are repositioned
     according to the specified offsets.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *new_width* (PDB_INT32)-New image width: (new_width > 0)

        * *new_height* (PDB_INT32)-New image height: (new_height > 0)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_set_active_channel IMAGE, CHANNEL
     If the channel exists, it is set as the active channel in the
     image.  Any previous active channel or channel is set to inactive.
     An exception is a previously existing floating selection, in
     which case this procedure will return an execution
     error.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *channel* (PDB_CHANNEL)-The channel to be set active
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_set_active_layer IMAGE, LAYER
     If the layer exists, it is set as the active layer in the image.
     Any previous active layer or channel is set to inactive.  An
     exception is a previously existing floating selection, in which
     case this procedure will return an execution error.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *layer* (PDB_LAYER)-The layer to be set active
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_set_cmap IMAGE, NUM_BYTES, CMAP
     This procedure sets the entries in the specified image's colormap.
     The number of entries is specified by the "num_bytes" parameter
     and corresponds the the number of INT8 triples that must be
     contained in the "cmap" array.  The actual number of colors in the
     transmitted colormap is "num_bytes" / 3.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *num_bytes* (PDB_INT32)-Number of bytes in the new colormap:
          0 <= num_colors <= 768

        * *cmap* (PDB_INT8ARRAY)-The new colormap values
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_set_component_active IMAGE, COMPONENT, ACTIVE
     This procedure sets whether the specified component is active or
     inactive-that is, whether it can be affected during painting
     operations.  If the specified component is not valid for the image
     type, an error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *component* (PDB_INT32)-The image component: { RED-CHANNEL
          (0), GREEN-CHANNEL (1), BLUE-CHANNEL (2), GRAY-CHANNEL (3),
          INDEXED-CHANNEL (4) }

        * *active* (PDB_INT32)-Active? 1 for true, 0 for false
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_set_component_visible IMAGE, COMPONENT, VISIBLE
     This procedure sets whether the specified component is visible or
     invisible.  If the specified component is not valid for the image
     type, an error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *component* (PDB_INT32)-The image component: { RED-CHANNEL
          (0), GREEN-CHANNEL (1), BLUE-CHANNEL (2), GRAY-CHANNEL (3),
          INDEXED-CHANNEL (4) }

        * *visible* (PDB_INT32)-Visible? 1 for true, 0 for false
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_set_filename IMAGE, FILENAME
     This procedure sets the image's filename.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *filename* (PDB_STRING)-The image's filename
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_unset_active_channel IMAGE
     If an active channel exists, it is unset.  There then exists no
     active channel, and if desired, one can be set through a call to
     'Set Active Channel'.  No error is returned in the case of no
     existing active channel.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_image_width IMAGE
     This procedure returns the image's width.  This value is
     independent of any of the layers in this image.  This is the
     "canvas" width.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *width* (PDB_INT32)-The image's width
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_invert IMAGE, DRAWABLE
     This procedure inverts the contents of the specified drawable.
     Each intensity channel is inverted independently.  The inverted
     intensity is given as inten' = (255 - inten).  Indexed color
     drawables are not valid for this operation.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_add_alpha LAYER
     This procedure adds an additional component to the specified layer
     if it does not already possess an alpha channel.  An alpha channel
     makes it possible to move a layer from the bottom of the layer
     stack and to clear and erase to transparency, instead of the
     background color.  This transforms images of type RGB to RGBA,
     Gray to GrayA, and Indexed to IndexedA.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_copy LAYER, ADD_APHA
     This procedure copies the specified layer and returns the copy.
     The newly copied layer is for use within the original layer's
     image.  It should not be subsequently added to any other image.
     The copied layer can optionally have an added alpha channel.  This
     is useful if the background layer in an image is being copied and
     added to the same image.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer to copy

        * *add_apha* (PDB_INT32)-Add an alpha channel to the copied
          layer

     *Outputs*
        * *layer_copy* (PDB_LAYER)-The newly copied layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_create_mask LAYER, MASK_TYPE
     This procedure creates a layer mask for the specified layer.
     Layer masks serve as an additional alpha channel for a layer.
     Three different types of masks are allowed initially: completely
     white masks (which will leave the layer fully visible), completely
     black masks (which will give the layer complete transparency), and
     the layer's already existing alpha channel (which will leave the
     layer fully visible, but which may be more useful than a white
     mask).  The layer mask still needs to be added to the layer.  This
     can be done with a call to 'gimage_add_layer_mask'.-*Internal GIMP
     procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer to which to add the mask

        * *mask_type* (PDB_INT32)-The type of mask: { WHITE-MASK (0),
          BLACK-MASK (1), ALPHA-MASK (2) }

     *Outputs*
        * *mask* (PDB_CHANNEL)-The newly created mask
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_delete LAYER
     This procedure deletes the specified layer.  This does not need to
     be done if a gimage containing this layer was already
     deleted.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer to delete
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_apply_mask LAYER
     This procedure returns the specified layer's apply mask setting.
     If the return value is non-zero, then the layer mask for this
     layer is currently being composited with the layer's alpha
     channel.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *apply_mask* (PDB_INT32)-The layer's apply mask setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_edit_mask LAYER
     This procedure returns the specified layer's edit mask setting.
     If the value is non-zero, then the layer's mask is currently
     active, and not the layer.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *edit_mask* (PDB_INT32)-The layer's edit mask setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_mode LAYER
     This procedure returns the specified layer's combination
     mode.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *mode* (PDB_INT32)-The layer combination mode: { NORMAL (0),
          DISSOLVE (1), MULTIPLY (3), SCREEN (4), OVERLAY (5)
          DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9),
          LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13),
          VALUE (14) }
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_name LAYER
     This procedure returns the specified layer's name.-*Internal GIMP
     procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *name* (PDB_STRING)-The layer name
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_opacity LAYER
     This procedure returns the specified layer's opacity.-*Internal
     GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *opacity* (PDB_FLOAT)-The layer opacity
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_preserve_trans LAYER
     This procedure returns the specified layer's preserve transparency
     setting.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *preserve_trans* (PDB_INT32)-The layer's preserve
          transparency setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_show_mask LAYER
     This procedure returns the specified layer's show mask setting.
     If the value is non-zero, then the layer's mask is currently being
     shown instead of the layer.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *show_mask* (PDB_INT32)-The layer's show mask setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_get_visible LAYER
     This procedure returns the specified layer's visibility.-*Internal
     GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *visible* (PDB_INT32)-The layer visibility
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_is_floating_sel LAYER
     This procedure returns whether the layer is a floating selection.
     Floating selections are special cases of layers which are attached
     to a specific drawable.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *is_floating_sel* (PDB_CHANNEL)-Non-zero if the layer is a
          floating selection
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_mask LAYER
     This procedure returns the specified layer's mask, or -1 if none
     exists.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

     *Outputs*
        * *mask* (PDB_CHANNEL)-The layer mask
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_new IMAGE, WIDTH, HEIGHT, TYPE, NAME, OPACITY,
          MODE
     This procedure creates a new layer with the specified width,
     height, and type.  Name, opacity, and mode are also supplied
     parameters.  The new layer still needs to be added to the image,
     as this is not automatic.  Add the new layer with the
     'gimp_image_add_layer' command.  Other attributes such as layer
     mask modes, and offsets should be set with explicit procedure
     calls.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image to which to add the layer

        * *width* (PDB_INT32)-The layer width: (width > 0)

        * *height* (PDB_INT32)-The layer height: (height > 0)

        * *type* (PDB_INT32)-The layer type: { RGB (0), RGBA (1), GRAY
          (2), GRAYA (3), INDEXED (4), INDEXEDA (5) }

        * *name* (PDB_STRING)-The layer name

        * *opacity* (PDB_FLOAT)-The layer opacity: (0 <= opacity <= 100)

        * *mode* (PDB_INT32)-The layer combination mode: { NORMAL (0),
          DISSOLVE (1), MULTIPLY (3), SCREEN (4), OVERLAY (5)
          DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9),
          LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13),
          VALUE (14) }

     *Outputs*
        * *layer* (PDB_LAYER)-The newly created layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_resize LAYER, NEW_WIDTH, NEW_HEIGHT, OFFX, OFFY
     This procedure resizes the layer so that it's new width and height
     are equal to the supplied parameters.  Offsets are also provided
     which describe the position of the previous layer's content.  No
     bounds checking is currently provided, so don't supply parameters
     that are out of bounds.  This operation on works if the layer has
     been added to an image.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *new_width* (PDB_INT32)-New layer width: (new_width > 0)

        * *new_height* (PDB_INT32)-New layer height: (new_height > 0)

        * *offx* (PDB_INT32)-X offset between upper left corner of old
          and new layers: (new - old)

        * *offy* (PDB_INT32)-Y offset between upper left corner of old
          and new layers: (new - old)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_scale LAYER, NEW_WIDTH, NEW_HEIGHT, LOCAL_ORIGIN
     This procedure scales the layer so that it's new width and height
     are equal to the supplied parameters.  The "local_origin"
     parameter specifies whether to scale from the center of the layer,
     or from the image origin.  This operation only works if the layer
     has been added to an image.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *new_width* (PDB_INT32)-New layer width: (new_width > 0)

        * *new_height* (PDB_INT32)-New layer height: (new_height > 0)

        * *local_origin* (PDB_INT32)-Use a local origin, or the image
          origin?
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_apply_mask LAYER, APPLY_MASK
     This procedure sets the specified layer's apply mask parameter.
     This controls whether the layer's mask is currently affecting the
     alpha channel.  If there is no layer mask, this function will
     return an error-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *apply_mask* (PDB_INT32)-The new layer apply mask setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_edit_mask LAYER, EDIT_MASK
     This procedure sets the specified layer's edit mask parameter.
     This setting controls whether the layer or it's mask is currently
     active for editing.  If the specified layer has no layer mask,
     then this procedure will return an error.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *edit_mask* (PDB_INT32)-The new layer edit mask setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_mode LAYER, MODE
     This procedure sets the specified layer's combination
     mode.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *mode* (PDB_INT32)-The new layer combination mode
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_name LAYER, NAME
     This procedure sets the specified layer's name to the supplied
     name.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *name* (PDB_STRING)-The new layer name
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_offsets LAYER, OFFX, OFFY
     This procedure sets the offsets for the specified layer.  The
     offsets are relative to the image origin and can be any values.
     This operation is valid only on layers which have been added to an
     image.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *offx* (PDB_INT32)-Offset in x direction

        * *offy* (PDB_INT32)-Offset in y direction
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_opacity LAYER, OPACITY
     This procedure sets the specified layer's opacity.-*Internal GIMP
     procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *opacity* (PDB_FLOAT)-The new layer opacity: (0 <= opacity <=
          100)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_preserve_trans LAYER, PRESERVE_TRANS
     This procedure sets the specified layer's preserve transparency
     option.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *preserve_trans* (PDB_INT32)-The new layer preserve
          transparency setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_show_mask LAYER, SHOW_MASK
     This procedure sets the specified layer's show mask parameter.
     This setting controls whether the layer or it's mask is visible.
     Non-zero values indicate that the mask should be visible.  If the
     layer has no mask, then this function returns an error.-*Internal
     GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *show_mask* (PDB_INT32)-The new layer show mask setting
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_set_visible LAYER, VISIBLE
     This procedure sets the specified layer's visibility.-*Internal
     GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *visible* (PDB_INT32)-The new layer visibility
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_layer_translate LAYER, OFFX, OFFY
     This procedure translates the layer by the amounts specified in
     the x and y arguments.  These can be negative, and are considered
     offsets from the current position.  This command only works if the
     layer has been added to an image.  All additional layers contained
     in the image which have the linked flag set to TRUE will also be
     translated by the specified offsets.-*Internal GIMP procedure*

     *Inputs*
        * *layer* (PDB_LAYER)-The layer

        * *offx* (PDB_INT32)-Offset in x direction

        * *offy* (PDB_INT32)-Offset in y direction
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_levels IMAGE, DRAWABLE, CHANNEL, LOW_INPUT,
          HIGH_INPUT, GAMMA, LOW_OUTPUT, HIGH_OUTPUT
     This tool allows intensity levels in the specified drawable to be
     remapped according to a set of parameters.  The low/high input
     levels specify an initial mapping from the source intensities.
     The gamma value determines how intensities between the low and
     high input intensities are interpolated.  A gamma value of 1.0
     results in a linear interpolation.  Higher gamma values result in
     more high-level intensities.  Lower gamma values result in more
     low-level intensities.  The low/high output levels constrain the
     final intensity mapping-that is, no final intensity will be lower
     than the low output level and no final intensity will be higher
     than the high output level.  This tool is only valid on RGB color
     and grayscale images.  It will not operate on indexed
     drawables.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *channel* (PDB_INT32)-The channel to modify: { VALUE (0), RED
          (1), GREEN (2), BLUE (3), GRAY (0) }

        * *low_input* (PDB_INT32)-Intensity of lowest input: (0 <=
          low_input <= 255)

        * *high_input* (PDB_INT32)-Intensity of highest input: (0 <=
          high_input <= 255)

        * *gamma* (PDB_FLOAT)-Gamma correction factor: (0.1 <= gamma <=
          10)

        * *low_output* (PDB_INT32)-Intensity of lowest output: (0 <=
          low_input <= 255)

        * *high_output* (PDB_INT32)-Intensity of highest output: (0 <=
          high_input <= 255)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_list_images
     This procedure returns the list of images currently open in the
     GIMP.-*Internal GIMP procedure*

     *Outputs*
        * *num_images* (PDB_INT32)-The number of images currently open

        * *image_ids* (PDB_INT32ARRAY)-The list of images currently open
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_paintbrush IMAGE, DRAWABLE, FADE_OUT, NUM_STROKES,
          STROKES
     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.  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.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *fade_out* (PDB_FLOAT)-Fade out parameter: fade_out > 0

        * *num_strokes* (PDB_INT32)-Number of stroke control points
          (count each coordinate as 2 points)

        * *strokes* (PDB_FLOATARRAY)-Array of stroke coordinates:
          {s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y}
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_palette_get_background
     This procedure retrieves the current GIMP background color.  The
     background color is used in a variety of tools such as blending,
     erasing (with non-apha images), and image filling.-*Internal GIMP
     procedure*

     *Outputs*
        * *background* (PDB_COLOR)-The background color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_palette_get_foreground
     This procedure retrieves the current GIMP foreground color.  The
     foreground color is used in a variety of tools such as paint
     tools, blending, and bucket fill.-*Internal GIMP procedure*

     *Outputs*
        * *foreground* (PDB_COLOR)-The foreground color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_palette_set_background BACKGROUND
     This procedure sets the current GIMP background color.  After this
     is set, operations which use background such as blending, filling
     images, clearing, and erasing (in non-alpha images) will use the
     new value.-*Internal GIMP procedure*

     *Inputs*
        * *background* (PDB_COLOR)-The background color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_palette_set_foreground FOREGROUND
     This procedure sets the current GIMP foreground color.  After this
     is set, operations which use foreground such as paint tools,
     blending, and bucket fill will use the new value.-*Internal GIMP
     procedure*

     *Inputs*
        * *foreground* (PDB_COLOR)-The foreground color
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_patterns_get_pattern
     This procedure retrieves information about the currently active
     pattern.  This includes the pattern name, and the pattern extents
     (width and height).  All clone and bucket-fill operations with
     patterns will use this pattern to control the application of paint
     to the image.-*Internal GIMP procedure*

     *Outputs*
        * *name* (PDB_STRING)-The pattern name

        * *width* (PDB_INT32)-The pattern width

        * *height* (PDB_INT32)-The pattern height
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_patterns_list
     This procedure returns a complete listing of available GIMP
     patterns.  Each name returned can be used as input to the
     'gimp_patterns_set_pattern'-*Internal GIMP procedure*

     *Outputs*
        * *num_patterns* (PDB_INT32)-The number of patterns in the
          pattern list

        * *pattern_list* (PDB_STRINGARRAY)-The list of pattern names
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_patterns_set_pattern NAME
     This procedure allows the active pattern mask to be set by
     specifying its name.  The name is simply a string which
     corresponds to one of the names of the installed patterns.  If
     there is no matching pattern found, this procedure will return an
     error.  Otherwise, the specified pattern becomes active and will
     be used in all subsequent paint operations.-*Internal GIMP
     procedure*

     *Inputs*
        * *name* (PDB_STRING)-The pattern name
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_pencil IMAGE, DRAWABLE, NUM_STROKES, STROKES
     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.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *num_strokes* (PDB_INT32)-Number of stroke control points
          (count each coordinate as 2 points)

        * *strokes* (PDB_FLOATARRAY)-Array of stroke coordinates:
          {s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y}
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_perspective IMAGE, DRAWABLE, INTERPOLATION, X0, Y0,
          X1, Y1, X2, Y2, X3, Y3
     This tool performs a possibly non-affine transformation on the
     specified drawable by allowing the corners of the original
     bounding box to be arbitrarily remapped to any values.  The
     specified drawable is remapped if no selection exists.  However,
     if a selection exists, the portion of the drawable which lies
     under the selection is cut from the drawable and made into a
     floating selection which is then remapped as specified.  The
     interpolation parameter can be set to TRUE to indicate that either
     linear or cubic interpolation should be used to smooth the
     resulting remapped drawable.  The return value is the ID of the
     remapped drawable.  If there was no selection, this will be equal
     to the drawable ID supplied as input.  Otherwise, this will be the
     newly created and remapped drawable.  The 4 coordinates specify
     the new locations of each corner of the original bounding box.  By
     specifying these values, any affine transformation (rotation,
     scaling, translation) can be affected.  Additionally, these values
     can be specified such that the resulting transformed drawable will
     appear to have been projected via a perspective
     transform.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *interpolation* (PDB_INT32)-Whether to use interpolation

        * *x0* (PDB_FLOAT)-The new x coordinate of upper-left corner of
          original bounding box

        * *y0* (PDB_FLOAT)-The new y coordinate of upper-left corner of
          original bounding box

        * *x1* (PDB_FLOAT)-The new x coordinate of upper-right corner
          of original bounding box

        * *y1* (PDB_FLOAT)-The new y coordinate of upper-right corner
          of original bounding box

        * *x2* (PDB_FLOAT)-The new x coordinate of lower-left corner of
          original bounding box

        * *y2* (PDB_FLOAT)-The new y coordinate of lower-left corner of
          original bounding box

        * *x3* (PDB_FLOAT)-The new x coordinate of lower-right corner
          of original bounding box

        * *y3* (PDB_FLOAT)-The new y coordinate of lower-right corner
          of original bounding box

     *Outputs*
        * *drawable* (PDB_DRAWABLE)-The newly mapped drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_posterize IMAGE, DRAWABLE, LEVELS
     This procedures reduces the number of shades allows in each
     intensity channel to the specified 'levels' parameter.-*Internal
     GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *levels* (PDB_INT32)-Levels of posterization: (2 <= levels <=
          255)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_procedural_db_dump FILENAME
     This procedure dumps the contents of the procedural database to
     the specified file.  The file will contain all of the information
     provided for each registered procedure.  This file is in a format
     appropriate for use with the supplied "pdb_self_doc.el" Elisp
     script, which generates a texinfo document.-*Internal GIMP
     procedure*

     *Inputs*
        * *filename* (PDB_STRING)-The dump filename
   *Spencer Kimball & Josh MacDonald*

 - Function: gimp_procedural_db_get_data IDENTIFIER
     This procedure returns any data which may have been associated
     with the specified identifier.  The data is a variable length
     array of bytes.  If no data has been associated with the
     identifier, an error is returned.-*Internal GIMP procedure*

     *Inputs*
        * *identifier* (PDB_STRING)-The identifier associated with data

     *Outputs*
        * *bytes* (PDB_INT32)-The number of bytes in the data

        * *data* (PDB_INT8ARRAY)-A byte array containing data
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_procedural_db_proc_arg PROCEDURE, ARG_NUM
     This procedure returns information on the specified procedure's
     argument.  The argument type, name, and a description are
     retrieved.-*Internal GIMP procedure*

     *Inputs*
        * *procedure* (PDB_STRING)-The procedure name

        * *arg_num* (PDB_INT32)-The argument number

     *Outputs*
        * *arg_type* (PDB_INT32)-The type of argument { PDB_INT32 (0),
          PDB_INT16 (1), PDB_INT8 (2), PDB_FLOAT (3), PDB_STRING (4),
          PDB_INT32ARRAY (5), PDB_INT16ARRAY (6), PDB_INT8ARRAY (7),
          PDB_FLOATARRAY (8), PDB_STRINGARRAY (9), PDB_COLOR (10),
          PDB_REGION (11), PDB_DISPLAY (12), PDB_IMAGE (13), PDB_LAYER
          (14), PDB_CHANNEL (15), PDB_DRAWABLE (16), PDB_SELECTION
          (17), PDB_BOUNDARY (18), PDB_PATH (19), PDB_STATUS (20) }

        * *arg_name* (PDB_STRING)-The name of the argument

        * *arg_desc* (PDB_STRING)-A description of the argument
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_procedural_db_proc_info PROCEDURE
     This procedure returns information on the specified procedure.  A
     short blurb, detailed help, author(s), copyright information,
     procedure type, number of input, and number of return values are
     returned.  For specific information on each input argument and
     return value, use the 'gimp_procedural_db_query_proc_arg' and
     'gimp_procedural_db_query_proc_val' procedures-*Internal GIMP
     procedure*

     *Inputs*
        * *procedure* (PDB_STRING)-The procedure name

     *Outputs*
        * *blurb* (PDB_STRING)-A short blurb

        * *help* (PDB_STRING)-Detailed procedure help

        * *author* (PDB_STRING)-Author(s) of the procedure

        * *copyright* (PDB_STRING)-The copyright

        * *date* (PDB_STRING)-Copyright date

        * *proc_type* (PDB_INT32)-The procedure type: { INTERNAL (0),
          PLUGIN (1), EXTENSION (2) }

        * *num_args* (PDB_INT32)-The number of input arguments

        * *num_rvals* (PDB_INT32)-The number of return values
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_procedural_db_proc_val PROCEDURE, VAL_NUM
     This procedure returns information on the specified procedure's
     return value.  The return value type, name, and a description are
     retrieved.-*Internal GIMP procedure*

     *Inputs*
        * *procedure* (PDB_STRING)-The procedure name

        * *val_num* (PDB_INT32)-The return value number

     *Outputs*
        * *val_type* (PDB_INT32)-The type of return value { PDB_INT32
          (0), PDB_INT16 (1), PDB_INT8 (2), PDB_FLOAT (3), PDB_STRING
          (4), PDB_INT32ARRAY (5), PDB_INT16ARRAY (6), PDB_INT8ARRAY
          (7), PDB_FLOATARRAY (8), PDB_STRINGARRAY (9), PDB_COLOR (10),
          PDB_REGION (11), PDB_DISPLAY (12), PDB_IMAGE (13), PDB_LAYER
          (14), PDB_CHANNEL (15), PDB_DRAWABLE (16), PDB_SELECTION
          (17), PDB_BOUNDARY (18), PDB_PATH (19), PDB_STATUS (20) }

        * *val_name* (PDB_STRING)-The name of the return value

        * *val_desc* (PDB_STRING)-A description of the return value
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_procedural_db_query NAME, BLURB, HELP, AUTHOR,
          COPYRIGHT, DATE, PROC_TYPE
     This procedure queries the contents of the procedural database.
     It is supplied with seven arguments matching procedures on {name,
     blurb, help, author, copyright, date, procedure type}.  This is
     accomplished using regular expression matching.  For instance, to
     find all procedures with "jpeg" listed in the blurb, all seven
     arguments can be supplied as ".*", except for the second, which
     can be supplied as ".*jpeg.*".  There are two return arguments for
     this procedure.  The first is the number of procedures matching
     the query.  The second is a concatenated list of procedure names
     corresponding to those matching the query.  If no matching entries
     are found, then the returned string is NULL and the number of
     entries is 0.-*Internal GIMP procedure*

     *Inputs*
        * *name* (PDB_STRING)-The regex for procedure name

        * *blurb* (PDB_STRING)-The regex for procedure blurb

        * *help* (PDB_STRING)-The regex for procedure help

        * *author* (PDB_STRING)-The regex for procedure author

        * *copyright* (PDB_STRING)-The regex for procedure copyright

        * *date* (PDB_STRING)-The regex for procedure date

        * *proc_type* (PDB_STRING)-The regex for procedure type:
          {'Internal GIMP procedure', 'GIMP Plug-In', 'GIMP Extension'}

     *Outputs*
        * *num_matches* (PDB_INT32)-The number of matching procedures

        * *procedure_names* (PDB_STRINGARRAY)-The list of procedure
          names
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_procedural_db_set_data IDENTIFIER, BYTES, DATA
     This procedure associates the supplied data with the provided
     identifier.  The data may be subsequently retrieved by a call to
     'procedural_db_get_data'.-*Internal GIMP procedure*

     *Inputs*
        * *identifier* (PDB_STRING)-The identifier for association with
          data

        * *bytes* (PDB_INT32)-The number of bytes in data

        * *data* (PDB_INT8ARRAY)-The data
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_progress_init MESSAGE
     Initializes the progress bar for the current plug-in. It is only
     valid to call this procedure from a plug-in.-*Internal GIMP
     procedure*

     *Inputs*
        * *message* (PDB_STRING)-Message to use in the progress dialog.
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_progress_update PERCENTAGE
     Updates the progress bar for the current plug-in. It is only valid
     to call this procedure from a plug-in.-*Internal GIMP procedure*

     *Inputs*
        * *percentage* (PDB_FLOAT)-Percentage of progress completed
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_quit KILL
     The internal procedure which can either be used to make the gimp
     quit normally, or to have the gimp clean up its resources and exit
     immediately. The normaly shutdown process allows for querying the
     user to save any dirty images.-*Internal GIMP procedure*

     *Inputs*
        * *kill* (PDB_INT32)-Flag specifying whether to kill the gimp
          process or exit normally
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_rect_select IMAGE, X, Y, WIDTH, HEIGHT, OPERATION,
          FEATHER, FEATHER_RADIUS
     This tool creates a rectangular selection over the specified
     image.  The rectangular region can be either added to, subtracted
     from, or replace the contents of the previous selection mask.  If
     the feather option is enabled, the resulting selection is blurred
     before combining.  The blur is a gaussian blur with the specified
     feather radius.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *x* (PDB_FLOAT)-X coordinate of upper-left corner of rectangle

        * *y* (PDB_FLOAT)-Y coordinate of upper-left corner of rectangle

        * *width* (PDB_FLOAT)-The width of the rectangle: width > 0

        * *height* (PDB_FLOAT)-The height of the rectangle: height > 0

        * *operation* (PDB_INT32)-The selection operation: { ADD (0),
          SUB (1), REPLACE (2), INTERSECT (3) }

        * *feather* (PDB_INT32)-Feather option for selections

        * *feather_radius* (PDB_FLOAT)-Radius for feather operation
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_register_load_handler PROCEDURE_NAME, EXTENSIONS,
          PREFIXES
     Registers a procedural database procedure to be called to load
     files of a particular file format.-*Internal GIMP procedure*

     *Inputs*
        * *procedure_name* (PDB_STRING)-The name of the procedure to be
          used for loading

        * *extensions* (PDB_STRING)-Comma separated list of extensions
          this handler can load (ie. "jpeg,jpg")

        * *prefixes* (PDB_STRING)-Comma separated list of prefixes this
          handler can load (ie. "http:,ftp:")
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_register_save_handler PROCEDURE_NAME, EXTENSIONS,
          PREFIXES
     Registers a procedural database procedure to be called to save
     files in a particular file format.-*Internal GIMP procedure*

     *Inputs*
        * *procedure_name* (PDB_STRING)-The name of the procedure to be
          used for saving

        * *extensions* (PDB_STRING)-Comma separated list of extensions
          this handler can save (ie. "jpeg,jpg")

        * *prefixes* (PDB_STRING)-Comma separated list of prefixes this
          handler can save (ie. "http:,ftp:")
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_rotate IMAGE, DRAWABLE, INTERPOLATION, ANGLE
     This tool rotates the specified drawable if no selection exists.
     If a selection exists, the portion of the drawable which lies
     under the selection is cut from the drawable and made into a
     floating selection which is then rotated by the specified amount.
     The interpolation parameter can be set to TRUE to indicate that
     either linear or cubic interpolation should be used to smooth the
     resulting rotated drawable.  The return value is the ID of the
     rotated drawable.  If there was no selection, this will be equal
     to the drawable ID supplied as input.  Otherwise, this will be the
     newly created and rotated drawable.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *interpolation* (PDB_INT32)-Whether to use interpolation

        * *angle* (PDB_FLOAT)-The angle of rotation (radians)

     *Outputs*
        * *drawable* (PDB_DRAWABLE)-The rotated drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_scale IMAGE, DRAWABLE, INTERPOLATION, X1, Y1, X2, Y2
     This tool scales the specified drawable if no selection exists.
     If a selection exists, the portion of the drawable which lies
     under the selection is cut from the drawable and made into a
     floating selection which is then scaled by the specified amount.
     The interpolation parameter can be set to TRUE to indicate that
     either linear or cubic interpolation should be used to smooth the
     resulting scaled drawable.  The return value is the ID of the
     scaled drawable.  If there was no selection, this will be equal to
     the drawable ID supplied as input.  Otherwise, this will be the
     newly created and scaled drawable.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *interpolation* (PDB_INT32)-Whether to use interpolation

        * *x1* (PDB_FLOAT)-The x coordinate of the upper-left corner of
          newly scaled region

        * *y1* (PDB_FLOAT)-The y coordinate of the upper-left corner of
          newly scaled region

        * *x2* (PDB_FLOAT)-The x coordinate of the lower-right corner
          of newly scaled region

        * *y2* (PDB_FLOAT)-The y coordinate of the lower-right corner
          of newly scaled region

     *Outputs*
        * *drawable* (PDB_DRAWABLE)-The scaled drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_all IMAGE
     This procedure sets the selection mask to completely encompass the
     image.  Every pixel in the selection channel is set to
     255.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_border IMAGE, RADIUS
     This procedure borders the selection.  Bordering creates a new
     selection which is defined along the boundary of the previous
     selection at every point within the specified radius.-*Internal
     GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *radius* (PDB_INT32)-Radius of border (pixels)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_bounds IMAGE
     This procedure returns whether there is a selection for the
     specified image.  If there is one, the upper left and lower right
     corners of the bounding box are returned.  These coordinates are
     relative to the image.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *non-empty* (PDB_INT32)-True if there is a selection

        * *x1* (PDB_INT32)-X coordinate of upper left corner of
          selection bounds

        * *y1* (PDB_INT32)-Y coordinate of upper left corner of
          selection bounds

        * *x2* (PDB_INT32)-X coordinate of lower right corner of
          selection bounds

        * *y2* (PDB_INT32)-Y coordinate of lower right corner of
          selection bounds
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_clear IMAGE
     This procedure sets the selection mask to empty, assigning the
     value 0 to every pixel in the selection channel.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_feather IMAGE, RADIUS
     This procedure feathers the selection.  Feathering is implemented
     using a gaussian blur.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *radius* (PDB_FLOAT)-Radius of feather (in pixels)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_float IMAGE, DRAWABLE, OFFSET_X, OFFSET_Y
     This procedure determines the region of the specified drawable
     that lies beneath the current selection.  The region is then cut
     from the drawable and the resulting data is made into a new layer
     which is instantiated as a floating selection.  The offsets allow
     initial positioning of the new floating selection.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable from which to float
          selection

        * *offset_x* (PDB_INT32)-X offset for translation

        * *offset_y* (PDB_INT32)-Y offset for translation

     *Outputs*
        * *layer* (PDB_LAYER)-The floated layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_grow IMAGE, STEPS
     This procedure grows the selection.  Growing involves expanding
     the boundary in all directions by the specified pixel
     amount.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *steps* (PDB_INT32)-Steps of grow (pixels)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_invert IMAGE
     This procedure inverts the selection mask.  For every pixel in the
     selection channel, its new value is calculated as (255 -
     old_value).-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_is_empty IMAGE
     This procedure returns non-zero if the selection for the specified
     image is not empty.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *is_empty* (PDB_INT32)-Is the selection empty?
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_layer_alpha IMAGE, LAYER
     This procedure requires a layer with an alpha channel.  The alpha
     channel information is used to create a selection mask such that
     for any pixel in the image defined in the specified layer, that
     layer pixel's alpha value is transferred to the selection mask.
     If the layer is undefined at a particular image pixel, the
     associated selection mask value is set to 0.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *layer* (PDB_LAYER)-Layer with alpha
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_load IMAGE, CHANNEL
     This procedure loads the specified channel into the selection
     mask.  This essentially involves a copy of the channel's content
     in to the selection mask.  Therefore, the channel must have the
     same width and height of the image, or an error is
     returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *channel* (PDB_CHANNEL)-The channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_none IMAGE
     This procedure deselects the entire image.  Every pixel in the
     selection channel is set to 0.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_save IMAGE
     This procedure copies the selection mask and stores the content in
     a new channel.  The new channel is automatically inserted into the
     image's list of channels.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

     *Outputs*
        * *channel* (PDB_CHANNEL)-The new channel
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_sharpen IMAGE
     This procedure sharpens the selection mask.  For every pixel in
     the selection channel, if the value is > 0, the new pixel is
     assigned a value of 255.  This removes any "anti-aliasing" that
     might exist in the selection mask's boundary.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_shrink IMAGE, RADIUS
     This procedure shrinks the selection.  Shrinking invovles trimming
     the existing selection boundary on all sides by the specified
     number of pixels.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *radius* (PDB_INT32)-Radius of shrink (pixels)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_translate IMAGE, OFFSET_X, OFFSET_Y
     This procedure actually translates the selection for the specified
     image by the specified offsets.  Regions that are translated from
     beyond the bounds of the image are set to empty.  Valid regions of
     the selection which are translated beyond the bounds of the image
     because of this call are lost.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *offset_x* (PDB_INT32)-X offset for translation

        * *offset_y* (PDB_INT32)-Y offset for translation
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_selection_value IMAGE, X, Y
     This procedure returns the value of the selection at the specified
     coordinates.  If the coordinates lie out of bounds, 0 is
     returned.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *x* (PDB_INT32)-X coordinate of value

        * *y* (PDB_INT32)-Y coordinate of value

     *Outputs*
        * *value* (PDB_INT32)-Value of the selection: (0 <= value <=
          255)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_shear IMAGE, DRAWABLE, INTERPOLATION, SHEAR_TYPE,
          MAGNITUDE
     This tool shears the specified drawable if no selection exists.
     If a selection exists, the portion of the drawable which lies
     under the selection is cut from the drawable and made into a
     floating selection which is then sheard by the specified amount.
     The interpolation parameter can be set to TRUE to indicate that
     either linear or cubic interpolation should be used to smooth the
     resulting sheard drawable.  The return value is the ID of the
     sheard drawable.  If there was no selection, this will be equal to
     the drawable ID supplied as input.  Otherwise, this will be the
     newly created and sheard drawable.  The shear type parameter
     indicates whether the shear will be applied horizontally or
     vertically.  The magnitude can be either positive or negative and
     indicates the extent (in pixels) to shear by.-*Internal GIMP
     procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable

        * *interpolation* (PDB_INT32)-Whether to use interpolation

        * *shear_type* (PDB_INT32)-Type of shear: { HORIZONTAL (0),
          VERTICAL (1) }

        * *magnitude* (PDB_FLOAT)-The magnitude of the shear

     *Outputs*
        * *drawable* (PDB_DRAWABLE)-The sheard drawable
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_temp_name EXTENSION
     Generates a unique filename using the temp path supplied in the
     user's gimprc.-*Internal GIMP procedure*

     *Inputs*
        * *extension* (PDB_STRING)-The extension the file will have.

     *Outputs*
        * *name* (PDB_STRING)-The temp name.
   *Josh MacDonald*

 - Function: gimp_text IMAGE, DRAWABLE, X, Y, TEXT, BORDER, ANTIALIAS,
          SIZE, SIZE_TYPE, FOUNDRY, FAMILY, WEIGHT, SLANT, SET_WIDTH,
          SPACING
     This tool requires font information in the form of seven
     parameters: {size, foundry, family, weight, slant, set_width,
     spacing}.  The font size can either be specified in units of
     pixels or points, and the appropriate metric is specified using
     the size_type argument.  The x and y parameters together control
     the placement of the new text by specifying the upper left corner
     of the text bounding box.  If the antialias parameter is non-zero,
     the generated text will blend more smoothly with underlying
     layers.  This option requires more time and memory to compute than
     non-antialiased text; the resulting floating selection or layer,
     however, will require the same amount of memory with or without
     antialiasing.  If the specified drawable parameter is valid, the
     text will be created as a floating selection attached to the
     drawable.  If the drawable parameter is not valid (-1), the text
     will appear as a new layer.  Finally, a border can be specified
     around the final rendered text.  The border is measured in
     pixels.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The affected drawable: (-1 for a
          new text layer)

        * *x* (PDB_FLOAT)-The x coordinate for the left side of text
          bounding box

        * *y* (PDB_FLOAT)-The y coordinate for the top of text bounding
          box

        * *text* (PDB_STRING)-The text to generate

        * *border* (PDB_INT32)-The size of the border: border >= 0

        * *antialias* (PDB_INT32)-Generate antialiased text

        * *size* (PDB_FLOAT)-The size of text in either pixels or points

        * *size_type* (PDB_INT32)-The units of the specified size: {
          PIXELS (0), POINTS (1) }

        * *foundry* (PDB_STRING)-The font foundry, "*" for any

        * *family* (PDB_STRING)-The font family, "*" for any

        * *weight* (PDB_STRING)-The font weight, "*" for any

        * *slant* (PDB_STRING)-The font slant, "*" for any

        * *set_width* (PDB_STRING)-The font set-width parameter, "*"
          for any

        * *spacing* (PDB_STRING)-The font spacing, "*" for any

     *Outputs*
        * *text_layer* (PDB_LAYER)-The new text layer
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_text_get_extents TEXT, SIZE, SIZE_TYPE, FOUNDRY,
          FAMILY, WEIGHT, SLANT, SET_WIDTH, SPACING
     This tool returns the width and height of a bounding box for the
     specified text string with the specified font information.  Ascent
     and descent for the specified font are returned as well.-*Internal
     GIMP procedure*

     *Inputs*
        * *text* (PDB_STRING)-The text to generate

        * *size* (PDB_FLOAT)-The size of text in either pixels or points

        * *size_type* (PDB_INT32)-The units of the specified size: {
          PIXELS (0), POINTS (1) }

        * *foundry* (PDB_STRING)-The font foundry, "*" for any

        * *family* (PDB_STRING)-The font family, "*" for any

        * *weight* (PDB_STRING)-The font weight, "*" for any

        * *slant* (PDB_STRING)-The font slant, "*" for any

        * *set_width* (PDB_STRING)-The font set-width parameter, "*"
          for any

        * *spacing* (PDB_STRING)-The font spacing, "*" for any

     *Outputs*
        * *width* (PDB_INT32)-The width of the specified text

        * *height* (PDB_INT32)-The height of the specified text

        * *ascent* (PDB_INT32)-The ascent of the specified font

        * *descent* (PDB_INT32)-The descent of the specified font
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_threshold IMAGE, DRAWABLE, LOW_THRESHOLD,
          HIGH_THRESHOLD
     This procedures generates a threshold map of the specified
     drawable.  All pixels between the values of 'low_threshold' and
     'high_threshold' are replaced with white, and all other pixels
     with black.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The image

        * *drawable* (PDB_DRAWABLE)-The drawable

        * *low_threshold* (PDB_INT32)-The low threshold value: (0 <=
          low_threshold <= 255)

        * *high_threshold* (PDB_INT32)-The high threshold value: (0 <=
          high_threshold <= 255)
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_undo_push_group_end IMAGE
     This function must be called once for each undo_push_group call
     that is made.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The ID of the image in which to pop an
          undo group
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_undo_push_group_start IMAGE
     This function is used to start a group undo-necessary for
     logically combining two or more undo operations into a single
     operation.  This call must be used in conjunction with a
     'gimp_undo_push_group_end' call.-*Internal GIMP procedure*

     *Inputs*
        * *image* (PDB_IMAGE)-The ID of the image in which to pop an
          undo group
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_xcf_load DUMMY_PARAM, FILENAME, RAW_FILENAME
     The xcf file format has been designed specifically for loading and
     saving tiled and layered images in the GIMP. This procedure will
     load the specified file.-*Internal GIMP procedure*

     *Inputs*
        * *dummy_param* (PDB_INT32)-Dummy parameter

        * *filename* (PDB_STRING)-The name of the file to load

        * *raw_filename* (PDB_STRING)-The name of the file to load

     *Outputs*
        * *image* (PDB_IMAGE)-Output image
   *Spencer Kimball & Peter Mattis*

 - Function: gimp_xcf_save DUMMY_PARAM, IMAGE, DRAWABLE, FILENAME,
          RAW_FILENAME
     The xcf file format has been designed specifically for loading and
     saving tiled and layered images in the GIMP. This procedure will
     save the specified image in the xcf file format.-*Internal GIMP
     procedure*

     *Inputs*
        * *dummy_param* (PDB_INT32)-Dummy parameter

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Active drawable of input image

        * *filename* (PDB_STRING)-The name of the file to save the
          image in

        * *raw_filename* (PDB_STRING)-The name of the file to load
   *Spencer Kimball & Peter Mattis*

 - Function: hot RUN_MODE, IMAGE, DRAWABLE
     hot scans an image for pixels that will give unsafe values of
     chrominance or composite signale amplitude when encoded into an
     NTSC or PAL signal.  Three actions can be performed on these "hot"
     pixels. (0) reduce luminance, (1) reduce saturation, or (2)
     Blacken.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-The Image

        * *drawable* (PDB_DRAWABLE)-The Drawable
   *Eric L. Hernes, Alan Wm Paeth*

 - Function: pixelize RUN_MODE, IMAGE, DRAWABLE, PIXELWIDTH
     More help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *pixelwidth* (PDB_INT32)-Pixel width  (the decrease in
          resolution)
   *Spencer Kimball & Peter Mattis, Tracy Scott, Eiichi Takamori*

 - Function: plug_in_CML_explorer RUN_MODE, IMAGE, DRAWABLE
     Fix Me. Make an image of Coupled-Map Lattice-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (not used)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Shuji Narazaki (narazaki@InetQ.or.jp)*

 - Function: plug_in_autocrop RUN_MODE, IMAGE, DRAWABLE
     -*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Tim Newsome*

 - Function: plug_in_blinds RUN_MODE, IMAGE, DRAWABLE, ANGLE_DSP,
          NUMBER_OF_SEGMENTS, ORIENTATION
     More here later-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *angle_dsp* (PDB_INT32)-Angle of Displacement

        * *number_of_segments* (PDB_INT32)-Number of segments in blinds

        * *orientation* (PDB_INT32)-Orientation; 0 = Horizontal, 1 =
          Vertical
   *Andy Thomas*

 - Function: plug_in_blur RUN_MODE, IMAGE, DRAWABLE
     This function applies a 3x3 blurring convolution kernel to the
     specified drawable.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Spencer Kimball & Peter Mattis*

 - Function: plug_in_bump_map RUN_MODE, IMAGE, DRAWABLE, BUMP_MAP,
          AZIMUTH, ELEVATION, DEPTH, X_OFFSET, Y_OFFSET
     This plug-in uses the algorithm described by John Schlag, "Fast
     Embossing Effects on Raster Image Data" in Graphics GEMS IV (ISBN
     0-12-336155-9). It takes a grayscale image to be applied as a bump
     map to another image and produces a nice embossing effect.-*GIMP
     Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *bump_map* (PDB_DRAWABLE)-Bump map drawable

        * *azimuth* (PDB_FLOAT)-Azimuth

        * *elevation* (PDB_FLOAT)-Elevation

        * *depth* (PDB_INT32)-Depth

        * *x_offset* (PDB_INT32)-X offset

        * *y_offset* (PDB_INT32)-Y offset
   *Federico Mena Quintero*

 - Function: plug_in_c_astretch RUN_MODE, IMAGE, DRAWABLE
     This simple plug-in does an automatic contrast stretch.  For each
     channel in the image, it finds the minimum and maximum values...
     it uses those values to stretch the individual histograms to the
     full contrast range.  For some images it may do just what you
     want; for others it may be total crap :)-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Federico Mena Quintero*

 - Function: plug_in_checkerboard RUN_MODE, IMAGE, DRAWABLE,
          CHECK_MODE, CHECK_SIZE
     More here later-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *check_mode* (PDB_INT32)-Regular or Physcobilly

        * *check_size* (PDB_INT32)-Size of the checks
   *Brent Burton & the Edward Blevins*

 - Function: plug_in_cubism RUN_MODE, IMAGE, DRAWABLE, TILE_SIZE,
          TILE_SATURATION, BG_COLOR
     Help not yet written for this plug-in-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *tile_size* (PDB_FLOAT)-Average diameter of each tile (in
          pixels)

        * *tile_saturation* (PDB_FLOAT)-Expand tiles by this amount

        * *bg_color* (PDB_INT32)-Background color: { BLACK (0), BG (1) }
   *Spencer Kimball & Tracy Scott*

 - Function: plug_in_demo RUN_MODE, IMAGE, DRAWABLE
     Demo plug-in used to test plug-in abilities.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Spencer Kimball & Peter Mattis*

 - Function: plug_in_dgimp RUN_MODE
     More help here later-*GIMP Extension*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive
   *Spencer Kimball*

 - Function: plug_in_diffraction RUN_MODE, IMAGE, DRAWABLE, LAM_R,
          LAM_G, LAM_B, CONTOUR_R, CONTOUR_G, CONTOUR_B, EDGES_R,
          EDGES_G, EDGES_B, BRIGHTNESS, SCATTERING, POLARIZATION
     Help?  What help?  Real men do not need help :-)-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *lam_r* (PDB_FLOAT)-Light frequency (red)

        * *lam_g* (PDB_FLOAT)-Light frequency (green)

        * *lam_b* (PDB_FLOAT)-Light frequency (blue)

        * *contour_r* (PDB_FLOAT)-Number of contours (red)

        * *contour_g* (PDB_FLOAT)-Number of contours (green)

        * *contour_b* (PDB_FLOAT)-Number of contours (blue)

        * *edges_r* (PDB_FLOAT)-Number of sharp edges (red)

        * *edges_g* (PDB_FLOAT)-Number of sharp edges (green)

        * *edges_b* (PDB_FLOAT)-Number of sharp edges (blue)

        * *brightness* (PDB_FLOAT)-Brightness and shifting/fattening of
          contours

        * *scattering* (PDB_FLOAT)-Scattering (Speed vs. quality)

        * *polarization* (PDB_FLOAT)-Polarization
   *Federico Mena Quintero*

 - Function: plug_in_displace RUN_MODE, IMAGE, DRAWABLE, AMOUNT_X,
          AMOUNT_Y, DO_X, DO_Y, DISPLACE_MAP_X, DISPLACE_MAP_Y,
          DISPLACE_TYPE
     Displaces the contents of the specified drawable by the amounts
     specified by 'amount_x' and 'amount_y' multiplied by the intensity
     of corresponding pixels in the 'displace_map' drawables.  Both
     'displace_map' drawables must be of type GRAY_IMAGE for this
     operation to succeed.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *amount_x* (PDB_FLOAT)-Displace multiplier for X direction

        * *amount_y* (PDB_FLOAT)-Displace multiplier for Y direction

        * *do_x* (PDB_INT32)-Displace in X direction?

        * *do_y* (PDB_INT32)-Displace in Y direction?

        * *displace_map_x* (PDB_DRAWABLE)-Displacement map for X
          direction

        * *displace_map_y* (PDB_DRAWABLE)-Displacement map for Y
          direction

        * *displace_type* (PDB_INT32)-Edge behavior: { WRAP (0), SMEAR
          (1), BLACK (2) }
   *Stephen Robert Norris & (ported to 1.0 by) Spencer Kimball*

 - Function: plug_in_edge RUN_MODE, IMAGE, DRAWABLE, AMOUNT, WRAPMODE
     Perform edge detection on the contents of the specified drawable.
     Apply convolusion with 3x3 kernel (or it seems that). AMOUNT is an
     arbitrary constant, WRAPMODE is like displace plug-in (useful for
     tilable image). -*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *amount* (PDB_FLOAT)-Edge detection amount

        * *wrapmode* (PDB_INT32)-Edge detection behavior: { WRAP (0),
          SMEAR (1), BLACK (2) }
   *Peter Mattis & (ported to 1.0 by) Eiichi Takamori*

 - Function: plug_in_emboss RUN_MODE, IMG, DRW, AZIMUTH, ELEVATION,
          DEPTH, EMBOSSP
     Emboss or Bumpmap the given drawable, specifying the angle and
     elevation for the light source.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *img* (PDB_IMAGE)-The Image

        * *drw* (PDB_DRAWABLE)-The Drawable

        * *azimuth* (PDB_FLOAT)-The Light Angle (degrees)

        * *elevation* (PDB_FLOAT)-The Elevation Angle (degrees)

        * *depth* (PDB_INT32)-The Filter Width

        * *embossp* (PDB_INT32)-Emboss or Bumpmap
   *Eric L. Hernes, John Schlag*

 - Function: plug_in_figures RUN_MODE, IMAGE, DRAWABLE, DENSITY,
          MIN_WIDTH, MAX_WIDTH, MIN_HEIGHT, MAX_HEIGHT
     Can be nice to use as "textures".-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *density* (PDB_FLOAT)-Density

        * *min_width* (PDB_INT32)-Min. width

        * *max_width* (PDB_INT32)-Max. width

        * *min_height* (PDB_INT32)-Min. height

        * *max_height* (PDB_INT32)-Max. height
   *Tim Newsome*

 - Function: plug_in_gauss_iir RUN_MODE, IMAGE, DRAWABLE, RADIUS,
          HORIZONTAL, VERTICAL
     Applies a gaussian blur to the drawable, with specified radius of
     affect.  The standard deviation of the normal distribution used to
     modify pixel values is calculated based on the supplied radius.
     Horizontal and vertical blurring can be independently invoked by
     specifying only one to run.  The IIR gaussian blurring works best
     for large radius values and for images which are not
     computer-generated.  Values for radius less than 1.0 are invalid
     as they will generate spurious results.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *radius* (PDB_FLOAT)-Radius of gaussian blur (in pixels > 1.0)

        * *horizontal* (PDB_INT32)-Blur in horizontal direction

        * *vertical* (PDB_INT32)-Blur in vertical direction
   *Spencer Kimball & Peter Mattis*

 - Function: plug_in_gauss_rle RUN_MODE, IMAGE, DRAWABLE, RADIUS,
          HORIZONTAL, VERTICAL
     Applies a gaussian blur to the drawable, with specified radius of
     affect.  The standard deviation of the normal distribution used to
     modify pixel values is calculated based on the supplied radius.
     Horizontal and vertical blurring can be independently invoked by
     specifying only one to run.  The RLE gaussian blurring performs
     most efficiently on computer-generated images or images with large
     areas of constant intensity.  Values for radii less than 1.0 are
     invalid as they will generate spurious results.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *radius* (PDB_FLOAT)-Radius of gaussian blur (in pixels > 1.0)

        * *horizontal* (PDB_INT32)-Blur in horizontal direction

        * *vertical* (PDB_INT32)-Blur in vertical direction
   *Spencer Kimball & Peter Mattis*

 - Function: plug_in_gradmap RUN_MODE, IMAGE, DRAWABLE
     This plug-in maps the contents of the specified drawable with the
     cusom gradient. Black becomes the leftmost color of the gradient,
     and white becomes the rightmost. Other intermediate colors become
     the related color of the gradient. Works on grayscale and RGB
     image with or without alpha channel.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Eiichi Takamori*

 - Function: plug_in_grid RUN_MODE, IMAGE, DRAWABLE, WIDTH, HEIGHT,
          X_OFFSET, Y_OFFSET
     -*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *width* (PDB_INT32)-Width

        * *height* (PDB_INT32)-Height

        * *x_offset* (PDB_INT32)-X Offset

        * *y_offset* (PDB_INT32)-Y Offset
   *Tim Newsome*

 - Function: plug_in_holes RUN_MODE, IMAGE, DRAWABLE, DENSITY, SHAPE,
          SIZE, FLAG
     makes holes in the alpha channel of an image, with a density
     depending on the actual transparency of this image. (so the image
     must have an alpha channel...)-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *density* (PDB_FLOAT)-Density (actually the log of the
          density)

        * *shape* (PDB_INT32)-Shape (0= square, 1= round, 2= diamond)

        * *size* (PDB_INT32)-Size (in pixels)

        * *flag* (PDB_INT32)-Clear it if you want to make holes in your
          image, or set it if you want to keep the painted (I mean
          opaque) regions.
   *Xavier Bouchoux*

 - Function: plug_in_ifs_compose RUN_MODE, IMAGE, DRAWABLE
     Interactively create an Iterated Function System fractal.Use the
     window on the upper left to adjust the componenttransformations of
     the fractal. The operation that is performedis selected by the
     buttons underneath the window, or from amenu popped up by the
     right mouse button. The fractal will berendered with a transparent
     background if the current image hasa transparent background.-*GIMP
     Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Owen Taylor*

 - Function: plug_in_laplace RUN_MODE, IMAGE, DRAWABLE
     This plugin creates one-pixel wide edges from the image, with the
     value proportional to the gradient. It uses the Laplace operator
     (a 3x3 kernel with -8 in the middle)The image has to be laplacered
     to get usefull results, a gauss_iir with 1.5 - 5.0 depending on
     the noise in the image is best-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Thorsten Schnier*

 - Function: plug_in_mosaic RUN_MODE, IMAGE, DRAWABLE, TILE_SIZE,
          TILE_HEIGHT, TILE_SPACING, TILE_NEATNESS, LIGHT_DIR,
          COLOR_VARIATION, ANTIALIASING, COLOR_AVERAGING, TILE_TYPE,
          TILE_SURFACE, GROUT_COLOR
     Help not yet written for this plug-in-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *tile_size* (PDB_FLOAT)-Average diameter of each tile (in
          pixels)

        * *tile_height* (PDB_FLOAT)-Apparent height of each tile (in
          pixels)

        * *tile_spacing* (PDB_FLOAT)-Inter-tile spacing (in pixels)

        * *tile_neatness* (PDB_FLOAT)-Deviation from perfectly formed
          tiles (0.0 - 1.0)

        * *light_dir* (PDB_FLOAT)-Direction of light-source (in degrees)

        * *color_variation* (PDB_FLOAT)-Magnitude of random color
          variations (0.0 - 1.0)

        * *antialiasing* (PDB_INT32)-Enables smoother tile output at
          the cost of speed

        * *color_averaging* (PDB_INT32)-Tile color based on average of
          subsumed pixels

        * *tile_type* (PDB_INT32)-Tile geometry: { SQUARES (0),
          HEXAGONS (1), OCTAGONS (2) }

        * *tile_surface* (PDB_INT32)-Surface characteristics: { SMOOTH
          (0), ROUGH (1) }

        * *grout_color* (PDB_INT32)-Grout color (black/white or
          fore/background): { BW (0), FG_BG (1) }
   *Spencer Kimball*

 - Function: plug_in_nlfilt RUN_MODE, IMG, DRW, ALPHA, RADIUS, FILTER
     This is the pnmnlfilt, in gimp's clothing.  See the pnmnlfilt
     manpage for details.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *img* (PDB_IMAGE)-The Image to Filter

        * *drw* (PDB_DRAWABLE)-The Drawable

        * *alpha* (PDB_FLOAT)-The amount of the filter to apply

        * *radius* (PDB_FLOAT)-The filter radius

        * *filter* (PDB_INT32)-The Filter to Run, 0 - alpha trimmed
          mean; 1 - optimal estimation (alpha controls noise variance);
          2 - edge enhancement
   *Graeme W. Gill, gimp 0.99 plugin by Eric L. Hernes*

 - Function: plug_in_noisify RUN_MODE, IMAGE, DRAWABLE, INDEPENDENT,
          NOISE_1, NOISE_2, NOISE_3, NOISE_4
     More here later-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *independent* (PDB_INT32)-Noise in channels independent

        * *noise_1* (PDB_FLOAT)-Noise in the first channel (red, gray)

        * *noise_2* (PDB_FLOAT)-Noise in the second channel (green,
          gray_alpha)

        * *noise_3* (PDB_FLOAT)-Noise in the third channel (blue)

        * *noise_4* (PDB_FLOAT)-Noise in the fourth channel (alpha)
   *Torsten Martinsen*

 - Function: plug_in_normalize RUN_MODE, IMAGE, DRAWABLE
     This plugin performs almost the same operation as the 'contrast
     autostretch' plugin, except that it won't allow the colour
     channels to normalize independently.  This is actually what most
     people probably want instead of contrast-autostretch; use c-a only
     if you wish to remove an undesirable colour-tint from a source
     image which is supposed to contain pure-white and
     pure-black.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Adam D. Moss, Federico Mena Quintero*

 - Function: plug_in_nova RUN_MODE, IMAGE, DRAWABLE, XCENTER, YCENTER,
          R, G, B, RADIUS
     This plug-in produces supernova effect which looks like a star
     light explosion. The amount of the light effect is approximately
     in proportion to 1/r, where r is the distance from the center of
     the star. In current version the light effect covers whole the
     image, which is a nuisance.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *xcenter* (PDB_INT32)-X coordinates of the center of supernova

        * *ycenter* (PDB_INT32)-Y coordinates of the center of supernova

        * *r* (PDB_INT32)-R value of Color of supernova

        * *g* (PDB_INT32)-G value of Color of supernova

        * *b* (PDB_INT32)-B value of Color of supernova

        * *radius* (PDB_INT32)-Radius of supernova
   *Eiichi Takamori*

 - Function: plug_in_oilify RUN_MODE, IMAGE, DRAWABLE, MASK_SIZE
     This function performs the well-known oil-paint effect on the
     specified drawable.  The size of the input mask is specified by
     'mask_size'.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *mask_size* (PDB_INT32)-Oil paint mask size
   *Torsten Martinsen*

 - Function: plug_in_plasma RUN_MODE, IMAGE, DRAWABLE, SEED, TURBULENCE
     More help-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *seed* (PDB_INT32)-Random seed

        * *turbulence* (PDB_FLOAT)-Turbulence of plasma
   *Stephen Norris & (ported to 1.0 by) Eiichi Takamori*

 - Function: plug_in_ripple RUN_MODE, IMAGE, DRAWABLE, PERIOD,
          AMPLITUDE, ORIENTATION, EDGES, WAVEFORM, ANTIALIAS, TILE
     Ripples the pixels of the specified drawable. Each row or colum
     will be displaced a certain number of pixels coinciding with the
     given wave form-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *period* (PDB_INT32)-Period; number of pixels for one wave to
          complete

        * *amplitude* (PDB_INT32)-Amplitude; maximum displacement of
          wave

        * *orientation* (PDB_INT32)-Orientation; 0 = Horizontal, 1 =
          Vertical

        * *edges* (PDB_INT32)-Edges; 0 = smear, 1 =  wrap, 2 = black

        * *waveform* (PDB_INT32)-0 = sawtooth, 1 = sine wave

        * *antialias* (PDB_INT32)-Antialias; True or False

        * *tile* (PDB_INT32)-Tile; if this is true, the image will
          retain it's tilability
   *Brian Degenhardt <bdegenha@ucsd.edu>*

 - Function: plug_in_shift RUN_MODE, IMAGE, DRAWABLE, SHIFT_AMOUNT,
          ORIENTATION
     Shifts the pixels of the specified drawable. Each row will be
     displaced a random value of pixels.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *shift_amount* (PDB_INT32)-Shift amount (0 <= shift_amount_x
          <= 200)

        * *orientation* (PDB_INT32)-Vertical, horizontal orientation
   *Spencer Kimball and Peter Mattis, ported by Brian Degenhardt and
Federico Mena Quintero*

 - Function: plug_in_sobel RUN_MODE, IMAGE, DRAWABLE, HORIZONTAL,
          VERTICAL, KEEP_SIGN
     This plugin calculates the gradient with a sobel operator. The
     user can specify which direction to use. When both directions are
     used, the result is the RMS of the two gradients; if only one
     direction is used, the result either the absolut value of the
     gradient, or 127 + gradient (if the 'keep sign' switch is on).
     This way, information about the direction of the gradient is
     preserved. Resulting images are not autoscaled.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *horizontal* (PDB_INT32)-Sobel in horizontal direction

        * *vertical* (PDB_INT32)-Sobel in vertical direction

        * *keep_sign* (PDB_INT32)-Keep sign of result (one direction
          only)
   *Thorsten Schnier*

 - Function: plug_in_solid_noise RUN_MODE, IMAGE, DRAWABLE, TILABLE,
          TURBULENT, SEED, DETAIL, XSCALE, YSCALE
     Generates textures using the classic Perlin's noise
     function.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *tilable* (PDB_INT32)-Create a tilable output (n/y)

        * *turbulent* (PDB_INT32)-Make a turbulent noise (n/y)

        * *seed* (PDB_INT32)-Random seed

        * *detail* (PDB_FLOAT)-Detail level

        * *xscale* (PDB_FLOAT)-Horizontal scaling factor

        * *yscale* (PDB_FLOAT)-Vertical scaling factor
   *Marcelo de Gomensoro Malheiros*

 - Function: plug_in_sparkle RUN_MODE, IMAGE, DRAWABLE, LUM_THRESHOLD,
          FLARE_INTEN, SPIKE_LEN, SPIKE_PTS, SPIKE_ANGLE
     More here later-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *lum_threshold* (PDB_FLOAT)-Luminosity threshold (0.0 - 1.0)

        * *flare_inten* (PDB_FLOAT)-Flare intensity (0.0 - 1.0)

        * *spike_len* (PDB_FLOAT)-Spike length (in pixels)

        * *spike_pts* (PDB_INT32)-# of spike points

        * *spike_angle* (PDB_FLOAT)-Spike angle (0.0-360.0 degrees)
   *John Beale, & (ported to GIMP v0.54) Michael J. Hammel & (ported to
GIMP v1.0) Spencer Kimball*

 - Function: plug_in_spread RUN_MODE, IMAGE, DRAWABLE, SPREAD_AMOUNT_X,
          SPREAD_AMOUNT_Y
     Spreads the pixels of the specified drawable.  Pixels are randomly
     moved to another location whose distance varies from the original
     by the horizontal and vertical spread amounts -*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *spread_amount_x* (PDB_FLOAT)-Horizontal spread amount (0 <=
          spread_amount_x <= 200)

        * *spread_amount_y* (PDB_FLOAT)-Vertical spread amount (0 <=
          spread_amount_y <= 200)
   *Spencer Kimball and Peter Mattis, ported by Brian Degenhardt and
Federico Mena Quintero*

 - Function: plug_in_tile RUN_MODE, IMAGE, DRAWABLE, NEW_WIDTH,
          NEW_HEIGHT, NEW_IMAGE
     This function creates a new image with a single layer sized to the
     specified 'new_width' and 'new_height' parameters.  The specified
     drawable is tiled into this layer.  The new layer will have the
     same type as the specified drawable and the new image will have a
     corresponding base type-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *new_width* (PDB_INT32)-New (tiled) image width

        * *new_height* (PDB_INT32)-New (tiled) image height

        * *new_image* (PDB_INT32)-Create a new image?

     *Outputs*
        * *new_image* (PDB_IMAGE)-Output image (N/A if new_image ==
          TRUE)

        * *new_layer* (PDB_IMAGE)-Output layer (N/A if new_image ==
          TRUE)
   *Spencer Kimball & Peter Mattis*

 - Function: plug_in_video RUN_MODE, IMAGE, DRAWABLE, PATTERN_NUMBER,
          ADDITIVE, ROTATED
     This function simulates the degradation of being on an old
     low-dotpitch RGB video monitor to the specified drawable.-*GIMP
     Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (unused)

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *pattern_number* (PDB_INT32)-Type of RGB pattern to use

        * *additive* (PDB_INT32)-Whether the function adds the result
          to the original image

        * *rotated* (PDB_INT32)-Whether to rotate the RGB pattern by
          ninety degrees
   *Adam D. Moss (adam@foxbox.org)*

 - Function: plug_in_vinvert RUN_MODE, IMAGE, DRAWABLE
     This function takes an indexed/RGB image and inverts its 'value'
     in HSV space.  The upshot of this is that the colour and
     saturation at any given point remains the same, but its brightness
     is effectively inverted.  Quite strange.  Tends to produce
     unpleasant colour artifacts on images from lossy sources (ie.
     JPEG).-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image (used for indexed images)

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Adam D. Moss (adam@foxbox.org)*

 - Function: plug_in_waves RUN_MODE, IMAGE, DRAWABLE, AMPLITUDE, PHASE,
          WAVELENGTH, TYPE
     none yet-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-The Image

        * *drawable* (PDB_DRAWABLE)-The Drawable

        * *amplitude* (PDB_FLOAT)-The Amplitude of the Waves

        * *phase* (PDB_FLOAT)-The Phase of the Waves

        * *wavelength* (PDB_FLOAT)-The Wavelength of the Waves

        * *type* (PDB_INT32)-Type of waves, black/smeared
   *Eric L. Hernes, Stephen Norris*

 - Function: plug_in_whirl_pinch RUN_MODE, IMAGE, DRAWABLE, WHIRL,
          PINCH, RADIUS
     Distorts the image by whirling and pinching, which are two common
     center-based, circular distortions.  Whirling is like projecting
     the image onto the surface of water in a toilet and flushing.
     Pinching is similar to projecting the image onto an elastic
     surface and pressing or pulling on the center of the
     surface.-*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable

        * *whirl* (PDB_FLOAT)-Whirl angle (degrees)

        * *pinch* (PDB_FLOAT)-Pinch amount

        * *radius* (PDB_FLOAT)-Radius (1.0 is the largest circle that
          fits in the image, and 2.0 goes all the way to the corners)
   *Federico Mena Quintero and Scott Goehring*

 - Function: plug_in_zealouscrop RUN_MODE, IMAGE, DRAWABLE
     -*GIMP Plug-In*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input image

        * *drawable* (PDB_DRAWABLE)-Input drawable
   *Adam D. Moss*

 - Function: script-fu-alien-glow-logo RUN_MODE, VALUE, VALUE, VALUE,
          COLOR
     Create an X-Files-esque logo with the specified glow
     color-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Glow Color
   *Spencer Kimball*

 - Function: script-fu-basic1-logo RUN_MODE, VALUE, VALUE, VALUE,
          COLOR, COLOR
     Creates a simple logo with a drop shadow-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color

        * *color* (PDB_COLOR)-Text Color
   *Spencer Kimball*

 - Function: script-fu-basic2-logo RUN_MODE, VALUE, VALUE, VALUE,
          COLOR, COLOR
     Creates a simple logo with a shadow and a highlight-*Temporary
     Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color

        * *color* (PDB_COLOR)-Text Color
   *Spencer Kimball*

 - Function: script-fu-blended-logo RUN_MODE, VALUE, VALUE, VALUE,
          VALUE, COLOR, COLOR, COLOR, COLOR
     Creates logos with blended backgrounds, highlights, and
     shadows-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Blend Mode

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color

        * *color* (PDB_COLOR)-Text Color

        * *color* (PDB_COLOR)-Starting Blend

        * *color* (PDB_COLOR)-Ending Blend
   *Spencer Kimball*

 - Function: script-fu-carve-it RUN_MODE, IMAGE, DRAWABLE, DRAWABLE,
          TOGGLE
     Use the specified [GRAY] drawable as a stencil to carve from the
     specified image-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Mask Image

        * *drawable* (PDB_DRAWABLE)-Mask Drawable

        * *drawable* (PDB_DRAWABLE)-Image to Carve

        * *toggle* (PDB_INT32)-Carve White Areas
   *Spencer Kimball*

 - Function: script-fu-carved-logo RUN_MODE, VALUE, VALUE, VALUE,
          VALUE, TOGGLE
     Carve the text from the specified image.  The image will be
     automatically tiled to accomodate the rendered text string.  The
     "Carve Raised Text" parameter determines whether to carve the text
     itself, or around the text.-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *value* (PDB_STRING)-Background Img

        * *toggle* (PDB_INT32)-Carve Raised Text
   *Spencer Kimball*

 - Function: script-fu-chrome-logo RUN_MODE, VALUE, VALUE, VALUE, COLOR
     Somewhat simplistic, but cool chromed logos-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color
   *Spencer Kimball*

 - Function: script-fu-circle-logo RUN_MODE, VALUE, VALUE, VALUE,
          VALUE, VALUE, VALUE
     Render the specified text along the perimeter of a
     circle-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text

        * *value* (PDB_STRING)-Radius

        * *value* (PDB_STRING)-Family

        * *value* (PDB_STRING)-Font Size

        * *value* (PDB_STRING)-Slant

        * *value* (PDB_STRING)-Antialias(0,1)
   *Shuji Narazaki (narazaki@InetQ.or.jp)*

 - Function: script-fu-clothify RUN_MODE, IMAGE, DRAWABLE, VALUE,
          VALUE, VALUE, VALUE, VALUE
     Render the specified text along the perimeter of a
     circle-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Input Image

        * *drawable* (PDB_DRAWABLE)-Input Drawable

        * *value* (PDB_STRING)-X Blur

        * *value* (PDB_STRING)-Y Blur

        * *value* (PDB_STRING)-Azimuth

        * *value* (PDB_STRING)-Elevation

        * *value* (PDB_STRING)-Depth
   *Tim Newsome <drz@froody.bloke.com>*

 - Function: script-fu-cool-metal-logo RUN_MODE, VALUE, VALUE, VALUE,
          COLOR, TOGGLE
     Metallic logos with reflections and perspective shadows-*Temporary
     Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color

        * *toggle* (PDB_INT32)-Seascape
   *Spencer Kimball & Rob Malda*

 - Function: script-fu-crystal-logo RUN_MODE, VALUE, VALUE, VALUE,
          VALUE, VALUE, VALUE
     Crystal/Gel effect which displaces the image underneath-*Temporary
     Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Chrome Factor

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *value* (PDB_STRING)-Background Img

        * *value* (PDB_STRING)-Environment Map
   *Spencer Kimball*

 - Function: script-fu-font-map RUN_MODE, VALUE, VALUE, VALUE
     Generate a listing of the specified fonts-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Fonts

        * *value* (PDB_STRING)-Font Size

        * *value* (PDB_STRING)-Border
   *Spencer Kimball*

 - Function: script-fu-frosty-logo RUN_MODE, VALUE, VALUE, VALUE, COLOR
     Frozen logos with drop shadows-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color
   *Spencer Kimball & Ed Mackey*

 - Function: script-fu-glowing-logo RUN_MODE, VALUE, VALUE, VALUE, COLOR
     Glowing hot logos-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color
   *Spencer Kimball*

 - Function: script-fu-gradient-example RUN_MODE, VALUE, VALUE
     Create an example image of a custom gradient-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Width

        * *value* (PDB_STRING)-Height
   *Federico Mena Quintero*

 - Function: script-fu-neon-logo RUN_MODE, VALUE, VALUE, VALUE, COLOR,
          COLOR, TOGGLE
     Neon logos-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color

        * *color* (PDB_COLOR)-Glow Color

        * *toggle* (PDB_INT32)-Create Shadow
   *Spencer Kimball*

 - Function: script-fu-ripply-anim RUN_MODE, IMAGE, DRAWABLE, VALUE,
          VALUE
     Ripple any image by creating animation frames as layers-*Temporary
     Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Image to Animage

        * *drawable* (PDB_DRAWABLE)-Drawable to Animate

        * *value* (PDB_STRING)-Rippling Strength

        * *value* (PDB_STRING)-Number of Frames
   *Adam D. Moss (adam@foxbox.org)*

 - Function: script-fu-sota-chrome-it RUN_MODE, IMAGE, DRAWABLE, VALUE,
          VALUE, VALUE, VALUE, COLOR, COLOR, TOGGLE
     Use the specified [GRAY] drawable as a stencil to run the chrome
     effect on.-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Chrome Image

        * *drawable* (PDB_DRAWABLE)-Chrome Mask

        * *value* (PDB_STRING)-Chrome Saturation

        * *value* (PDB_STRING)-Chrome Lightness

        * *value* (PDB_STRING)-Chrome Factor

        * *value* (PDB_STRING)-Environment Map

        * *color* (PDB_COLOR)-Highlight Balance

        * *color* (PDB_COLOR)-Chrome Balance

        * *toggle* (PDB_INT32)-Chrome White Areas
   *Spencer Kimball*

 - Function: script-fu-sota-chrome-logo RUN_MODE, VALUE, VALUE, VALUE,
          VALUE, VALUE, VALUE, VALUE, COLOR, COLOR
     State of the art chromed logos.-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Chrome Saturation

        * *value* (PDB_STRING)-Chrome Lightness

        * *value* (PDB_STRING)-Chrome Factor

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *value* (PDB_STRING)-Environment Map

        * *color* (PDB_COLOR)-Highlight Balance

        * *color* (PDB_COLOR)-Chrome Balance
   *Spencer Kimball*

 - Function: script-fu-sphere RUN_MODE, VALUE, VALUE, VALUE, COLOR,
          COLOR
     Simple spheres with drop shadows-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Radius (in pixels)

        * *value* (PDB_STRING)-Lighting (degrees)

        * *value* (PDB_STRING)-Shadow?

        * *color* (PDB_COLOR)-Background Color

        * *color* (PDB_COLOR)-Sphere Color
   *Spencer Kimball*

 - Function: script-fu-starburst-logo RUN_MODE, VALUE, VALUE, VALUE,
          COLOR, COLOR
     Starburst as inspired by GIMP News-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Burst Color

        * *color* (PDB_COLOR)-BG Color
   *Spencer Kimball & Xach Beane*

 - Function: script-fu-starscape-logo RUN_MODE, VALUE, VALUE, VALUE,
          COLOR
     Starscape using the Nova plug-in-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Glow Color
   *Spencer Kimball*

 - Function: script-fu-swirl-tile RUN_MODE, VALUE, VALUE, VALUE, VALUE,
          VALUE, VALUE, VALUE, VALUE, COLOR
     Create an interesting swirled tile-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Depth

        * *value* (PDB_STRING)-Azimuth

        * *value* (PDB_STRING)-Elevation

        * *value* (PDB_STRING)-Blur Radius

        * *value* (PDB_STRING)-Height

        * *value* (PDB_STRING)-Width

        * *value* (PDB_STRING)-Whirl Amount

        * *value* (PDB_STRING)-Roughness

        * *color* (PDB_COLOR)-Backgound Color
   *Adrian Likins <aklikins@eos.ncsu.edu>*

 - Function: script-fu-swirly-pattern RUN_MODE, VALUE, VALUE, VALUE
     Create a swirly pattern-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Quarter size

        * *value* (PDB_STRING)-Whirl angle

        * *value* (PDB_STRING)-Number of times to whirl
   *Federico Mena Quintero*

 - Function: script-fu-t-o-p-logo RUN_MODE, VALUE, VALUE, VALUE, VALUE,
          VALUE, VALUE, COLOR, COLOR
     Trace of Particles Effect-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *value* (PDB_STRING)-Hit Rate [0.0,1.0]

        * *value* (PDB_STRING)-Edge Width

        * *value* (PDB_STRING)-Edge Only [0/1]

        * *color* (PDB_COLOR)-Base Color

        * *color* (PDB_COLOR)-Background Color
   *Shuji Narazaki (narazaki@InetQ.or.jp)*

 - Function: script-fu-textured-logo RUN_MODE, VALUE, VALUE, VALUE,
          VALUE, VALUE, COLOR, COLOR, COLOR
     Creates textured logos with blended backgrounds, highlights, and
     shadows-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *value* (PDB_STRING)-Text Pattern

        * *value* (PDB_STRING)-Mosaic Tile Type

        * *value* (PDB_STRING)-Text String

        * *value* (PDB_STRING)-Font Size (in pixels)

        * *value* (PDB_STRING)-Font

        * *color* (PDB_COLOR)-Background Color

        * *color* (PDB_COLOR)-Starting Blend

        * *color* (PDB_COLOR)-Ending Blend
   *Spencer Kimball*

 - Function: script-fu-weave RUN_MODE, IMAGE, DRAWABLE, VALUE, VALUE,
          VALUE, VALUE, VALUE, VALUE, VALUE
     Weave effect a la Alien Skin-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-Interactive, non-interactive

        * *image* (PDB_IMAGE)-Image to weave

        * *drawable* (PDB_DRAWABLE)-Drawable to weave

        * *value* (PDB_STRING)-Ribbon width

        * *value* (PDB_STRING)-Ribbon spacing

        * *value* (PDB_STRING)-Shadow darkness

        * *value* (PDB_STRING)-Shadow depth

        * *value* (PDB_STRING)-Thread length

        * *value* (PDB_STRING)-Thread density

        * *value* (PDB_STRING)-Thread intensity
   *Federico Mena Quintero*

 - Function: script_fu_refresh RUN_MODE
     Re-read all available scripts-*Temporary Procedure*

     *Inputs*
        * *run_mode* (PDB_INT32)-[Interactive], non-interactive
   *Spencer Kimball & Peter Mattis*


