/* Register plugin to Procedural DataBase */
static void
query()
{
/* resynth_paramdefs defined in resynth-parameters.h */
GimpParamDef *return_vals = NULL;
gint nargs = sizeof(resynth_paramdefs)/sizeof(resynth_paramdefs[0]);
gint nreturn_vals = 0;
gimp_plugin_domain_register (RESYNTH_DOMAIN_NAME, LOCALEDIR);
gimp_install_procedure(
RESYNTH_CONTROLS_PDB_NAME,
N_("Make tiles, apply themes, render texture, remove features, etc."),
"The resynthesizer control panel.",
"Paul Francis Harrison, Lloyd Konneker",
"2000 Paul Francis Harrison, 2010 Lloyd Konneker",
"2010",
N_("_Resynthesize..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
nargs, nreturn_vals,
resynth_paramdefs, return_vals);
gimp_plugin_menu_register(RESYNTH_CONTROLS_PDB_NAME, "<Image>/Filters/Map");
}
static void query (void)
{
static GimpParamDef args[] = {
{ GIMP_PDB_INT32, "run-mode", "Run mode" }
};
gimp_plugin_domain_register (GETTEXT_PACKAGE, get_bimp_localedir());
gimp_install_procedure (
PLUG_IN_PROC,
PLUG_IN_FULLNAME,
_("Applies GIMP manipulations on groups of images"),
"Alessandro Francesconi <*****@*****.**>",
"Copyright (C) Alessandro Francesconi\n"
"http://www.alessandrofrancesconi.it/projects/bimp",
"2013",
"Batch Image Manipulation...",
"",
GIMP_PLUGIN,
G_N_ELEMENTS (args),
0,
args,
0
);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/File/Open");
}
static void
query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
gimp_install_procedure (PLUG_IN_PROC,
N_("Optimize & save image for web"),
"Optimize image for web.",
"Aurimas Juška",
"Aurimas Juška",
"0.25",
N_("Save for Web..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/File/Save");
}
static void
query (void)
{
static /* const */ GimpParamDef args[] =
{
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "run_mode", (BAD_CONST_CHAR) "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, (BAD_CONST_CHAR) "image", (BAD_CONST_CHAR) "Input image" },
{ GIMP_PDB_DRAWABLE, (BAD_CONST_CHAR) "drawable", (BAD_CONST_CHAR) "Input drawable" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "output_to", (BAD_CONST_CHAR) "Print command or filename (| to pipe to command)" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "driver", (BAD_CONST_CHAR) "Printer driver short name" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "ppd_file", (BAD_CONST_CHAR) "PPD file" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "output_type", (BAD_CONST_CHAR) "Output type (0 = gray, 1 = color)" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "resolution", (BAD_CONST_CHAR) "Resolution (\"300\", \"720\", etc.)" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "media_size", (BAD_CONST_CHAR) "Media size (\"Letter\", \"A4\", etc.)" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "media_type", (BAD_CONST_CHAR) "Media type (\"Plain\", \"Glossy\", etc.)" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "media_source", (BAD_CONST_CHAR) "Media source (\"Tray1\", \"Manual\", etc.)" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "brightness", (BAD_CONST_CHAR) "Brightness (0-400%)" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "scaling", (BAD_CONST_CHAR) "Output scaling (0-100%, -PPI)" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "orientation", (BAD_CONST_CHAR) "Output orientation (-1 = auto, 0 = portrait, 1 = landscape)" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "left", (BAD_CONST_CHAR) "Left offset (points, -1 = centered)" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "top", (BAD_CONST_CHAR) "Top offset (points, -1 = centered)" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "gamma", (BAD_CONST_CHAR) "Output gamma (0.1 - 3.0)" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "contrast", (BAD_CONST_CHAR) "Contrast" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "cyan", (BAD_CONST_CHAR) "Cyan level" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "magenta", (BAD_CONST_CHAR) "Magenta level" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "yellow", (BAD_CONST_CHAR) "Yellow level" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "linear", (BAD_CONST_CHAR) "Linear output (0 = normal, 1 = linear)" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "image_type", (BAD_CONST_CHAR) "Image type (0 = line art, 1 = solid tones, 2 = continuous tone, 3 = monochrome)"},
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "saturation", (BAD_CONST_CHAR) "Saturation (0-1000%)" },
{ GIMP_PDB_FLOAT, (BAD_CONST_CHAR) "density", (BAD_CONST_CHAR) "Density (0-200%)" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "ink_type", (BAD_CONST_CHAR) "Type of ink or cartridge" },
{ GIMP_PDB_STRING, (BAD_CONST_CHAR) "dither_algorithm", (BAD_CONST_CHAR) "Dither algorithm" },
{ GIMP_PDB_INT32, (BAD_CONST_CHAR) "unit", (BAD_CONST_CHAR) "Unit 0=Inches 1=Metric" },
};
static gint nargs = sizeof(args) / sizeof(args[0]);
static const gchar *blurb = "This plug-in prints images from The GIMP.";
static const gchar *help = "Prints images to PostScript, PCL, or ESC/P2 printers.";
static const gchar *auth = "Michael Sweet <*****@*****.**> and Robert Krawitz <*****@*****.**>";
static const gchar *copy = "Copyright 1997-2000 by Michael Sweet and Robert Krawitz";
static const gchar *types = "RGB*,GRAY*,INDEXED*";
gimp_plugin_domain_register ((BAD_CONST_CHAR) PACKAGE, (BAD_CONST_CHAR) PACKAGE_LOCALE_DIR);
gimp_install_procedure ((BAD_CONST_CHAR) "file_print_gimp",
(BAD_CONST_CHAR) blurb,
(BAD_CONST_CHAR) help,
(BAD_CONST_CHAR) auth,
(BAD_CONST_CHAR) copy,
(BAD_CONST_CHAR) VERSION " - " RELEASE_DATE,
(BAD_CONST_CHAR) N_("<Image>/File/Print..."),
(BAD_CONST_CHAR) types,
GIMP_PLUGIN,
nargs, 0,
args, NULL);
}
static void
query ()
{
static GimpParamDef args_fmac_varying[] =
{
{GIMP_PDB_INT32, "run_mode", "Interactive"},
{GIMP_PDB_IMAGE, "image", "Input image"},
{GIMP_PDB_DRAWABLE, "drawable", "Input drawable to be affected by the filtermacro"},
{GIMP_PDB_STRING, "filtermacro_1", "Name of the 1st filtermacro_file to execute on the input drawable)"},
{GIMP_PDB_STRING, "filtermacro_2", "Name of the 2nd filtermacro_file to execute on the input drawable)"},
{GIMP_PDB_FLOAT, "current_step", "current_step. (e.g curently processed frame) "
" valid range is 0.0 upto total_steps, "
" where 0.0 uses the parameter definitions from filtermacro_1. "
" current_step divided by total_steps defines the value mix ratio"
" A value mix ratio of 1.0 will use the parameter values of filtermacro_2."},
{GIMP_PDB_INT32, "total_steps", "total number of steps of varying iterations (e.g. number of frames to process)"},
};
static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0;
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
gimp_install_procedure(GAP_FMACNAME_PLUG_IN_NAME_FMAC_VARYING,
"This plug-in executes 2 filtermacro scripts, where parameter values of script 1 and 2 are mixed.",
"This plug-in allows the non-interactive caller to execute correlated filters "
"that have already been recorded in 2 filtermacro files where the parameter "
"values are a mix of filtermacro from file1 and file2 related to progress. "
"progress is specified by the total_steps and current_step parameters "
"if current_step is 0.0 use the values as defined in filtermacro file1. "
"the mix increases the influence of parameter values as definewd in filtermacro file2 "
" the more current_step approaches total_steps."
"Correlation is done by name of the filter and position in the filtermacro file1. "
"filternames that are only present in filtermacro file2 are ignored. "
"filternames that have no correlated matching filtername in filtermacro file2 "
"are executed with values as defined in filtermacro file1, independent from current_step. "
"This non-interactive API is typically used by the GAP storyboard processor for "
"applying filtermacros with varying values. "
"WARNING: filtermacro scriptfiles are a temporary solution. "
"They are machine dependent. Support may be dropped in future gimp "
"versions.",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
NULL, /* dont appear in menus */
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args_fmac_varying), nreturn_vals,
args_fmac_varying, return_vals);
} /* end query */
static void
query (void)
{
// gchar *help_path;
// gchar *help_uri;
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, "remove_lighting", "Remove Lighting TRUE or FALSE default FALSE"},
{GIMP_PDB_INT32, "resizie", "Upscale(HD) TRUE or FALSE default FALSE"},
{GIMP_PDB_INT32, "tile", "Tile TRUE or FALSE default FALSE"},
{GIMP_PDB_INT32, "new_width", "New Width(Integer Times larger) default 2"},
{GIMP_PDB_INT32, "edge_specular", "Edge Enhancing Specular TRUE or FALSE default TRUE"},
{GIMP_PDB_INT32, "def_specular", "Specular Definition(0-255) default 64"},
{GIMP_PDB_FLOAT, "depth", "Depth(+/-) default 20.00"},
{GIMP_PDB_INT32, "large_details", "Large Detail Size default 3"},
{GIMP_PDB_INT32, "medium_details", "Medium Detail Intensity(%) default 50"},
{GIMP_PDB_INT32, "small_details", "Small Detail Intensity(%) default 50"},
{GIMP_PDB_INT32, "shape_recog", "Shape Recognition(%) default 50"},
{GIMP_PDB_INT32, "smoothstep", "Smooth Step TRUE or FALSE default TRUE"},
{GIMP_PDB_INT32, "noise", "Noise TRUE or FALSE default FALSE"},
{GIMP_PDB_INT32, "invh", "Invert Height Map TRUE or FALSE default FALSE"},
{GIMP_PDB_INT32, "ao", "ao default 50"},
{GIMP_PDB_INT32, "prev", "Preview TRUE or FALSE default TRUE"},
};
gimp_plugin_domain_register (PLUG_IN_PROC, LOCALEDIR);
// help_path = g_build_filename (DATADIR, "help", NULL);
// help_uri = g_filename_to_uri (help_path, NULL, NULL);
// g_free (help_path);
//
// gimp_plugin_help_register ("http://developer.gimp.org/plug-in-insanebump/help",
// help_uri);
gimp_install_procedure (PLUG_IN_PROC,
N_("Produce images needed for Graphical Rendering"),
"This plug-in automatically produces specular, "
"normal and other images from current image. ",
PLUG_IN_AUTHOR_LINEONE,
PLUG_IN_AUTHOR_LINETWO,
"2014",
N_("_InsaneBump..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, PLUG_IN_LOCALDIR);
}
static
void query (void)
{
gchar *help_path;
gchar *help_uri;
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_STRING, "font_file", "Font file" },
{ GIMP_PDB_FLOAT, "size", "Size" },
{ GIMP_PDB_INT32, "unit_id", "The integer id of size's unit" },
{ GIMP_PDB_FLOAT, "transform_xx", "Transformation Matrix" },
{ GIMP_PDB_FLOAT, "transform_xy", "Transformation Matrix" },
{ GIMP_PDB_FLOAT, "transform_yx", "Transformation Matrix" },
{ GIMP_PDB_FLOAT, "transform_yy", "Transformation Matrix" },
{ GIMP_PDB_INT32, "kerning", "Kerning on/off" },
{ GIMP_PDB_INT32, "hinting", "Hinting on/off" },
{ GIMP_PDB_INT32, "antialiasing", "Antialiasing on/off" },
{ GIMP_PDB_INT32, "outline", "Bezier outline on/off" },
{ GIMP_PDB_INT32, "spacing", "Letter spacing" },
{ GIMP_PDB_STRING, "text", "Text" }
};
static GimpParamDef return_vals[] =
{
{ GIMP_PDB_LAYER, "layer", "The text layer" }
};
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
help_path = g_build_filename (DATADIR, "help", NULL);
help_uri = g_filename_to_uri (help_path, NULL, NULL);
g_free (help_path);
gimp_plugin_help_register ("http://freetype.gimp.org/help", help_uri);
g_free (help_uri);
gimp_install_procedure ("plug_in_freetype",
"FreeType Renderer",
"No help yet",
"Sven Neumann, Jens Lautenbacher, Michael Natterer",
"Sven Neumann, Jens Lautenbacher, Michael Natterer",
"2000-2003",
/* Don't translate the text in brackets (<Image>) */
N_("<Image>/Filters/Text/FreeType..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals),
args, return_vals);
}
/* ------------------
* query
* ------------------
*/
static void
query (void)
{
static GimpLastvalDef lastvals[] =
{
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_TRUE, glob_vals.corpus_border_radius, "corpus_border_radius"),
GIMP_LASTVALDEF_DRAWABLE (GIMP_ITER_TRUE, glob_vals.alt_selection, "alt_selection"),
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_TRUE, glob_vals.seed, "seed")
};
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
/* registration for last values buffer structure (useful for animated filter apply) */
gimp_lastval_desc_register(PLUG_IN_PROC,
&glob_vals,
sizeof(glob_vals),
G_N_ELEMENTS (lastvals),
lastvals);
gimp_install_procedure (PLUG_IN_PROC,
N_("Smart selection eraser."),
"Remove an object from an image by extending surrounding texture to cover it. "
"The object can be represented by the current selection "
"or by an alternative selection (provided as parameter alt_selection) "
"If the image, that is referred by the alt_selection drawable_id has a selection "
"then the referred selection is used to identify the object. "
"otherwise a grayscale copy of the alt_selection drawable_id will be used "
"to identify the object that shall be replaced. "
"alt_selection value -1 indicates that the selection of the input image shall be used. "
"Requires resynthesizer plug-in. (available in the gimp plug-in registry) "
"The smart selection eraser wrapper provides ability to run in GIMP_GAP filtermacros "
"when processing video frames (typically for removing unwanted logos from video frames)."
"(using the same seed value for all frames is recommended) ",
"Wolfgang Hofer",
"Wolfgang Hofer",
PLUG_IN_VERSION,
N_("Smart selection eraser..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
global_number_in_args, global_number_out_args,
in_args, return_vals);
{
/* Menu names */
const char *menupath_image_video_layer = N_("<Image>/Video/Layer/Enhance/");
gimp_plugin_menu_register (PLUG_IN_PROC, menupath_image_video_layer);
}
} /* end query */
static void
query (void)
{
gchar *help_path;
gchar *help_uri;
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Thumbnails" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "SampleTileWidth", "Sample Tile Width" },
{ GIMP_PDB_INT32, "SampleTileHeight", "Sample Tile Height" },
{ GIMP_PDB_INT32, "ActualTileWidth", "Actual Tile Width" },
{ GIMP_PDB_INT32, "ActualTileHeight", "Actual Tile Height" },
{ GIMP_PDB_INT32, "DestinationWidth", "Destination Width" }, // may just check layer size
{ GIMP_PDB_INT32, "DestinationHeight", "Destination Height" }, // ditto
{ GIMP_PDB_INT32, "SourceWidth", "Source Width" },
{ GIMP_PDB_INT32, "SourceHeight", "Source Height" },
{ GIMP_PDB_INT8, "MetricType", "MetricType" },
{ GIMP_PDB_FLOAT, "minMetric", "minMetric" },
{ GIMP_PDB_INT8, "TileOrder", "TileOrder" },
{ GIMP_PDB_INT32, "UniqueTiles", "UniqueTiles" }
//lowestMetric
//shuffle/random
//Unique tiles
};
gimp_plugin_domain_register (PLUGIN_NAME, LOCALEDIR);
help_path = g_build_filename (DATADIR, "help", NULL);
help_uri = g_filename_to_uri (help_path, NULL, NULL);
g_free (help_path);
gimp_plugin_help_register ("http://developer.gimp.org/plug-in-template/help",
help_uri);
gimp_install_procedure (PROCEDURE_NAME,
"Blurb",
"Help",
"Michael Natterer <*****@*****.**>",
"Michael Natterer <*****@*****.**>",
"2000-2004",
N_("Plug-In Template..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PROCEDURE_NAME, "<Image>/Filters/Misc/");
}
static void
query (void)
{
gchar *help_path;
gchar *help_uri;
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, "dummy", "dummy1" },
{ GIMP_PDB_INT32, "dummy", "dummy2" },
{ GIMP_PDB_INT32, "dummy", "dummy3" },
{ GIMP_PDB_INT32, "seed", "Seed value (used only if randomize is FALSE)" },
{ GIMP_PDB_INT32, "randomize", "Use a random seed (TRUE, FALSE)" }
};
gimp_plugin_domain_register (PLUGIN_NAME, LOCALEDIR);
help_path = g_build_filename (DATADIR, "help", NULL);
help_uri = g_filename_to_uri (help_path, NULL, NULL);
g_free (help_path);
gimp_plugin_help_register ("http://developer.gimp.org/plug-in-template/help",
help_uri);
gimp_install_procedure (PROCEDURE_NAME,
"Blurb",
"Help",
"Michael Natterer <*****@*****.**>",
"Michael Natterer <*****@*****.**>",
"2000-2004",
N_("Motion Deblur..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PROCEDURE_NAME, "<Image>/Filters/Enhance/");
#define PROCEDURE_2 "Bilteral Noise Filter"
gimp_install_procedure(PROCEDURE_2, "Blurb","Help","me", "me", "year"
N_("Bilateral noise filter")
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register(PROCEDURE_2, "<Image>/Filters/Enhance/");
}
static void
query (void)
{
gimp_plugin_domain_register (PLUGIN_NAME, NULL);
gimp_install_procedure (PSPI_SETTINGS_NAME,
N_("Set the search path for pspi"),
"Set the directory trees where the pspi plug-in searches for Photoshop filter plug-ins",
"Tor Lillqvist <*****@*****.**>",
"Tor Lillqvist <*****@*****.**>",
"2001",
N_("<Toolbox>/Xtns/Photoshop Plug-in Settings..."),
"",
GIMP_PLUGIN,
pspi_settings_nargs, 0,
pspi_settings_args, NULL);
}
static void
query (void)
{
/* setup for localization */
INIT_I18N ();
/* Arguments for CMYK Separation routines */
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_STRING, "filename", "Filename" }
};
static gint nargs = sizeof (args) / sizeof (args[0]);
static GimpParamDef rargs[] =
{
{ GIMP_PDB_IMAGE, "new_image", "Separated image" }
};
static gint nrargs = sizeof (rargs) / sizeof (rargs[0]);
gimp_install_procedure ("plug_in_separate_import",
_("Import CMYK TIFF image"),
_("Load the CMYK TIFF image, and generate four layers "
"as pseudo C/M/Y/K channels.\nTo convert to single-"
"layered RGB image, try to use the \"plug-in-separate"
"-proof\" procedure."),
"Yoshinori Yamakawa",
"Yoshinori Yamakawa",
"2007-2010",
N_("From CMYK TIFF"),
NULL,
GIMP_PLUGIN,
nargs, nrargs,
args, rargs );
gimp_plugin_menu_register ("plug_in_separate_import",
gimp_major_version > 2 ||
(gimp_major_version == 2 && gimp_minor_version >= 6) ?
"<Image>/File/Create/" : "<Toolbox>/File/Acquire");
gimp_plugin_domain_register (GETTEXT_PACKAGE, NULL);
}
static void
query (void) {
gchar *help_path;
gchar *help_uri;
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, "dummy", "dummy1" },
{ GIMP_PDB_INT32, "dummy", "dummy2" },
{ GIMP_PDB_INT32, "dummy", "dummy3" },
{ GIMP_PDB_INT32, "seed", "Seed value (used only if randomize is FALSE)" },
{ GIMP_PDB_INT32, "randomize", "Use a random seed (TRUE, FALSE)" }
};
gimp_plugin_domain_register (PLUGIN_NAME, LOCALEDIR);
help_path = g_build_filename (DATADIR, "help", NULL);
help_uri = g_filename_to_uri (help_path, NULL, NULL);
g_free (help_path);
gimp_plugin_help_register ("http://www.manucornet.net/Informatique/Texturize.php", help_uri);
gimp_install_procedure (
PROCEDURE_NAME,
"Blurb",
"Help",
"Emmanuel Cornet <*****@*****.**>",
"Jean-Baptiste Rouquier <*****@*****.**>",
"2007",
N_("Texturize..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PROCEDURE_NAME, "<Image>/Filters/Map/");
}
static void
query (void)
{
static const 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, "model", "Model of blurring: (0:Flat, 1:Spherical, 2:Gaussian, 3:Ring, 4:Concave, 5:Brush)"},
{GIMP_PDB_FLOAT, "radius", "Radius for blurring: (0.0 < radius))"},
{GIMP_PDB_FLOAT, "focus", "Focal depth: (0.0 <= focus <= 100.0)"},
{GIMP_PDB_INT32, "map_id", "Depth map drawable id: (drawable_ID or -1 unused)"},
{GIMP_PDB_FLOAT, "s_radius", "Radius for shining: (0.0 <= shine, 0 unused, -1 full shined)"},
{GIMP_PDB_FLOAT, "threshold", "Threshold for shining: (0.0 <= threshold <= 100.0 in %, 0 unused)"},
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Make a out of focus with luminosity and depth, "
"like a sight or lenses"),
"This plug-in makes a out of focus with luminosity "
"and depth, like a sight or lenses. It can be used "
"with depth map, depth fakes and shining effect. "
"Also it works as a simple and applicable blur.",
"Kyoichiro Suda <das atmark dream dot japan>",
"Kyoichiro Suda",
"2002-2008",
N_("_Focus Blur..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Blur");
#ifdef ENABLE_NLS
gimp_plugin_domain_register (GETTEXT_PACKAGE, NULL);
#endif
}
static void
script_fu_query (void)
{
static const GimpParamDef console_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, [non-interactive]" }
};
static const GimpParamDef textconsole_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, [non-interactive]" }
};
static const GimpParamDef eval_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "[Interactive], non-interactive" },
{ GIMP_PDB_STRING, "code", "The code to evaluate" }
};
static const GimpParamDef server_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "[Interactive], non-interactive" },
{ GIMP_PDB_INT32, "port", "The port on which to listen for requests" },
{ GIMP_PDB_STRING, "logfile", "The file to log server activity to" }
};
gimp_plugin_domain_register (GETTEXT_PACKAGE "-script-fu", NULL);
gimp_install_procedure ("extension-script-fu",
"A scheme interpreter for scripting GIMP operations",
"More help here later",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL,
NULL,
GIMP_EXTENSION,
0, 0, NULL, NULL);
gimp_install_procedure ("plug-in-script-fu-console",
N_("Interactive console for Script-Fu development"),
"Provides an interface which allows interactive "
"scheme development.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
N_("_Console"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (console_args), 0,
console_args, NULL);
gimp_plugin_menu_register ("plug-in-script-fu-console",
"<Image>/Filters/Languages/Script-Fu");
gimp_install_procedure ("plug-in-script-fu-text-console",
"Provides a text console mode for script-fu "
"development",
"Provides an interface which allows interactive "
"scheme development.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (textconsole_args), 0,
textconsole_args, NULL);
gimp_install_procedure ("plug-in-script-fu-server",
N_("Server for remote Script-Fu operation"),
"Provides a server for remote script-fu operation",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
N_("_Start Server..."),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (server_args), 0,
server_args, NULL);
gimp_plugin_menu_register ("plug-in-script-fu-server",
"<Image>/Filters/Languages/Script-Fu");
gimp_install_procedure ("plug-in-script-fu-eval",
"Evaluate scheme code",
"Evaluate the code under the scheme interpreter "
"(primarily for batch mode)",
"Manish Singh",
"Manish Singh",
"1998",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (eval_args), 0,
eval_args, NULL);
}
static void query (void)
{
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
/* the actual installation of the plugin */
gimp_install_procedure (PLUG_IN_NAME,
"Image Layer Morphing",
"This plug-in creates new layers by transforming the src_drawable to dst_drawable, "
"the transformation type depends on the render_mode parameter. "
"for MORPH render_mode (0) it is a combination of 2 warp deformation actions "
"and cross-blending, commonly known as morphing."
"The tween_steps parameter controls how much new layers to create. "
"(or how much layers to modify depending on the create_tween_layers parameter) "
"source and destination may differ in size and can be in different images. "
"for WARP render_mode (1) there will be just Move Deformation. "
"Deformation is controlled by workpoints. Workpoints are created and edited with the help "
"of the INTERACTIVE GUI and saved to file(s). "
"For the NON-INTERACTIVE runmode you must provide the filename of such a file. "
"Provide 2 filenames if you want to operate with multiple workpoint sets. "
"In that case your workpoint files can have a 2 digit numberpart. "
"This will implicitly select all filenames with numbers in between as well."
,
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Morph..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (in_args),
0, /* G_N_ELEMENTS (out_args) */
in_args,
NULL /* out_args */
);
/* the actual installation of the plugin */
gimp_install_procedure (PLUG_IN_NAME_TWEEN,
"Render tween frames via morphing",
"This plug-in creates and saves image frames that are a mix of the specified image frame and the frame with to_frame_nr, "
"The typical usage is to create the frame images of missing frame numbers in a series of anim frame images. "
"the overwrite flag allows overwriting of already existing frames between the start frame image "
"and the frame with to_frame_nr"
"Morphing is controled by workpoints. A Workpoint file can be created and edited with the help "
"of the Morph feature in the Video menu. "
"Note: without workpoints the resulting tween is calculated as simple fade operation. "
,
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Morph Tweenframes..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (in_tween_args),
G_N_ELEMENTS (out_tween_args),
in_tween_args,
out_tween_args
);
/* the actual installation of the plugin */
gimp_install_procedure (PLUG_IN_NAME_ONE_TWEEN,
"Render one tween via morphing",
"This plug-in creates a new image that is a mix of the specified src_drawable and dst_drawable, "
"the mixing is done based on a morphing transformation where the tween_mix_factor "
"determines how much the result looks like source or destination. "
"source and destination may differ in size and can be in different images. "
"Morphing is controlled by workpoints. A Workpoint file can be created and edited with the help "
"of the Morph feature in the Video menu. "
"Note: without workpoints the resulting tween is calculated as simple fade operation. "
,
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Morph One Tween..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (in_one_tween_args),
G_N_ELEMENTS (out_one_tween_args),
in_one_tween_args,
out_one_tween_args
);
/* the actual installation of the plugin */
gimp_install_procedure (PLUG_IN_NAME_WORKPOINTS,
"Generate workpoint files for tween frame morphing",
"This plug-in generates workpoint files for the specifed frame range."
"The generated files are saved with the same name as the frame name(s) "
"but with extension .morphpoints "
,
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Morph Workpoint Generator..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (in_workpoint_args),
G_N_ELEMENTS (out_workpoint_args),
in_workpoint_args,
out_workpoint_args
);
{
/* Menu names */
const char *menupath_image_video_morph = N_("<Image>/Video/Morphing/");
gimp_plugin_menu_register (PLUG_IN_NAME, menupath_image_video_morph);
gimp_plugin_menu_register (PLUG_IN_NAME_TWEEN, menupath_image_video_morph);
gimp_plugin_menu_register (PLUG_IN_NAME_ONE_TWEEN, menupath_image_video_morph);
gimp_plugin_menu_register (PLUG_IN_NAME_WORKPOINTS, menupath_image_video_morph);
}
}
static void
query ()
{
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
gimp_install_procedure(GAP_PLUGIN_NAME_ONION_CFG,
"This plugin sets Configuration for Onion Layers in Videofames",
"This plugin is the configuration GUI for Onion layers."
" Onion Layer(s) usually do show previous and/ or next frame(s)"
" of the video in the current frame, depending on ref_mode parameter"
" Onion Layers are not created automatically. You have to create or delete them manually"
" using the menu Video/OnionSkin/make or Video/OnionSkin/delete or call the Procedures "
GAP_PLUGIN_NAME_ONION_APPLY " "
GAP_PLUGIN_NAME_ONION_DEL " "
" The configuration can be saved in the gimprc parameter file.",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
N_("Configuration..."),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
nargs_onion_cfg, nreturn_vals,
args_onion_cfg, return_vals);
gimp_install_procedure(GAP_PLUGIN_NAME_ONION_APPLY,
"This plugin creates or replaces Onionskin Layer(s)",
"This plugin creates or updates Onionskin Layers in the current Videoframe."
" Onion Layer(s) usually do show previous (or next) frame(s)"
" of the video. At 1.st call in the current frame."
" This Plugin runs NONINTERACTIVE only. It depends on the configuration settings"
" made by Video/Onionskin/Config or call of the plugin: "
GAP_PLUGIN_NAME_ONION_CFG " "
" if no configuration is found, default settings are used",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
N_("Create or Replace"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
nargs_onion_std, nreturn_vals,
args_onion_std, return_vals);
gimp_install_procedure(GAP_PLUGIN_NAME_ONION_DEL,
"This plugin removes OnionSkin Layer(s)",
"This plugin removes Onion Skin Layers from the current Videoframe."
" Onion Layer(s) usually do show previous (or next) frame(s)"
" of the video.",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
N_("Delete"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
nargs_onion_std, nreturn_vals,
args_onion_std, return_vals);
gimp_install_procedure(GAP_PLUGIN_NAME_ONION_VISI,
"This plugin toggles visibility of OnionSkin Layer(s)",
"This plugin sets visibility for all onionskin Layers in the current Videoframe.",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
N_("Toggle Visibility"),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
nargs_onion_visi, nreturn_vals,
args_onion_visi, return_vals);
{
/* Menu names */
const char *menupath_image_video = N_("<Image>/Video/");
const char *menupath_image_video_onionskin = N_("<Image>/Video/Onionskin/");
//gimp_plugin_menu_branch_register("<Image>", "Video");
//gimp_plugin_menu_branch_register("<Image>/Video", "Onionskin");
gimp_plugin_menu_register (GAP_PLUGIN_NAME_ONION_CFG, menupath_image_video_onionskin);
gimp_plugin_menu_register (GAP_PLUGIN_NAME_ONION_APPLY, menupath_image_video_onionskin);
gimp_plugin_menu_register (GAP_PLUGIN_NAME_ONION_DEL, menupath_image_video_onionskin);
gimp_plugin_menu_register (GAP_PLUGIN_NAME_ONION_VISI, menupath_image_video_onionskin);
}
} /* end query */
static void
query ()
{
static GimpParamDef args_foreach[] =
{
{GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{GIMP_PDB_IMAGE, "image", "Input image"},
{GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)"},
{GIMP_PDB_STRING, "proc_name", "name of plugin procedure to run for each layer"},
{GIMP_PDB_INT32, "acceleration", "0 .. apply constant, 1..apply varying constant speed, positive accelerate, nagative decelerate"},
};
static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0;
static GimpParamDef args_com_iter[] =
{
{GIMP_PDB_INT32, "run_mode", "non-interactive"},
{GIMP_PDB_INT32, "total_steps", "total number of steps (# of layers-1 to apply the related plug-in)"},
{GIMP_PDB_FLOAT, "current_step", "current (for linear iterations this is the layerstack position, otherwise some value inbetween)"},
{GIMP_PDB_INT32, "len_struct", "length of stored data structure with id is equal to the plug_in proc_name"},
{GIMP_PDB_STRING, "plugin_name", "name of the plugin (used as keyname to access LAST_VALUES buffer)"},
};
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
gimp_install_procedure(PLUG_IN_NAME_ANIMFILTER,
"This plugin calls another plugin for each layer of an image, "
"optional varying its settings (to produce animated effects). "
"The called plugin must work on a single drawable and must be "
"able to run in runmode GIMP_RUN_WITH_LAST_VALS and using gimp_set_data "
"to store its parameters for this session with its own name as access key. "
"plug_in_gap_layers_run_animfilter runs as wizzard (using more dialog steps). "
"In Interactive runmode it starts with with a browser dialog where the name of the "
"other plug-in (that is to execute) can be selected."
"In non-interactive run mode this first browser dialog step is skiped. "
"But the selceted plug-in (in this case via parameter plugin_name) is called in "
"interactive runmode one time or two times if varying parameter is not 0. "
"Those interactive calls are done regardless what runmode is specified here.",
"",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
N_("Filter all Layers..."),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args_foreach), nreturn_vals,
args_foreach, return_vals);
/* ------------------ Common Iterator ------------------------------ */
gimp_install_procedure(GIMP_PLUGIN_GAP_COMMON_ITER,
"This procedure calculates the modified values in the LAST_VALUES buffer named by plugin_name for one iterationstep",
"",
"Wolfgang Hofer",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
NULL, /* do not appear in menus */
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (args_com_iter), nreturn_vals,
args_com_iter, return_vals);
/* ------------------ ALTernative Iterators ------------------------------ */
gimp_plugin_menu_register (PLUG_IN_NAME_ANIMFILTER, N_("<Image>/Filters/"));
gap_query_iterators_ALT();
} /* end query */
static void query (void)
{
static GimpLastvalDef lastvals[] =
{
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_FALSE, fiVals.refShapeRadius, "refShapeRadius"),
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_FALSE, fiVals.targetMoveRadius, "targetMoveRadius"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_FALSE, fiVals.loacteColodiffThreshold, "loacteColodiffThreshold"),
GIMP_LASTVALDEF_GBOOLEAN (GIMP_ITER_FALSE, fiVals.coordsRelToFrame1, "coordsRelToFrame1"),
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_TRUE, fiVals.offsX, "offsX"),
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_TRUE, fiVals.offsY, "offsY"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, fiVals.offsRotate, "offsRotate"),
GIMP_LASTVALDEF_GBOOLEAN (GIMP_ITER_FALSE, fiVals.enableScaling, "enableScaling"),
GIMP_LASTVALDEF_GBOOLEAN (GIMP_ITER_FALSE, fiVals.bgLayerIsReference, "bgLayerIsReference"),
GIMP_LASTVALDEF_GBOOLEAN (GIMP_ITER_FALSE, fiVals.removeMidlayers, "removeMidlayers"),
GIMP_LASTVALDEF_ARRAY (GIMP_ITER_FALSE, fiVals.moveLogFile, "moveLogFileArray"),
GIMP_LASTVALDEF_GCHAR (GIMP_ITER_FALSE, fiVals.moveLogFile[0], "moveLogFileChar"),
};
static GimpLastvalDef xaLastvals[] =
{
GIMP_LASTVALDEF_GINT32 (GIMP_ITER_TRUE, xaVals.framePhase, "framePhase"),
GIMP_LASTVALDEF_ARRAY (GIMP_ITER_FALSE, xaVals.moveLogFile, "moveLogFileArray"),
GIMP_LASTVALDEF_GCHAR (GIMP_ITER_FALSE, xaVals.moveLogFile[0], "moveLogFileChar"),
};
/* registration for last values buffer structure (useful for animated filter apply) */
gimp_lastval_desc_register(PLUG_IN_NAME,
&fiVals,
sizeof(fiVals),
G_N_ELEMENTS (lastvals),
lastvals);
gimp_lastval_desc_register(GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME,
&xaVals,
sizeof(xaVals),
G_N_ELEMENTS (xaLastvals),
xaLastvals);
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
/* the actual installation of the plugin with configuration dialog */
gimp_install_procedure (PLUG_IN_NAME_CFG,
"Locate the position of a small area of one layer in another layer.",
"This filter operates on 2 layers on top of the layerstack, where "
"the topmost layer is the target and the layer below acts as reference layer. "
"The position in the reference layer must be provided by the user as active path with one or 2 points. "
"For proper operation, both reference and target layer must have exact image size."
"The filter loactes the position of the corresponding detail within a specified radius in the target layer "
"and adjusts the marked positions on the corresponding detail in the target layer. "
"This new position is logged in XML format, suitable as input for the MovePath plug-in."
"Note that this filter is typically invoked from the Player on the snapshot image, "
"whenever the player puts the next frame on top of the snaphot image and detail tracking is enabled. "
"Detail tracking can record the unwanted camera movements in a static scene of a video shot freehand (without a stativ) "
"Applying the recorded movements with the MovePath feature can compensate such unwanted movements. "
" ",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("DetailTracking Config..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
global_number_in_args,
global_number_out_args,
in_args,
return_vals);
gimp_install_procedure (PLUG_IN_NAME,
"Non-Interactive Locate the position of a small area of one layer in another layer.",
"This filter operates on 2 layers on top of the layerstack, where "
"the topmost layer is the target and the layer below acts as reference layer. "
"The position in the reference layer must be provided by the user as active path with one or 2 points. "
"For proper operation, both reference and target layer must have exact image size."
"The filter loactes the position of the corresponding detail within a specified radius in the target layer "
"and adjusts the marked positions on the corresponding detail in the target layer. "
"This new position is logged in XML format, suitable as input for the MovePath plug-in."
"Note that this filter is typically invoked from the Player on the snapshot image, "
"whenever the player puts the next frame on top of the snaphot image and detail tracking is enabled. "
"Detail tracking can record the unwanted camera movements in a static scene of a video shot freehand (without a stativ) "
"Applying the recorded movements with the MovePath feature can compensate such unwanted movements. "
" ",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("DetailTracking"),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
global_number_in_args,
global_number_out_args,
in_args,
return_vals);
/* the installation of the xml based aligner plugin */
gimp_install_procedure (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME,
"Exact Align Layer via transformation according to current phase of detail tracking (recorded in XML file).",
"This filter tranforms the specified layer. "
"It uses the relevant controlpoint (that matches the framePhase parameter) in the recorded XML file as input. "
"and calculates offsts, scaling and rotation to transform the layer in a way that the points p1x p1y p2x p2y "
"will exactly match with the points p1x p1y p2x p2y of the 1st controlpoint in the XML file."
"(calling this filter with framePhase 1 does no transformation) "
"This filter is intended to run under control of the gimp-gap frames modify feature "
"to align multiple frames according to the controlpoints recorde in an XML file (via Detail tracking feature)."
" ",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Align Transform via XML file..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
global_number_in_xml_args,
global_number_out_args,
in_xml_args,
return_vals);
/* the installation of the 4-point path based aligner plugin */
gimp_install_procedure (GAP_EXACT_ALIGNER_PLUG_IN_NAME,
"Exact Align Layer via transformation according 4 points specified in the current path.",
"This filter expects a current path with 4 points as input where point 1 and 2 mark positions "
"within a reference layer and points 3 and 4 mark 2 corresponding point in the target layer. "
"The transformation is applied to the target layer and sets offsets, scaling and rotation "
"in a way that point3 is placed on position of point1, and point4 is placed on position of point2."
" "
" ",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Exact Align via 4-Point Path."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
global_number_in_exalign_args,
global_number_out_args,
in_exalign_args,
return_vals);
{
/* Menu names */
const char *menupath_image_layer_enhance = N_("<Image>/Video/Layer/Enhance/");
const char *menupath_image_layer_transform = N_("<Image>/Layer/Transform/");
gimp_plugin_menu_register (PLUG_IN_NAME_CFG, menupath_image_layer_enhance);
gimp_plugin_menu_register (PLUG_IN_NAME, menupath_image_layer_enhance);
gimp_plugin_menu_register (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME, menupath_image_layer_enhance);
gimp_plugin_menu_register (GAP_EXACT_ALIGNER_PLUG_IN_NAME, menupath_image_layer_transform);
}
} /* end query */
static void
script_fu_query (void)
{
static const GimpParamDef console_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" }
};
static const GimpParamDef textconsole_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" }
};
static const GimpParamDef eval_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "code", "The code to evaluate" }
};
static const GimpParamDef server_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "ip", "The ip on which to listen for requests" },
{ GIMP_PDB_INT32, "port", "The port on which to listen for requests" },
{ GIMP_PDB_STRING, "logfile", "The file to log server activity to" }
};
gimp_plugin_domain_register (GETTEXT_PACKAGE "-script-fu", NULL);
gimp_install_procedure ("extension-script-fu",
"A scheme interpreter for scripting GIMP operations",
"More help here later",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL,
NULL,
GIMP_EXTENSION,
0, 0, NULL, NULL);
gimp_install_procedure ("plug-in-script-fu-console",
N_("Interactive console for Script-Fu development"),
"Provides an interface which allows interactive "
"scheme development.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
N_("_Console"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (console_args), 0,
console_args, NULL);
gimp_plugin_menu_register ("plug-in-script-fu-console",
"<Image>/Filters/Languages/Script-Fu");
gimp_install_procedure ("plug-in-script-fu-text-console",
"Provides a text console mode for script-fu "
"development",
"Provides an interface which allows interactive "
"scheme development.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (textconsole_args), 0,
textconsole_args, NULL);
gimp_install_procedure ("plug-in-script-fu-server",
N_("Server for remote Script-Fu operation"),
"Provides a server for remote script-fu operation. "
"NOTE that for security reasons this procedure's "
"API was changed in an incompatible way since "
"GIMP 2.8.12. You now have to pass the IP to listen "
"on as first parameter. Calling this procedure with "
"the old API will fail on purpose.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
N_("_Start Server..."),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (server_args), 0,
server_args, NULL);
gimp_plugin_menu_register ("plug-in-script-fu-server",
"<Image>/Filters/Languages/Script-Fu");
gimp_install_procedure ("plug-in-script-fu-eval",
"Evaluate scheme code",
"Evaluate the code under the scheme interpreter "
"(primarily for batch mode)",
"Manish Singh",
"Manish Singh",
"1998",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (eval_args), 0,
eval_args, NULL);
}
static void
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 (must be a layer without layermask)"},
{ GIMP_PDB_INT32, "hue_range", "Range of affected hues: ALL_HUES (0), RED_HUES(1), YELLOW_HUES(2), GREEN_HUES(3), CYAN_HUES(4), BLUE_HUES(5), MAGENTA_HUES(6)"},
{ GIMP_PDB_FLOAT, "hue_offset", "Hue Offset uin degrees (-180 <= hue_offset <= 180"},
{ GIMP_PDB_FLOAT, "lightness", "lightness Modification (-100 <= lightness <= 100"},
{ GIMP_PDB_FLOAT, "saturation", "saturation Modification (-100 <= saturation <= 100"},
};
static int nargs = sizeof(args) / sizeof(args[0]);
static GimpParamDef return_vals[] =
{
{ GIMP_PDB_DRAWABLE, "the_drawable", "the handled drawable" }
};
static int nreturn_vals = sizeof(return_vals) / sizeof(return_vals[0]);
static GimpParamDef args_iter[] =
{
{GIMP_PDB_INT32, "run_mode", "non-interactive"},
{GIMP_PDB_INT32, "total_steps", "total number of steps (# of layers-1 to apply the related plug-in)"},
{GIMP_PDB_FLOAT, "current_step", "current (for linear iterations this is the layerstack position, otherwise some value inbetween)"},
{GIMP_PDB_INT32, "len_struct", "length of stored data structure with id is equal to the plug_in proc_name"},
};
static int nargs_iter = sizeof(args_iter) / sizeof(args_iter[0]);
static GimpParamDef *return_iter = NULL;
static int nreturn_iter = 0;
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
/* the actual installation of the bend plugin */
gimp_install_procedure (PLUG_IN_NAME,
PLUG_IN_DESCRIPTION,
"This Plugin is a wrapper to call the GIMP Hue Saturation Color Tool (gimp_hue_saturation)"
" it has a simplified Dialog (without preview) where you can enter the parameters"
" this wrapper is useful for animated filtercalls and provides "
" a PDB interface that runs in GIMP_RUN_WITH_LAST_VALUES mode"
" and also provides an Iterator Procedure for animated calls"
,
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
N_("Hue-Saturation..."),
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
nargs,
nreturn_vals,
args,
return_vals);
/* the installation of the Iterator extension for the bend plugin */
gimp_install_procedure (PLUG_IN_ITER_NAME,
"This extension calculates the modified values for one iterationstep for the call of plug_in_curve_bend",
"",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
GAP_VERSION_WITH_DATE,
NULL, /* do not appear in menus */
NULL,
GIMP_PLUGIN,
nargs_iter, nreturn_iter,
args_iter, return_iter);
{
/* Menu names */
const char *menupath_image_video_layer_colors = N_("<Image>/Video/Layer/Colors/");
//gimp_plugin_menu_branch_register("<Image>", "Video");
//gimp_plugin_menu_branch_register("<Image>/Video", "Layer");
//gimp_plugin_menu_branch_register("<Image>/Video/Layer", "Colors");
gimp_plugin_menu_register (PLUG_IN_NAME, menupath_image_video_layer_colors);
}
}
static void
init (void)
{
GimpMessageHandlerType old_handler;
gimp_plugin_domain_register (PLUGIN_NAME, NULL);
setup_debug_mask ();
old_handler = gimp_message_get_handler ();
if (old_handler == GIMP_CONSOLE)
gimp_message_set_handler (GIMP_MESSAGE_BOX);
search_path = gimp_gimprc_query (PSPI_PATH_TOKEN);
if (search_path == NULL)
search_path = g_strdup ("");
get_saved_plugin_data ();
pspirc_values_modified = FALSE;
scan_search_path ();
/* Forget those PS plug-ins that weren't around any longer. */
g_hash_table_foreach_remove (plug_in_hash, check_present, NULL);
/* Rewrite the pspirc file if necessary */
if (pspirc_values_modified)
{
gchar *pspirc_name = gimp_personal_rc_file (PSPIRC);
gchar *temp_name = g_strconcat (pspirc_name, ".new", NULL);
gchar *bak_name = g_strconcat (pspirc_name, ".bak", NULL);
FILE *pspirc = fopen (temp_name, "w");
if (pspirc == NULL)
g_message (_("Could not open %s for writing"), temp_name);
else
{
PSPI_DEBUG (PSPIRC, g_print ("Saving pspirc file\n"));
fprintf (pspirc, "<pspi-settings>\n");
g_hash_table_foreach (plug_in_hash, save_pspirc_entry, pspirc);
fprintf (pspirc, "</pspi-settings>\n");
PSPI_DEBUG (PSPIRC, g_print ("\n"));
fclose (pspirc);
remove (bak_name);
if (g_file_test (pspirc_name, G_FILE_TEST_EXISTS) &&
rename (pspirc_name, bak_name) != 0)
g_message (_("Could not rename %s to %s"),
pspirc_name, bak_name);
else
{
if (rename (temp_name, pspirc_name) != 0)
{
g_message (_("Could not rename %s to %s"),
temp_name, pspirc_name);
if (rename (bak_name, pspirc_name) != 0)
g_message (_("Could not rename %s to %s"),
bak_name, pspirc_name);
}
else
remove (bak_name);
}
}
g_free (pspirc_name);
g_free (temp_name);
g_free (bak_name);
}
if (old_handler == GIMP_CONSOLE)
gimp_message_set_handler (GIMP_CONSOLE);
}
/* ---------------------------------
* query
* ---------------------------------
*/
static void
query ()
{
static GapBlueboxVals bbox_vals; /* this structure is only used as structure model
* for common iterator procedure registration
*/
static GimpLastvalDef lastvals[] =
{
GIMP_LASTVALDEF_GIMPRGB (GIMP_ITER_TRUE, bbox_vals.keycolor, "keycolor"),
GIMP_LASTVALDEF_ENUM (GIMP_ITER_FALSE, bbox_vals.thres_mode, "thres_mode"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres_r, "thres_r"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres_g, "thres_g"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres_b, "thres_b"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres_h, "thres_h"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres_s, "thres_s"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres_v, "thres_v"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.thres, "thres"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.tolerance, "tolerance"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.grow, "grow"),
GIMP_LASTVALDEF_GINT (GIMP_ITER_TRUE, bbox_vals.feather_edges, "feather_edges"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.feather_radius, "feather_radius"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.source_alpha, "source_alpha"),
GIMP_LASTVALDEF_GDOUBLE (GIMP_ITER_TRUE, bbox_vals.target_alpha, "target_alpha"),
};
static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0;
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
/* registration for last values buffer structure (useful for animated filter apply) */
gimp_lastval_desc_register(GAP_BLUEBOX_PLUGIN_NAME,
&bbox_vals,
sizeof(bbox_vals),
G_N_ELEMENTS (lastvals),
lastvals);
gimp_install_procedure(GAP_BLUEBOX_PLUGIN_NAME,
"The bluebox effectfilter makes the specified color transparent",
"This plug-in selects pixels in the specified drawable by keycolor "
"and makes the Selected Pixels transparent. "
"If there is a selection at calling time, then operate only "
"on Pixels that are already selected (where selection value is > 0) "
"The Slection by color follows threshold values "
"The thresholds operate on RGB or HSV colormodel, "
"depending on the thres_mode parameter. "
"The selection by keycolor can be smoothed (by feather_radius) "
"and/or extended by a grow value.",
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
gap_bluebox_version,
N_("Bluebox ..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args_bluebox), nreturn_vals,
args_bluebox, return_vals);
//gimp_plugin_menu_branch_register("<Image>", "Video");
gimp_plugin_menu_register (GAP_BLUEBOX_PLUGIN_NAME, N_("<Image>/Video/"));
} /* end query */
/* ----------------------------------------
* query
* ----------------------------------------
*/
static void
query ()
{
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
static GimpParamDef args_qt_enc[] =
{
{GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{GIMP_PDB_IMAGE, "image", "Input image"},
{GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)"},
{GIMP_PDB_STRING, "vidfile", "filename of the output video (to write)"},
{GIMP_PDB_INT32, "range_from", "number of first frame"},
{GIMP_PDB_INT32, "range_to", "number of last frame"},
{GIMP_PDB_INT32, "vid_width", "Width of resulting Video Frames (all Frames are scaled to this width)"},
{GIMP_PDB_INT32, "vid_height", "Height of resulting Video Frames (all Frames are scaled to this height)"},
{GIMP_PDB_INT32, "vid_format", "videoformat: 0=comp., 1=PAL, 2=NTSC, 3=SECAM, 4=MAC, 5=unspec"},
{GIMP_PDB_FLOAT, "framerate", "framerate in frames per seconds"},
{GIMP_PDB_INT32, "samplerate", "audio samplerate in samples per seconds (.wav files are resampled using sox, if needed)"},
{GIMP_PDB_STRING, "audfile", "optional audiodata file .wav or any audiodata compatible to sox (see manpage of sox for more info)"},
{GIMP_PDB_STRING, "vid_enc_plugin", "name of a gap_video_encoder plugin choose one of these strings: \n"
"\"" GAP_PLUGIN_NAME_SINGLEFRAMES_ENCODE "\"\n"
"\"" GAP_PLUGIN_NAME_FFMPEG_ENCODE "\"\n"
"\"" GAP_PLUGIN_NAME_AVI_ENCODE "\"\n"
/* "\"" GAP_PLUGIN_NAME_QT1_ENCODE "\"\n" */
/* "\"" GAP_PLUGIN_NAME_QT2_ENCODE "\"\n" */
/* "\"" GAP_PLUGIN_NAME_MPG1_ENCODE "\"\n" */
/* "\"" GAP_PLUGIN_NAME_MPG2_ENCODE "\"\n" */
},
{GIMP_PDB_STRING, "filtermacro_file", "macro to apply on each handled frame."
" filtermacro_files are textfiles with filter plugin names and LASTVALUE bufferdump,"
" usually created by gimp-gap filermacro dialog "
" (menu: Filters->Filtermacro)"},
{GIMP_PDB_STRING, "storyboard_file", "textfile with list of one or more images, framesequences, videoclips or audioclips (see storyboard docs for more information)"},
{GIMP_PDB_INT32, "input_mode", "0 ... image is one of the frames to encode, range_from/to params refere to numberpart of the other frameimages on disc. \n"
"1 ... image is multilayer, range_from/to params refere to layer index. \n"
"2 ... image is ignored, input is specified by storyboard_file parameter."},
};
static int nargs_qt_enc = sizeof(args_qt_enc) / sizeof(args_qt_enc[0]);
static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0;
INIT_I18N();
gimp_install_procedure(GAP_CME_PLUGIN_NAME_VID_ENCODE_MASTER,
_("This plugin is the master dialog for video + audio encoding"),
_("This plugin is a common GUI for all available video + audio encoding plugins"
" it operates on a selected range of animframes or storyboard files."
" The (optional) audio inputdata (param: audfile) is transformed to RIFF WAVE format (16Bit PCM)"
" and passed to the selected videoencoder plug-in as temporary file."
" (or direct if format and samplerate already matches the desired target samplerate)."
" The videoformat is defined with vid_enc_plugin parameter. The specified plugin "
" is called with the parameters specified in the dialog. for noninteractive calls"
" default values will be used. (you may call the desired plugin directly if you"
" want to specify non-interacive parameters"),
"Wolfgang Hofer ([email protected])",
"Wolfgang Hofer",
GAP_VERSION_WITH_DATE,
N_("Master Videoencoder..."),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
nargs_qt_enc, nreturn_vals,
args_qt_enc, return_vals);
//gimp_plugin_menu_branch_register("<Image>", "Video");
gimp_plugin_menu_register (GAP_CME_PLUGIN_NAME_VID_ENCODE_MASTER, N_("<Image>/Video/"));
} /* end query */
