void
register_image_guides_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-add-hguide
*/
procedure = gimp_procedure_new (image_add_hguide_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-add-hguide");
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-hguide",
"Add a horizontal guide to an image.",
"This procedure adds a horizontal guide to an image. It takes the input image and the y-position of the new guide as parameters. It returns the guide ID of the new guide.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
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 ("yposition",
"yposition",
"The guide's y-offset from top of image",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_uint ("guide",
"guide",
"The new guide",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-add-vguide
*/
procedure = gimp_procedure_new (image_add_vguide_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-add-vguide");
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-vguide",
"Add a vertical guide to an image.",
"This procedure adds a vertical guide to an image. It takes the input image and the x-position of the new guide as parameters. It returns the guide ID of the new guide.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
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 ("xposition",
"xposition",
"The guide's x-offset from left of image",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_uint ("guide",
"guide",
"The new guide",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-delete-guide
*/
procedure = gimp_procedure_new (image_delete_guide_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-delete-guide");
gimp_procedure_set_static_strings (procedure,
"gimp-image-delete-guide",
"Deletes a guide from an image.",
"This procedure takes an image and a guide ID as input and removes the specified guide from the specified image.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
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_uint ("guide",
"guide",
"The ID of the guide to be removed",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-find-next-guide
*/
procedure = gimp_procedure_new (image_find_next_guide_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-find-next-guide");
gimp_procedure_set_static_strings (procedure,
"gimp-image-find-next-guide",
"Find next guide on an image.",
"This procedure takes an image and a guide ID as input and finds the guide ID of the successor of the given guide ID in the image's guide list. If the supplied guide ID is 0, the procedure will return the first Guide. The procedure will return 0 if given the final guide ID as an argument or the image has no guides.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
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_uint ("guide",
"guide",
"The ID of the current guide (0 if first invocation)",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_return_value (procedure,
g_param_spec_uint ("next-guide",
"next guide",
"The next guide's ID",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-get-guide-orientation
*/
procedure = gimp_procedure_new (image_get_guide_orientation_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-get-guide-orientation");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-guide-orientation",
"Get orientation of a guide on an image.",
"This procedure takes an image and a guide ID as input and returns the orientations of the guide.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
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_uint ("guide",
"guide",
"The guide",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_enum ("orientation",
"orientation",
"The guide's orientation",
GIMP_TYPE_ORIENTATION_TYPE,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->values[0]),
GIMP_ORIENTATION_UNKNOWN);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-get-guide-position
*/
procedure = gimp_procedure_new (image_get_guide_position_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-get-guide-position");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-guide-position",
"Get position of a guide on an image.",
"This procedure takes an image and a guide ID as input and returns the position of the guide relative to the top or left of the image.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
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_uint ("guide",
"guide",
"The guide",
1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("position",
"position",
"The guide's position relative to top or left of image",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_procedural_db_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-procedural-db-temp-name
*/
procedure = gimp_procedure_new (procedural_db_temp_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-temp-name");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-temp-name",
"Generates a unique temporary PDB name.",
"This procedure generates a temporary PDB entry name that is guaranteed to be unique.",
"Andy Thomas",
"Andy Thomas",
"1998",
NULL);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("temp-name",
"temp name",
"A unique temporary name for a temporary PDB entry",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-dump
*/
procedure = gimp_procedure_new (procedural_db_dump_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-dump");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-dump",
"Dumps the current contents of the procedural database",
"This procedure dumps the contents of the procedural database to the specified file. The file will contain all of the information provided for each registered procedure.",
"Spencer Kimball & Josh MacDonald",
"Spencer Kimball & Josh MacDonald & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"filename",
"The dump filename",
TRUE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-query
*/
procedure = gimp_procedure_new (procedural_db_query_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-query");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-query",
"Queries the procedural database for its contents using regular expression matching.",
"This procedure queries the contents of the procedural database. It is supplied with seven arguments matching procedures on { name, blurb, help, author, copyright, date, procedure type}. This is accomplished using regular expression matching. For instance, to find all procedures with \"jpeg\" listed in the blurb, all seven arguments can be supplied as \".*\", except for the second, which can be supplied as \".*jpeg.*\". There are two return arguments for this procedure. The first is the number of procedures matching the query. The second is a concatenated list of procedure names corresponding to those matching the query. If no matching entries are found, then the returned string is NULL and the number of entries is 0.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The regex for procedure name",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("blurb",
"blurb",
"The regex for procedure blurb",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("help",
"help",
"The regex for procedure help",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("author",
"author",
"The regex for procedure author",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("copyright",
"copyright",
"The regex for procedure copyright",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("date",
"date",
"The regex for procedure date",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("proc-type",
"proc type",
"The regex for procedure type: { 'Internal GIMP procedure', 'GIMP Plug-In', 'GIMP Extension', 'Temporary Procedure' }",
TRUE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-matches",
"num matches",
"The number of matching procedures",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("procedure-names",
"procedure names",
"The list of procedure names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-proc-exists
*/
procedure = gimp_procedure_new (procedural_db_proc_exists_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-proc-exists");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-exists",
"Checks if the specified procedure exists in the procedural database",
"This procedure checks if the specified procedure is registered in the procedural database.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2008",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The procedure name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("exists",
"exists",
"Whether a procedure of that name is registered",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-proc-info
*/
procedure = gimp_procedure_new (procedural_db_proc_info_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-proc-info");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-info",
"Queries the procedural database for information on the specified procedure.",
"This procedure returns information on the specified procedure. A short blurb, detailed help, author(s), copyright information, procedure type, number of input, and number of return values are returned. For specific information on each input argument and return value, use the 'gimp-procedural-db-proc-arg' and 'gimp-procedural-db-proc-val' procedures.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The procedure name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("blurb",
"blurb",
"A short blurb",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("help",
"help",
"Detailed procedure help",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("author",
"author",
"Author(s) of the procedure",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("copyright",
"copyright",
"The copyright",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("date",
"date",
"Copyright date",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("proc-type",
"proc type",
"The procedure type",
GIMP_TYPE_PDB_PROC_TYPE,
GIMP_INTERNAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-args",
"num args",
"The number of input arguments",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-values",
"num values",
"The number of return values",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-proc-arg
*/
procedure = gimp_procedure_new (procedural_db_proc_arg_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-proc-arg");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-arg",
"Queries the procedural database for information on the specified procedure's argument.",
"This procedure returns information on the specified procedure's argument. The argument type, name, and a description are retrieved.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The procedure name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("arg-num",
"arg num",
"The argument number",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_enum ("arg-type",
"arg type",
"The type of argument",
GIMP_TYPE_PDB_ARG_TYPE,
GIMP_PDB_INT32,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->values[0]),
GIMP_PDB_END);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("arg-name",
"arg name",
"The name of the argument",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("arg-desc",
"arg desc",
"A description of the argument",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-proc-val
*/
procedure = gimp_procedure_new (procedural_db_proc_val_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-proc-val");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-val",
"Queries the procedural database for information on the specified procedure's return value.",
"This procedure returns information on the specified procedure's return value. The return value type, name, and a description are retrieved.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The procedure name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("val-num",
"val num",
"The return value number",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_enum ("val-type",
"val type",
"The type of return value",
GIMP_TYPE_PDB_ARG_TYPE,
GIMP_PDB_INT32,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->values[0]),
GIMP_PDB_END);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("val-name",
"val name",
"The name of the return value",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("val-desc",
"val desc",
"A description of the return value",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-get-data
*/
procedure = gimp_procedure_new (procedural_db_get_data_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-get-data");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-get-data",
"Returns data associated with the specified identifier.",
"This procedure returns any data which may have been associated with the specified identifier. The data is a variable length array of bytes. If no data has been associated with the identifier, an error is returned.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("identifier",
"identifier",
"The identifier associated with data",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bytes",
"bytes",
"The number of bytes in the data",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("data",
"data",
"A byte array containing data",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-get-data-size
*/
procedure = gimp_procedure_new (procedural_db_get_data_size_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-get-data-size");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-get-data-size",
"Returns size of data associated with the specified identifier.",
"This procedure returns the size of any data which may have been associated with the specified identifier. If no data has been associated with the identifier, an error is returned.",
"Nick Lamb",
"Nick Lamb",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("identifier",
"identifier",
"The identifier associated with data",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bytes",
"bytes",
"The number of bytes in the data",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-procedural-db-set-data
*/
procedure = gimp_procedure_new (procedural_db_set_data_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-procedural-db-set-data");
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-set-data",
"Associates the specified identifier with the supplied data.",
"This procedure associates the supplied data with the provided identifier. The data may be subsequently retrieved by a call to 'procedural-db-get-data'.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("identifier",
"identifier",
"The identifier associated with data",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("bytes",
"bytes",
"The number of bytes in the data",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("data",
"data",
"A byte array containing data",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_image_transform_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-resize
*/
procedure = gimp_procedure_new (image_resize_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-resize");
gimp_procedure_set_static_strings (procedure,
"gimp-image-resize",
"Resize the image to the specified extents.",
"This procedure resizes the image so that it's new width and height are equal to the supplied parameters. Offsets are also provided which describe the position of the previous image's content. All channels within the image are resized according to the specified parameters; this includes the image selection mask. All layers within the image are repositioned according to the specified offsets.",
"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 ("new-width",
"new width",
"New image width",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height",
"new height",
"New image height",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx",
"offx",
"x offset between upper left corner of old and new images: (new - old)",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy",
"offy",
"y offset between upper left corner of old and new images: (new - old)",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-resize-to-layers
*/
procedure = gimp_procedure_new (image_resize_to_layers_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-resize-to-layers");
gimp_procedure_set_static_strings (procedure,
"gimp-image-resize-to-layers",
"Resize the image to fit all layers.",
"This procedure resizes the image to the bounding box of all layers of the image. All channels within the image are resized to the new size; this includes the image selection mask. All layers within the image are repositioned to the new image area.",
"Simon Budig",
"Simon Budig",
"2004",
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-image-scale
*/
procedure = gimp_procedure_new (image_scale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-scale");
gimp_procedure_set_static_strings (procedure,
"gimp-image-scale",
"Scale the image using the default interpolation method.",
"This procedure scales the image so that its new width and height are equal to the supplied parameters. All layers and channels within the image are scaled according to the specified parameters; this includes the image selection mask. The interpolation method used can be set with 'gimp-context-set-interpolation'.",
"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 ("new-width",
"new width",
"New image width",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height",
"new height",
"New image height",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-scale-full
*/
procedure = gimp_procedure_new (image_scale_full_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-scale-full");
gimp_procedure_set_static_strings (procedure,
"gimp-image-scale-full",
"Deprecated: Use 'gimp-image-scale' instead.",
"Deprecated: Use 'gimp-image-scale' instead.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2008",
"gimp-image-scale");
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 ("new-width",
"new width",
"New image width",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height",
"new height",
"New image height",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("interpolation",
"interpolation",
"Type of interpolation",
GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_NONE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-crop
*/
procedure = gimp_procedure_new (image_crop_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-crop");
gimp_procedure_set_static_strings (procedure,
"gimp-image-crop",
"Crop the image to the specified extents.",
"This procedure crops the image so that it's new width and height are equal to the supplied parameters. Offsets are also provided which describe the position of the previous image's content. All channels and layers within the image are cropped to the new image extents; this includes the image selection mask. If any parameters are out of range, an error 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 ("new-width",
"new width",
"New image width: (0 < new_width <= width)",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height",
"new height",
"New image height: (0 < new_height <= height)",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx",
"offx",
"X offset: (0 <= offx <= (width - new_width))",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy",
"offy",
"Y offset: (0 <= offy <= (height - new_height))",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-flip
*/
procedure = gimp_procedure_new (image_flip_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-flip");
gimp_procedure_set_static_strings (procedure,
"gimp-image-flip",
"Flips the image horizontally or vertically.",
"This procedure flips (mirrors) the image.",
"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_enum ("flip-type",
"flip type",
"Type of flip",
GIMP_TYPE_ORIENTATION_TYPE,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->args[1]),
GIMP_ORIENTATION_UNKNOWN);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-rotate
*/
procedure = gimp_procedure_new (image_rotate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-rotate");
gimp_procedure_set_static_strings (procedure,
"gimp-image-rotate",
"Rotates the image by the specified degrees.",
"This procedure rotates the image.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2003",
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_enum ("rotate-type",
"rotate type",
"Angle of rotation",
GIMP_TYPE_ROTATION_TYPE,
GIMP_ROTATE_90,
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_transform_tools_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-flip
*/
procedure = gimp_procedure_new (flip_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-flip");
gimp_procedure_set_static_strings (procedure,
"gimp-flip",
"Deprecated: Use 'gimp-item-transform-flip-simple' instead.",
"Deprecated: Use 'gimp-item-transform-flip-simple' instead.",
"",
"",
"",
"gimp-item-transform-flip-simple");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_enum ("flip-type",
"flip type",
"Type of flip",
GIMP_TYPE_ORIENTATION_TYPE,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->args[1]),
GIMP_ORIENTATION_UNKNOWN);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The flipped drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-perspective
*/
procedure = gimp_procedure_new (perspective_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-perspective");
gimp_procedure_set_static_strings (procedure,
"gimp-perspective",
"Deprecated: Use 'gimp-item-transform-perspective' instead.",
"Deprecated: Use 'gimp-item-transform-perspective' instead.",
"",
"",
"",
"gimp-item-transform-perspective");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("interpolation",
"interpolation",
"Whether to use interpolation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x0",
"x0",
"The new x coordinate of upper-left corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y0",
"y0",
"The new y coordinate of upper-left corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x1",
"x1",
"The new x coordinate of upper-right corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y1",
"y1",
"The new y coordinate of upper-right corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x2",
"x2",
"The new x coordinate of lower-left corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y2",
"y2",
"The new y coordinate of lower-left corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x3",
"x3",
"The new x coordinate of lower-right corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y3",
"y3",
"The new y coordinate of lower-right corner of original bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The newly mapped drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-rotate
*/
procedure = gimp_procedure_new (rotate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-rotate");
gimp_procedure_set_static_strings (procedure,
"gimp-rotate",
"Deprecated: Use 'gimp-item-transform-rotate' instead.",
"Deprecated: Use 'gimp-item-transform-rotate' instead.",
"",
"",
"",
"gimp-item-transform-rotate");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("interpolation",
"interpolation",
"Whether to use interpolation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("angle",
"angle",
"The angle of rotation (radians)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The rotated drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-scale
*/
procedure = gimp_procedure_new (scale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-scale");
gimp_procedure_set_static_strings (procedure,
"gimp-scale",
"Deprecated: Use 'gimp-item-transform-scale' instead.",
"Deprecated: Use 'gimp-item-transform-scale' instead.",
"",
"",
"",
"gimp-item-transform-scale");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("interpolation",
"interpolation",
"Whether to use interpolation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x0",
"x0",
"The new x coordinate of the upper-left corner of the scaled region",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y0",
"y0",
"The new y coordinate of the upper-left corner of the scaled region",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x1",
"x1",
"The new x coordinate of the lower-right corner of the scaled region",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y1",
"y1",
"The new y coordinate of the lower-right corner of the scaled region",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The scaled drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-shear
*/
procedure = gimp_procedure_new (shear_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-shear");
gimp_procedure_set_static_strings (procedure,
"gimp-shear",
"Deprecated: Use 'gimp-item-transform-shear' instead.",
"Deprecated: Use 'gimp-item-transform-shear' instead.",
"",
"",
"",
"gimp-item-transform-shear");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("interpolation",
"interpolation",
"Whether to use interpolation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_enum ("shear-type",
"shear type",
"Type of shear",
GIMP_TYPE_ORIENTATION_TYPE,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_READWRITE));
gimp_param_spec_enum_exclude_value (GIMP_PARAM_SPEC_ENUM (procedure->args[2]),
GIMP_ORIENTATION_UNKNOWN);
gimp_procedure_add_argument (procedure,
g_param_spec_double ("magnitude",
"magnitude",
"The magnitude of the shear",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The sheared drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-transform-2d
*/
procedure = gimp_procedure_new (transform_2d_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-transform-2d");
gimp_procedure_set_static_strings (procedure,
"gimp-transform-2d",
"Deprecated: Use 'gimp-item-transform-2d' instead.",
"Deprecated: Use 'gimp-item-transform-2d' instead.",
"",
"",
"",
"gimp-item-transform-2d");
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The affected drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("interpolation",
"interpolation",
"Whether to use interpolation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("source-x",
"source x",
"X coordinate of the transformation center",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("source-y",
"source y",
"Y coordinate of the transformation center",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("scale-x",
"scale x",
"Amount to scale in x direction",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("scale-y",
"scale y",
"Amount to scale in y direction",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("angle",
"angle",
"The angle of rotation (radians)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("dest-x",
"dest x",
"X coordinate of where the centre goes",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("dest-y",
"dest y",
"Y coordinate of where the centre goes",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The transformed drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}