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

GimpUndo *gimp_image_undo_push_channel_remove (GimpImage   *image,                                     const gchar *undo_desc,                                     GimpChannel *channel,                                     GimpChannel *prev_parent,                                     gint         prev_position,                                     GimpChannel *prev_channel){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)), NULL);  g_return_val_if_fail (prev_parent == NULL || GIMP_IS_CHANNEL (prev_parent),                        NULL);  g_return_val_if_fail (prev_channel == NULL || GIMP_IS_CHANNEL (prev_channel),                        NULL);  return gimp_image_undo_push (image, GIMP_TYPE_CHANNEL_UNDO,                               GIMP_UNDO_CHANNEL_REMOVE, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item",          channel,                               "prev-parent",   prev_parent,                               "prev-position", prev_position,                               "prev-channel",  prev_channel,                               NULL);}

voidgimp_channel_combine_mask (GimpChannel    *mask,                           GimpChannel    *add_on,                           GimpChannelOps  op,                           gint            off_x,                           gint            off_y){  PixelRegion srcPR, destPR;  gint        x, y, w, h;  g_return_if_fail (GIMP_IS_CHANNEL (mask));  g_return_if_fail (GIMP_IS_CHANNEL (add_on));  if (! gimp_rectangle_intersect (off_x, off_y,                                  gimp_item_get_width  (GIMP_ITEM (add_on)),                                  gimp_item_get_height (GIMP_ITEM (add_on)),                                  0, 0,                                  gimp_item_get_width  (GIMP_ITEM (mask)),                                  gimp_item_get_height (GIMP_ITEM (mask)),                                  &x, &y, &w, &h))    return;  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (add_on)),                     x - off_x, y - off_y, w, h, FALSE);  pixel_region_init (&destPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)),                     x, y, w, h, TRUE);  switch (op)    {    case GIMP_CHANNEL_OP_ADD:    case GIMP_CHANNEL_OP_REPLACE:      pixel_regions_process_parallel ((PixelProcessorFunc)                                      gimp_channel_combine_sub_region_add,                                      NULL, 2, &srcPR, &destPR);      break;    case GIMP_CHANNEL_OP_SUBTRACT:      pixel_regions_process_parallel ((PixelProcessorFunc)                                      gimp_channel_combine_sub_region_sub,                                      NULL, 2, &srcPR, &destPR);      break;    case GIMP_CHANNEL_OP_INTERSECT:      pixel_regions_process_parallel ((PixelProcessorFunc)                                      gimp_channel_combine_sub_region_intersect,                                      NULL, 2, &srcPR, &destPR);      break;    default:      g_warning ("%s: unknown operation type", G_STRFUNC);      break;    }  mask->bounds_known = FALSE;  gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h);}

voidgimp_channel_select_channel (GimpChannel    *channel,                             const gchar    *undo_desc,                             GimpChannel    *add_on,                             gint            offset_x,                             gint            offset_y,                             GimpChannelOps  op,                             gboolean        feather,                             gdouble         feather_radius_x,                             gdouble         feather_radius_y){  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (GIMP_IS_CHANNEL (add_on));  gimp_channel_push_undo (channel, undo_desc);  /*  if applicable, replace the current selection  */  if (op == GIMP_CHANNEL_OP_REPLACE)    gimp_channel_clear (channel, NULL, FALSE);  if (feather || op == GIMP_CHANNEL_OP_INTERSECT)    {      GimpItem    *item = GIMP_ITEM (channel);      GimpChannel *add_on2;      add_on2 = gimp_channel_new_mask (gimp_item_get_image (item),                                       gimp_item_width (item),                                       gimp_item_height (item));      gimp_channel_combine_mask (add_on2, add_on, GIMP_CHANNEL_OP_ADD,                                 offset_x, offset_y);      if (feather)        gimp_channel_feather (add_on2,                              feather_radius_x,                              feather_radius_y,                              FALSE /* no undo */);      gimp_channel_combine_mask (channel, add_on2, op, 0, 0);      g_object_unref (add_on2);    }  else    {      gimp_channel_combine_mask (channel, add_on, op, offset_x, offset_y);    }}

static voidgimp_channel_undo_constructed (GObject *object){  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_CHANNEL (GIMP_ITEM_UNDO (object)->item));}

