自学教程：C++ GIMP_IS_IMAGE函数代码示例

gbooleangimp_image_set_icc_profile (GimpImage     *image,                            const guint8  *data,                            gsize          length,                            GError       **error){  GimpParasite *parasite = NULL;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (data == NULL || length != 0, FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (data)    {      gboolean is_builtin;      parasite = gimp_parasite_new (GIMP_ICC_PROFILE_PARASITE_NAME,                                    GIMP_PARASITE_PERSISTENT |                                    GIMP_PARASITE_UNDOABLE,                                    length, data);      if (! gimp_image_validate_icc_parasite (image, parasite, &is_builtin,                                              error))        {          gimp_parasite_free (parasite);          return FALSE;        }      /*  don't tag the image with the built-in profile  */      if (is_builtin)        {          gimp_parasite_free (parasite);          parasite = NULL;        }    }  gimp_image_set_icc_parasite (image, parasite);  if (parasite)    gimp_parasite_free (parasite);  return TRUE;}

gbooleangimp_image_validate_color_profile (GimpImage        *image,                                   GimpColorProfile *profile,                                   gboolean         *is_builtin,                                   GError          **error){  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (profile), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (gimp_image_get_base_type (image) == GIMP_GRAY)    {      if (! gimp_color_profile_is_gray (profile))        {          g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,                               _("ICC profile validation failed: "                                 "Color profile is not for GRAY color space"));          return FALSE;        }    }  else    {      if (! gimp_color_profile_is_rgb (profile))        {          g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,                               _("ICC profile validation failed: "                                 "Color profile is not for RGB color space"));          return FALSE;        }    }  if (is_builtin)    {      GimpColorProfile *builtin;      builtin = gimp_image_get_builtin_color_profile (image);      *is_builtin = gimp_color_profile_is_equal (profile, builtin);    }  return TRUE;}

GimpObject *gimp_edit_copy (GimpImage     *image,                GimpDrawable  *drawable,                GimpContext   *context,                GError       **error){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  if (GIMP_IS_LAYER (drawable) &&      gimp_channel_is_empty (gimp_image_get_mask (image)))    {      GimpImage *clip_image;      clip_image = gimp_image_new_from_drawable (image->gimp, drawable);      gimp_container_remove (image->gimp->images, GIMP_OBJECT (clip_image));      gimp_set_clipboard_image (image->gimp, clip_image);      g_object_unref (clip_image);      return GIMP_OBJECT (gimp_get_clipboard_image (image->gimp));    }  else    {      GimpBuffer *buffer;      buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable),                                  context, FALSE, error);      if (buffer)        {          gimp_set_clipboard_buffer (image->gimp, buffer);          g_object_unref (buffer);          return GIMP_OBJECT (gimp_get_clipboard_buffer (image->gimp));        }    }  return NULL;}

GimpLayer *gimp_image_pick_layer_by_bounds (const GimpImage *image,                                 gint             x,                                 gint             y){  GList *all_layers;  GList *list;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  all_layers = gimp_image_get_layer_list (image);  for (list = all_layers; list; list = g_list_next (list))    {      GimpLayer *layer = list->data;      if (gimp_item_get_visible (GIMP_ITEM (layer)))        {          gint off_x, off_y;          gint width, height;          gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y);          width  = gimp_item_get_width  (GIMP_ITEM (layer));          height = gimp_item_get_height (GIMP_ITEM (layer));          if (x >= off_x        &&              y >= off_y        &&              x < off_x + width &&              y < off_y + height)            {              g_list_free (all_layers);              return layer;            }        }    }  g_list_free (all_layers);  return NULL;}

