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

API PATCH #2 or so

This commit is contained in:
Marc Lehmann 1999-10-17 00:07:55 +00:00
parent 0975e3dae4
commit ec40ac728b
257 changed files with 5520 additions and 4113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
Sun Oct 17 00:55:38 CEST 1999 Marc Lehmann <marc@gimp.org>
* (221 files): Corrected ~20 pdb function names by choosing the
class/selector syntax over the various other syntaxes floating
around. Maybe more to come before 1.2.
1999-10-16 Michael Natterer <mitch@gimp.org>
* app/gimprc.c: preview_size_to_str() uses the new set of preview

2
app/base/curves.c
View File

@ -189,7 +189,7 @@ curves_colour_update (Tool *tool,
return;
sample_type = gimp_drawable_type(drawable);
is_indexed = gimp_drawable_indexed (drawable);
is_indexed = gimp_drawable_is_indexed (drawable);
has_alpha = TYPE_HAS_ALPHA(sample_type);
curves_dialog->col_value[HISTOGRAM_RED] = color[RED_PIX];

2
app/batch.c
View File

@ -44,7 +44,7 @@ batch_init ()
/* until --batch-interp=xxx or something similar is implemented
* and gimp-1.0 is not extinct use a shortcut to speed up starting the
* perl-server tremendously. This is also fully compatible to 1.0.
* perl-server tremendously. This is also fully compatible with 1.0.
*/
{
int run_mode, flags, extra;

30
app/color_cmds.c
View File

@ -91,7 +91,7 @@ brightness_contrast_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
success = FALSE;
else
{
@ -207,8 +207,8 @@ levels_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable) ||
(gimp_drawable_gray (drawable) && channel != GRAY_LUT))
if (gimp_drawable_is_indexed (drawable) ||
(gimp_drawable_is_gray (drawable) && channel != GRAY_LUT))
success = FALSE;
else
{
@ -328,7 +328,7 @@ posterize_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
success = FALSE;
else
{
@ -447,7 +447,7 @@ equalize_invoker (Argument *args)
if (success)
{
if (! gimp_drawable_indexed (drawable))
if (! gimp_drawable_is_indexed (drawable))
equalize (drawable_gimage (drawable), drawable, mask_only);
else
success = FALSE;
@ -498,7 +498,7 @@ invert_invoker (Argument *args)
if (success)
{
if (! gimp_drawable_indexed (drawable))
if (! gimp_drawable_is_indexed (drawable))
invert (drawable);
else
success = FALSE;
@ -561,8 +561,8 @@ curves_spline_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable) || (num_points & 1) ||
(gimp_drawable_gray (drawable) && channel != GRAY_LUT))
if (gimp_drawable_is_indexed (drawable) || (num_points & 1) ||
(gimp_drawable_is_gray (drawable) && channel != GRAY_LUT))
success = FALSE;
else
{
@ -680,8 +680,8 @@ curves_explicit_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable) || (num_bytes != 256) ||
(gimp_drawable_gray (drawable) && channel != GRAY_LUT))
if (gimp_drawable_is_indexed (drawable) || (num_bytes != 256) ||
(gimp_drawable_is_gray (drawable) && channel != GRAY_LUT))
success = FALSE;
else
{
@ -799,7 +799,7 @@ color_balance_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
success = FALSE;
else
{
@ -921,8 +921,8 @@ histogram_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable) ||
(gimp_drawable_gray (drawable) && channel != GRAY_LUT))
if (gimp_drawable_is_indexed (drawable) ||
(gimp_drawable_is_gray (drawable) && channel != GRAY_LUT))
success = FALSE;
else
{
@ -1089,7 +1089,7 @@ hue_saturation_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
success = FALSE;
else
{
@ -1197,7 +1197,7 @@ threshold_invoker (Argument *args)
if (success)
{
if (gimp_drawable_indexed (drawable) || (low_threshold >= high_threshold))
if (gimp_drawable_is_indexed (drawable) || (low_threshold >= high_threshold))
success = FALSE;
else
{

2
app/color_picker.c
View File

@ -487,7 +487,7 @@ pick_color_do (GimpImage *gimage,
y -= offy;
sample_type = gimp_drawable_type (drawable);
is_indexed = gimp_drawable_indexed (drawable);
is_indexed = gimp_drawable_is_indexed (drawable);
get_color_func = (GetColorFunc) gimp_drawable_get_color_at;
get_color_obj = GTK_OBJECT (drawable);

6
app/core/gimp-parasites.c
View File

@ -42,19 +42,19 @@ gimp_init_parasites()
}
void
gimp_attach_parasite (Parasite *p)
gimp_parasite_attach (Parasite *p)
{
parasite_list_add(parasites, p);
}
void
gimp_detach_parasite (const char *name)
gimp_parasite_detach (const char *name)
{
parasite_list_remove(parasites, name);
}
Parasite *
gimp_find_parasite (const char *name)
gimp_parasite_find (const char *name)
{
return parasite_list_find(parasites, name);
}

6
app/core/gimp-parasites.h
View File

@ -21,9 +21,9 @@
#include "libgimp/parasiteF.h"
void gimp_init_parasites (void);
void gimp_attach_parasite (Parasite *p);
void gimp_detach_parasite (const char *name);
Parasite * gimp_find_parasite (const char *name);
void gimp_parasite_attach (Parasite *p);
void gimp_parasite_detach (const char *name);
Parasite * gimp_parasite_find (const char *name);
char ** gimp_parasite_list (gint *count);
void gimp_parasiterc_save (void);
void gimp_parasiterc_load (void);

2
app/core/gimpdrawable-equalize.c
View File

@ -31,7 +31,7 @@ image_equalize (GimpImage *gimage)
drawable = gimage_active_drawable (gimage);
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
{
g_message (_("Equalize does not operate on indexed drawables."));
return;

2
app/core/gimpdrawable-invert.c
View File

@ -38,7 +38,7 @@ image_invert (GimpImage *gimage)
drawable = gimage_active_drawable (gimage);
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
{
g_message (_("Invert does not operate on indexed drawables."));
return;

20
app/core/gimpdrawable.c
View File

@ -407,7 +407,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable,
guchar *dest;
if (!drawable ||
(!gimp_drawable_gimage (drawable) && gimp_drawable_indexed (drawable))
(!gimp_drawable_gimage (drawable) && gimp_drawable_is_indexed (drawable))
|| x < 0 || y < 0 ||
x >= drawable->width || y >= drawable->height)
{
@ -423,7 +423,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable,
dest[3] = src[gimp_drawable_bytes (drawable) - 1];
else
dest[3] = 255;
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
dest[4] = src[0];
else
dest[4] = 0;
@ -432,7 +432,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable,
}
Parasite *
gimp_drawable_find_parasite (const GimpDrawable *drawable,
gimp_drawable_parasite_find (const GimpDrawable *drawable,
const gchar *name)
{
return parasite_list_find (drawable->parasites, name);
@ -461,7 +461,7 @@ gimp_drawable_parasite_list (GimpDrawable *drawable,
}
void
gimp_drawable_attach_parasite (GimpDrawable *drawable,
gimp_drawable_parasite_attach (GimpDrawable *drawable,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -475,7 +475,7 @@ gimp_drawable_attach_parasite (GimpDrawable *drawable,
}
else if (parasite_is_persistent(parasite) &&
!parasite_compare( parasite,
gimp_drawable_find_parasite
gimp_drawable_parasite_find
(drawable, parasite_name (parasite))))
undo_push_cantundo (drawable->gimage, _("parasite attach to drawable"));
@ -483,13 +483,13 @@ gimp_drawable_attach_parasite (GimpDrawable *drawable,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_image_attach_parasite (drawable->gimage, parasite);
gimp_image_parasite_attach (drawable->gimage, parasite);
}
else if (parasite_has_flag (parasite, PARASITE_ATTACH_GRANDPARENT))
{
parasite_shift_parent (parasite);
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
if (parasite_is_undoable (parasite))
{
@ -498,7 +498,7 @@ gimp_drawable_attach_parasite (GimpDrawable *drawable,
}
void
gimp_drawable_detach_parasite (GimpDrawable *drawable,
gimp_drawable_parasite_detach (GimpDrawable *drawable,
const gchar *parasite)
{
Parasite *p;
@ -532,7 +532,7 @@ gimp_drawable_color (GimpDrawable *drawable)
}
gboolean
gimp_drawable_gray (GimpDrawable *drawable)
gimp_drawable_is_gray (GimpDrawable *drawable)
{
if (gimp_drawable_type (drawable) == GRAYA_GIMAGE ||
gimp_drawable_type (drawable) == GRAY_GIMAGE)
@ -542,7 +542,7 @@ gimp_drawable_gray (GimpDrawable *drawable)
}
gboolean
gimp_drawable_indexed (GimpDrawable *drawable)
gimp_drawable_is_indexed (GimpDrawable *drawable)
{
if (gimp_drawable_type (drawable) == INDEXEDA_GIMAGE ||
gimp_drawable_type (drawable) == INDEXED_GIMAGE)

12
app/core/gimpdrawable.h
View File

@ -51,8 +51,8 @@ gboolean gimp_drawable_has_alpha (GimpDrawable *);
GimpImageType gimp_drawable_type (GimpDrawable *);
GimpImageType gimp_drawable_type_with_alpha (GimpDrawable *);
gboolean gimp_drawable_color (GimpDrawable *);
gboolean gimp_drawable_gray (GimpDrawable *);
gboolean gimp_drawable_indexed (GimpDrawable *);
gboolean gimp_drawable_is_gray (GimpDrawable *);
gboolean gimp_drawable_is_indexed (GimpDrawable *);
TileManager * gimp_drawable_data (GimpDrawable *);
TileManager * gimp_drawable_shadow (GimpDrawable *);
gint gimp_drawable_bytes (GimpDrawable *);
@ -69,12 +69,10 @@ void gimp_drawable_set_name (GimpDrawable *, gchar *);
guchar * gimp_drawable_get_color_at (GimpDrawable *,
gint x, gint y);
Parasite * gimp_drawable_find_parasite (const GimpDrawable *,
const gchar *name);
void gimp_drawable_attach_parasite (GimpDrawable *, Parasite *);
void gimp_drawable_detach_parasite (GimpDrawable *,
void gimp_drawable_parasite_attach (GimpDrawable *, Parasite *);
void gimp_drawable_parasite_detach (GimpDrawable *,
const gchar *);
Parasite * gimp_drawable_find_parasite (const GimpDrawable *,
Parasite * gimp_drawable_parasite_find (const GimpDrawable *,
const gchar *);
gchar ** gimp_drawable_parasite_list (GimpDrawable *drawable,
gint *count);

22
app/core/gimpimage-guides.c
View File

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpimage-guides.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

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

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpimage-merge.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

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

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpimage-projection.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

22
app/core/gimpimage-resize.c
View File

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpimage-resize.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

22
app/core/gimpimage-scale.c
View File

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpimage-scale.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

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

@ -2446,7 +2446,7 @@ undo_push_image_parasite (GImage *gimage,
data->gimage = gimage;
data->drawable = NULL;
data->name = g_strdup (parasite_name (parasite));
data->parasite = parasite_copy (gimp_image_find_parasite (gimage, data->name));
data->parasite = parasite_copy (gimp_image_parasite_find (gimage, data->name));
return TRUE;
}
@ -2474,7 +2474,7 @@ undo_push_image_parasite_remove (GImage *gimage,
data->gimage = gimage;
data->drawable = NULL;
data->name = g_strdup (name);
data->parasite = parasite_copy (gimp_image_find_parasite (gimage, data->name));
data->parasite = parasite_copy (gimp_image_parasite_find (gimage, data->name));
return TRUE;
}
@ -2503,7 +2503,7 @@ undo_push_drawable_parasite (GImage *gimage,
data->gimage = NULL;
data->drawable = drawable;
data->name = g_strdup (parasite_name (parasite));
data->parasite = parasite_copy (gimp_drawable_find_parasite (drawable, data->name));
data->parasite = parasite_copy (gimp_drawable_parasite_find (drawable, data->name));
return TRUE;
}
@ -2531,7 +2531,7 @@ undo_push_drawable_parasite_remove (GImage *gimage,
data->gimage = NULL;
data->drawable = drawable;
data->name = g_strdup (name);
data->parasite = parasite_copy (gimp_drawable_find_parasite (drawable, data->name));
data->parasite = parasite_copy (gimp_drawable_parasite_find (drawable, data->name));
return TRUE;
}
@ -2554,7 +2554,7 @@ undo_pop_parasite (GImage *gimage,
if (data->gimage)
{
data->parasite = parasite_copy (gimp_image_find_parasite (gimage,
data->parasite = parasite_copy (gimp_image_parasite_find (gimage,
data->name));
if (tmp)
parasite_list_add (data->gimage->parasites, tmp);
@ -2563,7 +2563,7 @@ undo_pop_parasite (GImage *gimage,
}
else if (data->drawable)
{
data->parasite = parasite_copy (gimp_drawable_find_parasite (data->drawable,
data->parasite = parasite_copy (gimp_drawable_parasite_find (data->drawable,
data->name));
if (tmp)
parasite_list_add (data->drawable->parasites, tmp);
@ -2572,11 +2572,11 @@ undo_pop_parasite (GImage *gimage,
}
else
{
data->parasite = parasite_copy (gimp_find_parasite (data->name));
data->parasite = parasite_copy (gimp_parasite_find (data->name));
if (tmp)
gimp_attach_parasite (tmp);
gimp_parasite_attach (tmp);
else
gimp_detach_parasite (data->name);
gimp_parasite_detach (data->name);
}
if (tmp)

22
app/core/gimpimage.c
View File

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpimage.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

4
app/core/gimpimagemap.c
View File

@ -320,7 +320,7 @@ image_map_get_color_at (ImageMap image_map, int x, int y)
if (!image_map ||
(!gimp_drawable_gimage(_image_map->drawable) &&
gimp_drawable_indexed(_image_map->drawable)) ||
gimp_drawable_is_indexed(_image_map->drawable)) ||
x < 0 || y < 0 ||
x >= _image_map->undo_tiles->width ||
y >= _image_map->undo_tiles->height)
@ -342,7 +342,7 @@ image_map_get_color_at (ImageMap image_map, int x, int y)
dest[3] = src[gimp_drawable_bytes (_image_map->drawable) - 1];
else
dest[3] = 255;
if (gimp_drawable_indexed(_image_map->drawable))
if (gimp_drawable_is_indexed(_image_map->drawable))
dest[4] = src[0];
else
dest[4] = 0;

6
app/core/gimpparasite.c
View File

@ -42,19 +42,19 @@ gimp_init_parasites()
}
void
gimp_attach_parasite (Parasite *p)
gimp_parasite_attach (Parasite *p)
{
parasite_list_add(parasites, p);
}
void
gimp_detach_parasite (const char *name)
gimp_parasite_detach (const char *name)
{
parasite_list_remove(parasites, name);
}
Parasite *
gimp_find_parasite (const char *name)
gimp_parasite_find (const char *name)
{
return parasite_list_find(parasites, name);
}

6
app/core/gimpparasite.h
View File

@ -21,9 +21,9 @@
#include "libgimp/parasiteF.h"
void gimp_init_parasites (void);
void gimp_attach_parasite (Parasite *p);
void gimp_detach_parasite (const char *name);
Parasite * gimp_find_parasite (const char *name);
void gimp_parasite_attach (Parasite *p);
void gimp_parasite_detach (const char *name);
Parasite * gimp_parasite_find (const char *name);
char ** gimp_parasite_list (gint *count);
void gimp_parasiterc_save (void);
void gimp_parasiterc_load (void);

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

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/core/gimpprojection-construct.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

2
app/cursorutil.h
View File

@ -21,7 +21,7 @@
#include <gdk/gdktypes.h>
#if defined (GDK_WINDOWING_WIN32) || defined (GDK_WINDOWING_X11)
/* Stopgap measure to detect build with current CVS GTk+ */
#include <gdk/gdkcursor.h>
//#include <gdk/gdkcursor.h>
#endif
typedef enum

2
app/curves.c
View File

@ -189,7 +189,7 @@ curves_colour_update (Tool *tool,
return;
sample_type = gimp_drawable_type(drawable);
is_indexed = gimp_drawable_indexed (drawable);
is_indexed = gimp_drawable_is_indexed (drawable);
has_alpha = TYPE_HAS_ALPHA(sample_type);
curves_dialog->col_value[HISTOGRAM_RED] = color[RED_PIX];

4
app/drawable.h
View File

@ -37,8 +37,8 @@ void drawable_apply_image (GimpDrawable *, gint, gint, gint, gint,
#define drawable_has_alpha gimp_drawable_has_alpha
#define drawable_type_with_alpha gimp_drawable_type_with_alpha
#define drawable_color gimp_drawable_color
#define drawable_gray gimp_drawable_gray
#define drawable_indexed gimp_drawable_indexed
#define drawable_gray gimp_drawable_is_gray
#define drawable_indexed gimp_drawable_is_indexed
#define drawable_data gimp_drawable_data
#define drawable_shadow gimp_drawable_shadow
#define drawable_bytes gimp_drawable_bytes

2
app/equalize.c
View File

@ -31,7 +31,7 @@ image_equalize (GimpImage *gimage)
drawable = gimage_active_drawable (gimage);
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
{
g_message (_("Equalize does not operate on indexed drawables."));
return;

8
app/gimage.h
View File

@ -102,10 +102,10 @@ void gimage_foreach (GFunc func,
#define gimage_base_type gimp_image_base_type
#define gimage_base_type_with_alpha gimp_image_base_type_with_alpha
#define gimage_filename gimp_image_filename
#define gimage_enable_undo gimp_image_enable_undo
#define gimage_disable_undo gimp_image_disable_undo
#define gimage_thaw_undo gimp_image_thaw_undo
#define gimage_freeze_undo gimp_image_freeze_undo
#define gimage_enable_undo gimp_image_undo_enable
#define gimage_disable_undo gimp_image_undo_disable
#define gimage_thaw_undo gimp_image_undo_thaw
#define gimage_freeze_undo gimp_image_undo_freeze
#define gimage_dirty gimp_image_dirty
#define gimage_clean gimp_image_clean
#define gimage_clean_all gimp_image_clean_all

114
app/gimage_cmds.c
View File

@ -32,7 +32,7 @@
#include "layer.h"
#include "layer_pvt.h"
static ProcRecord list_images_proc;
static ProcRecord image_list_proc;
static ProcRecord image_new_proc;
static ProcRecord image_resize_proc;
static ProcRecord image_scale_proc;
@ -61,10 +61,10 @@ static ProcRecord image_active_drawable_proc;
static ProcRecord image_base_type_proc;
static ProcRecord image_get_cmap_proc;
static ProcRecord image_set_cmap_proc;
static ProcRecord image_enable_undo_proc;
static ProcRecord image_disable_undo_proc;
static ProcRecord image_freeze_undo_proc;
static ProcRecord image_thaw_undo_proc;
static ProcRecord image_undo_enable_proc;
static ProcRecord image_undo_disable_proc;
static ProcRecord image_undo_freeze_proc;
static ProcRecord image_undo_thaw_proc;
static ProcRecord image_clean_all_proc;
static ProcRecord image_floating_selection_proc;
static ProcRecord image_floating_sel_attached_to_proc;
@ -92,7 +92,7 @@ static ProcRecord image_get_channel_by_tattoo_proc;
void
register_gimage_procs (void)
{
procedural_db_register (&list_images_proc);
procedural_db_register (&image_list_proc);
procedural_db_register (&image_new_proc);
procedural_db_register (&image_resize_proc);
procedural_db_register (&image_scale_proc);
@ -121,10 +121,10 @@ register_gimage_procs (void)
procedural_db_register (&image_base_type_proc);
procedural_db_register (&image_get_cmap_proc);
procedural_db_register (&image_set_cmap_proc);
procedural_db_register (&image_enable_undo_proc);
procedural_db_register (&image_disable_undo_proc);
procedural_db_register (&image_freeze_undo_proc);
procedural_db_register (&image_thaw_undo_proc);
procedural_db_register (&image_undo_enable_proc);
procedural_db_register (&image_undo_disable_proc);
procedural_db_register (&image_undo_freeze_proc);
procedural_db_register (&image_undo_thaw_proc);
procedural_db_register (&image_clean_all_proc);
procedural_db_register (&image_floating_selection_proc);
procedural_db_register (&image_floating_sel_attached_to_proc);
@ -161,7 +161,7 @@ gimlist_cb (gpointer im,
}
static Argument *
list_images_invoker (Argument *args)
image_list_invoker (Argument *args)
{
Argument *return_args;
gint32 num_images = 0;
@ -179,7 +179,7 @@ list_images_invoker (Argument *args)
image_ids[i] = pdb_image_to_id (GIMP_IMAGE (list->data));
}
return_args = procedural_db_return_args (&list_images_proc, TRUE);
return_args = procedural_db_return_args (&image_list_proc, TRUE);
return_args[1].value.pdb_int = num_images;
return_args[2].value.pdb_pointer = image_ids;
@ -187,7 +187,7 @@ list_images_invoker (Argument *args)
return return_args;
}
static ProcArg list_images_outargs[] =
static ProcArg image_list_outargs[] =
{
{
PDB_INT32,
@ -201,9 +201,9 @@ static ProcArg list_images_outargs[] =
}
};
static ProcRecord list_images_proc =
static ProcRecord image_list_proc =
{
"gimp_list_images",
"gimp_image_list",
"Returns the list of images currently open.",
"This procedure returns the list of images currently open in the GIMP.",
"Spencer Kimball & Peter Mattis",
@ -213,8 +213,8 @@ static ProcRecord list_images_proc =
0,
NULL,
2,
list_images_outargs,
{ { list_images_invoker } }
image_list_outargs,
{ { image_list_invoker } }
};
static Argument *
@ -1911,7 +1911,7 @@ static ProcRecord image_set_cmap_proc =
};
static Argument *
image_enable_undo_invoker (Argument *args)
image_undo_enable_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
@ -1924,7 +1924,7 @@ image_enable_undo_invoker (Argument *args)
if (success)
success = gimage_enable_undo (gimage);
return_args = procedural_db_return_args (&image_enable_undo_proc, success);
return_args = procedural_db_return_args (&image_undo_enable_proc, success);
if (success)
return_args[1].value.pdb_int = success ? TRUE : FALSE;
@ -1932,7 +1932,7 @@ image_enable_undo_invoker (Argument *args)
return return_args;
}
static ProcArg image_enable_undo_inargs[] =
static ProcArg image_undo_enable_inargs[] =
{
{
PDB_IMAGE,
@ -1941,7 +1941,7 @@ static ProcArg image_enable_undo_inargs[] =
}
};
static ProcArg image_enable_undo_outargs[] =
static ProcArg image_undo_enable_outargs[] =
{
{
PDB_INT32,
@ -1950,24 +1950,24 @@ static ProcArg image_enable_undo_outargs[] =
}
};
static ProcRecord image_enable_undo_proc =
static ProcRecord image_undo_enable_proc =
{
"gimp_image_enable_undo",
"gimp_image_undo_enable",
"Enable the image's undo stack.",
"This procedure enables the image's undo stack, allowing subsequent operations to store their undo steps. This is generally called in conjunction with 'gimp_image_disable_undo' to temporarily disable an image undo stack.",
"This procedure enables the image's undo stack, allowing subsequent operations to store their undo steps. This is generally called in conjunction with 'gimp_image_undo_disable' to temporarily disable an image undo stack.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
PDB_INTERNAL,
1,
image_enable_undo_inargs,
image_undo_enable_inargs,
1,
image_enable_undo_outargs,
{ { image_enable_undo_invoker } }
image_undo_enable_outargs,
{ { image_undo_enable_invoker } }
};
static Argument *
image_disable_undo_invoker (Argument *args)
image_undo_disable_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
@ -1980,7 +1980,7 @@ image_disable_undo_invoker (Argument *args)
if (success)
success = gimage_disable_undo (gimage);
return_args = procedural_db_return_args (&image_disable_undo_proc, success);
return_args = procedural_db_return_args (&image_undo_disable_proc, success);
if (success)
return_args[1].value.pdb_int = success ? TRUE : FALSE;
@ -1988,7 +1988,7 @@ image_disable_undo_invoker (Argument *args)
return return_args;
}
static ProcArg image_disable_undo_inargs[] =
static ProcArg image_undo_disable_inargs[] =
{
{
PDB_IMAGE,
@ -1997,7 +1997,7 @@ static ProcArg image_disable_undo_inargs[] =
}
};
static ProcArg image_disable_undo_outargs[] =
static ProcArg image_undo_disable_outargs[] =
{
{
PDB_INT32,
@ -2006,24 +2006,24 @@ static ProcArg image_disable_undo_outargs[] =
}
};
static ProcRecord image_disable_undo_proc =
static ProcRecord image_undo_disable_proc =
{
"gimp_image_disable_undo",
"gimp_image_undo_disable",
"Disable the image's undo stack.",
"This procedure disables the image's undo stack, allowing subsequent operations to ignore their undo steps. This is generally called in conjunction with 'gimp_image_enable_undo' to temporarily disable an image undo stack. This is advantageous because saving undo steps can be time and memory intensive.",
"This procedure disables the image's undo stack, allowing subsequent operations to ignore their undo steps. This is generally called in conjunction with 'gimp_image_undo_enable' to temporarily disable an image undo stack. This is advantageous because saving undo steps can be time and memory intensive.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
PDB_INTERNAL,
1,
image_disable_undo_inargs,
image_undo_disable_inargs,
1,
image_disable_undo_outargs,
{ { image_disable_undo_invoker } }
image_undo_disable_outargs,
{ { image_undo_disable_invoker } }
};
static Argument *
image_freeze_undo_invoker (Argument *args)
image_undo_freeze_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
@ -2036,7 +2036,7 @@ image_freeze_undo_invoker (Argument *args)
if (success)
success = gimage_freeze_undo (gimage);
return_args = procedural_db_return_args (&image_freeze_undo_proc, success);
return_args = procedural_db_return_args (&image_undo_freeze_proc, success);
if (success)
return_args[1].value.pdb_int = success ? TRUE : FALSE;
@ -2044,7 +2044,7 @@ image_freeze_undo_invoker (Argument *args)
return return_args;
}
static ProcArg image_freeze_undo_inargs[] =
static ProcArg image_undo_freeze_inargs[] =
{
{
PDB_IMAGE,
@ -2053,7 +2053,7 @@ static ProcArg image_freeze_undo_inargs[] =
}
};
static ProcArg image_freeze_undo_outargs[] =
static ProcArg image_undo_freeze_outargs[] =
{
{
PDB_INT32,
@ -2062,24 +2062,24 @@ static ProcArg image_freeze_undo_outargs[] =
}
};
static ProcRecord image_freeze_undo_proc =
static ProcRecord image_undo_freeze_proc =
{
"gimp_image_freeze_undo",
"gimp_image_undo_freeze",
"Freeze the image's undo stack.",
"This procedure freezes the image's undo stack, allowing subsequent operations to ignore their undo steps. This is generally called in conjunction with 'gimp_image_thaw_undo' to temporarily disable an image undo stack. This is advantageous because saving undo steps can be time and memory intensive. 'gimp_image_{freeze,thaw}_undo' and 'gimp_image_{disable,enable}_undo' differ in that the former does not free up all undo steps when undo is thawed, so is more suited to interactive in-situ previews. It is important in this case that the image is back to the same state it was frozen in before thawing, else 'undo' behaviour is undefined.",
"This procedure freezes the image's undo stack, allowing subsequent operations to ignore their undo steps. This is generally called in conjunction with 'gimp_image_undo_thaw' to temporarily disable an image undo stack. This is advantageous because saving undo steps can be time and memory intensive. 'gimp_image_undo_{freeze,thaw}' and 'gimp_image_undo_{disable,enable}' differ in that the former does not free up all undo steps when undo is thawed, so is more suited to interactive in-situ previews. It is important in this case that the image is back to the same state it was frozen in before thawing, else 'undo' behaviour is undefined.",
"Adam D. Moss",
"Adam D. Moss",
"1999",
PDB_INTERNAL,
1,
image_freeze_undo_inargs,
image_undo_freeze_inargs,
1,
image_freeze_undo_outargs,
{ { image_freeze_undo_invoker } }
image_undo_freeze_outargs,
{ { image_undo_freeze_invoker } }
};
static Argument *
image_thaw_undo_invoker (Argument *args)
image_undo_thaw_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
@ -2092,7 +2092,7 @@ image_thaw_undo_invoker (Argument *args)
if (success)
success = gimage_thaw_undo (gimage);
return_args = procedural_db_return_args (&image_thaw_undo_proc, success);
return_args = procedural_db_return_args (&image_undo_thaw_proc, success);
if (success)
return_args[1].value.pdb_int = success ? TRUE : FALSE;
@ -2100,7 +2100,7 @@ image_thaw_undo_invoker (Argument *args)
return return_args;
}
static ProcArg image_thaw_undo_inargs[] =
static ProcArg image_undo_thaw_inargs[] =
{
{
PDB_IMAGE,
@ -2109,7 +2109,7 @@ static ProcArg image_thaw_undo_inargs[] =
}
};
static ProcArg image_thaw_undo_outargs[] =
static ProcArg image_undo_thaw_outargs[] =
{
{
PDB_INT32,
@ -2118,20 +2118,20 @@ static ProcArg image_thaw_undo_outargs[] =
}
};
static ProcRecord image_thaw_undo_proc =
static ProcRecord image_undo_thaw_proc =
{
"gimp_image_thaw_undo",
"gimp_image_undo_thaw",
"Thaw the image's undo stack.",
"This procedure thaws the image's undo stack, allowing subsequent operations to store their undo steps. This is generally called in conjunction with 'gimp_image_disable_freeze' to temporarily freeze an image undo stack. 'gimp_image_thaw_undo' does NOT free the undo stack as 'gimp_image_enable_undo' does, so is suited for situations where one wishes to leave the undo stack in the same state in which one found it despite non-destructively playing with the image in the meantime. An example would be in-situ plugin previews. Balancing freezes and thaws and ensuring image consistancy is the responsibility of the caller.",
"This procedure thaws the image's undo stack, allowing subsequent operations to store their undo steps. This is generally called in conjunction with 'gimp_image_undo_freeze' to temporarily freeze an image undo stack. 'gimp_image_undo_thaw' does NOT free the undo stack as 'gimp_image_undo_enable' does, so is suited for situations where one wishes to leave the undo stack in the same state in which one found it despite non-destructively playing with the image in the meantime. An example would be in-situ plugin previews. Balancing freezes and thaws and ensuring image consistancy is the responsibility of the caller.",
"Adam D. Moss",
"Adam D. Moss",
"1999",
PDB_INTERNAL,
1,
image_thaw_undo_inargs,
image_undo_thaw_inargs,
1,
image_thaw_undo_outargs,
{ { image_thaw_undo_invoker } }
image_undo_thaw_outargs,
{ { image_undo_thaw_invoker } }
};
static Argument *

2
app/gimpdrawable-equalize.c
View File

@ -31,7 +31,7 @@ image_equalize (GimpImage *gimage)
drawable = gimage_active_drawable (gimage);
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
{
g_message (_("Equalize does not operate on indexed drawables."));
return;

2
app/gimpdrawable-invert.c
View File

@ -38,7 +38,7 @@ image_invert (GimpImage *gimage)
drawable = gimage_active_drawable (gimage);
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
{
g_message (_("Invert does not operate on indexed drawables."));
return;

20
app/gimpdrawable.c
View File

@ -407,7 +407,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable,
guchar *dest;
if (!drawable ||
(!gimp_drawable_gimage (drawable) && gimp_drawable_indexed (drawable))
(!gimp_drawable_gimage (drawable) && gimp_drawable_is_indexed (drawable))
|| x < 0 || y < 0 ||
x >= drawable->width || y >= drawable->height)
{
@ -423,7 +423,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable,
dest[3] = src[gimp_drawable_bytes (drawable) - 1];
else
dest[3] = 255;
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
dest[4] = src[0];
else
dest[4] = 0;
@ -432,7 +432,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable,
}
Parasite *
gimp_drawable_find_parasite (const GimpDrawable *drawable,
gimp_drawable_parasite_find (const GimpDrawable *drawable,
const gchar *name)
{
return parasite_list_find (drawable->parasites, name);
@ -461,7 +461,7 @@ gimp_drawable_parasite_list (GimpDrawable *drawable,
}
void
gimp_drawable_attach_parasite (GimpDrawable *drawable,
gimp_drawable_parasite_attach (GimpDrawable *drawable,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -475,7 +475,7 @@ gimp_drawable_attach_parasite (GimpDrawable *drawable,
}
else if (parasite_is_persistent(parasite) &&
!parasite_compare( parasite,
gimp_drawable_find_parasite
gimp_drawable_parasite_find
(drawable, parasite_name (parasite))))
undo_push_cantundo (drawable->gimage, _("parasite attach to drawable"));
@ -483,13 +483,13 @@ gimp_drawable_attach_parasite (GimpDrawable *drawable,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_image_attach_parasite (drawable->gimage, parasite);
gimp_image_parasite_attach (drawable->gimage, parasite);
}
else if (parasite_has_flag (parasite, PARASITE_ATTACH_GRANDPARENT))
{
parasite_shift_parent (parasite);
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
if (parasite_is_undoable (parasite))
{
@ -498,7 +498,7 @@ gimp_drawable_attach_parasite (GimpDrawable *drawable,
}
void
gimp_drawable_detach_parasite (GimpDrawable *drawable,
gimp_drawable_parasite_detach (GimpDrawable *drawable,
const gchar *parasite)
{
Parasite *p;
@ -532,7 +532,7 @@ gimp_drawable_color (GimpDrawable *drawable)
}
gboolean
gimp_drawable_gray (GimpDrawable *drawable)
gimp_drawable_is_gray (GimpDrawable *drawable)
{
if (gimp_drawable_type (drawable) == GRAYA_GIMAGE ||
gimp_drawable_type (drawable) == GRAY_GIMAGE)
@ -542,7 +542,7 @@ gimp_drawable_gray (GimpDrawable *drawable)
}
gboolean
gimp_drawable_indexed (GimpDrawable *drawable)
gimp_drawable_is_indexed (GimpDrawable *drawable)
{
if (gimp_drawable_type (drawable) == INDEXEDA_GIMAGE ||
gimp_drawable_type (drawable) == INDEXED_GIMAGE)

12
app/gimpdrawable.h
View File

@ -51,8 +51,8 @@ gboolean gimp_drawable_has_alpha (GimpDrawable *);
GimpImageType gimp_drawable_type (GimpDrawable *);
GimpImageType gimp_drawable_type_with_alpha (GimpDrawable *);
gboolean gimp_drawable_color (GimpDrawable *);
gboolean gimp_drawable_gray (GimpDrawable *);
gboolean gimp_drawable_indexed (GimpDrawable *);
gboolean gimp_drawable_is_gray (GimpDrawable *);
gboolean gimp_drawable_is_indexed (GimpDrawable *);
TileManager * gimp_drawable_data (GimpDrawable *);
TileManager * gimp_drawable_shadow (GimpDrawable *);
gint gimp_drawable_bytes (GimpDrawable *);
@ -69,12 +69,10 @@ void gimp_drawable_set_name (GimpDrawable *, gchar *);
guchar * gimp_drawable_get_color_at (GimpDrawable *,
gint x, gint y);
Parasite * gimp_drawable_find_parasite (const GimpDrawable *,
const gchar *name);
void gimp_drawable_attach_parasite (GimpDrawable *, Parasite *);
void gimp_drawable_detach_parasite (GimpDrawable *,
void gimp_drawable_parasite_attach (GimpDrawable *, Parasite *);
void gimp_drawable_parasite_detach (GimpDrawable *,
const gchar *);
Parasite * gimp_drawable_find_parasite (const GimpDrawable *,
Parasite * gimp_drawable_parasite_find (const GimpDrawable *,
const gchar *);
gchar ** gimp_drawable_parasite_list (GimpDrawable *drawable,
gint *count);

22
app/gimpimage.c
View File

@ -1079,7 +1079,7 @@ gimp_image_delete_guide (GimpImage *gimage,
Parasite *
gimp_image_find_parasite (const GimpImage *gimage,
gimp_image_parasite_find (const GimpImage *gimage,
const gchar *name)
{
return parasite_list_find (gimage->parasites, name);
@ -1108,7 +1108,7 @@ gimp_image_parasite_list (GimpImage *image,
}
void
gimp_image_attach_parasite (GimpImage *gimage,
gimp_image_parasite_attach (GimpImage *gimage,
Parasite *parasite)
{
/* only set the dirty bit manually if we can be saved and the new
@ -1117,7 +1117,7 @@ gimp_image_attach_parasite (GimpImage *gimage,
undo_push_image_parasite (gimage, parasite);
if (parasite_is_persistent (parasite)
&& !parasite_compare (parasite,
gimp_image_find_parasite(gimage,
gimp_image_parasite_find(gimage,
parasite_name(parasite))))
undo_push_cantundo (gimage, _("attach parasite to image"));
@ -1126,12 +1126,12 @@ gimp_image_attach_parasite (GimpImage *gimage,
if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
{
parasite_shift_parent (parasite);
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
}
}
void
gimp_image_detach_parasite (GimpImage *gimage,
gimp_image_parasite_detach (GimpImage *gimage,
const gchar *parasite)
{
Parasite *p;
@ -3149,7 +3149,7 @@ gimp_image_filename (GimpImage *gimage)
}
gboolean
gimp_image_freeze_undo (GimpImage *gimage)
gimp_image_undo_freeze (GimpImage *gimage)
{
gimage->undo_on = FALSE;
@ -3157,7 +3157,7 @@ gimp_image_freeze_undo (GimpImage *gimage)
}
gboolean
gimp_image_thaw_undo (GimpImage *gimage)
gimp_image_undo_thaw (GimpImage *gimage)
{
gimage->undo_on = TRUE;
@ -3165,18 +3165,18 @@ gimp_image_thaw_undo (GimpImage *gimage)
}
gboolean
gimp_image_disable_undo (GimpImage *gimage)
gimp_image_undo_disable (GimpImage *gimage)
{
return gimp_image_freeze_undo (gimage);
return gimp_image_undo_freeze (gimage);
}
gboolean
gimp_image_enable_undo (GimpImage *gimage)
gimp_image_undo_enable (GimpImage *gimage)
{
/* Free all undo steps as they are now invalidated */
undo_free (gimage);
return gimp_image_thaw_undo (gimage);
return gimp_image_undo_thaw (gimage);
}
void

14
app/gimpimage.h
View File

@ -160,12 +160,12 @@ void gimp_image_add_guide (GimpImage *, Guide *);
void gimp_image_remove_guide (GimpImage *, Guide *);
void gimp_image_delete_guide (GimpImage *, Guide *);
Parasite * gimp_image_find_parasite (const GimpImage *,
Parasite * gimp_image_parasite_find (const GimpImage *,
const gchar *name);
gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
void gimp_image_attach_parasite (GimpImage *, Parasite *);
void gimp_image_detach_parasite (GimpImage *, const gchar *);
void gimp_image_parasite_attach (GimpImage *, Parasite *);
void gimp_image_parasite_detach (GimpImage *, const gchar *);
Tattoo gimp_image_get_new_tattoo (GimpImage *);
@ -248,10 +248,10 @@ GimpDrawable * gimp_image_active_drawable (GimpImage *);
GimpImageBaseType gimp_image_base_type (GimpImage *);
GimpImageType gimp_image_base_type_with_alpha (GimpImage *);
gchar * gimp_image_filename (GimpImage *);
gboolean gimp_image_enable_undo (GimpImage *);
gboolean gimp_image_disable_undo (GimpImage *);
gboolean gimp_image_freeze_undo (GimpImage *);
gboolean gimp_image_thaw_undo (GimpImage *);
gboolean gimp_image_undo_enable (GimpImage *);
gboolean gimp_image_undo_disable (GimpImage *);
gboolean gimp_image_undo_freeze (GimpImage *);
gboolean gimp_image_undo_thaw (GimpImage *);
void gimp_image_undo_event (GimpImage *, int);
gint gimp_image_dirty (GimpImage *);
gint gimp_image_clean (GimpImage *);

6
app/gimpparasite.c
View File

@ -42,19 +42,19 @@ gimp_init_parasites()
}
void
gimp_attach_parasite (Parasite *p)
gimp_parasite_attach (Parasite *p)
{
parasite_list_add(parasites, p);
}
void
gimp_detach_parasite (const char *name)
gimp_parasite_detach (const char *name)
{
parasite_list_remove(parasites, name);
}
Parasite *
gimp_find_parasite (const char *name)
gimp_parasite_find (const char *name)
{
return parasite_list_find(parasites, name);
}

6
app/gimpparasite.h
View File

@ -21,9 +21,9 @@
#include "libgimp/parasiteF.h"
void gimp_init_parasites (void);
void gimp_attach_parasite (Parasite *p);
void gimp_detach_parasite (const char *name);
Parasite * gimp_find_parasite (const char *name);
void gimp_parasite_attach (Parasite *p);
void gimp_parasite_detach (const char *name);
Parasite * gimp_parasite_find (const char *name);
char ** gimp_parasite_list (gint *count);
void gimp_parasiterc_save (void);
void gimp_parasiterc_load (void);

2
app/gimprc.c
View File

@ -2315,7 +2315,7 @@ parse_parasite (gpointer val1p,
if (token != TOKEN_STRING)
goto error;
gimp_attach_parasite (parasite_new (identifier, flags, token_int, token_str));
gimp_parasite_attach (parasite_new (identifier, flags, token_int, token_str));
token = get_next_token ();
if (token != TOKEN_RIGHT_PAREN)

256
app/gui/palette-editor.c
View File

@ -74,6 +74,7 @@ typedef enum
{
GRAD_IMPORT = 0,
IMAGE_IMPORT = 1,
INDEXED_IMPORT = 2,
} ImportType;
typedef struct _ImportDialog ImportDialog;
@ -87,6 +88,7 @@ struct _ImportDialog
GtkWidget *select;
GtkWidget *image_list;
GtkWidget *image_menu_item_image;
GtkWidget *image_menu_item_indexed;
GtkWidget *image_menu_item_gradient;
GtkWidget *optionmenu1_menu;
GtkWidget *type_option;
@ -151,6 +153,9 @@ static void palette_scroll_top_left (PaletteDialog *palette);
static ImportDialog * palette_import_dialog (PaletteDialog *palette);
static void palette_import_dialog_callback (GtkWidget *, gpointer);
static void import_palette_create_from_indexed (GImage *gimage,
guchar *pname,
PaletteDialog *palette);
static void import_palette_create_from_image (GImage *gimage,
guchar *pname,
PaletteDialog *palette);
@ -2420,6 +2425,10 @@ import_dialog_import_callback (GtkWidget *widget,
import_palette_create_from_image (import_dialog->gimage,
pname, palette);
break;
case INDEXED_IMPORT:
import_palette_create_from_indexed (import_dialog->gimage,
pname, palette);
break;
default:
break;
}
@ -2589,6 +2598,19 @@ gimlist_cb (gpointer im,
*l = g_slist_prepend (*l, im);
}
static void
gimlist_indexed_cb (gpointer im,
gpointer data)
{
GimpImage *gimage = GIMP_IMAGE (im);
GSList** l;
if (gimage_base_type (gimage) == INDEXED) {
l = (GSList**) data;
*l = g_slist_prepend (*l, im);
}
}
static void
import_image_update_image_preview (GimpImage *gimage)
{
@ -2690,7 +2712,7 @@ import_image_menu_add (GimpImage *gimage)
/* Last Param gives us control over what goes in the menu on a delete oper */
static void
import_image_menu_activate (gint redo,
import_image_menu_activate (gint redo, ImportType type,
GimpImage *del_image)
{
GSList *list=NULL;
@ -2701,105 +2723,123 @@ import_image_menu_activate (gint redo,
gint count = 0;
gchar *lab;
if (import_dialog)
if (!import_dialog)
return;
if (import_dialog->import_type == type && !redo)
return;
/* Destroy existing widget if necessary */
if (import_dialog->image_list)
{
if (import_dialog->import_type == IMAGE_IMPORT)
{
if (!redo)
return;
else
{
if (import_dialog->image_list)
{
last_img = import_dialog->gimage;
gtk_widget_hide (import_dialog->image_list);
gtk_widget_destroy (import_dialog->image_list);
import_dialog->image_list = NULL;
}
}
}
import_dialog->import_type = IMAGE_IMPORT;
if (redo) /* Preserve settings in this case */
last_img = import_dialog->gimage;
gtk_widget_hide (import_dialog->image_list);
gtk_widget_destroy (import_dialog->image_list);
import_dialog->image_list = NULL;
}
/* Get list of images */
import_dialog->import_type= type;
/* Get list of images */
if (import_dialog->import_type == INDEXED_IMPORT)
{
gimage_foreach (gimlist_indexed_cb, &list);
}
else
{
gimage_foreach (gimlist_cb, &list);
num_images = g_slist_length (list);
}
num_images = g_slist_length (list);
if (num_images)
{
gint i;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
if (num_images)
{
gint i;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();
import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();
for (i = 0; i < num_images; i++, list = g_slist_next (list))
{
if (GIMP_IMAGE (list->data) != del_image)
{
if (first_img == NULL)
first_img = GIMP_IMAGE (list->data);
import_image_menu_add (GIMP_IMAGE (list->data));
if (last_img == GIMP_IMAGE (list->data))
act_num = count;
else
count++;
}
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
optionmenu1_menu);
gtk_widget_hide (import_dialog->select);
gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
optionmenu1, FALSE, FALSE, 0);
if(last_img != NULL && last_img != del_image)
import_image_update_image_preview (last_img);
else if (first_img != NULL)
import_image_update_image_preview (first_img);
gtk_widget_show (optionmenu1);
/* reset to last one */
if(redo && act_num >= 0)
{
gchar *lab =
g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
for (i = 0; i < num_images; i++, list = g_slist_next (list))
{
if (GIMP_IMAGE (list->data) != del_image)
{
if (first_img == NULL)
first_img = GIMP_IMAGE (list->data);
import_image_menu_add (GIMP_IMAGE (list->data));
if (last_img == GIMP_IMAGE (list->data))
act_num = count;
else
count++;
}
}
g_slist_free (list);
lab =
g_strdup_printf ("%s-%d",
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
optionmenu1_menu);
gtk_widget_hide (import_dialog->select);
gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
optionmenu1, FALSE, FALSE, 0);
if(last_img != NULL && last_img != del_image)
import_image_update_image_preview (last_img);
else if (first_img != NULL)
import_image_update_image_preview (first_img);
gtk_widget_show (optionmenu1);
/* reset to last one */
if (redo && act_num >= 0)
{
gchar *lab = g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}
}
g_slist_free (list);
lab = g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}
static void
import_image_callback (GtkWidget *widget,
gpointer data)
{
import_image_menu_activate (FALSE, NULL);
import_image_menu_activate (FALSE, IMAGE_IMPORT, NULL);
gtk_widget_set_sensitive (import_dialog->threshold_scale, TRUE);
gtk_widget_set_sensitive (import_dialog->threshold_text, TRUE);
}
static void
import_indexed_callback (GtkWidget *widget,
gpointer data)
{
import_image_menu_activate (FALSE, INDEXED_IMPORT, NULL);
gtk_widget_set_sensitive (import_dialog->threshold_scale, FALSE);
gtk_widget_set_sensitive (import_dialog->threshold_text, FALSE);
}
static gint
image_count ()
image_count (ImportType type)
{
GSList *list=NULL;
gint num_images = 0;
gimage_foreach (gimlist_cb, &list);
if (type == INDEXED_IMPORT) {
gimage_foreach (gimlist_indexed_cb, &list);
} else {
gimage_foreach (gimlist_cb, &list);
}
num_images = g_slist_length (list);
g_slist_free (list);
@ -2903,9 +2943,18 @@ palette_import_dialog (PaletteDialog *palette)
(gpointer) import_dialog);
gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_set_sensitive (menuitem, image_count(IMAGE_IMPORT) > 0);
menuitem = import_dialog->image_menu_item_indexed =
gtk_menu_item_new_with_label ("Indexed Palette");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) import_indexed_callback,
(gpointer) import_dialog);
gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_set_sensitive (menuitem, image_count(INDEXED_IMPORT) > 0);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), optionmenu_menu);
gtk_widget_set_sensitive (menuitem, image_count() > 0);
gtk_widget_show (optionmenu);
/* The sample size */
@ -2985,10 +3034,18 @@ palette_import_image_new (GimpImage * gimage)
return;
}
/* Now fill in the names if image menu shown */
if (import_dialog->import_type == IMAGE_IMPORT)
if (!GTK_WIDGET_IS_SENSITIVE (import_dialog->image_menu_item_indexed) &&
gimage_base_type(gimage) == INDEXED)
{
import_image_menu_activate (TRUE, NULL);
gtk_widget_set_sensitive (import_dialog->image_menu_item_indexed, TRUE);
return;
}
/* Now fill in the names if image menu shown */
if (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT)
{
import_image_menu_activate (TRUE, import_dialog->import_type, NULL);
}
}
@ -3000,7 +3057,7 @@ palette_import_image_destroyed (GimpImage* gimage)
if (!import_dialog)
return;
if (image_count() <= 1)
if (image_count(import_dialog->import_type) <= 1)
{
/* Back to gradient type */
gtk_option_menu_set_history (GTK_OPTION_MENU (import_dialog->type_option), 0);
@ -3010,9 +3067,10 @@ palette_import_image_destroyed (GimpImage* gimage)
return;
}
if (import_dialog->import_type == IMAGE_IMPORT)
if (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT)
{
import_image_menu_activate (TRUE, gimage);
import_image_menu_activate (TRUE, import_dialog->import_type, gimage);
}
}
@ -3020,9 +3078,10 @@ void
palette_import_image_renamed (GimpImage* gimage)
{
/* Now fill in the names if image menu shown */
if(import_dialog && import_dialog->import_type == IMAGE_IMPORT)
if (import_dialog && (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT))
{
import_image_menu_activate (TRUE, NULL);
import_image_menu_activate (TRUE, import_dialog->import_type, NULL);
}
}
@ -3279,3 +3338,38 @@ import_palette_create_from_image (GImage *gimage,
/* Make palette from the store_array */
import_image_make_palette (store_array, pname, palette);
}
static void
import_palette_create_from_indexed (GImage *gimage,
guchar *pname,
PaletteDialog *palette)
{
gint samples, count;
PaletteEntriesP entries;
samples = (gint) import_dialog->sample->value;
if (gimage == NULL)
return;
if (gimage_base_type (gimage) != INDEXED)
return;
entries= palette_create_entries (palette, pname);
for (count= 0; count < samples && count < gimage->num_cols; ++count)
{
palette_add_entry (entries, NULL, gimage->cmap[count*3],
gimage->cmap[count*3+1],
gimage->cmap[count*3+2]);
}
/* Redraw with new palette */
palette_update_small_preview (palette);
redraw_palette (palette);
/* Update other selectors on screen */
palette_select_clist_insert_all (entries);
palette_select2_clist_insert_all (entries);
palette_scroll_clist_to_current (palette);
}

4
app/image_map.c
View File

@ -320,7 +320,7 @@ image_map_get_color_at (ImageMap image_map, int x, int y)
if (!image_map ||
(!gimp_drawable_gimage(_image_map->drawable) &&
gimp_drawable_indexed(_image_map->drawable)) ||
gimp_drawable_is_indexed(_image_map->drawable)) ||
x < 0 || y < 0 ||
x >= _image_map->undo_tiles->width ||
y >= _image_map->undo_tiles->height)
@ -342,7 +342,7 @@ image_map_get_color_at (ImageMap image_map, int x, int y)
dest[3] = src[gimp_drawable_bytes (_image_map->drawable) - 1];
else
dest[3] = 255;
if (gimp_drawable_indexed(_image_map->drawable))
if (gimp_drawable_is_indexed(_image_map->drawable))
dest[4] = src[0];
else
dest[4] = 0;

4
app/image_new.c
View File

@ -226,9 +226,9 @@ image_new_create_image (const GimpImageNewValues *values)
if (layer)
{
/* add the new layer to the gimage */
gimp_image_disable_undo (image);
gimp_image_undo_disable (image);
gimp_image_add_layer (image, layer, 0);
gimp_image_enable_undo (image);
gimp_image_undo_enable (image);
drawable_fill (GIMP_DRAWABLE (layer), values->fill_type);

2
app/invert.c
View File

@ -38,7 +38,7 @@ image_invert (GimpImage *gimage)
drawable = gimage_active_drawable (gimage);
if (gimp_drawable_indexed (drawable))
if (gimp_drawable_is_indexed (drawable))
{
g_message (_("Invert does not operate on indexed drawables."));
return;

256
app/palette.c
View File

@ -74,6 +74,7 @@ typedef enum
{
GRAD_IMPORT = 0,
IMAGE_IMPORT = 1,
INDEXED_IMPORT = 2,
} ImportType;
typedef struct _ImportDialog ImportDialog;
@ -87,6 +88,7 @@ struct _ImportDialog
GtkWidget *select;
GtkWidget *image_list;
GtkWidget *image_menu_item_image;
GtkWidget *image_menu_item_indexed;
GtkWidget *image_menu_item_gradient;
GtkWidget *optionmenu1_menu;
GtkWidget *type_option;
@ -151,6 +153,9 @@ static void palette_scroll_top_left (PaletteDialog *palette);
static ImportDialog * palette_import_dialog (PaletteDialog *palette);
static void palette_import_dialog_callback (GtkWidget *, gpointer);
static void import_palette_create_from_indexed (GImage *gimage,
guchar *pname,
PaletteDialog *palette);
static void import_palette_create_from_image (GImage *gimage,
guchar *pname,
PaletteDialog *palette);
@ -2420,6 +2425,10 @@ import_dialog_import_callback (GtkWidget *widget,
import_palette_create_from_image (import_dialog->gimage,
pname, palette);
break;
case INDEXED_IMPORT:
import_palette_create_from_indexed (import_dialog->gimage,
pname, palette);
break;
default:
break;
}
@ -2589,6 +2598,19 @@ gimlist_cb (gpointer im,
*l = g_slist_prepend (*l, im);
}
static void
gimlist_indexed_cb (gpointer im,
gpointer data)
{
GimpImage *gimage = GIMP_IMAGE (im);
GSList** l;
if (gimage_base_type (gimage) == INDEXED) {
l = (GSList**) data;
*l = g_slist_prepend (*l, im);
}
}
static void
import_image_update_image_preview (GimpImage *gimage)
{
@ -2690,7 +2712,7 @@ import_image_menu_add (GimpImage *gimage)
/* Last Param gives us control over what goes in the menu on a delete oper */
static void
import_image_menu_activate (gint redo,
import_image_menu_activate (gint redo, ImportType type,
GimpImage *del_image)
{
GSList *list=NULL;
@ -2701,105 +2723,123 @@ import_image_menu_activate (gint redo,
gint count = 0;
gchar *lab;
if (import_dialog)
if (!import_dialog)
return;
if (import_dialog->import_type == type && !redo)
return;
/* Destroy existing widget if necessary */
if (import_dialog->image_list)
{
if (import_dialog->import_type == IMAGE_IMPORT)
{
if (!redo)
return;
else
{
if (import_dialog->image_list)
{
last_img = import_dialog->gimage;
gtk_widget_hide (import_dialog->image_list);
gtk_widget_destroy (import_dialog->image_list);
import_dialog->image_list = NULL;
}
}
}
import_dialog->import_type = IMAGE_IMPORT;
if (redo) /* Preserve settings in this case */
last_img = import_dialog->gimage;
gtk_widget_hide (import_dialog->image_list);
gtk_widget_destroy (import_dialog->image_list);
import_dialog->image_list = NULL;
}
/* Get list of images */
import_dialog->import_type= type;
/* Get list of images */
if (import_dialog->import_type == INDEXED_IMPORT)
{
gimage_foreach (gimlist_indexed_cb, &list);
}
else
{
gimage_foreach (gimlist_cb, &list);
num_images = g_slist_length (list);
}
num_images = g_slist_length (list);
if (num_images)
{
gint i;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
if (num_images)
{
gint i;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();
import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();
for (i = 0; i < num_images; i++, list = g_slist_next (list))
{
if (GIMP_IMAGE (list->data) != del_image)
{
if (first_img == NULL)
first_img = GIMP_IMAGE (list->data);
import_image_menu_add (GIMP_IMAGE (list->data));
if (last_img == GIMP_IMAGE (list->data))
act_num = count;
else
count++;
}
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
optionmenu1_menu);
gtk_widget_hide (import_dialog->select);
gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
optionmenu1, FALSE, FALSE, 0);
if(last_img != NULL && last_img != del_image)
import_image_update_image_preview (last_img);
else if (first_img != NULL)
import_image_update_image_preview (first_img);
gtk_widget_show (optionmenu1);
/* reset to last one */
if(redo && act_num >= 0)
{
gchar *lab =
g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
for (i = 0; i < num_images; i++, list = g_slist_next (list))
{
if (GIMP_IMAGE (list->data) != del_image)
{
if (first_img == NULL)
first_img = GIMP_IMAGE (list->data);
import_image_menu_add (GIMP_IMAGE (list->data));
if (last_img == GIMP_IMAGE (list->data))
act_num = count;
else
count++;
}
}
g_slist_free (list);
lab =
g_strdup_printf ("%s-%d",
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
optionmenu1_menu);
gtk_widget_hide (import_dialog->select);
gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
optionmenu1, FALSE, FALSE, 0);
if(last_img != NULL && last_img != del_image)
import_image_update_image_preview (last_img);
else if (first_img != NULL)
import_image_update_image_preview (first_img);
gtk_widget_show (optionmenu1);
/* reset to last one */
if (redo && act_num >= 0)
{
gchar *lab = g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}
}
g_slist_free (list);
lab = g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}
static void
import_image_callback (GtkWidget *widget,
gpointer data)
{
import_image_menu_activate (FALSE, NULL);
import_image_menu_activate (FALSE, IMAGE_IMPORT, NULL);
gtk_widget_set_sensitive (import_dialog->threshold_scale, TRUE);
gtk_widget_set_sensitive (import_dialog->threshold_text, TRUE);
}
static void
import_indexed_callback (GtkWidget *widget,
gpointer data)
{
import_image_menu_activate (FALSE, INDEXED_IMPORT, NULL);
gtk_widget_set_sensitive (import_dialog->threshold_scale, FALSE);
gtk_widget_set_sensitive (import_dialog->threshold_text, FALSE);
}
static gint
image_count ()
image_count (ImportType type)
{
GSList *list=NULL;
gint num_images = 0;
gimage_foreach (gimlist_cb, &list);
if (type == INDEXED_IMPORT) {
gimage_foreach (gimlist_indexed_cb, &list);
} else {
gimage_foreach (gimlist_cb, &list);
}
num_images = g_slist_length (list);
g_slist_free (list);
@ -2903,9 +2943,18 @@ palette_import_dialog (PaletteDialog *palette)
(gpointer) import_dialog);
gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_set_sensitive (menuitem, image_count(IMAGE_IMPORT) > 0);
menuitem = import_dialog->image_menu_item_indexed =
gtk_menu_item_new_with_label ("Indexed Palette");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) import_indexed_callback,
(gpointer) import_dialog);
gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_set_sensitive (menuitem, image_count(INDEXED_IMPORT) > 0);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), optionmenu_menu);
gtk_widget_set_sensitive (menuitem, image_count() > 0);
gtk_widget_show (optionmenu);
/* The sample size */
@ -2985,10 +3034,18 @@ palette_import_image_new (GimpImage * gimage)
return;
}
/* Now fill in the names if image menu shown */
if (import_dialog->import_type == IMAGE_IMPORT)
if (!GTK_WIDGET_IS_SENSITIVE (import_dialog->image_menu_item_indexed) &&
gimage_base_type(gimage) == INDEXED)
{
import_image_menu_activate (TRUE, NULL);
gtk_widget_set_sensitive (import_dialog->image_menu_item_indexed, TRUE);
return;
}
/* Now fill in the names if image menu shown */
if (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT)
{
import_image_menu_activate (TRUE, import_dialog->import_type, NULL);
}
}
@ -3000,7 +3057,7 @@ palette_import_image_destroyed (GimpImage* gimage)
if (!import_dialog)
return;
if (image_count() <= 1)
if (image_count(import_dialog->import_type) <= 1)
{
/* Back to gradient type */
gtk_option_menu_set_history (GTK_OPTION_MENU (import_dialog->type_option), 0);
@ -3010,9 +3067,10 @@ palette_import_image_destroyed (GimpImage* gimage)
return;
}
if (import_dialog->import_type == IMAGE_IMPORT)
if (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT)
{
import_image_menu_activate (TRUE, gimage);
import_image_menu_activate (TRUE, import_dialog->import_type, gimage);
}
}
@ -3020,9 +3078,10 @@ void
palette_import_image_renamed (GimpImage* gimage)
{
/* Now fill in the names if image menu shown */
if(import_dialog && import_dialog->import_type == IMAGE_IMPORT)
if (import_dialog && (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT))
{
import_image_menu_activate (TRUE, NULL);
import_image_menu_activate (TRUE, import_dialog->import_type, NULL);
}
}
@ -3279,3 +3338,38 @@ import_palette_create_from_image (GImage *gimage,
/* Make palette from the store_array */
import_image_make_palette (store_array, pname, palette);
}
static void
import_palette_create_from_indexed (GImage *gimage,
guchar *pname,
PaletteDialog *palette)
{
gint samples, count;
PaletteEntriesP entries;
samples = (gint) import_dialog->sample->value;
if (gimage == NULL)
return;
if (gimage_base_type (gimage) != INDEXED)
return;
entries= palette_create_entries (palette, pname);
for (count= 0; count < samples && count < gimage->num_cols; ++count)
{
palette_add_entry (entries, NULL, gimage->cmap[count*3],
gimage->cmap[count*3+1],
gimage->cmap[count*3+2]);
}
/* Redraw with new palette */
palette_update_small_preview (palette);
redraw_palette (palette);
/* Update other selectors on screen */
palette_select_clist_insert_all (entries);
palette_select2_clist_insert_all (entries);
palette_scroll_clist_to_current (palette);
}

18
app/parasite_cmds.c
View File

@ -155,7 +155,7 @@ find_parasite_invoker (Argument *args)
name = (gchar *) args[0].value.pdb_pointer;
parasite = parasite_copy (gimp_find_parasite (name));
parasite = parasite_copy (gimp_parasite_find (name));
success = parasite != NULL;
return_args = procedural_db_return_args (&find_parasite_proc, success);
@ -211,7 +211,7 @@ attach_parasite_invoker (Argument *args)
success = FALSE;
if (success)
gimp_attach_parasite (parasite);
gimp_parasite_attach (parasite);
return procedural_db_return_args (&attach_parasite_proc, success);
}
@ -252,7 +252,7 @@ detach_parasite_invoker (Argument *args)
success = FALSE;
if (success)
gimp_detach_parasite (name);
gimp_parasite_detach (name);
return procedural_db_return_args (&detach_parasite_proc, success);
}
@ -346,7 +346,7 @@ drawable_find_parasite_invoker (Argument *args)
if (success)
{
parasite = parasite_copy (gimp_drawable_find_parasite (drawable, name));
parasite = parasite_copy (gimp_drawable_parasite_find (drawable, name));
success = parasite != NULL;
}
@ -413,7 +413,7 @@ drawable_attach_parasite_invoker (Argument *args)
success = FALSE;
if (success)
gimp_drawable_attach_parasite (drawable, parasite);
gimp_drawable_parasite_attach (drawable, parasite);
return procedural_db_return_args (&drawable_attach_parasite_proc, success);
}
@ -464,7 +464,7 @@ drawable_detach_parasite_invoker (Argument *args)
success = FALSE;
if (success)
gimp_drawable_detach_parasite (drawable, name);
gimp_drawable_parasite_detach (drawable, name);
return procedural_db_return_args (&drawable_detach_parasite_proc, success);
}
@ -582,7 +582,7 @@ image_find_parasite_invoker (Argument *args)
if (success)
{
parasite = parasite_copy (gimp_image_find_parasite (gimage, name));
parasite = parasite_copy (gimp_image_parasite_find (gimage, name));
success = parasite != NULL;
}
@ -649,7 +649,7 @@ image_attach_parasite_invoker (Argument *args)
success = FALSE;
if (success)
gimp_image_attach_parasite (gimage, parasite);
gimp_image_parasite_attach (gimage, parasite);
return procedural_db_return_args (&image_attach_parasite_proc, success);
}
@ -700,7 +700,7 @@ image_detach_parasite_invoker (Argument *args)
success = FALSE;
if (success)
gimp_image_detach_parasite (gimage, name);
gimp_image_parasite_detach (gimage, name);
return procedural_db_return_args (&image_detach_parasite_proc, success);
}

2
app/tools/color_picker.c
View File

@ -487,7 +487,7 @@ pick_color_do (GimpImage *gimage,
y -= offy;
sample_type = gimp_drawable_type (drawable);
is_indexed = gimp_drawable_indexed (drawable);
is_indexed = gimp_drawable_is_indexed (drawable);
get_color_func = (GetColorFunc) gimp_drawable_get_color_at;
get_color_obj = GTK_OBJECT (drawable);

2
app/tools/curves.c
View File

@ -189,7 +189,7 @@ curves_colour_update (Tool *tool,
return;
sample_type = gimp_drawable_type(drawable);
is_indexed = gimp_drawable_indexed (drawable);
is_indexed = gimp_drawable_is_indexed (drawable);
has_alpha = TYPE_HAS_ALPHA(sample_type);
curves_dialog->col_value[HISTOGRAM_RED] = color[RED_PIX];

2
app/tools/gimpcurvestool.c
View File

@ -189,7 +189,7 @@ curves_colour_update (Tool *tool,
return;
sample_type = gimp_drawable_type(drawable);
is_indexed = gimp_drawable_indexed (drawable);
is_indexed = gimp_drawable_is_indexed (drawable);
has_alpha = TYPE_HAS_ALPHA(sample_type);
curves_dialog->col_value[HISTOGRAM_RED] = color[RED_PIX];

18
app/undo.c
View File

@ -2446,7 +2446,7 @@ undo_push_image_parasite (GImage *gimage,
data->gimage = gimage;
data->drawable = NULL;
data->name = g_strdup (parasite_name (parasite));
data->parasite = parasite_copy (gimp_image_find_parasite (gimage, data->name));
data->parasite = parasite_copy (gimp_image_parasite_find (gimage, data->name));
return TRUE;
}
@ -2474,7 +2474,7 @@ undo_push_image_parasite_remove (GImage *gimage,
data->gimage = gimage;
data->drawable = NULL;
data->name = g_strdup (name);
data->parasite = parasite_copy (gimp_image_find_parasite (gimage, data->name));
data->parasite = parasite_copy (gimp_image_parasite_find (gimage, data->name));
return TRUE;
}
@ -2503,7 +2503,7 @@ undo_push_drawable_parasite (GImage *gimage,
data->gimage = NULL;
data->drawable = drawable;
data->name = g_strdup (parasite_name (parasite));
data->parasite = parasite_copy (gimp_drawable_find_parasite (drawable, data->name));
data->parasite = parasite_copy (gimp_drawable_parasite_find (drawable, data->name));
return TRUE;
}
@ -2531,7 +2531,7 @@ undo_push_drawable_parasite_remove (GImage *gimage,
data->gimage = NULL;
data->drawable = drawable;
data->name = g_strdup (name);
data->parasite = parasite_copy (gimp_drawable_find_parasite (drawable, data->name));
data->parasite = parasite_copy (gimp_drawable_parasite_find (drawable, data->name));
return TRUE;
}
@ -2554,7 +2554,7 @@ undo_pop_parasite (GImage *gimage,
if (data->gimage)
{
data->parasite = parasite_copy (gimp_image_find_parasite (gimage,
data->parasite = parasite_copy (gimp_image_parasite_find (gimage,
data->name));
if (tmp)
parasite_list_add (data->gimage->parasites, tmp);
@ -2563,7 +2563,7 @@ undo_pop_parasite (GImage *gimage,
}
else if (data->drawable)
{
data->parasite = parasite_copy (gimp_drawable_find_parasite (data->drawable,
data->parasite = parasite_copy (gimp_drawable_parasite_find (data->drawable,
data->name));
if (tmp)
parasite_list_add (data->drawable->parasites, tmp);
@ -2572,11 +2572,11 @@ undo_pop_parasite (GImage *gimage,
}
else
{
data->parasite = parasite_copy (gimp_find_parasite (data->name));
data->parasite = parasite_copy (gimp_parasite_find (data->name));
if (tmp)
gimp_attach_parasite (tmp);
gimp_parasite_attach (tmp);
else
gimp_detach_parasite (data->name);
gimp_parasite_detach (data->name);
}
if (tmp)

2
app/widgets/gimpcursor.h
View File

@ -21,7 +21,7 @@
#include <gdk/gdktypes.h>
#if defined (GDK_WINDOWING_WIN32) || defined (GDK_WINDOWING_X11)
/* Stopgap measure to detect build with current CVS GTk+ */
#include <gdk/gdkcursor.h>
//#include <gdk/gdkcursor.h>
#endif
typedef enum

256
app/widgets/gimppaletteeditor.c
View File

@ -74,6 +74,7 @@ typedef enum
{
GRAD_IMPORT = 0,
IMAGE_IMPORT = 1,
INDEXED_IMPORT = 2,
} ImportType;
typedef struct _ImportDialog ImportDialog;
@ -87,6 +88,7 @@ struct _ImportDialog
GtkWidget *select;
GtkWidget *image_list;
GtkWidget *image_menu_item_image;
GtkWidget *image_menu_item_indexed;
GtkWidget *image_menu_item_gradient;
GtkWidget *optionmenu1_menu;
GtkWidget *type_option;
@ -151,6 +153,9 @@ static void palette_scroll_top_left (PaletteDialog *palette);
static ImportDialog * palette_import_dialog (PaletteDialog *palette);
static void palette_import_dialog_callback (GtkWidget *, gpointer);
static void import_palette_create_from_indexed (GImage *gimage,
guchar *pname,
PaletteDialog *palette);
static void import_palette_create_from_image (GImage *gimage,
guchar *pname,
PaletteDialog *palette);
@ -2420,6 +2425,10 @@ import_dialog_import_callback (GtkWidget *widget,
import_palette_create_from_image (import_dialog->gimage,
pname, palette);
break;
case INDEXED_IMPORT:
import_palette_create_from_indexed (import_dialog->gimage,
pname, palette);
break;
default:
break;
}
@ -2589,6 +2598,19 @@ gimlist_cb (gpointer im,
*l = g_slist_prepend (*l, im);
}
static void
gimlist_indexed_cb (gpointer im,
gpointer data)
{
GimpImage *gimage = GIMP_IMAGE (im);
GSList** l;
if (gimage_base_type (gimage) == INDEXED) {
l = (GSList**) data;
*l = g_slist_prepend (*l, im);
}
}
static void
import_image_update_image_preview (GimpImage *gimage)
{
@ -2690,7 +2712,7 @@ import_image_menu_add (GimpImage *gimage)
/* Last Param gives us control over what goes in the menu on a delete oper */
static void
import_image_menu_activate (gint redo,
import_image_menu_activate (gint redo, ImportType type,
GimpImage *del_image)
{
GSList *list=NULL;
@ -2701,105 +2723,123 @@ import_image_menu_activate (gint redo,
gint count = 0;
gchar *lab;
if (import_dialog)
if (!import_dialog)
return;
if (import_dialog->import_type == type && !redo)
return;
/* Destroy existing widget if necessary */
if (import_dialog->image_list)
{
if (import_dialog->import_type == IMAGE_IMPORT)
{
if (!redo)
return;
else
{
if (import_dialog->image_list)
{
last_img = import_dialog->gimage;
gtk_widget_hide (import_dialog->image_list);
gtk_widget_destroy (import_dialog->image_list);
import_dialog->image_list = NULL;
}
}
}
import_dialog->import_type = IMAGE_IMPORT;
if (redo) /* Preserve settings in this case */
last_img = import_dialog->gimage;
gtk_widget_hide (import_dialog->image_list);
gtk_widget_destroy (import_dialog->image_list);
import_dialog->image_list = NULL;
}
/* Get list of images */
import_dialog->import_type= type;
/* Get list of images */
if (import_dialog->import_type == INDEXED_IMPORT)
{
gimage_foreach (gimlist_indexed_cb, &list);
}
else
{
gimage_foreach (gimlist_cb, &list);
num_images = g_slist_length (list);
}
num_images = g_slist_length (list);
if (num_images)
{
gint i;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
if (num_images)
{
gint i;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();
import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();
for (i = 0; i < num_images; i++, list = g_slist_next (list))
{
if (GIMP_IMAGE (list->data) != del_image)
{
if (first_img == NULL)
first_img = GIMP_IMAGE (list->data);
import_image_menu_add (GIMP_IMAGE (list->data));
if (last_img == GIMP_IMAGE (list->data))
act_num = count;
else
count++;
}
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
optionmenu1_menu);
gtk_widget_hide (import_dialog->select);
gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
optionmenu1, FALSE, FALSE, 0);
if(last_img != NULL && last_img != del_image)
import_image_update_image_preview (last_img);
else if (first_img != NULL)
import_image_update_image_preview (first_img);
gtk_widget_show (optionmenu1);
/* reset to last one */
if(redo && act_num >= 0)
{
gchar *lab =
g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
for (i = 0; i < num_images; i++, list = g_slist_next (list))
{
if (GIMP_IMAGE (list->data) != del_image)
{
if (first_img == NULL)
first_img = GIMP_IMAGE (list->data);
import_image_menu_add (GIMP_IMAGE (list->data));
if (last_img == GIMP_IMAGE (list->data))
act_num = count;
else
count++;
}
}
g_slist_free (list);
lab =
g_strdup_printf ("%s-%d",
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
optionmenu1_menu);
gtk_widget_hide (import_dialog->select);
gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
optionmenu1, FALSE, FALSE, 0);
if(last_img != NULL && last_img != del_image)
import_image_update_image_preview (last_img);
else if (first_img != NULL)
import_image_update_image_preview (first_img);
gtk_widget_show (optionmenu1);
/* reset to last one */
if (redo && act_num >= 0)
{
gchar *lab = g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}
}
g_slist_free (list);
lab = g_strdup_printf ("%s-%d",
g_basename (gimage_filename (import_dialog->gimage)),
pdb_image_to_id (import_dialog->gimage));
gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}
static void
import_image_callback (GtkWidget *widget,
gpointer data)
{
import_image_menu_activate (FALSE, NULL);
import_image_menu_activate (FALSE, IMAGE_IMPORT, NULL);
gtk_widget_set_sensitive (import_dialog->threshold_scale, TRUE);
gtk_widget_set_sensitive (import_dialog->threshold_text, TRUE);
}
static void
import_indexed_callback (GtkWidget *widget,
gpointer data)
{
import_image_menu_activate (FALSE, INDEXED_IMPORT, NULL);
gtk_widget_set_sensitive (import_dialog->threshold_scale, FALSE);
gtk_widget_set_sensitive (import_dialog->threshold_text, FALSE);
}
static gint
image_count ()
image_count (ImportType type)
{
GSList *list=NULL;
gint num_images = 0;
gimage_foreach (gimlist_cb, &list);
if (type == INDEXED_IMPORT) {
gimage_foreach (gimlist_indexed_cb, &list);
} else {
gimage_foreach (gimlist_cb, &list);
}
num_images = g_slist_length (list);
g_slist_free (list);
@ -2903,9 +2943,18 @@ palette_import_dialog (PaletteDialog *palette)
(gpointer) import_dialog);
gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_set_sensitive (menuitem, image_count(IMAGE_IMPORT) > 0);
menuitem = import_dialog->image_menu_item_indexed =
gtk_menu_item_new_with_label ("Indexed Palette");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) import_indexed_callback,
(gpointer) import_dialog);
gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_set_sensitive (menuitem, image_count(INDEXED_IMPORT) > 0);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), optionmenu_menu);
gtk_widget_set_sensitive (menuitem, image_count() > 0);
gtk_widget_show (optionmenu);
/* The sample size */
@ -2985,10 +3034,18 @@ palette_import_image_new (GimpImage * gimage)
return;
}
/* Now fill in the names if image menu shown */
if (import_dialog->import_type == IMAGE_IMPORT)
if (!GTK_WIDGET_IS_SENSITIVE (import_dialog->image_menu_item_indexed) &&
gimage_base_type(gimage) == INDEXED)
{
import_image_menu_activate (TRUE, NULL);
gtk_widget_set_sensitive (import_dialog->image_menu_item_indexed, TRUE);
return;
}
/* Now fill in the names if image menu shown */
if (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT)
{
import_image_menu_activate (TRUE, import_dialog->import_type, NULL);
}
}
@ -3000,7 +3057,7 @@ palette_import_image_destroyed (GimpImage* gimage)
if (!import_dialog)
return;
if (image_count() <= 1)
if (image_count(import_dialog->import_type) <= 1)
{
/* Back to gradient type */
gtk_option_menu_set_history (GTK_OPTION_MENU (import_dialog->type_option), 0);
@ -3010,9 +3067,10 @@ palette_import_image_destroyed (GimpImage* gimage)
return;
}
if (import_dialog->import_type == IMAGE_IMPORT)
if (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT)
{
import_image_menu_activate (TRUE, gimage);
import_image_menu_activate (TRUE, import_dialog->import_type, gimage);
}
}
@ -3020,9 +3078,10 @@ void
palette_import_image_renamed (GimpImage* gimage)
{
/* Now fill in the names if image menu shown */
if(import_dialog && import_dialog->import_type == IMAGE_IMPORT)
if (import_dialog && (import_dialog->import_type == IMAGE_IMPORT ||
import_dialog->import_type == INDEXED_IMPORT))
{
import_image_menu_activate (TRUE, NULL);
import_image_menu_activate (TRUE, import_dialog->import_type, NULL);
}
}
@ -3279,3 +3338,38 @@ import_palette_create_from_image (GImage *gimage,
/* Make palette from the store_array */
import_image_make_palette (store_array, pname, palette);
}
static void
import_palette_create_from_indexed (GImage *gimage,
guchar *pname,
PaletteDialog *palette)
{
gint samples, count;
PaletteEntriesP entries;
samples = (gint) import_dialog->sample->value;
if (gimage == NULL)
return;
if (gimage_base_type (gimage) != INDEXED)
return;
entries= palette_create_entries (palette, pname);
for (count= 0; count < samples && count < gimage->num_cols; ++count)
{
palette_add_entry (entries, NULL, gimage->cmap[count*3],
gimage->cmap[count*3+1],
gimage->cmap[count*3+2]);
}
/* Redraw with new palette */
palette_update_small_preview (palette);
redraw_palette (palette);
/* Update other selectors on screen */
palette_select_clist_insert_all (entries);
palette_select2_clist_insert_all (entries);
palette_scroll_clist_to_current (palette);
}

6
app/xcf.c
View File

@ -1850,7 +1850,7 @@ xcf_load_image_props (XcfInfo *info,
while (info->cp - base < prop_size)
{
p = read_a_parasite(info);
gimp_image_attach_parasite(gimage, p);
gimp_image_parasite_attach(gimage, p);
parasite_free(p);
}
if (info->cp - base != prop_size)
@ -2013,7 +2013,7 @@ xcf_load_layer_props (XcfInfo *info,
while (info->cp - base < prop_size)
{
p = read_a_parasite(info);
gimp_drawable_attach_parasite(GIMP_DRAWABLE(layer), p);
gimp_drawable_parasite_attach(GIMP_DRAWABLE(layer), p);
parasite_free(p);
}
if (info->cp - base != prop_size)
@ -2090,7 +2090,7 @@ xcf_load_channel_props (XcfInfo *info,
while ((info->cp - base) < prop_size)
{
p = read_a_parasite(info);
gimp_drawable_attach_parasite(GIMP_DRAWABLE(channel), p);
gimp_drawable_parasite_attach(GIMP_DRAWABLE(channel), p);
parasite_free(p);
}
if (info->cp - base != prop_size)

6
app/xcf/xcf.c
View File

@ -1850,7 +1850,7 @@ xcf_load_image_props (XcfInfo *info,
while (info->cp - base < prop_size)
{
p = read_a_parasite(info);
gimp_image_attach_parasite(gimage, p);
gimp_image_parasite_attach(gimage, p);
parasite_free(p);
}
if (info->cp - base != prop_size)
@ -2013,7 +2013,7 @@ xcf_load_layer_props (XcfInfo *info,
while (info->cp - base < prop_size)
{
p = read_a_parasite(info);
gimp_drawable_attach_parasite(GIMP_DRAWABLE(layer), p);
gimp_drawable_parasite_attach(GIMP_DRAWABLE(layer), p);
parasite_free(p);
}
if (info->cp - base != prop_size)
@ -2090,7 +2090,7 @@ xcf_load_channel_props (XcfInfo *info,
while ((info->cp - base) < prop_size)
{
p = read_a_parasite(info);
gimp_drawable_attach_parasite(GIMP_DRAWABLE(channel), p);
gimp_drawable_parasite_attach(GIMP_DRAWABLE(channel), p);
parasite_free(p);
}
if (info->cp - base != prop_size)

8
docs/script-fu.tex
View File

@ -576,7 +576,7 @@ come a long way in two years.
(shadow-layer (car (gimp-layer-new img width height RGBA_IMAGE "Shadow" 100 MULTIPLY)))
(old-fg (car (gimp-palette-get-foreground)))
(old-bg (car (gimp-palette-get-background))))
(gimp-image-disable-undo img)
(gimp-image-undo-disable img)
(gimp-image-resize img width height 0 0)
(gimp-image-add-layer img bg-layer 1)
(gimp-image-add-layer img shadow-layer 1)
@ -603,7 +603,7 @@ come a long way in two years.
(gimp-layer-set-name highlight-layer "Highlight")
(gimp-palette-set-background old-bg)
(gimp-palette-set-foreground old-fg)
(gimp-image-enable-undo img)
(gimp-image-undo-enable img)
(gimp-display-new img)))
\end{verbatim}}
@ -697,7 +697,7 @@ come a long way in two years.
(gimp-image-delete banding-img)
(gimp-image-delete back-img)
(gimp-image-delete tile-img)
(gimp-image-disable-undo img)
(gimp-image-undo-disable img)
(gimp-image-resize img width height 0 0)
(gimp-image-add-layer img layer3 0)
(gimp-image-add-layer img layer2 0)
@ -776,7 +776,7 @@ come a long way in two years.
(gimp-palette-set-foreground old-fg)
(gimp-palette-set-background old-bg)
(gimp-brushes-set-brush old-brush)
(gimp-image-enable-undo img)
(gimp-image-undo-enable img)
(gimp-display-new img)))
\end{verbatim}}
\twocolumn

2
libgimp/gimp.c
View File

@ -554,7 +554,7 @@ gimp_query_images (int *nimages)
int nreturn_vals;
gint32 *images;
return_vals = gimp_run_procedure ("gimp_list_images",
return_vals = gimp_run_procedure ("gimp_image_list",
&nreturn_vals,
PARAM_END);

32
libgimp/gimp.def
View File

@ -27,19 +27,19 @@ EXPORTS
gimp_default_display
gimp_destroy_paramdefs
gimp_destroy_params
gimp_detach_parasite
gimp_parasite_detach
gimp_directory
gimp_display_delete
gimp_display_new
gimp_displays_flush
gimp_drawable_attach_new_parasite
gimp_drawable_attach_parasite
gimp_drawable_parasite_attach
gimp_drawable_bpp
gimp_drawable_channel
gimp_drawable_is_channel
gimp_drawable_color
gimp_drawable_delete
gimp_drawable_detach
gimp_drawable_detach_parasite
gimp_drawable_parasite_detach
gimp_drawable_fill
gimp_drawable_find_parasite
gimp_drawable_flush
@ -47,13 +47,13 @@ EXPORTS
gimp_drawable_get_thumbnail_data
gimp_drawable_get_tile
gimp_drawable_get_tile2
gimp_drawable_gray
gimp_drawable_is_gray
gimp_drawable_has_alpha
gimp_drawable_height
gimp_drawable_image_id
gimp_drawable_indexed
gimp_drawable_layer
gimp_drawable_layer_mask
gimp_drawable_is_indexed
gimp_drawable_is_layer
gimp_drawable_is_layer_mask
gimp_drawable_mask_bounds
gimp_drawable_merge_shadow
gimp_drawable_name
@ -66,7 +66,7 @@ EXPORTS
gimp_drawable_width
gimp_extension_ack
gimp_extension_process
gimp_find_parasite
gimp_parasite_find
gimp_gamma
gimp_get_data
gimp_get_data_size
@ -82,7 +82,7 @@ EXPORTS
gimp_image_add_layer_mask
gimp_image_add_vguide
gimp_image_attach_new_parasite
gimp_image_attach_parasite
gimp_image_parasite_attach
gimp_image_base_type
gimp_image_clean_all
gimp_image_convert_grayscale
@ -90,15 +90,15 @@ EXPORTS
gimp_image_convert_rgb
gimp_image_delete
gimp_image_delete_guide
gimp_image_detach_parasite
gimp_image_disable_undo
gimp_image_parasite_detach
gimp_image_undo_disable
gimp_image_duplicate
gimp_image_enable_undo
gimp_image_undo_enable
gimp_image_find_next_guide
gimp_image_find_parasite
gimp_image_parasite_find
gimp_image_flatten
gimp_image_floating_selection
gimp_image_freeze_undo
gimp_image_undo_freeze
gimp_image_get_active_channel
gimp_image_get_active_layer
gimp_image_get_channel_by_tattoo
@ -135,7 +135,7 @@ EXPORTS
gimp_image_set_filename
gimp_image_set_resolution
gimp_image_set_unit
gimp_image_thaw_undo
gimp_image_undo_thaw
gimp_image_width
gimp_install_cmap
gimp_install_procedure

34
libgimp/gimp.h
View File

@ -439,10 +439,10 @@ void gimp_image_add_layer_mask (gint32 image_ID,
gint32 layer_ID,
gint32 mask_ID);
void gimp_image_clean_all (gint32 image_ID);
void gimp_image_disable_undo (gint32 image_ID);
void gimp_image_enable_undo (gint32 image_ID);
void gimp_image_freeze_undo (gint32 image_ID);
void gimp_image_thaw_undo (gint32 image_ID);
void gimp_image_undo_disable (gint32 image_ID);
void gimp_image_undo_enable (gint32 image_ID);
void gimp_image_undo_freeze (gint32 image_ID);
void gimp_image_undo_thaw (gint32 image_ID);
void gimp_undo_push_group_start (gint32 image_ID);
void gimp_undo_push_group_end (gint32 image_ID);
void gimp_image_clean_all (gint32 image_ID);
@ -501,16 +501,16 @@ void gimp_image_set_component_visible (gint32 image_ID,
gint visible);
void gimp_image_set_filename (gint32 image_ID,
char *name);
Parasite *gimp_image_find_parasite (gint32 image_ID,
Parasite *gimp_image_parasite_find (gint32 image_ID,
const char *name);
void gimp_image_attach_parasite (gint32 image_ID,
void gimp_image_parasite_attach (gint32 image_ID,
const Parasite *p);
void gimp_image_attach_new_parasite (gint32 image_ID,
const char *name,
int flags,
int size,
const void *data);
void gimp_image_detach_parasite (gint32 image_ID,
void gimp_image_parasite_detach (gint32 image_ID,
const char *name);
void gimp_image_set_resolution (gint32 image_ID,
double xresolution,
@ -693,13 +693,13 @@ guint gimp_drawable_height (gint32 drawable_ID);
guint gimp_drawable_bpp (gint32 drawable_ID);
GDrawableType gimp_drawable_type (gint32 drawable_ID);
gint gimp_drawable_visible (gint32 drawable_ID);
gint gimp_drawable_channel (gint32 drawable_ID);
gint gimp_drawable_is_channel (gint32 drawable_ID);
gint gimp_drawable_color (gint32 drawable_ID);
gint gimp_drawable_gray (gint32 drawable_ID);
gint gimp_drawable_is_gray (gint32 drawable_ID);
gint gimp_drawable_has_alpha (gint32 drawable_ID);
gint gimp_drawable_indexed (gint32 drawable_ID);
gint gimp_drawable_layer (gint32 drawable_ID);
gint gimp_drawable_layer_mask (gint32 drawable_ID);
gint gimp_drawable_is_indexed (gint32 drawable_ID);
gint gimp_drawable_is_layer (gint32 drawable_ID);
gint gimp_drawable_is_layer_mask (gint32 drawable_ID);
gint gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1,
gint *y1,
@ -724,12 +724,12 @@ GTile* gimp_drawable_get_tile2 (GDrawable *drawable,
gint y);
Parasite *gimp_drawable_find_parasite (gint32 drawable,
const char *name);
void gimp_drawable_attach_parasite (gint32 drawable,
void gimp_drawable_parasite_attach (gint32 drawable,
const Parasite *p);
void gimp_layer_attach_new_parasite(gint32 drawable,
const char *name, int flags,
int size, const void *data);
void gimp_drawable_detach_parasite (gint32 drawable,
void gimp_drawable_parasite_detach (gint32 drawable,
const char *name);
guchar * gimp_drawable_get_thumbnail_data (gint32 drawable_ID,
gint *width,
@ -847,11 +847,11 @@ gdouble* gimp_gradients_sample_custom (gint num_samples,
* Parasites *
****************************************/
Parasite *gimp_find_parasite (const char *name);
void gimp_attach_parasite (const Parasite *p);
Parasite *gimp_parasite_find (const char *name);
void gimp_parasite_attach (const Parasite *p);
void gimp_attach_new_parasite (const char *name, int flags,
int size, const void *data);
void gimp_detach_parasite (const char *name);
void gimp_parasite_detach (const char *name);
#ifdef __cplusplus
}

40
libgimp/gimpdrawable.c
View File

@ -97,7 +97,7 @@ gimp_drawable_delete (GDrawable *drawable)
{
if (drawable)
{
if (gimp_drawable_layer (drawable->id))
if (gimp_drawable_is_layer (drawable->id))
gimp_layer_delete (drawable->id);
else
gimp_channel_delete (drawable->id);
@ -166,7 +166,7 @@ gimp_drawable_image_id (gint32 drawable_ID)
char*
gimp_drawable_name (gint32 drawable_ID)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
return gimp_layer_get_name (drawable_ID);
return gimp_channel_get_name (drawable_ID);
}
@ -258,19 +258,19 @@ gimp_drawable_type (gint32 drawable_ID)
gint
gimp_drawable_visible (gint32 drawable_ID)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
return gimp_layer_get_visible (drawable_ID);
return gimp_channel_get_visible (drawable_ID);
}
gint
gimp_drawable_channel (gint32 drawable_ID)
gimp_drawable_is_channel (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_channel",
return_vals = gimp_run_procedure ("gimp_drawable_is_channel",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -306,13 +306,13 @@ gimp_drawable_color (gint32 drawable_ID)
}
gint
gimp_drawable_gray (gint32 drawable_ID)
gimp_drawable_is_gray (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_gray",
return_vals = gimp_run_procedure ("gimp_drawable_is_gray",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -348,13 +348,13 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
}
gint
gimp_drawable_indexed (gint32 drawable_ID)
gimp_drawable_is_indexed (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_indexed",
return_vals = gimp_run_procedure ("gimp_drawable_is_indexed",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -369,13 +369,13 @@ gimp_drawable_indexed (gint32 drawable_ID)
}
gint
gimp_drawable_layer (gint32 drawable_ID)
gimp_drawable_is_layer (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_layer",
return_vals = gimp_run_procedure ("gimp_drawable_is_layer",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -390,13 +390,13 @@ gimp_drawable_layer (gint32 drawable_ID)
}
gint
gimp_drawable_layer_mask (gint32 drawable_ID)
gimp_drawable_is_layer_mask (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_layer_mask",
return_vals = gimp_run_procedure ("gimp_drawable_is_layer_mask",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -483,7 +483,7 @@ void
gimp_drawable_set_name (gint32 drawable_ID,
char *name)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
gimp_layer_set_name (drawable_ID, name);
else
gimp_channel_set_name (drawable_ID, name);
@ -493,7 +493,7 @@ void
gimp_drawable_set_visible (gint32 drawable_ID,
gint visible)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
gimp_layer_set_visible (drawable_ID, visible);
else
gimp_channel_set_visible (drawable_ID, visible);
@ -605,13 +605,13 @@ gimp_drawable_find_parasite (gint32 drawable_ID,
}
void
gimp_drawable_attach_parasite (gint32 drawable_ID,
gimp_drawable_parasite_attach (gint32 drawable_ID,
const Parasite *p)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_attach_parasite",
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_PARASITE, p,
@ -629,7 +629,7 @@ gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags,
int nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_drawable_attach_parasite",
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals,
PARAM_DRAWABLE, drawable,
PARAM_PARASITE, p,
@ -640,13 +640,13 @@ gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags,
}
void
gimp_drawable_detach_parasite (gint32 drawable_ID,
gimp_drawable_parasite_detach (gint32 drawable_ID,
const char *name)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_detach_parasite",
return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_STRING, name,

40
libgimp/gimpdrawable_pdb.c
View File

@ -97,7 +97,7 @@ gimp_drawable_delete (GDrawable *drawable)
{
if (drawable)
{
if (gimp_drawable_layer (drawable->id))
if (gimp_drawable_is_layer (drawable->id))
gimp_layer_delete (drawable->id);
else
gimp_channel_delete (drawable->id);
@ -166,7 +166,7 @@ gimp_drawable_image_id (gint32 drawable_ID)
char*
gimp_drawable_name (gint32 drawable_ID)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
return gimp_layer_get_name (drawable_ID);
return gimp_channel_get_name (drawable_ID);
}
@ -258,19 +258,19 @@ gimp_drawable_type (gint32 drawable_ID)
gint
gimp_drawable_visible (gint32 drawable_ID)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
return gimp_layer_get_visible (drawable_ID);
return gimp_channel_get_visible (drawable_ID);
}
gint
gimp_drawable_channel (gint32 drawable_ID)
gimp_drawable_is_channel (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_channel",
return_vals = gimp_run_procedure ("gimp_drawable_is_channel",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -306,13 +306,13 @@ gimp_drawable_color (gint32 drawable_ID)
}
gint
gimp_drawable_gray (gint32 drawable_ID)
gimp_drawable_is_gray (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_gray",
return_vals = gimp_run_procedure ("gimp_drawable_is_gray",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -348,13 +348,13 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
}
gint
gimp_drawable_indexed (gint32 drawable_ID)
gimp_drawable_is_indexed (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_indexed",
return_vals = gimp_run_procedure ("gimp_drawable_is_indexed",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -369,13 +369,13 @@ gimp_drawable_indexed (gint32 drawable_ID)
}
gint
gimp_drawable_layer (gint32 drawable_ID)
gimp_drawable_is_layer (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_layer",
return_vals = gimp_run_procedure ("gimp_drawable_is_layer",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -390,13 +390,13 @@ gimp_drawable_layer (gint32 drawable_ID)
}
gint
gimp_drawable_layer_mask (gint32 drawable_ID)
gimp_drawable_is_layer_mask (gint32 drawable_ID)
{
GParam *return_vals;
int nreturn_vals;
int result;
return_vals = gimp_run_procedure ("gimp_drawable_layer_mask",
return_vals = gimp_run_procedure ("gimp_drawable_is_layer_mask",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_END);
@ -483,7 +483,7 @@ void
gimp_drawable_set_name (gint32 drawable_ID,
char *name)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
gimp_layer_set_name (drawable_ID, name);
else
gimp_channel_set_name (drawable_ID, name);
@ -493,7 +493,7 @@ void
gimp_drawable_set_visible (gint32 drawable_ID,
gint visible)
{
if (gimp_drawable_layer (drawable_ID))
if (gimp_drawable_is_layer (drawable_ID))
gimp_layer_set_visible (drawable_ID, visible);
else
gimp_channel_set_visible (drawable_ID, visible);
@ -605,13 +605,13 @@ gimp_drawable_find_parasite (gint32 drawable_ID,
}
void
gimp_drawable_attach_parasite (gint32 drawable_ID,
gimp_drawable_parasite_attach (gint32 drawable_ID,
const Parasite *p)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_attach_parasite",
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_PARASITE, p,
@ -629,7 +629,7 @@ gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags,
int nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_drawable_attach_parasite",
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals,
PARAM_DRAWABLE, drawable,
PARAM_PARASITE, p,
@ -640,13 +640,13 @@ gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags,
}
void
gimp_drawable_detach_parasite (gint32 drawable_ID,
gimp_drawable_parasite_detach (gint32 drawable_ID,
const char *name)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_detach_parasite",
return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach",
&nreturn_vals,
PARAM_DRAWABLE, drawable_ID,
PARAM_STRING, name,

2
libgimp/gimpexport.c
View File

@ -470,7 +470,7 @@ gimp_export_image (gint32 *image_ID_ptr,
{
*image_ID_ptr = gimp_image_duplicate (*image_ID_ptr);
*drawable_ID_ptr = gimp_image_get_active_layer (*image_ID_ptr);
gimp_image_disable_undo (*image_ID_ptr);
gimp_image_undo_disable (*image_ID_ptr);
for (list = actions; list; list = list->next)
{
action = (ExportAction*)(list->data);

30
libgimp/gimpimage.c
View File

@ -355,12 +355,12 @@ gimp_image_add_layer_mask (gint32 image_ID,
}
void
gimp_image_disable_undo (gint32 image_ID)
gimp_image_undo_disable (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_disable_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_disable",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -369,12 +369,12 @@ gimp_image_disable_undo (gint32 image_ID)
}
void
gimp_image_enable_undo (gint32 image_ID)
gimp_image_undo_enable (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_enable_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_enable",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -383,12 +383,12 @@ gimp_image_enable_undo (gint32 image_ID)
}
void
gimp_image_freeze_undo (gint32 image_ID)
gimp_image_undo_freeze (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_freeze_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_freeze",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -397,12 +397,12 @@ gimp_image_freeze_undo (gint32 image_ID)
}
void
gimp_image_thaw_undo (gint32 image_ID)
gimp_image_undo_thaw (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_thaw_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_thaw",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -976,13 +976,13 @@ gimp_image_set_filename (gint32 image_ID,
}
Parasite *
gimp_image_find_parasite (gint32 image_ID,
gimp_image_parasite_find (gint32 image_ID,
const char *name)
{
GParam *return_vals;
int nreturn_vals;
Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_image_find_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_find",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_STRING, name,
@ -1001,13 +1001,13 @@ gimp_image_find_parasite (gint32 image_ID,
}
void
gimp_image_attach_parasite (gint32 image_ID,
gimp_image_parasite_attach (gint32 image_ID,
const Parasite *p)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_attach_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_PARASITE, p,
@ -1027,7 +1027,7 @@ gimp_image_attach_new_parasite (gint32 image_ID,
int nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_image_attach_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_PARASITE, p,
@ -1038,13 +1038,13 @@ gimp_image_attach_new_parasite (gint32 image_ID,
}
void
gimp_image_detach_parasite (gint32 image_ID,
gimp_image_parasite_detach (gint32 image_ID,
const char *name)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_detach_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_detach",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_STRING, name,

30
libgimp/gimpimage_pdb.c
View File

@ -355,12 +355,12 @@ gimp_image_add_layer_mask (gint32 image_ID,
}
void
gimp_image_disable_undo (gint32 image_ID)
gimp_image_undo_disable (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_disable_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_disable",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -369,12 +369,12 @@ gimp_image_disable_undo (gint32 image_ID)
}
void
gimp_image_enable_undo (gint32 image_ID)
gimp_image_undo_enable (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_enable_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_enable",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -383,12 +383,12 @@ gimp_image_enable_undo (gint32 image_ID)
}
void
gimp_image_freeze_undo (gint32 image_ID)
gimp_image_undo_freeze (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_freeze_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_freeze",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -397,12 +397,12 @@ gimp_image_freeze_undo (gint32 image_ID)
}
void
gimp_image_thaw_undo (gint32 image_ID)
gimp_image_undo_thaw (gint32 image_ID)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_thaw_undo",
return_vals = gimp_run_procedure ("gimp_image_undo_thaw",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_END);
@ -976,13 +976,13 @@ gimp_image_set_filename (gint32 image_ID,
}
Parasite *
gimp_image_find_parasite (gint32 image_ID,
gimp_image_parasite_find (gint32 image_ID,
const char *name)
{
GParam *return_vals;
int nreturn_vals;
Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_image_find_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_find",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_STRING, name,
@ -1001,13 +1001,13 @@ gimp_image_find_parasite (gint32 image_ID,
}
void
gimp_image_attach_parasite (gint32 image_ID,
gimp_image_parasite_attach (gint32 image_ID,
const Parasite *p)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_attach_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_PARASITE, p,
@ -1027,7 +1027,7 @@ gimp_image_attach_new_parasite (gint32 image_ID,
int nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_image_attach_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_PARASITE, p,
@ -1038,13 +1038,13 @@ gimp_image_attach_new_parasite (gint32 image_ID,
}
void
gimp_image_detach_parasite (gint32 image_ID,
gimp_image_parasite_detach (gint32 image_ID,
const char *name)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_detach_parasite",
return_vals = gimp_run_procedure ("gimp_image_parasite_detach",
&nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_STRING, name,

14
libgimp/gimpparasite_pdb.c
View File

@ -1,12 +1,12 @@
#include "gimp.h"
Parasite *
gimp_find_parasite (const char *name)
gimp_parasite_find (const char *name)
{
GParam *return_vals;
int nreturn_vals;
Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_find_parasite",
return_vals = gimp_run_procedure ("gimp_parasite_find",
&nreturn_vals,
PARAM_STRING, name,
PARAM_END);
@ -25,12 +25,12 @@ gimp_find_parasite (const char *name)
void
gimp_attach_parasite (const Parasite *p)
gimp_parasite_attach (const Parasite *p)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_attach_parasite",
return_vals = gimp_run_procedure ("gimp_parasite_attach",
&nreturn_vals,
PARAM_PARASITE, p,
PARAM_END);
@ -46,7 +46,7 @@ gimp_attach_new_parasite (const char *name, int flags,
int nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_attach_parasite",
return_vals = gimp_run_procedure ("gimp_parasite_attach",
&nreturn_vals,
PARAM_PARASITE, p,
PARAM_END);
@ -56,12 +56,12 @@ gimp_attach_new_parasite (const char *name, int flags,
}
void
gimp_detach_parasite (const char *name)
gimp_parasite_detach (const char *name)
{
GParam *return_vals;
int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_detach_parasite",
return_vals = gimp_run_procedure ("gimp_parasite_detach",
&nreturn_vals,
PARAM_STRING, name,
PARAM_END);

4
plug-ins/Lighting/lighting_main.c
View File

@ -102,7 +102,7 @@ void check_drawables(void)
/* Check if bump-map is grayscale and of the same size as the input drawable */
/* ========================================================================= */
if (!gimp_drawable_gray(mapvals.bumpmap_id) ||
if (!gimp_drawable_is_gray(mapvals.bumpmap_id) ||
gimp_drawable_width(mapvals.drawable_id)!=gimp_drawable_width(mapvals.bumpmap_id) ||
gimp_drawable_height(mapvals.drawable_id)!=gimp_drawable_height(mapvals.bumpmap_id))
{
@ -119,7 +119,7 @@ void check_drawables(void)
/* Check if env-map is grayscale or has alpha */
/* ========================================== */
if (gimp_drawable_gray(mapvals.envmap_id) ||
if (gimp_drawable_is_gray(mapvals.envmap_id) ||
gimp_drawable_has_alpha(mapvals.envmap_id))
{
/* If it has then we silently disable env mapping */

4
plug-ins/Lighting/lighting_ui.c
View File

@ -480,7 +480,7 @@ gint bumpmap_constrain(gint32 image_id, gint32 drawable_id, gpointer data)
if (drawable_id == -1)
return(TRUE);
return (gimp_drawable_gray(drawable_id) && !gimp_drawable_has_alpha(drawable_id) &&
return (gimp_drawable_is_gray(drawable_id) && !gimp_drawable_has_alpha(drawable_id) &&
gimp_drawable_width(drawable_id)==gimp_drawable_width(mapvals.drawable_id) &&
gimp_drawable_height(drawable_id)==gimp_drawable_height(mapvals.drawable_id));
}
@ -495,7 +495,7 @@ gint envmap_constrain(gint32 image_id, gint32 drawable_id, gpointer data)
if (drawable_id == -1)
return(TRUE);
return (!gimp_drawable_gray(drawable_id) && !gimp_drawable_has_alpha(drawable_id));
return (!gimp_drawable_is_gray(drawable_id) && !gimp_drawable_has_alpha(drawable_id));
}
void envmap_drawable_callback(gint32 id, gpointer data)

4
plug-ins/MapObject/mapobject_main.c
View File

@ -102,7 +102,7 @@ void check_drawables(GDrawable *drawable)
mapvals.boxmap_id[i] = drawable->id;
else if (mapvals.boxmap_id[i]!=-1 && gimp_drawable_image_id(mapvals.boxmap_id[i])==-1)
mapvals.boxmap_id[i] = drawable->id;
else if (gimp_drawable_gray(mapvals.boxmap_id[i]))
else if (gimp_drawable_is_gray(mapvals.boxmap_id[i]))
mapvals.boxmap_id[i] = drawable->id;
}
@ -116,7 +116,7 @@ void check_drawables(GDrawable *drawable)
else if (mapvals.cylindermap_id[i]!=-1 &&
gimp_drawable_image_id(mapvals.cylindermap_id[i])==-1)
mapvals.cylindermap_id[i] = drawable->id;
else if (gimp_drawable_gray(mapvals.cylindermap_id[i]))
else if (gimp_drawable_is_gray(mapvals.cylindermap_id[i]))
mapvals.cylindermap_id[i] = drawable->id;
}
}

4
plug-ins/MapObject/mapobject_ui.c
View File

@ -568,7 +568,7 @@ gint box_constrain(gint32 image_id, gint32 drawable_id, gpointer data)
if (drawable_id == -1)
return(TRUE);
return (gimp_drawable_color(drawable_id) && !gimp_drawable_indexed(drawable_id));
return (gimp_drawable_color(drawable_id) && !gimp_drawable_is_indexed(drawable_id));
}
void box_drawable_callback(gint32 id, gpointer data)
@ -585,7 +585,7 @@ gint cylinder_constrain(gint32 image_id, gint32 drawable_id, gpointer data)
if (drawable_id == -1)
return(TRUE);
return (gimp_drawable_color(drawable_id) && !gimp_drawable_indexed(drawable_id));
return (gimp_drawable_color(drawable_id) && !gimp_drawable_is_indexed(drawable_id));
}
void cylinder_drawable_callback(gint32 id, gpointer data)

2
plug-ins/common/CML_explorer.c
View File

@ -598,7 +598,7 @@ MAIN_FUNCTION (gint preview_p)
drawable = gimp_drawable_get (drawable_id);
gimp_drawable_mask_bounds (drawable_id, &x1, &y1, &x2, &y2);
src_has_alpha = dest_has_alpha = gimp_drawable_has_alpha (drawable_id);
src_is_gray = dest_is_gray = gimp_drawable_gray (drawable_id);
src_is_gray = dest_is_gray = gimp_drawable_is_gray (drawable_id);
src_bpp = dest_bpp = (src_is_gray ? 1 : 3) + (src_has_alpha ? 1 : 0);
if (preview_p)

4
plug-ins/common/autocrop.c
View File

@ -99,8 +99,8 @@ static void run(char *name, int n_params, GParam * param, int *nreturn_vals,
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color(drawable->id) ||
gimp_drawable_gray(drawable->id) ||
gimp_drawable_indexed(drawable->id))
gimp_drawable_is_gray(drawable->id) ||
gimp_drawable_is_indexed(drawable->id))
{
gimp_progress_init(_("Cropping..."));
gimp_tile_cache_ntiles(2 * (drawable->width / gimp_tile_width() + 1));

4
plug-ins/common/autostretch_hsv.c
View File

@ -114,7 +114,7 @@ run (char *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init (_("Auto-Stretching HSV..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -123,7 +123,7 @@ run (char *name,
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->id))
{
indexed_autostretch_hsv (image_ID);

2
plug-ins/common/blinds.c
View File

@ -260,7 +260,7 @@ run (gchar *name,
break;
}
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init ("Adding Blinds ...");

2
plug-ins/common/blur.c
View File

@ -261,7 +261,7 @@ run(char *name, int nparams, GParam *param, int *nreturn_vals,
* Make sure the drawable type is appropriate.
*/
if (gimp_drawable_color(drawable->id) ||
gimp_drawable_gray(drawable->id)) {
gimp_drawable_is_gray(drawable->id)) {
switch (run_mode) {
/*

4
plug-ins/common/bumpmap.c
View File

@ -444,7 +444,7 @@ run(char *name,
if (status == STATUS_SUCCESS) {
if ((gimp_drawable_color(drawable->id) ||
gimp_drawable_gray(drawable->id))) {
gimp_drawable_is_gray(drawable->id))) {
/* Set the tile cache size */
gimp_tile_cache_ntiles(2*(drawable->width +
@ -1546,7 +1546,7 @@ dialog_constrain(gint32 image_id, gint32 drawable_id, gpointer data)
if (drawable_id == -1)
return TRUE;
return (gimp_drawable_color(drawable_id) || gimp_drawable_gray(drawable_id));
return (gimp_drawable_color(drawable_id) || gimp_drawable_is_gray(drawable_id));
} /* dialog_constrain */

4
plug-ins/common/c_astretch.c
View File

@ -110,7 +110,7 @@ run (char *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init (_("Auto-Stretching Contrast..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -119,7 +119,7 @@ run (char *name,
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->id))
{
indexed_c_astretch (image_ID);

2
plug-ins/common/checkerboard.c
View File

@ -159,7 +159,7 @@ run (gchar *name,
break;
}
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init (_("Adding Checkerboard..."));

4
plug-ins/common/color_enhance.c
View File

@ -116,7 +116,7 @@ run (char *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init (_("Color Enhance..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -125,7 +125,7 @@ run (char *name,
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->id))
{
indexed_Color_Enhance (image_ID);

2
plug-ins/common/compose.c
View File

@ -363,7 +363,7 @@ run (char *name,
else
{
values[1].data.d_int32 = image_ID;
gimp_image_enable_undo (image_ID);
gimp_image_undo_enable (image_ID);
gimp_image_clean_all (image_ID);
if (run_mode != RUN_NONINTERACTIVE)
gimp_display_new (image_ID);

4
plug-ins/common/convmatrix.c
View File

@ -235,7 +235,7 @@ static void run(char *name, int n_params, GParam * param,
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color(drawable->id) ||
gimp_drawable_gray(drawable->id)) {
gimp_drawable_is_gray(drawable->id)) {
gimp_progress_init(_("Applying convolution"));
gimp_tile_cache_ntiles(2 * (drawable->width /
gimp_tile_width() + 1));
@ -607,7 +607,7 @@ static void check_config(void){
my_config.channels[i]=0;
if(gimp_drawable_color(drawable->id))
my_config.channels[0]=-1;
else if(gimp_drawable_gray(drawable->id))
else if(gimp_drawable_is_gray(drawable->id))
for(i=1;i<4;i++)
my_config.channels[i]=-1;
if(!gimp_drawable_has_alpha(drawable->id)){

6
plug-ins/common/csource.c
View File

@ -137,7 +137,7 @@ run (gchar *name,
drawable_type == GRAYA_IMAGE ||
drawable_type == INDEXEDA_IMAGE);
parasite = gimp_image_find_parasite (image_ID, "gimp-comment");
parasite = gimp_image_parasite_find (image_ID, "gimp-comment");
if (parasite)
{
config.comment = g_strdup (parasite->data);
@ -151,14 +151,14 @@ run (gchar *name,
!(x && config.comment && strcmp (x, config.comment) == 0))
{
if (!config.comment || !config.comment[0])
gimp_image_detach_parasite (image_ID, "gimp-comment");
gimp_image_parasite_detach (image_ID, "gimp-comment");
else
{
parasite = parasite_new ("gimp-comment",
PARASITE_PERSISTENT,
strlen (config.comment) + 1,
config.comment);
gimp_image_attach_parasite (image_ID, parasite);
gimp_image_parasite_attach (image_ID, parasite);
parasite_free (parasite);
}
}

2
plug-ins/common/cubism.c
View File

@ -243,7 +243,7 @@ run (char *name,
/* Render the cubism effect */
if ((status == STATUS_SUCCESS) &&
(gimp_drawable_color (active_drawable->id) || gimp_drawable_gray (active_drawable->id)))
(gimp_drawable_color (active_drawable->id) || gimp_drawable_is_gray (active_drawable->id)))
{
/* set cache size */
gimp_tile_cache_ntiles (SQR (4 * cvals.tile_size * cvals.tile_saturation) / SQR (gimp_tile_width ()));

2
plug-ins/common/curve_bend.c
View File

@ -840,7 +840,7 @@ run (char *name, /* name of plugin */
gimp_run_procedure ("gimp_undo_push_group_start", &l_nreturn_vals,
PARAM_IMAGE, l_image_id, PARAM_END);
if(!gimp_drawable_layer(l_layer_id))
if(!gimp_drawable_is_layer(l_layer_id))
{
gimp_message(PLUG_IN_PRINT_NAME " operates on layers only (but was called on channel or mask)");
printf("Passed drawable is no Layer\n");

2
plug-ins/common/decompose.c
View File

@ -320,7 +320,7 @@ run (char *name,
for (j = 0; j < num_images; j++)
{
values[j+1].data.d_int32 = image_ID_extract[j];
gimp_image_enable_undo (image_ID_extract[j]);
gimp_image_undo_enable (image_ID_extract[j]);
gimp_image_clean_all (image_ID_extract[j]);
if (run_mode != RUN_NONINTERACTIVE)
gimp_display_new (image_ID_extract[j]);

2
plug-ins/common/deinterlace.c
View File

@ -126,7 +126,7 @@ run (char *name,
if (status == STATUS_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init ("deinterlace");
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));

4
plug-ins/common/depthmerge.c
View File

@ -962,7 +962,7 @@ gint constraintResultSizeAndResultColorOrGray(gint32 imageId,
gimp_drawable_height(dm->params.result)) &&
((gimp_drawable_color(drawableId) &&
(gimp_drawable_color(dm->params.result))) ||
gimp_drawable_gray( drawableId))));
gimp_drawable_is_gray( drawableId))));
}
gint constraintResultSizeAndGray(gint32 imageId,
@ -974,7 +974,7 @@ gint constraintResultSizeAndGray(gint32 imageId,
gimp_drawable_width( dm->params.result)) &&
(gimp_drawable_height(drawableId) ==
gimp_drawable_height(dm->params.result)) &&
(gimp_drawable_gray( drawableId))));
(gimp_drawable_is_gray( drawableId))));
}
void dialogOkCallback(GtkWidget *widget, gpointer data) {

5
plug-ins/common/despeckle.c
View File

@ -43,6 +43,9 @@
* Revision History:
*
* $Log$
* Revision 1.16 1999/10/17 00:07:38 pcg
* API PATCH #2 or so
*
* Revision 1.15 1999/04/23 06:35:14 asbjoer
* use MAIN macro
*
@ -394,7 +397,7 @@ run(char *name, /* I - Name of filter program. */
if (status == STATUS_SUCCESS)
{
if ((gimp_drawable_color(drawable->id) ||
gimp_drawable_gray(drawable->id)))
gimp_drawable_is_gray(drawable->id)))
{
/*
* Set the tile cache size...

2
plug-ins/common/destripe.c
View File

@ -251,7 +251,7 @@ run(char *name, /* I - Name of filter program. */
if (status == STATUS_SUCCESS)
{
if ((gimp_drawable_color(drawable->id) ||
gimp_drawable_gray(drawable->id)))
gimp_drawable_is_gray(drawable->id)))
{
/*
* Set the tile cache size...

2
plug-ins/common/edge.c
View File

@ -226,7 +226,7 @@ run (gchar *name,
}
/* make sure the drawable exist and is not indexed */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init ("Edge detection...");

2
plug-ins/common/film.c
View File

@ -344,7 +344,7 @@ run (char *name,
else
{
values[1].data.d_int32 = image_ID;
gimp_image_enable_undo (image_ID);
gimp_image_undo_enable (image_ID);
gimp_image_clean_all (image_ID);
if (run_mode != RUN_NONINTERACTIVE)
gimp_display_new (image_ID);

2
plug-ins/common/flarefx.c
View File

@ -254,7 +254,7 @@ static void run (gchar *name,
if (status == STATUS_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
if (gimp_drawable_color (drawable->id) || gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init ("Render flare...");
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));

2
plug-ins/common/fp.c
View File

@ -92,7 +92,7 @@ run (char *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
mask=gimp_drawable_get(gimp_image_get_selection(param[1].data.d_image));
if (gimp_drawable_indexed (drawable->id) ||gimp_drawable_gray (drawable->id) ) {
if (gimp_drawable_is_indexed (drawable->id) ||gimp_drawable_is_gray (drawable->id) ) {
ErrorMessage("Convert the image to RGB first!");
status = STATUS_EXECUTION_ERROR;
}

2
plug-ins/common/fractaltrace.c
View File

@ -188,7 +188,7 @@ static void run( char *name, int argc, GParam *args, int *retc, GParam **rets )
pixels_init( drawable );
if( !gimp_drawable_color( drawable->id ) &&
!gimp_drawable_gray( drawable->id ) ){
!gimp_drawable_is_gray( drawable->id ) ){
status = STATUS_EXECUTION_ERROR;
}

2
plug-ins/common/gauss_iir.c
View File

@ -202,7 +202,7 @@ run (gchar *name,
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) ||
gimp_drawable_gray (drawable->id))
gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init ("IIR Gaussian Blur");

2
plug-ins/common/gauss_rle.c
View File

@ -195,7 +195,7 @@ run (gchar *name,
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) ||
gimp_drawable_gray (drawable->id))
gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init ("RLE Gaussian Blur");

4
plug-ins/common/gif.c
View File

@ -889,7 +889,7 @@ save_image (char *filename,
comment_parasite = parasite_new ("gimp-comment", PARASITE_PERSISTENT,
strlen (globalcomment)+1,
(void*) globalcomment);
gimp_image_attach_parasite (orig_image_ID, comment_parasite);
gimp_image_parasite_attach (orig_image_ID, comment_parasite);
parasite_free (comment_parasite);
comment_parasite = NULL;
}
@ -1349,7 +1349,7 @@ save_dialog ( gint32 image_ID )
g_free(globalcomment);
}
#ifdef FACEHUGGERS
GIF2_CMNT = gimp_image_find_parasite (image_ID, "gimp-comment");
GIF2_CMNT = gimp_image_parasite_find (image_ID, "gimp-comment");
if (GIF2_CMNT)
{
globalcomment = g_malloc(GIF2_CMNT->size);

2
plug-ins/common/gifload.c
View File

@ -422,7 +422,7 @@ load_image (char *filename)
#ifdef FACEHUGGERS
if (comment_parasite != NULL)
{
gimp_image_attach_parasite (image_ID, comment_parasite);
gimp_image_parasite_attach (image_ID, comment_parasite);
parasite_free (comment_parasite);
comment_parasite = NULL;
}

Some files were not shown because too many files have changed in this diff Show More