void
register_floating_sel_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-floating-sel-remove
*/
procedure = gimp_procedure_new (floating_sel_remove_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-remove");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-remove",
"Remove the specified floating selection from its associated drawable.",
"This procedure removes the floating selection completely, without any side effects. The associated drawable is then set to active.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-anchor
*/
procedure = gimp_procedure_new (floating_sel_anchor_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-anchor");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-anchor",
"Anchor the specified floating selection to its associated drawable.",
"This procedure anchors the floating selection to its associated drawable. This is similar to merging with a merge type of ClipToBottomLayer. The floating selection layer is no longer valid after this operation.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-to-layer
*/
procedure = gimp_procedure_new (floating_sel_to_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-to-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-to-layer",
"Transforms the specified floating selection into a layer.",
"This procedure transforms the specified floating selection into a layer with the same offsets and extents. The composited image will look precisely the same, but the floating selection layer will no longer be clipped to the extents of the drawable it was attached to. The floating selection will become the active layer. This procedure will not work if the floating selection has a different base type from the underlying image. This might be the case if the floating selection is above an auxillary channel or a layer mask.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-attach
*/
procedure = gimp_procedure_new (floating_sel_attach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-attach");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-attach",
"Attach the specified layer as floating to the specified drawable.",
"This procedure attaches the layer as floating selection to the drawable.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("layer",
"layer",
"The layer (is attached as floating selection)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable (where to attach the floating selection)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-rigor
*/
procedure = gimp_procedure_new (floating_sel_rigor_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-rigor");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-rigor",
"Deprecated: There is no replacement for this procedure.",
"Deprecated: There is no replacement for this procedure.",
"",
"",
"",
"NONE");
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("undo",
"undo",
"",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-floating-sel-relax
*/
procedure = gimp_procedure_new (floating_sel_relax_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-floating-sel-relax");
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-relax",
"Deprecated: There is no replacement for this procedure.",
"Deprecated: There is no replacement for this procedure.",
"",
"",
"",
"NONE");
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("undo",
"undo",
"",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_edit_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-edit-cut
*/
procedure = gimp_procedure_new (edit_cut_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-cut");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-cut",
"Cut from the specified drawable.",
"If there is a selection in the image, then the area specified by the selection is cut from the specified drawable and placed in an internal GIMP edit buffer. It can subsequently be retrieved using the 'gimp-edit-paste' command. If there is no selection, then the specified drawable will be removed and its contents stored in the internal GIMP edit buffer. This procedure will fail if the selected area lies completely outside the bounds of the current drawable and there is nothing to copy from.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable to cut from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("non-empty",
"non empty",
"TRUE if the cut was successful, FALSE if there was nothing to copy from",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-copy
*/
procedure = gimp_procedure_new (edit_copy_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-copy");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-copy",
"Copy from the specified drawable.",
"If there is a selection in the image, then the area specified by the selection is copied from the specified drawable and placed in an internal GIMP edit buffer. It can subsequently be retrieved using the 'gimp-edit-paste' command. If there is no selection, then the specified drawable's contents will be stored in the internal GIMP edit buffer. This procedure will fail if the selected area lies completely outside the bounds of the current drawable and there is nothing to copy from.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable to copy from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("non-empty",
"non empty",
"TRUE if the cut was successful, FALSE if there was nothing to copy from",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-copy-visible
*/
procedure = gimp_procedure_new (edit_copy_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-copy-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-copy-visible",
"Copy from the projection.",
"If there is a selection in the image, then the area specified by the selection is copied from the projection and placed in an internal GIMP edit buffer. It can subsequently be retrieved using the 'gimp-edit-paste' command. If there is no selection, then the projection's contents will be stored in the internal GIMP edit buffer.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image to copy from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("non-empty",
"non empty",
"TRUE if the copy was successful",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-paste
*/
procedure = gimp_procedure_new (edit_paste_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-paste");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-paste",
"Paste buffer to the specified drawable.",
"This procedure pastes a copy of the internal GIMP edit buffer to the specified drawable. The GIMP edit buffer will be empty unless a call was previously made to either 'gimp-edit-cut' or 'gimp-edit-copy'. The \"paste_into\" option specifies whether to clear the current image selection, or to paste the buffer \"behind\" the selection. This allows the selection to act as a mask for the pasted buffer. Anywhere that the selection mask is non-zero, the pasted buffer will show through. The pasted buffer will be a new layer in the image which is designated as the image floating selection. If the image has a floating selection at the time of pasting, the old floating selection will be anchored to its drawable before the new floating selection is added. This procedure returns the new floating layer. The resulting floating selection will already be attached to the specified drawable, and a subsequent call to floating_sel_attach is not needed.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable to paste to",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("paste-into",
"paste into",
"Clear selection, or paste behind it?",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The new floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-paste-as-new-image
*/
procedure = gimp_procedure_new (edit_paste_as_new_image_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-paste-as-new-image");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-paste-as-new-image",
"Paste buffer to a new image.",
"This procedure pastes a copy of the internal GIMP edit buffer to a new image. The GIMP edit buffer will be empty unless a call was previously made to either 'gimp-edit-cut' or 'gimp-edit-copy'. This procedure returns the new image or -1 if the edit buffer was empty.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("image",
"image",
"The new image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-named-cut
*/
procedure = gimp_procedure_new (edit_named_cut_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-named-cut");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-cut",
"Cut into a named buffer.",
"This procedure works like 'gimp-edit-cut', but additionally stores the cut buffer into a named buffer that will stay available for later pasting, regardless of any intermediate copy or cut operations.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable to cut from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The name of the buffer to create",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("real-name",
"real name",
"The real name given to the buffer, or NULL if the cut failed",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-named-copy
*/
procedure = gimp_procedure_new (edit_named_copy_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-named-copy");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-copy",
"Copy into a named buffer.",
"This procedure works like 'gimp-edit-copy', but additionally stores the copied buffer into a named buffer that will stay available for later pasting, regardless of any intermediate copy or cut operations.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable to copy from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The name of the buffer to create",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("real-name",
"real name",
"The real name given to the buffer, or NULL if the copy failed",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-named-copy-visible
*/
procedure = gimp_procedure_new (edit_named_copy_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-named-copy-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-copy-visible",
"Copy from the projection into a named buffer.",
"This procedure works like 'gimp-edit-copy-visible', but additionally stores the copied buffer into a named buffer that will stay available for later pasting, regardless of any intermediate copy or cut operations.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image to copy from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The name of the buffer to create",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("real-name",
"real name",
"The real name given to the buffer, or NULL if the copy failed",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-named-paste
*/
procedure = gimp_procedure_new (edit_named_paste_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-named-paste");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-paste",
"Paste named buffer to the specified drawable.",
"This procedure works like 'gimp-edit-paste' but pastes a named buffer instead of the global buffer.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable to paste to",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The name of the buffer to paste",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("paste-into",
"paste into",
"Clear selection, or paste behind it?",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("floating-sel",
"floating sel",
"The new floating selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-edit-named-paste-as-new-image
*/
procedure = gimp_procedure_new (edit_named_paste_as_new_image_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-edit-named-paste-as-new-image");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-paste-as-new-image",
"Paste named buffer to a new image.",
"This procedure works like 'gimp-edit-paste-as-new-image' but pastes a named buffer instead of the global buffer.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The name of the buffer to paste",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("image",
"image",
"The new image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_fileops_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-file-load
*/
procedure = gimp_procedure_new (file_load_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-file-load");
gimp_procedure_set_static_strings (procedure,
"gimp-file-load",
"Loads an image file by invoking the right load handler.",
"This procedure invokes the correct file load handler using magic if possible, and falling back on the file's extension and/or prefix if not. The name of the file to load is typically a full pathname, and the name entered is what the user actually typed before prepending a directory path. The reason for this is that if the user types http://www.xcf/~gimp/ he wants to fetch a URL, and the full pathname will not look like a URL.\"",
"Josh MacDonald",
"Josh MacDonald",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_enum ("run-mode",
"run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->args[0]),
GIMP_RUN_WITH_LAST_VALS);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The name of the file to load",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("raw-filename",
"raw filename",
"The name as entered by the user",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("image",
"image",
"The output image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-file-load-layer
*/
procedure = gimp_procedure_new (file_load_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-file-load-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-file-load-layer",
"Loads an image file as a layer for an existing image.",
"This procedure behaves like the file-load procedure but opens the specified image as a layer for an existing image. The returned layer needs to be added to the existing image with 'gimp-image-insert-layer'.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_enum ("run-mode",
"run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->args[0]),
GIMP_RUN_WITH_LAST_VALS);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"Destination image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The name of the file to load",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("layer",
"layer",
"The layer created when loading the image file",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-file-load-layers
*/
procedure = gimp_procedure_new (file_load_layers_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-file-load-layers");
gimp_procedure_set_static_strings (procedure,
"gimp-file-load-layers",
"Loads an image file as layers for an existing image.",
"This procedure behaves like the file-load procedure but opens the specified image as layers for an existing image. The returned layers needs to be added to the existing image with 'gimp-image-insert-layer'.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_enum ("run-mode",
"run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->args[0]),
GIMP_RUN_WITH_LAST_VALS);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"Destination image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The name of the file to load",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-layers",
"num layers",
"The number of loaded layers",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("layer-ids",
"layer ids",
"The list of loaded layers",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-file-save
*/
procedure = gimp_procedure_new (file_save_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-file-save");
gimp_procedure_set_static_strings (procedure,
"gimp-file-save",
"Saves a file by extension.",
"This procedure invokes the correct file save handler according to the file's extension and/or prefix. The name of the file to save is typically a full pathname, and the name entered is what the user actually typed before prepending a directory path. The reason for this is that if the user types http://www.xcf/~gimp/ she wants to fetch a URL, and the full pathname will not look like a URL.",
"Josh MacDonald",
"Josh MacDonald",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("run-mode",
"run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"Input image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"Drawable to save",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The name of the file to save the image in",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("raw-filename",
"raw filename",
"The name as entered by the user",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-file-load-thumbnail
*/
procedure = gimp_procedure_new (file_load_thumbnail_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-file-load-thumbnail");
gimp_procedure_set_static_strings (procedure,
"gimp-file-load-thumbnail",
"Loads the thumbnail for a file.",
"This procedure tries to load a thumbnail that belongs to the file with the given filename. This name is a full pathname. The returned data is an array of colordepth 3 (RGB), regardless of the image type. Width and height of the thumbnail are also returned. Don't use this function if you need a thumbnail of an already opened image, use 'gimp-image-thumbnail' instead.",
"Adam D. Moss, Sven Neumann",
"Adam D. Moss, Sven Neumann",
"1999-2003",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The name of the file that owns the thumbnail to load",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The width of the thumbnail",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The height of the thumbnail",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("thumb-data-count",
"thumb data count",
"The number of bytes in thumbnail data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("thumb-data",
"thumb data",
"The thumbnail data",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-file-save-thumbnail
*/
procedure = gimp_procedure_new (file_save_thumbnail_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-file-save-thumbnail");
gimp_procedure_set_static_strings (procedure,
"gimp-file-save-thumbnail",
"Saves a thumbnail for the given image",
"This procedure saves a thumbnail for the given image according to the Free Desktop Thumbnail Managing Standard. The thumbnail is saved so that it belongs to the file with the given filename. This means you have to save the image under this name first, otherwise this procedure will fail. This procedure may become useful if you want to explicitly save a thumbnail with a file.",
"Josh MacDonald",
"Josh MacDonald",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The name of the file the thumbnail belongs to",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-temp-name
*/
procedure = gimp_procedure_new (temp_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-temp-name");
gimp_procedure_set_static_strings (procedure,
"gimp-temp-name",
"Generates a unique filename.",
"Generates a unique filename using the temp path supplied in the user's gimprc.",
"Josh MacDonald",
"Josh MacDonald",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("extension",
"extension",
"The extension the file will have",
TRUE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("name",
"name",
"The new temp filename",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-register-magic-load-handler
*/
procedure = gimp_procedure_new (register_magic_load_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-register-magic-load-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-register-magic-load-handler",
"Registers a file load handler procedure.",
"Registers a procedural database procedure to be called to load files of a particular file format using magic file information.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The name of the procedure to be used for loading",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("extensions",
"extensions",
"comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("prefixes",
"prefixes",
"comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("magics",
"magics",
"comma separated list of magic file information this handler can load (i.e. \"0,string,GIF\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-register-load-handler
*/
procedure = gimp_procedure_new (register_load_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-register-load-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-register-load-handler",
"Registers a file load handler procedure.",
"Registers a procedural database procedure to be called to load files of a particular file format.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The name of the procedure to be used for loading",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("extensions",
"extensions",
"comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("prefixes",
"prefixes",
"comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-register-save-handler
*/
procedure = gimp_procedure_new (register_save_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-register-save-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-register-save-handler",
"Registers a file save handler procedure.",
"Registers a procedural database procedure to be called to save files in a particular file format.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The name of the procedure to be used for saving",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("extensions",
"extensions",
"comma separated list of extensions this handler can save (i.e. \"jpg,jpeg\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("prefixes",
"prefixes",
"comma separated list of prefixes this handler can save (i.e. \"http:,ftp:\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-register-file-handler-mime
*/
procedure = gimp_procedure_new (register_file_handler_mime_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-register-file-handler-mime");
gimp_procedure_set_static_strings (procedure,
"gimp-register-file-handler-mime",
"Associates a MIME type with a file handler procedure.",
"Registers a MIME type for a file handler procedure. This allows GIMP to determine the MIME type of the file opened or saved using this procedure.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The name of the procedure to associate a MIME type with.",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("mime-type",
"mime type",
"A single MIME type, like for example \"image/jpeg\".",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-register-thumbnail-loader
*/
procedure = gimp_procedure_new (register_thumbnail_loader_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-register-thumbnail-loader");
gimp_procedure_set_static_strings (procedure,
"gimp-register-thumbnail-loader",
"Associates a thumbnail loader with a file load procedure.",
"Some file formats allow for embedded thumbnails, other file formats contain a scalable image or provide the image data in different resolutions. A file plug-in for such a format may register a special procedure that allows GIMP to load a thumbnail preview of the image. This procedure is then associated with the standard load procedure using this function.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("load-proc",
"load proc",
"The name of the procedure the thumbnail loader with.",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("thumb-proc",
"thumb proc",
"The name of the thumbnail load procedure.",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_text_tool_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-text-fontname
*/
procedure = gimp_procedure_new (text_fontname_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-text-fontname");
gimp_procedure_set_static_strings (procedure,
"gimp-text-fontname",
"Add text at the specified location as a floating selection or a new layer.",
"This tool requires a fontname matching an installed PangoFT2 font. You can specify the fontsize in units of pixels or points, and the appropriate metric is specified using the size_type argument. The x and y parameters together control the placement of the new text by specifying the upper left corner of the text bounding box. If the specified drawable parameter is valid, the text will be created as a floating selection attached to the drawable. If the drawable parameter is not valid (-1), the text will appear as a new layer. Finally, a border can be specified around the final rendered text. The border is measured in pixels. Parameter size-type is not used and is currently ignored. If you need to display a font in points, divide the size in points by 72.0 and multiply it by the image's vertical resolution.",
"Martin Edlman & Sven Neumann",
"Spencer Kimball & Peter Mattis",
"1998- 2001",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable: (-1 for a new text layer)",
pdb->gimp, TRUE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x",
"x",
"The x coordinate for the left of the text bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y",
"y",
"The y coordinate for the top of the text bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("text",
"text",
"The text to generate (in UTF-8 encoding)",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("border",
"border",
"The size of the border",
-1, G_MAXINT32, -1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("antialias",
"antialias",
"Antialiasing",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("size",
"size",
"The size of text in either pixels or points",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("size-type",
"size type",
"The units of specified size",
GIMP_TYPE_SIZE_TYPE,
GIMP_PIXELS,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("fontname",
"fontname",
"The name of the font",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("text-layer",
"text layer",
"The new text layer or -1 if no layer was created.",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-text-get-extents-fontname
*/
procedure = gimp_procedure_new (text_get_extents_fontname_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-text-get-extents-fontname");
gimp_procedure_set_static_strings (procedure,
"gimp-text-get-extents-fontname",
"Get extents of the bounding box for the specified text.",
"This tool returns the width and height of a bounding box for the specified text string with the specified font information. Ascent and descent for the specified font are returned as well. Parameter size-type is not used and is currently ignored. If you need to display a font in points, divide the size in points by 72.0 and multiply it by the vertical resolution of the image you are taking into account.",
"Martin Edlman & Sven Neumann",
"Spencer Kimball & Peter Mattis",
"1998- 2001",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("text",
"text",
"The text to generate (in UTF-8 encoding)",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("size",
"size",
"The size of text in either pixels or points",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("size-type",
"size type",
"The units of specified size",
GIMP_TYPE_SIZE_TYPE,
GIMP_PIXELS,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("fontname",
"fontname",
"The name of the font",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The width of the specified font",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The height of the specified font",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("ascent",
"ascent",
"The ascent of the specified font",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("descent",
"descent",
"The descent of the specified font",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_selection_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-selection-bounds
*/
procedure = gimp_procedure_new (selection_bounds_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-bounds");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-bounds",
"Find the bounding box of the current selection.",
"This procedure returns whether there is a selection for the specified image. If there is one, the upper left and lower right corners of the bounding box are returned. These coordinates are relative to the image. Please note that the pixel specified by the lower righthand coordinate of the bounding box is not part of the selection. The selection ends at the upper left corner of this pixel. This means the width of the selection can be calculated as (x2 - x1), its height as (y2 - y1).",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("non-empty",
"non empty",
"TRUE if there is a selection",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x1",
"x1",
"x coordinate of upper left corner of selection bounds",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y1",
"y1",
"y coordinate of upper left corner of selection bounds",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x2",
"x2",
"x coordinate of lower right corner of selection bounds",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y2",
"y2",
"y coordinate of lower right corner of selection bounds",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-value
*/
procedure = gimp_procedure_new (selection_value_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-value");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-value",
"Find the value of the selection at the specified coordinates.",
"This procedure returns the value of the selection at the specified coordinates. If the coordinates lie out of bounds, 0 is returned.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("x",
"x",
"x coordinate of value",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("y",
"y",
"y coordinate of value",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("value",
"value",
"Value of the selection",
0, 255, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-is-empty
*/
procedure = gimp_procedure_new (selection_is_empty_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-is-empty");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-is-empty",
"Determine whether the selection is empty.",
"This procedure returns TRUE if the selection for the specified image is empty.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("is-empty",
"is empty",
"Is the selection empty?",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-translate
*/
procedure = gimp_procedure_new (selection_translate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-translate");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-translate",
"Translate the selection by the specified offsets.",
"This procedure actually translates the selection for the specified image by the specified offsets. Regions that are translated from beyond the bounds of the image are set to empty. Valid regions of the selection which are translated beyond the bounds of the image because of this call are lost.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx",
"offx",
"x offset for translation",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy",
"offy",
"y offset for translation",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-float
*/
procedure = gimp_procedure_new (selection_float_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-float");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-float",
"Float the selection from the specified drawable with initial offsets as specified.",
"This procedure determines the region of the specified drawable that lies beneath the current selection. The region is then cut from the drawable and the resulting data is made into a new layer which is instantiated as a floating selection. The offsets allow initial positioning of the new floating selection.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable from which to float selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx",
"offx",
"x offset for translation",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy",
"offy",
"y offset for translation",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("layer",
"layer",
"The floated layer",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-invert
*/
procedure = gimp_procedure_new (selection_invert_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-invert");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-invert",
"Invert the selection mask.",
"This procedure inverts the selection mask. For every pixel in the selection channel, its new value is calculated as (255 - old-value).",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-sharpen
*/
procedure = gimp_procedure_new (selection_sharpen_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-sharpen");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-sharpen",
"Sharpen the selection mask.",
"This procedure sharpens the selection mask. For every pixel in the selection channel, if the value is > 127, the new pixel is assigned a value of 255. This removes any \"anti-aliasing\" that might exist in the selection mask's boundary.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-all
*/
procedure = gimp_procedure_new (selection_all_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-all");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-all",
"Select all of the image.",
"This procedure sets the selection mask to completely encompass the image. Every pixel in the selection channel is set to 255.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-none
*/
procedure = gimp_procedure_new (selection_none_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-none");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-none",
"Deselect the entire image.",
"This procedure deselects the entire image. Every pixel in the selection channel is set to 0.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-feather
*/
procedure = gimp_procedure_new (selection_feather_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-feather");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-feather",
"Feather the image's selection",
"This procedure feathers the selection. Feathering is implemented using a gaussian blur.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("radius",
"radius",
"Radius of feather (in pixels)",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-border
*/
procedure = gimp_procedure_new (selection_border_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-border");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-border",
"Border the image's selection",
"This procedure borders the selection. Bordering creates a new selection which is defined along the boundary of the previous selection at every point within the specified radius.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("radius",
"radius",
"Radius of border (in pixels)",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-grow
*/
procedure = gimp_procedure_new (selection_grow_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-grow");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-grow",
"Grow the image's selection",
"This procedure grows the selection. Growing involves expanding the boundary in all directions by the specified pixel amount.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("steps",
"steps",
"Steps of grow (in pixels)",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-shrink
*/
procedure = gimp_procedure_new (selection_shrink_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-shrink");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-shrink",
"Shrink the image's selection",
"This procedure shrinks the selection. Shrinking invovles trimming the existing selection boundary on all sides by the specified number of pixels.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("steps",
"steps",
"Steps of shrink (in pixels)",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-layer-alpha
*/
procedure = gimp_procedure_new (selection_layer_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-layer-alpha");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-layer-alpha",
"Deprecated: Use 'gimp-image-select-item' instead.",
"Deprecated: Use 'gimp-image-select-item' instead.",
"",
"",
"",
"gimp-image-select-item");
gimp_procedure_add_argument (procedure,
gimp_param_spec_layer_id ("layer",
"layer",
"Layer with alpha",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-load
*/
procedure = gimp_procedure_new (selection_load_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-load");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-load",
"Deprecated: Use 'gimp-image-select-item' instead.",
"Deprecated: Use 'gimp-image-select-item' instead.",
"",
"",
"",
"gimp-image-select-item");
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-save
*/
procedure = gimp_procedure_new (selection_save_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-save");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-save",
"Copy the selection mask to a new channel.",
"This procedure copies the selection mask and stores the content in a new channel. The new channel is automatically inserted into the image's list of channels.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The new channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-selection-combine
*/
procedure = gimp_procedure_new (selection_combine_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-selection-combine");
gimp_procedure_set_static_strings (procedure,
"gimp-selection-combine",
"Deprecated: Use 'gimp-image-select-item' instead.",
"Deprecated: Use 'gimp-image-select-item' instead.",
"",
"",
"",
"gimp-image-select-item");
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("operation",
"operation",
"The selection operation",
GIMP_TYPE_CHANNEL_OPS,
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}