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

create code with spaces instead of tabs. 

2006-04-12  Sven Neumann  <sven@gimp.org>

	* tools/pdbgen/lib.pl: create code with spaces instead of tabs.

	* libgimp/gimp*_pdb.[ch]: regenerated.
This commit is contained in:
Sven Neumann 2006-04-12 10:27:31 +00:00 committed by Sven Neumann
parent 5583a9048e
commit 8824a9bc86
90 changed files with 4070 additions and 4067 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
2006-04-12 Sven Neumann <sven@gimp.org>
* tools/pdbgen/lib.pl: create code with spaces instead of tabs.
* libgimp/gimp*_pdb.[ch]: regenerated.
2006-04-12 Sven Neumann <sven@gimp.org>
* tools/gimp-remote.c

190
libgimp/gimpbrush_pdb.c
View File

@ -47,9 +47,9 @@ gimp_brush_new (const gchar *name)
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-brush-new",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
actual_name = g_strdup (return_vals[1].data.d_string);
@ -79,9 +79,9 @@ gimp_brush_duplicate (const gchar *name)
gchar *copy_name = NULL;
return_vals = gimp_run_procedure ("gimp-brush-duplicate",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
copy_name = g_strdup (return_vals[1].data.d_string);
@ -111,9 +111,9 @@ gimp_brush_is_generated (const gchar *name)
gboolean generated = FALSE;
return_vals = gimp_run_procedure ("gimp-brush-is-generated",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
generated = return_vals[1].data.d_int32;
@ -138,17 +138,17 @@ gimp_brush_is_generated (const gchar *name)
*/
gchar *
gimp_brush_rename (const gchar *name,
const gchar *new_name)
const gchar *new_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-brush-rename",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
actual_name = g_strdup (return_vals[1].data.d_string);
@ -178,9 +178,9 @@ gimp_brush_delete (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brush-delete",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -209,9 +209,9 @@ gimp_brush_is_editable (const gchar *name)
gboolean editable = FALSE;
return_vals = gimp_run_procedure ("gimp-brush-is-editable",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
editable = return_vals[1].data.d_int32;
@ -240,19 +240,19 @@ gimp_brush_is_editable (const gchar *name)
*/
gboolean
gimp_brush_get_info (const gchar *name,
gint *width,
gint *height,
gint *mask_bpp,
gint *color_bpp)
gint *width,
gint *height,
gint *mask_bpp,
gint *color_bpp)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brush-get-info",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*width = 0;
*height = 0;
@ -297,23 +297,23 @@ gimp_brush_get_info (const gchar *name,
*/
gboolean
gimp_brush_get_pixels (const gchar *name,
gint *width,
gint *height,
gint *mask_bpp,
gint *num_mask_bytes,
guint8 **mask_bytes,
gint *color_bpp,
gint *num_color_bytes,
guint8 **color_bytes)
gint *width,
gint *height,
gint *mask_bpp,
gint *num_mask_bytes,
guint8 **mask_bytes,
gint *color_bpp,
gint *num_color_bytes,
guint8 **color_bytes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brush-get-pixels",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*width = 0;
*height = 0;
@ -364,16 +364,16 @@ gimp_brush_get_pixels (const gchar *name,
*/
gboolean
gimp_brush_get_spacing (const gchar *name,
gint *spacing)
gint *spacing)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brush-get-spacing",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*spacing = 0;
@ -403,17 +403,17 @@ gimp_brush_get_spacing (const gchar *name,
*/
gboolean
gimp_brush_set_spacing (const gchar *name,
gint spacing)
gint spacing)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brush-set-spacing",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, spacing,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, spacing,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -447,9 +447,9 @@ gimp_brush_get_shape (const gchar *name)
GimpBrushGeneratedShape shape = 0;
return_vals = gimp_run_procedure ("gimp-brush-get-shape",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
shape = return_vals[1].data.d_int32;
@ -480,9 +480,9 @@ gimp_brush_get_radius (const gchar *name)
gdouble radius = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-get-radius",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
radius = return_vals[1].data.d_float;
@ -513,9 +513,9 @@ gimp_brush_get_spikes (const gchar *name)
gint spikes = 0;
return_vals = gimp_run_procedure ("gimp-brush-get-spikes",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
spikes = return_vals[1].data.d_int32;
@ -547,9 +547,9 @@ gimp_brush_get_hardness (const gchar *name)
gdouble hardness = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-get-hardness",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
hardness = return_vals[1].data.d_float;
@ -580,9 +580,9 @@ gimp_brush_get_aspect_ratio (const gchar *name)
gdouble aspect_ratio = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-get-aspect-ratio",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
aspect_ratio = return_vals[1].data.d_float;
@ -613,9 +613,9 @@ gimp_brush_get_angle (const gchar *name)
gdouble angle = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-get-angle",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
angle = return_vals[1].data.d_float;
@ -645,17 +645,17 @@ gimp_brush_get_angle (const gchar *name)
*/
GimpBrushGeneratedShape
gimp_brush_set_shape (const gchar *name,
GimpBrushGeneratedShape shape_in)
GimpBrushGeneratedShape shape_in)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpBrushGeneratedShape shape_out = 0;
return_vals = gimp_run_procedure ("gimp-brush-set-shape",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, shape_in,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, shape_in,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
shape_out = return_vals[1].data.d_int32;
@ -681,17 +681,17 @@ gimp_brush_set_shape (const gchar *name,
*/
gdouble
gimp_brush_set_radius (const gchar *name,
gdouble radius_in)
gdouble radius_in)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble radius_out = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-set-radius",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, radius_in,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, radius_in,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
radius_out = return_vals[1].data.d_float;
@ -717,17 +717,17 @@ gimp_brush_set_radius (const gchar *name,
*/
gint
gimp_brush_set_spikes (const gchar *name,
gint spikes_in)
gint spikes_in)
{
GimpParam *return_vals;
gint nreturn_vals;
gint spikes_out = 0;
return_vals = gimp_run_procedure ("gimp-brush-set-spikes",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, spikes_in,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, spikes_in,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
spikes_out = return_vals[1].data.d_int32;
@ -753,17 +753,17 @@ gimp_brush_set_spikes (const gchar *name,
*/
gdouble
gimp_brush_set_hardness (const gchar *name,
gdouble hardness_in)
gdouble hardness_in)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble hardness_out = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-set-hardness",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, hardness_in,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, hardness_in,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
hardness_out = return_vals[1].data.d_float;
@ -789,17 +789,17 @@ gimp_brush_set_hardness (const gchar *name,
*/
gdouble
gimp_brush_set_aspect_ratio (const gchar *name,
gdouble aspect_ratio_in)
gdouble aspect_ratio_in)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble aspect_ratio_out = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-set-aspect-ratio",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, aspect_ratio_in,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, aspect_ratio_in,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
aspect_ratio_out = return_vals[1].data.d_float;
@ -825,17 +825,17 @@ gimp_brush_set_aspect_ratio (const gchar *name,
*/
gdouble
gimp_brush_set_angle (const gchar *name,
gdouble angle_in)
gdouble angle_in)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble angle_out = 0.0;
return_vals = gimp_run_procedure ("gimp-brush-set-angle",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, angle_in,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, angle_in,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
angle_out = return_vals[1].data.d_float;

42
libgimp/gimpbrush_pdb.h
View File

@ -33,27 +33,27 @@ gchar* gimp_brush_new (const gchar *n
gchar* gimp_brush_duplicate (const gchar *name);
gboolean gimp_brush_is_generated (const gchar *name);
gchar* gimp_brush_rename (const gchar *name,
const gchar *new_name);
const gchar *new_name);
gboolean gimp_brush_delete (const gchar *name);
gboolean gimp_brush_is_editable (const gchar *name);
gboolean gimp_brush_get_info (const gchar *name,
gint *width,
gint *height,
gint *mask_bpp,
gint *color_bpp);
gint *width,
gint *height,
gint *mask_bpp,
gint *color_bpp);
gboolean gimp_brush_get_pixels (const gchar *name,
gint *width,
gint *height,
gint *mask_bpp,
gint *num_mask_bytes,
guint8 **mask_bytes,
gint *color_bpp,
gint *num_color_bytes,
guint8 **color_bytes);
gint *width,
gint *height,
gint *mask_bpp,
gint *num_mask_bytes,
guint8 **mask_bytes,
gint *color_bpp,
gint *num_color_bytes,
guint8 **color_bytes);
gboolean gimp_brush_get_spacing (const gchar *name,
gint *spacing);
gint *spacing);
gboolean gimp_brush_set_spacing (const gchar *name,
gint spacing);
gint spacing);
GimpBrushGeneratedShape gimp_brush_get_shape (const gchar *name);
gdouble gimp_brush_get_radius (const gchar *name);
gint gimp_brush_get_spikes (const gchar *name);
@ -61,17 +61,17 @@ gdouble gimp_brush_get_hardness (const gchar *n
gdouble gimp_brush_get_aspect_ratio (const gchar *name);
gdouble gimp_brush_get_angle (const gchar *name);
GimpBrushGeneratedShape gimp_brush_set_shape (const gchar *name,
GimpBrushGeneratedShape shape_in);
GimpBrushGeneratedShape shape_in);
gdouble gimp_brush_set_radius (const gchar *name,
gdouble radius_in);
gdouble radius_in);
gint gimp_brush_set_spikes (const gchar *name,
gint spikes_in);
gint spikes_in);
gdouble gimp_brush_set_hardness (const gchar *name,
gdouble hardness_in);
gdouble hardness_in);
gdouble gimp_brush_set_aspect_ratio (const gchar *name,
gdouble aspect_ratio_in);
gdouble aspect_ratio_in);
gdouble gimp_brush_set_angle (const gchar *name,
gdouble angle_in);
gdouble angle_in);
G_END_DECLS

50
libgimp/gimpbrushes_pdb.c
View File

@ -45,8 +45,8 @@ gimp_brushes_refresh (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brushes-refresh",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -70,7 +70,7 @@ gimp_brushes_refresh (void)
*/
gchar **
gimp_brushes_get_list (const gchar *filter,
gint *num_brushes)
gint *num_brushes)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -78,9 +78,9 @@ gimp_brushes_get_list (const gchar *filter,
gint i;
return_vals = gimp_run_procedure ("gimp-brushes-get-list",
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
*num_brushes = 0;
@ -109,16 +109,16 @@ gimp_brushes_get_list (const gchar *filter,
*/
gchar *
gimp_brushes_get_brush (gint *width,
gint *height,
gint *spacing)
gint *height,
gint *spacing)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-brushes-get-brush",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -148,8 +148,8 @@ gimp_brushes_get_spacing (void)
gint spacing = 0;
return_vals = gimp_run_procedure ("gimp-brushes-get-spacing",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
spacing = return_vals[1].data.d_int32;
@ -175,9 +175,9 @@ gimp_brushes_set_spacing (gint spacing)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brushes-set-spacing",
&nreturn_vals,
GIMP_PDB_INT32, spacing,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, spacing,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -203,22 +203,22 @@ gimp_brushes_set_spacing (gint spacing)
*/
gchar *
gimp_brushes_get_brush_data (const gchar *name,
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data)
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-brushes-get-brush-data",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*length = 0;

20
libgimp/gimpbrushes_pdb.h
View File

@ -31,21 +31,21 @@ G_BEGIN_DECLS
gboolean gimp_brushes_refresh (void);
gchar** gimp_brushes_get_list (const gchar *filter,
gint *num_brushes);
gint *num_brushes);
#ifndef GIMP_DISABLE_DEPRECATED
gchar* gimp_brushes_get_brush (gint *width,
gint *height,
gint *spacing);
gint *height,
gint *spacing);
gint gimp_brushes_get_spacing (void);
gboolean gimp_brushes_set_spacing (gint spacing);
gchar* gimp_brushes_get_brush_data (const gchar *name,
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data);
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data);
#endif /* GIMP_DISABLE_DEPRECATED */

54
libgimp/gimpbrushselect_pdb.c
View File

@ -42,25 +42,25 @@
*/
gboolean
gimp_brushes_popup (const gchar *brush_callback,
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brushes-popup",
&nreturn_vals,
GIMP_PDB_STRING, brush_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_brush,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, spacing,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, brush_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_brush,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, spacing,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -87,9 +87,9 @@ gimp_brushes_close_popup (const gchar *brush_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brushes-close-popup",
&nreturn_vals,
GIMP_PDB_STRING, brush_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, brush_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -114,23 +114,23 @@ gimp_brushes_close_popup (const gchar *brush_callback)
*/
gboolean
gimp_brushes_set_popup (const gchar *brush_callback,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brushes-set-popup",
&nreturn_vals,
GIMP_PDB_STRING, brush_callback,
GIMP_PDB_STRING, brush_name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, spacing,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, brush_callback,
GIMP_PDB_STRING, brush_name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, spacing,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

18
libgimp/gimpbrushselect_pdb.h
View File

@ -30,17 +30,17 @@ G_BEGIN_DECLS
gboolean gimp_brushes_popup (const gchar *brush_callback,
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
gboolean gimp_brushes_close_popup (const gchar *brush_callback);
gboolean gimp_brushes_set_popup (const gchar *brush_callback,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
G_END_DECLS

48
libgimp/gimpbuffer_pdb.c
View File

@ -41,7 +41,7 @@
*/
gchar **
gimp_buffers_get_list (const gchar *filter,
gint *num_buffers)
gint *num_buffers)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -49,9 +49,9 @@ gimp_buffers_get_list (const gchar *filter,
gint i;
return_vals = gimp_run_procedure ("gimp-buffers-get-list",
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
*num_buffers = 0;
@ -83,17 +83,17 @@ gimp_buffers_get_list (const gchar *filter,
*/
gchar *
gimp_buffer_rename (const gchar *buffer_name,
const gchar *new_name)
const gchar *new_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *real_name = NULL;
return_vals = gimp_run_procedure ("gimp-buffer-rename",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
real_name = g_strdup (return_vals[1].data.d_string);
@ -123,9 +123,9 @@ gimp_buffer_delete (const gchar *buffer_name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-buffer-delete",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -154,9 +154,9 @@ gimp_buffer_get_width (const gchar *buffer_name)
gint width = 0;
return_vals = gimp_run_procedure ("gimp-buffer-get-width",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
width = return_vals[1].data.d_int32;
@ -186,9 +186,9 @@ gimp_buffer_get_height (const gchar *buffer_name)
gint height = 0;
return_vals = gimp_run_procedure ("gimp-buffer-get-height",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
height = return_vals[1].data.d_int32;
@ -218,9 +218,9 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
gint bytes = 0;
return_vals = gimp_run_procedure ("gimp-buffer-get-bytes",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
bytes = return_vals[1].data.d_int32;
@ -250,9 +250,9 @@ gimp_buffer_get_image_type (const gchar *buffer_name)
GimpImageBaseType image_type = 0;
return_vals = gimp_run_procedure ("gimp-buffer-get-image-type",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
image_type = return_vals[1].data.d_int32;

4
libgimp/gimpbuffer_pdb.h
View File

@ -30,9 +30,9 @@ G_BEGIN_DECLS
gchar** gimp_buffers_get_list (const gchar *filter,
gint *num_buffers);
gint *num_buffers);
gchar* gimp_buffer_rename (const gchar *buffer_name,
const gchar *new_name);
const gchar *new_name);
gboolean gimp_buffer_delete (const gchar *buffer_name);
gint gimp_buffer_get_width (const gchar *buffer_name);
gint gimp_buffer_get_height (const gchar *buffer_name);

118
libgimp/gimpchannel_pdb.c
View File

@ -48,25 +48,25 @@
*/
gint32
_gimp_channel_new (gint32 image_ID,
gint width,
gint height,
const gchar *name,
gdouble opacity,
const GimpRGB *color)
gint width,
gint height,
const gchar *name,
gdouble opacity,
const GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 channel_ID = -1;
return_vals = gimp_run_procedure ("gimp-channel-new",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
channel_ID = return_vals[1].data.d_channel;
@ -92,19 +92,19 @@ _gimp_channel_new (gint32 image_ID,
*/
gint32
gimp_channel_new_from_component (gint32 image_ID,
GimpChannelType component,
const gchar *name)
GimpChannelType component,
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 channel_ID = -1;
return_vals = gimp_run_procedure ("gimp-channel-new-from-component",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, component,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, component,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
channel_ID = return_vals[1].data.d_channel;
@ -132,9 +132,9 @@ gimp_channel_copy (gint32 channel_ID)
gint32 channel_copy_ID = -1;
return_vals = gimp_run_procedure ("gimp-channel-copy",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
channel_copy_ID = return_vals[1].data.d_channel;
@ -161,23 +161,23 @@ gimp_channel_copy (gint32 channel_ID)
*/
gboolean
gimp_channel_combine_masks (gint32 channel1_ID,
gint32 channel2_ID,
GimpChannelOps operation,
gint offx,
gint offy)
gint32 channel2_ID,
GimpChannelOps operation,
gint offx,
gint offy)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-channel-combine-masks",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel1_ID,
GIMP_PDB_CHANNEL, channel2_ID,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel1_ID,
GIMP_PDB_CHANNEL, channel2_ID,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -206,9 +206,9 @@ gimp_channel_get_show_masked (gint32 channel_ID)
gboolean show_masked = FALSE;
return_vals = gimp_run_procedure ("gimp-channel-get-show-masked",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
show_masked = return_vals[1].data.d_int32;
@ -233,17 +233,17 @@ gimp_channel_get_show_masked (gint32 channel_ID)
*/
gboolean
gimp_channel_set_show_masked (gint32 channel_ID,
gboolean show_masked)
gboolean show_masked)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-channel-set-show-masked",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_INT32, show_masked,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_INT32, show_masked,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -270,9 +270,9 @@ gimp_channel_get_opacity (gint32 channel_ID)
gdouble opacity = 0.0;
return_vals = gimp_run_procedure ("gimp-channel-get-opacity",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
opacity = return_vals[1].data.d_float;
@ -295,17 +295,17 @@ gimp_channel_get_opacity (gint32 channel_ID)
*/
gboolean
gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity)
gdouble opacity)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-channel-set-opacity",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -327,16 +327,16 @@ gimp_channel_set_opacity (gint32 channel_ID,
*/
gboolean
gimp_channel_get_color (gint32 channel_ID,
GimpRGB *color)
GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-channel-get-color",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -361,17 +361,17 @@ gimp_channel_get_color (gint32 channel_ID,
*/
gboolean
gimp_channel_set_color (gint32 channel_ID,
const GimpRGB *color)
const GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-channel-set-color",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

30
libgimp/gimpchannel_pdb.h
View File

@ -30,30 +30,30 @@ G_BEGIN_DECLS
gint32 _gimp_channel_new (gint32 image_ID,
gint width,
gint height,
const gchar *name,
gdouble opacity,
const GimpRGB *color) G_GNUC_INTERNAL;
gint width,
gint height,
const gchar *name,
gdouble opacity,
const GimpRGB *color) G_GNUC_INTERNAL;
gint32 gimp_channel_new_from_component (gint32 image_ID,
GimpChannelType component,
const gchar *name);
GimpChannelType component,
const gchar *name);
gint32 gimp_channel_copy (gint32 channel_ID);
gboolean gimp_channel_combine_masks (gint32 channel1_ID,
gint32 channel2_ID,
GimpChannelOps operation,
gint offx,
gint offy);
gint32 channel2_ID,
GimpChannelOps operation,
gint offx,
gint offy);
gboolean gimp_channel_get_show_masked (gint32 channel_ID);
gboolean gimp_channel_set_show_masked (gint32 channel_ID,
gboolean show_masked);
gboolean show_masked);
gdouble gimp_channel_get_opacity (gint32 channel_ID);
gboolean gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity);
gdouble opacity);
gboolean gimp_channel_get_color (gint32 channel_ID,
GimpRGB *color);
GimpRGB *color);
gboolean gimp_channel_set_color (gint32 channel_ID,
const GimpRGB *color);
const GimpRGB *color);
G_END_DECLS

244
libgimp/gimpcolor_pdb.c
View File

@ -41,19 +41,19 @@
*/
gboolean
gimp_brightness_contrast (gint32 drawable_ID,
gint brightness,
gint contrast)
gint brightness,
gint contrast)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-brightness-contrast",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, brightness,
GIMP_PDB_INT32, contrast,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, brightness,
GIMP_PDB_INT32, contrast,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -91,27 +91,27 @@ gimp_brightness_contrast (gint32 drawable_ID,
*/
gboolean
gimp_levels (gint32 drawable_ID,
GimpHistogramChannel channel,
gint low_input,
gint high_input,
gdouble gamma,
gint low_output,
gint high_output)
GimpHistogramChannel channel,
gint low_input,
gint high_input,
gdouble gamma,
gint low_output,
gint high_output)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-levels",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, low_input,
GIMP_PDB_INT32, high_input,
GIMP_PDB_FLOAT, gamma,
GIMP_PDB_INT32, low_output,
GIMP_PDB_INT32, high_output,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, low_input,
GIMP_PDB_INT32, high_input,
GIMP_PDB_FLOAT, gamma,
GIMP_PDB_INT32, low_output,
GIMP_PDB_INT32, high_output,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -136,9 +136,9 @@ gimp_levels_auto (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-levels-auto",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -169,9 +169,9 @@ gimp_levels_stretch (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-levels-stretch",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -194,17 +194,17 @@ gimp_levels_stretch (gint32 drawable_ID)
*/
gboolean
gimp_posterize (gint32 drawable_ID,
gint levels)
gint levels)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-posterize",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, levels,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, levels,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -232,9 +232,9 @@ gimp_desaturate (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-desaturate",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -261,17 +261,17 @@ gimp_desaturate (gint32 drawable_ID)
*/
gboolean
gimp_desaturate_full (gint32 drawable_ID,
GimpDesaturateMode desaturate_mode)
GimpDesaturateMode desaturate_mode)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-desaturate-full",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, desaturate_mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, desaturate_mode,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -300,17 +300,17 @@ gimp_desaturate_full (gint32 drawable_ID,
*/
gboolean
gimp_equalize (gint32 drawable_ID,
gboolean mask_only)
gboolean mask_only)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-equalize",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, mask_only,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, mask_only,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -340,9 +340,9 @@ gimp_invert (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-invert",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -372,21 +372,21 @@ gimp_invert (gint32 drawable_ID)
*/
gboolean
gimp_curves_spline (gint32 drawable_ID,
GimpHistogramChannel channel,
gint num_points,
const guint8 *control_pts)
GimpHistogramChannel channel,
gint num_points,
const guint8 *control_pts)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-curves-spline",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, num_points,
GIMP_PDB_INT8ARRAY, control_pts,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, num_points,
GIMP_PDB_INT8ARRAY, control_pts,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -416,21 +416,21 @@ gimp_curves_spline (gint32 drawable_ID,
*/
gboolean
gimp_curves_explicit (gint32 drawable_ID,
GimpHistogramChannel channel,
gint num_bytes,
const guint8 *curve)
GimpHistogramChannel channel,
gint num_bytes,
const guint8 *curve)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-curves-explicit",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, num_bytes,
GIMP_PDB_INT8ARRAY, curve,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, num_bytes,
GIMP_PDB_INT8ARRAY, curve,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -463,25 +463,25 @@ gimp_curves_explicit (gint32 drawable_ID,
*/
gboolean
gimp_color_balance (gint32 drawable_ID,
GimpTransferMode transfer_mode,
gboolean preserve_lum,
gdouble cyan_red,
gdouble magenta_green,
gdouble yellow_blue)
GimpTransferMode transfer_mode,
gboolean preserve_lum,
gdouble cyan_red,
gdouble magenta_green,
gdouble yellow_blue)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-color-balance",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, transfer_mode,
GIMP_PDB_INT32, preserve_lum,
GIMP_PDB_FLOAT, cyan_red,
GIMP_PDB_FLOAT, magenta_green,
GIMP_PDB_FLOAT, yellow_blue,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, transfer_mode,
GIMP_PDB_INT32, preserve_lum,
GIMP_PDB_FLOAT, cyan_red,
GIMP_PDB_FLOAT, magenta_green,
GIMP_PDB_FLOAT, yellow_blue,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -510,21 +510,21 @@ gimp_color_balance (gint32 drawable_ID,
*/
gboolean
gimp_colorize (gint32 drawable_ID,
gdouble hue,
gdouble saturation,
gdouble lightness)
gdouble hue,
gdouble saturation,
gdouble lightness)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-colorize",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, hue,
GIMP_PDB_FLOAT, saturation,
GIMP_PDB_FLOAT, lightness,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, hue,
GIMP_PDB_FLOAT, saturation,
GIMP_PDB_FLOAT, lightness,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -567,27 +567,27 @@ gimp_colorize (gint32 drawable_ID,
*/
gboolean
gimp_histogram (gint32 drawable_ID,
GimpHistogramChannel channel,
gint start_range,
gint end_range,
gdouble *mean,
gdouble *std_dev,
gdouble *median,
gdouble *pixels,
gdouble *count,
gdouble *percentile)
GimpHistogramChannel channel,
gint start_range,
gint end_range,
gdouble *mean,
gdouble *std_dev,
gdouble *median,
gdouble *pixels,
gdouble *count,
gdouble *percentile)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-histogram",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, start_range,
GIMP_PDB_INT32, end_range,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, channel,
GIMP_PDB_INT32, start_range,
GIMP_PDB_INT32, end_range,
GIMP_PDB_END);
*mean = 0.0;
*std_dev = 0.0;
@ -631,23 +631,23 @@ gimp_histogram (gint32 drawable_ID,
*/
gboolean
gimp_hue_saturation (gint32 drawable_ID,
GimpHueRange hue_range,
gdouble hue_offset,
gdouble lightness,
gdouble saturation)
GimpHueRange hue_range,
gdouble hue_offset,
gdouble lightness,
gdouble saturation)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-hue-saturation",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, hue_range,
GIMP_PDB_FLOAT, hue_offset,
GIMP_PDB_FLOAT, lightness,
GIMP_PDB_FLOAT, saturation,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, hue_range,
GIMP_PDB_FLOAT, hue_offset,
GIMP_PDB_FLOAT, lightness,
GIMP_PDB_FLOAT, saturation,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -673,19 +673,19 @@ gimp_hue_saturation (gint32 drawable_ID,
*/
gboolean
gimp_threshold (gint32 drawable_ID,
gint low_threshold,
gint high_threshold)
gint low_threshold,
gint high_threshold)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-threshold",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, low_threshold,
GIMP_PDB_INT32, high_threshold,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, low_threshold,
GIMP_PDB_INT32, high_threshold,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

