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

GimpUndo *gimp_image_undo_push_layer_remove (GimpImage   *image,                                   const gchar *undo_desc,                                   GimpLayer   *layer,                                   GimpLayer   *prev_parent,                                   gint         prev_position,                                   GimpLayer   *prev_layer){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL);  g_return_val_if_fail (prev_parent == NULL || GIMP_IS_LAYER (prev_parent),                        NULL);  g_return_val_if_fail (prev_layer == NULL || GIMP_IS_LAYER (prev_layer),                        NULL);  return gimp_image_undo_push (image, GIMP_TYPE_LAYER_UNDO,                               GIMP_UNDO_LAYER_REMOVE, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item",          layer,                               "prev-parent",   prev_parent,                               "prev-position", prev_position,                               "prev-layer",    prev_layer,                               NULL);}

static voidgimp_layer_mask_prop_undo_constructed (GObject *object){  GimpLayerMaskPropUndo *layer_mask_prop_undo;  GimpLayer             *layer;  layer_mask_prop_undo = GIMP_LAYER_MASK_PROP_UNDO (object);  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));  layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);  switch (GIMP_UNDO (object)->undo_type)    {    case GIMP_UNDO_LAYER_MASK_APPLY:      layer_mask_prop_undo->apply = gimp_layer_get_apply_mask (layer);      break;    case GIMP_UNDO_LAYER_MASK_SHOW:      layer_mask_prop_undo->show = gimp_layer_get_show_mask (layer);      break;    default:      g_assert_not_reached ();    }}

static voidgimp_layer_prop_undo_constructed (GObject *object){  GimpLayerPropUndo *layer_prop_undo = GIMP_LAYER_PROP_UNDO (object);  GimpLayer         *layer;  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));  layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);  switch (GIMP_UNDO (object)->undo_type)    {    case GIMP_UNDO_LAYER_MODE:      layer_prop_undo->mode = gimp_layer_get_mode (layer);      break;    case GIMP_UNDO_LAYER_OPACITY:      layer_prop_undo->opacity = gimp_layer_get_opacity (layer);      break;    case GIMP_UNDO_LAYER_LOCK_ALPHA:      layer_prop_undo->lock_alpha = gimp_layer_get_lock_alpha (layer);      break;    default:      g_assert_not_reached ();    }}

voidfloating_sel_remove (GimpLayer *layer){  GimpImage *image;  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->fs.drawable));  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_REMOVE,                               _("Remove Floating Selection"));  /*  store the affected area from the drawable in the backing store  */  floating_sel_relax (layer, TRUE);  /*  Invalidate the preview of the obscured drawable.  We do this here   *  because it will not be done until the floating selection is removed,   *  at which point the obscured drawable's preview will not be declared   *  invalid.   */  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer));  /*  remove the layer from the image  */  gimp_image_remove_layer (image, layer);  gimp_image_undo_group_end (image);}

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

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

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

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

static voidgimp_layer_mask_undo_constructed (GObject *object){  GimpLayerMaskUndo *layer_mask_undo = GIMP_LAYER_MASK_UNDO (object);  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));  g_assert (GIMP_IS_LAYER_MASK (layer_mask_undo->layer_mask));}

GimpUndo *gimp_image_undo_push_layer_add (GimpImage   *image,                                const gchar *undo_desc,                                GimpLayer   *layer,                                GimpLayer   *prev_layer){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);  g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (layer)), NULL);  g_return_val_if_fail (prev_layer == NULL || GIMP_IS_LAYER (prev_layer),                        NULL);  return gimp_image_undo_push (image, GIMP_TYPE_LAYER_UNDO,                               GIMP_UNDO_LAYER_ADD, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item",       layer,                               "prev-layer", prev_layer,                               NULL);}

static gbooleangimp_layer_mask_is_attached (const GimpItem *item){  GimpLayerMask *mask  = GIMP_LAYER_MASK (item);  GimpLayer     *layer = gimp_layer_mask_get_layer (mask);  return (GIMP_IS_IMAGE (gimp_item_get_image (item)) &&          GIMP_IS_LAYER (layer)                      &&          gimp_layer_get_mask (layer) == mask        &&          gimp_item_is_attached (GIMP_ITEM (layer)));}

voidfloating_sel_invalidate (GimpLayer *layer){  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  /*  Invalidate the attached-to drawable's preview  */  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimp_layer_get_floating_sel_drawable (layer)));  /*  Invalidate the boundary  */  layer->fs.boundary_known = FALSE;}