GimpTransformResizegimp_drawable_transform_get_effective_clip (GimpDrawable        *drawable,                                            GeglBuffer          *orig_buffer,                                            GimpTransformResize  clip_result){  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), clip_result);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)),                                               clip_result);  g_return_val_if_fail (orig_buffer == NULL || GEGL_IS_BUFFER (orig_buffer),                        clip_result);  /*  Always clip unfloated buffers since they must keep their size  */  if (GIMP_IS_CHANNEL (drawable))    {      if (orig_buffer)        {          if (! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer)))            clip_result = GIMP_TRANSFORM_RESIZE_CLIP;        }      else        {          GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));          if (gimp_channel_is_empty (gimp_image_get_mask (image)))            clip_result = GIMP_TRANSFORM_RESIZE_CLIP;        }    }  return clip_result;}

voidfloating_sel_activate_drawable (GimpLayer *layer){  GimpImage    *image;  GimpDrawable *drawable;  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  image = gimp_item_get_image (GIMP_ITEM (layer));  drawable = gimp_layer_get_floating_sel_drawable (layer);  /*  set the underlying drawable to active  */  if (GIMP_IS_LAYER_MASK (drawable))    {      GimpLayerMask *mask = GIMP_LAYER_MASK (drawable);      gimp_image_set_active_layer (image, gimp_layer_mask_get_layer (mask));    }  else if (GIMP_IS_CHANNEL (drawable))    {      gimp_image_set_active_channel (image, GIMP_CHANNEL (drawable));    }  else    {      gimp_image_set_active_layer (image, GIMP_LAYER (drawable));    }}

voidgimp_channel_select_polygon (GimpChannel    *channel,                             const gchar    *undo_desc,                             gint            n_points,                             GimpVector2    *points,                             GimpChannelOps  op,                             gboolean        antialias,                             gboolean        feather,                             gdouble         feather_radius_x,                             gdouble         feather_radius_y,                             gboolean        push_undo){  GimpScanConvert *scan_convert;  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  scan_convert = gimp_scan_convert_new ();  gimp_scan_convert_add_polyline (scan_convert, n_points, points, TRUE);  gimp_channel_select_scan_convert (channel, undo_desc, scan_convert, 0, 0,                                    op, antialias, feather,                                    feather_radius_x, feather_radius_y,                                    push_undo);  gimp_scan_convert_free (scan_convert);}

voidgimp_channel_select_vectors (GimpChannel    *channel,                             const gchar    *undo_desc,                             GimpVectors    *vectors,                             GimpChannelOps  op,                             gboolean        antialias,                             gboolean        feather,                             gdouble         feather_radius_x,                             gdouble         feather_radius_y,                             gboolean        push_undo){  const GimpBezierDesc *bezier;  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (GIMP_IS_VECTORS (vectors));  bezier = gimp_vectors_get_bezier (vectors);  if (bezier && bezier->num_data > 4)    {      GimpScanConvert *scan_convert;      scan_convert = gimp_scan_convert_new ();      gimp_scan_convert_add_bezier (scan_convert, bezier);      gimp_channel_select_scan_convert (channel, undo_desc, scan_convert, 0, 0,                                        op, antialias, feather,                                        feather_radius_x, feather_radius_y,                                        push_undo);      gimp_scan_convert_free (scan_convert);    }}

static voidgimp_mask_undo_constructed (GObject *object){  GimpMaskUndo *mask_undo = GIMP_MASK_UNDO (object);  GimpChannel  *channel;  GimpDrawable *drawable;  gint          x1, y1, x2, y2;  if (G_OBJECT_CLASS (parent_class)->constructed)    G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_CHANNEL (GIMP_ITEM_UNDO (object)->item));  channel  = GIMP_CHANNEL (GIMP_ITEM_UNDO (object)->item);  drawable = GIMP_DRAWABLE (channel);  if (gimp_channel_bounds (channel, &x1, &y1, &x2, &y2))    {      mask_undo->buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,                                                           x2 - x1, y2 - y1),                                           gimp_drawable_get_format (drawable));      gegl_buffer_copy (gimp_drawable_get_buffer (drawable),                        GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1),                        mask_undo->buffer,                        GEGL_RECTANGLE (0, 0, 0, 0));      mask_undo->x = x1;      mask_undo->y = y1;    }  mask_undo->format = gimp_drawable_get_format (drawable);}