80
libgimp/gimpcolor_pdb.h
View File

@ -30,63 +30,63 @@ G_BEGIN_DECLS
gboolean gimp_brightness_contrast (gint32 drawable_ID,
gint brightness,
gint contrast);
gint brightness,
gint contrast);
gboolean gimp_levels (gint32 drawable_ID,
GimpHistogramChannel channel,
gint low_input,
gint high_input,
gdouble gamma,
gint low_output,
gint high_output);
GimpHistogramChannel channel,
gint low_input,
gint high_input,
gdouble gamma,
gint low_output,
gint high_output);
#ifndef GIMP_DISABLE_DEPRECATED
gboolean gimp_levels_auto (gint32 drawable_ID);
#endif /* GIMP_DISABLE_DEPRECATED */
gboolean gimp_levels_stretch (gint32 drawable_ID);
gboolean gimp_posterize (gint32 drawable_ID,
gint levels);
gint levels);
gboolean gimp_desaturate (gint32 drawable_ID);
gboolean gimp_desaturate_full (gint32 drawable_ID,
GimpDesaturateMode desaturate_mode);
GimpDesaturateMode desaturate_mode);
gboolean gimp_equalize (gint32 drawable_ID,
gboolean mask_only);
gboolean mask_only);
gboolean gimp_invert (gint32 drawable_ID);
gboolean gimp_curves_spline (gint32 drawable_ID,
GimpHistogramChannel channel,
gint num_points,
const guint8 *control_pts);
GimpHistogramChannel channel,
gint num_points,
const guint8 *control_pts);
gboolean gimp_curves_explicit (gint32 drawable_ID,
GimpHistogramChannel channel,
gint num_bytes,
const guint8 *curve);
GimpHistogramChannel channel,
gint num_bytes,
const guint8 *curve);
gboolean gimp_color_balance (gint32 drawable_ID,
GimpTransferMode transfer_mode,
gboolean preserve_lum,
gdouble cyan_red,
gdouble magenta_green,
gdouble yellow_blue);
GimpTransferMode transfer_mode,
gboolean preserve_lum,
gdouble cyan_red,
gdouble magenta_green,
gdouble yellow_blue);
gboolean gimp_colorize (gint32 drawable_ID,
gdouble hue,
gdouble saturation,
gdouble lightness);
gdouble hue,
gdouble saturation,
gdouble lightness);
gboolean gimp_histogram (gint32 drawable_ID,
GimpHistogramChannel channel,
gint start_range,
gint end_range,
gdouble *mean,
gdouble *std_dev,
gdouble *median,
gdouble *pixels,
gdouble *count,
gdouble *percentile);
GimpHistogramChannel channel,
gint start_range,
gint end_range,
gdouble *mean,
gdouble *std_dev,
gdouble *median,
gdouble *pixels,
gdouble *count,
gdouble *percentile);
gboolean gimp_hue_saturation (gint32 drawable_ID,
GimpHueRange hue_range,
gdouble hue_offset,
gdouble lightness,
gdouble saturation);
GimpHueRange hue_range,
gdouble hue_offset,
gdouble lightness,
gdouble saturation);
gboolean gimp_threshold (gint32 drawable_ID,
gint low_threshold,
gint high_threshold);
gint low_threshold,
gint high_threshold);
G_END_DECLS

116
libgimp/gimpcontext_pdb.c
View File

@ -46,8 +46,8 @@ gimp_context_push (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-push",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -78,8 +78,8 @@ gimp_context_pop (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-pop",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -108,8 +108,8 @@ gimp_context_get_paint_method (void)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-context-get-paint-method",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -144,9 +144,9 @@ gimp_context_set_paint_method (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-paint-method",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -177,8 +177,8 @@ gimp_context_get_foreground (GimpRGB *foreground)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-get-foreground",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -212,9 +212,9 @@ gimp_context_set_foreground (const GimpRGB *foreground)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-foreground",
&nreturn_vals,
GIMP_PDB_COLOR, foreground,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_COLOR, foreground,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -245,8 +245,8 @@ gimp_context_get_background (GimpRGB *background)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-get-background",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -281,9 +281,9 @@ gimp_context_set_background (const GimpRGB *background)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-background",
&nreturn_vals,
GIMP_PDB_COLOR, background,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_COLOR, background,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -313,8 +313,8 @@ gimp_context_set_default_colors (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-default-colors",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -344,8 +344,8 @@ gimp_context_swap_colors (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-swap-colors",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -374,8 +374,8 @@ gimp_context_get_opacity (void)
gdouble opacity = 0.0;
return_vals = gimp_run_procedure ("gimp-context-get-opacity",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
opacity = return_vals[1].data.d_float;
@ -406,9 +406,9 @@ gimp_context_set_opacity (gdouble opacity)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-opacity",
&nreturn_vals,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -438,8 +438,8 @@ gimp_context_get_paint_mode (void)
GimpLayerModeEffects paint_mode = 0;
return_vals = gimp_run_procedure ("gimp-context-get-paint-mode",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
paint_mode = return_vals[1].data.d_int32;
@ -469,9 +469,9 @@ gimp_context_set_paint_mode (GimpLayerModeEffects paint_mode)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-paint-mode",
&nreturn_vals,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -501,8 +501,8 @@ gimp_context_get_brush (void)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-context-get-brush",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -536,9 +536,9 @@ gimp_context_set_brush (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-brush",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -568,8 +568,8 @@ gimp_context_get_pattern (void)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-context-get-pattern",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -604,9 +604,9 @@ gimp_context_set_pattern (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-pattern",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -634,8 +634,8 @@ gimp_context_get_gradient (void)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-context-get-gradient",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -670,9 +670,9 @@ gimp_context_set_gradient (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-gradient",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -700,8 +700,8 @@ gimp_context_get_palette (void)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-context-get-palette",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -736,9 +736,9 @@ gimp_context_set_palette (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-palette",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -766,8 +766,8 @@ gimp_context_get_font (void)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-context-get-font",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -801,9 +801,9 @@ gimp_context_set_font (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-context-set-font",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

42
libgimp/gimpconvert_pdb.c
View File

@ -46,9 +46,9 @@ gimp_image_convert_rgb (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-convert-rgb",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -77,9 +77,9 @@ gimp_image_convert_grayscale (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-convert-grayscale",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -118,27 +118,27 @@ gimp_image_convert_grayscale (gint32 image_ID)
*/
gboolean
gimp_image_convert_indexed (gint32 image_ID,
GimpConvertDitherType dither_type,
GimpConvertPaletteType palette_type,
gint num_cols,
gboolean alpha_dither,
gboolean remove_unused,
const gchar *palette)
GimpConvertDitherType dither_type,
GimpConvertPaletteType palette_type,
gint num_cols,
gboolean alpha_dither,
gboolean remove_unused,
const gchar *palette)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-convert-indexed",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, dither_type,
GIMP_PDB_INT32, palette_type,
GIMP_PDB_INT32, num_cols,
GIMP_PDB_INT32, alpha_dither,
GIMP_PDB_INT32, remove_unused,
GIMP_PDB_STRING, palette,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, dither_type,
GIMP_PDB_INT32, palette_type,
GIMP_PDB_INT32, num_cols,
GIMP_PDB_INT32, alpha_dither,
GIMP_PDB_INT32, remove_unused,
GIMP_PDB_STRING, palette,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

12
libgimp/gimpconvert_pdb.h
View File

@ -32,12 +32,12 @@ G_BEGIN_DECLS
gboolean gimp_image_convert_rgb (gint32 image_ID);
gboolean gimp_image_convert_grayscale (gint32 image_ID);
gboolean gimp_image_convert_indexed (gint32 image_ID,
GimpConvertDitherType dither_type,
GimpConvertPaletteType palette_type,
gint num_cols,
gboolean alpha_dither,
gboolean remove_unused,
const gchar *palette);
GimpConvertDitherType dither_type,
GimpConvertPaletteType palette_type,
gint num_cols,
gboolean alpha_dither,
gboolean remove_unused,
const gchar *palette);
G_END_DECLS

32
libgimp/gimpdisplay_pdb.c
View File

@ -47,9 +47,9 @@ gimp_display_new (gint32 image_ID)
gint32 display_ID = -1;
return_vals = gimp_run_procedure ("gimp-display-new",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
display_ID = return_vals[1].data.d_display;
@ -79,9 +79,9 @@ gimp_display_delete (gint32 display_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-display-delete",
&nreturn_vals,
GIMP_PDB_DISPLAY, display_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DISPLAY, display_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -114,9 +114,9 @@ gimp_display_get_window_handle (gint32 display_ID)
gint window = 0;
return_vals = gimp_run_procedure ("gimp-display-get-window-handle",
&nreturn_vals,
GIMP_PDB_DISPLAY, display_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DISPLAY, display_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
window = return_vals[1].data.d_int32;
@ -146,8 +146,8 @@ gimp_displays_flush (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-displays-flush",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -172,17 +172,17 @@ gimp_displays_flush (void)
*/
gboolean
gimp_displays_reconnect (gint32 old_image_ID,
gint32 new_image_ID)
gint32 new_image_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-displays-reconnect",
&nreturn_vals,
GIMP_PDB_IMAGE, old_image_ID,
GIMP_PDB_IMAGE, new_image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, old_image_ID,
GIMP_PDB_IMAGE, new_image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

2
libgimp/gimpdisplay_pdb.h
View File

@ -34,7 +34,7 @@ gboolean gimp_display_delete (gint32 display_ID);
gint gimp_display_get_window_handle (gint32 display_ID);
gboolean gimp_displays_flush (void);
gboolean gimp_displays_reconnect (gint32 old_image_ID,
gint32 new_image_ID);
gint32 new_image_ID);
G_END_DECLS

376
libgimp/gimpdrawable_pdb.c
View File

@ -49,9 +49,9 @@ gimp_drawable_delete (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-delete",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -78,9 +78,9 @@ gimp_drawable_is_layer (gint32 drawable_ID)
gboolean layer = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-is-layer",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer = return_vals[1].data.d_int32;
@ -109,9 +109,9 @@ gimp_drawable_is_layer_mask (gint32 drawable_ID)
gboolean layer_mask = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-is-layer-mask",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_mask = return_vals[1].data.d_int32;
@ -139,9 +139,9 @@ gimp_drawable_is_channel (gint32 drawable_ID)
gboolean channel = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-is-channel",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
channel = return_vals[1].data.d_int32;
@ -169,9 +169,9 @@ gimp_drawable_type (gint32 drawable_ID)
GimpImageType type = 0;
return_vals = gimp_run_procedure ("gimp-drawable-type",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
type = return_vals[1].data.d_int32;
@ -202,9 +202,9 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID)
GimpImageType type_with_alpha = 0;
return_vals = gimp_run_procedure ("gimp-drawable-type-with-alpha",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
type_with_alpha = return_vals[1].data.d_int32;
@ -234,9 +234,9 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
gboolean has_alpha = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-has-alpha",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
has_alpha = return_vals[1].data.d_int32;
@ -265,9 +265,9 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
gboolean is_rgb = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-is-rgb",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
is_rgb = return_vals[1].data.d_int32;
@ -296,9 +296,9 @@ gimp_drawable_is_gray (gint32 drawable_ID)
gboolean is_gray = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-is-gray",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
is_gray = return_vals[1].data.d_int32;
@ -327,9 +327,9 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
gboolean is_indexed = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-is-indexed",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
is_indexed = return_vals[1].data.d_int32;
@ -358,9 +358,9 @@ gimp_drawable_bpp (gint32 drawable_ID)
gint bpp = 0;
return_vals = gimp_run_procedure ("gimp-drawable-bpp",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
bpp = return_vals[1].data.d_int32;
@ -388,9 +388,9 @@ gimp_drawable_width (gint32 drawable_ID)
gint width = 0;
return_vals = gimp_run_procedure ("gimp-drawable-width",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
width = return_vals[1].data.d_int32;
@ -418,9 +418,9 @@ gimp_drawable_height (gint32 drawable_ID)
gint height = 0;
return_vals = gimp_run_procedure ("gimp-drawable-height",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
height = return_vals[1].data.d_int32;
@ -446,17 +446,17 @@ gimp_drawable_height (gint32 drawable_ID)
*/
gboolean
gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_x,
gint *offset_y)
gint *offset_x,
gint *offset_y)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-offsets",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
*offset_x = 0;
*offset_y = 0;
@ -492,9 +492,9 @@ gimp_drawable_get_image (gint32 drawable_ID)
gint32 image_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-get-image",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
image_ID = return_vals[1].data.d_image;
@ -515,17 +515,17 @@ gimp_drawable_get_image (gint32 drawable_ID)
*/
gboolean
gimp_drawable_set_image (gint32 drawable_ID,
gint32 image_ID)
gint32 image_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-set-image",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -552,9 +552,9 @@ gimp_drawable_get_name (gint32 drawable_ID)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-drawable-get-name",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -577,17 +577,17 @@ gimp_drawable_get_name (gint32 drawable_ID)
*/
gboolean
gimp_drawable_set_name (gint32 drawable_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-set-name",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -614,9 +614,9 @@ gimp_drawable_get_visible (gint32 drawable_ID)
gboolean visible = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-get-visible",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
visible = return_vals[1].data.d_int32;
@ -639,17 +639,17 @@ gimp_drawable_get_visible (gint32 drawable_ID)
*/
gboolean
gimp_drawable_set_visible (gint32 drawable_ID,
gboolean visible)
gboolean visible)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-set-visible",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, visible,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, visible,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -676,9 +676,9 @@ gimp_drawable_get_linked (gint32 drawable_ID)
gboolean linked = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-get-linked",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
linked = return_vals[1].data.d_int32;
@ -701,17 +701,17 @@ gimp_drawable_get_linked (gint32 drawable_ID)
*/
gboolean
gimp_drawable_set_linked (gint32 drawable_ID,
gboolean linked)
gboolean linked)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-set-linked",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, linked,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, linked,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -741,9 +741,9 @@ gimp_drawable_get_tattoo (gint32 drawable_ID)
gint tattoo = 0;
return_vals = gimp_run_procedure ("gimp-drawable-get-tattoo",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
tattoo = return_vals[1].data.d_tattoo;
@ -769,17 +769,17 @@ gimp_drawable_get_tattoo (gint32 drawable_ID)
*/
gboolean
gimp_drawable_set_tattoo (gint32 drawable_ID,
gint tattoo)
gint tattoo)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-set-tattoo",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, tattoo,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, tattoo,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -816,19 +816,19 @@ gimp_drawable_set_tattoo (gint32 drawable_ID,
*/
gboolean
gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1,
gint *y1,
gint *x2,
gint *y2)
gint *x1,
gint *y1,
gint *x2,
gint *y2)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean non_empty = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-mask-bounds",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -867,19 +867,19 @@ gimp_drawable_mask_bounds (gint32 drawable_ID,
*/
gboolean
gimp_drawable_mask_intersect (gint32 drawable_ID,
gint *x,
gint *y,
gint *width,
gint *height)
gint *x,
gint *y,
gint *width,
gint *height)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean non_empty = FALSE;
return_vals = gimp_run_procedure ("gimp-drawable-mask-intersect",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -911,17 +911,17 @@ gimp_drawable_mask_intersect (gint32 drawable_ID,
*/
gboolean
gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean undo)
gboolean undo)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-merge-shadow",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, undo,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, undo,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -949,23 +949,23 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
*/
gboolean
gimp_drawable_update (gint32 drawable_ID,
gint x,
gint y,
gint width,
gint height)
gint x,
gint y,
gint width,
gint height)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-update",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, x,
GIMP_PDB_INT32, y,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, x,
GIMP_PDB_INT32, y,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -991,20 +991,20 @@ gimp_drawable_update (gint32 drawable_ID,
*/
guint8 *
gimp_drawable_get_pixel (gint32 drawable_ID,
gint x_coord,
gint y_coord,
gint *num_channels)
gint x_coord,
gint y_coord,
gint *num_channels)
{
GimpParam *return_vals;
gint nreturn_vals;
guint8 *pixel = NULL;
return_vals = gimp_run_procedure ("gimp-drawable-get-pixel",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, x_coord,
GIMP_PDB_INT32, y_coord,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, x_coord,
GIMP_PDB_INT32, y_coord,
GIMP_PDB_END);
*num_channels = 0;
@ -1041,23 +1041,23 @@ gimp_drawable_get_pixel (gint32 drawable_ID,
*/
gboolean
gimp_drawable_set_pixel (gint32 drawable_ID,
gint x_coord,
gint y_coord,
gint num_channels,
const guint8 *pixel)
gint x_coord,
gint y_coord,
gint num_channels,
const guint8 *pixel)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-set-pixel",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, x_coord,
GIMP_PDB_INT32, y_coord,
GIMP_PDB_INT32, num_channels,
GIMP_PDB_INT8ARRAY, pixel,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, x_coord,
GIMP_PDB_INT32, y_coord,
GIMP_PDB_INT32, num_channels,
GIMP_PDB_INT8ARRAY, pixel,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1088,17 +1088,17 @@ gimp_drawable_set_pixel (gint32 drawable_ID,
*/
gboolean
gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type)
GimpFillType fill_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-fill",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, fill_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, fill_type,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1129,23 +1129,23 @@ gimp_drawable_fill (gint32 drawable_ID,
*/
gboolean
gimp_drawable_offset (gint32 drawable_ID,
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y)
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-offset",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, wrap_around,
GIMP_PDB_INT32, fill_type,
GIMP_PDB_INT32, offset_x,
GIMP_PDB_INT32, offset_y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, wrap_around,
GIMP_PDB_INT32, fill_type,
GIMP_PDB_INT32, offset_x,
GIMP_PDB_INT32, offset_y,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1176,24 +1176,24 @@ gimp_drawable_offset (gint32 drawable_ID,
*/
gboolean
_gimp_drawable_thumbnail (gint32 drawable_ID,
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-thumbnail",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_END);
*actual_width = 0;
*actual_height = 0;
@ -1247,32 +1247,32 @@ _gimp_drawable_thumbnail (gint32 drawable_ID,
*/
gboolean
_gimp_drawable_sub_thumbnail (gint32 drawable_ID,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height,
gint *width,
gint *height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height,
gint *width,
gint *height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-sub-thumbnail",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, src_x,
GIMP_PDB_INT32, src_y,
GIMP_PDB_INT32, src_width,
GIMP_PDB_INT32, src_height,
GIMP_PDB_INT32, dest_width,
GIMP_PDB_INT32, dest_height,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, src_x,
GIMP_PDB_INT32, src_y,
GIMP_PDB_INT32, src_width,
GIMP_PDB_INT32, src_height,
GIMP_PDB_INT32, dest_width,
GIMP_PDB_INT32, dest_height,
GIMP_PDB_END);
*width = 0;
*height = 0;
@ -1315,19 +1315,19 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
*/
gboolean
gimp_drawable_foreground_extract (gint32 drawable_ID,
GimpForegroundExtractMode mode,
gint32 mask_ID)
GimpForegroundExtractMode mode,
gint32 mask_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-foreground-extract",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, mode,
GIMP_PDB_DRAWABLE, mask_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, mode,
GIMP_PDB_DRAWABLE, mask_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

104
libgimp/gimpdrawable_pdb.h
View File

@ -43,81 +43,81 @@ gint gimp_drawable_bpp (gint32 draw
gint gimp_drawable_width (gint32 drawable_ID);
gint gimp_drawable_height (gint32 drawable_ID);
gboolean gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_x,
gint *offset_y);
gint *offset_x,
gint *offset_y);
gint32 gimp_drawable_get_image (gint32 drawable_ID);
#ifndef GIMP_DISABLE_DEPRECATED
gboolean gimp_drawable_set_image (gint32 drawable_ID,
gint32 image_ID);
gint32 image_ID);
#endif /* GIMP_DISABLE_DEPRECATED */
gchar* gimp_drawable_get_name (gint32 drawable_ID);
gboolean gimp_drawable_set_name (gint32 drawable_ID,
const gchar *name);
const gchar *name);
gboolean gimp_drawable_get_visible (gint32 drawable_ID);
gboolean gimp_drawable_set_visible (gint32 drawable_ID,
gboolean visible);
gboolean visible);
gboolean gimp_drawable_get_linked (gint32 drawable_ID);
gboolean gimp_drawable_set_linked (gint32 drawable_ID,
gboolean linked);
gboolean linked);
gint gimp_drawable_get_tattoo (gint32 drawable_ID);
gboolean gimp_drawable_set_tattoo (gint32 drawable_ID,
gint tattoo);
gint tattoo);
gboolean gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1,
gint *y1,
gint *x2,
gint *y2);
gint *x1,
gint *y1,
gint *x2,
gint *y2);
gboolean gimp_drawable_mask_intersect (gint32 drawable_ID,
gint *x,
gint *y,
gint *width,
gint *height);
gint *x,
gint *y,
gint *width,
gint *height);
gboolean gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean undo);
gboolean undo);
gboolean gimp_drawable_update (gint32 drawable_ID,
gint x,
gint y,
gint width,
gint height);
gint x,
gint y,
gint width,
gint height);
guint8* gimp_drawable_get_pixel (gint32 drawable_ID,
gint x_coord,
gint y_coord,
gint *num_channels);
gint x_coord,
gint y_coord,
gint *num_channels);
gboolean gimp_drawable_set_pixel (gint32 drawable_ID,
gint x_coord,
gint y_coord,
gint num_channels,
const guint8 *pixel);
gint x_coord,
gint y_coord,
gint num_channels,
const guint8 *pixel);
gboolean gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type);
GimpFillType fill_type);
gboolean gimp_drawable_offset (gint32 drawable_ID,
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y);
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y);
gboolean _gimp_drawable_thumbnail (gint32 drawable_ID,
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data) G_GNUC_INTERNAL;
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data) G_GNUC_INTERNAL;
gboolean _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height,
gint *width,
gint *height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data) G_GNUC_INTERNAL;
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height,
gint *width,
gint *height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data) G_GNUC_INTERNAL;
gboolean gimp_drawable_foreground_extract (gint32 drawable_ID,
GimpForegroundExtractMode mode,
gint32 mask_ID);
GimpForegroundExtractMode mode,
gint32 mask_ID);
G_END_DECLS

632
libgimp/gimpdrawabletransform_pdb.c
View File

