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

voidgimp_paint_core_validate_undo_tiles (GimpPaintCore *core,                                     GimpDrawable  *drawable,                                     gint           x,                                     gint           y,                                     gint           w,                                     gint           h){  gint i, j;  g_return_if_fail (GIMP_IS_PAINT_CORE (core));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (core->undo_tiles != NULL);  for (i = y; i < (y + h); i += (TILE_HEIGHT - (i % TILE_HEIGHT)))    {      for (j = x; j < (x + w); j += (TILE_WIDTH - (j % TILE_WIDTH)))        {          Tile *dest_tile = tile_manager_get_tile (core->undo_tiles,                                                   j, i, FALSE, FALSE);          if (! tile_is_valid (dest_tile))            {              Tile *src_tile =                tile_manager_get_tile (gimp_drawable_get_tiles (drawable),                                       j, i, TRUE, FALSE);              tile_manager_map_tile (core->undo_tiles, j, i, src_tile);              tile_release (src_tile, FALSE);            }        }    }}

voidgimp_drawable_apply_operation_to_tiles (GimpDrawable *drawable,                                        GimpProgress *progress,                                        const gchar  *undo_desc,                                        GeglNode     *operation,                                        gboolean      linear,                                        TileManager  *new_tiles){  GeglRectangle rect;  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (GEGL_IS_NODE (operation));  g_return_if_fail (new_tiles != NULL);  rect.x      = 0;  rect.y      = 0;  rect.width  = tile_manager_width  (new_tiles);  rect.height = tile_manager_height (new_tiles);  gimp_drawable_apply_operation_private (drawable,                                         progress,                                         undo_desc,                                         operation,                                         linear,                                         new_tiles,                                         &rect);  if (progress)    gimp_progress_end (progress);}

voidgimp_edit_clear (GimpImage    *image,                 GimpDrawable *drawable,                 GimpContext  *context){  GimpFillOptions *options;  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_CONTEXT (context));  options = gimp_fill_options_new (context->gimp);  if (gimp_drawable_has_alpha (drawable))    gimp_fill_options_set_by_fill_type (options, context,                                        GIMP_FILL_TRANSPARENT, NULL);  else    gimp_fill_options_set_by_fill_type (options, context,                                        GIMP_FILL_BACKGROUND, NULL);  gimp_edit_fill (image, drawable, options, C_("undo-type", "Clear"));  g_object_unref (options);}

gbooleangimp_edit_clear (GimpImage    *image,                 GimpDrawable *drawable,                 GimpContext  *context){  GimpRGB              background;  GimpLayerModeEffects paint_mode;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  gimp_context_get_background (context, &background);  if (gimp_drawable_has_alpha (drawable))    paint_mode = GIMP_ERASE_MODE;  else    paint_mode = GIMP_NORMAL_MODE;  return gimp_edit_fill_full (image, drawable,                              &background, NULL,                              GIMP_OPACITY_OPAQUE, paint_mode,                              C_("undo-type", "Clear"));}

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)),                              NULL, x, y);  g_object_unref (buffer);  gimp_drawable_update (drawable, x, y, width, height);}

GeglBuffer *gimp_paint_core_get_paint_buffer (GimpPaintCore    *core,                                  GimpDrawable     *drawable,                                  GimpPaintOptions *paint_options,                                  const GimpCoords *coords,                                  gint             *paint_buffer_x,                                  gint             *paint_buffer_y){  GeglBuffer *paint_buffer;  g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), 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_PAINT_OPTIONS (paint_options), NULL);  g_return_val_if_fail (coords != NULL, NULL);  g_return_val_if_fail (paint_buffer_x != NULL, NULL);  g_return_val_if_fail (paint_buffer_y != NULL, NULL);  paint_buffer =    GIMP_PAINT_CORE_GET_CLASS (core)->get_paint_buffer (core, drawable,                                                        paint_options,                                                        coords,                                                        paint_buffer_x,                                                        paint_buffer_y);  core->paint_buffer_x = *paint_buffer_x;  core->paint_buffer_y = *paint_buffer_y;  return paint_buffer;}

