static void gimp_posterize_tool_map (GimpImageMapTool *image_map_tool) { GimpPosterizeTool *posterize_tool = GIMP_POSTERIZE_TOOL (image_map_tool); posterize_lut_setup (posterize_tool->lut, posterize_tool->config->levels, gimp_drawable_bytes (image_map_tool->drawable)); }
static CombinationMode gimp_image_merge_layers_get_operation (GimpLayer *dest, GimpLayer *src) { GimpImageType type = gimp_drawable_type (GIMP_DRAWABLE (dest)); gint bytes = gimp_drawable_bytes (GIMP_DRAWABLE (src)); return gimp_image_get_combination_mode (type, bytes); }
static void gimp_brightness_contrast_tool_map (GimpImageMapTool *im_tool) { GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_TOOL (im_tool); brightness_contrast_lut_setup (bc_tool->lut, bc_tool->config->brightness / 2.0, bc_tool->config->contrast, gimp_drawable_bytes (im_tool->drawable)); }
static void gimp_curves_tool_map (GimpImageMapTool *image_map_tool) { GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool); GimpDrawable *drawable = image_map_tool->drawable; Curves curves; gimp_curves_config_to_cruft (tool->config, &curves, gimp_drawable_is_rgb (drawable)); gimp_lut_setup (tool->lut, (GimpLutFunc) curves_lut_func, &curves, gimp_drawable_bytes (drawable)); }
static void gimp_levels_tool_map (GimpImageMapTool *image_map_tool) { GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool); GimpDrawable *drawable = image_map_tool->drawable; Levels levels; gimp_levels_config_to_cruft (tool->config, &levels, gimp_drawable_is_rgb (drawable)); gimp_lut_setup (tool->lut, (GimpLutFunc) levels_lut_func, &levels, gimp_drawable_bytes (drawable)); }
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); }
void gimp_drawable_equalize (GimpDrawable *drawable, gboolean mask_only) { GimpHistogram *hist; GimpLut *lut; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); hist = gimp_histogram_new (); gimp_drawable_calculate_histogram (drawable, hist); lut = equalize_lut_new (hist, gimp_drawable_bytes (drawable)); gimp_histogram_unref (hist); gimp_drawable_process_lut (drawable, NULL, _("Equalize"), lut); gimp_lut_free (lut); }
void floating_sel_attach (GimpLayer *layer, GimpDrawable *drawable) { GimpImage *image; GimpLayer *floating_sel; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (drawable != GIMP_DRAWABLE (layer)); g_return_if_fail (gimp_item_get_image (GIMP_ITEM (layer)) == gimp_item_get_image (GIMP_ITEM (drawable))); image = gimp_item_get_image (GIMP_ITEM (drawable)); floating_sel = gimp_image_floating_sel (image); /* If there is already a floating selection, anchor it */ if (floating_sel) { floating_sel_anchor (floating_sel); /* if we were pasting to the old floating selection, paste now * to the drawable */ if (drawable == (GimpDrawable *) floating_sel) drawable = gimp_image_get_active_drawable (image); } /* set the drawable and allocate a backing store */ gimp_layer_set_lock_alpha (layer, TRUE, FALSE); layer->fs.drawable = drawable; layer->fs.backing_store = tile_manager_new (GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height, gimp_drawable_bytes (drawable)); /* add the layer to the image */ gimp_image_add_layer (image, layer, 0); /* store the affected area from the drawable in the backing store */ floating_sel_rigor (layer, TRUE); }
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); }
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); } }
gint gimp_drawable_preview_bytes (GimpDrawable *drawable) { GimpImageBaseType base_type; gint bytes = 0; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), 0); base_type = GIMP_IMAGE_TYPE_BASE_TYPE (gimp_drawable_type (drawable)); switch (base_type) { case GIMP_RGB: case GIMP_GRAY: bytes = gimp_drawable_bytes (drawable); break; case GIMP_INDEXED: bytes = gimp_drawable_has_alpha (drawable) ? 4 : 3; break; } return bytes; }
void floating_sel_store (GimpLayer *layer, gint x, gint y, gint w, gint h) { PixelRegion srcPR, destPR; gint offx, offy; gint x1, y1, x2, y2; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* Check the backing store & make sure it has the correct dimensions */ if ((tile_manager_width (layer->fs.backing_store) != gimp_item_width (GIMP_ITEM(layer))) || (tile_manager_height (layer->fs.backing_store) != gimp_item_height (GIMP_ITEM(layer))) || (tile_manager_bpp (layer->fs.backing_store) != gimp_drawable_bytes (layer->fs.drawable))) { /* free the backing store and allocate anew */ tile_manager_unref (layer->fs.backing_store); layer->fs.backing_store = tile_manager_new (GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height, gimp_drawable_bytes (layer->fs.drawable)); } /* What this function does is save the specified area of the * drawable that this floating selection obscures. We do this so * that it will be possible to subsequently restore the drawable's area */ gimp_item_offsets (GIMP_ITEM (layer->fs.drawable), &offx, &offy); /* Find the minimum area we need to uncover -- in image space */ x1 = MAX (GIMP_ITEM (layer)->offset_x, offx); y1 = MAX (GIMP_ITEM (layer)->offset_y, offy); x2 = MIN (GIMP_ITEM (layer)->offset_x + GIMP_ITEM (layer)->width, offx + gimp_item_width (GIMP_ITEM (layer->fs.drawable))); y2 = MIN (GIMP_ITEM (layer)->offset_y + GIMP_ITEM (layer)->height, offy + gimp_item_height (GIMP_ITEM (layer->fs.drawable))); x1 = CLAMP (x, x1, x2); y1 = CLAMP (y, y1, y2); x2 = CLAMP (x + w, x1, x2); y2 = CLAMP (y + h, y1, y2); if ((x2 - x1) > 0 && (y2 - y1) > 0) { /* Copy the area from the drawable to the backing store */ pixel_region_init (&srcPR, gimp_drawable_get_tiles (layer->fs.drawable), (x1 - offx), (y1 - offy), (x2 - x1), (y2 - y1), FALSE); pixel_region_init (&destPR, layer->fs.backing_store, (x1 - GIMP_ITEM (layer)->offset_x), (y1 - GIMP_ITEM (layer)->offset_y), (x2 - x1), (y2 - y1), TRUE); copy_region (&srcPR, &destPR); } }
gboolean gimp_paint_core_start (GimpPaintCore *core, GimpDrawable *drawable, GimpPaintOptions *paint_options, const GimpCoords *coords, GError **error) { GimpItem *item; g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), 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_PAINT_OPTIONS (paint_options), FALSE); g_return_val_if_fail (coords != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); item = GIMP_ITEM (drawable); if (core->stroke_buffer) { g_array_free (core->stroke_buffer, TRUE); core->stroke_buffer = NULL; } core->stroke_buffer = g_array_sized_new (TRUE, TRUE, sizeof (GimpCoords), STROKE_BUFFER_INIT_SIZE); core->cur_coords = *coords; if (! GIMP_PAINT_CORE_GET_CLASS (core)->start (core, drawable, paint_options, coords, error)) { return FALSE; } /* Allocate the undo structure */ if (core->undo_tiles) tile_manager_unref (core->undo_tiles); core->undo_tiles = tile_manager_new (gimp_item_get_width (item), gimp_item_get_height (item), gimp_drawable_bytes (drawable)); /* Allocate the saved proj structure */ if (core->saved_proj_tiles) tile_manager_unref (core->saved_proj_tiles); core->saved_proj_tiles = NULL; if (core->use_saved_proj) { GimpImage *image = gimp_item_get_image (item); GimpPickable *pickable = GIMP_PICKABLE (gimp_image_get_projection (image)); TileManager *tiles = gimp_pickable_get_tiles (pickable); core->saved_proj_tiles = tile_manager_new (tile_manager_width (tiles), tile_manager_height (tiles), tile_manager_bpp (tiles)); } /* Allocate the canvas blocks structure */ if (core->canvas_tiles) tile_manager_unref (core->canvas_tiles); core->canvas_tiles = tile_manager_new (gimp_item_get_width (item), gimp_item_get_height (item), 1); /* Get the initial undo extents */ core->x1 = core->x2 = core->cur_coords.x; core->y1 = core->y2 = core->cur_coords.y; core->last_paint.x = -1e6; core->last_paint.y = -1e6; /* Freeze the drawable preview so that it isn't constantly updated. */ gimp_viewable_preview_freeze (GIMP_VIEWABLE (drawable)); return TRUE; }
TempBuf * gimp_paint_core_get_orig_image (GimpPaintCore *core, GimpDrawable *drawable, gint x, gint y, gint width, gint height) { PixelRegion srcPR; PixelRegion destPR; Tile *undo_tile; gboolean release_tile; gint h; gint pixelwidth; gint drawable_width; gint drawable_height; const guchar *s; guchar *d; gpointer pr; g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (core->undo_tiles != NULL, NULL); core->orig_buf = temp_buf_resize (core->orig_buf, gimp_drawable_bytes (drawable), x, y, width, height); drawable_width = gimp_item_get_width (GIMP_ITEM (drawable)); drawable_height = gimp_item_get_height (GIMP_ITEM (drawable)); gimp_rectangle_intersect (x, y, width, height, 0, 0, drawable_width, drawable_height, &x, &y, &width, &height); /* configure the pixel regions */ pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable), x, y, width, height, FALSE); pixel_region_init_temp_buf (&destPR, core->orig_buf, x - core->orig_buf->x, y - core->orig_buf->y, width, height); for (pr = pixel_regions_register (2, &srcPR, &destPR); pr != NULL; pr = pixel_regions_process (pr)) { /* If the undo tile corresponding to this location is valid, use it */ undo_tile = tile_manager_get_tile (core->undo_tiles, srcPR.x, srcPR.y, FALSE, FALSE); if (tile_is_valid (undo_tile)) { release_tile = TRUE; undo_tile = tile_manager_get_tile (core->undo_tiles, srcPR.x, srcPR.y, TRUE, FALSE); s = tile_data_pointer (undo_tile, srcPR.x, srcPR.y); } else { release_tile = FALSE; s = srcPR.data; } d = destPR.data; pixelwidth = srcPR.w * srcPR.bytes; h = srcPR.h; while (h --) { memcpy (d, s, pixelwidth); s += srcPR.rowstride; d += destPR.rowstride; } if (release_tile) tile_release (undo_tile, FALSE); } return core->orig_buf; }
void gimp_drawable_bucket_fill_full (GimpDrawable *drawable, GimpBucketFillMode fill_mode, gint paint_mode, gdouble opacity, gboolean do_seed_fill, gboolean fill_transparent, GimpSelectCriterion fill_criterion, gdouble threshold, gboolean sample_merged, gdouble x, gdouble y, const GimpRGB *color, GimpPattern *pattern) { GimpImage *image; TileManager *buf_tiles; PixelRegion bufPR, maskPR; GimpChannel *mask = NULL; gint bytes; gint x1, y1, x2, y2; guchar col[MAX_CHANNELS]; TempBuf *pat_buf = NULL; gboolean new_buf = FALSE; gboolean selection; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (fill_mode != GIMP_PATTERN_BUCKET_FILL || GIMP_IS_PATTERN (pattern)); g_return_if_fail (fill_mode == GIMP_PATTERN_BUCKET_FILL || color != NULL); image = gimp_item_get_image (GIMP_ITEM (drawable)); bytes = gimp_drawable_bytes (drawable); selection = gimp_item_mask_bounds (GIMP_ITEM (drawable), &x1, &y1, &x2, &y2); if ((x1 == x2) || (y1 == y2)) return; if (fill_mode == GIMP_FG_BUCKET_FILL || fill_mode == GIMP_BG_BUCKET_FILL) { guchar tmp_col[MAX_CHANNELS]; gimp_rgb_get_uchar (color, &tmp_col[RED], &tmp_col[GREEN], &tmp_col[BLUE]); gimp_image_transform_color (image, gimp_drawable_type (drawable), col, GIMP_RGB, tmp_col); col[gimp_drawable_bytes_with_alpha (drawable) - 1] = OPAQUE_OPACITY; } else if (fill_mode == GIMP_PATTERN_BUCKET_FILL) { pat_buf = gimp_image_transform_temp_buf (image, gimp_drawable_type (drawable), pattern->mask, &new_buf); } else { g_warning ("%s: invalid fill_mode passed", G_STRFUNC); return; } gimp_set_busy (image->gimp); /* Do a seed bucket fill...To do this, calculate a new * contiguous region. If there is a selection, calculate the * intersection of this region with the existing selection. */ if (do_seed_fill) { mask = gimp_image_contiguous_region_by_seed (image, drawable, sample_merged, TRUE, (gint) threshold, fill_transparent, fill_criterion, (gint) x, (gint) y); if (selection) { gint off_x = 0; gint off_y = 0; if (! sample_merged) gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); gimp_channel_combine_mask (mask, gimp_image_get_mask (image), GIMP_CHANNEL_OP_INTERSECT, -off_x, -off_y); } gimp_channel_bounds (mask, &x1, &y1, &x2, &y2); /* make sure we handle the mask correctly if it was sample-merged */ if (sample_merged) { GimpItem *item; gint off_x, off_y; item = GIMP_ITEM (drawable); /* Limit the channel bounds to the drawable's extents */ gimp_item_get_offset (item, &off_x, &off_y); x1 = CLAMP (x1, off_x, (off_x + gimp_item_get_width (item))); y1 = CLAMP (y1, off_y, (off_y + gimp_item_get_height (item))); x2 = CLAMP (x2, off_x, (off_x + gimp_item_get_width (item))); y2 = CLAMP (y2, off_y, (off_y + gimp_item_get_height (item))); pixel_region_init (&maskPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)), x1, y1, (x2 - x1), (y2 - y1), TRUE); /* translate mask bounds to drawable coords */ x1 -= off_x; y1 -= off_y; x2 -= off_x; y2 -= off_y; } else { pixel_region_init (&maskPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)), x1, y1, (x2 - x1), (y2 - y1), TRUE); } /* if the image doesn't have an alpha channel, make sure that * the buf_tiles have. We need the alpha channel to fill with * the region calculated above */ if (! gimp_drawable_has_alpha (drawable)) bytes++; } else if (fill_mode == GIMP_PATTERN_BUCKET_FILL && (pat_buf->bytes == 2 || pat_buf->bytes == 4)) { /* If pattern being applied has an alpha channel, add one to the * buf_tiles. */ if (! gimp_drawable_has_alpha (drawable)) bytes++; } buf_tiles = tile_manager_new ((x2 - x1), (y2 - y1), bytes); pixel_region_init (&bufPR, buf_tiles, 0, 0, (x2 - x1), (y2 - y1), TRUE); switch (fill_mode) { case GIMP_FG_BUCKET_FILL: case GIMP_BG_BUCKET_FILL: if (mask) color_region_mask (&bufPR, &maskPR, col); else color_region (&bufPR, col); break; case GIMP_PATTERN_BUCKET_FILL: if (mask) pattern_region (&bufPR, &maskPR, pat_buf, x1, y1); else pattern_region (&bufPR, NULL, pat_buf, x1, y1); break; } /* Apply it to the image */ pixel_region_init (&bufPR, buf_tiles, 0, 0, (x2 - x1), (y2 - y1), FALSE); gimp_drawable_apply_region (drawable, &bufPR, TRUE, C_("undo-type", "Bucket Fill"), opacity, paint_mode, NULL, NULL, x1, y1); tile_manager_unref (buf_tiles); /* update the image */ gimp_drawable_update (drawable, x1, y1, x2 - x1, y2 - y1); /* free the mask */ if (mask) g_object_unref (mask); if (new_buf) temp_buf_free (pat_buf); gimp_unset_busy (image->gimp); }
static void levels_update (GimpLevelsTool *tool, guint update) { GimpHistogramChannel channel; if (tool->color) { channel = tool->channel; } else { /* FIXME: hack */ if (tool->channel == 1) channel = GIMP_HISTOGRAM_ALPHA; else channel = GIMP_HISTOGRAM_VALUE; } /* Recalculate the transfer arrays */ levels_calculate_transfers (tool->levels); /* set up the lut */ if (GIMP_IMAGE_MAP_TOOL (tool)->drawable) gimp_lut_setup (tool->lut, (GimpLutFunc) levels_lut_func, tool->levels, gimp_drawable_bytes (GIMP_IMAGE_MAP_TOOL (tool)->drawable)); if (update & LOW_INPUT) gtk_adjustment_set_value (tool->low_input, tool->levels->low_input[tool->channel]); if (update & GAMMA) gtk_adjustment_set_value (tool->gamma, tool->levels->gamma[tool->channel]); if (update & HIGH_INPUT) gtk_adjustment_set_value (tool->high_input, tool->levels->high_input[tool->channel]); if (update & LOW_OUTPUT) gtk_adjustment_set_value (tool->low_output, tool->levels->low_output[tool->channel]); if (update & HIGH_OUTPUT) gtk_adjustment_set_value (tool->high_output, tool->levels->high_output[tool->channel]); if (update & INPUT_LEVELS) { switch (channel) { case GIMP_HISTOGRAM_VALUE: case GIMP_HISTOGRAM_ALPHA: case GIMP_HISTOGRAM_RGB: gimp_color_bar_set_buffers (GIMP_COLOR_BAR (tool->input_bar), tool->levels->input[tool->channel], tool->levels->input[tool->channel], tool->levels->input[tool->channel]); break; case GIMP_HISTOGRAM_RED: case GIMP_HISTOGRAM_GREEN: case GIMP_HISTOGRAM_BLUE: gimp_color_bar_set_buffers (GIMP_COLOR_BAR (tool->input_bar), tool->levels->input[GIMP_HISTOGRAM_RED], tool->levels->input[GIMP_HISTOGRAM_GREEN], tool->levels->input[GIMP_HISTOGRAM_BLUE]); break; } } if (update & OUTPUT_LEVELS) { gimp_color_bar_set_channel (GIMP_COLOR_BAR (tool->output_bar), channel); } if (update & INPUT_SLIDERS) { gtk_widget_queue_draw (tool->input_area); } if (update & OUTPUT_SLIDERS) { gtk_widget_queue_draw (tool->output_area); } }
static gboolean gimp_text_layer_render (GimpTextLayer *layer) { GimpDrawable *drawable; GimpItem *item; GimpImage *image; GimpTextLayout *layout; gdouble xres; gdouble yres; gint width; gint height; if (! layer->text) return FALSE; drawable = GIMP_DRAWABLE (layer); item = GIMP_ITEM (layer); image = gimp_item_get_image (item); if (gimp_container_is_empty (image->gimp->fonts)) { gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_ERROR, _("Due to lack of any fonts, " "text functionality is not available.")); return FALSE; } gimp_image_get_resolution (image, &xres, &yres); layout = gimp_text_layout_new (layer->text, xres, yres); g_object_freeze_notify (G_OBJECT (drawable)); if (gimp_text_layout_get_size (layout, &width, &height) && (width != gimp_item_get_width (item) || height != gimp_item_get_height (item))) { TileManager *new_tiles = tile_manager_new (width, height, gimp_drawable_bytes (drawable)); gimp_drawable_set_tiles (drawable, FALSE, NULL, new_tiles, gimp_drawable_type (drawable)); tile_manager_unref (new_tiles); if (gimp_layer_get_mask (GIMP_LAYER (layer))) { GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (layer)); static GimpContext *unused_eek = NULL; if (! unused_eek) unused_eek = gimp_context_new (image->gimp, "eek", NULL); gimp_item_resize (GIMP_ITEM (mask), unused_eek, width, height, 0, 0); } } if (layer->auto_rename) { GimpItem *item = GIMP_ITEM (layer); gchar *name = NULL; if (layer->text->text) { name = gimp_utf8_strtrim (layer->text->text, 30); } else if (layer->text->markup) { gchar *tmp = gimp_markup_extract_text (layer->text->markup); name = gimp_utf8_strtrim (tmp, 30); g_free (tmp); } if (! name) name = g_strdup (_("Empty Text Layer")); if (gimp_item_is_attached (item)) { gimp_item_tree_rename_item (gimp_item_get_tree (item), item, name, FALSE, NULL); g_free (name); } else { gimp_object_take_name (GIMP_OBJECT (layer), name); } } gimp_text_layer_render_layout (layer, layout); g_object_unref (layout); g_object_thaw_notify (G_OBJECT (drawable)); return (width > 0 && height > 0); }
static gboolean gimp_smudge_start (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options) { GimpSmudge *smudge = GIMP_SMUDGE (paint_core); GimpImage *image; TempBuf *area; PixelRegion srcPR; gint bytes; gint x, y, w, h; image = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimp_drawable_is_indexed (drawable)) return FALSE; area = gimp_paint_core_get_paint_area (paint_core, drawable, paint_options); if (! area) return FALSE; /* adjust the x and y coordinates to the upper left corner of the brush */ gimp_smudge_brush_coords (paint_core, &x, &y, &w, &h); /* Allocate the accumulation buffer */ bytes = gimp_drawable_bytes (drawable); smudge->accum_data = g_malloc (w * h * bytes); /* If clipped, prefill the smudge buffer with the color at the * brush position. */ if (x != area->x || y != area->y || w != area->width || h != area->height) { guchar fill[4]; gimp_pickable_get_pixel_at (GIMP_PICKABLE (drawable), CLAMP ((gint) paint_core->cur_coords.x, 0, gimp_item_width (GIMP_ITEM (drawable)) - 1), CLAMP ((gint) paint_core->cur_coords.y, 0, gimp_item_height (GIMP_ITEM (drawable)) - 1), fill); pixel_region_init_data (&srcPR, smudge->accum_data, bytes, bytes * w, 0, 0, w, h); color_region (&srcPR, fill); } pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable), area->x, area->y, area->width, area->height, FALSE); pixel_region_init_data (&smudge->accumPR, smudge->accum_data, bytes, bytes * w, area->x - x, area->y - y, area->width, area->height); /* copy the region under the original painthit. */ copy_region (&srcPR, &smudge->accumPR); pixel_region_init_data (&smudge->accumPR, smudge->accum_data, bytes, bytes * w, area->x - x, area->y - y, area->width, area->height); return TRUE; }