@ -51,23 +51,23 @@
*/
gint32
gimp_drawable_transform_flip_simple (gint32 drawable_ID,
GimpOrientationType flip_type,
gboolean auto_center,
gdouble axis,
gboolean clip_result)
GimpOrientationType flip_type,
gboolean auto_center,
gdouble axis,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-flip-simple",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, flip_type,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_FLOAT, axis,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, flip_type,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_FLOAT, axis,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -109,33 +109,33 @@ gimp_drawable_transform_flip_simple (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_flip (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-flip",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -167,27 +167,27 @@ gimp_drawable_transform_flip (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_flip_default (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result)
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-flip-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -239,41 +239,41 @@ gimp_drawable_transform_flip_default (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_perspective (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-perspective",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_FLOAT, x3,
GIMP_PDB_FLOAT, y3,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_FLOAT, x3,
GIMP_PDB_FLOAT, y3,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -310,35 +310,35 @@ gimp_drawable_transform_perspective (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_perspective_default (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
gboolean interpolate,
gboolean clip_result)
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-perspective-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_FLOAT, x3,
GIMP_PDB_FLOAT, y3,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_FLOAT, x3,
GIMP_PDB_FLOAT, y3,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -374,25 +374,25 @@ gimp_drawable_transform_perspective_default (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_rotate_simple (gint32 drawable_ID,
GimpRotationType rotate_type,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean clip_result)
GimpRotationType rotate_type,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate-simple",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, rotate_type,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, rotate_type,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -432,33 +432,33 @@ gimp_drawable_transform_rotate_simple (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_rotate (gint32 drawable_ID,
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -491,27 +491,27 @@ gimp_drawable_transform_rotate (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_rotate_default (gint32 drawable_ID,
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean interpolate,
gboolean clip_result)
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_INT32, auto_center,
GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -550,33 +550,33 @@ gimp_drawable_transform_rotate_default (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_scale (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-scale",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -608,27 +608,27 @@ gimp_drawable_transform_scale (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_scale_default (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result)
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-scale-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -669,29 +669,29 @@ gimp_drawable_transform_scale_default (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_shear (gint32 drawable_ID,
GimpOrientationType shear_type,
gdouble magnitude,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
GimpOrientationType shear_type,
gdouble magnitude,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-shear",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, shear_type,
GIMP_PDB_FLOAT, magnitude,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, shear_type,
GIMP_PDB_FLOAT, magnitude,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -722,23 +722,23 @@ gimp_drawable_transform_shear (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_shear_default (gint32 drawable_ID,
GimpOrientationType shear_type,
gdouble magnitude,
gboolean interpolate,
gboolean clip_result)
GimpOrientationType shear_type,
gdouble magnitude,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-shear-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, shear_type,
GIMP_PDB_FLOAT, magnitude,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, shear_type,
GIMP_PDB_FLOAT, magnitude,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -783,39 +783,39 @@ gimp_drawable_transform_shear_default (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_2d (gint32 drawable_ID,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-2d",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, source_x,
GIMP_PDB_FLOAT, source_y,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_FLOAT, dest_x,
GIMP_PDB_FLOAT, dest_y,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, source_x,
GIMP_PDB_FLOAT, source_y,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_FLOAT, dest_x,
GIMP_PDB_FLOAT, dest_y,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -850,33 +850,33 @@ gimp_drawable_transform_2d (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_2d_default (gint32 drawable_ID,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
gboolean interpolate,
gboolean clip_result)
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-2d-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, source_x,
GIMP_PDB_FLOAT, source_y,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_FLOAT, dest_x,
GIMP_PDB_FLOAT, dest_y,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, source_x,
GIMP_PDB_FLOAT, source_y,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_FLOAT, dest_x,
GIMP_PDB_FLOAT, dest_y,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -921,43 +921,43 @@ gimp_drawable_transform_2d_default (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_matrix (gint32 drawable_ID,
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-matrix",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, coeff_0_0,
GIMP_PDB_FLOAT, coeff_0_1,
GIMP_PDB_FLOAT, coeff_0_2,
GIMP_PDB_FLOAT, coeff_1_0,
GIMP_PDB_FLOAT, coeff_1_1,
GIMP_PDB_FLOAT, coeff_1_2,
GIMP_PDB_FLOAT, coeff_2_0,
GIMP_PDB_FLOAT, coeff_2_1,
GIMP_PDB_FLOAT, coeff_2_2,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, coeff_0_0,
GIMP_PDB_FLOAT, coeff_0_1,
GIMP_PDB_FLOAT, coeff_0_2,
GIMP_PDB_FLOAT, coeff_1_0,
GIMP_PDB_FLOAT, coeff_1_1,
GIMP_PDB_FLOAT, coeff_1_2,
GIMP_PDB_FLOAT, coeff_2_0,
GIMP_PDB_FLOAT, coeff_2_1,
GIMP_PDB_FLOAT, coeff_2_2,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -994,37 +994,37 @@ gimp_drawable_transform_matrix (gint32 drawable_ID,
*/
gint32
gimp_drawable_transform_matrix_default (gint32 drawable_ID,
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
gboolean interpolate,
gboolean clip_result)
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
gboolean interpolate,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-drawable-transform-matrix-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, coeff_0_0,
GIMP_PDB_FLOAT, coeff_0_1,
GIMP_PDB_FLOAT, coeff_0_2,
GIMP_PDB_FLOAT, coeff_1_0,
GIMP_PDB_FLOAT, coeff_1_1,
GIMP_PDB_FLOAT, coeff_1_2,
GIMP_PDB_FLOAT, coeff_2_0,
GIMP_PDB_FLOAT, coeff_2_1,
GIMP_PDB_FLOAT, coeff_2_2,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, coeff_0_0,
GIMP_PDB_FLOAT, coeff_0_1,
GIMP_PDB_FLOAT, coeff_0_2,
GIMP_PDB_FLOAT, coeff_1_0,
GIMP_PDB_FLOAT, coeff_1_1,
GIMP_PDB_FLOAT, coeff_1_2,
GIMP_PDB_FLOAT, coeff_2_0,
GIMP_PDB_FLOAT, coeff_2_1,
GIMP_PDB_FLOAT, coeff_2_2,
GIMP_PDB_INT32, interpolate,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;

268
libgimp/gimpdrawabletransform_pdb.h
View File

@ -30,155 +30,155 @@ G_BEGIN_DECLS
gint32 gimp_drawable_transform_flip_simple (gint32 drawable_ID,
GimpOrientationType flip_type,
gboolean auto_center,
gdouble axis,
gboolean clip_result);
GimpOrientationType flip_type,
gboolean auto_center,
gdouble axis,
gboolean clip_result);
gint32 gimp_drawable_transform_flip (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_flip_default (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result);
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result);
gint32 gimp_drawable_transform_perspective (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_perspective_default (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
gboolean interpolate,
gboolean clip_result);
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3,
gboolean interpolate,
gboolean clip_result);
gint32 gimp_drawable_transform_rotate_simple (gint32 drawable_ID,
GimpRotationType rotate_type,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean clip_result);
GimpRotationType rotate_type,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean clip_result);
gint32 gimp_drawable_transform_rotate (gint32 drawable_ID,
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_rotate_default (gint32 drawable_ID,
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean interpolate,
gboolean clip_result);
gdouble angle,
gboolean auto_center,
gint center_x,
gint center_y,
gboolean interpolate,
gboolean clip_result);
gint32 gimp_drawable_transform_scale (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_scale_default (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result);
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gboolean interpolate,
gboolean clip_result);
gint32 gimp_drawable_transform_shear (gint32 drawable_ID,
GimpOrientationType shear_type,
gdouble magnitude,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
GimpOrientationType shear_type,
gdouble magnitude,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_shear_default (gint32 drawable_ID,
GimpOrientationType shear_type,
gdouble magnitude,
gboolean interpolate,
gboolean clip_result);
GimpOrientationType shear_type,
gdouble magnitude,
gboolean interpolate,
gboolean clip_result);
gint32 gimp_drawable_transform_2d (gint32 drawable_ID,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_2d_default (gint32 drawable_ID,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
gboolean interpolate,
gboolean clip_result);
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y,
gboolean interpolate,
gboolean clip_result);
gint32 gimp_drawable_transform_matrix (gint32 drawable_ID,
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
gint32 gimp_drawable_transform_matrix_default (gint32 drawable_ID,
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
gboolean interpolate,
gboolean clip_result);
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
gboolean interpolate,
gboolean clip_result);
G_END_DECLS

204
libgimp/gimpedit_pdb.c
View File

@ -48,9 +48,9 @@ gimp_edit_cut (gint32 drawable_ID)
gboolean non_empty = FALSE;
return_vals = gimp_run_procedure ("gimp-edit-cut",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
non_empty = return_vals[1].data.d_int32;
@ -83,9 +83,9 @@ gimp_edit_copy (gint32 drawable_ID)
gboolean non_empty = FALSE;
return_vals = gimp_run_procedure ("gimp-edit-copy",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
non_empty = return_vals[1].data.d_int32;
@ -120,9 +120,9 @@ gimp_edit_copy_visible (gint32 image_ID)
gboolean non_empty = FALSE;
return_vals = gimp_run_procedure ("gimp-edit-copy-visible",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
non_empty = return_vals[1].data.d_int32;
@ -159,17 +159,17 @@ gimp_edit_copy_visible (gint32 image_ID)
*/
gint32
gimp_edit_paste (gint32 drawable_ID,
gboolean paste_into)
gboolean paste_into)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 floating_sel_ID = -1;
return_vals = gimp_run_procedure ("gimp-edit-paste",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, paste_into,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, paste_into,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
floating_sel_ID = return_vals[1].data.d_layer;
@ -201,8 +201,8 @@ gimp_edit_paste_as_new (void)
gint32 image_ID = -1;
return_vals = gimp_run_procedure ("gimp-edit-paste-as-new",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
image_ID = return_vals[1].data.d_image;
@ -229,17 +229,17 @@ gimp_edit_paste_as_new (void)
*/
gchar *
gimp_edit_named_cut (gint32 drawable_ID,
const gchar *buffer_name)
const gchar *buffer_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *real_name = NULL;
return_vals = gimp_run_procedure ("gimp-edit-named-cut",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
real_name = g_strdup (return_vals[1].data.d_string);
@ -267,17 +267,17 @@ gimp_edit_named_cut (gint32 drawable_ID,
*/
gchar *
gimp_edit_named_copy (gint32 drawable_ID,
const gchar *buffer_name)
const gchar *buffer_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *real_name = NULL;
return_vals = gimp_run_procedure ("gimp-edit-named-copy",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
real_name = g_strdup (return_vals[1].data.d_string);
@ -305,17 +305,17 @@ gimp_edit_named_copy (gint32 drawable_ID,
*/
gchar *
gimp_edit_named_copy_visible (gint32 image_ID,
const gchar *buffer_name)
const gchar *buffer_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *real_name = NULL;
return_vals = gimp_run_procedure ("gimp-edit-named-copy-visible",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
real_name = g_strdup (return_vals[1].data.d_string);
@ -342,19 +342,19 @@ gimp_edit_named_copy_visible (gint32 image_ID,
*/
gint32
gimp_edit_named_paste (gint32 drawable_ID,
const gchar *buffer_name,
gboolean paste_into)
const gchar *buffer_name,
gboolean paste_into)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 floating_sel_ID = -1;
return_vals = gimp_run_procedure ("gimp-edit-named-paste",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_INT32, paste_into,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_INT32, paste_into,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
floating_sel_ID = return_vals[1].data.d_layer;
@ -385,9 +385,9 @@ gimp_edit_named_paste_as_new (const gchar *buffer_name)
gint32 image_ID = -1;
return_vals = gimp_run_procedure ("gimp-edit-named-paste-as-new",
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, buffer_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
image_ID = return_vals[1].data.d_image;
@ -419,9 +419,9 @@ gimp_edit_clear (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-edit-clear",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -449,17 +449,17 @@ gimp_edit_clear (gint32 drawable_ID)
*/
gboolean
gimp_edit_fill (gint32 drawable_ID,
GimpFillType fill_type)
GimpFillType fill_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-edit-fill",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, fill_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, fill_type,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -499,29 +499,29 @@ gimp_edit_fill (gint32 drawable_ID,
*/
gboolean
gimp_edit_bucket_fill (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y)
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-edit-bucket-fill",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, fill_mode,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_FLOAT, threshold,
GIMP_PDB_INT32, sample_merged,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, fill_mode,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_FLOAT, threshold,
GIMP_PDB_INT32, sample_merged,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -561,45 +561,45 @@ gimp_edit_bucket_fill (gint32 drawable_ID,
*/
gboolean
gimp_edit_blend (gint32 drawable_ID,
GimpBlendMode blend_mode,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
GimpBlendMode blend_mode,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-edit-blend",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, blend_mode,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_INT32, gradient_type,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_FLOAT, offset,
GIMP_PDB_INT32, repeat,
GIMP_PDB_INT32, reverse,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, max_depth,
GIMP_PDB_FLOAT, threshold,
GIMP_PDB_INT32, dither,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, blend_mode,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_INT32, gradient_type,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_FLOAT, offset,
GIMP_PDB_INT32, repeat,
GIMP_PDB_INT32, reverse,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, max_depth,
GIMP_PDB_FLOAT, threshold,
GIMP_PDB_INT32, dither,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -629,9 +629,9 @@ gimp_edit_stroke (gint32 drawable_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-edit-stroke",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

58
libgimp/gimpedit_pdb.h
View File

@ -33,45 +33,45 @@ gboolean gimp_edit_cut (gint32 drawable_ID);
gboolean gimp_edit_copy (gint32 drawable_ID);
gboolean gimp_edit_copy_visible (gint32 image_ID);
gint32 gimp_edit_paste (gint32 drawable_ID,
gboolean paste_into);
gboolean paste_into);
gint32 gimp_edit_paste_as_new (void);
gchar* gimp_edit_named_cut (gint32 drawable_ID,
const gchar *buffer_name);
const gchar *buffer_name);
gchar* gimp_edit_named_copy (gint32 drawable_ID,
const gchar *buffer_name);
const gchar *buffer_name);
gchar* gimp_edit_named_copy_visible (gint32 image_ID,
const gchar *buffer_name);
const gchar *buffer_name);
gint32 gimp_edit_named_paste (gint32 drawable_ID,
const gchar *buffer_name,
gboolean paste_into);
const gchar *buffer_name,
gboolean paste_into);
gint32 gimp_edit_named_paste_as_new (const gchar *buffer_name);
gboolean gimp_edit_clear (gint32 drawable_ID);
gboolean gimp_edit_fill (gint32 drawable_ID,
GimpFillType fill_type);
GimpFillType fill_type);
gboolean gimp_edit_bucket_fill (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y);
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y);
gboolean gimp_edit_blend (gint32 drawable_ID,
GimpBlendMode blend_mode,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2);
GimpBlendMode blend_mode,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2);
gboolean gimp_edit_stroke (gint32 drawable_ID);

122
libgimp/gimpfileops_pdb.c
View File

@ -45,19 +45,19 @@
*/
gint32
gimp_file_load (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename)
const gchar *filename,
const gchar *raw_filename)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 image_ID = -1;
return_vals = gimp_run_procedure ("gimp-file-load",
&nreturn_vals,
GIMP_PDB_INT32, run_mode,
GIMP_PDB_STRING, filename,
GIMP_PDB_STRING, raw_filename,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, run_mode,
GIMP_PDB_STRING, filename,
GIMP_PDB_STRING, raw_filename,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
image_ID = return_vals[1].data.d_image;
@ -84,19 +84,19 @@ gimp_file_load (GimpRunMode run_mode,
*/
gint32
gimp_file_load_layer (GimpRunMode run_mode,
gint32 image_ID,
const gchar *filename)
gint32 image_ID,
const gchar *filename)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 layer_ID = -1;
return_vals = gimp_run_procedure ("gimp-file-load-layer",
&nreturn_vals,
GIMP_PDB_INT32, run_mode,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, filename,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, run_mode,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, filename,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_ID = return_vals[1].data.d_layer;
@ -127,23 +127,23 @@ gimp_file_load_layer (GimpRunMode run_mode,
*/
gboolean
gimp_file_save (GimpRunMode run_mode,
gint32 image_ID,
gint32 drawable_ID,
const gchar *filename,
const gchar *raw_filename)
gint32 image_ID,
gint32 drawable_ID,
const gchar *filename,
const gchar *raw_filename)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-file-save",
&nreturn_vals,
GIMP_PDB_INT32, run_mode,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, filename,
GIMP_PDB_STRING, raw_filename,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, run_mode,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, filename,
GIMP_PDB_STRING, raw_filename,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -171,9 +171,9 @@ gimp_temp_name (const gchar *extension)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-temp-name",
&nreturn_vals,
GIMP_PDB_STRING, extension,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, extension,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -199,21 +199,21 @@ gimp_temp_name (const gchar *extension)
*/
gboolean
gimp_register_magic_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes,
const gchar *magics)
const gchar *extensions,
const gchar *prefixes,
const gchar *magics)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-register-magic-load-handler",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, extensions,
GIMP_PDB_STRING, prefixes,
GIMP_PDB_STRING, magics,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, extensions,
GIMP_PDB_STRING, prefixes,
GIMP_PDB_STRING, magics,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -237,19 +237,19 @@ gimp_register_magic_load_handler (const gchar *procedure_name,
*/
gboolean
gimp_register_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes)
const gchar *extensions,
const gchar *prefixes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-register-load-handler",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, extensions,
GIMP_PDB_STRING, prefixes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, extensions,
GIMP_PDB_STRING, prefixes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -273,19 +273,19 @@ gimp_register_load_handler (const gchar *procedure_name,
*/
gboolean
gimp_register_save_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes)
const gchar *extensions,
const gchar *prefixes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-register-save-handler",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, extensions,
GIMP_PDB_STRING, prefixes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, extensions,
GIMP_PDB_STRING, prefixes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -311,17 +311,17 @@ gimp_register_save_handler (const gchar *procedure_name,
*/
gboolean
gimp_register_file_handler_mime (const gchar *procedure_name,
const gchar *mime_type)
const gchar *mime_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-register-file-handler-mime",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, mime_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, mime_type,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -350,17 +350,17 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
*/
gboolean
gimp_register_thumbnail_loader (const gchar *load_proc,
const gchar *thumb_proc)
const gchar *thumb_proc)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-register-thumbnail-loader",
&nreturn_vals,
GIMP_PDB_STRING, load_proc,
GIMP_PDB_STRING, thumb_proc,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, load_proc,
GIMP_PDB_STRING, thumb_proc,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

34
libgimp/gimpfileops_pdb.h
View File

@ -30,31 +30,31 @@ G_BEGIN_DECLS
gint32 gimp_file_load (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename);
const gchar *filename,
const gchar *raw_filename);
gint32 gimp_file_load_layer (GimpRunMode run_mode,
gint32 image_ID,
const gchar *filename);
gint32 image_ID,
const gchar *filename);
gboolean gimp_file_save (GimpRunMode run_mode,
gint32 image_ID,
gint32 drawable_ID,
const gchar *filename,
const gchar *raw_filename);
gint32 image_ID,
gint32 drawable_ID,
const gchar *filename,
const gchar *raw_filename);
gchar* gimp_temp_name (const gchar *extension);
gboolean gimp_register_magic_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes,
const gchar *magics);
const gchar *extensions,
const gchar *prefixes,
const gchar *magics);
gboolean gimp_register_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes);
const gchar *extensions,
const gchar *prefixes);
gboolean gimp_register_save_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes);
const gchar *extensions,
const gchar *prefixes);
gboolean gimp_register_file_handler_mime (const gchar *procedure_name,
const gchar *mime_type);
const gchar *mime_type);
gboolean gimp_register_thumbnail_loader (const gchar *load_proc,
const gchar *thumb_proc);
const gchar *thumb_proc);
G_END_DECLS

48
libgimp/gimpfloatingsel_pdb.c
View File

@ -45,9 +45,9 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-floating-sel-remove",
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -77,9 +77,9 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-floating-sel-anchor",
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -113,9 +113,9 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-floating-sel-to-layer",
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -138,17 +138,17 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID)
*/
gboolean
gimp_floating_sel_attach (gint32 layer_ID,
gint32 drawable_ID)
gint32 drawable_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-floating-sel-attach",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -170,17 +170,17 @@ gimp_floating_sel_attach (gint32 layer_ID,
*/
gboolean
gimp_floating_sel_rigor (gint32 floating_sel_ID,
gboolean undo)
gboolean undo)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-floating-sel-rigor",
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_INT32, undo,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_INT32, undo,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -202,17 +202,17 @@ gimp_floating_sel_rigor (gint32 floating_sel_ID,
*/
gboolean
gimp_floating_sel_relax (gint32 floating_sel_ID,
gboolean undo)
gboolean undo)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-floating-sel-relax",
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_INT32, undo,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, floating_sel_ID,
GIMP_PDB_INT32, undo,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

6
libgimp/gimpfloatingsel_pdb.h
View File

@ -33,11 +33,11 @@ gboolean gimp_floating_sel_remove (gint32 floating_sel_ID);
gboolean gimp_floating_sel_anchor (gint32 floating_sel_ID);
gboolean gimp_floating_sel_to_layer (gint32 floating_sel_ID);
gboolean gimp_floating_sel_attach (gint32 layer_ID,
gint32 drawable_ID);
gint32 drawable_ID);
gboolean gimp_floating_sel_rigor (gint32 floating_sel_ID,
gboolean undo);
gboolean undo);
gboolean gimp_floating_sel_relax (gint32 floating_sel_ID,
gboolean undo);
gboolean undo);
G_END_DECLS

12
libgimp/gimpfonts_pdb.c
View File

@ -43,8 +43,8 @@ gimp_fonts_refresh (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-fonts-refresh",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -67,7 +67,7 @@ gimp_fonts_refresh (void)
*/
gchar **
gimp_fonts_get_list (const gchar *filter,
gint *num_fonts)
gint *num_fonts)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -75,9 +75,9 @@ gimp_fonts_get_list (const gchar *filter,
gint i;
return_vals = gimp_run_procedure ("gimp-fonts-get-list",
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
*num_fonts = 0;

2
libgimp/gimpfonts_pdb.h
View File

@ -31,7 +31,7 @@ G_BEGIN_DECLS
gboolean gimp_fonts_refresh (void);
gchar** gimp_fonts_get_list (const gchar *filter,
gint *num_fonts);
gint *num_fonts);
G_END_DECLS

30
libgimp/gimpfontselect_pdb.c
View File

@ -39,19 +39,19 @@
*/
gboolean
gimp_fonts_popup (const gchar *font_callback,
const gchar *popup_title,
const gchar *initial_font)
const gchar *popup_title,
const gchar *initial_font)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-fonts-popup",
&nreturn_vals,
GIMP_PDB_STRING, font_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_font,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, font_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_font,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -78,9 +78,9 @@ gimp_fonts_close_popup (const gchar *font_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-fonts-close-popup",
&nreturn_vals,
GIMP_PDB_STRING, font_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, font_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -102,17 +102,17 @@ gimp_fonts_close_popup (const gchar *font_callback)
*/
gboolean
gimp_fonts_set_popup (const gchar *font_callback,
const gchar *font_name)
const gchar *font_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-fonts-set-popup",
&nreturn_vals,
GIMP_PDB_STRING, font_callback,
GIMP_PDB_STRING, font_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, font_callback,
GIMP_PDB_STRING, font_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

6
libgimp/gimpfontselect_pdb.h
View File

@ -30,11 +30,11 @@ G_BEGIN_DECLS
gboolean gimp_fonts_popup (const gchar *font_callback,
const gchar *popup_title,
const gchar *initial_font);
const gchar *popup_title,
const gchar *initial_font);
gboolean gimp_fonts_close_popup (const gchar *font_callback);
gboolean gimp_fonts_set_popup (const gchar *font_callback,
const gchar *font_name);
const gchar *font_name);
G_END_DECLS

38
libgimp/gimpgimprc_pdb.c
View File

@ -51,9 +51,9 @@ gimp_gimprc_query (const gchar *token)
gchar *value = NULL;
return_vals = gimp_run_procedure ("gimp-gimprc-query",
&nreturn_vals,
GIMP_PDB_STRING, token,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, token,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
value = g_strdup (return_vals[1].data.d_string);
@ -80,17 +80,17 @@ gimp_gimprc_query (const gchar *token)
*/
gboolean
gimp_gimprc_set (const gchar *token,
const gchar *value)
const gchar *value)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gimprc-set",
&nreturn_vals,
GIMP_PDB_STRING, token,
GIMP_PDB_STRING, value,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, token,
GIMP_PDB_STRING, value,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -116,8 +116,8 @@ gimp_get_default_comment (void)
gchar *comment = NULL;
return_vals = gimp_run_procedure ("gimp-get-default-comment",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
comment = g_strdup (return_vals[1].data.d_string);
@ -143,15 +143,15 @@ gimp_get_default_comment (void)
*/
gboolean
gimp_get_monitor_resolution (gdouble *xres,
gdouble *yres)
gdouble *yres)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-get-monitor-resolution",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
*xres = 0.0;
*yres = 0.0;
@ -186,8 +186,8 @@ gimp_get_theme_dir (void)
gchar *theme_dir = NULL;
return_vals = gimp_run_procedure ("gimp-get-theme-dir",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
theme_dir = g_strdup (return_vals[1].data.d_string);
@ -217,8 +217,8 @@ _gimp_get_color_configuration (void)
gchar *config = NULL;
return_vals = gimp_run_procedure ("gimp-get-color-configuration",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
config = g_strdup (return_vals[1].data.d_string);
@ -245,8 +245,8 @@ gimp_get_module_load_inhibit (void)
gchar *load_inhibit = NULL;
return_vals = gimp_run_procedure ("gimp-get-module-load-inhibit",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
load_inhibit = g_strdup (return_vals[1].data.d_string);

4
libgimp/gimpgimprc_pdb.h
View File

@ -31,10 +31,10 @@ G_BEGIN_DECLS
gchar* gimp_gimprc_query (const gchar *token);
gboolean gimp_gimprc_set (const gchar *token,
const gchar *value);
const gchar *value);
gchar* gimp_get_default_comment (void);
gboolean gimp_get_monitor_resolution (gdouble *xres,
gdouble *yres);
gdouble *yres);
gchar* gimp_get_theme_dir (void);
gchar* _gimp_get_color_configuration (void) G_GNUC_INTERNAL;
gchar* gimp_get_module_load_inhibit (void);

424
libgimp/gimpgradient_pdb.c
View File

@ -47,9 +47,9 @@ gimp_gradient_new (const gchar *name)
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-gradient-new",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
actual_name = g_strdup (return_vals[1].data.d_string);
@ -79,9 +79,9 @@ gimp_gradient_duplicate (const gchar *name)
gchar *copy_name = NULL;
return_vals = gimp_run_procedure ("gimp-gradient-duplicate",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
copy_name = g_strdup (return_vals[1].data.d_string);
@ -111,9 +111,9 @@ gimp_gradient_is_editable (const gchar *name)
gboolean editable = FALSE;
return_vals = gimp_run_procedure ("gimp-gradient-is-editable",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
editable = return_vals[1].data.d_int32;
@ -138,17 +138,17 @@ gimp_gradient_is_editable (const gchar *name)
*/
gchar *
gimp_gradient_rename (const gchar *name,
const gchar *new_name)
const gchar *new_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-gradient-rename",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
actual_name = g_strdup (return_vals[1].data.d_string);
@ -178,9 +178,9 @@ gimp_gradient_delete (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-delete",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -213,21 +213,21 @@ gimp_gradient_delete (const gchar *name)
*/
gboolean
gimp_gradient_get_uniform_samples (const gchar *name,
gint num_samples,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples)
gint num_samples,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-get-uniform-samples",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
*num_color_samples = 0;
*color_samples = NULL;
@ -271,23 +271,23 @@ gimp_gradient_get_uniform_samples (const gchar *name,
*/
gboolean
gimp_gradient_get_custom_samples (const gchar *name,
gint num_samples,
const gdouble *positions,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples)
gint num_samples,
const gdouble *positions,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-get-custom-samples",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_FLOATARRAY, positions,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_FLOATARRAY, positions,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
*num_color_samples = 0;
*color_samples = NULL;
@ -325,19 +325,19 @@ gimp_gradient_get_custom_samples (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_left_color (const gchar *name,
gint segment,
GimpRGB *color,
gdouble *opacity)
gint segment,
GimpRGB *color,
gdouble *opacity)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-left-color",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*opacity = 0.0;
@ -372,21 +372,21 @@ gimp_gradient_segment_get_left_color (const gchar *name,
*/
gboolean
gimp_gradient_segment_set_left_color (const gchar *name,
gint segment,
const GimpRGB *color,
gdouble opacity)
gint segment,
const GimpRGB *color,
gdouble opacity)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-set-left-color",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_COLOR, color,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_COLOR, color,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -413,19 +413,19 @@ gimp_gradient_segment_set_left_color (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_right_color (const gchar *name,
gint segment,
GimpRGB *color,
gdouble *opacity)
gint segment,
GimpRGB *color,
gdouble *opacity)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-right-color",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*opacity = 0.0;
@ -460,21 +460,21 @@ gimp_gradient_segment_get_right_color (const gchar *name,
*/
gboolean
gimp_gradient_segment_set_right_color (const gchar *name,
gint segment,
const GimpRGB *color,
gdouble opacity)
gint segment,
const GimpRGB *color,
gdouble opacity)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-set-right-color",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_COLOR, color,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_COLOR, color,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -500,18 +500,18 @@ gimp_gradient_segment_set_right_color (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_left_pos (const gchar *name,
gint segment,
gdouble *pos)
gint segment,
gdouble *pos)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-left-pos",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*pos = 0.0;
@ -546,20 +546,20 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
*/
gboolean
gimp_gradient_segment_set_left_pos (const gchar *name,
gint segment,
gdouble pos,
gdouble *final_pos)
gint segment,
gdouble pos,
gdouble *final_pos)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-set-left-pos",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_FLOAT, pos,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_FLOAT, pos,
GIMP_PDB_END);
*final_pos = 0.0;
@ -590,18 +590,18 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_middle_pos (const gchar *name,
gint segment,
gdouble *pos)
gint segment,
gdouble *pos)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-middle-pos",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*pos = 0.0;
@ -635,20 +635,20 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
*/
gboolean
gimp_gradient_segment_set_middle_pos (const gchar *name,
gint segment,
gdouble pos,
gdouble *final_pos)
gint segment,
gdouble pos,
gdouble *final_pos)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-set-middle-pos",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_FLOAT, pos,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_FLOAT, pos,
GIMP_PDB_END);
*final_pos = 0.0;
@ -679,18 +679,18 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_right_pos (const gchar *name,
gint segment,
gdouble *pos)
gint segment,
gdouble *pos)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-right-pos",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*pos = 0.0;
@ -725,20 +725,20 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
*/
gboolean
gimp_gradient_segment_set_right_pos (const gchar *name,
gint segment,
gdouble pos,
gdouble *final_pos)
gint segment,
gdouble pos,
gdouble *final_pos)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-set-right-pos",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_FLOAT, pos,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_FLOAT, pos,
GIMP_PDB_END);
*final_pos = 0.0;
@ -769,18 +769,18 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_blending_function (const gchar *name,
gint segment,
GimpGradientSegmentType *blend_func)
gint segment,
GimpGradientSegmentType *blend_func)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-blending-function",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*blend_func = 0;
@ -811,18 +811,18 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
*/
gboolean
gimp_gradient_segment_get_coloring_type (const gchar *name,
gint segment,
GimpGradientSegmentColor *coloring_type)
gint segment,
GimpGradientSegmentColor *coloring_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-get-coloring-type",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, segment,
GIMP_PDB_END);
*coloring_type = 0;
@ -854,21 +854,21 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_set_blending_function (const gchar *name,
gint start_segment,
gint end_segment,
GimpGradientSegmentType blending_function)
gint start_segment,
gint end_segment,
GimpGradientSegmentType blending_function)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-set-blending-function",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, blending_function,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, blending_function,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -895,21 +895,21 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
*/
gboolean
gimp_gradient_segment_range_set_coloring_type (const gchar *name,
gint start_segment,
gint end_segment,
GimpGradientSegmentColor coloring_type)
gint start_segment,
gint end_segment,
GimpGradientSegmentColor coloring_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-set-coloring-type",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, coloring_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, coloring_type,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -934,19 +934,19 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_flip (const gchar *name,
gint start_segment,
gint end_segment)
gint start_segment,
gint end_segment)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-flip",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -974,21 +974,21 @@ gimp_gradient_segment_range_flip (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_replicate (const gchar *name,
gint start_segment,
gint end_segment,
gint replicate_times)
gint start_segment,
gint end_segment,
gint replicate_times)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-replicate",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, replicate_times,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, replicate_times,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1014,19 +1014,19 @@ gimp_gradient_segment_range_replicate (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_split_midpoint (const gchar *name,
gint start_segment,
gint end_segment)
gint start_segment,
gint end_segment)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-split-midpoint",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1053,21 +1053,21 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_split_uniform (const gchar *name,
gint start_segment,
gint end_segment,
gint split_parts)
gint start_segment,
gint end_segment,
gint split_parts)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-split-uniform",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, split_parts,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_INT32, split_parts,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1092,19 +1092,19 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_delete (const gchar *name,
gint start_segment,
gint end_segment)
gint start_segment,
gint end_segment)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-delete",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1130,19 +1130,19 @@ gimp_gradient_segment_range_delete (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_redistribute_handles (const gchar *name,
gint start_segment,
gint end_segment)
gint start_segment,
gint end_segment)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-redistribute-handles",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1169,19 +1169,19 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_blend_colors (const gchar *name,
gint start_segment,
gint end_segment)
gint start_segment,
gint end_segment)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-blend-colors",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1208,19 +1208,19 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
*/
gboolean
gimp_gradient_segment_range_blend_opacity (const gchar *name,
gint start_segment,
gint end_segment)
gint start_segment,
gint end_segment)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-blend-opacity",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -1249,23 +1249,23 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
*/
gdouble
gimp_gradient_segment_range_move (const gchar *name,
gint start_segment,
gint end_segment,
gdouble delta,
gboolean control_compress)
gint start_segment,
gint end_segment,
gdouble delta,
gboolean control_compress)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble final_delta = 0.0;
return_vals = gimp_run_procedure ("gimp-gradient-segment-range-move",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_FLOAT, delta,
GIMP_PDB_INT32, control_compress,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, start_segment,
GIMP_PDB_INT32, end_segment,
GIMP_PDB_FLOAT, delta,
GIMP_PDB_INT32, control_compress,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
final_delta = return_vals[1].data.d_float;

138
libgimp/gimpgradient_pdb.h
View File

@ -33,101 +33,101 @@ gchar* gimp_gradient_new (const gchar
gchar* gimp_gradient_duplicate (const gchar *name);
gboolean gimp_gradient_is_editable (const gchar *name);
gchar* gimp_gradient_rename (const gchar *name,
const gchar *new_name);
const gchar *new_name);
gboolean gimp_gradient_delete (const gchar *name);
gboolean gimp_gradient_get_uniform_samples (const gchar *name,
gint num_samples,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples);
gint num_samples,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples);
gboolean gimp_gradient_get_custom_samples (const gchar *name,
gint num_samples,
const gdouble *positions,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples);
gint num_samples,
const gdouble *positions,
gboolean reverse,
gint *num_color_samples,
gdouble **color_samples);
gboolean gimp_gradient_segment_get_left_color (const gchar *name,
gint segment,
GimpRGB *color,
gdouble *opacity);
gint segment,
GimpRGB *color,
gdouble *opacity);
gboolean gimp_gradient_segment_set_left_color (const gchar *name,
gint segment,
const GimpRGB *color,
gdouble opacity);
gint segment,
const GimpRGB *color,
gdouble opacity);
gboolean gimp_gradient_segment_get_right_color (const gchar *name,
gint segment,
GimpRGB *color,
gdouble *opacity);
gint segment,
GimpRGB *color,
gdouble *opacity);
gboolean gimp_gradient_segment_set_right_color (const gchar *name,
gint segment,
const GimpRGB *color,
gdouble opacity);
gint segment,
const GimpRGB *color,
gdouble opacity);
gboolean gimp_gradient_segment_get_left_pos (const gchar *name,
gint segment,
gdouble *pos);
gint segment,
gdouble *pos);
gboolean gimp_gradient_segment_set_left_pos (const gchar *name,
gint segment,
gdouble pos,
gdouble *final_pos);
gint segment,
gdouble pos,
gdouble *final_pos);
gboolean gimp_gradient_segment_get_middle_pos (const gchar *name,
gint segment,
gdouble *pos);
gint segment,
gdouble *pos);
gboolean gimp_gradient_segment_set_middle_pos (const gchar *name,
gint segment,
gdouble pos,
gdouble *final_pos);
gint segment,
gdouble pos,
gdouble *final_pos);
gboolean gimp_gradient_segment_get_right_pos (const gchar *name,
gint segment,
gdouble *pos);
gint segment,
gdouble *pos);
gboolean gimp_gradient_segment_set_right_pos (const gchar *name,
gint segment,
gdouble pos,
gdouble *final_pos);
gint segment,
gdouble pos,
gdouble *final_pos);
gboolean gimp_gradient_segment_get_blending_function (const gchar *name,
gint segment,
GimpGradientSegmentType *blend_func);
gint segment,
GimpGradientSegmentType *blend_func);
gboolean gimp_gradient_segment_get_coloring_type (const gchar *name,
gint segment,
GimpGradientSegmentColor *coloring_type);
gint segment,
GimpGradientSegmentColor *coloring_type);
gboolean gimp_gradient_segment_range_set_blending_function (const gchar *name,
gint start_segment,
gint end_segment,
GimpGradientSegmentType blending_function);
gint start_segment,
gint end_segment,
GimpGradientSegmentType blending_function);
gboolean gimp_gradient_segment_range_set_coloring_type (const gchar *name,
gint start_segment,
gint end_segment,
GimpGradientSegmentColor coloring_type);
gint start_segment,
gint end_segment,
GimpGradientSegmentColor coloring_type);
gboolean gimp_gradient_segment_range_flip (const gchar *name,
gint start_segment,
gint end_segment);
gint start_segment,
gint end_segment);
gboolean gimp_gradient_segment_range_replicate (const gchar *name,
gint start_segment,
gint end_segment,
gint replicate_times);
gint start_segment,
gint end_segment,
gint replicate_times);
gboolean gimp_gradient_segment_range_split_midpoint (const gchar *name,
gint start_segment,
gint end_segment);
gint start_segment,
gint end_segment);
gboolean gimp_gradient_segment_range_split_uniform (const gchar *name,
gint start_segment,
gint end_segment,
gint split_parts);
gint start_segment,
gint end_segment,
gint split_parts);
gboolean gimp_gradient_segment_range_delete (const gchar *name,
gint start_segment,
gint end_segment);
gint start_segment,
gint end_segment);
gboolean gimp_gradient_segment_range_redistribute_handles (const gchar *name,
gint start_segment,
gint end_segment);
gint start_segment,
gint end_segment);
gboolean gimp_gradient_segment_range_blend_colors (const gchar *name,
gint start_segment,
gint end_segment);
gint start_segment,
gint end_segment);
gboolean gimp_gradient_segment_range_blend_opacity (const gchar *name,
gint start_segment,
gint end_segment);
gint start_segment,
gint end_segment);
gdouble gimp_gradient_segment_range_move (const gchar *name,
gint start_segment,
gint end_segment,
gdouble delta,
gboolean control_compress);
gint start_segment,
gint end_segment,
gdouble delta,
gboolean control_compress);
G_END_DECLS

