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

plug-ins/FractalExplorer/FractalExplorer.c 

2004-05-07  Michael Natterer  <mitch@gimp.org>

	* plug-ins/FractalExplorer/FractalExplorer.c
	* plug-ins/Lighting/lighting_main.c
	* plug-ins/MapObject/mapobject_main.c
	* plug-ins/dbbrowser/dbbrowser.c
	* plug-ins/flame/flame.c
	* plug-ins/gimpressionist/gimp.c
	* plug-ins/ifscompose/ifscompose.c
	* plug-ins/imagemap/imap_main.c
	* plug-ins/maze/maze.c
	* plug-ins/pagecurl/pagecurl.c
	* plug-ins/print/print.c
	* plug-ins/rcm/rcm.c
	* plug-ins/winsnap/winsnap.c
	* plug-ins/common/[g-z]*.c: use gimp_plugin_menu_register(). Some
	formatting cleanups in some query() functions.
This commit is contained in:
Michael Natterer 2004-05-07 13:15:52 +00:00 committed by Michael Natterer
parent 9b7196a0b7
commit bbeef1a8d2
81 changed files with 674 additions and 374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ChangeLog
View File

@ -1,3 +1,21 @@
2004-05-07 Michael Natterer <mitch@gimp.org>
* plug-ins/FractalExplorer/FractalExplorer.c
* plug-ins/Lighting/lighting_main.c
* plug-ins/MapObject/mapobject_main.c
* plug-ins/dbbrowser/dbbrowser.c
* plug-ins/flame/flame.c
* plug-ins/gimpressionist/gimp.c
* plug-ins/ifscompose/ifscompose.c
* plug-ins/imagemap/imap_main.c
* plug-ins/maze/maze.c
* plug-ins/pagecurl/pagecurl.c
* plug-ins/print/print.c
* plug-ins/rcm/rcm.c
* plug-ins/winsnap/winsnap.c
* plug-ins/common/[g-z]*.c: use gimp_plugin_menu_register(). Some
formatting cleanups in some query() functions.
2004-05-07 Michael Natterer <mitch@gimp.org>
* app/plug-in/plug-in-proc.[ch]: removed member "accelerator".

5
plug-ins/FractalExplorer/FractalExplorer.c
View File

@ -258,11 +258,14 @@ query (void)
"Daniel Cotting (cotting@multimania.com, www.multimania.com/cotting)",
"Daniel Cotting (cotting@multimania.com, www.multimania.com/cotting)",
"December, 1998",
N_("<Image>/Filters/Render/_Fractal Explorer..."),
N_("_Fractal Explorer..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_fractalexplorer",
N_("<Image>/Filters/Render"));
}
/**********************************************************************

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

@ -164,11 +164,14 @@ query (void)
"Tom Bech & Federico Mena Quintero",
"Tom Bech & Federico Mena Quintero",
"Version 0.2.0, March 15 1998",
N_("<Image>/Filters/Light Effects/_Lighting Effects..."),
N_("_Lighting Effects..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_lighting",
N_("<Image>/Filters/Light Effects"));
}
static void

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

@ -197,11 +197,14 @@ query (void)
"Tom Bech & Federico Mena Quintero",
"Tom Bech & Federico Mena Quintero",
"Version 1.2.0, July 16 1998",
N_("<Image>/Filters/Map/Map _Object..."),
N_("Map _Object..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_map_object",
N_("<Image>/Filters/Map"));
}
static void

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

@ -161,11 +161,14 @@ query (void)
"Spencer Kimball, Peter Mattis & Sven Neumann",
"Spencer Kimball, Peter Mattis & Sven Neumann",
"1995-2000",
N_("<Image>/Filters/Blur/Gaussian Blur (_IIR)..."),
N_("Gaussian Blur (_IIR)..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args2), 0,
args2, NULL);
gimp_plugin_menu_register ("plug_in_gauss_iir2",
N_("<Image>/Filters/Blur"));
}
static void

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

@ -155,11 +155,14 @@ query (void)
"Spencer Kimball, Peter Mattis & Sven Neumann",
"Spencer Kimball, Peter Mattis & Sven Neumann",
"1995-2000",
N_("<Image>/Filters/Blur/Gaussian Blur (_RLE)..."),
N_("Gaussian Blur (_RLE)..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args2), 0,
args2, NULL);
gimp_plugin_menu_register ("plug_in_gauss_rle2",
N_("<Image>/Filters/Blur"));
}
static void

31
plug-ins/common/gee.c
View File

@ -83,22 +83,25 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Must be interactive (1)" },
{ GIMP_PDB_IMAGE, "image", "Input Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input Drawable" },
{ GIMP_PDB_INT32, "run_mode", "Must be interactive (1)" },
{ GIMP_PDB_IMAGE, "image", "Input Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input Drawable" }
};
gimp_install_procedure("plug_in_the_slimy_egg",
"A big hello from the GIMP team!",
"Beyond help.",
"Adam D. Moss <adam@gimp.org>",
"Adam D. Moss <adam@gimp.org>",
"2000",
N_("<Image>/Filters/Toys/Gee-_Slime"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_install_procedure ("plug_in_the_slimy_egg",
"A big hello from the GIMP team!",
"Beyond help.",
"Adam D. Moss <adam@gimp.org>",
"Adam D. Moss <adam@gimp.org>",
"2000",
N_("Gee-_Slime"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_the_slimy_egg",
N_("<Image>/Filters/Toys"));
}
static void

35
plug-ins/common/gee_zoom.c
View File

@ -121,22 +121,25 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Must be interactive (1)" },
{ GIMP_PDB_IMAGE, "image", "Input Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input Drawable" },
{ GIMP_PDB_INT32, "run_mode", "Must be interactive (1)" },
{ GIMP_PDB_IMAGE, "image", "Input Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input Drawable" }
};
gimp_install_procedure("plug_in_the_old_egg",
"A big hello from the GIMP team!",
"Hay-ulp",
"Adam D. Moss <adam@gimp.org>",
"Adam D. Moss <adam@gimp.org>",
"1998",
N_("<Image>/Filters/Toys/Gee-_Zoom"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_install_procedure ("plug_in_the_old_egg",
"A big hello from the GIMP team!",
"Hay-ulp",
"Adam D. Moss <adam@gimp.org>",
"Adam D. Moss <adam@gimp.org>",
"1998",
N_("Gee-_Zoom"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_the_old_egg",
N_("<Image>/Filters/Toys"));
}
static void
@ -147,10 +150,10 @@ run (const gchar *name,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gr = g_rand_new();
gr = g_rand_new ();
*nreturn_vals = 1;
*return_vals = values;

15
plug-ins/common/glasstile.c
View File

@ -98,11 +98,11 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "tilex", "Tile width (10 - 50)" },
{ GIMP_PDB_INT32, "tiley", "Tile height (10 - 50)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "tilex", "Tile width (10 - 50)" },
{ GIMP_PDB_INT32, "tiley", "Tile height (10 - 50)" }
};
gimp_install_procedure ("plug_in_glasstile",
@ -112,11 +112,14 @@ query (void)
"Karl-Johan Andersson", /* Author */
"Karl-Johan Andersson", /* Copyright */
"May 2000",
N_("<Image>/Filters/Glass Effects/_Glass Tile..."),
N_("_Glass Tile..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_glasstile",
N_("<Image>/Filters/Glass Effects"));
}
static void

11
plug-ins/common/gqbist.c
View File

@ -425,9 +425,9 @@ query (void)
{
GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_install_procedure (PLUG_IN_NAME,
@ -436,11 +436,14 @@ query (void)
"Jörn Loviscach, Jens Ch. Restemeier",
"Jörn Loviscach, Jens Ch. Restemeier",
PLUG_IN_VERSION,
N_("<Image>/Filters/Render/Pattern/_Qbist..."),
N_("_Qbist..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Render/Pattern"));
}
static void

11
plug-ins/common/gradmap.c
View File

@ -98,9 +98,9 @@ query()
{
static GimpParamDef args[]=
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_install_procedure ("plug_in_gradmap",
@ -118,11 +118,14 @@ query()
"Eiichi Takamori",
"Eiichi Takamori",
"1997",
N_("<Image>/Filters/Colors/Map/_Gradient Map"),
N_("_Gradient Map"),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_gradmap",
N_("<Image>/Filters/Colors/Map"));
}
static void

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