gbooleangimp_text_layer_xcf_load_hack (GimpLayer **layer){  const gchar        *name;  GimpText           *text = NULL;  const GimpParasite *parasite;  g_return_val_if_fail (layer != NULL, FALSE);  g_return_val_if_fail (GIMP_IS_LAYER (*layer), FALSE);  name = gimp_text_parasite_name ();  parasite = gimp_item_parasite_find (GIMP_ITEM (*layer), name);  if (parasite)    {      GError *error = NULL;      text = gimp_text_from_parasite (parasite, &error);      if (error)        {          gimp_message (gimp_item_get_image (GIMP_ITEM (*layer))->gimp, NULL,                        GIMP_MESSAGE_ERROR,                        _("Problems parsing the text parasite for layer '%s':/n"                          "%s/n/n"                          "Some text properties may be wrong. "                          "Unless you want to edit the text layer, "                          "you don't need to worry about this."),                        gimp_object_get_name (*layer),                        error->message);          g_clear_error (&error);        }    }  else    {      name = gimp_text_gdyntext_parasite_name ();      parasite = gimp_item_parasite_find (GIMP_ITEM (*layer), name);      if (parasite)        text = gimp_text_from_gdyntext_parasite (parasite);    }  if (text)    {      *layer = gimp_text_layer_from_layer (*layer, text);      /*  let the text layer knows what parasite was used to create it  */      GIMP_TEXT_LAYER (*layer)->text_parasite = name;    }  return (text != NULL);}

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

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

voidfloating_sel_anchor (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));  if (! gimp_layer_is_floating_sel (layer))    {      gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING,                    _("Cannot anchor this layer because "                      "it is not a floating selection."));      return;    }  /*  Start a floating selection anchoring undo  */  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR,                               _("Anchor Floating Selection"));  /* Invalidate the previews of the layer that will be composited   * with the floating section.   */  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer->fs.drawable));  /*  Relax the floating selection  */  floating_sel_relax (layer, TRUE);  /*  Composite the floating selection contents  */  floating_sel_composite (layer,                          GIMP_ITEM (layer)->offset_x,                          GIMP_ITEM (layer)->offset_y,                          GIMP_ITEM (layer)->width,                          GIMP_ITEM (layer)->height, TRUE);  drawable = layer->fs.drawable;  /*  remove the floating selection  */  gimp_image_remove_layer (image, layer);  /*  end the group undo  */  gimp_image_undo_group_end (image);  /*  invalidate the boundaries  */  gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image)));}

GimpUndo *gimp_image_undo_push_layer_mask_show (GimpImage   *image,                                      const gchar *undo_desc,                                      GimpLayer   *layer){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL);  return gimp_image_undo_push (image, GIMP_TYPE_LAYER_MASK_PROP_UNDO,                               GIMP_UNDO_LAYER_MASK_SHOW, undo_desc,                               GIMP_DIRTY_ITEM_META,                               "item", layer,                               NULL);}

voidfloating_sel_restore (GimpLayer *layer,                      gint       x,                      gint       y,                      gint       w,                      gint       h){  PixelRegion srcPR, destPR;  gint        offx, offy;  gint        x1, y1, x2, y2;  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  /*  What this function does is "uncover" the specified area in the   *  drawable that this floating selection obscures.  We do this so   *  that either the floating selection can be removed or it can be   *  translated   */  /*  Find the minimum area we need to uncover -- in image space  */  gimp_item_offsets (GIMP_ITEM (layer->fs.drawable), &offx, &offy);  x1 = MAX (GIMP_ITEM (layer)->offset_x, offx);  y1 = MAX (GIMP_ITEM (layer)->offset_y, offy);  x2 = MIN (GIMP_ITEM (layer)->offset_x + GIMP_ITEM (layer)->width,            offx + gimp_item_width  (GIMP_ITEM (layer->fs.drawable)));  y2 = MIN (GIMP_ITEM(layer)->offset_y + GIMP_ITEM (layer)->height,            offy + gimp_item_height (GIMP_ITEM (layer->fs.drawable)));  x1 = CLAMP (x, x1, x2);  y1 = CLAMP (y, y1, y2);  x2 = CLAMP (x + w, x1, x2);  y2 = CLAMP (y + h, y1, y2);  if ((x2 - x1) > 0 && (y2 - y1) > 0)    {      /*  Copy the area from the backing store to the drawable  */      pixel_region_init (&srcPR, layer->fs.backing_store,                         (x1 - GIMP_ITEM (layer)->offset_x),                         (y1 - GIMP_ITEM (layer)->offset_y),                         (x2 - x1), (y2 - y1), FALSE);      pixel_region_init (&destPR, gimp_drawable_get_tiles (layer->fs.drawable),                         (x1 - offx), (y1 - offy), (x2 - x1), (y2 - y1), TRUE);      copy_region (&srcPR, &destPR);    }}

