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

pdb, plug-ins: remove the rotate plug-in and add a PDB compat procedure

This commit is contained in:
Michael Natterer 2014-05-24 22:46:11 +02:00
parent 21ea6216f7
commit 3e6a7f4012
9 changed files with 161 additions and 562 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/pdb/internal-procs.c
View File

@ -28,7 +28,7 @@
#include "internal-procs.h"
/* 730 procedures registered total */
/* 731 procedures registered total */
void
internal_procs_init (GimpPDB *pdb)

100
app/pdb/plug-in-compat-cmds.c
View File

@ -33,10 +33,12 @@
#include "pdb-types.h"
#include "core/gimpchannel.h"
#include "core/gimpcontext.h"
#include "core/gimpdrawable-operation.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage-crop.h"
#include "core/gimpimage-rotate.h"
#include "core/gimpimage-undo.h"
#include "core/gimpimage.h"
#include "core/gimpparamspecs.h"
@ -1918,6 +1920,56 @@ plug_in_rgb_noise_invoker (GimpProcedure *procedure,
error ? *error : NULL);
}
static GimpValueArray *
plug_in_rotate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
GimpDrawable *drawable;
gint32 angle;
gboolean everything;
image = gimp_value_get_image (gimp_value_array_index (args, 1), gimp);
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp);
angle = g_value_get_int (gimp_value_array_index (args, 3));
everything = g_value_get_boolean (gimp_value_array_index (args, 4));
if (success)
{
GimpRotationType rotate_type = angle - 1;
if (everything)
{
gimp_image_rotate (image, context, rotate_type, progress);
}
else if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
GIMP_PDB_ITEM_CONTENT, error))
{
GimpItem *item = GIMP_ITEM (drawable);
gint off_x, off_y;
gdouble center_x, center_y;
gimp_item_get_offset (item, &off_x, &off_y);
center_x = ((gdouble) off_x + (gdouble) gimp_item_get_width (item) / 2.0);
center_y = ((gdouble) off_y + (gdouble) gimp_item_get_height (item) / 2.0);
gimp_item_rotate (item, context, rotate_type, center_x, center_y,
GIMP_IS_CHANNEL (drawable));
}
else
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
plug_in_noisify_invoker (GimpProcedure *procedure,
Gimp *gimp,
@ -4183,6 +4235,54 @@ register_plug_in_compat_procs (GimpPDB *pdb)
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plug-in-rotate
*/
procedure = gimp_procedure_new (plug_in_rotate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"plug-in-rotate");
gimp_procedure_set_static_strings (procedure,
"plug-in-rotate",
"Rotates a layer or the whole image by 90, 180 or 270 degrees",
"This plug-in does rotate the active layer or the whole image clockwise by multiples of 90 degrees. When the whole image is chosen, the image is resized if necessary.",
"Sven Neumann <sven@gimp.org>",
"Sven Neumann",
"2014",
NULL);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("run-mode",
"run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"Input image (unused)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"Input drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("angle",
"angle",
"Angle { 90 (1), 180 (2), 270 (3) } degrees",
1, 3, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("everything",
"everything",
"Rotate the whole image",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plug-in-noisify
*/

2
plug-ins/common/.gitignore vendored
View File

@ -192,8 +192,6 @@
/qbist.exe
/ripple
/ripple.exe
/rotate
/rotate.exe
/sample-colorize
/sample-colorize.exe
/screenshot

16
plug-ins/common/Makefile.am
View File

@ -139,7 +139,6 @@ libexec_PROGRAMS = \
procedure-browser \
qbist \
ripple \
rotate \
sample-colorize \
$(SCREENSHOT) \
sharpen \
@ -1860,21 +1859,6 @@ ripple_LDADD = \
$(INTLLIBS) \
$(ripple_RC)
rotate_SOURCES = \
rotate.c
rotate_LDADD = \
$(libgimp) \
$(libgimpmath) \
$(libgimpconfig) \
$(libgimpcolor) \
$(libgimpbase) \
$(CAIRO_LIBS) \
$(GDK_PIXBUF_LIBS) \
$(RT_LIBS) \
$(INTLLIBS) \
$(rotate_RC)
sample_colorize_SOURCES = \
sample-colorize.c

1
plug-ins/common/gimprc.common
View File

@ -93,7 +93,6 @@ plugin_browser_RC = plugin-browser.rc.o
procedure_browser_RC = procedure-browser.rc.o
qbist_RC = qbist.rc.o
ripple_RC = ripple.rc.o
rotate_RC = rotate.rc.o
sample_colorize_RC = sample-colorize.rc.o
screenshot_RC = screenshot.rc.o
sharpen_RC = sharpen.rc.o

1
plug-ins/common/plugin-defs.pl
View File

@ -94,7 +94,6 @@
'procedure-browser' => { ui => 1 },
'qbist' => { ui => 1 },
'ripple' => { ui => 1 },
'rotate' => {},
'sample-colorize' => { ui => 1 },
'screenshot' => { ui => 1, optional => 1, libs => 'SCREENSHOT_LIBS', cflags => 'XFIXES_CFLAGS', gegl => 1 },
'sharpen' => { ui => 1 },

538
plug-ins/common/rotate.c
View File

@ -1,538 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Rotate plug-in v1.0
* Copyright 1997-2000 by Sven Neumann <sven@gimp.org>
* & Adam D. Moss <adam@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* Revision history
* (09/28/97) v0.1 first development release
* (09/29/97) v0.2 nicer dialog,
* changed the menu-location to Filters/Transforms
* (10/01/97) v0.3 now handles layered images and undo
* (10/13/97) v0.3a small bugfix, no real changes
* (10/17/97) v0.4 now handles selections
* (01/09/98) v0.5 a few fixes to support portability
* (01/15/98) v0.6 fixed a line that caused rotate to crash on some
* systems
* (05/28/98) v0.7 use the new gimp_message function for error output
* (10/09/99) v0.8 rotate guides too
* (11/13/99) v0.9 merge rotators and rotate plug-ins
* -> drop the dialog, register directly into menus instead
* (06/18/00) v1.0 speed up 180° rotations,
* declare version 1.0 for gimp-1.2 release
*/
/* TODO List
* - handle channels and masks
* - rewrite the main function to make it work on tiles rather than
* process the image row by row. This should result in a significant
* speedup (thanks to quartic for this suggestion).
* - do something magical so that only one rotate can be occurring at a time!
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <libgimp/gimp.h>
#include "libgimp/stdplugins-intl.h"
/* Defines */
#define PLUG_IN_PROC "plug-in-rotate"
#define PLUG_IN_VERSION "v1.0 (2000/06/18)"
#define PLUG_IN_IMAGE_TYPES "RGB*, INDEXED*, GRAY*"
#define PLUG_IN_AUTHOR "Sven Neumann <sven@gimp.org>, Adam D. Moss <adam@gimp.org>"
#define PLUG_IN_COPYRIGHT "Sven Neumann, Adam D. Moss"
typedef struct
{
gint angle;
gint everything;
} RotateValues;
typedef struct
{
gint32 ID;
gint32 orientation;
gint32 position;
} GuideInfo;
static RotateValues rotvals =
{
1, /* default to 90 degrees */
1 /* default to whole image */
};
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static void rotate (void);
static void rotate_drawable (GimpDrawable *drawable);
static void rotate_compute_offsets (gint *offsetx,
gint *offsety,
gint image_width,
gint image_height,
gint width,
gint height);
/* Global Variables */
const GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run /* run_proc */
};
/* the image and drawable that will be used later */
static GimpDrawable *active_drawable = NULL;
static gint32 image_ID = -1;
/* Functions */
MAIN ()
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "angle", "Angle { 90 (1), 180 (2), 270 (3) } degrees" },
{ GIMP_PDB_INT32, "everything", "Rotate the whole image { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
"Rotates a layer or the whole image by 90, 180 or 270 degrees",
"This plug-in does rotate the active layer or the "
"whole image clockwise by multiples of 90 degrees. "
"When the whole image is chosen, the image is "
"resized if necessary.",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
PLUG_IN_VERSION,
NULL,
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
static GimpParam values[1];
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N ();
image_ID = param[1].data.d_int32;
active_drawable = gimp_drawable_get (param[2].data.d_drawable);
if (strcmp (name, PLUG_IN_PROC) == 0)
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_NONINTERACTIVE:
/* check to see if invoked with the correct number of parameters */
if (nparams == 5)
{
rotvals.angle = (gint) param[3].data.d_int32;
rotvals.angle = rotvals.angle % 4;
rotvals.everything = (gint) param[4].data.d_int32;
/* Store variable states for next run */
gimp_set_data (PLUG_IN_PROC, &rotvals, sizeof (RotateValues));
}
else
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &rotvals);
rotvals.angle = rotvals.angle % 4;
break;
default:
break;
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
/* Run the main function */
rotate ();
/* If run mode is interactive, flush displays, else (script) don't
do it, as the screen updates would make the scripts slow */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
values[0].data.d_status = status;
}
static void
rotate_compute_offsets (gint *offsetx,
gint *offsety,
gint image_width,
gint image_height,
gint width,
gint height)
{
gint buffer;
if (rotvals.everything) /* rotate around the image center */
{
switch (rotvals.angle)
{
case 1: /* 90° */
buffer = *offsetx;
*offsetx = image_height - *offsety - height;
*offsety = buffer;
break;
case 2: /* 180° */
*offsetx = image_width - *offsetx - width;
*offsety = image_height - *offsety - height;
break;
case 3: /* 270° */
buffer = *offsetx;
*offsetx = *offsety;
*offsety = image_width - buffer - width;
}
}
else /* rotate around the drawable center */
{
if (rotvals.angle != 2)
{
*offsetx = *offsetx + (width-height)/2 ;
*offsety = *offsety + (height-width)/2 ;
}
}
return;
}
static void
rotate_drawable (GimpDrawable *drawable)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
gint longside;
gint bytes;
gint row, col;
gint offsetx, offsety;
gboolean was_lock_alpha = FALSE;
guchar *buffer;
guchar *src_row, *dest_row;
/* Get the size of the input drawable. */
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
if (gimp_layer_get_lock_alpha (drawable->drawable_id))
{
was_lock_alpha = TRUE;
gimp_layer_set_lock_alpha (drawable->drawable_id, FALSE);
}
if (rotvals.angle == 2) /* we're rotating by 180° */
{
gimp_tile_cache_ntiles (2 * (width / gimp_tile_width() + 1));
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height,
TRUE, TRUE);
src_row = (guchar *) g_malloc (width * bytes);
dest_row = (guchar *) g_malloc (width * bytes);
for (row = 0; row < height; row++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, 0, row, width);
for (col = 0; col < width; col++)
{
memcpy (dest_row + col * bytes,
src_row + (width - 1 - col) * bytes,
bytes);
}
gimp_pixel_rgn_set_row (&destPR, dest_row, 0, (height - row - 1),
width);
if ((row % 5) == 0)
gimp_progress_update ((double) row / (double) height);
}
g_free (src_row);
g_free (dest_row);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, width, height);
}
else /* we're rotating by 90° or 270° */
{
(width > height) ? (longside = width) : (longside = height);
gimp_layer_resize (drawable->drawable_id, longside, longside, 0, 0);
drawable = gimp_drawable_get (drawable->drawable_id);
gimp_drawable_flush (drawable);
gimp_tile_cache_ntiles ((longside / gimp_tile_width () + 1) +
(longside / gimp_tile_height () + 1));
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, longside, longside,
FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, longside, longside,
TRUE, TRUE);
buffer = g_malloc (longside * bytes);
if (rotvals.angle == 1) /* we're rotating by 90° */
{
for (row = 0; row < height; row++)
{
gimp_pixel_rgn_get_row (&srcPR, buffer, 0, row, width);
gimp_pixel_rgn_set_col (&destPR, buffer, (height - row - 1), 0,
width);
if ((row % 5) == 0)
gimp_progress_update ((double) row / (double) height);
}
}
else /* we're rotating by 270° */
{
for (col = 0; col < width; col++)
{
gimp_pixel_rgn_get_col (&srcPR, buffer, col, 0, height);
gimp_pixel_rgn_set_row (&destPR, buffer, 0, (width - col - 1),
height);
if ((col % 5) == 0)
gimp_progress_update ((double) col / (double) width);
}
}
g_free (buffer);
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, height, width);
gimp_layer_resize (drawable->drawable_id, height, width, 0, 0);
drawable = gimp_drawable_get (drawable->drawable_id);
gimp_drawable_flush (drawable);
gimp_drawable_update (drawable->drawable_id, 0, 0, height, width);
}
gimp_drawable_offsets (drawable->drawable_id, &offsetx, &offsety);
rotate_compute_offsets (&offsetx, &offsety,
gimp_image_width (image_ID),
gimp_image_height (image_ID),
width, height);
gimp_layer_set_offsets (drawable->drawable_id, offsetx, offsety);
if (was_lock_alpha)
gimp_layer_set_lock_alpha (drawable->drawable_id, TRUE);
return;
}
/* The main rotate function */
static void
rotate (void)
{
GimpDrawable *drawable;
gint32 *layers;
gint i;
gint nlayers;
gint32 guide_ID;
GuideInfo *guide;
GList *guides = NULL;
GList *list;
if (rotvals.angle == 0) return;
/* if there's a selection and we try to rotate the whole image */
/* create an error message and exit */
if (rotvals.everything)
{
if (! gimp_selection_is_empty (image_ID))
{
gimp_message (_("You can not rotate the whole image if there's a selection."));
gimp_drawable_detach (active_drawable);
return;
}
if (gimp_item_is_layer (active_drawable->drawable_id) &&
gimp_layer_is_floating_sel (active_drawable->drawable_id))
{
gimp_message (_("You can not rotate the whole image if there's a floating selection."));
gimp_drawable_detach (active_drawable);
return;
}
}
else
/* if we are trying to rotate a channel or a mask,
create an error message and exit */
{
if (! gimp_item_is_layer (active_drawable->drawable_id))
{
gimp_message (_("Sorry, channels and masks can not be rotated."));
gimp_drawable_detach (active_drawable);
return;
}
}
gimp_progress_init (_("Rotating"));
gimp_image_undo_group_start (image_ID);
if (rotvals.everything) /* rotate the whole image */
{
gint32 width = gimp_image_width (image_ID);
gint32 height = gimp_image_height (image_ID);
gimp_drawable_detach (active_drawable);
layers = gimp_image_get_layers (image_ID, &nlayers);
for (i = 0; i < nlayers; i++)
{
drawable = gimp_drawable_get (layers[i]);
rotate_drawable (drawable);
gimp_drawable_detach (drawable);
}
g_free (layers);
/* build a list of all guides and remove them */
guide_ID = 0;
while ((guide_ID = gimp_image_find_next_guide (image_ID, guide_ID)) != 0)
{
guide = g_new (GuideInfo, 1);
guide->ID = guide_ID;
guide->orientation = gimp_image_get_guide_orientation (image_ID,
guide_ID);
guide->position = gimp_image_get_guide_position (image_ID, guide_ID);
guides = g_list_prepend (guides, guide);
}
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *) list->data;
gimp_image_delete_guide (image_ID, guide->ID);
}
/* if rotation is not 180 degrees, resize the image */
/* Do it now after the guides are removed, since */
/* gimp_image_resize() moves the guides. */
if (rotvals.angle != 2)
gimp_image_resize (image_ID, height, width, 0, 0);
/* add the guides back to the image */
if (guides)
{
switch (rotvals.angle)
{
case 1:
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *)list->data;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_image_add_vguide (image_ID, height - guide->position);
else
gimp_image_add_hguide (image_ID, guide->position);
g_free (guide);
}
break;
case 2:
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *)list->data;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_image_add_hguide (image_ID, height - guide->position);
else
gimp_image_add_vguide (image_ID, width - guide->position);
g_free (guide);
}
break;
case 3:
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *)list->data;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_image_add_vguide (image_ID, guide->position);
else
gimp_image_add_hguide (image_ID, width - guide->position);
g_free (guide);
}
break;
default:
break;
}
g_list_free (guides);
}
}
else /* rotate only the active layer */
{
/* check for active selection and float it */
if (! gimp_selection_is_empty (image_ID) &&
! gimp_layer_is_floating_sel (active_drawable->drawable_id))
{
active_drawable =
gimp_drawable_get (gimp_selection_float (image_ID,
active_drawable->drawable_id,
0, 0));
}
rotate_drawable (active_drawable);
gimp_drawable_detach (active_drawable);
}
gimp_image_undo_group_end (image_ID);
return;
}