@ -149,11 +149,14 @@ void query (void)
"Tim Newsome",
"Tim Newsome, Sven Neumann, Tom Rathborne, TC",
"1997 - 2000",
N_("<Image>/Filters/Render/Pattern/_Grid..."),
N_("_Grid..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_grid",
N_("<Image>/Filters/Render/Pattern"));
}
static void

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

@ -76,11 +76,14 @@ query (void)
"Adam D. Moss (adam@foxbox.org)",
"Adam D. Moss (adam@foxbox.org)",
"1998",
N_("<Image>/Image/Transform/_Guillotine"),
N_("_Guillotine"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_guillotine",
N_("<Image>/Image/Transform"));
}
static void

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

@ -214,11 +214,14 @@ query (void)
"Eric L. Hernes, Alan Wm Paeth",
"Eric L. Hernes",
"1997",
N_("<Image>/Filters/Colors/_Hot..."),
N_("_Hot..."),
"RGB",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_hot",
N_("<Image>/Filters/Colors"));
}
static void

13
plug-ins/common/illusion.c
View File

@ -89,10 +89,10 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "interactive / non-interactive" },
{ GIMP_PDB_IMAGE, "image", "input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "input drawable" },
{ GIMP_PDB_INT32, "division", "the number of divisions" },
{ GIMP_PDB_INT32, "run_mode", "interactive / non-interactive" },
{ GIMP_PDB_IMAGE, "image", "input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "input drawable" },
{ GIMP_PDB_INT32, "division", "the number of divisions" },
{ GIMP_PDB_INT32, "type", "illusion type (0=type1, 1=type2)" }
};
@ -102,11 +102,14 @@ query (void)
"Hirotsuna Mizuno <s1041150@u-aizu.ac.jp>",
"Hirotsuna Mizuno",
PLUG_IN_VERSION,
N_("<Image>/Filters/Map/_Illusion..."),
N_("_Illusion..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Map"));
}
static void

11
plug-ins/common/iwarp.c
View File

@ -246,9 +246,9 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_install_procedure ("plug_in_iwarp",
@ -257,11 +257,14 @@ query (void)
"Norbert Schmitz",
"Norbert Schmitz",
"1997",
N_("<Image>/Filters/Distorts/_IWarp..."),
N_("_IWarp..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_iwarp",
N_("<Image>/Filters/Distorts"));
}
static void

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

@ -405,11 +405,14 @@ query (void)
"Nigel Wetten",
"Nigel Wetten",
"May 2000",
N_("<Image>/Filters/Render/Pattern/_Jigsaw..."),
N_("_Jigsaw..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_jigsaw",
N_("<Image>/Filters/Render/Pattern"));
}
static void

9
plug-ins/common/laplace.c
View File

@ -20,7 +20,7 @@
/* Based on S&P's Gauss and Laplace filters */
/* updated 1/30/03: <sjburges@gimp.org>
* fixed an off-by-1 error that was causing an attempt to read a
* fixed an off-by-1 error that was causing an attempt to read a
* get_pixel_by_row at the -1'th row
*/
@ -92,11 +92,14 @@ query (void)
"Thorsten Schnier",
"Thorsten Schnier",
"1997",
N_("<Image>/Filters/Edge-Detect/_Laplace"),
N_("_Laplace"),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_laplace",
N_("<Image>/Filters/Edge-Detect"));
}
static void
@ -158,7 +161,7 @@ laplace_prepare_row (GimpPixelRgn *pixel_rgn,
gimp_pixel_rgn_get_row (pixel_rgn, data, x, (y - 1), w);
else
gimp_pixel_rgn_get_row (pixel_rgn, data, x, y, w);
/* Fill in edge pixels */
for (b = 0; b < pixel_rgn->bpp; b++)
{

9
plug-ins/common/lic.c
View File

@ -785,8 +785,8 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_INT32, "run_mode", "Interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
@ -796,11 +796,14 @@ query (void)
"Tom Bech & Federico Mena Quintero",
"Tom Bech & Federico Mena Quintero",
"Version 0.14, September 24 1997",
N_("<Image>/Filters/Map/_Van Gogh (LIC)..."),
N_("_Van Gogh (LIC)..."),
"RGB",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_lic",
N_("<Image>/Filters/Map"));
}
static void

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

@ -211,11 +211,14 @@ query (void)
"Adrian Likins, Reagan Blundell",
"Adrian Likins, Reagan Blundell, Daniel Risacher, Spencer Kimball and Peter Mattis",
"1995-1997",
N_("<Image>/File/Send/_Mail Image..."),
N_("_Mail Image..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_mail_image",
N_("<Image>/File/Send"));
}
static void

10
plug-ins/common/mapcolor.c
View File

@ -332,12 +332,15 @@ query (void)
"Peter Kirchgessner",
"Peter Kirchgessner",
dversio,
N_("<Image>/Filters/Colors/Map/Adjust _FG-BG"),
N_("Adjust _FG-BG"),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (adjust_args), 0,
adjust_args, NULL);
gimp_plugin_menu_register ("plug_in_color_adjust",
N_("<Image>/Filters/Colors/Map"));
gimp_install_procedure ("plug_in_color_map",
"Map color range specified by two colors"
"to color range specified by two other color.",
@ -347,11 +350,14 @@ query (void)
"Peter Kirchgessner",
"Peter Kirchgessner",
dversio,
N_("<Image>/Filters/Colors/Map/Color Range _Mapping..."),
N_("Color Range _Mapping..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (map_args), 0,
map_args, NULL);
gimp_plugin_menu_register ("plug_in_color_map",
N_("<Image>/Filters/Colors/Map"));
}

13
plug-ins/common/max_rgb.c
View File

@ -94,10 +94,10 @@ query (void)
{
static GimpParamDef args [] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{ GIMP_PDB_IMAGE, "image", "Input image (not used)"},
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable"},
{ GIMP_PDB_INT32, "max_p", "1 for maximizing, 0 for minimizing"}
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (not used)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "max_p", "1 for maximizing, 0 for minimizing" }
};
gimp_install_procedure (PLUG_IN_NAME,
@ -109,11 +109,14 @@ query (void)
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"May 2000",
N_("<Image>/Filters/Colors/_Max RGB..."),
N_("_Max RGB..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Colors"));
}
static void

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

@ -147,11 +147,14 @@ query (void)
"Torsten Martinsen, Federico Mena Quintero and Daniel Skarda",
"Torsten Martinsen, Federico Mena Quintero and Daniel Skarda",
PLUG_IN_VERSION,
N_("<Image>/Filters/Blur/_Motion Blur..."),
N_("_Motion Blur..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Blur"));
}
static void

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

@ -306,11 +306,14 @@ query (void)
"Spencer Kimball",
"Spencer Kimball & Peter Mattis",
"1996",
N_("<Image>/Filters/Distorts/_Mosaic..."),
N_("_Mosaic..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), nreturn_vals,
args, return_vals);
gimp_plugin_menu_register ("plug_in_mosaic",
N_("<Image>/Filters/Distorts"));
}
static void

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

@ -535,11 +535,14 @@ query (void)
"Austin Donnelly",
"Austin Donnelly",
"1998 (" VERSION ")",
N_("<Image>/Filters/Distorts/Newsprin_t..."),
N_("Newsprin_t..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_newsprint",
N_("<Image>/Filters/Distorts"));
}
static void

17
plug-ins/common/nlfilt.c
View File

@ -111,12 +111,12 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "img", "The Image to Filter" },
{ GIMP_PDB_DRAWABLE, "drw", "The Drawable" },
{ GIMP_PDB_FLOAT, "alpha", "The amount of the filter to apply" },
{ GIMP_PDB_FLOAT, "radius", "The filter radius" },
{ GIMP_PDB_INT32, "filter", "The Filter to Run, 0 - alpha trimmed mean; 1 - optimal estimation (alpha controls noise variance); 2 - edge enhancement" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "img", "The Image to Filter" },
{ GIMP_PDB_DRAWABLE, "drw", "The Drawable" },
{ GIMP_PDB_FLOAT, "alpha", "The amount of the filter to apply" },
{ GIMP_PDB_FLOAT, "radius", "The filter radius" },
{ GIMP_PDB_INT32, "filter", "The Filter to Run, 0 - alpha trimmed mean; 1 - optimal estimation (alpha controls noise variance); 2 - edge enhancement" }
};
gimp_install_procedure ("plug_in_nlfilt",
@ -125,11 +125,14 @@ query (void)
"Graeme W. Gill, gimp 0.99 plugin by Eric L. Hernes",
"Graeme W. Gill, Eric L. Hernes",
"1997",
N_("<Image>/Filters/Enhance/_NL Filter..."),
N_("_NL Filter..."),
"RGB,GRAY",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_nlfilt",
N_("<Image>/Filters/Enhance"));
}
static void