voidgimp_channel_combine_buffer (GimpChannel    *mask,                             GeglBuffer     *add_on_buffer,                             GimpChannelOps  op,                             gint            off_x,                             gint            off_y){  GeglBuffer *buffer;  gint        x, y, w, h;  g_return_if_fail (GIMP_IS_CHANNEL (mask));  g_return_if_fail (GEGL_IS_BUFFER (add_on_buffer));  buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));  if (! gimp_gegl_mask_combine_buffer (buffer, add_on_buffer,                                       op, off_x, off_y))    return;  gimp_rectangle_intersect (off_x, off_y,                            gegl_buffer_get_width  (add_on_buffer),                            gegl_buffer_get_height (add_on_buffer),                            0, 0,                            gimp_item_get_width  (GIMP_ITEM (mask)),                            gimp_item_get_height (GIMP_ITEM (mask)),                            &x, &y, &w, &h);  mask->bounds_known = FALSE;  gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h);}

voidgimp_channel_select_round_rect (GimpChannel         *channel,                                gint                 x,                                gint                 y,                                gint                 w,                                gint                 h,                                gdouble              corner_radius_x,                                gdouble              corner_radius_y,                                GimpChannelOps       op,                                gboolean             antialias,                                gboolean             feather,                                gdouble              feather_radius_x,                                gdouble              feather_radius_y,                                gboolean             push_undo){  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  if (push_undo)    gimp_channel_push_undo (channel, C_("undo-type", "Rounded Rectangle Select"));  /*  if applicable, replace the current selection  */  if (op == GIMP_CHANNEL_OP_REPLACE)    gimp_channel_clear (channel, NULL, FALSE);  /*  if feathering for rect, make a new mask with the   *  rectangle and feather that with the old mask   */  if (feather || op == GIMP_CHANNEL_OP_INTERSECT)    {      GimpItem   *item = GIMP_ITEM (channel);      GeglBuffer *add_on;      add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0,                                                gimp_item_get_width  (item),                                                gimp_item_get_height (item)),                                babl_format ("Y float"));      gimp_gegl_mask_combine_ellipse_rect (add_on, GIMP_CHANNEL_OP_ADD,                                           x, y, w, h,                                           corner_radius_x, corner_radius_y,                                           antialias);      if (feather)        gimp_gegl_apply_feather (add_on, NULL, NULL, add_on, NULL,                                 feather_radius_x,                                 feather_radius_y);      gimp_channel_combine_buffer (channel, add_on, op, 0, 0);      g_object_unref (add_on);    }  else    {      gimp_channel_combine_ellipse_rect (channel, op, x, y, w, h,                                         corner_radius_x, corner_radius_y,                                         antialias);    }}

voidgimp_channel_select_round_rect (GimpChannel         *channel,                                gint                 x,                                gint                 y,                                gint                 w,                                gint                 h,                                gdouble              corner_radius_x,                                gdouble              corner_radius_y,                                GimpChannelOps       op,                                gboolean             antialias,                                gboolean             feather,                                gdouble              feather_radius_x,                                gdouble              feather_radius_y,                                gboolean             push_undo){  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  if (push_undo)    gimp_channel_push_undo (channel, Q_("command|Rounded Rectangle Select"));  /*  if applicable, replace the current selection  */  if (op == GIMP_CHANNEL_OP_REPLACE)    gimp_channel_clear (channel, NULL, FALSE);  /*  if feathering for rect, make a new mask with the   *  rectangle and feather that with the old mask   */  if (feather || op == GIMP_CHANNEL_OP_INTERSECT)    {      GimpItem    *item = GIMP_ITEM (channel);      GimpChannel *add_on;      add_on = gimp_channel_new_mask (gimp_item_get_image (item),                                      gimp_item_width (item),                                      gimp_item_height (item));      gimp_channel_combine_ellipse_rect (add_on, GIMP_CHANNEL_OP_ADD,                                         x, y, w, h,                                         corner_radius_x, corner_radius_y,                                         antialias);      if (feather)        gimp_channel_feather (add_on,                              feather_radius_x,                              feather_radius_y,                              FALSE /* no undo */);      gimp_channel_combine_mask (channel, add_on, op, 0, 0);      g_object_unref (add_on);    }  else    {      gimp_channel_combine_ellipse_rect (channel, op, x, y, w, h,                                         corner_radius_x, corner_radius_y,                                         antialias);    }}

