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

static voidgimp_group_layer_undo_constructed (GObject *object){    GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (object);    GimpGroupLayer     *group;    G_OBJECT_CLASS (parent_class)->constructed (object);    g_assert (GIMP_IS_GROUP_LAYER (GIMP_ITEM_UNDO (object)->item));    group = GIMP_GROUP_LAYER (GIMP_ITEM_UNDO (object)->item);    switch (GIMP_UNDO (object)->undo_type)    {    case GIMP_UNDO_GROUP_LAYER_SUSPEND:    case GIMP_UNDO_GROUP_LAYER_RESUME:        break;    case GIMP_UNDO_GROUP_LAYER_CONVERT:        group_layer_undo->prev_type = gimp_drawable_get_base_type (GIMP_DRAWABLE (group));        group_layer_undo->prev_precision = gimp_drawable_get_precision (GIMP_DRAWABLE (group));        break;    default:        g_assert_not_reached ();    }}

void bfm_onionskin_rm (GDisplay *disp){  if (!bfm_check (disp) || !disp->bfm->onionskin_b)    return;  if(disp->bfm->cfm)    {      /*cfm_onionskin_rm (disp->bfm->cfm);*/    }  else    if(disp->bfm->sfm && disp->bfm->onionskin_b)      {        disp->bfm->sfm->old_offset_x = GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_x;        disp->bfm->sfm->old_offset_y = GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_y;        disp->bfm->sfm->old_ex = disp->bfm->sfm->ex;        disp->bfm->sfm->old_ey = disp->bfm->sfm->ey;        disp->bfm->sfm->old_opacity = disp->bfm->fg->active_layer->opacity;	disp->bfm->fg->active_layer->opacity = 1;	gimage_remove_layer (disp->bfm->fg, (disp->bfm->bg->active_layer));	GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_x = 0;	GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_y = 0;	GIMP_DRAWABLE(disp->bfm->bg->active_layer)->gimage_ID = disp->bfm->bg->ID;	disp->bfm->onionskin_b = 0;	sfm_onionskin_rm (disp);      }}

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

static voidgimp_group_layer_undo_pop (GimpUndo            *undo,                           GimpUndoMode         undo_mode,                           GimpUndoAccumulator *accum){    GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (undo);    GimpGroupLayer     *group;    group = GIMP_GROUP_LAYER (GIMP_ITEM_UNDO (undo)->item);    GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);    switch (undo->undo_type)    {    case GIMP_UNDO_GROUP_LAYER_SUSPEND:    case GIMP_UNDO_GROUP_LAYER_RESUME:        if ((undo_mode       == GIMP_UNDO_MODE_UNDO &&                undo->undo_type == GIMP_UNDO_GROUP_LAYER_SUSPEND) ||                (undo_mode       == GIMP_UNDO_MODE_REDO &&                 undo->undo_type == GIMP_UNDO_GROUP_LAYER_RESUME))        {            /*  resume group layer auto-resizing  */            gimp_group_layer_resume_resize (group, FALSE);        }        else        {            /*  suspend group layer auto-resizing  */            gimp_group_layer_suspend_resize (group, FALSE);        }        break;    case GIMP_UNDO_GROUP_LAYER_CONVERT:    {        GimpImageBaseType type;        GimpPrecision     precision;        type      = gimp_drawable_get_base_type (GIMP_DRAWABLE (group));        precision = gimp_drawable_get_precision (GIMP_DRAWABLE (group));        gimp_drawable_convert_type (GIMP_DRAWABLE (group),                                    gimp_item_get_image (GIMP_ITEM (group)),                                    group_layer_undo->prev_type,                                    group_layer_undo->prev_precision,                                    0, 0, FALSE,                                    FALSE, NULL);        group_layer_undo->prev_type      = type;        group_layer_undo->prev_precision = precision;    }    break;    default:        g_assert_not_reached ();    }}

static CombinationModegimp_image_merge_layers_get_operation (GimpLayer *dest,                                       GimpLayer *src){  GimpImageType type  = gimp_drawable_type (GIMP_DRAWABLE (dest));  gint          bytes = gimp_drawable_bytes (GIMP_DRAWABLE (src));  return gimp_image_get_combination_mode (type, bytes);}

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

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

