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

removed "visible" and all its API... 

2003-09-11  Michael Natterer  <mitch@gimp.org>

	* app/core/gimpdrawable.[ch]: removed "visible" and all its API...

	* app/core/gimpitem.[ch]: ...and added it here.

	* app/core/core-enums.[ch]
	* app/core/gimpimage-undo-push.[ch]: changed the drawable
	visibility undo to be an item visibility undo.

	* app/xcf/xcf-load.c
	* app/xcf/xcf-save.c: save it in PROP_VECTORS and changed channel
	and layer loading/saving accordingly.

	* app/core/gimpimage-merge.c
	* app/core/gimpimage-preview.c
	* app/core/gimpimage-projection.c
	* app/core/gimpimage.c
	* app/core/gimplayer-floating-sel.c
	* app/core/gimplayer.c
	* app/core/gimpselection.c
	* app/text/gimptextlayer.c
	* app/gui/channels-commands.c
	* tools/pdbgen/pdb/channel.pdb
	* tools/pdbgen/pdb/layer.pdb: changed accordingly.

	* app/pdb/channel_cmds.c
	* app/pdb/layer_cmds.c: regenerated.

	* app/widgets/gimpdrawabletreeview.[ch]: removed the eye icon...

	* app/widgets/gimpitemtreeview.[ch]: ...and added it here.
This commit is contained in:
Michael Natterer 2003-09-11 19:52:29 +00:00 committed by Michael Natterer
parent 53d4915cf5
commit 7cf4eb467a
30 changed files with 573 additions and 612 deletions

33
ChangeLog
View File

@ -1,3 +1,36 @@
2003-09-11 Michael Natterer <mitch@gimp.org>
* app/core/gimpdrawable.[ch]: removed "visible" and all its API...
* app/core/gimpitem.[ch]: ...and added it here.
* app/core/core-enums.[ch]
* app/core/gimpimage-undo-push.[ch]: changed the drawable
visibility undo to be an item visibility undo.
* app/xcf/xcf-load.c
* app/xcf/xcf-save.c: save it in PROP_VECTORS and changed channel
and layer loading/saving accordingly.
* app/core/gimpimage-merge.c
* app/core/gimpimage-preview.c
* app/core/gimpimage-projection.c
* app/core/gimpimage.c
* app/core/gimplayer-floating-sel.c
* app/core/gimplayer.c
* app/core/gimpselection.c
* app/text/gimptextlayer.c
* app/gui/channels-commands.c
* tools/pdbgen/pdb/channel.pdb
* tools/pdbgen/pdb/layer.pdb: changed accordingly.
* app/pdb/channel_cmds.c
* app/pdb/layer_cmds.c: regenerated.
* app/widgets/gimpdrawabletreeview.[ch]: removed the eye icon...
* app/widgets/gimpitemtreeview.[ch]: ...and added it here.
2003-09-11 Jakub Steiner <jimmac@ximian.com>
* themes/Default/images/preferences/folders-fonts.png:

8
app/actions/channels-commands.c
View File

