static void gimp_display_shell_drop_buffer (GtkWidget *widget, gint drop_x, gint drop_y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = gimp_display_get_image (shell->display); GimpDrawable *drawable; GimpBuffer *buffer; gint x, y, width, height; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { image = gimp_image_new_from_buffer (shell->display->gimp, NULL, GIMP_BUFFER (viewable)); gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0); g_object_unref (image); return; } drawable = gimp_image_get_active_drawable (image); if (drawable) { if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Cannot modify the pixels of layer groups.")); return; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("The active layer's pixels are locked.")); return; } } buffer = GIMP_BUFFER (viewable); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); /* FIXME: popup a menu for selecting "Paste Into" */ gimp_edit_paste (image, drawable, buffer, FALSE, x, y, width, height); gimp_display_shell_dnd_flush (shell, image); }
static gboolean gimp_bucket_fill_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } return TRUE; }
static void gimp_blend_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; blend_tool->mouse_x = coords->x; blend_tool->mouse_y = coords->y; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable)) || ! gimp_item_is_visible (GIMP_ITEM (drawable))) { modifier = GIMP_CURSOR_MODIFIER_BAD; } else if (gimp_blend_tool_is_shapeburst (blend_tool)) { modifier = GIMP_CURSOR_MODIFIER_PLUS; } else if (gimp_blend_tool_get_point_under_cursor (blend_tool)) { modifier = GIMP_CURSOR_MODIFIER_MOVE; } gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
gboolean gimp_pdb_item_is_modifyable (GimpItem *item, GimpPDBItemModify modify, GError **error) { g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if ((modify & GIMP_PDB_ITEM_CONTENT) && gimp_item_is_content_locked (item)) { g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Item '%s' (%d) cannot be modified because its " "contents are locked"), gimp_object_get_name (item), gimp_item_get_ID (item)); return FALSE; } if ((modify & GIMP_PDB_ITEM_POSITION) && gimp_item_is_position_locked (item)) { g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Item '%s' (%d) cannot be modified because its " "position and size are locked"), gimp_object_get_name (item), gimp_item_get_ID (item)); return FALSE; } return TRUE; }
static void gimp_paint_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpCursorModifier modifier; GimpCursorModifier toggle_modifier; GimpCursorModifier old_modifier; GimpCursorModifier old_toggle_modifier; modifier = tool->control->cursor_modifier; toggle_modifier = tool->control->toggle_cursor_modifier; old_modifier = modifier; old_toggle_modifier = toggle_modifier; if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable)) || ! gimp_item_is_visible (GIMP_ITEM (drawable))) { modifier = GIMP_CURSOR_MODIFIER_BAD; toggle_modifier = GIMP_CURSOR_MODIFIER_BAD; } if (! paint_tool->show_cursor && modifier != GIMP_CURSOR_MODIFIER_BAD) { gimp_tool_set_cursor (tool, display, GIMP_CURSOR_NONE, GIMP_TOOL_CURSOR_NONE, GIMP_CURSOR_MODIFIER_NONE); return; } gimp_tool_control_set_cursor_modifier (tool->control, modifier); gimp_tool_control_set_toggle_cursor_modifier (tool->control, toggle_modifier); } GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); /* reset old stuff here so we are not interferring with the modifiers * set by our subclasses */ gimp_tool_control_set_cursor_modifier (tool->control, old_modifier); gimp_tool_control_set_toggle_cursor_modifier (tool->control, old_toggle_modifier); }
static gboolean gimp_crop_tool_execute (GimpRectangleTool *rectangle, gint x, gint y, gint w, gint h) { GimpTool *tool = GIMP_TOOL (rectangle); GimpCropOptions *options = GIMP_CROP_TOOL_GET_OPTIONS (tool); GimpImage *image = gimp_display_get_image (tool->display); gimp_tool_pop_status (tool, tool->display); /* if rectangle exists, crop it */ if (w > 0 && h > 0) { if (options->layer_only) { GimpLayer *layer = gimp_image_get_active_layer (image); gint off_x, off_y; if (! layer) { gimp_tool_message_literal (tool, tool->display, _("There is no active layer to crop.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (layer))) { gimp_tool_message_literal (tool, tool->display, _("The active layer's pixels are locked.")); return FALSE; } gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y); off_x -= x; off_y -= y; gimp_item_resize (GIMP_ITEM (layer), GIMP_CONTEXT (options), w, h, off_x, off_y); } else { gimp_image_crop (image, GIMP_CONTEXT (options), x, y, w + x, h + y, TRUE); } gimp_image_flush (image); return TRUE; } return TRUE; }
static void gimp_display_shell_dnd_bucket_fill (GimpDisplayShell *shell, GimpBucketFillMode fill_mode, const GimpRGB *color, GimpPattern *pattern) { GimpImage *image = gimp_display_get_image (shell->display); GimpDrawable *drawable; if (shell->display->gimp->busy) return; if (! image) return; drawable = gimp_image_get_active_drawable (image); if (! drawable) return; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Cannot modify the pixels of layer groups.")); return; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("The active layer's pixels are locked.")); return; } /* FIXME: there should be a virtual method for this that the * GimpTextLayer can override. */ if (color && gimp_item_is_text_layer (GIMP_ITEM (drawable))) { gimp_text_layer_set (GIMP_TEXT_LAYER (drawable), NULL, "color", color, NULL); } else { gimp_edit_fill_full (image, drawable, color, pattern, GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE, pattern ? C_("undo-type", "Drop pattern to layer") : C_("undo-type", "Drop color to layer")); } gimp_display_shell_dnd_flush (shell, image); }
static void gimp_display_shell_dnd_fill (GimpDisplayShell *shell, GimpFillOptions *options, const gchar *undo_desc) { GimpImage *image = gimp_display_get_image (shell->display); GimpDrawable *drawable; if (shell->display->gimp->busy) return; if (! image) return; drawable = gimp_image_get_active_drawable (image); if (! drawable) return; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Cannot modify the pixels of layer groups.")); return; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("The active layer's pixels are locked.")); return; } /* FIXME: there should be a virtual method for this that the * GimpTextLayer can override. */ if (gimp_fill_options_get_style (options) == GIMP_FILL_STYLE_SOLID && gimp_item_is_text_layer (GIMP_ITEM (drawable))) { GimpRGB color; gimp_context_get_foreground (GIMP_CONTEXT (options), &color); gimp_text_layer_set (GIMP_TEXT_LAYER (drawable), NULL, "color", &color, NULL); } else { gimp_edit_fill (image, drawable, options, undo_desc); } gimp_display_shell_dnd_flush (shell, image); }
void filters_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean writable = FALSE; gboolean gray = FALSE; gboolean alpha = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item; alpha = gimp_drawable_has_alpha (drawable); gray = gimp_drawable_is_gray (drawable); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) writable = FALSE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("filters-color-reduction", writable); SET_SENSITIVE ("filters-color-temperature", writable && !gray); SET_SENSITIVE ("filters-color-to-alpha", writable && !gray && alpha); SET_SENSITIVE ("filters-difference-of-gaussians", writable); SET_SENSITIVE ("filters-gaussian-blur", writable); SET_SENSITIVE ("filters-laplace", writable); SET_SENSITIVE ("filters-lens-distortion", writable); SET_SENSITIVE ("filters-pixelize", writable); SET_SENSITIVE ("filters-polar-coordinates", writable); SET_SENSITIVE ("filters-ripple", writable); SET_SENSITIVE ("filters-sobel", writable); SET_SENSITIVE ("filters-semi-flatten", writable && alpha); SET_SENSITIVE ("filters-threshold-alpha", writable && alpha); SET_SENSITIVE ("filters-unsharp-mask", writable); #undef SET_SENSITIVE }
static gboolean gimp_layer_mask_is_content_locked (const GimpItem *item) { GimpLayerMask *mask = GIMP_LAYER_MASK (item); GimpLayer *layer = gimp_layer_mask_get_layer (mask); if (layer) return gimp_item_is_content_locked (GIMP_ITEM (layer)); return FALSE; }
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 }
static gboolean gimp_blend_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer is not visible.")); return FALSE; } if (! gimp_context_get_gradient (GIMP_CONTEXT (options))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("No gradient available for use with this tool.")); return FALSE; } return TRUE; }
static void gimp_warp_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (tool); GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_PLUS; if (display == tool->display) { /* FIXME have better cursors */ switch (options->behavior) { case GIMP_WARP_BEHAVIOR_MOVE: case GEGL_WARP_BEHAVIOR_GROW: case GEGL_WARP_BEHAVIOR_SHRINK: case GEGL_WARP_BEHAVIOR_SWIRL_CW: case GEGL_WARP_BEHAVIOR_SWIRL_CCW: case GEGL_WARP_BEHAVIOR_ERASE: case GEGL_WARP_BEHAVIOR_SMOOTH: modifier = GIMP_CURSOR_MODIFIER_MOVE; break; } } else { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable)) || ! gimp_item_is_visible (GIMP_ITEM (drawable))) { modifier = GIMP_CURSOR_MODIFIER_BAD; } } gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
gboolean gimp_pdb_item_is_writable (GimpItem *item, GError **error) { g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (gimp_item_is_content_locked (item)) { g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Item '%s' (%d) cannot be modified because its " "contents are locked"), gimp_object_get_name (item), gimp_item_get_ID (item)); return FALSE; } return TRUE; }
static void gimp_blend_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; if (gimp_drawable_is_indexed (drawable) || gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable))) { modifier = GIMP_CURSOR_MODIFIER_BAD; } gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
static void gimp_bucket_fill_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool); GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_BAD; GimpImage *image = gimp_display_get_image (display); if (gimp_image_coords_in_active_pickable (image, coords, options->sample_merged, TRUE)) { GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (! gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) && ! gimp_item_is_content_locked (GIMP_ITEM (drawable)) && gimp_item_is_visible (GIMP_ITEM (drawable))) { switch (options->fill_mode) { case GIMP_BUCKET_FILL_FG: modifier = GIMP_CURSOR_MODIFIER_FOREGROUND; break; case GIMP_BUCKET_FILL_BG: modifier = GIMP_CURSOR_MODIFIER_BACKGROUND; break; case GIMP_BUCKET_FILL_PATTERN: modifier = GIMP_CURSOR_MODIFIER_PATTERN; break; } } } gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
static gboolean gimp_drawable_tree_view_drop_possible (GimpContainerTreeView *tree_view, GimpDndType src_type, GimpViewable *src_viewable, GimpViewable *dest_viewable, GtkTreePath *drop_path, GtkTreeViewDropPosition drop_pos, GtkTreeViewDropPosition *return_drop_pos, GdkDragAction *return_drag_action) { if (GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_possible (tree_view, src_type, src_viewable, dest_viewable, drop_path, drop_pos, return_drop_pos, return_drag_action)) { if (src_type == GIMP_DND_TYPE_COLOR || src_type == GIMP_DND_TYPE_PATTERN) { if (! dest_viewable || gimp_item_is_content_locked (GIMP_ITEM (dest_viewable)) || gimp_viewable_get_children (GIMP_VIEWABLE (dest_viewable))) return FALSE; if (return_drop_pos) { *return_drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER; } } return TRUE; } return FALSE; }
static void gimp_plug_in_handle_tile_put (GimpPlugIn *plug_in, GPTileReq *request) { GPTileData tile_data; GPTileData *tile_info; GimpWireMessage msg; GimpDrawable *drawable; GeglBuffer *buffer; const Babl *format; GeglRectangle tile_rect; tile_data.drawable_ID = -1; tile_data.tile_num = 0; tile_data.shadow = 0; tile_data.bpp = 0; tile_data.width = 0; tile_data.height = 0; tile_data.use_shm = (plug_in->manager->shm != NULL); tile_data.data = NULL; if (! gp_tile_data_write (plug_in->my_write, &tile_data, plug_in)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "%s: ERROR", G_STRFUNC); gimp_plug_in_close (plug_in, TRUE); return; } if (! gimp_wire_read_msg (plug_in->my_read, &msg, plug_in)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "%s: ERROR", G_STRFUNC); gimp_plug_in_close (plug_in, TRUE); return; } if (msg.type != GP_TILE_DATA) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "expected tile data and received: %d", msg.type); gimp_plug_in_close (plug_in, TRUE); return; } tile_info = msg.data; drawable = (GimpDrawable *) gimp_item_get_by_ID (plug_in->manager->gimp, tile_info->drawable_ID); if (! GIMP_IS_DRAWABLE (drawable)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "tried writing to invalid drawable %d (killing)", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), tile_info->drawable_ID); gimp_plug_in_close (plug_in, TRUE); return; } else if (gimp_item_is_removed (GIMP_ITEM (drawable))) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "tried writing to drawable %d which was removed " "from the image (killing)", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), tile_info->drawable_ID); gimp_plug_in_close (plug_in, TRUE); return; } if (tile_info->shadow) { /* don't check whether the drawable is a group or locked here, * the plugin will get a proper error message when it tries to * merge the shadow tiles, which is much better than just * killing it. */ buffer = gimp_drawable_get_shadow_buffer (drawable); gimp_plug_in_cleanup_add_shadow (plug_in, drawable); } else { if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "tried writing to a locked drawable %d (killing)", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), tile_info->drawable_ID); gimp_plug_in_close (plug_in, TRUE); return; } else if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "tried writing to a group layer %d (killing)", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), tile_info->drawable_ID); gimp_plug_in_close (plug_in, TRUE); return; } buffer = gimp_drawable_get_buffer (drawable); } if (! gimp_gegl_buffer_get_tile_rect (buffer, GIMP_PLUG_IN_TILE_WIDTH, GIMP_PLUG_IN_TILE_HEIGHT, tile_info->tile_num, &tile_rect)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "requested invalid tile (killing)", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file)); gimp_plug_in_close (plug_in, TRUE); return; } format = gegl_buffer_get_format (buffer); if (! gimp_plug_in_precision_enabled (plug_in)) { format = gimp_babl_compat_u8_format (format); } if (tile_data.use_shm) { gegl_buffer_set (buffer, &tile_rect, 0, format, gimp_plug_in_shm_get_addr (plug_in->manager->shm), GEGL_AUTO_ROWSTRIDE); } else { gegl_buffer_set (buffer, &tile_rect, 0, format, tile_info->data, GEGL_AUTO_ROWSTRIDE); } gimp_wire_destroy (&msg); if (! gp_tile_ack_write (plug_in->my_write, plug_in)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "%s: ERROR", G_STRFUNC); gimp_plug_in_close (plug_in, TRUE); return; } }
static void gimp_display_shell_drop_buffer (GtkWidget *widget, gint drop_x, gint drop_y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = gimp_display_get_image (shell->display); GimpDrawable *drawable; GimpBuffer *buffer; GimpPasteType paste_type; gint x, y, width, height; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { image = gimp_image_new_from_buffer (shell->display->gimp, NULL, GIMP_BUFFER (viewable)); gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (image); return; } paste_type = GIMP_PASTE_TYPE_FLOATING; drawable = gimp_image_get_active_drawable (image); if (drawable) { if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_INFO, _("Pasted as new layer because the " "target is a layer group.")); paste_type = GIMP_PASTE_TYPE_NEW_LAYER; } else if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Pasted as new layer because the " "target's pixels are locked.")); paste_type = GIMP_PASTE_TYPE_NEW_LAYER; } } buffer = GIMP_BUFFER (viewable); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); /* FIXME: popup a menu for selecting "Paste Into" */ gimp_edit_paste (image, drawable, GIMP_OBJECT (buffer), paste_type, x, y, width, height); gimp_display_shell_dnd_flush (shell, image); }
void edit_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image = action_data_get_image (data); GimpDisplay *display = action_data_get_display (data); GimpDrawable *drawable = NULL; gchar *undo_name = NULL; gchar *redo_name = NULL; gchar *fade_name = NULL; gboolean writable = FALSE; gboolean children = FALSE; gboolean undo_enabled = FALSE; gboolean fade_enabled = 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; } undo_enabled = gimp_image_undo_is_enabled (image); if (undo_enabled) { GimpUndoStack *undo_stack = gimp_image_get_undo_stack (image); GimpUndoStack *redo_stack = gimp_image_get_redo_stack (image); GimpUndo *undo = gimp_undo_stack_peek (undo_stack); GimpUndo *redo = gimp_undo_stack_peek (redo_stack); const gchar *tool_undo = NULL; const gchar *tool_redo = NULL; if (display) { tool_undo = tool_manager_get_undo_desc_active (image->gimp, display); tool_redo = tool_manager_get_redo_desc_active (image->gimp, display); } if (tool_undo) undo_name = g_strdup_printf (_("_Undo %s"), tool_undo); else if (undo) undo_name = g_strdup_printf (_("_Undo %s"), gimp_object_get_name (undo)); if (tool_redo) redo_name = g_strdup_printf (_("_Redo %s"), tool_redo); else if (redo) redo_name = g_strdup_printf (_("_Redo %s"), gimp_object_get_name (redo)); undo = gimp_image_undo_get_fadeable (image); if (GIMP_IS_DRAWABLE_UNDO (undo) && GIMP_DRAWABLE_UNDO (undo)->applied_buffer) { fade_enabled = TRUE; } if (fade_enabled) { fade_name = g_strdup_printf (_("_Fade %s..."), gimp_object_get_name (undo)); } } } #define SET_LABEL(action,label) \ gimp_action_group_set_action_label (group, action, (label)) #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_LABEL ("edit-undo", undo_name ? undo_name : _("_Undo")); SET_LABEL ("edit-redo", redo_name ? redo_name : _("_Redo")); SET_LABEL ("edit-fade", fade_name ? fade_name : _("_Fade...")); SET_SENSITIVE ("edit-undo", undo_enabled && undo_name); SET_SENSITIVE ("edit-redo", undo_enabled && redo_name); SET_SENSITIVE ("edit-strong-undo", undo_enabled && undo_name); SET_SENSITIVE ("edit-strong-redo", undo_enabled && redo_name); SET_SENSITIVE ("edit-undo-clear", undo_enabled && (undo_name || redo_name)); SET_SENSITIVE ("edit-fade", fade_enabled && fade_name); g_free (undo_name); g_free (redo_name); g_free (fade_name); SET_SENSITIVE ("edit-cut", writable && !children); SET_SENSITIVE ("edit-copy", drawable); SET_SENSITIVE ("edit-copy-visible", image); SET_SENSITIVE ("edit-paste", !image || (!drawable || (writable && !children))); SET_SENSITIVE ("edit-paste-as-new-layer", image); SET_SENSITIVE ("edit-paste-into", image && (!drawable || (writable && !children))); SET_SENSITIVE ("edit-named-cut", writable && !children); SET_SENSITIVE ("edit-named-copy", drawable); SET_SENSITIVE ("edit-named-copy-visible", drawable); SET_SENSITIVE ("edit-named-paste", TRUE); SET_SENSITIVE ("edit-clear", writable && !children); SET_SENSITIVE ("edit-fill-fg", writable && !children); SET_SENSITIVE ("edit-fill-bg", writable && !children); SET_SENSITIVE ("edit-fill-pattern", writable && !children); #undef SET_LABEL #undef SET_SENSITIVE }
GimpLayer * gimp_image_merge_down (GimpImage *image, GimpLayer *current_layer, GimpContext *context, GimpMergeType merge_type, GError **error) { GimpLayer *layer; GList *list; GList *layer_list = NULL; GSList *merge_list = NULL; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_LAYER (current_layer), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (current_layer)), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); for (list = gimp_item_get_container_iter (GIMP_ITEM (current_layer)); list; list = g_list_next (list)) { layer = list->data; if (layer == current_layer) break; } for (layer_list = g_list_next (list); layer_list; layer_list = g_list_next (layer_list)) { layer = layer_list->data; if (gimp_item_get_visible (GIMP_ITEM (layer))) { if (gimp_viewable_get_children (GIMP_VIEWABLE (layer))) { g_set_error_literal (error, 0, 0, _("Cannot merge down to a layer group.")); return NULL; } if (gimp_item_is_content_locked (GIMP_ITEM (layer))) { g_set_error_literal (error, 0, 0, _("The layer to merge down to is locked.")); return NULL; } merge_list = g_slist_append (NULL, layer); break; } } if (! merge_list) { g_set_error_literal (error, 0, 0, _("There is no visible layer to merge down to.")); return NULL; } merge_list = g_slist_prepend (merge_list, current_layer); gimp_set_busy (image->gimp); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, C_("undo-type", "Merge Down")); layer = gimp_image_merge_layers (image, gimp_item_get_container (GIMP_ITEM (current_layer)), merge_list, context, merge_type); g_slist_free (merge_list); gimp_image_undo_group_end (image); gimp_unset_busy (image->gimp); return layer; }
void drawable_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean is_rgb = FALSE; gboolean is_gray = FALSE; gboolean is_indexed = FALSE; gboolean visible = FALSE; gboolean linked = FALSE; gboolean locked = FALSE; gboolean can_lock = FALSE; gboolean writable = FALSE; gboolean children = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpImageType drawable_type = gimp_drawable_type (drawable); GimpItem *item; is_rgb = GIMP_IMAGE_TYPE_IS_RGB (drawable_type); is_gray = GIMP_IMAGE_TYPE_IS_GRAY (drawable_type); is_indexed = GIMP_IMAGE_TYPE_IS_INDEXED (drawable_type); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); visible = gimp_item_get_visible (item); linked = gimp_item_get_linked (item); locked = gimp_item_get_lock_content (item); can_lock = gimp_item_can_lock_content (item); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) children = TRUE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) #define SET_ACTIVE(action,condition) \ gimp_action_group_set_action_active (group, action, (condition) != 0) SET_SENSITIVE ("drawable-equalize", writable && !children && !is_indexed); SET_SENSITIVE ("drawable-invert", writable && !children && !is_indexed); SET_SENSITIVE ("drawable-levels-stretch", writable && !children && is_rgb); SET_SENSITIVE ("drawable-offset", writable && !children); SET_SENSITIVE ("drawable-visible", drawable); SET_SENSITIVE ("drawable-linked", drawable); SET_SENSITIVE ("drawable-lock-content", can_lock); SET_ACTIVE ("drawable-visible", visible); SET_ACTIVE ("drawable-linked", linked); SET_ACTIVE ("drawable-lock-content", locked); SET_SENSITIVE ("drawable-flip-horizontal", writable); SET_SENSITIVE ("drawable-flip-vertical", writable); SET_SENSITIVE ("drawable-rotate-90", writable); SET_SENSITIVE ("drawable-rotate-180", writable); SET_SENSITIVE ("drawable-rotate-270", writable); #undef SET_SENSITIVE #undef SET_ACTIVE }
static gboolean gimp_image_map_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool); GimpToolInfo *tool_info = tool->tool_info; GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpDisplayShell *shell = gimp_display_get_shell (display); if (! drawable) return FALSE; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer is not visible.")); return FALSE; } if (im_tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker), FALSE); /* set display so the dialog can be hidden on display destruction */ tool->display = display; if (im_tool->config) gimp_config_reset (GIMP_CONFIG (im_tool->config)); if (! im_tool->gui) { GimpImageMapToolClass *klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool); GtkWidget *vbox; GtkWidget *hbox; GtkWidget *toggle; gchar *operation_name; /* disabled for at least GIMP 2.8 */ im_tool->overlay = FALSE; im_tool->gui = gimp_tool_gui_new (tool_info, im_tool->title, im_tool->description, im_tool->icon_name, im_tool->help_id, gtk_widget_get_screen (GTK_WIDGET (shell)), gimp_widget_get_monitor (GTK_WIDGET (shell)), im_tool->overlay, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gimp_tool_gui_set_default_response (im_tool->gui, GTK_RESPONSE_OK); gimp_tool_gui_set_alternative_button_order (im_tool->gui, RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gimp_tool_gui_get_vbox (im_tool->gui); g_signal_connect_object (im_tool->gui, "response", G_CALLBACK (gimp_image_map_tool_response), G_OBJECT (im_tool), 0); if (im_tool->config && klass->settings_name) { GType type = G_TYPE_FROM_INSTANCE (im_tool->config); GimpContainer *settings; GFile *settings_file; GFile *default_folder; GtkWidget *settings_ui; settings = gimp_gegl_config_get_container (type); if (! gimp_list_get_sort_func (GIMP_LIST (settings))) gimp_list_set_sort_func (GIMP_LIST (settings), (GCompareFunc) gimp_settings_compare); settings_file = gimp_tool_info_get_options_file (tool_info, ".settings"); default_folder = gimp_directory_file (klass->settings_name, NULL); settings_ui = klass->get_settings_ui (im_tool, settings, settings_file, klass->import_dialog_title, klass->export_dialog_title, im_tool->help_id, default_folder, &im_tool->settings_box); g_object_unref (default_folder); g_object_unref (settings_file); gtk_box_pack_start (GTK_BOX (vbox), settings_ui, FALSE, FALSE, 0); gtk_widget_show (settings_ui); } /* The gamma hack toggle */ toggle = gtk_check_button_new_with_label ("Gamma hack (temp hack, please ignore)"); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gamma_hack), im_tool); /* The preview and split view toggles */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), "preview", NULL); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), "preview-split", NULL); gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_object_bind_property (G_OBJECT (tool_info->tool_options), "preview", toggle, "sensitive", G_BINDING_SYNC_CREATE); /* The area combo */ gegl_node_get (im_tool->operation, "operation", &operation_name, NULL); im_tool->region_combo = gimp_prop_enum_combo_box_new (G_OBJECT (tool_info->tool_options), "region", 0, 0); gtk_box_pack_end (GTK_BOX (vbox), im_tool->region_combo, FALSE, FALSE, 0); if (operation_name && gegl_operation_get_key (operation_name, "position-dependent")) { gtk_widget_show (im_tool->region_combo); } g_free (operation_name); /* Fill in subclass widgets */ gimp_image_map_tool_dialog (im_tool); } else { gimp_tool_gui_set_title (im_tool->gui, im_tool->title); gimp_tool_gui_set_description (im_tool->gui, im_tool->description); gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name); gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id); } gimp_tool_gui_set_shell (im_tool->gui, shell); gimp_tool_gui_set_viewable (im_tool->gui, GIMP_VIEWABLE (drawable)); gimp_tool_gui_show (im_tool->gui); im_tool->drawable = drawable; gimp_image_map_tool_create_map (im_tool); gimp_image_map_tool_preview (im_tool); return TRUE; }
static gboolean gimp_warp_tool_start (GimpWarpTool *wt, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (wt); GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); const Babl *format; GeglRectangle bbox; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_tool_message_literal (tool, display, _("Cannot warp layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_tool_message_literal (tool, display, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { gimp_tool_message_literal (tool, display, _("The active layer is not visible.")); return FALSE; } tool->display = display; tool->drawable = drawable; /* Create the coords buffer, with the size of the selection */ format = babl_format_n (babl_type ("float"), 2); gimp_item_mask_intersect (GIMP_ITEM (drawable), &bbox.x, &bbox.y, &bbox.width, &bbox.height); #ifdef WARP_DEBUG g_printerr ("Initialize coordinate buffer (%d,%d) at %d,%d\n", bbox.width, bbox.height, bbox.x, bbox.y); #endif wt->coords_buffer = gegl_buffer_new (&bbox, format); gimp_warp_tool_create_filter (wt, drawable); if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt))) gimp_draw_tool_start (GIMP_DRAW_TOOL (wt), display); if (options->animate_button) { g_signal_connect_swapped (options->animate_button, "clicked", G_CALLBACK (gimp_warp_tool_animate), wt); gtk_widget_set_sensitive (options->animate_button, TRUE); } return TRUE; }
void layers_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image = action_data_get_image (data); GimpLayer *layer = NULL; GimpLayerMask *mask = NULL; /* layer mask */ gboolean fs = FALSE; /* floating sel */ gboolean ac = FALSE; /* active channel */ gboolean sel = FALSE; gboolean alpha = FALSE; /* alpha channel present */ gboolean indexed = FALSE; /* is indexed */ gboolean lock_alpha = FALSE; gboolean can_lock_alpha = FALSE; gboolean text_layer = FALSE; gboolean writable = FALSE; gboolean children = FALSE; GList *next = NULL; GList *next_visible = NULL; GList *prev = NULL; if (image) { fs = (gimp_image_get_floating_selection (image) != NULL); ac = (gimp_image_get_active_channel (image) != NULL); sel = ! gimp_channel_is_empty (gimp_image_get_mask (image)); indexed = (gimp_image_base_type (image) == GIMP_INDEXED); layer = gimp_image_get_active_layer (image); if (layer) { GList *layer_list; GList *list; mask = gimp_layer_get_mask (layer); lock_alpha = gimp_layer_get_lock_alpha (layer); can_lock_alpha = gimp_layer_can_lock_alpha (layer); alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)); writable = ! gimp_item_is_content_locked (GIMP_ITEM (layer)); if (gimp_viewable_get_children (GIMP_VIEWABLE (layer))) children = TRUE; layer_list = gimp_item_get_container_iter (GIMP_ITEM (layer)); list = g_list_find (layer_list, layer); if (list) { prev = g_list_previous (list); next = g_list_next (list); for (next_visible = next; next_visible; next_visible = g_list_next (next_visible)) { if (gimp_item_get_visible (next_visible->data)) { /* "next_visible" is actually "next_visible" and * "writable" and "not group" */ if (gimp_item_is_content_locked (next_visible->data) || gimp_viewable_get_children (next_visible->data)) next_visible = NULL; break; } } } text_layer = gimp_item_is_text_layer (GIMP_ITEM (layer)); } } #define SET_VISIBLE(action,condition) \ gimp_action_group_set_action_visible (group, action, (condition) != 0) #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) #define SET_ACTIVE(action,condition) \ gimp_action_group_set_action_active (group, action, (condition) != 0) #define SET_LABEL(action,label) \ gimp_action_group_set_action_label (group, action, label) SET_VISIBLE ("layers-text-tool", text_layer && !ac); SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac); if (layer && gimp_layer_is_floating_sel (layer)) { SET_LABEL ("layers-new", C_("layers-action", "To _New Layer")); SET_LABEL ("layers-new-last-values", C_("layers-action", "To _New Layer")); } else { SET_LABEL ("layers-new", C_("layers-action", "_New Layer...")); SET_LABEL ("layers-new-last-values", C_("layers-action", "_New Layer")); } SET_SENSITIVE ("layers-new", image); SET_SENSITIVE ("layers-new-last-values", image); SET_SENSITIVE ("layers-new-from-visible", image); SET_SENSITIVE ("layers-new-group", image && !indexed); SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac); SET_SENSITIVE ("layers-delete", layer && !ac); SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev); SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next); SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev); SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next); SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev); SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev); SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next); SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next); SET_SENSITIVE ("layers-anchor", layer && fs && !ac); SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next_visible); SET_VISIBLE ("layers-merge-group", children); SET_SENSITIVE ("layers-merge-group", layer && !fs && !ac && children); SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac); SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac); SET_VISIBLE ("layers-text-discard", text_layer && !ac); SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac); SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac); SET_SENSITIVE ("layers-resize", writable && !ac); SET_SENSITIVE ("layers-resize-to-image", writable && !ac); SET_SENSITIVE ("layers-scale", writable && !ac); SET_SENSITIVE ("layers-crop", writable && sel); SET_SENSITIVE ("layers-alpha-add", writable && !children && !fs && !alpha); SET_SENSITIVE ("layers-alpha-remove", writable && !children && !fs && alpha); SET_SENSITIVE ("layers-lock-alpha", can_lock_alpha); SET_ACTIVE ("layers-lock-alpha", lock_alpha); SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask && !children); SET_SENSITIVE ("layers-mask-apply", writable && !fs && !ac && mask && !children); SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask); SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask)); SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask)); SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask)); SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask); SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac); SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac); SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac); SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac); #undef SET_VISIBLE #undef SET_SENSITIVE #undef SET_ACTIVE #undef SET_LABEL }
void vectors_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image = action_data_get_image (data); GimpVectors *vectors = NULL; GimpDrawable *drawable = NULL; gint n_vectors = 0; gboolean mask_empty = TRUE; gboolean visible = FALSE; gboolean linked = FALSE; gboolean locked = FALSE; gboolean can_lock = FALSE; gboolean locked_pos = FALSE; gboolean can_lock_pos = FALSE; gboolean dr_writable = FALSE; gboolean dr_children = FALSE; GList *next = NULL; GList *prev = NULL; if (image) { n_vectors = gimp_image_get_n_vectors (image); mask_empty = gimp_channel_is_empty (gimp_image_get_mask (image)); vectors = gimp_image_get_active_vectors (image); if (vectors) { GimpItem *item = GIMP_ITEM (vectors); GList *vectors_list; GList *list; visible = gimp_item_get_visible (item); linked = gimp_item_get_linked (item); locked = gimp_item_get_lock_content (item); can_lock = gimp_item_can_lock_content (item); locked_pos = gimp_item_get_lock_position (item); can_lock_pos = gimp_item_can_lock_position (item); vectors_list = gimp_item_get_container_iter (item); list = g_list_find (vectors_list, vectors); if (list) { prev = g_list_previous (list); next = g_list_next (list); } } drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item = GIMP_ITEM (drawable); dr_writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (item))) dr_children = TRUE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) #define SET_ACTIVE(action,condition) \ gimp_action_group_set_action_active (group, action, (condition) != 0) SET_SENSITIVE ("vectors-path-tool", vectors); SET_SENSITIVE ("vectors-edit-attributes", vectors); SET_SENSITIVE ("vectors-new", image); SET_SENSITIVE ("vectors-new-last-values", image); SET_SENSITIVE ("vectors-duplicate", vectors); SET_SENSITIVE ("vectors-delete", vectors); SET_SENSITIVE ("vectors-merge-visible", n_vectors > 1); SET_SENSITIVE ("vectors-raise", vectors && prev); SET_SENSITIVE ("vectors-raise-to-top", vectors && prev); SET_SENSITIVE ("vectors-lower", vectors && next); SET_SENSITIVE ("vectors-lower-to-bottom", vectors && next); SET_SENSITIVE ("vectors-copy", vectors); SET_SENSITIVE ("vectors-paste", image); SET_SENSITIVE ("vectors-export", vectors); SET_SENSITIVE ("vectors-import", image); SET_SENSITIVE ("vectors-visible", vectors); SET_SENSITIVE ("vectors-linked", vectors); SET_SENSITIVE ("vectors-lock-content", can_lock); SET_SENSITIVE ("vectors-lock-position", can_lock_pos); SET_ACTIVE ("vectors-visible", visible); SET_ACTIVE ("vectors-linked", linked); SET_ACTIVE ("vectors-lock-content", locked); SET_ACTIVE ("vectors-lock-position", locked_pos); SET_SENSITIVE ("vectors-selection-to-vectors", image && !mask_empty); SET_SENSITIVE ("vectors-selection-to-vectors-short", image && !mask_empty); SET_SENSITIVE ("vectors-selection-to-vectors-advanced", image && !mask_empty); SET_SENSITIVE ("vectors-fill", vectors && dr_writable && !dr_children); SET_SENSITIVE ("vectors-fill-last-values", vectors && dr_writable && !dr_children); SET_SENSITIVE ("vectors-stroke", vectors && dr_writable && !dr_children); SET_SENSITIVE ("vectors-stroke-last-values", vectors && dr_writable && !dr_children); SET_SENSITIVE ("vectors-selection-replace", vectors); SET_SENSITIVE ("vectors-selection-from-vectors", vectors); SET_SENSITIVE ("vectors-selection-add", vectors); SET_SENSITIVE ("vectors-selection-subtract", vectors); SET_SENSITIVE ("vectors-selection-intersect", vectors); #undef SET_SENSITIVE #undef SET_ACTIVE }
void filters_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean writable = FALSE; gboolean gray = FALSE; gboolean alpha = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item; alpha = gimp_drawable_has_alpha (drawable); gray = gimp_drawable_is_gray (drawable); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) writable = FALSE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("filters-alien-map", writable); SET_SENSITIVE ("filters-antialias", writable); SET_SENSITIVE ("filters-apply-canvas", writable); SET_SENSITIVE ("filters-apply-lens", writable); SET_SENSITIVE ("filters-bump-map", writable); SET_SENSITIVE ("filters-c2g", writable && !gray); SET_SENSITIVE ("filters-cartoon", writable); SET_SENSITIVE ("filters-channel-mixer", writable); SET_SENSITIVE ("filters-checkerboard", writable); SET_SENSITIVE ("filters-color-enhance", writable && !gray); SET_SENSITIVE ("filters-color-exchange", writable); SET_SENSITIVE ("filters-color-reduction", writable); SET_SENSITIVE ("filters-color-rotate", writable); SET_SENSITIVE ("filters-color-temperature", writable && !gray); SET_SENSITIVE ("filters-color-to-alpha", writable && !gray && alpha); SET_SENSITIVE ("filters-convolution-matrix", writable); SET_SENSITIVE ("filters-cubism", writable); SET_SENSITIVE ("filters-deinterlace", writable); SET_SENSITIVE ("filters-desaturate", writable && !gray); SET_SENSITIVE ("filters-difference-of-gaussians", writable); SET_SENSITIVE ("filters-diffraction-patterns", writable); SET_SENSITIVE ("filters-displace", writable); SET_SENSITIVE ("filters-distance-map", writable); SET_SENSITIVE ("filters-dropshadow", writable && alpha); SET_SENSITIVE ("filters-edge", writable); SET_SENSITIVE ("filters-edge-laplace", writable); SET_SENSITIVE ("filters-edge-sobel", writable); SET_SENSITIVE ("filters-emboss", writable); SET_SENSITIVE ("filters-engrave", writable); SET_SENSITIVE ("filters-exposure", writable); SET_SENSITIVE ("filters-fractal-trace", writable); SET_SENSITIVE ("filters-gaussian-blur", writable); SET_SENSITIVE ("filters-gaussian-blur-selective", writable); SET_SENSITIVE ("filters-gegl-graph", writable); SET_SENSITIVE ("filters-grid", writable); SET_SENSITIVE ("filters-high-pass", writable); SET_SENSITIVE ("filters-illusion", writable); SET_SENSITIVE ("filters-kaleidoscope", writable); SET_SENSITIVE ("filters-lens-distortion", writable); SET_SENSITIVE ("filters-lens-flare", writable); SET_SENSITIVE ("filters-maze", writable); SET_SENSITIVE ("filters-mono-mixer", writable && !gray); SET_SENSITIVE ("filters-mosaic", writable); SET_SENSITIVE ("filters-motion-blur-circular", writable); SET_SENSITIVE ("filters-motion-blur-linear", writable); SET_SENSITIVE ("filters-motion-blur-zoom", writable); SET_SENSITIVE ("filters-noise-cell", writable); SET_SENSITIVE ("filters-noise-cie-lch", writable); SET_SENSITIVE ("filters-noise-hsv", writable && !gray); SET_SENSITIVE ("filters-noise-hurl", writable); SET_SENSITIVE ("filters-noise-perlin", writable); SET_SENSITIVE ("filters-noise-pick", writable); SET_SENSITIVE ("filters-noise-reduction", writable); SET_SENSITIVE ("filters-noise-rgb", writable); SET_SENSITIVE ("filters-noise-simplex", writable); SET_SENSITIVE ("filters-noise-slur", writable); SET_SENSITIVE ("filters-noise-solid", writable); SET_SENSITIVE ("filters-noise-spread", writable); SET_SENSITIVE ("filters-oilify", writable); SET_SENSITIVE ("filters-panorama-projection", writable); SET_SENSITIVE ("filters-photocopy", writable); SET_SENSITIVE ("filters-pixelize", writable); SET_SENSITIVE ("filters-plasma", writable); SET_SENSITIVE ("filters-polar-coordinates", writable); SET_SENSITIVE ("filters-posterize", writable); SET_SENSITIVE ("filters-red-eye-removal", writable && !gray); SET_SENSITIVE ("filters-ripple", writable); SET_SENSITIVE ("filters-saturation", writable && !gray); SET_SENSITIVE ("filters-semi-flatten", writable && alpha); SET_SENSITIVE ("filters-sepia", writable && !gray); SET_SENSITIVE ("filters-shift", writable); SET_SENSITIVE ("filters-sinus", writable); SET_SENSITIVE ("filters-softglow", writable); SET_SENSITIVE ("filters-stretch-contrast", writable); SET_SENSITIVE ("filters-stretch-contrast-hsv", writable); SET_SENSITIVE ("filters-supernova", writable); SET_SENSITIVE ("filters-threshold-alpha", writable && alpha); SET_SENSITIVE ("filters-tile-glass", writable); SET_SENSITIVE ("filters-tile-paper", writable); SET_SENSITIVE ("filters-tile-seamless", writable); SET_SENSITIVE ("filters-unsharp-mask", writable); SET_SENSITIVE ("filters-value-propagate", writable); SET_SENSITIVE ("filters-video-degradation", writable); SET_SENSITIVE ("filters-vignette", writable); SET_SENSITIVE ("filters-waves", writable); SET_SENSITIVE ("filters-whirl-pinch", writable); SET_SENSITIVE ("filters-wind", writable); #undef SET_SENSITIVE { GimpProcedure *proc = gimp_filter_history_nth (group->gimp, 0); gint i; if (proc && gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable))) { gimp_action_group_set_action_sensitive (group, "filters-repeat", TRUE); gimp_action_group_set_action_sensitive (group, "filters-reshow", TRUE); } else { gimp_action_group_set_action_sensitive (group, "filters-repeat", FALSE); gimp_action_group_set_action_sensitive (group, "filters-reshow", FALSE); } for (i = 0; i < gimp_filter_history_length (group->gimp); i++) { gchar *name = g_strdup_printf ("filter-recent-%02d", i + 1); gboolean sensitive; proc = gimp_filter_history_nth (group->gimp, i); sensitive = gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable)); gimp_action_group_set_action_sensitive (group, name, sensitive); g_free (name); } } }
GimpLayer * gimp_edit_paste (GimpImage *image, GimpDrawable *drawable, GimpObject *paste, GimpPasteType paste_type, gint viewport_x, gint viewport_y, gint viewport_width, gint viewport_height) { GimpLayer *layer = NULL; const Babl *floating_format; gint offset_x; gint offset_y; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (drawable == NULL || gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL); /* change paste type to NEW_LAYER for cases where we can't attach a * floating selection */ if (! drawable || gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable))) { paste_type = GIMP_PASTE_TYPE_NEW_LAYER; } /* floating pastes always have the pasted-to drawable's format with * alpha; if drawable == NULL, user is pasting into an empty image */ if (drawable) floating_format = gimp_drawable_get_format_with_alpha (drawable); else floating_format = gimp_image_get_layer_format (image, TRUE); if (GIMP_IS_IMAGE (paste)) { GType layer_type; layer = gimp_image_get_layer_iter (GIMP_IMAGE (paste))->data; switch (paste_type) { case GIMP_PASTE_TYPE_FLOATING: case GIMP_PASTE_TYPE_FLOATING_INTO: /* when pasting as floating selection, force creation of a * plain layer, so gimp_item_convert() will collapse a * group layer */ layer_type = GIMP_TYPE_LAYER; break; case GIMP_PASTE_TYPE_NEW_LAYER: layer_type = G_TYPE_FROM_INSTANCE (layer); break; default: g_return_val_if_reached (NULL); } layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer), image, layer_type)); switch (paste_type) { case GIMP_PASTE_TYPE_FLOATING: case GIMP_PASTE_TYPE_FLOATING_INTO: /* when pasting as floating selection, get rid of the layer mask, * and make sure the layer has the right format */ if (gimp_layer_get_mask (layer)) gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE); if (gimp_drawable_get_format (GIMP_DRAWABLE (layer)) != floating_format) { gimp_drawable_convert_type (GIMP_DRAWABLE (layer), image, gimp_drawable_get_base_type (drawable), gimp_drawable_get_precision (drawable), TRUE, NULL, GEGL_DITHER_NONE, GEGL_DITHER_NONE, FALSE, NULL); } break; default: break; } } else if (GIMP_IS_BUFFER (paste)) { layer = gimp_layer_new_from_buffer (GIMP_BUFFER (paste), image, floating_format, _("Pasted Layer"), GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); } if (! layer) return NULL; gimp_edit_get_paste_offset (image, drawable, GIMP_OBJECT (layer), viewport_x, viewport_y, viewport_width, viewport_height, &offset_x, &offset_y); gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, C_("undo-type", "Paste")); switch (paste_type) { case GIMP_PASTE_TYPE_FLOATING: /* if there is a selection mask clear it - this might not * always be desired, but in general, it seems like the correct * behavior */ if (! gimp_channel_is_empty (gimp_image_get_mask (image))) gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE); /* fall thru */ case GIMP_PASTE_TYPE_FLOATING_INTO: floating_sel_attach (layer, drawable); break; case GIMP_PASTE_TYPE_NEW_LAYER: { GimpLayer *parent = NULL; gint position = 0; /* always add on top of the passed layer, where we would * attach a floating selection */ if (GIMP_IS_LAYER (drawable)) { parent = gimp_layer_get_parent (GIMP_LAYER (drawable)); position = gimp_item_get_index (GIMP_ITEM (drawable)); } gimp_image_add_layer (image, layer, parent, position, TRUE); } break; } gimp_image_undo_group_end (image); return layer; }
void filters_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean writable = FALSE; gboolean gray = FALSE; gboolean alpha = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item; alpha = gimp_drawable_has_alpha (drawable); gray = gimp_drawable_is_gray (drawable); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) writable = FALSE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("filters-c2g", writable && !gray); SET_SENSITIVE ("filters-cartoon", writable); SET_SENSITIVE ("filters-checkerboard", writable); SET_SENSITIVE ("filters-color-reduction", writable); SET_SENSITIVE ("filters-color-temperature", writable && !gray); SET_SENSITIVE ("filters-color-to-alpha", writable && !gray && alpha); SET_SENSITIVE ("filters-cubism", writable); SET_SENSITIVE ("filters-deinterlace", writable); SET_SENSITIVE ("filters-difference-of-gaussians", writable); SET_SENSITIVE ("filters-dot", writable); SET_SENSITIVE ("filters-dropshadow", writable && alpha); SET_SENSITIVE ("filters-edge-laplace", writable); SET_SENSITIVE ("filters-edge-sobel", writable); SET_SENSITIVE ("filters-emboss", writable); SET_SENSITIVE ("filters-exposure", writable); SET_SENSITIVE ("filters-fractal-trace", writable); SET_SENSITIVE ("filters-gaussian-blur", writable); SET_SENSITIVE ("filters-grid", writable); SET_SENSITIVE ("filters-mono-mixer", writable && !gray); SET_SENSITIVE ("filters-motion-blur-circular", writable); SET_SENSITIVE ("filters-motion-blur-linear", writable); SET_SENSITIVE ("filters-motion-blur-zoom", writable); SET_SENSITIVE ("filters-noise-cie-lch", writable); SET_SENSITIVE ("filters-noise-hsv", writable && !gray); SET_SENSITIVE ("filters-noise-hurl", writable); SET_SENSITIVE ("filters-noise-pick", writable); SET_SENSITIVE ("filters-noise-rgb", writable); SET_SENSITIVE ("filters-noise-slur", writable); SET_SENSITIVE ("filters-noise-spread", writable); SET_SENSITIVE ("filters-lens-distortion", writable); SET_SENSITIVE ("filters-photocopy", writable); SET_SENSITIVE ("filters-pixelize", writable); SET_SENSITIVE ("filters-polar-coordinates", writable); SET_SENSITIVE ("filters-red-eye-removal", writable && !gray); SET_SENSITIVE ("filters-ripple", writable); SET_SENSITIVE ("filters-semi-flatten", writable && alpha); SET_SENSITIVE ("filters-shift", writable); SET_SENSITIVE ("filters-softglow", writable); SET_SENSITIVE ("filters-threshold-alpha", writable && alpha); SET_SENSITIVE ("filters-unsharp-mask", writable); SET_SENSITIVE ("filters-vignette", writable); SET_SENSITIVE ("filters-waves", writable); SET_SENSITIVE ("filters-whirl-pinch", writable); #undef SET_SENSITIVE }
static void gimp_paint_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); GimpPaintCore *core = paint_tool->core; GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpCoords curr_coords; gint off_x, off_y; GError *error = NULL; if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); return; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_tool_message_literal (tool, display, _("Cannot paint on layer groups.")); return; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_tool_message_literal (tool, display, _("The active layer's pixels are locked.")); return; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { gimp_tool_message_literal (tool, display, _("The active layer is not visible.")); return; } curr_coords = *coords; gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); curr_coords.x -= off_x; curr_coords.y -= off_y; if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_stop (draw_tool); if (tool->display && tool->display != display && gimp_display_get_image (tool->display) == image) { /* if this is a different display, but the same image, HACK around * in tool internals AFTER stopping the current draw_tool, so * straight line drawing works across different views of the * same image. */ tool->display = display; } if (! gimp_paint_core_start (core, drawable, paint_options, &curr_coords, &error)) { gimp_tool_message_literal (tool, display, error->message); g_clear_error (&error); return; } if ((display != tool->display) || ! paint_tool->draw_line) { /* if this is a new display, resest the "last stroke's endpoint" * because there is none */ if (display != tool->display) core->start_coords = core->cur_coords; core->last_coords = core->cur_coords; core->distance = 0.0; core->pixel_dist = 0.0; } else if (paint_tool->draw_line) { gboolean constrain = (state & gimp_get_constrain_behavior_mask ()) != 0; /* If shift is down and this is not the first paint * stroke, then draw a line from the last coords to the pointer */ gimp_paint_core_round_line (core, paint_options, constrain); } /* chain up to activate the tool */ GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); /* pause the current selection */ gimp_display_shell_selection_pause (shell); /* Let the specific painting function initialize itself */ gimp_paint_core_paint (core, drawable, paint_options, GIMP_PAINT_STATE_INIT, time); /* Paint to the image */ if (paint_tool->draw_line) { gimp_paint_core_interpolate (core, drawable, paint_options, &core->cur_coords, time); } else { gimp_paint_core_paint (core, drawable, paint_options, GIMP_PAINT_STATE_MOTION, time); } gimp_projection_flush_now (gimp_image_get_projection (image)); gimp_display_flush_now (display); gimp_draw_tool_start (draw_tool, display); }