static voidgimp_text_layer_render_layout (GimpTextLayer  *layer,                               GimpTextLayout *layout){  GimpDrawable    *drawable = GIMP_DRAWABLE (layer);  GimpItem        *item     = GIMP_ITEM (layer);  GeglBuffer      *buffer;  cairo_t         *cr;  cairo_surface_t *surface;  gint             width;  gint             height;  g_return_if_fail (gimp_drawable_has_alpha (drawable));  width  = gimp_item_get_width  (item);  height = gimp_item_get_height (item);  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);  cr = cairo_create (surface);  gimp_text_layout_render (layout, cr, layer->text->base_dir, FALSE);  cairo_destroy (cr);  cairo_surface_flush (surface);  buffer = gimp_cairo_surface_create_buffer (surface);  gegl_buffer_copy (buffer, NULL,                    gimp_drawable_get_buffer (drawable), NULL);  g_object_unref (buffer);  cairo_surface_destroy (surface);  gimp_drawable_update (drawable, 0, 0, width, height);}

static voidgimp_drawable_mod_undo_pop (GimpUndo            *undo,                            GimpUndoMode         undo_mode,                            GimpUndoAccumulator *accum){  GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (undo);  GimpDrawable        *drawable          = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item);  GeglBuffer          *buffer;  gint                 offset_x;  gint                 offset_y;  GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);  buffer   = drawable_mod_undo->buffer;  offset_x = drawable_mod_undo->offset_x;  offset_y = drawable_mod_undo->offset_y;  drawable_mod_undo->buffer = g_object_ref (gimp_drawable_get_buffer (drawable));  gimp_item_get_offset (GIMP_ITEM (drawable),                        &drawable_mod_undo->offset_x,                        &drawable_mod_undo->offset_y);  gimp_drawable_set_buffer_full (drawable, FALSE, NULL,                                 buffer, offset_x, offset_y);  g_object_unref (buffer);}

voiddrawable_lock_position_cmd_callback (GtkAction *action,                                    gpointer   data){  GimpImage    *image;  GimpDrawable *drawable;  gboolean      locked;  return_if_no_drawable (image, drawable, data);  locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));  if (GIMP_IS_LAYER_MASK (drawable))    drawable =      GIMP_DRAWABLE (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)));  if (locked != gimp_item_get_lock_position (GIMP_ITEM (drawable)))    {      GimpUndo *undo;      gboolean  push_undo = TRUE;      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,                                           GIMP_UNDO_ITEM_LOCK_POSITION);      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (drawable))        push_undo = FALSE;      gimp_item_set_lock_position (GIMP_ITEM (drawable), locked, push_undo);      gimp_image_flush (image);    }}

voidgimp_layer_mask_set_show (GimpLayerMask *layer_mask,                          gboolean       show,                          gboolean       push_undo){  g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask));  if (layer_mask->show_mask != show)    {      GimpImage *image = GIMP_ITEM (layer_mask)->image;      if (push_undo)        gimp_image_undo_push_layer_mask_show (image, _("Show Layer Mask"),                                              layer_mask);      layer_mask->show_mask = show ? TRUE : FALSE;      if (layer_mask->layer)        {          GimpDrawable *drawable = GIMP_DRAWABLE (layer_mask->layer);          gimp_drawable_update (drawable,                                0, 0,                                gimp_item_width  (GIMP_ITEM (drawable)),                                gimp_item_height (GIMP_ITEM (drawable)));        }      g_signal_emit (layer_mask, layer_mask_signals[SHOW_CHANGED], 0);    }}

voidgimp_layer_mask_set_apply (GimpLayerMask *layer_mask,                           gboolean       apply,                           gboolean       push_undo){  g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask));  if (layer_mask->apply_mask != apply)    {      GimpImage *image = GIMP_ITEM (layer_mask)->image;      if (push_undo)        gimp_image_undo_push_layer_mask_apply (image, _("Apply Layer Mask"),                                               layer_mask);      layer_mask->apply_mask = apply ? TRUE : FALSE;      if (layer_mask->layer)        {          GimpDrawable *drawable = GIMP_DRAWABLE (layer_mask->layer);          gimp_drawable_update (drawable,                                0, 0,                                gimp_item_width  (GIMP_ITEM (drawable)),                                gimp_item_height (GIMP_ITEM (drawable)));        }      g_signal_emit (layer_mask, layer_mask_signals[APPLY_CHANGED], 0);    }}

