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); }
gboolean plug_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); }
void gimp_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; }
void gimp_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); }
void gimp_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; }
void gimp_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; }
gboolean gimp_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")); }
gboolean gimp_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); }
void gimp_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 void gimp_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); }
void gimp_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); } }
void gimp_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; }
void gimp_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); }
void gimp_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); }
void gimp_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); }
gboolean gimp_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; }
gboolean gimp_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; }