54
libgimp/gimpgradients_pdb.c
View File

@ -45,8 +45,8 @@ gimp_gradients_refresh (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradients-refresh",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -70,7 +70,7 @@ gimp_gradients_refresh (void)
*/
gchar **
gimp_gradients_get_list (const gchar *filter,
gint *num_gradients)
gint *num_gradients)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -78,9 +78,9 @@ gimp_gradients_get_list (const gchar *filter,
gint i;
return_vals = gimp_run_procedure ("gimp-gradients-get-list",
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
*num_gradients = 0;
@ -109,7 +109,7 @@ gimp_gradients_get_list (const gchar *filter,
*/
gdouble *
gimp_gradients_sample_uniform (gint num_samples,
gboolean reverse)
gboolean reverse)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -117,10 +117,10 @@ gimp_gradients_sample_uniform (gint num_samples,
gint num_color_samples;
return_vals = gimp_run_procedure ("gimp-gradients-sample-uniform",
&nreturn_vals,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -148,8 +148,8 @@ gimp_gradients_sample_uniform (gint num_samples,
*/
gdouble *
gimp_gradients_sample_custom (gint num_samples,
const gdouble *positions,
gboolean reverse)
const gdouble *positions,
gboolean reverse)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -157,11 +157,11 @@ gimp_gradients_sample_custom (gint num_samples,
gint num_color_samples;
return_vals = gimp_run_procedure ("gimp-gradients-sample-custom",
&nreturn_vals,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_FLOATARRAY, positions,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, num_samples,
GIMP_PDB_FLOATARRAY, positions,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -191,21 +191,21 @@ gimp_gradients_sample_custom (gint num_samples,
*/
gchar *
gimp_gradients_get_gradient_data (const gchar *name,
gint sample_size,
gboolean reverse,
gint *width,
gdouble **grad_data)
gint sample_size,
gboolean reverse,
gint *width,
gdouble **grad_data)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-gradients-get-gradient-data",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, sample_size,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, sample_size,
GIMP_PDB_INT32, reverse,
GIMP_PDB_END);
*width = 0;

16
libgimp/gimpgradients_pdb.h
View File

@ -31,18 +31,18 @@ G_BEGIN_DECLS
gboolean gimp_gradients_refresh (void);
gchar** gimp_gradients_get_list (const gchar *filter,
gint *num_gradients);
gint *num_gradients);
#ifndef GIMP_DISABLE_DEPRECATED
gdouble* gimp_gradients_sample_uniform (gint num_samples,
gboolean reverse);
gboolean reverse);
gdouble* gimp_gradients_sample_custom (gint num_samples,
const gdouble *positions,
gboolean reverse);
const gdouble *positions,
gboolean reverse);
gchar* gimp_gradients_get_gradient_data (const gchar *name,
gint sample_size,
gboolean reverse,
gint *width,
gdouble **grad_data);
gint sample_size,
gboolean reverse,
gint *width,
gdouble **grad_data);
#endif /* GIMP_DISABLE_DEPRECATED */

34
libgimp/gimpgradientselect_pdb.c
View File

@ -40,21 +40,21 @@
*/
gboolean
gimp_gradients_popup (const gchar *gradient_callback,
const gchar *popup_title,
const gchar *initial_gradient,
gint sample_size)
const gchar *popup_title,
const gchar *initial_gradient,
gint sample_size)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradients-popup",
&nreturn_vals,
GIMP_PDB_STRING, gradient_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_gradient,
GIMP_PDB_INT32, sample_size,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, gradient_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_gradient,
GIMP_PDB_INT32, sample_size,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -81,9 +81,9 @@ gimp_gradients_close_popup (const gchar *gradient_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradients-close-popup",
&nreturn_vals,
GIMP_PDB_STRING, gradient_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, gradient_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -105,17 +105,17 @@ gimp_gradients_close_popup (const gchar *gradient_callback)
*/
gboolean
gimp_gradients_set_popup (const gchar *gradient_callback,
const gchar *gradient_name)
const gchar *gradient_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-gradients-set-popup",
&nreturn_vals,
GIMP_PDB_STRING, gradient_callback,
GIMP_PDB_STRING, gradient_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, gradient_callback,
GIMP_PDB_STRING, gradient_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

8
libgimp/gimpgradientselect_pdb.h
View File

@ -30,12 +30,12 @@ G_BEGIN_DECLS
gboolean gimp_gradients_popup (const gchar *gradient_callback,
const gchar *popup_title,
const gchar *initial_gradient,
gint sample_size);
const gchar *popup_title,
const gchar *initial_gradient,
gint sample_size);
gboolean gimp_gradients_close_popup (const gchar *gradient_callback);
gboolean gimp_gradients_set_popup (const gchar *gradient_callback,
const gchar *gradient_name);
const gchar *gradient_name);
G_END_DECLS

100
libgimp/gimpgrid_pdb.c
View File

@ -42,17 +42,17 @@
*/
gboolean
gimp_image_grid_get_spacing (gint32 image_ID,
gdouble *xspacing,
gdouble *yspacing)
gdouble *xspacing,
gdouble *yspacing)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-get-spacing",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
*xspacing = 0.0;
*yspacing = 0.0;
@ -87,19 +87,19 @@ gimp_image_grid_get_spacing (gint32 image_ID,
*/
gboolean
gimp_image_grid_set_spacing (gint32 image_ID,
gdouble xspacing,
gdouble yspacing)
gdouble xspacing,
gdouble yspacing)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-set-spacing",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, xspacing,
GIMP_PDB_FLOAT, yspacing,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, xspacing,
GIMP_PDB_FLOAT, yspacing,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -125,17 +125,17 @@ gimp_image_grid_set_spacing (gint32 image_ID,
*/
gboolean
gimp_image_grid_get_offset (gint32 image_ID,
gdouble *xoffset,
gdouble *yoffset)
gdouble *xoffset,
gdouble *yoffset)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-get-offset",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
*xoffset = 0.0;
*yoffset = 0.0;
@ -170,19 +170,19 @@ gimp_image_grid_get_offset (gint32 image_ID,
*/
gboolean
gimp_image_grid_set_offset (gint32 image_ID,
gdouble xoffset,
gdouble yoffset)
gdouble xoffset,
gdouble yoffset)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-set-offset",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, xoffset,
GIMP_PDB_FLOAT, yoffset,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, xoffset,
GIMP_PDB_FLOAT, yoffset,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -206,16 +206,16 @@ gimp_image_grid_set_offset (gint32 image_ID,
*/
gboolean
gimp_image_grid_get_foreground_color (gint32 image_ID,
GimpRGB *fgcolor)
GimpRGB *fgcolor)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-get-foreground-color",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -242,17 +242,17 @@ gimp_image_grid_get_foreground_color (gint32 image_ID,
*/
gboolean
gimp_image_grid_set_foreground_color (gint32 image_ID,
const GimpRGB *fgcolor)
const GimpRGB *fgcolor)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-set-foreground-color",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_COLOR, fgcolor,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_COLOR, fgcolor,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -276,16 +276,16 @@ gimp_image_grid_set_foreground_color (gint32 image_ID,
*/
gboolean
gimp_image_grid_get_background_color (gint32 image_ID,
GimpRGB *bgcolor)
GimpRGB *bgcolor)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-get-background-color",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -312,17 +312,17 @@ gimp_image_grid_get_background_color (gint32 image_ID,
*/
gboolean
gimp_image_grid_set_background_color (gint32 image_ID,
const GimpRGB *bgcolor)
const GimpRGB *bgcolor)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-set-background-color",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_COLOR, bgcolor,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_COLOR, bgcolor,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -351,9 +351,9 @@ gimp_image_grid_get_style (gint32 image_ID)
GimpGridStyle style = 0;
return_vals = gimp_run_procedure ("gimp-image-grid-get-style",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
style = return_vals[1].data.d_int32;
@ -379,17 +379,17 @@ gimp_image_grid_get_style (gint32 image_ID)
*/
gboolean
gimp_image_grid_set_style (gint32 image_ID,
GimpGridStyle style)
GimpGridStyle style)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-grid-set-style",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, style,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, style,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

26
libgimp/gimpgrid_pdb.h
View File

@ -30,28 +30,28 @@ G_BEGIN_DECLS
gboolean gimp_image_grid_get_spacing (gint32 image_ID,
gdouble *xspacing,
gdouble *yspacing);
gdouble *xspacing,
gdouble *yspacing);
gboolean gimp_image_grid_set_spacing (gint32 image_ID,
gdouble xspacing,
gdouble yspacing);
gdouble xspacing,
gdouble yspacing);
gboolean gimp_image_grid_get_offset (gint32 image_ID,
gdouble *xoffset,
gdouble *yoffset);
gdouble *xoffset,
gdouble *yoffset);
gboolean gimp_image_grid_set_offset (gint32 image_ID,
gdouble xoffset,
gdouble yoffset);
gdouble xoffset,
gdouble yoffset);
gboolean gimp_image_grid_get_foreground_color (gint32 image_ID,
GimpRGB *fgcolor);
GimpRGB *fgcolor);
gboolean gimp_image_grid_set_foreground_color (gint32 image_ID,
const GimpRGB *fgcolor);
const GimpRGB *fgcolor);
gboolean gimp_image_grid_get_background_color (gint32 image_ID,
GimpRGB *bgcolor);
GimpRGB *bgcolor);
gboolean gimp_image_grid_set_background_color (gint32 image_ID,
const GimpRGB *bgcolor);
const GimpRGB *bgcolor);
GimpGridStyle gimp_image_grid_get_style (gint32 image_ID);
gboolean gimp_image_grid_set_style (gint32 image_ID,
GimpGridStyle style);
GimpGridStyle style);
G_END_DECLS

60
libgimp/gimpguides_pdb.c
View File

@ -40,17 +40,17 @@
*/
gint32
gimp_image_add_hguide (gint32 image_ID,
gint yposition)
gint yposition)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 guide_ID = -1;
return_vals = gimp_run_procedure ("gimp-image-add-hguide",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, yposition,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, yposition,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
guide_ID = return_vals[1].data.d_int32;
@ -75,17 +75,17 @@ gimp_image_add_hguide (gint32 image_ID,
*/
gint32
gimp_image_add_vguide (gint32 image_ID,
gint xposition)
gint xposition)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 guide_ID = -1;
return_vals = gimp_run_procedure ("gimp-image-add-vguide",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, xposition,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, xposition,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
guide_ID = return_vals[1].data.d_int32;
@ -109,17 +109,17 @@ gimp_image_add_vguide (gint32 image_ID,
*/
gboolean
gimp_image_delete_guide (gint32 image_ID,
gint32 guide_ID)
gint32 guide_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-delete-guide",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -145,17 +145,17 @@ gimp_image_delete_guide (gint32 image_ID,
*/
gint32
gimp_image_find_next_guide (gint32 image_ID,
gint32 guide_ID)
gint32 guide_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 next_guide_ID = -1;
return_vals = gimp_run_procedure ("gimp-image-find-next-guide",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
next_guide_ID = return_vals[1].data.d_int32;
@ -179,17 +179,17 @@ gimp_image_find_next_guide (gint32 image_ID,
*/
GimpOrientationType
gimp_image_get_guide_orientation (gint32 image_ID,
gint32 guide_ID)
gint32 guide_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN;
return_vals = gimp_run_procedure ("gimp-image-get-guide-orientation",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
orientation = return_vals[1].data.d_int32;
@ -213,17 +213,17 @@ gimp_image_get_guide_orientation (gint32 image_ID,
*/
gint
gimp_image_get_guide_position (gint32 image_ID,
gint32 guide_ID)
gint32 guide_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gint position = -1;
return_vals = gimp_run_procedure ("gimp-image-get-guide-position",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, guide_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
position = return_vals[1].data.d_int32;

12
libgimp/gimpguides_pdb.h
View File

@ -30,17 +30,17 @@ G_BEGIN_DECLS
gint32 gimp_image_add_hguide (gint32 image_ID,
gint yposition);
gint yposition);
gint32 gimp_image_add_vguide (gint32 image_ID,
gint xposition);
gint xposition);
gboolean gimp_image_delete_guide (gint32 image_ID,
gint32 guide_ID);
gint32 guide_ID);
gint32 gimp_image_find_next_guide (gint32 image_ID,
gint32 guide_ID);
gint32 guide_ID);
GimpOrientationType gimp_image_get_guide_orientation (gint32 image_ID,
gint32 guide_ID);
gint32 guide_ID);
gint gimp_image_get_guide_position (gint32 image_ID,
gint32 guide_ID);
gint32 guide_ID);
G_END_DECLS

10
libgimp/gimphelp_pdb.c
View File

@ -43,17 +43,17 @@
*/
gboolean
gimp_help (const gchar *help_domain,
const gchar *help_id)
const gchar *help_id)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-help",
&nreturn_vals,
GIMP_PDB_STRING, help_domain,
GIMP_PDB_STRING, help_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, help_domain,
GIMP_PDB_STRING, help_id,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

2
libgimp/gimphelp_pdb.h
View File

@ -30,7 +30,7 @@ G_BEGIN_DECLS
gboolean gimp_help (const gchar *help_domain,
const gchar *help_id);
const gchar *help_id);
G_END_DECLS

692
libgimp/gimpimage_pdb.c
View File

File diff suppressed because it is too large Load Diff

152
libgimp/gimpimage_pdb.h
View File

