void gimp_channel_select_by_color (GimpChannel *channel, GimpDrawable *drawable, gboolean sample_merged, const GimpRGB *color, gfloat threshold, gboolean select_transparent, GimpSelectCriterion select_criterion, GimpChannelOps op, gboolean antialias, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y) { GimpPickable *pickable; GeglBuffer *add_on; gint add_on_x = 0; gint add_on_y = 0; g_return_if_fail (GIMP_IS_CHANNEL (channel)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (color != NULL); if (sample_merged) pickable = GIMP_PICKABLE (gimp_item_get_image (GIMP_ITEM (drawable))); else pickable = GIMP_PICKABLE (drawable); add_on = gimp_pickable_contiguous_region_by_color (pickable, antialias, threshold, select_transparent, select_criterion, color); if (! sample_merged) gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y); gimp_channel_select_buffer (channel, C_("undo-type", "Select by Color"), add_on, add_on_x, add_on_y, op, feather, feather_radius_x, feather_radius_y); g_object_unref (add_on); }
void gimp_drawable_brightness_contrast (GimpDrawable *drawable, GimpProgress *progress, gint brightness, gint contrast) { GimpBrightnessContrastConfig *config; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (! gimp_drawable_is_indexed (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); config = g_object_new (GIMP_TYPE_BRIGHTNESS_CONTRAST_CONFIG, "brightness", brightness / 127.0, "contrast", contrast / 127.0, NULL); if (gimp_use_gegl (gimp_item_get_image (GIMP_ITEM (drawable))->gimp)) { GeglNode *node; node = g_object_new (GEGL_TYPE_NODE, "operation", "gimp:brightness-contrast", "config", config, NULL); gimp_drawable_apply_operation (drawable, progress, C_("undo-type", "Brightness-Contrast") , node, TRUE); g_object_unref (node); } else { GimpLut *lut; lut = brightness_contrast_lut_new (config->brightness / 2.0, config->contrast, gimp_drawable_bytes (drawable)); gimp_drawable_process_lut (drawable, progress, C_("undo-type", "Brightness-Contrast"), lut); gimp_lut_free (lut); } g_object_unref (config); }
gboolean gimp_item_get_popup_size (GimpViewable *viewable, gint width, gint height, gboolean dot_for_dot, gint *popup_width, gint *popup_height) { GimpItem *item = GIMP_ITEM (viewable); GimpImage *image = gimp_item_get_image (item); if (image && ! image->gimp->config->layer_previews) return FALSE; if (gimp_item_get_width (item) > width || gimp_item_get_height (item) > height) { gboolean scaling_up; gdouble xres = 1.0; gdouble yres = 1.0; if (image) gimp_image_get_resolution (image, &xres, &yres); gimp_viewable_calc_preview_size (gimp_item_get_width (item), gimp_item_get_height (item), width * 2, height * 2, dot_for_dot, xres, yres, popup_width, popup_height, &scaling_up); if (scaling_up) { *popup_width = gimp_item_get_width (item); *popup_height = gimp_item_get_height (item); } return TRUE; } return FALSE; }
void gimp_channel_select_scan_convert (GimpChannel *channel, const gchar *undo_desc, GimpScanConvert *scan_convert, gint offset_x, gint offset_y, GimpChannelOps op, gboolean antialias, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y, gboolean push_undo) { GimpItem *item; GimpChannel *add_on; g_return_if_fail (GIMP_IS_CHANNEL (channel)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); g_return_if_fail (undo_desc != NULL); g_return_if_fail (scan_convert != NULL); if (push_undo) gimp_channel_push_undo (channel, undo_desc); /* if applicable, replace the current selection */ if (op == GIMP_CHANNEL_OP_REPLACE) gimp_channel_clear (channel, NULL, FALSE); item = GIMP_ITEM (channel); add_on = gimp_channel_new_mask (gimp_item_get_image (item), gimp_item_width (item), gimp_item_height (item)); gimp_scan_convert_render (scan_convert, gimp_drawable_get_tiles (GIMP_DRAWABLE (add_on)), offset_x, offset_y, antialias); if (feather) gimp_channel_feather (add_on, feather_radius_x, feather_radius_y, FALSE /* no undo */); gimp_channel_combine_mask (channel, add_on, op, 0, 0); g_object_unref (add_on); }
void gimp_drawable_stroke_scan_convert (GimpDrawable *drawable, GimpStrokeOptions *options, GimpScanConvert *scan_convert, gboolean push_undo) { gdouble width; GimpUnit unit; 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_STROKE_OPTIONS (options)); g_return_if_fail (scan_convert != NULL); g_return_if_fail (gimp_fill_options_get_style (GIMP_FILL_OPTIONS (options)) != GIMP_FILL_STYLE_PATTERN || gimp_context_get_pattern (GIMP_CONTEXT (options)) != NULL); if (! gimp_item_mask_intersect (GIMP_ITEM (drawable), NULL, NULL, NULL, NULL)) return; width = gimp_stroke_options_get_width (options); unit = gimp_stroke_options_get_unit (options); if (unit != GIMP_UNIT_PIXEL) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); gimp_scan_convert_set_pixel_ratio (scan_convert, yres / xres); width = gimp_units_to_pixels (width, unit, yres); } gimp_scan_convert_stroke (scan_convert, width, gimp_stroke_options_get_join_style (options), gimp_stroke_options_get_cap_style (options), gimp_stroke_options_get_miter_limit (options), gimp_stroke_options_get_dash_offset (options), gimp_stroke_options_get_dash_info (options)); gimp_drawable_fill_scan_convert (drawable, GIMP_FILL_OPTIONS (options), scan_convert, push_undo); }
void gimp_channel_select_by_color (GimpChannel *channel, GimpDrawable *drawable, gboolean sample_merged, const GimpRGB *color, gint threshold, gboolean select_transparent, GimpSelectCriterion select_criterion, GimpChannelOps op, gboolean antialias, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y) { GimpItem *item; GimpChannel *add_on; gint add_on_x = 0; gint add_on_y = 0; g_return_if_fail (GIMP_IS_CHANNEL (channel)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (color != NULL); item = GIMP_ITEM (channel); add_on = gimp_image_contiguous_region_by_color (gimp_item_get_image (item), drawable, sample_merged, antialias, threshold, select_transparent, select_criterion, color); if (! sample_merged) gimp_item_offsets (GIMP_ITEM (drawable), &add_on_x, &add_on_y); gimp_channel_select_channel (channel, Q_("command|Select by Color"), add_on, add_on_x, add_on_y, op, feather, feather_radius_x, feather_radius_y); g_object_unref (add_on); }
static GimpValueArray * edit_cut_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; gboolean non_empty = FALSE; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); if (success) { if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, GIMP_PDB_ITEM_CONTENT, error) && gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error)) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); GError *my_error = NULL; non_empty = gimp_edit_cut (image, drawable, context, &my_error) != NULL; if (! non_empty) { gimp_message_literal (gimp, G_OBJECT (progress), GIMP_MESSAGE_WARNING, my_error->message); g_clear_error (&my_error); } } else success = FALSE; } 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), non_empty); return return_vals; }
static void gimp_image_map_tool_add_guide (GimpImageMapTool *im_tool) { GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool); GimpItem *item; GimpImage *image; GimpOrientationType orientation; gint position; if (im_tool->percent_guide) return; item = GIMP_ITEM (im_tool->drawable); image = gimp_item_get_image (item); if (options->preview_alignment == GIMP_ALIGN_LEFT || options->preview_alignment == GIMP_ALIGN_RIGHT) { orientation = GIMP_ORIENTATION_VERTICAL; position = (gimp_item_get_offset_x (item) + gimp_item_get_width (item) * options->preview_position); } else { orientation = GIMP_ORIENTATION_HORIZONTAL; position = (gimp_item_get_offset_y (item) + gimp_item_get_height (item) * options->preview_position); } im_tool->percent_guide = gimp_guide_custom_new (orientation, image->gimp->next_guide_ID++, GIMP_GUIDE_STYLE_SPLIT_VIEW); gimp_image_add_guide (image, im_tool->percent_guide, position); g_signal_connect (im_tool->percent_guide, "removed", G_CALLBACK (gimp_image_map_tool_guide_removed), im_tool); g_signal_connect (im_tool->percent_guide, "notify::position", G_CALLBACK (gimp_image_map_tool_guide_moved), im_tool); }
static GimpValueArray * selection_float_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; gint32 offx; gint32 offy; GimpLayer *layer = NULL; drawable = gimp_value_get_drawable (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) { if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, GIMP_PDB_ITEM_CONTENT, error) && gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error)) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); layer = gimp_selection_float (GIMP_SELECTION (gimp_image_get_mask (image)), drawable, context, TRUE, offx, offy, error); if (! layer) success = FALSE; } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_layer (gimp_value_array_index (return_vals, 1), layer); return return_vals; }
/* ----------------------------------------------- * gap_image_get_parentpositions_as_int_stringlist * ----------------------------------------------- * returns the list of parent stackpositions as list of integer numbers * separated by the "/" delimiter. * example 2/3/2 * return NULL in case the specified drawable is invalid or has no perent item */ char * gap_image_get_parentpositions_as_int_stringlist(gint32 drawable_id) { char *parentpositions; gint32 l_parent_id; gint32 l_image_id; parentpositions = NULL; l_parent_id = gimp_item_get_parent(drawable_id); if (l_parent_id > 0) { gint l_position; l_image_id = gimp_item_get_image(drawable_id); l_position = gimp_image_get_item_position (l_image_id, l_parent_id); parentpositions = g_strdup_printf("%d", l_position); while(l_parent_id > 0) { l_parent_id = gimp_item_get_parent(l_parent_id); if (l_parent_id > 0) { char *new_parentpositions; l_position = gimp_image_get_item_position (l_image_id, l_parent_id); new_parentpositions = g_strdup_printf("%d/%s" , (int)l_position , parentpositions ); g_free(parentpositions); parentpositions = new_parentpositions; } } } if(gap_debug) { printf("parentpositions_as_int_stringlist: %s\n" , parentpositions == NULL ? "null" : parentpositions ); } return (parentpositions); } /* end gap_image_get_parentpositions_as_int_stringlist */
static void gimp_vectors_to_selection (GimpItem *item, GimpChannelOps op, gboolean antialias, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y) { GimpVectors *vectors = GIMP_VECTORS (item); GimpImage *image = gimp_item_get_image (item); gimp_channel_select_vectors (gimp_image_get_mask (image), GIMP_ITEM_GET_CLASS (item)->to_selection_desc, vectors, op, antialias, feather, feather_radius_x, feather_radius_x, TRUE); }
static GValueArray * selection_float_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; GimpDrawable *drawable; gint32 offx; gint32 offy; GimpLayer *layer = NULL; drawable = gimp_value_get_drawable (&args->values[0], gimp); offx = g_value_get_int (&args->values[1]); offy = g_value_get_int (&args->values[2]); if (success) { if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), error)) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); layer = gimp_selection_float (gimp_image_get_mask (image), drawable, context, TRUE, offx, offy, error); if (! layer) success = FALSE; } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_layer (&return_vals->values[1], layer); return return_vals; }
GdkPixbuf * gimp_drawable_get_new_pixbuf (GimpViewable *viewable, GimpContext *context, gint width, gint height) { GimpItem *item = GIMP_ITEM (viewable); GimpImage *image = gimp_item_get_image (item); if (! image->gimp->config->layer_previews) return NULL; return gimp_drawable_get_sub_pixbuf (GIMP_DRAWABLE (viewable), 0, 0, gimp_item_get_width (item), gimp_item_get_height (item), width, height); }
void gimp_drawable_posterize (GimpDrawable *drawable, GimpProgress *progress, gint levels) { GimpPosterizeConfig *config; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (! gimp_drawable_is_indexed (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); config = g_object_new (GIMP_TYPE_POSTERIZE_CONFIG, "levels", levels, NULL); if (gimp_use_gegl (gimp_item_get_image (GIMP_ITEM (drawable))->gimp)) { GeglNode *node; node = g_object_new (GEGL_TYPE_NODE, "operation", "gimp:posterize", NULL); gegl_node_set (node, "config", config, NULL); gimp_drawable_apply_operation (drawable, progress, _("Posterize"), node, TRUE); g_object_unref (node); } else { GimpLut *lut; lut = posterize_lut_new (config->levels, gimp_drawable_bytes (drawable)); gimp_drawable_process_lut (drawable, progress, _("Posterize"), lut); gimp_lut_free (lut); } g_object_unref (config); }
void floating_sel_rigor (GimpLayer *layer, gboolean push_undo) { g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* store the affected area from the drawable in the backing store */ floating_sel_store (layer, GIMP_ITEM (layer)->offset_x, GIMP_ITEM (layer)->offset_y, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height); layer->fs.initial = TRUE; if (push_undo) gimp_image_undo_push_fs_rigor (gimp_item_get_image (GIMP_ITEM (layer)), NULL, layer); }
gboolean gimp_item_stroke (GimpItem *item, GimpDrawable *drawable, GimpContext *context, GimpStrokeDesc *stroke_desc, gboolean use_default_values, GimpProgress *progress, GError **error) { GimpItemClass *item_class; gboolean retval = FALSE; g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE); g_return_val_if_fail (gimp_item_is_attached (item), 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); g_return_val_if_fail (GIMP_IS_STROKE_DESC (stroke_desc), FALSE); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); item_class = GIMP_ITEM_GET_CLASS (item); if (item_class->stroke) { GimpImage *image = gimp_item_get_image (item); gimp_stroke_desc_prepare (stroke_desc, context, use_default_values); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_PAINT, item_class->stroke_desc); retval = item_class->stroke (item, drawable, stroke_desc, progress, error); gimp_image_undo_group_end (image); gimp_stroke_desc_finish (stroke_desc); } return retval; }
void floating_sel_relax (GimpLayer *layer, gboolean push_undo) { g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* restore the contents of drawable the floating layer is attached to */ if (layer->fs.initial == FALSE) floating_sel_restore (layer, GIMP_ITEM (layer)->offset_x, GIMP_ITEM (layer)->offset_y, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height); layer->fs.initial = TRUE; if (push_undo) gimp_image_undo_push_fs_relax (gimp_item_get_image (GIMP_ITEM (layer)), NULL, layer); }
TempBuf * gimp_drawable_get_sub_preview (GimpDrawable *drawable, gint src_x, gint src_y, gint src_width, gint src_height, gint dest_width, gint dest_height) { GimpItem *item; GimpImage *image; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (src_x >= 0, NULL); g_return_val_if_fail (src_y >= 0, NULL); g_return_val_if_fail (src_width > 0, NULL); g_return_val_if_fail (src_height > 0, NULL); g_return_val_if_fail (dest_width > 0, NULL); g_return_val_if_fail (dest_height > 0, NULL); item = GIMP_ITEM (drawable); g_return_val_if_fail ((src_x + src_width) <= gimp_item_width (item), NULL); g_return_val_if_fail ((src_y + src_height) <= gimp_item_height (item), NULL); image = gimp_item_get_image (item); if (! image->gimp->config->layer_previews) return NULL; if (GIMP_IMAGE_TYPE_BASE_TYPE (gimp_drawable_type (drawable)) == GIMP_INDEXED) return gimp_drawable_indexed_preview (drawable, gimp_image_get_colormap (image), src_x, src_y, src_width, src_height, dest_width, dest_height); return tile_manager_get_sub_preview (gimp_drawable_get_tiles (drawable), src_x, src_y, src_width, src_height, dest_width, dest_height); }
/** * gimp_text_layer_from_layer: * @layer: a #GimpLayer object * @text: a #GimpText object * * Converts a standard #GimpLayer and a #GimpText object into a * #GimpTextLayer. The new text layer takes ownership of the @text and * @layer objects. The @layer object is rendered unusable by this * function. Don't even try to use if afterwards! * * This is a gross hack that is needed in order to load text layers * from XCF files in a backwards-compatible way. Please don't use it * for anything else! * * Return value: a newly allocated #GimpTextLayer object **/ static GimpLayer * gimp_text_layer_from_layer (GimpLayer *layer, GimpText *text) { GimpTextLayer *text_layer; GimpDrawable *drawable; g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_TEXT (text), NULL); text_layer = g_object_new (GIMP_TYPE_TEXT_LAYER, "image", gimp_item_get_image (GIMP_ITEM (layer)), NULL); gimp_item_replace_item (GIMP_ITEM (text_layer), GIMP_ITEM (layer)); drawable = GIMP_DRAWABLE (text_layer); gimp_drawable_steal_buffer (drawable, GIMP_DRAWABLE (layer)); gimp_layer_set_opacity (GIMP_LAYER (text_layer), gimp_layer_get_opacity (layer), FALSE); gimp_layer_set_mode (GIMP_LAYER (text_layer), gimp_layer_get_mode (layer), FALSE); gimp_layer_set_blend_space (GIMP_LAYER (text_layer), gimp_layer_get_blend_space (layer), FALSE); gimp_layer_set_composite_space (GIMP_LAYER (text_layer), gimp_layer_get_composite_space (layer), FALSE); gimp_layer_set_composite_mode (GIMP_LAYER (text_layer), gimp_layer_get_composite_mode (layer), FALSE); gimp_layer_set_lock_alpha (GIMP_LAYER (text_layer), gimp_layer_get_lock_alpha (layer), FALSE); gimp_text_layer_set_text (text_layer, text); g_object_unref (text); g_object_unref (layer); return GIMP_LAYER (text_layer); }
static void gimp_image_map_tool_move_guide (GimpImageMapTool *im_tool) { GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool); GimpItem *item; GimpOrientationType orientation; gint position; if (! im_tool->percent_guide) return; item = GIMP_ITEM (im_tool->drawable); if (options->preview_alignment == GIMP_ALIGN_LEFT || options->preview_alignment == GIMP_ALIGN_RIGHT) { orientation = GIMP_ORIENTATION_VERTICAL; position = (gimp_item_get_offset_x (item) + gimp_item_get_width (item) * options->preview_position); } else { orientation = GIMP_ORIENTATION_HORIZONTAL; position = (gimp_item_get_offset_y (item) + gimp_item_get_height (item) * options->preview_position); } if (orientation != gimp_guide_get_orientation (im_tool->percent_guide) || position != gimp_guide_get_position (im_tool->percent_guide)) { gimp_guide_set_orientation (im_tool->percent_guide, orientation); gimp_image_move_guide (gimp_item_get_image (item), im_tool->percent_guide, position, FALSE); } }
void gimp_channel_select_component (GimpChannel *channel, GimpChannelType component, GimpChannelOps op, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y) { GimpItem *item; GimpChannel *add_on; const gchar *desc; gchar *undo_desc; g_return_if_fail (GIMP_IS_CHANNEL (channel)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); item = GIMP_ITEM (channel); add_on = gimp_channel_new_from_component (gimp_item_get_image (item), component, NULL, NULL); if (feather) gimp_channel_feather (add_on, feather_radius_x, feather_radius_y, FALSE /* no undo */); gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component, NULL, NULL, &desc, NULL); undo_desc = g_strdup_printf (C_("undo-type", "%s Channel to Selection"), desc); gimp_channel_select_channel (channel, undo_desc, add_on, 0, 0, op, FALSE, 0.0, 0.0); g_free (undo_desc); g_object_unref (add_on); }
void gimp_item_set_linked (GimpItem *item, gboolean linked, gboolean push_undo) { g_return_if_fail (GIMP_IS_ITEM (item)); if (gimp_item_get_linked (item) != linked) { if (push_undo && gimp_item_is_attached (item)) { GimpImage *image = gimp_item_get_image (item); if (image) gimp_image_undo_push_item_linked (image, NULL, item); } item->linked = linked ? TRUE : FALSE; g_signal_emit (item, gimp_item_signals[LINKED_CHANGED], 0); } }
void gimp_item_set_visible (GimpItem *item, gboolean visible, gboolean push_undo) { g_return_if_fail (GIMP_IS_ITEM (item)); if (gimp_item_get_visible (item) != visible) { if (push_undo && gimp_item_is_attached (item)) { GimpImage *image = gimp_item_get_image (item); if (image) gimp_image_undo_push_item_visibility (image, NULL, item); } item->visible = visible ? TRUE : FALSE; g_signal_emit (item, gimp_item_signals[VISIBILITY_CHANGED], 0); } }
static void gimp_drawable_curves (GimpDrawable *drawable, GimpProgress *progress, GimpCurvesConfig *config) { if (gimp_use_gegl (gimp_item_get_image (GIMP_ITEM (drawable))->gimp)) { GeglNode *node; node = g_object_new (GEGL_TYPE_NODE, "operation", "gimp:curves", NULL); gegl_node_set (node, "config", config, NULL); gimp_drawable_apply_operation (drawable, progress, C_("undo-type", "Curves"), node, TRUE); g_object_unref (node); } else { GimpLut *lut = gimp_lut_new (); Curves cruft; gimp_curves_config_to_cruft (config, &cruft, gimp_drawable_is_rgb (drawable)); gimp_lut_setup (lut, (GimpLutFunc) curves_lut_func, &cruft, gimp_drawable_bytes (drawable)); gimp_drawable_process_lut (drawable, progress, C_("undo-type", "Curves"), lut); gimp_lut_free (lut); } }
gboolean gimp_item_linked_is_locked (const GimpItem *item) { GList *list; GList *l; gboolean locked = FALSE; g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE); g_return_val_if_fail (gimp_item_get_linked (item) == TRUE, FALSE); g_return_val_if_fail (gimp_item_is_attached (item), FALSE); 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); for (l = list; l && ! locked; l = g_list_next (l)) { GimpItem *item = l->data; /* temporarily set the item to not being linked, or we will * run into a recursion because gimp_item_is_position_locked() * call this function if the item is linked */ gimp_item_set_linked (item, FALSE, FALSE); if (gimp_item_is_position_locked (item)) locked = TRUE; gimp_item_set_linked (item, TRUE, FALSE); } g_list_free (list); return locked; }
void gimp_item_flip (GimpItem *item, GimpContext *context, GimpOrientationType flip_type, gdouble axis, 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->flip_desc); item_class->flip (item, context, flip_type, axis, clip_result); gimp_image_undo_group_end (image); }
/** * gimp_item_check_scaling: * @item: Item to check * @new_width: proposed width of item, in pixels * @new_height: proposed height of item, in pixels * * Scales item dimensions, then snaps them to pixel centers * * Returns: #FALSE if any dimension reduces to zero as a result * of this; otherwise, returns #TRUE. **/ gboolean gimp_item_check_scaling (const GimpItem *item, gint new_width, gint new_height) { GimpImage *image; gdouble img_scale_w; gdouble img_scale_h; gint new_item_width; gint new_item_height; g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE); image = gimp_item_get_image (item); img_scale_w = ((gdouble) new_width / (gdouble) gimp_image_get_width (image)); img_scale_h = ((gdouble) new_height / (gdouble) gimp_image_get_height (image)); new_item_width = ROUND (img_scale_w * (gdouble) gimp_item_width (item)); new_item_height = ROUND (img_scale_h * (gdouble) gimp_item_height (item)); return (new_item_width > 0 && new_item_height > 0); }
TempBuf * gimp_drawable_get_preview (GimpViewable *viewable, GimpContext *context, gint width, gint height) { GimpDrawable *drawable; GimpImage *image; drawable = GIMP_DRAWABLE (viewable); image = gimp_item_get_image (GIMP_ITEM (drawable)); if (! image->gimp->config->layer_previews) return NULL; /* Ok prime the cache with a large preview if the cache is invalid */ if (! drawable->preview_valid && width <= PREVIEW_CACHE_PRIME_WIDTH && height <= PREVIEW_CACHE_PRIME_HEIGHT && image && image->width > PREVIEW_CACHE_PRIME_WIDTH && image->height > PREVIEW_CACHE_PRIME_HEIGHT) { TempBuf *tb = gimp_drawable_preview_private (drawable, PREVIEW_CACHE_PRIME_WIDTH, PREVIEW_CACHE_PRIME_HEIGHT); /* Save the 2nd call */ if (width == PREVIEW_CACHE_PRIME_WIDTH && height == PREVIEW_CACHE_PRIME_HEIGHT) return tb; } /* Second call - should NOT visit the tile cache...*/ return gimp_drawable_preview_private (drawable, width, height); }
static void gimp_viewable_dialog_name_changed (GimpObject *object, GimpViewableDialog *dialog) { gchar *name; name = gimp_viewable_get_description (GIMP_VIEWABLE (object), NULL); if (GIMP_IS_ITEM (object)) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (object)); gchar *tmp; tmp = name; name = g_strdup_printf ("%s-%d (%s)", tmp, gimp_item_get_ID (GIMP_ITEM (object)), gimp_image_get_display_name (image)); g_free (tmp); } gtk_label_set_text (GTK_LABEL (dialog->viewable_label), name); g_free (name); }
static void gimp_vectors_scale (GimpItem *item, gint new_width, gint new_height, gint new_offset_x, gint new_offset_y, GimpInterpolationType interpolation_type, GimpProgress *progress) { GimpVectors *vectors = GIMP_VECTORS (item); GimpImage *image = gimp_item_get_image (item); GList *list; gimp_vectors_freeze (vectors); if (gimp_item_is_attached (item)) gimp_image_undo_push_vectors_mod (image, NULL, vectors); for (list = vectors->strokes; list; list = g_list_next (list)) { GimpStroke *stroke = list->data; gimp_stroke_scale (stroke, (gdouble) new_width / (gdouble) gimp_item_get_width (item), (gdouble) new_height / (gdouble) gimp_item_get_height (item)); gimp_stroke_translate (stroke, new_offset_x, new_offset_y); } GIMP_ITEM_CLASS (parent_class)->scale (item, gimp_image_get_width (image), gimp_image_get_height (image), 0, 0, interpolation_type, progress); gimp_vectors_thaw (vectors); }