gbooleangimp_edit_fade (GimpImage   *image,                GimpContext *context){  GimpDrawableUndo *undo;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  undo = GIMP_DRAWABLE_UNDO (gimp_image_undo_get_fadeable (image));  if (undo && undo->applied_buffer)    {      GimpDrawable *drawable;      GeglBuffer   *buffer;      drawable = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item);      g_object_ref (undo);      buffer = g_object_ref (undo->applied_buffer);      gimp_image_undo (image);      gimp_drawable_apply_buffer (drawable, buffer,                                  GEGL_RECTANGLE (0, 0,                                                  gegl_buffer_get_width (undo->buffer),                                                  gegl_buffer_get_height (undo->buffer)),                                  TRUE,                                  gimp_object_get_name (undo),                                  gimp_context_get_opacity (context),                                  gimp_context_get_paint_mode (context),                                  NULL, undo->x, undo->y);      g_object_unref (buffer);      g_object_unref (undo);      return TRUE;    }  return FALSE;}

voidgimp_image_add_colormap_entry (GimpImage     *image,                               const GimpRGB *color){  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (image->colormap != NULL);  g_return_if_fail (image->n_colors < 256);  g_return_if_fail (color != NULL);  gimp_image_undo_push_image_colormap (image,                                       _("Add Color to Colormap"));  gimp_rgb_get_uchar (color,                      &image->colormap[image->n_colors * 3],                      &image->colormap[image->n_colors * 3 + 1],                      &image->colormap[image->n_colors * 3 + 2]);  image->n_colors++;  gimp_image_colormap_changed (image, -1);}

GimpUndo *gimp_image_undo_push_layer_mask_remove (GimpImage     *image,                                        const gchar   *undo_desc,                                        GimpLayer     *layer,                                        GimpLayerMask *mask){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL);  g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (mask)), NULL);  g_return_val_if_fail (gimp_layer_mask_get_layer (mask) == layer, NULL);  g_return_val_if_fail (gimp_layer_get_mask (layer) == mask, NULL);  return gimp_image_undo_push (image, GIMP_TYPE_LAYER_MASK_UNDO,                               GIMP_UNDO_LAYER_MASK_REMOVE, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item",       layer,                               "layer-mask", mask,                               NULL);}

GimpColorProfile *gimp_image_get_builtin_color_profile (GimpImage *image){  static GimpColorProfile *srgb_profile       = NULL;  static GimpColorProfile *linear_rgb_profile = NULL;  const  Babl             *format;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  if (! srgb_profile)    {      srgb_profile       = gimp_color_profile_new_srgb ();      linear_rgb_profile = gimp_color_profile_new_linear_rgb ();    }  format = gimp_image_get_layer_format (image, FALSE);  if (gimp_babl_format_get_linear (format))    {      if (! srgb_profile)        {          srgb_profile = gimp_color_profile_new_srgb ();          g_object_add_weak_pointer (G_OBJECT (srgb_profile),                                     (gpointer) &srgb_profile);        }      return linear_rgb_profile;    }  else    {      if (! linear_rgb_profile)        {          linear_rgb_profile = gimp_color_profile_new_linear_rgb ();          g_object_add_weak_pointer (G_OBJECT (linear_rgb_profile),                                     (gpointer) &linear_rgb_profile);        }      return srgb_profile;    }}

/** * gimp_vectors_export_file: * @image: the #GimpImage from which to export vectors * @vectors: a #GimpVectors object or %NULL to export all vectors in @image * @filename: the name of the file to write * @error: return location for errors * * Exports one or more vectors to a SVG file. * * Return value: %TRUE on success, *               %FALSE if there was an error writing the file **/gbooleangimp_vectors_export_file (const GimpImage    *image,                          const GimpVectors  *vectors,                          const gchar        *filename,                          GError            **error){  FILE    *file;  GString *str;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), FALSE);  g_return_val_if_fail (filename != NULL, FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  file = g_fopen (filename, "w");  if (!file)    {      g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),		   _("Could not open '%s' for writing: %s"),                   gimp_filename_to_utf8 (filename), g_strerror (errno));      return FALSE;    }  str = gimp_vectors_export (image, vectors);  fprintf (file, "%s", str->str);  g_string_free (str, TRUE);  if (fclose (file))    {      g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),		   _("Error while writing '%s': %s"),                   gimp_filename_to_utf8 (filename), g_strerror (errno));      return FALSE;    }  return TRUE;}

