dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

added flag "guint static_name : 1" and new APIs 

2006-04-07  Michael Natterer  <mitch@gimp.org>

	* app/core/gimpobject.[ch]: added flag "guint static_name : 1" and
	new APIs gimp_object_set_static_name() and _take_name().

	* app/pdb/gimpprocedure.[ch]: removed member "name". Use
	GimpObject's name instead.

	* app/actions/plug-in-actions.c
	* app/file/file-open.c
	* app/file/file-save.c
	* app/menus/plug-in-menus.c
	* app/pdb/gimp-pdb-query.c
	* app/pdb/gimp-pdb.c
	* app/pdb/gimppluginprocedure.c
	* app/plug-in/plug-in-message.c
	* app/plug-in/plug-in-rc.c
	* app/plug-in/plug-ins-query.c
	* app/plug-in/plug-ins.c
	* app/xcf/xcf.c
	* tools/pdbgen/app.pl
	* tools/pdbgen/pdb/fileops.pdb: use GimpObject API to set/get
	a procedure's name.

	* app/pdb/*_cmds.c: regenerated.
This commit is contained in:
Michael Natterer 2006-04-07 10:04:27 +00:00 committed by Michael Natterer
parent cfd7233bc2
commit c03c336ccf
71 changed files with 690 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
ChangeLog
View File

@ -1,3 +1,29 @@
2006-04-07 Michael Natterer <mitch@gimp.org>
* app/core/gimpobject.[ch]: added flag "guint static_name : 1" and
new APIs gimp_object_set_static_name() and _take_name().
* app/pdb/gimpprocedure.[ch]: removed member "name". Use
GimpObject's name instead.
* app/actions/plug-in-actions.c
* app/file/file-open.c
* app/file/file-save.c
* app/menus/plug-in-menus.c
* app/pdb/gimp-pdb-query.c
* app/pdb/gimp-pdb.c
* app/pdb/gimppluginprocedure.c
* app/plug-in/plug-in-message.c
* app/plug-in/plug-in-rc.c
* app/plug-in/plug-ins-query.c
* app/plug-in/plug-ins.c
* app/xcf/xcf.c
* tools/pdbgen/app.pl
* tools/pdbgen/pdb/fileops.pdb: use GimpObject API to set/get
a procedure's name.
* app/pdb/*_cmds.c: regenerated.
2006-04-07 Sven Neumann <sven@gimp.org>
* app/core/gimpdrawable.[ch]: renamed gimp_drawable_shadow() to

10
app/actions/plug-in-actions.c
View File

@ -218,7 +218,7 @@ plug_in_actions_update (GimpActionGroup *group,
gboolean sensitive = gimp_plug_in_procedure_get_sensitive (proc, type);
gimp_action_group_set_action_sensitive (group,
GIMP_PROCEDURE (proc)->name,
GIMP_OBJECT (proc)->name,
sensitive);
}
}
@ -301,7 +301,7 @@ plug_in_actions_add_proc (GimpActionGroup *group,
if (GIMP_PROCEDURE (proc)->blurb)
tooltip = dgettext (locale_domain, GIMP_PROCEDURE (proc)->blurb);
entry.name = GIMP_PROCEDURE (proc)->name;
entry.name = GIMP_OBJECT (proc)->name;
entry.stock_id = gimp_plug_in_procedure_get_stock_id (proc);
entry.label = label;
entry.accelerator = NULL;
@ -311,7 +311,7 @@ plug_in_actions_add_proc (GimpActionGroup *group,
#if 0
g_print ("adding plug-in action '%s' (%s)\n",
GIMP_PROCEDURE (proc)->name, label);
GIMP_OBJECT (proc)->name, label);
#endif
gimp_action_group_add_plug_in_actions (group, &entry, 1,
@ -378,13 +378,13 @@ plug_in_actions_remove_proc (GimpActionGroup *group,
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
GIMP_PROCEDURE (proc)->name);
GIMP_OBJECT (proc)->name);
if (action)
{
#if 0
g_print ("removing plug-in action '%s'\n",
GIMP_PROCEDURE (proc)->name);
GIMP_OBJECT (proc)->name);
#endif
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);

44
app/core/gimpobject.c
View File

@ -169,7 +169,10 @@ gimp_object_get_property (GObject *object,
switch (property_id)
{
case PROP_NAME:
g_value_set_string (value, gimp_object->name);
if (gimp_object->static_name)
g_value_set_static_string (value, gimp_object->name);
else
g_value_set_string (value, gimp_object->name);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@ -198,6 +201,7 @@ gimp_object_set_name (GimpObject *object,
gimp_object_name_free (object);
object->name = g_strdup (name);
object->static_name = FALSE;
gimp_object_name_changed (object);
g_object_notify (G_OBJECT (object), "name");
@ -225,6 +229,37 @@ gimp_object_set_name_safe (GimpObject *object,
gimp_object_name_free (object);
object->name = gimp_utf8_strtrim (name, 30);
object->static_name = FALSE;
gimp_object_name_changed (object);
g_object_notify (G_OBJECT (object), "name");
}
void
gimp_object_set_static_name (GimpObject *object,
const gchar *name)
{
g_return_if_fail (GIMP_IS_OBJECT (object));
gimp_object_name_free (object);
object->name = (gchar *) name;
object->static_name = TRUE;
gimp_object_name_changed (object);
g_object_notify (G_OBJECT (object), "name");
}
void
gimp_object_take_name (GimpObject *object,
gchar *name)
{
g_return_if_fail (GIMP_IS_OBJECT (object));
gimp_object_name_free (object);
object->name = name;
object->static_name = FALSE;
gimp_object_name_changed (object);
g_object_notify (G_OBJECT (object), "name");
@ -286,8 +321,11 @@ gimp_object_name_free (GimpObject *object)
if (object->name)
{
g_free (object->name);
if (! object->static_name)
g_free (object->name);
object->name = NULL;
object->static_name = FALSE;
}
}
@ -420,7 +458,7 @@ gimp_object_real_get_memsize (GimpObject *object,
{
gint64 memsize = 0;
if (object->name)
if (object->name && ! object->static_name)
memsize += strlen (object->name) + 1;
return memsize + gimp_g_object_get_memsize ((GObject *) object);

29
app/core/gimpobject.h
View File

@ -38,6 +38,7 @@ struct _GimpObject
/*< private >*/
gchar *normalized;
guint static_name : 1;
};
struct _GimpObjectClass
@ -54,20 +55,24 @@ struct _GimpObjectClass
};
GType gimp_object_get_type (void) G_GNUC_CONST;
GType gimp_object_get_type (void) G_GNUC_CONST;
void gimp_object_set_name (GimpObject *object,
const gchar *name);
const gchar * gimp_object_get_name (const GimpObject *object);
void gimp_object_set_name_safe (GimpObject *object,
const gchar *name);
void gimp_object_name_changed (GimpObject *object);
void gimp_object_name_free (GimpObject *object);
void gimp_object_set_name (GimpObject *object,
const gchar *name);
void gimp_object_set_name_safe (GimpObject *object,
const gchar *name);
void gimp_object_set_static_name (GimpObject *object,
const gchar *name);
void gimp_object_take_name (GimpObject *object,
gchar *name);
const gchar * gimp_object_get_name (const GimpObject *object);
void gimp_object_name_changed (GimpObject *object);
void gimp_object_name_free (GimpObject *object);
gint gimp_object_name_collate (GimpObject *object1,
GimpObject *object2);
gint64 gimp_object_get_memsize (GimpObject *object,
gint64 *gui_size);
gint gimp_object_name_collate (GimpObject *object1,
GimpObject *object2);
gint64 gimp_object_get_memsize (GimpObject *object,
gint64 *gui_size);
#endif /* __GIMP_OBJECT_H__ */

4
app/file/file-open.c
View File