GimpDrawable *gimp_drawable_transform_paste (GimpDrawable     *drawable,                               GeglBuffer       *buffer,                               GimpColorProfile *buffer_profile,                               gint              offset_x,                               gint              offset_y,                               gboolean          new_layer){  GimpImage   *image;  GimpLayer   *layer     = NULL;  const gchar *undo_desc = 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 (GEGL_IS_BUFFER (buffer), NULL);  g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (buffer_profile), NULL);  image = gimp_item_get_image (GIMP_ITEM (drawable));  if (GIMP_IS_LAYER (drawable))    undo_desc = C_("undo-type", "Transform Layer");  else if (GIMP_IS_CHANNEL (drawable))    undo_desc = C_("undo-type", "Transform Channel");  else    return NULL;  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, undo_desc);  if (new_layer)    {      layer =        gimp_layer_new_from_gegl_buffer (buffer, image,                                         gimp_drawable_get_format_with_alpha (drawable),                                         _("Transformation"),                                         GIMP_OPACITY_OPAQUE,                                         gimp_image_get_default_new_layer_mode (image),                                         buffer_profile);      gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y);      floating_sel_attach (layer, drawable);      drawable = GIMP_DRAWABLE (layer);    }  else    {      gimp_drawable_set_buffer_full (drawable, TRUE, NULL,                                     buffer,                                     offset_x, offset_y,                                     TRUE);    }  gimp_image_undo_group_end (image);  return drawable;}

voidfloating_sel_to_layer (GimpLayer *layer){  GimpItem  *item;  GimpImage *image;  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  item = GIMP_ITEM (layer);  if (! (image = gimp_item_get_image (item)))    return;  /*  Check if the floating layer belongs to a channel...  */  if (GIMP_IS_CHANNEL (layer->fs.drawable))    {      gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING,                    _("Cannot create a new layer from the floating selection "                      "because it belongs to a layer mask or channel."));      return;    }  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_TO_LAYER,                               _("Floating Selection to Layer"));  /*  restore the contents of the drawable  */  floating_sel_restore (layer,                        item->offset_x,                        item->offset_y,                        item->width,                        item->height);  gimp_image_undo_push_fs_to_layer (image, NULL, layer);  /*  clear the selection  */  gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (layer));  /*  Set pointers  */  layer->fs.drawable   = NULL;  image->floating_sel = NULL;  gimp_item_set_visible (GIMP_ITEM (layer), TRUE, TRUE);  gimp_layer_set_lock_alpha (layer, FALSE, TRUE);  gimp_image_undo_group_end (image);  gimp_object_name_changed (GIMP_OBJECT (layer));  gimp_drawable_update (GIMP_DRAWABLE (layer),                        0, 0,                        GIMP_ITEM (layer)->width,                        GIMP_ITEM (layer)->height);  gimp_image_floating_selection_changed (image);}

