static void query (void) { static const GimpParamDef args[] = { { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)" } }; static const GimpParamDef return_args[] = { { GIMP_PDB_IMAGE, "result", "Resulting image" } }; gimp_install_procedure (OPTIMIZE_PROC, N_("Modify image to reduce size when saved as GIF animation"), "This procedure applies various optimizations to" " a GIMP layer-based animation in an attempt to" " reduce the final file size. If a frame of the" " animation can use the 'combine' mode, this" " procedure attempts to maximize the number of" " ajdacent pixels having the same color, which" " improves the compression for some image formats" " such as GIF or MNG.", "Adam D. Moss <*****@*****.**>", "Adam D. Moss <*****@*****.**>", "1997-2003", N_("Optimize (for _GIF)"), "RGB*, INDEXED*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_args), args, return_args); gimp_install_procedure (OPTIMIZE_DIFF_PROC, N_("Reduce file size where combining layers is possible"), "This procedure applies various optimizations to" " a GIMP layer-based animation in an attempt to" " reduce the final file size. If a frame of the" " animation can use the 'combine' mode, this" " procedure uses a simple difference between the" " frames.", "Adam D. Moss <*****@*****.**>", "Adam D. Moss <*****@*****.**>", "1997-2001", N_("_Optimize (Difference)"), "RGB*, INDEXED*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_args), args, return_args); gimp_install_procedure (UNOPTIMIZE_PROC, N_("Remove optimization to make editing easier"), "This procedure 'simplifies' a GIMP layer-based" " animation that has been optimized for animation. " "This makes editing the animation much easier.", "Adam D. Moss <*****@*****.**>", "Adam D. Moss <*****@*****.**>", "1997-2001", N_("_Unoptimize"), "RGB*, INDEXED*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_args), args, return_args); gimp_plugin_menu_register (OPTIMIZE_PROC, "<Image>/Filters/Animation"); gimp_plugin_menu_register (OPTIMIZE_DIFF_PROC, "<Image>/Filters/Animation"); gimp_plugin_menu_register (UNOPTIMIZE_PROC, "<Image>/Filters/Animation"); #ifdef EXPERIMENTAL_BACKDROP_CODE gimp_install_procedure (REMOVE_BACKDROP_PROC, "This procedure attempts to remove the backdrop" " from a GIMP layer-based animation, leaving" " the foreground animation over transparency.", "", "Adam D. Moss <*****@*****.**>", "Adam D. Moss <*****@*****.**>", "2001", N_("_Remove Backdrop"), "RGB*, INDEXED*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_args), args, return_args); gimp_install_procedure (FIND_BACKDROP_PROC, "This procedure attempts to remove the foreground" " from a GIMP layer-based animation, leaving" " a one-layered image containing only the" " constant backdrop image.", "", "Adam D. Moss <*****@*****.**>", "Adam D. Moss <*****@*****.**>", "2001", N_("_Find Backdrop"), "RGB*, INDEXED*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_args), args, return_args); gimp_plugin_menu_register (REMOVE_BACKDROP_PROC, "<Image>/Filters/Animation"); gimp_plugin_menu_register (FIND_BACKDROP_PROC, "<Image>/Filters/Animation"); #endif }
static void query (void) { static const GimpParamDef info_return_vals[] = { { GIMP_PDB_STRING, "profile-name", "Name" }, { GIMP_PDB_STRING, "profile-desc", "Description" }, { GIMP_PDB_STRING, "profile-info", "Info" } }; gimp_install_procedure (PLUG_IN_PROC_SET, N_("Set a color profile on the image"), "This procedure sets an ICC color profile on an " "image using the 'icc-profile' parasite. It does " "not do any color conversion.", "Sven Neumann", "Sven Neumann", "2006, 2007", N_("_Assign Color Profile..."), "RGB*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (set_args), 0, set_args, NULL); gimp_install_procedure (PLUG_IN_PROC_SET_RGB, "Set the default RGB color profile on the image", "This procedure sets the user-configured RGB " "profile on an image using the 'icc-profile' " "parasite. If no RGB profile is configured, sRGB " "is assumed and the parasite is unset. This " "procedure does not do any color conversion.", "Sven Neumann", "Sven Neumann", "2006, 2007", N_("Assign default RGB Profile"), "RGB*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (set_rgb_args), 0, set_rgb_args, NULL); gimp_install_procedure (PLUG_IN_PROC_APPLY, _("Apply a color profile on the image"), "This procedure transform from the image's color " "profile (or the default RGB profile if none is " "set) to the given ICC color profile. Only RGB " "color profiles are accepted. The profile " "is then set on the image using the 'icc-profile' " "parasite.", "Sven Neumann", "Sven Neumann", "2006, 2007", N_("_Convert to Color Profile..."), "RGB*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (apply_args), 0, apply_args, NULL); gimp_install_procedure (PLUG_IN_PROC_APPLY_RGB, "Apply default RGB color profile on the image", "This procedure transform from the image's color " "profile (or the default RGB profile if none is " "set) to the configured default RGB color profile. " "The profile is then set on the image using the " "'icc-profile' parasite. If no RGB color profile " "is configured, sRGB is assumed and the parasite " "is unset.", "Sven Neumann", "Sven Neumann", "2006, 2007", N_("Convert to default RGB Profile"), "RGB*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (apply_rgb_args), 0, apply_rgb_args, NULL); gimp_install_procedure (PLUG_IN_PROC_INFO, "Retrieve information about an image's color profile", "This procedure returns information about the RGB " "color profile attached to an image. If no RGB " "color profile is attached, sRGB is assumed.", "Sven Neumann", "Sven Neumann", "2006, 2007", N_("Image Color Profile Information"), "*", GIMP_PLUGIN, G_N_ELEMENTS (info_args), G_N_ELEMENTS (info_return_vals), info_args, info_return_vals); gimp_install_procedure (PLUG_IN_PROC_FILE_INFO, "Retrieve information about a color profile", "This procedure returns information about an ICC " "color profile on disk.", "Sven Neumann", "Sven Neumann", "2006, 2007", N_("Color Profile Information"), "*", GIMP_PLUGIN, G_N_ELEMENTS (file_info_args), G_N_ELEMENTS (info_return_vals), file_info_args, info_return_vals); gimp_plugin_menu_register (PLUG_IN_PROC_SET, "<Image>/Image/Mode/Color Profile"); gimp_plugin_menu_register (PLUG_IN_PROC_APPLY, "<Image>/Image/Mode/Color Profile"); }
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 */
/* --------------------------------- * 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 */
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 const GimpParamDef editor_args[] = { { GIMP_PDB_INT32, "run-mode", "Run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)" } }; static const GimpParamDef decode_xmp_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "xmp", "XMP packet" } }; static const GimpParamDef encode_xmp_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" } }; static const GimpParamDef encode_xmp_return_vals[] = { { GIMP_PDB_STRING, "xmp", "XMP packet" } }; static const GimpParamDef decode_exif_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_INT32, "exif-size", "size of the EXIF block" }, { GIMP_PDB_INT8ARRAY, "exif", "EXIF block" } }; /* FIXME: uncomment when these are working static const GimpParamDef encode_exif_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" } }; static const GimpParamDef encode_exif_return_vals[] = { { GIMP_PDB_INT32, "exif-size", "size of the EXIF block" }, { GIMP_PDB_INT8ARRAY, "exif", "EXIF block" } }; */ static const GimpParamDef get_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" }, { GIMP_PDB_STRING, "property", "XMP property name" } }; static const GimpParamDef get_return_vals[] = { { GIMP_PDB_INT32, "type", "XMP property type" }, { GIMP_PDB_INT32, "num-vals", "number of values" }, { GIMP_PDB_STRINGARRAY, "vals", "XMP property values" } }; static const GimpParamDef set_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" }, { GIMP_PDB_STRING, "property", "XMP property name" }, { GIMP_PDB_INT32, "type", "XMP property type" }, { GIMP_PDB_INT32, "num-vals", "number of values" }, { GIMP_PDB_STRINGARRAY, "vals", "XMP property values" } }; static const GimpParamDef get_simple_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" }, { GIMP_PDB_STRING, "property", "XMP property name" } }; static const GimpParamDef get_simple_return_vals[] = { { GIMP_PDB_STRING, "value", "XMP property value" } }; static const GimpParamDef set_simple_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" }, { GIMP_PDB_STRING, "property", "XMP property name" }, { GIMP_PDB_STRING, "value", "XMP property value" } }; /* FIXME: uncomment when these are working static const GimpParamDef delete_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "schema", "XMP schema prefix or URI" }, { GIMP_PDB_STRING, "property", "XMP property name" } }; static const GimpParamDef add_schema_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "prefix", "XMP schema prefix" }, { GIMP_PDB_STRING, "uri", "XMP schema URI" } }; */ static const GimpParamDef import_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "filename", "The name of the XMP file to import" } }; static const GimpParamDef export_args[] = { { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_STRING, "filename", "The name of the file to save the XMP packet in" }, { GIMP_PDB_INT32, "overwrite", "Overwrite existing file: { FALSE (0), TRUE (1) }" } }; gimp_install_procedure (EDITOR_PROC, N_("View and edit metadata (EXIF, IPTC, XMP)"), "View and edit metadata information attached to the " "current image. This can include EXIF, IPTC and/or " "XMP information. Some or all of this metadata " "will be saved in the file, depending on the output " "file format.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2004-2005", N_("Propert_ies"), "RGB*, INDEXED*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (editor_args), 0, editor_args, NULL); gimp_plugin_menu_register (EDITOR_PROC, "<Image>/File/Info"); // XXX gimp_plugin_icon_register (EDITOR_PROC, GIMP_ICON_TYPE_STOCK_ID, gimp_install_procedure (DECODE_XMP_PROC, "Decode an XMP packet", "Parse an XMP packet and merge the results with " "any metadata already attached to the image. This " "should be used when an XMP packet is read from an " "image file.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (decode_xmp_args), 0, decode_xmp_args, NULL); gimp_install_procedure (ENCODE_XMP_PROC, "Encode metadata into an XMP packet", "Generate an XMP packet from the metadata " "information attached to the image. The new XMP " "packet can then be saved into a file.", "Róman Joost <*****@*****.**>", "Róman Joost <*****@*****.**>", "2008", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (encode_xmp_args), G_N_ELEMENTS (encode_xmp_return_vals), encode_xmp_args, encode_xmp_return_vals); gimp_install_procedure (DECODE_EXIF_PROC, "Decode an EXIF block", "Parse an EXIF block and merge the results with " "any metadata already attached to the image. This " "should be used when an EXIF block is read from an " "image file.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (decode_exif_args), 0, decode_exif_args, NULL); /* FIXME: uncomment when these are working gimp_install_procedure (ENCODE_EXIF_PROC, "Encode metadata into an EXIF block", "Generate an EXIF block from the metadata " "information attached to the image. The new EXIF " "block can then be saved into a file.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (encode_exif_args), G_N_ELEMENTS (encode_exif_return_vals), encode_exif_args, encode_exif_return_vals); */ gimp_install_procedure (GET_PROC, "Retrieve the values of an XMP property", "Retrieve the list of values associated with " "an XMP property.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (get_args), G_N_ELEMENTS (get_return_vals), get_args, get_return_vals); gimp_install_procedure (SET_PROC, "Set the values of an XMP property", "Set the list of values associated with " "an XMP property. If a property with the same " "name already exists, it will be replaced.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (set_args), 0, set_args, NULL); gimp_install_procedure (GET_SIMPLE_PROC, "Retrieve the value of an XMP property", "Retrieve value associated with a scalar XMP " "property. This can only be done for simple " "property types such as text or integers. " "Structured types must be retrieved with " "plug_in_metadata_get().", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (get_simple_args), G_N_ELEMENTS (get_simple_return_vals), get_simple_args, get_simple_return_vals); gimp_install_procedure (SET_SIMPLE_PROC, "Set the value of an XMP property", "Set the value of a scalar XMP property. This " "can only be done for simple property types such " "as text or integers. Structured types need to " "be set with plug_in_metadata_set().", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (set_simple_args), 0, set_simple_args, NULL); gimp_install_procedure (IMPORT_PROC, "Import XMP from a file into the current image", "Load an XMP packet from a file and import it into " "the current image. This can be used to add a " "license statement or some other predefined " "metadata to an image", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (import_args), 0, import_args, NULL); gimp_install_procedure (EXPORT_PROC, "Export XMP from the current image to a file", "Export the metadata associated with the current " "image into a file. The metadata will be saved as " "an XMP packet. If overwrite is TRUE, then any " "existing file will be overwritten without warning. " "If overwrite is FALSE, then an error will occur if " "the file already exists.", "Raphaël Quinet <*****@*****.**>", "Raphaël Quinet <*****@*****.**>", "2005", NULL, NULL, GIMP_PLUGIN, G_N_ELEMENTS (export_args), 0, export_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 script_fu_extension_init (void) { static const GimpParamDef args[] = { { GIMP_PDB_INT32, "run-mode", "[Interactive], non-interactive" } }; gimp_plugin_menu_branch_register ("<Toolbox>/Help", N_("_GIMP Online")); gimp_plugin_menu_branch_register ("<Toolbox>/Help", N_("_User Manual")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns/Languages", N_("_Script-Fu")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns", N_("_Buttons")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns", N_("_Logos")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns", N_("_Misc")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns", N_("_Patterns")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns/Languages/Script-Fu", N_("_Test")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns", N_("_Utilities")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns", N_("_Web Page Themes")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns/Web Page Themes", N_("_Alien Glow")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns/Web Page Themes", N_("_Beveled Pattern")); gimp_plugin_menu_branch_register ("<Toolbox>/Xtns/Web Page Themes", N_("_Classic.Gimp.Org")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("Alpha to _Logo")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("An_imation")); gimp_plugin_menu_branch_register ("<Image>/Filters/Animation", N_("_Animators")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("_Artistic")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("_Blur")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("_Decor")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("_Effects")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("En_hance")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("_Light and Shadow")); gimp_plugin_menu_branch_register ("<Image>/Filters/Light and Shadow", N_("S_hadow")); gimp_plugin_menu_branch_register ("<Image>/Filters", N_("_Render")); gimp_plugin_menu_branch_register ("<Image>/Filters/Effects", N_("_Alchemy")); gimp_install_temp_proc ("script-fu-refresh", N_("Re-read all available Script-Fu scripts"), "Re-read all available Script-Fu scripts", "Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis", "1997", N_("_Refresh Scripts"), NULL, GIMP_TEMPORARY, G_N_ELEMENTS (args), 0, args, NULL, script_fu_refresh_proc); gimp_plugin_menu_register ("script-fu-refresh", "<Toolbox>/Xtns/Languages/Script-Fu"); }
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 query(void) { // Load procedure arguments static const GimpParamDef load_args[] = { {GIMP_PDB_INT32, (gchar*)"run-mode", (gchar*)"Interactive, non-interactive"}, {GIMP_PDB_STRING, (gchar*)"filename", (gchar*)"The name of the file to load"}, {GIMP_PDB_STRING, (gchar*)"raw-filename", (gchar*)"The name entered"} }; // Load procedure return values static const GimpParamDef load_return_values[] = { {GIMP_PDB_IMAGE, (gchar*)"image", (gchar*)"Output image"} }; // Install load procedure gimp_install_procedure(LOAD_PROCEDURE, "Load a Packed Layer Texture (.plt)", "Load a Packed Layer Texture (.plt)", "Attila Gyoerkoes", "GPL v3", "2016", "<Load>/Packed Layer Texture", NULL, GIMP_PLUGIN, G_N_ELEMENTS(load_args), G_N_ELEMENTS(load_return_values), load_args, load_return_values); // Register Load handlers gimp_register_file_handler_mime(LOAD_PROCEDURE, "image/plt"); gimp_register_load_handler(LOAD_PROCEDURE, "plt", ""); // Save procedure arguments static const GimpParamDef save_args[] = { {GIMP_PDB_INT32, (gchar*)"run-mode", (gchar*)"Interactive, non-interactive" }, {GIMP_PDB_IMAGE, (gchar*)"image", (gchar*)"Input image" }, {GIMP_PDB_DRAWABLE, (gchar*)"drawable", (gchar*)"Drawable to save" }, {GIMP_PDB_STRING, (gchar*)"filename", (gchar*)"The name of the file to save the image in" }, {GIMP_PDB_STRING, (gchar*)"raw-filename", (gchar*)"The name entered" } }; // Install save procedure gimp_install_procedure(SAVE_PROCEDURE, "Save a Packed Layer Texture (.plt)", "Save a Packed Layer Texture (.plt)", "Attila Gyoerkoes", "GPL v3", "2016", "<Save>/Packed Layer Texture", "RGB*", GIMP_PLUGIN, G_N_ELEMENTS(save_args), 0, save_args, NULL); // Register Save handlers gimp_register_file_handler_mime(SAVE_PROCEDURE, "image/plt"); gimp_register_save_handler(SAVE_PROCEDURE, "plt", ""); // Add Layers procedure arguments static const GimpParamDef addl_args[] = { {GIMP_PDB_INT32, (gchar*)"run-mode", (gchar*)"Interactive, non-interactive" }, {GIMP_PDB_IMAGE, (gchar*)"image", (gchar*)"Input image" } }; // Install Add Layers procedure gimp_install_procedure(ADDL_PROCEDURE, "Add plt layers", "Add plt layers", "Attila Gyoerkoes", "GPL v3", "2016", "Add missing plt layers", "*", GIMP_PLUGIN, G_N_ELEMENTS(addl_args), 0, addl_args, NULL); // Register Add Layers handlers gimp_plugin_menu_register(ADDL_PROCEDURE, "<Image>/Tools"); }
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 (void) { static const GimpParamDef args[] = { { GIMP_PDB_INT32, "run_mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_FLOAT, "rndm_pct", "Randomization percentage (1.0 - 100.0)" }, { GIMP_PDB_FLOAT, "rndm_rcount", "Repeat count (1.0 - 100.0)" }, { GIMP_PDB_INT32, "randomize", "Use random seed { TRUE, FALSE }" }, { GIMP_PDB_INT32, "seed", "Seed value (used only if randomize is FALSE)" } }; const gchar *hurl_blurb = N_("Completely randomize a fraction of pixels"); const gchar *pick_blurb = N_("Randomly interchange some pixels with neighbors"); const gchar *slur_blurb = N_("Randomly slide some pixels downward (similar to melting)"); const gchar *hurl_help = "This plug-in ``hurls'' randomly-valued pixels onto the selection or " "image. You may select the percentage of pixels to modify and the number " "of times to repeat the process."; const gchar *pick_help = "This plug-in replaces a pixel with a random adjacent pixel. You may " "select the percentage of pixels to modify and the number of times to " "repeat the process."; const gchar *slur_help = "This plug-in slurs (melts like a bunch of icicles) an image. You may " "select the percentage of pixels to modify and the number of times to " "repeat the process."; const gchar *author = "Miles O'Neal <*****@*****.**>"; const gchar *copyrights = "Miles O'Neal, Spencer Kimball, Peter Mattis, " "Torsten Martinsen, Brian Degenhardt, Federico Mena Quintero, Stephen " "Norris, Daniel Cotting"; const gchar *copyright_date = "1995-1998"; gimp_install_procedure (PLUG_IN_PROC[0], hurl_blurb, hurl_help, author, copyrights, copyright_date, N_("_Hurl..."), "RGB*, GRAY*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL); gimp_install_procedure (PLUG_IN_PROC[1], pick_blurb, pick_help, author, copyrights, copyright_date, N_("_Pick..."), "RGB*, GRAY*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL); gimp_install_procedure (PLUG_IN_PROC[2], slur_blurb, slur_help, author, copyrights, copyright_date, N_("_Slur..."), "RGB*, GRAY*, INDEXED*", GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL); gimp_plugin_menu_register (PLUG_IN_PROC[0], "<Image>/Filters/Noise"); gimp_plugin_menu_register (PLUG_IN_PROC[1], "<Image>/Filters/Noise"); gimp_plugin_menu_register (PLUG_IN_PROC[2], "<Image>/Filters/Noise"); }
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 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) { static GimpParamDef args[] = { { GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_STRING, "decompose-type", NULL }, { GIMP_PDB_INT32, "layers-mode", "Create channels as layers in a single image" } }; static const GimpParamDef return_vals[] = { { GIMP_PDB_IMAGE, "new-image", "Output gray image" }, { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" }, { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" }, { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" } }; GString *type_desc; int i; type_desc = g_string_new ("What to decompose: "); g_string_append_c (type_desc, '"'); g_string_append (type_desc, extract[0].type); g_string_append_c (type_desc, '"'); for (i = 1; i < G_N_ELEMENTS (extract); i++) { g_string_append (type_desc, ", "); g_string_append_c (type_desc, '"'); g_string_append (type_desc, extract[i].type); g_string_append_c (type_desc, '"'); } args[3].description = type_desc->str; gimp_install_procedure (PLUG_IN_PROC, N_("Decompose an image into separate colorspace components"), "This function creates new gray images with " "different channel information in each of them", "Peter Kirchgessner", "Peter Kirchgessner", "1997", N_("_Decompose..."), "RGB*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals), args, return_vals); gimp_install_procedure (PLUG_IN_PROC_REG, N_("Decompose an image into separate colorspace components"), "This function creates new gray images with " "different channel information in each of them. " "Pixels in the foreground color will appear black " "in all output images. This can be used for " "things like crop marks that have to show up on " "all channels.", "Peter Kirchgessner", "Peter Kirchgessner, Clarence Risher", "1997", N_("_Decompose..."), "RGB*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals), args, return_vals); gimp_plugin_menu_register (PLUG_IN_PROC_REG, "<Image>/Colors/Components"); g_string_free (type_desc, TRUE); }
static void query (void) { static const GimpParamDef args[] = { { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_INT32, "maptype", "Type of mapping (0=plane,1=sphere,2=box,3=cylinder)" }, { GIMP_PDB_FLOAT, "viewpoint-x", "Position of viewpoint (x,y,z)" }, { GIMP_PDB_FLOAT, "viewpoint-y", "Position of viewpoint (x,y,z)" }, { GIMP_PDB_FLOAT, "viewpoint-z", "Position of viewpoint (x,y,z)" }, { GIMP_PDB_FLOAT, "position-x", "Object position (x,y,z)" }, { GIMP_PDB_FLOAT, "position-y", "Object position (x,y,z)" }, { GIMP_PDB_FLOAT, "position-z", "Object position (x,y,z)" }, { GIMP_PDB_FLOAT, "firstaxis-x", "First axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "firstaxis-y", "First axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "firstaxis-z", "First axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "secondaxis-x", "Second axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "secondaxis-y", "Second axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "secondaxis-z", "Second axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "rotationangle-x", "Rotation about X axis in degrees" }, { GIMP_PDB_FLOAT, "rotationangle-y", "Rotation about Y axis in degrees" }, { GIMP_PDB_FLOAT, "rotationangle-z", "Rotation about Z axis in degrees" }, { GIMP_PDB_INT32, "lighttype", "Type of lightsource (0=point,1=directional,2=none)" }, { GIMP_PDB_COLOR, "lightcolor", "Lightsource color (r,g,b)" }, { GIMP_PDB_FLOAT, "lightposition-x", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition-y", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition-z", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightdirection-x", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection-y", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection-z", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "ambient_intensity", "Material ambient intensity (0..1)" }, { GIMP_PDB_FLOAT, "diffuse_intensity", "Material diffuse intensity (0..1)" }, { GIMP_PDB_FLOAT, "diffuse_reflectivity", "Material diffuse reflectivity (0..1)" }, { GIMP_PDB_FLOAT, "specular_reflectivity", "Material specular reflectivity (0..1)" }, { GIMP_PDB_FLOAT, "highlight", "Material highlight (0..->), note: it's expotential" }, { GIMP_PDB_INT32, "antialiasing", "Apply antialiasing (TRUE/FALSE)" }, { GIMP_PDB_INT32, "tiled", "Tile source image (TRUE/FALSE)" }, { GIMP_PDB_INT32, "newimage", "Create a new image (TRUE/FALSE)" }, { GIMP_PDB_INT32, "transparentbackground", "Make background transparent (TRUE/FALSE)" }, { GIMP_PDB_FLOAT, "radius", "Sphere/cylinder radius (only used when maptype=1 or 3)" }, { GIMP_PDB_FLOAT, "x-scale", "Box x size (0..->)" }, { GIMP_PDB_FLOAT, "y-scale", "Box y size (0..->)" }, { GIMP_PDB_FLOAT, "z-scale", "Box z size (0..->)"}, { GIMP_PDB_FLOAT, "cylinder-length", "Cylinder length (0..->)"}, { GIMP_PDB_DRAWABLE, "box-front-drawable", "Box front face (set these to -1 if not used)" }, { GIMP_PDB_DRAWABLE, "box-back-drawable", "Box back face" }, { GIMP_PDB_DRAWABLE, "box-top-drawable", "Box top face" }, { GIMP_PDB_DRAWABLE, "box-bottom-drawable", "Box bottom face" }, { GIMP_PDB_DRAWABLE, "box-left-drawable", "Box left face" }, { GIMP_PDB_DRAWABLE, "box-right-drawable", "Box right face" }, { GIMP_PDB_DRAWABLE, "cyl-top-drawable", "Cylinder top face (set these to -1 if not used)" }, { GIMP_PDB_DRAWABLE, "cyl-bottom-drawable", "Cylinder bottom face" } }; gimp_install_procedure (PLUG_IN_PROC, N_("Map the image to an object (plane, sphere, box or cylinder)"), "No help yet", "Tom Bech & Federico Mena Quintero", "Tom Bech & Federico Mena Quintero", "Version 1.2.0, July 16 1998", N_("Map _Object..."), "RGB*", GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL); gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Map"); }