21
plug-ins/common/noisify.c
View File

@ -110,14 +110,14 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "independent", "Noise in channels independent" },
{ GIMP_PDB_FLOAT, "noise_1", "Noise in the first channel (red, gray)" },
{ GIMP_PDB_FLOAT, "noise_2", "Noise in the second channel (green, gray_alpha)" },
{ GIMP_PDB_FLOAT, "noise_3", "Noise in the third channel (blue)" },
{ GIMP_PDB_FLOAT, "noise_4", "Noise in the fourth channel (alpha)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "independent", "Noise in channels independent" },
{ GIMP_PDB_FLOAT, "noise_1", "Noise in the first channel (red, gray)" },
{ GIMP_PDB_FLOAT, "noise_2", "Noise in the second channel (green, gray_alpha)" },
{ GIMP_PDB_FLOAT, "noise_3", "Noise in the third channel (blue)" },
{ GIMP_PDB_FLOAT, "noise_4", "Noise in the fourth channel (alpha)" }
};
gimp_install_procedure ("plug_in_noisify",
@ -126,11 +126,14 @@ query (void)
"Torsten Martinsen",
"Torsten Martinsen",
"May 2000",
N_("<Image>/Filters/Noise/_Noisify..."),
N_("_Noisify..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_noisify",
N_("<Image>/Filters/Noise"));
}
static void

9
plug-ins/common/normalize.c
View File

@ -68,8 +68,8 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
@ -87,11 +87,14 @@ query (void)
"Adam D. Moss, Federico Mena Quintero",
"Adam D. Moss, Federico Mena Quintero",
"1997",
N_("<Image>/Layer/Colors/Auto/_Normalize"),
N_("_Normalize"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_normalize",
N_("<Image>/Layer/Colors/Auto"));
}
static void

7
plug-ins/common/nova.c
View File

@ -192,12 +192,15 @@ query (void)
"Eiichi Takamori",
"Eiichi Takamori",
"May 2000",
/* don't translate '<Image>' */
N_("<Image>/Filters/Light Effects/Su_perNova..."),
N_("Su_perNova..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_nova",
/* don't translate '<Image>' */
N_("<Image>/Filters/Light Effects"));
}
static void

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

@ -103,11 +103,14 @@ query (void)
"Torsten Martinsen",
"Torsten Martinsen",
"1996",
N_("<Image>/Filters/Artistic/Oili_fy..."),
N_("Oili_fy..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_oilify",
N_("<Image>/Filters/Artistic"));
}
static void

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

@ -821,11 +821,14 @@ plugin_query (void)
"Hirotsuna Mizuno <s1041150@u-aizu.ac.jp>",
"Copyright (c)1997-1999 Hirotsuna Mizuno",
_("September 31, 1999"),
N_("<Image>/Filters/Map/_Paper Tile..."),
N_("_Paper Tile..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUGIN_PROCEDURE_NAME,
N_("<Image>/Filters/Map"));
}
static void

36
plug-ins/common/pixelize.c
View File

@ -147,36 +147,44 @@ query (void)
{
static GimpParamDef pixelize_args[]=
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "pixelwidth", "Pixel width (the decrease in resolution)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "pixelwidth", "Pixel width (the decrease in resolution)" }
};
static GimpParamDef pixelize2_args[]=
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "pixelwidth", "Pixel width (the decrease in horizontal resolution)" },
{ GIMP_PDB_INT32, "pixelheight", "Pixel height (the decrease in vertical resolution)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "pixelwidth", "Pixel width (the decrease in horizontal resolution)" },
{ GIMP_PDB_INT32, "pixelheight", "Pixel height (the decrease in vertical resolution)" }
};
gimp_install_procedure ("plug_in_pixelize",
"Pixelize the contents of the specified drawable",
"Pixelize the contents of the specified drawable with speficied pixelizing width.",
"Spencer Kimball & Peter Mattis, Tracy Scott, (ported to 1.0 by) Eiichi Takamori",
"Pixelize the contents of the specified drawable "
"with speficied pixelizing width.",
"Spencer Kimball & Peter Mattis, Tracy Scott, "
"(ported to 1.0 by) Eiichi Takamori",
"Spencer Kimball & Peter Mattis, Tracy Scott",
"1995",
N_("<Image>/Filters/Blur/_Pixelize..."),
N_("_Pixelize..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (pixelize_args), 0,
pixelize_args, NULL);
gimp_plugin_menu_register ("plug_in_pixelize",
N_("<Image>/Filters/Blur"));
gimp_install_procedure ("plug_in_pixelize2",
"Pixelize the contents of the specified drawable",
"Pixelize the contents of the specified drawable with speficied pixelizing width.",
"Spencer Kimball & Peter Mattis, Tracy Scott, (ported to 1.0 by) Eiichi Takamori",
"Pixelize the contents of the specified drawable "
"with speficied pixelizing width.",
"Spencer Kimball & Peter Mattis, Tracy Scott, "
"(ported to 1.0 by) Eiichi Takamori",
"Spencer Kimball & Peter Mattis, Tracy Scott",
"2001",
NULL,

8
plug-ins/common/plasma.c
View File

@ -176,16 +176,20 @@ query (void)
};
gimp_install_procedure ("plug_in_plasma",
"Create a plasma cloud like image on the specified drawable",
"Create a plasma cloud like image on the "
"specified drawable",
"More help",
"Stephen Norris & (ported to 1.0 by) Eiichi Takamori",
"Stephen Norris",
"May 2000",
N_("<Image>/Filters/Render/Clouds/_Plasma..."),
N_("_Plasma..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_plasma",
N_("<Image>/Filters/Render/Clouds"));
}
static void

5
plug-ins/common/plugin-browser.c
View File

@ -150,11 +150,14 @@ query (void)
"Andy Thomas",
"Andy Thomas",
"1999",
N_("<Toolbox>/Xtns/Extensions/_Plugin Details"),
N_("_Plugin Details"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_plug_in_details",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

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

@ -150,11 +150,14 @@ query (void)
"Andy Thomas",
"Andy Thomas",
"1999",
N_("<Toolbox>/Xtns/Extensions/_Plugin Details"),
N_("_Plugin Details"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_plug_in_details",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

22
plug-ins/common/polar.c
View File

@ -156,27 +156,31 @@ query (void)
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "circle", "Circle depth in %" },
{ GIMP_PDB_FLOAT, "angle", "Offset angle" },
{ GIMP_PDB_INT32, "backwards", "Map backwards?" },
{ GIMP_PDB_INT32, "inverse", "Map from top?" },
{ GIMP_PDB_INT32, "polrec", "Polar to rectangular?" }
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "circle", "Circle depth in %" },
{ GIMP_PDB_FLOAT, "angle", "Offset angle" },
{ GIMP_PDB_INT32, "backwards", "Map backwards?" },
{ GIMP_PDB_INT32, "inverse", "Map from top?" },
{ GIMP_PDB_INT32, "polrec", "Polar to rectangular?" }
};
gimp_install_procedure (PLUG_IN_NAME,
"Converts and image to and from polar coords",
"Remaps and image from rectangular coordinates to polar coordinates "
"Remaps and image from rectangular coordinates "
"to polar coordinates "
"or vice versa",
"Daniel Dunbar and Federico Mena Quintero",
"Daniel Dunbar and Federico Mena Quintero",
PLUG_IN_VERSION,
N_("<Image>/Filters/Distorts/P_olar Coords..."),
N_("P_olar Coords..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Distorts"));
}
static void

5
plug-ins/common/procedure-browser.c
View File

