Commit ed6fe48b authored by Michael Natterer's avatar Michael Natterer 😴 Committed by Michael Natterer

Some PDB fixes/cosmetics before doing real changes again:

2003-12-08  Michael Natterer  <mitch@gimp.org>

	Some PDB fixes/cosmetics before doing real changes again:

	* tools/pdbgen/pdb/drawable.pdb
	* tools/pdbgen/pdb/layer.pdb: changed order of generated functions
	to make more sense.

	* tools/pdbgen/pdb/misc_tools.pdb: doc cosmetics, removed unused
	subroutines.

	* tools/pdbgen/pdb/image.pdb: reordered generated functions as
	above, fixed resolution and unit accessors to use functions
	instead of setting gimage->foo directly, use &image_accessors()
	for the tattoo_state functions, cleanup.

	* app/pdb/drawable_cmds.c
	* app/pdb/image_cmds.c
	* app/pdb/layer_cmds.c
	* app/pdb/misc_tools_cmds.c
	* libgimp/gimpdrawable_pdb.[ch]
	* libgimp/gimpimage_pdb.[ch]
	* libgimp/gimplayer_pdb.[ch]
	* libgimp/gimpmisctools_pdb.c: regenerated.
parent 53be6dae
2003-12-08 Michael Natterer <mitch@gimp.org>
Some PDB fixes/cosmetics before doing real changes again:
* tools/pdbgen/pdb/drawable.pdb
* tools/pdbgen/pdb/layer.pdb: changed order of generated functions
to make more sense.
* tools/pdbgen/pdb/misc_tools.pdb: doc cosmetics, removed unused
subroutines.
* tools/pdbgen/pdb/image.pdb: reordered generated functions as
above, fixed resolution and unit accessors to use functions
instead of setting gimage->foo directly, use &image_accessors()
for the tattoo_state functions, cleanup.
* app/pdb/drawable_cmds.c
* app/pdb/image_cmds.c
* app/pdb/layer_cmds.c
* app/pdb/misc_tools_cmds.c
* libgimp/gimpdrawable_pdb.[ch]
* libgimp/gimpimage_pdb.[ch]
* libgimp/gimplayer_pdb.[ch]
* libgimp/gimpmisctools_pdb.c: regenerated.
2003-12-08 Sven Neumann <sven@gimp.org>
* libgimpthumb/gimpthumbnail.c (gimp_thumbnail_load_thumb): don't
This diff is collapsed.
This diff is collapsed.
......@@ -41,17 +41,17 @@
#include "pdb_glue.h"
static ProcRecord layer_new_proc;
static ProcRecord layer_new_from_drawable_proc;
static ProcRecord layer_copy_proc;
static ProcRecord layer_create_mask_proc;
static ProcRecord layer_add_alpha_proc;
static ProcRecord layer_scale_proc;
static ProcRecord layer_resize_proc;
static ProcRecord layer_resize_to_image_size_proc;
static ProcRecord layer_translate_proc;
static ProcRecord layer_add_alpha_proc;
static ProcRecord layer_set_offsets_proc;
static ProcRecord layer_create_mask_proc;
static ProcRecord layer_get_mask_proc;
static ProcRecord layer_is_floating_sel_proc;
static ProcRecord layer_new_from_drawable_proc;
static ProcRecord layer_get_preserve_trans_proc;
static ProcRecord layer_set_preserve_trans_proc;
static ProcRecord layer_get_apply_mask_proc;
......@@ -69,17 +69,17 @@ void
register_layer_procs (Gimp *gimp)
{
procedural_db_register (gimp, &layer_new_proc);
procedural_db_register (gimp, &layer_new_from_drawable_proc);
procedural_db_register (gimp, &layer_copy_proc);
procedural_db_register (gimp, &layer_create_mask_proc);
procedural_db_register (gimp, &layer_add_alpha_proc);
procedural_db_register (gimp, &layer_scale_proc);
procedural_db_register (gimp, &layer_resize_proc);
procedural_db_register (gimp, &layer_resize_to_image_size_proc);
procedural_db_register (gimp, &layer_translate_proc);
procedural_db_register (gimp, &layer_add_alpha_proc);
procedural_db_register (gimp, &layer_set_offsets_proc);
procedural_db_register (gimp, &layer_create_mask_proc);
procedural_db_register (gimp, &layer_get_mask_proc);
procedural_db_register (gimp, &layer_is_floating_sel_proc);
procedural_db_register (gimp, &layer_new_from_drawable_proc);
procedural_db_register (gimp, &layer_get_preserve_trans_proc);
procedural_db_register (gimp, &layer_set_preserve_trans_proc);
procedural_db_register (gimp, &layer_get_apply_mask_proc);
......@@ -219,6 +219,92 @@ static ProcRecord layer_new_proc =
{ { layer_new_invoker } }
};
static Argument *
layer_new_from_drawable_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpDrawable *drawable;
GimpImage *dest_image;
GimpLayer *layer_copy = NULL;
drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_DRAWABLE (drawable))
success = FALSE;
dest_image = gimp_image_get_by_ID (gimp, args[1].value.pdb_int);
if (! GIMP_IS_IMAGE (dest_image))
success = FALSE;
if (success)
{
GType new_type;
GimpItem *new_item;
if (GIMP_IS_LAYER (drawable))
new_type = G_TYPE_FROM_INSTANCE (drawable);
else
new_type = GIMP_TYPE_LAYER;
if (dest_image == gimp_item_get_image (GIMP_ITEM (drawable)))
new_item = gimp_item_duplicate (GIMP_ITEM (drawable), new_type, TRUE);
else
new_item = gimp_item_convert (GIMP_ITEM (drawable), dest_image, new_type, TRUE);
if (new_item)
layer_copy = GIMP_LAYER (new_item);
else
success = FALSE;
}
return_args = procedural_db_return_args (&layer_new_from_drawable_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer_copy));
return return_args;
}
static ProcArg layer_new_from_drawable_inargs[] =
{
{
GIMP_PDB_DRAWABLE,
"drawable",
"The source drawable from where the new layer is copied"
},
{
GIMP_PDB_IMAGE,
"dest_image",
"The destination image to which to add the layer"
}
};
static ProcArg layer_new_from_drawable_outargs[] =
{
{
GIMP_PDB_LAYER,
"layer_copy",
"The newly copied layer"
}
};
static ProcRecord layer_new_from_drawable_proc =
{
"gimp_layer_new_from_drawable",
"Create a new layer by copying an existing drawable.",
"This procedure creates a new layer as a copy of the specified drawable. The new layer still needs to be added to the image, as this is not automatic. Add the new layer with the 'gimp_image_add_layer' command. Other attributes such as layer mask modes, and offsets should be set with explicit procedure calls.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
GIMP_INTERNAL,
2,
layer_new_from_drawable_inargs,
1,
layer_new_from_drawable_outargs,
{ { layer_new_from_drawable_invoker } }
};
static Argument *
layer_copy_invoker (Gimp *gimp,
Argument *args)
......@@ -286,71 +372,45 @@ static ProcRecord layer_copy_proc =
};
static Argument *
layer_create_mask_invoker (Gimp *gimp,
Argument *args)
layer_add_alpha_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpLayer *layer;
gint32 mask_type;
GimpLayerMask *mask = NULL;
layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_LAYER (layer))
success = FALSE;
mask_type = args[1].value.pdb_int;
if (mask_type < GIMP_ADD_WHITE_MASK || mask_type > GIMP_ADD_COPY_MASK)
success = FALSE;
if (success)
success = (mask = gimp_layer_create_mask (layer, (GimpAddMaskType) mask_type)) != NULL;
return_args = procedural_db_return_args (&layer_create_mask_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (mask));
gimp_layer_add_alpha (layer);
return return_args;
return procedural_db_return_args (&layer_add_alpha_proc, success);
}
static ProcArg layer_create_mask_inargs[] =
static ProcArg layer_add_alpha_inargs[] =
{
{
GIMP_PDB_LAYER,
"layer",
"The layer to which to add the mask"
},
{
GIMP_PDB_INT32,
"mask_type",
"The type of mask: { GIMP_ADD_WHITE_MASK (0), GIMP_ADD_BLACK_MASK (1), GIMP_ADD_ALPHA_MASK (2), GIMP_ADD_ALPHA_TRANSFER_MASK (3), GIMP_ADD_SELECTION_MASK (4), GIMP_ADD_COPY_MASK (5) }"
}
};
static ProcArg layer_create_mask_outargs[] =
{
{
GIMP_PDB_CHANNEL,
"mask",
"The newly created mask"
"The layer"
}
};
static ProcRecord layer_create_mask_proc =
static ProcRecord layer_add_alpha_proc =
{
"gimp_layer_create_mask",
"Create a layer mask for the specified specified layer.",
"This procedure creates a layer mask for the specified layer. Layer masks serve as an additional alpha channel for a layer. A number of ifferent types of masks are allowed for initialisation: completely white masks (which will leave the layer fully visible), completely black masks (which will give the layer complete transparency, the layer's already existing alpha channel (which will leave the layer fully visible, but which may be more useful than a white mask), the current selection or a grayscale copy of the layer. The layer mask still needs to be added to the layer. This can be done with a call to 'gimp_image_add_layer_mask'.",
"gimp_layer_add_alpha",
"Add an alpha channel to the layer if it doesn't already have one.",
"This procedure adds an additional component to the specified layer if it does not already possess an alpha channel. An alpha channel makes it possible to move a layer from the bottom of the layer stack and to clear and erase to transparency, instead of the background color. This transforms images of type RGB to RGBA, GRAY to GRAYA, and INDEXED to INDEXEDA.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
GIMP_INTERNAL,
2,
layer_create_mask_inargs,
1,
layer_create_mask_outargs,
{ { layer_create_mask_invoker } }
layer_add_alpha_inargs,
0,
NULL,
{ { layer_add_alpha_invoker } }
};
static Argument *
......@@ -681,48 +741,6 @@ static ProcRecord layer_translate_proc =
{ { layer_translate_invoker } }
};
static Argument *
layer_add_alpha_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_LAYER (layer))
success = FALSE;
if (success)
gimp_layer_add_alpha (layer);
return procedural_db_return_args (&layer_add_alpha_proc, success);
}
static ProcArg layer_add_alpha_inargs[] =
{
{
GIMP_PDB_LAYER,
"layer",
"The layer"
}
};
static ProcRecord layer_add_alpha_proc =
{
"gimp_layer_add_alpha",
"Add an alpha channel to the layer if it doesn't already have one.",
"This procedure adds an additional component to the specified layer if it does not already possess an alpha channel. An alpha channel makes it possible to move a layer from the bottom of the layer stack and to clear and erase to transparency, instead of the background color. This transforms images of type RGB to RGBA, GRAY to GRAYA, and INDEXED to INDEXEDA.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
GIMP_INTERNAL,
1,
layer_add_alpha_inargs,
0,
NULL,
{ { layer_add_alpha_invoker } }
};
static Argument *
layer_set_offsets_invoker (Gimp *gimp,
Argument *args)
......@@ -812,6 +830,74 @@ static ProcRecord layer_set_offsets_proc =
{ { layer_set_offsets_invoker } }
};
static Argument *
layer_create_mask_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpLayer *layer;
gint32 mask_type;
GimpLayerMask *mask = NULL;
layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_LAYER (layer))
success = FALSE;
mask_type = args[1].value.pdb_int;
if (mask_type < GIMP_ADD_WHITE_MASK || mask_type > GIMP_ADD_COPY_MASK)
success = FALSE;
if (success)
success = (mask = gimp_layer_create_mask (layer, (GimpAddMaskType) mask_type)) != NULL;
return_args = procedural_db_return_args (&layer_create_mask_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (mask));
return return_args;
}
static ProcArg layer_create_mask_inargs[] =
{
{
GIMP_PDB_LAYER,
"layer",
"The layer to which to add the mask"
},
{
GIMP_PDB_INT32,
"mask_type",
"The type of mask: { GIMP_ADD_WHITE_MASK (0), GIMP_ADD_BLACK_MASK (1), GIMP_ADD_ALPHA_MASK (2), GIMP_ADD_ALPHA_TRANSFER_MASK (3), GIMP_ADD_SELECTION_MASK (4), GIMP_ADD_COPY_MASK (5) }"
}
};
static ProcArg layer_create_mask_outargs[] =
{
{
GIMP_PDB_CHANNEL,
"mask",
"The newly created mask"
}
};
static ProcRecord layer_create_mask_proc =
{
"gimp_layer_create_mask",
"Create a layer mask for the specified specified layer.",
"This procedure creates a layer mask for the specified layer. Layer masks serve as an additional alpha channel for a layer. A number of ifferent types of masks are allowed for initialisation: completely white masks (which will leave the layer fully visible), completely black masks (which will give the layer complete transparency, the layer's already existing alpha channel (which will leave the layer fully visible, but which may be more useful than a white mask), the current selection or a grayscale copy of the layer. The layer mask still needs to be added to the layer. This can be done with a call to 'gimp_image_add_layer_mask'.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
GIMP_INTERNAL,
2,
layer_create_mask_inargs,
1,
layer_create_mask_outargs,
{ { layer_create_mask_invoker } }
};
static Argument *
layer_get_mask_invoker (Gimp *gimp,
Argument *args)
......@@ -920,92 +1006,6 @@ static ProcRecord layer_is_floating_sel_proc =
{ { layer_is_floating_sel_invoker } }
};
static Argument *
layer_new_from_drawable_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpDrawable *drawable;
GimpImage *dest_image;
GimpLayer *layer_copy = NULL;
drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_DRAWABLE (drawable))
success = FALSE;
dest_image = gimp_image_get_by_ID (gimp, args[1].value.pdb_int);
if (! GIMP_IS_IMAGE (dest_image))
success = FALSE;
if (success)
{
GType new_type;
GimpItem *new_item;
if (GIMP_IS_LAYER (drawable))
new_type = G_TYPE_FROM_INSTANCE (drawable);
else
new_type = GIMP_TYPE_LAYER;
if (dest_image == gimp_item_get_image (GIMP_ITEM (drawable)))
new_item = gimp_item_duplicate (GIMP_ITEM (drawable), new_type, TRUE);
else
new_item = gimp_item_convert (GIMP_ITEM (drawable), dest_image, new_type, TRUE);
if (new_item)
layer_copy = GIMP_LAYER (new_item);
else
success = FALSE;
}
return_args = procedural_db_return_args (&layer_new_from_drawable_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer_copy));
return return_args;
}
static ProcArg layer_new_from_drawable_inargs[] =
{
{
GIMP_PDB_DRAWABLE,
"drawable",
"The source drawable from where the new layer is copied"
},
{
GIMP_PDB_IMAGE,
"dest_image",
"The destination image to which to add the layer"
}
};
static ProcArg layer_new_from_drawable_outargs[] =
{
{
GIMP_PDB_LAYER,
"layer_copy",
"The newly copied layer"
}
};
static ProcRecord layer_new_from_drawable_proc =
{
"gimp_layer_new_from_drawable",
"Create a new layer by copying an existing drawable.",
"This procedure creates a new layer as a copy of the specified drawable. The new layer still needs to be added to the image, as this is not automatic. Add the new layer with the 'gimp_image_add_layer' command. Other attributes such as layer mask modes, and offsets should be set with explicit procedure calls.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
GIMP_INTERNAL,
2,
layer_new_from_drawable_inargs,
1,
layer_new_from_drawable_outargs,
{ { layer_new_from_drawable_invoker } }
};
static Argument *
layer_get_preserve_trans_invoker (Gimp *gimp,
Argument *args)
......
......@@ -359,7 +359,7 @@ static ProcRecord bucket_fill_proc =
{
"gimp_bucket_fill",
"Fill the area specified either by the current selection if there is one, or by a seed fill starting at the specified coordinates.",
"This tool requires information on the paint application mode, and the fill mode, which can either be in the foreground color, or in the currently active pattern. If there is no selection, a seed fill is executed at the specified coordinates and extends outward in keeping with the threshold parameter. If there is a selection in the target image, the threshold, sample merged, x, and y arguments are unused. If the sample_merged parameter is non-zero, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of merged sampling, the x,y coordinates are relative to the image's origin; otherwise, they are relative to the drawable's origin.",
"This tool requires information on the paint application mode, and the fill mode, which can either be in the foreground color, or in the currently active pattern. If there is no selection, a seed fill is executed at the specified coordinates and extends outward in keeping with the threshold parameter. If there is a selection in the target image, the threshold, sample merged, x, and y arguments are unused. If the sample_merged parameter is non-zero, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of merged sampling, the x and y coordinates are relative to the image's origin; otherwise, they are relative to the drawable's origin.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
......@@ -482,7 +482,7 @@ static ProcRecord color_picker_proc =
{
"gimp_color_picker",
"Determine the color at the given drawable coordinates",
"This tool determines the color at the specified coordinates. The returned color is an RGB triplet even for grayscale and indexed drawables. If the coordinates lie outside of the extents of the specified drawable, then an error is returned. If the drawable has an alpha channel, the algorithm examines the alpha value of the drawable at the coordinates. If the alpha value is completely transparent (0), then an error is returned. If the sample_merged parameter is non-zero, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of a merged sampling, the supplied drawable is ignored.",
"This tool determines the color at the specified coordinates. The returned color is an RGB triplet even for grayscale and indexed drawables. If the coordinates lie outside of the extents of the specified drawable, then an error is returned. If the drawable has an alpha channel, the algorithm examines the alpha value of the drawable at the coordinates. If the alpha value is completely transparent (0), then an error is returned. If the sample_merged parameter is non-zero, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of a merged sampling, the supplied drawable is ignored except for finding the image it belongs to.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
......
This diff is collapsed.
......@@ -29,26 +29,13 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
gboolean gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean undo);
gboolean gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type);
gboolean gimp_drawable_update (gint32 drawable_ID,
gint x,
gint y,
gint width,
gint height);
gboolean gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1,
gint *y1,
gint *x2,
gint *y2);
gint32 gimp_drawable_get_image (gint32 drawable_ID);
gboolean gimp_drawable_set_image (gint32 drawable_ID,
gint32 image_ID);
gboolean gimp_drawable_has_alpha (gint32 drawable_ID);
gboolean gimp_drawable_delete (gint32 drawable_ID);
gboolean gimp_drawable_is_layer (gint32 drawable_ID);
gboolean gimp_drawable_is_layer_mask (gint32 drawable_ID);
gboolean gimp_drawable_is_channel (gint32 drawable_ID);
GimpImageType gimp_drawable_type (gint32 drawable_ID);
GimpImageType gimp_drawable_type_with_alpha (gint32 drawable_ID);
gboolean gimp_drawable_has_alpha (gint32 drawable_ID);
gboolean gimp_drawable_is_rgb (gint32 drawable_ID);
gboolean gimp_drawable_is_gray (gint32 drawable_ID);
gboolean gimp_drawable_is_indexed (gint32 drawable_ID);
......@@ -58,9 +45,9 @@ gint gimp_drawable_height (gint32 drawable_ID);
gboolean gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_x,
gint *offset_y);
gboolean gimp_drawable_is_layer (gint32 drawable_ID);
gboolean gimp_drawable_is_layer_mask (gint32 drawable_ID);
gboolean gimp_drawable_is_channel (gint32 drawable_ID);
gint32 gimp_drawable_get_image (gint32 drawable_ID);
gboolean gimp_drawable_set_image (gint32 drawable_ID,
gint32 image_ID);
gchar* gimp_drawable_get_name (gint32 drawable_ID);
gboolean gimp_drawable_set_name (gint32 drawable_ID,
const gchar *name);
......@@ -73,6 +60,18 @@ gboolean gimp_drawable_set_linked (gint32 drawable_ID,
gint gimp_drawable_get_tattoo (gint32 drawable_ID);
gboolean gimp_drawable_set_tattoo (gint32 drawable_ID,
gint tattoo);
gboolean gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1,
gint *y1,
gint *x2,
gint *y2);
gboolean gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean undo);
gboolean gimp_drawable_update (gint32 drawable_ID,
gint x,
gint y,
gint width,
gint height);
guint8* gimp_drawable_get_pixel (gint32 drawable_ID,
gint x_coord,
gint y_coord,
......@@ -82,6 +81,13 @@ gboolean gimp_drawable_set_pixel (gint32 drawable_ID,
gint y_coord,
gint num_channels,
const guint8 *pixel);
gboolean gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type);
gboolean gimp_drawable_offset (gint32 drawable_ID,
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y);
gboolean _gimp_drawable_thumbnail (gint32 drawable_ID,
gint width,
gint height,
......@@ -90,12 +96,6 @@ gboolean _gimp_drawable_thumbnail (gint32 drawable_ID,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data);
gboolean gimp_drawable_offset (gint32 drawable_ID,
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y);
gboolean gimp_drawable_delete (gint32 drawable_ID);
G_END_DECLS
......
This diff is collapsed.
......@@ -33,8 +33,12 @@ gint* gimp_image_list (gint *num
gint32 gimp_image_new (gint width,
gint height,
GimpImageBaseType type);
gint32 gimp_image_duplicate (gint32 image_ID);
gboolean gimp_image_delete (gint32 image_ID);
GimpImageBaseType gimp_image_base_type (gint32 image_ID);
gint gimp_image_width (gint32 image_ID);
gint gimp_image_height (gint32 image_ID);
gboolean gimp_image_free_shadow (gint32 image_ID);
gboolean gimp_image_resize (gint32 image_ID,
gint new_width,
gint new_height,
......@@ -50,16 +54,22 @@ gboolean gimp_image_crop (gint32 ima
gint offy);
gboolean gimp_image_flip (gint32 image_ID,
GimpOrientationType flip_type);
gboolean gimp_image_free_shadow (gint32 image_ID);
gint* gimp_image_get_layers (gint32 image_ID,
gint *num_layers);
gint* gimp_image_get_channels (gint32 image_ID,
gint *num_channels);
gint32 gimp_image_active_drawable (gint32 image_ID);
gboolean gimp_image_unset_active_channel (gint32 image_ID);
gint32 gimp_image_get_floating_sel (gint32 image_ID);
gint32 gimp_image_floating_sel_attached_to (gint32 image_ID);
gint32 gimp_image_pick_correlate_layer (gint32 image_ID,
gint x,
gint y);
gboolean gimp_image_add_layer (gint32 image_ID,
gint32 layer_ID,
gint position);
gboolean gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID);
gboolean gimp_image_raise_layer (gint32 image_ID,
gint32 layer_ID);
gboolean gimp_image_lower_layer (gint32 image_ID,
......@@ -68,32 +78,27 @@ gboolean gimp_image_raise_layer_to_top (gint32 ima
gint32 layer_ID);
gboolean gimp_image_lower_layer_to_bottom (gint32 image_ID,
gint32 layer_ID);
gboolean gimp_image_add_channel (gint32 image_ID,
gint32 channel_ID,
gint position);
gboolean gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID);
gboolean gimp_image_raise_channel (gint32 image_ID,
gint32 channel_ID);
gboolean gimp_image_lower_channel (gint32 image_ID,
gint32 layer_ID);
gint32 gimp_image_flatten (gint32 image_ID);
gint32 gimp_image_merge_visible_layers (gint32 image_ID,
GimpMergeType merge_type);
gint32 gimp_image_merge_down (gint32 image_ID,
gint32 merge_layer_ID,
GimpMergeType merge_type);
gint32 gimp_image_flatten (gint32 image_ID);
gboolean gimp_image_add_layer (gint32 image_ID,
gint32 layer_ID,
gint position);
gboolean gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID);
gboolean gimp_image_add_layer_mask (gint32 image_ID,
gint32 layer_ID,
gint32 mask_ID);
gboolean gimp_image_remove_layer_mask (gint32 image_ID,
gint32 layer_ID,
GimpMaskApplyMode mode);
gboolean gimp_image_raise_channel (gint32 image_ID,
gint32 channel_ID);
gboolean gimp_image_lower_channel (gint32 image_ID,
gint32 layer_ID);
gboolean gimp_image_add_channel (gint32 image_ID,
gint32 channel_ID,
gint position);
gboolean gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID);
guint8* _gimp_image_get_cmap (gint32 image_ID,
gint *num_bytes);
gboolean _gimp_image_set_cmap (gint32 image_ID,
......@@ -101,8 +106,6 @@ gboolean _gimp_image_set_cmap (gint32 ima
const guint8 *cmap);
gboolean gimp_image_clean_all (gint32 image_ID);
gboolean gimp_image_is_dirty (gint32 image_ID);
gint32 gimp_image_get_floating_sel (gint32 image_ID);
gint32 gimp_image_floating_sel_attached_to (gint32 image_ID);
gboolean _gimp_image_thumbnail (gint32 image_ID,
gint width,
gint height,
......@@ -111,12 +114,6 @@ gboolean _gimp_image_thumbnail (gint32 ima
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data);
gboolean gimp_image_set_tattoo_state (gint32 image_ID,
gint tattoo);
gint gimp_image_get_tattoo_state (gint32 image_ID);
gint32 gimp_image_duplicate (gint32 image_ID);
gint gimp_image_width (gint32 image_ID);
gint gimp_image_height (gint32 image_ID);
gint32 gimp_image_get_active_layer (gint32 image_ID);
gboolean gimp_image_set_active_layer (gint32 image_ID,
gint32 active_layer_ID);
......@@ -147,6 +144,9 @@ gboolean gimp_image_set_resolution (gint32 ima
GimpUnit gimp_image_get_unit (gint32 image_ID);
gboolean gimp_image_set_unit (gint32 image_ID,
GimpUnit unit);
gint gimp_image_get_tattoo_state (gint32 image_ID);
gboolean gimp_image_set_tattoo_state (gint32 image_ID,
gint tattoo_state);
gint32 gimp_image_get_layer_by_tattoo (gint32 image_ID,
gint tattoo);
gint32 gimp_image_get_channel_by_tattoo (gint32 image_ID,
......
This diff is collapsed.
......@@ -36,10 +36,11 @@ gint32 _gimp_layer_new (gint32 imag
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode);
gint32 gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32 dest_image_ID);
gint32 _gimp_layer_copy (gint32 layer_ID,
gboolean add_alpha);
gint32 gimp_layer_create_mask (gint32 layer_ID,
GimpAddMaskType mask_type);
gboolean gimp_layer_add_alpha (gint32 layer_ID);
gboolean gimp_layer_scale (gint32 layer_ID,
gint new_width,
gint new_height,
......@@ -53,14 +54,13 @@ gboolean gimp_layer_resize_to_image_size (gint32 laye
gboolean gimp_layer_translate (gint32 layer_ID,
gint offx,
gint offy);
gboolean gimp_layer_add_alpha (gint32 layer_ID);
gboolean gimp_layer_set_offsets (gint32 layer_ID,
gint offx,
gint offy);
gint32 gimp_layer_create_mask (gint32 layer_ID,
GimpAddMaskType mask_type);
gint32 gimp_layer_get_mask (gint32 layer_ID);
gboolean gimp_layer_is_floating_sel (gint32 layer_ID);
gint32 gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32 dest_image_ID);
gboolean gimp_layer_get_preserve_trans (gint32 layer_ID);
gboolean gimp_layer_set_preserve_trans (gint32 layer_ID,
gboolean preserve_trans);
......
......@@ -126,7 +126,7 @@ gimp_blend (gint32 drawable_ID,
* unused. If the sample_merged parameter is non-zero, the data of the
* composite image will be used instead of that for the specified
* drawable. This is equivalent to sampling for colors after merging
* all visible layers. In the case of merged sampling, the x,y
* all visible layers. In the case of merged sampling, the x and y
* coordinates are relative to the image's origin; otherwise, they are
* relative to the drawable's origin.
*
......@@ -188,7 +188,8 @@ gimp_bucket_fill (gint32 drawable_ID,
* parameter is non-zero, the data of the composite image will be used
* instead of that for the specified drawable. This is equivalent to
* sampling for colors after merging all visible layers. In the case of
* a merged sampling, the supplied drawable is ignored.
* a merged sampling, the supplied drawable is ignored except for
* finding the image it belongs to.
*
* Returns: TRUE on success.
*/
......