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

GimpPlugIn *gimp_plug_in_new (GimpPlugInManager   *manager,                  GimpContext         *context,                  GimpProgress        *progress,                  GimpPlugInProcedure *procedure,                  const gchar         *prog){  GimpPlugIn *plug_in;  g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);  g_return_val_if_fail (procedure == NULL ||                        GIMP_IS_PLUG_IN_PROCEDURE (procedure), NULL);  g_return_val_if_fail (prog == NULL || g_path_is_absolute (prog), NULL);  g_return_val_if_fail ((procedure != NULL || prog != NULL) &&                        ! (procedure != NULL && prog != NULL), NULL);  plug_in = g_object_new (GIMP_TYPE_PLUG_IN, NULL);  if (! prog)    prog = gimp_plug_in_procedure_get_progname (procedure);  gimp_object_take_name (GIMP_OBJECT (plug_in),                         g_filename_display_basename (prog));  plug_in->manager = manager;  plug_in->prog    = g_strdup (prog);  gimp_plug_in_proc_frame_init (&plug_in->main_proc_frame,                                context, progress, procedure);  return plug_in;}

GtkWidget *gimp_prop_font_box_new (GimpContainer *container,                        GimpContext   *context,                        const gchar   *label,                        gint           spacing,                        const gchar   *view_type_prop,                        const gchar   *view_size_prop){  GimpViewType view_type;  GimpViewSize view_size;  g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),                        NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);  g_object_get (context,                view_type_prop, &view_type,                view_size_prop, &view_size,                NULL);  return view_props_connect (font_box_new (container, context, label, spacing,                                           view_type, view_size),                             context,                             view_type_prop, view_size_prop);}

gbooleanplug_in_icc_profile_info (GimpImage     *image,                          GimpContext   *context,                          GimpProgress  *progress,                          gchar        **name,                          gchar        **desc,                          gchar        **info,                          GError       **error){  Gimp          *gimp;  GimpProcedure *procedure;  g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  gimp = image->gimp;  procedure = gimp_pdb_lookup_procedure (gimp->pdb, ICC_PROFILE_INFO_PROC);  if (procedure &&      procedure->num_args >= 1 &&      GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[0]))    {      GimpValueArray    *return_vals;      GimpPDBStatusType  status;      return_vals =        gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error,                                            ICC_PROFILE_INFO_PROC,                                            GIMP_TYPE_IMAGE_ID,                                            gimp_image_get_ID (image),                                            G_TYPE_NONE);      status = g_value_get_enum (gimp_value_array_index (return_vals, 0));      switch (status)        {        case GIMP_PDB_SUCCESS:          plug_in_icc_profile_info_return (return_vals, name, desc, info);          break;        default:          if (error && *error == NULL)            g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,                         _("Error running '%s'"), ICC_PROFILE_INFO_PROC);          break;        }      gimp_value_array_unref (return_vals);      return (status == GIMP_PDB_SUCCESS);    }  g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,               _("Plug-In missing (%s)"), ICC_PROFILE_INFO_PROC);  return FALSE;}

GtkWidget *gimp_dynamics_factory_view_new (GimpViewType      view_type,                                GimpDataFactory  *factory,                                GimpContext      *context,                                gint              view_size,                                gint              view_border_width,                                GimpMenuFactory  *menu_factory){    g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL);    g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);    g_return_val_if_fail (view_size > 0 &&                          view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);    g_return_val_if_fail (view_border_width >= 0 &&                          view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,                          NULL);    g_return_val_if_fail (menu_factory == NULL ||                          GIMP_IS_MENU_FACTORY (menu_factory), NULL);    return g_object_new (GIMP_TYPE_DYNAMICS_FACTORY_VIEW,                         "view-type",         view_type,                         "data-factory",      factory,                         "context",           context,                         "view-size",         view_size,                         "view-border-width", view_border_width,                         "menu-factory",      menu_factory,                         "menu-identifier",   "<Dynamics>",                         "ui-path",           "/dynamics-popup",                         "action-group",      "dynamics",                         NULL);}