voidgimp_image_set_colormap_entry (GimpImage     *image,                               gint           color_index,                               const GimpRGB *color,                               gboolean       push_undo){  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (image->colormap != NULL);  g_return_if_fail (color_index >= 0 && color_index < image->n_colors);  g_return_if_fail (color != NULL);  if (push_undo)    gimp_image_undo_push_image_colormap (image,                                         _("Change Colormap entry"));  gimp_rgb_get_uchar (color,                      &image->colormap[color_index * 3],                      &image->colormap[color_index * 3 + 1],                      &image->colormap[color_index * 3 + 2]);  gimp_image_colormap_changed (image, color_index);}

voidgimp_image_add_sample_point (GimpImage       *image,                             GimpSamplePoint *sample_point,                             gint             x,                             gint             y){  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (sample_point != NULL);  g_return_if_fail (x >= 0);  g_return_if_fail (y >= 0);  g_return_if_fail (x < gimp_image_get_width  (image));  g_return_if_fail (y < gimp_image_get_height (image));  image->sample_points = g_list_append (image->sample_points, sample_point);  sample_point->x = x;  sample_point->y = y;  gimp_sample_point_ref (sample_point);  gimp_image_sample_point_added (image, sample_point);  gimp_image_update_sample_point (image, sample_point);}

GimpSamplePoint *gimp_image_find_sample_point (GimpImage *image,                              gdouble    x,                              gdouble    y,                              gdouble    epsilon_x,                              gdouble    epsilon_y){  GList           *list;  GimpSamplePoint *ret     = NULL;  gdouble          mindist = G_MAXDOUBLE;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (epsilon_x > 0 && epsilon_y > 0, NULL);  if (x < 0 || x >= gimp_image_get_width  (image) ||      y < 0 || y >= gimp_image_get_height (image))    {      return NULL;    }  for (list = image->sample_points; list; list = g_list_next (list))    {      GimpSamplePoint *sample_point = list->data;      gdouble          dist;      if (sample_point->x < 0 || sample_point->y < 0)        continue;      dist = hypot ((sample_point->x + 0.5) - x,                    (sample_point->y + 0.5) - y);      if (dist < MIN (epsilon_y, mindist))        {          mindist = dist;          ret = sample_point;        }    }  return ret;}

GimpColorProfilePolicygimp_query_profile_policy (Gimp                      *gimp,                           GimpImage                 *image,                           GimpContext               *context,                           GimpColorProfile         **dest_profile,                           GimpColorRenderingIntent  *intent,                           gboolean                  *bpc,                           gboolean                  *dont_ask){  g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_COLOR_PROFILE_POLICY_KEEP);  g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_COLOR_PROFILE_POLICY_KEEP);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_COLOR_PROFILE_POLICY_KEEP);  g_return_val_if_fail (dest_profile != NULL, GIMP_COLOR_PROFILE_POLICY_KEEP);  if (gimp->gui.query_profile_policy)    return gimp->gui.query_profile_policy (gimp, image, context,                                           dest_profile,                                           intent, bpc,                                           dont_ask);  return GIMP_COLOR_PROFILE_POLICY_KEEP;}

GimpSamplePoint *gimp_pdb_image_get_sample_point (GimpImage  *image,                                 gint        sample_point_ID,                                 GError    **error){  GimpSamplePoint *sample_point;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  sample_point = gimp_image_get_sample_point (image, sample_point_ID);  if (sample_point)    return sample_point;  g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,               _("Image '%s' (%d) does not contain sample point with ID %d"),               gimp_image_get_display_name (image),               gimp_image_get_ID (image),               sample_point_ID);  return NULL;}