@ -31,8 +31,8 @@ G_BEGIN_DECLS
gint* gimp_image_list (gint *num_images);
gint32 gimp_image_new (gint width,
gint height,
GimpImageBaseType type);
gint height,
GimpImageBaseType type);
gint32 gimp_image_duplicate (gint32 image_ID);
gboolean gimp_image_delete (gint32 image_ID);
GimpImageBaseType gimp_image_base_type (gint32 image_ID);
@ -40,140 +40,140 @@ gint gimp_image_width (gint32 ima
gint gimp_image_height (gint32 image_ID);
gboolean gimp_image_free_shadow (gint32 image_ID);
gboolean gimp_image_resize (gint32 image_ID,
gint new_width,
gint new_height,
gint offx,
gint offy);
gint new_width,
gint new_height,
gint offx,
gint offy);
gboolean gimp_image_resize_to_layers (gint32 image_ID);
gboolean gimp_image_scale (gint32 image_ID,
gint new_width,
gint new_height);
gint new_width,
gint new_height);
gboolean gimp_image_crop (gint32 image_ID,
gint new_width,
gint new_height,
gint offx,
gint offy);
gint new_width,
gint new_height,
gint offx,
gint offy);
gboolean gimp_image_flip (gint32 image_ID,
GimpOrientationType flip_type);
GimpOrientationType flip_type);
gboolean gimp_image_rotate (gint32 image_ID,
GimpRotationType rotate_type);
GimpRotationType rotate_type);
gint* gimp_image_get_layers (gint32 image_ID,
gint *num_layers);
gint *num_layers);
gint* gimp_image_get_channels (gint32 image_ID,
gint *num_channels);
gint *num_channels);
gint* gimp_image_get_vectors (gint32 image_ID,
gint *num_vectors);
gint *num_vectors);
gint32 gimp_image_get_active_drawable (gint32 image_ID);
gboolean gimp_image_unset_active_channel (gint32 image_ID);
gint32 gimp_image_get_floating_sel (gint32 image_ID);
gint32 gimp_image_floating_sel_attached_to (gint32 image_ID);
gboolean gimp_image_pick_color (gint32 image_ID,
gint32 drawable_ID,
gdouble x,
gdouble y,
gboolean sample_merged,
gboolean sample_average,
gdouble average_radius,
GimpRGB *color);
gint32 drawable_ID,
gdouble x,
gdouble y,
gboolean sample_merged,
gboolean sample_average,
gdouble average_radius,
GimpRGB *color);
gint32 gimp_image_pick_correlate_layer (gint32 image_ID,
gint x,
gint y);
gint x,
gint y);
gboolean gimp_image_add_layer (gint32 image_ID,
gint32 layer_ID,
gint position);
gint32 layer_ID,
gint position);
gboolean gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID);
gint32 layer_ID);
gboolean gimp_image_raise_layer (gint32 image_ID,
gint32 layer_ID);
gint32 layer_ID);
gboolean gimp_image_lower_layer (gint32 image_ID,
gint32 layer_ID);
gint32 layer_ID);
gboolean gimp_image_raise_layer_to_top (gint32 image_ID,
gint32 layer_ID);
gint32 layer_ID);
gboolean gimp_image_lower_layer_to_bottom (gint32 image_ID,
gint32 layer_ID);
gint32 layer_ID);
gboolean gimp_image_add_channel (gint32 image_ID,
gint32 channel_ID,
gint position);
gint32 channel_ID,
gint position);
gboolean gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID);
gint32 channel_ID);
gboolean gimp_image_raise_channel (gint32 image_ID,
gint32 channel_ID);
gint32 channel_ID);
gboolean gimp_image_lower_channel (gint32 image_ID,
gint32 channel_ID);
gint32 channel_ID);
gboolean gimp_image_add_vectors (gint32 image_ID,
gint32 vectors_ID,
gint position);
gint32 vectors_ID,
gint position);
gboolean gimp_image_remove_vectors (gint32 image_ID,
gint32 vectors_ID);
gint32 vectors_ID);
gboolean gimp_image_raise_vectors (gint32 image_ID,
gint32 vectors_ID);
gint32 vectors_ID);
gboolean gimp_image_lower_vectors (gint32 image_ID,
gint32 vectors_ID);
gint32 vectors_ID);
gboolean gimp_image_raise_vectors_to_top (gint32 image_ID,
gint32 vectors_ID);
gint32 vectors_ID);
gboolean gimp_image_lower_vectors_to_bottom (gint32 image_ID,
gint32 vectors_ID);
gint32 vectors_ID);
gint32 gimp_image_flatten (gint32 image_ID);
gint32 gimp_image_merge_visible_layers (gint32 image_ID,
GimpMergeType merge_type);
GimpMergeType merge_type);
gint32 gimp_image_merge_down (gint32 image_ID,
gint32 merge_layer_ID,
GimpMergeType merge_type);
gint32 merge_layer_ID,
GimpMergeType merge_type);
guint8* _gimp_image_get_colormap (gint32 image_ID,
gint *num_bytes) G_GNUC_INTERNAL;
gint *num_bytes) G_GNUC_INTERNAL;
gboolean _gimp_image_set_colormap (gint32 image_ID,
gint num_bytes,
const guint8 *colormap) G_GNUC_INTERNAL;
gint num_bytes,
const guint8 *colormap) G_GNUC_INTERNAL;
gboolean gimp_image_clean_all (gint32 image_ID);
gboolean gimp_image_is_dirty (gint32 image_ID);
gboolean _gimp_image_thumbnail (gint32 image_ID,
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data) G_GNUC_INTERNAL;
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp,
gint *thumbnail_data_count,
guint8 **thumbnail_data) G_GNUC_INTERNAL;
gint32 gimp_image_get_active_layer (gint32 image_ID);
gboolean gimp_image_set_active_layer (gint32 image_ID,
gint32 active_layer_ID);
gint32 active_layer_ID);
gint32 gimp_image_get_active_channel (gint32 image_ID);
gboolean gimp_image_set_active_channel (gint32 image_ID,
gint32 active_channel_ID);
gint32 active_channel_ID);
gint32 gimp_image_get_active_vectors (gint32 image_ID);
gboolean gimp_image_set_active_vectors (gint32 image_ID,
gint32 active_vectors_ID);
gint32 active_vectors_ID);
gint32 gimp_image_get_selection (gint32 image_ID);
gboolean gimp_image_get_component_active (gint32 image_ID,
GimpChannelType component);
GimpChannelType component);
gboolean gimp_image_set_component_active (gint32 image_ID,
GimpChannelType component,
gboolean active);
GimpChannelType component,
gboolean active);
gboolean gimp_image_get_component_visible (gint32 image_ID,
GimpChannelType component);
GimpChannelType component);
gboolean gimp_image_set_component_visible (gint32 image_ID,
GimpChannelType component,
gboolean visible);
GimpChannelType component,
gboolean visible);
gchar* gimp_image_get_filename (gint32 image_ID);
gboolean gimp_image_set_filename (gint32 image_ID,
const gchar *filename);
const gchar *filename);
gchar* gimp_image_get_name (gint32 image_ID);
gboolean gimp_image_get_resolution (gint32 image_ID,
gdouble *xresolution,
gdouble *yresolution);
gdouble *xresolution,
gdouble *yresolution);
gboolean gimp_image_set_resolution (gint32 image_ID,
gdouble xresolution,
gdouble yresolution);
gdouble xresolution,
gdouble yresolution);
GimpUnit gimp_image_get_unit (gint32 image_ID);
gboolean gimp_image_set_unit (gint32 image_ID,
GimpUnit unit);
GimpUnit unit);
gint gimp_image_get_tattoo_state (gint32 image_ID);
gboolean gimp_image_set_tattoo_state (gint32 image_ID,
gint tattoo_state);
gint tattoo_state);
gint32 gimp_image_get_layer_by_tattoo (gint32 image_ID,
gint tattoo);
gint tattoo);
gint32 gimp_image_get_channel_by_tattoo (gint32 image_ID,
gint tattoo);
gint tattoo);
G_END_DECLS

274
libgimp/gimplayer_pdb.c
View File

@ -48,27 +48,27 @@
*/
gint32
_gimp_layer_new (gint32 image_ID,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode)
gint width,
gint height,
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 layer_ID = -1;
return_vals = gimp_run_procedure ("gimp-layer-new",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_INT32, type,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, width,
GIMP_PDB_INT32, height,
GIMP_PDB_INT32, type,
GIMP_PDB_STRING, name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, mode,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_ID = return_vals[1].data.d_layer;
@ -95,17 +95,17 @@ _gimp_layer_new (gint32 image_ID,
*/
gint32
gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32 dest_image_ID)
gint32 dest_image_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 layer_copy_ID = -1;
return_vals = gimp_run_procedure ("gimp-layer-new-from-drawable",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_IMAGE, dest_image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_IMAGE, dest_image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_copy_ID = return_vals[1].data.d_layer;
@ -133,17 +133,17 @@ gimp_layer_new_from_drawable (gint32 drawable_ID,
*/
gint32
_gimp_layer_copy (gint32 layer_ID,
gboolean add_alpha)
gboolean add_alpha)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 layer_copy_ID = -1;
return_vals = gimp_run_procedure ("gimp-layer-copy",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, add_alpha,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, add_alpha,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_copy_ID = return_vals[1].data.d_layer;
@ -176,9 +176,9 @@ gimp_layer_add_alpha (gint32 layer_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-add-alpha",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -206,21 +206,21 @@ gimp_layer_add_alpha (gint32 layer_ID)
*/
gboolean
gimp_layer_scale (gint32 layer_ID,
gint new_width,
gint new_height,
gboolean local_origin)
gint new_width,
gint new_height,
gboolean local_origin)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-scale",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, new_width,
GIMP_PDB_INT32, new_height,
GIMP_PDB_INT32, local_origin,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, new_width,
GIMP_PDB_INT32, new_height,
GIMP_PDB_INT32, local_origin,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -248,23 +248,23 @@ gimp_layer_scale (gint32 layer_ID,
*/
gboolean
gimp_layer_resize (gint32 layer_ID,
gint new_width,
gint new_height,
gint offx,
gint offy)
gint new_width,
gint new_height,
gint offx,
gint offy)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-resize",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, new_width,
GIMP_PDB_INT32, new_height,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, new_width,
GIMP_PDB_INT32, new_height,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -292,9 +292,9 @@ gimp_layer_resize_to_image_size (gint32 layer_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-resize-to-image-size",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -322,19 +322,19 @@ gimp_layer_resize_to_image_size (gint32 layer_ID)
*/
gboolean
gimp_layer_translate (gint32 layer_ID,
gint offx,
gint offy)
gint offx,
gint offy)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-translate",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -359,19 +359,19 @@ gimp_layer_translate (gint32 layer_ID,
*/
gboolean
gimp_layer_set_offsets (gint32 layer_ID,
gint offx,
gint offy)
gint offx,
gint offy)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-offsets",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -402,17 +402,17 @@ gimp_layer_set_offsets (gint32 layer_ID,
*/
gint32
gimp_layer_create_mask (gint32 layer_ID,
GimpAddMaskType mask_type)
GimpAddMaskType mask_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 mask_ID = -1;
return_vals = gimp_run_procedure ("gimp-layer-create-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, mask_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, mask_type,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
mask_ID = return_vals[1].data.d_layer_mask;
@ -441,9 +441,9 @@ gimp_layer_get_mask (gint32 layer_ID)
gint32 mask_ID = -1;
return_vals = gimp_run_procedure ("gimp-layer-get-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
mask_ID = return_vals[1].data.d_layer_mask;
@ -474,9 +474,9 @@ gimp_layer_from_mask (gint32 mask_ID)
gint32 layer_ID = -1;
return_vals = gimp_run_procedure ("gimp-layer-from-mask",
&nreturn_vals,
GIMP_PDB_CHANNEL, mask_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, mask_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_ID = return_vals[1].data.d_layer;
@ -504,17 +504,17 @@ gimp_layer_from_mask (gint32 mask_ID)
*/
gboolean
gimp_layer_add_mask (gint32 layer_ID,
gint32 mask_ID)
gint32 mask_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-add-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_CHANNEL, mask_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_CHANNEL, mask_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -537,17 +537,17 @@ gimp_layer_add_mask (gint32 layer_ID,
*/
gboolean
gimp_layer_remove_mask (gint32 layer_ID,
GimpMaskApplyMode mode)
GimpMaskApplyMode mode)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-remove-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, mode,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -576,9 +576,9 @@ gimp_layer_is_floating_sel (gint32 layer_ID)
gboolean is_floating_sel = FALSE;
return_vals = gimp_run_procedure ("gimp-layer-is-floating-sel",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
is_floating_sel = return_vals[1].data.d_int32;
@ -607,9 +607,9 @@ gimp_layer_get_lock_alpha (gint32 layer_ID)
gboolean lock_alpha = FALSE;
return_vals = gimp_run_procedure ("gimp-layer-get-lock-alpha",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
lock_alpha = return_vals[1].data.d_int32;
@ -633,17 +633,17 @@ gimp_layer_get_lock_alpha (gint32 layer_ID)
*/
gboolean
gimp_layer_set_lock_alpha (gint32 layer_ID,
gboolean lock_alpha)
gboolean lock_alpha)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-lock-alpha",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, lock_alpha,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, lock_alpha,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -672,9 +672,9 @@ gimp_layer_get_apply_mask (gint32 layer_ID)
gboolean apply_mask = FALSE;
return_vals = gimp_run_procedure ("gimp-layer-get-apply-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
apply_mask = return_vals[1].data.d_int32;
@ -700,17 +700,17 @@ gimp_layer_get_apply_mask (gint32 layer_ID)
*/
gboolean
gimp_layer_set_apply_mask (gint32 layer_ID,
gboolean apply_mask)
gboolean apply_mask)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-apply-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, apply_mask,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, apply_mask,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -740,9 +740,9 @@ gimp_layer_get_show_mask (gint32 layer_ID)
gboolean show_mask = FALSE;
return_vals = gimp_run_procedure ("gimp-layer-get-show-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
show_mask = return_vals[1].data.d_int32;
@ -768,17 +768,17 @@ gimp_layer_get_show_mask (gint32 layer_ID)
*/
gboolean
gimp_layer_set_show_mask (gint32 layer_ID,
gboolean show_mask)
gboolean show_mask)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-show-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, show_mask,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, show_mask,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -807,9 +807,9 @@ gimp_layer_get_edit_mask (gint32 layer_ID)
gboolean edit_mask = FALSE;
return_vals = gimp_run_procedure ("gimp-layer-get-edit-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
edit_mask = return_vals[1].data.d_int32;
@ -835,17 +835,17 @@ gimp_layer_get_edit_mask (gint32 layer_ID)
*/
gboolean
gimp_layer_set_edit_mask (gint32 layer_ID,
gboolean edit_mask)
gboolean edit_mask)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-edit-mask",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, edit_mask,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, edit_mask,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -872,9 +872,9 @@ gimp_layer_get_opacity (gint32 layer_ID)
gdouble opacity = 0.0;
return_vals = gimp_run_procedure ("gimp-layer-get-opacity",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
opacity = return_vals[1].data.d_float;
@ -897,17 +897,17 @@ gimp_layer_get_opacity (gint32 layer_ID)
*/
gboolean
gimp_layer_set_opacity (gint32 layer_ID,
gdouble opacity)
gdouble opacity)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-opacity",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -934,9 +934,9 @@ gimp_layer_get_mode (gint32 layer_ID)
GimpLayerModeEffects mode = 0;
return_vals = gimp_run_procedure ("gimp-layer-get-mode",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
mode = return_vals[1].data.d_int32;
@ -959,17 +959,17 @@ gimp_layer_get_mode (gint32 layer_ID)
*/
gboolean
gimp_layer_set_mode (gint32 layer_ID,
GimpLayerModeEffects mode)
GimpLayerModeEffects mode)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-layer-set-mode",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, mode,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, mode,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

56
libgimp/gimplayer_pdb.h
View File

@ -30,60 +30,60 @@ G_BEGIN_DECLS
gint32 _gimp_layer_new (gint32 image_ID,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode) G_GNUC_INTERNAL;
gint width,
gint height,
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode) G_GNUC_INTERNAL;
gint32 gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32 dest_image_ID);
gint32 dest_image_ID);
gint32 _gimp_layer_copy (gint32 layer_ID,
gboolean add_alpha) G_GNUC_INTERNAL;
gboolean add_alpha) G_GNUC_INTERNAL;
gboolean gimp_layer_add_alpha (gint32 layer_ID);
gboolean gimp_layer_scale (gint32 layer_ID,
gint new_width,
gint new_height,
gboolean local_origin);
gint new_width,
gint new_height,
gboolean local_origin);
gboolean gimp_layer_resize (gint32 layer_ID,
gint new_width,
gint new_height,
gint offx,
gint offy);
gint new_width,
gint new_height,
gint offx,
gint offy);
gboolean gimp_layer_resize_to_image_size (gint32 layer_ID);
gboolean gimp_layer_translate (gint32 layer_ID,
gint offx,
gint offy);
gint offx,
gint offy);
gboolean gimp_layer_set_offsets (gint32 layer_ID,
gint offx,
gint offy);
gint offx,
gint offy);
gint32 gimp_layer_create_mask (gint32 layer_ID,
GimpAddMaskType mask_type);
GimpAddMaskType mask_type);
gint32 gimp_layer_get_mask (gint32 layer_ID);
gint32 gimp_layer_from_mask (gint32 mask_ID);
gboolean gimp_layer_add_mask (gint32 layer_ID,
gint32 mask_ID);
gint32 mask_ID);
gboolean gimp_layer_remove_mask (gint32 layer_ID,
GimpMaskApplyMode mode);
GimpMaskApplyMode mode);
gboolean gimp_layer_is_floating_sel (gint32 layer_ID);
gboolean gimp_layer_get_lock_alpha (gint32 layer_ID);
gboolean gimp_layer_set_lock_alpha (gint32 layer_ID,
gboolean lock_alpha);
gboolean lock_alpha);
gboolean gimp_layer_get_apply_mask (gint32 layer_ID);
gboolean gimp_layer_set_apply_mask (gint32 layer_ID,
gboolean apply_mask);
gboolean apply_mask);
gboolean gimp_layer_get_show_mask (gint32 layer_ID);
gboolean gimp_layer_set_show_mask (gint32 layer_ID,
gboolean show_mask);
gboolean show_mask);
gboolean gimp_layer_get_edit_mask (gint32 layer_ID);
gboolean gimp_layer_set_edit_mask (gint32 layer_ID,
gboolean edit_mask);
gboolean edit_mask);
gdouble gimp_layer_get_opacity (gint32 layer_ID);
gboolean gimp_layer_set_opacity (gint32 layer_ID,
gdouble opacity);
gdouble opacity);
GimpLayerModeEffects gimp_layer_get_mode (gint32 layer_ID);
gboolean gimp_layer_set_mode (gint32 layer_ID,
GimpLayerModeEffects mode);
GimpLayerModeEffects mode);
G_END_DECLS

16
libgimp/gimpmessage_pdb.c
View File

@ -44,9 +44,9 @@ gimp_message (const gchar *message)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-message",
&nreturn_vals,
GIMP_PDB_STRING, message,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, message,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -74,8 +74,8 @@ gimp_message_get_handler (void)
GimpMessageHandlerType handler = 0;
return_vals = gimp_run_procedure ("gimp-message-get-handler",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
handler = return_vals[1].data.d_int32;
@ -105,9 +105,9 @@ gimp_message_set_handler (GimpMessageHandlerType handler)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-message-set-handler",
&nreturn_vals,
GIMP_PDB_INT32, handler,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, handler,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

8
libgimp/gimpmisc_pdb.c
View File

@ -43,8 +43,8 @@ gimp_version (void)
gchar *version = NULL;
return_vals = gimp_run_procedure ("gimp-version",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
version = g_strdup (return_vals[1].data.d_string);
@ -73,8 +73,8 @@ gimp_getpid (void)
gint pid = 0;
return_vals = gimp_run_procedure ("gimp-getpid",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
pid = return_vals[1].data.d_int32;

274
libgimp/gimppainttools_pdb.c
View File

@ -44,21 +44,21 @@
*/
gboolean
gimp_airbrush (gint32 drawable_ID,
gdouble pressure,
gint num_strokes,
const gdouble *strokes)
gdouble pressure,
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-airbrush",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, pressure,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, pressure,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -85,19 +85,19 @@ gimp_airbrush (gint32 drawable_ID,
*/
gboolean
gimp_airbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-airbrush-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -135,27 +135,27 @@ gimp_airbrush_default (gint32 drawable_ID,
*/
gboolean
gimp_clone (gint32 drawable_ID,
gint32 src_drawable_ID,
GimpCloneType clone_type,
gdouble src_x,
gdouble src_y,
gint num_strokes,
const gdouble *strokes)
gint32 src_drawable_ID,
GimpCloneType clone_type,
gdouble src_x,
gdouble src_y,
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-clone",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_DRAWABLE, src_drawable_ID,
GIMP_PDB_INT32, clone_type,
GIMP_PDB_FLOAT, src_x,
GIMP_PDB_FLOAT, src_y,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_DRAWABLE, src_drawable_ID,
GIMP_PDB_INT32, clone_type,
GIMP_PDB_FLOAT, src_x,
GIMP_PDB_FLOAT, src_y,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -183,19 +183,19 @@ gimp_clone (gint32 drawable_ID,
*/
gboolean
gimp_clone_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-clone-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -223,23 +223,23 @@ gimp_clone_default (gint32 drawable_ID,
*/
gboolean
gimp_convolve (gint32 drawable_ID,
gdouble pressure,
GimpConvolveType convolve_type,
gint num_strokes,
const gdouble *strokes)
gdouble pressure,
GimpConvolveType convolve_type,
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-convolve",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, pressure,
GIMP_PDB_INT32, convolve_type,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, pressure,
GIMP_PDB_INT32, convolve_type,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -266,19 +266,19 @@ gimp_convolve (gint32 drawable_ID,
*/
gboolean
gimp_convolve_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-convolve-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -304,25 +304,25 @@ gimp_convolve_default (gint32 drawable_ID,
*/
gboolean
gimp_dodgeburn (gint32 drawable_ID,
gdouble exposure,
GimpDodgeBurnType dodgeburn_type,
GimpTransferMode dodgeburn_mode,
gint num_strokes,
const gdouble *strokes)
gdouble exposure,
GimpDodgeBurnType dodgeburn_type,
GimpTransferMode dodgeburn_mode,
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-dodgeburn",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, exposure,
GIMP_PDB_INT32, dodgeburn_type,
GIMP_PDB_INT32, dodgeburn_mode,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, exposure,
GIMP_PDB_INT32, dodgeburn_type,
GIMP_PDB_INT32, dodgeburn_mode,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -348,19 +348,19 @@ gimp_dodgeburn (gint32 drawable_ID,
*/
gboolean
gimp_dodgeburn_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-dodgeburn-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -389,23 +389,23 @@ gimp_dodgeburn_default (gint32 drawable_ID,
*/
gboolean
gimp_eraser (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method)
gint num_strokes,
const gdouble *strokes,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-eraser",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_INT32, hardness,
GIMP_PDB_INT32, method,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_INT32, hardness,
GIMP_PDB_INT32, method,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -432,19 +432,19 @@ gimp_eraser (gint32 drawable_ID,
*/
gboolean
gimp_eraser_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-eraser-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -480,25 +480,25 @@ gimp_eraser_default (gint32 drawable_ID,
*/
gboolean
gimp_paintbrush (gint32 drawable_ID,
gdouble fade_out,
gint num_strokes,
const gdouble *strokes,
GimpPaintApplicationMode method,
gdouble gradient_length)
gdouble fade_out,
gint num_strokes,
const gdouble *strokes,
GimpPaintApplicationMode method,
gdouble gradient_length)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-paintbrush",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, fade_out,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_INT32, method,
GIMP_PDB_FLOAT, gradient_length,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, fade_out,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_INT32, method,
GIMP_PDB_FLOAT, gradient_length,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -534,19 +534,19 @@ gimp_paintbrush (gint32 drawable_ID,
*/
gboolean
gimp_paintbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-paintbrush-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -574,19 +574,19 @@ gimp_paintbrush_default (gint32 drawable_ID,
*/
gboolean
gimp_pencil (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-pencil",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -612,21 +612,21 @@ gimp_pencil (gint32 drawable_ID,
*/
gboolean
gimp_smudge (gint32 drawable_ID,
gdouble pressure,
gint num_strokes,
const gdouble *strokes)
gdouble pressure,
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-smudge",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, pressure,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, pressure,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -652,19 +652,19 @@ gimp_smudge (gint32 drawable_ID,
*/
gboolean
gimp_smudge_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
gint num_strokes,
const gdouble *strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-smudge-default",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, num_strokes,
GIMP_PDB_FLOATARRAY, strokes,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

92
libgimp/gimppainttools_pdb.h
View File

@ -30,66 +30,66 @@ G_BEGIN_DECLS
gboolean gimp_airbrush (gint32 drawable_ID,
gdouble pressure,
gint num_strokes,
const gdouble *strokes);
gdouble pressure,
gint num_strokes,
const gdouble *strokes);
gboolean gimp_airbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_clone (gint32 drawable_ID,
gint32 src_drawable_ID,
GimpCloneType clone_type,
gdouble src_x,
gdouble src_y,
gint num_strokes,
const gdouble *strokes);
gint32 src_drawable_ID,
GimpCloneType clone_type,
gdouble src_x,
gdouble src_y,
gint num_strokes,
const gdouble *strokes);
gboolean gimp_clone_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_convolve (gint32 drawable_ID,
gdouble pressure,
GimpConvolveType convolve_type,
gint num_strokes,
const gdouble *strokes);
gdouble pressure,
GimpConvolveType convolve_type,
gint num_strokes,
const gdouble *strokes);
gboolean gimp_convolve_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_dodgeburn (gint32 drawable_ID,
gdouble exposure,
GimpDodgeBurnType dodgeburn_type,
GimpTransferMode dodgeburn_mode,
gint num_strokes,
const gdouble *strokes);
gdouble exposure,
GimpDodgeBurnType dodgeburn_type,
GimpTransferMode dodgeburn_mode,
gint num_strokes,
const gdouble *strokes);
gboolean gimp_dodgeburn_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_eraser (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method);
gint num_strokes,
const gdouble *strokes,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method);
gboolean gimp_eraser_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_paintbrush (gint32 drawable_ID,
gdouble fade_out,
gint num_strokes,
const gdouble *strokes,
GimpPaintApplicationMode method,
gdouble gradient_length);
gdouble fade_out,
gint num_strokes,
const gdouble *strokes,
GimpPaintApplicationMode method,
gdouble gradient_length);
gboolean gimp_paintbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_pencil (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
gboolean gimp_smudge (gint32 drawable_ID,
gdouble pressure,
gint num_strokes,
const gdouble *strokes);
gdouble pressure,
gint num_strokes,
const gdouble *strokes);
gboolean gimp_smudge_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes);
gint num_strokes,
const gdouble *strokes);
G_END_DECLS

136
libgimp/gimppalette_pdb.c
View File

@ -45,9 +45,9 @@ gimp_palette_new (const gchar *name)
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-palette-new",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
actual_name = g_strdup (return_vals[1].data.d_string);
@ -77,9 +77,9 @@ gimp_palette_duplicate (const gchar *name)
gchar *copy_name = NULL;
return_vals = gimp_run_procedure ("gimp-palette-duplicate",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
copy_name = g_strdup (return_vals[1].data.d_string);
@ -104,17 +104,17 @@ gimp_palette_duplicate (const gchar *name)
*/
gchar *
gimp_palette_rename (const gchar *name,
const gchar *new_name)
const gchar *new_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-palette-rename",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, new_name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
actual_name = g_strdup (return_vals[1].data.d_string);
@ -144,9 +144,9 @@ gimp_palette_delete (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-delete",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -175,9 +175,9 @@ gimp_palette_is_editable (const gchar *name)
gboolean editable = FALSE;
return_vals = gimp_run_procedure ("gimp-palette-is-editable",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
editable = return_vals[1].data.d_int32;
@ -203,16 +203,16 @@ gimp_palette_is_editable (const gchar *name)
*/
gboolean
gimp_palette_get_info (const gchar *name,
gint *num_colors)
gint *num_colors)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-get-info",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*num_colors = 0;
@ -247,9 +247,9 @@ gimp_palette_get_columns (const gchar *name)
gint num_columns = 0;
return_vals = gimp_run_procedure ("gimp-palette-get-columns",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
num_columns = return_vals[1].data.d_int32;
@ -276,17 +276,17 @@ gimp_palette_get_columns (const gchar *name)
*/
gboolean
gimp_palette_set_columns (const gchar *name,
gint columns)
gint columns)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-set-columns",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, columns,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, columns,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -313,20 +313,20 @@ gimp_palette_set_columns (const gchar *name,
*/
gboolean
gimp_palette_add_entry (const gchar *name,
const gchar *entry_name,
const GimpRGB *color,
gint *entry_num)
const gchar *entry_name,
const GimpRGB *color,
gint *entry_num)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-add-entry",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, entry_name,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, entry_name,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
*entry_num = 0;
@ -356,17 +356,17 @@ gimp_palette_add_entry (const gchar *name,
*/
gboolean
gimp_palette_delete_entry (const gchar *name,
gint entry_num)
gint entry_num)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-delete-entry",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -393,18 +393,18 @@ gimp_palette_delete_entry (const gchar *name,
*/
gboolean
gimp_palette_entry_get_color (const gchar *name,
gint entry_num,
GimpRGB *color)
gint entry_num,
GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-entry-get-color",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -434,19 +434,19 @@ gimp_palette_entry_get_color (const gchar *name,
*/
gboolean
gimp_palette_entry_set_color (const gchar *name,
gint entry_num,
const GimpRGB *color)
gint entry_num,
const GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-entry-set-color",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_COLOR, color,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -473,18 +473,18 @@ gimp_palette_entry_set_color (const gchar *name,
*/
gboolean
gimp_palette_entry_get_name (const gchar *name,
gint entry_num,
gchar **entry_name)
gint entry_num,
gchar **entry_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-entry-get-name",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
*entry_name = NULL;
@ -516,19 +516,19 @@ gimp_palette_entry_get_name (const gchar *name,
*/
gboolean
gimp_palette_entry_set_name (const gchar *name,
gint entry_num,
const gchar *entry_name)
gint entry_num,
const gchar *entry_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palette-entry-set-name",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_STRING, entry_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_STRING, entry_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

30
libgimp/gimppalette_pdb.h
View File

@ -32,32 +32,32 @@ G_BEGIN_DECLS
gchar* gimp_palette_new (const gchar *name);
gchar* gimp_palette_duplicate (const gchar *name);
gchar* gimp_palette_rename (const gchar *name,
const gchar *new_name);
const gchar *new_name);
gboolean gimp_palette_delete (const gchar *name);
gboolean gimp_palette_is_editable (const gchar *name);
gboolean gimp_palette_get_info (const gchar *name,
gint *num_colors);
gint *num_colors);
gint gimp_palette_get_columns (const gchar *name);
gboolean gimp_palette_set_columns (const gchar *name,
gint columns);
gint columns);
gboolean gimp_palette_add_entry (const gchar *name,
const gchar *entry_name,
const GimpRGB *color,
gint *entry_num);
const gchar *entry_name,
const GimpRGB *color,
gint *entry_num);
gboolean gimp_palette_delete_entry (const gchar *name,
gint entry_num);
gint entry_num);
gboolean gimp_palette_entry_get_color (const gchar *name,
gint entry_num,
GimpRGB *color);
gint entry_num,
GimpRGB *color);
gboolean gimp_palette_entry_set_color (const gchar *name,
gint entry_num,
const GimpRGB *color);
gint entry_num,
const GimpRGB *color);
gboolean gimp_palette_entry_get_name (const gchar *name,
gint entry_num,
gchar **entry_name);
gint entry_num,
gchar **entry_name);
gboolean gimp_palette_entry_set_name (const gchar *name,
gint entry_num,
const gchar *entry_name);
gint entry_num,
const gchar *entry_name);
G_END_DECLS