1
po-plug-ins/POTFILES.in
View File

@ -101,7 +101,6 @@ plug-ins/common/plugin-browser.c
plug-ins/common/procedure-browser.c
plug-ins/common/qbist.c
plug-ins/common/ripple.c
plug-ins/common/rotate.c
plug-ins/common/sample-colorize.c
plug-ins/common/screenshot.c
plug-ins/common/sharpen.c

62
tools/pdbgen/pdb/plug_in_compat.pdb
View File

@ -1996,6 +1996,62 @@ CODE
);
}
sub plug_in_rotate {
$blurb = 'Rotates a layer or the whole image by 90, 180 or 270 degrees';
$help = <<'HELP';
This plug-in does rotate the active layer or the whole image clockwise
by multiples of 90 degrees. When the whole image is chosen, the image
is resized if necessary.
HELP
&neo_pdb_misc;
$date = '2014';
@inargs = (
{ name => 'run_mode', type => 'enum GimpRunMode', dead => 1,
desc => 'The run mode' },
{ name => 'image', type => 'image',
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'angle', type => '1 <= int32 <= 3',
desc => 'Angle { 90 (1), 180 (2), 270 (3) } degrees' },
{ name => 'everything', type => 'boolean',
desc => 'Rotate the whole image' }
);
%invoke = (
code => <<'CODE'
{
GimpRotationType rotate_type = angle - 1;
if (everything)
{
gimp_image_rotate (image, context, rotate_type, progress);
}
else if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
GIMP_PDB_ITEM_CONTENT, error))
{
GimpItem *item = GIMP_ITEM (drawable);
gint off_x, off_y;
gdouble center_x, center_y;
gimp_item_get_offset (item, &off_x, &off_y);
center_x = ((gdouble) off_x + (gdouble) gimp_item_get_width (item) / 2.0);
center_y = ((gdouble) off_y + (gdouble) gimp_item_get_height (item) / 2.0);
gimp_item_rotate (item, context, rotate_type, center_x, center_y,
GIMP_IS_CHANNEL (drawable));
}
else
success = FALSE;
}
CODE
);
}
sub plug_in_noisify {
$blurb = 'Adds random noise to image channels';
@ -2603,10 +2659,11 @@ CODE
"libgimpmath/gimpmath.h"
"gegl/gimp-babl.h"
"gegl/gimp-gegl-utils.h"
"core/gimpchannel.h"
"core/gimpcontext.h"
"core/gimpdrawable.h"
"core/gimpdrawable-operation.h"
"core/gimpimage-crop.h"
"core/gimpimage-rotate.h"
"core/gimpimage-undo.h"
"core/gimppickable.h"
"core/gimppickable-auto-shrink.h"
@ -2647,6 +2704,7 @@ CODE
plug_in_randomize_pick
plug_in_randomize_slur
plug_in_rgb_noise
plug_in_rotate
plug_in_noisify
plug_in_semiflatten
plug_in_shift
@ -2661,6 +2719,6 @@ CODE
$desc = 'Plug-In Compat';
$doc_title = 'plugincolor';
$doc_short_desc = 'Compatibility for removed plug-ins.';
$doc_long_desc = 'Functions that perform the operation of removed plug-ins using GEGL operations.';
$doc_long_desc = 'Functions that perform the operation of removed plug-ins using GEGL operations or other GIMP internal functions.';
1;