gbooleangimp_pdb_image_is_precision (GimpImage      *image,                             GimpPrecision   precision,                             GError        **error){  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (gimp_image_get_precision (image) == precision)    return TRUE;  g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,               _("Image '%s' (%d) has precision '%s', "                 "but an image of precision '%s' is expected"),               gimp_image_get_display_name (image),               gimp_image_get_ID (image),               gimp_pdb_enum_value_get_nick (GIMP_TYPE_PRECISION,                                             gimp_image_get_precision (image)),               gimp_pdb_enum_value_get_nick (GIMP_TYPE_PRECISION, precision));  return FALSE;}

GimpGuide *gimp_pdb_image_get_guide (GimpImage  *image,                          gint        guide_ID,                          GError    **error){  GimpGuide *guide;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  guide = gimp_image_get_guide (image, guide_ID);  if (guide)    return guide;  g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,               _("Image '%s' (%d) does not contain guide with ID %d"),               gimp_image_get_display_name (image),               gimp_image_get_ID (image),               guide_ID);  return NULL;}

GimpLayerMask *gimp_layer_mask_new_from_buffer (GeglBuffer    *buffer,                                 GimpImage     *image,                                 const gchar   *name,                                 const GimpRGB *color){  GimpLayerMask  *layer_mask;  GeglBuffer *dest;  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  layer_mask = gimp_layer_mask_new (image,                                    gegl_buffer_get_width  (buffer),                                    gegl_buffer_get_height (buffer),                                    name, color);  dest = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer_mask));  gegl_buffer_copy (buffer, NULL, dest, NULL);  return layer_mask;}

voidgimp_image_item_list_translate (GimpImage *image,                                GList     *list,                                gint       offset_x,                                gint       offset_y,                                gboolean   push_undo){  g_return_if_fail (GIMP_IS_IMAGE (image));  if (list)    {      GList *l;      if (list->next)        {          if (push_undo)            {              gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_DISPLACE,                                           C_("undo-type", "Translate Items"));            }          for (l = list; l; l = g_list_next (l))            gimp_item_start_transform (GIMP_ITEM (l->data), push_undo);        }      for (l = list; l; l = g_list_next (l))        gimp_item_translate (GIMP_ITEM (l->data),                             offset_x, offset_y, push_undo);      if (list->next)        {          for (l = list; l; l = g_list_next (l))            gimp_item_end_transform (GIMP_ITEM (l->data), push_undo);          if (push_undo)            gimp_image_undo_group_end (image);        }    }}

gbooleangimp_pdb_image_is_base_type (GimpImage          *image,                             GimpImageBaseType   type,                             GError            **error){  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (gimp_image_get_base_type (image) == type)    return TRUE;  g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,               _("Image '%s' (%d) is of type '%s', "                 "but an image of type '%s' is expected"),               gimp_image_get_display_name (image),               gimp_image_get_ID (image),               gimp_pdb_enum_value_get_nick (GIMP_TYPE_IMAGE_BASE_TYPE,                                             gimp_image_get_base_type (image)),               gimp_pdb_enum_value_get_nick (GIMP_TYPE_IMAGE_BASE_TYPE, type));  return FALSE;}

voidgimp_image_item_list_rotate (GimpImage        *image,                             GList            *list,                             GimpContext      *context,                             GimpRotationType  rotate_type,                             gdouble           center_x,                             gdouble           center_y,                             gboolean          clip_result){  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (GIMP_IS_CONTEXT (context));  if (list)    {      GList *l;      if (list->next)        {          gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,                                       C_("undo-type", "Rotate Items"));          for (l = list; l; l = g_list_next (l))            gimp_item_start_transform (GIMP_ITEM (l->data), TRUE);        }      for (l = list; l; l = g_list_next (l))        gimp_item_rotate (GIMP_ITEM (l->data), context,                          rotate_type, center_x, center_y, clip_result);      if (list->next)        {          for (l = list; l; l = g_list_next (l))            gimp_item_end_transform (GIMP_ITEM (l->data), TRUE);          gimp_image_undo_group_end (image);        }    }}

