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");
}
