GIMP Library Reference Manual
<<< Previous Page | Home | Up | Next Page >>>

# gimp

## Name

gimp --

## Synopsis

    #define     GIMPVAR
    struct      GPlugInInfo;
    struct      GTile;
    struct      GDrawable;
    struct      GPixelRgn;
    struct      GParamDef;
    struct      GParamColor;
    struct      GParamRegion;
    struct      GParam;
    void        (*GRunProc)                     (char *name,
                                                 int nparams,
                                                 GParam *param,
                                                 int *nreturn_vals,
                                                 GParam **return_vals);
    union       GParamData;
    #define     MAIN                            ()
    int         gimp_main                       (int argc,
                                                 char *argv[]);
    void        gimp_set_data                   (gchar *id,
                                                 gpointer data,
                                                 guint32 length);
    void        gimp_get_data                   (gchar *id,
                                                 gpointer data);
    guint32     gimp_get_data_size              (gchar *id);
    void        gimp_progress_init              (char *message);
    void        gimp_progress_update            (gdouble percentage);
    gint32      gimp_default_display            (void);
    void        gimp_message                    (const gchar *message);
    void        gimp_query_database             (char *name_regexp,
                                                 char *blurb_regexp,
                                                 char *help_regexp,
                                                 char *author_regexp,
                                                 char *copyright_regexp,
                                                 char *date_regexp,
                                                 char *proc_type_regexp,
                                                 int *nprocs,
                                                 char ***proc_names);
    gint        gimp_query_procedure            (char *proc_name,
                                                 char **proc_blurb,
                                                 char **proc_help,
                                                 char **proc_author,
                                                 char **proc_copyright,
                                                 char **proc_date,
                                                 int *proc_type,
                                                 int *nparams,
                                                 int *nreturn_vals,
                                                 GParamDef **params,
                                                 GParamDef **return_vals);
    gint32*     gimp_query_images               (int *nimages);
    void        gimp_install_procedure          (char *name,
                                                 char *blurb,
                                                 char *help,
                                                 char *author,
                                                 char *copyright,
                                                 char *date,
                                                 char *menu_path,
                                                 char *image_types,
                                                 int type,
                                                 int nparams,
                                                 int nreturn_vals,
                                                 GParamDef *params,
                                                 GParamDef *return_vals);
    void        gimp_install_temp_proc          (char *name,
                                                 char *blurb,
                                                 char *help,
                                                 char *author,
                                                 char *copyright,
                                                 char *date,
                                                 char *menu_path,
                                                 char *image_types,
                                                 int type,
                                                 int nparams,
                                                 int nreturn_vals,
                                                 GParamDef *params,
                                                 GParamDef *return_vals,
                                                 GRunProc run_proc);
    void        gimp_uninstall_temp_proc        (char *name);
    void        gimp_register_magic_load_handler
                                                (char *name,
                                                 char *extensions,
                                                 char *prefixes,
                                                 char *magics);
    void        gimp_register_load_handler      (char *name,
                                                 char *extensions,
                                                 char *prefixes);
    void        gimp_register_save_handler      (char *name,
                                                 char *extensions,
                                                 char *prefixes);
    GParam*     gimp_run_procedure              (char *name,
                                                 int *nreturn_vals,
                                                 ...);
    GParam*     gimp_run_procedure2             (char *name,
                                                 int *nreturn_vals,
                                                 int nparams,
                                                 GParam *params);
    void        gimp_destroy_params             (GParam *params,
                                                 int nparams);
    void        gimp_destroy_paramdefs          (GParamDef *paramdefs,
                                                 int nparams);
    gdouble     gimp_gamma                      (void);
    gint        gimp_install_cmap               (void);
    gint        gimp_use_xshm                   (void);
    guchar*     gimp_color_cube                 (void);
    void        gimp_request_wakeups            (void);
    gint32      gimp_image_new                  (guint width,
                                                 guint height,
                                                 GImageType type);
    gint32      gimp_image_duplicate            (gint32 image_ID);
    void        gimp_image_delete               (gint32 image_ID);
    guint       gimp_image_width                (gint32 image_ID);
    guint       gimp_image_height               (gint32 image_ID);
    GImageType  gimp_image_base_type            (gint32 image_ID);
    gint32      gimp_image_floating_selection   (gint32 image_ID);
    void        gimp_image_add_channel          (gint32 image_ID,
                                                 gint32 channel_ID,
                                                 gint position);
    void        gimp_image_add_layer            (gint32 image_ID,
                                                 gint32 layer_ID,
                                                 gint position);
    void        gimp_image_add_layer_mask       (gint32 image_ID,
                                                 gint32 layer_ID,
                                                 gint32 mask_ID);
    void        gimp_image_clean_all            (gint32 image_ID);
    void        gimp_image_undo_disable         (gint32 image_ID);
    void        gimp_image_undo_enable          (gint32 image_ID);
    void        gimp_image_undo_freeze          (gint32 image_ID);
    void        gimp_image_undo_thaw            (gint32 image_ID);
    void        gimp_undo_push_group_start      (gint32 image_ID);
    void        gimp_undo_push_group_end        (gint32 image_ID);
    gint32      gimp_image_flatten              (gint32 image_ID);
    void        gimp_image_lower_channel        (gint32 image_ID,
                                                 gint32 channel_ID);
    void        gimp_image_lower_layer          (gint32 image_ID,
                                                 gint32 layer_ID);
    gint32      gimp_image_merge_visible_layers (gint32 image_ID,
                                                 GimpMergeType merge_type);
    gint32      gimp_image_pick_correlate_layer (gint32 image_ID,
                                                 gint x,
                                                 gint y);
    void        gimp_image_raise_channel        (gint32 image_ID,
                                                 gint32 channel_ID);
    void        gimp_image_raise_layer          (gint32 image_ID,
                                                 gint32 layer_ID);
    void        gimp_image_remove_channel       (gint32 image_ID,
                                                 gint32 channel_ID);
    void        gimp_image_remove_layer         (gint32 image_ID,
                                                 gint32 layer_ID);
    void        gimp_image_remove_layer_mask    (gint32 image_ID,
                                                 gint32 layer_ID,
                                                 gint mode);
    void        gimp_image_resize               (gint32 image_ID,
                                                 guint new_width,
                                                 guint new_height,
                                                 gint offset_x,
                                                 gint offset_y);
    gint32      gimp_image_get_active_channel   (gint32 image_ID);
    gint32      gimp_image_get_active_layer     (gint32 image_ID);
    gint32*     gimp_image_get_channels         (gint32 image_ID,
                                                 gint *nchannels);
    guchar*     gimp_image_get_cmap             (gint32 image_ID,
                                                 gint *ncolors);
    gint        gimp_image_get_component_active (gint32 image_ID,
                                                 gint component);
    gint        gimp_image_get_component_visible
                                                (gint32 image_ID,
                                                 gint component);
    char*       gimp_image_get_filename         (gint32 image_ID);
    gint32*     gimp_image_get_layers           (gint32 image_ID,
                                                 gint *nlayers);
    gint32      gimp_image_get_selection        (gint32 image_ID);
    void        gimp_image_set_active_channel   (gint32 image_ID,
                                                 gint32 channel_ID);
    void        gimp_image_set_active_layer     (gint32 image_ID,
                                                 gint32 layer_ID);
    void        gimp_image_set_cmap             (gint32 image_ID,
                                                 guchar *cmap,
                                                 gint ncolors);
    void        gimp_image_set_component_active (gint32 image_ID,
                                                 gint component,
                                                 gint active);
    void        gimp_image_set_component_visible
                                                (gint32 image_ID,
                                                 gint component,
                                                 gint visible);
    void        gimp_image_set_filename         (gint32 image_ID,
                                                 char *name);
    Parasite*   gimp_image_parasite_find        (gint32 image_ID,
                                                 const char *name);
    void        gimp_image_parasite_attach      (gint32 image_ID,
                                                 const Parasite *p);
    void        gimp_image_attach_new_parasite  (gint32 image_ID,
                                                 const char *name,
                                                 int flags,
                                                 int size,
                                                 const void *data);
    void        gimp_image_parasite_detach      (gint32 image_ID,
                                                 const char *name);
    void        gimp_image_set_resolution       (gint32 image_ID,
                                                 double xresolution,
                                                 double yresolution);
    void        gimp_image_get_resolution       (gint32 image_ID,
                                                 double *xresolution,
                                                 double *yresolution);
    void        gimp_image_set_unit             (gint32 image_ID,
                                                 GimpUnit unit);
    GimpUnit    gimp_image_get_unit             (gint32 image_ID);
    gint32      gimp_image_get_layer_by_tattoo  (gint32 image_ID,
                                                 gint32 tattoo);
    gint32      gimp_image_get_channel_by_tattoo
                                                (gint32 image_ID,
                                                 gint32 tattoo);
    guchar*     gimp_image_get_thumbnail_data   (gint32 image_ID,
                                                 gint *width,
                                                 gint *height,
                                                 gint *bytes);
    void        gimp_image_convert_rgb          (gint32 image_ID);
    void        gimp_image_convert_grayscale    (gint32 image_ID);
    void        gimp_image_convert_indexed      (gint32 image_ID,
                                                 GimpConvertDitherType dither_type,
                                                 GimpConvertPaletteType palette_type,
                                                 gint num_colors,
                                                 gint alpha_dither,
                                                 gint remove_unused,
                                                 gchar *palette);
    gint32      gimp_image_add_hguide           (gint32 image_ID,
                                                 gint32 yposition);
    gint32      gimp_image_add_vguide           (gint32 image_ID,
                                                 gint32 xposition);
    void        gimp_image_delete_guide         (gint32 image_ID,
                                                 gint32 guide_ID);
    gint32      gimp_image_find_next_guide      (gint32 image_ID,
                                                 gint32 guide_ID);
    GOrientation gimp_image_get_guide_orientation
                                                (gint32 image_ID,
                                                 gint32 guide_ID);
    gint32      gimp_image_get_guide_position   (gint32 image_ID,
                                                 gint32 guide_ID);
    gint32      gimp_display_new                (gint32 image_ID);
    void        gimp_display_delete             (gint32 display_ID);
    void        gimp_displays_flush             (void);
    gint32      gimp_layer_new                  (gint32 image_ID,
                                                 char *name,
                                                 guint width,
                                                 guint height,
                                                 GDrawableType type,
                                                 gdouble opacity,
                                                 GLayerMode mode);
    gint32      gimp_layer_copy                 (gint32 layer_ID);
    void        gimp_layer_delete               (gint32 layer_ID);
    guint       gimp_layer_width                (gint32 layer_ID);
    guint       gimp_layer_height               (gint32 layer_ID);
    guint       gimp_layer_bpp                  (gint32 layer_ID);
    GDrawableType gimp_layer_type               (gint32 layer_ID);
    void        gimp_layer_add_alpha            (gint32 layer_ID);
    gint32      gimp_layer_create_mask          (gint32 layer_ID,
                                                 GimpAddMaskType mask_type);
    void        gimp_layer_resize               (gint32 layer_ID,
                                                 guint new_width,
                                                 guint new_height,
                                                 gint offset_x,
                                                 gint offset_y);
    void        gimp_layer_scale                (gint32 layer_ID,
                                                 guint new_width,
                                                 guint new_height,
                                                 gint local_origin);
    void        gimp_layer_translate            (gint32 layer_ID,
                                                 gint offset_x,
                                                 gint offset_y);
    gint        gimp_layer_is_floating_selection
                                                (gint32 layer_ID);
    gint32      gimp_layer_get_image_id         (gint32 layer_ID);
    gint32      gimp_layer_get_mask_id          (gint32 layer_ID);
    gint        gimp_layer_get_apply_mask       (gint32 layer_ID);
    gint        gimp_layer_get_edit_mask        (gint32 layer_ID);
    GLayerMode  gimp_layer_get_mode             (gint32 layer_ID);
    char*       gimp_layer_get_name             (gint32 layer_ID);
    gdouble     gimp_layer_get_opacity          (gint32 layer_ID);
    gint        gimp_layer_get_preserve_transparency
                                                (gint32 layer_ID);
    gint        gimp_layer_get_show_mask        (gint32 layer_ID);
    gint        gimp_layer_get_visible          (gint32 layer_ID);
    void        gimp_layer_set_apply_mask       (gint32 layer_ID,
                                                 gint apply_mask);
    void        gimp_layer_set_edit_mask        (gint32 layer_ID,
                                                 gint edit_mask);
    void        gimp_layer_set_mode             (gint32 layer_ID,
                                                 GLayerMode mode);
    void        gimp_layer_set_name             (gint32 layer_ID,
                                                 char *name);
    void        gimp_layer_set_offsets          (gint32 layer_ID,
                                                 gint offset_x,
                                                 gint offset_y);
    void        gimp_layer_set_opacity          (gint32 layer_ID,
                                                 gdouble opacity);
    void        gimp_layer_set_preserve_transparency
                                                (gint32 layer_ID,
                                                 gint preserve_transparency);
    void        gimp_layer_set_show_mask        (gint32 layer_ID,
                                                 gint show_mask);
    void        gimp_layer_set_visible          (gint32 layer_ID,
                                                 gint visible);
    gint32      gimp_layer_get_tattoo           (gint32 layer_ID);
    gint32      gimp_channel_new                (gint32 image_ID,
                                                 char *name,
                                                 guint width,
                                                 guint height,
                                                 gdouble opacity,
                                                 guchar *color);
    gint32      gimp_channel_copy               (gint32 channel_ID);
    void        gimp_channel_delete             (gint32 channel_ID);
    guint       gimp_channel_width              (gint32 channel_ID);
    guint       gimp_channel_height             (gint32 channel_ID);
    gint32      gimp_channel_get_image_id       (gint32 channel_ID);
    gint32      gimp_channel_get_layer_id       (gint32 channel_ID);
    void        gimp_channel_get_color          (gint32 channel_ID,
                                                 guchar *red,
                                                 guchar *green,
                                                 guchar *blue);
    char*       gimp_channel_get_name           (gint32 channel_ID);
    gdouble     gimp_channel_get_opacity        (gint32 channel_ID);
    gint        gimp_channel_get_show_masked    (gint32 channel_ID);
    gint        gimp_channel_get_visible        (gint32 channel_ID);
    void        gimp_channel_set_color          (gint32 channel_ID,
                                                 guchar red,
                                                 guchar green,
                                                 guchar blue);
    void        gimp_channel_set_name           (gint32 channel_ID,
                                                 char *name);
    void        gimp_channel_set_opacity        (gint32 channel_ID,
                                                 gdouble opacity);
    void        gimp_channel_set_show_masked    (gint32 channel_ID,
                                                 gint show_masked);
    void        gimp_channel_set_visible        (gint32 channel_ID,
                                                 gint visible);
    gint32      gimp_channel_get_tattoo         (gint32 channel_ID);
    GDrawable*  gimp_drawable_get               (gint32 drawable_ID);
    void        gimp_drawable_detach            (GDrawable *drawable);
    void        gimp_drawable_flush             (GDrawable *drawable);
    void        gimp_drawable_delete            (GDrawable *drawable);
    void        gimp_drawable_update            (gint32 drawable_ID,
                                                 gint x,
                                                 gint y,
                                                 guint width,
                                                 guint height);
    void        gimp_drawable_merge_shadow      (gint32 drawable_ID,
                                                 gint undoable);
    gint32      gimp_drawable_image_id          (gint32 drawable_ID);
    char*       gimp_drawable_name              (gint32 drawable_ID);
    guint       gimp_drawable_width             (gint32 drawable_ID);
    guint       gimp_drawable_height            (gint32 drawable_ID);
    guint       gimp_drawable_bpp               (gint32 drawable_ID);
    GDrawableType gimp_drawable_type            (gint32 drawable_ID);
    gint        gimp_drawable_visible           (gint32 drawable_ID);
    gint        gimp_drawable_is_channel        (gint32 drawable_ID);
    gint        gimp_drawable_is_rgb            (gint32 drawable_ID);
    gint        gimp_drawable_is_gray           (gint32 drawable_ID);
    gint        gimp_drawable_has_alpha         (gint32 drawable_ID);
    gint        gimp_drawable_is_indexed        (gint32 drawable_ID);
    gint        gimp_drawable_is_layer          (gint32 drawable_ID);
    gint        gimp_drawable_is_layer_mask     (gint32 drawable_ID);
    gint        gimp_drawable_mask_bounds       (gint32 drawable_ID,
                                                 gint *x1,
                                                 gint *y1,
                                                 gint *x2,
                                                 gint *y2);
    void        gimp_drawable_offsets           (gint32 drawable_ID,
                                                 gint *offset_x,
                                                 gint *offset_y);
    void        gimp_drawable_fill              (gint32 drawable_ID,
                                                 GimpFillType fill_type);
    void        gimp_drawable_set_name          (gint32 drawable_ID,
                                                 char *name);
    void        gimp_drawable_set_visible       (gint32 drawable_ID,
                                                 gint visible);
    GTile*      gimp_drawable_get_tile          (GDrawable *drawable,
                                                 gint shadow,
                                                 gint row,
                                                 gint col);
    GTile*      gimp_drawable_get_tile2         (GDrawable *drawable,
                                                 gint shadow,
                                                 gint x,
                                                 gint y);
    Parasite*   gimp_drawable_parasite_find     (gint32 drawable,
                                                 const char *name);
    void        gimp_drawable_parasite_attach   (gint32 drawable,
                                                 const Parasite *p);
    void        gimp_drawable_attach_new_parasite
                                                (gint32 drawable,
                                                 const char *name,
                                                 int flags,
                                                 int size,
                                                 const void *data);
    void        gimp_drawable_parasite_detach   (gint32 drawable,
                                                 const char *name);
    guchar*     gimp_drawable_get_thumbnail_data
                                                (gint32 drawable_ID,
                                                 gint *width,
                                                 gint *height,
                                                 gint *bytes);
    gint32      gimp_selection_bounds           (gint32 image_ID,
                                                 gint32 *non_empty,
                                                 gint32 *x1,
                                                 gint32 *y1,
                                                 gint32 *x2,
                                                 gint32 *y2);
    gint32      gimp_selection_float            (gint32 image_ID,
                                                 gint32 drawable_ID,
                                                 gint32 x_offset,
                                                 gint32 y_offset);
    gint32      gimp_selection_is_empty         (gint32 image_ID);
    void        gimp_selection_none             (gint32 image_ID);
    void        gimp_tile_ref                   (GTile *tile);
    void        gimp_tile_ref_zero              (GTile *tile);
    void        gimp_tile_unref                 (GTile *tile,
                                                 int dirty);
    void        gimp_tile_flush                 (GTile *tile);
    void        gimp_tile_cache_size            (gulong kilobytes);
    void        gimp_tile_cache_ntiles          (gulong ntiles);
    guint       gimp_tile_width                 (void);
    guint       gimp_tile_height                (void);
    void        gimp_pixel_rgn_init             (GPixelRgn *pr,
                                                 GDrawable *drawable,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height,
                                                 int dirty,
                                                 int shadow);
    void        gimp_pixel_rgn_resize           (GPixelRgn *pr,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height);
    void        gimp_pixel_rgn_get_pixel        (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y);
    void        gimp_pixel_rgn_get_row          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width);
    void        gimp_pixel_rgn_get_col          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int height);
    void        gimp_pixel_rgn_get_rect         (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height);
    void        gimp_pixel_rgn_set_pixel        (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y);
    void        gimp_pixel_rgn_set_row          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width);
    void        gimp_pixel_rgn_set_col          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int height);
    void        gimp_pixel_rgn_set_rect         (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height);
    gpointer    gimp_pixel_rgns_register        (int nrgns,
                                                 ...);
    gpointer    gimp_pixel_rgns_register2       (int nrgns,
                                                 GPixelRgn **prs);
    gpointer    gimp_pixel_rgns_process         (gpointer pri_ptr);
    void        gimp_palette_get_background     (guchar *red,
                                                 guchar *green,
                                                 guchar *blue);
    void        gimp_palette_get_foreground     (guchar *red,
                                                 guchar *green,
                                                 guchar *blue);
    void        gimp_palette_set_background     (guchar red,
                                                 guchar green,
                                                 guchar blue);
    void        gimp_palette_set_foreground     (guchar red,
                                                 guchar green,
                                                 guchar blue);
    char**      gimp_gradients_get_list         (gint *num_gradients);
    char*       gimp_gradients_get_active       (void);
    void        gimp_gradients_set_active       (char *name);
    gdouble*    gimp_gradients_sample_uniform   (gint num_samples);
    gdouble*    gimp_gradients_sample_custom    (gint num_samples,
                                                 gdouble *positions);
    Parasite*   gimp_parasite_find              (const char *name);
    void        gimp_parasite_attach            (const Parasite *p);
    void        gimp_attach_new_parasite        (const char *name,
                                                 int flags,
                                                 int size,
                                                 const void *data);
    void        gimp_parasite_detach            (const char *name);
    void        gimp_plugin_help_func           (gchar *help_data);
    void        gimp_help                       (gchar *help_data);

