GimpImage

GimpImage

Synopsis

#define             GIMP_IMAGE_TYPE_IS_RGB              (t)
#define             GIMP_IMAGE_TYPE_IS_GRAY             (t)
#define             GIMP_IMAGE_TYPE_IS_INDEXED          (t)
#define             GIMP_IMAGE_TYPE_HAS_ALPHA           (t)
#define             GIMP_IMAGE_TYPE_WITH_ALPHA          (t)
#define             GIMP_IMAGE_TYPE_WITHOUT_ALPHA       (t)
#define             GIMP_IMAGE_TYPE_BYTES               (t)
#define             GIMP_IMAGE_TYPE_BASE_TYPE           (t)
#define             GIMP_IMAGE_TYPE_FROM_BASE_TYPE      (b)
                    GimpImageFlushAccumulator;
                    GimpImage;
GimpImage*          gimp_image_new                      (Gimp *gimp,
                                                         gint width,
                                                         gint height,
                                                         GimpImageBaseType base_type);
GimpImageBaseType   gimp_image_base_type                (const GimpImage *image);
GimpImageType       gimp_image_base_type_with_alpha     (const GimpImage *image);
CombinationMode     gimp_image_get_combination_mode     (GimpImageType dest_type,
                                                         gint src_bytes);
gint                gimp_image_get_ID                   (const GimpImage *image);
GimpImage*          gimp_image_get_by_ID                (Gimp *gimp,
                                                         gint id);
void                gimp_image_set_uri                  (GimpImage *image,
                                                         const gchar *uri);
const gchar*        gimp_image_get_uri                  (const GimpImage *image);
void                gimp_image_set_filename             (GimpImage *image,
                                                         const gchar *filename);
gchar*              gimp_image_get_filename             (const GimpImage *image);
GimpPlugInProcedure* gimp_image_get_load_proc           (const GimpImage *image);
void                gimp_image_set_load_proc            (GimpImage *image,
                                                         GimpPlugInProcedure *proc);
void                gimp_image_set_save_proc            (GimpImage *image,
                                                         GimpPlugInProcedure *proc);
GimpPlugInProcedure* gimp_image_get_save_proc           (const GimpImage *image);
void                gimp_image_saved                    (GimpImage *image,
                                                         const gchar *uri);
void                gimp_image_set_resolution           (GimpImage *image,
                                                         gdouble xres,
                                                         gdouble yres);
void                gimp_image_get_resolution           (const GimpImage *image,
                                                         gdouble *xres,
                                                         gdouble *yres);
void                gimp_image_resolution_changed       (GimpImage *image);
void                gimp_image_set_unit                 (GimpImage *image,
                                                         GimpUnit unit);
GimpUnit            gimp_image_get_unit                 (const GimpImage *image);
void                gimp_image_unit_changed             (GimpImage *image);
gint                gimp_image_get_width                (const GimpImage *image);
gint                gimp_image_get_height               (const GimpImage *image);
gboolean            gimp_image_has_alpha                (const GimpImage *image);
gboolean            gimp_image_is_empty                 (const GimpImage *image);
GimpLayer*          gimp_image_floating_sel             (const GimpImage *image);
void                gimp_image_floating_selection_changed
                                                        (GimpImage *image);
GimpChannel*        gimp_image_get_mask                 (const GimpImage *image);
void                gimp_image_mask_changed             (GimpImage *image);
gint                gimp_image_get_component_index      (const GimpImage *image,
                                                         GimpChannelType channel);
void                gimp_image_set_component_active     (GimpImage *image,
                                                         GimpChannelType type,
                                                         gboolean active);
gboolean            gimp_image_get_component_active     (const GimpImage *image,
                                                         GimpChannelType type);
void                gimp_image_set_component_visible    (GimpImage *image,
                                                         GimpChannelType type,
                                                         gboolean visible);
gboolean            gimp_image_get_component_visible    (const GimpImage *image,
                                                         GimpChannelType type);