@ -86,11 +86,14 @@ query (void)
"Thomas Noel",
"Thomas Noel",
"23th june 1997",
N_("<Toolbox>/Xtns/Extensions/_DB Browser"),
N_("_DB Browser"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_db_browser",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

70
plug-ins/common/randomize.c
View File

@ -200,13 +200,13 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "rndm_pct", "Randomization percentage (1.0 - 100.0)" },
{ GIMP_PDB_FLOAT, "rndm_rcount", "Repeat count (1.0 - 100.0)" },
{ GIMP_PDB_INT32, "randomize", "Use random seed (TRUE, FALSE)" },
{ GIMP_PDB_INT32, "seed", "Seed value (used only if randomize is FALSE)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "rndm_pct", "Randomization percentage (1.0 - 100.0)" },
{ GIMP_PDB_FLOAT, "rndm_rcount", "Repeat count (1.0 - 100.0)" },
{ GIMP_PDB_INT32, "randomize", "Use random seed (TRUE, FALSE)" },
{ GIMP_PDB_INT32, "seed", "Seed value (used only if randomize is FALSE)" }
};
const gchar *hurl_blurb =
@ -217,51 +217,63 @@ query (void)
"Add a random factor to the image by slurring (similar to melting).";
const gchar *hurl_help =
"This plug-in ``hurls'' randomly-valued pixels onto the selection or image. You may select the percentage of pixels to modify and the number of times to repeat the process.";
"This plug-in ``hurls'' randomly-valued pixels onto the selection or "
"image. You may select the percentage of pixels to modify and the number "
"of times to repeat the process.";
const gchar *pick_help =
"This plug-in replaces a pixel with a random adjacent pixel. You may select the percentage of pixels to modify and the number of times to repeat the process.";
"This plug-in replaces a pixel with a random adjacent pixel. You may "
"select the percentage of pixels to modify and the number of times to "
"repeat the process.";
const gchar *slur_help =
"This plug-in slurs (melts like a bunch of icicles) an image. You may select the percentage of pixels to modify and the number of times to repeat the process.";
"This plug-in slurs (melts like a bunch of icicles) an image. You may "
"select the percentage of pixels to modify and the number of times to "
"repeat the process.";
const gchar *author = "Miles O'Neal <meo@rru.com>";
const gchar *copyrights = "Miles O'Neal, Spencer Kimball, Peter Mattis, Torsten Martinsen, Brian Degenhardt, Federico Mena Quintero, Stephen Norris, Daniel Cotting";
const gchar *copyrights = "Miles O'Neal, Spencer Kimball, Peter Mattis, "
"Torsten Martinsen, Brian Degenhardt, Federico Mena Quintero, Stephen "
"Norris, Daniel Cotting";
const gchar *copyright_date = "1995-1998";
gimp_install_procedure (PLUG_IN_NAME[0],
(gchar *) hurl_blurb,
(gchar *) hurl_help,
(gchar *) author,
(gchar *) copyrights,
(gchar *) copyright_date,
N_("<Image>/Filters/Noise/_Hurl..."),
hurl_blurb,
hurl_help,
author,
copyrights,
copyright_date,
N_("_Hurl..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_install_procedure (PLUG_IN_NAME[1],
(gchar *) pick_blurb,
(gchar *) pick_help,
(gchar *) author,
(gchar *) copyrights,
(gchar *) copyright_date,
N_("<Image>/Filters/Noise/_Pick..."),
pick_blurb,
pick_help,
author,
copyrights,
copyright_date,
N_("_Pick..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_install_procedure (PLUG_IN_NAME[2],
(gchar *) slur_blurb,
(gchar *) slur_help,
(gchar *) author,
(gchar *) copyrights,
(gchar *) copyright_date,
N_("<Image>/Filters/Noise/_Slur..."),
slur_blurb,
slur_help,
author,
copyrights,
copyright_date,
N_("_Slur..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME[0], N_("<Image>/Filters/Noise"));
gimp_plugin_menu_register (PLUG_IN_NAME[1], N_("<Image>/Filters/Noise"));
gimp_plugin_menu_register (PLUG_IN_NAME[2], N_("<Image>/Filters/Noise"));
}
/*********************************

25
plug-ins/common/ripple.c
View File

@ -116,16 +116,16 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "period", "period; number of pixels for one wave to complete" },
{ GIMP_PDB_INT32, "amplitude", "amplitude; maximum displacement of wave" },
{ GIMP_PDB_INT32, "orientation", "orientation; 0 = Horizontal, 1 = Vertical" },
{ GIMP_PDB_INT32, "edges", "edges; 0 = smear, 1 = wrap, 2 = black" },
{ GIMP_PDB_INT32, "waveform", "0 = sawtooth, 1 = sine wave" },
{ GIMP_PDB_INT32, "antialias", "antialias; True or False" },
{ GIMP_PDB_INT32, "tile", "tile; if this is true, the image will retain it's tilability" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "period", "period; number of pixels for one wave to complete" },
{ GIMP_PDB_INT32, "amplitude", "amplitude; maximum displacement of wave" },
{ GIMP_PDB_INT32, "orientation", "orientation; 0 = Horizontal, 1 = Vertical" },
{ GIMP_PDB_INT32, "edges", "edges; 0 = smear, 1 = wrap, 2 = black" },
{ GIMP_PDB_INT32, "waveform", "0 = sawtooth, 1 = sine wave" },
{ GIMP_PDB_INT32, "antialias", "antialias; True or False" },
{ GIMP_PDB_INT32, "tile", "tile; if this is true, the image will retain it's tilability" }
};
gimp_install_procedure ("plug_in_ripple",
@ -134,11 +134,14 @@ query (void)
"Brian Degenhardt <bdegenha@ucsd.edu>",
"Brian Degenhardt",
"1997",
N_("<Image>/Filters/Distorts/_Ripple..."),
N_("_Ripple..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_ripple",
N_("<Image>/Filters/Distorts"));
}
static void

8
plug-ins/common/sample_colorize.c
View File

@ -293,16 +293,20 @@ query (void)
" The sample_drawable should be of type RGB or RGBA";
gimp_install_procedure (PLUG_IN_NAME,
"Colorize the contents of the specified drawable similar to sample drawable",
"Colorize the contents of the specified drawable "
"similar to sample drawable",
help_string,
"Wolfgang Hofer",
"hof@hotbot.com",
"02/2000",
N_("<Image>/Filters/Colors/Map/_Sample Colorize..."),
N_("_Sample Colorize..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Colors/Map"));
}
static void

19
plug-ins/common/scatter_hsv.c
View File

@ -120,13 +120,13 @@ query (void)
{
static GimpParamDef args [] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{ GIMP_PDB_IMAGE, "image", "Input image (not used)"},
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable"},
{ GIMP_PDB_INT32, "holdness", "convolution strength"},
{ GIMP_PDB_INT32, "hue_distance", "distribution distance on hue axis [0,255]"},
{ GIMP_PDB_INT32, "saturation_distance", "distribution distance on saturation axis [0,255]"},
{ GIMP_PDB_INT32, "value_distance", "distribution distance on value axis [0,255]"}
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (not used)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "holdness", "convolution strength" },
{ GIMP_PDB_INT32, "hue_distance", "distribution distance on hue axis [0,255]" },
{ GIMP_PDB_INT32, "saturation_distance", "distribution distance on saturation axis [0,255]" },
{ GIMP_PDB_INT32, "value_distance", "distribution distance on value axis [0,255]" }
};
gimp_install_procedure (PLUG_IN_NAME,
@ -135,11 +135,14 @@ query (void)
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"1997",
N_("<Image>/Filters/Noise/S_catter HSV..."),
N_("S_catter HSV..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Noise"));
}
static void

16
plug-ins/common/sel_gauss.c
View File

@ -92,15 +92,16 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "radius", "Radius of gaussian blur (in pixels, > 0.0)" },
{ GIMP_PDB_INT32, "maxdelta", "Maximum delta" }
{ GIMP_PDB_FLOAT, "radius", "Radius of gaussian blur (in pixels, > 0.0)" },
{ GIMP_PDB_INT32, "maxdelta", "Maximum delta" }
};
gimp_install_procedure ("plug_in_sel_gauss",
"Applies a selective gaussian blur to the specified drawable.",
"Applies a selective gaussian blur to the "
"specified drawable.",
"This filter functions similar to the regular "
"gaussian blur filter except that neighbouring "
"pixels that differ more than the given maxdelta "
@ -111,11 +112,14 @@ query (void)
"Thom van Os",
"Thom van Os",
"1999",
N_("<Image>/Filters/Blur/_Selective Gaussian Blur..."),
N_("_Selective Gaussian Blur..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_sel_gauss",
N_("<Image>/Filters/Blur"));
}
static void

11
plug-ins/common/semiflatten.c
View File

@ -61,8 +61,8 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", " Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
@ -76,11 +76,16 @@ query (void)
"Adam D. Moss (adam@foxbox.org)",
"Adam D. Moss (adam@foxbox.org)",
"27th January 1998",
N_("<Image>/Filters/Colors/_Semi-Flatten"),
N_("_Semi-Flatten"),
"RGBA",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_semiflatten",
N_("<Image>/Filters/Colors"));
gimp_plugin_menu_register ("plug_in_semiflatten",
N_("<Image>/Layer/Transparency/Modify"));
}

19
plug-ins/common/sharpen.c
View File

@ -133,23 +133,28 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "percent", "Percent sharpening (default = 10)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "percent", "Percent sharpening (default = 10)" }
};
gimp_install_procedure (PLUG_IN_NAME,
"Sharpen filter, typically used to 'sharpen' a photographic image.",
"This plug-in selectively performs a convolution filter on an image.",
"Sharpen filter, typically used to 'sharpen' a "
"photographic image.",
"This plug-in selectively performs a convolution "
"filter on an image.",
"Michael Sweet <mike@easysw.com>",
"Copyright 1997-1998 by Michael Sweet",
PLUG_IN_VERSION,
N_("<Image>/Filters/Enhance/_Sharpen..."),
N_("_Sharpen..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Enhance"));
}
static void

21
plug-ins/common/shift.c
View File

@ -91,24 +91,29 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "shift_amount", "shift amount (0 <= shift_amount_x <= 200)" },
{ GIMP_PDB_INT32, "orientation", "vertical, horizontal orientation" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "shift_amount", "shift amount (0 <= shift_amount_x <= 200)" },
{ GIMP_PDB_INT32, "orientation", "vertical, horizontal orientation" }
};
gimp_install_procedure ("plug_in_shift",
"Shift the contents of the specified drawable",
"Shifts the pixels of the specified drawable. Each row will be displaced a random value of pixels.",
"Spencer Kimball and Peter Mattis, ported by Brian Degenhardt and Federico Mena Quintero",
"Shifts the pixels of the specified drawable. "
"Each row will be displaced a random value of pixels.",
"Spencer Kimball and Peter Mattis, ported by Brian "
"Degenhardt and Federico Mena Quintero",
"Brian Degenhardt",
"1997",
N_("<Image>/Filters/Distorts/_Shift..."),
N_("_Shift..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_shift",
N_("<Image>/Filters/Distorts"));
}
static void

37
plug-ins/common/sinus.c
View File

@ -168,23 +168,23 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "xscale", "Scale value for x axis" },
{ GIMP_PDB_FLOAT, "yscale", "Scale value dor y axis" },
{ GIMP_PDB_FLOAT, "complex", "Complexity factor" },
{ GIMP_PDB_INT32, "seed", "Seed value for random number generator" },
{ GIMP_PDB_INT32, "tiling", "If set, the pattern generated will tile" },
{ GIMP_PDB_INT32, "perturb", "If set, the pattern is a little more distorted..." },
{ GIMP_PDB_INT32, "colors", "where to take the colors (0= B&W, 1= fg/bg, 2= col1/col2)"},
{ GIMP_PDB_COLOR, "col1", "fist color (sometimes unused)" },
{ GIMP_PDB_COLOR, "col2", "second color (sometimes unused)" },
{ GIMP_PDB_FLOAT, "alpha1", "alpha for the first color (used if the drawable has an alpha chanel)" },
{ GIMP_PDB_FLOAT, "alpha2", "alpha for the second color (used if the drawable has an alpha chanel)" },
{ GIMP_PDB_INT32, "blend", "0= linear, 1= bilinear, 2= sinusoidal" },
{ GIMP_PDB_FLOAT, "blend_power", "Power used to strech the blend" },
{ GIMP_PDB_FLOAT, "xscale", "Scale value for x axis" },
{ GIMP_PDB_FLOAT, "yscale", "Scale value dor y axis" },
{ GIMP_PDB_FLOAT, "complex", "Complexity factor" },
{ GIMP_PDB_INT32, "seed", "Seed value for random number generator" },
{ GIMP_PDB_INT32, "tiling", "If set, the pattern generated will tile" },
{ GIMP_PDB_INT32, "perturb", "If set, the pattern is a little more distorted..." },
{ GIMP_PDB_INT32, "colors", "where to take the colors (0= B&W, 1= fg/bg, 2= col1/col2)"},
{ GIMP_PDB_COLOR, "col1", "fist color (sometimes unused)" },
{ GIMP_PDB_COLOR, "col2", "second color (sometimes unused)" },
{ GIMP_PDB_FLOAT, "alpha1", "alpha for the first color (used if the drawable has an alpha chanel)" },
{ GIMP_PDB_FLOAT, "alpha2", "alpha for the second color (used if the drawable has an alpha chanel)" },
{ GIMP_PDB_INT32, "blend", "0= linear, 1= bilinear, 2= sinusoidal" },
{ GIMP_PDB_FLOAT, "blend_power", "Power used to strech the blend" }
};
gimp_install_procedure ("plug_in_sinus",
@ -193,11 +193,14 @@ query (void)
"Xavier Bouchoux",
"Xavier Bouchoux",
"1997",
N_("<Image>/Filters/Render/Pattern/_Sinus..."),
N_("_Sinus..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_sinus",
N_("<Image>/Filters/Render/Pattern"));
}
static void

19
plug-ins/common/smooth_palette.c
View File

@ -64,13 +64,13 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "width", "Width" },
{ GIMP_PDB_INT32, "height", "Height" },
{ GIMP_PDB_INT32, "ntries", "Search Depth" },
{ GIMP_PDB_INT32, "show_image","Show Image?" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "width", "Width" },
{ GIMP_PDB_INT32, "height", "Height" },
{ GIMP_PDB_INT32, "ntries", "Search Depth" },
{ GIMP_PDB_INT32, "show_image", "Show Image?" }
};
static GimpParamDef return_vals[] =
@ -85,11 +85,14 @@ query (void)
"Scott Draves",
"Scott Draves",
"1997",
N_("<Image>/Filters/Colors/Smoo_th Palette..."),
N_("Smoo_th Palette..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals),
args, return_vals);
gimp_plugin_menu_register ("plug_in_smooth_palette",
N_("<Image>/Filters/Colors"));
}
static struct

23
plug-ins/common/snoise.c
View File

@ -153,15 +153,15 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "tilable", "Create a tilable output (n=0/y=1)" },
{ GIMP_PDB_INT32, "turbulent", "Make a turbulent noise (n=0/y=1)" },
{ GIMP_PDB_INT32, "seed", "Random seed" },
{ GIMP_PDB_INT32, "detail", "Detail level (0 - 15)" },
{ GIMP_PDB_FLOAT, "xsize", "Horizontal texture size" },
{ GIMP_PDB_FLOAT, "ysize", "Vertical texture size" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "tilable", "Create a tilable output (n=0/y=1)" },
{ GIMP_PDB_INT32, "turbulent", "Make a turbulent noise (n=0/y=1)" },
{ GIMP_PDB_INT32, "seed", "Random seed" },
{ GIMP_PDB_INT32, "detail", "Detail level (0 - 15)" },
{ GIMP_PDB_FLOAT, "xsize", "Horizontal texture size" },
{ GIMP_PDB_FLOAT, "ysize", "Vertical texture size" }
};
gimp_install_procedure ("plug_in_solid_noise",
@ -170,11 +170,14 @@ query (void)
"Marcelo de Gomensoro Malheiros",
"Marcelo de Gomensoro Malheiros",
"Apr 1998, v1.03",
N_("<Image>/Filters/Render/Clouds/_Solid Noise..."),
N_("_Solid Noise..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_solid_noise",
N_("<Image>/Filters/Render/Clouds"));
}

17
plug-ins/common/sobel.c
View File

@ -91,12 +91,12 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "horizontal", "Sobel in horizontal direction" },
{ GIMP_PDB_INT32, "vertical", "Sobel in vertical direction" },
{ GIMP_PDB_INT32, "keep_sign", "Keep sign of result (one direction only)" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "horizontal", "Sobel in horizontal direction" },
{ GIMP_PDB_INT32, "vertical", "Sobel in vertical direction" },
{ GIMP_PDB_INT32, "keep_sign", "Keep sign of result (one direction only)" }
};
gimp_install_procedure ("plug_in_sobel",
@ -113,11 +113,14 @@ query (void)
"Thorsten Schnier",
"Thorsten Schnier",
"1997",
N_("<Image>/Filters/Edge-Detect/_Sobel..."),
N_("_Sobel..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_sobel",
N_("<Image>/Filters/Edge-Detect"));
}
static void

59
plug-ins/common/sparkle.c
View File

@ -156,36 +156,41 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "lum_threshold", "Luminosity threshold (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "flare_inten", "Flare intensity (0.0 - 1.0)" },
{ GIMP_PDB_INT32, "spike_len", "Spike length (in pixels)" },
{ GIMP_PDB_INT32, "spike_pts", "# of spike points" },
{ GIMP_PDB_INT32, "spike_angle", "Spike angle (0-360 degrees, -1: random)" },
{ GIMP_PDB_FLOAT, "density", "Spike density (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "opacity", "Opacity (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "random_hue", "Random hue (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "random_saturation", "Random saturation (0.0 - 1.0)" },
{ GIMP_PDB_INT32, "preserve_luminosity", "Preserve luminosity (TRUE/FALSE)" },
{ GIMP_PDB_INT32, "inverse", "Inverse (TRUE/FALSE)" },
{ GIMP_PDB_INT32, "border", "Add border (TRUE/FALSE)" },
{ GIMP_PDB_INT32, "colortype", "Color of sparkles: { NATURAL (0), FOREGROUND (1), BACKGROUND (2) }" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "lum_threshold", "Luminosity threshold (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "flare_inten", "Flare intensity (0.0 - 1.0)" },
{ GIMP_PDB_INT32, "spike_len", "Spike length (in pixels)" },
{ GIMP_PDB_INT32, "spike_pts", "# of spike points" },
{ GIMP_PDB_INT32, "spike_angle", "Spike angle (0-360 degrees, -1: random)" },
{ GIMP_PDB_FLOAT, "density", "Spike density (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "opacity", "Opacity (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "random_hue", "Random hue (0.0 - 1.0)" },
{ GIMP_PDB_FLOAT, "random_saturation", "Random saturation (0.0 - 1.0)" },
{ GIMP_PDB_INT32, "preserve_luminosity", "Preserve luminosity (TRUE/FALSE)" },
{ GIMP_PDB_INT32, "inverse", "Inverse (TRUE/FALSE)" },
{ GIMP_PDB_INT32, "border", "Add border (TRUE/FALSE)" },
{ GIMP_PDB_INT32, "colortype", "Color of sparkles: { NATURAL (0), FOREGROUND (1), BACKGROUND (2) }" }
};
gimp_install_procedure ("plug_in_sparkle",
"Simulates pixel bloom and diffraction effects",
"Uses a percentage based luminoisty threhsold to find "
"candidate pixels for adding some sparkles (spikes). ",
"John Beale, & (ported to GIMP v0.54) Michael J. Hammel & ted to GIMP v1.0) & Seth Burgess & Spencer Kimball",
"John Beale",
"Version 1.27, September 2003",
N_("<Image>/Filters/Light Effects/_Sparkle..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
"Simulates pixel bloom and diffraction effects",
"Uses a percentage based luminoisty threhsold to find "
"candidate pixels for adding some sparkles (spikes). ",
"John Beale, & (ported to GIMP v0.54) Michael "
"J. Hammel & ted to GIMP v1.0) & Seth Burgess & "
"Spencer Kimball",
"John Beale",
"Version 1.27, September 2003",
N_("_Sparkle..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_sparkle",
N_("<Image>/Filters/Light Effects"));
}
static void

9
plug-ins/common/spheredesigner.c
View File

@ -3103,9 +3103,14 @@ query (void)
"Vidar Madsen",
"Vidar Madsen",
"1999",
N_("<Image>/Filters/Render/Sphere _Designer..."),
N_("Sphere _Designer..."),
"RGB*, GRAY*",
GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL);
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_spheredesigner",
N_("<Image>/Filters/Render"));
}
static gboolean

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

@ -107,11 +107,14 @@ query (void)
"Degenhardt and Federico Mena Quintero",
"Federico Mena Quintero and Brian Degenhardt",
"1997",
N_("<Image>/Filters/Noise/Sp_read..."),
N_("Sp_read..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_spread",
N_("<Image>/Filters/Noise"));
}
static void

22
plug-ins/common/struc.c
View File

@ -41,7 +41,10 @@
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
static char sdata[] =
#include "libgimp/stdplugins-intl.h"
static const gchar sdata[] =
{
0, 5, -3, -13, 13, 10, -11, 6, -11, -14, 29, 43, -18, -40, 24, 4,
-32, 26, 39, -34, -16, 25, -22, 12, 2, -40, 9, 46, -13, -47, 17, 19,
@ -1069,8 +1072,6 @@ static char sdata[] =
11, -4, 2, -14, -26, 3, 3, 2, 28, 13, -27, -18, 5, 5, 13, 0
};
#include "libgimp/stdplugins-intl.h"
/* --- Typedefs --- */
enum
@ -1126,11 +1127,11 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "direction", "Light direction (0 - 3)" },
{ GIMP_PDB_INT32, "depth", "Texture depth (1 - 50)" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "direction", "Light direction (0 - 3)" },
{ GIMP_PDB_INT32, "depth", "Texture depth (1 - 50)" }
};
gimp_install_procedure ("plug_in_apply_canvas",
@ -1139,11 +1140,14 @@ query (void)
"Karl-Johan Andersson", /* Author */
"Karl-Johan Andersson", /* Copyright */
"1997",
N_("<Image>/Filters/Artistic/_Apply Canvas..."),
N_("_Apply Canvas..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_apply_canvas",
N_("<Image>/Filters/Artistic"));
}
static void

13
plug-ins/common/threshold_alpha.c
View File

@ -82,10 +82,10 @@ query (void)
{
static GimpParamDef args [] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{ GIMP_PDB_IMAGE, "image", "Input image (not used)"},
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "threshold", "Threshold" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (not used)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "threshold", "Threshold" }
};
gimp_install_procedure (PLUG_IN_NAME,
@ -94,11 +94,14 @@ query (void)
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"1997",
N_("<Image>/Layer/Transparency/Modify/_Threshold Alpha..."),
N_("_Threshold Alpha..."),
"RGBA,GRAYA",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Layer/Transparency/Modify"));
}
static void

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