GimpUndo *gimp_image_undo_push_fs_to_layer (GimpImage    *image,                                  const gchar  *undo_desc,                                  GimpLayer    *floating_layer){  GimpUndo *undo;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_LAYER (floating_layer), NULL);  undo = gimp_image_undo_push (image, GIMP_TYPE_FLOATING_SEL_UNDO,                               GIMP_UNDO_FS_TO_LAYER, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item", floating_layer,                               NULL);  return undo;}

GimpUndo *gimp_image_undo_push_layer_mask_add (GimpImage     *image,                                     const gchar   *undo_desc,                                     GimpLayer     *layer,                                     GimpLayerMask *mask){  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL);  g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), NULL);  g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (mask)), NULL);  return gimp_image_undo_push (image, GIMP_TYPE_LAYER_MASK_UNDO,                               GIMP_UNDO_LAYER_MASK_ADD, undo_desc,                               GIMP_DIRTY_IMAGE_STRUCTURE,                               "item",       layer,                               "layer-mask", mask,                               NULL);}

voidfloating_sel_attach (GimpLayer    *layer,                     GimpDrawable *drawable){  GimpImage *image;  GimpLayer *floating_sel;  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  g_return_if_fail (drawable != GIMP_DRAWABLE (layer));  g_return_if_fail (gimp_item_get_image (GIMP_ITEM (layer)) ==                    gimp_item_get_image (GIMP_ITEM (drawable)));  image = gimp_item_get_image (GIMP_ITEM (drawable));  floating_sel = gimp_image_floating_sel (image);  /*  If there is already a floating selection, anchor it  */  if (floating_sel)    {      floating_sel_anchor (floating_sel);      /*  if we were pasting to the old floating selection, paste now       *  to the drawable       */      if (drawable == (GimpDrawable *) floating_sel)        drawable = gimp_image_get_active_drawable (image);    }  /*  set the drawable and allocate a backing store  */  gimp_layer_set_lock_alpha (layer, TRUE, FALSE);  layer->fs.drawable      = drawable;  layer->fs.backing_store = tile_manager_new (GIMP_ITEM (layer)->width,                                              GIMP_ITEM (layer)->height,                                              gimp_drawable_bytes (drawable));  /*  add the layer to the image  */  gimp_image_add_layer (image, layer, 0);  /*  store the affected area from the drawable in the backing store  */  floating_sel_rigor (layer, TRUE);}

static GObject *gimp_layer_prop_undo_constructor (GType                  type,                                  guint                  n_params,                                  GObjectConstructParam *params){  GObject           *object;  GimpLayerPropUndo *layer_prop_undo;  GimpImage         *image;  GimpLayer         *layer;  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);  layer_prop_undo = GIMP_LAYER_PROP_UNDO (object);  g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));  image = GIMP_UNDO (object)->image;  layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);  switch (GIMP_UNDO (object)->undo_type)    {    case GIMP_UNDO_LAYER_REPOSITION:      layer_prop_undo->position = gimp_image_get_layer_index (image, layer);      break;    case GIMP_UNDO_LAYER_MODE:      layer_prop_undo->mode = gimp_layer_get_mode (layer);      break;    case GIMP_UNDO_LAYER_OPACITY:      layer_prop_undo->opacity = gimp_layer_get_opacity (layer);      break;    case GIMP_UNDO_LAYER_LOCK_ALPHA:      layer_prop_undo->lock_alpha = gimp_layer_get_lock_alpha (layer);      break;    default:      g_assert_not_reached ();    }  return object;}

voidfloating_sel_rigor (GimpLayer *layer,                    gboolean   push_undo){  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  /*  store the affected area from the drawable in the backing store  */  floating_sel_store (layer,                      GIMP_ITEM (layer)->offset_x,                      GIMP_ITEM (layer)->offset_y,                      GIMP_ITEM (layer)->width,                      GIMP_ITEM (layer)->height);  layer->fs.initial = TRUE;  if (push_undo)    gimp_image_undo_push_fs_rigor (gimp_item_get_image (GIMP_ITEM (layer)),                                   NULL,                                   layer);}

voidfloating_sel_relax (GimpLayer *layer,                    gboolean   push_undo){  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  /*  restore the contents of drawable the floating layer is attached to  */  if (layer->fs.initial == FALSE)    floating_sel_restore (layer,                          GIMP_ITEM (layer)->offset_x,                          GIMP_ITEM (layer)->offset_y,                          GIMP_ITEM (layer)->width,                          GIMP_ITEM (layer)->height);  layer->fs.initial = TRUE;  if (push_undo)    gimp_image_undo_push_fs_relax (gimp_item_get_image (GIMP_ITEM (layer)),                                   NULL,                                   layer);}

