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

Unfinished first step to make the projection independent of GimpImage, 

2008-11-04  Michael Natterer  <mitch@gimp.org>

	Unfinished first step to make the projection independent of
	GimpImage, also one step closer to layer grouping.

	* app/core/Makefile.am
	* app/core/core-types.h
	* app/core/gimpprojectable.[ch]: add new interface which abstracts
	something that can have a projection attached to it. Has "update"
	and "flush" signals and get_graph() and get_image()
	vfuncs. get_image() is temporary until the hack is finishes.

	* app/core/gimpimage.[ch]: implement GimpProjectableInterface,
	remove "update" and "flush" signals and made get_graph() a private
	implementation of the interface method. Moved interface method
	implementations after virtual function implementations.

	* app/core/gimpprojection.[ch]: change member "image" to
	"projectable" and use the projectable API as often as
	possible. Still some implicit dependencies on the projectable
	being an image left but it's getting close.

	* app/core/gimpprojection-construct.c: same here.


svn path=/trunk/; revision=27552
This commit is contained in:
Michael Natterer 2008-11-04 18:06:36 +00:00 committed by Michael Natterer
parent cc7222d8e4
commit 716e00f88b
10 changed files with 480 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
ChangeLog
View File

@ -1,3 +1,27 @@
2008-11-04 Michael Natterer <mitch@gimp.org>
Unfinished first step to make the projection independent of
GimpImage, also one step closer to layer grouping.
* app/core/Makefile.am
* app/core/core-types.h
* app/core/gimpprojectable.[ch]: add new interface which abstracts
something that can have a projection attached to it. Has "update"
and "flush" signals and get_graph() and get_image()
vfuncs. get_image() is temporary until the hack is finishes.
* app/core/gimpimage.[ch]: implement GimpProjectableInterface,
remove "update" and "flush" signals and made get_graph() a private
implementation of the interface method. Moved interface method
implementations after virtual function implementations.
* app/core/gimpprojection.[ch]: change member "image" to
"projectable" and use the projectable API as often as
possible. Still some implicit dependencies on the projectable
being an image left but it's getting close.
* app/core/gimpprojection-construct.c: same here.
2008-11-04 Sven Neumann <sven@gimp.org>
* app/display/gimpdisplay-foreach.c: added missing include.

2
app/core/Makefile.am
View File

@ -297,6 +297,8 @@ libappcore_a_sources = \
gimppreviewcache.h \
gimpprogress.c \
gimpprogress.h \
gimpprojectable.c \
gimpprojectable.h \
gimpprojection.c \
gimpprojection.h \
gimpprojection-construct.c \

7
app/core/core-types.h
View File

@ -153,9 +153,10 @@ typedef struct _GimpSubProgress GimpSubProgress;
/* interfaces */
typedef struct _GimpPickable GimpPickable; /* dummy typedef */
typedef struct _GimpProgress GimpProgress; /* dummy typedef */
typedef struct _GimpTagged GimpTagged; /* dummy typedef */
typedef struct _GimpPickable GimpPickable; /* dummy typedef */
typedef struct _GimpProgress GimpProgress; /* dummy typedef */
typedef struct _GimpProjectable GimpProjectable; /* dummy typedef */
typedef struct _GimpTagged GimpTagged; /* dummy typedef */
/* non-object types */

205
app/core/gimpimage.c
View File