@ -109,12 +109,15 @@ query (void)
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1996-1997",
N_("<Image>/Filters/Map/_Tile..."),
N_("_Tile..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args),
G_N_ELEMENTS (return_vals),
args, return_vals);
gimp_plugin_menu_register ("plug_in_tile",
N_("<Image>/Filters/Map"));
}
static void

13
plug-ins/common/tileit.c
View File

@ -213,10 +213,10 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "number_of_tiles", "Number of tiles to make" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "number_of_tiles", "Number of tiles to make" }
};
gimp_install_procedure ("plug_in_small_tiles",
@ -225,11 +225,14 @@ query (void)
"Andy Thomas",
"Andy Thomas",
"1997",
N_("<Image>/Filters/Map/_Small Tiles..."),
N_("_Small Tiles..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_small_tiles",
N_("<Image>/Filters/Map"));
}
static void

12
plug-ins/common/tiler.c
View File

@ -51,22 +51,26 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_install_procedure ("plug_in_make_seamless",
"Seamless tile creation",
"This plugin creates a seamless tileable from the input image",
"This plugin creates a seamless tileable from "
"the input drawable",
"Tim Rowley",
"Tim Rowley",
"1997",
N_("<Image>/Filters/Map/_Make Seamless"),
N_("_Make Seamless"),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_make_seamless",
N_("<Image>/Filters/Map"));
}

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