gbooleangimp_pdb_layer_is_text_layer (GimpLayer          *layer,                              GimpPDBItemModify   modify,                              GError            **error){  g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  if (! gimp_item_is_text_layer (GIMP_ITEM (layer)))    {      g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,                   _("Layer '%s' (%d) cannot be used because it is not "                     "a text layer"),                   gimp_object_get_name (layer),                   gimp_item_get_ID (GIMP_ITEM (layer)));      return FALSE;    }  return gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL, modify, error);}

/** * gimp_text_layer_from_layer: * @layer: a #GimpLayer object * @text: a #GimpText object * * Converts a standard #GimpLayer and a #GimpText object into a * #GimpTextLayer. The new text layer takes ownership of the @text and * @layer objects.  The @layer object is rendered unusable by this * function. Don't even try to use if afterwards! * * This is a gross hack that is needed in order to load text layers * from XCF files in a backwards-compatible way. Please don't use it * for anything else! * * Return value: a newly allocated #GimpTextLayer object **/static GimpLayer *gimp_text_layer_from_layer (GimpLayer *layer,                            GimpText  *text){  GimpTextLayer *text_layer;  GimpDrawable  *drawable;  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);  g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);  text_layer = g_object_new (GIMP_TYPE_TEXT_LAYER,                             "image", gimp_item_get_image (GIMP_ITEM (layer)),                             NULL);  gimp_item_replace_item (GIMP_ITEM (text_layer), GIMP_ITEM (layer));  drawable = GIMP_DRAWABLE (text_layer);  gimp_drawable_steal_buffer (drawable, GIMP_DRAWABLE (layer));  gimp_layer_set_opacity         (GIMP_LAYER (text_layer),                                  gimp_layer_get_opacity (layer), FALSE);  gimp_layer_set_mode            (GIMP_LAYER (text_layer),                                  gimp_layer_get_mode (layer), FALSE);  gimp_layer_set_blend_space     (GIMP_LAYER (text_layer),                                  gimp_layer_get_blend_space (layer), FALSE);  gimp_layer_set_composite_space (GIMP_LAYER (text_layer),                                  gimp_layer_get_composite_space (layer), FALSE);  gimp_layer_set_composite_mode  (GIMP_LAYER (text_layer),                                  gimp_layer_get_composite_mode (layer), FALSE);  gimp_layer_set_lock_alpha      (GIMP_LAYER (text_layer),                                  gimp_layer_get_lock_alpha (layer), FALSE);  gimp_text_layer_set_text (text_layer, text);  g_object_unref (text);  g_object_unref (layer);  return GIMP_LAYER (text_layer);}

static voidgimp_floating_sel_undo_constructed (GObject *object){  GimpFloatingSelUndo *floating_sel_undo = GIMP_FLOATING_SEL_UNDO (object);  GimpLayer           *layer;  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));  layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);  switch (GIMP_UNDO (object)->undo_type)    {    case GIMP_UNDO_FS_TO_LAYER:      floating_sel_undo->drawable = gimp_layer_get_floating_sel_drawable (layer);      break;    default:      g_assert_not_reached ();    }}

voidgimp_layer_mask_set_layer (GimpLayerMask *layer_mask,                           GimpLayer     *layer){  g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask));  g_return_if_fail (layer == NULL || GIMP_IS_LAYER (layer));  layer_mask->layer = layer;  if (layer)    {      gchar *mask_name;      GIMP_ITEM (layer_mask)->offset_x = GIMP_ITEM (layer)->offset_x;      GIMP_ITEM (layer_mask)->offset_y = GIMP_ITEM (layer)->offset_y;      mask_name = g_strdup_printf (_("%s mask"),                                   gimp_object_get_name (GIMP_OBJECT (layer)));      gimp_object_take_name (GIMP_OBJECT (layer_mask), mask_name);    }}

voidgimp_display_shell_set_layer_style (GimpDisplayShell *shell,                                    cairo_t          *cr,                                    GimpLayer        *layer){  cairo_pattern_t *pattern;  g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));  g_return_if_fail (cr != NULL);  g_return_if_fail (GIMP_IS_LAYER (layer));  cairo_set_line_width (cr, 1.0);  cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);  if (gimp_layer_get_mask (layer) &&      gimp_layer_mask_get_edit (gimp_layer_get_mask (layer)))    {      pattern = gimp_cairo_stipple_pattern_create (&layer_mask_fg,                                                   &layer_mask_bg,                                                   0);    }  else if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))    {      pattern = gimp_cairo_stipple_pattern_create (&layer_group_fg,                                                   &layer_group_bg,                                                   0);    }  else    {      pattern = gimp_cairo_stipple_pattern_create (&layer_fg,                                                   &layer_bg,                                                   0);    }  cairo_set_source (cr, pattern);  cairo_pattern_destroy (pattern);}