GimpUndo *gimp_image_undo_push_channel_add (GimpImage   *image,                                  const gchar *undo_desc,                                  GimpChannel *channel,                                  GimpChannel *prev_channel){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);  g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (channel)), NULL);  g_return_val_if_fail (prev_channel == NULL || GIMP_IS_CHANNEL (prev_channel),                        NULL);  return gimp_image_undo_push (image, GIMP_TYPE_CHANNEL_UNDO,                               GIMP_UNDO_CHANNEL_ADD, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item",         channel,                               "prev-channel", prev_channel,                               NULL);}

voidgimp_channel_combine_rect (GimpChannel    *mask,                           GimpChannelOps  op,                           gint            x,                           gint            y,                           gint            w,                           gint            h){  GeglBuffer *buffer;  g_return_if_fail (GIMP_IS_CHANNEL (mask));  buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));  if (! gimp_gegl_mask_combine_rect (buffer, op, x, y, w, h))    return;  gimp_rectangle_intersect (x, y, w, h,                            0, 0,                            gimp_item_get_width  (GIMP_ITEM (mask)),                            gimp_item_get_height (GIMP_ITEM (mask)),                            &x, &y, &w, &h);  /*  Determine new boundary  */  if (mask->bounds_known && (op == GIMP_CHANNEL_OP_ADD) && ! mask->empty)    {      if (x < mask->x1)        mask->x1 = x;      if (y < mask->y1)        mask->y1 = y;      if ((x + w) > mask->x2)        mask->x2 = (x + w);      if ((y + h) > mask->y2)        mask->y2 = (y + h);    }  else if (op == GIMP_CHANNEL_OP_REPLACE || mask->empty)    {      mask->empty = FALSE;      mask->x1    = x;      mask->y1    = y;      mask->x2    = x + w;      mask->y2    = y + h;    }  else    {      mask->bounds_known = FALSE;    }  mask->x1 = CLAMP (mask->x1, 0, gimp_item_get_width  (GIMP_ITEM (mask)));  mask->y1 = CLAMP (mask->y1, 0, gimp_item_get_height (GIMP_ITEM (mask)));  mask->x2 = CLAMP (mask->x2, 0, gimp_item_get_width  (GIMP_ITEM (mask)));  mask->y2 = CLAMP (mask->y2, 0, gimp_item_get_height (GIMP_ITEM (mask)));  gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h);}

voidgimp_channel_select_channel (GimpChannel    *channel,                             const gchar    *undo_desc,                             GimpChannel    *add_on,                             gint            offset_x,                             gint            offset_y,                             GimpChannelOps  op,                             gboolean        feather,                             gdouble         feather_radius_x,                             gdouble         feather_radius_y){  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (GIMP_IS_CHANNEL (add_on));  gimp_channel_select_buffer (channel, undo_desc,                              gimp_drawable_get_buffer (GIMP_DRAWABLE (add_on)),                              offset_x, offset_y, op,                              feather,                              feather_radius_x, feather_radius_y);}

gbooleanfloating_sel_to_layer (GimpLayer  *layer,                       GError    **error){  GimpItem  *item;  GimpImage *image;  g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);  g_return_val_if_fail (gimp_layer_is_floating_sel (layer), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  item  = GIMP_ITEM (layer);  image = gimp_item_get_image (item);  /*  Check if the floating layer belongs to a channel  */  if (GIMP_IS_CHANNEL (gimp_layer_get_floating_sel_drawable (layer)))    {      g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,			   _("Cannot create a new layer from the floating "			     "selection because it belongs to a layer mask "			     "or channel."));      return FALSE;    }  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_TO_LAYER,                               C_("undo-type", "Floating Selection to Layer"));  gimp_image_undo_push_fs_to_layer (image, NULL, layer);  gimp_drawable_detach_floating_sel (gimp_layer_get_floating_sel_drawable (layer));  gimp_layer_set_floating_sel_drawable (layer, NULL);  gimp_item_set_visible (item, TRUE, TRUE);  gimp_layer_set_lock_alpha (layer, FALSE, TRUE);  gimp_image_undo_group_end (image);  /* When the floating selection is converted to/from a normal layer   * it does something resembling a name change, so emit the   * "name-changed" signal   */  gimp_object_name_changed (GIMP_OBJECT (layer));  gimp_drawable_update (GIMP_DRAWABLE (layer),                        0, 0,                        gimp_item_get_width  (item),                        gimp_item_get_height (item));  return TRUE;}