voidgimp_image_item_list_transform (GimpImage              *image,                                GList                  *list,                                GimpContext            *context,                                const GimpMatrix3      *matrix,                                GimpTransformDirection  direction,                                GimpInterpolationType   interpolation_type,                                GimpTransformResize     clip_result,                                GimpProgress           *progress){  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (GIMP_IS_CONTEXT (context));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  if (list)    {      GList *l;      if (list->next)        gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,                                     C_("undo-type", "Transform Items"));      for (l = list; l; l = g_list_next (l))        gimp_item_transform (GIMP_ITEM (l->data), context,                             matrix, direction,                             interpolation_type,                             clip_result, progress);      if (list->next)        gimp_image_undo_group_end (image);    }}

const gchar *gimp_edit_named_cut (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, TRUE, 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_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);}

voidgimp_item_linked_flip (GimpItem            *item,                       GimpContext         *context,                       GimpOrientationType  flip_type,                       gdouble              axis,                       gboolean             clip_result){  GList *list;  g_return_if_fail (GIMP_IS_ITEM (item));  g_return_if_fail (GIMP_IS_CONTEXT (context));  g_return_if_fail (gimp_item_get_linked (item) == TRUE);  g_return_if_fail (gimp_item_is_attached (item));  list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,                                        GIMP_ITEM_TYPE_ALL,                                        GIMP_ITEM_SET_LINKED);  list = gimp_image_item_list_filter (item, list, TRUE, FALSE);  gimp_image_item_list_flip (gimp_item_get_image (item), list, context,                             flip_type, axis, clip_result);  g_list_free (list);}

GtkWidget *gimp_view_new_full (GimpContext  *context,                    GimpViewable *viewable,                    gint          width,                    gint          height,                    gint          border_width,                    gboolean      is_popup,                    gboolean      clickable,                    gboolean      show_popup){    GtkWidget *view;    g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);    g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), NULL);    view = gimp_view_new_full_by_types (context,                                        GIMP_TYPE_VIEW,                                        G_TYPE_FROM_INSTANCE (viewable),                                        width, height, border_width,                                        is_popup, clickable, show_popup);    if (view)        gimp_view_set_viewable (GIMP_VIEW (view), viewable);    gimp_view_renderer_remove_idle (GIMP_VIEW (view)->renderer);    return view;}

GtkWidget *gimp_container_combo_box_new (GimpContainer *container,                              GimpContext   *context,                              gint           view_size,                              gint           view_border_width){  GtkWidget         *combo_box;  GimpContainerView *view;  g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),                        NULL);  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);  combo_box = g_object_new (GIMP_TYPE_CONTAINER_COMBO_BOX, NULL);  view = GIMP_CONTAINER_VIEW (combo_box);  gimp_container_view_set_view_size (view, view_size, view_border_width);  if (container)    gimp_container_view_set_container (view, container);  if (context)    gimp_container_view_set_context (view, context);  return combo_box;}

voidgimp_item_linked_transform (GimpItem               *item,                            GimpContext            *context,                            const GimpMatrix3      *matrix,                            GimpTransformDirection  direction,                            GimpInterpolationType   interpolation_type,                            GimpTransformResize     clip_result,                            GimpProgress           *progress){  GList *list;  g_return_if_fail (GIMP_IS_ITEM (item));  g_return_if_fail (GIMP_IS_CONTEXT (context));  g_return_if_fail (gimp_item_get_linked (item) == TRUE);  g_return_if_fail (gimp_item_is_attached (item));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,                                        GIMP_ITEM_TYPE_ALL,                                        GIMP_ITEM_SET_LINKED);  list = gimp_image_item_list_filter (item, list, TRUE, FALSE);  gimp_image_item_list_transform (gimp_item_get_image (item), list, context,                                  matrix, direction,                                  interpolation_type,                                  clip_result, progress);  g_list_free (list);}

