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);
void        gimp_plugin_domain_add_with_path
                                            (gchar *domain_name,
                                             gchar *domain_path);
void        gimp_plugin_domain_add          (gchar *domain_name);

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 : 


gimp_plugin_domain_add_with_path ()

void        gimp_plugin_domain_add_with_path
                                            (gchar *domain_name,
                                             gchar *domain_path);

domain_name : 
domain_path : 


gimp_plugin_domain_add ()

void        gimp_plugin_domain_add          (gchar *domain_name);

domain_name :