dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app: use a pickable instead of a drawable in GimpCanvasTransformPreview 

In GimpCanvasTransformPreview, use a GimpPickable, instead of a
GimpDrawable, as the preview source, so that we can use it with the
image projection, rather than just with drawables.
This commit is contained in:
Ell 2019-08-10 18:46:14 +03:00
parent 539d666ae2
commit 6023f97509
5 changed files with 93 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
app/display/gimpcanvastransformpreview.c
View File

@ -32,13 +32,16 @@
#include "display/display-types.h" #include "display/display-types.h"
#include "gegl/gimp-gegl-nodes.h"
#include "gegl/gimp-gegl-utils.h"
#include "gegl/gimptilehandlervalidate.h"
#include "core/gimp-transform-utils.h"
#include "core/gimp-utils.h"
#include "core/gimpchannel.h" #include "core/gimpchannel.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
#include "core/gimplayer.h" #include "core/gimplayer.h"
#include "core/gimp-transform-utils.h" #include "core/gimppickable.h"
#include "core/gimp-utils.h"
#include "gegl/gimp-gegl-nodes.h"
#include "gimpcanvas.h" #include "gimpcanvas.h"
#include "gimpcanvastransformpreview.h" #include "gimpcanvastransformpreview.h"
@ -48,7 +51,7 @@
enum enum
{ {
PROP_0, PROP_0,
PROP_DRAWABLE, PROP_PICKABLE,
PROP_TRANSFORM, PROP_TRANSFORM,
PROP_X1, PROP_X1,
PROP_Y1, PROP_Y1,
@ -62,7 +65,7 @@ typedef struct _GimpCanvasTransformPreviewPrivate GimpCanvasTransformPreviewPriv
struct _GimpCanvasTransformPreviewPrivate struct _GimpCanvasTransformPreviewPrivate
{ {
GimpDrawable *drawable; GimpPickable *pickable;
GimpMatrix3 transform; GimpMatrix3 transform;
gdouble x1, y1; gdouble x1, y1;
gdouble x2, y2; gdouble x2, y2;
@ -80,7 +83,7 @@ struct _GimpCanvasTransformPreviewPrivate
GeglNode *cache_node; GeglNode *cache_node;
GeglNode *transform_node; GeglNode *transform_node;
GimpDrawable *node_drawable; GimpPickable *node_pickable;
GimpDrawable *node_layer_mask; GimpDrawable *node_layer_mask;
GimpDrawable *node_mask; GimpDrawable *node_mask;
GeglRectangle node_rect; GeglRectangle node_rect;
@ -112,8 +115,8 @@ static cairo_region_t * gimp_canvas_transform_preview_get_extents (GimpCanvasI
static void gimp_canvas_transform_preview_layer_changed (GimpLayer *layer, static void gimp_canvas_transform_preview_layer_changed (GimpLayer *layer,
GimpCanvasTransformPreview *transform_preview); GimpCanvasTransformPreview *transform_preview);
static void gimp_canvas_transform_preview_set_drawable (GimpCanvasTransformPreview *transform_preview, static void gimp_canvas_transform_preview_set_pickable (GimpCanvasTransformPreview *transform_preview,
GimpDrawable *drawable); GimpPickable *pickable);
static void gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_preview); static void gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_preview);
@ -140,10 +143,10 @@ gimp_canvas_transform_preview_class_init (GimpCanvasTransformPreviewClass *klass
item_class->draw = gimp_canvas_transform_preview_draw; item_class->draw = gimp_canvas_transform_preview_draw;
item_class->get_extents = gimp_canvas_transform_preview_get_extents; item_class->get_extents = gimp_canvas_transform_preview_get_extents;
g_object_class_install_property (object_class, PROP_DRAWABLE, g_object_class_install_property (object_class, PROP_PICKABLE,
g_param_spec_object ("drawable", g_param_spec_object ("pickable",
NULL, NULL, NULL, NULL,
GIMP_TYPE_DRAWABLE, GIMP_TYPE_PICKABLE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_TRANSFORM, g_object_class_install_property (object_class, PROP_TRANSFORM,
@ -204,7 +207,7 @@ gimp_canvas_transform_preview_dispose (GObject *object)
g_clear_object (&private->node); g_clear_object (&private->node);
gimp_canvas_transform_preview_set_drawable (transform_preview, NULL); gimp_canvas_transform_preview_set_pickable (transform_preview, NULL);
G_OBJECT_CLASS (parent_class)->dispose (object); G_OBJECT_CLASS (parent_class)->dispose (object);
} }
@ -220,8 +223,8 @@ gimp_canvas_transform_preview_set_property (GObject *object,
switch (property_id) switch (property_id)
{ {
case PROP_DRAWABLE: case PROP_PICKABLE:
gimp_canvas_transform_preview_set_drawable (transform_preview, gimp_canvas_transform_preview_set_pickable (transform_preview,
g_value_get_object (value)); g_value_get_object (value));
break; break;
@ -272,8 +275,8 @@ gimp_canvas_transform_preview_get_property (GObject *object,
switch (property_id) switch (property_id)
{ {
case PROP_DRAWABLE: case PROP_PICKABLE:
g_value_set_object (value, private->drawable); g_value_set_object (value, private->pickable);
break; break;
case PROP_TRANSFORM: case PROP_TRANSFORM:
@ -450,33 +453,33 @@ gimp_canvas_transform_preview_layer_changed (GimpLayer *layer,
} }
static void static void
gimp_canvas_transform_preview_set_drawable (GimpCanvasTransformPreview *transform_preview, gimp_canvas_transform_preview_set_pickable (GimpCanvasTransformPreview *transform_preview,
GimpDrawable *drawable) GimpPickable *pickable)
{ {
GimpCanvasTransformPreviewPrivate *private = GET_PRIVATE (transform_preview); GimpCanvasTransformPreviewPrivate *private = GET_PRIVATE (transform_preview);
if (private->drawable && GIMP_IS_LAYER (private->drawable)) if (private->pickable && GIMP_IS_LAYER (private->pickable))
{ {
g_signal_handlers_disconnect_by_func ( g_signal_handlers_disconnect_by_func (
private->drawable, private->pickable,
gimp_canvas_transform_preview_layer_changed, gimp_canvas_transform_preview_layer_changed,
transform_preview); transform_preview);
} }
g_set_object (&private->drawable, drawable); g_set_object (&private->pickable, pickable);
if (drawable && GIMP_IS_LAYER (drawable)) if (pickable && GIMP_IS_LAYER (pickable))
{ {
g_signal_connect (drawable, "opacity-changed", g_signal_connect (pickable, "opacity-changed",
G_CALLBACK (gimp_canvas_transform_preview_layer_changed), G_CALLBACK (gimp_canvas_transform_preview_layer_changed),
transform_preview); transform_preview);
g_signal_connect (drawable, "mask-changed", g_signal_connect (pickable, "mask-changed",
G_CALLBACK (gimp_canvas_transform_preview_layer_changed), G_CALLBACK (gimp_canvas_transform_preview_layer_changed),
transform_preview); transform_preview);
g_signal_connect (drawable, "apply-mask-changed", g_signal_connect (pickable, "apply-mask-changed",
G_CALLBACK (gimp_canvas_transform_preview_layer_changed), G_CALLBACK (gimp_canvas_transform_preview_layer_changed),
transform_preview); transform_preview);
g_signal_connect (drawable, "show-mask-changed", g_signal_connect (pickable, "show-mask-changed",
G_CALLBACK (gimp_canvas_transform_preview_layer_changed), G_CALLBACK (gimp_canvas_transform_preview_layer_changed),
transform_preview); transform_preview);
} }
@ -489,11 +492,12 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
GimpCanvasItem *item = GIMP_CANVAS_ITEM (transform_preview); GimpCanvasItem *item = GIMP_CANVAS_ITEM (transform_preview);
GimpDisplayShell *shell = gimp_canvas_item_get_shell (item); GimpDisplayShell *shell = gimp_canvas_item_get_shell (item);
GimpImage *image = gimp_canvas_item_get_image (item); GimpImage *image = gimp_canvas_item_get_image (item);
GimpDrawable *drawable = private->drawable; GimpPickable *pickable = private->pickable;
GimpDrawable *layer_mask = NULL; GimpDrawable *layer_mask = NULL;
GimpDrawable *mask = NULL; GimpDrawable *mask = NULL;
gdouble opacity = private->opacity; gdouble opacity = private->opacity;
gint offset_x, offset_y; gint offset_x = 0;
gint offset_y = 0;
GimpMatrix3 matrix; GimpMatrix3 matrix;
if (! private->node) if (! private->node)
@ -567,7 +571,7 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
private->mask_crop_node, private->mask_crop_node,
NULL); NULL);
private->node_drawable = NULL; private->node_pickable = NULL;
private->node_layer_mask = NULL; private->node_layer_mask = NULL;
private->node_mask = NULL; private->node_mask = NULL;
private->node_rect = *GEGL_RECTANGLE (0, 0, 0, 0); private->node_rect = *GEGL_RECTANGLE (0, 0, 0, 0);
@ -576,49 +580,66 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
private->node_output = private->transform_node; private->node_output = private->transform_node;
} }
gimp_item_get_offset (GIMP_ITEM (private->drawable), &offset_x, &offset_y); if (GIMP_IS_ITEM (pickable))
{
gimp_item_get_offset (GIMP_ITEM (private->pickable),
&offset_x, &offset_y);
if (gimp_item_mask_bounds (GIMP_ITEM (pickable),
NULL, NULL, NULL, NULL))
{
mask = GIMP_DRAWABLE (gimp_image_get_mask (image));
}
if (GIMP_IS_LAYER (pickable))
{
GimpLayer *layer = GIMP_LAYER (pickable);
opacity *= gimp_layer_get_opacity (layer);
layer_mask = GIMP_DRAWABLE (gimp_layer_get_mask (layer));
if (layer_mask)
{
if (gimp_layer_get_show_mask (layer) && ! mask)
{
pickable = GIMP_PICKABLE (layer_mask);
layer_mask = NULL;
}
else if (! gimp_layer_get_apply_mask (layer))
{
layer_mask = NULL;
}
}
}
}
gimp_matrix3_identity (&matrix); gimp_matrix3_identity (&matrix);
gimp_matrix3_translate (&matrix, offset_x, offset_y); gimp_matrix3_translate (&matrix, offset_x, offset_y);
gimp_matrix3_mult (&private->transform, &matrix); gimp_matrix3_mult (&private->transform, &matrix);
gimp_matrix3_scale (&matrix, shell->scale_x, shell->scale_y); gimp_matrix3_scale (&matrix, shell->scale_x, shell->scale_y);
if (gimp_item_mask_bounds (GIMP_ITEM (private->drawable), if (pickable != private->node_pickable)
NULL, NULL, NULL, NULL))
{ {
mask = GIMP_DRAWABLE (gimp_image_get_mask (image)); GeglBuffer *buffer;
}
if (GIMP_IS_LAYER (drawable)) gimp_pickable_flush (pickable);
{
GimpLayer *layer = GIMP_LAYER (drawable);
opacity *= gimp_layer_get_opacity (layer); buffer = gimp_pickable_get_buffer (pickable);
layer_mask = GIMP_DRAWABLE (gimp_layer_get_mask (layer)); if (gimp_tile_handler_validate_get_assigned (buffer))
buffer = gimp_gegl_buffer_dup (buffer);
else
buffer = g_object_ref (buffer);
if (layer_mask)
{
if (gimp_layer_get_show_mask (layer) && ! mask)
{
drawable = layer_mask;
layer_mask = NULL;
}
else if (! gimp_layer_get_apply_mask (layer))
{
layer_mask = NULL;
}
}
}
if (drawable != private->node_drawable)
{
gegl_node_set (private->source_node, gegl_node_set (private->source_node,
"buffer", gimp_drawable_get_buffer (drawable), "buffer", buffer,
NULL); NULL);
gegl_node_set (private->convert_format_node, gegl_node_set (private->convert_format_node,
"format", gimp_drawable_get_format_with_alpha (drawable), "format", gimp_pickable_get_format_with_alpha (pickable),
NULL); NULL);
g_object_unref (buffer);
} }
if (layer_mask != private->node_layer_mask) if (layer_mask != private->node_layer_mask)
@ -636,8 +657,8 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
rect.x = offset_x; rect.x = offset_x;
rect.y = offset_y; rect.y = offset_y;
rect.width = gimp_item_get_width (GIMP_ITEM (private->drawable)); rect.width = gimp_item_get_width (GIMP_ITEM (private->pickable));
rect.height = gimp_item_get_height (GIMP_ITEM (private->drawable)); rect.height = gimp_item_get_height (GIMP_ITEM (private->pickable));
if (mask != private->node_mask) if (mask != private->node_mask)
{ {
@ -739,7 +760,7 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
gimp_gegl_node_set_matrix (private->transform_node, &matrix); gimp_gegl_node_set_matrix (private->transform_node, &matrix);
} }
private->node_drawable = drawable; private->node_pickable = pickable;
private->node_layer_mask = layer_mask; private->node_layer_mask = layer_mask;
private->node_mask = mask; private->node_mask = mask;
private->node_opacity = opacity; private->node_opacity = opacity;
@ -751,7 +772,7 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
GimpCanvasItem * GimpCanvasItem *
gimp_canvas_transform_preview_new (GimpDisplayShell *shell, gimp_canvas_transform_preview_new (GimpDisplayShell *shell,
GimpDrawable *drawable, GimpPickable *pickable,
const GimpMatrix3 *transform, const GimpMatrix3 *transform,
gdouble x1, gdouble x1,
gdouble y1, gdouble y1,
@ -759,12 +780,12 @@ gimp_canvas_transform_preview_new (GimpDisplayShell *shell,
gdouble y2) gdouble y2)
{ {
g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL); g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), NULL);
g_return_val_if_fail (transform != NULL, NULL); g_return_val_if_fail (transform != NULL, NULL);
return g_object_new (GIMP_TYPE_CANVAS_TRANSFORM_PREVIEW, return g_object_new (GIMP_TYPE_CANVAS_TRANSFORM_PREVIEW,
"shell", shell, "shell", shell,
"drawable", drawable, "pickable", pickable,
"transform", transform, "transform", transform,
"x1", x1, "x1", x1,
"y1", y1, "y1", y1,

2
app/display/gimpcanvastransformpreview.h
View File

@ -50,7 +50,7 @@ struct _GimpCanvasTransformPreviewClass
GType gimp_canvas_transform_preview_get_type (void) G_GNUC_CONST; GType gimp_canvas_transform_preview_get_type (void) G_GNUC_CONST;
GimpCanvasItem * gimp_canvas_transform_preview_new (GimpDisplayShell *shell, GimpCanvasItem * gimp_canvas_transform_preview_new (GimpDisplayShell *shell,
GimpDrawable *drawable, GimpPickable *pickable,
const GimpMatrix3 *transform, const GimpMatrix3 *transform,
gdouble x1, gdouble x1,
gdouble y1, gdouble y1,

8
app/tools/gimpdrawtool.c
View File

@ -26,8 +26,8 @@
#include "tools-types.h" #include "tools-types.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
#include "core/gimppickable.h"
#include "display/gimpcanvas.h" #include "display/gimpcanvas.h"
#include "display/gimpcanvasarc.h" #include "display/gimpcanvasarc.h"
@ -1187,7 +1187,7 @@ gimp_draw_tool_add_text_cursor (GimpDrawTool *draw_tool,
GimpCanvasItem * GimpCanvasItem *
gimp_draw_tool_add_transform_preview (GimpDrawTool *draw_tool, gimp_draw_tool_add_transform_preview (GimpDrawTool *draw_tool,
GimpDrawable *drawable, GimpPickable *pickable,
const GimpMatrix3 *transform, const GimpMatrix3 *transform,
gdouble x1, gdouble x1,
gdouble y1, gdouble y1,
@ -1197,11 +1197,11 @@ gimp_draw_tool_add_transform_preview (GimpDrawTool *draw_tool,
GimpCanvasItem *item; GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_DRAW_TOOL (draw_tool), NULL); g_return_val_if_fail (GIMP_IS_DRAW_TOOL (draw_tool), NULL);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), NULL);
g_return_val_if_fail (transform != NULL, NULL); g_return_val_if_fail (transform != NULL, NULL);
item = gimp_canvas_transform_preview_new (gimp_display_get_shell (draw_tool->display), item = gimp_canvas_transform_preview_new (gimp_display_get_shell (draw_tool->display),
drawable, transform, pickable, transform,
x1, y1, x2, y2); x1, y1, x2, y2);
gimp_draw_tool_add_preview (draw_tool, item); gimp_draw_tool_add_preview (draw_tool, item);

2
app/tools/gimpdrawtool.h
View File

@ -145,7 +145,7 @@ GimpCanvasItem * gimp_draw_tool_add_arc (GimpDrawTool *draw_too
gdouble start_angle, gdouble start_angle,
gdouble slice_angle); gdouble slice_angle);
GimpCanvasItem * gimp_draw_tool_add_transform_preview(GimpDrawTool *draw_tool, GimpCanvasItem * gimp_draw_tool_add_transform_preview(GimpDrawTool *draw_tool,
GimpDrawable *drawable, GimpPickable *pickable,
const GimpMatrix3 *transform, const GimpMatrix3 *transform,
gdouble x1, gdouble x1,
gdouble y1, gdouble y1,

3
app/tools/gimptransformgridtool.c
View File

@ -34,6 +34,7 @@
#include "core/gimpimage-undo-push.h" #include "core/gimpimage-undo-push.h"
#include "core/gimplayer.h" #include "core/gimplayer.h"
#include "core/gimplayermask.h" #include "core/gimplayermask.h"
#include "core/gimppickable.h"
#include "core/gimpprojection.h" #include "core/gimpprojection.h"
#include "core/gimptoolinfo.h" #include "core/gimptoolinfo.h"
@ -664,7 +665,7 @@ gimp_transform_grid_tool_draw (GimpDrawTool *draw_tool)
tg_tool->preview = tg_tool->preview =
gimp_draw_tool_add_transform_preview (draw_tool, gimp_draw_tool_add_transform_preview (draw_tool,
tool->drawable, GIMP_PICKABLE (tool->drawable),
&matrix, &matrix,
tr_tool->x1, tr_tool->x1,
tr_tool->y1, tr_tool->y1,