GtkWidget *gimp_container_grid_view_new (GimpContainer *container,                              GimpContext   *context,                              gint           view_size,                              gint           view_border_width){  GimpContainerGridView *grid_view;  GimpContainerView     *view;  g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),                        NULL);  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);  g_return_val_if_fail (view_size  > 0 &&                        view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);  g_return_val_if_fail (view_border_width >= 0 &&                        view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,                        NULL);  grid_view = g_object_new (GIMP_TYPE_CONTAINER_GRID_VIEW, NULL);  view = GIMP_CONTAINER_VIEW (grid_view);  gimp_container_view_set_view_size (view, view_size, view_border_width);  if (container)    gimp_container_view_set_container (view, container);  if (context)    gimp_container_view_set_context (view, context);  return GTK_WIDGET (grid_view);}

GimpContext *gimp_pdb_context_new (Gimp        *gimp,                      GimpContext *parent,                      gboolean     set_parent){  GimpContext *context;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (parent), NULL);  context = g_object_new (GIMP_TYPE_PDB_CONTEXT,                          "gimp", gimp,                          "name", "PDB Context",                          NULL);  gimp_config_sync (G_OBJECT (parent), G_OBJECT (context), 0);  if (set_parent)    {      gimp_context_define_properties (context,                                      GIMP_CONTEXT_ALL_PROPS_MASK, FALSE);      gimp_context_set_parent (context, parent);    }  return context;}

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

gbooleangimp_pdb_dialog_new (Gimp          *gimp,                     GimpContext   *context,                     GimpProgress  *progress,                     GimpContainer *container,                     const gchar   *title,                     const gchar   *callback_name,                     const gchar   *object_name,                     ...){  gboolean retval = FALSE;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);  g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);  g_return_val_if_fail (title != NULL, FALSE);  g_return_val_if_fail (callback_name != NULL, FALSE);  if (gimp->gui.pdb_dialog_new)    {      va_list args;      va_start (args, object_name);      retval = gimp->gui.pdb_dialog_new (gimp, context, progress,                                         container, title,                                         callback_name, object_name,                                         args);      va_end (args);    }  return retval;}

GtkWidget *gimp_view_new_by_types (GimpContext *context,                        GType        view_type,                        GType        viewable_type,                        gint         size,                        gint         border_width,                        gboolean     is_popup){    GimpViewRenderer *renderer;    GimpView         *view;    g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);    g_return_val_if_fail (g_type_is_a (view_type, GIMP_TYPE_VIEW), NULL);    g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), NULL);    g_return_val_if_fail (size >  0 &&                          size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);    g_return_val_if_fail (border_width >= 0 &&                          border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL);    renderer = gimp_view_renderer_new (context, viewable_type, size,                                       border_width, is_popup);    g_return_val_if_fail (renderer != NULL, NULL);    view = g_object_new (view_type, NULL);    g_signal_connect (renderer, "update",                      G_CALLBACK (gimp_view_update_callback),                      view);    view->renderer = renderer;    return GTK_WIDGET (view);}

voidgimp_procedure_execute_async (GimpProcedure  *procedure,                              Gimp           *gimp,                              GimpContext    *context,                              GimpProgress   *progress,                              GValueArray    *args,                              GimpObject     *display,                              GError        **error){  g_return_if_fail (GIMP_IS_PROCEDURE (procedure));  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (GIMP_IS_CONTEXT (context));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (args != NULL);  g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display));  g_return_if_fail (error == NULL || *error == NULL);  if (gimp_procedure_validate_args (procedure,                                    procedure->args, procedure->num_args,                                    args, FALSE, error))    {      if (GIMP_IS_PDB_CONTEXT (context))        context = g_object_ref (context);      else        context = gimp_pdb_context_new (gimp, context, TRUE);      GIMP_PROCEDURE_GET_CLASS (procedure)->execute_async (procedure, gimp,                                                           context, progress,                                                           args, display);      g_object_unref (context);    }}