## Description

## Details

### GIMPVAR

    #define     GIMPVAR

### struct GPlugInInfo

    struct GPlugInInfo
    {
      /* called when the gimp application initially starts up */
      void (*init_proc) (void);

      /* called when the gimp application exits */
      void (*quit_proc) (void);

      /* called by the gimp so that the plug-in can inform the
       *  gimp of what it does. (ie. installing a procedure database
       *  procedure).
       */
      void (*query_proc) (void);

      /* called to run a procedure the plug-in installed in the
       *  procedure database.
       */
      GRunProc run_proc;
    };

### struct GTile

    struct GTile
    {
      guint ewidth;        /* the effective width of the tile */
      guint eheight;       /* the effective height of the tile */
      guint bpp;           /* the bytes per pixel (1, 2, 3 or 4 ) */
      guint tile_num;      /* the number of this tile within the drawable */
      guint16 ref_count;   /* reference count for the tile */
      guint dirty : 1;     /* is the tile dirty? has it been modified? */
      guint shadow: 1;     /* is this a shadow tile */
      guchar *data;        /* the pixel data for the tile */
      GDrawable *drawable; /* the drawable this tile came from */
    };

### struct GDrawable

    struct GDrawable
    {
      gint32 id;            /* drawable ID */
      guint width;          /* width of drawble */
      guint height;         /* height of drawble */
      guint bpp;            /* bytes per pixel of drawable */
      guint ntile_rows;     /* # of tile rows */
      guint ntile_cols;     /* # of tile columns */
      GTile *tiles;         /* the normal tiles */
      GTile *shadow_tiles;  /* the shadow tiles */
    };