void                gimp_image_mode_changed             (GimpImage *image);
void                gimp_image_alpha_changed            (GimpImage *image);
void                gimp_image_update                   (GimpImage *image,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gimp_image_update_guide             (GimpImage *image,
                                                         GimpGuide *guide);
void                gimp_image_update_sample_point      (GimpImage *image,
                                                         GimpSamplePoint *sample_point);
void                gimp_image_sample_point_added       (GimpImage *image,
                                                         GimpSamplePoint *sample_point);
void                gimp_image_sample_point_removed     (GimpImage *image,
                                                         GimpSamplePoint *sample_point);
void                gimp_image_colormap_changed         (GimpImage *image,
                                                         gint col);
void                gimp_image_selection_control        (GimpImage *image,
                                                         GimpSelectionControl control);
void                gimp_image_quick_mask_changed       (GimpImage *image);
gboolean            gimp_image_undo_is_enabled          (const GimpImage *image);
GimpUndo*           gimp_image_undo_can_compress        (GimpImage *image,
                                                         GType object_type,
                                                         GimpUndoType undo_type);
gboolean            gimp_image_undo_enable              (GimpImage *image);
gboolean            gimp_image_undo_disable             (GimpImage *image);
gboolean            gimp_image_undo_freeze              (GimpImage *image);
gboolean            gimp_image_undo_thaw                (GimpImage *image);
void                gimp_image_undo_event               (GimpImage *image,
                                                         GimpUndoEvent event,
                                                         GimpUndo *undo);
gint                gimp_image_dirty                    (GimpImage *image,
                                                         GimpDirtyMask dirty_mask);
gint                gimp_image_clean                    (GimpImage *image,
                                                         GimpDirtyMask dirty_mask);
void                gimp_image_clean_all                (GimpImage *image);
void                gimp_image_flush                    (GimpImage *image);
GimpProjection*     gimp_image_get_projection           (const GimpImage *image);
void                gimp_image_get_foreground           (const GimpImage *image,
                                                         GimpContext *context,
                                                         GimpImageType dest_type,
                                                         guchar *fg);
void                gimp_image_get_background           (const GimpImage *image,
                                                         GimpContext *context,
                                                         GimpImageType dest_type,
                                                         guchar *bg);
void                gimp_image_get_color                (const GimpImage *src_image,
                                                         GimpImageType src_type,
                                                         const guchar *src,
                                                         guchar *rgba);
void                gimp_image_transform_color          (const GimpImage *dest_image,
                                                         GimpImageType dest_type,
                                                         guchar *dest,
                                                         GimpImageBaseType src_type,
                                                         const guchar *src);
void                gimp_image_transform_rgb            (const GimpImage *dest_image,
                                                         GimpImageType dest_type,
                                                         const GimpRGB *rgb,
                                                         guchar *color);
TempBuf*            gimp_image_transform_temp_buf       (const GimpImage *dest_image,
                                                         GimpImageType dest_type,
                                                         TempBuf *temp_buf,
                                                         gboolean *new_buf);
const GimpParasite* gimp_image_parasite_find            (const GimpImage *image,
                                                         const gchar *name);
gchar**             gimp_image_parasite_list            (const GimpImage *image,
                                                         gint *count);
void                gimp_image_parasite_attach          (GimpImage *image,
                                                         const GimpParasite *parasite);
void                gimp_image_parasite_detach          (GimpImage *image,
                                                         const gchar *name);
GimpTattoo          gimp_image_get_new_tattoo           (GimpImage *image);
gboolean            gimp_image_set_tattoo_state         (GimpImage *image,
                                                         GimpTattoo val);
GimpTattoo          gimp_image_get_tattoo_state         (GimpImage *image);
GimpContainer*      gimp_image_get_layers               (const GimpImage *image);
GimpContainer*      gimp_image_get_channels             (const GimpImage *image);
GimpContainer*      gimp_image_get_vectors              (const GimpImage *image);
GimpDrawable*       gimp_image_get_active_drawable      (const GimpImage *image);
GimpLayer*          gimp_image_get_active_layer         (const GimpImage *image);
GimpChannel*        gimp_image_get_active_channel       (const GimpImage *image);
GimpVectors*        gimp_image_get_active_vectors       (const GimpImage *image);
GimpLayer*          gimp_image_set_active_layer         (GimpImage *image,
                                                         GimpLayer *layer);
GimpChannel*        gimp_image_set_active_channel       (GimpImage *image,
                                                         GimpChannel *channel);
GimpChannel*        gimp_image_unset_active_channel     (GimpImage *image);
GimpVectors*        gimp_image_set_active_vectors       (GimpImage *image,
                                                         GimpVectors *vectors);
void                gimp_image_active_layer_changed     (GimpImage *image);
void                gimp_image_active_channel_changed   (GimpImage *image);
void                gimp_image_active_vectors_changed   (GimpImage *image);
gint                gimp_image_get_layer_index          (const GimpImage *image,
                                                         const GimpLayer *layer);
gint                gimp_image_get_channel_index        (const GimpImage *image,
                                                         const GimpChannel *channel);
gint                gimp_image_get_vectors_index        (const GimpImage *image,
                                                         const GimpVectors *vectors);
GimpLayer*          gimp_image_get_layer_by_tattoo      (const GimpImage *image,
                                                         GimpTattoo tattoo);
GimpChannel*        gimp_image_get_channel_by_tattoo    (const GimpImage *image,
                                                         GimpTattoo tattoo);
GimpVectors*        gimp_image_get_vectors_by_tattoo    (const GimpImage *image,
                                                         GimpTattoo tattoo);
GimpLayer*          gimp_image_get_layer_by_name        (const GimpImage *image,
                                                         const gchar *name);
GimpChannel*        gimp_image_get_channel_by_name      (const GimpImage *image,
                                                         const gchar *name);
GimpVectors*        gimp_image_get_vectors_by_name      (const GimpImage *image,
                                                         const gchar *name);
gboolean            gimp_image_add_layer                (GimpImage *image,
                                                         GimpLayer *layer,
                                                         gint position);
void                gimp_image_add_layers               (GimpImage *image,
                                                         GList *layers,
                                                         gint position,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         const gchar *undo_desc);
void                gimp_image_remove_layer             (GimpImage *image,
                                                         GimpLayer *layer);
gboolean            gimp_image_raise_layer              (GimpImage *image,
                                                         GimpLayer *layer,
                                                         GError **error);
gboolean            gimp_image_lower_layer              (GimpImage *image,
                                                         GimpLayer *layer,
                                                         GError **error);
gboolean            gimp_image_raise_layer_to_top       (GimpImage *image,
                                                         GimpLayer *layer);
gboolean            gimp_image_lower_layer_to_bottom    (GimpImage *image,
                                                         GimpLayer *layer);
gboolean            gimp_image_position_layer           (GimpImage *image,
                                                         GimpLayer *layer,
                                                         gint new_index,
                                                         gboolean push_undo,
                                                         const gchar *undo_desc);
gboolean            gimp_image_add_channel              (GimpImage *image,
                                                         GimpChannel *channel,
                                                         gint position);
void                gimp_image_remove_channel           (GimpImage *image,
                                                         GimpChannel *channel);
gboolean            gimp_image_raise_channel            (GimpImage *image,
                                                         GimpChannel *channel,
                                                         GError **error);
gboolean            gimp_image_lower_channel            (GimpImage *image,
                                                         GimpChannel *channel,
                                                         GError **error);
gboolean            gimp_image_raise_channel_to_top     (GimpImage *image,
                                                         GimpChannel *channel);
gboolean            gimp_image_lower_channel_to_bottom  (GimpImage *image,
                                                         GimpChannel *channel);
gboolean            gimp_image_position_channel         (GimpImage *image,
                                                         GimpChannel *channel,
                                                         gint new_index,
                                                         gboolean push_undo,
                                                         const gchar *undo_desc);
gboolean            gimp_image_add_vectors              (GimpImage *image,
                                                         GimpVectors *vectors,
                                                         gint position);
void                gimp_image_remove_vectors           (GimpImage *image,
                                                         GimpVectors *vectors);
gboolean            gimp_image_raise_vectors            (GimpImage *image,
                                                         GimpVectors *vectors,
                                                         GError **error);
gboolean            gimp_image_lower_vectors            (GimpImage *image,
                                                         GimpVectors *vectors,
                                                         GError **error);
gboolean            gimp_image_raise_vectors_to_top     (GimpImage *image,
                                                         GimpVectors *vectors);
gboolean            gimp_image_lower_vectors_to_bottom  (GimpImage *image,
                                                         GimpVectors *vectors);
gboolean            gimp_image_position_vectors         (GimpImage *image,
                                                         GimpVectors *vectors,
                                                         gint new_index,
                                                         gboolean push_undo,
                                                         const gchar *undo_desc);
gboolean            gimp_image_layer_boundary           (const GimpImage *image,
                                                         BoundSeg **segs,
                                                         gint *n_segs);
GimpLayer*          gimp_image_pick_correlate_layer     (const GimpImage *image,
                                                         gint x,
                                                         gint y);
gboolean            gimp_image_coords_in_active_pickable
                                                        (GimpImage *image,
                                                         const GimpCoords *coords,
                                                         gboolean sample_merged,
                                                         gboolean selected_only);
void                gimp_image_invalidate_layer_previews
                                                        (GimpImage *image);
void                gimp_image_invalidate_channel_previews
                                                        (GimpImage *image);

Object Hierarchy

  GObject
   +----GimpObject
         +----GimpViewable
               +----GimpImage

Implemented Interfaces

GimpImage implements GimpConfigInterface and GimpColorManagedInterface.

Properties

  "base-type"                GimpImageBaseType     : Read / Write / Construct
  "gimp"                     Gimp*                 : Read / Write / Construct Only
  "height"                   gint                  : Read / Write / Construct
  "id"                       gint                  : Read
  "width"                    gint                  : Read / Write / Construct

Signals

  "active-channel-changed"                         : Run First
  "active-layer-changed"                           : Run First
  "active-vectors-changed"                         : Run First
  "alpha-changed"                                  : Run First
  "clean"                                          : Run First
  "colormap-changed"                               : Run First
  "component-active-changed"                       : Run First
  "component-visibility-changed"                   : Run First
  "dirty"                                          : Run First
  "floating-selection-changed"                     : Run First
  "flush"                                          : Run First
  "mask-changed"                                   : Run First
  "mode-changed"                                   : Run First
  "parasite-attached"                              : Run First
  "parasite-detached"                              : Run First
  "quick-mask-changed"                             : Run First
  "resolution-changed"                             : Run First
  "sample-point-added"                             : Run First
  "sample-point-removed"                           : Run First
  "saved"                                          : Run First
  "selection-control"                              : Run First
  "size-changed-detailed"                          : Run First
  "undo-event"                                     : Run First
  "unit-changed"                                   : Run First
  "update"                                         : Run First
  "update-guide"                                   : Run First
  "update-sample-point"                            : Run First

Description

Details

GIMP_IMAGE_TYPE_IS_RGB()

#define             GIMP_IMAGE_TYPE_IS_RGB(t)

t :

GIMP_IMAGE_TYPE_IS_GRAY()

#define             GIMP_IMAGE_TYPE_IS_GRAY(t)

t :

GIMP_IMAGE_TYPE_IS_INDEXED()

#define             GIMP_IMAGE_TYPE_IS_INDEXED(t)

t :

GIMP_IMAGE_TYPE_HAS_ALPHA()

#define             GIMP_IMAGE_TYPE_HAS_ALPHA(t)

t :

GIMP_IMAGE_TYPE_WITH_ALPHA()

#define             GIMP_IMAGE_TYPE_WITH_ALPHA(t)

t :

GIMP_IMAGE_TYPE_WITHOUT_ALPHA()

#define             GIMP_IMAGE_TYPE_WITHOUT_ALPHA(t)

t :

GIMP_IMAGE_TYPE_BYTES()

#define             GIMP_IMAGE_TYPE_BYTES(t)

t :

GIMP_IMAGE_TYPE_BASE_TYPE()

#define             GIMP_IMAGE_TYPE_BASE_TYPE(t)

t :

GIMP_IMAGE_TYPE_FROM_BASE_TYPE()

#define             GIMP_IMAGE_TYPE_FROM_BASE_TYPE(b)

b :

GimpImageFlushAccumulator

typedef struct {
  gboolean alpha_changed;
  gboolean mask_changed;
  gboolean preview_invalidated;
} GimpImageFlushAccumulator;

GimpImage

typedef struct _GimpImage GimpImage;

gimp_image_new ()

GimpImage*          gimp_image_new                      (Gimp *gimp,
                                                         gint width,
                                                         gint height,
                                                         GimpImageBaseType base_type);

gimp :

width :

height :

base_type :

Returns :

gimp_image_base_type ()

GimpImageBaseType   gimp_image_base_type                (const GimpImage *image);

image :

Returns :

gimp_image_base_type_with_alpha ()

GimpImageType       gimp_image_base_type_with_alpha     (const GimpImage *image);

image :

Returns :

gimp_image_get_combination_mode ()

CombinationMode     gimp_image_get_combination_mode     (GimpImageType dest_type,
                                                         gint src_bytes);

dest_type :

src_bytes :

Returns :

gimp_image_get_ID ()

gint                gimp_image_get_ID                   (const GimpImage *image);

image :

Returns :

gimp_image_get_by_ID ()

GimpImage*          gimp_image_get_by_ID                (Gimp *gimp,
                                                         gint id);

gimp :

id :

Returns :

gimp_image_set_uri ()

void                gimp_image_set_uri                  (GimpImage *image,
                                                         const gchar *uri);

image :

uri :

gimp_image_get_uri ()

const gchar*        gimp_image_get_uri                  (const GimpImage *image);

image :

Returns :

gimp_image_set_filename ()

void                gimp_image_set_filename             (GimpImage *image,
                                                         const gchar *filename);

image :

filename :

gimp_image_get_filename ()

gchar*              gimp_image_get_filename             (const GimpImage *image);

image :

Returns :

gimp_image_get_load_proc ()

GimpPlugInProcedure* gimp_image_get_load_proc           (const GimpImage *image);

image :

Returns :

gimp_image_set_load_proc ()

void                gimp_image_set_load_proc            (GimpImage *image,
                                                         GimpPlugInProcedure *proc);

image :

proc :

gimp_image_set_save_proc ()

void                gimp_image_set_save_proc            (GimpImage *image,
                                                         GimpPlugInProcedure *proc);

image :

proc :

gimp_image_get_save_proc ()

GimpPlugInProcedure* gimp_image_get_save_proc           (const GimpImage *image);

image :

Returns :

gimp_image_saved ()

void                gimp_image_saved                    (GimpImage *image,
                                                         const gchar *uri);

Emits the "saved" signal, indicating that image was saved to the location specified by uri.

image :

uri :

gimp_image_set_resolution ()

void                gimp_image_set_resolution           (GimpImage *image,
                                                         gdouble xres,
                                                         gdouble yres);

image :

xres :

yres :

gimp_image_get_resolution ()

void                gimp_image_get_resolution           (const GimpImage *image,
                                                         gdouble *xres,
                                                         gdouble *yres);

image :

xres :

yres :

gimp_image_resolution_changed ()

void                gimp_image_resolution_changed       (GimpImage *image);

image :

gimp_image_set_unit ()

void                gimp_image_set_unit                 (GimpImage *image,
                                                         GimpUnit unit);

image :

unit :

gimp_image_get_unit ()

GimpUnit            gimp_image_get_unit                 (const GimpImage *image);

image :

Returns :

gimp_image_unit_changed ()

void                gimp_image_unit_changed             (GimpImage *image);

image :

gimp_image_get_width ()

gint                gimp_image_get_width                (const GimpImage *image);

image :

Returns :

gimp_image_get_height ()

gint                gimp_image_get_height               (const GimpImage *image);

image :

Returns :

gimp_image_has_alpha ()

gboolean            gimp_image_has_alpha                (const GimpImage *image);

image :

Returns :

gimp_image_is_empty ()

gboolean            gimp_image_is_empty                 (const GimpImage *image);

image :

Returns :

gimp_image_floating_sel ()

GimpLayer*          gimp_image_floating_sel             (const GimpImage *image);

image :

Returns :

gimp_image_floating_selection_changed ()

void                gimp_image_floating_selection_changed
                                                        (GimpImage *image);

image :

gimp_image_get_mask ()

GimpChannel*        gimp_image_get_mask                 (const GimpImage *image);

image :

Returns :

gimp_image_mask_changed ()

void                gimp_image_mask_changed             (GimpImage *image);

image :

gimp_image_get_component_index ()

gint                gimp_image_get_component_index      (const GimpImage *image,
                                                         GimpChannelType channel);

image :

channel :

Returns :

gimp_image_set_component_active ()

void                gimp_image_set_component_active     (GimpImage *image,
                                                         GimpChannelType type,
                                                         gboolean active);

image :

type :

active :

gimp_image_get_component_active ()

gboolean            gimp_image_get_component_active     (const GimpImage *image,
                                                         GimpChannelType type);

image :

type :

Returns :

gimp_image_set_component_visible ()

void                gimp_image_set_component_visible    (GimpImage *image,
                                                         GimpChannelType type,
                                                         gboolean visible);

image :

type :

visible :

gimp_image_get_component_visible ()

gboolean            gimp_image_get_component_visible    (const GimpImage *image,
                                                         GimpChannelType type);

image :

type :

Returns :

gimp_image_mode_changed ()

void                gimp_image_mode_changed             (GimpImage *image);

image :

gimp_image_alpha_changed ()

void                gimp_image_alpha_changed            (GimpImage *image);

image :

gimp_image_update ()

void                gimp_image_update                   (GimpImage *image,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

image :

x :

y :

width :

height :

gimp_image_update_guide ()

void                gimp_image_update_guide             (GimpImage *image,
                                                         GimpGuide *guide);

image :

guide :

gimp_image_update_sample_point ()

void                gimp_image_update_sample_point      (GimpImage *image,
                                                         GimpSamplePoint *sample_point);

image :

sample_point :

gimp_image_sample_point_added ()

void                gimp_image_sample_point_added       (GimpImage *image,
                                                         GimpSamplePoint *sample_point);

image :

sample_point :

gimp_image_sample_point_removed ()

void                gimp_image_sample_point_removed     (GimpImage *image,
                                                         GimpSamplePoint *sample_point);

image :

sample_point :

gimp_image_colormap_changed ()

void                gimp_image_colormap_changed         (GimpImage *image,
                                                         gint col);

image :

col :

gimp_image_selection_control ()

void                gimp_image_selection_control        (GimpImage *image,
                                                         GimpSelectionControl control);

image :

control :

gimp_image_quick_mask_changed ()

void                gimp_image_quick_mask_changed       (GimpImage *image);

image :

gimp_image_undo_is_enabled ()

gboolean            gimp_image_undo_is_enabled          (const GimpImage *image);

image :

Returns :

gimp_image_undo_can_compress ()

GimpUndo*           gimp_image_undo_can_compress        (GimpImage *image,
                                                         GType object_type,
                                                         GimpUndoType undo_type);

image :

object_type :

undo_type :

Returns :

gimp_image_undo_enable ()

gboolean            gimp_image_undo_enable              (GimpImage *image);

image :

Returns :

gimp_image_undo_disable ()

gboolean            gimp_image_undo_disable             (GimpImage *image);

image :

Returns :

gimp_image_undo_freeze ()

gboolean            gimp_image_undo_freeze              (GimpImage *image);

image :

Returns :

gimp_image_undo_thaw ()

gboolean            gimp_image_undo_thaw                (GimpImage *image);

image :

Returns :

gimp_image_undo_event ()

void                gimp_image_undo_event               (GimpImage *image,
                                                         GimpUndoEvent event,
                                                         GimpUndo *undo);

image :

event :

undo :

gimp_image_dirty ()

gint                gimp_image_dirty                    (GimpImage *image,
                                                         GimpDirtyMask dirty_mask);

image :

dirty_mask :

Returns :

gimp_image_clean ()

gint                gimp_image_clean                    (GimpImage *image,
                                                         GimpDirtyMask dirty_mask);

image :

dirty_mask :

Returns :

gimp_image_clean_all ()

void                gimp_image_clean_all                (GimpImage *image);

image :

gimp_image_flush ()

void                gimp_image_flush                    (GimpImage *image);

image :

gimp_image_get_projection ()

GimpProjection*     gimp_image_get_projection           (const GimpImage *image);

image :

Returns :

gimp_image_get_foreground ()

void                gimp_image_get_foreground           (const GimpImage *image,
                                                         GimpContext *context,
                                                         GimpImageType dest_type,
                                                         guchar *fg);

image :

context :

dest_type :

fg :

gimp_image_get_background ()

void                gimp_image_get_background           (const GimpImage *image,
                                                         GimpContext *context,
                                                         GimpImageType dest_type,
                                                         guchar *bg);

image :

context :

dest_type :

bg :

gimp_image_get_color ()

void                gimp_image_get_color                (const GimpImage *src_image,
                                                         GimpImageType src_type,
                                                         const guchar *src,
                                                         guchar *rgba);

src_image :

src_type :

src :

rgba :

gimp_image_transform_color ()

void                gimp_image_transform_color          (const GimpImage *dest_image,
                                                         GimpImageType dest_type,
                                                         guchar *dest,
                                                         GimpImageBaseType src_type,
                                                         const guchar *src);

dest_image :

dest_type :

dest :

src_type :

src :

gimp_image_transform_rgb ()

void                gimp_image_transform_rgb            (const GimpImage *dest_image,
                                                         GimpImageType dest_type,
                                                         const GimpRGB *rgb,
                                                         guchar *color);

dest_image :

dest_type :

rgb :

color :

gimp_image_transform_temp_buf ()

TempBuf*            gimp_image_transform_temp_buf       (const GimpImage *dest_image,
                                                         GimpImageType dest_type,
                                                         TempBuf *t