@ -57,6 +57,7 @@
#include "gimpmarshal.h"
#include "gimpparasitelist.h"
#include "gimppickable.h"
#include "gimpprojectable.h"
#include "gimpprojection.h"
#include "gimpsamplepoint.h"
#include "gimpselection.h"
@ -96,7 +97,6 @@ enum
CLEAN,
DIRTY,
SAVED,
UPDATE,
UPDATE_GUIDE,
UPDATE_SAMPLE_POINT,
SAMPLE_POINT_ADDED,
@ -105,7 +105,6 @@ enum
PARASITE_DETACHED,
COLORMAP_CHANGED,
UNDO_EVENT,
FLUSH,
LAST_SIGNAL
};
@ -130,6 +129,7 @@ GeglNode * gegl_node_add_child (GeglNode *self,
/* local function prototypes */
static void gimp_color_managed_iface_init (GimpColorManagedInterface *iface);
static void gimp_projectable_iface_init (GimpProjectableInterface *iface);
static GObject *gimp_image_constructor (GType type,
guint n_params,
@ -164,8 +164,14 @@ static void gimp_image_real_size_changed_detailed
gint previous_height);
static void gimp_image_real_colormap_changed (GimpImage *image,
gint color_index);
static void gimp_image_real_flush (GimpImage *image,
static const guint8 * gimp_image_get_icc_profile (GimpColorManaged *managed,
gsize *len);
static void gimp_image_projectable_flush (GimpProjectable *projectable,
gboolean invalidate_preview);
static GimpImage * gimp_image_get_image (GimpProjectable *projectable);
static GeglNode * gimp_image_get_graph (GimpProjectable *projectable);
static void gimp_image_mask_update (GimpDrawable *drawable,
gint x,
@ -186,9 +192,6 @@ static void gimp_image_channel_name_changed (GimpChannel *channel,
static void gimp_image_channel_color_changed (GimpChannel *channel,
GimpImage *image);
static const guint8 * gimp_image_get_icc_profile (GimpColorManaged *managed,
gsize *len);
static const gint valid_combinations[][MAX_CHANNELS + 1] =
{
@ -209,7 +212,9 @@ static const gint valid_combinations[][MAX_CHANNELS + 1] =
G_DEFINE_TYPE_WITH_CODE (GimpImage, gimp_image, GIMP_TYPE_VIEWABLE,
G_IMPLEMENT_INTERFACE (GIMP_TYPE_COLOR_MANAGED,
gimp_color_managed_iface_init))
gimp_color_managed_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROJECTABLE,
gimp_projectable_iface_init))
#define parent_class gimp_image_parent_class
@ -386,19 +391,6 @@ gimp_image_class_init (GimpImageClass *klass)
G_TYPE_NONE, 1,
G_TYPE_STRING);
gimp_image_signals[UPDATE] =
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[UPDATE_GUIDE] =
g_signal_new ("update-guide",
G_TYPE_FROM_CLASS (klass),
@ -480,16 +472,6 @@ gimp_image_class_init (GimpImageClass *klass)
GIMP_TYPE_UNDO_EVENT,
GIMP_TYPE_UNDO);
gimp_image_signals[FLUSH] =
g_signal_new ("flush",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, flush),
NULL, NULL,
gimp_marshal_VOID__BOOLEAN,
G_TYPE_NONE, 1,
G_TYPE_BOOLEAN);
object_class->constructor = gimp_image_constructor;
object_class->set_property = gimp_image_set_property;
object_class->get_property = gimp_image_get_property;
@ -527,7 +509,6 @@ gimp_image_class_init (GimpImageClass *klass)
klass->clean = NULL;
klass->dirty = NULL;
klass->saved = NULL;
klass->update = NULL;
klass->update_guide = NULL;
klass->update_sample_point = NULL;
klass->sample_point_added = NULL;
@ -536,7 +517,6 @@ gimp_image_class_init (GimpImageClass *klass)
klass->parasite_detached = NULL;
klass->colormap_changed = gimp_image_real_colormap_changed;
klass->undo_event = NULL;
klass->flush = gimp_image_real_flush;
g_object_class_install_property (object_class, PROP_GIMP,
g_param_spec_object ("gimp", NULL, NULL,
@ -577,6 +557,14 @@ gimp_color_managed_iface_init (GimpColorManagedInterface *iface)
iface->get_icc_profile = gimp_image_get_icc_profile;
}
static void
gimp_projectable_iface_init (GimpProjectableInterface *iface)
{
iface->flush = gimp_image_projectable_flush;
iface->get_image = gimp_image_get_image;
iface->get_graph = gimp_image_get_graph;
}
static void
gimp_image_init (GimpImage *image)
{
@ -606,7 +594,7 @@ gimp_image_init (GimpImage *image)
image->tattoo_state = 0;
image->projection = gimp_projection_new (image);
image->projection = gimp_projection_new (GIMP_PROJECTABLE (image));
image->guides = NULL;
image->grid = NULL;
@ -1135,10 +1123,35 @@ gimp_image_real_colormap_changed (GimpImage *image,
}
}
static void
gimp_image_real_flush (GimpImage *image,
gboolean invalidate_preview)
static const guint8 *
gimp_image_get_icc_profile (GimpColorManaged *managed,
gsize *len)
{
const GimpParasite *parasite;
parasite = gimp_image_parasite_find (GIMP_IMAGE (managed), "icc-profile");
if (parasite)
{
gsize data_size = gimp_parasite_data_size (parasite);
if (data_size > 0)
{
*len = data_size;
return gimp_parasite_data (parasite);
}
}
return NULL;
}
static void
gimp_image_projectable_flush (GimpProjectable *projectable,
gboolean invalidate_preview)
{
GimpImage *image = GIMP_IMAGE (projectable);
if (image->flush_accum.alpha_changed)
{
gimp_image_alpha_changed (image);
@ -1160,6 +1173,53 @@ gimp_image_real_flush (GimpImage *image,
}
}
static GimpImage *
gimp_image_get_image (GimpProjectable *projectable)
{
return GIMP_IMAGE (projectable);
}
static GeglNode *
gimp_image_get_graph (GimpProjectable *projectable)
{
GimpImage *image = GIMP_IMAGE (projectable);
GeglNode *layers_node;
GeglNode *channels_node;
GeglNode *blend_node;
GeglNode *output;
if (image->graph)
return image->graph;
image->graph = gegl_node_new ();
layers_node =
gimp_drawable_stack_get_graph (GIMP_DRAWABLE_STACK (image->layers));
gegl_node_add_child (image->graph, layers_node);
channels_node =
gimp_drawable_stack_get_graph (GIMP_DRAWABLE_STACK (image->channels));
gegl_node_add_child (image->graph, channels_node);
blend_node = gegl_node_new_child (image->graph,
"operation", "gegl:normal",
NULL);
gegl_node_connect_to (layers_node, "output",
blend_node, "input");
gegl_node_connect_to (channels_node, "output",
blend_node, "aux");
output = gegl_node_get_output_proxy (image->graph, "output");
gegl_node_connect_to (blend_node, "output",
output, "input");
return image->graph;
}
static void
gimp_image_mask_update (GimpDrawable *drawable,
gint x,
@ -1699,8 +1759,8 @@ gimp_image_update (GimpImage *image,
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_signal_emit (image, gimp_image_signals[UPDATE], 0,
x, y, width, height);
gimp_projectable_update (GIMP_PROJECTABLE (image),
x, y, width, height);
image->flush_accum.preview_invalidated = TRUE;
}
@ -1975,8 +2035,8 @@ gimp_image_flush (GimpImage *image)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_signal_emit (image, gimp_image_signals[FLUSH], 0,
image->flush_accum.preview_invalidated);
gimp_projectable_flush (GIMP_PROJECTABLE (image),
image->flush_accum.preview_invalidated);
}
@ -2443,48 +2503,6 @@ gimp_image_get_projection (const GimpImage *image)
return image->projection;
}
GeglNode *
gimp_image_get_graph (GimpImage *image)
{
GeglNode *layers_node;
GeglNode *channels_node;
GeglNode *blend_node;
GeglNode *output;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
if (image->graph)
return image->graph;
image->graph = gegl_node_new ();
layers_node =
gimp_drawable_stack_get_graph (GIMP_DRAWABLE_STACK (image->layers));
gegl_node_add_child (image->graph, layers_node);
channels_node =
gimp_drawable_stack_get_graph (GIMP_DRAWABLE_STACK (image->channels));
gegl_node_add_child (image->graph, channels_node);
blend_node = gegl_node_new_child (image->graph,
"operation", "gegl:normal",
NULL);
gegl_node_connect_to (layers_node, "output",
blend_node, "input");
gegl_node_connect_to (channels_node, "output",
blend_node, "aux");
output = gegl_node_get_output_proxy (image->graph, "output");
gegl_node_connect_to (blend_node, "output",
output, "input");
return image->graph;
}
/* layers / channels / vectors */
@ -3774,26 +3792,3 @@ gimp_image_invalidate_channel_previews (GimpImage *image)
(GFunc) gimp_viewable_invalidate_preview,
NULL);
}
static const guint8 *
gimp_image_get_icc_profile (GimpColorManaged *managed,
gsize *len)
{
const GimpParasite *parasite;
parasite = gimp_image_parasite_find (GIMP_IMAGE (managed), "icc-profile");
if (parasite)
{
gsize data_size = gimp_parasite_data_size (parasite);
if (data_size > 0)
{
*len = data_size;
return gimp_parasite_data (parasite);
}
}
return NULL;
}