voidgimp_drawable_foreground_extract (GimpDrawable              *drawable,                                  GimpForegroundExtractMode  mode,                                  GimpDrawable              *mask,                                  GimpProgress              *progress){  SioxState    *state;  const gdouble sensitivity[3] = { SIOX_DEFAULT_SENSITIVITY_L,                                   SIOX_DEFAULT_SENSITIVITY_A,                                   SIOX_DEFAULT_SENSITIVITY_B };  g_return_if_fail (GIMP_IS_DRAWABLE (mask));  g_return_if_fail (mode == GIMP_FOREGROUND_EXTRACT_SIOX);  state =    gimp_drawable_foreground_extract_siox_init (drawable,                                                0, 0,                                                gimp_item_get_width  (GIMP_ITEM (mask)),                                                gimp_item_get_height (GIMP_ITEM (mask)));  if (state)    {      gimp_drawable_foreground_extract_siox (mask, state,                                             SIOX_REFINEMENT_RECALCULATE,                                             SIOX_DEFAULT_SMOOTHNESS,                                             sensitivity,                                             FALSE,                                             progress);      gimp_drawable_foreground_extract_siox_done (state);    }}

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;}

gbooleangimp_plug_in_cleanup_remove_shadow (GimpPlugIn   *plug_in,                                    GimpDrawable *drawable){  GimpPlugInProcFrame   *proc_frame;  GimpPlugInCleanupItem *cleanup;  g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);  proc_frame = gimp_plug_in_get_proc_frame (plug_in);  cleanup    = gimp_plug_in_cleanup_item_get (proc_frame, GIMP_ITEM (drawable));  if (! cleanup)    return FALSE;  if (! cleanup->shadow_buffer)    return FALSE;  proc_frame->item_cleanups = g_list_remove (proc_frame->item_cleanups,                                             cleanup);  gimp_plug_in_cleanup_item_free (cleanup);  return TRUE;}

GimpUndo *gimp_image_undo_push_drawable (GimpImage    *image,                               const gchar  *undo_desc,                               GimpDrawable *drawable,                               GeglBuffer   *buffer,                               gint          x,                               gint          y){  GimpItem *item;  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 (GEGL_IS_BUFFER (buffer), NULL);  item = GIMP_ITEM (drawable);  g_return_val_if_fail (gimp_item_is_attached (item), NULL);  return gimp_image_undo_push (image, GIMP_TYPE_DRAWABLE_UNDO,                               GIMP_UNDO_DRAWABLE, undo_desc,                               GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE,                               "item",   item,                               "buffer", buffer,                               "x",      x,                               "y",      y,                               NULL);}

/** * gimp_symmetry_set_origin: * @sym:      the #GimpSymmetry * @drawable: the #GimpDrawable where painting will happen * @origin:   new base coordinates. * * Set the symmetry to new origin coordinates and drawable. **/voidgimp_symmetry_set_origin (GimpSymmetry *sym,                          GimpDrawable *drawable,                          GimpCoords   *origin){  g_return_if_fail (GIMP_IS_SYMMETRY (sym));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_get_image (GIMP_ITEM (drawable)) == sym->image);  if (drawable != sym->drawable)    {      if (sym->drawable)        g_object_unref (sym->drawable);      sym->drawable = g_object_ref (drawable);    }  if (origin != sym->origin)    {      g_free (sym->origin);      sym->origin = g_memdup (origin, sizeof (GimpCoords));    }  g_list_free_full (sym->strokes, g_free);  sym->strokes = NULL;  GIMP_SYMMETRY_GET_CLASS (sym)->update_strokes (sym, drawable, origin);}

const gchar *gimp_edit_named_copy (GimpImage     *image,                      const gchar   *name,                      GimpDrawable  *drawable,                      GimpContext   *context,                      GError       **error){  GimpBuffer *buffer;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (name != NULL, 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);  buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable),                              context, FALSE, error);  if (buffer)    {      gimp_object_set_name (GIMP_OBJECT (buffer), name);      gimp_container_add (image->gimp->named_buffers, GIMP_OBJECT (buffer));      g_object_unref (buffer);      return gimp_object_get_name (buffer);    }  return NULL;}

voidgimp_drawable_stroke_boundary (GimpDrawable       *drawable,                               GimpStrokeOptions  *options,                               const GimpBoundSeg *bound_segs,                               gint                n_bound_segs,                               gint                offset_x,                               gint                offset_y,                               gboolean            push_undo){  GimpScanConvert *scan_convert;  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_STROKE_OPTIONS (options));  g_return_if_fail (bound_segs == NULL || n_bound_segs != 0);  g_return_if_fail (gimp_fill_options_get_style (GIMP_FILL_OPTIONS (options)) !=                    GIMP_FILL_STYLE_PATTERN ||                    gimp_context_get_pattern (GIMP_CONTEXT (options)) != NULL);  scan_convert = gimp_scan_convert_new_from_boundary (bound_segs, n_bound_segs,                                                      offset_x, offset_y);  if (scan_convert)    {      gimp_drawable_stroke_scan_convert (drawable, options,                                         scan_convert, push_undo);      gimp_scan_convert_free (scan_convert);    }}