### struct GPixelRgn

    struct GPixelRgn
    {
      guchar *data;         /* pointer to region data */
      GDrawable *drawable;  /* pointer to drawable */
      guint bpp;            /* bytes per pixel */
      guint rowstride;      /* bytes per pixel row */
      guint x, y;           /* origin */
      guint w, h;           /* width and height of region */
      guint dirty : 1;      /* will this region be dirtied? */
      guint shadow : 1;     /* will this region use the shadow or normal tiles */
      guint process_count;  /* used internally */
    };

### struct GParamDef

    struct GParamDef
    {
      GParamType type;
      char *name;
      char *description;
    };

### struct GParamColor

    struct GParamColor
    {
      guint8 red;
      guint8 green;
      guint8 blue;
    };

### struct GParamRegion

    struct GParamRegion
    {
      gint32 x;
      gint32 y;
      gint32 width;
      gint32 height;
    };

### struct GParam

    struct GParam
    {
      GParamType type;
      GParamData data;
    };

### GRunProc ()

    void        (*GRunProc)                     (char *name,
                                                 int nparams,
                                                 GParam *param,
                                                 int *nreturn_vals,
                                                 GParam **return_vals);

`name` : |
`nparams` : |
`param` : |
`nreturn_vals` : |
`return_vals` : |