9
app/core/gimpimage.h
View File

@ -205,11 +205,6 @@ struct _GimpImageClass
void (* saved) (GimpImage *image,
const gchar *uri);
void (* update) (GimpImage *image,
gint x,
gint y,
gint width,
gint height);
void (* update_guide) (GimpImage *image,
GimpGuide *guide);
void (* update_sample_point) (GimpImage *image,
@ -227,9 +222,6 @@ struct _GimpImageClass
void (* undo_event) (GimpImage *image,
GimpUndoEvent event,
GimpUndo *undo);
void (* flush) (GimpImage *image,
gboolean invalidate_preview);
};
@ -407,7 +399,6 @@ GimpTattoo gimp_image_get_tattoo_state (GimpImage *image);
/* projection */
GimpProjection * gimp_image_get_projection (const GimpImage *image);
GeglNode * gimp_image_get_graph (GimpImage *image);
/* layers / channels / vectors */

163
app/core/gimpprojectable.c Normal file
View File

@ -0,0 +1,163 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpprojectable.c
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gegl.h>
#include "core-types.h"
#include "gimpmarshal.h"
#include "gimpprojectable.h"
#include "gimpviewable.h"
enum
{
UPDATE,
FLUSH,
LAST_SIGNAL
};
/* local function prototypes */
static void gimp_projectable_iface_base_init (GimpProjectableInterface *iface);
static guint projectable_signals[LAST_SIGNAL] = { 0 };
GType
gimp_projectable_interface_get_type (void)
{
static GType projectable_iface_type = 0;
if (! projectable_iface_type)
{
const GTypeInfo projectable_iface_info =
{
sizeof (GimpProjectableInterface),
(GBaseInitFunc) gimp_projectable_iface_base_init,
(GBaseFinalizeFunc) NULL,
};
projectable_iface_type = g_type_register_static (G_TYPE_INTERFACE,
"GimpProjectableInterface",
&projectable_iface_info,
0);
g_type_interface_add_prerequisite (projectable_iface_type,
GIMP_TYPE_VIEWABLE);
}
return projectable_iface_type;
}
static void
gimp_projectable_iface_base_init (GimpProjectableInterface *iface)
{
static gboolean initialized = FALSE;
if (! initialized)
{
projectable_signals[UPDATE] =
g_signal_new ("update",
G_TYPE_FROM_CLASS (iface),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpProjectableInterface, update),
NULL, NULL,
gimp_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
projectable_signals[FLUSH] =
g_signal_new ("flush",
G_TYPE_FROM_CLASS (iface),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpProjectableInterface, flush),
NULL, NULL,
gimp_marshal_VOID__BOOLEAN,
G_TYPE_NONE, 1,
G_TYPE_BOOLEAN);
initialized = TRUE;
}
}
/* public functions */
void
gimp_projectable_update (GimpProjectable *projectable,
gint x,
gint y,
gint width,
gint height)
{
g_return_if_fail (GIMP_IS_PROJECTABLE (projectable));
g_signal_emit (projectable, projectable_signals[UPDATE], 0,
x, y, width, height);
}
void
gimp_projectable_flush (GimpProjectable *projectable,
gboolean preview_invalidated)
{
g_return_if_fail (GIMP_IS_PROJECTABLE (projectable));
g_signal_emit (projectable, projectable_signals[FLUSH], 0,
preview_invalidated);
}
GimpImage *
gimp_projectable_get_image (GimpProjectable *projectable)
{
GimpProjectableInterface *iface;
g_return_val_if_fail (GIMP_IS_PROJECTABLE (projectable), NULL);
iface = GIMP_PROJECTABLE_GET_INTERFACE (projectable);
if (iface->get_image)
return iface->get_image (projectable);
return NULL;
}
GeglNode *
gimp_projectable_get_graph (GimpProjectable *projectable)
{
GimpProjectableInterface *iface;
g_return_val_if_fail (GIMP_IS_PROJECTABLE (projectable), NULL);
iface = GIMP_PROJECTABLE_GET_INTERFACE (projectable);
if (iface->get_graph)
return iface->get_graph (projectable);
return NULL;
}