@ -114,11 +114,14 @@ query (void)
"Michael Natterer <mitch@gimp.org>",
"Michael Natterer <mitch@gimp.org>",
"2000",
N_("<Toolbox>/Xtns/Extensions/_Unit Editor"),
N_("_Unit Editor"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_unit_editor",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

19
plug-ins/common/unsharp.c
View File

@ -126,15 +126,14 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "(unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to draw on" },
{ GIMP_PDB_FLOAT, "radius", "Radius of gaussian blur (in pixels > 1.0)" },
{ GIMP_PDB_FLOAT, "amount", "Strength of effect" },
{ GIMP_PDB_FLOAT, "threshold", "Threshold" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "(unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to draw on" },
{ GIMP_PDB_FLOAT, "radius", "Radius of gaussian blur (in pixels > 1.0)" },
{ GIMP_PDB_FLOAT, "amount", "Strength of effect" },
{ GIMP_PDB_FLOAT, "threshold", "Threshold" }
};
/* Install a procedure in the procedure database. */
gimp_install_procedure ("plug_in_unsharp_mask",
"An unsharp mask filter",
"The unsharp mask is a sharpening filter that works "
@ -146,14 +145,16 @@ query (void)
"Winston Chang <winstonc@cs.wisc.edu>",
"Winston Chang",
"1999",
N_("<Image>/Filters/Enhance/_Unsharp Mask..."),
N_("_Unsharp Mask..."),
"GRAY*, RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_unsharp_mask",
N_("<Image>/Filters/Enhance"));
}
/* this is the actual function */
static void
run (const gchar *name,
gint nparams,

24
plug-ins/common/video.c
View File

@ -1811,25 +1811,31 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "pattern_number", "Type of RGB pattern to use" },
{ GIMP_PDB_INT32, "additive", "Whether the function adds the result to the original image" },
{ GIMP_PDB_INT32, "rotated", "Whether to rotate the RGB pattern by ninety degrees" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "pattern_number", "Type of RGB pattern to use" },
{ GIMP_PDB_INT32, "additive", "Whether the function adds the result to the original image" },
{ GIMP_PDB_INT32, "rotated", "Whether to rotate the RGB pattern by ninety degrees" }
};
gimp_install_procedure ("plug_in_video",
"Apply low-dotpitch RGB simulation to the specified drawable",
"This function simulates the degradation of being on an old low-dotpitch RGB video monitor to the specified drawable.",
"Apply low-dotpitch RGB simulation to the "
"specified drawable",
"This function simulates the degradation of "
"being on an old low-dotpitch RGB video monitor "
"to the specified drawable.",
"Adam D. Moss (adam@foxbox.org)",
"Adam D. Moss (adam@foxbox.org)",
"2nd March 1997",
N_("<Image>/Filters/Distorts/Vi_deo..."),
N_("Vi_deo..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_video",
N_("<Image>/Filters/Distorts"));
}
static void

