void
register_fonts_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-fonts-refresh
*/
procedure = gimp_procedure_new (fonts_refresh_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-fonts-refresh");
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-refresh",
"Refresh current fonts. This function always succeeds.",
"This procedure retrieves all fonts currently in the user's font path and updates the font dialogs accordingly.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2003",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-fonts-get-list
*/
procedure = gimp_procedure_new (fonts_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-fonts-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-get-list",
"Retrieve the list of loaded fonts.",
"This procedure returns a list of the fonts that are currently available.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2003",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-fonts",
"num fonts",
"The number of available fonts",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("font-list",
"font list",
"The list of font names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_palettes_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-palettes-refresh
*/
procedure = gimp_procedure_new (palettes_refresh_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-refresh");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-refresh",
"Refreshes current palettes. This function always succeeds.",
"This procedure retrieves all palettes currently in the user's palette path and updates the palette dialogs accordingly.",
"Adrian Likins <*****@*****.**>",
"Adrian Likins",
"1998",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palettes-get-list
*/
procedure = gimp_procedure_new (palettes_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-list",
"Retrieves a list of all of the available palettes",
"This procedure returns a complete listing of available palettes. Each name returned can be used as input to the command 'gimp-context-set-palette'.",
"Nathan Summers <*****@*****.**>",
"Nathan Summers",
"2001",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-palettes",
"num palettes",
"The number of palettes in the list",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("palette-list",
"palette list",
"The list of palette names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
/**
* gimp_procedure_create_override:
* @procedure:
* @new_marshal_func:
*
* Creates a new GimpProcedure that can be used to override the
* existing @procedure.
*
* Returns: The new #GimpProcedure.
**/
GimpProcedure *
gimp_procedure_create_override (GimpProcedure *procedure,
GimpMarshalFunc new_marshal_func)
{
GimpProcedure *new_procedure = NULL;
const gchar *name = NULL;
int i = 0;
new_procedure = gimp_procedure_new (new_marshal_func);
name = gimp_object_get_name (procedure);
gimp_object_set_static_name (GIMP_OBJECT (new_procedure), name);
for (i = 0; i < procedure->num_args; i++)
gimp_procedure_add_argument (new_procedure, procedure->args[i]);
for (i = 0; i < procedure->num_values; i++)
gimp_procedure_add_return_value (new_procedure, procedure->values[i]);
return new_procedure;
}
void
register_help_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-help
*/
procedure = gimp_procedure_new (help_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-help");
gimp_procedure_set_static_strings (procedure,
"gimp-help",
"Load a help page.",
"This procedure loads the specified help page into the helpbrowser or what ever is configured as help viewer. The help page is identified by its domain and ID: if help_domain is NULL, we use the help_domain which was registered using the 'gimp-plugin-help-register' procedure. If help_domain is NULL and no help domain was registered, the help domain of the main GIMP installation is used.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2000",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("help-domain",
"help domain",
"The help domain in which help_id is registered",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("help-id",
"help id",
"The help page's ID",
FALSE, FALSE, FALSE,
NULL,
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_convert_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-convert-rgb
*/
procedure = gimp_procedure_new (image_convert_rgb_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-rgb");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-rgb",
"Convert specified image to RGB color",
"This procedure converts the specified image to RGB color. This process requires an image in Grayscale or Indexed color mode. No image content is lost in this process aside from the colormap for an indexed 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_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-convert-grayscale
*/
procedure = gimp_procedure_new (image_convert_grayscale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-grayscale");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-grayscale",
"Convert specified image to grayscale (256 intensity levels)",
"This procedure converts the specified image to grayscale with 8 bits per pixel (256 intensity levels). This process requires an image in RGB or Indexed color mode.",
"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-image-convert-indexed
*/
procedure = gimp_procedure_new (image_convert_indexed_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-indexed");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-indexed",
"Convert specified image to and Indexed image",
"This procedure converts the specified image to 'indexed' color. This process requires an image in RGB or Grayscale mode. The 'palette_type' specifies what kind of palette to use, A type of '0' means to use an optimal palette of 'num_cols' generated from the colors in the image. A type of '1' means to re-use the previous palette (not currently implemented). A type of '2' means to use the so-called WWW-optimized palette. Type '3' means to use only black and white colors. A type of '4' means to use a palette from the gimp palettes directories. The 'dither type' specifies what kind of dithering to use. '0' means no dithering, '1' means standard Floyd-Steinberg error diffusion, '2' means Floyd-Steinberg error diffusion with reduced bleeding, '3' means dithering based on pixel location ('Fixed' dithering).",
"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_enum ("dither-type",
"dither type",
"The dither type to use",
GIMP_TYPE_CONVERT_DITHER_TYPE,
GIMP_NO_DITHER,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("palette-type",
"palette type",
"The type of palette to use",
GIMP_TYPE_CONVERT_PALETTE_TYPE,
GIMP_MAKE_PALETTE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-cols",
"num cols",
"The number of colors to quantize to, ignored unless (palette_type == GIMP_MAKE_PALETTE)",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("alpha-dither",
"alpha dither",
"Dither transparency to fake partial opacity",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("remove-unused",
"remove unused",
"Remove unused or duplicate color entries from final palette, ignored if (palette_type == GIMP_MAKE_PALETTE)",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("palette",
"palette",
"The name of the custom palette to use, ignored unless (palette_type == GIMP_CUSTOM_PALETTE)",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-convert-set-dither-matrix
*/
procedure = gimp_procedure_new (image_convert_set_dither_matrix_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-set-dither-matrix");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-set-dither-matrix",
"Set dither matrix for conversion to indexed",
"This procedure sets the dither matrix used when converting images to INDEXED mode with positional dithering.",
"David Gowers",
"David Gowers",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width",
"width",
"Width of the matrix (0 to reset to default matrix)",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height",
"height",
"Height of the matrix (0 to reset to default matrix)",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("matrix-length",
"matrix length",
"The length of 'matrix'",
1, 1024, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("matrix",
"matrix",
"The matrix -- all values must be >= 1",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-convert-precision
*/
procedure = gimp_procedure_new (image_convert_precision_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-precision");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-precision",
"Convert the image to the specified precision",
"This procedure converts the image to the specified precision. Note that indexed images cannot be converted and are always in GIMP_PRECISION_U8.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2012",
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 ("precision",
"precision",
"The new precision",
GIMP_TYPE_PRECISION,
GIMP_PRECISION_U8,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
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_channel_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-channel-new
*/
procedure = gimp_procedure_new (channel_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-new");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-new",
"Create a new channel.",
"This procedure creates a new channel with the specified width and height. Name, opacity, and color are also supplied parameters. The new channel still needs to be added to the image, as this is not automatic. Add the new channel with the 'gimp-image-add-channel' command. Other attributes such as channel show masked, should be set with explicit procedure calls. The channel's contents are undefined initially.",
"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 to which to add the channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width",
"width",
"The channel width",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height",
"height",
"The channel height",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The channel name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("opacity",
"opacity",
"The channel opacity",
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color",
"color",
"The channel compositing color",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The newly created channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-new-from-component
*/
procedure = gimp_procedure_new (channel_new_from_component_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-new-from-component");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-new-from-component",
"Create a new channel from a color component",
"This procedure creates a new channel from a color component.",
"Shlomi Fish <*****@*****.**>",
"Shlomi Fish",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The image to which to add the channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("component",
"component",
"The image component",
GIMP_TYPE_CHANNEL_TYPE,
GIMP_RED_CHANNEL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The channel name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The newly created channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-copy
*/
procedure = gimp_procedure_new (channel_copy_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-copy");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-copy",
"Copy a channel.",
"This procedure copies the specified channel and returns the copy.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The channel to copy",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_channel_id ("channel-copy",
"channel copy",
"The newly copied channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-combine-masks
*/
procedure = gimp_procedure_new (channel_combine_masks_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-combine-masks");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-combine-masks",
"Combine two channel masks.",
"This procedure combines two channel masks. The result is stored in the first channel.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel1",
"channel1",
"The channel1",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel2",
"channel2",
"The channel2",
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_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx",
"offx",
"x offset between upper left corner of channels: (second - first)",
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 channels: (second - first)",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-get-show-masked
*/
procedure = gimp_procedure_new (channel_get_show_masked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-get-show-masked");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-get-show-masked",
"Get the composite method of the specified channel.",
"This procedure returns the specified channel's composite method. If it is TRUE, then the channel is composited with the image so that masked regions are shown. Otherwise, selected regions are shown.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("show-masked",
"show masked",
"The channel composite method",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-set-show-masked
*/
procedure = gimp_procedure_new (channel_set_show_masked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-set-show-masked");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-set-show-masked",
"Set the composite method of the specified channel.",
"This procedure sets the specified channel's composite method. If it is TRUE, then the channel is composited with the image so that masked regions are shown. Otherwise, selected regions are shown.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
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_boolean ("show-masked",
"show masked",
"The new channel composite method",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-get-opacity
*/
procedure = gimp_procedure_new (channel_get_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-get-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-get-opacity",
"Get the opacity of the specified channel.",
"This procedure returns the specified channel's opacity.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_double ("opacity",
"opacity",
"The channel opacity",
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-set-opacity
*/
procedure = gimp_procedure_new (channel_set_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-set-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-set-opacity",
"Set the opacity of the specified channel.",
"This procedure sets the specified channel's opacity.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
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_double ("opacity",
"opacity",
"The new channel opacity",
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-get-color
*/
procedure = gimp_procedure_new (channel_get_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-get-color");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-get-color",
"Get the compositing color of the specified channel.",
"This procedure returns the specified channel's compositing color.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_channel_id ("channel",
"channel",
"The channel",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_rgb ("color",
"color",
"The channel compositing color",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-channel-set-color
*/
procedure = gimp_procedure_new (channel_set_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-channel-set-color");
gimp_procedure_set_static_strings (procedure,
"gimp-channel-set-color",
"Set the compositing color of the specified channel.",
"This procedure sets the specified channel's compositing color.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
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,
gimp_param_spec_rgb ("color",
"color",
"The new channel compositing color",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_buffer_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-buffers-get-list
*/
procedure = gimp_procedure_new (buffers_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffers-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-buffers-get-list",
"Retrieve a complete listing of the available buffers.",
"This procedure returns a complete listing of available named buffers.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-buffers",
"num buffers",
"The number of buffers",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("buffer-list",
"buffer list",
"The list of buffer names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-buffer-rename
*/
procedure = gimp_procedure_new (buffer_rename_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffer-rename");
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-rename",
"Renames a named buffer.",
"This procedure renames a named buffer.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The buffer name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("new-name",
"new name",
"The buffer's new name",
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",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-buffer-delete
*/
procedure = gimp_procedure_new (buffer_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffer-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-delete",
"Deletes a named buffer.",
"This procedure deletes a named buffer.",
"David Gowers <*****@*****.**>",
"David Gowers <*****@*****.**>",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The buffer name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-buffer-get-width
*/
procedure = gimp_procedure_new (buffer_get_width_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffer-get-width");
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-width",
"Retrieves the specified buffer's width.",
"This procedure retrieves the specified named buffer's width.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The buffer name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The buffer width",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-buffer-get-height
*/
procedure = gimp_procedure_new (buffer_get_height_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffer-get-height");
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-height",
"Retrieves the specified buffer's height.",
"This procedure retrieves the specified named buffer's height.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The buffer name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The buffer height",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-buffer-get-bytes
*/
procedure = gimp_procedure_new (buffer_get_bytes_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffer-get-bytes");
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-bytes",
"Retrieves the specified buffer's bytes.",
"This procedure retrieves the specified named buffer's bytes.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The buffer name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bytes",
"bytes",
"The buffer bpp",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-buffer-get-image-type
*/
procedure = gimp_procedure_new (buffer_get_image_type_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-buffer-get-image-type");
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-image-type",
"Retrieves the specified buffer's image type.",
"This procedure retrieves the specified named buffer's image type.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("buffer-name",
"buffer name",
"The buffer name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("image-type",
"image type",
"The buffer image type",
GIMP_TYPE_IMAGE_BASE_TYPE,
GIMP_RGB,
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_brushes_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-brushes-refresh
*/
procedure = gimp_procedure_new (brushes_refresh_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-refresh");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-refresh",
"Refresh current brushes. This function always succeeds.",
"This procedure retrieves all brushes currently in the user's brush path and updates the brush dialogs accordingly.",
"Seth Burgess",
"Seth Burgess",
"1997",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-brushes-get-list
*/
procedure = gimp_procedure_new (brushes_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-list",
"Retrieve a complete listing of the available brushes.",
"This procedure returns a complete listing of available GIMP brushes. Each name returned can be used as input to the 'gimp-context-set-brush' procedure.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-brushes",
"num brushes",
"The number of brushes in the brush list",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("brush-list",
"brush list",
"The list of brush names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-brushes-get-brush
*/
procedure = gimp_procedure_new (brushes_get_brush_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-get-brush");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-brush",
"This procedure is deprecated! Use 'gimp-context-get-brush' instead.",
"This procedure is deprecated! Use 'gimp-context-get-brush' instead.",
"",
"",
"",
"gimp-context-get-brush");
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("name",
"name",
"The brush name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The brush width",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The brush height",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("spacing",
"spacing",
"The brush spacing",
0, 1000, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-brushes-get-spacing
*/
procedure = gimp_procedure_new (brushes_get_spacing_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-get-spacing");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-spacing",
"This procedure is deprecated! Use 'gimp-brush-get-spacing' instead.",
"This procedure is deprecated! Use 'gimp-brush-get-spacing' instead.",
"",
"",
"",
"gimp-brush-get-spacing");
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("spacing",
"spacing",
"The brush spacing",
0, 1000, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-brushes-set-spacing
*/
procedure = gimp_procedure_new (brushes_set_spacing_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-set-spacing");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-set-spacing",
"This procedure is deprecated! Use 'gimp-brush-set-spacing' instead.",
"This procedure is deprecated! Use 'gimp-brush-set-spacing' instead.",
"",
"",
"",
"gimp-brush-set-spacing");
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spacing",
"spacing",
"The brush spacing",
0, 1000, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-brushes-get-brush-data
*/
procedure = gimp_procedure_new (brushes_get_brush_data_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-get-brush-data");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-brush-data",
"This procedure is deprecated! Use 'gimp-brush-get-pixels' instead.",
"This procedure is deprecated! Use 'gimp-brush-get-pixels' instead.",
"",
"",
"",
"gimp-brush-get-pixels");
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The brush name (\"\" means current active brush)",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("actual-name",
"actual name",
"The brush name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_double ("opacity",
"opacity",
"The brush opacity",
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("spacing",
"spacing",
"The brush spacing",
0, 1000, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The brush width",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The brush height",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("length",
"length",
"Length of brush mask data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("mask-data",
"mask data",
"The brush mask data",
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_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);
}
void
register_font_select_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-fonts-popup
*/
procedure = gimp_procedure_new (fonts_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-fonts-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-popup",
"Invokes the Gimp font selection.",
"This procedure opens the font selection dialog.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2003",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("font-callback",
"font callback",
"The callback PDB proc to call when font selection is made",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("popup-title",
"popup title",
"Title of the font selection dialog",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("initial-font",
"initial font",
"The name of the font to set as the first selected",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-fonts-close-popup
*/
procedure = gimp_procedure_new (fonts_close_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-fonts-close-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-close-popup",
"Close the font selection dialog.",
"This procedure closes an opened font selection dialog.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2003",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("font-callback",
"font callback",
"The name of the callback registered for this pop-up",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-fonts-set-popup
*/
procedure = gimp_procedure_new (fonts_set_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-fonts-set-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-set-popup",
"Sets the current font in a font selection dialog.",
"Sets the current font in a font selection dialog.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2003",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("font-callback",
"font callback",
"The name of the callback registered for this pop-up",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("font-name",
"font name",
"The name of the font to set as selected",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_grid_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-grid-get-spacing
*/
procedure = gimp_procedure_new (image_grid_get_spacing_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-get-spacing");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-spacing",
"Gets the spacing of an image's grid.",
"This procedure retrieves the horizontal and vertical spacing of an image's grid. It takes the image as parameter.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_double ("xspacing",
"xspacing",
"The image's grid horizontal spacing",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_double ("yspacing",
"yspacing",
"The image's grid vertical spacing",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-set-spacing
*/
procedure = gimp_procedure_new (image_grid_set_spacing_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-set-spacing");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-spacing",
"Sets the spacing of an image's grid.",
"This procedure sets the horizontal and vertical spacing of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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 ("xspacing",
"xspacing",
"The image's grid horizontal spacing",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("yspacing",
"yspacing",
"The image's grid vertical spacing",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-get-offset
*/
procedure = gimp_procedure_new (image_grid_get_offset_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-get-offset");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-offset",
"Gets the offset of an image's grid.",
"This procedure retrieves the horizontal and vertical offset of an image's grid. It takes the image as parameter.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_double ("xoffset",
"xoffset",
"The image's grid horizontal offset",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_double ("yoffset",
"yoffset",
"The image's grid vertical offset",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-set-offset
*/
procedure = gimp_procedure_new (image_grid_set_offset_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-set-offset");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-offset",
"Sets the offset of an image's grid.",
"This procedure sets the horizontal and vertical offset of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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 ("xoffset",
"xoffset",
"The image's grid horizontal offset",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("yoffset",
"yoffset",
"The image's grid vertical offset",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-get-foreground-color
*/
procedure = gimp_procedure_new (image_grid_get_foreground_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-get-foreground-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-foreground-color",
"Sets the foreground color of an image's grid.",
"This procedure gets the foreground color of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_rgb ("fgcolor",
"fgcolor",
"The image's grid foreground color",
TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-set-foreground-color
*/
procedure = gimp_procedure_new (image_grid_set_foreground_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-set-foreground-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-foreground-color",
"Gets the foreground color of an image's grid.",
"This procedure sets the foreground color of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_rgb ("fgcolor",
"fgcolor",
"The new foreground color",
TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-get-background-color
*/
procedure = gimp_procedure_new (image_grid_get_background_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-get-background-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-background-color",
"Sets the background color of an image's grid.",
"This procedure gets the background color of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_rgb ("bgcolor",
"bgcolor",
"The image's grid background color",
TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-set-background-color
*/
procedure = gimp_procedure_new (image_grid_set_background_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-set-background-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-background-color",
"Gets the background color of an image's grid.",
"This procedure sets the background color of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_rgb ("bgcolor",
"bgcolor",
"The new background color",
TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-get-style
*/
procedure = gimp_procedure_new (image_grid_get_style_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-get-style");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-style",
"Gets the style of an image's grid.",
"This procedure retrieves the style of an image's grid.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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_enum ("style",
"style",
"The image's grid style",
GIMP_TYPE_GRID_STYLE,
GIMP_GRID_DOTS,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-grid-set-style
*/
procedure = gimp_procedure_new (image_grid_set_style_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-grid-set-style");
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-style",
"Sets the style unit of an image's grid.",
"This procedure sets the style of an image's grid. It takes the image and the new style as parameters.",
"Sylvain Foret",
"Sylvain Foret",
"2005",
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 ("style",
"style",
"The image's grid style",
GIMP_TYPE_GRID_STYLE,
GIMP_GRID_DOTS,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_gradients_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-gradients-refresh
*/
procedure = gimp_procedure_new (gradients_refresh_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-gradients-refresh");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-refresh",
"Refresh current gradients. This function always succeeds.",
"This procedure retrieves all gradients currently in the user's gradient path and updates the gradient dialogs accordingly.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2002",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-gradients-get-list
*/
procedure = gimp_procedure_new (gradients_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-gradients-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-get-list",
"Retrieve the list of loaded gradients.",
"This procedure returns a list of the gradients that are currently loaded. You can later use the 'gimp-context-set-gradient' function to set the active gradient.",
"Federico Mena Quintero",
"Federico Mena Quintero",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-gradients",
"num gradients",
"The number of loaded gradients",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("gradient-list",
"gradient list",
"The list of gradient names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-gradients-sample-uniform
*/
procedure = gimp_procedure_new (gradients_sample_uniform_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-gradients-sample-uniform");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-sample-uniform",
"This procedure is deprecated! Use 'gimp-gradient-get-uniform-samples' instead.",
"This procedure is deprecated! Use 'gimp-gradient-get-uniform-samples' instead.",
"",
"",
"",
"gimp-gradient-get-uniform-samples");
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-samples",
"num samples",
"The number of samples to take",
2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("reverse",
"reverse",
"Use the reverse gradient",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("array-length",
"array length",
"Length of the color_samples array (4 * num_samples)",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples",
"color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-gradients-sample-custom
*/
procedure = gimp_procedure_new (gradients_sample_custom_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-gradients-sample-custom");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-sample-custom",
"This procedure is deprecated! Use 'gimp-gradient-get-custom-samples' instead.",
"This procedure is deprecated! Use 'gimp-gradient-get-custom-samples' instead.",
"",
"",
"",
"gimp-gradient-get-custom-samples");
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-samples",
"num samples",
"The number of samples to take",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("positions",
"positions",
"The list of positions to sample along the gradient",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("reverse",
"reverse",
"Use the reverse gradient",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("array-length",
"array length",
"Length of the color_samples array (4 * num_samples)",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples",
"color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-gradients-get-gradient-data
*/
procedure = gimp_procedure_new (gradients_get_gradient_data_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-gradients-get-gradient-data");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-get-gradient-data",
"This procedure is deprecated! Use 'gimp-gradient-get-uniform-samples' instead.",
"This procedure is deprecated! Use 'gimp-gradient-get-uniform-samples' instead.",
"",
"",
"",
"gimp-gradient-get-uniform-samples");
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The gradient name (\"\" means current active gradient)",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("sample-size",
"sample size",
"Size of the sample to return when the gradient is changed",
1, 10000, 1,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("reverse",
"reverse",
"Use the reverse gradient",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("actual-name",
"actual name",
"The gradient name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The gradient sample width (r,g,b,a)",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("grad-data",
"grad data",
"The gradient sample data",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
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_message_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-message
*/
procedure = gimp_procedure_new (message_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-message");
gimp_procedure_set_static_strings (procedure,
"gimp-message",
"Displays a dialog box with a message.",
"Displays a dialog box with a message. Useful for status or error reporting. The message must be in UTF-8 encoding.",
"Manish Singh",
"Manish Singh",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("message",
"message",
"Message to display in the dialog",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-message-get-handler
*/
procedure = gimp_procedure_new (message_get_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-message-get-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-message-get-handler",
"Returns the current state of where warning messages are displayed.",
"This procedure returns the way g_message warnings are displayed. They can be shown in a dialog box or printed on the console where gimp was started.",
"Manish Singh",
"Manish Singh",
"1998",
NULL);
gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("handler",
"handler",
"The current handler type",
GIMP_TYPE_MESSAGE_HANDLER_TYPE,
GIMP_MESSAGE_BOX,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-message-set-handler
*/
procedure = gimp_procedure_new (message_set_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-message-set-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-message-set-handler",
"Controls where warning messages are displayed.",
"This procedure controls how g_message warnings are displayed. They can be shown in a dialog box or printed on the console where gimp was started.",
"Manish Singh",
"Manish Singh",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("handler",
"handler",
"The new handler type",
GIMP_TYPE_MESSAGE_HANDLER_TYPE,
GIMP_MESSAGE_BOX,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_image_select_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-select-color
*/
procedure = gimp_procedure_new (image_select_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-color",
"Create a selection by selecting all pixels (in the specified drawable) with the same (or similar) color to that specified.",
"This tool creates a selection over the specified image. A by-color selection is determined by the supplied color under the constraints of the current context settings. Essentially, all pixels (in the drawable) that have color sufficiently close to the specified color (as determined by the threshold and criterion context values) are included in the selection. To select transparent regions, the color specified must also have minimum alpha.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-antialias', 'gimp-context-set-feather', 'gimp-context-set-feather-radius', 'gimp-context-set-sample-merged', 'gimp-context-set-sample-criterion', 'gimp-context-set-sample-threshold', 'gimp-context-set-sample-transparent'.\n"
"\n"
"In the case of a merged sampling, the supplied drawable is ignored.",
"David Gowers",
"David Gowers",
"2010",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The affected image",
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_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_rgb ("color",
"color",
"The color to select",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-select-contiguous-color
*/
procedure = gimp_procedure_new (image_select_contiguous_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-contiguous-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-contiguous-color",
"Create a selection by selecting all pixels around specified coordinates with the same (or similar) color to that at the coordinates.",
"This tool creates a contiguous selection over the specified image. A contiguous color selection is determined by a seed fill under the constraints of the current context settings. Essentially, the color at the specified coordinates (in the drawable) is measured and the selection expands outwards from that point to any adjacent pixels which are not significantly different (as determined by the threshold and criterion context settings). This process continues until no more expansion is possible. If antialiasing is turned on, the final selection mask will contain intermediate values based on close misses to the threshold bar at pixels along the seed fill boundary.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-antialias', 'gimp-context-set-feather', 'gimp-context-set-feather-radius', 'gimp-context-set-sample-merged', 'gimp-context-set-sample-criterion', 'gimp-context-set-sample-threshold', 'gimp-context-set-sample-transparent', 'gimp-context-set-diagonal-neighbors'.\n"
"\n"
"In the case of a merged sampling, the supplied drawable is ignored. If the sample is merged, the specified coordinates are relative to the image origin; otherwise, they are relative to the drawable's origin.",
"David Gowers",
"David Gowers",
"2010",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The affected image",
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_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_double ("x",
"x",
"x coordinate of initial seed fill point: (image coordinates)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y",
"y",
"y coordinate of initial seed fill point: (image coordinates)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-select-rectangle
*/
procedure = gimp_procedure_new (image_select_rectangle_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-rectangle");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-rectangle",
"Create a rectangular selection over the specified image;",
"This tool creates a rectangular selection over the specified image. The rectangular region can be either added to, subtracted from, or replace the contents of the previous selection mask.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-feather', 'gimp-context-set-feather-radius'.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2010",
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 ("operation",
"operation",
"The selection operation",
GIMP_TYPE_CHANNEL_OPS,
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x",
"x",
"x coordinate of upper-left corner of rectangle",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y",
"y",
"y coordinate of upper-left corner of rectangle",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("width",
"width",
"The width of the rectangle",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("height",
"height",
"The height of the rectangle",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-select-round-rectangle
*/
procedure = gimp_procedure_new (image_select_round_rectangle_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-round-rectangle");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-round-rectangle",
"Create a rectangular selection with round corners over the specified image;",
"This tool creates a rectangular selection with round corners over the specified image. The rectangular region can be either added to, subtracted from, or replace the contents of the previous selection mask.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-antialias', 'gimp-context-set-feather', 'gimp-context-set-feather-radius'.",
"Martin Nordholts",
"Martin Nordholts",
"2010",
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 ("operation",
"operation",
"The selection operation",
GIMP_TYPE_CHANNEL_OPS,
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x",
"x",
"x coordinate of upper-left corner of rectangle",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y",
"y",
"y coordinate of upper-left corner of rectangle",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("width",
"width",
"The width of the rectangle",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("height",
"height",
"The height of the rectangle",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("corner-radius-x",
"corner radius x",
"The corner radius in X direction",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("corner-radius-y",
"corner radius y",
"The corner radius in Y direction",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-select-ellipse
*/
procedure = gimp_procedure_new (image_select_ellipse_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-ellipse");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-ellipse",
"Create an elliptical selection over the specified image.",
"This tool creates an elliptical selection over the specified image. The elliptical region can be either added to, subtracted from, or replace the contents of the previous selection mask.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-antialias', 'gimp-context-set-feather', 'gimp-context-set-feather-radius'.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2010",
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 ("operation",
"operation",
"The selection operation",
GIMP_TYPE_CHANNEL_OPS,
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("x",
"x",
"x coordinate of upper-left corner of ellipse bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("y",
"y",
"y coordinate of upper-left corner of ellipse bounding box",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("width",
"width",
"The width of the ellipse",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("height",
"height",
"The height of the ellipse",
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-select-polygon
*/
procedure = gimp_procedure_new (image_select_polygon_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-polygon");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-polygon",
"Create a polygonal selection over the specified image.",
"This tool creates a polygonal selection over the specified image. The polygonal region can be either added to, subtracted from, or replace the contents of the previous selection mask. The polygon is specified through an array of floating point numbers and its length. The length of array must be 2n, where n is the number of points. Each point is defined by 2 floating point values which correspond to the x and y coordinates. If the final point does not connect to the starting point, a connecting segment is automatically added.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-antialias', 'gimp-context-set-feather', 'gimp-context-set-feather-radius'.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2010",
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 ("operation",
"operation",
"The selection operation",
GIMP_TYPE_CHANNEL_OPS,
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-segs",
"num segs",
"Number of points (count 1 coordinate as two points)",
2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("segs",
"segs",
"Array of points: { p1.x, p1.y, p2.x, p2.y, ..., pn.x, pn.y}",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-select-item
*/
procedure = gimp_procedure_new (image_select_item_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-select-item");
gimp_procedure_set_static_strings (procedure,
"gimp-image-select-item",
"Transforms the specified item into a selection",
"This procedure renders the item's outline into the current selection of the image the item belongs to. What exactly the item's outline is depends on the item type: for layers, it's the layer's alpha channel, for vectors the vector's shape.\n"
"\n"
"This procedure is affected by the following context setters: 'gimp-context-set-antialias', 'gimp-context-set-feather', 'gimp-context-set-feather-radius'.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2010",
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 ("operation",
"operation",
"The desired operation with current selection",
GIMP_TYPE_CHANNEL_OPS,
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_item_id ("item",
"item",
"The item to render to the selection",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_parasite_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-parasite-find
*/
procedure = gimp_procedure_new (parasite_find_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-parasite-find");
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-find",
"Look up a global parasite.",
"Finds and returns the global parasite that was previously attached.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to find",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The found parasite",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-parasite-attach
*/
procedure = gimp_procedure_new (parasite_attach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-parasite-attach");
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-attach",
"Add a global parasite.",
"This procedure attaches a global parasite. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The parasite to attach",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-parasite-detach
*/
procedure = gimp_procedure_new (parasite_detach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-parasite-detach");
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-detach",
"Removes a global parasite.",
"This procedure detaches a global parasite from. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to detach.",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-parasite-list
*/
procedure = gimp_procedure_new (parasite_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-parasite-list");
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-list",
"List all parasites.",
"Returns a list of all currently attached global parasites.",
"Marc Lehmann",
"Marc Lehmann",
"1999",
NULL);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites",
"num parasites",
"The number of attached parasites",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites",
"parasites",
"The names of currently attached parasites",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-parasite-find
*/
procedure = gimp_procedure_new (image_parasite_find_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-parasite-find");
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-find",
"Look up a parasite in an image",
"Finds and returns the parasite that was previously attached to an image.",
"Jay Cox",
"Jay Cox",
"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_string ("name",
"name",
"The name of the parasite to find",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The found parasite",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-parasite-attach
*/
procedure = gimp_procedure_new (image_parasite_attach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-parasite-attach");
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-attach",
"Add a parasite to an image.",
"This procedure attaches a parasite to an image. It has no return values.",
"Jay Cox",
"Jay Cox",
"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_parasite ("parasite",
"parasite",
"The parasite to attach to an image",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-parasite-detach
*/
procedure = gimp_procedure_new (image_parasite_detach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-parasite-detach");
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-detach",
"Removes a parasite from an image.",
"This procedure detaches a parasite from an image. It has no return values.",
"Jay Cox",
"Jay Cox",
"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_string ("name",
"name",
"The name of the parasite to detach from an image.",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-parasite-list
*/
procedure = gimp_procedure_new (image_parasite_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-parasite-list");
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
"Marc Lehmann",
"Marc Lehmann",
"1999",
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_int32 ("num-parasites",
"num parasites",
"The number of attached parasites",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites",
"parasites",
"The names of currently attached parasites",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-parasite-find
*/
procedure = gimp_procedure_new (drawable_parasite_find_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-drawable-parasite-find");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-find",
"Look up a parasite in a drawable",
"Finds and returns the parasite that was previously attached to a drawable.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to find",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The found parasite",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-parasite-attach
*/
procedure = gimp_procedure_new (drawable_parasite_attach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-drawable-parasite-attach");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-attach",
"Add a parasite to a drawable.",
"This procedure attaches a parasite to a drawable. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The parasite to attach to a drawable",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-parasite-detach
*/
procedure = gimp_procedure_new (drawable_parasite_detach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-drawable-parasite-detach");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-detach",
"Removes a parasite from a drawable.",
"This procedure detaches a parasite from a drawable. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to detach from a drawable.",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-drawable-parasite-list
*/
procedure = gimp_procedure_new (drawable_parasite_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-drawable-parasite-list");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
"Marc Lehmann",
"Marc Lehmann",
"1999",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"drawable",
"The drawable",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites",
"num parasites",
"The number of attached parasites",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites",
"parasites",
"The names of currently attached parasites",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-vectors-parasite-find
*/
procedure = gimp_procedure_new (vectors_parasite_find_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-vectors-parasite-find");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-find",
"Look up a parasite in a vectors object",
"Finds and returns the parasite that was previously attached to a vectors object.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_vectors_id ("vectors",
"vectors",
"The vectors object",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to find",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The found parasite",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-vectors-parasite-attach
*/
procedure = gimp_procedure_new (vectors_parasite_attach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-vectors-parasite-attach");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-attach",
"Add a parasite to a vectors object",
"This procedure attaches a parasite to a vectors object. It has no return values.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_vectors_id ("vectors",
"vectors",
"The vectors object",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The parasite to attach to a vectors object",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-vectors-parasite-detach
*/
procedure = gimp_procedure_new (vectors_parasite_detach_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-vectors-parasite-detach");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-detach",
"Removes a parasite from a vectors object",
"This procedure detaches a parasite from a vectors object. It has no return values.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_vectors_id ("vectors",
"vectors",
"The vectors object",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to detach from a vectors object.",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-vectors-parasite-list
*/
procedure = gimp_procedure_new (vectors_parasite_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-vectors-parasite-list");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_vectors_id ("vectors",
"vectors",
"The vectors object",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites",
"num parasites",
"The number of attached parasites",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites",
"parasites",
"The names of currently attached parasites",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_patterns_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-patterns-refresh
*/
procedure = gimp_procedure_new (patterns_refresh_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-refresh");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-refresh",
"Refresh current patterns. This function always succeeds.",
"This procedure retrieves all patterns currently in the user's pattern path and updates all pattern dialogs accordingly.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2002",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-patterns-get-list
*/
procedure = gimp_procedure_new (patterns_get_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-get-list");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-list",
"Retrieve a complete listing of the available patterns.",
"This procedure returns a complete listing of available GIMP patterns. Each name returned can be used as input to the 'gimp-context-set-pattern'.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filter",
"filter",
"An optional regular expression used to filter the list",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-patterns",
"num patterns",
"The number of patterns in the pattern list",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("pattern-list",
"pattern list",
"The list of pattern names",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-patterns-get-pattern
*/
procedure = gimp_procedure_new (patterns_get_pattern_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-get-pattern");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-pattern",
"Deprecated: Use 'gimp-context-get-pattern' instead.",
"Deprecated: Use 'gimp-context-get-pattern' instead.",
"",
"",
"",
"gimp-context-get-pattern");
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("name",
"name",
"The pattern name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The pattern width",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The pattern height",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-patterns-get-pattern-data
*/
procedure = gimp_procedure_new (patterns_get_pattern_data_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-patterns-get-pattern-data");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-pattern-data",
"Deprecated: Use 'gimp-pattern-get-pixels' instead.",
"Deprecated: Use 'gimp-pattern-get-pixels' instead.",
"",
"",
"",
"gimp-pattern-get-pixels");
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The pattern name (\"\" means currently active pattern)",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("actual-name",
"actual name",
"The pattern name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",
"width",
"The pattern width",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height",
"height",
"The pattern height",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("mask-bpp",
"mask bpp",
"Pattern bytes per pixel",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("length",
"length",
"Length of pattern mask data",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("mask-data",
"mask data",
"The pattern mask data",
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_plug_in_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-plugins-query
*/
procedure = gimp_procedure_new (plugins_query_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugins-query");
gimp_procedure_set_static_strings (procedure,
"gimp-plugins-query",
"Queries the plugin database for its contents.",
"This procedure queries the contents of the plugin database.",
"Andy Thomas",
"Andy Thomas",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("search-string",
"search string",
"If not an empty string then use this as a search pattern",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins",
"num plugins",
"The number of plugins",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("menu-path",
"menu path",
"The menu path of the plugin",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins",
"num plugins",
"The number of plugins",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-accelerator",
"plugin accelerator",
"String representing keyboard accelerator (could be empty string)",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins",
"num plugins",
"The number of plugins",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-location",
"plugin location",
"Location of the plugin program",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins",
"num plugins",
"The number of plugins",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-image-type",
"plugin image type",
"Type of image that this plugin will work on",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins",
"num plugins",
"The number of plugins",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("plugin-install-time",
"plugin install time",
"Time that the plugin was installed",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins",
"num plugins",
"The number of plugins",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-real-name",
"plugin real name",
"The internal name of the plugin",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-domain-register
*/
procedure = gimp_procedure_new (plugin_domain_register_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-domain-register");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-domain-register",
"Registers a textdomain for localisation.",
"This procedure adds a textdomain to the list of domains Gimp searches for strings when translating its menu entries. There is no need to call this function for plug-ins that have their strings included in the 'gimp-std-plugins' domain as that is used by default. If the compiled message catalog is not in the standard location, you may specify an absolute path to another location. This procedure can only be called in the query function of a plug-in and it has to be called before any procedure is installed.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2000",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("domain-name",
"domain name",
"The name of the textdomain (must be unique)",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("domain-path",
"domain path",
"The absolute path to the compiled message catalog (may be NULL)",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-help-register
*/
procedure = gimp_procedure_new (plugin_help_register_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-help-register");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-help-register",
"Register a help path for a plug-in.",
"This procedure registers user documentation for the calling plug-in with the GIMP help system. The domain_uri parameter points to the root directory where the plug-in help is installed. For each supported language there should be a file called 'gimp-help.xml' that maps the help IDs to the actual help files.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2000",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("domain-name",
"domain name",
"The XML namespace of the plug-in's help pages",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("domain-uri",
"domain uri",
"The root URI of the plug-in's help pages",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-menu-register
*/
procedure = gimp_procedure_new (plugin_menu_register_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-menu-register");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-menu-register",
"Register an additional menu path for a plug-in procedure.",
"This procedure installs an additional menu entry for the given procedure.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The procedure for which to install the menu path",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("menu-path",
"menu path",
"The procedure's additional menu path",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-menu-branch-register
*/
procedure = gimp_procedure_new (plugin_menu_branch_register_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-menu-branch-register");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-menu-branch-register",
"Register a sub-menu.",
"This procedure installs a sub-menu which does not belong to any procedure. The menu-name should be the untranslated menu label. GIMP will look up the translation in the textdomain registered for the plug-in.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("menu-path",
"menu path",
"The sub-menu's menu path",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("menu-name",
"menu name",
"The name of the sub-menu",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-icon-register
*/
procedure = gimp_procedure_new (plugin_icon_register_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-icon-register");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-icon-register",
"Register an icon for a plug-in procedure.",
"This procedure installs an icon for the given procedure.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("procedure-name",
"procedure name",
"The procedure for which to install the icon",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("icon-type",
"icon type",
"The type of the icon",
GIMP_TYPE_ICON_TYPE,
GIMP_ICON_TYPE_STOCK_ID,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("icon-data-length",
"icon data length",
"The length of 'icon-data'",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("icon-data",
"icon data",
"The procedure's icon. The format depends on the 'icon_type' parameter",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-set-pdb-error-handler
*/
procedure = gimp_procedure_new (plugin_set_pdb_error_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-set-pdb-error-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-set-pdb-error-handler",
"Sets an error handler for procedure calls.",
"This procedure changes the way that errors in procedure calls are handled. By default GIMP will raise an error dialog if a procedure call made by a plug-in fails. Using this procedure the plug-in can change this behavior. If the error handler is set to %GIMP_PDB_ERROR_HANDLER_PLUGIN, then the plug-in is responsible for calling 'gimp-get-pdb-error' and handling the error whenever one if its procedure calls fails. It can do this by displaying the error message or by forwarding it in its own return values.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2008",
NULL);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("handler",
"handler",
"Who is responsible for handling procedure call errors",
GIMP_TYPE_PDB_ERROR_HANDLER,
GIMP_PDB_ERROR_HANDLER_INTERNAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-plugin-get-pdb-error-handler
*/
procedure = gimp_procedure_new (plugin_get_pdb_error_handler_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-plugin-get-pdb-error-handler");
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-get-pdb-error-handler",
"Retrieves the active error handler for procedure calls.",
"This procedure retrieves the currently active error handler for procedure calls made by the calling plug-in. See 'gimp-plugin-set-pdb-error-handler' for details.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2008",
NULL);
gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("handler",
"handler",
"Who is responsible for handling procedure call errors",
GIMP_TYPE_PDB_ERROR_HANDLER,
GIMP_PDB_ERROR_HANDLER_INTERNAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_palette_select_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-palettes-popup
*/
procedure = gimp_procedure_new (palettes_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-popup",
"Invokes the Gimp palette selection.",
"This procedure opens the palette selection dialog.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2002",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("palette-callback",
"palette callback",
"The callback PDB proc to call when palette selection is made",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("popup-title",
"popup title",
"Title of the palette selection dialog",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("initial-palette",
"initial palette",
"The name of the palette to set as the first selected",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palettes-close-popup
*/
procedure = gimp_procedure_new (palettes_close_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-close-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-close-popup",
"Close the palette selection dialog.",
"This procedure closes an opened palette selection dialog.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2002",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("palette-callback",
"palette callback",
"The name of the callback registered for this pop-up",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palettes-set-popup
*/
procedure = gimp_procedure_new (palettes_set_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palettes-set-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-set-popup",
"Sets the current palette in a palette selection dialog.",
"Sets the current palette in a palette selection dialog.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2002",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("palette-callback",
"palette callback",
"The name of the callback registered for this pop-up",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("palette-name",
"palette name",
"The name of the palette to set as selected",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_image_color_profile_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-get-color-profile
*/
procedure = gimp_procedure_new (image_get_color_profile_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-get-color-profile");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-color-profile",
"Returns the image's color profile",
"This procedure returns the image's color profile, or NULL if the image has no color profile assigned.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2015",
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_int32 ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("profile-data",
"profile data",
"The image's serialized color profile. The returned value must be freed with g_free()",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-get-effective-color-profile
*/
procedure = gimp_procedure_new (image_get_effective_color_profile_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-get-effective-color-profile");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-effective-color-profile",
"Returns the color profile that is used for the image",
"This procedure returns the color profile that is actually used for this image, which is the profile returned by 'gimp-image-get-color-profile' if the image has a profile assigned, or the default RGB profile from preferences if no profile is assigned to the image. If there is no default RGB profile configured in preferences either, a generated default RGB profile is returned.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2015",
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_int32 ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("profile-data",
"profile data",
"The image's serialized color profile. The returned value must be freed with g_free()",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-set-color-profile
*/
procedure = gimp_procedure_new (image_set_color_profile_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-set-color-profile");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-color-profile",
"Sets the image's color profile",
"This procedure sets the image's color profile, or unsets it if NULL is passed as 'color_profile'. This procedure does no color conversion.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2015",
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 ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("color-profile",
"color profile",
"The new serialized color profile",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-set-color-profile-from-file
*/
procedure = gimp_procedure_new (image_set_color_profile_from_file_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-set-color-profile-from-file");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-color-profile-from-file",
"Sets the image's color profile from an ICC file",
"This procedure sets the image's color profile from a file containing an ICC profile, or unsets it if NULL is passed as 'uri'. This procedure does no color conversion.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2015",
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 ("uri",
"uri",
"The URI of the file containing the new color profile",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-convert-color-profile
*/
procedure = gimp_procedure_new (image_convert_color_profile_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-color-profile");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-color-profile",
"Convert the image's layers to a color profile",
"This procedure converts from the image's color profile (or the default RGB profile if none is set) to the given color profile. Only RGB color profiles are accepted.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2015",
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 ("num-bytes",
"num bytes",
"Number of bytes in the color_profile array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("color-profile",
"color profile",
"The serialized color profile",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("intent",
"intent",
"Rendering intent",
GIMP_TYPE_COLOR_RENDERING_INTENT,
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("bpc",
"bpc",
"Black point compensation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-convert-color-profile-from-file
*/
procedure = gimp_procedure_new (image_convert_color_profile_from_file_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-convert-color-profile-from-file");
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-color-profile-from-file",
"Convert the image's layers to a color profile",
"This procedure converts from the image's color profile (or the default RGB profile if none is set) to an ICC profile precified by 'uri'. Only RGB color profiles are accepted.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2015",
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 ("uri",
"uri",
"The URI of the file containing the new color profile",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("intent",
"intent",
"Rendering intent",
GIMP_TYPE_COLOR_RENDERING_INTENT,
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("bpc",
"bpc",
"Black point compensation",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_display_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-display-is-valid
*/
procedure = gimp_procedure_new (display_is_valid_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-display-is-valid");
gimp_procedure_set_static_strings (procedure,
"gimp-display-is-valid",
"Returns TRUE if the display is valid.",
"This procedure checks if the given display ID is valid and refers to an existing display.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2007",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_display_id ("display",
"display",
"The display to check",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("valid",
"valid",
"Whether the display ID is valid",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-display-new
*/
procedure = gimp_procedure_new (display_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-display-new");
gimp_procedure_set_static_strings (procedure,
"gimp-display-new",
"Create a new display for the specified image.",
"Creates a new display for the specified image. If the image already has a display, another is added. Multiple displays are handled transparently by GIMP. The newly created display is returned and can be subsequently destroyed with a call to 'gimp-display-delete'. This procedure only makes sense for use with the GIMP UI.",
"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_display_id ("display",
"display",
"The new display",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-display-delete
*/
procedure = gimp_procedure_new (display_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-display-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-display-delete",
"Delete the specified display.",
"This procedure removes the specified display. If this is the last remaining display for the underlying image, then the image is deleted also. Note that the display is closed no matter if the image is dirty or not. Better save the image before calling this procedure.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_display_id ("display",
"display",
"The display to delete",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-display-get-window-handle
*/
procedure = gimp_procedure_new (display_get_window_handle_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-display-get-window-handle");
gimp_procedure_set_static_strings (procedure,
"gimp-display-get-window-handle",
"Get a handle to the native window for an image display.",
"This procedure returns a handle to the native window for a given image display. For example in the X backend of GDK, a native window handle is an Xlib XID. A value of 0 is returned for an invalid display or if this function is unimplemented for the windowing system that is being used.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_display_id ("display",
"display",
"The display to get the window handle from",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("window",
"window",
"The native window handle or 0",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-displays-flush
*/
procedure = gimp_procedure_new (displays_flush_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-displays-flush");
gimp_procedure_set_static_strings (procedure,
"gimp-displays-flush",
"Flush all internal changes to the user interface",
"This procedure takes no arguments and returns nothing except a success status. Its purpose is to flush all pending updates of image manipulations to the user interface. It should be called whenever appropriate.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-displays-reconnect
*/
procedure = gimp_procedure_new (displays_reconnect_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-displays-reconnect");
gimp_procedure_set_static_strings (procedure,
"gimp-displays-reconnect",
"Reconnect displays from one image to another image.",
"This procedure connects all displays of the old_image to the new_image. If the old_image has no display or new_image already has a display the reconnect is not performed and the procedure returns without success. You should rarely need to use this function.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("old-image",
"old image",
"The old image (must have at least one display)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("new-image",
"new image",
"The new image (must not have a display)",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_undo_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-image-undo-group-start
*/
procedure = gimp_procedure_new (image_undo_group_start_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-group-start");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-group-start",
"Starts a group undo.",
"This function is used to start a group undo--necessary for logically combining two or more undo operations into a single operation. This call must be used in conjunction with a 'gimp-image-undo-group-end' call.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The ID of the image in which to open an undo group",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-undo-group-end
*/
procedure = gimp_procedure_new (image_undo_group_end_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-group-end");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-group-end",
"Finish a group undo.",
"This function must be called once for each 'gimp-image-undo-group-start' call that is made.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"image",
"The ID of the image in which to close an undo group",
pdb->gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-undo-is-enabled
*/
procedure = gimp_procedure_new (image_undo_is_enabled_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-is-enabled");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-is-enabled",
"Check if the image's undo stack is enabled.",
"This procedure checks if the image's undo stack is currently enabled or disabled. This is useful when several plugins or scripts call each other and want to check if their caller has already used 'gimp-image-undo-disable' or 'gimp-image-undo-freeze'.",
"Rapha\xc3\xabl Quinet <*****@*****.**>",
"Rapha\xc3\xabl Quinet",
"1999",
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 ("enabled",
"enabled",
"TRUE if undo is enabled for this image",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-undo-disable
*/
procedure = gimp_procedure_new (image_undo_disable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-disable");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-disable",
"Disable the image's undo stack.",
"This procedure disables the image's undo stack, allowing subsequent operations to ignore their undo steps. This is generally called in conjunction with 'gimp-image-undo-enable' to temporarily disable an image undo stack. This is advantageous because saving undo steps can be time and memory intensive.",
"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 ("disabled",
"disabled",
"TRUE if the image undo has been disabled",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-undo-enable
*/
procedure = gimp_procedure_new (image_undo_enable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-enable");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-enable",
"Enable the image's undo stack.",
"This procedure enables the image's undo stack, allowing subsequent operations to store their undo steps. This is generally called in conjunction with 'gimp-image-undo-disable' to temporarily disable an image undo stack.",
"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 ("enabled",
"enabled",
"TRUE if the image undo has been enabled",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-undo-freeze
*/
procedure = gimp_procedure_new (image_undo_freeze_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-freeze");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-freeze",
"Freeze the image's undo stack.",
"This procedure freezes the image's undo stack, allowing subsequent operations to ignore their undo steps. This is generally called in conjunction with 'gimp-image-undo-thaw' to temporarily disable an image undo stack. This is advantageous because saving undo steps can be time and memory intensive. 'gimp-image-undo-freeze' / 'gimp-image-undo-thaw' and 'gimp-image-undo-disable' / 'gimp-image-undo-enable' differ in that the former does not free up all undo steps when undo is thawed, so is more suited to interactive in-situ previews. It is important in this case that the image is back to the same state it was frozen in before thawing, else 'undo' behaviour is undefined.",
"Adam D. Moss",
"Adam D. Moss",
"1999",
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 ("frozen",
"frozen",
"TRUE if the image undo has been frozen",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-undo-thaw
*/
procedure = gimp_procedure_new (image_undo_thaw_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-undo-thaw");
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-thaw",
"Thaw the image's undo stack.",
"This procedure thaws the image's undo stack, allowing subsequent operations to store their undo steps. This is generally called in conjunction with 'gimp-image-undo-freeze' to temporarily freeze an image undo stack. 'gimp-image-undo-thaw' does NOT free the undo stack as 'gimp-image-undo-enable' does, so is suited for situations where one wishes to leave the undo stack in the same state in which one found it despite non-destructively playing with the image in the meantime. An example would be in-situ plugin previews. Balancing freezes and thaws and ensuring image consistancy is the responsibility of the caller.",
"Adam D. Moss",
"Adam D. Moss",
"1999",
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 ("thawed",
"thawed",
"TRUE if the image undo has been thawed",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}
void
register_gimp_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-version
*/
procedure = gimp_procedure_new (version_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-version");
gimp_procedure_set_static_strings (procedure,
"gimp-version",
"Returns the host GIMP version.",
"This procedure returns the version number of the currently running GIMP.",
"Manish Singh",
"Manish Singh",
"1999",
NULL);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("version",
"version",
"GIMP version number",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-getpid
*/
procedure = gimp_procedure_new (getpid_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-getpid");
gimp_procedure_set_static_strings (procedure,
"gimp-getpid",
"Returns the PID of the host GIMP process.",
"This procedure returns the process ID of the currently running GIMP.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2005",
NULL);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("pid",
"pid",
"The PID",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-quit
*/
procedure = gimp_procedure_new (quit_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-quit");
gimp_procedure_set_static_strings (procedure,
"gimp-quit",
"Causes GIMP to exit gracefully.",
"If there are unsaved images in an interactive GIMP session, the user will be asked for confirmation. If force is TRUE, the application is quit without querying the user to save any dirty images.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("force",
"force",
"Force GIMP to quit without asking",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-attach-parasite
*/
procedure = gimp_procedure_new (attach_parasite_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-attach-parasite");
gimp_procedure_set_static_strings (procedure,
"gimp-attach-parasite",
"Add a global parasite.",
"This procedure attaches a global parasite. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The parasite to attach",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-detach-parasite
*/
procedure = gimp_procedure_new (detach_parasite_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-detach-parasite");
gimp_procedure_set_static_strings (procedure,
"gimp-detach-parasite",
"Removes a global parasite.",
"This procedure detaches a global parasite from. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to detach.",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-get-parasite
*/
procedure = gimp_procedure_new (get_parasite_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-get-parasite");
gimp_procedure_set_static_strings (procedure,
"gimp-get-parasite",
"Look up a global parasite.",
"Finds and returns the global parasite that was previously attached.",
"Jay Cox",
"Jay Cox",
"1998",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The name of the parasite to find",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_parasite ("parasite",
"parasite",
"The found parasite",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-get-parasite-list
*/
procedure = gimp_procedure_new (get_parasite_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-get-parasite-list");
gimp_procedure_set_static_strings (procedure,
"gimp-get-parasite-list",
"List all parasites.",
"Returns a list of all currently attached global parasites.",
"Marc Lehmann",
"Marc Lehmann",
"1999",
NULL);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites",
"num parasites",
"The number of attached parasites",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites",
"parasites",
"The names of currently attached parasites",
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);
}
void
register_palette_procs (GimpPDB *pdb)
{
GimpProcedure *procedure;
/*
* gimp-palette-new
*/
procedure = gimp_procedure_new (palette_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-new");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-new",
"Creates a new palette",
"This procedure creates a new, uninitialized palette",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The requested name of the new palette",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("actual-name",
"actual name",
"The actual new palette name",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-duplicate
*/
procedure = gimp_procedure_new (palette_duplicate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-duplicate");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-duplicate",
"Duplicates a palette",
"This procedure creates an identical palette by a different name",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("copy-name",
"copy name",
"The name of the palette's copy",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-rename
*/
procedure = gimp_procedure_new (palette_rename_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-rename");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-rename",
"Rename a palette",
"This procedure renames a palette",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("new-name",
"new name",
"The new name of the palette",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("actual-name",
"actual name",
"The actual new name of the palette",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-delete
*/
procedure = gimp_procedure_new (palette_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-delete",
"Deletes a palette",
"This procedure deletes a palette",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-is-editable
*/
procedure = gimp_procedure_new (palette_is_editable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-is-editable");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-is-editable",
"Tests if palette can be edited",
"Returns TRUE if you have permission to change the palette",
"Bill Skaggs <*****@*****.**>",
"Bill Skaggs",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("editable",
"editable",
"TRUE if the palette can be edited",
FALSE,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-get-info
*/
procedure = gimp_procedure_new (palette_get_info_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-get-info");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-get-info",
"Retrieve information about the specified palette.",
"This procedure retrieves information about the specified palette. This includes the name, and the number of colors.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-colors",
"num colors",
"The number of colors in the palette",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-get-colors
*/
procedure = gimp_procedure_new (palette_get_colors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-get-colors");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-get-colors",
"Gets all colors from the specified palette.",
"This procedure retrieves all color entries of the specified palette.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2006",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-colors",
"num colors",
"Length of the colors array",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_color_array ("colors",
"colors",
"The colors in the palette",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-get-columns
*/
procedure = gimp_procedure_new (palette_get_columns_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-get-columns");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-get-columns",
"Retrieves the number of columns to use to display this palette",
"This procedures retrieves the preferred number of columns to use when the palette is being displayed.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-columns",
"num columns",
"The number of columns used to display this palette",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-set-columns
*/
procedure = gimp_procedure_new (palette_set_columns_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-set-columns");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-set-columns",
"Sets the number of columns to use when displaying the palette",
"This procedures controls how many colors are shown per row when the palette is being displayed. This value can only be changed if the palette is writable. The maximum allowed value is 64.",
"Sven Neumann <*****@*****.**>",
"Sven Neumann",
"2005",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("columns",
"columns",
"The new number of columns",
0, 64, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-add-entry
*/
procedure = gimp_procedure_new (palette_add_entry_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-add-entry");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-add-entry",
"Adds a palette entry to the specified palette.",
"This procedure adds an entry to the specified palette. It returns an error if the entry palette does not exist.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("entry-name",
"entry name",
"The name of the entry",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color",
"color",
"The new entry's color color",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("entry-num",
"entry num",
"The index of the added entry",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-delete-entry
*/
procedure = gimp_procedure_new (palette_delete_entry_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-delete-entry");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-delete-entry",
"Deletes a palette entry from the specified palette.",
"This procedure deletes an entry from the specified palette. It returns an error if the entry palette does not exist.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num",
"entry num",
"The index of the added entry",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-entry-get-color
*/
procedure = gimp_procedure_new (palette_entry_get_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-entry-get-color");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-get-color",
"Gets the specified palette entry from the specified palette.",
"This procedure retrieves the color of the zero-based entry specified for the specified palette. It returns an error if the entry does not exist.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num",
"entry num",
"The entry to retrieve",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_rgb ("color",
"color",
"The color requested",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-entry-set-color
*/
procedure = gimp_procedure_new (palette_entry_set_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-entry-set-color");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-set-color",
"Sets the specified palette entry in the specified palette.",
"This procedure sets the color of the zero-based entry specified for the specified palette. It returns an error if the entry does not exist.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num",
"entry num",
"The entry to retrieve",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color",
"color",
"The new color",
FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-entry-get-name
*/
procedure = gimp_procedure_new (palette_entry_get_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-entry-get-name");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-get-name",
"Gets the specified palette entry from the specified palette.",
"This procedure retrieves the name of the zero-based entry specified for the specified palette. It returns an error if the entry does not exist.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num",
"entry num",
"The entry to retrieve",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("entry-name",
"entry name",
"The name requested",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-palette-entry-set-name
*/
procedure = gimp_procedure_new (palette_entry_set_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-palette-entry-set-name");
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-set-name",
"Sets the specified palette entry in the specified palette.",
"This procedure sets the name of the zero-based entry specified for the specified palette. It returns an error if the entry does not exist.",
"Michael Natterer <*****@*****.**>",
"Michael Natterer",
"2004",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name",
"name",
"The palette name",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num",
"entry num",
"The entry to retrieve",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("entry-name",
"entry name",
"The new name",
FALSE, TRUE, FALSE,
NULL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
}