GtkWidget *gimp_container_entry_new (GimpContainer *container,                          GimpContext   *context,                          gint           view_size,                          gint           view_border_width){  GtkWidget         *entry;  GimpContainerView *view;  g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),                        NULL);  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);  entry = g_object_new (GIMP_TYPE_CONTAINER_ENTRY, NULL);  view = GIMP_CONTAINER_VIEW (entry);  gimp_container_view_set_view_size (view, view_size, view_border_width);  if (container)    gimp_container_view_set_container (view, container);  if (context)    gimp_container_view_set_context (view, context);  return entry;}

const gchar *gimp_edit_named_copy_visible (GimpImage    *image,                              const gchar  *name,                              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_CONTEXT (context), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  buffer = gimp_edit_extract (image, GIMP_PICKABLE (image),                              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;}

static voidgimp_data_editor_constructed (GObject *object){  GimpDataEditor *editor = GIMP_DATA_EDITOR (object);  G_OBJECT_CLASS (parent_class)->constructed (object);  g_assert (GIMP_IS_DATA_FACTORY (editor->data_factory));  g_assert (GIMP_IS_CONTEXT (editor->context));  gimp_data_editor_set_edit_active (editor, TRUE);  editor->save_button =    gimp_editor_add_button (GIMP_EDITOR (editor),                            "document-save",                            _("Save"), NULL,                            G_CALLBACK (gimp_data_editor_save_clicked),                            NULL,                            editor);  editor->revert_button =    gimp_editor_add_button (GIMP_EDITOR (editor),                            "document-revert",                            _("Revert"), NULL,                            G_CALLBACK (gimp_data_editor_revert_clicked),                            NULL,                            editor);  /* Hide because revert buttons are not yet implemented */  gtk_widget_hide (editor->revert_button);}

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

GtkWidget *gimp_prop_mybrush_box_new (GimpContainer *container,                           GimpContext   *context,                           const gchar   *label,                           gint           spacing,                           const gchar   *view_type_prop,                           const gchar   *view_size_prop){  GimpViewType view_type = GIMP_VIEW_TYPE_GRID;  GimpViewSize view_size = GIMP_VIEW_SIZE_LARGE;  g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),                        NULL);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);  if (view_type_prop && view_size_prop)    g_object_get (context,                  view_type_prop, &view_type,                  view_size_prop, &view_size,                  NULL);  return view_props_connect (mybrush_box_new (container, context, label, spacing,                                              view_type, view_size),                             context,                             view_type_prop, view_size_prop);}

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

voidgimp_undo_create_preview (GimpUndo    *undo,                          GimpContext *context,                          gboolean     create_now){  g_return_if_fail (GIMP_IS_UNDO (undo));  g_return_if_fail (context == NULL || GIMP_IS_CONTEXT (context));  if (undo->preview || undo->preview_idle_id)    return;  if (create_now)    {      gimp_undo_create_preview_private (undo, context);    }  else    {      GimpUndoIdle *idle = g_slice_new0 (GimpUndoIdle);      idle->undo = undo;      if (context)        idle->context = g_object_ref (context);      undo->preview_idle_id =        g_idle_add_full (GIMP_VIEWABLE_PRIORITY_IDLE,                         gimp_undo_create_preview_idle, idle,                         (GDestroyNotify) gimp_undo_idle_free);    }}

GimpViewRenderer *gimp_view_renderer_new_full (GimpContext *context,                             GType        viewable_type,                             gint         width,                             gint         height,                             gint         border_width,                             gboolean     is_popup){  GimpViewRenderer *renderer;  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);  g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), NULL);  g_return_val_if_fail (width >  0 &&                        width <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);  g_return_val_if_fail (height > 0 &&                        height <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);  g_return_val_if_fail (border_width >= 0 &&                        border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL);  renderer = gimp_view_renderer_new_internal (context, viewable_type,                                              is_popup);  gimp_view_renderer_set_size_full (renderer, width, height, border_width);  gimp_view_renderer_remove_idle (renderer);  return renderer;}