67
app/core/gimpprojectable.h Normal file
View File

@ -0,0 +1,67 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* gimpprojectable.h
* Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PROJECTABLE_H__
#define __GIMP_PROJECTABLE_H__
#define GIMP_TYPE_PROJECTABLE (gimp_projectable_interface_get_type ())
#define GIMP_IS_PROJECTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PROJECTABLE))
#define GIMP_PROJECTABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PROJECTABLE, GimpProjectable))
#define GIMP_PROJECTABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_PROJECTABLE, GimpProjectableInterface))
typedef struct _GimpProjectableInterface GimpProjectableInterface;
struct _GimpProjectableInterface
{
GTypeInterface base_iface;
/* signals */
void (* update) (GimpProjectable *projectable,
gint x,
gint y,
gint width,
gint height);
void (* flush) (GimpProjectable *projectable,
gboolean invalidate_preview);
/* virtual functions */
GimpImage * (* get_image) (GimpProjectable *projectable);
GeglNode * (* get_graph) (GimpProjectable *projectable);
};
GType gimp_projectable_interface_get_type (void) G_GNUC_CONST;
void gimp_projectable_update (GimpProjectable *projectable,
gint x,
gint y,
gint width,
gint height);
void gimp_projectable_flush (GimpProjectable *projectable,
gboolean preview_invalidated);
GimpImage * gimp_projectable_get_image (GimpProjectable *projectable);
GeglNode * gimp_projectable_get_graph (GimpProjectable *projectable);
#endif /* __GIMP_PROJECTABLE_H__ */