GimpLayerMask *gimp_layer_mask_new (GimpImage     *image,                     gint           width,                     gint           height,                     const gchar   *name,                     const GimpRGB *color){  GimpLayerMask *layer_mask;  layer_mask = g_object_new (GIMP_TYPE_LAYER_MASK, NULL);  gimp_drawable_configure (GIMP_DRAWABLE (layer_mask),                           image,                           0, 0, width, height,                           GIMP_GRAY_IMAGE, name);  /*  set the layer_mask color and opacity  */  GIMP_CHANNEL (layer_mask)->color       = *color;  GIMP_CHANNEL (layer_mask)->show_masked = TRUE;  /*  selection mask variables  */  GIMP_CHANNEL (layer_mask)->x2          = width;  GIMP_CHANNEL (layer_mask)->y2          = height;  return layer_mask;}

static voidgimp_drawable_tree_view_new_dropped (GimpItemTreeView   *view,                                     gint                x,                                     gint                y,                                     const GimpRGB      *color,                                     GimpPattern        *pattern){  GimpItem *item;  gimp_image_undo_group_start (gimp_item_tree_view_get_image (view), GIMP_UNDO_GROUP_EDIT_PASTE,                               _("New Layer"));  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->new_item (gimp_item_tree_view_get_image (view));  if (item)    {      gimp_edit_fill_full (gimp_item_get_image (item),                           GIMP_DRAWABLE (item),                           color, pattern,                           GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE,                           pattern ?                           C_("undo-type", "Drop pattern to layer") :                           C_("undo-type", "Drop color to layer"));    }  gimp_image_undo_group_end (gimp_item_tree_view_get_image (view));  gimp_image_flush (gimp_item_tree_view_get_image (view));}

/** @return fg drawable if `disp' has bfm, NULL else */CanvasDrawable* bfm_get_fg_drawable (GDisplay *disp){  if (!bfm_check (disp))    return NULL;  return GIMP_DRAWABLE (disp->bfm->fg->active_layer); }                               /* relies on fg!=NULL */

static GValueArray *selection_layer_alpha_invoker (GimpProcedure      *procedure,                               Gimp               *gimp,                               GimpContext        *context,                               GimpProgress       *progress,                               const GValueArray  *args,                               GError            **error){  gboolean success = TRUE;  GimpLayer *layer;  layer = gimp_value_get_layer (&args->values[0], gimp);  if (success)    {      GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer));      gimp_channel_select_alpha (gimp_image_get_mask (image),                                 GIMP_DRAWABLE (layer),                                 GIMP_CHANNEL_OP_REPLACE, FALSE, 0.0, 0.0);    }  return gimp_procedure_get_return_values (procedure, success,                                           error ? *error : NULL);}

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

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

static voidgimp_image_duplicate_mask (GimpImage *image,                           GimpImage *new_image){  GimpDrawable *mask;  GimpDrawable *new_mask;  mask     = GIMP_DRAWABLE (gimp_image_get_mask (image));  new_mask = GIMP_DRAWABLE (gimp_image_get_mask (new_image));  gegl_buffer_copy (gimp_drawable_get_buffer (mask), NULL,                    gimp_drawable_get_buffer (new_mask), NULL);  GIMP_CHANNEL (new_mask)->bounds_known   = FALSE;  GIMP_CHANNEL (new_mask)->boundary_known = FALSE;}