voidgimp_edit_fill (GimpImage       *image,                GimpDrawable    *drawable,                GimpFillOptions *options,                const gchar     *undo_desc){  GeglBuffer  *buffer;  gint         x, y, width, height;  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  g_return_if_fail (GIMP_IS_FILL_OPTIONS (options));  if (! gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &width, &height))    return;  /*  nothing to do, but the fill succeeded  */  buffer = gimp_fill_options_create_buffer (options, drawable,                                            GEGL_RECTANGLE (0, 0,                                                            width, height));  if (! undo_desc)    undo_desc = gimp_fill_options_get_undo_desc (options);  gimp_drawable_apply_buffer (drawable, buffer,                              GEGL_RECTANGLE (0, 0, width, height),                              TRUE, undo_desc,                              gimp_context_get_opacity (GIMP_CONTEXT (options)),                              gimp_context_get_paint_mode (GIMP_CONTEXT (options)),                              GIMP_LAYER_COLOR_SPACE_AUTO,                              GIMP_LAYER_COLOR_SPACE_AUTO,                              GIMP_LAYER_COMPOSITE_AUTO,                              NULL, x, y);  g_object_unref (buffer);  gimp_drawable_update (drawable, x, y, width, height);}

GimpSamplePoint *gimp_image_add_sample_point_at_pos (GimpImage *image,                                    gint       x,                                    gint       y,                                    gboolean   push_undo){  GimpSamplePoint *sample_point;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (x >= 0 && x < gimp_image_get_width  (image), NULL);  g_return_val_if_fail (y >= 0 && y < gimp_image_get_height (image), NULL);  sample_point = gimp_sample_point_new (image->gimp->next_sample_point_ID++);  if (push_undo)    gimp_image_undo_push_sample_point (image, _("Add Sample Point"),                                       sample_point);  gimp_image_add_sample_point (image, sample_point, x, y);  gimp_sample_point_unref (sample_point);  return sample_point;}

GimpGuide *gimp_image_add_hguide (GimpImage *image,                       gint       position,                       gboolean   push_undo){  GimpGuide *guide;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (position >= 0 &&                        position <= gimp_image_get_height (image), NULL);  guide = gimp_guide_new (GIMP_ORIENTATION_HORIZONTAL,                          image->gimp->next_guide_ID++);  if (push_undo)    gimp_image_undo_push_guide (image,                                C_("undo-type", "Add Horizontal Guide"), guide);  gimp_image_add_guide (image, guide, position);  g_object_unref (G_OBJECT (guide));  return guide;}

voidgimp_image_move_sample_point (GimpImage       *image,                              GimpSamplePoint *sample_point,                              gint             x,                              gint             y,                              gboolean         push_undo){  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (sample_point != NULL);  g_return_if_fail (x >= 0);  g_return_if_fail (y >= 0);  g_return_if_fail (x < gimp_image_get_width  (image));  g_return_if_fail (y < gimp_image_get_height (image));  if (push_undo)    gimp_image_undo_push_sample_point (image, _("Move Sample Point"),                                       sample_point);  gimp_image_update_sample_point (image, sample_point);  sample_point->x = x;  sample_point->y = y;  gimp_image_update_sample_point (image, sample_point);}

GimpGuide *gimp_image_add_vguide (GimpImage *image,                       gint       position,                       gboolean   push_undo){  GimpGuide *guide;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (position >= 0 &&                        position <= gimp_image_get_width (image), NULL);  guide = gimp_guide_new (GIMP_ORIENTATION_VERTICAL,                          image->gimp->next_guide_ID++);  if (push_undo)    gimp_image_undo_push_guide (image,                                C_("undo-type", "Add Vertical Guide"), guide);  gimp_image_add_guide (image, guide, position);  g_object_unref (guide);  return guide;}

const guint8 *gimp_image_get_icc_profile (GimpImage *image,                            gsize     *length){  const GimpParasite *parasite;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  parasite = gimp_image_parasite_find (image, GIMP_ICC_PROFILE_PARASITE_NAME);  if (parasite)    {      if (length)        *length = gimp_parasite_data_size (parasite);      return gimp_parasite_data (parasite);    }  if (length)    *length = 0;  return NULL;}