30
libgimp/gimppalettes_pdb.c
View File

@ -43,8 +43,8 @@ gimp_palettes_refresh (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palettes-refresh",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -68,7 +68,7 @@ gimp_palettes_refresh (void)
*/
gchar **
gimp_palettes_get_list (const gchar *filter,
gint *num_palettes)
gint *num_palettes)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -76,9 +76,9 @@ gimp_palettes_get_list (const gchar *filter,
gint i;
return_vals = gimp_run_procedure ("gimp-palettes-get-list",
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
*num_palettes = 0;
@ -112,8 +112,8 @@ gimp_palettes_get_palette (gint *num_colors)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-palettes-get-palette",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -140,19 +140,19 @@ gimp_palettes_get_palette (gint *num_colors)
*/
gchar *
gimp_palettes_get_palette_entry (const gchar *name,
gint entry_num,
gint *num_colors,
GimpRGB *color)
gint entry_num,
gint *num_colors,
GimpRGB *color)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-palettes-get-palette-entry",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, entry_num,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{

8
libgimp/gimppalettes_pdb.h
View File

@ -31,13 +31,13 @@ G_BEGIN_DECLS
gboolean gimp_palettes_refresh (void);
gchar** gimp_palettes_get_list (const gchar *filter,
gint *num_palettes);
gint *num_palettes);
#ifndef GIMP_DISABLE_DEPRECATED
gchar* gimp_palettes_get_palette (gint *num_colors);
gchar* gimp_palettes_get_palette_entry (const gchar *name,
gint entry_num,
gint *num_colors,
GimpRGB *color);
gint entry_num,
gint *num_colors,
GimpRGB *color);
#endif /* GIMP_DISABLE_DEPRECATED */

30
libgimp/gimppaletteselect_pdb.c
View File

@ -39,19 +39,19 @@
*/
gboolean
gimp_palettes_popup (const gchar *palette_callback,
const gchar *popup_title,
const gchar *initial_palette)
const gchar *popup_title,
const gchar *initial_palette)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palettes-popup",
&nreturn_vals,
GIMP_PDB_STRING, palette_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_palette,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, palette_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_palette,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -78,9 +78,9 @@ gimp_palettes_close_popup (const gchar *palette_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palettes-close-popup",
&nreturn_vals,
GIMP_PDB_STRING, palette_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, palette_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -102,17 +102,17 @@ gimp_palettes_close_popup (const gchar *palette_callback)
*/
gboolean
gimp_palettes_set_popup (const gchar *palette_callback,
const gchar *palette_name)
const gchar *palette_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-palettes-set-popup",
&nreturn_vals,
GIMP_PDB_STRING, palette_callback,
GIMP_PDB_STRING, palette_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, palette_callback,
GIMP_PDB_STRING, palette_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

6
libgimp/gimppaletteselect_pdb.h
View File

@ -30,11 +30,11 @@ G_BEGIN_DECLS
gboolean gimp_palettes_popup (const gchar *palette_callback,
const gchar *popup_title,
const gchar *initial_palette);
const gchar *popup_title,
const gchar *initial_palette);
gboolean gimp_palettes_close_popup (const gchar *palette_callback);
gboolean gimp_palettes_set_popup (const gchar *palette_callback,
const gchar *palette_name);
const gchar *palette_name);
G_END_DECLS

144
libgimp/gimpparasite_pdb.c
View File

@ -44,9 +44,9 @@ gimp_parasite_find (const gchar *name)
GimpParasite *parasite = NULL;
return_vals = gimp_run_procedure ("gimp-parasite-find",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
@ -75,9 +75,9 @@ gimp_parasite_attach (const GimpParasite *parasite)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-parasite-attach",
&nreturn_vals,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -105,9 +105,9 @@ gimp_parasite_detach (const gchar *name)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-parasite-detach",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -129,7 +129,7 @@ gimp_parasite_detach (const gchar *name)
*/
gboolean
gimp_parasite_list (gint *num_parasites,
gchar ***parasites)
gchar ***parasites)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -137,8 +137,8 @@ gimp_parasite_list (gint *num_parasites,
gint i;
return_vals = gimp_run_procedure ("gimp-parasite-list",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
*num_parasites = 0;
*parasites = NULL;
@ -172,17 +172,17 @@ gimp_parasite_list (gint *num_parasites,
*/
GimpParasite *
gimp_image_parasite_find (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpParasite *parasite = NULL;
return_vals = gimp_run_procedure ("gimp-image-parasite-find",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
@ -206,17 +206,17 @@ gimp_image_parasite_find (gint32 image_ID,
*/
gboolean
gimp_image_parasite_attach (gint32 image_ID,
const GimpParasite *parasite)
const GimpParasite *parasite)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-parasite-attach",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -239,17 +239,17 @@ gimp_image_parasite_attach (gint32 image_ID,
*/
gboolean
gimp_image_parasite_detach (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-parasite-detach",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -272,8 +272,8 @@ gimp_image_parasite_detach (gint32 image_ID,
*/
gboolean
gimp_image_parasite_list (gint32 image_ID,
gint *num_parasites,
gchar ***parasites)
gint *num_parasites,
gchar ***parasites)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -281,9 +281,9 @@ gimp_image_parasite_list (gint32 image_ID,
gint i;
return_vals = gimp_run_procedure ("gimp-image-parasite-list",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
*num_parasites = 0;
*parasites = NULL;
@ -317,17 +317,17 @@ gimp_image_parasite_list (gint32 image_ID,
*/
GimpParasite *
gimp_drawable_parasite_find (gint32 drawable_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpParasite *parasite = NULL;
return_vals = gimp_run_procedure ("gimp-drawable-parasite-find",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
@ -351,17 +351,17 @@ gimp_drawable_parasite_find (gint32 drawable_ID,
*/
gboolean
gimp_drawable_parasite_attach (gint32 drawable_ID,
const GimpParasite *parasite)
const GimpParasite *parasite)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-parasite-attach",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -384,17 +384,17 @@ gimp_drawable_parasite_attach (gint32 drawable_ID,
*/
gboolean
gimp_drawable_parasite_detach (gint32 drawable_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-drawable-parasite-detach",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -417,8 +417,8 @@ gimp_drawable_parasite_detach (gint32 drawable_ID,
*/
gboolean
gimp_drawable_parasite_list (gint32 drawable_ID,
gint *num_parasites,
gchar ***parasites)
gint *num_parasites,
gchar ***parasites)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -426,9 +426,9 @@ gimp_drawable_parasite_list (gint32 drawable_ID,
gint i;
return_vals = gimp_run_procedure ("gimp-drawable-parasite-list",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
*num_parasites = 0;
*parasites = NULL;
@ -464,17 +464,17 @@ gimp_drawable_parasite_list (gint32 drawable_ID,
*/
GimpParasite *
gimp_vectors_parasite_find (gint32 vectors_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpParasite *parasite = NULL;
return_vals = gimp_run_procedure ("gimp-vectors-parasite-find",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
@ -500,17 +500,17 @@ gimp_vectors_parasite_find (gint32 vectors_ID,
*/
gboolean
gimp_vectors_parasite_attach (gint32 vectors_ID,
const GimpParasite *parasite)
const GimpParasite *parasite)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-parasite-attach",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_PARASITE, parasite,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -535,17 +535,17 @@ gimp_vectors_parasite_attach (gint32 vectors_ID,
*/
gboolean
gimp_vectors_parasite_detach (gint32 vectors_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-parasite-detach",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -570,8 +570,8 @@ gimp_vectors_parasite_detach (gint32 vectors_ID,
*/
gboolean
gimp_vectors_parasite_list (gint32 vectors_ID,
gint *num_parasites,
gchar ***parasites)
gint *num_parasites,
gchar ***parasites)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -579,9 +579,9 @@ gimp_vectors_parasite_list (gint32 vectors_ID,
gint i;
return_vals = gimp_run_procedure ("gimp-vectors-parasite-list",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
*num_parasites = 0;
*parasites = NULL;

32
libgimp/gimpparasite_pdb.h
View File

@ -33,34 +33,34 @@ GimpParasite* gimp_parasite_find (const gchar *name);
gboolean gimp_parasite_attach (const GimpParasite *parasite);
gboolean gimp_parasite_detach (const gchar *name);
gboolean gimp_parasite_list (gint *num_parasites,
gchar ***parasites);
gchar ***parasites);
GimpParasite* gimp_image_parasite_find (gint32 image_ID,
const gchar *name);
const gchar *name);
gboolean gimp_image_parasite_attach (gint32 image_ID,
const GimpParasite *parasite);
const GimpParasite *parasite);
gboolean gimp_image_parasite_detach (gint32 image_ID,
const gchar *name);
const gchar *name);
gboolean gimp_image_parasite_list (gint32 image_ID,
gint *num_parasites,
gchar ***parasites);
gint *num_parasites,
gchar ***parasites);
GimpParasite* gimp_drawable_parasite_find (gint32 drawable_ID,
const gchar *name);
const gchar *name);
gboolean gimp_drawable_parasite_attach (gint32 drawable_ID,
const GimpParasite *parasite);
const GimpParasite *parasite);
gboolean gimp_drawable_parasite_detach (gint32 drawable_ID,
const gchar *name);
const gchar *name);
gboolean gimp_drawable_parasite_list (gint32 drawable_ID,
gint *num_parasites,
gchar ***parasites);
gint *num_parasites,
gchar ***parasites);
GimpParasite* gimp_vectors_parasite_find (gint32 vectors_ID,
const gchar *name);
const gchar *name);
gboolean gimp_vectors_parasite_attach (gint32 vectors_ID,
const GimpParasite *parasite);
const GimpParasite *parasite);
gboolean gimp_vectors_parasite_detach (gint32 vectors_ID,
const gchar *name);
const gchar *name);
gboolean gimp_vectors_parasite_list (gint32 vectors_ID,
gint *num_parasites,
gchar ***parasites);
gint *num_parasites,
gchar ***parasites);
G_END_DECLS

220
libgimp/gimppaths_pdb.c
View File

@ -38,7 +38,7 @@
*/
gchar **
gimp_path_list (gint32 image_ID,
gint *num_paths)
gint *num_paths)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -46,9 +46,9 @@ gimp_path_list (gint32 image_ID,
gint i;
return_vals = gimp_run_procedure ("gimp-path-list",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
*num_paths = 0;
@ -82,9 +82,9 @@ gimp_path_get_current (gint32 image_ID)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-path-get-current",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -106,17 +106,17 @@ gimp_path_get_current (gint32 image_ID)
*/
gboolean
gimp_path_set_current (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-set-current",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -137,17 +137,17 @@ gimp_path_set_current (gint32 image_ID,
*/
gboolean
gimp_path_delete (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-delete",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -172,20 +172,20 @@ gimp_path_delete (gint32 image_ID,
*/
gint
gimp_path_get_points (gint32 image_ID,
const gchar *name,
gint *path_closed,
gint *num_path_point_details,
gdouble **points_pairs)
const gchar *name,
gint *path_closed,
gint *num_path_point_details,
gdouble **points_pairs)
{
GimpParam *return_vals;
gint nreturn_vals;
gint path_type = 0;
return_vals = gimp_run_procedure ("gimp-path-get-points",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*num_path_point_details = 0;
@ -220,23 +220,23 @@ gimp_path_get_points (gint32 image_ID,
*/
gboolean
gimp_path_set_points (gint32 image_ID,
const gchar *name,
gint ptype,
gint num_path_points,
const gdouble *points_pairs)
const gchar *name,
gint ptype,
gint num_path_points,
const gdouble *points_pairs)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-set-points",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, ptype,
GIMP_PDB_INT32, num_path_points,
GIMP_PDB_FLOATARRAY, points_pairs,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, ptype,
GIMP_PDB_INT32, num_path_points,
GIMP_PDB_FLOATARRAY, points_pairs,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -263,9 +263,9 @@ gimp_path_stroke_current (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-stroke-current",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -288,19 +288,19 @@ gimp_path_stroke_current (gint32 image_ID)
*/
gint
gimp_path_get_point_at_dist (gint32 image_ID,
gdouble distance,
gint *y_point,
gdouble *slope)
gdouble distance,
gint *y_point,
gdouble *slope)
{
GimpParam *return_vals;
gint nreturn_vals;
gint x_point = 0;
return_vals = gimp_run_procedure ("gimp-path-get-point-at-dist",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, distance,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, distance,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -325,17 +325,17 @@ gimp_path_get_point_at_dist (gint32 image_ID,
*/
gint
gimp_path_get_tattoo (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gint tattoo = 0;
return_vals = gimp_run_procedure ("gimp-path-get-tattoo",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
tattoo = return_vals[1].data.d_int32;
@ -357,19 +357,19 @@ gimp_path_get_tattoo (gint32 image_ID,
*/
gboolean
gimp_path_set_tattoo (gint32 image_ID,
const gchar *name,
gint tattovalue)
const gchar *name,
gint tattovalue)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-set-tattoo",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, tattovalue,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, tattovalue,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -390,17 +390,17 @@ gimp_path_set_tattoo (gint32 image_ID,
*/
gchar *
gimp_get_path_by_tattoo (gint32 image_ID,
gint tattoo)
gint tattoo)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-get-path-by-tattoo",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, tattoo,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, tattoo,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -421,17 +421,17 @@ gimp_get_path_by_tattoo (gint32 image_ID,
*/
gboolean
gimp_path_get_locked (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean locked = FALSE;
return_vals = gimp_run_procedure ("gimp-path-get-locked",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
locked = return_vals[1].data.d_int32;
@ -453,19 +453,19 @@ gimp_path_get_locked (gint32 image_ID,
*/
gboolean
gimp_path_set_locked (gint32 image_ID,
const gchar *name,
gboolean locked)
const gchar *name,
gboolean locked)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-set-locked",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, locked,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, locked,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -492,27 +492,27 @@ gimp_path_set_locked (gint32 image_ID,
*/
gboolean
gimp_path_to_selection (gint32 image_ID,
const gchar *name,
GimpChannelOps op,
gboolean antialias,
gboolean feather,
gdouble feather_radius_x,
gdouble feather_radius_y)
const gchar *name,
GimpChannelOps op,
gboolean antialias,
gboolean feather,
gdouble feather_radius_x,
gdouble feather_radius_y)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-to-selection",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, op,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius_x,
GIMP_PDB_FLOAT, feather_radius_y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_INT32, op,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius_x,
GIMP_PDB_FLOAT, feather_radius_y,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -537,21 +537,21 @@ gimp_path_to_selection (gint32 image_ID,
*/
gboolean
gimp_path_import (gint32 image_ID,
const gchar *filename,
gboolean merge,
gboolean scale)
const gchar *filename,
gboolean merge,
gboolean scale)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-import",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, filename,
GIMP_PDB_INT32, merge,
GIMP_PDB_INT32, scale,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, filename,
GIMP_PDB_INT32, merge,
GIMP_PDB_INT32, scale,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -580,23 +580,23 @@ gimp_path_import (gint32 image_ID,
*/
gboolean
gimp_path_import_string (gint32 image_ID,
const gchar *string,
gint length,
gboolean merge,
gboolean scale)
const gchar *string,
gint length,
gboolean merge,
gboolean scale)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-path-import-string",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, string,
GIMP_PDB_INT32, length,
GIMP_PDB_INT32, merge,
GIMP_PDB_INT32, scale,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, string,
GIMP_PDB_INT32, length,
GIMP_PDB_INT32, merge,
GIMP_PDB_INT32, scale,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

68
libgimp/gimppaths_pdb.h
View File

@ -31,58 +31,58 @@ G_BEGIN_DECLS
#ifndef GIMP_DISABLE_DEPRECATED
gchar** gimp_path_list (gint32 image_ID,
gint *num_paths);
gint *num_paths);
gchar* gimp_path_get_current (gint32 image_ID);
gboolean gimp_path_set_current (gint32 image_ID,
const gchar *name);
const gchar *name);
gboolean gimp_path_delete (gint32 image_ID,
const gchar *name);
const gchar *name);
#endif /* GIMP_DISABLE_DEPRECATED */
gint gimp_path_get_points (gint32 image_ID,
const gchar *name,
gint *path_closed,
gint *num_path_point_details,
gdouble **points_pairs);
const gchar *name,
gint *path_closed,
gint *num_path_point_details,
gdouble **points_pairs);
gboolean gimp_path_set_points (gint32 image_ID,
const gchar *name,
gint ptype,
gint num_path_points,
const gdouble *points_pairs);
const gchar *name,
gint ptype,
gint num_path_points,
const gdouble *points_pairs);
gboolean gimp_path_stroke_current (gint32 image_ID);
#ifndef GIMP_DISABLE_DEPRECATED
gint gimp_path_get_point_at_dist (gint32 image_ID,
gdouble distance,
gint *y_point,
gdouble *slope);
gdouble distance,
gint *y_point,
gdouble *slope);
gint gimp_path_get_tattoo (gint32 image_ID,
const gchar *name);
const gchar *name);
gboolean gimp_path_set_tattoo (gint32 image_ID,
const gchar *name,
gint tattovalue);
const gchar *name,
gint tattovalue);
gchar* gimp_get_path_by_tattoo (gint32 image_ID,
gint tattoo);
gint tattoo);
gboolean gimp_path_get_locked (gint32 image_ID,
const gchar *name);
const gchar *name);
gboolean gimp_path_set_locked (gint32 image_ID,
const gchar *name,
gboolean locked);
const gchar *name,
gboolean locked);
#endif /* GIMP_DISABLE_DEPRECATED */
gboolean gimp_path_to_selection (gint32 image_ID,
const gchar *name,
GimpChannelOps op,
gboolean antialias,
gboolean feather,
gdouble feather_radius_x,
gdouble feather_radius_y);
const gchar *name,
GimpChannelOps op,
gboolean antialias,
gboolean feather,
gdouble feather_radius_x,
gdouble feather_radius_y);
gboolean gimp_path_import (gint32 image_ID,
const gchar *filename,
gboolean merge,
gboolean scale);
const gchar *filename,
gboolean merge,
gboolean scale);
gboolean gimp_path_import_string (gint32 image_ID,
const gchar *string,
gint length,
gboolean merge,
gboolean scale);
const gchar *string,
gint length,
gboolean merge,
gboolean scale);
G_END_DECLS

28
libgimp/gimppattern_pdb.c
View File

@ -45,18 +45,18 @@
*/
gboolean
gimp_pattern_get_info (const gchar *name,
gint *width,
gint *height,
gint *bpp)
gint *width,
gint *height,
gint *bpp)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-pattern-get-info",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*width = 0;
*height = 0;
@ -97,20 +97,20 @@ gimp_pattern_get_info (const gchar *name,
*/
gboolean
gimp_pattern_get_pixels (const gchar *name,
gint *width,
gint *height,
gint *bpp,
gint *num_color_bytes,
guint8 **color_bytes)
gint *width,
gint *height,
gint *bpp,
gint *num_color_bytes,
guint8 **color_bytes)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-pattern-get-pixels",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*width = 0;
*height = 0;

16
libgimp/gimppattern_pdb.h
View File

@ -30,15 +30,15 @@ G_BEGIN_DECLS
gboolean gimp_pattern_get_info (const gchar *name,
gint *width,
gint *height,
gint *bpp);
gint *width,
gint *height,
gint *bpp);
gboolean gimp_pattern_get_pixels (const gchar *name,
gint *width,
gint *height,
gint *bpp,
gint *num_color_bytes,
guint8 **color_bytes);
gint *width,
gint *height,
gint *bpp,
gint *num_color_bytes,
guint8 **color_bytes);
G_END_DECLS