@ -137,7 +137,7 @@ channels_duplicate_cmd_callback (GtkWidget *widget,
enum_class = g_type_class_ref (GIMP_TYPE_CHANNEL_TYPE);
enum_value = g_enum_get_value (enum_class, component);
g_type_class_unref (enum_class);
name = g_strdup_printf (_("%s Channel Copy"),
gettext (enum_value->value_name));
@ -147,7 +147,7 @@ channels_duplicate_cmd_callback (GtkWidget *widget,
/* copied components are invisible by default so subsequent copies
* of components don't affect each other
*/
gimp_drawable_set_visible (GIMP_DRAWABLE (new_channel), FALSE, FALSE);
gimp_item_set_visible (GIMP_ITEM (new_channel), FALSE, FALSE);
g_free (name);
}
@ -336,7 +336,7 @@ channels_new_channel_query (GimpImage *gimage,
48, 64);
gimp_color_panel_set_context (GIMP_COLOR_PANEL (options->color_panel),
gimp_get_user_context (gimage->gimp));
/* The dialog */
options->query_box =
gimp_viewable_dialog_new (GIMP_VIEWABLE (gimage),
@ -561,7 +561,7 @@ channels_edit_channel_query (GimpChannel *channel)
g_signal_connect (options->color_panel, "color_changed",
G_CALLBACK (channels_color_changed),
opacity_scale_data);
opacity_scale_data);
gtk_widget_show (table);
gtk_widget_show (vbox);

4
app/core/core-enums.c
View File

@ -502,8 +502,8 @@ static const GEnumValue gimp_undo_type_enum_values[] =
{ GIMP_UNDO_GROUP_MASK, N_("Selection Mask"), "group-mask" },
{ GIMP_UNDO_GROUP_ITEM_PROPERTIES, N_("Item Properties"), "group-item-properties" },
{ GIMP_UNDO_GROUP_ITEM_DISPLACE, N_("Move Item"), "group-item-displace" },
{ GIMP_UNDO_GROUP_ITEM_VISIBILITY, N_("Item Visibility"), "group-item-visibility" },
{ GIMP_UNDO_GROUP_ITEM_LINKED, N_("Linked Item"), "group-item-linked" },
{ GIMP_UNDO_GROUP_DRAWABLE_VISIBILITY, N_("Drawable Visibility"), "group-drawable-visibility" },
{ GIMP_UNDO_GROUP_LAYER_SCALE, N_("Scale Layer"), "group-layer-scale" },
{ GIMP_UNDO_GROUP_LAYER_RESIZE, N_("Resize Layer"), "group-layer-resize" },
{ GIMP_UNDO_GROUP_LAYER_APPLY_MASK, N_("Apply Layer Mask"), "group-layer-apply-mask" },
@ -531,8 +531,8 @@ static const GEnumValue gimp_undo_type_enum_values[] =
{ GIMP_UNDO_MASK, N_("Selection Mask"), "mask" },
{ GIMP_UNDO_ITEM_RENAME, N_("Rename Item"), "item-rename" },
{ GIMP_UNDO_ITEM_DISPLACE, N_("Move Item"), "item-displace" },
{ GIMP_UNDO_ITEM_VISIBILITY, N_("Item Visibility"), "item-visibility" },
{ GIMP_UNDO_ITEM_LINKED, N_("Set Item Linked"), "item-linked" },
{ GIMP_UNDO_DRAWABLE_VISIBILITY, N_("Drawable Visibility"), "drawable-visibility" },
{ GIMP_UNDO_LAYER_ADD, N_("New Layer"), "layer-add" },
{ GIMP_UNDO_LAYER_REMOVE, N_("Delete Layer"), "layer-remove" },
{ GIMP_UNDO_LAYER_MOD, N_("Layer Mod"), "layer-mod" },

4
app/core/core-enums.h
View File

@ -365,8 +365,8 @@ typedef enum /*< pdb-skip >*/
GIMP_UNDO_GROUP_MASK, /*< desc="Selection Mask" >*/
GIMP_UNDO_GROUP_ITEM_PROPERTIES, /*< desc="Item Properties" >*/
GIMP_UNDO_GROUP_ITEM_DISPLACE, /*< desc="Move Item" >*/
GIMP_UNDO_GROUP_ITEM_VISIBILITY, /*< desc="Item Visibility" >*/
GIMP_UNDO_GROUP_ITEM_LINKED, /*< desc="Linked Item" >*/
GIMP_UNDO_GROUP_DRAWABLE_VISIBILITY,/*< desc="Drawable Visibility" >*/
GIMP_UNDO_GROUP_LAYER_SCALE, /*< desc="Scale Layer" >*/
GIMP_UNDO_GROUP_LAYER_RESIZE, /*< desc="Resize Layer" >*/
GIMP_UNDO_GROUP_LAYER_APPLY_MASK, /*< desc="Apply Layer Mask" >*/
@ -399,8 +399,8 @@ typedef enum /*< pdb-skip >*/
GIMP_UNDO_MASK, /*< desc="Selection Mask" >*/
GIMP_UNDO_ITEM_RENAME, /*< desc="Rename Item" >*/
GIMP_UNDO_ITEM_DISPLACE, /*< desc="Move Item" >*/
GIMP_UNDO_ITEM_VISIBILITY, /*< desc="Item Visibility" >*/
GIMP_UNDO_ITEM_LINKED, /*< desc="Set Item Linked" >*/
GIMP_UNDO_DRAWABLE_VISIBILITY, /*< desc="Drawable Visibility" >*/
GIMP_UNDO_LAYER_ADD, /*< desc="New Layer" >*/
GIMP_UNDO_LAYER_REMOVE, /*< desc="Delete Layer" >*/
GIMP_UNDO_LAYER_MOD, /*< desc="Layer Mod" >*/

49
app/core/gimpdrawable.c
View File

@ -57,7 +57,6 @@
enum
{
UPDATE,
VISIBILITY_CHANGED,
ALPHA_CHANGED,
LAST_SIGNAL
};
@ -176,15 +175,6 @@ gimp_drawable_class_init (GimpDrawableClass *klass)
G_TYPE_INT,
G_TYPE_INT);
gimp_drawable_signals[VISIBILITY_CHANGED] =
g_signal_new ("visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDrawableClass, visibility_changed),
NULL, NULL,
gimp_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_drawable_signals[ALPHA_CHANGED] =
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
@ -211,7 +201,6 @@ gimp_drawable_class_init (GimpDrawableClass *klass)
item_class->transform = gimp_drawable_transform;
klass->update = gimp_drawable_real_update;
klass->visibility_changed = NULL;
klass->alpha_changed = NULL;
klass->invalidate_boundary = NULL;
}
@ -220,7 +209,6 @@ static void
gimp_drawable_init (GimpDrawable *drawable)
{
drawable->tiles = NULL;
drawable->visible = FALSE;
drawable->bytes = 0;
drawable->type = -1;
drawable->has_alpha = FALSE;
@ -317,8 +305,6 @@ gimp_drawable_duplicate (GimpItem *item,
new_image_type,
GIMP_OBJECT (new_drawable)->name);
new_drawable->visible = drawable->visible;
pixel_region_init (&srcPR, drawable->tiles,
0, 0,
item->width,
@ -609,7 +595,7 @@ gimp_drawable_configure (GimpDrawable *drawable,
drawable->tiles = tile_manager_new (width, height, drawable->bytes);
drawable->visible = TRUE;
GIMP_ITEM (drawable)->visible = TRUE;
/* preview variables */
drawable->preview_cache = NULL;
@ -927,39 +913,6 @@ gimp_drawable_bytes_with_alpha (const GimpDrawable *drawable)
return GIMP_IMAGE_TYPE_BYTES (type);
}
gboolean
gimp_drawable_get_visible (const GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
return drawable->visible;
}
void
gimp_drawable_set_visible (GimpDrawable *drawable,
gboolean visible,
gboolean push_undo)
{
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
if (drawable->visible != visible)
{
GimpItem *item = GIMP_ITEM (drawable);
if (push_undo)
{
GimpImage *gimage = gimp_item_get_image (item);
if (gimage)
gimp_image_undo_push_drawable_visibility (gimage, NULL, drawable);
}
drawable->visible = visible ? TRUE : FALSE;
g_signal_emit (drawable, gimp_drawable_signals[VISIBILITY_CHANGED], 0);
}
}
void
gimp_drawable_alpha_changed (GimpDrawable *drawable)
{

9
app/core/gimpdrawable.h
View File

@ -38,7 +38,6 @@ struct _GimpDrawable
GimpItem parent_instance;
TileManager *tiles; /* tiles for drawable data */
gboolean visible; /* controls visibility */
gint bytes; /* bytes per pixel */
GimpImageType type; /* type of drawable */
@ -59,7 +58,6 @@ struct _GimpDrawableClass
gint y,
gint width,
gint height);
void (* visibility_changed) (GimpDrawable *drawable);
void (* alpha_changed) (GimpDrawable *drawable);
/* virtual functions */
@ -91,7 +89,7 @@ void gimp_drawable_push_undo (GimpDrawable *drawable,
gint x1,
gint y1,
gint x2,
gint y2,
gint y2,
TileManager *tiles,
gboolean sparse);
@ -122,11 +120,6 @@ TileManager * gimp_drawable_shadow (GimpDrawable *drawable);
gint gimp_drawable_bytes (const GimpDrawable *drawable);
gint gimp_drawable_bytes_with_alpha (const GimpDrawable *drawable);
gboolean gimp_drawable_get_visible (const GimpDrawable *drawable);
void gimp_drawable_set_visible (GimpDrawable *drawable,
gboolean visible,
gboolean push_undo);
void gimp_drawable_alpha_changed (GimpDrawable *drawable);
void gimp_drawable_invalidate_boundary (GimpDrawable *drawable);

8
app/core/gimpimage-merge.c
View File

@ -75,7 +75,7 @@ gimp_image_merge_visible_layers (GimpImage *gimage,
{
layer = (GimpLayer *) list->data;
if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (gimp_item_get_visible (GIMP_ITEM (layer)))
merge_list = g_slist_append (merge_list, layer);
}
@ -128,7 +128,7 @@ gimp_image_flatten (GimpImage *gimage)
{
layer = (GimpLayer *) list->data;
if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (gimp_item_get_visible (GIMP_ITEM (layer)))
merge_list = g_slist_append (merge_list, layer);
}
@ -171,7 +171,7 @@ gimp_image_merge_down (GimpImage *gimage,
{
layer = (GimpLayer *) layer_list->data;
if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (gimp_item_get_visible (GIMP_ITEM (layer)))
merge_list = g_slist_append (NULL, layer);
}
@ -489,7 +489,7 @@ gimp_image_merge_layers (GimpImage *gimage,
gimp_object_set_name (GIMP_OBJECT (merge_layer), name);
g_free (name);
gimp_drawable_set_visible (GIMP_DRAWABLE (merge_layer), TRUE, TRUE);
gimp_item_set_visible (GIMP_ITEM (merge_layer), TRUE, TRUE);
/* End the merge undo group */
gimp_image_undo_group_end (gimage);

30
app/core/gimpimage-preview.c
View File

@ -114,7 +114,7 @@ gimp_image_get_popup_size (GimpViewable *viewable,
TempBuf *
gimp_image_get_preview (GimpViewable *viewable,
gint width,
gint width,
gint height)
{
GimpImage *gimage;
@ -152,7 +152,7 @@ gimp_image_get_preview (GimpViewable *viewable,
TempBuf *
gimp_image_get_new_preview (GimpViewable *viewable,
gint width,
gint width,
gint height)
{
GimpImage *gimage;
@ -201,16 +201,16 @@ gimp_image_get_new_preview (GimpViewable *viewable,
floating_sel = NULL;
for (list = GIMP_LIST (gimage->layers)->list;
list;
for (list = GIMP_LIST (gimage->layers)->list;
list;
list = g_list_next (list))
{
layer = (GimpLayer *) list->data;
/* only add layers that are visible to the list */
if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (gimp_item_get_visible (GIMP_ITEM (layer)))
{
/* floating selections are added right above the layer
/* floating selections are added right above the layer
* they are attached to
*/
if (gimp_layer_is_floating_sel (layer))
@ -266,12 +266,12 @@ gimp_image_get_new_preview (GimpViewable *viewable,
g_assert (layer_buf->bytes <= comp->bytes);
src2PR.bytes = layer_buf->bytes;
src2PR.x = src1PR.x;
src2PR.x = src1PR.x;
src2PR.y = src1PR.y;
src2PR.w = src1PR.w;
src2PR.w = src1PR.w;
src2PR.h = src1PR.h;
src2PR.rowstride = layer_buf->width * src2PR.bytes;
src2PR.data = (temp_buf_data (layer_buf) +
src2PR.data = (temp_buf_data (layer_buf) +
(y1 - y) * src2PR.rowstride +
(x1 - x) * src2PR.bytes);
@ -280,9 +280,9 @@ gimp_image_get_new_preview (GimpViewable *viewable,
mask_buf = gimp_viewable_get_preview (GIMP_VIEWABLE (layer->mask),
w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.x = src1PR.x;
maskPR.x = src1PR.x;
maskPR.y = src1PR.y;
maskPR.w = src1PR.w;
maskPR.w = src1PR.w;
maskPR.h = src1PR.h;
maskPR.rowstride = mask_buf->width * mask_buf->bytes;
maskPR.data = (mask_buf_data (mask_buf) +
@ -305,14 +305,14 @@ gimp_image_get_new_preview (GimpViewable *viewable,
if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
{
if (! construct_flag)
initial_region (&src2PR, &src1PR,
initial_region (&src2PR, &src1PR,
mask, NULL,
layer->opacity * 255.999,
layer->mode,
visible_components,
INITIAL_INTENSITY_ALPHA);
else
combine_regions (&src1PR, &src2PR, &src1PR,
combine_regions (&src1PR, &src2PR, &src1PR,
mask, NULL,
layer->opacity * 255.999,
layer->mode,
@ -322,14 +322,14 @@ gimp_image_get_new_preview (GimpViewable *viewable,
else
{
if (! construct_flag)
initial_region (&src2PR, &src1PR,
initial_region (&src2PR, &src1PR,
mask, NULL,
layer->opacity * 255.999,
layer->mode,
visible_components,
INITIAL_INTENSITY);
else
combine_regions (&src1PR, &src2PR, &src1PR,
combine_regions (&src1PR, &src2PR, &src1PR,
mask, NULL,
layer->opacity * 255.999,
layer->mode,

136
app/core/gimpimage-projection.c
View File

@ -78,9 +78,9 @@ static void project_indexed (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *dest);
static void project_indexed_alpha (GimpImage *gimage,
static void project_indexed_alpha (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *mask);
static void project_channel (GimpImage *gimage,
@ -147,7 +147,7 @@ gimp_image_projection (GimpImage *gimage)
{
gimp_image_projection_allocate (gimage);
}
return gimage->projection;
}
@ -176,8 +176,8 @@ gimp_image_projection_opacity (const GimpImage *gimage)
}
guchar *
gimp_image_projection_get_color_at (GimpImage *gimage,
gint x,
gimp_image_projection_get_color_at (GimpImage *gimage,
gint x,
gint y)
{
Tile *tile;
@ -188,7 +188,7 @@ gimp_image_projection_get_color_at (GimpImage *gimage,
if (x < 0 || y < 0 || x >= gimage->width || y >= gimage->height)
return NULL;
dest = g_new (guchar, 5);
tile = tile_manager_get_tile (gimp_image_projection (gimage), x, y,
TRUE, FALSE);
@ -207,7 +207,7 @@ gimp_image_projection_get_color_at (GimpImage *gimage,
}
void
gimp_image_invalidate (GimpImage *gimage,
gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
@ -267,25 +267,25 @@ gimp_image_invalidate (GimpImage *gimage,
{
tilex = j - (j % TILE_WIDTH);
tiley = i - (i % TILE_HEIGHT);
startx = MIN (startx, tilex);
endx = MAX (endx, tilex + tile_ewidth (tile));
starty = MIN (starty, tiley);
endy = MAX (endy, tiley + tile_eheight (tile));
tile_mark_valid (tile); /* hmmmmmmm..... */
}
}
}
if ((endx - startx) > 0 && (endy - starty) > 0)
gimp_image_construct (gimage,
startx, starty,
gimp_image_construct (gimage,
startx, starty,
(endx - startx), (endy - starty));
}
void
gimp_image_invalidate_without_render (GimpImage *gimage,
gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
@ -327,7 +327,7 @@ gimp_image_invalidate_without_render (GimpImage *gimage,
/* private functions */
static void
gimp_image_projection_validate_tile (TileManager *tm,
gimp_image_projection_validate_tile (TileManager *tm,
Tile *tile)
{
GimpImage *gimage;
@ -348,10 +348,10 @@ gimp_image_projection_validate_tile (TileManager *tm,
}
static void
gimp_image_construct_layers (GimpImage *gimage,
gint x,
gint y,
gint w,
gimp_image_construct_layers (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h)
{
GimpLayer *layer;
@ -370,17 +370,17 @@ gimp_image_construct_layers (GimpImage *gimage,
reverse_list = NULL;
for (list = GIMP_LIST (gimage->layers)->list;
list;
for (list = GIMP_LIST (gimage->layers)->list;
list;
list = g_list_next (list))
{
layer = (GimpLayer *) list->data;
/* only add layers that are visible and not floating selections
/* only add layers that are visible and not floating selections
* to the list
*/
if (! gimp_layer_is_floating_sel (layer) &&
gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (! gimp_layer_is_floating_sel (layer) &&
gimp_item_get_visible (GIMP_ITEM (layer)))
{
reverse_list = g_list_prepend (reverse_list, layer);
}
@ -398,14 +398,14 @@ gimp_image_construct_layers (GimpImage *gimage,
y2 = CLAMP (off_y + gimp_item_height (GIMP_ITEM (layer)), y, y + h);
/* configure the pixel regions */
pixel_region_init (&src1PR, gimp_image_projection (gimage),
x1, y1, (x2 - x1), (y2 - y1),
pixel_region_init (&src1PR, gimp_image_projection (gimage),
x1, y1, (x2 - x1), (y2 - y1),
TRUE);
/* If we're showing the layer mask instead of the layer... */
if (layer->mask && layer->mask->show_mask)
{
pixel_region_init (&src2PR,
pixel_region_init (&src2PR,
gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
(x1 - off_x), (y1 - off_y),
(x2 - x1), (y2 - y1), FALSE);
@ -415,14 +415,14 @@ gimp_image_construct_layers (GimpImage *gimage,
/* Otherwise, normal */
else
{
pixel_region_init (&src2PR,
pixel_region_init (&src2PR,
gimp_drawable_data (GIMP_DRAWABLE (layer)),
(x1 - off_x), (y1 - off_y),
(x2 - x1), (y2 - y1), FALSE);
if (layer->mask && layer->mask->apply_mask)
{
pixel_region_init (&maskPR,
pixel_region_init (&maskPR,
gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
(x1 - off_x), (y1 - off_y),
(x2 - x1), (y2 - y1), FALSE);
@ -466,10 +466,10 @@ gimp_image_construct_layers (GimpImage *gimage,
}
static void
gimp_image_construct_channels (GimpImage *gimage,
gint x,
gint y,
gint w,
gimp_image_construct_channels (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h)
{
GimpChannel *channel;
@ -479,8 +479,8 @@ gimp_image_construct_channels (GimpImage *gimage,
GList *reverse_list = NULL;
/* reverse the channel list */
for (list = GIMP_LIST (gimage->channels)->list;
list;
for (list = GIMP_LIST (gimage->channels)->list;
list;
list = g_list_next (list))
{
reverse_list = g_list_prepend (reverse_list, list->data);
@ -490,16 +490,16 @@ gimp_image_construct_channels (GimpImage *gimage,
{
channel = (GimpChannel *) list->data;
if (gimp_drawable_get_visible (GIMP_DRAWABLE (channel)))
if (gimp_item_get_visible (GIMP_ITEM (channel)))
{
/* configure the pixel regions */
pixel_region_init (&src1PR,
gimp_image_projection (gimage),
x, y, w, h,
gimp_image_projection (gimage),
x, y, w, h,
TRUE);
pixel_region_init (&src2PR,
gimp_drawable_data (GIMP_DRAWABLE (channel)),
x, y, w, h,
gimp_drawable_data (GIMP_DRAWABLE (channel)),
x, y, w, h,
FALSE);
project_channel (gimage, channel, &src1PR, &src2PR);
@ -512,10 +512,10 @@ gimp_image_construct_channels (GimpImage *gimage,
}
static void
gimp_image_initialize_projection (GimpImage *gimage,
gint x,
gint y,
gint w,
gimp_image_initialize_projection (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h)
{
@ -528,9 +528,9 @@ gimp_image_initialize_projection (GimpImage *gimage,
* provides complete coverage over the image. If not,
* the projection is initialized to transparent
*/
for (list = GIMP_LIST (gimage->layers)->list;
list;
for (list = GIMP_LIST (gimage->layers)->list;
list;
list = g_list_next (list))
{
GimpItem *item;
@ -540,11 +540,11 @@ gimp_image_initialize_projection (GimpImage *gimage,
gimp_item_offsets (item, &off_x, &off_y);
if (gimp_drawable_get_visible (GIMP_DRAWABLE (item)) &&
if (gimp_item_get_visible (GIMP_ITEM (item)) &&
! gimp_drawable_has_alpha (GIMP_DRAWABLE (item)) &&
(off_x <= x) &&
(off_y <= y) &&
(off_x + gimp_item_width (item) >= x + w) &&
(off_x <= x) &&
(off_y <= y) &&
(off_x + gimp_item_width (item) >= x + w) &&
(off_y + gimp_item_height (item) >= y + h))
{
coverage = 1;
@ -554,14 +554,14 @@ gimp_image_initialize_projection (GimpImage *gimage,
if (!coverage)
{
pixel_region_init (&PR, gimp_image_projection (gimage),
pixel_region_init (&PR, gimp_image_projection (gimage),
x, y, w, h, TRUE);
color_region (&PR, clear);
}
}
static void
gimp_image_construct (GimpImage *gimage,
gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
@ -572,7 +572,7 @@ gimp_image_construct (GimpImage *gimage,
#if 0
gint xoff;
gint yoff;
/* set the construct flag, used to determine if anything
* has been written to the gimage raw image yet.
*/
@ -584,10 +584,10 @@ gimp_image_construct (GimpImage *gimage,
}
if ((gimage->layers) && /* There's a layer. */
(! g_slist_next (gimage->layers)) && /* It's the only layer. */
(! g_slist_next (gimage->layers)) && /* It's the only layer. */
(gimp_drawable_has_alpha (GIMP_DRAWABLE (gimage->layers->data))) &&
/* It's !flat. */
(gimp_drawable_get_visible (GIMP_DRAWABLE (gimage->layers->data))) &&
(gimp_item_get_visible (GIMP_ITEM (gimage->layers->data))) &&
/* It's visible. */
(gimp_item_width (GIMP_ITEM (gimage->layers->data)) ==
gimage->width) &&
@ -596,7 +596,7 @@ gimp_image_construct (GimpImage *gimage,
(!gimp_drawable_is_indexed (GIMP_DRAWABLE (gimage->layers->data))) &&
/* Not indexed. */
(((GimpLayer *)(gimage->layers->data))->opacity == GIMP_OPACITY_OPAQUE)
/* Opaque */
/* Opaque */
)
{
gint xoff;
@ -608,7 +608,7 @@ gimp_image_construct (GimpImage *gimage,
{
PixelRegion srcPR, destPR;
gpointer pr;
g_warning("Can use cow-projection hack. Yay!");
pixel_region_init (&srcPR, gimp_drawable_data
@ -635,14 +635,14 @@ gimp_image_construct (GimpImage *gimage,
#else
gimage->construct_flag = FALSE;
#endif
/* First, determine if the projection image needs to be
* initialized--this is the case when there are no visible
* layers that cover the entire canvas--either because layers
* are offset or only a floating selection is visible
*/
gimp_image_initialize_projection (gimage, x, y, w, h);
/* call functions which process the list of layers and
* the list of channels
*/
@ -651,10 +651,10 @@ gimp_image_construct (GimpImage *gimage,
}
static void
project_intensity (GimpImage *gimage,
project_intensity (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *mask)
{
if (! gimage->construct_flag)
@ -672,7 +672,7 @@ project_intensity (GimpImage *gimage,
}
static void
project_intensity_alpha (GimpImage *gimage,
project_intensity_alpha (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *dest,
@ -693,9 +693,9 @@ project_intensity_alpha (GimpImage *gimage,
}
static void
project_indexed (GimpImage *gimage,
project_indexed (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *src,
PixelRegion *dest)
{
if (! gimage->construct_flag)
@ -709,9 +709,9 @@ project_indexed (GimpImage *gimage,
}
static void
project_indexed_alpha (GimpImage *gimage,
project_indexed_alpha (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *mask)
{
@ -730,9 +730,9 @@ project_indexed_alpha (GimpImage *gimage,
}
static void
project_channel (GimpImage *gimage,
project_channel (GimpImage *gimage,
GimpChannel *channel,
PixelRegion *src,
PixelRegion *src,
PixelRegion *src2)
{
guchar col[3];

150
app/core/gimpimage-undo-push.c
View File

@ -1264,6 +1264,81 @@ undo_free_item_displace (GimpUndo *undo,
}
/******************************/
/* Item Visibility Undo */
/******************************/
typedef struct _ItemVisibilityUndo ItemVisibilityUndo;
struct _ItemVisibilityUndo
{
gboolean old_visible;
};
static gboolean undo_pop_item_visibility (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
static void undo_free_item_visibility (GimpUndo *undo,
GimpUndoMode undo_mode);
gboolean
gimp_image_undo_push_item_visibility (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item)
{
GimpUndo *new;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
if ((new = gimp_image_undo_push_item (gimage, item,
sizeof (ItemVisibilityUndo),
sizeof (ItemVisibilityUndo),
GIMP_UNDO_ITEM_VISIBILITY, undo_desc,
TRUE,
undo_pop_item_visibility,
undo_free_item_visibility)))
{
ItemVisibilityUndo *ivu;
ivu = new->data;
ivu->old_visible = gimp_item_get_visible (item);
return TRUE;
}
return FALSE;
}
static gboolean
undo_pop_item_visibility (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
ItemVisibilityUndo *ivu;
GimpItem *item;
gboolean visible;
ivu = (ItemVisibilityUndo *) undo->data;
item = GIMP_ITEM_UNDO (undo)->item;
visible = gimp_item_get_visible (item);
gimp_item_set_visible (item, ivu->old_visible, FALSE);
ivu->old_visible = visible;
return TRUE;
}
static void
undo_free_item_visibility (GimpUndo *undo,
GimpUndoMode undo_mode)
{
g_free (undo->data);
}
/**********************/
/* Item linked Undo */
/**********************/
@ -1339,81 +1414,6 @@ undo_free_item_linked (GimpUndo *undo,
}
/******************************/
/* Drawable Visibility Undo */
/******************************/
typedef struct _DrawableVisibilityUndo DrawableVisibilityUndo;
struct _DrawableVisibilityUndo
{
gboolean old_visible;
};
static gboolean undo_pop_drawable_visibility (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
static void undo_free_drawable_visibility (GimpUndo *undo,
GimpUndoMode undo_mode);
gboolean
gimp_image_undo_push_drawable_visibility (GimpImage *gimage,
const gchar *undo_desc,
GimpDrawable *drawable)
{
GimpUndo *new;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
if ((new = gimp_image_undo_push_item (gimage, GIMP_ITEM (drawable),
sizeof (DrawableVisibilityUndo),
sizeof (DrawableVisibilityUndo),
GIMP_UNDO_DRAWABLE_VISIBILITY, undo_desc,
TRUE,
undo_pop_drawable_visibility,
undo_free_drawable_visibility)))
{
DrawableVisibilityUndo *dvu;
dvu = new->data;
dvu->old_visible = gimp_drawable_get_visible (drawable);
return TRUE;
}
return FALSE;
}
static gboolean
undo_pop_drawable_visibility (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
DrawableVisibilityUndo *dvu;
GimpDrawable *drawable;
gboolean visible;
dvu = (DrawableVisibilityUndo *) undo->data;
drawable = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item);
visible = gimp_drawable_get_visible (drawable);
gimp_drawable_set_visible (drawable, dvu->old_visible, FALSE);
dvu->old_visible = visible;
return TRUE;
}
static void
undo_free_drawable_visibility (GimpUndo *undo,
GimpUndoMode undo_mode)
{
g_free (undo->data);
}
/***************************/
/* Layer Add/Remove Undo */
/***************************/

46
app/core/gimpimage-undo-push.h
View File

@ -65,24 +65,20 @@ gboolean gimp_image_undo_push_mask (GimpImage *gimage,
/* item undos */
gboolean gimp_image_undo_push_item_rename (GimpImage *gimage,
gboolean gimp_image_undo_push_item_rename (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item);
gboolean gimp_image_undo_push_item_displace (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item);
gboolean gimp_image_undo_push_item_visibility (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item);
gboolean gimp_image_undo_push_item_linked (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item);
/* drawable undos */
gboolean gimp_image_undo_push_drawable_visibility (GimpImage *gimage,
const gchar *undo_desc,
GimpDrawable *drawable);
/* layer undos */
gboolean gimp_image_undo_push_layer_add (GimpImage *gimage,
@ -98,15 +94,15 @@ gboolean gimp_image_undo_push_layer_remove (GimpImage *gimage,
gboolean gimp_image_undo_push_layer_mod (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer);
gboolean gimp_image_undo_push_layer_mask_add (GimpImage *gimage,
gboolean gimp_image_undo_push_layer_mask_add (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_remove (GimpImage *gimage,
gboolean gimp_image_undo_push_layer_mask_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_reposition (GimpImage *gimage,
gboolean gimp_image_undo_push_layer_reposition (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer);
gboolean gimp_image_undo_push_layer_mode (GimpImage *gimage,
@ -122,40 +118,40 @@ gboolean gimp_image_undo_push_layer_preserve_trans (GimpImage *gimage,
/* channel undos */
gboolean gimp_image_undo_push_channel_add (GimpImage *gimage,
gboolean gimp_image_undo_push_channel_add (GimpImage *gimage,
const gchar *undo_desc,
GimpChannel *channel,
gint prev_position,
GimpChannel *prev_channel);
gboolean gimp_image_undo_push_channel_remove (GimpImage *gimage,
gboolean gimp_image_undo_push_channel_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpChannel *channel,
gint prev_position,
GimpChannel *prev_channel);
gboolean gimp_image_undo_push_channel_mod (GimpImage *gimage,
gboolean gimp_image_undo_push_channel_mod (GimpImage *gimage,
const gchar *undo_desc,
GimpChannel *channel);
gboolean gimp_image_undo_push_channel_reposition (GimpImage *gimage,
gboolean gimp_image_undo_push_channel_reposition (GimpImage *gimage,
const gchar *undo_desc,
GimpChannel *channel);
gboolean gimp_image_undo_push_channel_color (GimpImage *gimage,
gboolean gimp_image_undo_push_channel_color (GimpImage *gimage,
const gchar *undo_desc,
GimpChannel *channel);
/* vectors undos */
gboolean gimp_image_undo_push_vectors_add (GimpImage *gimage,
gboolean gimp_image_undo_push_vectors_add (GimpImage *gimage,
const gchar *undo_desc,
GimpVectors *vectors,
gint prev_position,
GimpVectors *prev_vectors);
gboolean gimp_image_undo_push_vectors_remove (GimpImage *gimage,
gboolean gimp_image_undo_push_vectors_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpVectors *channel,
gint prev_position,
GimpVectors *prev_vectors);
gboolean gimp_image_undo_push_vectors_mod (GimpImage *gimage,
gboolean gimp_image_undo_push_vectors_mod (GimpImage *gimage,
const gchar *undo_desc,
GimpVectors *vectors);
gboolean gimp_image_undo_push_vectors_reposition (GimpImage *gimage,
@ -169,10 +165,10 @@ gboolean gimp_image_undo_push_fs_to_layer (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *floating_layer,
GimpDrawable *drawable);
gboolean gimp_image_undo_push_fs_rigor (GimpImage *gimage,
gboolean gimp_image_undo_push_fs_rigor (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *floating_layer);
gboolean gimp_image_undo_push_fs_relax (GimpImage *gimage,
gboolean gimp_image_undo_push_fs_relax (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *floating_layer);
@ -182,15 +178,15 @@ gboolean gimp_image_undo_push_fs_relax (GimpImage *gimage,
gboolean gimp_image_undo_push_image_parasite (GimpImage *gimage,
const gchar *undo_desc,
gpointer parasite);
gboolean gimp_image_undo_push_image_parasite_remove (GimpImage *gimage,
gboolean gimp_image_undo_push_image_parasite_remove (GimpImage *gimage,
const gchar *undo_desc,
const gchar *name);
gboolean gimp_image_undo_push_item_parasite (GimpImage *gimage,
gboolean gimp_image_undo_push_item_parasite (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item,
gpointer parasite);
gboolean gimp_image_undo_push_item_parasite_remove (GimpImage *gimage,
gboolean gimp_image_undo_push_item_parasite_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpItem *item,
const gchar *name);
@ -198,7 +194,7 @@ gboolean gimp_image_undo_push_item_parasite_remove (GimpImage *gimage,
/* EEK undo */
gboolean gimp_image_undo_push_cantundo (GimpImage *gimage,
gboolean gimp_image_undo_push_cantundo (GimpImage *gimage,
const gchar *undo_desc);

41
app/core/gimpimage.c
View File

@ -124,13 +124,13 @@ static void gimp_image_drawable_update (GimpDrawable *drawable,
gint width,
gint height,
GimpImage *gimage);
static void gimp_image_drawable_visibility (GimpDrawable *drawable,
static void gimp_image_drawable_visibility (GimpItem *item,
GimpImage *gimage);
static void gimp_image_drawable_add (GimpContainer *container,
GimpDrawable *drawable,
GimpItem *item,
GimpImage *gimage);
static void gimp_image_drawable_remove (GimpContainer *container,
GimpDrawable *drawable,
GimpItem *item,
GimpImage *gimage);
static void gimp_image_get_active_components (const GimpImage *gimage,
@ -844,12 +844,14 @@ gimp_image_drawable_update (GimpDrawable *drawable,
gint height,
GimpImage *gimage)
{
if (gimp_drawable_get_visible (drawable))
GimpItem *item = GIMP_ITEM (drawable);
if (gimp_item_get_visible (item))
{
gint offset_x;
gint offset_y;
gimp_item_offsets (GIMP_ITEM (drawable), &offset_x, &offset_y);
gimp_item_offsets (item, &offset_x, &offset_y);
x += offset_x;
y += offset_y;
@ -859,14 +861,11 @@ gimp_image_drawable_update (GimpDrawable *drawable,
}
static void
gimp_image_drawable_visibility (GimpDrawable *drawable,
GimpImage *gimage)
gimp_image_drawable_visibility (GimpItem *item,
GimpImage *gimage)
{
GimpItem *item;
gint offset_x;
gint offset_y;
item = GIMP_ITEM (drawable);
gint offset_x;
gint offset_y;
gimp_item_offsets (item, &offset_x, &offset_y);
@ -879,20 +878,20 @@ gimp_image_drawable_visibility (GimpDrawable *drawable,
static void
gimp_image_drawable_add (GimpContainer *container,
GimpDrawable *drawable,
GimpItem *item,
GimpImage *gimage)
{
if (gimp_drawable_get_visible (drawable))
gimp_image_drawable_visibility (drawable, gimage);
if (gimp_item_get_visible (item))
gimp_image_drawable_visibility (item, gimage);
}
static void
gimp_image_drawable_remove (GimpContainer *container,
GimpDrawable *drawable,
GimpItem *item,
GimpImage *gimage)
{
if (gimp_drawable_get_visible (drawable))
gimp_image_drawable_visibility (drawable, gimage);
if (gimp_item_get_visible (item))
gimp_image_drawable_visibility (item, gimage);
}
static void
@ -2910,7 +2909,7 @@ gimp_image_position_layer (GimpImage *gimage,
gimp_container_reorder (gimage->layers, GIMP_OBJECT (layer), new_index);
if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (gimp_item_get_visible (GIMP_ITEM (layer)))
{
gint off_x, off_y;
@ -3074,7 +3073,7 @@ gimp_image_position_channel (GimpImage *gimage,
gboolean push_undo,
const gchar *undo_desc)
{
gint index;
gint index;
gint num_channels;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
@ -3098,7 +3097,7 @@ gimp_image_position_channel (GimpImage *gimage,
gimp_container_reorder (gimage->channels,
GIMP_OBJECT (channel), new_index);
if (gimp_drawable_get_visible (GIMP_DRAWABLE (channel)))
if (gimp_item_get_visible (GIMP_ITEM (channel)))
{
gint off_x, off_y;

47
app/core/gimpitem.c
View File

@ -49,6 +49,7 @@
enum
{
REMOVED,
VISIBILITY_CHANGED,
LINKED_CHANGED,
LAST_SIGNAL
};
@ -147,6 +148,15 @@ gimp_item_class_init (GimpItemClass *klass)
gimp_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_item_signals[VISIBILITY_CHANGED] =
g_signal_new ("visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpItemClass, visibility_changed),
NULL, NULL,
gimp_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_item_signals[LINKED_CHANGED] =
g_signal_new ("linked_changed",
G_TYPE_FROM_CLASS (klass),
@ -162,7 +172,9 @@ gimp_item_class_init (GimpItemClass *klass)
gimp_object_class->get_memsize = gimp_item_get_memsize;
klass->removed = NULL;
klass->visibility_changed = NULL;
klass->linked_changed = NULL;
klass->duplicate = gimp_item_real_duplicate;
klass->convert = gimp_item_real_convert;
klass->rename = gimp_item_real_rename;
@ -186,6 +198,7 @@ gimp_item_init (GimpItem *item)
item->height = 0;
item->offset_x = 0;
item->offset_y = 0;
item->visible = FALSE;
item->linked = FALSE;
}
@ -300,7 +313,8 @@ gimp_item_real_duplicate (GimpItem *item,
g_object_unref (new_item->parasites);
new_item->parasites = gimp_parasite_list_copy (item->parasites);
new_item->linked = item->linked;
new_item->visible = item->visible;
new_item->linked = item->linked;
return new_item;
}
@ -950,6 +964,37 @@ gimp_item_parasite_list (const GimpItem *item,
return list;
}
gboolean
gimp_item_get_visible (const GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
return item->visible;
}
void
gimp_item_set_visible (GimpItem *item,
gboolean visible,
gboolean push_undo)
{
g_return_if_fail (GIMP_IS_ITEM (item));
if (item->visible != visible)
{
if (push_undo)
{
GimpImage *gimage = gimp_item_get_image (item);
if (gimage)
gimp_image_undo_push_item_visibility (gimage, NULL, item);
}
item->visible = visible ? TRUE : FALSE;
g_signal_emit (item, gimp_item_signals[VISIBILITY_CHANGED], 0);
}
}
void
gimp_item_set_linked (GimpItem *item,
gboolean linked,

11
app/core/gimpitem.h
View File

@ -47,6 +47,7 @@ struct _GimpItem
gint width, height; /* size in pixels */
gint offset_x, offset_y; /* pixel offset in image */
gboolean visible; /* control visibility */
gboolean linked; /* control linkage */
};
@ -55,8 +56,9 @@ struct _GimpItemClass
GimpViewableClass parent_class;
/* signals */
void (* removed) (GimpItem *item);
void (* linked_changed) (GimpItem *item);
void (* removed) (GimpItem *item);
void (* visibility_changed) (GimpItem *item);
void (* linked_changed) (GimpItem *item);
/* virtual functions */
GimpItem * (* duplicate) (GimpItem *item,
@ -209,6 +211,11 @@ GimpParasite * gimp_item_parasite_find (const GimpItem *item,
gchar ** gimp_item_parasite_list (const GimpItem *item,
gint *count);
gboolean gimp_item_get_visible (const GimpItem *item);
void gimp_item_set_visible (GimpItem *item,
gboolean visible,
gboolean push_undo);
void gimp_item_set_linked (GimpItem *item,
gboolean linked,
gboolean push_undo);

6
app/core/gimplayer-floating-sel.c
View File

@ -230,7 +230,7 @@ floating_sel_to_layer (GimpLayer *layer)
/* Set pointers */
layer->fs.drawable = NULL;
gimage->floating_sel = NULL;
gimp_drawable_set_visible (GIMP_DRAWABLE (layer), TRUE, TRUE);
gimp_item_set_visible (GIMP_ITEM (layer), TRUE, TRUE);
gimp_image_undo_group_end (gimage);
@ -418,13 +418,13 @@ floating_sel_composite (GimpLayer *layer,
*/
if (! layer->fs.initial)
floating_sel_restore (layer, x, y, w, h);
else if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
else if (gimp_item_get_visible (GIMP_ITEM (layer)))
layer->fs.initial = FALSE;
/* First restore what's behind the image if necessary,
* then check for visibility
*/
if (gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (gimp_item_get_visible (GIMP_ITEM (layer)))
{
/* Find the minimum area we need to composite -- in gimage space */
gimp_item_offsets (GIMP_ITEM (layer->fs.drawable), &offx, &offy);

6
app/core/gimplayer.c
View File

@ -1389,7 +1389,7 @@ gimp_layer_pick_correlate (GimpLayer *layer,
if (x >= 0 && x < GIMP_ITEM (layer)->width &&
y >= 0 && y < GIMP_ITEM (layer)->height &&
gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
gimp_item_get_visible (GIMP_ITEM (layer)))
{
/* If the point is inside, and the layer has no
* alpha channel, success!
@ -1400,7 +1400,7 @@ gimp_layer_pick_correlate (GimpLayer *layer,
/* Otherwise, determine if the alpha value at
* the given point is non-zero
*/
tile = tile_manager_get_tile (GIMP_DRAWABLE(layer)->tiles,
tile = tile_manager_get_tile (GIMP_DRAWABLE (layer)->tiles,
x, y, TRUE, FALSE);
val = * ((guchar *) tile_data_pointer (tile,
@ -1412,7 +1412,7 @@ gimp_layer_pick_correlate (GimpLayer *layer,
{
guchar *ptr;
mask_tile = tile_manager_get_tile (GIMP_DRAWABLE(layer->mask)->tiles,
mask_tile = tile_manager_get_tile (GIMP_DRAWABLE (layer->mask)->tiles,
x, y, TRUE, FALSE);
ptr = tile_data_pointer (mask_tile, x % TILE_WIDTH, y % TILE_HEIGHT);
val = val * (*ptr) / 255;

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

@ -78,9 +78,9 @@ static void project_indexed (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *dest);
static void project_indexed_alpha (GimpImage *gimage,
static void project_indexed_alpha (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *mask);
static void project_channel (GimpImage *gimage,
@ -147,7 +147,7 @@ gimp_image_projection (GimpImage *gimage)
{
gimp_image_projection_allocate (gimage);
}
return gimage->projection;
}
@ -176,8 +176,8 @@ gimp_image_projection_opacity (const GimpImage *gimage)
}
guchar *
gimp_image_projection_get_color_at (GimpImage *gimage,
gint x,
gimp_image_projection_get_color_at (GimpImage *gimage,
gint x,
gint y)
{
Tile *tile;
@ -188,7 +188,7 @@ gimp_image_projection_get_color_at (GimpImage *gimage,
if (x < 0 || y < 0 || x >= gimage->width || y >= gimage->height)
return NULL;
dest = g_new (guchar, 5);
tile = tile_manager_get_tile (gimp_image_projection (gimage), x, y,
TRUE, FALSE);
@ -207,7 +207,7 @@ gimp_image_projection_get_color_at (GimpImage *gimage,
}
void
gimp_image_invalidate (GimpImage *gimage,
gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
@ -267,25 +267,25 @@ gimp_image_invalidate (GimpImage *gimage,
{
tilex = j - (j % TILE_WIDTH);
tiley = i - (i % TILE_HEIGHT);
startx = MIN (startx, tilex);
endx = MAX (endx, tilex + tile_ewidth (tile));
starty = MIN (starty, tiley);
endy = MAX (endy, tiley + tile_eheight (tile));
tile_mark_valid (tile); /* hmmmmmmm..... */
}
}
}
if ((endx - startx) > 0 && (endy - starty) > 0)
gimp_image_construct (gimage,
startx, starty,
gimp_image_construct (gimage,
startx, starty,
(endx - startx), (endy - starty));
}
void
gimp_image_invalidate_without_render (GimpImage *gimage,
gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
@ -327,7 +327,7 @@ gimp_image_invalidate_without_render (GimpImage *gimage,
/* private functions */
static void
gimp_image_projection_validate_tile (TileManager *tm,
gimp_image_projection_validate_tile (TileManager *tm,
Tile *tile)
{
GimpImage *gimage;
@ -348,10 +348,10 @@ gimp_image_projection_validate_tile (TileManager *tm,
}
static void
gimp_image_construct_layers (GimpImage *gimage,
gint x,
gint y,
gint w,
gimp_image_construct_layers (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h)
{
GimpLayer *layer;
@ -370,17 +370,17 @@ gimp_image_construct_layers (GimpImage *gimage,
reverse_list = NULL;
for (list = GIMP_LIST (gimage->layers)->list;
list;
for (list = GIMP_LIST (gimage->layers)->list;
list;
list = g_list_next (list))
{
layer = (GimpLayer *) list->data;
/* only add layers that are visible and not floating selections
/* only add layers that are visible and not floating selections
* to the list
*/
if (! gimp_layer_is_floating_sel (layer) &&
gimp_drawable_get_visible (GIMP_DRAWABLE (layer)))
if (! gimp_layer_is_floating_sel (layer) &&
gimp_item_get_visible (GIMP_ITEM (layer)))
{
reverse_list = g_list_prepend (reverse_list, layer);
}
@ -398,14 +398,14 @@ gimp_image_construct_layers (GimpImage *gimage,
y2 = CLAMP (off_y + gimp_item_height (GIMP_ITEM (layer)), y, y + h);
/* configure the pixel regions */
pixel_region_init (&src1PR, gimp_image_projection (gimage),
x1, y1, (x2 - x1), (y2 - y1),
pixel_region_init (&src1PR, gimp_image_projection (gimage),
x1, y1, (x2 - x1), (y2 - y1),
TRUE);
/* If we're showing the layer mask instead of the layer... */
if (layer->mask && layer->mask->show_mask)
{
pixel_region_init (&src2PR,
pixel_region_init (&src2PR,
gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
(x1 - off_x), (y1 - off_y),
(x2 - x1), (y2 - y1), FALSE);
@ -415,14 +415,14 @@ gimp_image_construct_layers (GimpImage *gimage,
/* Otherwise, normal */
else
{
pixel_region_init (&src2PR,
pixel_region_init (&src2PR,
gimp_drawable_data (GIMP_DRAWABLE (layer)),
(x1 - off_x), (y1 - off_y),
(x2 - x1), (y2 - y1), FALSE);
if (layer->mask && layer->mask->apply_mask)
{
pixel_region_init (&maskPR,
pixel_region_init (&maskPR,
gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
(x1 - off_x), (y1 - off_y),
(x2 - x1), (y2 - y1), FALSE);
@ -466,10 +466,10 @@ gimp_image_construct_layers (GimpImage *gimage,
}
static void
gimp_image_construct_channels (GimpImage *gimage,
gint x,
gint y,
gint w,
gimp_image_construct_channels (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h)
{
GimpChannel *channel;
@ -479,8 +479,8 @@ gimp_image_construct_channels (GimpImage *gimage,
GList *reverse_list = NULL;
/* reverse the channel list */
for (list = GIMP_LIST (gimage->channels)->list;
list;
for (list = GIMP_LIST (gimage->channels)->list;
list;
list = g_list_next (list))
{
reverse_list = g_list_prepend (reverse_list, list->data);
@ -490,16 +490,16 @@ gimp_image_construct_channels (GimpImage *gimage,
{
channel = (GimpChannel *) list->data;
if (gimp_drawable_get_visible (GIMP_DRAWABLE (channel)))
if (gimp_item_get_visible (GIMP_ITEM (channel)))
{
/* configure the pixel regions */
pixel_region_init (&src1PR,
gimp_image_projection (gimage),
x, y, w, h,
gimp_image_projection (gimage),
x, y, w, h,
TRUE);
pixel_region_init (&src2PR,
gimp_drawable_data (GIMP_DRAWABLE (channel)),
x, y, w, h,
gimp_drawable_data (GIMP_DRAWABLE (channel)),
x, y, w, h,
FALSE);
project_channel (gimage, channel, &src1PR, &src2PR);
@ -512,10 +512,10 @@ gimp_image_construct_channels (GimpImage *gimage,
}
static void
gimp_image_initialize_projection (GimpImage *gimage,
gint x,
gint y,
gint w,
gimp_image_initialize_projection (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h)
{
@ -528,9 +528,9 @@ gimp_image_initialize_projection (GimpImage *gimage,
* provides complete coverage over the image. If not,
* the projection is initialized to transparent
*/
for (list = GIMP_LIST (gimage->layers)->list;
list;
for (list = GIMP_LIST (gimage->layers)->list;
list;
list = g_list_next (list))
{
GimpItem *item;
@ -540,11 +540,11 @@ gimp_image_initialize_projection (GimpImage *gimage,
gimp_item_offsets (item, &off_x, &off_y);
if (gimp_drawable_get_visible (GIMP_DRAWABLE (item)) &&
if (gimp_item_get_visible (GIMP_ITEM (item)) &&
! gimp_drawable_has_alpha (GIMP_DRAWABLE (item)) &&
(off_x <= x) &&
(off_y <= y) &&
(off_x + gimp_item_width (item) >= x + w) &&
(off_x <= x) &&
(off_y <= y) &&
(off_x + gimp_item_width (item) >= x + w) &&
(off_y + gimp_item_height (item) >= y + h))
{
coverage = 1;
@ -554,14 +554,14 @@ gimp_image_initialize_projection (GimpImage *gimage,
if (!coverage)
{
pixel_region_init (&PR, gimp_image_projection (gimage),
pixel_region_init (&PR, gimp_image_projection (gimage),
x, y, w, h, TRUE);
color_region (&PR, clear);
}
}
static void
gimp_image_construct (GimpImage *gimage,
gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
@ -572,7 +572,7 @@ gimp_image_construct (GimpImage *gimage,
#if 0
gint xoff;
gint yoff;
/* set the construct flag, used to determine if anything
* has been written to the gimage raw image yet.
*/
@ -584,10 +584,10 @@ gimp_image_construct (GimpImage *gimage,
}
if ((gimage->layers) && /* There's a layer. */
(! g_slist_next (gimage->layers)) && /* It's the only layer. */
(! g_slist_next (gimage->layers)) && /* It's the only layer. */
(gimp_drawable_has_alpha (GIMP_DRAWABLE (gimage->layers->data))) &&
/* It's !flat. */
(gimp_drawable_get_visible (GIMP_DRAWABLE (gimage->layers->data))) &&
(gimp_item_get_visible (GIMP_ITEM (gimage->layers->data))) &&
/* It's visible. */
(gimp_item_width (GIMP_ITEM (gimage->layers->data)) ==
gimage->width) &&
@ -596,7 +596,7 @@ gimp_image_construct (GimpImage *gimage,
(!gimp_drawable_is_indexed (GIMP_DRAWABLE (gimage->layers->data))) &&
/* Not indexed. */
(((GimpLayer *)(gimage->layers->data))->opacity == GIMP_OPACITY_OPAQUE)
/* Opaque */
/* Opaque */
)
{
gint xoff;
@ -608,7 +608,7 @@ gimp_image_construct (GimpImage *gimage,
{
PixelRegion srcPR, destPR;
gpointer pr;
g_warning("Can use cow-projection hack. Yay!");
pixel_region_init (&srcPR, gimp_drawable_data
@ -635,14 +635,14 @@ gimp_image_construct (GimpImage *gimage,
#else
gimage->construct_flag = FALSE;
#endif
/* First, determine if the projection image needs to be
* initialized--this is the case when there are no visible
* layers that cover the entire canvas--either because layers
* are offset or only a floating selection is visible
*/
gimp_image_initialize_projection (gimage, x, y, w, h);
/* call functions which process the list of layers and
* the list of channels
*/
@ -651,10 +651,10 @@ gimp_image_construct (GimpImage *gimage,
}
static void
project_intensity (GimpImage *gimage,
project_intensity (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *mask)
{
if (! gimage->construct_flag)
@ -672,7 +672,7 @@ project_intensity (GimpImage *gimage,
}
static void
project_intensity_alpha (GimpImage *gimage,
project_intensity_alpha (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *dest,
@ -693,9 +693,9 @@ project_intensity_alpha (GimpImage *gimage,
}
static void
project_indexed (GimpImage *gimage,
project_indexed (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *src,
PixelRegion *dest)
{
if (! gimage->construct_flag)
@ -709,9 +709,9 @@ project_indexed (GimpImage *gimage,
}
static void
project_indexed_alpha (GimpImage *gimage,
project_indexed_alpha (GimpImage *gimage,
GimpLayer *layer,
PixelRegion *src,
PixelRegion *src,
PixelRegion *dest,
PixelRegion *mask)
{
@ -730,9 +730,9 @@ project_indexed_alpha (GimpImage *gimage,
}
static void
project_channel (GimpImage *gimage,
project_channel (GimpImage *gimage,
GimpChannel *channel,
PixelRegion *src,
PixelRegion *src,
PixelRegion *src2)
{
guchar col[3];

2
app/core/gimpselection.c
View File

@ -655,7 +655,7 @@ gimp_selection_save (GimpChannel *selection)
FALSE));
/* saved selections are not visible by default */
gimp_drawable_set_visible (GIMP_DRAWABLE (new_channel), FALSE, FALSE);
gimp_item_set_visible (GIMP_ITEM (new_channel), FALSE, FALSE);
gimp_image_add_channel (gimage, new_channel, -1);

8
app/gui/channels-commands.c
View File

@ -137,7 +137,7 @@ channels_duplicate_cmd_callback (GtkWidget *widget,
enum_class = g_type_class_ref (GIMP_TYPE_CHANNEL_TYPE);
enum_value = g_enum_get_value (enum_class, component);
g_type_class_unref (enum_class);
name = g_strdup_printf (_("%s Channel Copy"),
gettext (enum_value->value_name));
@ -147,7 +147,7 @@ channels_duplicate_cmd_callback (GtkWidget *widget,
/* copied components are invisible by default so subsequent copies
* of components don't affect each other
*/
gimp_drawable_set_visible (GIMP_DRAWABLE (new_channel), FALSE, FALSE);
gimp_item_set_visible (GIMP_ITEM (new_channel), FALSE, FALSE);
g_free (name);
}
@ -336,7 +336,7 @@ channels_new_channel_query (GimpImage *gimage,
48, 64);
gimp_color_panel_set_context (GIMP_COLOR_PANEL (options->color_panel),
gimp_get_user_context (gimage->gimp));
/* The dialog */
options->query_box =
gimp_viewable_dialog_new (GIMP_VIEWABLE (gimage),
@ -561,7 +561,7 @@ channels_edit_channel_query (GimpChannel *channel)
g_signal_connect (options->color_panel, "color_changed",
G_CALLBACK (channels_color_changed),
opacity_scale_data);
opacity_scale_data);
gtk_widget_show (table);
gtk_widget_show (vbox);

4
app/pdb/channel_cmds.c
View File

@ -492,7 +492,7 @@ channel_get_visible_invoker (Gimp *gimp,
return_args = procedural_db_return_args (&channel_get_visible_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_drawable_get_visible (GIMP_DRAWABLE (channel));
return_args[1].value.pdb_int = gimp_item_get_visible (GIMP_ITEM (channel));
return return_args;
}
@ -546,7 +546,7 @@ channel_set_visible_invoker (Gimp *gimp,
visible = args[1].value.pdb_int ? TRUE : FALSE;
if (success)
gimp_drawable_set_visible (GIMP_DRAWABLE (channel), visible, TRUE);
gimp_item_set_visible (GIMP_ITEM (channel), visible, TRUE);
return procedural_db_return_args (&channel_set_visible_proc, success);
}

4
app/pdb/layer_cmds.c
View File

@ -1144,7 +1144,7 @@ layer_get_visible_invoker (Gimp *gimp,
return_args = procedural_db_return_args (&layer_get_visible_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_drawable_get_visible (GIMP_DRAWABLE (layer));
return_args[1].value.pdb_int = gimp_item_get_visible (GIMP_ITEM (layer));
return return_args;
}
@ -1198,7 +1198,7 @@ layer_set_visible_invoker (Gimp *gimp,
visible = args[1].value.pdb_int ? TRUE : FALSE;
if (success)
gimp_drawable_set_visible (GIMP_DRAWABLE (layer), visible, TRUE);
gimp_item_set_visible (GIMP_ITEM (layer), visible, TRUE);
return procedural_db_return_args (&layer_set_visible_proc, success);
}

18
app/text/gimptextlayer.c
View File

@ -248,32 +248,32 @@ gimp_text_layer_new (GimpImage *image,
GimpText *text)
{
GimpTextLayer *layer;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
if (!text->text)
return NULL;
layer = g_object_new (GIMP_TYPE_TEXT_LAYER, NULL);
gimp_drawable_configure (GIMP_DRAWABLE (layer),
image,
0, 0, 0, 0,
gimp_image_base_type_with_alpha (image),
NULL);
gimp_text_layer_set_text (layer, text);
if (! gimp_text_layer_render_now (layer))
{
g_object_unref (layer);
return NULL;
}
return GIMP_LAYER (layer);
}
/**
* gimp_text_layer_from_layer:
* @layer: a #GimpLayer object
@ -326,12 +326,12 @@ gimp_text_layer_from_layer (GimpLayer *layer,
gimp_item_offsets (GIMP_ITEM (layer), &item->offset_x, &item->offset_y);
item->visible = gimp_item_get_visible (GIMP_ITEM (layer));
item->linked = gimp_item_get_linked (GIMP_ITEM (layer));
drawable->tiles = GIMP_DRAWABLE (layer)->tiles;
GIMP_DRAWABLE (layer)->tiles = NULL;
drawable->visible = gimp_drawable_get_visible (GIMP_DRAWABLE (layer));
drawable->bytes = gimp_drawable_bytes (GIMP_DRAWABLE (layer));
drawable->type = gimp_drawable_type (GIMP_DRAWABLE (layer));
drawable->has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));

224
app/widgets/gimpdrawabletreeview.c
View File

@ -32,7 +32,6 @@
#include "core/gimpchannel.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpdrawable.h"
#include "core/gimpdrawable-bucket-fill.h"
#include "core/gimpimage.h"
#include "core/gimpimage-undo.h"
@ -54,14 +53,6 @@
static void gimp_drawable_tree_view_class_init (GimpDrawableTreeViewClass *klass);
static void gimp_drawable_tree_view_init (GimpDrawableTreeView *view);
static GObject *gimp_drawable_tree_view_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_drawable_tree_view_set_container (GimpContainerView *view,
GimpContainer *container);
static gpointer gimp_drawable_tree_view_insert_item (GimpContainerView *view,
GimpViewable *viewable,
gint index);
static gboolean gimp_drawable_tree_view_select_item (GimpContainerView *view,
GimpViewable *item,
gpointer insert_data);
@ -82,14 +73,6 @@ static void gimp_drawable_tree_view_new_color_dropped
const GimpRGB *color,
gpointer data);
static void gimp_drawable_tree_view_visibility_changed
(GimpDrawable *drawable,
GimpDrawableTreeView *view);
static void gimp_drawable_tree_view_eye_clicked(GtkCellRendererToggle *toggle,
gchar *path,
GdkModifierType state,
GimpDrawableTreeView *view);
static GimpItemTreeViewClass *parent_class = NULL;
@ -125,20 +108,14 @@ gimp_drawable_tree_view_get_type (void)
static void
gimp_drawable_tree_view_class_init (GimpDrawableTreeViewClass *klass)
{
GObjectClass *object_class;
GimpContainerViewClass *container_view_class;
GimpItemTreeViewClass *item_view_class;
object_class = G_OBJECT_CLASS (klass);
container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass);
item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->constructor = gimp_drawable_tree_view_constructor;
container_view_class->set_container = gimp_drawable_tree_view_set_container;
container_view_class->insert_item = gimp_drawable_tree_view_insert_item;
container_view_class->select_item = gimp_drawable_tree_view_select_item;
item_view_class->set_image = gimp_drawable_tree_view_set_image;
@ -153,10 +130,6 @@ gimp_drawable_tree_view_init (GimpDrawableTreeView *view)
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
item_view = GIMP_ITEM_TREE_VIEW (view);
view->model_column_visible = tree_view->n_model_columns;
tree_view->model_columns[tree_view->n_model_columns++] = G_TYPE_BOOLEAN;
gimp_dnd_viewable_dest_add (item_view->new_button, GIMP_TYPE_PATTERN,
gimp_drawable_tree_view_new_pattern_dropped,
view);
@ -165,88 +138,9 @@ gimp_drawable_tree_view_init (GimpDrawableTreeView *view)
view);
}
static GObject *
gimp_drawable_tree_view_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GimpContainerTreeView *tree_view;
GimpDrawableTreeView *drawable_view;
GObject *object;
GtkTreeViewColumn *column;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
tree_view = GIMP_CONTAINER_TREE_VIEW (object);
drawable_view = GIMP_DRAWABLE_TREE_VIEW (object);
column = gtk_tree_view_column_new ();
gtk_tree_view_insert_column (tree_view->view, column, 0);
drawable_view->eye_cell = gimp_cell_renderer_toggle_new (GIMP_STOCK_VISIBLE);
gtk_tree_view_column_pack_start (column, drawable_view->eye_cell, FALSE);
gtk_tree_view_column_set_attributes (column, drawable_view->eye_cell,
"active",
drawable_view->model_column_visible,
NULL);
tree_view->toggle_cells = g_list_prepend (tree_view->toggle_cells,
drawable_view->eye_cell);
g_signal_connect (drawable_view->eye_cell, "clicked",
G_CALLBACK (gimp_drawable_tree_view_eye_clicked),
drawable_view);
return object;
}
/* GimpContainerView methods */
static void
gimp_drawable_tree_view_set_container (GimpContainerView *view,
GimpContainer *container)
{
GimpDrawableTreeView *drawable_view;
drawable_view = GIMP_DRAWABLE_TREE_VIEW (view);
if (view->container)
{
gimp_container_remove_handler (view->container,
drawable_view->visibility_changed_handler_id);
}
GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container (view, container);
if (view->container)
{
drawable_view->visibility_changed_handler_id =
gimp_container_add_handler (view->container, "visibility_changed",
G_CALLBACK (gimp_drawable_tree_view_visibility_changed),
view);
}
}
static gpointer
gimp_drawable_tree_view_insert_item (GimpContainerView *view,
GimpViewable *viewable,
gint index)
{
GtkTreeIter *iter;
iter = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, viewable,
index);
gtk_list_store_set (GTK_LIST_STORE (GIMP_CONTAINER_TREE_VIEW (view)->model),
iter,
GIMP_DRAWABLE_TREE_VIEW (view)->model_column_visible,
gimp_drawable_get_visible (GIMP_DRAWABLE (viewable)),
-1);
return iter;
}
static gboolean
gimp_drawable_tree_view_select_item (GimpContainerView *view,
GimpViewable *item,
@ -376,121 +270,3 @@ gimp_drawable_tree_view_new_color_dropped (GtkWidget *widget,
color,
NULL);
}
static void
gimp_drawable_tree_view_visibility_changed (GimpDrawable *drawable,
GimpDrawableTreeView *view)
{
GimpContainerView *container_view;
GimpContainerTreeView *tree_view;
GtkTreeIter *iter;
container_view = GIMP_CONTAINER_VIEW (view);
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
iter = g_hash_table_lookup (container_view->hash_table, drawable);
if (iter)
gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
view->model_column_visible,
gimp_drawable_get_visible (drawable),
-1);
}
static void
gimp_drawable_tree_view_eye_clicked (GtkCellRendererToggle *toggle,
gchar *path_str,
GdkModifierType state,
GimpDrawableTreeView *view)
{
GimpContainerTreeView *tree_view;
GtkTreePath *path;
GtkTreeIter iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
path = gtk_tree_path_new_from_string (path_str);
if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
{
GimpPreviewRenderer *renderer;
GimpDrawable *drawable;
GimpImage *gimage;
gboolean active;
gtk_tree_model_get (tree_view->model, &iter,
tree_view->model_column_renderer, &renderer,
-1);
g_object_get (toggle,
"active", &active,
NULL);
drawable = GIMP_DRAWABLE (renderer->viewable);
g_object_unref (renderer);
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
if (state & GDK_SHIFT_MASK)
{
GList *visible = NULL;
GList *invisible = NULL;
GList *list;
gboolean iter_valid;
for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model,
&iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (tree_view->model,
&iter))
{
gtk_tree_model_get (tree_view->model, &iter,
tree_view->model_column_renderer, &renderer,
-1);
if ((GimpDrawable *) renderer->viewable != drawable)
{
if (gimp_drawable_get_visible (GIMP_DRAWABLE (renderer->viewable)))
visible = g_list_prepend (visible, renderer->viewable);
else
invisible = g_list_prepend (invisible, renderer->viewable);
}
g_object_unref (renderer);
}
if (visible || invisible)
gimp_image_undo_group_start (gimage,
GIMP_UNDO_GROUP_DRAWABLE_VISIBILITY,
_("Set Drawable Exclusive Visible"));
gimp_drawable_set_visible (drawable, TRUE, TRUE);
if (visible)
{
for (list = visible; list; list = g_list_next (list))
gimp_drawable_set_visible (GIMP_DRAWABLE (list->data), FALSE,
TRUE);
}
else if (invisible)
{
for (list = invisible; list; list = g_list_next (list))
gimp_drawable_set_visible (GIMP_DRAWABLE (list->data), TRUE,
TRUE);
}
if (visible || invisible)
gimp_image_undo_group_end (gimage);
g_list_free (visible);
g_list_free (invisible);
}
else
{
gimp_drawable_set_visible (drawable, !active, TRUE);
}
gimp_image_flush (gimage);
}
gtk_tree_path_free (path);
}

8
app/widgets/gimpdrawabletreeview.h
View File

@ -38,13 +38,7 @@ typedef struct _GimpDrawableTreeViewClass GimpDrawableTreeViewClass;
struct _GimpDrawableTreeView
{
GimpItemTreeView parent_instance;
gint model_column_visible;
GtkCellRenderer *eye_cell;
GQuark visibility_changed_handler_id;
GimpItemTreeView parent_instance;
};
struct _GimpDrawableTreeViewClass

155
app/widgets/gimpitemtreeview.c
View File

@ -31,6 +31,7 @@
#include "core/gimpchannel.h"
#include "core/gimpcontainer.h"
#include "core/gimpimage.h"
#include "core/gimpimage-undo.h"
#include "core/gimplayer.h"
#include "core/gimpmarshal.h"
@ -130,8 +131,15 @@ static void gimp_item_tree_view_name_edited (GtkCellRendererText *cell,
const gchar *name,
GimpItemTreeView *view);
static void gimp_item_tree_view_visible_changed (GimpItem *item,
GimpItemTreeView *view);
static void gimp_item_tree_view_linked_changed (GimpItem *item,
GimpItemTreeView *view);
static void gimp_item_tree_view_eye_clicked (GtkCellRendererToggle *toggle,
gchar *path,
GdkModifierType state,
GimpItemTreeView *view);
static void gimp_item_tree_view_chain_clicked (GtkCellRendererToggle *toggle,
gchar *path,
GdkModifierType state,
@ -247,6 +255,9 @@ gimp_item_tree_view_init (GimpItemTreeView *view,
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
editor = GIMP_EDITOR (view);
view->model_column_visible = tree_view->n_model_columns;
tree_view->model_columns[tree_view->n_model_columns++] = G_TYPE_BOOLEAN;
view->model_column_linked = tree_view->n_model_columns;
tree_view->model_columns[tree_view->n_model_columns++] = G_TYPE_BOOLEAN;
@ -352,6 +363,23 @@ gimp_item_tree_view_constructor (GType type,
column = gtk_tree_view_column_new ();
gtk_tree_view_insert_column (tree_view->view, column, 0);
item_view->eye_cell = gimp_cell_renderer_toggle_new (GIMP_STOCK_VISIBLE);
gtk_tree_view_column_pack_start (column, item_view->eye_cell, FALSE);
gtk_tree_view_column_set_attributes (column, item_view->eye_cell,
"active",
item_view->model_column_visible,
NULL);
tree_view->toggle_cells = g_list_prepend (tree_view->toggle_cells,
item_view->eye_cell);
g_signal_connect (item_view->eye_cell, "clicked",
G_CALLBACK (gimp_item_tree_view_eye_clicked),
item_view);
column = gtk_tree_view_column_new ();
gtk_tree_view_insert_column (tree_view->view, column, 0);
item_view->chain_cell = gimp_cell_renderer_toggle_new (GIMP_STOCK_LINKED);
gtk_tree_view_column_pack_start (column, item_view->chain_cell, FALSE);
gtk_tree_view_column_set_attributes (column, item_view->chain_cell,
@ -551,6 +579,8 @@ gimp_item_tree_view_set_container (GimpContainerView *view,
if (view->container)
{
gimp_container_remove_handler (view->container,
item_view->visible_changed_handler_id);
gimp_container_remove_handler (view->container,
item_view->linked_changed_handler_id);
}
@ -559,6 +589,10 @@ gimp_item_tree_view_set_container (GimpContainerView *view,
if (view->container)
{
item_view->visible_changed_handler_id =
gimp_container_add_handler (view->container, "visibility_changed",
G_CALLBACK (gimp_item_tree_view_visible_changed),
view);
item_view->linked_changed_handler_id =
gimp_container_add_handler (view->container, "linked_changed",
G_CALLBACK (gimp_item_tree_view_linked_changed),
@ -585,6 +619,8 @@ gimp_item_tree_view_insert_item (GimpContainerView *view,
item = GIMP_ITEM (viewable);
gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
item_view->model_column_visible,
gimp_item_get_visible (item),
item_view->model_column_linked,
gimp_item_get_linked (item),
-1);
@ -1067,6 +1103,125 @@ gimp_item_tree_view_name_edited (GtkCellRendererText *cell,
}
/* "Visible" callbacks */
static void
gimp_item_tree_view_visible_changed (GimpItem *item,
GimpItemTreeView *view)
{
GimpContainerView *container_view;
GimpContainerTreeView *tree_view;
GtkTreeIter *iter;
container_view = GIMP_CONTAINER_VIEW (view);
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
iter = g_hash_table_lookup (container_view->hash_table, item);
if (iter)
gtk_list_store_set (GTK_LIST_STORE (tree_view->model), iter,
view->model_column_visible,
gimp_item_get_visible (item),
-1);
}
static void
gimp_item_tree_view_eye_clicked (GtkCellRendererToggle *toggle,
gchar *path_str,
GdkModifierType state,
GimpItemTreeView *view)
{
GimpContainerTreeView *tree_view;
GtkTreePath *path;
GtkTreeIter iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
path = gtk_tree_path_new_from_string (path_str);
if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
{
GimpPreviewRenderer *renderer;
GimpItem *item;
GimpImage *gimage;
gboolean active;
gtk_tree_model_get (tree_view->model, &iter,
tree_view->model_column_renderer, &renderer,
-1);
g_object_get (toggle,
"active", &active,
NULL);
item = GIMP_ITEM (renderer->viewable);
g_object_unref (renderer);
gimage = gimp_item_get_image (item);
if (state & GDK_SHIFT_MASK)
{
GList *visible = NULL;
GList *invisible = NULL;
GList *list;
gboolean iter_valid;
for (iter_valid = gtk_tree_model_get_iter_first (tree_view->model,
&iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (tree_view->model,
&iter))
{
gtk_tree_model_get (tree_view->model, &iter,
tree_view->model_column_renderer, &renderer,
-1);
if ((GimpItem *) renderer->viewable != item)
{
if (gimp_item_get_visible (GIMP_ITEM (renderer->viewable)))
visible = g_list_prepend (visible, renderer->viewable);
else
invisible = g_list_prepend (invisible, renderer->viewable);
}
g_object_unref (renderer);
}
if (visible || invisible)
gimp_image_undo_group_start (gimage,
GIMP_UNDO_GROUP_ITEM_VISIBILITY,
_("Set Item Exclusive Visible"));
gimp_item_set_visible (item, TRUE, TRUE);
if (visible)
{
for (list = visible; list; list = g_list_next (list))
gimp_item_set_visible (GIMP_ITEM (list->data), FALSE, TRUE);
}
else if (invisible)
{
for (list = invisible; list; list = g_list_next (list))
gimp_item_set_visible (GIMP_ITEM (list->data), TRUE, TRUE);
}
if (visible || invisible)
gimp_image_undo_group_end (gimage);
g_list_free (visible);
g_list_free (invisible);
}
else
{
gimp_item_set_visible (item, ! active, TRUE);
}
gimp_image_flush (gimage);
}
gtk_tree_path_free (path);
}
/* "Linked" callbacks */
static void

3
app/widgets/gimpitemtreeview.h
View File

@ -78,10 +78,13 @@ struct _GimpItemTreeView
GtkWidget *edit_button;
GtkWidget *delete_button;
gint model_column_visible;
gint model_column_linked;
GtkCellRenderer *eye_cell;
GtkCellRenderer *chain_cell;
/*< private >*/
GQuark visible_changed_handler_id;
GQuark linked_changed_handler_id;
};

17
app/xcf/xcf-load.c
View File

@ -574,8 +574,8 @@ xcf_load_layer_props (XcfInfo *info,
gboolean visible;
info->cp += xcf_read_int32 (info->fp, (guint32 *) &visible, 1);
gimp_drawable_set_visible (GIMP_DRAWABLE (layer),
visible ? TRUE : FALSE, FALSE);
gimp_item_set_visible (GIMP_ITEM (layer),
visible ? TRUE : FALSE, FALSE);
}
break;
case PROP_LINKED:
@ -701,8 +701,8 @@ xcf_load_channel_props (XcfInfo *info,
gboolean visible;
info->cp += xcf_read_int32 (info->fp, (guint32 *) &visible, 1);
gimp_drawable_set_visible (GIMP_DRAWABLE (*channel),
visible ? TRUE : FALSE, FALSE);
gimp_item_set_visible (GIMP_ITEM (*channel),
visible ? TRUE : FALSE, FALSE);
}
break;
case PROP_LINKED:
@ -1552,6 +1552,7 @@ xcf_load_vector (XcfInfo *info,
{
gchar *name;
GimpTattoo tattoo = 0;
guint32 visible;
guint32 linked;
guint32 num_parasites;
guint32 num_strokes;
@ -1562,17 +1563,19 @@ xcf_load_vector (XcfInfo *info,
info->cp += xcf_read_string (info->fp, &name, 1);
info->cp += xcf_read_int32 (info->fp, &tattoo, 1);
info->cp += xcf_read_int32 (info->fp, &visible, 1);
info->cp += xcf_read_int32 (info->fp, &linked, 1);
info->cp += xcf_read_int32 (info->fp, &num_parasites, 1);
info->cp += xcf_read_int32 (info->fp, &num_strokes, 1);
g_printerr ("name: %s, tattoo: %d, linked: %d, num_parasites %d, "
g_printerr ("name: %s, tattoo: %d, visible: %d, linked: %d, num_parasites %d, "
"num_strokes %d\n",
name, tattoo, linked, num_parasites, num_strokes);
name, tattoo, visible, linked, num_parasites, num_strokes);
vectors = gimp_vectors_new (gimage, name);
GIMP_ITEM (vectors)->linked = linked;
GIMP_ITEM (vectors)->visible = visible ? TRUE : FALSE;
GIMP_ITEM (vectors)->linked = linked ? TRUE : FALSE;
if (tattoo)
GIMP_ITEM (vectors)->tattoo = tattoo;

14
app/xcf/xcf-save.c
View File

@ -504,7 +504,7 @@ xcf_save_layer_props (XcfInfo *info,
xcf_check_error (xcf_save_prop (info, gimage, PROP_OPACITY, error,
layer->opacity));
xcf_check_error (xcf_save_prop (info, gimage, PROP_VISIBLE, error,
gimp_drawable_get_visible (GIMP_DRAWABLE (layer))));
gimp_item_get_visible (GIMP_ITEM (layer))));
xcf_check_error (xcf_save_prop (info, gimage, PROP_LINKED, error,
gimp_item_get_linked (GIMP_ITEM (layer))));
xcf_check_error (xcf_save_prop (info, gimage, PROP_PRESERVE_TRANSPARENCY,
@ -580,7 +580,7 @@ xcf_save_channel_props (XcfInfo *info,
xcf_check_error (xcf_save_prop (info, gimage, PROP_OPACITY, error,
channel->color.a));
xcf_check_error (xcf_save_prop (info, gimage, PROP_VISIBLE, error,
gimp_drawable_get_visible (GIMP_DRAWABLE (channel))));
gimp_item_get_visible (GIMP_ITEM (channel))));
xcf_check_error (xcf_save_prop (info, gimage, PROP_LINKED, error,
gimp_item_get_linked (GIMP_ITEM (channel))));
xcf_check_error (xcf_save_prop (info, gimage, PROP_SHOW_MASKED, error,
@ -1675,6 +1675,7 @@ xcf_save_vectors (XcfInfo *info,
GimpParasiteList *parasites;
gchar *name;
guint32 tattoo;
guint32 visible;
guint32 linked;
guint32 num_parasites;
guint32 num_strokes;
@ -1682,6 +1683,7 @@ xcf_save_vectors (XcfInfo *info,
/*
* name (string)
* tattoo (gint)
* visible (gint)
* linked (gint)
* num_parasites (gint)
* num_strokes (gint)
@ -1693,6 +1695,7 @@ xcf_save_vectors (XcfInfo *info,
parasites = GIMP_ITEM (vectors)->parasites;
name = (gchar *) gimp_object_get_name (GIMP_OBJECT (vectors));
visible = gimp_item_get_visible (GIMP_ITEM (vectors));
linked = gimp_item_get_linked (GIMP_ITEM (vectors));
tattoo = gimp_item_get_tattoo (GIMP_ITEM (vectors));
num_parasites = gimp_parasite_list_persistent_length (parasites);
@ -1700,13 +1703,14 @@ xcf_save_vectors (XcfInfo *info,
xcf_write_string_check_error (info, &name, 1);
xcf_write_int32_check_error (info, &tattoo, 1);
xcf_write_int32_check_error (info, &visible, 1);
xcf_write_int32_check_error (info, &linked, 1);
xcf_write_int32_check_error (info, &num_parasites, 1);
xcf_write_int32_check_error (info, &num_strokes, 1);
g_printerr ("name: %s, tattoo: %d, linked: %d, num_parasites %d, "
"num_strokes %d\n",
name, tattoo, linked, num_parasites, num_strokes);
g_printerr ("name: %s, tattoo: %d, visible: %d, linked: %d, "
"num_parasites %d, num_strokes %d\n",
name, tattoo, visible, linked, num_parasites, num_strokes);
xcf_check_error (xcf_save_parasite_list (info, parasites, error));

2
tools/pdbgen/pdb/channel.pdb
View File

@ -268,7 +268,7 @@ CODE
'object', 'GIMP_OBJECT (channel)');
&channel_accessors('visible', 'boolean', 'visibility', 1, undef,
'drawable', 'GIMP_DRAWABLE (channel)');
'item', 'GIMP_ITEM (channel)');
&channel_accessors('show_masked', 'boolean', 'composite method', 0,
<<'CODE');

2
tools/pdbgen/pdb/layer.pdb
View File

@ -548,7 +548,7 @@ CODE
'object', 'GIMP_OBJECT (layer)');
&layer_accessors('visible', 'boolean', 'visibility', 0, 1, undef,
'drawable', 'GIMP_DRAWABLE (layer)');
'item', 'GIMP_ITEM (layer)');
&layer_accessors('preserve_trans', 'boolean', 'preserve transperancy', 1, 1);