static GimpValueArray * selection_save_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; GimpChannel *channel = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); if (success) { channel = gimp_selection_save (GIMP_SELECTION (gimp_image_get_mask (image))); if (! channel) success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_channel (gimp_value_array_index (return_vals, 1), channel); return return_vals; }
static void gimp_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; }
void select_stroke_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); drawable = gimp_image_get_active_drawable (image); if (! drawable) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel to stroke to.")); return; } dialog = stroke_dialog_new (GIMP_ITEM (gimp_image_get_mask (image)), action_data_get_context (data), _("Stroke Selection"), GIMP_STOCK_SELECTION_STROKE, GIMP_HELP_SELECTION_STROKE, widget); gtk_widget_show (dialog); }
static GimpValueArray * selection_translate_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 offx; gint32 offy; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); offx = g_value_get_int (gimp_value_array_index (args, 1)); offy = g_value_get_int (gimp_value_array_index (args, 2)); if (success) { gimp_item_translate (GIMP_ITEM (gimp_image_get_mask (image)), offx, offy, TRUE); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
GimpTransformResize gimp_drawable_transform_get_effective_clip (GimpDrawable *drawable, GeglBuffer *orig_buffer, GimpTransformResize clip_result) { g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), clip_result); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), clip_result); g_return_val_if_fail (orig_buffer == NULL || GEGL_IS_BUFFER (orig_buffer), clip_result); /* Always clip unfloated buffers since they must keep their size */ if (GIMP_IS_CHANNEL (drawable)) { if (orig_buffer) { if (! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer))) clip_result = GIMP_TRANSFORM_RESIZE_CLIP; } else { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimp_channel_is_empty (gimp_image_get_mask (image))) clip_result = GIMP_TRANSFORM_RESIZE_CLIP; } } return clip_result; }
static void select_grow_callback (GtkWidget *widget, gdouble size, GimpUnit unit, gpointer data) { GimpImage *image = GIMP_IMAGE (data); gdouble radius_x; gdouble radius_y; radius_x = radius_y = select_grow_pixels = ROUND (size); if (unit != GIMP_UNIT_PIXEL) { gdouble factor; factor = (MAX (image->xresolution, image->yresolution) / MIN (image->xresolution, image->yresolution)); if (image->xresolution == MIN (image->xresolution, image->yresolution)) radius_y *= factor; else radius_x *= factor; } gimp_channel_grow (gimp_image_get_mask (image), radius_x, radius_y, TRUE); gimp_image_flush (image); }
static GimpValueArray * selection_is_empty_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; gboolean is_empty = FALSE; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); if (success) { is_empty = gimp_channel_is_empty (gimp_image_get_mask (image)); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) g_value_set_boolean (gimp_value_array_index (return_vals, 1), is_empty); return return_vals; }
static void select_shrink_callback (GtkWidget *widget, gdouble size, GimpUnit unit, gpointer data) { GimpImage *image = GIMP_IMAGE (data); GtkWidget *button = g_object_get_data (G_OBJECT (widget), "edge-lock-toggle"); gint radius_x; gint radius_y; radius_x = radius_y = select_shrink_pixels = ROUND (size); select_shrink_edge_lock = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); if (unit != GIMP_UNIT_PIXEL) { gdouble factor; factor = (MAX (image->xresolution, image->yresolution) / MIN (image->xresolution, image->yresolution)); if (image->xresolution == MIN (image->xresolution, image->yresolution)) radius_y *= factor; else radius_x *= factor; } gimp_channel_shrink (gimp_image_get_mask (image), radius_x, radius_y, select_shrink_edge_lock, TRUE); gimp_image_flush (image); }
static void select_feather_callback (GtkWidget *widget, gdouble size, GimpUnit unit, gpointer data) { GimpImage *image = GIMP_IMAGE (data); gdouble radius_x; gdouble radius_y; radius_x = radius_y = select_feather_radius = size; if (unit != GIMP_UNIT_PIXEL) { gdouble xres; gdouble yres; gdouble factor; gimp_image_get_resolution (image, &xres, &yres); factor = (MAX (xres, yres) / MIN (xres, yres)); if (xres == MIN (xres, yres)) radius_y *= factor; else radius_x *= factor; } gimp_channel_feather (gimp_image_get_mask (image), radius_x, radius_y, TRUE); gimp_image_flush (image); }
static GValueArray * selection_value_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; GimpImage *image; gint32 x; gint32 y; gint32 value = 0; image = gimp_value_get_image (&args->values[0], gimp); x = g_value_get_int (&args->values[1]); y = g_value_get_int (&args->values[2]); if (success) { value = gimp_pickable_get_opacity_at (GIMP_PICKABLE (gimp_image_get_mask (image)), x, y); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) g_value_set_int (&return_vals->values[1], value); return return_vals; }
void select_float_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; GError *error = NULL; return_if_no_image (image, data); return_if_no_widget (widget, data); if (gimp_selection_float (GIMP_SELECTION (gimp_image_get_mask (image)), gimp_image_get_active_drawable (image), action_data_get_context (data), TRUE, 0, 0, &error)) { gimp_image_flush (image); } else { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } }
static GValueArray * selection_combine_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GimpChannel *channel; gint32 operation; channel = gimp_value_get_channel (&args->values[0], gimp); operation = g_value_get_enum (&args->values[1]); if (success) { GimpImage *image; gint off_x, off_y; image = gimp_item_get_image (GIMP_ITEM (channel)); gimp_item_offsets (GIMP_ITEM (channel), &off_x, &off_y); gimp_channel_select_channel (gimp_image_get_mask (image), _("Channel to Selection"), channel, off_x, off_y, operation, FALSE, 0.0, 0.0); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GValueArray * selection_save_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; GimpImage *image; GimpChannel *channel = NULL; image = gimp_value_get_image (&args->values[0], gimp); if (success) { channel = gimp_selection_save (gimp_image_get_mask (image)); if (! channel) success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_channel (&return_vals->values[1], channel); return return_vals; }
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 void gimp_selection_editor_set_image (GimpImageEditor *image_editor, GimpImage *image) { GimpSelectionEditor *editor = GIMP_SELECTION_EDITOR (image_editor); if (image_editor->image) { g_signal_handlers_disconnect_by_func (image_editor->image, gimp_selection_editor_mask_changed, editor); } GIMP_IMAGE_EDITOR_CLASS (parent_class)->set_image (image_editor, image); if (image) { g_signal_connect (image, "mask-changed", G_CALLBACK (gimp_selection_editor_mask_changed), editor); gimp_view_set_viewable (GIMP_VIEW (editor->view), GIMP_VIEWABLE (gimp_image_get_mask (image))); } else { gimp_view_set_viewable (GIMP_VIEW (editor->view), NULL); } }
static GimpValueArray * selection_border_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 radius; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); radius = g_value_get_int (gimp_value_array_index (args, 1)); if (success) { /* FIXME: "feather" and "edge-lock" hardcoded to TRUE */ gimp_channel_border (gimp_image_get_mask (image), radius, radius, TRUE, TRUE, TRUE); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
void floating_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); }
void select_all_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; return_if_no_image (image, data); gimp_channel_all (gimp_image_get_mask (image), TRUE); gimp_image_flush (image); }
static GimpValueArray * flip_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; gint32 flip_type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); flip_type = g_value_get_enum (gimp_value_array_index (args, 1)); if (success) { gint x, y, width, height; success = gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, TRUE, error); if (success && gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &width, &height)) { gdouble axis; gimp_transform_get_flip_axis (x, y, width, height, flip_type, TRUE, &axis); if (! gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) && ! gimp_channel_is_empty (gimp_image_get_mask (gimp_item_get_image (GIMP_ITEM (drawable))))) { if (! gimp_drawable_transform_flip (drawable, context, flip_type, axis, FALSE)) { success = FALSE; } } else { gimp_item_flip (GIMP_ITEM (drawable), context, flip_type, axis, FALSE); } } } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_drawable (gimp_value_array_index (return_vals, 1), drawable); return return_vals; }
static void gimp_undo_create_preview_private (GimpUndo *undo, GimpContext *context) { GimpImage *image = undo->image; GimpViewable *preview_viewable; GimpViewSize preview_size; gint width; gint height; switch (undo->undo_type) { case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK: case GIMP_UNDO_GROUP_MASK: case GIMP_UNDO_MASK: preview_viewable = GIMP_VIEWABLE (gimp_image_get_mask (image)); break; default: preview_viewable = GIMP_VIEWABLE (image); break; } preview_size = image->gimp->config->undo_preview_size; if (gimp_image_get_width (image) <= preview_size && gimp_image_get_height (image) <= preview_size) { width = gimp_image_get_width (image); height = gimp_image_get_height (image); } else { if (gimp_image_get_width (image) > gimp_image_get_height (image)) { width = preview_size; height = MAX (1, (gimp_image_get_height (image) * preview_size / gimp_image_get_width (image))); } else { height = preview_size; width = MAX (1, (gimp_image_get_width (image) * preview_size / gimp_image_get_height (image))); } } undo->preview = gimp_viewable_get_new_preview (preview_viewable, context, width, height); gimp_viewable_invalidate_preview (GIMP_VIEWABLE (undo)); }
static GimpBuffer * gimp_edit_extract (GimpImage *image, GimpPickable *pickable, GimpContext *context, gboolean cut_pixels, GError **error) { GeglBuffer *buffer; gint offset_x; gint offset_y; if (cut_pixels) gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_CUT, C_("undo-type", "Cut")); /* Cut/copy the mask portion from the image */ buffer = gimp_selection_extract (GIMP_SELECTION (gimp_image_get_mask (image)), pickable, context, cut_pixels, FALSE, &offset_x, &offset_y, error); if (cut_pixels) gimp_image_undo_group_end (image); if (buffer) { GimpBuffer *gimp_buffer; gdouble res_x; gdouble res_y; gimp_buffer = gimp_buffer_new (buffer, _("Global Buffer"), offset_x, offset_y, FALSE); g_object_unref (buffer); gimp_image_get_resolution (image, &res_x, &res_y); gimp_buffer_set_resolution (gimp_buffer, res_x, res_y); gimp_buffer_set_unit (gimp_buffer, gimp_image_get_unit (image)); if (GIMP_IS_COLOR_MANAGED (pickable)) { GimpColorProfile *profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (pickable)); if (profile) gimp_buffer_set_color_profile (gimp_buffer, profile); } return gimp_buffer; } return NULL; }
static GimpValueArray * image_select_contiguous_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 operation; GimpDrawable *drawable; gdouble x; gdouble y; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); operation = g_value_get_enum (gimp_value_array_index (args, 1)); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); x = g_value_get_double (gimp_value_array_index (args, 3)); y = g_value_get_double (gimp_value_array_index (args, 4)); if (success) { GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context); if (pdb_context->sample_merged || gimp_pdb_item_is_attached (GIMP_ITEM (drawable), image, 0, error)) { gimp_channel_select_fuzzy (gimp_image_get_mask (image), drawable, pdb_context->sample_merged, x, y, pdb_context->sample_threshold, pdb_context->sample_transparent, pdb_context->sample_criterion, pdb_context->diagonal_neighbors, operation, pdb_context->antialias, pdb_context->feather, pdb_context->feather_radius_x, pdb_context->feather_radius_y); } else success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
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; }
void floating_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))); }
static gboolean gimp_drawable_edit_can_fill_direct (GimpDrawable *drawable, GimpFillOptions *options) { GimpImage *image; GimpContext *context; gdouble opacity; GimpComponentMask affect; GimpLayerMode mode; GimpLayerCompositeMode composite_mode; GimpLayerCompositeRegion composite_region; image = gimp_item_get_image (GIMP_ITEM (drawable)); context = GIMP_CONTEXT (options); opacity = gimp_context_get_opacity (context); affect = gimp_drawable_get_active_mask (drawable); mode = gimp_context_get_paint_mode (context); composite_mode = gimp_layer_mode_get_paint_composite_mode (mode); composite_region = gimp_layer_mode_get_included_region (mode, composite_mode); if (gimp_channel_is_empty (gimp_image_get_mask (image)) && opacity == GIMP_OPACITY_OPAQUE && affect == GIMP_COMPONENT_MASK_ALL && gimp_layer_mode_is_trivial (mode) && (! gimp_layer_mode_is_subtractive (mode) ^ ! (composite_region & GIMP_LAYER_COMPOSITE_REGION_SOURCE))) { switch (gimp_fill_options_get_style (options)) { case GIMP_FILL_STYLE_SOLID: return TRUE; case GIMP_FILL_STYLE_PATTERN: { GimpPattern *pattern; GimpTempBuf *mask; const Babl *format; pattern = gimp_context_get_pattern (context); mask = gimp_pattern_get_mask (pattern); format = gimp_temp_buf_get_format (mask); return ! babl_format_has_alpha (format); } } } return FALSE; }
void gimp_image_resize_to_selection (GimpImage *image, GimpContext *context, GimpProgress *progress) { GimpChannel *selection = gimp_image_get_mask (image); gint x, y, w, h; if (gimp_item_bounds (GIMP_ITEM (selection), &x, &y, &w, &h)) { gimp_image_resize (image, context, w, h, -x, -y, progress); } }
void select_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image = action_data_get_image (data); GimpDrawable *drawable = NULL; gboolean fs = FALSE; gboolean sel = FALSE; gboolean writable = FALSE; gboolean children = FALSE; if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { writable = ! gimp_item_is_content_locked (GIMP_ITEM (drawable)); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) children = TRUE; } fs = (gimp_image_get_floating_selection (image) != NULL); sel = ! gimp_channel_is_empty (gimp_image_get_mask (image)); } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("select-all", drawable); SET_SENSITIVE ("select-none", drawable && sel); SET_SENSITIVE ("select-invert", drawable); SET_SENSITIVE ("select-float", writable && !children && sel); SET_SENSITIVE ("select-feather", drawable && sel); SET_SENSITIVE ("select-sharpen", drawable && sel); SET_SENSITIVE ("select-shrink", drawable && sel); SET_SENSITIVE ("select-grow", drawable && sel); SET_SENSITIVE ("select-border", drawable && sel); SET_SENSITIVE ("select-flood", drawable && sel); SET_SENSITIVE ("select-save", drawable && !fs); SET_SENSITIVE ("select-stroke", writable && !children && sel); SET_SENSITIVE ("select-stroke-last-values", writable && !children && sel); #undef SET_SENSITIVE }
void select_save_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; return_if_no_image (image, data); return_if_no_widget (widget, data); gimp_selection_save (gimp_image_get_mask (image)); gimp_image_flush (image); gimp_dialog_factory_dialog_raise (global_dock_factory, gtk_widget_get_screen (widget), "gimp-channel-list", -1); }
static GimpValueArray * image_select_round_rectangle_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 operation; gdouble x; gdouble y; gdouble width; gdouble height; gdouble corner_radius_x; gdouble corner_radius_y; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); operation = g_value_get_enum (gimp_value_array_index (args, 1)); x = g_value_get_double (gimp_value_array_index (args, 2)); y = g_value_get_double (gimp_value_array_index (args, 3)); width = g_value_get_double (gimp_value_array_index (args, 4)); height = g_value_get_double (gimp_value_array_index (args, 5)); corner_radius_x = g_value_get_double (gimp_value_array_index (args, 6)); corner_radius_y = g_value_get_double (gimp_value_array_index (args, 7)); if (success) { GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context); gimp_channel_select_round_rect (gimp_image_get_mask (image), (gint) x, (gint) y, (gint) width, (gint) height, corner_radius_x, corner_radius_y, operation, pdb_context->antialias, pdb_context->feather, pdb_context->feather_radius_x, pdb_context->feather_radius_y, TRUE); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
void select_stroke_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; GimpContext *context; GtkWidget *widget; GimpStrokeOptions *options; GError *error = NULL; return_if_no_image (image, data); return_if_no_context (context, data); return_if_no_widget (widget, data); drawable = gimp_image_get_active_drawable (image); if (! drawable) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel to stroke to.")); return; } options = g_object_get_data (G_OBJECT (image->gimp), "saved-stroke-options"); if (options) g_object_ref (options); else options = gimp_stroke_options_new (image->gimp, context, TRUE); if (! gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)), drawable, context, options, NULL, TRUE, NULL, &error)) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } else { gimp_image_flush (image); } g_object_unref (options); }