34
libgimp/gimppatterns_pdb.c
View File

@ -45,8 +45,8 @@ gimp_patterns_refresh (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-patterns-refresh",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -70,7 +70,7 @@ gimp_patterns_refresh (void)
*/
gchar **
gimp_patterns_get_list (const gchar *filter,
gint *num_patterns)
gint *num_patterns)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -78,9 +78,9 @@ gimp_patterns_get_list (const gchar *filter,
gint i;
return_vals = gimp_run_procedure ("gimp-patterns-get-list",
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filter,
GIMP_PDB_END);
*num_patterns = 0;
@ -109,15 +109,15 @@ gimp_patterns_get_list (const gchar *filter,
*/
gchar *
gimp_patterns_get_pattern (gint *width,
gint *height)
gint *height)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-patterns-get-pattern",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -146,20 +146,20 @@ gimp_patterns_get_pattern (gint *width,
*/
gchar *
gimp_patterns_get_pattern_data (const gchar *name,
gint *width,
gint *height,
gint *mask_bpp,
gint *length,
guint8 **mask_data)
gint *width,
gint *height,
gint *mask_bpp,
gint *length,
guint8 **mask_data)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *actual_name = NULL;
return_vals = gimp_run_procedure ("gimp-patterns-get-pattern-data",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
*length = 0;

14
libgimp/gimppatterns_pdb.h
View File

@ -31,16 +31,16 @@ G_BEGIN_DECLS
gboolean gimp_patterns_refresh (void);
gchar** gimp_patterns_get_list (const gchar *filter,
gint *num_patterns);
gint *num_patterns);
#ifndef GIMP_DISABLE_DEPRECATED
gchar* gimp_patterns_get_pattern (gint *width,
gint *height);
gint *height);
gchar* gimp_patterns_get_pattern_data (const gchar *name,
gint *width,
gint *height,
gint *mask_bpp,
gint *length,
guint8 **mask_data);
gint *width,
gint *height,
gint *mask_bpp,
gint *length,
guint8 **mask_data);
#endif /* GIMP_DISABLE_DEPRECATED */

30
libgimp/gimppatternselect_pdb.c
View File

@ -39,19 +39,19 @@
*/
gboolean
gimp_patterns_popup (const gchar *pattern_callback,
const gchar *popup_title,
const gchar *initial_pattern)
const gchar *popup_title,
const gchar *initial_pattern)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-patterns-popup",
&nreturn_vals,
GIMP_PDB_STRING, pattern_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_pattern,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, pattern_callback,
GIMP_PDB_STRING, popup_title,
GIMP_PDB_STRING, initial_pattern,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -78,9 +78,9 @@ gimp_patterns_close_popup (const gchar *pattern_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-patterns-close-popup",
&nreturn_vals,
GIMP_PDB_STRING, pattern_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, pattern_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -102,17 +102,17 @@ gimp_patterns_close_popup (const gchar *pattern_callback)
*/
gboolean
gimp_patterns_set_popup (const gchar *pattern_callback,
const gchar *pattern_name)
const gchar *pattern_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-patterns-set-popup",
&nreturn_vals,
GIMP_PDB_STRING, pattern_callback,
GIMP_PDB_STRING, pattern_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, pattern_callback,
GIMP_PDB_STRING, pattern_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

6
libgimp/gimppatternselect_pdb.h
View File

@ -30,11 +30,11 @@ G_BEGIN_DECLS
gboolean gimp_patterns_popup (const gchar *pattern_callback,
const gchar *popup_title,
const gchar *initial_pattern);
const gchar *popup_title,
const gchar *initial_pattern);
gboolean gimp_patterns_close_popup (const gchar *pattern_callback);
gboolean gimp_patterns_set_popup (const gchar *pattern_callback,
const gchar *pattern_name);
const gchar *pattern_name);
G_END_DECLS

58
libgimp/gimpplugin_pdb.c
View File

@ -45,17 +45,17 @@
*/
gboolean
gimp_plugin_domain_register (const gchar *domain_name,
const gchar *domain_path)
const gchar *domain_path)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-plugin-domain-register",
&nreturn_vals,
GIMP_PDB_STRING, domain_name,
GIMP_PDB_STRING, domain_path,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, domain_name,
GIMP_PDB_STRING, domain_path,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -79,17 +79,17 @@ gimp_plugin_domain_register (const gchar *domain_name,
*/
gboolean
gimp_plugin_help_register (const gchar *domain_name,
const gchar *domain_uri)
const gchar *domain_uri)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-plugin-help-register",
&nreturn_vals,
GIMP_PDB_STRING, domain_name,
GIMP_PDB_STRING, domain_uri,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, domain_name,
GIMP_PDB_STRING, domain_uri,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -114,17 +114,17 @@ gimp_plugin_help_register (const gchar *domain_name,
*/
gboolean
gimp_plugin_menu_register (const gchar *procedure_name,
const gchar *menu_path)
const gchar *menu_path)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-plugin-menu-register",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, menu_path,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_STRING, menu_path,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -149,17 +149,17 @@ gimp_plugin_menu_register (const gchar *procedure_name,
*/
gboolean
gimp_plugin_menu_branch_register (const gchar *menu_path,
const gchar *menu_name)
const gchar *menu_name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-plugin-menu-branch-register",
&nreturn_vals,
GIMP_PDB_STRING, menu_path,
GIMP_PDB_STRING, menu_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, menu_path,
GIMP_PDB_STRING, menu_name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -185,21 +185,21 @@ gimp_plugin_menu_branch_register (const gchar *menu_path,
*/
gboolean
_gimp_plugin_icon_register (const gchar *procedure_name,
GimpIconType icon_type,
gint icon_data_length,
const guint8 *icon_data)
GimpIconType icon_type,
gint icon_data_length,
const guint8 *icon_data)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-plugin-icon-register",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_INT32, icon_type,
GIMP_PDB_INT32, icon_data_length,
GIMP_PDB_INT8ARRAY, icon_data,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_INT32, icon_type,
GIMP_PDB_INT32, icon_data_length,
GIMP_PDB_INT8ARRAY, icon_data,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

14
libgimp/gimpplugin_pdb.h
View File

@ -30,17 +30,17 @@ G_BEGIN_DECLS
gboolean gimp_plugin_domain_register (const gchar *domain_name,
const gchar *domain_path);
const gchar *domain_path);
gboolean gimp_plugin_help_register (const gchar *domain_name,
const gchar *domain_uri);
const gchar *domain_uri);
gboolean gimp_plugin_menu_register (const gchar *procedure_name,
const gchar *menu_path);
const gchar *menu_path);
gboolean gimp_plugin_menu_branch_register (const gchar *menu_path,
const gchar *menu_name);
const gchar *menu_name);
gboolean _gimp_plugin_icon_register (const gchar *procedure_name,
GimpIconType icon_type,
gint icon_data_length,
const guint8 *icon_data) G_GNUC_INTERNAL;
GimpIconType icon_type,
gint icon_data_length,
const guint8 *icon_data) G_GNUC_INTERNAL;
G_END_DECLS

128
libgimp/gimpproceduraldb_pdb.c
View File

@ -46,8 +46,8 @@ gimp_procedural_db_temp_name (void)
gchar *temp_name = NULL;
return_vals = gimp_run_procedure ("gimp-procedural-db-temp-name",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
temp_name = g_strdup (return_vals[1].data.d_string);
@ -79,9 +79,9 @@ gimp_procedural_db_dump (const gchar *filename)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-procedural-db-dump",
&nreturn_vals,
GIMP_PDB_STRING, filename,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, filename,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -122,14 +122,14 @@ gimp_procedural_db_dump (const gchar *filename)
*/
gboolean
gimp_procedural_db_query (const gchar *name,
const gchar *blurb,
const gchar *help,
const gchar *author,
const gchar *copyright,
const gchar *date,
const gchar *proc_type,
gint *num_matches,
gchar ***procedure_names)
const gchar *blurb,
const gchar *help,
const gchar *author,
const gchar *copyright,
const gchar *date,
const gchar *proc_type,
gint *num_matches,
gchar ***procedure_names)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -137,15 +137,15 @@ gimp_procedural_db_query (const gchar *name,
gint i;
return_vals = gimp_run_procedure ("gimp-procedural-db-query",
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, blurb,
GIMP_PDB_STRING, help,
GIMP_PDB_STRING, author,
GIMP_PDB_STRING, copyright,
GIMP_PDB_STRING, date,
GIMP_PDB_STRING, proc_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, name,
GIMP_PDB_STRING, blurb,
GIMP_PDB_STRING, help,
GIMP_PDB_STRING, author,
GIMP_PDB_STRING, copyright,
GIMP_PDB_STRING, date,
GIMP_PDB_STRING, proc_type,
GIMP_PDB_END);
*num_matches = 0;
*procedure_names = NULL;
@ -191,23 +191,23 @@ gimp_procedural_db_query (const gchar *name,
*/
gboolean
_gimp_procedural_db_proc_info (const gchar *procedure_name,
gchar **blurb,
gchar **help,
gchar **author,
gchar **copyright,
gchar **date,
GimpPDBProcType *proc_type,
gint *num_args,
gint *num_values)
gchar **blurb,
gchar **help,
gchar **author,
gchar **copyright,
gchar **date,
GimpPDBProcType *proc_type,
gint *num_args,
gint *num_values)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-procedural-db-proc-info",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_END);
*blurb = NULL;
*help = NULL;
@ -255,20 +255,20 @@ _gimp_procedural_db_proc_info (const gchar *procedure_name,
*/
gboolean
gimp_procedural_db_proc_arg (const gchar *procedure_name,
gint arg_num,
GimpPDBArgType *arg_type,
gchar **arg_name,
gchar **arg_desc)
gint arg_num,
GimpPDBArgType *arg_type,
gchar **arg_name,
gchar **arg_desc)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-procedural-db-proc-arg",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_INT32, arg_num,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_INT32, arg_num,
GIMP_PDB_END);
*arg_type = 0;
*arg_name = NULL;
@ -307,20 +307,20 @@ gimp_procedural_db_proc_arg (const gchar *procedure_name,
*/
gboolean
gimp_procedural_db_proc_val (const gchar *procedure_name,
gint val_num,
GimpPDBArgType *val_type,
gchar **val_name,
gchar **val_desc)
gint val_num,
GimpPDBArgType *val_type,
gchar **val_name,
gchar **val_desc)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-procedural-db-proc-val",
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_INT32, val_num,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, procedure_name,
GIMP_PDB_INT32, val_num,
GIMP_PDB_END);
*val_type = 0;
*val_name = NULL;
@ -357,17 +357,17 @@ gimp_procedural_db_proc_val (const gchar *procedure_name,
*/
gboolean
_gimp_procedural_db_get_data (const gchar *identifier,
gint *bytes,
guint8 **data)
gint *bytes,
guint8 **data)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-procedural-db-get-data",
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_END);
*bytes = 0;
*data = NULL;
@ -407,9 +407,9 @@ gimp_procedural_db_get_data_size (const gchar *identifier)
gint bytes = 0;
return_vals = gimp_run_procedure ("gimp-procedural-db-get-data-size",
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
bytes = return_vals[1].data.d_int32;
@ -435,19 +435,19 @@ gimp_procedural_db_get_data_size (const gchar *identifier)
*/
gboolean
_gimp_procedural_db_set_data (const gchar *identifier,
gint bytes,
const guint8 *data)
gint bytes,
const guint8 *data)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-procedural-db-set-data",
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_INT32, bytes,
GIMP_PDB_INT8ARRAY, data,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_INT32, bytes,
GIMP_PDB_INT8ARRAY, data,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

56
libgimp/gimpproceduraldb_pdb.h
View File

@ -32,40 +32,40 @@ G_BEGIN_DECLS
gchar* gimp_procedural_db_temp_name (void);
gboolean gimp_procedural_db_dump (const gchar *filename);
gboolean gimp_procedural_db_query (const gchar *name,
const gchar *blurb,
const gchar *help,
const gchar *author,
const gchar *copyright,
const gchar *date,
const gchar *proc_type,
gint *num_matches,
gchar ***procedure_names);
const gchar *blurb,
const gchar *help,
const gchar *author,
const gchar *copyright,
const gchar *date,
const gchar *proc_type,
gint *num_matches,
gchar ***procedure_names);
gboolean _gimp_procedural_db_proc_info (const gchar *procedure_name,
gchar **blurb,
gchar **help,
gchar **author,
gchar **copyright,
gchar **date,
GimpPDBProcType *proc_type,
gint *num_args,
gint *num_values) G_GNUC_INTERNAL;
gchar **blurb,
gchar **help,
gchar **author,
gchar **copyright,
gchar **date,
GimpPDBProcType *proc_type,
gint *num_args,
gint *num_values) G_GNUC_INTERNAL;
gboolean gimp_procedural_db_proc_arg (const gchar *procedure_name,
gint arg_num,
GimpPDBArgType *arg_type,
gchar **arg_name,
gchar **arg_desc);
gint arg_num,
GimpPDBArgType *arg_type,
gchar **arg_name,
gchar **arg_desc);
gboolean gimp_procedural_db_proc_val (const gchar *procedure_name,
gint val_num,
GimpPDBArgType *val_type,
gchar **val_name,
gchar **val_desc);
gint val_num,
GimpPDBArgType *val_type,
gchar **val_name,
gchar **val_desc);
gboolean _gimp_procedural_db_get_data (const gchar *identifier,
gint *bytes,
guint8 **data) G_GNUC_INTERNAL;
gint *bytes,
guint8 **data) G_GNUC_INTERNAL;
gint gimp_procedural_db_get_data_size (const gchar *identifier);
gboolean _gimp_procedural_db_set_data (const gchar *identifier,
gint bytes,
const guint8 *data) G_GNUC_INTERNAL;
gint bytes,
const guint8 *data) G_GNUC_INTERNAL;
G_END_DECLS

48
libgimp/gimpprogress_pdb.c
View File

@ -39,17 +39,17 @@
*/
gboolean
_gimp_progress_init (const gchar *message,
gint32 gdisplay_ID)
gint32 gdisplay_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-init",
&nreturn_vals,
GIMP_PDB_STRING, message,
GIMP_PDB_DISPLAY, gdisplay_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, message,
GIMP_PDB_DISPLAY, gdisplay_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -77,9 +77,9 @@ _gimp_progress_update (gdouble percentage)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-update",
&nreturn_vals,
GIMP_PDB_FLOAT, percentage,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_FLOAT, percentage,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -111,8 +111,8 @@ gimp_progress_pulse (void)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-pulse",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -143,9 +143,9 @@ gimp_progress_set_text (const gchar *message)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-set-text",
&nreturn_vals,
GIMP_PDB_STRING, message,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, message,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -175,8 +175,8 @@ gimp_progress_get_window_handle (void)
gint window = 0;
return_vals = gimp_run_procedure ("gimp-progress-get-window-handle",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
window = return_vals[1].data.d_int32;
@ -209,9 +209,9 @@ _gimp_progress_install (const gchar *progress_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-install",
&nreturn_vals,
GIMP_PDB_STRING, progress_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, progress_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -241,9 +241,9 @@ _gimp_progress_uninstall (const gchar *progress_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-uninstall",
&nreturn_vals,
GIMP_PDB_STRING, progress_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, progress_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -272,9 +272,9 @@ gimp_progress_cancel (const gchar *progress_callback)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-progress-cancel",
&nreturn_vals,
GIMP_PDB_STRING, progress_callback,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, progress_callback,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

2
libgimp/gimpprogress_pdb.h
View File

@ -30,7 +30,7 @@ G_BEGIN_DECLS
gboolean _gimp_progress_init (const gchar *message,
gint32 gdisplay_ID) G_GNUC_INTERNAL;
gint32 gdisplay_ID) G_GNUC_INTERNAL;
gboolean _gimp_progress_update (gdouble percentage) G_GNUC_INTERNAL;
gboolean gimp_progress_pulse (void);
gboolean gimp_progress_set_text (const gchar *message);

156
libgimp/gimpselection_pdb.c
View File

@ -49,20 +49,20 @@
*/
gboolean
gimp_selection_bounds (gint32 image_ID,
gboolean *non_empty,
gint *x1,
gint *y1,
gint *x2,
gint *y2)
gboolean *non_empty,
gint *x1,
gint *y1,
gint *x2,
gint *y2)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-bounds",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
*non_empty = FALSE;
*x1 = 0;
@ -101,19 +101,19 @@ gimp_selection_bounds (gint32 image_ID,
*/
gint
gimp_selection_value (gint32 image_ID,
gint x,
gint y)
gint x,
gint y)
{
GimpParam *return_vals;
gint nreturn_vals;
gint value = 0;
return_vals = gimp_run_procedure ("gimp-selection-value",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, x,
GIMP_PDB_INT32, y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, x,
GIMP_PDB_INT32, y,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
value = return_vals[1].data.d_int32;
@ -142,9 +142,9 @@ gimp_selection_is_empty (gint32 image_ID)
gboolean is_empty = FALSE;
return_vals = gimp_run_procedure ("gimp-selection-is-empty",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
is_empty = return_vals[1].data.d_int32;
@ -172,19 +172,19 @@ gimp_selection_is_empty (gint32 image_ID)
*/
gboolean
gimp_selection_translate (gint32 image_ID,
gint offx,
gint offy)
gint offx,
gint offy)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-translate",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -212,19 +212,19 @@ gimp_selection_translate (gint32 image_ID,
*/
gint32
_gimp_selection_float (gint32 drawable_ID,
gint offx,
gint offy)
gint offx,
gint offy)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 layer_ID = -1;
return_vals = gimp_run_procedure ("gimp-selection-float",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, offx,
GIMP_PDB_INT32, offy,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
layer_ID = return_vals[1].data.d_layer;
@ -253,9 +253,9 @@ gimp_selection_invert (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-invert",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -285,9 +285,9 @@ gimp_selection_sharpen (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-sharpen",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -315,9 +315,9 @@ gimp_selection_all (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-all",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -345,9 +345,9 @@ gimp_selection_none (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-none",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -370,17 +370,17 @@ gimp_selection_none (gint32 image_ID)
*/
gboolean
gimp_selection_feather (gint32 image_ID,
gdouble radius)
gdouble radius)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-feather",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, radius,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, radius,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -404,17 +404,17 @@ gimp_selection_feather (gint32 image_ID,
*/
gboolean
gimp_selection_border (gint32 image_ID,
gint radius)
gint radius)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-border",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, radius,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, radius,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -437,17 +437,17 @@ gimp_selection_border (gint32 image_ID,
*/
gboolean
gimp_selection_grow (gint32 image_ID,
gint steps)
gint steps)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-grow",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, steps,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, steps,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -471,17 +471,17 @@ gimp_selection_grow (gint32 image_ID,
*/
gboolean
gimp_selection_shrink (gint32 image_ID,
gint steps)
gint steps)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-shrink",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, steps,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, steps,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -513,9 +513,9 @@ gimp_selection_layer_alpha (gint32 layer_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-layer-alpha",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -542,9 +542,9 @@ gimp_selection_load (gint32 channel_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-load",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -573,9 +573,9 @@ gimp_selection_save (gint32 image_ID)
gint32 channel_ID = -1;
return_vals = gimp_run_procedure ("gimp-selection-save",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
channel_ID = return_vals[1].data.d_channel;
@ -599,17 +599,17 @@ gimp_selection_save (gint32 image_ID)
*/
gboolean
gimp_selection_combine (gint32 channel_ID,
GimpChannelOps operation)
GimpChannelOps operation)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-selection-combine",
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_INT32, operation,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_CHANNEL, channel_ID,
GIMP_PDB_INT32, operation,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

32
libgimp/gimpselection_pdb.h
View File

@ -30,38 +30,38 @@ G_BEGIN_DECLS
gboolean gimp_selection_bounds (gint32 image_ID,
gboolean *non_empty,
gint *x1,
gint *y1,
gint *x2,
gint *y2);
gboolean *non_empty,
gint *x1,
gint *y1,
gint *x2,
gint *y2);
gint gimp_selection_value (gint32 image_ID,
gint x,
gint y);
gint x,
gint y);
gboolean gimp_selection_is_empty (gint32 image_ID);
gboolean gimp_selection_translate (gint32 image_ID,
gint offx,
gint offy);
gint offx,
gint offy);
gint32 _gimp_selection_float (gint32 drawable_ID,
gint offx,
gint offy) G_GNUC_INTERNAL;
gint offx,
gint offy) G_GNUC_INTERNAL;
gboolean gimp_selection_invert (gint32 image_ID);
gboolean gimp_selection_sharpen (gint32 image_ID);
gboolean gimp_selection_all (gint32 image_ID);
gboolean gimp_selection_none (gint32 image_ID);
gboolean gimp_selection_feather (gint32 image_ID,
gdouble radius);
gdouble radius);
gboolean gimp_selection_border (gint32 image_ID,
gint radius);
gint radius);
gboolean gimp_selection_grow (gint32 image_ID,
gint steps);
gint steps);
gboolean gimp_selection_shrink (gint32 image_ID,
gint steps);
gint steps);
gboolean gimp_selection_layer_alpha (gint32 layer_ID);
gboolean gimp_selection_load (gint32 channel_ID);
gint32 gimp_selection_save (gint32 image_ID);
gboolean gimp_selection_combine (gint32 channel_ID,
GimpChannelOps operation);
GimpChannelOps operation);
G_END_DECLS

174
libgimp/gimpselectiontools_pdb.c
View File

@ -57,29 +57,29 @@
*/
gboolean
gimp_by_color_select (gint32 drawable_ID,
const GimpRGB *color,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged)
const GimpRGB *color,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-by-color-select",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_COLOR, color,
GIMP_PDB_INT32, threshold,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_INT32, sample_merged,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_COLOR, color,
GIMP_PDB_INT32, threshold,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_INT32, sample_merged,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -116,31 +116,31 @@ gimp_by_color_select (gint32 drawable_ID,
*/
gboolean
gimp_ellipse_select (gint32 image_ID,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius)
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-ellipse-select",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_FLOAT, width,
GIMP_PDB_FLOAT, height,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_FLOAT, width,
GIMP_PDB_FLOAT, height,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -177,27 +177,27 @@ gimp_ellipse_select (gint32 image_ID,
*/
gboolean
gimp_free_select (gint32 image_ID,
gint num_segs,
const gdouble *segs,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius)
gint num_segs,
const gdouble *segs,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-free-select",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, num_segs,
GIMP_PDB_FLOATARRAY, segs,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_INT32, num_segs,
GIMP_PDB_FLOATARRAY, segs,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -244,31 +244,31 @@ gimp_free_select (gint32 image_ID,
*/
gboolean
gimp_fuzzy_select (gint32 drawable_ID,
gdouble x,
gdouble y,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged)
gdouble x,
gdouble y,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-fuzzy-select",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_INT32, threshold,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_INT32, sample_merged,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_INT32, threshold,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, antialias,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_INT32, sample_merged,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -301,29 +301,29 @@ gimp_fuzzy_select (gint32 drawable_ID,
*/
gboolean
gimp_rect_select (gint32 image_ID,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean feather,
gdouble feather_radius)
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean feather,
gdouble feather_radius)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-rect-select",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_FLOAT, width,
GIMP_PDB_FLOAT, height,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_FLOAT, width,
GIMP_PDB_FLOAT, height,
GIMP_PDB_INT32, operation,
GIMP_PDB_INT32, feather,
GIMP_PDB_FLOAT, feather_radius,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

72
libgimp/gimpselectiontools_pdb.h
View File

@ -30,46 +30,46 @@ G_BEGIN_DECLS
gboolean gimp_by_color_select (gint32 drawable_ID,
const GimpRGB *color,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged);
const GimpRGB *color,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged);
gboolean gimp_ellipse_select (gint32 image_ID,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius);
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius);
gboolean gimp_free_select (gint32 image_ID,
gint num_segs,
const gdouble *segs,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius);
gint num_segs,
const gdouble *segs,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius);
gboolean gimp_fuzzy_select (gint32 drawable_ID,
gdouble x,
gdouble y,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged);
gdouble x,
gdouble y,
gint threshold,
GimpChannelOps operation,
gboolean antialias,
gboolean feather,
gdouble feather_radius,
gboolean sample_merged);
gboolean gimp_rect_select (gint32 image_ID,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean feather,
gdouble feather_radius);
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpChannelOps operation,
gboolean feather,
gdouble feather_radius);
G_END_DECLS

192
libgimp/gimptexttool_pdb.c
View File

