/* 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 */