12
plug-ins/common/vinvert.c
View File

@ -65,13 +65,14 @@ query ()
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (used for indexed images)" },
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (used for indexed images)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_install_procedure ("plug_in_vinvert",
"Invert the 'value' component of an indexed/RGB image in HSV colorspace",
"Invert the 'value' component of an indexed/RGB "
"image in HSV colorspace",
"This function takes an indexed/RGB image and "
"inverts its 'value' in HSV space. The upshot of "
"this is that the color and saturation at any given "
@ -82,11 +83,14 @@ query ()
"Adam D. Moss (adam@foxbox.org)",
"Adam D. Moss (adam@foxbox.org)",
"27th March 1997",
N_("<Image>/Filters/Colors/_Value Invert"),
N_("_Value Invert"),
"RGB*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_vinvert",
N_("<Image>/Filters/Colors"));
}
static void

13
plug-ins/common/vpropagate.c
View File

@ -240,7 +240,7 @@ query (void)
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"1996-1997",
N_("<Image>/Filters/Distorts/_Value Propagate..."),
N_("_Value Propagate..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
@ -252,7 +252,7 @@ query (void)
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"1996-1997",
N_("<Image>/Filters/Generic/E_rode"),
N_("E_rode"),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
@ -264,11 +264,18 @@ query (void)
"Shuji Narazaki (narazaki@InetQ.or.jp)",
"Shuji Narazaki",
"1996-1997",
N_("<Image>/Filters/Generic/_Dilate"),
N_("_Dilate"),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (DEFAULT_PLUG_IN_NAME,
N_("<Image>/Filters/Distorts"));
gimp_plugin_menu_register (ERODE_PLUG_IN_NAME,
N_("<Image>/Filters/Generic"));
gimp_plugin_menu_register (DILATE_PLUG_IN_NAME,
N_("<Image>/Filters/Generic"));
}
static void

8
plug-ins/common/warp.c
View File

@ -235,7 +235,8 @@ query (void)
};
gimp_install_procedure ("plug_in_warp",
"Twist or smear an image. (only first six arguments are required)",
"Twist or smear an image. (only first six "
"arguments are required)",
"Smears an image along vector paths calculated as "
"the gradient of a separate control matrix. The "
"effect can look like brushstrokes of acrylic or "
@ -243,11 +244,14 @@ query (void)
"John P. Beale",
"John P. Beale",
"1997",
N_("<Image>/Filters/Map/_Warp..."),
N_("_Warp..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_warp",
N_("<Image>/Filters/Map"));
}
static void

21
plug-ins/common/waves.c
View File

@ -106,14 +106,14 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "The Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "The Drawable" },
{ GIMP_PDB_FLOAT, "amplitude", "The Amplitude of the Waves" },
{ GIMP_PDB_FLOAT, "phase", "The Phase of the Waves" },
{ GIMP_PDB_FLOAT, "wavelength", "The Wavelength of the Waves" },
{ GIMP_PDB_INT32, "type", "Type of waves, black/smeared" },
{ GIMP_PDB_INT32, "reflective", "Use Reflection" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "The Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "The Drawable" },
{ GIMP_PDB_FLOAT, "amplitude", "The Amplitude of the Waves" },
{ GIMP_PDB_FLOAT, "phase", "The Phase of the Waves" },
{ GIMP_PDB_FLOAT, "wavelength", "The Wavelength of the Waves" },
{ GIMP_PDB_INT32, "type", "Type of waves, black/smeared" },
{ GIMP_PDB_INT32, "reflective", "Use Reflection" }
};
gimp_install_procedure ("plug_in_waves",
@ -122,11 +122,14 @@ query (void)
"Eric L. Hernes, Stephen Norris",
"Stephen Norris",
"1997",
N_("<Image>/Filters/Distorts/_Waves..."),
N_("_Waves..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_waves",
N_("<Image>/Filters/Distorts"));
}
static void

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

@ -182,11 +182,14 @@ query (void)
"Federico Mena Quintero and Scott Goehring",
"Federico Mena Quintero and Scott Goehring",
PLUG_IN_VERSION,
N_("<Image>/Filters/Distorts/W_hirl and Pinch..."),
N_("W_hirl and Pinch..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Distorts"));
}
static void

18
plug-ins/common/winclipboard.c
View File

@ -95,9 +95,9 @@ query ()
{
static GimpParamDef copy_args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" }
};
gimp_install_procedure ("plug_in_clipboard_copy",
@ -106,7 +106,7 @@ query ()
"Hans Breuer",
"Hans Breuer",
"1999",
N_("<Image>/Edit/Copy to Clipboard"),
N_("Copy to Clipboard"),
"INDEXED*, RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (copy_args), 0,
@ -118,7 +118,7 @@ query ()
"Hans Breuer",
"Hans Breuer",
"1999",
N_("<Image>/Edit/Paste from Clipboard"),
N_("Paste from Clipboard"),
"INDEXED*, RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (copy_args), 0,
@ -130,12 +130,18 @@ query ()
"Hans Breuer",
"Hans Breuer",
"1999",
N_("<Toolbox>/File/Acquire/From Clipboard"),
N_("From Clipboard"),
"",
GIMP_PLUGIN,
1, 0,
copy_args, NULL);
gimp_plugin_menu_register ("plug_in_clipboard_copy",
N_("<Image>/Edit"));
gimp_plugin_menu_register ("plug_in_clipboard_paste",
N_("<Image>/Edit"));
gimp_plugin_menu_register ("plug_in_clipboard_paste_as_new",
N_("<Toolbox>/File/Acquire"));
}
static void