@ -56,33 +56,33 @@
*/
gint32
gimp_text_fontname (gint32 image_ID,
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *fontname)
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *fontname)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 text_layer_ID = -1;
return_vals = gimp_run_procedure ("gimp-text-fontname",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_STRING, text,
GIMP_PDB_INT32, border,
GIMP_PDB_INT32, antialias,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, fontname,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_STRING, text,
GIMP_PDB_INT32, border,
GIMP_PDB_INT32, antialias,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, fontname,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
text_layer_ID = return_vals[1].data.d_layer;
@ -113,25 +113,25 @@ gimp_text_fontname (gint32 image_ID,
*/
gboolean
gimp_text_get_extents_fontname (const gchar *text,
gdouble size,
GimpSizeType size_type,
const gchar *fontname,
gint *width,
gint *height,
gint *ascent,
gint *descent)
gdouble size,
GimpSizeType size_type,
const gchar *fontname,
gint *width,
gint *height,
gint *ascent,
gint *descent)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-text-get-extents-fontname",
&nreturn_vals,
GIMP_PDB_STRING, text,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, fontname,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, text,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, fontname,
GIMP_PDB_END);
*width = 0;
*height = 0;
@ -179,47 +179,47 @@ gimp_text_get_extents_fontname (const gchar *text,
*/
gint32
gimp_text (gint32 image_ID,
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding)
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 text_layer_ID = -1;
return_vals = gimp_run_procedure ("gimp-text",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_STRING, text,
GIMP_PDB_INT32, border,
GIMP_PDB_INT32, antialias,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, foundry,
GIMP_PDB_STRING, family,
GIMP_PDB_STRING, weight,
GIMP_PDB_STRING, slant,
GIMP_PDB_STRING, set_width,
GIMP_PDB_STRING, spacing,
GIMP_PDB_STRING, registry,
GIMP_PDB_STRING, encoding,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x,
GIMP_PDB_FLOAT, y,
GIMP_PDB_STRING, text,
GIMP_PDB_INT32, border,
GIMP_PDB_INT32, antialias,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, foundry,
GIMP_PDB_STRING, family,
GIMP_PDB_STRING, weight,
GIMP_PDB_STRING, slant,
GIMP_PDB_STRING, set_width,
GIMP_PDB_STRING, spacing,
GIMP_PDB_STRING, registry,
GIMP_PDB_STRING, encoding,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
text_layer_ID = return_vals[1].data.d_layer;
@ -254,39 +254,39 @@ gimp_text (gint32 image_ID,
*/
gboolean
gimp_text_get_extents (const gchar *text,
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding,
gint *width,
gint *height,
gint *ascent,
gint *descent)
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding,
gint *width,
gint *height,
gint *ascent,
gint *descent)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-text-get-extents",
&nreturn_vals,
GIMP_PDB_STRING, text,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, foundry,
GIMP_PDB_STRING, family,
GIMP_PDB_STRING, weight,
GIMP_PDB_STRING, slant,
GIMP_PDB_STRING, set_width,
GIMP_PDB_STRING, spacing,
GIMP_PDB_STRING, registry,
GIMP_PDB_STRING, encoding,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, text,
GIMP_PDB_FLOAT, size,
GIMP_PDB_INT32, size_type,
GIMP_PDB_STRING, foundry,
GIMP_PDB_STRING, family,
GIMP_PDB_STRING, weight,
GIMP_PDB_STRING, slant,
GIMP_PDB_STRING, set_width,
GIMP_PDB_STRING, spacing,
GIMP_PDB_STRING, registry,
GIMP_PDB_STRING, encoding,
GIMP_PDB_END);
*width = 0;
*height = 0;

92
libgimp/gimptexttool_pdb.h
View File

@ -30,56 +30,56 @@ G_BEGIN_DECLS
gint32 gimp_text_fontname (gint32 image_ID,
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *fontname);
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *fontname);
gboolean gimp_text_get_extents_fontname (const gchar *text,
gdouble size,
GimpSizeType size_type,
const gchar *fontname,
gint *width,
gint *height,
gint *ascent,
gint *descent);
gdouble size,
GimpSizeType size_type,
const gchar *fontname,
gint *width,
gint *height,
gint *ascent,
gint *descent);
#ifndef GIMP_DISABLE_DEPRECATED
gint32 gimp_text (gint32 image_ID,
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding);
gint32 drawable_ID,
gdouble x,
gdouble y,
const gchar *text,
gint border,
gboolean antialias,
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding);
gboolean gimp_text_get_extents (const gchar *text,
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding,
gint *width,
gint *height,
gint *ascent,
gint *descent);
gdouble size,
GimpSizeType size_type,
const gchar *foundry,
const gchar *family,
const gchar *weight,
const gchar *slant,
const gchar *set_width,
const gchar *spacing,
const gchar *registry,
const gchar *encoding,
gint *width,
gint *height,
gint *ascent,
gint *descent);
#endif /* GIMP_DISABLE_DEPRECATED */

148
libgimp/gimptransformtools_pdb.c
View File

@ -37,17 +37,17 @@
*/
gint32
gimp_flip (gint32 drawable_ID,
GimpOrientationType flip_type)
GimpOrientationType flip_type)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-flip",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, flip_type,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, flip_type,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -77,33 +77,33 @@ gimp_flip (gint32 drawable_ID,
*/
gint32
gimp_perspective (gint32 drawable_ID,
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3)
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-perspective",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_FLOAT, x3,
GIMP_PDB_FLOAT, y3,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_FLOAT, x3,
GIMP_PDB_FLOAT, y3,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -126,19 +126,19 @@ gimp_perspective (gint32 drawable_ID,
*/
gint32
gimp_rotate (gint32 drawable_ID,
gboolean interpolation,
gdouble angle)
gboolean interpolation,
gdouble angle)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-rotate",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -164,25 +164,25 @@ gimp_rotate (gint32 drawable_ID,
*/
gint32
gimp_scale (gint32 drawable_ID,
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1)
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-scale",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -206,21 +206,21 @@ gimp_scale (gint32 drawable_ID,
*/
gint32
gimp_shear (gint32 drawable_ID,
gboolean interpolation,
GimpOrientationType shear_type,
gdouble magnitude)
gboolean interpolation,
GimpOrientationType shear_type,
gdouble magnitude)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-shear",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, shear_type,
GIMP_PDB_FLOAT, magnitude,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, shear_type,
GIMP_PDB_FLOAT, magnitude,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
@ -249,31 +249,31 @@ gimp_shear (gint32 drawable_ID,
*/
gint32
gimp_transform_2d (gint32 drawable_ID,
gboolean interpolation,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y)
gboolean interpolation,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp-transform-2d",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, source_x,
GIMP_PDB_FLOAT, source_y,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_FLOAT, dest_x,
GIMP_PDB_FLOAT, dest_y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_FLOAT, source_x,
GIMP_PDB_FLOAT, source_y,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_FLOAT, dest_x,
GIMP_PDB_FLOAT, dest_y,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;

56
libgimp/gimptransformtools_pdb.h
View File

@ -31,39 +31,39 @@ G_BEGIN_DECLS
#ifndef GIMP_DISABLE_DEPRECATED
gint32 gimp_flip (gint32 drawable_ID,
GimpOrientationType flip_type);
GimpOrientationType flip_type);
gint32 gimp_perspective (gint32 drawable_ID,
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3);
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gdouble x3,
gdouble y3);
gint32 gimp_rotate (gint32 drawable_ID,
gboolean interpolation,
gdouble angle);
gboolean interpolation,
gdouble angle);
gint32 gimp_scale (gint32 drawable_ID,
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1);
gboolean interpolation,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1);
gint32 gimp_shear (gint32 drawable_ID,
gboolean interpolation,
GimpOrientationType shear_type,
gdouble magnitude);
gboolean interpolation,
GimpOrientationType shear_type,
gdouble magnitude);
gint32 gimp_transform_2d (gint32 drawable_ID,
gboolean interpolation,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y);
gboolean interpolation,
gdouble source_x,
gdouble source_y,
gdouble scale_x,
gdouble scale_y,
gdouble angle,
gdouble dest_x,
gdouble dest_y);
#endif /* GIMP_DISABLE_DEPRECATED */

42
libgimp/gimpundo_pdb.c
View File

@ -46,9 +46,9 @@ gimp_image_undo_group_start (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-undo-group-start",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -76,9 +76,9 @@ gimp_image_undo_group_end (gint32 image_ID)
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-image-undo-group-end",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -108,9 +108,9 @@ gimp_image_undo_is_enabled (gint32 image_ID)
gboolean enabled = FALSE;
return_vals = gimp_run_procedure ("gimp-image-undo-is-enabled",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
enabled = return_vals[1].data.d_int32;
@ -142,9 +142,9 @@ gimp_image_undo_disable (gint32 image_ID)
gboolean disabled = FALSE;
return_vals = gimp_run_procedure ("gimp-image-undo-disable",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
disabled = return_vals[1].data.d_int32;
@ -175,9 +175,9 @@ gimp_image_undo_enable (gint32 image_ID)
gboolean enabled = FALSE;
return_vals = gimp_run_procedure ("gimp-image-undo-enable",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
enabled = return_vals[1].data.d_int32;
@ -214,9 +214,9 @@ gimp_image_undo_freeze (gint32 image_ID)
gboolean frozen = FALSE;
return_vals = gimp_run_procedure ("gimp-image-undo-freeze",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
frozen = return_vals[1].data.d_int32;
@ -253,9 +253,9 @@ gimp_image_undo_thaw (gint32 image_ID)
gboolean thawed = FALSE;
return_vals = gimp_run_procedure ("gimp-image-undo-thaw",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
thawed = return_vals[1].data.d_int32;

96
libgimp/gimpunit_pdb.c
View File

@ -42,8 +42,8 @@ _gimp_unit_get_number_of_units (void)
gint num_units = GIMP_UNIT_END;
return_vals = gimp_run_procedure ("gimp-unit-get-number-of-units",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
num_units = return_vals[1].data.d_int32;
@ -71,8 +71,8 @@ _gimp_unit_get_number_of_built_in_units (void)
gint num_units = GIMP_UNIT_END;
return_vals = gimp_run_procedure ("gimp-unit-get-number-of-built-in-units",
&nreturn_vals,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
num_units = return_vals[1].data.d_int32;
@ -103,27 +103,27 @@ _gimp_unit_get_number_of_built_in_units (void)
*/
GimpUnit
_gimp_unit_new (const gchar *identifier,
gdouble factor,
gint digits,
const gchar *symbol,
const gchar *abbreviation,
const gchar *singular,
const gchar *plural)
gdouble factor,
gint digits,
const gchar *symbol,
const gchar *abbreviation,
const gchar *singular,
const gchar *plural)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpUnit unit_id = GIMP_UNIT_INCH;
return_vals = gimp_run_procedure ("gimp-unit-new",
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_FLOAT, factor,
GIMP_PDB_INT32, digits,
GIMP_PDB_STRING, symbol,
GIMP_PDB_STRING, abbreviation,
GIMP_PDB_STRING, singular,
GIMP_PDB_STRING, plural,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_STRING, identifier,
GIMP_PDB_FLOAT, factor,
GIMP_PDB_INT32, digits,
GIMP_PDB_STRING, symbol,
GIMP_PDB_STRING, abbreviation,
GIMP_PDB_STRING, singular,
GIMP_PDB_STRING, plural,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
unit_id = return_vals[1].data.d_unit;
@ -153,9 +153,9 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id)
gboolean deletion_flag = FALSE;
return_vals = gimp_run_procedure ("gimp-unit-get-deletion-flag",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
deletion_flag = return_vals[1].data.d_int32;
@ -180,17 +180,17 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id)
*/
gboolean
_gimp_unit_set_deletion_flag (GimpUnit unit_id,
gboolean deletion_flag)
gboolean deletion_flag)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-unit-set-deletion-flag",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_INT32, deletion_flag,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_INT32, deletion_flag,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -219,9 +219,9 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
gchar *identifier = NULL;
return_vals = gimp_run_procedure ("gimp-unit-get-identifier",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
identifier = g_strdup (return_vals[1].data.d_string);
@ -251,9 +251,9 @@ _gimp_unit_get_factor (GimpUnit unit_id)
gdouble factor = 0.0;
return_vals = gimp_run_procedure ("gimp-unit-get-factor",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
factor = return_vals[1].data.d_float;
@ -284,9 +284,9 @@ _gimp_unit_get_digits (GimpUnit unit_id)
gint digits = 0;
return_vals = gimp_run_procedure ("gimp-unit-get-digits",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
digits = return_vals[1].data.d_int32;
@ -314,9 +314,9 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
gchar *symbol = NULL;
return_vals = gimp_run_procedure ("gimp-unit-get-symbol",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
symbol = g_strdup (return_vals[1].data.d_string);
@ -345,9 +345,9 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
gchar *abbreviation = NULL;
return_vals = gimp_run_procedure ("gimp-unit-get-abbreviation",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
abbreviation = g_strdup (return_vals[1].data.d_string);
@ -375,9 +375,9 @@ _gimp_unit_get_singular (GimpUnit unit_id)
gchar *singular = NULL;
return_vals = gimp_run_procedure ("gimp-unit-get-singular",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
singular = g_strdup (return_vals[1].data.d_string);
@ -405,9 +405,9 @@ _gimp_unit_get_plural (GimpUnit unit_id)
gchar *plural = NULL;
return_vals = gimp_run_procedure ("gimp-unit-get-plural",
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_INT32, unit_id,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
plural = g_strdup (return_vals[1].data.d_string);

14
libgimp/gimpunit_pdb.h
View File

@ -32,15 +32,15 @@ G_BEGIN_DECLS
gint _gimp_unit_get_number_of_units (void) G_GNUC_INTERNAL;
gint _gimp_unit_get_number_of_built_in_units (void) G_GNUC_INTERNAL;
GimpUnit _gimp_unit_new (const gchar *identifier,
gdouble factor,
gint digits,
const gchar *symbol,
const gchar *abbreviation,
const gchar *singular,
const gchar *plural) G_GNUC_INTERNAL;
gdouble factor,
gint digits,
const gchar *symbol,
const gchar *abbreviation,
const gchar *singular,
const gchar *plural) G_GNUC_INTERNAL;
gboolean _gimp_unit_get_deletion_flag (GimpUnit unit_id) G_GNUC_INTERNAL;
gboolean _gimp_unit_set_deletion_flag (GimpUnit unit_id,
gboolean deletion_flag) G_GNUC_INTERNAL;
gboolean deletion_flag) G_GNUC_INTERNAL;
gchar* _gimp_unit_get_identifier (GimpUnit unit_id) G_GNUC_INTERNAL;
gdouble _gimp_unit_get_factor (GimpUnit unit_id) G_GNUC_INTERNAL;
gint _gimp_unit_get_digits (GimpUnit unit_id) G_GNUC_INTERNAL;

318
libgimp/gimpvectors_pdb.c
View File

@ -43,17 +43,17 @@
*/
gint32
gimp_vectors_new (gint32 image_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 vectors_ID = -1;
return_vals = gimp_run_procedure ("gimp-vectors-new",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
vectors_ID = return_vals[1].data.d_vectors;
@ -83,9 +83,9 @@ gimp_vectors_get_image (gint32 vectors_ID)
gint32 image_ID = -1;
return_vals = gimp_run_procedure ("gimp-vectors-get-image",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
image_ID = return_vals[1].data.d_image;
@ -115,9 +115,9 @@ gimp_vectors_get_name (gint32 vectors_ID)
gchar *name = NULL;
return_vals = gimp_run_procedure ("gimp-vectors-get-name",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
name = g_strdup (return_vals[1].data.d_string);
@ -142,17 +142,17 @@ gimp_vectors_get_name (gint32 vectors_ID)
*/
gboolean
gimp_vectors_set_name (gint32 vectors_ID,
const gchar *name)
const gchar *name)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-set-name",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_STRING, name,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -181,9 +181,9 @@ gimp_vectors_get_visible (gint32 vectors_ID)
gboolean visible = FALSE;
return_vals = gimp_run_procedure ("gimp-vectors-get-visible",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
visible = return_vals[1].data.d_int32;
@ -208,17 +208,17 @@ gimp_vectors_get_visible (gint32 vectors_ID)
*/
gboolean
gimp_vectors_set_visible (gint32 vectors_ID,
gboolean visible)
gboolean visible)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-set-visible",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, visible,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, visible,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -247,9 +247,9 @@ gimp_vectors_get_linked (gint32 vectors_ID)
gboolean linked = FALSE;
return_vals = gimp_run_procedure ("gimp-vectors-get-linked",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
linked = return_vals[1].data.d_int32;
@ -274,17 +274,17 @@ gimp_vectors_get_linked (gint32 vectors_ID)
*/
gboolean
gimp_vectors_set_linked (gint32 vectors_ID,
gboolean linked)
gboolean linked)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-set-linked",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, linked,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, linked,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -313,9 +313,9 @@ gimp_vectors_get_tattoo (gint32 vectors_ID)
gint tattoo = 0;
return_vals = gimp_run_procedure ("gimp-vectors-get-tattoo",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
tattoo = return_vals[1].data.d_int32;
@ -340,17 +340,17 @@ gimp_vectors_get_tattoo (gint32 vectors_ID)
*/
gboolean
gimp_vectors_set_tattoo (gint32 vectors_ID,
gint tattoo)
gint tattoo)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-set-tattoo",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, tattoo,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, tattoo,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -375,16 +375,16 @@ gimp_vectors_set_tattoo (gint32 vectors_ID,
*/
gint *
gimp_vectors_get_strokes (gint32 vectors_ID,
gint *num_strokes)
gint *num_strokes)
{
GimpParam *return_vals;
gint nreturn_vals;
gint *stroke_ids = NULL;
return_vals = gimp_run_procedure ("gimp-vectors-get-strokes",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_END);
*num_strokes = 0;
@ -417,19 +417,19 @@ gimp_vectors_get_strokes (gint32 vectors_ID,
*/
gdouble
gimp_vectors_stroke_get_length (gint32 vectors_ID,
gint stroke_id,
gdouble prescision)
gint stroke_id,
gdouble prescision)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble length = 0.0;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-length",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, prescision,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, prescision,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
length = return_vals[1].data.d_float;
@ -464,24 +464,24 @@ gimp_vectors_stroke_get_length (gint32 vectors_ID,
*/
gdouble
gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID,
gint stroke_id,
gdouble dist,
gdouble prescision,
gdouble *y_point,
gdouble *slope,
gboolean *valid)
gint stroke_id,
gdouble dist,
gdouble prescision,
gdouble *y_point,
gdouble *slope,
gboolean *valid)
{
GimpParam *return_vals;
gint nreturn_vals;
gdouble x_point = 0.0;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-point-at-dist",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, dist,
GIMP_PDB_FLOAT, prescision,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, dist,
GIMP_PDB_FLOAT, prescision,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{
@ -511,17 +511,17 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID,
*/
gboolean
gimp_vectors_stroke_remove (gint32 vectors_ID,
gint stroke_id)
gint stroke_id)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-remove",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -545,17 +545,17 @@ gimp_vectors_stroke_remove (gint32 vectors_ID,
*/
gboolean
gimp_vectors_stroke_close (gint32 vectors_ID,
gint stroke_id)
gint stroke_id)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-close",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -581,21 +581,21 @@ gimp_vectors_stroke_close (gint32 vectors_ID,
*/
gboolean
gimp_vectors_stroke_translate (gint32 vectors_ID,
gint stroke_id,
gint off_x,
gint off_y)
gint stroke_id,
gint off_x,
gint off_y)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-translate",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_INT32, off_x,
GIMP_PDB_INT32, off_y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_INT32, off_x,
GIMP_PDB_INT32, off_y,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -621,21 +621,21 @@ gimp_vectors_stroke_translate (gint32 vectors_ID,
*/
gboolean
gimp_vectors_stroke_scale (gint32 vectors_ID,
gint stroke_id,
gdouble scale_x,
gdouble scale_y)
gint stroke_id,
gdouble scale_x,
gdouble scale_y)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-scale",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, scale_x,
GIMP_PDB_FLOAT, scale_y,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -662,21 +662,21 @@ gimp_vectors_stroke_scale (gint32 vectors_ID,
*/
gboolean
gimp_vectors_stroke_interpolate (gint32 vectors_ID,
gint stroke_id,
gdouble prescision,
gint *num_coords,
gdouble **coords)
gint stroke_id,
gdouble prescision,
gint *num_coords,
gdouble **coords)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean closed = FALSE;
return_vals = gimp_run_procedure ("gimp-vectors-stroke-interpolate",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, prescision,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, prescision,
GIMP_PDB_END);
*num_coords = 0;
@ -710,19 +710,19 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID,
*/
gint
gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID,
gdouble x0,
gdouble y0)
gdouble x0,
gdouble y0)
{
GimpParam *return_vals;
gint nreturn_vals;
gint stroke_id = 0;
return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-new-moveto",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
stroke_id = return_vals[1].data.d_int32;
@ -749,21 +749,21 @@ gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID,
*/
gboolean
gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
gint stroke_id,
gdouble x0,
gdouble y0)
gint stroke_id,
gdouble x0,
gdouble y0)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-lineto",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -793,25 +793,25 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
*/
gboolean
gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1)
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-conicto",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -841,29 +841,29 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
*/
gboolean
gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-cubicto",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_INT32, stroke_id,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
@ -891,25 +891,25 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
*/
gint
gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID,
gdouble x0,
gdouble y0,
gdouble radius_x,
gdouble radius_y,
gdouble angle)
gdouble x0,
gdouble y0,
gdouble radius_x,
gdouble radius_y,
gdouble angle)
{
GimpParam *return_vals;
gint nreturn_vals;
gint stroke_id = 0;
return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-new-ellipse",
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, radius_x,
GIMP_PDB_FLOAT, radius_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_END);
&nreturn_vals,
GIMP_PDB_VECTORS, vectors_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, radius_x,
GIMP_PDB_FLOAT, radius_y,
GIMP_PDB_FLOAT, angle,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
stroke_id = return_vals[1].data.d_int32;

96
libgimp/gimpvectors_pdb.h
View File

@ -30,76 +30,76 @@ G_BEGIN_DECLS
gint32 gimp_vectors_new (gint32 image_ID,
const gchar *name);
const gchar *name);
gint32 gimp_vectors_get_image (gint32 vectors_ID);
gchar* gimp_vectors_get_name (gint32 vectors_ID);
gboolean gimp_vectors_set_name (gint32 vectors_ID,
const gchar *name);
const gchar *name);
gboolean gimp_vectors_get_visible (gint32 vectors_ID);
gboolean gimp_vectors_set_visible (gint32 vectors_ID,
gboolean visible);
gboolean visible);
gboolean gimp_vectors_get_linked (gint32 vectors_ID);
gboolean gimp_vectors_set_linked (gint32 vectors_ID,
gboolean linked);
gboolean linked);
gint gimp_vectors_get_tattoo (gint32 vectors_ID);
gboolean gimp_vectors_set_tattoo (gint32 vectors_ID,
gint tattoo);
gint tattoo);
gint* gimp_vectors_get_strokes (gint32 vectors_ID,
gint *num_strokes);
gint *num_strokes);
gdouble gimp_vectors_stroke_get_length (gint32 vectors_ID,
gint stroke_id,
gdouble prescision);
gint stroke_id,
gdouble prescision);
gdouble gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID,
gint stroke_id,
gdouble dist,
gdouble prescision,
gdouble *y_point,
gdouble *slope,
gboolean *valid);
gint stroke_id,
gdouble dist,
gdouble prescision,
gdouble *y_point,
gdouble *slope,
gboolean *valid);
gboolean gimp_vectors_stroke_remove (gint32 vectors_ID,
gint stroke_id);
gint stroke_id);
gboolean gimp_vectors_stroke_close (gint32 vectors_ID,
gint stroke_id);
gint stroke_id);
gboolean gimp_vectors_stroke_translate (gint32 vectors_ID,
gint stroke_id,
gint off_x,
gint off_y);
gint stroke_id,
gint off_x,
gint off_y);
gboolean gimp_vectors_stroke_scale (gint32 vectors_ID,
gint stroke_id,
gdouble scale_x,
gdouble scale_y);
gint stroke_id,
gdouble scale_x,
gdouble scale_y);
gboolean gimp_vectors_stroke_interpolate (gint32 vectors_ID,
gint stroke_id,
gdouble prescision,
gint *num_coords,
gdouble **coords);
gint stroke_id,
gdouble prescision,
gint *num_coords,
gdouble **coords);
gint gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID,
gdouble x0,
gdouble y0);
gdouble x0,
gdouble y0);
gboolean gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
gint stroke_id,
gdouble x0,
gdouble y0);
gint stroke_id,
gdouble x0,
gdouble y0);
gboolean gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1);
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1);
gboolean gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2);
gint stroke_id,
gdouble x0,
gdouble y0,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2);
gint gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID,
gdouble x0,
gdouble y0,
gdouble radius_x,
gdouble radius_y,
gdouble angle);
gdouble x0,
gdouble y0,
gdouble radius_x,
gdouble radius_y,
gdouble angle);
G_END_DECLS

11
tools/pdbgen/lib.pl
View File

@ -157,7 +157,7 @@ sub generate {
$argdesc .= ": $desc";
# This is what's passed into gimp_run_procedure
$argpass .= "\n\t\t\t\t" . ' ' x 4;
$argpass .= "\n" . ' ' x 36;
$argpass .= "GIMP_PDB_$arg->{name}, ";
$argpass .= "$_->{name}";
@ -433,8 +433,7 @@ CODE
my $clist = $arglist;
my $padlen = length($wrapped) + length($funcname) + 2;
my $padtab = $padlen / 8; my $padspace = $padlen % 8;
my $padding = "\t" x $padtab . ' ' x $padspace;
my $padding = ' ' x $padlen;
$clist =~ s/\t/$padding/eg;
unless ($retdesc =~ /[\.\!\?]$/) { $retdesc .= '.' }
@ -476,8 +475,8 @@ $wrapped$funcname ($clist)
gint nreturn_vals;$return_args
return_vals = gimp_run_procedure ("gimp-$proc->{canonical_name}",
\&nreturn_vals,$argpass
GIMP_PDB_END);
\&nreturn_vals,$argpass
GIMP_PDB_END);
$return_marshal
}
@ -612,8 +611,6 @@ LGPL
$arg .= ' ' x ($longest[0] - length($type) + 1) . $func;
$arg .= ' ' x ($longest[1] - length($func) + 1) . $arglist;
$arg =~ s/\t/' ' x ($longest[0] + $longest[1] + 3)/eg;
while ($arg =~ /^\t* {8}/m) { $arg =~ s/^(\t*) {8}/$1\t/mg }
}
else {
$arg = $_;