const GimpBuffer *gimp_edit_copy (GimpImage     *image,                GimpDrawable  *drawable,                GimpContext   *context,                GError       **error){  GimpBuffer *buffer;  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);  buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable),                              context, FALSE, error);  if (buffer)    {      gimp_set_global_buffer (image->gimp, buffer);      g_object_unref (buffer);      return image->gimp->global_buffer;    }  return NULL;}

static voidgimp_drawable_mod_undo_constructed (GObject *object){  GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (object);  GimpItem            *item;  GimpDrawable        *drawable;  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_DRAWABLE (GIMP_ITEM_UNDO (object)->item));  item     = GIMP_ITEM_UNDO (object)->item;  drawable = GIMP_DRAWABLE (item);  if (drawable_mod_undo->copy_buffer)    {      drawable_mod_undo->buffer =        gegl_buffer_dup (gimp_drawable_get_buffer (drawable));    }  else    {      drawable_mod_undo->buffer =        g_object_ref (gimp_drawable_get_buffer (drawable));    }  gimp_item_get_offset (item,                        &drawable_mod_undo->offset_x,                        &drawable_mod_undo->offset_y);}

const Babl *gimp_drawable_get_preview_format (GimpDrawable *drawable){  gboolean alpha;  gboolean linear;  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);  alpha  = gimp_drawable_has_alpha (drawable);  linear = gimp_drawable_get_linear (drawable);  switch (gimp_drawable_get_base_type (drawable))    {    case GIMP_GRAY:      return gimp_babl_format (GIMP_GRAY,                               gimp_babl_precision (GIMP_COMPONENT_TYPE_U8,                                                    linear),                               alpha);    case GIMP_RGB:      return gimp_babl_format (GIMP_RGB,                               gimp_babl_precision (GIMP_COMPONENT_TYPE_U8,                                                    linear),                               alpha);    case GIMP_INDEXED:      if (alpha)        return babl_format ("R'G'B'A u8");      else        return babl_format ("R'G'B' u8");    }  g_return_val_if_reached (NULL);}

gbooleangimp_plug_in_cleanup_add_shadow (GimpPlugIn   *plug_in,                                 GimpDrawable *drawable){  GimpPlugInProcFrame   *proc_frame;  GimpPlugInCleanupItem *cleanup;  g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);  proc_frame = gimp_plug_in_get_proc_frame (plug_in);  cleanup    = gimp_plug_in_cleanup_item_get (proc_frame, GIMP_ITEM (drawable));  if (! cleanup)    {      cleanup = gimp_plug_in_cleanup_item_new (GIMP_ITEM (drawable));      proc_frame->item_cleanups = g_list_prepend (proc_frame->item_cleanups,                                                  cleanup);    }  cleanup->shadow_tiles = TRUE;  return TRUE;}

gbooleangimp_drawable_bucket_fill (GimpDrawable         *drawable,                           GimpContext          *context,                           GimpBucketFillMode    fill_mode,                           gint                  paint_mode,                           gdouble               opacity,                           gboolean              do_seed_fill,                           gboolean              fill_transparent,                           GimpSelectCriterion   fill_criterion,                           gdouble               threshold,                           gboolean              sample_merged,                           gdouble               x,                           gdouble               y,                           GError              **error){  GimpRGB      color;  GimpPattern *pattern = NULL;  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (fill_mode == GIMP_FG_BUCKET_FILL)    {      gimp_context_get_foreground (context, &color);    }  else if (fill_mode == GIMP_BG_BUCKET_FILL)    {      gimp_context_get_background (context, &color);    }  else if (fill_mode == GIMP_PATTERN_BUCKET_FILL)    {      pattern = gimp_context_get_pattern (context);      if (! pattern)        {          g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,			       _("No patterns available for this operation."));          return FALSE;        }    }  else    {      g_warning ("%s: invalid fill_mode passed", G_STRFUNC);      return FALSE;    }  gimp_drawable_bucket_fill_full (drawable,                                  fill_mode,                                  paint_mode, opacity,                                  do_seed_fill,                                  fill_transparent, fill_criterion,                                  threshold, sample_merged,                                  x, y,                                  &color, pattern);  return TRUE;}