21
plug-ins/common/wind.c
View File

@ -171,14 +171,14 @@ query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "threshold", "Controls where blending will be done >= 0" },
{ GIMP_PDB_INT32, "direction", "Left or Right: 0 or 1" },
{ GIMP_PDB_INT32, "strength", "Controls the extent of the blending > 1" },
{ GIMP_PDB_INT32, "alg", "WIND, BLAST" },
{ GIMP_PDB_INT32, "edge", "LEADING, TRAILING, or BOTH" }
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "threshold", "Controls where blending will be done >= 0" },
{ GIMP_PDB_INT32, "direction", "Left or Right: 0 or 1" },
{ GIMP_PDB_INT32, "strength", "Controls the extent of the blending > 1" },
{ GIMP_PDB_INT32, "alg", "WIND, BLAST" },
{ GIMP_PDB_INT32, "edge", "LEADING, TRAILING, or BOTH" }
};
gimp_install_procedure ("plug_in_wind",
@ -187,11 +187,14 @@ query (void)
"Nigel Wetten",
"Nigel Wetten",
"May 2000",
N_("<Image>/Filters/Distorts/Wi_nd..."),
N_("Wi_nd..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_wind",
N_("<Image>/Filters/Distorts"));
}
static void

9
plug-ins/common/winprint.c
View File

@ -183,7 +183,7 @@ query (void)
"Tor Lillqvist <tml@iki.fi>",
"Copyright 1999 Tor Lillqvist",
"$Id$",
N_("<Image>/File/Send/_Print"),
N_("_Print"),
"RGB*,GRAY*,INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (print_args), 0,
@ -195,11 +195,16 @@ query (void)
"Tor Lillqvist <tml@iki.fi>",
"Copyright 1999 Tor Lillqvist",
"$Id$",
N_("<Image>/File/Send/Page Setup"),
N_("Page Setup"),
"RGB*,GRAY*,INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (pagesetup_args), 0,
pagesetup_args, NULL);
gimp_plugin_menu_register (NAME_PRINT,
N_("<Image>/File/Send"));
gimp_plugin_menu_register (NAME_PAGE_SETUP,
N_("<Image>/File/Send"));
}
/*

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

@ -66,11 +66,14 @@ query (void)
"Adam D. Moss",
"Adam D. Moss",
"1997",
N_("<Image>/Layer/Crop/_Zealous Crop"),
N_("_Zealous Crop"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_zealouscrop",
N_("<Image>/Layer/Crop"));
}
static void

5
plug-ins/dbbrowser/dbbrowser.c
View File

@ -86,11 +86,14 @@ query (void)
"Thomas Noel",
"Thomas Noel",
"23th june 1997",
N_("<Toolbox>/Xtns/Extensions/_DB Browser"),
N_("_DB Browser"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_db_browser",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

5
plug-ins/dbbrowser/plugin-browser.c
View File

@ -150,11 +150,14 @@ query (void)
"Andy Thomas",
"Andy Thomas",
"1999",
N_("<Toolbox>/Xtns/Extensions/_Plugin Details"),
N_("_Plugin Details"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_plug_in_details",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

5
plug-ins/dbbrowser/procedure-browser.c
View File

@ -86,11 +86,14 @@ query (void)
"Thomas Noel",
"Thomas Noel",
"23th june 1997",
N_("<Toolbox>/Xtns/Extensions/_DB Browser"),
N_("_DB Browser"),
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_db_browser",
N_("<Toolbox>/Xtns/Extensions"));
}
static void

5
plug-ins/flame/flame.c
View File

@ -138,11 +138,14 @@ query (void)
"Scott Draves",
"Scott Draves",
"1997",
N_("<Image>/Filters/Render/Nature/_Flame..."),
N_("_Flame..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_flame",
N_("<Image>/Filters/Render/Nature"));
}
static void

5
plug-ins/gimpressionist/gimp.c
View File

@ -105,11 +105,14 @@ query(void)
"Vidar Madsen <vidar@prosalg.no>",
"Vidar Madsen",
PLUG_IN_VERSION,
N_("<Image>/Filters/Artistic/_GIMPressionist..."),
N_("_GIMPressionist..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Artistic"));
}
static void

5
plug-ins/ifscompose/ifscompose.c
View File

@ -366,11 +366,14 @@ query (void)
"Owen Taylor",
"Owen Taylor",
"1997",
N_("<Image>/Filters/Render/Nature/Ifs_Compose..."),
N_("Ifs_Compose..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), nreturn_vals,
args, return_vals);
gimp_plugin_menu_register ("plug_in_ifs_compose",
N_("<Image>/Filters/Render/Nature"));
}
static void

5
plug-ins/imagemap/imap_main.c
View File

@ -125,11 +125,14 @@ static void query()
"Maurits Rijk",
"Maurits Rijk",
"1998-2002",
N_("<Image>/Filters/Web/_ImageMap..."),
N_("_ImageMap..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), nreturn_vals,
args, return_vals);
gimp_plugin_menu_register ("plug_in_imagemap",
N_("<Image>/Filters/Web"));
}
static void

13
plug-ins/maze/maze.c
View File

@ -154,23 +154,26 @@ query ()
gchar *help;
help = g_strdup_printf (_("Generates a maze using either the depth-first "
"search method or Prim's algorithm. Can make "
"tileable mazes too. See %s for more help."),
help = g_strdup_printf ("Generates a maze using either the depth-first "
"search method or Prim's algorithm. Can make "
"tileable mazes too. See %s for more help.",
MAZE_URL);
gimp_install_procedure ("plug_in_maze",
_("Draws a maze."),
"Draws a maze.",
help,
"Kevin Turner <kevint@poboxes.com>",
"Kevin Turner",
"1997, 1998",
N_("<Image>/Filters/Render/Pattern/_Maze..."),
N_("_Maze..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_maze",
N_("<Image>/Filters/Render/Pattern"));
g_free (help);
}

5
plug-ins/pagecurl/pagecurl.c
View File

@ -209,13 +209,16 @@ query (void)
"Federico Mena Quintero and Simon Budig",
"Federico Mena Quintero and Simon Budig",
PLUG_IN_VERSION,
N_("<Image>/Filters/Distorts/_Pagecurl..."),
N_("_Pagecurl..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args),
G_N_ELEMENTS (return_vals),
args,
return_vals);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/Filters/Distorts"));
}
static void

5
plug-ins/print/print.c
View File

@ -161,11 +161,14 @@ query (void)
gimp_install_procedure ("file_print_gimp",
blurb, help, auth, copy,
PLUG_IN_VERSION,
N_("<Image>/File/Send/_Print..."),
N_("_Print..."),
types,
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("file_print_gimp",
N_("<Image>/File/Send"));
}

5
plug-ins/rcm/rcm.c
View File

@ -103,11 +103,14 @@ query (void)
"Sven Anders (anderss@fmi.uni-passau.de) and Pavel Grinfeld (pavel@ml.com)",
"Sven Anders (anderss@fmi.uni-passau.de)",
"04th April 1999",
N_("<Image>/Filters/Colors/Map/Colormap _Rotation..."),
N_("Colormap _Rotation..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_rotate_colormap",
N_("<Image>/Filters/Colors/Map"));
}

6
plug-ins/winsnap/winsnap.c
View File

@ -1070,7 +1070,7 @@ query(void)
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
PLUG_IN_VERSION,
N_("<Toolbox>/File/Acquire/_Screen Shot..."),
N_("_Screen Shot..."),
NULL,
GIMP_PLUGIN,
NUMBER_IN_ARGS,
@ -1078,8 +1078,8 @@ query(void)
args,
return_vals);
gimp_plugin_menu_register (PLUG_IN_NAME,
N_("<Image>/File/Acquire/_Screen Shot..."));
gimp_plugin_menu_register (PLUG_IN_NAME, N_("<Toolbox>/File/Acquire"));
/* gimp_plugin_menu_register (PLUG_IN_NAME, N_("<Image>/File/Acquire")); */
}
/* Return values storage */