static voidgimp_layer_new_convert_buffer (GimpLayer         *layer,                               GeglBuffer        *src_buffer,                               GimpColorProfile  *src_profile,                               GError           **error){  GimpDrawable     *drawable    = GIMP_DRAWABLE (layer);  GimpImage        *image       = gimp_item_get_image (GIMP_ITEM (layer));  GimpColorConfig  *config      = image->gimp->config->color_management;  GeglBuffer       *dest_buffer = gimp_drawable_get_buffer (drawable);  GimpColorProfile *dest_profile;  dest_profile =    gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (layer));  if (! src_profile  ||      ! dest_profile ||      /*  FIXME: this is the wrong check, need something like file import       *  conversion config       */      config->mode == GIMP_COLOR_MANAGEMENT_OFF)    {      gegl_buffer_copy (src_buffer, NULL, GEGL_ABYSS_NONE, dest_buffer, NULL);      return;    }  gimp_gegl_convert_color_profile (src_buffer,  NULL, src_profile,                                   dest_buffer, NULL, dest_profile,                                   GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,                                   TRUE, NULL);}

static GdkSegment *gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,                                   GimpDisplay          *display,                                   gint                 *num_segs){  GimpTool                *tool    = GIMP_TOOL (region_sel);  GimpRegionSelectOptions *options = GIMP_REGION_SELECT_TOOL_GET_OPTIONS (tool);  GimpDisplayShell        *shell   = GIMP_DISPLAY_SHELL (display->shell);  GimpDrawable            *drawable;  GdkSegment              *segs;  BoundSeg                *bsegs;  PixelRegion              maskPR;  drawable = gimp_image_get_active_drawable (display->image);  gimp_display_shell_set_override_cursor (shell, GDK_WATCH);  if (region_sel->region_mask)    g_object_unref (region_sel->region_mask);  region_sel->region_mask =    GIMP_REGION_SELECT_TOOL_GET_CLASS (region_sel)->get_mask (region_sel,                                                              display);  if (! region_sel->region_mask)    {      gimp_display_shell_unset_override_cursor (shell);      *num_segs = 0;      return NULL;    }  /*  calculate and allocate a new segment array which represents the   *  boundary of the contiguous region   */  pixel_region_init (&maskPR,                     gimp_drawable_get_tiles (GIMP_DRAWABLE (region_sel->region_mask)),                     0, 0,                     gimp_item_width  (GIMP_ITEM (region_sel->region_mask)),                     gimp_item_height (GIMP_ITEM (region_sel->region_mask)),                     FALSE);  bsegs = boundary_find (&maskPR, BOUNDARY_WITHIN_BOUNDS,                         0, 0,                         gimp_item_width  (GIMP_ITEM (region_sel->region_mask)),                         gimp_item_height (GIMP_ITEM (region_sel->region_mask)),                         BOUNDARY_HALF_WAY,                         num_segs);  segs = g_new (GdkSegment, *num_segs);  gimp_display_shell_transform_segments (shell, bsegs, segs, *num_segs,                                         ! options->sample_merged);  g_free (bsegs);  gimp_display_shell_unset_override_cursor (shell);  return segs;}

/** * gimp_projection_initialize: * @proj: A #GimpProjection. * @x: * @y: * @w: * @h: * * This function determines whether a visible layer with combine mode * Normal provides complete coverage over the specified area.  If not, * the projection is initialized to transparent black. */static voidgimp_projection_initialize (GimpProjection *proj,                            gint            x,                            gint            y,                            gint            w,                            gint            h){    GList    *list;    gint      proj_off_x;    gint      proj_off_y;    gboolean  coverage = FALSE;    gimp_projectable_get_offset (proj->projectable, &proj_off_x, &proj_off_y);    for (list = gimp_projectable_get_layers (proj->projectable);            list;            list = g_list_next (list))    {        GimpLayer    *layer    = list->data;        GimpDrawable *drawable = GIMP_DRAWABLE (layer);        GimpItem     *item     = GIMP_ITEM (layer);        gint          off_x, off_y;        gimp_item_get_offset (item, &off_x, &off_y);        /*  subtract the projectable's offsets because the list of         *  update areas is in tile-pyramid coordinates, but our         *  external API is always in terms of image coordinates.         */        off_x -= proj_off_x;        off_y -= proj_off_y;        if (gimp_item_get_visible (item)                          &&                ! gimp_drawable_has_alpha (drawable)                  &&                ! gimp_layer_get_mask (layer)                         &&                gimp_layer_get_mode (layer) == GIMP_NORMAL_MODE       &&                gimp_layer_get_opacity (layer) == GIMP_OPACITY_OPAQUE &&                off_x <= x                                            &&                off_y <= y                                            &&                (off_x + gimp_item_get_width  (item)) >= (x + w)      &&                (off_y + gimp_item_get_height (item)) >= (y + h))        {            coverage = TRUE;            break;        }    }    if (! coverage)    {        PixelRegion region;        pixel_region_init (&region,                           gimp_pickable_get_tiles (GIMP_PICKABLE (proj)),                           x, y, w, h, TRUE);        clear_region (&region);    }}