49
app/core/gimpprojection-construct.c
View File

@ -35,6 +35,7 @@
#include "gimplayer-floating-sel.h"
#include "gimplayermask.h"
#include "gimppickable.h"
#include "gimpprojectable.h"
#include "gimpprojection.h"
#include "gimpprojection-construct.h"
@ -100,7 +101,7 @@ gimp_projection_construct (GimpProjection *proj,
g_return_if_fail (GIMP_IS_PROJECTION (proj));
#if 0
GimpImage *image = proj->image;
GimpImage *image = gimp_projectable_get_image (proj->projectable);
if ((gimp_container_num_children (image->layers) == 1)) /* a single layer */
{
@ -203,6 +204,7 @@ gimp_projection_construct_layers (GimpProjection *proj,
gint w,
gint h)
{
GimpImage *image = gimp_projectable_get_image (proj->projectable);
GimpLayer *layer;
GList *list;
GList *reverse_list;
@ -211,12 +213,12 @@ gimp_projection_construct_layers (GimpProjection *proj,
gint off_y;
/* composite the floating selection if it exists */
if ((layer = gimp_image_floating_sel (proj->image)))
if ((layer = gimp_image_floating_sel (image)))
floating_sel_composite (layer, x, y, w, h, FALSE);
reverse_list = NULL;
for (list = gimp_image_get_layer_iter (proj->image);
for (list = gimp_image_get_layer_iter (image);
list;
list = g_list_next (list))
{
@ -328,11 +330,12 @@ gimp_projection_construct_channels (GimpProjection *proj,
gint w,
gint h)
{
GList *list;
GList *reverse_list = NULL;
GimpImage *image = gimp_projectable_get_image (proj->projectable);
GList *list;
GList *reverse_list = NULL;
/* reverse the channel list */
for (list = gimp_image_get_channel_iter (proj->image);
for (list = gimp_image_get_channel_iter (image);
list;
list = g_list_next (list))
{
@ -386,11 +389,11 @@ gimp_projection_initialize (GimpProjection *proj,
gint w,
gint h)
{
GimpImage *image = gimp_projectable_get_image (proj->projectable);
GList *list;
gboolean coverage = FALSE;
GList *list;
gboolean coverage = FALSE;
for (list = gimp_image_get_layer_iter (proj->image);
for (list = gimp_image_get_layer_iter (image);
list;
list = g_list_next (list))
{
@ -432,12 +435,14 @@ project_intensity (GimpProjection *proj,
PixelRegion *dest,
PixelRegion *mask)
{
GimpImage *image = gimp_projectable_get_image (proj->projectable);
if (proj->construct_flag)
{
combine_regions (dest, src, dest, mask, NULL,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
COMBINE_INTEN_A_INTEN);
}
else
@ -445,7 +450,7 @@ project_intensity (GimpProjection *proj,
initial_region (src, dest, mask, NULL,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
INITIAL_INTENSITY);
}
}
@ -457,12 +462,14 @@ project_intensity_alpha (GimpProjection *proj,
PixelRegion *dest,
PixelRegion *mask)
{
GimpImage *image = gimp_projectable_get_image (proj->projectable);
if (proj->construct_flag)
{
combine_regions (dest, src, dest, mask, NULL,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
COMBINE_INTEN_A_INTEN_A);
}
else
@ -470,7 +477,7 @@ project_intensity_alpha (GimpProjection *proj,
initial_region (src, dest, mask, NULL,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
INITIAL_INTENSITY_ALPHA);
}
}
@ -482,7 +489,8 @@ project_indexed (GimpProjection *proj,
PixelRegion *dest,
PixelRegion *mask)
{
const guchar *colormap = gimp_image_get_colormap (proj->image);
GimpImage *image = gimp_projectable_get_image (proj->projectable);
const guchar *colormap = gimp_image_get_colormap (image);
g_return_if_fail (colormap != NULL);
@ -491,7 +499,7 @@ project_indexed (GimpProjection *proj,
combine_regions (dest, src, dest, mask, colormap,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
COMBINE_INTEN_A_INDEXED);
}
else
@ -499,7 +507,7 @@ project_indexed (GimpProjection *proj,
initial_region (src, dest, mask, colormap,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
INITIAL_INDEXED);
}
}
@ -511,7 +519,8 @@ project_indexed_alpha (GimpProjection *proj,
PixelRegion *dest,
PixelRegion *mask)
{
const guchar *colormap = gimp_image_get_colormap (proj->image);
GimpImage *image = gimp_projectable_get_image (proj->projectable);
const guchar *colormap = gimp_image_get_colormap (image);
g_return_if_fail (colormap != NULL);
@ -520,7 +529,7 @@ project_indexed_alpha (GimpProjection *proj,
combine_regions (dest, src, dest, mask, colormap,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
COMBINE_INTEN_A_INDEXED_A);
}
else
@ -528,7 +537,7 @@ project_indexed_alpha (GimpProjection *proj,
initial_region (src, dest, mask, colormap,
gimp_layer_get_opacity (layer) * 255.999,
gimp_layer_get_mode (layer),
proj->image->visible,
image->visible,
INITIAL_INDEXED_ALPHA);
}
}

178
app/core/gimpprojection.c
View File

@ -31,6 +31,7 @@
#include "gimpimage.h"
#include "gimpmarshal.h"
#include "gimppickable.h"
#include "gimpprojectable.h"
#include "gimpprojection.h"
#include "gimpprojection-construct.h"
@ -99,19 +100,18 @@ static void gimp_projection_invalidate (GimpProjection *proj,
static void gimp_projection_validate_tile (TileManager *tm,
Tile *tile,
GimpProjection *proj);
static void gimp_projection_image_update (GimpImage *image,
static void gimp_projection_projectable_update (GimpProjectable *projectable,
gint x,
gint y,
gint w,
gint h,
GimpProjection *proj);
static void gimp_projection_image_size_changed (GimpImage *image,
GimpProjection *proj);
static void gimp_projection_image_mode_changed (GimpImage *image,
GimpProjection *proj);
static void gimp_projection_image_flush (GimpImage *image,
static void gimp_projection_projectable_flush (GimpProjectable *projectable,
gboolean invalidate_preview,
GimpProjection *proj);
static void gimp_projection_image_changed (GimpImage *image,
GimpProjection *proj);
G_DEFINE_TYPE_WITH_CODE (GimpProjection, gimp_projection, GIMP_TYPE_OBJECT,
@ -151,7 +151,7 @@ gimp_projection_class_init (GimpProjectionClass *klass)
static void
gimp_projection_init (GimpProjection *proj)
{
proj->image = NULL;
proj->projectable = NULL;
proj->pyramid = NULL;
proj->update_areas = NULL;
proj->idle_render.idle_id = 0;
@ -223,8 +223,8 @@ gimp_projection_get_memsize (GimpObject *object,
/**
* gimp_projection_estimate_memsize:
* @type: the image base type
* @width: image width
* @height: image height
* @width: projection width
* @height: projection height
*
* Calculates a rough estimate of the memory that is required for the
* projection of an image with the given @width and @height.
@ -270,7 +270,7 @@ gimp_projection_pickable_flush (GimpPickable *pickable)
*/
proj->invalidate_preview = FALSE;
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (proj->image));
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (proj->projectable));
}
}
@ -279,7 +279,7 @@ gimp_projection_get_image (GimpPickable *pickable)
{
GimpProjection *proj = GIMP_PROJECTION (pickable);
return proj->image;
return gimp_projectable_get_image (proj->projectable);
}
static GimpImageType
@ -320,15 +320,15 @@ gimp_projection_get_pixel_at (GimpPickable *pickable,
gint y,
guchar *pixel)
{
GimpProjection *proj = GIMP_PROJECTION (pickable);
TileManager *tiles = gimp_projection_get_tiles (pickable);
if (x < 0 ||
y < 0 ||
x >= gimp_image_get_width (proj->image) ||
y >= gimp_image_get_height (proj->image))
if (x < 0 ||
y < 0 ||
x >= tile_manager_width (tiles) ||
y >= tile_manager_height (tiles))
return FALSE;
read_pixel_data_1 (gimp_projection_get_tiles (pickable), x, y, pixel);
read_pixel_data_1 (tiles, x, y, pixel);
return TRUE;
}
@ -342,27 +342,31 @@ gimp_projection_get_opacity_at (GimpPickable *pickable,
}
GimpProjection *
gimp_projection_new (GimpImage *image)
gimp_projection_new (GimpProjectable *projectable)
{
GimpProjection *proj;
GimpImage *image;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_PROJECTABLE (projectable), NULL);
proj = g_object_new (GIMP_TYPE_PROJECTION, NULL);
proj->image = image;
proj->projectable = projectable;
g_signal_connect_object (image, "update",
G_CALLBACK (gimp_projection_image_update),
g_signal_connect_object (projectable, "update",
G_CALLBACK (gimp_projection_projectable_update),
proj, 0);
g_signal_connect_object (projectable, "flush",
G_CALLBACK (gimp_projection_projectable_flush),
proj, 0);
image = gimp_projectable_get_image (projectable);
g_signal_connect_object (image, "size-changed",
G_CALLBACK (gimp_projection_image_size_changed),
G_CALLBACK (gimp_projection_image_changed),
proj, 0);
g_signal_connect_object (image, "mode-changed",
G_CALLBACK (gimp_projection_image_mode_changed),
proj, 0);
g_signal_connect_object (image, "flush",
G_CALLBACK (gimp_projection_image_flush),
G_CALLBACK (gimp_projection_image_changed),
proj, 0);
return proj;
@ -371,7 +375,7 @@ gimp_projection_new (GimpImage *image)
GeglNode *
gimp_projection_get_sink_node (GimpProjection *proj)
{
GeglNode *image_graph;
GeglNode *graph;
g_return_val_if_fail (GIMP_IS_PROJECTION (proj), NULL);
@ -384,8 +388,8 @@ gimp_projection_get_sink_node (GimpProjection *proj)
"dont-cache", TRUE,
NULL);
image_graph = gimp_image_get_graph (proj->image);
gegl_node_add_child (proj->graph, image_graph);
graph = gimp_projectable_get_graph (proj->projectable);
gegl_node_add_child (proj->graph, graph);
proj->sink_node =
gegl_node_new_child (proj->graph,
@ -394,7 +398,7 @@ gimp_projection_get_sink_node (GimpProjection *proj)
"linear", TRUE,
NULL);
gegl_node_connect_to (image_graph, "output",
gegl_node_connect_to (graph, "output",
proj->sink_node, "input");
return proj->sink_node;
@ -409,9 +413,13 @@ gimp_projection_get_tiles_at_level (GimpProjection *proj,
if (! proj->pyramid)
{
gint width, height;
gimp_viewable_get_size (GIMP_VIEWABLE (proj->projectable),
&width, &height);
proj->pyramid = tile_pyramid_new (gimp_projection_get_image_type (GIMP_PICKABLE (proj)),
gimp_image_get_width (proj->image),
gimp_image_get_height (proj->image));
width, height);
tile_pyramid_set_validate_proc (proj->pyramid,
(TileValidateProc) gimp_projection_validate_tile,
@ -445,9 +453,11 @@ gimp_projection_get_level (GimpProjection *proj,
gdouble scale_x,
gdouble scale_y)
{
return tile_pyramid_get_level (gimp_image_get_width (proj->image),
gimp_image_get_height (proj->image),
MAX (scale_x, scale_y));
gint width, height;
gimp_viewable_get_size (GIMP_VIEWABLE (proj->projectable), &width, &height);
return tile_pyramid_get_level (width, height, MAX (scale_x, scale_y));
}
void
@ -497,13 +507,14 @@ gimp_projection_add_update_area (GimpProjection *proj,
gint h)
{
GimpArea *area;
gint width, height;
g_return_if_fail (GIMP_IS_PROJECTION (proj));
gimp_viewable_get_size (GIMP_VIEWABLE (proj->projectable), &width, &height);
area = gimp_area_new (CLAMP (x, 0, gimp_image_get_width (proj->image)),
CLAMP (y, 0, gimp_image_get_height (proj->image)),
CLAMP (x + w, 0, gimp_image_get_width (proj->image)),
CLAMP (y + h, 0, gimp_image_get_height (proj->image)));
area = gimp_area_new (CLAMP (x, 0, width),
CLAMP (y, 0, height),
CLAMP (x + w, 0, width),
CLAMP (y + h, 0, height));
proj->update_areas = gimp_area_list_process (proj->update_areas, area);
}
@ -550,7 +561,7 @@ gimp_projection_flush_whenever (GimpProjection *proj,
*/
proj->invalidate_preview = FALSE;
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (proj->image));
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (proj->projectable));
}
}
@ -667,7 +678,7 @@ gimp_projection_idle_render_callback (gpointer data)
*/
proj->invalidate_preview = FALSE;
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (proj->image));
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (proj->projectable));
}
return FALSE;
@ -710,14 +721,16 @@ gimp_projection_paint_area (GimpProjection *proj,
gint w,
gint h)
{
const gint width = gimp_image_get_width (proj->image);
const gint height = gimp_image_get_height (proj->image);
gint width, height;
gint x1, y1, x2, y2;
gimp_viewable_get_size (GIMP_VIEWABLE (proj->projectable), &width, &height);
/* Bounds check */
gint x1 = CLAMP (x, 0, width);
gint y1 = CLAMP (y, 0, height);
gint x2 = CLAMP (x + w, 0, width);
gint y2 = CLAMP (y + h, 0, height);
x1 = CLAMP (x, 0, width);
y1 = CLAMP (y, 0, height);
x2 = CLAMP (x + w, 0, width);
y2 = CLAMP (y + h, 0, height);
gimp_projection_invalidate (proj, x1, y1, x2 - x1, y2 - y1);
@ -754,55 +767,40 @@ gimp_projection_validate_tile (TileManager *tm,
/* image callbacks */
static void
gimp_projection_image_update (GimpImage *image,
gint x,
gint y,
gint w,
gint h,
GimpProjection *proj)
gimp_projection_projectable_update (GimpProjectable *projectable,
gint x,
gint y,
gint w,
gint h,
GimpProjection *proj)
{
gimp_projection_add_update_area (proj, x, y, w, h);
}
static void
gimp_projection_image_size_changed (GimpImage *image,
GimpProjection *proj)
{
if (proj->pyramid)
{
tile_pyramid_destroy (proj->pyramid);
proj->pyramid = NULL;
}
gimp_projection_add_update_area (proj,
0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image));
}
static void
gimp_projection_image_mode_changed (GimpImage *image,
GimpProjection *proj)
{
if (proj->pyramid)
{
tile_pyramid_destroy (proj->pyramid);
proj->pyramid = NULL;
}
gimp_projection_add_update_area (proj,
0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image));
}
static void
gimp_projection_image_flush (GimpImage *image,
gboolean invalidate_preview,
GimpProjection *proj)
gimp_projection_projectable_flush (GimpProjectable *projectable,
gboolean invalidate_preview,
GimpProjection *proj)
{
if (invalidate_preview)
proj->invalidate_preview = TRUE;
gimp_projection_flush (proj);
}
static void
gimp_projection_image_changed (GimpImage *image,
GimpProjection *proj)
{
gint width, height;
if (proj->pyramid)
{
tile_pyramid_destroy (proj->pyramid);
proj->pyramid = NULL;
}
gimp_viewable_get_size (GIMP_VIEWABLE (image), &width, &height);
gimp_projection_add_update_area (proj, 0, 0, width, height);
}

6
app/core/gimpprojection.h
View File

@ -53,7 +53,7 @@ struct _GimpProjection
{
GimpObject parent_instance;
GimpImage *image;
GimpProjectable *projectable;
TilePyramid *pyramid;
GeglNode *graph;
@ -72,7 +72,7 @@ struct _GimpProjectionClass
{
GimpObjectClass parent_class;
void (* update) (GimpProjection *image,
void (* update) (GimpProjection *proj,
gboolean now,
gint x,
gint y,
@ -83,7 +83,7 @@ struct _GimpProjectionClass
GType gimp_projection_get_type (void) G_GNUC_CONST;
GimpProjection * gimp_projection_new (GimpImage *image);
GimpProjection * gimp_projection_new (GimpProjectable *projectable);
GeglNode * gimp_projection_get_sink_node (GimpProjection *proj);