voidgimp_drawable_foreground_extract_siox (GimpDrawable       *mask,                                       SioxState          *state,                                       SioxRefinementType  refinement,                                       gint                smoothness,                                       const gdouble       sensitivity[3],                                       gboolean            multiblob,                                       GimpProgress       *progress){  GeglBuffer *buffer;  gint        x1, y1;  gint        x2, y2;  g_return_if_fail (GIMP_IS_DRAWABLE (mask));  g_return_if_fail (babl_format_get_bytes_per_pixel (gimp_drawable_get_format (mask)) == 1);  g_return_if_fail (state != NULL);  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  if (progress)    gimp_progress_start (progress, _("Foreground Extraction"), FALSE);  if (GIMP_IS_CHANNEL (mask))    {      gimp_channel_bounds (GIMP_CHANNEL (mask), &x1, &y1, &x2, &y2);    }  else    {      x1 = 0;      y1 = 0;      x2 = gimp_item_get_width  (GIMP_ITEM (mask));      y2 = gimp_item_get_height (GIMP_ITEM (mask));    }  buffer = gimp_drawable_get_buffer (mask);  siox_foreground_extract (state, refinement,                           gimp_gegl_buffer_get_tiles (buffer),                           x1, y1, x2, y2,                           smoothness, sensitivity, multiblob,                           (SioxProgressFunc) gimp_progress_set_value,                           progress);  if (progress)    gimp_progress_end (progress);  gimp_drawable_update (mask, x1, y1, x2, y2);}

voidgimp_channel_select_fuzzy (GimpChannel         *channel,                           GimpDrawable        *drawable,                           gboolean             sample_merged,                           gint                 x,                           gint                 y,                           gfloat               threshold,                           gboolean             select_transparent,                           GimpSelectCriterion  select_criterion,                           gboolean             diagonal_neighbors,                           GimpChannelOps       op,                           gboolean             antialias,                           gboolean             feather,                           gdouble              feather_radius_x,                           gdouble              feather_radius_y){  GimpPickable *pickable;  GeglBuffer   *add_on;  gint          add_on_x = 0;  gint          add_on_y = 0;  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  if (sample_merged)    pickable = GIMP_PICKABLE (gimp_item_get_image (GIMP_ITEM (drawable)));  else    pickable = GIMP_PICKABLE (drawable);  add_on = gimp_pickable_contiguous_region_by_seed (pickable,                                                    antialias,                                                    threshold,                                                    select_transparent,                                                    select_criterion,                                                    diagonal_neighbors,                                                    x, y);  if (! sample_merged)    gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y);  gimp_channel_select_buffer (channel, C_("undo-type", "Fuzzy Select"),                              add_on, add_on_x, add_on_y,                              op,                              feather,                              feather_radius_x,                              feather_radius_y);  g_object_unref (add_on);}

voidgimp_channel_select_buffer (GimpChannel    *channel,                            const gchar    *undo_desc,                            GeglBuffer     *add_on,                            gint            offset_x,                            gint            offset_y,                            GimpChannelOps  op,                            gboolean        feather,                            gdouble         feather_radius_x,                            gdouble         feather_radius_y){  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (GEGL_IS_BUFFER (add_on));  gimp_channel_push_undo (channel, undo_desc);  /*  if applicable, replace the current selection  */  if (op == GIMP_CHANNEL_OP_REPLACE)    gimp_channel_clear (channel, NULL, FALSE);  if (feather || op == GIMP_CHANNEL_OP_INTERSECT)    {      GimpItem   *item = GIMP_ITEM (channel);      GeglBuffer *add_on2;      add_on2 = gegl_buffer_new (GEGL_RECTANGLE (0, 0,                                                 gimp_item_get_width  (item),                                                 gimp_item_get_height (item)),                                 babl_format ("Y float"));      gimp_gegl_mask_combine_buffer (add_on2, add_on,                                     GIMP_CHANNEL_OP_ADD,                                     offset_x, offset_y);      if (feather)        gimp_gegl_apply_feather (add_on2, NULL, NULL, add_on2, NULL,                                 feather_radius_x,                                 feather_radius_y);      gimp_channel_combine_buffer (channel, add_on2, op, 0, 0);      g_object_unref (add_on2);    }  else    {      gimp_channel_combine_buffer (channel, add_on, op, offset_x, offset_y);    }}

GimpUndo *gimp_image_undo_push_channel_color (GimpImage   *image,                                    const gchar *undo_desc,                                    GimpChannel *channel){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)), NULL);  return gimp_image_undo_push (image, GIMP_TYPE_CHANNEL_PROP_UNDO,                               GIMP_UNDO_CHANNEL_COLOR, undo_desc,                               GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE,                               "item", channel,                               NULL);}