/** @return bg drawable if `disp' has bfm, NULL else */CanvasDrawable* bfm_get_bg_drawable (GDisplay *disp){  if (!bfm_check (disp))    return NULL;  if (!disp->bfm->bg)     return NULL;    return GIMP_DRAWABLE (disp->bfm->bg->active_layer);}

voidfloating_sel_anchor (GimpLayer *layer){  GimpImage    *image;  GimpDrawable *drawable;  GimpFilter   *filter = NULL;  gint          off_x, off_y;  gint          dr_off_x, dr_off_y;  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  /* Don't let gimp_image_remove_layer free the layer while we still need it */  g_object_ref (layer);  image = gimp_item_get_image (GIMP_ITEM (layer));  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR,                               C_("undo-type", "Anchor Floating Selection"));  drawable = gimp_layer_get_floating_sel_drawable (layer);  gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y);  gimp_item_get_offset (GIMP_ITEM (drawable), &dr_off_x, &dr_off_y);  if (gimp_item_get_visible (GIMP_ITEM (layer)) &&      gimp_rectangle_intersect (off_x, off_y,                                gimp_item_get_width  (GIMP_ITEM (layer)),                                gimp_item_get_height (GIMP_ITEM (layer)),                                dr_off_x, dr_off_y,                                gimp_item_get_width  (GIMP_ITEM (drawable)),                                gimp_item_get_height (GIMP_ITEM (drawable)),                                NULL, NULL, NULL, NULL))    {      filter = gimp_drawable_get_floating_sel_filter (drawable);      g_object_ref (filter);    }  /*  first remove the filter, then merge it, or we will get warnings   *  about already connected nodes   */  gimp_image_remove_layer (image, layer, TRUE, NULL);  if (filter)    {      gimp_drawable_merge_filter (drawable, filter, NULL, NULL);      g_object_unref (filter);    }  gimp_image_undo_group_end (image);  /*  invalidate the boundaries  */  gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image)));  g_object_unref (layer);}

static voidgimp_display_shell_drop_drawable (GtkWidget    *widget,                                  gint          x,                                  gint          y,                                  GimpViewable *viewable,                                  gpointer      data){  GimpDisplayShell *shell     = GIMP_DISPLAY_SHELL (data);  GimpImage        *image     = gimp_display_get_image (shell->display);  GType             new_type;  GimpItem         *new_item;  GIMP_LOG (DND, NULL);  if (shell->display->gimp->busy)    return;  if (! image)    {      image = gimp_image_new_from_drawable (shell->display->gimp,                                            GIMP_DRAWABLE (viewable));      gimp_create_display (shell->display->gimp, image, GIMP_UNIT_PIXEL, 1.0,                           G_OBJECT (gtk_widget_get_screen (widget)),                           gimp_widget_get_monitor (widget));      g_object_unref (image);      return;    }  if (GIMP_IS_LAYER (viewable))    new_type = G_TYPE_FROM_INSTANCE (viewable);  else    new_type = GIMP_TYPE_LAYER;  new_item = gimp_item_convert (GIMP_ITEM (viewable), image, new_type);  if (new_item)    {      GimpLayer *new_layer = GIMP_LAYER (new_item);      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,                                   _("Drop New Layer"));      gimp_display_shell_dnd_position_item (shell, image, new_item);      gimp_item_set_visible (new_item, TRUE, FALSE);      gimp_item_set_linked (new_item, FALSE, FALSE);      gimp_image_add_layer (image, new_layer,                            GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);      gimp_image_undo_group_end (image);      gimp_display_shell_dnd_flush (shell, image);    }}

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