voidgimp_drawable_stroke_vectors (GimpDrawable      *drawable,                              GimpStrokeOptions *options,                              GimpVectors       *vectors){  GimpScanConvert *scan_convert;  GimpStroke      *stroke;  gint             num_coords = 0;  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_STROKE_OPTIONS (options));  g_return_if_fail (GIMP_IS_VECTORS (vectors));  scan_convert = gimp_scan_convert_new ();  /* For each Stroke in the vector, interpolate it, and add it to the   * ScanConvert   */  for (stroke = gimp_vectors_stroke_get_next (vectors, NULL);       stroke;       stroke = gimp_vectors_stroke_get_next (vectors, stroke))    {      GArray   *coords;      gboolean  closed;      /* Get the interpolated version of this stroke, and add it to our       * scanconvert.       */      coords = gimp_stroke_interpolate (stroke, 0.2, &closed);      if (coords && coords->len)        {          GimpVector2 *points = g_new0 (GimpVector2, coords->len);          gint         i;          for (i = 0; i < coords->len; i++)            {              points[i].x = g_array_index (coords, GimpCoords, i).x;              points[i].y = g_array_index (coords, GimpCoords, i).y;              num_coords++;            }          gimp_scan_convert_add_polyline (scan_convert, coords->len,                                          points, closed);          g_free (points);        }      if (coords)        g_array_free (coords, TRUE);    }  if (num_coords > 0)    gimp_drawable_stroke_scan_convert (drawable, options, scan_convert);  gimp_scan_convert_free (scan_convert);}

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;}

gbooleangimp_image_pick_color (GimpImage     *image,                       GimpDrawable  *drawable,                       gint           x,                       gint           y,                       gboolean       sample_merged,                       gboolean       sample_average,                       gdouble        average_radius,                       const Babl   **sample_format,                       gpointer       pixel,                       GimpRGB       *color){  GimpPickable *pickable;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), FALSE);  g_return_val_if_fail (drawable == NULL ||                        gimp_item_get_image (GIMP_ITEM (drawable)) == image,                        FALSE);  if (! sample_merged)    {      if (! drawable)        drawable = gimp_image_get_active_drawable (image);      if (! drawable)        return FALSE;    }  if (sample_merged)    {      pickable = GIMP_PICKABLE (image);    }  else    {      gint off_x, off_y;      gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);      x -= off_x;      y -= off_y;      pickable = GIMP_PICKABLE (drawable);    }  /* Do *not* call gimp_pickable_flush() here because it's too expensive   * to call it unconditionally each time e.g. the cursor view is updated.   * Instead, call gimp_pickable_flush() in the callers if needed.   */  if (sample_format)    *sample_format = gimp_pickable_get_format (pickable);  return gimp_pickable_pick_color (pickable, x, y,                                   sample_average, average_radius,                                   pixel, color);}

static voidgimp_drawable_undo_constructed (GObject *object){  GimpDrawableUndo *drawable_undo = GIMP_DRAWABLE_UNDO (object);  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_DRAWABLE (GIMP_ITEM_UNDO (object)->item));  g_assert (drawable_undo->buffer != NULL);}

GimpTempBuf *gimp_drawable_get_sub_preview (GimpDrawable *drawable,                               gint          src_x,                               gint          src_y,                               gint          src_width,                               gint          src_height,                               gint          dest_width,                               gint          dest_height){  GimpItem    *item;  GimpImage   *image;  GeglBuffer  *buffer;  GimpTempBuf *preview;  gdouble      scale;  gint         scaled_x;  gint         scaled_y;  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);  g_return_val_if_fail (src_x >= 0, NULL);  g_return_val_if_fail (src_y >= 0, NULL);  g_return_val_if_fail (src_width  > 0, NULL);  g_return_val_if_fail (src_height > 0, NULL);  g_return_val_if_fail (dest_width  > 0, NULL);  g_return_val_if_fail (dest_height > 0, NULL);  item = GIMP_ITEM (drawable);  g_return_val_if_fail ((src_x + src_width)  <= gimp_item_get_width  (item), NULL);  g_return_val_if_fail ((src_y + src_height) <= gimp_item_get_height (item), NULL);  image = gimp_item_get_image (item);  if (! image->gimp->config->layer_previews)    return NULL;  buffer = gimp_drawable_get_buffer (drawable);  preview = gimp_temp_buf_new (dest_width, dest_height,                               gimp_drawable_get_preview_format (drawable));  scale = MIN ((gdouble) dest_width  / (gdouble) src_width,               (gdouble) dest_height / (gdouble) src_height);  scaled_x = RINT ((gdouble) src_x * scale);  scaled_y = RINT ((gdouble) src_y * scale);  gegl_buffer_get (buffer,                   GEGL_RECTANGLE (scaled_x, scaled_y, dest_width, dest_height),                   scale,                   gimp_temp_buf_get_format (preview),                   gimp_temp_buf_get_data (preview),                   GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);  return preview;}