voidgimp_channel_select_scan_convert (GimpChannel     *channel,                                  const gchar     *undo_desc,                                  GimpScanConvert *scan_convert,                                  gint             offset_x,                                  gint             offset_y,                                  GimpChannelOps   op,                                  gboolean         antialias,                                  gboolean         feather,                                  gdouble          feather_radius_x,                                  gdouble          feather_radius_y,                                  gboolean         push_undo){  GimpItem    *item;  GimpChannel *add_on;  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (scan_convert != NULL);  if (push_undo)    gimp_channel_push_undo (channel, undo_desc);  /*  if applicable, replace the current selection  */  if (op == GIMP_CHANNEL_OP_REPLACE)    gimp_channel_clear (channel, NULL, FALSE);  item = GIMP_ITEM (channel);  add_on = gimp_channel_new_mask (gimp_item_get_image (item),                                  gimp_item_width (item),                                  gimp_item_height (item));  gimp_scan_convert_render (scan_convert,                            gimp_drawable_get_tiles (GIMP_DRAWABLE (add_on)),                            offset_x, offset_y, antialias);  if (feather)    gimp_channel_feather (add_on,                          feather_radius_x,                          feather_radius_y,                          FALSE /* no undo */);  gimp_channel_combine_mask (channel, add_on, op, 0, 0);  g_object_unref (add_on);}

voidgimp_channel_select_scan_convert (GimpChannel     *channel,                                  const gchar     *undo_desc,                                  GimpScanConvert *scan_convert,                                  gint             offset_x,                                  gint             offset_y,                                  GimpChannelOps   op,                                  gboolean         antialias,                                  gboolean         feather,                                  gdouble          feather_radius_x,                                  gdouble          feather_radius_y,                                  gboolean         push_undo){  GimpItem   *item;  GeglBuffer *add_on;  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (scan_convert != NULL);  if (push_undo)    gimp_channel_push_undo (channel, undo_desc);  /*  if applicable, replace the current selection  */  if (op == GIMP_CHANNEL_OP_REPLACE)    gimp_channel_clear (channel, NULL, FALSE);  item = GIMP_ITEM (channel);  add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0,                                            gimp_item_get_width  (item),                                            gimp_item_get_height (item)),                            babl_format ("Y float"));  gimp_scan_convert_render (scan_convert, add_on,                            offset_x, offset_y, antialias);  if (feather)    gimp_gegl_apply_feather (add_on, NULL, NULL, add_on, NULL,                             feather_radius_x,                             feather_radius_y);  gimp_channel_combine_buffer (channel, add_on, op, 0, 0);  g_object_unref (add_on);}

voidgimp_channel_select_by_color (GimpChannel         *channel,                              GimpDrawable        *drawable,                              gboolean             sample_merged,                              const GimpRGB       *color,                              gint                 threshold,                              gboolean             select_transparent,                              GimpSelectCriterion  select_criterion,                              GimpChannelOps       op,                              gboolean             antialias,                              gboolean             feather,                              gdouble              feather_radius_x,                              gdouble              feather_radius_y){  GimpItem    *item;  GimpChannel *add_on;  gint         add_on_x = 0;  gint         add_on_y = 0;  g_return_if_fail (GIMP_IS_CHANNEL (channel));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (color != NULL);  item = GIMP_ITEM (channel);  add_on = gimp_image_contiguous_region_by_color (gimp_item_get_image (item),                                                  drawable,                                                  sample_merged,                                                  antialias,                                                  threshold,                                                  select_transparent,                                                  select_criterion,                                                  color);  if (! sample_merged)    gimp_item_offsets (GIMP_ITEM (drawable), &add_on_x, &add_on_y);  gimp_channel_select_channel (channel, Q_("command|Select by Color"),                               add_on, add_on_x, add_on_y,                               op,                               feather,                               feather_radius_x,                               feather_radius_y);  g_object_unref (add_on);}

GimpUndo *gimp_image_undo_push_mask (GimpImage   *image,                           const gchar *undo_desc,                           GimpChannel *mask){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_CHANNEL (mask), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (mask)), NULL);  return gimp_image_undo_push (image, GIMP_TYPE_MASK_UNDO,                               GIMP_UNDO_MASK, undo_desc,                               GIMP_IS_SELECTION (mask) ?                               GIMP_DIRTY_SELECTION :                               GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE,                               "item", mask,                               NULL);}