gbooleangimp_paint_options_get_gradient_color (GimpPaintOptions *paint_options,                                       GimpImage        *image,                                       gdouble           grad_point,                                       gdouble           pixel_dist,                                       GimpRGB          *color){  GimpGradientOptions *gradient_options;  GimpGradient        *gradient;  GimpDynamics        *dynamics;  GimpDynamicsOutput  *color_output;  g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (color != NULL, FALSE);  gradient_options = paint_options->gradient_options;  gradient = gimp_context_get_gradient (GIMP_CONTEXT (paint_options));  dynamics = gimp_context_get_dynamics (GIMP_CONTEXT (paint_options));  color_output = gimp_dynamics_get_output (dynamics,                                           GIMP_DYNAMICS_OUTPUT_COLOR);  if (gimp_dynamics_output_is_enabled (color_output))    {      gimp_gradient_get_color_at (gradient, GIMP_CONTEXT (paint_options),                                  NULL, grad_point,                                  gradient_options->gradient_reverse,                                  color);      return TRUE;    }  return FALSE;}

GimpColorProfilegimp_image_get_profile (GimpImage  *image,                        GError    **error){  GimpColorConfig    *config;  const GimpParasite *parasite;  GimpColorProfile   *profile = NULL;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  config = image->gimp->config->color_management;  parasite = gimp_image_get_icc_profile (image);  if (parasite)    {      return gimp_lcms_profile_open_from_data (gimp_parasite_data (parasite),                                               gimp_parasite_data_size (parasite),                                               error);    }  else if (config->rgb_profile)    {      profile = gimp_lcms_profile_open_from_file (config->rgb_profile, error);      if (profile && ! gimp_lcms_profile_is_rgb (profile))        {          g_set_error (error, GIMP_ERROR, GIMP_FAILED,                       _("Color profile '%s' is not for RGB color space"),                       gimp_filename_to_utf8 (config->rgb_profile));          cmsCloseProfile (profile);          profile = NULL;        }    }  return profile;}

GtkWidget *image_scale_dialog_new (GimpImage             *image,                        GimpContext           *context,                        GtkWidget             *parent,                        GimpUnit               unit,                        GimpInterpolationType  interpolation,                        GimpScaleCallback      callback,                        gpointer               user_data){  ImageScaleDialog *dialog;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);  g_return_val_if_fail (callback != NULL, NULL);  dialog = g_slice_new0 (ImageScaleDialog);  dialog->image  = image;  dialog->dialog = scale_dialog_new (GIMP_VIEWABLE (image), context,                                     C_("dialog-title", "Scale Image"),                                     "gimp-image-scale",                                     parent,                                     gimp_standard_help_func,                                     GIMP_HELP_IMAGE_SCALE,                                     unit,                                     interpolation,                                     image_scale_callback,                                     dialog);  g_object_weak_ref (G_OBJECT (dialog->dialog),                     (GWeakNotify) image_scale_dialog_free, dialog);  dialog->callback  = callback;  dialog->user_data = user_data;  return dialog->dialog;}

GimpLayer *gimp_image_flatten (GimpImage   *image,                    GimpContext *context){  GList     *list;  GSList    *merge_list = NULL;  GimpLayer *layer;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);  gimp_set_busy (image->gimp);  /* if there's a floating selection, anchor it */  if (gimp_image_floating_sel (image))    floating_sel_anchor (image->floating_sel);  for (list = GIMP_LIST (image->layers)->list;       list;       list = g_list_next (list))    {      layer = list->data;      if (gimp_item_get_visible (GIMP_ITEM (layer)))        merge_list = g_slist_append (merge_list, layer);    }  layer = gimp_image_merge_layers (image, merge_list, context,                                   GIMP_FLATTEN_IMAGE, _("Flatten Image"));  g_slist_free (merge_list);  gimp_image_alpha_changed (image);  gimp_unset_busy (image->gimp);  return layer;}