### union GParamData

    union GParamData
    {
      gint32 d_int32;
      gint16 d_int16;
      gint8 d_int8;
      gdouble d_float;
      gchar *d_string;
      gint32 *d_int32array;
      gint16 *d_int16array;
      gint8 *d_int8array;
      gdouble *d_floatarray;
      gchar **d_stringarray;
      GParamColor d_color;
      GParamRegion d_region;
      gint32 d_display;
      gint32 d_image;
      gint32 d_layer;
      gint32 d_channel;
      gint32 d_drawable;
      gint32 d_selection;
      gint32 d_boundary;
      gint32 d_path;
      Parasite d_parasite;
      gint32 d_status;
    };

### MAIN()

    #define     MAIN()

### gimp_main ()

    int         gimp_main                       (int argc,
                                                 char *argv[]);

`argc` : |
`argv` : |
Returns : |

### gimp_set_data ()

    void        gimp_set_data                   (gchar *id,
                                                 gpointer data,
                                                 guint32 length);

`id` : |
`data` : |
`length` : |

### gimp_get_data ()

    void        gimp_get_data                   (gchar *id,
                                                 gpointer data);

`id` : |
`data` : |

### gimp_get_data_size ()

    guint32     gimp_get_data_size              (gchar *id);

`id` : |
Returns : |

### gimp_progress_init ()

    void        gimp_progress_init              (char *message);

`message` : |

### gimp_progress_update ()

    void        gimp_progress_update            (gdouble percentage);

`percentage` : |

### gimp_default_display ()

    gint32      gimp_default_display            (void);

Returns : |

### gimp_message ()

    void        gimp_message                    (const gchar *message);

`message` : |

### gimp_query_database ()

    void        gimp_query_database             (char *name_regexp,
                                                 char *blurb_regexp,
                                                 char *help_regexp,
                                                 char *author_regexp,
                                                 char *copyright_regexp,
                                                 char *date_regexp,
                                                 char *proc_type_regexp,
                                                 int *nprocs,
                                                 char ***proc_names);

`name_regexp` : |
`blurb_regexp` : |
`help_regexp` : |
`author_regexp` : |
`copyright_regexp` : |
`date_regexp` : |
`proc_type_regexp` : |
`nprocs` : |
`proc_names` : |

### gimp_query_procedure ()

    gint        gimp_query_procedure            (char *proc_name,
                                                 char **proc_blurb,
                                                 char **proc_help,
                                                 char **proc_author,
                                                 char **proc_copyright,
                                                 char **proc_date,
                                                 int *proc_type,
                                                 int *nparams,
                                                 int *nreturn_vals,
                                                 GParamDef **params,
                                                 GParamDef **return_vals);

`proc_name` : |
`proc_blurb` : |
`proc_help` : |
`proc_author` : |
`proc_copyright` : |
`proc_date` : |
`proc_type` : |
`nparams` : |
`nreturn_vals` : |
`params` : |
`return_vals` : |
Returns : |

### gimp_query_images ()

    gint32*     gimp_query_images               (int *nimages);

`nimages` : |
Returns : |

### gimp_install_procedure ()

    void        gimp_install_procedure          (char *name,
                                                 char *blurb,
                                                 char *help,
                                                 char *author,
                                                 char *copyright,
                                                 char *date,
                                                 char *menu_path,
                                                 char *image_types,
                                                 int type,
                                                 int nparams,
                                                 int nreturn_vals,
                                                 GParamDef *params,
                                                 GParamDef *return_vals);

`name` : |
`blurb` : |
`help` : |
`author` : |
`copyright` : |
`date` : |
`menu_path` : |
`image_types` : |
`type` : |
`nparams` : |
`nreturn_vals` : |
`params` : |
`return_vals` : |

### gimp_install_temp_proc ()

    void        gimp_install_temp_proc          (char *name,
                                                 char *blurb,
                                                 char *help,
                                                 char *author,
                                                 char *copyright,
                                                 char *date,
                                                 char *menu_path,
                                                 char *image_types,
                                                 int type,
                                                 int nparams,
                                                 int nreturn_vals,
                                                 GParamDef *params,
                                                 GParamDef *return_vals,
                                                 GRunProc run_proc);

`name` : |
`blurb` : |
`help` : |
`author` : |
`copyright` : |
`date` : |
`menu_path` : |
`image_types` : |
`type` : |
`nparams` : |
`nreturn_vals` : |
`params` : |
`return_vals` : |
`run_proc` : |

### gimp_uninstall_temp_proc ()

    void        gimp_uninstall_temp_proc        (char *name);

`name` : |

### gimp_register_magic_load_handler ()

    void        gimp_register_magic_load_handler
                                                (char *name,
                                                 char *extensions,
                                                 char *prefixes,
                                                 char *magics);

`name` : |
`extensions` : |
`prefixes` : |
`magics` : |

### gimp_register_load_handler ()

    void        gimp_register_load_handler      (char *name,
                                                 char *extensions,
                                                 char *prefixes);

`name` : |
`extensions` : |
`prefixes` : |

### gimp_register_save_handler ()

    void        gimp_register_save_handler      (char *name,
                                                 char *extensions,
                                                 char *prefixes);

`name` : |
`extensions` : |
`prefixes` : |

### gimp_run_procedure ()

    GParam*     gimp_run_procedure              (char *name,
                                                 int *nreturn_vals,
                                                 ...);

`name` : |
`nreturn_vals` : |
`...` : |
Returns : |

### gimp_run_procedure2 ()

    GParam*     gimp_run_procedure2             (char *name,
                                                 int *nreturn_vals,
                                                 int nparams,
                                                 GParam *params);

`name` : |
`nreturn_vals` : |
`nparams` : |
`params` : |
Returns : |

### gimp_destroy_params ()

    void        gimp_destroy_params             (GParam *params,
                                                 int nparams);

`params` : |
`nparams` : |

### gimp_destroy_paramdefs ()

    void        gimp_destroy_paramdefs          (GParamDef *paramdefs,
                                                 int nparams);

`paramdefs` : |
`nparams` : |

### gimp_gamma ()

    gdouble     gimp_gamma                      (void);

Returns : |

### gimp_install_cmap ()

    gint        gimp_install_cmap               (void);