voidgimp_paint_core_finish (GimpPaintCore *core,                        GimpDrawable  *drawable,                        gboolean       push_undo){  GimpImage *image;  g_return_if_fail (GIMP_IS_PAINT_CORE (core));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  if (core->stroke_buffer)    {      g_array_free (core->stroke_buffer, TRUE);      core->stroke_buffer = NULL;    }  image = gimp_item_get_image (GIMP_ITEM (drawable));  /*  Determine if any part of the image has been altered--   *  if nothing has, then just return...   */  if ((core->x2 == core->x1) || (core->y2 == core->y1))    {      gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable));      return;    }  if (push_undo)    {      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_PAINT,                                   core->undo_desc);      GIMP_PAINT_CORE_GET_CLASS (core)->push_undo (core, image, NULL);      gimp_drawable_push_undo (drawable, NULL,                               core->x1, core->y1,                               core->x2 - core->x1, core->y2 - core->y1,                               core->undo_tiles,                               TRUE);      gimp_image_undo_group_end (image);    }  tile_manager_unref (core->undo_tiles);  core->undo_tiles = NULL;  if (core->saved_proj_tiles)    {      tile_manager_unref (core->saved_proj_tiles);      core->saved_proj_tiles = NULL;    }  gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable));}

gbooleangimp_edit_fill (GimpImage             *image,                GimpDrawable          *drawable,                GimpContext           *context,                GimpFillType           fill_type,                gdouble                opacity,                GimpLayerModeEffects   paint_mode,                GError               **error){  GimpRGB      color;  GimpPattern *pattern;  const gchar *undo_desc = NULL;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (! gimp_get_fill_params (context, fill_type, &color, &pattern, error))    return FALSE;  switch (fill_type)    {    case GIMP_FILL_FOREGROUND:      undo_desc = C_("undo-type", "Fill with Foreground Color");      break;    case GIMP_FILL_BACKGROUND:      undo_desc = C_("undo-type", "Fill with Background Color");      break;    case GIMP_FILL_WHITE:      undo_desc = C_("undo-type", "Fill with White");      break;    case GIMP_FILL_TRANSPARENT:      undo_desc = C_("undo-type", "Fill with Transparency");      break;    case GIMP_FILL_PATTERN:      undo_desc = C_("undo-type", "Fill with Pattern");      break;    }  return gimp_edit_fill_full (image, drawable,                              &color, pattern,                              opacity, paint_mode,                              undo_desc);}

GimpObject *gimp_edit_cut (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);      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_CUT,                                   C_("undo-type", "Cut Layer"));      gimp_image_remove_layer (image, GIMP_LAYER (drawable),                               TRUE, NULL);      gimp_image_undo_group_end (image);      return GIMP_OBJECT (gimp_get_clipboard_image (image->gimp));    }  else    {      GimpBuffer *buffer;      buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable),                                  context, TRUE, 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;}

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_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_drawable_bucket_fill (GimpDrawable         *drawable,                           GimpFillOptions      *options,                           gboolean              fill_transparent,                           GimpSelectCriterion   fill_criterion,                           gdouble               threshold,                           gboolean              sample_merged,                           gboolean              diagonal_neighbors,                           gdouble               seed_x,                           gdouble               seed_y){  GimpImage  *image;  GeglBuffer *buffer;  gdouble     mask_x;  gdouble     mask_y;  gint        width, height;  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));  image = gimp_item_get_image (GIMP_ITEM (drawable));  gimp_set_busy (image->gimp);  buffer = gimp_drawable_get_bucket_fill_buffer (drawable, options,                                                 fill_transparent, fill_criterion,                                                 threshold, sample_merged,                                                 diagonal_neighbors,                                                 seed_x, seed_y, NULL,                                                 &mask_x, &mask_y, &width, &height);  if (buffer)    {      /*  Apply it to the image  */      gimp_drawable_apply_buffer (drawable, buffer,                                  GEGL_RECTANGLE (0, 0, width, height),                                  TRUE, C_("undo-type", "Bucket Fill"),                                  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_mode_get_paint_composite_mode (                                                                            gimp_context_get_paint_mode (GIMP_CONTEXT (options))),                                  NULL, (gint) mask_x, mask_y);      g_object_unref (buffer);      gimp_drawable_update (drawable, mask_x, mask_y, width, height);    }  gimp_unset_busy (image->gimp);}