voidgimp_item_transform (GimpItem               *item,                     GimpContext            *context,                     const GimpMatrix3      *matrix,                     GimpTransformDirection  direction,                     GimpInterpolationType   interpolation,                     gint                    recursion_level,                     GimpTransformResize     clip_result,                     GimpProgress           *progress){  GimpItemClass *item_class;  GimpImage     *image;  g_return_if_fail (GIMP_IS_ITEM (item));  g_return_if_fail (gimp_item_is_attached (item));  g_return_if_fail (GIMP_IS_CONTEXT (context));  g_return_if_fail (matrix != NULL);  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  item_class = GIMP_ITEM_GET_CLASS (item);  image = gimp_item_get_image (item);  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,                               item_class->transform_desc);  item_class->transform (item, context, matrix, direction, interpolation,                         recursion_level, clip_result, progress);  gimp_image_undo_group_end (image);}

voidgimp_item_resize (GimpItem    *item,                  GimpContext *context,                  gint         new_width,                  gint         new_height,                  gint         offset_x,                  gint         offset_y){  GimpItemClass *item_class;  GimpImage     *image;  g_return_if_fail (GIMP_IS_ITEM (item));  g_return_if_fail (GIMP_IS_CONTEXT (context));  if (new_width < 1 || new_height < 1)    return;  item_class = GIMP_ITEM_GET_CLASS (item);  image = gimp_item_get_image (item);  if (gimp_item_is_attached (item))    gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_RESIZE,                                 item_class->resize_desc);  item_class->resize (item, context, new_width, new_height, offset_x, offset_y);  if (gimp_item_is_attached (item))    gimp_image_undo_group_end (image);}

voidgimp_item_rotate (GimpItem         *item,                  GimpContext      *context,                  GimpRotationType  rotate_type,                  gdouble           center_x,                  gdouble           center_y,                  gboolean          clip_result){  GimpItemClass *item_class;  GimpImage     *image;  g_return_if_fail (GIMP_IS_ITEM (item));  g_return_if_fail (gimp_item_is_attached (item));  g_return_if_fail (GIMP_IS_CONTEXT (context));  item_class = GIMP_ITEM_GET_CLASS (item);  image = gimp_item_get_image (item);  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,                               item_class->rotate_desc);  item_class->rotate (item, context, rotate_type, center_x, center_y,                      clip_result);  gimp_image_undo_group_end (image);}

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

gbooleangimp_view_popup_show (GtkWidget      *widget,                      GdkEventButton *bevent,                      GimpContext    *context,                      GimpViewable   *viewable,                      gint            view_width,                      gint            view_height,                      gboolean        dot_for_dot){  GimpViewPopup *popup;  gint           popup_width;  gint           popup_height;  g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);  g_return_val_if_fail (bevent != NULL, FALSE);  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), FALSE);  g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), FALSE);  if (! gimp_viewable_get_popup_size (viewable,                                      view_width,                                      view_height,                                      dot_for_dot,                                      &popup_width,                                      &popup_height))    return FALSE;  popup = g_slice_new0 (GimpViewPopup);  popup->widget       = widget;  popup->context      = context;  popup->viewable     = viewable;  popup->popup_width  = popup_width;  popup->popup_height = popup_height;  popup->dot_for_dot  = dot_for_dot;  popup->button       = bevent->button;  popup->button_x     = bevent->x_root;  popup->button_y     = bevent->y_root;  g_signal_connect (widget, "button-release-event",                    G_CALLBACK (gimp_view_popup_button_release),                    popup);  g_signal_connect (widget, "unmap",                    G_CALLBACK (gimp_view_popup_unmap),                    popup);  g_signal_connect (widget, "drag-begin",                    G_CALLBACK (gimp_view_popup_drag_begin),                    popup);  popup->timeout_id = g_timeout_add (VIEW_POPUP_DELAY,                                     (GSourceFunc) gimp_view_popup_timeout,                                     popup);  g_object_set_data_full (G_OBJECT (widget), "gimp-view-popup", popup,                          (GDestroyNotify) gimp_view_popup_hide);  gtk_grab_add (widget);  return TRUE;}