@ -135,7 +135,7 @@ file_open_image (Gimp *gimp,
}
return_vals = gimp_pdb_run_proc (gimp, context, progress,
GIMP_PROCEDURE (file_proc)->name,
GIMP_OBJECT (file_proc)->name,
GIMP_TYPE_INT32, run_mode,
G_TYPE_STRING, filename,
G_TYPE_STRING, entered_filename,
@ -219,7 +219,7 @@ file_open_thumbnail (Gimp *gimp,
filename = g_strdup (uri);
return_vals = gimp_pdb_run_proc (gimp, context, progress,
procedure->name,
GIMP_OBJECT (procedure)->name,
G_TYPE_STRING, filename,
GIMP_TYPE_INT32, size,
G_TYPE_NONE);

2
app/file/file-save.c
View File

@ -126,7 +126,7 @@ file_save (GimpImage *image,
g_object_ref (image);
return_vals = gimp_pdb_run_proc (image->gimp, context, progress,
GIMP_PROCEDURE (file_proc)->name,
GIMP_OBJECT (file_proc)->name,
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID, gimp_image_get_ID (image),
GIMP_TYPE_DRAWABLE_ID, gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (image))),

10
app/menus/plug-in-menus.c
View File

@ -266,7 +266,7 @@ plug_in_menus_add_proc (GimpUIManager *manager,
*p = '\0';
}
merge_key = g_strdup_printf ("%s-merge-id", GIMP_PROCEDURE (proc)->name);
merge_key = g_strdup_printf ("%s-merge-id", GIMP_OBJECT (proc)->name);
merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
@ -303,13 +303,13 @@ plug_in_menus_add_proc (GimpUIManager *manager,
#if 0
g_print ("adding menu item for '%s' (@ %s)\n",
GIMP_PROCEDURE (proc)->name, action_path);
GIMP_OBJECT (proc)->name, action_path);
#endif
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path,
GIMP_PROCEDURE (proc)->name,
GIMP_PROCEDURE (proc)->name,
GIMP_OBJECT (proc)->name,
GIMP_OBJECT (proc)->name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
@ -327,7 +327,7 @@ plug_in_menus_remove_proc (GimpUIManager *manager,
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
merge_key = g_strdup_printf ("%s-merge-id", GIMP_PROCEDURE (proc)->name);
merge_key = g_strdup_printf ("%s-merge-id", GIMP_OBJECT (proc)->name);
merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
g_free (merge_key);

44
app/pdb/brush_cmds.c
View File

@ -870,8 +870,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-new
*/
procedure = gimp_procedure_new (brush_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-new");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-new",
"gimp-brush-new",
"Creates a new brush",
"This procedure creates a new, uninitialized brush",
@ -901,8 +901,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-duplicate
*/
procedure = gimp_procedure_new (brush_duplicate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-duplicate");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-duplicate",
"gimp-brush-duplicate",
"Duplicates a brush",
"This procedure creates an identical brush by a different name",
@ -932,8 +932,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-is-generated
*/
procedure = gimp_procedure_new (brush_is_generated_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-is-generated");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-is-generated",
"gimp-brush-is-generated",
"Tests if brush is generated",
"Returns TRUE if this brush is parametric, FALSE for other types",
@ -962,8 +962,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-rename
*/
procedure = gimp_procedure_new (brush_rename_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-rename");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-rename",
"gimp-brush-rename",
"Rename a brush",
"This procedure renames a brush",
@ -1000,8 +1000,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-delete
*/
procedure = gimp_procedure_new (brush_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-delete",
"gimp-brush-delete",
"Deletes a brush",
"This procedure deletes a brush",
@ -1024,8 +1024,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-is-editable
*/
procedure = gimp_procedure_new (brush_is_editable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-is-editable");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-is-editable",
"gimp-brush-is-editable",
"Tests if brush can be edited",
"Returns TRUE if you have permission to change the brush",
@ -1054,8 +1054,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-info
*/
procedure = gimp_procedure_new (brush_get_info_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-info");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-info",
"gimp-brush-get-info",
"Retrieve information about the specified brush.",
"This procedure retrieves information about the specified brush. This includes the brush name, and the brush extents (width and height).",
@ -1102,8 +1102,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-pixels
*/
procedure = gimp_procedure_new (brush_get_pixels_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-pixels");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-pixels",
"gimp-brush-get-pixels",
"Retrieve information about the specified brush.",
"This procedure retrieves information about the specified brush. This includes the brush extents (width and height) and its pixels data.",
@ -1172,8 +1172,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-spacing
*/
procedure = gimp_procedure_new (brush_get_spacing_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-spacing");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-spacing",
"gimp-brush-get-spacing",
"Get the brush spacing.",
"This procedure returns the spacing setting for the specified brush. The return value is an integer between 0 and 1000 which represents percentage of the maximum of the width and height of the mask.",
@ -1202,8 +1202,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-spacing
*/
procedure = gimp_procedure_new (brush_set_spacing_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-spacing");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-spacing",
"gimp-brush-set-spacing",
"Set the brush spacing.",
"This procedure modifies the spacing setting for the specified brush. The value should be a integer between 0 and 1000.",
@ -1232,8 +1232,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-shape
*/
procedure = gimp_procedure_new (brush_get_shape_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-shape");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-shape",
"gimp-brush-get-shape",
"Get the shape of a generated brush.",
"This procedure gets the shape value for a generated brush. If called for any other type of brush, it does not succeed. The current possibilities are Circle (GIMP_BRUSH_GENERATED_CIRCLE), Square (GIMP_BRUSH_GENERATED_SQUARE), and Diamond (GIMP_BRUSH_GENERATED_DIAMOND). Other shapes are likely to be added in the future.",
@ -1263,8 +1263,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-radius
*/
procedure = gimp_procedure_new (brush_get_radius_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-radius");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-radius",
"gimp-brush-get-radius",
"Get the radius of a generated brush.",
"This procedure gets the radius value for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1293,8 +1293,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-spikes
*/
procedure = gimp_procedure_new (brush_get_spikes_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-spikes");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-spikes",
"gimp-brush-get-spikes",
"Get the number of spikes for a generated brush.",
"This procedure gets the number of spikes for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1323,8 +1323,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-hardness
*/
procedure = gimp_procedure_new (brush_get_hardness_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-hardness");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-hardness",
"gimp-brush-get-hardness",
"Get the hardness of a generated brush.",
"This procedure gets the hardness of a generated brush. The hardness of a brush is the amount its intensity fades at the outside edge. If called for any other type of brush, the function does not succeed.",
@ -1353,8 +1353,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-aspect-ratio
*/
procedure = gimp_procedure_new (brush_get_aspect_ratio_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-aspect-ratio");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-aspect-ratio",
"gimp-brush-get-aspect-ratio",
"Get the aspect ratio of a generated brush.",
"This procedure gets the aspect ratio of a generated brush. If called for any other type of brush, it does not succeed.",
@ -1383,8 +1383,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-get-angle
*/
procedure = gimp_procedure_new (brush_get_angle_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-get-angle");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-angle",
"gimp-brush-get-angle",
"Get the rotation angle of a generated brush.",
"This procedure gets the angle of rotation for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1413,8 +1413,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-shape
*/
procedure = gimp_procedure_new (brush_set_shape_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-shape");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-shape",
"gimp-brush-set-shape",
"Set the shape of a generated brush.",
"This procedure sets the shape value for a generated brush. If called for any other type of brush, it does not succeed. The current possibilities are Circle (GIMP_BRUSH_GENERATED_CIRCLE), Square (GIMP_BRUSH_GENERATED_SQUARE), and Diamond (GIMP_BRUSH_GENERATED_DIAMOND). Other shapes are likely to be added in the future.",
@ -1451,8 +1451,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-radius
*/
procedure = gimp_procedure_new (brush_set_radius_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-radius");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-radius",
"gimp-brush-set-radius",
"Set the radius of a generated brush.",
"This procedure sets the radius for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1487,8 +1487,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-spikes
*/
procedure = gimp_procedure_new (brush_set_spikes_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-spikes");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-spikes",
"gimp-brush-set-spikes",
"Set the number of spikes for a generated brush.",
"This procedure sets the number of spikes for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1523,8 +1523,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-hardness
*/
procedure = gimp_procedure_new (brush_set_hardness_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-hardness");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-hardness",
"gimp-brush-set-hardness",
"Set the hardness of a generated brush.",
"This procedure sets the hardness for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1559,8 +1559,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-aspect-ratio
*/
procedure = gimp_procedure_new (brush_set_aspect_ratio_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-aspect-ratio");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-aspect-ratio",
"gimp-brush-set-aspect-ratio",
"Set the aspect ratio of a generated brush.",
"This procedure sets the aspect ratio for a generated brush. If called for any other type of brush, it does not succeed.",
@ -1595,8 +1595,8 @@ register_brush_procs (Gimp *gimp)
* gimp-brush-set-angle
*/
procedure = gimp_procedure_new (brush_set_angle_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brush-set-angle");
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-angle",
"gimp-brush-set-angle",
"Set the rotation angle of a generated brush.",
"This procedure sets the rotation angle for a generated brush. If called for any other type of brush, it does not succeed.",

6
app/pdb/brush_select_cmds.c
View File

@ -139,8 +139,8 @@ register_brush_select_procs (Gimp *gimp)
* gimp-brushes-popup
*/
procedure = gimp_procedure_new (brushes_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-popup",
"gimp-brushes-popup",
"Invokes the Gimp brush selection.",
"This procedure popups the brush selection dialog.",
@ -196,8 +196,8 @@ register_brush_select_procs (Gimp *gimp)
* gimp-brushes-close-popup
*/
procedure = gimp_procedure_new (brushes_close_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-close-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-close-popup",
"gimp-brushes-close-popup",
"Popdown the Gimp brush selection.",
"This procedure closes an opened brush selection dialog.",
@ -220,8 +220,8 @@ register_brush_select_procs (Gimp *gimp)
* gimp-brushes-set-popup
*/
procedure = gimp_procedure_new (brushes_set_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brushes-set-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-set-popup",
"gimp-brushes-set-popup",
"Sets the current brush selection in a popup.",
"Sets the current brush selection in a popup.",

12
app/pdb/brushes_cmds.c
View File

@ -242,8 +242,8 @@ register_brushes_procs (Gimp *gimp)
* 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",
"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.",
@ -259,8 +259,8 @@ register_brushes_procs (Gimp *gimp)
* 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",
"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.",
@ -294,8 +294,8 @@ register_brushes_procs (Gimp *gimp)
* 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",
"gimp-brushes-get-brush",
"This procedure is deprecated! Use 'gimp-context-get-brush' instead.",
"This procedure is deprecated! Use 'gimp-context-get-brush' instead.",
@ -336,8 +336,8 @@ register_brushes_procs (Gimp *gimp)
* 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",
"gimp-brushes-get-spacing",
"This procedure is deprecated! Use 'gimp-brush-get-spacing' instead.",
"This procedure is deprecated! Use 'gimp-brush-get-spacing' instead.",
@ -359,8 +359,8 @@ register_brushes_procs (Gimp *gimp)
* 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",
"gimp-brushes-set-spacing",
"This procedure is deprecated! Use 'gimp-brush-set-spacing' instead.",
"This procedure is deprecated! Use 'gimp-brush-set-spacing' instead.",
@ -382,8 +382,8 @@ register_brushes_procs (Gimp *gimp)
* 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",
"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.",

14
app/pdb/buffer_cmds.c
View File

@ -273,8 +273,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffers-get-list",
"Retrieve a complete listing of the available buffers.",
"This procedure returns a complete listing of available named buffers.",
@ -308,8 +308,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffer-rename",
"Renames a named buffer.",
"This procedure renames a named buffer.",
@ -346,8 +346,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffer-delete",
"Deletes a named buffer.",
"This procedure deletes a named buffer.",
@ -370,8 +370,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffer-get-width",
"Retrieves the specified buffer's width.",
"This procedure retrieves the specified named buffer's width.",
@ -400,8 +400,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffer-get-height",
"Retrieves the specified buffer's height.",
"This procedure retrieves the specified named buffer's height.",
@ -430,8 +430,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffer-get-bytes",
"Retrieves the specified buffer's bytes.",
"This procedure retrieves the specified named buffer's bytes.",
@ -460,8 +460,8 @@ register_buffer_procs (Gimp *gimp)
* 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",
"gimp-buffer-get-image-type",
"Retrieves the specified buffer's image type.",
"This procedure retrieves the specified named buffer's image type.",

20
app/pdb/channel_cmds.c
View File

@ -334,8 +334,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"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.",
@ -394,8 +394,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-new-from-component",
"Create a new channel from a color component",
"This procedure creates a new channel from a color component.",
@ -437,8 +437,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-copy",
"Copy a channel.",
"This procedure copies the specified channel and returns the copy.",
@ -466,8 +466,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-combine-masks",
"Combine two channel masks.",
"This procedure combines two channel masks. The result is stored in the first channel.",
@ -514,8 +514,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"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.",
@ -543,8 +543,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"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.",
@ -572,8 +572,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-get-opacity",
"Get the opacity of the specified channel.",
"This procedure returns the specified channel's opacity.",
@ -601,8 +601,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-set-opacity",
"Set the opacity of the specified channel.",
"This procedure sets the specified channel's opacity.",
@ -630,8 +630,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-get-color",
"Get the compositing color of the specified channel.",
"This procedure returns the specified channel's compositing color.",
@ -659,8 +659,8 @@ register_channel_procs (Gimp *gimp)
* 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",
"gimp-channel-set-color",
"Set the compositing color of the specified channel.",
"This procedure sets the specified channel's compositing color.",

32
app/pdb/color_cmds.c
View File

@ -840,8 +840,8 @@ register_color_procs (Gimp *gimp)
* gimp-brightness-contrast
*/
procedure = gimp_procedure_new (brightness_contrast_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-brightness-contrast");
gimp_procedure_set_static_strings (procedure,
"gimp-brightness-contrast",
"gimp-brightness-contrast",
"Modify brightness/contrast in the specified drawable.",
"This procedures allows the brightness and contrast of the specified drawable to be modified. Both 'brightness' and 'contrast' parameters are defined between -127 and 127.",
@ -875,8 +875,8 @@ register_color_procs (Gimp *gimp)
* gimp-levels
*/
procedure = gimp_procedure_new (levels_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-levels");
gimp_procedure_set_static_strings (procedure,
"gimp-levels",
"gimp-levels",
"Modifies intensity levels in the specified drawable.",
"This tool allows intensity levels in the specified drawable to be remapped according to a set of parameters. The low/high input levels specify an initial mapping from the source intensities. The gamma value determines how intensities between the low and high input intensities are interpolated. A gamma value of 1.0 results in a linear interpolation. Higher gamma values result in more high-level intensities. Lower gamma values result in more low-level intensities. The low/high output levels constrain the final intensity mapping--that is, no final intensity will be lower than the low output level and no final intensity will be higher than the high output level. This tool is only valid on RGB color and grayscale images. It will not operate on indexed drawables.",
@ -935,8 +935,8 @@ register_color_procs (Gimp *gimp)
* gimp-levels-auto
*/
procedure = gimp_procedure_new (levels_auto_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-levels-auto");
gimp_procedure_set_static_strings (procedure,
"gimp-levels-auto",
"gimp-levels-auto",
"This procedure is deprecated! Use 'gimp_levels_stretch' instead.",
"This procedure is deprecated! Use 'gimp_levels_stretch' instead.",
@ -958,8 +958,8 @@ register_color_procs (Gimp *gimp)
* gimp-levels-stretch
*/
procedure = gimp_procedure_new (levels_stretch_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-levels-stretch");
gimp_procedure_set_static_strings (procedure,
"gimp-levels-stretch",
"gimp-levels-stretch",
"Automatically modifies intensity levels in the specified drawable.",
"This procedure allows intensity levels in the specified drawable to be remapped according to a set of guessed parameters. It is equivalent to clicking the \"Auto\" button in the Levels tool. This procedure is only valid on RGB color and grayscale images. It will not operate on indexed drawables.",
@ -981,8 +981,8 @@ register_color_procs (Gimp *gimp)
* gimp-posterize
*/
procedure = gimp_procedure_new (posterize_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-posterize");
gimp_procedure_set_static_strings (procedure,
"gimp-posterize",
"gimp-posterize",
"Posterize the specified drawable.",
"This procedures reduces the number of shades allows in each intensity channel to the specified 'levels' parameter.",
@ -1010,8 +1010,8 @@ register_color_procs (Gimp *gimp)
* gimp-desaturate
*/
procedure = gimp_procedure_new (desaturate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-desaturate");
gimp_procedure_set_static_strings (procedure,
"gimp-desaturate",
"gimp-desaturate",
"Desaturate the contents of the specified drawable.",
"This procedure desaturates the contents of the specified drawable. This procedure only works on drawables of type RGB color.",
@ -1033,8 +1033,8 @@ register_color_procs (Gimp *gimp)
* gimp-desaturate-full
*/
procedure = gimp_procedure_new (desaturate_full_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-desaturate-full");
gimp_procedure_set_static_strings (procedure,
"gimp-desaturate-full",
"gimp-desaturate-full",
"Desaturate the contents of the specified drawable, with the specified formula.",
"This procedure desaturates the contents of the specified drawable, with the specified formula. This procedure only works on drawables of type RGB color.",
@ -1063,8 +1063,8 @@ register_color_procs (Gimp *gimp)
* gimp-equalize
*/
procedure = gimp_procedure_new (equalize_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-equalize");
gimp_procedure_set_static_strings (procedure,
"gimp-equalize",
"gimp-equalize",
"Equalize the contents of the specified drawable.",
"This procedure equalizes the contents of the specified drawable. Each intensity channel is equalizeed independently. The equalized intensity is given as inten' = (255 - inten). Indexed color drawables are not valid for this operation. The 'mask_only' option specifies whether to adjust only the area of the image within the selection bounds, or the entire image based on the histogram of the selected area. If there is no selection, the entire image is adjusted based on the histogram for the entire image.",
@ -1092,8 +1092,8 @@ register_color_procs (Gimp *gimp)
* gimp-invert
*/
procedure = gimp_procedure_new (invert_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-invert");
gimp_procedure_set_static_strings (procedure,
"gimp-invert",
"gimp-invert",
"Invert the contents of the specified drawable.",
"This procedure inverts the contents of the specified drawable. Each intensity channel is inverted independently. The inverted intensity is given as inten' = (255 - inten). Indexed color drawables are not valid for this operation.",
@ -1115,8 +1115,8 @@ register_color_procs (Gimp *gimp)
* gimp-curves-spline
*/
procedure = gimp_procedure_new (curves_spline_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-curves-spline");
gimp_procedure_set_static_strings (procedure,
"gimp-curves-spline",
"gimp-curves-spline",
"Modifies the intensity curve(s) for specified drawable.",
"Modifies the intensity mapping for one channel in the specified drawable. The drawable must be either grayscale or RGB, and the channel can be either an intensity component, or the value. The 'control_pts' parameter is an array of integers which define a set of control points which describe a Catmull Rom spline which yields the final intensity curve. Use the 'gimp_curves_explicit' function to explicitly modify intensity levels.",
@ -1156,8 +1156,8 @@ register_color_procs (Gimp *gimp)
* gimp-curves-explicit
*/
procedure = gimp_procedure_new (curves_explicit_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-curves-explicit");
gimp_procedure_set_static_strings (procedure,
"gimp-curves-explicit",
"gimp-curves-explicit",
"Modifies the intensity curve(s) for specified drawable.",
"Modifies the intensity mapping for one channel in the specified drawable. The drawable must be either grayscale or RGB, and the channel can be either an intensity component, or the value. The 'curve' parameter is an array of bytes which explicitly defines how each pixel value in the drawable will be modified. Use the 'gimp_curves_spline' function to modify intensity levels with Catmull Rom splines.",
@ -1197,8 +1197,8 @@ register_color_procs (Gimp *gimp)
* gimp-color-balance
*/
procedure = gimp_procedure_new (color_balance_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-color-balance");
gimp_procedure_set_static_strings (procedure,
"gimp-color-balance",
"gimp-color-balance",
"Modify the color balance of the specified drawable.",
"Modify the color balance of the specified drawable. There are three axis which can be modified: cyan-red, magenta-green, and yellow-blue. Negative values increase the amount of the former, positive values increase the amount of the latter. Color balance can be controlled with the 'transfer_mode' setting, which allows shadows, midtones, and highlights in an image to be affected differently. The 'preserve_lum' parameter, if TRUE, ensures that the luminosity of each pixel remains fixed.",
@ -1251,8 +1251,8 @@ register_color_procs (Gimp *gimp)
* gimp-colorize
*/
procedure = gimp_procedure_new (colorize_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-colorize");
gimp_procedure_set_static_strings (procedure,
"gimp-colorize",
"gimp-colorize",
"Render the drawable as a grayscale image seen through a colored glass.",
"Desatures the drawable, then tints it with the specified color. This tool is only valid on RGB color images. It will not operate on grayscale or indexed drawables.",
@ -1292,8 +1292,8 @@ register_color_procs (Gimp *gimp)
* gimp-histogram
*/
procedure = gimp_procedure_new (histogram_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-histogram");
gimp_procedure_set_static_strings (procedure,
"gimp-histogram",
"gimp-histogram",
"Returns information on the intensity histogram for the specified drawable.",
"This tool makes it possible to gather information about the intensity histogram of a drawable. A channel to examine is first specified. This can be either value, red, green, or blue, depending on whether the drawable is of type color or grayscale. The drawable may not be indexed. Second, a range of intensities are specified. The gimp_histogram function returns statistics based on the pixels in the drawable that fall under this range of values. Mean, standard deviation, median, number of pixels, and percentile are all returned. Additionally, the total count of pixels in the image is returned. Counts of pixels are weighted by any associated alpha values and by the current selection mask. That is, pixels that lie outside an active selection mask will not be counted. Similarly, pixels with transparent alpha values will not be counted.",
@ -1370,8 +1370,8 @@ register_color_procs (Gimp *gimp)
* gimp-hue-saturation
*/
procedure = gimp_procedure_new (hue_saturation_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-hue-saturation");
gimp_procedure_set_static_strings (procedure,
"gimp-hue-saturation",
"gimp-hue-saturation",
"Modify hue, lightness, and saturation in the specified drawable.",
"This procedures allows the hue, lightness, and saturation in the specified drawable to be modified. The 'hue_range' parameter provides the capability to limit range of affected hues.",
@ -1418,8 +1418,8 @@ register_color_procs (Gimp *gimp)
* gimp-threshold
*/
procedure = gimp_procedure_new (threshold_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-threshold");
gimp_procedure_set_static_strings (procedure,
"gimp-threshold",
"gimp-threshold",
"Threshold the specified drawable.",
"This procedures generates a threshold map of the specified drawable. All pixels between the values of 'low_threshold' and 'high_threshold' are replaced with white, and all other pixels with black.",

48
app/pdb/context_cmds.c
View File

@ -565,8 +565,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-push
*/
procedure = gimp_procedure_new (context_push_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-push");
gimp_procedure_set_static_strings (procedure,
"gimp-context-push",
"gimp-context-push",
"Pushes a context to the top of the plug-in's context stack.",
"This procedure creates a new context by copying the current context. This copy becomes the new current context for the calling plug-in until it is popped again using gimp-context-pop.",
@ -582,8 +582,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-pop
*/
procedure = gimp_procedure_new (context_pop_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-pop");
gimp_procedure_set_static_strings (procedure,
"gimp-context-pop",
"gimp-context-pop",
"Pops the topmost context from the plug-in's context stack.",
"This procedure removes the topmost context from the plug-in's context stack. The context that was active before the corresponding call to gimp-context-push becomes the new current context of the plug-in.",
@ -599,8 +599,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-paint-method
*/
procedure = gimp_procedure_new (context_get_paint_method_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-paint-method");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-paint-method",
"gimp-context-get-paint-method",
"Retrieve the currently active paint method.",
"This procedure returns the name of the currently active paint method.",
@ -623,8 +623,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-paint-method
*/
procedure = gimp_procedure_new (context_set_paint_method_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-paint-method");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-paint-method",
"gimp-context-set-paint-method",
"Set the specified paint method as the active paint method.",
"This procedure allows the active paint method to be set by specifying its name. The name is simply a string which corresponds to one of the names of the available paint methods. If there is no matching method found, this procedure will return an error. Otherwise, the specified method becomes active and will be used in all subsequent paint operations.",
@ -647,8 +647,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-foreground
*/
procedure = gimp_procedure_new (context_get_foreground_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-foreground");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-foreground",
"gimp-context-get-foreground",
"Get the current GIMP foreground color.",
"This procedure returns the current GIMP foreground color. The foreground color is used in a variety of tools such as paint tools, blending, and bucket fill.",
@ -670,8 +670,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-foreground
*/
procedure = gimp_procedure_new (context_set_foreground_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-foreground");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-foreground",
"gimp-context-set-foreground",
"Set the current GIMP foreground color.",
"This procedure sets the current GIMP foreground color. After this is set, operations which use foreground such as paint tools, blending, and bucket fill will use the new value.",
@ -693,8 +693,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-background
*/
procedure = gimp_procedure_new (context_get_background_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-background");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-background",
"gimp-context-get-background",
"Get the current GIMP background color.",
"This procedure returns the current GIMP background color. The background color is used in a variety of tools such as blending, erasing (with non-alpha images), and image filling.",
@ -716,8 +716,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-background
*/
procedure = gimp_procedure_new (context_set_background_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-background");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-background",
"gimp-context-set-background",
"Set the current GIMP background color.",
"This procedure sets the current GIMP background color. After this is set, operations which use background such as blending, filling images, clearing, and erasing (in non-alpha images) will use the new value.",
@ -739,8 +739,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-default-colors
*/
procedure = gimp_procedure_new (context_set_default_colors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-default-colors");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-default-colors",
"gimp-context-set-default-colors",
"Set the current GIMP foreground and background colors to black and white.",
"This procedure sets the current GIMP foreground and background colors to their initial default values, black and white.",
@ -756,8 +756,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-swap-colors
*/
procedure = gimp_procedure_new (context_swap_colors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-swap-colors");
gimp_procedure_set_static_strings (procedure,
"gimp-context-swap-colors",
"gimp-context-swap-colors",
"Swap the current GIMP foreground and background colors.",
"This procedure swaps the current GIMP foreground and background colors, so that the new foreground color becomes the old background color and vice versa.",
@ -773,8 +773,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-opacity
*/
procedure = gimp_procedure_new (context_get_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-opacity",
"gimp-context-get-opacity",
"Get the opacity.",
"This procedure returns the opacity setting. The return value is a floating point number between 0 and 100.",
@ -796,8 +796,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-opacity
*/
procedure = gimp_procedure_new (context_set_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-opacity",
"gimp-context-set-opacity",
"Set the opacity.",
"This procedure modifies the opacity setting. The value should be a floating point number between 0 and 100.",
@ -819,8 +819,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-paint-mode
*/
procedure = gimp_procedure_new (context_get_paint_mode_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-paint-mode");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-paint-mode",
"gimp-context-get-paint-mode",
"Get the paint mode.",
"This procedure returns the paint-mode setting. The return value is an integer which corresponds to the values listed in the argument description.",
@ -843,8 +843,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-paint-mode
*/
procedure = gimp_procedure_new (context_set_paint_mode_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-paint-mode");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-paint-mode",
"gimp-context-set-paint-mode",
"Set the paint mode.",
"This procedure modifies the paint_mode setting.",
@ -867,8 +867,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-brush
*/
procedure = gimp_procedure_new (context_get_brush_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-brush");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-brush",
"gimp-context-get-brush",
"Retrieve the currently active brush.",
"This procedure returns the name of the currently active brush. All paint operations and stroke operations use this brush to control the application of paint to the image.",
@ -891,8 +891,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-brush
*/
procedure = gimp_procedure_new (context_set_brush_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-brush");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-brush",
"gimp-context-set-brush",
"Set the specified brush as the active brush.",
"This procedure allows the active brush to be set by specifying its name. The name is simply a string which corresponds to one of the names of the installed brushes. If there is no matching brush found, this procedure will return an error. Otherwise, the specified brush becomes active and will be used in all subsequent paint operations.",
@ -915,8 +915,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-pattern
*/
procedure = gimp_procedure_new (context_get_pattern_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-pattern");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-pattern",
"gimp-context-get-pattern",
"Retrieve the currently active pattern.",
"This procedure returns name of the the currently active pattern. All clone and bucket-fill operations with patterns will use this pattern to control the application of paint to the image.",
@ -939,8 +939,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-pattern
*/
procedure = gimp_procedure_new (context_set_pattern_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-pattern");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-pattern",
"gimp-context-set-pattern",
"Set the specified pattern as the active pattern.",
"This procedure allows the active pattern to be set by specifying its name. The name is simply a string which corresponds to one of the names of the installed patterns. If there is no matching pattern found, this procedure will return an error. Otherwise, the specified pattern becomes active and will be used in all subsequent paint operations.",
@ -963,8 +963,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-gradient
*/
procedure = gimp_procedure_new (context_get_gradient_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-gradient");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-gradient",
"gimp-context-get-gradient",
"Retrieve the currently active gradient.",
"This procedure returns the name of the currently active gradient.",
@ -987,8 +987,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-gradient
*/
procedure = gimp_procedure_new (context_set_gradient_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-gradient");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-gradient",
"gimp-context-set-gradient",
"Sets the specified gradient as the active gradient.",
"This procedure lets you set the specified gradient as the active or \"current\" one. The name is simply a string which corresponds to one of the loaded gradients. If no matching gradient is found, this procedure will return an error. Otherwise, the specified gradient will become active and will be used for subsequent custom gradient operations.",
@ -1011,8 +1011,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-palette
*/
procedure = gimp_procedure_new (context_get_palette_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-palette");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-palette",
"gimp-context-get-palette",
"Retrieve the currently active palette.",
"This procedure returns the name of the the currently active palette.",
@ -1035,8 +1035,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-palette
*/
procedure = gimp_procedure_new (context_set_palette_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-palette");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-palette",
"gimp-context-set-palette",
"Set the specified palette as the active palette.",
"This procedure allows the active palette to be set by specifying its name. The name is simply a string which corresponds to one of the names of the installed palettes. If no matching palette is found, this procedure will return an error. Otherwise, the specified palette becomes active and will be used in all subsequent palette operations.",
@ -1059,8 +1059,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-get-font
*/
procedure = gimp_procedure_new (context_get_font_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-get-font");
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-font",
"gimp-context-get-font",
"Retrieve the currently active font.",
"This procedure returns the name of the currently active font.",
@ -1083,8 +1083,8 @@ register_context_procs (Gimp *gimp)
* gimp-context-set-font
*/
procedure = gimp_procedure_new (context_set_font_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-context-set-font");
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-font",
"gimp-context-set-font",
"Set the specified font as the active font.",
"This procedure allows the active font to be set by specifying its name. The name is simply a string which corresponds to one of the names of the installed fonts. If no matching font is found, this procedure will return an error. Otherwise, the specified font becomes active and will be used in all subsequent font operations.",

6
app/pdb/convert_cmds.c
View File

@ -152,8 +152,8 @@ register_convert_procs (Gimp *gimp)
* 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",
"gimp-image-convert-rgb",
"Convert specified image to RGB color",
"This procedure converts the specified image to RGB color. This process requires an image of type GIMP_GRAY or GIMP_INDEXED. No image content is lost in this process aside from the colormap for an indexed image.",
@ -175,8 +175,8 @@ register_convert_procs (Gimp *gimp)
* 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",
"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 of type GIMP_RGB or GIMP_INDEXED.",
@ -198,8 +198,8 @@ register_convert_procs (Gimp *gimp)
* 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",
"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 of type GIMP_GRAY or GIMP_RGB. 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).",

10
app/pdb/display_cmds.c
View File

@ -169,8 +169,8 @@ register_display_procs (Gimp *gimp)
* 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",
"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 the 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.",
@ -198,8 +198,8 @@ register_display_procs (Gimp *gimp)
* 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",
"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.",
@ -221,8 +221,8 @@ register_display_procs (Gimp *gimp)
* 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",
"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.",
@ -250,8 +250,8 @@ register_display_procs (Gimp *gimp)
* 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",
"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.",
@ -267,8 +267,8 @@ register_display_procs (Gimp *gimp)
* 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",
"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.",

70
app/pdb/drawable_cmds.c
View File

@ -1162,8 +1162,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-delete
*/
procedure = gimp_procedure_new (drawable_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-delete",
"gimp-drawable-delete",
"Delete a drawable.",
"This procedure deletes the specified drawable. This must not be done if the image containing this drawable was already deleted or if the drawable was already removed from the image. The only case in which this procedure is useful is if you want to get rid of a drawable which has not yet been added to an image.",
@ -1185,8 +1185,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-is-layer
*/
procedure = gimp_procedure_new (drawable_is_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-is-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-layer",
"gimp-drawable-is-layer",
"Returns whether the drawable is a layer.",
"This procedure returns TRUE if the specified drawable is a layer.",
@ -1214,8 +1214,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-is-layer-mask
*/
procedure = gimp_procedure_new (drawable_is_layer_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-is-layer-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-layer-mask",
"gimp-drawable-is-layer-mask",
"Returns whether the drawable is a layer mask.",
"This procedure returns TRUE if the specified drawable is a layer mask.",
@ -1243,8 +1243,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-is-channel
*/
procedure = gimp_procedure_new (drawable_is_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-is-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-channel",
"gimp-drawable-is-channel",
"Returns whether the drawable is a channel.",
"This procedure returns TRUE if the specified drawable is a channel.",
@ -1272,8 +1272,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-type
*/
procedure = gimp_procedure_new (drawable_type_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-type");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-type",
"gimp-drawable-type",
"Returns the drawable's type.",
"This procedure returns the drawable's type.",
@ -1302,8 +1302,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-type-with-alpha
*/
procedure = gimp_procedure_new (drawable_type_with_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-type-with-alpha");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-type-with-alpha",
"gimp-drawable-type-with-alpha",
"Returns the drawable's type with alpha.",
"This procedure returns the drawable's type as if had an alpha channel. If the type is currently Gray, for instance, the returned type would be GrayA. If the drawable already has an alpha channel, the drawable's type is simply returned.",
@ -1338,8 +1338,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-has-alpha
*/
procedure = gimp_procedure_new (drawable_has_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-has-alpha");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-has-alpha",
"gimp-drawable-has-alpha",
"Returns TRUE if the drawable has an alpha channel.",
"This procedure returns whether the specified drawable has an alpha channel. This can only be true for layers, and the associated type will be one of: { RGBA , GRAYA, INDEXEDA }.",
@ -1367,8 +1367,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-is-rgb
*/
procedure = gimp_procedure_new (drawable_is_rgb_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-is-rgb");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-rgb",
"gimp-drawable-is-rgb",
"Returns whether the drawable is an RGB type.",
"This procedure returns TRUE if the specified drawable is of type { RGB, RGBA }.",
@ -1396,8 +1396,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-is-gray
*/
procedure = gimp_procedure_new (drawable_is_gray_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-is-gray");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-gray",
"gimp-drawable-is-gray",
"Returns whether the drawable is a grayscale type.",
"This procedure returns TRUE if the specified drawable is of type { Gray, GrayA }.",
@ -1425,8 +1425,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-is-indexed
*/
procedure = gimp_procedure_new (drawable_is_indexed_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-is-indexed");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-indexed",
"gimp-drawable-is-indexed",
"Returns whether the drawable is an indexed type.",
"This procedure returns TRUE if the specified drawable is of type { Indexed, IndexedA }.",
@ -1454,8 +1454,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-bpp
*/
procedure = gimp_procedure_new (drawable_bpp_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-bpp");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-bpp",
"gimp-drawable-bpp",
"Returns the bytes per pixel.",
"This procedure returns the number of bytes per pixel (or the number of channels) for the specified drawable.",
@ -1483,8 +1483,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-width
*/
procedure = gimp_procedure_new (drawable_width_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-width");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-width",
"gimp-drawable-width",
"Returns the width of the drawable.",
"This procedure returns the specified drawable's width in pixels.",
@ -1512,8 +1512,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-height
*/
procedure = gimp_procedure_new (drawable_height_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-height");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-height",
"gimp-drawable-height",
"Returns the height of the drawable.",
"This procedure returns the specified drawable's height in pixels.",
@ -1541,8 +1541,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-offsets
*/
procedure = gimp_procedure_new (drawable_offsets_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-offsets");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-offsets",
"gimp-drawable-offsets",
"Returns the offsets for the drawable.",
"This procedure returns the specified drawable's offsets. This only makes sense if the drawable is a layer since channels are anchored. The offsets of a channel will be returned as 0.",
@ -1576,8 +1576,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-get-image
*/
procedure = gimp_procedure_new (drawable_get_image_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-get-image");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-image",
"gimp-drawable-get-image",
"Returns the drawable's image.",
"This procedure returns the drawable's image.",
@ -1605,8 +1605,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-set-image
*/
procedure = gimp_procedure_new (drawable_set_image_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-set-image");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-image",
"gimp-drawable-set-image",
"This procedure is deprecated!",
"This procedure is deprecated!",
@ -1634,8 +1634,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-get-name
*/
procedure = gimp_procedure_new (drawable_get_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-get-name");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-name",
"gimp-drawable-get-name",
"Get the name of the specified drawable.",
"This procedure returns the specified drawable's name.",
@ -1664,8 +1664,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-set-name
*/
procedure = gimp_procedure_new (drawable_set_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-set-name");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-name",
"gimp-drawable-set-name",
"Set the name of the specified drawable.",
"This procedure sets the specified drawable's name.",
@ -1694,8 +1694,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-get-visible
*/
procedure = gimp_procedure_new (drawable_get_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-get-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-visible",
"gimp-drawable-get-visible",
"Get the visibility of the specified drawable.",
"This procedure returns the specified drawable's visibility.",
@ -1723,8 +1723,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-set-visible
*/
procedure = gimp_procedure_new (drawable_set_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-set-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-visible",
"gimp-drawable-set-visible",
"Set the visibility of the specified drawable.",
"This procedure sets the specified drawable's visibility.",
@ -1752,8 +1752,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-get-linked
*/
procedure = gimp_procedure_new (drawable_get_linked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-get-linked");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-linked",
"gimp-drawable-get-linked",
"Get the linked state of the specified drawable.",
"This procedure returns the specified drawable's linked state.",
@ -1781,8 +1781,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-set-linked
*/
procedure = gimp_procedure_new (drawable_set_linked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-set-linked");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-linked",
"gimp-drawable-set-linked",
"Set the linked state of the specified drawable.",
"This procedure sets the specified drawable's linked state.",
@ -1810,8 +1810,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-get-tattoo
*/
procedure = gimp_procedure_new (drawable_get_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-get-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-tattoo",
"gimp-drawable-get-tattoo",
"Get the tattoo of the specified drawable.",
"This procedure returns the specified drawable's tattoo. A tattoo is a unique and permanent identifier attached to a drawable that can be used to uniquely identify a drawable within an image even between sessions.",
@ -1839,8 +1839,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-set-tattoo
*/
procedure = gimp_procedure_new (drawable_set_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-set-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-tattoo",
"gimp-drawable-set-tattoo",
"Set the tattoo of the specified drawable.",
"This procedure sets the specified drawable's tattoo. A tattoo is a unique and permanent identifier attached to a drawable that can be used to uniquely identify a drawable within an image even between sessions.",
@ -1868,8 +1868,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-mask-bounds
*/
procedure = gimp_procedure_new (drawable_mask_bounds_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-mask-bounds");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-mask-bounds",
"gimp-drawable-mask-bounds",
"Find the bounding box of the current selection in relation to the specified drawable.",
"This procedure returns whether there is a selection. If there is one, the upper left and lower righthand corners of its bounding box are returned. These coordinates are specified relative to the drawable's origin, and bounded by the drawable's extents. 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). Note that the returned boolean does NOT correspond with the returned region being empty or not, it always returns whether the selection is non_empty. See gimp_drawable_mask_intersect() for a boolean return value which is more useful in most cases.",
@ -1921,8 +1921,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-mask-intersect
*/
procedure = gimp_procedure_new (drawable_mask_intersect_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-mask-intersect");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-mask-intersect",
"gimp-drawable-mask-intersect",
"Find the bounding box of the current selection in relation to the specified drawable.",
"This procedure returns whether there is an intersection between the drawable and the selection. Unlike gimp_drawable_mask_bounds(), the intersection's bounds are returned as x, y, width, height. If there is no selection this function returns TRUE and the returned bounds are the extents of the whole drawable.",
@ -1974,8 +1974,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-merge-shadow
*/
procedure = gimp_procedure_new (drawable_merge_shadow_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-merge-shadow");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-merge-shadow",
"gimp-drawable-merge-shadow",
"Merge the shadow buffer with the specified drawable.",
"This procedure combines the contents of the image's shadow buffer (for temporary processing) with the specified drawable. The \"undo\" parameter specifies whether to add an undo step for the operation. Requesting no undo is useful for such applications as 'auto-apply'.",
@ -2003,8 +2003,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-update
*/
procedure = gimp_procedure_new (drawable_update_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-update");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-update",
"gimp-drawable-update",
"Update the specified region of the drawable.",
"This procedure updates the specified region of the drawable. The (x, y) coordinate pair is relative to the drawable's origin, not to the image origin. Therefore, the entire drawable can be updated using (0, 0, width, height).",
@ -2050,8 +2050,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-get-pixel
*/
procedure = gimp_procedure_new (drawable_get_pixel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-get-pixel");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-pixel",
"gimp-drawable-get-pixel",
"Gets the value of the pixel at the specified coordinates.",
"This procedure gets the pixel value at the specified coordinates. The 'num_channels' argument must always be equal to the bytes-per-pixel value for the specified drawable.",
@ -2096,8 +2096,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-set-pixel
*/
procedure = gimp_procedure_new (drawable_set_pixel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-set-pixel");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-pixel",
"gimp-drawable-set-pixel",
"Sets the value of the pixel at the specified coordinates.",
"This procedure sets the pixel value at the specified coordinates. The 'num_channels' argument must always be equal to the bytes-per-pixel value for the specified drawable. Note that this function is not undoable, you should use it only on drawables you just created yourself.",
@ -2142,8 +2142,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-fill
*/
procedure = gimp_procedure_new (drawable_fill_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-fill");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-fill",
"gimp-drawable-fill",
"Fill the drawable with the specified fill mode.",
"This procedure fills the drawable. If the fill mode is foreground the current foreground color is used. If the fill mode is background, the current background color is used. If the fill type is white, then white is used. Transparent fill only affects layers with an alpha channel, in which case the alpha channel is set to transparent. If the drawable has no alpha channel, it is filled to white. No fill leaves the drawable's contents undefined. This procedure is unlike the bucket fill tool because it fills regardless of a selection. Its main purpose is to fill a newly created drawable before adding it to the image. This operation cannot be undone.",
@ -2172,8 +2172,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-offset
*/
procedure = gimp_procedure_new (drawable_offset_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-offset");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-offset",
"gimp-drawable-offset",
"Offset the drawable by the specified amounts in the X and Y directions",
"This procedure offsets the specified drawable by the amounts specified by 'offset_x' and 'offset_y'. If 'wrap_around' is set to TRUE, then portions of the drawable which are offset out of bounds are wrapped around. Alternatively, the undefined regions of the drawable can be filled with transparency or the background color, as specified by the 'fill_type' parameter.",
@ -2220,8 +2220,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-thumbnail
*/
procedure = gimp_procedure_new (drawable_thumbnail_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-thumbnail");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-thumbnail",
"gimp-drawable-thumbnail",
"Get a thumbnail of a drawable.",
"This function gets data from which a thumbnail of a drawable preview can be created. Maximum x or y dimension is 512 pixels. The pixels are returned in RGB[A] or GRAY[A] format. The bpp return value gives the number of bytes in the image.",
@ -2284,8 +2284,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-sub-thumbnail
*/
procedure = gimp_procedure_new (drawable_sub_thumbnail_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-sub-thumbnail");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-sub-thumbnail",
"gimp-drawable-sub-thumbnail",
"Get a thumbnail of a sub-area of a drawable drawable.",
"This function gets data from which a thumbnail of a drawable preview can be created. Maximum x or y dimension is 512 pixels. The pixels are returned in RGB[A] or GRAY[A] format. The bpp return value gives the number of bytes in the image.",
@ -2372,8 +2372,8 @@ register_drawable_procs (Gimp *gimp)
* gimp-drawable-foreground-extract
*/
procedure = gimp_procedure_new (drawable_foreground_extract_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-foreground-extract");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-foreground-extract",
"gimp-drawable-foreground-extract",
"Extract the foreground of a drawable using a given trimap.",
"Image Segmentation by Uniform Color Clustering, see http://www.inf.fu-berlin.de/inst/pubs/tr-b-05-07.pdf",

32
app/pdb/drawable_transform_cmds.c
View File

@ -1185,8 +1185,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-flip-simple
*/
procedure = gimp_procedure_new (drawable_transform_flip_simple_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-flip-simple");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-flip-simple",
"gimp-drawable-transform-flip-simple",
"Flip the specified drawable either vertically or horizontally.",
"This procedure flips the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then flipped. If auto_center is set to TRUE, the flip is around the selection's center. Otherwise, the coordinate of the axis needs to be specified. The return value is the ID of the flipped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and flipped drawable.",
@ -1241,8 +1241,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-flip
*/
procedure = gimp_procedure_new (drawable_transform_flip_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-flip");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-flip",
"gimp-drawable-transform-flip",
"Flip the specified drawable around a given line.",
"This procedure flips the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then flipped. The axis to flip around is specified by specifying two points from that line. The return value is the ID of the flipped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and flipped drawable. The clip results parameter specifies wheter current selection will affect the transform.",
@ -1326,8 +1326,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-flip-default
*/
procedure = gimp_procedure_new (drawable_transform_flip_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-flip-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-flip-default",
"gimp-drawable-transform-flip-default",
"Flip the specified drawable around a given line.",
"This procedure is a variant of gimp_drawable_transform_flip() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",
@ -1391,8 +1391,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-perspective
*/
procedure = gimp_procedure_new (drawable_transform_perspective_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-perspective");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-perspective",
"gimp-drawable-transform-perspective",
"Perform a possibly non-affine transformation on the specified drawable, with extra parameters.",
"This procedure performs a possibly non-affine transformation on the specified drawable by allowing the corners of the original bounding box to be arbitrarily remapped to any values. The specified drawable is remapped if no selection exists. However, if a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then remapped as specified. The return value is the ID of the remapped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and remapped drawable. The 4 coordinates specify the new locations of each corner of the original bounding box. By specifying these values, any affine transformation (rotation, scaling, translation) can be affected. Additionally, these values can be specified such that the resulting transformed drawable will appear to have been projected via a perspective transform.",
@ -1500,8 +1500,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-perspective-default
*/
procedure = gimp_procedure_new (drawable_transform_perspective_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-perspective-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-perspective-default",
"gimp-drawable-transform-perspective-default",
"Perform a possibly non-affine transformation on the specified drawable, with extra parameters.",
"This procedure is a variant of gimp_drawable_transform_perspective() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",
@ -1589,8 +1589,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-rotate-simple
*/
procedure = gimp_procedure_new (drawable_transform_rotate_simple_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-rotate-simple");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-rotate-simple",
"gimp-drawable-transform-rotate-simple",
"Rotate the specified drawable about given coordinates through the specified angle.",
"This function rotates the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then rotated by the specified amount. The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and rotated drawable.",
@ -1649,8 +1649,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-rotate
*/
procedure = gimp_procedure_new (drawable_transform_rotate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-rotate");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-rotate",
"gimp-drawable-transform-rotate",
"Rotate the specified drawable about given coordinates through the specified angle.",
"This function rotates the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then rotated by the specified amount. The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and rotated drawable.",
@ -1734,8 +1734,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-rotate-default
*/
procedure = gimp_procedure_new (drawable_transform_rotate_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-rotate-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-rotate-default",
"gimp-drawable-transform-rotate-default",
"Rotate the specified drawable about given coordinates through the specified angle.",
"This procedure is a variant of gimp_drawable_transform_rotate() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",
@ -1799,8 +1799,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-scale
*/
procedure = gimp_procedure_new (drawable_transform_scale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-scale");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-scale",
"gimp-drawable-transform-scale",
"Scale the specified drawable with extra parameters",
"This procedure scales the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then scaled by the specified amount. The return value is the ID of the scaled drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and scaled drawable.",
@ -1884,8 +1884,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-scale-default
*/
procedure = gimp_procedure_new (drawable_transform_scale_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-scale-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-scale-default",
"gimp-drawable-transform-scale-default",
"Scale the specified drawable with extra parameters",
"This procedure is a variant of gimp_drawable_transform_scale() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",
@ -1949,8 +1949,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-shear
*/
procedure = gimp_procedure_new (drawable_transform_shear_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-shear");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-shear",
"gimp-drawable-transform-shear",
"Shear the specified drawable about its center by the specified magnitude, with extra parameters.",
"This procedure shears the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then sheard by the specified amount. The return value is the ID of the sheard drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and sheard drawable. The shear type parameter indicates whether the shear will be applied horizontally or vertically. The magnitude can be either positive or negative and indicates the extent (in pixels) to shear by.",
@ -2025,8 +2025,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-shear-default
*/
procedure = gimp_procedure_new (drawable_transform_shear_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-shear-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-shear-default",
"gimp-drawable-transform-shear-default",
"Shear the specified drawable about its center by the specified magnitude, with extra parameters.",
"This procedure is a variant of gimp_drawable_transform_shear() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",
@ -2081,8 +2081,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-2d
*/
procedure = gimp_procedure_new (drawable_transform_2d_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-2d");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-2d",
"gimp-drawable-transform-2d",
"Transform the specified drawable in 2d, with extra parameters.",
"This procedure transforms the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then transformed. The transformation is done by scaling the image by the x and y scale factors about the point (source_x, source_y), then rotating around the same point, then translating that point to the new position (dest_x, dest_y). The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and transformed drawable.",
@ -2184,8 +2184,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-2d-default
*/
procedure = gimp_procedure_new (drawable_transform_2d_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-2d-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-2d-default",
"gimp-drawable-transform-2d-default",
"Transform the specified drawable in 2d, with extra parameters.",
"This procedure is a variant of gimp_drawable_transform_2d() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",
@ -2267,8 +2267,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-matrix
*/
procedure = gimp_procedure_new (drawable_transform_matrix_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-matrix");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-matrix",
"gimp-drawable-transform-matrix",
"Transform the specified drawable in 2d, with extra parameters.",
"This procedure transforms the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then transformed. The transformation is done by assembling a 3x3 matrix from the coefficients passed. The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and transformed drawable.",
@ -2382,8 +2382,8 @@ register_drawable_transform_procs (Gimp *gimp)
* gimp-drawable-transform-matrix-default
*/
procedure = gimp_procedure_new (drawable_transform_matrix_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-drawable-transform-matrix-default");
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-matrix-default",
"gimp-drawable-transform-matrix-default",
"Transform the specified drawable in 2d, with extra parameters.",
"This procedure is a variant of gimp_drawable_transform_matrix() which uses no interpolation/supersampling at all, or default values (depending on the 'interpolate' parameter).",

30
app/pdb/edit_cmds.c
View File

@ -638,8 +638,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -667,8 +667,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -696,8 +696,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -725,8 +725,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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 it's 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.",
@ -760,8 +760,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-paste-as-new
*/
procedure = gimp_procedure_new (edit_paste_as_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-paste-as-new");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-paste-as-new",
"gimp-edit-paste-as-new",
"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.",
@ -783,8 +783,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -820,8 +820,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -857,8 +857,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -894,8 +894,8 @@ register_edit_procs (Gimp *gimp)
* 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",
"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.",
@ -936,8 +936,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-named-paste-as-new
*/
procedure = gimp_procedure_new (edit_named_paste_as_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-named-paste-as-new");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-paste-as-new",
"gimp-edit-named-paste-as-new",
"Paste named buffer to a new image.",
"This procedure works like gimp-edit-paste-as-new but pastes a named buffer instead of the global buffer.",
@ -966,8 +966,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-clear
*/
procedure = gimp_procedure_new (edit_clear_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-clear");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-clear",
"gimp-edit-clear",
"Clear selected area of drawable.",
"This procedure clears the specified drawable. If the drawable has an alpha channel, the cleared pixels will become transparent. If the drawable does not have an alpha channel, cleared pixels will be set to the background color. This procedure only affects regions within a selection if there is a selection active.",
@ -989,8 +989,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-fill
*/
procedure = gimp_procedure_new (edit_fill_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-fill");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-fill",
"gimp-edit-fill",
"Fill selected area of drawable.",
"This procedure fills the specified drawable with the fill mode. If the fill mode is foreground, the current foreground color is used. If the fill mode is background, the current background color is used. Other fill modes should not be used. This procedure only affects regions within a selection if there is a selection active. If you want to fill the whole drawable, regardless of the selection, use gimp_drawable_fill().",
@ -1019,8 +1019,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-bucket-fill
*/
procedure = gimp_procedure_new (edit_bucket_fill_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-bucket-fill");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-bucket-fill",
"gimp-edit-bucket-fill",
"Fill the area specified either by the current selection if there is one, or by a seed fill starting at the specified coordinates.",
"This tool requires information on the paint application mode, and the fill mode, which can either be in the foreground color, or in the currently active pattern. If there is no selection, a seed fill is executed at the specified coordinates and extends outward in keeping with the threshold parameter. If there is a selection in the target image, the threshold, sample merged, x, and y arguments are unused. If the sample_merged parameter is TRUE, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of merged sampling, the x and y coordinates are relative to the image's origin; otherwise, they are relative to the drawable's origin.",
@ -1086,8 +1086,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-blend
*/
procedure = gimp_procedure_new (edit_blend_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-blend");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-blend",
"gimp-edit-blend",
"Blend between the starting and ending coordinates with the specified blend mode and gradient type.",
"This tool requires information on the paint application mode, the blend mode, and the gradient type. It creates the specified variety of blend using the starting and ending coordinates as defined for each gradient type.",
@ -1203,8 +1203,8 @@ register_edit_procs (Gimp *gimp)
* gimp-edit-stroke
*/
procedure = gimp_procedure_new (edit_stroke_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-edit-stroke");
gimp_procedure_set_static_strings (procedure,
"gimp-edit-stroke",
"gimp-edit-stroke",
"Stroke the current selection",
"This procedure strokes the current selection, painting along the selection boundary with the active brush and foreground color. The paint is applied to the specified drawable regardless of the active selection.",

26
app/pdb/fileops_cmds.c
View File

@ -135,7 +135,7 @@ file_load_invoker (GimpProcedure *procedure,
g_value_set_static_string (&new_args->values[i], "");
return_vals = gimp_pdb_execute (gimp, context, progress,
proc->name, new_args);
GIMP_OBJECT (proc)->name, new_args);
g_value_array_free (new_args);
@ -307,7 +307,7 @@ file_save_invoker (GimpProcedure *procedure,
g_value_set_static_string (&new_args->values[i], "");
return_vals = gimp_pdb_execute (gimp, context, progress,
proc->name, new_args);
GIMP_OBJECT (proc)->name, new_args);
g_value_array_free (new_args);
@ -572,8 +572,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.\"",
@ -618,8 +618,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"gimp-file-load-layer",
"Loads an image file as a layer into an already opened image.",
"This procedure behaves like the file-load procedure but opens the specified image as a layer into an already opened image.",
@ -663,8 +663,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",
@ -710,8 +710,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",
@ -760,8 +760,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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 explicitely save a thumbnail with a file.",
@ -790,8 +790,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"gimp-temp-name",
"Generates a unique filename.",
"Generates a unique filename using the temp path supplied in the user's gimprc.",
@ -821,8 +821,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",
@ -866,8 +866,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",
@ -904,8 +904,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",
@ -942,8 +942,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",
@ -973,8 +973,8 @@ register_fileops_procs (Gimp *gimp)
* 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",
"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.",

12
app/pdb/floating_sel_cmds.c
View File

@ -186,8 +186,8 @@ register_floating_sel_procs (Gimp *gimp)
* 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",
"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.",
@ -209,8 +209,8 @@ register_floating_sel_procs (Gimp *gimp)
* 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",
"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.",
@ -232,8 +232,8 @@ register_floating_sel_procs (Gimp *gimp)
* 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",
"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.",
@ -255,8 +255,8 @@ register_floating_sel_procs (Gimp *gimp)
* 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",
"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.",
@ -284,8 +284,8 @@ register_floating_sel_procs (Gimp *gimp)
* 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",
"gimp-floating-sel-rigor",
"Rigor the floating selection.",
"This procedure rigors the floating selection.",
@ -313,8 +313,8 @@ register_floating_sel_procs (Gimp *gimp)
* 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",
"gimp-floating-sel-relax",
"Relax the floating selection.",
"This procedure relaxes the floating selection.",

6
app/pdb/font_select_cmds.c
View File

@ -118,8 +118,8 @@ register_font_select_procs (Gimp *gimp)
* 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",
"gimp-fonts-popup",
"Invokes the Gimp font selection.",
"This procedure popups the font selection dialog.",
@ -156,8 +156,8 @@ register_font_select_procs (Gimp *gimp)
* 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",
"gimp-fonts-close-popup",
"Popdown the Gimp font selection.",
"This procedure closes an opened font selection dialog.",
@ -180,8 +180,8 @@ register_font_select_procs (Gimp *gimp)
* 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",
"gimp-fonts-set-popup",
"Sets the current font selection in a popup.",
"Sets the current font selection in a popup.",

4
app/pdb/fonts_cmds.c
View File

@ -86,8 +86,8 @@ register_fonts_procs (Gimp *gimp)
* 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",
"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.",
@ -103,8 +103,8 @@ register_fonts_procs (Gimp *gimp)
* 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",
"gimp-fonts-get-list",
"Retrieve the list of loaded fonts.",
"This procedure returns a list of the fonts that are currently available.",

7
app/pdb/gimp-pdb-query.c
View File

@ -384,12 +384,12 @@ gimp_pdb_print_entry (gpointer key,
if (list || num != 1)
{
g_string_printf (buf, "%s <%d>", procedure->name, num);
g_string_printf (buf, "%s <%d>", GIMP_OBJECT (procedure)->name, num);
output_string (file, buf->str);
}
else
{
output_string (file, procedure->name);
output_string (file, GIMP_OBJECT (procedure)->name);
}
type_desc = gimp_enum_get_desc (proc_class, procedure->proc_type);
@ -458,7 +458,8 @@ gimp_pdb_get_strings (PDBStrings *strings,
if (compat)
{
strings->blurb = g_strdup_printf (COMPAT_BLURB, procedure->name);
strings->blurb = g_strdup_printf (COMPAT_BLURB,
GIMP_OBJECT (procedure)->name);
strings->help = g_strdup (strings->blurb);
strings->author = NULL;
strings->copyright = NULL;

13
app/pdb/gimp-pdb.c
View File

@ -195,15 +195,17 @@ void
gimp_pdb_register (Gimp *gimp,
GimpProcedure *procedure)
{
GList *list;
const gchar *name;
GList *list;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
list = g_hash_table_lookup (gimp->procedural_ht, procedure->name);
name = gimp_object_get_name (GIMP_OBJECT (procedure));
g_hash_table_insert (gimp->procedural_ht,
procedure->name,
list = g_hash_table_lookup (gimp->procedural_ht, name);
g_hash_table_insert (gimp->procedural_ht, (gpointer) name,
g_list_prepend (list, g_object_ref (procedure)));
}
@ -369,7 +371,8 @@ gimp_pdb_run_proc (Gimp *gimp,
g_message (_("PDB calling error for procedure '%s':\n"
"Argument #%d type mismatch (expected %s, got %s)"),
procedure->name, i + 1, expected, got);
gimp_object_get_name (GIMP_OBJECT (procedure)),
i + 1, expected, got);
return_vals = gimp_procedure_get_return_values (procedure, FALSE);
g_value_set_enum (return_vals->values, GIMP_PDB_CALLING_ERROR);

7
app/pdb/gimppdb-query.c
View File

@ -384,12 +384,12 @@ gimp_pdb_print_entry (gpointer key,
if (list || num != 1)
{
g_string_printf (buf, "%s <%d>", procedure->name, num);
g_string_printf (buf, "%s <%d>", GIMP_OBJECT (procedure)->name, num);
output_string (file, buf->str);
}
else
{
output_string (file, procedure->name);
output_string (file, GIMP_OBJECT (procedure)->name);
}
type_desc = gimp_enum_get_desc (proc_class, procedure->proc_type);
@ -458,7 +458,8 @@ gimp_pdb_get_strings (PDBStrings *strings,
if (compat)
{
strings->blurb = g_strdup_printf (COMPAT_BLURB, procedure->name);
strings->blurb = g_strdup_printf (COMPAT_BLURB,
GIMP_OBJECT (procedure)->name);
strings->help = g_strdup (strings->blurb);
strings->author = NULL;
strings->copyright = NULL;

13
app/pdb/gimppdb.c
View File

@ -195,15 +195,17 @@ void
gimp_pdb_register (Gimp *gimp,
GimpProcedure *procedure)
{
GList *list;
const gchar *name;
GList *list;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
list = g_hash_table_lookup (gimp->procedural_ht, procedure->name);
name = gimp_object_get_name (GIMP_OBJECT (procedure));
g_hash_table_insert (gimp->procedural_ht,
procedure->name,
list = g_hash_table_lookup (gimp->procedural_ht, name);
g_hash_table_insert (gimp->procedural_ht, (gpointer) name,
g_list_prepend (list, g_object_ref (procedure)));
}
@ -369,7 +371,8 @@ gimp_pdb_run_proc (Gimp *gimp,
g_message (_("PDB calling error for procedure '%s':\n"
"Argument #%d type mismatch (expected %s, got %s)"),
procedure->name, i + 1, expected, got);
gimp_object_get_name (GIMP_OBJECT (procedure)),
i + 1, expected, got);
return_vals = gimp_procedure_get_return_values (procedure, FALSE);
g_value_set_enum (return_vals->values, GIMP_PDB_CALLING_ERROR);

10
app/pdb/gimppluginprocedure.c
View File

@ -163,10 +163,10 @@ gimp_plug_in_procedure_find (GSList *list,
for (l = list; l; l = g_slist_next (l))
{
GimpProcedure *proc = l->data;
GimpObject *object = l->data;
if (! strcmp (proc_name, proc->name))
return GIMP_PLUG_IN_PROCEDURE (proc);
if (! strcmp (proc_name, object->name))
return GIMP_PLUG_IN_PROCEDURE (object);
}
return NULL;
@ -304,9 +304,9 @@ gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc,
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
if (help_domain)
return g_strconcat (help_domain, "?", GIMP_PROCEDURE (proc)->name, NULL);
return g_strconcat (help_domain, "?", GIMP_OBJECT (proc)->name, NULL);
return g_strdup (GIMP_PROCEDURE (proc)->name);
return g_strdup (GIMP_OBJECT (proc)->name);
}
gboolean

12
app/pdb/gimpprocedure.c
View File

@ -139,7 +139,6 @@ gimp_procedure_new (GimpMarshalFunc marshal_func)
void
gimp_procedure_set_strings (GimpProcedure *procedure,
gchar *name,
gchar *original_name,
gchar *blurb,
gchar *help,
@ -152,7 +151,6 @@ gimp_procedure_set_strings (GimpProcedure *procedure,
gimp_procedure_free_strings (procedure);
procedure->name = g_strdup (name);
procedure->original_name = g_strdup (original_name);
procedure->blurb = g_strdup (blurb);
procedure->help = g_strdup (help);
@ -166,7 +164,6 @@ gimp_procedure_set_strings (GimpProcedure *procedure,
void
gimp_procedure_set_static_strings (GimpProcedure *procedure,
gchar *name,
gchar *original_name,
gchar *blurb,
gchar *help,
@ -179,7 +176,6 @@ gimp_procedure_set_static_strings (GimpProcedure *procedure,
gimp_procedure_free_strings (procedure);
procedure->name = name;
procedure->original_name = original_name;
procedure->blurb = blurb;
procedure->help = help;
@ -193,7 +189,6 @@ gimp_procedure_set_static_strings (GimpProcedure *procedure,
void
gimp_procedure_take_strings (GimpProcedure *procedure,
gchar *name,
gchar *original_name,
gchar *blurb,
gchar *help,
@ -206,7 +201,6 @@ gimp_procedure_take_strings (GimpProcedure *procedure,
gimp_procedure_free_strings (procedure);
procedure->name = name;
procedure->original_name = original_name;
procedure->blurb = blurb;
procedure->help = help;
@ -249,7 +243,7 @@ gimp_procedure_execute (GimpProcedure *procedure,
g_message (_("PDB calling error for procedure '%s':\n"
"Argument '%s' (#%d, type %s) type mismatch "
"(got %s)."),
procedure->name,
gimp_object_get_name (GIMP_OBJECT (procedure)),
g_param_spec_get_name (pspec),
i + 1, type_name, got);
@ -290,7 +284,7 @@ gimp_procedure_execute (GimpProcedure *procedure,
g_message (_("PDB calling error for procedure '%s':\n"
"Argument '%s' (#%d, type %s) out of bounds "
"(validation changed '%s' to '%s')"),
procedure->name,
gimp_object_get_name (GIMP_OBJECT (procedure)),
g_param_spec_get_name (pspec),
i + 1, type_name,
old_value, new_value);
@ -428,7 +422,6 @@ gimp_procedure_free_strings (GimpProcedure *procedure)
{
if (! procedure->static_strings)
{
g_free (procedure->name);
g_free (procedure->original_name);
g_free (procedure->blurb);
g_free (procedure->help);
@ -438,7 +431,6 @@ gimp_procedure_free_strings (GimpProcedure *procedure)
g_free (procedure->deprecated);
}
procedure->name = NULL;
procedure->original_name = NULL;
procedure->blurb = NULL;
procedure->help = NULL;

4
app/pdb/gimpprocedure.h
View File

@ -48,7 +48,6 @@ struct _GimpProcedure
gboolean static_strings; /* Are the strings allocated? */
gchar *name; /* Procedure name */
gchar *original_name; /* Uncanonicalized procedure name */
gchar *blurb; /* Short procedure description */
gchar *help; /* Detailed help instructions */
@ -83,7 +82,6 @@ GType gimp_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_procedure_new (GimpMarshalFunc marshal_func);
void gimp_procedure_set_strings (GimpProcedure *procedure,
gchar *name,
gchar *original_name,
gchar *blurb,
gchar *help,
@ -92,7 +90,6 @@ void gimp_procedure_set_strings (GimpProcedure *procedure,
gchar *date,
gchar *deprecated);
void gimp_procedure_set_static_strings (GimpProcedure *procedure,
gchar *name,
gchar *original_name,
gchar *blurb,
gchar *help,
@ -101,7 +98,6 @@ void gimp_procedure_set_static_strings (GimpProcedure *procedure,
gchar *date,
gchar *deprecated);
void gimp_procedure_take_strings (GimpProcedure *procedure,
gchar *name,
gchar *original_name,
gchar *blurb,
gchar *help,

14
app/pdb/gimprc_cmds.c
View File

@ -204,8 +204,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-gimprc-query
*/
procedure = gimp_procedure_new (gimprc_query_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gimprc-query");
gimp_procedure_set_static_strings (procedure,
"gimp-gimprc-query",
"gimp-gimprc-query",
"Queries the gimprc file parser for information on a specified token.",
"This procedure is used to locate additional information contained in the gimprc file considered extraneous to the operation of the GIMP. Plug-ins that need configuration information can expect it will be stored in the user gimprc file and can use this procedure to retrieve it. This query procedure will return the value associated with the specified token. This corresponds _only_ to entries with the format: (<token> <value>). The value must be a string. Entries not corresponding to this format will cause warnings to be issued on gimprc parsing and will not be queryable.",
@ -235,8 +235,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-gimprc-set
*/
procedure = gimp_procedure_new (gimprc_set_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gimprc-set");
gimp_procedure_set_static_strings (procedure,
"gimp-gimprc-set",
"gimp-gimprc-set",
"Sets a gimprc token to a value and saves it in the gimprc.",
"This procedure is used to add or change additional information in the gimprc file that is considered extraneous to the operation of the GIMP. Plug-ins that need configuration information can use this function to store it, and gimp_gimprc_query to retrieve it. This will accept _only_ string values in UTF-8 encoding.",
@ -266,8 +266,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-get-default-comment
*/
procedure = gimp_procedure_new (get_default_comment_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-get-default-comment");
gimp_procedure_set_static_strings (procedure,
"gimp-get-default-comment",
"gimp-get-default-comment",
"Get the default image comment as specified in the Preferences.",
"Returns a copy of the default image comment.",
@ -290,8 +290,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-get-monitor-resolution
*/
procedure = gimp_procedure_new (get_monitor_resolution_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-get-monitor-resolution");
gimp_procedure_set_static_strings (procedure,
"gimp-get-monitor-resolution",
"gimp-get-monitor-resolution",
"Get the monitor resolution as specified in the Preferences.",
"Returns the resolution of the monitor in pixels/inch. This value is taken from the Preferences (or the windowing system if this is set in the Preferences) and there's no guarantee for the value to be reasonable.",
@ -319,8 +319,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-get-theme-dir
*/
procedure = gimp_procedure_new (get_theme_dir_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-get-theme-dir");
gimp_procedure_set_static_strings (procedure,
"gimp-get-theme-dir",
"gimp-get-theme-dir",
"Get the directory of the current GUI theme.",
"Returns a copy of the current GUI theme dir.",
@ -343,8 +343,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-get-color-configuration
*/
procedure = gimp_procedure_new (get_color_configuration_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-get-color-configuration");
gimp_procedure_set_static_strings (procedure,
"gimp-get-color-configuration",
"gimp-get-color-configuration",
"Get a serialized version of the color management configuration.",
"Returns a string that can be deserialized into a GimpColorConfig object representing the current color management configuration.",
@ -367,8 +367,8 @@ register_gimprc_procs (Gimp *gimp)
* gimp-get-module-load-inhibit
*/
procedure = gimp_procedure_new (get_module_load_inhibit_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-get-module-load-inhibit");
gimp_procedure_set_static_strings (procedure,
"gimp-get-module-load-inhibit",
"gimp-get-module-load-inhibit",
"Get the list of modules which should not be loaded.",
"Returns a copy of the list of modules which should not be loaded.",

60
app/pdb/gradient_cmds.c
View File

@ -1338,8 +1338,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-new
*/
procedure = gimp_procedure_new (gradient_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-new");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-new",
"gimp-gradient-new",
"Creates a new gradient",
"This procedure creates a new, uninitialized gradient",
@ -1369,8 +1369,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-duplicate
*/
procedure = gimp_procedure_new (gradient_duplicate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-duplicate");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-duplicate",
"gimp-gradient-duplicate",
"Duplicates a gradient",
"This procedure creates an identical gradient by a different name",
@ -1400,8 +1400,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-is-editable
*/
procedure = gimp_procedure_new (gradient_is_editable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-is-editable");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-is-editable",
"gimp-gradient-is-editable",
"Tests if gradient can be edited",
"Returns TRUE if you have permission to change the gradient",
@ -1430,8 +1430,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-rename
*/
procedure = gimp_procedure_new (gradient_rename_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-rename");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-rename",
"gimp-gradient-rename",
"Rename a gradient",
"This procedure renames a gradient",
@ -1468,8 +1468,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-delete
*/
procedure = gimp_procedure_new (gradient_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-delete",
"gimp-gradient-delete",
"Deletes a gradient",
"This procedure deletes a gradient",
@ -1492,8 +1492,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-get-uniform-samples
*/
procedure = gimp_procedure_new (gradient_get_uniform_samples_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-get-uniform-samples");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-get-uniform-samples",
"gimp-gradient-get-uniform-samples",
"Sample the specified in uniform parts.",
"This procedure samples the active gradient in the specified number of uniform parts. It returns a list of floating-point values which correspond to the RGBA values for each sample. The minimum number of samples to take is 2, in which case the returned colors will correspond to the { 0.0, 1.0 } positions in the gradient. For example, if the number of samples is 3, the procedure will return the colors at positions { 0.0, 0.5, 1.0 }.",
@ -1539,8 +1539,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-get-custom-samples
*/
procedure = gimp_procedure_new (gradient_get_custom_samples_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-get-custom-samples");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-get-custom-samples",
"gimp-gradient-get-custom-samples",
"Sample the spacified gradient in custom positions.",
"This procedure samples the active gradient in the specified number of points. The procedure will sample the gradient in the specified positions from the list. The left endpoint of the gradient corresponds to position 0.0, and the right endpoint corresponds to 1.0. The procedure returns a list of floating-point values which correspond to the RGBA values for each sample.",
@ -1591,8 +1591,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-left-color
*/
procedure = gimp_procedure_new (gradient_segment_get_left_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-left-color");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-left-color",
"gimp-gradient-segment-get-left-color",
"Retrieves the left endpoint color of the specified segment",
"This procedure retrieves the left endpoint color of the specified segment of the specified gradient.",
@ -1633,8 +1633,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-set-left-color
*/
procedure = gimp_procedure_new (gradient_segment_set_left_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-set-left-color");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-left-color",
"gimp-gradient-segment-set-left-color",
"Retrieves the left endpoint color of the specified segment",
"This procedure retrieves the left endpoint color of the specified segment of the specified gradient.",
@ -1675,8 +1675,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-right-color
*/
procedure = gimp_procedure_new (gradient_segment_get_right_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-right-color");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-right-color",
"gimp-gradient-segment-get-right-color",
"Retrieves the right endpoint color of the specified segment",
"This procedure retrieves the right endpoint color of the specified segment of the specified gradient.",
@ -1717,8 +1717,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-set-right-color
*/
procedure = gimp_procedure_new (gradient_segment_set_right_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-set-right-color");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-right-color",
"gimp-gradient-segment-set-right-color",
"Retrieves the right endpoint color of the specified segment",
"This procedure retrieves the right endpoint color of the specified segment of the specified gradient.",
@ -1759,8 +1759,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-left-pos
*/
procedure = gimp_procedure_new (gradient_segment_get_left_pos_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-left-pos");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-left-pos",
"gimp-gradient-segment-get-left-pos",
"Retrieves the left endpoint position of the specified segment",
"This procedure retrieves the left endpoint position of the specified segment of the specified gradient.",
@ -1795,8 +1795,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-set-left-pos
*/
procedure = gimp_procedure_new (gradient_segment_set_left_pos_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-set-left-pos");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-left-pos",
"gimp-gradient-segment-set-left-pos",
"Sets the left endpoint position of the specified segment",
"This procedure sets the left endpoint position of the specified segment of the specified gradient. The final position will be between the position of the middle point to the left to the middle point of the current segement. This procedure returns the final position.",
@ -1837,8 +1837,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-middle-pos
*/
procedure = gimp_procedure_new (gradient_segment_get_middle_pos_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-middle-pos");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-middle-pos",
"gimp-gradient-segment-get-middle-pos",
"Retrieves the middle point position of the specified segment",
"This procedure retrieves the middle point position of the specified segment of the specified gradient.",
@ -1873,8 +1873,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-set-middle-pos
*/
procedure = gimp_procedure_new (gradient_segment_set_middle_pos_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-set-middle-pos");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-middle-pos",
"gimp-gradient-segment-set-middle-pos",
"Sets the middle point position of the specified segment",
"This procedure sets the middle point position of the specified segment of the specified gradient. The final position will be between the two endpoints of the segment. This procedure returns the final position.",
@ -1915,8 +1915,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-right-pos
*/
procedure = gimp_procedure_new (gradient_segment_get_right_pos_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-right-pos");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-right-pos",
"gimp-gradient-segment-get-right-pos",
"Retrieves the right endpoint position of the specified segment",
"This procedure retrieves the right endpoint position of the specified segment of the specified gradient.",
@ -1951,8 +1951,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-set-right-pos
*/
procedure = gimp_procedure_new (gradient_segment_set_right_pos_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-set-right-pos");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-right-pos",
"gimp-gradient-segment-set-right-pos",
"Sets the right endpoint position of the specified segment",
"This procedure sets the right endpoint position of the specified segment of the specified gradient. The final position will be between the position of the middle point of the current segment and the middle point of the segment to the right. This procedure returns the final position.",
@ -1993,8 +1993,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-blending-function
*/
procedure = gimp_procedure_new (gradient_segment_get_blending_function_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-blending-function");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-blending-function",
"gimp-gradient-segment-get-blending-function",
"Retrieves the gradient segment's blending function",
"This procedure retrieves the blending function of the segment at the specified gradient name and segment index.",
@ -2030,8 +2030,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-get-coloring-type
*/
procedure = gimp_procedure_new (gradient_segment_get_coloring_type_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-get-coloring-type");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-coloring-type",
"gimp-gradient-segment-get-coloring-type",
"Retrieves the gradient segment's coloring type",
"This procedure retrieves the coloring type of the segment at the specified gradient name and segment index.",
@ -2067,8 +2067,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-set-blending-function
*/
procedure = gimp_procedure_new (gradient_segment_range_set_blending_function_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-set-blending-function");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-set-blending-function",
"gimp-gradient-segment-range-set-blending-function",
"Change the blending function of a segments range",
"This function changes the blending function of a segment range to the specified blending function.",
@ -2110,8 +2110,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-set-coloring-type
*/
procedure = gimp_procedure_new (gradient_segment_range_set_coloring_type_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-set-coloring-type");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-set-coloring-type",
"gimp-gradient-segment-range-set-coloring-type",
"Change the coloring type of a segments range",
"This function changes the coloring type of a segment range to the specified coloring type.",
@ -2153,8 +2153,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-flip
*/
procedure = gimp_procedure_new (gradient_segment_range_flip_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-flip");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-flip",
"gimp-gradient-segment-range-flip",
"Flip the segment range",
"This function flips a segment range.",
@ -2189,8 +2189,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-replicate
*/
procedure = gimp_procedure_new (gradient_segment_range_replicate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-replicate");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-replicate",
"gimp-gradient-segment-range-replicate",
"Replicate the segment range",
"This function replicates a segment range a given number of times. Instead of the original segment range, several smaller scaled copies of it will appear in equal widths.",
@ -2231,8 +2231,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-split-midpoint
*/
procedure = gimp_procedure_new (gradient_segment_range_split_midpoint_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-split-midpoint");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-split-midpoint",
"gimp-gradient-segment-range-split-midpoint",
"Splits each segment in the segment range at midpoint",
"This function splits each segment in the segment range at its midpoint.",
@ -2267,8 +2267,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-split-uniform
*/
procedure = gimp_procedure_new (gradient_segment_range_split_uniform_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-split-uniform");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-split-uniform",
"gimp-gradient-segment-range-split-uniform",
"Splits each segment in the segment range uniformly",
"This function splits each segment in the segment range uniformly according to the number of times specified by the parameter.",
@ -2309,8 +2309,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-delete
*/
procedure = gimp_procedure_new (gradient_segment_range_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-delete",
"gimp-gradient-segment-range-delete",
"Delete the segment range",
"This function deletes a segment range.",
@ -2345,8 +2345,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-redistribute-handles
*/
procedure = gimp_procedure_new (gradient_segment_range_redistribute_handles_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-redistribute-handles");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-redistribute-handles",
"gimp-gradient-segment-range-redistribute-handles",
"Uniformly redistribute the segment range's handles",
"This function redistributes the handles of the specified segment range of the specified gradient, so they'll be evenly spaced.",
@ -2381,8 +2381,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-blend-colors
*/
procedure = gimp_procedure_new (gradient_segment_range_blend_colors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-blend-colors");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-blend-colors",
"gimp-gradient-segment-range-blend-colors",
"Blend the colors of the segment range.",
"This function blends the colors (but not the opacity) of the segments' range of the gradient. Using it, the colors' transition will be uniform across the range.",
@ -2417,8 +2417,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-blend-opacity
*/
procedure = gimp_procedure_new (gradient_segment_range_blend_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-blend-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-blend-opacity",
"gimp-gradient-segment-range-blend-opacity",
"Blend the opacity of the segment range.",
"This function blends the opacity (but not the colors) of the segments' range of the gradient. Using it, the opacity's transition will be uniform across the range.",
@ -2453,8 +2453,8 @@ register_gradient_procs (Gimp *gimp)
* gimp-gradient-segment-range-move
*/
procedure = gimp_procedure_new (gradient_segment_range_move_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradient-segment-range-move");
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-move",
"gimp-gradient-segment-range-move",
"Move the position of an entire segment range by a delta.",
"This funtions moves the position of an entire segment range by a delta. The actual delta (which is returned) will be limited by the control points of the neighboring segments.",

6
app/pdb/gradient_select_cmds.c
View File

@ -128,8 +128,8 @@ register_gradient_select_procs (Gimp *gimp)
* gimp-gradients-popup
*/
procedure = gimp_procedure_new (gradients_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradients-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-popup",
"gimp-gradients-popup",
"Invokes the Gimp gradients selection.",
"This procedure popups the gradients selection dialog.",
@ -172,8 +172,8 @@ register_gradient_select_procs (Gimp *gimp)
* gimp-gradients-close-popup
*/
procedure = gimp_procedure_new (gradients_close_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradients-close-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-close-popup",
"gimp-gradients-close-popup",
"Popdown the Gimp gradient selection.",
"This procedure closes an opened gradient selection dialog.",
@ -196,8 +196,8 @@ register_gradient_select_procs (Gimp *gimp)
* gimp-gradients-set-popup
*/
procedure = gimp_procedure_new (gradients_set_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-gradients-set-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-set-popup",
"gimp-gradients-set-popup",
"Sets the current gradient selection in a popup.",
"Sets the current gradient selection in a popup.",

10
app/pdb/gradients_cmds.c
View File

@ -286,8 +286,8 @@ register_gradients_procs (Gimp *gimp)
* 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",
"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.",
@ -303,8 +303,8 @@ register_gradients_procs (Gimp *gimp)
* 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",
"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.",
@ -338,8 +338,8 @@ register_gradients_procs (Gimp *gimp)
* 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",
"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.",
@ -378,8 +378,8 @@ register_gradients_procs (Gimp *gimp)
* 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",
"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.",
@ -423,8 +423,8 @@ register_gradients_procs (Gimp *gimp)
* 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",
"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.",

20
app/pdb/grid_cmds.c
View File

@ -364,8 +364,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -399,8 +399,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -434,8 +434,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -469,8 +469,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -504,8 +504,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -533,8 +533,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -562,8 +562,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -591,8 +591,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",
@ -620,8 +620,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"gimp-image-grid-get-style",
"Gets the style of an image's grid.",
"This procedure retrieves the style of an image's grid.",
@ -650,8 +650,8 @@ register_grid_procs (Gimp *gimp)
* 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",
"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.",

12
app/pdb/guides_cmds.c
View File

@ -243,8 +243,8 @@ register_guides_procs (Gimp *gimp)
* 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",
"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.",
@ -278,8 +278,8 @@ register_guides_procs (Gimp *gimp)
* 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",
"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.",
@ -313,8 +313,8 @@ register_guides_procs (Gimp *gimp)
* 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",
"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.",
@ -342,8 +342,8 @@ register_guides_procs (Gimp *gimp)
* 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",
"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.",
@ -377,8 +377,8 @@ register_guides_procs (Gimp *gimp)
* 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",
"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.",
@ -415,8 +415,8 @@ register_guides_procs (Gimp *gimp)
* 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",
"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.",

2
app/pdb/help_cmds.c
View File

@ -68,8 +68,8 @@ register_help_procs (Gimp *gimp)
* 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",
"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.",

144
app/pdb/image_cmds.c
View File

@ -2149,8 +2149,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-list
*/
procedure = gimp_procedure_new (image_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-list");
gimp_procedure_set_static_strings (procedure,
"gimp-image-list",
"gimp-image-list",
"Returns the list of images currently open.",
"This procedure returns the list of images currently open in the GIMP.",
@ -2177,8 +2177,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-new
*/
procedure = gimp_procedure_new (image_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-new");
gimp_procedure_set_static_strings (procedure,
"gimp-image-new",
"gimp-image-new",
"Creates a new image with the specified width, height, and type.",
"Creates a new image, undisplayed with the specified extents and type. A layer should be created and added before this image is displayed, or subsequent calls to 'gimp_display_new' with this image as an argument will fail. Layers can be created using the 'gimp_layer_new' commands. They can be added to an image using the 'gimp_image_add_layer' command.",
@ -2219,8 +2219,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-duplicate
*/
procedure = gimp_procedure_new (image_duplicate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-duplicate");
gimp_procedure_set_static_strings (procedure,
"gimp-image-duplicate",
"gimp-image-duplicate",
"Duplicate the specified image",
"This procedure duplicates the specified image, copying all layers, channels, and image information.",
@ -2248,8 +2248,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-delete
*/
procedure = gimp_procedure_new (image_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-image-delete",
"gimp-image-delete",
"Delete the specified image.",
"If there are no displays associated with this image it will be deleted. This means that you can not delete an image through the PDB that was created by the user. If the associated display was however created through the PDB and you know the display ID, you may delete the display. Removal of the last associated display will then delete the image.",
@ -2271,8 +2271,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-base-type
*/
procedure = gimp_procedure_new (image_base_type_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-base-type");
gimp_procedure_set_static_strings (procedure,
"gimp-image-base-type",
"gimp-image-base-type",
"Get the base type of the image.",
"This procedure returns the image's base type. Layers in the image must be of this subtype, but can have an optional alpha channel.",
@ -2301,8 +2301,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-width
*/
procedure = gimp_procedure_new (image_width_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-width");
gimp_procedure_set_static_strings (procedure,
"gimp-image-width",
"gimp-image-width",
"Return the width of the image",
"This procedure returns the image's width. This value is independent of any of the layers in this image. This is the \"canvas\" width.",
@ -2330,8 +2330,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-height
*/
procedure = gimp_procedure_new (image_height_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-height");
gimp_procedure_set_static_strings (procedure,
"gimp-image-height",
"gimp-image-height",
"Return the height of the image",
"This procedure returns the image's height. This value is independent of any of the layers in this image. This is the \"canvas\" height.",
@ -2359,8 +2359,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-free-shadow
*/
procedure = gimp_procedure_new (image_free_shadow_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-free-shadow");
gimp_procedure_set_static_strings (procedure,
"gimp-image-free-shadow",
"gimp-image-free-shadow",
"Free the specified image's shadow data (if it exists).",
"This procedure is intended as a memory saving device. If any shadow memory has been allocated, it will be freed automatically on a call to 'gimp_image_delete'.",
@ -2382,8 +2382,8 @@ register_image_procs (Gimp *gimp)
* 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",
"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. No bounds checking is currently provided, so don't supply parameters that are out of bounds. 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.",
@ -2429,8 +2429,8 @@ register_image_procs (Gimp *gimp)
* 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",
"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.",
@ -2452,8 +2452,8 @@ register_image_procs (Gimp *gimp)
* 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",
"gimp-image-scale",
"Scale the image to the specified extents.",
"This procedure scales the image so that its new width and height are equal to the supplied parameters. Offsets are also provided which describe the position of the previous image's content. No bounds checking is currently provided, so don't supply parameters that are out of bounds. All channels within the image are scaled according to the specified parameters; this includes the image selection mask. All layers within the image are repositioned according to the specified offsets.",
@ -2487,8 +2487,8 @@ register_image_procs (Gimp *gimp)
* 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",
"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.",
@ -2534,8 +2534,8 @@ register_image_procs (Gimp *gimp)
* 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",
"gimp-image-flip",
"Flips the image horizontally or vertically.",
"This procedure flips (mirrors) the image.",
@ -2566,8 +2566,8 @@ register_image_procs (Gimp *gimp)
* 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",
"gimp-image-rotate",
"Rotates the image by the specified degrees.",
"This procedure rotates the image.",
@ -2596,8 +2596,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-layers
*/
procedure = gimp_procedure_new (image_get_layers_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-layers");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-layers",
"gimp-image-get-layers",
"Returns the list of layers contained in the specified image.",
"This procedure returns the list of layers contained in the specified image. The order of layers is from topmost to bottommost.",
@ -2630,8 +2630,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-channels
*/
procedure = gimp_procedure_new (image_get_channels_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-channels");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-channels",
"gimp-image-get-channels",
"Returns the list of channels contained in the specified image.",
"This procedure returns the list of channels contained in the specified image. This does not include the selection mask, or layer masks. The order is from topmost to bottommost.",
@ -2664,8 +2664,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-vectors
*/
procedure = gimp_procedure_new (image_get_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-vectors",
"gimp-image-get-vectors",
"Returns the list of vectors contained in the specified image.",
"This procedure returns the list of vectors contained in the specified image.",
@ -2698,8 +2698,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-active-drawable
*/
procedure = gimp_procedure_new (image_get_active_drawable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-active-drawable");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-drawable",
"gimp-image-get-active-drawable",
"Get the image's active drawable",
"This procedure returns the ID of the image's active drawable. This can be either a layer, a channel, or a layer mask. The active drawable is specified by the active image channel. If that is -1, then by the active image layer. If the active image layer has a layer mask and the layer mask is in edit mode, then the layer mask is the active drawable.",
@ -2727,8 +2727,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-unset-active-channel
*/
procedure = gimp_procedure_new (image_unset_active_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-unset-active-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-unset-active-channel",
"gimp-image-unset-active-channel",
"Unsets the active channel in the specified image.",
"If an active channel exists, it is unset. There then exists no active channel, and if desired, one can be set through a call to 'Set Active Channel'. No error is returned in the case of no existing active channel.",
@ -2750,8 +2750,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-floating-sel
*/
procedure = gimp_procedure_new (image_get_floating_sel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-floating-sel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-floating-sel",
"gimp-image-get-floating-sel",
"Return the floating selection of the image.",
"This procedure returns the image's floating selection, if it exists. If it doesn't exist, -1 is returned as the layer ID.",
@ -2779,8 +2779,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-floating-sel-attached-to
*/
procedure = gimp_procedure_new (image_floating_sel_attached_to_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-floating-sel-attached-to");
gimp_procedure_set_static_strings (procedure,
"gimp-image-floating-sel-attached-to",
"gimp-image-floating-sel-attached-to",
"Return the drawable the floating selection is attached to.",
"This procedure returns the drawable the image's floating selection is attached to, if it exists. If it doesn't exist, -1 is returned as the drawable ID.",
@ -2808,8 +2808,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-pick-color
*/
procedure = gimp_procedure_new (image_pick_color_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-pick-color");
gimp_procedure_set_static_strings (procedure,
"gimp-image-pick-color",
"gimp-image-pick-color",
"Determine the color at the given drawable coordinates",
"This tool determines the color at the specified coordinates. The returned color is an RGB triplet even for grayscale and indexed drawables. If the coordinates lie outside of the extents of the specified drawable, then an error is returned. If the drawable has an alpha channel, the algorithm examines the alpha value of the drawable at the coordinates. If the alpha value is completely transparent (0), then an error is returned. If the sample_merged parameter is TRUE, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of a merged sampling, the supplied drawable is ignored.",
@ -2873,8 +2873,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-pick-correlate-layer
*/
procedure = gimp_procedure_new (image_pick_correlate_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-pick-correlate-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-pick-correlate-layer",
"gimp-image-pick-correlate-layer",
"Find the layer visible at the specified coordinates.",
"This procedure finds the layer which is visible at the specified coordinates. Layers which do not qualify are those whose extents do not pass within the specified coordinates, or which are transparent at the specified coordinates. This procedure will return -1 if no layer is found.",
@ -2914,8 +2914,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-add-layer
*/
procedure = gimp_procedure_new (image_add_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-add-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-layer",
"gimp-image-add-layer",
"Add the specified layer to the image.",
"This procedure adds the specified layer to the image at the given position. If the position is specified as -1, then the layer is inserted at the top of the layer stack. If the layer to be added has no alpha channel, it must be added at position 0. The layer type must be compatible with the image base type.",
@ -2949,8 +2949,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-remove-layer
*/
procedure = gimp_procedure_new (image_remove_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-remove-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-layer",
"gimp-image-remove-layer",
"Remove the specified layer from the image.",
"This procedure removes the specified layer from the image. If the layer doesn't exist, an error is returned. If there are no layers left in the image, this call will fail. If this layer is the last layer remaining, the image will become empty and have no active layer.",
@ -2978,8 +2978,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-raise-layer
*/
procedure = gimp_procedure_new (image_raise_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-raise-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-layer",
"gimp-image-raise-layer",
"Raise the specified layer in the image's layer stack",
"This procedure raises the specified layer one step in the existing layer stack. It will not move the layer if there is no layer above it.",
@ -3007,8 +3007,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-lower-layer
*/
procedure = gimp_procedure_new (image_lower_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-lower-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-layer",
"gimp-image-lower-layer",
"Lower the specified layer in the image's layer stack",
"This procedure lowers the specified layer one step in the existing layer stack. It will not move the layer if there is no layer below it.",
@ -3036,8 +3036,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-raise-layer-to-top
*/
procedure = gimp_procedure_new (image_raise_layer_to_top_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-raise-layer-to-top");
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-layer-to-top",
"gimp-image-raise-layer-to-top",
"Raise the specified layer in the image's layer stack to top of stack",
"This procedure raises the specified layer to top of the existing layer stack. It will not move the layer if there is no layer above it.",
@ -3065,8 +3065,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-lower-layer-to-bottom
*/
procedure = gimp_procedure_new (image_lower_layer_to_bottom_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-lower-layer-to-bottom");
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-layer-to-bottom",
"gimp-image-lower-layer-to-bottom",
"Lower the specified layer in the image's layer stack to bottom of stack",
"This procedure lowers the specified layer to bottom of the existing layer stack. It will not move the layer if there is no layer below it.",
@ -3094,8 +3094,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-add-channel
*/
procedure = gimp_procedure_new (image_add_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-add-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-channel",
"gimp-image-add-channel",
"Add the specified channel to the image.",
"This procedure adds the specified channel to the image. The position channel is not currently used, so the channel is always inserted at the top of the channel stack.",
@ -3129,8 +3129,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-remove-channel
*/
procedure = gimp_procedure_new (image_remove_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-remove-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-channel",
"gimp-image-remove-channel",
"Remove the specified channel from the image.",
"This procedure removes the specified channel from the image. If the channel doesn't exist, an error is returned.",
@ -3158,8 +3158,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-raise-channel
*/
procedure = gimp_procedure_new (image_raise_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-raise-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-channel",
"gimp-image-raise-channel",
"Raise the specified channel in the image's channel stack",
"This procedure raises the specified channel one step in the existing channel stack. It will not move the channel if there is no channel above it.",
@ -3187,8 +3187,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-lower-channel
*/
procedure = gimp_procedure_new (image_lower_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-lower-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-channel",
"gimp-image-lower-channel",
"Lower the specified channel in the image's channel stack",
"This procedure lowers the specified channel one step in the existing channel stack. It will not move the channel if there is no channel below it.",
@ -3216,8 +3216,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-add-vectors
*/
procedure = gimp_procedure_new (image_add_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-add-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-vectors",
"gimp-image-add-vectors",
"Add the specified vectors object to the image.",
"This procedure adds the specified vectors object to the image at the given position. If the position is specified as -1, then the vectors object is inserted at the top of the vectors stack.",
@ -3251,8 +3251,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-remove-vectors
*/
procedure = gimp_procedure_new (image_remove_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-remove-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-vectors",
"gimp-image-remove-vectors",
"Remove the specified path from the image.",
"This procedure removes the specified path from the image. If the path doesn't exist, an error is returned.",
@ -3280,8 +3280,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-raise-vectors
*/
procedure = gimp_procedure_new (image_raise_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-raise-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-vectors",
"gimp-image-raise-vectors",
"Raise the specified vectors in the image's vectors stack",
"This procedure raises the specified vectors one step in the existing vectors stack. It will not move the vectors if there is no vectors above it.",
@ -3309,8 +3309,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-lower-vectors
*/
procedure = gimp_procedure_new (image_lower_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-lower-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-vectors",
"gimp-image-lower-vectors",
"Lower the specified vectors in the image's vectors stack",
"This procedure lowers the specified vectors one step in the existing vectors stack. It will not move the vectors if there is no vectors below it.",
@ -3338,8 +3338,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-raise-vectors-to-top
*/
procedure = gimp_procedure_new (image_raise_vectors_to_top_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-raise-vectors-to-top");
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-vectors-to-top",
"gimp-image-raise-vectors-to-top",
"Raise the specified vectors in the image's vectors stack to top of stack",
"This procedure raises the specified vectors to top of the existing vectors stack. It will not move the vectors if there is no vectors above it.",
@ -3367,8 +3367,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-lower-vectors-to-bottom
*/
procedure = gimp_procedure_new (image_lower_vectors_to_bottom_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-lower-vectors-to-bottom");
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-vectors-to-bottom",
"gimp-image-lower-vectors-to-bottom",
"Lower the specified vectors in the image's vectors stack to bottom of stack",
"This procedure lowers the specified vectors to bottom of the existing vectors stack. It will not move the vectors if there is no vectors below it.",
@ -3396,8 +3396,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-flatten
*/
procedure = gimp_procedure_new (image_flatten_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-flatten");
gimp_procedure_set_static_strings (procedure,
"gimp-image-flatten",
"gimp-image-flatten",
"Flatten all visible layers into a single layer. Discard all invisible layers.",
"This procedure combines the visible layers in a manner analogous to merging with the CLIP_TO_IMAGE merge type. Non-visible layers are discarded, and the resulting image is stripped of its alpha channel.",
@ -3425,8 +3425,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-merge-visible-layers
*/
procedure = gimp_procedure_new (image_merge_visible_layers_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-merge-visible-layers");
gimp_procedure_set_static_strings (procedure,
"gimp-image-merge-visible-layers",
"gimp-image-merge-visible-layers",
"Merge the visible image layers into one.",
"This procedure combines the visible layers into a single layer using the specified merge type. A merge type of EXPAND_AS_NECESSARY expands the final layer to encompass the areas of the visible layers. A merge type of CLIP_TO_IMAGE clips the final layer to the extents of the image. A merge type of CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the bottommost layer.",
@ -3463,8 +3463,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-merge-down
*/
procedure = gimp_procedure_new (image_merge_down_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-merge-down");
gimp_procedure_set_static_strings (procedure,
"gimp-image-merge-down",
"gimp-image-merge-down",
"Merge the layer passed and the first visible layer below.",
"This procedure combines the passed layer and the first visible layer below it using the specified merge type. A merge type of EXPAND_AS_NECESSARY expands the final layer to encompass the areas of the visible layers. A merge type of CLIP_TO_IMAGE clips the final layer to the extents of the image. A merge type of CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the bottommost layer.",
@ -3507,8 +3507,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-add-layer-mask
*/
procedure = gimp_procedure_new (image_add_layer_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-add-layer-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-layer-mask",
"gimp-image-add-layer-mask",
"This procedure is deprecated! Use 'gimp-layer-add-mask' instead.",
"This procedure is deprecated! Use 'gimp-layer-add-mask' instead.",
@ -3542,8 +3542,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-remove-layer-mask
*/
procedure = gimp_procedure_new (image_remove_layer_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-remove-layer-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-layer-mask",
"gimp-image-remove-layer-mask",
"This procedure is deprecated! Use 'gimp-layer-remove-mask' instead.",
"This procedure is deprecated! Use 'gimp-layer-remove-mask' instead.",
@ -3578,8 +3578,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-colormap
*/
procedure = gimp_procedure_new (image_get_colormap_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-colormap");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-colormap",
"gimp-image-get-colormap",
"Returns the image's colormap",
"This procedure returns an actual pointer to the image's colormap, as well as the number of bytes contained in the colormap. The actual number of colors in the transmitted colormap will be \"num_bytes\" / 3. If the image is not of base type GIMP_INDEXED, this pointer will be NULL.",
@ -3612,8 +3612,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-colormap
*/
procedure = gimp_procedure_new (image_set_colormap_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-colormap");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-colormap",
"gimp-image-set-colormap",
"Sets the entries in the image's colormap.",
"This procedure sets the entries in the specified image's colormap. The number of entries is specified by the \"num_bytes\" parameter and corresponds to the number of INT8 triples that must be contained in the \"colormap\" array. The actual number of colors in the transmitted colormap is \"num_bytes\" / 3.",
@ -3646,8 +3646,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-clean-all
*/
procedure = gimp_procedure_new (image_clean_all_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-clean-all");
gimp_procedure_set_static_strings (procedure,
"gimp-image-clean-all",
"gimp-image-clean-all",
"Set the image dirty count to 0.",
"This procedure sets the specified image's dirty count to 0, allowing operations to occur without having a 'dirtied' image. This is especially useful for creating and loading images which should not initially be considered dirty, even though layers must be created, filled, and installed in the image. Note that save plug-ins must NOT call this function themselves after saving the image.",
@ -3669,8 +3669,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-is-dirty
*/
procedure = gimp_procedure_new (image_is_dirty_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-is-dirty");
gimp_procedure_set_static_strings (procedure,
"gimp-image-is-dirty",
"gimp-image-is-dirty",
"Checks if the image has unsaved changes.",
"This procedure checks the specified image's dirty count to see if it needs to be saved. Note that saving the image does not automatically set the dirty count to 0, you need to call gimp-image-clean-all after calling a save procedure to make the image clean.",
@ -3698,8 +3698,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-thumbnail
*/
procedure = gimp_procedure_new (image_thumbnail_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-thumbnail");
gimp_procedure_set_static_strings (procedure,
"gimp-image-thumbnail",
"gimp-image-thumbnail",
"Get a thumbnail of an image.",
"This function gets data from which a thumbnail of an image preview can be created. Maximum x or y dimension is 1024 pixels. The pixels are returned in RGB[A] or GRAY[A] format. The bpp return value gives the number of bits per pixel in the image.",
@ -3762,8 +3762,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-active-layer
*/
procedure = gimp_procedure_new (image_get_active_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-active-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-layer",
"gimp-image-get-active-layer",
"Returns the specified image's active layer.",
"If there is an active layer, its ID will be returned, otherwise, -1. If a channel is currently active, then no layer will be. If a layer mask is active, then this will return the associated layer.",
@ -3791,8 +3791,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-active-layer
*/
procedure = gimp_procedure_new (image_set_active_layer_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-active-layer");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-active-layer",
"gimp-image-set-active-layer",
"Sets the specified image's active layer.",
"If the layer exists, it is set as the active layer in the image. Any previous active layer or channel is set to inactive. An exception is a previously existing floating selection, in which case this procedure will return an execution error.",
@ -3820,8 +3820,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-active-channel
*/
procedure = gimp_procedure_new (image_get_active_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-active-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-channel",
"gimp-image-get-active-channel",
"Returns the specified image's active channel.",
"If there is an active channel, this will return the channel ID, otherwise, -1.",
@ -3849,8 +3849,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-active-channel
*/
procedure = gimp_procedure_new (image_set_active_channel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-active-channel");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-active-channel",
"gimp-image-set-active-channel",
"Sets the specified image's active channel.",
"If the channel exists, it is set as the active channel in the image. Any previous active channel or channel is set to inactive. An exception is a previously existing floating selection, in which case this procedure will return an execution error.",
@ -3878,8 +3878,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-active-vectors
*/
procedure = gimp_procedure_new (image_get_active_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-active-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-vectors",
"gimp-image-get-active-vectors",
"Returns the specified image's active vectors.",
"If there is an active path, its ID will be returned, otherwise, -1.",
@ -3907,8 +3907,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-active-vectors
*/
procedure = gimp_procedure_new (image_set_active_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-active-vectors");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-active-vectors",
"gimp-image-set-active-vectors",
"Sets the specified image's active vectors.",
"If the path exists, it is set as the active path in the image.",
@ -3936,8 +3936,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-selection
*/
procedure = gimp_procedure_new (image_get_selection_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-selection");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-selection",
"gimp-image-get-selection",
"Returns the specified image's selection.",
"This will always return a valid ID for a selection -- which is represented as a channel internally.",
@ -3965,8 +3965,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-component-active
*/
procedure = gimp_procedure_new (image_get_component_active_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-component-active");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-component-active",
"gimp-image-get-component-active",
"Returns if the specified image's image component is active.",
"This procedure returns if the specified image's image component (i.e. Red, Green, Blue intensity channels in an RGB image) is active or inactive -- whether or not it can be modified. If the specified component is not valid for the image type, an error is returned.",
@ -4001,8 +4001,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-component-active
*/
procedure = gimp_procedure_new (image_set_component_active_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-component-active");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-component-active",
"gimp-image-set-component-active",
"Sets if the specified image's image component is active.",
"This procedure sets if the specified image's image component (i.e. Red, Green, Blue intensity channels in an RGB image) is active or inactive -- whether or not it can be modified. If the specified component is not valid for the image type, an error is returned.",
@ -4037,8 +4037,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-component-visible
*/
procedure = gimp_procedure_new (image_get_component_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-component-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-component-visible",
"gimp-image-get-component-visible",
"Returns if the specified image's image component is visible.",
"This procedure returns if the specified image's image component (i.e. Red, Green, Blue intensity channels in an RGB image) is visible or invisible -- whether or not it can be seen. If the specified component is not valid for the image type, an error is returned.",
@ -4073,8 +4073,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-component-visible
*/
procedure = gimp_procedure_new (image_set_component_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-component-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-component-visible",
"gimp-image-set-component-visible",
"Sets if the specified image's image component is visible.",
"This procedure sets if the specified image's image component (i.e. Red, Green, Blue intensity channels in an RGB image) is visible or invisible -- whether or not it can be seen. If the specified component is not valid for the image type, an error is returned.",
@ -4109,8 +4109,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-filename
*/
procedure = gimp_procedure_new (image_get_filename_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-filename");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-filename",
"gimp-image-get-filename",
"Returns the specified image's filename.",
"This procedure returns the specified image's filename in the filesystem encoding. The image has a filename only if it was loaded or has since been saved. Otherwise, this function returns %NULL.",
@ -4139,8 +4139,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-filename
*/
procedure = gimp_procedure_new (image_set_filename_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-filename");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-filename",
"gimp-image-set-filename",
"Sets the specified image's filename.",
"This procedure sets the specified image's filename. The filename should be in the filesystem encoding.",
@ -4169,8 +4169,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-name
*/
procedure = gimp_procedure_new (image_get_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-name");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-name",
"gimp-image-get-name",
"Returns the specified image's name.",
"This procedure returns the specified image's name.",
@ -4199,8 +4199,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-resolution
*/
procedure = gimp_procedure_new (image_get_resolution_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-resolution");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-resolution",
"gimp-image-get-resolution",
"Returns the specified image's resolution.",
"This procedure returns the specified image's resolution in dots per inch. This value is independent of any of the layers in this image.",
@ -4234,8 +4234,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-resolution
*/
procedure = gimp_procedure_new (image_set_resolution_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-resolution");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-resolution",
"gimp-image-set-resolution",
"Sets the specified image's resolution.",
"This procedure sets the specified image's resolution in dots per inch. This value is independent of any of the layers in this image. No scaling or resizing is performed.",
@ -4269,8 +4269,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-unit
*/
procedure = gimp_procedure_new (image_get_unit_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-unit");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-unit",
"gimp-image-get-unit",
"Returns the specified image's unit.",
"This procedure returns the specified image's unit. This value is independent of any of the layers in this image. See the gimp_unit_* procedure definitions for the valid range of unit IDs and a description of the unit system.",
@ -4300,8 +4300,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-unit
*/
procedure = gimp_procedure_new (image_set_unit_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-unit");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-unit",
"gimp-image-set-unit",
"Sets the specified image's unit.",
"This procedure sets the specified image's unit. No scaling or resizing is performed. This value is independent of any of the layers in this image. See the gimp_unit_* procedure definitions for the valid range of unit IDs and a description of the unit system.",
@ -4331,8 +4331,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-tattoo-state
*/
procedure = gimp_procedure_new (image_get_tattoo_state_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-tattoo-state");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-tattoo-state",
"gimp-image-get-tattoo-state",
"Returns the tattoo state associated with the image.",
"This procedure returns the tattoo state of the image. Use only by save/load plugins that wish to preserve an images tattoo state. Using this function at other times will produce unexpected results.",
@ -4360,8 +4360,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-set-tattoo-state
*/
procedure = gimp_procedure_new (image_set_tattoo_state_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-set-tattoo-state");
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-tattoo-state",
"gimp-image-set-tattoo-state",
"Set the tattoo state associated with the image.",
"This procedure sets the tattoo state of the image. Use only by save/load plugins that wish to preserve an images tattoo state. Using this function at other times will produce unexpected results. A full check of uniqueness of states in layers, channels and paths will be performed by this procedure and a execution failure will be returned if this fails. A failure will also be returned if the new tattoo state value is less than the maximum tattoo value from all of the tattoos from the paths, layers and channels. After the image data has been loaded and all the tattoos have been set then this is the last procedure that should be called. If effectively does a status check on the tattoo values that have been set to make sure that all is OK.",
@ -4389,8 +4389,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-layer-by-tattoo
*/
procedure = gimp_procedure_new (image_get_layer_by_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-layer-by-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-layer-by-tattoo",
"gimp-image-get-layer-by-tattoo",
"Find a layer with a given tattoo in an image.",
"This procedure returns the layer with the given tattoo in the specified image.",
@ -4424,8 +4424,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-channel-by-tattoo
*/
procedure = gimp_procedure_new (image_get_channel_by_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-channel-by-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-channel-by-tattoo",
"gimp-image-get-channel-by-tattoo",
"Find a channel with a given tattoo in an image.",
"This procedure returns the channel with the given tattoo in the specified image.",
@ -4459,8 +4459,8 @@ register_image_procs (Gimp *gimp)
* gimp-image-get-vectors-by-tattoo
*/
procedure = gimp_procedure_new (image_get_vectors_by_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-image-get-vectors-by-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-vectors-by-tattoo",
"gimp-image-get-vectors-by-tattoo",
"Find a vectors with a given tattoo in an image.",
"This procedure returns the vectors with the given tattoo in the specified image.",

54
app/pdb/layer_cmds.c
View File

@ -821,8 +821,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-new
*/
procedure = gimp_procedure_new (layer_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-new");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-new",
"gimp-layer-new",
"Create a new layer.",
"This procedure creates a new layer with the specified width, height, and type. Name, opacity, and mode are also supplied parameters. The new layer still needs to be added to the image, as this is not automatic. Add the new layer with the 'gimp_image_add_layer' command. Other attributes such as layer mask modes, and offsets should be set with explicit procedure calls.",
@ -889,8 +889,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-new-from-drawable
*/
procedure = gimp_procedure_new (layer_new_from_drawable_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-new-from-drawable");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-new-from-drawable",
"gimp-layer-new-from-drawable",
"Create a new layer by copying an existing drawable.",
"This procedure creates a new layer as a copy of the specified drawable. The new layer still needs to be added to the image, as this is not automatic. Add the new layer with the 'gimp_image_add_layer' command. Other attributes such as layer mask modes, and offsets should be set with explicit procedure calls.",
@ -924,8 +924,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-copy
*/
procedure = gimp_procedure_new (layer_copy_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-copy");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-copy",
"gimp-layer-copy",
"Copy a layer.",
"This procedure copies the specified layer and returns the copy. The newly copied layer is for use within the original layer's image. It should not be subsequently added to any other image. The copied layer can optionally have an added alpha channel. This is useful if the background layer in an image is being copied and added to the same image.",
@ -959,8 +959,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-add-alpha
*/
procedure = gimp_procedure_new (layer_add_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-add-alpha");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-add-alpha",
"gimp-layer-add-alpha",
"Add an alpha channel to the layer if it doesn't already have one.",
"This procedure adds an additional component to the specified layer if it does not already possess an alpha channel. An alpha channel makes it possible to move a layer from the bottom of the layer stack and to clear and erase to transparency, instead of the background color. This transforms images of type RGB to RGBA, GRAY to GRAYA, and INDEXED to INDEXEDA.",
@ -982,8 +982,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-scale
*/
procedure = gimp_procedure_new (layer_scale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-scale");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-scale",
"gimp-layer-scale",
"Scale the layer to the specified extents.",
"This procedure scales the layer so that its new width and height are equal to the supplied parameters. The \"local_origin\" parameter specifies whether to scale from the center of the layer, or from the image origin. This operation only works if the layer has been added to an image.",
@ -1023,8 +1023,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-resize
*/
procedure = gimp_procedure_new (layer_resize_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-resize");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-resize",
"gimp-layer-resize",
"Resize the layer to the specified extents.",
"This procedure resizes the layer so that its new width and height are equal to the supplied parameters. Offsets are also provided which describe the position of the previous layer's content. This operation only works if the layer has been added to an image.",
@ -1070,8 +1070,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-resize-to-image-size
*/
procedure = gimp_procedure_new (layer_resize_to_image_size_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-resize-to-image-size");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-resize-to-image-size",
"gimp-layer-resize-to-image-size",
"Resize a layer to the image size.",
"This procedure resizes the layer so that it's new width and height are equal to the width and height of its image container.",
@ -1093,8 +1093,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-translate
*/
procedure = gimp_procedure_new (layer_translate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-translate");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-translate",
"gimp-layer-translate",
"Translate the layer by the specified offsets.",
"This procedure translates the layer by the amounts specified in the x and y arguments. These can be negative, and are considered offsets from the current position. This command only works if the layer has been added to an image. All additional layers contained in the image which have the linked flag set to TRUE w ill also be translated by the specified offsets.",
@ -1128,8 +1128,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-offsets
*/
procedure = gimp_procedure_new (layer_set_offsets_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-offsets");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-offsets",
"gimp-layer-set-offsets",
"Set the layer offsets.",
"This procedure sets the offsets for the specified layer. The offsets are relative to the image origin and can be any values. This operation is valid only on layers which have been added to an image.",
@ -1163,8 +1163,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-create-mask
*/
procedure = gimp_procedure_new (layer_create_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-create-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-create-mask",
"gimp-layer-create-mask",
"Create a layer mask for the specified specified layer.",
"This procedure creates a layer mask for the specified layer. Layer masks serve as an additional alpha channel for a layer. A number of ifferent types of masks are allowed for initialisation: completely white masks (which will leave the layer fully visible), completely black masks (which will give the layer complete transparency, the layer's already existing alpha channel (which will leave the layer fully visible, but which may be more useful than a white mask), the current selection or a grayscale copy of the layer. The layer mask still needs to be added to the layer. This can be done with a call to 'gimp_layer_add_mask'.",
@ -1199,8 +1199,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-mask
*/
procedure = gimp_procedure_new (layer_get_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-mask",
"gimp-layer-get-mask",
"Get the specified layer's mask if it exists.",
"This procedure returns the specified layer's mask, or -1 if none exists.",
@ -1228,8 +1228,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-from-mask
*/
procedure = gimp_procedure_new (layer_from_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-from-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-from-mask",
"gimp-layer-from-mask",
"Get the specified mask's layer.",
"This procedure returns the specified mask's layer , or -1 if none exists.",
@ -1257,8 +1257,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-add-mask
*/
procedure = gimp_procedure_new (layer_add_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-add-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-add-mask",
"gimp-layer-add-mask",
"Add a layer mask to the specified layer.",
"This procedure adds a layer mask to the specified layer. Layer masks serve as an additional alpha channel for a layer. This procedure will fail if a number of prerequisites aren't met. The layer cannot already have a layer mask. The specified mask must exist and have the same dimensions as the layer. Both the mask and the layer must have been created for use with the specified image.",
@ -1286,8 +1286,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-remove-mask
*/
procedure = gimp_procedure_new (layer_remove_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-remove-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-remove-mask",
"gimp-layer-remove-mask",
"Remove the specified layer mask from the layer.",
"This procedure removes the specified layer mask from the layer. If the mask doesn't exist, an error is returned.",
@ -1316,8 +1316,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-is-floating-sel
*/
procedure = gimp_procedure_new (layer_is_floating_sel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-is-floating-sel");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-is-floating-sel",
"gimp-layer-is-floating-sel",
"Is the specified layer a floating selection?",
"This procedure returns whether the layer is a floating selection. Floating selections are special cases of layers which are attached to a specific drawable.",
@ -1345,8 +1345,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-lock-alpha
*/
procedure = gimp_procedure_new (layer_get_lock_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-lock-alpha");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-lock-alpha",
"gimp-layer-get-lock-alpha",
"Get the lock alpha channel setting of the specified layer.",
"This procedure returns the specified layer's lock alpha channel setting.",
@ -1374,8 +1374,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-lock-alpha
*/
procedure = gimp_procedure_new (layer_set_lock_alpha_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-lock-alpha");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-lock-alpha",
"gimp-layer-set-lock-alpha",
"Set the lock alpha channel setting of the specified layer.",
"This procedure sets the specified layer's lock alpha channel setting.",
@ -1403,8 +1403,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-apply-mask
*/
procedure = gimp_procedure_new (layer_get_apply_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-apply-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-apply-mask",
"gimp-layer-get-apply-mask",
"Get the apply mask setting of the specified layer.",
"This procedure returns the specified layer's apply mask setting. If the value is TRUE, then the layer mask for this layer is currently being composited with the layer's alpha channel.",
@ -1432,8 +1432,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-apply-mask
*/
procedure = gimp_procedure_new (layer_set_apply_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-apply-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-apply-mask",
"gimp-layer-set-apply-mask",
"Set the apply mask setting of the specified layer.",
"This procedure sets the specified layer's apply mask setting. This controls whether the layer's mask is currently affecting the alpha channel. If there is no layer mask, this function will return an error.",
@ -1461,8 +1461,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-show-mask
*/
procedure = gimp_procedure_new (layer_get_show_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-show-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-show-mask",
"gimp-layer-get-show-mask",
"Get the show mask setting of the specified layer.",
"This procedure returns the specified layer's show mask setting. This controls whether the layer or its mask is visible. TRUE indicates that the mask should be visible. If the layer has no mask, then this function returns an error.",
@ -1490,8 +1490,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-show-mask
*/
procedure = gimp_procedure_new (layer_set_show_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-show-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-show-mask",
"gimp-layer-set-show-mask",
"Set the show mask setting of the specified layer.",
"This procedure sets the specified layer's show mask setting. This controls whether the layer's mask is currently affecting the alpha channel. If there is no layer mask, this function will return an error.",
@ -1519,8 +1519,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-edit-mask
*/
procedure = gimp_procedure_new (layer_get_edit_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-edit-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-edit-mask",
"gimp-layer-get-edit-mask",
"Get the edit mask setting of the specified layer.",
"This procedure returns the specified layer's edit mask setting. If the value is TRUE, then the layer mask for this layer is currently active, and not the layer.",
@ -1548,8 +1548,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-edit-mask
*/
procedure = gimp_procedure_new (layer_set_edit_mask_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-edit-mask");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-edit-mask",
"gimp-layer-set-edit-mask",
"Set the edit mask setting of the specified layer.",
"This procedure sets the specified layer's edit mask setting. This controls whether the layer or it's mask is currently active for editing. If the specified layer has no layer mask, then this procedure will return an error.",
@ -1577,8 +1577,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-opacity
*/
procedure = gimp_procedure_new (layer_get_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-opacity",
"gimp-layer-get-opacity",
"Get the opacity of the specified layer.",
"This procedure returns the specified layer's opacity.",
@ -1606,8 +1606,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-opacity
*/
procedure = gimp_procedure_new (layer_set_opacity_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-opacity");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-opacity",
"gimp-layer-set-opacity",
"Set the opacity of the specified layer.",
"This procedure sets the specified layer's opacity.",
@ -1635,8 +1635,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-get-mode
*/
procedure = gimp_procedure_new (layer_get_mode_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-get-mode");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-mode",
"gimp-layer-get-mode",
"Get the combination mode of the specified layer.",
"This procedure returns the specified layer's combination mode.",
@ -1665,8 +1665,8 @@ register_layer_procs (Gimp *gimp)
* gimp-layer-set-mode
*/
procedure = gimp_procedure_new (layer_set_mode_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-layer-set-mode");
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-mode",
"gimp-layer-set-mode",
"Set the combination mode of the specified layer.",
"This procedure sets the specified layer's combination mode.",

6
app/pdb/message_cmds.c
View File

@ -105,8 +105,8 @@ register_message_procs (Gimp *gimp)
* 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",
"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.",
@ -129,8 +129,8 @@ register_message_procs (Gimp *gimp)
* 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",
"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.",
@ -153,8 +153,8 @@ register_message_procs (Gimp *gimp)
* 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",
"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.",

6
app/pdb/misc_cmds.c
View File

@ -110,8 +110,8 @@ register_misc_procs (Gimp *gimp)
* 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",
"gimp-version",
"Returns the host gimp version.",
"This procedure returns the version number of the currently running gimp.",
@ -134,8 +134,8 @@ register_misc_procs (Gimp *gimp)
* 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",
"gimp-getpid",
"Returns the PID of the host gimp process.",
"This procedure returns the process ID of the currently running gimp.",
@ -157,8 +157,8 @@ register_misc_procs (Gimp *gimp)
* 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",
"gimp-quit",
"Causes the gimp to exit gracefully.",
"The internal procedure which can either be used to make the gimp quit. 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.",

30
app/pdb/paint_tools_cmds.c
View File

@ -698,8 +698,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-airbrush
*/
procedure = gimp_procedure_new (airbrush_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-airbrush");
gimp_procedure_set_static_strings (procedure,
"gimp-airbrush",
"gimp-airbrush",
"Paint in the current brush with varying pressure. Paint application is time-dependent.",
"This tool simulates the use of an airbrush. Paint pressure represents the relative intensity of the paint application. High pressure results in a thicker layer of paint while low pressure results in a thinner layer.",
@ -738,8 +738,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-airbrush-default
*/
procedure = gimp_procedure_new (airbrush_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-airbrush-default");
gimp_procedure_set_static_strings (procedure,
"gimp-airbrush-default",
"gimp-airbrush-default",
"Paint in the current brush with varying pressure. Paint application is time-dependent.",
"This tool simulates the use of an airbrush. It is similar to gimp_airbrush except that the pressure is derived from the airbrush tools options box. It the option has not been set the default for the option will be used.",
@ -772,8 +772,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-clone
*/
procedure = gimp_procedure_new (clone_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-clone");
gimp_procedure_set_static_strings (procedure,
"gimp-clone",
"gimp-clone",
"Clone from the source to the dest drawable using the current brush",
"This tool clones (copies) from the source drawable starting at the specified source coordinates to the dest drawable. If the \"clone_type\" argument is set to PATTERN-CLONE, then the current pattern is used as the source and the \"src_drawable\" argument is ignored. Pattern cloning assumes a tileable pattern and mods the sum of the src coordinates and subsequent stroke offsets with the width and height of the pattern. For image cloning, if the sum of the src coordinates and subsequent stroke offsets exceeds the extents of the src drawable, then no paint is transferred. The clone tool is capable of transforming between any image types including RGB->Indexed--although converting from any type to indexed is significantly slower.",
@ -831,8 +831,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-clone-default
*/
procedure = gimp_procedure_new (clone_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-clone-default");
gimp_procedure_set_static_strings (procedure,
"gimp-clone-default",
"gimp-clone-default",
"Clone from the source to the dest drawable using the current brush",
"This tool clones (copies) from the source drawable starting at the specified source coordinates to the dest drawable. This function performs exactly the same as the gimp_clone function except that the tools arguments are obtained from the clones option dialog. It this dialog has not been activated then the dialogs default values will be used.",
@ -865,8 +865,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-convolve
*/
procedure = gimp_procedure_new (convolve_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-convolve");
gimp_procedure_set_static_strings (procedure,
"gimp-convolve",
"gimp-convolve",
"Convolve (Blur, Sharpen) using the current brush.",
"This tool convolves the specified drawable with either a sharpening or blurring kernel. The pressure parameter controls the magnitude of the operation. Like the paintbrush, this tool linearly interpolates between the specified stroke coordinates.",
@ -912,8 +912,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-convolve-default
*/
procedure = gimp_procedure_new (convolve_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-convolve-default");
gimp_procedure_set_static_strings (procedure,
"gimp-convolve-default",
"gimp-convolve-default",
"Convolve (Blur, Sharpen) using the current brush.",
"This tool convolves the specified drawable with either a sharpening or blurring kernel. This function performs exactly the same as the gimp_convolve function except that the tools arguments are obtained from the convolve option dialog. It this dialog has not been activated then the dialogs default values will be used.",
@ -946,8 +946,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-dodgeburn
*/
procedure = gimp_procedure_new (dodgeburn_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-dodgeburn");
gimp_procedure_set_static_strings (procedure,
"gimp-dodgeburn",
"gimp-dodgeburn",
"Dodgeburn image with varying exposure.",
"Dodgeburn. More details here later.",
@ -1000,8 +1000,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-dodgeburn-default
*/
procedure = gimp_procedure_new (dodgeburn_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-dodgeburn-default");
gimp_procedure_set_static_strings (procedure,
"gimp-dodgeburn-default",
"gimp-dodgeburn-default",
"Dodgeburn image with varying exposure. This is the same as the gimp_dodgeburn function except that the exposure, type and mode are taken from the tools option dialog. If the dialog has not been activated then the defaults as used by the dialog will be used.",
"Dodgeburn. More details here later.",
@ -1034,8 +1034,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-eraser
*/
procedure = gimp_procedure_new (eraser_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-eraser");
gimp_procedure_set_static_strings (procedure,
"gimp-eraser",
"gimp-eraser",
"Erase using the current brush.",
"This tool erases using the current brush mask. If the specified drawable contains an alpha channel, then the erased pixels will become transparent. Otherwise, the eraser tool replaces the contents of the drawable with the background color. Like paintbrush, this tool linearly interpolates between the specified stroke coordinates.",
@ -1082,8 +1082,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-eraser-default
*/
procedure = gimp_procedure_new (eraser_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-eraser-default");
gimp_procedure_set_static_strings (procedure,
"gimp-eraser-default",
"gimp-eraser-default",
"Erase using the current brush.",
"This tool erases using the current brush mask. This function performs exactly the same as the gimp_eraser function except that the tools arguments are obtained from the eraser option dialog. It this dialog has not been activated then the dialogs default values will be used.",
@ -1116,8 +1116,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-paintbrush
*/
procedure = gimp_procedure_new (paintbrush_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-paintbrush");
gimp_procedure_set_static_strings (procedure,
"gimp-paintbrush",
"gimp-paintbrush",
"Paint in the current brush with optional fade out parameter and pull colors from a gradient.",
"This tool is the standard paintbrush. It draws linearly interpolated lines through the specified stroke coordinates. It operates on the specified drawable in the foreground color with the active brush. The \"fade_out\" parameter is measured in pixels and allows the brush stroke to linearly fall off. The pressure is set to the maximum at the beginning of the stroke. As the distance of the stroke nears the fade_out value, the pressure will approach zero. The gradient_length is the distance to spread the gradient over. It is measured in pixels. If the gradient_length is 0, no gradient is used.",
@ -1169,8 +1169,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-paintbrush-default
*/
procedure = gimp_procedure_new (paintbrush_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-paintbrush-default");
gimp_procedure_set_static_strings (procedure,
"gimp-paintbrush-default",
"gimp-paintbrush-default",
"Paint in the current brush. The fade out parameter and pull colors from a gradient parameter are set from the paintbrush options dialog. If this dialog has not been activated then the dialog defaults will be used.",
"This tool is similar to the standard paintbrush. It draws linearly interpolated lines through the specified stroke coordinates. It operates on the specified drawable in the foreground color with the active brush. The \"fade_out\" parameter is measured in pixels and allows the brush stroke to linearly fall off (value obtained from the option dialog). The pressure is set to the maximum at the beginning of the stroke. As the distance of the stroke nears the fade_out value, the pressure will approach zero. The gradient_length (value obtained from the option dialog) is the distance to spread the gradient over. It is measured in pixels. If the gradient_length is 0, no gradient is used.",
@ -1203,8 +1203,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-pencil
*/
procedure = gimp_procedure_new (pencil_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-pencil");
gimp_procedure_set_static_strings (procedure,
"gimp-pencil",
"gimp-pencil",
"Paint in the current brush without sub-pixel sampling.",
"This tool is the standard pencil. It draws linearly interpolated lines through the specified stroke coordinates. It operates on the specified drawable in the foreground color with the active brush. The brush mask is treated as though it contains only black and white values. Any value below half is treated as black; any above half, as white.",
@ -1237,8 +1237,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-smudge
*/
procedure = gimp_procedure_new (smudge_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-smudge");
gimp_procedure_set_static_strings (procedure,
"gimp-smudge",
"gimp-smudge",
"Smudge image with varying pressure.",
"This tool simulates a smudge using the current brush. High pressure results in a greater smudge of paint while low pressure results in a lesser smudge.",
@ -1277,8 +1277,8 @@ register_paint_tools_procs (Gimp *gimp)
* gimp-smudge-default
*/
procedure = gimp_procedure_new (smudge_default_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-smudge-default");
gimp_procedure_set_static_strings (procedure,
"gimp-smudge-default",
"gimp-smudge-default",
"Smudge image with varying pressure.",
"This tool simulates a smudge using the current brush. It behaves exactly the same as gimp_smudge except that the pressure value is taken from the smudge tool options or the options default if the tools option dialog has not been activated.",

28
app/pdb/palette_cmds.c
View File

@ -579,8 +579,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-new",
"Creates a new palette",
"This procedure creates a new, uninitialized palette",
@ -610,8 +610,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-duplicate",
"Duplicates a palette",
"This procedure creates an identical palette by a different name",
@ -641,8 +641,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-rename",
"Rename a palette",
"This procedure renames a palette",
@ -679,8 +679,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-delete",
"Deletes a palette",
"This procedure deletes a palette",
@ -703,8 +703,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-is-editable",
"Tests if palette can be edited",
"Returns TRUE if you have permission to change the palette",
@ -733,8 +733,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"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.",
@ -763,8 +763,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-get-columns",
"Retrieves the number of columns to use to display this palette",
"This procedures retrieves the prefered number of columns to use when the palette is being displayed.",
@ -793,8 +793,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-set-columns",
"Sets the number of columns to use when displaying the palette",
"This procedures allows to control 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.",
@ -823,8 +823,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-add-entry",
"Adds a palette entry to the specified palette.",
"This procedure adds an entry to the specifed palette. It returns an error if the entry palette does not exist.",
@ -866,8 +866,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-delete-entry",
"Deletes a palette entry from the specified palette.",
"This procedure deletes an entry from the specifed palette. It returns an error if the entry palette does not exist.",
@ -896,8 +896,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-entry-get-color",
"Gets the specified palette entry from the specified palette.",
"This procedure retrieves the color of the zero-based entry specifed for the specified palette. It returns an error if the entry does not exist.",
@ -932,8 +932,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-entry-set-color",
"Sets the specified palette entry in the specified palette.",
"This procedure sets the color of the zero-based entry specifed for the specified palette. It returns an error if the entry does not exist.",
@ -968,8 +968,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-entry-get-name",
"Gets the specified palette entry from the specified palette.",
"This procedure retrieves the name of the zero-based entry specifed for the specified palette. It returns an error if the entry does not exist.",
@ -1005,8 +1005,8 @@ register_palette_procs (Gimp *gimp)
* 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",
"gimp-palette-entry-set-name",
"Sets the specified palette entry in the specified palette.",
"This procedure sets the name of the zero-based entry specifed for the specified palette. It returns an error if the entry does not exist.",

6
app/pdb/palette_select_cmds.c
View File

@ -121,8 +121,8 @@ register_palette_select_procs (Gimp *gimp)
* 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",
"gimp-palettes-popup",
"Invokes the Gimp palette selection.",
"This procedure popups the palette selection dialog.",
@ -159,8 +159,8 @@ register_palette_select_procs (Gimp *gimp)
* 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",
"gimp-palettes-close-popup",
"Popdown the Gimp palette selection.",
"This procedure closes an opened palette selection dialog.",
@ -183,8 +183,8 @@ register_palette_select_procs (Gimp *gimp)
* 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",
"gimp-palettes-set-popup",
"Sets the current palette selection in a popup.",
"Sets the current palette selection in a popup.",

8
app/pdb/palettes_cmds.c
View File

@ -186,8 +186,8 @@ register_palettes_procs (Gimp *gimp)
* 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",
"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.",
@ -203,8 +203,8 @@ register_palettes_procs (Gimp *gimp)
* 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",
"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'.",
@ -238,8 +238,8 @@ register_palettes_procs (Gimp *gimp)
* gimp-palettes-get-palette
*/
procedure = gimp_procedure_new (palettes_get_palette_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-palettes-get-palette");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-palette",
"gimp-palettes-get-palette",
"This procedure is deprecated! Use 'gimp-context-get-palette' instead.",
"This procedure is deprecated! Use 'gimp-context-get-palette' instead.",
@ -268,8 +268,8 @@ register_palettes_procs (Gimp *gimp)
* gimp-palettes-get-palette-entry
*/
procedure = gimp_procedure_new (palettes_get_palette_entry_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-palettes-get-palette-entry");
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-palette-entry",
"gimp-palettes-get-palette-entry",
"This procedure is deprecated! Use 'gimp-palette-entry-get-color' instead.",
"This procedure is deprecated! Use 'gimp-palette-entry-get-color' instead.",

32
app/pdb/parasite_cmds.c
View File

@ -459,8 +459,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-parasite-find",
"Finds the named parasite.",
"Finds and returns the named parasite that was previously attached to the gimp.",
@ -488,8 +488,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-parasite-attach",
"Add a parasite to the gimp.",
"This procedure attaches a parasite to the gimp. It has no return values.",
@ -510,8 +510,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-parasite-detach",
"Removes a parasite from the gimp.",
"This procedure detaches a parasite from the gimp. It has no return values.",
@ -534,8 +534,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
@ -562,8 +562,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-image-parasite-find",
"Finds the named parasite in an image",
"Finds and returns the named parasite that was previously attached to an image.",
@ -597,8 +597,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-image-parasite-attach",
"Add a parasite to an image.",
"This procedure attaches a parasite to an image. It has no return values.",
@ -625,8 +625,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-image-parasite-detach",
"Removes a parasite from an image.",
"This procedure detaches a parasite from an image. It has no return values.",
@ -655,8 +655,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-image-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
@ -689,8 +689,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-drawable-parasite-find",
"Finds the named parasite in a drawable",
"Finds and returns the named parasite that was previously attached to a drawable.",
@ -724,8 +724,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-drawable-parasite-attach",
"Add a parasite to a drawable.",
"This procedure attaches a parasite to a drawable. It has no return values.",
@ -752,8 +752,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-drawable-parasite-detach",
"Removes a parasite from a drawable.",
"This procedure detaches a parasite from a drawable. It has no return values.",
@ -782,8 +782,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-drawable-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
@ -816,8 +816,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-vectors-parasite-find",
"Finds the named parasite in a vectors object",
"Finds and returns the named parasite that was previously attached to a vectors object.",
@ -851,8 +851,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"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.",
@ -879,8 +879,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"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.",
@ -909,8 +909,8 @@ register_parasite_procs (Gimp *gimp)
* 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",
"gimp-vectors-parasite-list",
"List all parasites.",
"Returns a list of all currently attached parasites.",

32
app/pdb/paths_cmds.c
View File

@ -683,8 +683,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-list
*/
procedure = gimp_procedure_new (path_list_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-list");
gimp_procedure_set_static_strings (procedure,
"gimp-path-list",
"gimp-path-list",
"This procedure is deprecated! Use 'gimp-image-get-vectors' instead.",
"This procedure is deprecated! Use 'gimp-image-get-vectors' instead.",
@ -717,8 +717,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-get-current
*/
procedure = gimp_procedure_new (path_get_current_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-get-current");
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-current",
"gimp-path-get-current",
"This procedure is deprecated! Use 'gimp-image-get-active-vectors' instead.",
"This procedure is deprecated! Use 'gimp-image-get-active-vectors' instead.",
@ -747,8 +747,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-set-current
*/
procedure = gimp_procedure_new (path_set_current_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-set-current");
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-current",
"gimp-path-set-current",
"This procedure is deprecated! Use 'gimp-image-set-active-vectors' instead.",
"This procedure is deprecated! Use 'gimp-image-set-active-vectors' instead.",
@ -777,8 +777,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-delete
*/
procedure = gimp_procedure_new (path_delete_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-delete");
gimp_procedure_set_static_strings (procedure,
"gimp-path-delete",
"gimp-path-delete",
"This procedure is deprecated! Use 'gimp-image-remove-vectors' instead.",
"This procedure is deprecated! Use 'gimp-image-remove-vectors' instead.",
@ -807,8 +807,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-get-points
*/
procedure = gimp_procedure_new (path_get_points_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-get-points");
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-points",
"gimp-path-get-points",
"List the points associated with the named path.",
"List the points associated with the named path.",
@ -860,8 +860,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-set-points
*/
procedure = gimp_procedure_new (path_set_points_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-set-points");
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-points",
"gimp-path-set-points",
"Set the points associated with the named path.",
"Set the points associated with the named path.",
@ -907,8 +907,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-stroke-current
*/
procedure = gimp_procedure_new (path_stroke_current_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-stroke-current");
gimp_procedure_set_static_strings (procedure,
"gimp-path-stroke-current",
"gimp-path-stroke-current",
"Stroke the current path in the passed image.",
"Stroke the current path in the passed image.",
@ -930,8 +930,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-get-point-at-dist
*/
procedure = gimp_procedure_new (path_get_point_at_dist_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-get-point-at-dist");
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-point-at-dist",
"gimp-path-get-point-at-dist",
"This procedure is deprecated! Use 'gimp-vectors-stroke-get-point-at-dist' instead.",
"This will return the x,y position of a point at a given distance along the bezier curve. The distance will be obtained by first digitizing the curve internally and then walking along the curve. For a closed curve the start of the path is the first point on the path that was created. This might not be obvious. Note the current path is used.",
@ -977,8 +977,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-get-tattoo
*/
procedure = gimp_procedure_new (path_get_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-get-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-tattoo",
"gimp-path-get-tattoo",
"This procedure is deprecated! Use 'gimp-vectors-get-tattoo' instead.",
"This procedure is deprecated! Use 'gimp-vectors-get-tattoo' instead.",
@ -1013,8 +1013,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-set-tattoo
*/
procedure = gimp_procedure_new (path_set_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-set-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-tattoo",
"gimp-path-set-tattoo",
"This procedure is deprecated! Use 'gimp-vectors-set-tattoo' instead.",
"This procedure is deprecated! Use 'gimp-vectors-set-tattoo' instead.",
@ -1049,8 +1049,8 @@ register_paths_procs (Gimp *gimp)
* gimp-get-path-by-tattoo
*/
procedure = gimp_procedure_new (get_path_by_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-get-path-by-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-get-path-by-tattoo",
"gimp-get-path-by-tattoo",
"This procedure is deprecated! Use 'gimp-image-get-vectors-by-tattoo' instead.",
"This procedure is deprecated! Use 'gimp-image-get-vectors-by-tattoo' instead.",
@ -1085,8 +1085,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-get-locked
*/
procedure = gimp_procedure_new (path_get_locked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-get-locked");
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-locked",
"gimp-path-get-locked",
"This procedure is deprecated! Use 'gimp-vectors-get-linked' instead.",
"This procedure is deprecated! Use 'gimp-vectors-get-linked' instead.",
@ -1121,8 +1121,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-set-locked
*/
procedure = gimp_procedure_new (path_set_locked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-set-locked");
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-locked",
"gimp-path-set-locked",
"This procedure is deprecated! Use 'gimp-vectors-set-linked' instead.",
"This procedure is deprecated! Use 'gimp-vectors-set-linked' instead.",
@ -1157,8 +1157,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-to-selection
*/
procedure = gimp_procedure_new (path_to_selection_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-to-selection");
gimp_procedure_set_static_strings (procedure,
"gimp-path-to-selection",
"gimp-path-to-selection",
"Transforms the active path into a selection",
"This procedure renders the desired path into the current selection.",
@ -1218,8 +1218,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-import
*/
procedure = gimp_procedure_new (path_import_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-import");
gimp_procedure_set_static_strings (procedure,
"gimp-path-import",
"gimp-path-import",
"Import paths from an SVG file.",
"This procedure imports paths from an SVG file. SVG elements other than paths and basic shapes are ignored.",
@ -1260,8 +1260,8 @@ register_paths_procs (Gimp *gimp)
* gimp-path-import-string
*/
procedure = gimp_procedure_new (path_import_string_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-path-import-string");
gimp_procedure_set_static_strings (procedure,
"gimp-path-import-string",
"gimp-path-import-string",
"Import paths from an SVG string.",
"This procedure works like gimp_path_import() but takes a string rather than reading the SVG from a file. This allows you to write scripts that generate SVG and feed it to GIMP.",

4
app/pdb/pattern_cmds.c
View File

@ -140,8 +140,8 @@ register_pattern_procs (Gimp *gimp)
* gimp-pattern-get-info
*/
procedure = gimp_procedure_new (pattern_get_info_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-pattern-get-info");
gimp_procedure_set_static_strings (procedure,
"gimp-pattern-get-info",
"gimp-pattern-get-info",
"Retrieve information about the specified pattern.",
"This procedure retrieves information about the specified pattern. This includes the pattern extents (width and height).",
@ -182,8 +182,8 @@ register_pattern_procs (Gimp *gimp)
* gimp-pattern-get-pixels
*/
procedure = gimp_procedure_new (pattern_get_pixels_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-pattern-get-pixels");
gimp_procedure_set_static_strings (procedure,
"gimp-pattern-get-pixels",
"gimp-pattern-get-pixels",
"Retrieve information about the specified pattern (including pixels).",
"This procedure retrieves information about the specified. This includes the pattern extents (width and height), its bpp and its pixel data.",

6
app/pdb/pattern_select_cmds.c
View File

@ -121,8 +121,8 @@ register_pattern_select_procs (Gimp *gimp)
* gimp-patterns-popup
*/
procedure = gimp_procedure_new (patterns_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-patterns-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-popup",
"gimp-patterns-popup",
"Invokes the Gimp pattern selection.",
"This procedure popups the pattern selection dialog.",
@ -159,8 +159,8 @@ register_pattern_select_procs (Gimp *gimp)
* gimp-patterns-close-popup
*/
procedure = gimp_procedure_new (patterns_close_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-patterns-close-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-close-popup",
"gimp-patterns-close-popup",
"Popdown the Gimp pattern selection.",
"This procedure closes an opened pattern selection dialog.",
@ -183,8 +183,8 @@ register_pattern_select_procs (Gimp *gimp)
* gimp-patterns-set-popup
*/
procedure = gimp_procedure_new (patterns_set_popup_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-patterns-set-popup");
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-set-popup",
"gimp-patterns-set-popup",
"Sets the current pattern selection in a popup.",
"Sets the current pattern selection in a popup.",

8
app/pdb/patterns_cmds.c
View File

@ -189,8 +189,8 @@ register_patterns_procs (Gimp *gimp)
* 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",
"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.",
@ -206,8 +206,8 @@ register_patterns_procs (Gimp *gimp)
* 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",
"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'.",
@ -241,8 +241,8 @@ register_patterns_procs (Gimp *gimp)
* 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",
"gimp-patterns-get-pattern",
"This procedure is deprecated! Use 'gimp-context-get-pattern' instead.",
"This procedure is deprecated! Use 'gimp-context-get-pattern' instead.",
@ -277,8 +277,8 @@ register_patterns_procs (Gimp *gimp)
* 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",
"gimp-patterns-get-pattern-data",
"This procedure is deprecated! Use 'gimp-pattern-get-pixels' instead.",
"This procedure is deprecated! Use 'gimp-pattern-get-pixels' instead.",

12
app/pdb/plug_in_cmds.c
View File

@ -270,8 +270,8 @@ register_plug_in_procs (Gimp *gimp)
* 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",
"gimp-plugins-query",
"Queries the plugin database for its contents.",
"This procedure queries the contents of the plugin database.",
@ -360,8 +360,8 @@ register_plug_in_procs (Gimp *gimp)
* 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",
"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.",
@ -391,8 +391,8 @@ register_plug_in_procs (Gimp *gimp)
* 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",
"gimp-plugin-help-register",
"Register a help path for a plug-in.",
"This procedure changes the help rootdir for the plug-in which calls it. All subsequent calls of gimp_help from this plug-in will be interpreted relative to this rootdir.",
@ -422,8 +422,8 @@ register_plug_in_procs (Gimp *gimp)
* 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",
"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.",
@ -453,8 +453,8 @@ register_plug_in_procs (Gimp *gimp)
* 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",
"gimp-plugin-menu-branch-register",
"Register a sub-menu.",
"This procedure installs an sub-menu which does not belong to any procedure.",
@ -484,8 +484,8 @@ register_plug_in_procs (Gimp *gimp)
* 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",
"gimp-plugin-icon-register",
"Register an icon for a plug-in procedure.",
"This procedure installs an icon for the given procedure.",

18
app/pdb/procedural_db_cmds.c
View File

@ -422,8 +422,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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. It is mainly used by the interactive popup dialogs to generate a PDB entry name.",
@ -446,8 +446,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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. This file is in a format appropriate for use with the supplied \"pdb_self_doc.el\" Elisp script, which generates a texinfo document.",
@ -470,8 +470,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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.",
@ -547,8 +547,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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.",
@ -625,8 +625,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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.",
@ -678,8 +678,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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.",
@ -731,8 +731,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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.",
@ -766,8 +766,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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.",
@ -796,8 +796,8 @@ register_procedural_db_procs (Gimp *gimp)
* 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",
"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'.",

16
app/pdb/progress_cmds.c
View File

@ -239,8 +239,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-init
*/
procedure = gimp_procedure_new (progress_init_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-init");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-init",
"gimp-progress-init",
"Initializes the progress bar for the current plug-in.",
"Initializes the progress bar for the current plug-in. It is only valid to call this procedure from a plug-in.",
@ -269,8 +269,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-update
*/
procedure = gimp_procedure_new (progress_update_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-update");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-update",
"gimp-progress-update",
"Updates the progress bar for the current plug-in.",
"Updates the progress bar for the current plug-in. It is only valid to call this procedure from a plug-in.",
@ -292,8 +292,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-pulse
*/
procedure = gimp_procedure_new (progress_pulse_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-pulse");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-pulse",
"gimp-progress-pulse",
"Pulses the progress bar for the current plug-in.",
"Updates the progress bar for the current plug-in. It is only valid to call this procedure from a plug-in. Use this function instead of gimp_progress_update() if you cannot tell how much progress has been made. This usually causes the the progress bar to enter \"activity mode\", where a block bounces back and forth.",
@ -309,8 +309,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-set-text
*/
procedure = gimp_procedure_new (progress_set_text_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-set-text");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-set-text",
"gimp-progress-set-text",
"Changes the text in the progress bar for the current plug-in.",
"This function allows to change the text in the progress bar for the current plug-in. Unlike gimp_progress_init() it does not change the displayed value.",
@ -333,8 +333,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-get-window-handle
*/
procedure = gimp_procedure_new (progress_get_window_handle_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-get-window-handle");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-get-window-handle",
"gimp-progress-get-window-handle",
"Returns the native window ID of the toplevel window this plug-in's progress is displayed in.",
"This function returns the native window ID of the toplevel window this plug-in\'s progress is displayed in.",
@ -356,8 +356,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-install
*/
procedure = gimp_procedure_new (progress_install_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-install");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-install",
"gimp-progress-install",
"Installs a progress callback for the current plug-in.",
"This function installs a temporary PDB procedure which will handle all progress calls made by this plug-in and any procedure it calls. Calling this function multiple times simply replaces the old progress callbacks.",
@ -380,8 +380,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-uninstall
*/
procedure = gimp_procedure_new (progress_uninstall_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-uninstall");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-uninstall",
"gimp-progress-uninstall",
"Uninstalls the progress callback for the current plug-in.",
"This function uninstalls any progress callback installed with gimp_progress_install() before.",
@ -404,8 +404,8 @@ register_progress_procs (Gimp *gimp)
* gimp-progress-cancel
*/
procedure = gimp_procedure_new (progress_cancel_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-progress-cancel");
gimp_procedure_set_static_strings (procedure,
"gimp-progress-cancel",
"gimp-progress-cancel",
"Cancels a running progress.",
"This function cancels the currently running progress.",

34
app/pdb/selection_cmds.c
View File

@ -499,8 +499,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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).",
@ -552,8 +552,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -593,8 +593,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-is-empty",
"Determine whether the selection is empty.",
"This procedure returns TRUE if the selection for the specified image is not empty.",
@ -622,8 +622,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -657,8 +657,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -698,8 +698,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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).",
@ -721,8 +721,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-sharpen",
"Sharpen the selection mask.",
"This procedure sharpens the selection mask. For every pixel in the selection channel, if the value is > 0, the new pixel is assigned a value of 255. This removes any \"anti-aliasing\" that might exist in the selection mask's boundary.",
@ -744,8 +744,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -767,8 +767,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-none",
"Deselect the entire image.",
"This procedure deselects the entire image. Every pixel in the selection channel is set to 0.",
@ -790,8 +790,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-feather",
"Feather the image's selection",
"This procedure feathers the selection. Feathering is implemented using a gaussian blur.",
@ -819,8 +819,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -848,8 +848,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -877,8 +877,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -906,8 +906,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-layer-alpha",
"Transfer the specified layer's alpha channel to the selection mask.",
"This procedure requires a layer with an alpha channel. The alpha channel information is used to create a selection mask such that for any pixel in the image defined in the specified layer, that layer pixel's alpha value is transferred to the selection mask. If the layer is undefined at a particular image pixel, the associated selection mask value is set to 0.",
@ -929,8 +929,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-load",
"Transfer the specified channel to the selection mask.",
"This procedure loads the specified channel into the selection mask.",
@ -952,8 +952,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"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.",
@ -981,8 +981,8 @@ register_selection_procs (Gimp *gimp)
* 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",
"gimp-selection-combine",
"Combines the specified channel with the selection mask.",
"This procedure combines the specified channel into the selection mask.",

10
app/pdb/selection_tools_cmds.c
View File

@ -261,8 +261,8 @@ register_selection_tools_procs (Gimp *gimp)
* gimp-by-color-select
*/
procedure = gimp_procedure_new (by_color_select_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-by-color-select");
gimp_procedure_set_static_strings (procedure,
"gimp-by-color-select",
"gimp-by-color-select",
"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 specified threshold. Essentially, all pixels (in the drawable) that have color sufficiently close to the specified color (as determined by the threshold value) are included in the selection. The antialiasing parameter allows the final selection mask to contain intermediate values based on close misses to the threshold bar. Feathering can be enabled optionally and is controlled with the \"feather_radius\" parameter. If the sample_merged parameter is TRUE, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of a merged sampling, the supplied drawable is ignored.",
@ -327,8 +327,8 @@ register_selection_tools_procs (Gimp *gimp)
* gimp-ellipse-select
*/
procedure = gimp_procedure_new (ellipse_select_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-ellipse-select");
gimp_procedure_set_static_strings (procedure,
"gimp-ellipse-select",
"gimp-ellipse-select",
"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. If antialiasing is turned on, the edges of the elliptical region will contain intermediate values which give the appearance of a sharper, less pixelized edge. This should be set as TRUE most of the time. If the feather option is enabled, the resulting selection is blurred before combining. The blur is a gaussian blur with the specified feather radius.",
@ -399,8 +399,8 @@ register_selection_tools_procs (Gimp *gimp)
* gimp-free-select
*/
procedure = gimp_procedure_new (free_select_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-free-select");
gimp_procedure_set_static_strings (procedure,
"gimp-free-select",
"gimp-free-select",
"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. If the feather option is enabled, the resulting selection is blurred before combining. The blur is a gaussian blur with the specified feather radius.",
@ -458,8 +458,8 @@ register_selection_tools_procs (Gimp *gimp)
* gimp-fuzzy-select
*/
procedure = gimp_procedure_new (fuzzy_select_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-fuzzy-select");
gimp_procedure_set_static_strings (procedure,
"gimp-fuzzy-select",
"gimp-fuzzy-select",
"Create a fuzzy selection starting at the specified coordinates on the specified drawable.",
"This tool creates a fuzzy selection over the specified image. A fuzzy selection is determined by a seed fill under the constraints of the specified threshold. 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 value). This process continues until no more expansion is possible. The antialiasing parameter allows the final selection mask to contain intermediate values based on close misses to the threshold bar at pixels along the seed fill boundary. Feathering can be enabled optionally and is controlled with the \"feather_radius\" paramter. If the sample_merged parameter is TRUE, the data of the composite image will be used instead of that for the specified drawable. This is equivalent to sampling for colors after merging all visible layers. In the case of a merged sampling, the supplied drawable is ignored. If"
@ -531,8 +531,8 @@ register_selection_tools_procs (Gimp *gimp)
* gimp-rect-select
*/
procedure = gimp_procedure_new (rect_select_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-rect-select");
gimp_procedure_set_static_strings (procedure,
"gimp-rect-select",
"gimp-rect-select",
"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. If the feather option is enabled, the resulting selection is blurred before combining. The blur is a gaussian blur with the specified feather radius.",

8
app/pdb/text_tool_cmds.c
View File

@ -281,8 +281,8 @@ register_text_tool_procs (Gimp *gimp)
* 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",
"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.",
@ -367,8 +367,8 @@ register_text_tool_procs (Gimp *gimp)
* 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",
"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.",
@ -435,8 +435,8 @@ register_text_tool_procs (Gimp *gimp)
* gimp-text
*/
procedure = gimp_procedure_new (text_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-text");
gimp_procedure_set_static_strings (procedure,
"gimp-text",
"gimp-text",
"This procedure is deprecated! Use 'gimp-text-fontname' instead.",
"This procedure is deprecated! Use 'gimp-text-fontname' instead.",
@ -570,8 +570,8 @@ register_text_tool_procs (Gimp *gimp)
* gimp-text-get-extents
*/
procedure = gimp_procedure_new (text_get_extents_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-text-get-extents");
gimp_procedure_set_static_strings (procedure,
"gimp-text-get-extents",
"gimp-text-get-extents",
"This procedure is deprecated! Use 'gimp-text-get-extents-fontname' instead.",
"This procedure is deprecated! Use 'gimp-text-get-extents-fontname' instead.",

12
app/pdb/transform_tools_cmds.c
View File

@ -430,8 +430,8 @@ register_transform_tools_procs (Gimp *gimp)
* gimp-flip
*/
procedure = gimp_procedure_new (flip_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-flip");
gimp_procedure_set_static_strings (procedure,
"gimp-flip",
"gimp-flip",
"This procedure is deprecated! Use 'gimp-drawable-transform-flip-simple' instead.",
"This procedure is deprecated! Use 'gimp-drawable-transform-flip-simple' instead.",
@ -468,8 +468,8 @@ register_transform_tools_procs (Gimp *gimp)
* gimp-perspective
*/
procedure = gimp_procedure_new (perspective_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-perspective");
gimp_procedure_set_static_strings (procedure,
"gimp-perspective",
"gimp-perspective",
"This procedure is deprecated! Use 'gimp-drawable-transform-perspective-default' instead.",
"This procedure is deprecated! Use 'gimp-drawable-transform-perspective-default' instead.",
@ -551,8 +551,8 @@ register_transform_tools_procs (Gimp *gimp)
* gimp-rotate
*/
procedure = gimp_procedure_new (rotate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-rotate");
gimp_procedure_set_static_strings (procedure,
"gimp-rotate",
"gimp-rotate",
"This procedure is deprecated! Use 'gimp-drawable-transform-rotate-default' instead.",
"This procedure is deprecated! Use 'gimp-drawable-transform-rotate-default' instead.",
@ -592,8 +592,8 @@ register_transform_tools_procs (Gimp *gimp)
* gimp-scale
*/
procedure = gimp_procedure_new (scale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-scale");
gimp_procedure_set_static_strings (procedure,
"gimp-scale",
"gimp-scale",
"This procedure is deprecated! Use 'gimp-drawable-transform-scale-default' instead.",
"This procedure is deprecated! Use 'gimp-drawable-transform-scale-default' instead.",
@ -651,8 +651,8 @@ register_transform_tools_procs (Gimp *gimp)
* gimp-shear
*/
procedure = gimp_procedure_new (shear_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-shear");
gimp_procedure_set_static_strings (procedure,
"gimp-shear",
"gimp-shear",
"This procedure is deprecated! Use 'gimp-drawable-transform-shear-default' instead.",
"This procedure is deprecated! Use 'gimp-drawable-transform-shear-default' instead.",
@ -701,8 +701,8 @@ register_transform_tools_procs (Gimp *gimp)
* gimp-transform-2d
*/
procedure = gimp_procedure_new (transform_2d_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-transform-2d");
gimp_procedure_set_static_strings (procedure,
"gimp-transform-2d",
"gimp-transform-2d",
"This procedure is deprecated! Use 'gimp-drawable-transform-2d-default' instead.",
"This procedure is deprecated! Use 'gimp-drawable-transform-2d-default' instead.",

14
app/pdb/undo_cmds.c
View File

@ -226,8 +226,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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.",
@ -249,8 +249,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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.",
@ -272,8 +272,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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'.",
@ -301,8 +301,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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.",
@ -330,8 +330,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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.",
@ -359,8 +359,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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,thaw}' and 'gimp_image_undo_{disable,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.",
@ -388,8 +388,8 @@ register_undo_procs (Gimp *gimp)
* 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",
"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.",

24
app/pdb/unit_cmds.c
View File

@ -356,8 +356,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-number-of-units
*/
procedure = gimp_procedure_new (unit_get_number_of_units_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-number-of-units");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-number-of-units",
"gimp-unit-get-number-of-units",
"Returns the number of units.",
"This procedure returns the number of defined units.",
@ -379,8 +379,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-number-of-built-in-units
*/
procedure = gimp_procedure_new (unit_get_number_of_built_in_units_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-number-of-built-in-units");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-number-of-built-in-units",
"gimp-unit-get-number-of-built-in-units",
"Returns the number of built-in units.",
"This procedure returns the number of defined units built-in to the GIMP.",
@ -402,8 +402,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-new
*/
procedure = gimp_procedure_new (unit_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-new");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-new",
"gimp-unit-new",
"Creates a new unit and returns it's integer ID.",
"This procedure creates a new unit and returns it's integer ID. Note that the new unit will have it's deletion flag set to TRUE, so you will have to set it to FALSE with gimp_unit_set_deletion_flag to make it persistent.",
@ -474,8 +474,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-deletion-flag
*/
procedure = gimp_procedure_new (unit_get_deletion_flag_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-deletion-flag");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-deletion-flag",
"gimp-unit-get-deletion-flag",
"Returns the deletion flag of the unit.",
"This procedure returns the deletion flag of the unit. If this value is TRUE the unit's definition will not be saved in the user's unitrc file on gimp exit.",
@ -505,8 +505,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-set-deletion-flag
*/
procedure = gimp_procedure_new (unit_set_deletion_flag_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-set-deletion-flag");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-set-deletion-flag",
"gimp-unit-set-deletion-flag",
"Sets the deletion flag of a unit.",
"This procedure sets the unit's deletion flag. If the deletion flag of a unit is TRUE on gimp exit, this unit's definition will not be saved in the user's unitrc.",
@ -536,8 +536,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-identifier
*/
procedure = gimp_procedure_new (unit_get_identifier_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-identifier");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-identifier",
"gimp-unit-get-identifier",
"Returns the textual identifier of the unit.",
"This procedure returns the textual identifier of the unit. For built-in units it will be the english singular form of the unit's name. For user-defined units this should equal to the singular form.",
@ -568,8 +568,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-factor
*/
procedure = gimp_procedure_new (unit_get_factor_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-factor");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-factor",
"gimp-unit-get-factor",
"Returns the factor of the unit.",
"This procedure returns the unit's factor which indicates how many units make up an inch. Note that asking for the factor of \"pixels\" will produce an error.",
@ -599,8 +599,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-digits
*/
procedure = gimp_procedure_new (unit_get_digits_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-digits");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-digits",
"gimp-unit-get-digits",
"Returns the number of digits of the unit.",
"This procedure returns the number of digits you should provide in input or output functions to get approximately the same accuracy as with two digits and inches. Note that asking for the digits of \"pixels\" will produce an error.",
@ -630,8 +630,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-symbol
*/
procedure = gimp_procedure_new (unit_get_symbol_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-symbol");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-symbol",
"gimp-unit-get-symbol",
"Returns the symbol of the unit.",
"This procedure returns the symbol of the unit (\"''\" for inches).",
@ -662,8 +662,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-abbreviation
*/
procedure = gimp_procedure_new (unit_get_abbreviation_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-abbreviation");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-abbreviation",
"gimp-unit-get-abbreviation",
"Returns the abbreviation of the unit.",
"This procedure returns the abbreviation of the unit (\"in\" for inches).",
@ -694,8 +694,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-singular
*/
procedure = gimp_procedure_new (unit_get_singular_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-singular");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-singular",
"gimp-unit-get-singular",
"Returns the singular form of the unit.",
"This procedure returns the singular form of the unit.",
@ -726,8 +726,8 @@ register_unit_procs (Gimp *gimp)
* gimp-unit-get-plural
*/
procedure = gimp_procedure_new (unit_get_plural_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-unit-get-plural");
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-plural",
"gimp-unit-get-plural",
"Returns the plural form of the unit.",
"This procedure returns the plural form of the unit.",

46
app/pdb/vectors_cmds.c
View File

@ -836,8 +836,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-new
*/
procedure = gimp_procedure_new (vectors_new_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-new");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-new",
"gimp-vectors-new",
"Creates a new empty vectors object.",
"Creates a new empty vectors object. Needs to be added to an image using gimp_image_add_vectors.",
@ -872,8 +872,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-get-image
*/
procedure = gimp_procedure_new (vectors_get_image_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-get-image");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-image",
"gimp-vectors-get-image",
"Returns the vectors objects image.",
"Returns the vectors objects image.",
@ -901,8 +901,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-get-name
*/
procedure = gimp_procedure_new (vectors_get_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-get-name");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-name",
"gimp-vectors-get-name",
"Gets the name of the vectors object.",
"Gets the name of the vectors object.",
@ -931,8 +931,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-set-name
*/
procedure = gimp_procedure_new (vectors_set_name_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-set-name");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-name",
"gimp-vectors-set-name",
"Sets the name of the vectors object.",
"Sets the name of the vectors object.",
@ -961,8 +961,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-get-visible
*/
procedure = gimp_procedure_new (vectors_get_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-get-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-visible",
"gimp-vectors-get-visible",
"Gets the visibility of the vectors object.",
"Gets the visibility of the vectors object.",
@ -990,8 +990,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-set-visible
*/
procedure = gimp_procedure_new (vectors_set_visible_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-set-visible");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-visible",
"gimp-vectors-set-visible",
"Sets the visibility of the vectors object.",
"Sets the visibility of the vectors object.",
@ -1019,8 +1019,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-get-linked
*/
procedure = gimp_procedure_new (vectors_get_linked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-get-linked");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-linked",
"gimp-vectors-get-linked",
"Gets the linked state of the vectors object.",
"Gets the linked state of the vectors object.",
@ -1048,8 +1048,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-set-linked
*/
procedure = gimp_procedure_new (vectors_set_linked_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-set-linked");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-linked",
"gimp-vectors-set-linked",
"Sets the linked state of the vectors object.",
"Sets the linked state of the vectors object.",
@ -1077,8 +1077,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-get-tattoo
*/
procedure = gimp_procedure_new (vectors_get_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-get-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-tattoo",
"gimp-vectors-get-tattoo",
"Get the tattoo of the vectors object.",
"Get the tattoo state of the vectors object.",
@ -1106,8 +1106,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-set-tattoo
*/
procedure = gimp_procedure_new (vectors_set_tattoo_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-set-tattoo");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-tattoo",
"gimp-vectors-set-tattoo",
"Set the tattoo of the vectors object.",
"Set the tattoo of the vectors object.",
@ -1135,8 +1135,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-get-strokes
*/
procedure = gimp_procedure_new (vectors_get_strokes_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-get-strokes");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-strokes",
"gimp-vectors-get-strokes",
"List the strokes associated with the passed path.",
"Returns an Array with the stroke-IDs associated with the passed path.",
@ -1169,8 +1169,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-get-length
*/
procedure = gimp_procedure_new (vectors_stroke_get_length_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-get-length");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-get-length",
"gimp-vectors-stroke-get-length",
"Measure the length of the given stroke.",
"Measure the length of the given stroke.",
@ -1210,8 +1210,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-get-point-at-dist
*/
procedure = gimp_procedure_new (vectors_stroke_get_point_at_dist_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-get-point-at-dist");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-get-point-at-dist",
"gimp-vectors-stroke-get-point-at-dist",
"Get point at a specified distance along the stroke.",
"This will return the x,y position of a point at a given distance along the stroke. The distance will be obtained by first digitizing the curve internally and then walking along the curve. For a closed stroke the start of the path is the first point on the path that was created. This might not be obvious. If the stroke is not long enough, a \"valid\" flag will be FALSE.",
@ -1275,8 +1275,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-remove
*/
procedure = gimp_procedure_new (vectors_stroke_remove_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-remove");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-remove",
"gimp-vectors-stroke-remove",
"remove the stroke from a vectors object.",
"Remove the stroke from a vectors object.",
@ -1304,8 +1304,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-close
*/
procedure = gimp_procedure_new (vectors_stroke_close_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-close");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-close",
"gimp-vectors-stroke-close",
"closes the specified stroke.",
"Closes the specified stroke.",
@ -1333,8 +1333,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-translate
*/
procedure = gimp_procedure_new (vectors_stroke_translate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-translate");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-translate",
"gimp-vectors-stroke-translate",
"translate the given stroke.",
"Translate the given stroke.",
@ -1374,8 +1374,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-scale
*/
procedure = gimp_procedure_new (vectors_stroke_scale_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-scale");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-scale",
"gimp-vectors-stroke-scale",
"scales the given stroke.",
"Scale the given stroke.",
@ -1415,8 +1415,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-stroke-interpolate
*/
procedure = gimp_procedure_new (vectors_stroke_interpolate_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-stroke-interpolate");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-interpolate",
"gimp-vectors-stroke-interpolate",
"returns polygonal approximation of the stroke.",
"returns polygonal approximation of the stroke.",
@ -1467,8 +1467,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-bezier-stroke-new-moveto
*/
procedure = gimp_procedure_new (vectors_bezier_stroke_new_moveto_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-bezier-stroke-new-moveto");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-new-moveto",
"gimp-vectors-bezier-stroke-new-moveto",
"Adds a bezier stroke with a single moveto to the vectors object.",
"Adds a bezier stroke with a single moveto to the vectors object.",
@ -1508,8 +1508,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-bezier-stroke-lineto
*/
procedure = gimp_procedure_new (vectors_bezier_stroke_lineto_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-bezier-stroke-lineto");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-lineto",
"gimp-vectors-bezier-stroke-lineto",
"Extends a bezier stroke with a lineto.",
"Extends a bezier stroke with a lineto.",
@ -1549,8 +1549,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-bezier-stroke-conicto
*/
procedure = gimp_procedure_new (vectors_bezier_stroke_conicto_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-bezier-stroke-conicto");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-conicto",
"gimp-vectors-bezier-stroke-conicto",
"Extends a bezier stroke with a conic bezier spline.",
"Extends a bezier stroke with a conic bezier spline. Actually a cubic bezier spline gets added that realizes the shape of a conic bezier spline.",
@ -1602,8 +1602,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-bezier-stroke-cubicto
*/
procedure = gimp_procedure_new (vectors_bezier_stroke_cubicto_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-bezier-stroke-cubicto");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-cubicto",
"gimp-vectors-bezier-stroke-cubicto",
"Extends a bezier stroke with a cubic bezier spline.",
"Extends a bezier stroke with a cubic bezier spline.",
@ -1667,8 +1667,8 @@ register_vectors_procs (Gimp *gimp)
* gimp-vectors-bezier-stroke-new-ellipse
*/
procedure = gimp_procedure_new (vectors_bezier_stroke_new_ellipse_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-vectors-bezier-stroke-new-ellipse");
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-new-ellipse",
"gimp-vectors-bezier-stroke-new-ellipse",
"Adds a bezier stroke describing an ellipse the vectors object.",
"Adds a bezier stroke describing an ellipse the vectors object.",

4
app/plug-in/gimpplugin-message.c
View File

@ -678,8 +678,8 @@ plug_in_handle_proc_install (PlugIn *plug_in,
gimp_plug_in_procedure_set_image_types (proc, proc_install->image_types);
gimp_object_take_name (GIMP_OBJECT (procedure), canonical);
gimp_procedure_set_strings (procedure,
canonical,
proc_install->name,
proc_install->blurb,
proc_install->help,
@ -688,8 +688,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc_install->date,
NULL);
g_free (canonical);
for (i = 0; i < proc_install->nparams; i++)
{
GParamSpec *pspec =

2
app/plug-in/gimppluginmanager-query.c
View File

@ -146,7 +146,7 @@ plug_ins_query (Gimp *gimp,
(*accel_strs)[i] = NULL;
(*prog_strs)[i] = g_strdup (proc->prog);
(*types_strs)[i] = g_strdup (proc->image_types);
(*realname_strs)[i] = g_strdup (GIMP_PROCEDURE (proc)->name);
(*realname_strs)[i] = g_strdup (GIMP_OBJECT (proc)->name);
(*time_ints)[i] = proc->mtime;
g_free (name);

18
app/plug-in/gimppluginmanager.c
View File

@ -242,7 +242,7 @@ plug_ins_init (Gimp *gimp,
g_printerr ("removing duplicate PDB procedure \"%s\" "
"registered by '%s'\n",
GIMP_PROCEDURE (overridden_proc)->name,
GIMP_OBJECT (overridden_proc)->name,
gimp_filename_to_utf8 (overridden_proc->prog));
/* search the plugin list to see if any plugins had references to
@ -348,9 +348,9 @@ plug_ins_init (Gimp *gimp,
if (gimp->be_verbose)
g_print (_("Starting extension: '%s'\n"),
GIMP_PROCEDURE (proc)->name);
GIMP_OBJECT (proc)->name);
status_callback (NULL, GIMP_PROCEDURE (proc)->name,
status_callback (NULL, GIMP_OBJECT (proc)->name,
(gdouble) nth / (gdouble) n_extensions);
args = g_value_array_new (0);
@ -639,7 +639,7 @@ plug_ins_temp_procedure_remove (Gimp *gimp,
gimp->plug_in_procedures = g_slist_remove (gimp->plug_in_procedures, proc);
/* Unregister the procedural database entry */
gimp_pdb_unregister (gimp, GIMP_PROCEDURE (proc)->name);
gimp_pdb_unregister (gimp, GIMP_OBJECT (proc)->name);
g_object_unref (proc);
}
@ -880,7 +880,7 @@ plug_ins_add_to_db (Gimp *gimp,
else
{
g_printerr ("%s: NOT adding %s (prog = %s) to PDB\n",
G_STRFUNC, GIMP_PROCEDURE (proc)->name, proc->prog);
G_STRFUNC, GIMP_OBJECT (proc)->name, proc->prog);
}
}
@ -897,7 +897,7 @@ plug_ins_add_to_db (Gimp *gimp,
return_vals =
gimp_pdb_run_proc (gimp, context, NULL,
"gimp-register-save-handler",
G_TYPE_STRING, GIMP_PROCEDURE (proc)->name,
G_TYPE_STRING, GIMP_OBJECT (proc)->name,
G_TYPE_STRING, proc->extensions,
G_TYPE_STRING, proc->prefixes,
G_TYPE_NONE);
@ -907,7 +907,7 @@ plug_ins_add_to_db (Gimp *gimp,
return_vals =
gimp_pdb_run_proc (gimp, context, NULL,
"gimp-register-magic-load-handler",
G_TYPE_STRING, GIMP_PROCEDURE (proc)->name,
G_TYPE_STRING, GIMP_OBJECT (proc)->name,
G_TYPE_STRING, proc->extensions,
G_TYPE_STRING, proc->prefixes,
G_TYPE_STRING, proc->magics,
@ -929,8 +929,8 @@ plug_ins_procedure_insert (Gimp *gimp,
{
GimpPlugInProcedure *tmp_proc = list->data;
if (strcmp (GIMP_PROCEDURE (proc)->name,
GIMP_PROCEDURE (tmp_proc)->name) == 0)
if (strcmp (GIMP_OBJECT (proc)->name,
GIMP_OBJECT (tmp_proc)->name) == 0)
{
list->data = g_object_ref (proc);

10
app/plug-in/gimppluginprocedure.c
View File

@ -163,10 +163,10 @@ gimp_plug_in_procedure_find (GSList *list,
for (l = list; l; l = g_slist_next (l))
{
GimpProcedure *proc = l->data;
GimpObject *object = l->data;
if (! strcmp (proc_name, proc->name))
return GIMP_PLUG_IN_PROCEDURE (proc);
if (! strcmp (proc_name, object->name))
return GIMP_PLUG_IN_PROCEDURE (object);
}
return NULL;
@ -304,9 +304,9 @@ gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc,
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
if (help_domain)
return g_strconcat (help_domain, "?", GIMP_PROCEDURE (proc)->name, NULL);
return g_strconcat (help_domain, "?", GIMP_OBJECT (proc)->name, NULL);
return g_strdup (GIMP_PROCEDURE (proc)->name);
return g_strdup (GIMP_OBJECT (proc)->name);
}
gboolean

4
app/plug-in/plug-in-message.c
View File

@ -678,8 +678,8 @@ plug_in_handle_proc_install (PlugIn *plug_in,
gimp_plug_in_procedure_set_image_types (proc, proc_install->image_types);
gimp_object_take_name (GIMP_OBJECT (procedure), canonical);
gimp_procedure_set_strings (procedure,
canonical,
proc_install->name,
proc_install->blurb,
proc_install->help,
@ -688,8 +688,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc_install->date,
NULL);
g_free (canonical);
for (i = 0; i < proc_install->nparams; i++)
{
GParamSpec *pspec =

4
app/plug-in/plug-in-rc.c
View File

@ -339,8 +339,10 @@ plug_in_procedure_deserialize (GScanner *scanner,
*proc = GIMP_PLUG_IN_PROCEDURE (procedure);
gimp_object_take_name (GIMP_OBJECT (procedure),
gimp_canonicalize_identifier (str));
procedure->original_name = str;
procedure->name = gimp_canonicalize_identifier (procedure->original_name);
if (! gimp_scanner_parse_string (scanner, &procedure->blurb))
return G_TOKEN_STRING;

2
app/plug-in/plug-ins-query.c
View File

@ -146,7 +146,7 @@ plug_ins_query (Gimp *gimp,
(*accel_strs)[i] = NULL;
(*prog_strs)[i] = g_strdup (proc->prog);
(*types_strs)[i] = g_strdup (proc->image_types);
(*realname_strs)[i] = g_strdup (GIMP_PROCEDURE (proc)->name);
(*realname_strs)[i] = g_strdup (GIMP_OBJECT (proc)->name);
(*time_ints)[i] = proc->mtime;
g_free (name);

18
app/plug-in/plug-ins.c
View File

@ -242,7 +242,7 @@ plug_ins_init (Gimp *gimp,
g_printerr ("removing duplicate PDB procedure \"%s\" "
"registered by '%s'\n",
GIMP_PROCEDURE (overridden_proc)->name,
GIMP_OBJECT (overridden_proc)->name,
gimp_filename_to_utf8 (overridden_proc->prog));
/* search the plugin list to see if any plugins had references to
@ -348,9 +348,9 @@ plug_ins_init (Gimp *gimp,
if (gimp->be_verbose)
g_print (_("Starting extension: '%s'\n"),
GIMP_PROCEDURE (proc)->name);
GIMP_OBJECT (proc)->name);
status_callback (NULL, GIMP_PROCEDURE (proc)->name,
status_callback (NULL, GIMP_OBJECT (proc)->name,
(gdouble) nth / (gdouble) n_extensions);
args = g_value_array_new (0);
@ -639,7 +639,7 @@ plug_ins_temp_procedure_remove (Gimp *gimp,
gimp->plug_in_procedures = g_slist_remove (gimp->plug_in_procedures, proc);
/* Unregister the procedural database entry */
gimp_pdb_unregister (gimp, GIMP_PROCEDURE (proc)->name);
gimp_pdb_unregister (gimp, GIMP_OBJECT (proc)->name);
g_object_unref (proc);
}
@ -880,7 +880,7 @@ plug_ins_add_to_db (Gimp *gimp,
else
{
g_printerr ("%s: NOT adding %s (prog = %s) to PDB\n",
G_STRFUNC, GIMP_PROCEDURE (proc)->name, proc->prog);
G_STRFUNC, GIMP_OBJECT (proc)->name, proc->prog);
}
}
@ -897,7 +897,7 @@ plug_ins_add_to_db (Gimp *gimp,
return_vals =
gimp_pdb_run_proc (gimp, context, NULL,
"gimp-register-save-handler",
G_TYPE_STRING, GIMP_PROCEDURE (proc)->name,
G_TYPE_STRING, GIMP_OBJECT (proc)->name,
G_TYPE_STRING, proc->extensions,
G_TYPE_STRING, proc->prefixes,
G_TYPE_NONE);
@ -907,7 +907,7 @@ plug_ins_add_to_db (Gimp *gimp,
return_vals =
gimp_pdb_run_proc (gimp, context, NULL,
"gimp-register-magic-load-handler",
G_TYPE_STRING, GIMP_PROCEDURE (proc)->name,
G_TYPE_STRING, GIMP_OBJECT (proc)->name,
G_TYPE_STRING, proc->extensions,
G_TYPE_STRING, proc->prefixes,
G_TYPE_STRING, proc->magics,
@ -929,8 +929,8 @@ plug_ins_procedure_insert (Gimp *gimp,
{
GimpPlugInProcedure *tmp_proc = list->data;
if (strcmp (GIMP_PROCEDURE (proc)->name,
GIMP_PROCEDURE (tmp_proc)->name) == 0)
if (strcmp (GIMP_OBJECT (proc)->name,
GIMP_OBJECT (tmp_proc)->name) == 0)
{
list->data = g_object_ref (proc);

4
app/xcf/xcf.c
View File

@ -151,8 +151,8 @@ xcf_init (Gimp *gimp)
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "", NULL);
gimp_plug_in_procedure_set_mime_type (proc, "image/xcf");
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-xcf-save");
gimp_procedure_set_static_strings (procedure,
"gimp-xcf-save",
"gimp-xcf-save",
"saves file in the .xcf file format",
"The xcf file format has been designed "
@ -219,8 +219,8 @@ xcf_init (Gimp *gimp)
"0,string,gimp\\040xcf\\040");
gimp_plug_in_procedure_set_mime_type (proc, "image/xcf");
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-xcf-load");
gimp_procedure_set_static_strings (procedure,
"gimp-xcf-load",
"gimp-xcf-load",
"loads file saved in the .xcf file format",
"The xcf file format has been designed "

2
tools/pdbgen/app.pl
View File

@ -528,8 +528,8 @@ sub generate {
* gimp-$proc->{canonical_name}
*/
procedure = gimp_procedure_new (${name}_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-$proc->{canonical_name}");
gimp_procedure_set_static_strings (procedure,
"gimp-$proc->{canonical_name}",
"gimp-$proc->{canonical_name}",
@{[ &quotewrap($proc->{blurb}, 2) ]},
@{[ &quotewrap($proc->{help}, 2) ]},

4
tools/pdbgen/pdb/fileops.pdb
View File

@ -84,7 +84,7 @@ HELP
g_value_set_static_string (&new_args->values[i], "");
return_vals = gimp_pdb_execute (gimp, context, progress,
proc->name, new_args);
GIMP_OBJECT (proc)->name, new_args);
g_value_array_free (new_args);
@ -208,7 +208,7 @@ HELP
g_value_set_static_string (&new_args->values[i], "");
return_vals = gimp_pdb_execute (gimp, context, progress,
proc->name, new_args);
GIMP_OBJECT (proc)->name, new_args);
g_value_array_free (new_args);