Returns : |

### gimp_use_xshm ()

    gint        gimp_use_xshm                   (void);

Returns : |

### gimp_color_cube ()

    guchar*     gimp_color_cube                 (void);

Returns : |

### gimp_request_wakeups ()

    void        gimp_request_wakeups            (void);

### gimp_image_new ()

    gint32      gimp_image_new                  (guint width,
                                                 guint height,
                                                 GImageType type);

`width` : |
`height` : |
`type` : |
Returns : |

### gimp_image_duplicate ()

    gint32      gimp_image_duplicate            (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_delete ()

    void        gimp_image_delete               (gint32 image_ID);

`image_ID` : |

### gimp_image_width ()

    guint       gimp_image_width                (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_height ()

    guint       gimp_image_height               (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_base_type ()

    GImageType  gimp_image_base_type            (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_floating_selection ()

    gint32      gimp_image_floating_selection   (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_add_channel ()

    void        gimp_image_add_channel          (gint32 image_ID,
                                                 gint32 channel_ID,
                                                 gint position);

`image_ID` : |
`channel_ID` : |
`position` : |

### gimp_image_add_layer ()

    void        gimp_image_add_layer            (gint32 image_ID,
                                                 gint32 layer_ID,
                                                 gint position);

`image_ID` : |
`layer_ID` : |
`position` : |

### gimp_image_add_layer_mask ()

    void        gimp_image_add_layer_mask       (gint32 image_ID,
                                                 gint32 layer_ID,
                                                 gint32 mask_ID);

`image_ID` : |
`layer_ID` : |
`mask_ID` : |

### gimp_image_clean_all ()

    void        gimp_image_clean_all            (gint32 image_ID);

`image_ID` : |

### gimp_image_undo_disable ()

    void        gimp_image_undo_disable         (gint32 image_ID);

`image_ID` : |

### gimp_image_undo_enable ()

    void        gimp_image_undo_enable          (gint32 image_ID);

`image_ID` : |

### gimp_image_undo_freeze ()

    void        gimp_image_undo_freeze          (gint32 image_ID);

`image_ID` : |

### gimp_image_undo_thaw ()

    void        gimp_image_undo_thaw            (gint32 image_ID);

`image_ID` : |

### gimp_undo_push_group_start ()

    void        gimp_undo_push_group_start      (gint32 image_ID);

`image_ID` : |

### gimp_undo_push_group_end ()

    void        gimp_undo_push_group_end        (gint32 image_ID);

`image_ID` : |

### gimp_image_flatten ()

    gint32      gimp_image_flatten              (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_lower_channel ()

    void        gimp_image_lower_channel        (gint32 image_ID,
                                                 gint32 channel_ID);

`image_ID` : |
`channel_ID` : |

### gimp_image_lower_layer ()

    void        gimp_image_lower_layer          (gint32 image_ID,
                                                 gint32 layer_ID);

`image_ID` : |
`layer_ID` : |

### gimp_image_merge_visible_layers ()

    gint32      gimp_image_merge_visible_layers (gint32 image_ID,
                                                 GimpMergeType merge_type);

`image_ID` : |
`merge_type` : |
Returns : |

### gimp_image_pick_correlate_layer ()

    gint32      gimp_image_pick_correlate_layer (gint32 image_ID,
                                                 gint x,
                                                 gint y);

`image_ID` : |
`x` : |
`y` : |
Returns : |

### gimp_image_raise_channel ()

    void        gimp_image_raise_channel        (gint32 image_ID,
                                                 gint32 channel_ID);

`image_ID` : |
`channel_ID` : |

### gimp_image_raise_layer ()

    void        gimp_image_raise_layer          (gint32 image_ID,
                                                 gint32 layer_ID);

`image_ID` : |
`layer_ID` : |

### gimp_image_remove_channel ()

    void        gimp_image_remove_channel       (gint32 image_ID,
                                                 gint32 channel_ID);

`image_ID` : |
`channel_ID` : |

### gimp_image_remove_layer ()

    void        gimp_image_remove_layer         (gint32 image_ID,
                                                 gint32 layer_ID);

`image_ID` : |
`layer_ID` : |

### gimp_image_remove_layer_mask ()

    void        gimp_image_remove_layer_mask    (gint32 image_ID,
                                                 gint32 layer_ID,
                                                 gint mode);

`image_ID` : |
`layer_ID` : |
`mode` : |

### gimp_image_resize ()

    void        gimp_image_resize               (gint32 image_ID,
                                                 guint new_width,
                                                 guint new_height,
                                                 gint offset_x,
                                                 gint offset_y);

`image_ID` : |
`new_width` : |
`new_height` : |
`offset_x` : |
`offset_y` : |

### gimp_image_get_active_channel ()

    gint32      gimp_image_get_active_channel   (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_get_active_layer ()

    gint32      gimp_image_get_active_layer     (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_get_channels ()

    gint32*     gimp_image_get_channels         (gint32 image_ID,
                                                 gint *nchannels);

`image_ID` : |
`nchannels` : |
Returns : |

### gimp_image_get_cmap ()

    guchar*     gimp_image_get_cmap             (gint32 image_ID,
                                                 gint *ncolors);

`image_ID` : |
`ncolors` : |
Returns : |

### gimp_image_get_component_active ()

    gint        gimp_image_get_component_active (gint32 image_ID,
                                                 gint component);

`image_ID` : |
`component` : |
Returns : |

### gimp_image_get_component_visible ()

    gint        gimp_image_get_component_visible
                                                (gint32 image_ID,
                                                 gint component);

`image_ID` : |
`component` : |
Returns : |

### gimp_image_get_filename ()

    char*       gimp_image_get_filename         (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_get_layers ()

    gint32*     gimp_image_get_layers           (gint32 image_ID,
                                                 gint *nlayers);

`image_ID` : |
`nlayers` : |
Returns : |

### gimp_image_get_selection ()

    gint32      gimp_image_get_selection        (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_set_active_channel ()

    void        gimp_image_set_active_channel   (gint32 image_ID,
                                                 gint32 channel_ID);

`image_ID` : |
`channel_ID` : |

### gimp_image_set_active_layer ()

    void        gimp_image_set_active_layer     (gint32 image_ID,
                                                 gint32 layer_ID);

`image_ID` : |
`layer_ID` : |

### gimp_image_set_cmap ()

    void        gimp_image_set_cmap             (gint32 image_ID,
                                                 guchar *cmap,
                                                 gint ncolors);

`image_ID` : |
`cmap` : |
`ncolors` : |

### gimp_image_set_component_active ()

    void        gimp_image_set_component_active (gint32 image_ID,
                                                 gint component,
                                                 gint active);

`image_ID` : |
`component` : |
`active` : |

### gimp_image_set_component_visible ()

    void        gimp_image_set_component_visible
                                                (gint32 image_ID,
                                                 gint component,
                                                 gint visible);

`image_ID` : |
`component` : |
`visible` : |

### gimp_image_set_filename ()

    void        gimp_image_set_filename         (gint32 image_ID,
                                                 char *name);

`image_ID` : |
`name` : |

### gimp_image_parasite_find ()

    Parasite*   gimp_image_parasite_find        (gint32 image_ID,
                                                 const char *name);

`image_ID` : |
`name` : |
Returns : |

### gimp_image_parasite_attach ()

    void        gimp_image_parasite_attach      (gint32 image_ID,
                                                 const Parasite *p);

`image_ID` : |
`p` : |

### gimp_image_attach_new_parasite ()

    void        gimp_image_attach_new_parasite  (gint32 image_ID,
                                                 const char *name,
                                                 int flags,
                                                 int size,
                                                 const void *data);

`image_ID` : |
`name` : |
`flags` : |
`size` : |
`data` : |

### gimp_image_parasite_detach ()

    void        gimp_image_parasite_detach      (gint32 image_ID,
                                                 const char *name);

`image_ID` : |
`name` : |

### gimp_image_set_resolution ()

    void        gimp_image_set_resolution       (gint32 image_ID,
                                                 double xresolution,
                                                 double yresolution);

`image_ID` : |
`xresolution` : |
`yresolution` : |

### gimp_image_get_resolution ()

    void        gimp_image_get_resolution       (gint32 image_ID,
                                                 double *xresolution,
                                                 double *yresolution);

`image_ID` : |
`xresolution` : |
`yresolution` : |

### gimp_image_set_unit ()

    void        gimp_image_set_unit             (gint32 image_ID,
                                                 GimpUnit unit);

`image_ID` : |
`unit` : |

### gimp_image_get_unit ()

    GimpUnit    gimp_image_get_unit             (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_image_get_layer_by_tattoo ()

    gint32      gimp_image_get_layer_by_tattoo  (gint32 image_ID,
                                                 gint32 tattoo);

`image_ID` : |
`tattoo` : |
Returns : |

### gimp_image_get_channel_by_tattoo ()

    gint32      gimp_image_get_channel_by_tattoo
                                                (gint32 image_ID,
                                                 gint32 tattoo);

`image_ID` : |
`tattoo` : |
Returns : |

### gimp_image_get_thumbnail_data ()

    guchar*     gimp_image_get_thumbnail_data   (gint32 image_ID,
                                                 gint *width,
                                                 gint *height,
                                                 gint *bytes);

`image_ID` : |
`width` : |
`height` : |
`bytes` : |
Returns : |

### gimp_image_convert_rgb ()

    void        gimp_image_convert_rgb          (gint32 image_ID);

`image_ID` : |

### gimp_image_convert_grayscale ()

    void        gimp_image_convert_grayscale    (gint32 image_ID);

`image_ID` : |

### gimp_image_convert_indexed ()

    void        gimp_image_convert_indexed      (gint32 image_ID,
                                                 GimpConvertDitherType dither_type,
                                                 GimpConvertPaletteType palette_type,
                                                 gint num_colors,
                                                 gint alpha_dither,
                                                 gint remove_unused,
                                                 gchar *palette);

`image_ID` : |
`dither_type` : |
`palette_type` : |
`num_colors` : |
`alpha_dither` : |
`remove_unused` : |
`palette` : |

### gimp_image_add_hguide ()

    gint32      gimp_image_add_hguide           (gint32 image_ID,
                                                 gint32 yposition);

`image_ID` : |
`yposition` : |
Returns : |

### gimp_image_add_vguide ()

    gint32      gimp_image_add_vguide           (gint32 image_ID,
                                                 gint32 xposition);

`image_ID` : |
`xposition` : |
Returns : |

### gimp_image_delete_guide ()

    void        gimp_image_delete_guide         (gint32 image_ID,
                                                 gint32 guide_ID);

`image_ID` : |
`guide_ID` : |

### gimp_image_find_next_guide ()

    gint32      gimp_image_find_next_guide      (gint32 image_ID,
                                                 gint32 guide_ID);

`image_ID` : |
`guide_ID` : |
Returns : |

### gimp_image_get_guide_orientation ()

    GOrientation gimp_image_get_guide_orientation
                                                (gint32 image_ID,
                                                 gint32 guide_ID);

`image_ID` : |
`guide_ID` : |
Returns : |

### gimp_image_get_guide_position ()

    gint32      gimp_image_get_guide_position   (gint32 image_ID,
                                                 gint32 guide_ID);

`image_ID` : |
`guide_ID` : |
Returns : |

### gimp_display_new ()

    gint32      gimp_display_new                (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_display_delete ()

    void        gimp_display_delete             (gint32 display_ID);

`display_ID` : |

### gimp_displays_flush ()

    void        gimp_displays_flush             (void);

### gimp_layer_new ()

    gint32      gimp_layer_new                  (gint32 image_ID,
                                                 char *name,
                                                 guint width,
                                                 guint height,
                                                 GDrawableType type,
                                                 gdouble opacity,
                                                 GLayerMode mode);

`image_ID` : |
`name` : |
`width` : |
`height` : |
`type` : |
`opacity` : |
`mode` : |
Returns : |

### gimp_layer_copy ()

    gint32      gimp_layer_copy                 (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_delete ()

    void        gimp_layer_delete               (gint32 layer_ID);

`layer_ID` : |

### gimp_layer_width ()

    guint       gimp_layer_width                (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_height ()

    guint       gimp_layer_height               (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_bpp ()

    guint       gimp_layer_bpp                  (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_type ()

    GDrawableType gimp_layer_type               (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_add_alpha ()

    void        gimp_layer_add_alpha            (gint32 layer_ID);

`layer_ID` : |

### gimp_layer_create_mask ()

    gint32      gimp_layer_create_mask          (gint32 layer_ID,
                                                 GimpAddMaskType mask_type);

`layer_ID` : |
`mask_type` : |
Returns : |

### gimp_layer_resize ()

    void        gimp_layer_resize               (gint32 layer_ID,
                                                 guint new_width,
                                                 guint new_height,
                                                 gint offset_x,
                                                 gint offset_y);

`layer_ID` : |
`new_width` : |
`new_height` : |
`offset_x` : |
`offset_y` : |

### gimp_layer_scale ()

    void        gimp_layer_scale                (gint32 layer_ID,
                                                 guint new_width,
                                                 guint new_height,
                                                 gint local_origin);

`layer_ID` : |
`new_width` : |
`new_height` : |
`local_origin` : |

### gimp_layer_translate ()

    void        gimp_layer_translate            (gint32 layer_ID,
                                                 gint offset_x,
                                                 gint offset_y);

`layer_ID` : |
`offset_x` : |
`offset_y` : |

### gimp_layer_is_floating_selection ()

    gint        gimp_layer_is_floating_selection
                                                (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_image_id ()

    gint32      gimp_layer_get_image_id         (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_mask_id ()

    gint32      gimp_layer_get_mask_id          (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_apply_mask ()

    gint        gimp_layer_get_apply_mask       (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_edit_mask ()

    gint        gimp_layer_get_edit_mask        (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_mode ()

    GLayerMode  gimp_layer_get_mode             (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_name ()

    char*       gimp_layer_get_name             (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_opacity ()

    gdouble     gimp_layer_get_opacity          (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_preserve_transparency ()

    gint        gimp_layer_get_preserve_transparency
                                                (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_show_mask ()

    gint        gimp_layer_get_show_mask        (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_get_visible ()

    gint        gimp_layer_get_visible          (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_layer_set_apply_mask ()

    void        gimp_layer_set_apply_mask       (gint32 layer_ID,
                                                 gint apply_mask);

`layer_ID` : |
`apply_mask` : |

### gimp_layer_set_edit_mask ()

    void        gimp_layer_set_edit_mask        (gint32 layer_ID,
                                                 gint edit_mask);

`layer_ID` : |
`edit_mask` : |

### gimp_layer_set_mode ()

    void        gimp_layer_set_mode             (gint32 layer_ID,
                                                 GLayerMode mode);

`layer_ID` : |
`mode` : |

### gimp_layer_set_name ()

    void        gimp_layer_set_name             (gint32 layer_ID,
                                                 char *name);

`layer_ID` : |
`name` : |

### gimp_layer_set_offsets ()

    void        gimp_layer_set_offsets          (gint32 layer_ID,
                                                 gint offset_x,
                                                 gint offset_y);

`layer_ID` : |
`offset_x` : |
`offset_y` : |

### gimp_layer_set_opacity ()

    void        gimp_layer_set_opacity          (gint32 layer_ID,
                                                 gdouble opacity);

`layer_ID` : |
`opacity` : |

### gimp_layer_set_preserve_transparency ()

    void        gimp_layer_set_preserve_transparency
                                                (gint32 layer_ID,
                                                 gint preserve_transparency);

`layer_ID` : |
`preserve_transparency` : |

### gimp_layer_set_show_mask ()

    void        gimp_layer_set_show_mask        (gint32 layer_ID,
                                                 gint show_mask);

`layer_ID` : |
`show_mask` : |

### gimp_layer_set_visible ()

    void        gimp_layer_set_visible          (gint32 layer_ID,
                                                 gint visible);

`layer_ID` : |
`visible` : |

### gimp_layer_get_tattoo ()

    gint32      gimp_layer_get_tattoo           (gint32 layer_ID);

`layer_ID` : |
Returns : |

### gimp_channel_new ()

    gint32      gimp_channel_new                (gint32 image_ID,
                                                 char *name,
                                                 guint width,
                                                 guint height,
                                                 gdouble opacity,
                                                 guchar *color);

`image_ID` : |
`name` : |
`width` : |
`height` : |
`opacity` : |
`color` : |
Returns : |

### gimp_channel_copy ()

    gint32      gimp_channel_copy               (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_delete ()

    void        gimp_channel_delete             (gint32 channel_ID);

`channel_ID` : |

### gimp_channel_width ()

    guint       gimp_channel_width              (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_height ()

    guint       gimp_channel_height             (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_get_image_id ()

    gint32      gimp_channel_get_image_id       (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_get_layer_id ()

    gint32      gimp_channel_get_layer_id       (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_get_color ()

    void        gimp_channel_get_color          (gint32 channel_ID,
                                                 guchar *red,
                                                 guchar *green,
                                                 guchar *blue);

`channel_ID` : |
`red` : |
`green` : |
`blue` : |

### gimp_channel_get_name ()

    char*       gimp_channel_get_name           (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_get_opacity ()

    gdouble     gimp_channel_get_opacity        (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_get_show_masked ()

    gint        gimp_channel_get_show_masked    (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_get_visible ()

    gint        gimp_channel_get_visible        (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_channel_set_color ()

    void        gimp_channel_set_color          (gint32 channel_ID,
                                                 guchar red,
                                                 guchar green,
                                                 guchar blue);

`channel_ID` : |
`red` : |
`green` : |
`blue` : |

### gimp_channel_set_name ()

    void        gimp_channel_set_name           (gint32 channel_ID,
                                                 char *name);

`channel_ID` : |
`name` : |

### gimp_channel_set_opacity ()

    void        gimp_channel_set_opacity        (gint32 channel_ID,
                                                 gdouble opacity);

`channel_ID` : |
`opacity` : |

### gimp_channel_set_show_masked ()

    void        gimp_channel_set_show_masked    (gint32 channel_ID,
                                                 gint show_masked);

`channel_ID` : |
`show_masked` : |

### gimp_channel_set_visible ()

    void        gimp_channel_set_visible        (gint32 channel_ID,
                                                 gint visible);

`channel_ID` : |
`visible` : |

### gimp_channel_get_tattoo ()

    gint32      gimp_channel_get_tattoo         (gint32 channel_ID);

`channel_ID` : |
Returns : |

### gimp_drawable_get ()

    GDrawable*  gimp_drawable_get               (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_detach ()

    void        gimp_drawable_detach            (GDrawable *drawable);

`drawable` : |

### gimp_drawable_flush ()

    void        gimp_drawable_flush             (GDrawable *drawable);

`drawable` : |

### gimp_drawable_delete ()

    void        gimp_drawable_delete            (GDrawable *drawable);

`drawable` : |

### gimp_drawable_update ()

    void        gimp_drawable_update            (gint32 drawable_ID,
                                                 gint x,
                                                 gint y,
                                                 guint width,
                                                 guint height);

`drawable_ID` : |
`x` : |
`y` : |
`width` : |
`height` : |

### gimp_drawable_merge_shadow ()

    void        gimp_drawable_merge_shadow      (gint32 drawable_ID,
                                                 gint undoable);

`drawable_ID` : |
`undoable` : |

### gimp_drawable_image_id ()

    gint32      gimp_drawable_image_id          (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_name ()

    char*       gimp_drawable_name              (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_width ()

    guint       gimp_drawable_width             (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_height ()

    guint       gimp_drawable_height            (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_bpp ()

    guint       gimp_drawable_bpp               (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_type ()

    GDrawableType gimp_drawable_type            (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_visible ()

    gint        gimp_drawable_visible           (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_is_channel ()

    gint        gimp_drawable_is_channel        (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_is_rgb ()

    gint        gimp_drawable_is_rgb            (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_is_gray ()

    gint        gimp_drawable_is_gray           (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_has_alpha ()

    gint        gimp_drawable_has_alpha         (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_is_indexed ()

    gint        gimp_drawable_is_indexed        (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_is_layer ()

    gint        gimp_drawable_is_layer          (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_is_layer_mask ()

    gint        gimp_drawable_is_layer_mask     (gint32 drawable_ID);

`drawable_ID` : |
Returns : |

### gimp_drawable_mask_bounds ()

    gint        gimp_drawable_mask_bounds       (gint32 drawable_ID,
                                                 gint *x1,
                                                 gint *y1,
                                                 gint *x2,
                                                 gint *y2);

`drawable_ID` : |
`x1` : |
`y1` : |
`x2` : |
`y2` : |
Returns : |

### gimp_drawable_offsets ()

    void        gimp_drawable_offsets           (gint32 drawable_ID,
                                                 gint *offset_x,
                                                 gint *offset_y);

`drawable_ID` : |
`offset_x` : |
`offset_y` : |

### gimp_drawable_fill ()

    void        gimp_drawable_fill              (gint32 drawable_ID,
                                                 GimpFillType fill_type);

`drawable_ID` : |
`fill_type` : |

### gimp_drawable_set_name ()

    void        gimp_drawable_set_name          (gint32 drawable_ID,
                                                 char *name);

`drawable_ID` : |
`name` : |

### gimp_drawable_set_visible ()

    void        gimp_drawable_set_visible       (gint32 drawable_ID,
                                                 gint visible);

`drawable_ID` : |
`visible` : |

### gimp_drawable_get_tile ()

    GTile*      gimp_drawable_get_tile          (GDrawable *drawable,
                                                 gint shadow,
                                                 gint row,
                                                 gint col);

`drawable` : |
`shadow` : |
`row` : |
`col` : |
Returns : |

### gimp_drawable_get_tile2 ()

    GTile*      gimp_drawable_get_tile2         (GDrawable *drawable,
                                                 gint shadow,
                                                 gint x,
                                                 gint y);

`drawable` : |
`shadow` : |
`x` : |
`y` : |
Returns : |

### gimp_drawable_parasite_find ()

    Parasite*   gimp_drawable_parasite_find     (gint32 drawable,
                                                 const char *name);

`drawable` : |
`name` : |
Returns : |

### gimp_drawable_parasite_attach ()

    void        gimp_drawable_parasite_attach   (gint32 drawable,
                                                 const Parasite *p);

`drawable` : |
`p` : |

### gimp_drawable_attach_new_parasite ()

    void        gimp_drawable_attach_new_parasite
                                                (gint32 drawable,
                                                 const char *name,
                                                 int flags,
                                                 int size,
                                                 const void *data);

`drawable` : |
`name` : |
`flags` : |
`size` : |
`data` : |

### gimp_drawable_parasite_detach ()

    void        gimp_drawable_parasite_detach   (gint32 drawable,
                                                 const char *name);

`drawable` : |
`name` : |

### gimp_drawable_get_thumbnail_data ()

    guchar*     gimp_drawable_get_thumbnail_data
                                                (gint32 drawable_ID,
                                                 gint *width,
                                                 gint *height,
                                                 gint *bytes);

`drawable_ID` : |
`width` : |
`height` : |
`bytes` : |
Returns : |

### gimp_selection_bounds ()

    gint32      gimp_selection_bounds           (gint32 image_ID,
                                                 gint32 *non_empty,
                                                 gint32 *x1,
                                                 gint32 *y1,
                                                 gint32 *x2,
                                                 gint32 *y2);

`image_ID` : |
`non_empty` : |
`x1` : |
`y1` : |
`x2` : |
`y2` : |
Returns : |

### gimp_selection_float ()

    gint32      gimp_selection_float            (gint32 image_ID,
                                                 gint32 drawable_ID,
                                                 gint32 x_offset,
                                                 gint32 y_offset);

`image_ID` : |
`drawable_ID` : |
`x_offset` : |
`y_offset` : |
Returns : |

### gimp_selection_is_empty ()

    gint32      gimp_selection_is_empty         (gint32 image_ID);

`image_ID` : |
Returns : |

### gimp_selection_none ()

    void        gimp_selection_none             (gint32 image_ID);

`image_ID` : |

### gimp_tile_ref ()

    void        gimp_tile_ref                   (GTile *tile);

`tile` : |

### gimp_tile_ref_zero ()

    void        gimp_tile_ref_zero              (GTile *tile);

`tile` : |

### gimp_tile_unref ()

    void        gimp_tile_unref                 (GTile *tile,
                                                 int dirty);

`tile` : |
`dirty` : |

### gimp_tile_flush ()

    void        gimp_tile_flush                 (GTile *tile);

`tile` : |

### gimp_tile_cache_size ()

    void        gimp_tile_cache_size            (gulong kilobytes);

`kilobytes` : |

### gimp_tile_cache_ntiles ()

    void        gimp_tile_cache_ntiles          (gulong ntiles);

`ntiles` : |

### gimp_tile_width ()

    guint       gimp_tile_width                 (void);

Returns : |

### gimp_tile_height ()

    guint       gimp_tile_height                (void);

Returns : |

### gimp_pixel_rgn_init ()

    void        gimp_pixel_rgn_init             (GPixelRgn *pr,
                                                 GDrawable *drawable,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height,
                                                 int dirty,
                                                 int shadow);

`pr` : |
`drawable` : |
`x` : |
`y` : |
`width` : |
`height` : |
`dirty` : |
`shadow` : |

### gimp_pixel_rgn_resize ()

    void        gimp_pixel_rgn_resize           (GPixelRgn *pr,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height);

`pr` : |
`x` : |
`y` : |
`width` : |
`height` : |

### gimp_pixel_rgn_get_pixel ()

    void        gimp_pixel_rgn_get_pixel        (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y);

`pr` : |
`buf` : |
`x` : |
`y` : |

### gimp_pixel_rgn_get_row ()

    void        gimp_pixel_rgn_get_row          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width);

`pr` : |
`buf` : |
`x` : |
`y` : |
`width` : |

### gimp_pixel_rgn_get_col ()

    void        gimp_pixel_rgn_get_col          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int height);

`pr` : |
`buf` : |
`x` : |
`y` : |
`height` : |

### gimp_pixel_rgn_get_rect ()

    void        gimp_pixel_rgn_get_rect         (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height);

`pr` : |
`buf` : |
`x` : |
`y` : |
`width` : |
`height` : |

### gimp_pixel_rgn_set_pixel ()

    void        gimp_pixel_rgn_set_pixel        (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y);

`pr` : |
`buf` : |
`x` : |
`y` : |

### gimp_pixel_rgn_set_row ()

    void        gimp_pixel_rgn_set_row          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width);

`pr` : |
`buf` : |
`x` : |
`y` : |
`width` : |

### gimp_pixel_rgn_set_col ()

    void        gimp_pixel_rgn_set_col          (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int height);

`pr` : |
`buf` : |
`x` : |
`y` : |
`height` : |

### gimp_pixel_rgn_set_rect ()

    void        gimp_pixel_rgn_set_rect         (GPixelRgn *pr,
                                                 guchar *buf,
                                                 int x,
                                                 int y,
                                                 int width,
                                                 int height);

`pr` : |
`buf` : |
`x` : |
`y` : |
`width` : |
`height` : |

### gimp_pixel_rgns_register ()

    gpointer    gimp_pixel_rgns_register        (int nrgns,
                                                 ...);

`nrgns` : |
`...` : |
Returns : |

### gimp_pixel_rgns_register2 ()

    gpointer    gimp_pixel_rgns_register2       (int nrgns,
                                                 GPixelRgn **prs);

`nrgns` : |
`prs` : |
Returns : |

### gimp_pixel_rgns_process ()

    gpointer    gimp_pixel_rgns_process         (gpointer pri_ptr);

`pri_ptr` : |
Returns : |

### gimp_palette_get_background ()

    void        gimp_palette_get_background     (guchar *red,
                                                 guchar *green,
                                                 guchar *blue);

`red` : |
`green` : |
`blue` : |

### gimp_palette_get_foreground ()

    void        gimp_palette_get_foreground     (guchar *red,
                                                 guchar *green,
                                                 guchar *blue);

`red` : |
`green` : |
`blue` : |

### gimp_palette_set_background ()

    void        gimp_palette_set_background     (guchar red,
                                                 guchar green,
                                                 guchar blue);

`red` : |
`green` : |
`blue` : |

### gimp_palette_set_foreground ()

    void        gimp_palette_set_foreground     (guchar red,
                                                 guchar green,
                                                 guchar blue);

`red` : |
`green` : |
`blue` : |

### gimp_gradients_get_list ()

    char**      gimp_gradients_get_list         (gint *num_gradients);

`num_gradients` : |
Returns : |

### gimp_gradients_get_active ()

    char*       gimp_gradients_get_active       (void);

Returns : |

### gimp_gradients_set_active ()

    void        gimp_gradients_set_active       (char *name);

`name` : |

### gimp_gradients_sample_uniform ()

    gdouble*    gimp_gradients_sample_uniform   (gint num_samples);

`num_samples` : |
Returns : |

### gimp_gradients_sample_custom ()

    gdouble*    gimp_gradients_sample_custom    (gint num_samples,
                                                 gdouble *positions);

`num_samples` : |
`positions` : |
Returns : |

### gimp_parasite_find ()

    Parasite*   gimp_parasite_find              (const char *name);

`name` : |
Returns : |

### gimp_parasite_attach ()

    void        gimp_parasite_attach            (const Parasite *p);

`p` : |

### gimp_attach_new_parasite ()

    void        gimp_attach_new_parasite        (const char *name,
                                                 int flags,
                                                 int size,
                                                 const void *data);

`name` : |
`flags` : |
`size` : |
`data` : |

### gimp_parasite_detach ()

    void        gimp_parasite_detach            (const char *name);

`name` : |

### gimp_plugin_help_func ()

    void        gimp_plugin_help_func           (gchar *help_data);

`help_data` : |

### gimp_help ()

    void        gimp_help                       (gchar *help_data);

`help_data` : |

<<< Previous Page | Home | Up | Next Page >>>
GIMP Library | gimpprotocol