procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 17:33:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

fixed bug 7744 and cleaned up libgimp

Browse source 
--Sven
This commit is contained in:
Sven Neumann 2000-03-25 18:49:05 +00:00
parent e85517dff8
commit 3a24f6d9b0
18 changed files with 691 additions and 649 deletions
Download patch file Download diff file Expand all files Collapse all files

24
ChangeLog
View file

@ -1,3 +1,27 @@
2000-03-25 Sven Neumann <sven@gimp.org>
* app/app_procs.c: use gtk_exit(0) instead of gtk_main_quit()
since there is a chance that the main loop is never entered.
Fixes bug #7744.
* app/main.c: cosmetic change
* libgimp/gimp.[ch]: (gimp_read_expect_msg) don't claim about
receiving a message of type GP_QUIT, simply execute it. Fixes a
warning that occured when calling gimp_quit from a plug_in.
Cleanup up the code a bit and changed gint to gboolean where
appropriate.
* libgimp/gimpchannel.c
* libgimp/gimpdrawable.c
* libgimp/gimpimage.c
* libgimp/gimpparasite.c: cleaned up and changed gint to gboolean
where appropriate.
* plug-ins/common/autocrop.c
* plug-ins/dbbrowser/dbbrowser_utils.c: removed unused variables
2000-03-25 Michael Natterer <mitch@gimp.org> 2000-03-25 Michael Natterer <mitch@gimp.org>
* app/cursorutil.[ch]: new global variable "gimp_busy" which gets * app/cursorutil.[ch]: new global variable "gimp_busy" which gets

6
app/app_procs.c
View file

@ -692,8 +692,10 @@ app_exit_finish (void)
save_sessionrc (); save_sessionrc ();
} }
/* gtk_exit (0); */ /* There used to be gtk_main_quit() here, but there's a chance
gtk_main_quit(); * that gtk_main() was never called before we reach this point. --Sven
*/
gtk_exit (0);
} }
void void

2
app/main.c
View file

@ -288,7 +288,7 @@ main (int argc,
g_print (_(" --no-xshm Do not use the X Shared Memory extension.\n")); g_print (_(" --no-xshm Do not use the X Shared Memory extension.\n"));
g_print (_(" --console-messages Display warnings to console instead of a dialog box.\n")); g_print (_(" --console-messages Display warnings to console instead of a dialog box.\n"));
g_print (_(" --debug-handlers Enable debugging signal handlers.\n")); g_print (_(" --debug-handlers Enable debugging signal handlers.\n"));
g_print (_(" --display <display> Use the designated X display.\n\n")); g_print (_(" --display <display> Use the designated X display.\n"));
g_print (_(" --system-gimprc <gimprc> Use an alternate system gimprc file.\n")); g_print (_(" --system-gimprc <gimprc> Use an alternate system gimprc file.\n"));
} }

269
libgimp/gimp.c
View file

@ -69,27 +69,27 @@
void gimp_extension_process (guint timeout); void gimp_extension_process (guint timeout);
void gimp_extension_ack (void); void gimp_extension_ack (void);
void gimp_read_expect_msg(WireMessage *msg, int type); void gimp_read_expect_msg (WireMessage *msg, gint type);
#ifndef G_OS_WIN32 #ifndef G_OS_WIN32
static RETSIGTYPE gimp_signal (int signum); static RETSIGTYPE gimp_signal (gint signum);
#endif #endif
static int gimp_write (GIOChannel *channel , guint8 *buf, gulong count); static int gimp_write (GIOChannel *channel , guint8 *buf, gulong count);
static int gimp_flush (GIOChannel *channel ); static int gimp_flush (GIOChannel *channel);
static void gimp_loop (void); static void gimp_loop (void);
static void gimp_config (GPConfig *config); static void gimp_config (GPConfig *config);
static void gimp_proc_run (GPProcRun *proc_run); static void gimp_proc_run (GPProcRun *proc_run);
static void gimp_temp_proc_run (GPProcRun *proc_run); static void gimp_temp_proc_run (GPProcRun *proc_run);
static void gimp_message_func (char *str); static void gimp_message_func (gchar *str);
static void gimp_process_message(WireMessage *msg); static void gimp_process_message (WireMessage *msg);
static void gimp_close (void); static void gimp_close (void);
GIOChannel *_readchannel = NULL; GIOChannel *_readchannel = NULL;
GIOChannel *_writechannel = NULL; GIOChannel *_writechannel = NULL;
int _shm_ID = -1; gint _shm_ID = -1;
guchar *_shm_addr = NULL; guchar *_shm_addr = NULL;
guint gimp_major_version = GIMP_MAJOR_VERSION; guint gimp_major_version = GIMP_MAJOR_VERSION;
@ -100,15 +100,15 @@ guint gimp_micro_version = GIMP_MICRO_VERSION;
static HANDLE shm_handle; static HANDLE shm_handle;
#endif #endif
static gdouble _gamma_val; static gdouble _gamma_val;
static gint _install_cmap; static gboolean _install_cmap;
static gint _use_xshm; static gboolean _use_xshm;
static guchar _color_cube[4]; static guchar _color_cube[4];
static gint _gdisp_ID = -1; static gint _gdisp_ID = -1;
static char *progname = NULL; static gchar *progname = NULL;
static guint8 write_buffer[WRITE_BUFFER_SIZE]; static guint8 write_buffer[WRITE_BUFFER_SIZE];
static guint write_buffer_index = 0; static guint write_buffer_index = 0;
static GHashTable *temp_proc_ht = NULL; static GHashTable *temp_proc_ht = NULL;
@ -284,9 +284,9 @@ gimp_quit (void)
} }
void void
gimp_set_data (gchar * id, gimp_set_data (gchar *id,
gpointer data, gpointer data,
guint32 length) guint32 length)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; int nreturn_vals;
@ -302,10 +302,10 @@ gimp_set_data (gchar * id,
} }
guint32 guint32
gimp_get_data_size (gchar * id) gimp_get_data_size (gchar *id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint32 length; guint32 length;
return_vals = gimp_run_procedure ("gimp_procedural_db_get_data_size", return_vals = gimp_run_procedure ("gimp_procedural_db_get_data_size",
@ -324,12 +324,12 @@ gimp_get_data_size (gchar * id)
void void
gimp_get_data (gchar * id, gimp_get_data (gchar *id,
gpointer data) gpointer data)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int length; gint length;
gchar *returned_data; gchar *returned_data;
return_vals = gimp_run_procedure ("gimp_procedural_db_get_data", return_vals = gimp_run_procedure ("gimp_procedural_db_get_data",
@ -353,7 +353,7 @@ void
gimp_progress_init (char *message) gimp_progress_init (char *message)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_progress_init", return_vals = gimp_run_procedure ("gimp_progress_init",
&nreturn_vals, &nreturn_vals,
@ -368,7 +368,7 @@ void
gimp_progress_update (gdouble percentage) gimp_progress_update (gdouble percentage)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_progress_update", return_vals = gimp_run_procedure ("gimp_progress_update",
&nreturn_vals, &nreturn_vals,
@ -389,7 +389,7 @@ void
gimp_message (const gchar *message) gimp_message (const gchar *message)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_message", return_vals = gimp_run_procedure ("gimp_message",
&nreturn_vals, &nreturn_vals,
@ -400,26 +400,26 @@ gimp_message (const gchar *message)
} }
static void static void
gimp_message_func (char *str) gimp_message_func (gchar *str)
{ {
gimp_message (str); gimp_message (str);
} }
void void
gimp_query_database (char *name_regexp, gimp_query_database (gchar *name_regexp,
char *blurb_regexp, gchar *blurb_regexp,
char *help_regexp, gchar *help_regexp,
char *author_regexp, gchar *author_regexp,
char *copyright_regexp, gchar *copyright_regexp,
char *date_regexp, gchar *date_regexp,
char *proc_type_regexp, gchar *proc_type_regexp,
int *nprocs, gint *nprocs,
char ***proc_names) gchar ***proc_names)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int i; gint i;
return_vals = gimp_run_procedure ("gimp_procedural_db_query", return_vals = gimp_run_procedure ("gimp_procedural_db_query",
&nreturn_vals, &nreturn_vals,
@ -447,23 +447,23 @@ gimp_query_database (char *name_regexp,
gimp_destroy_params (return_vals, nreturn_vals); gimp_destroy_params (return_vals, nreturn_vals);
} }
gint gboolean
gimp_query_procedure (char *proc_name, gimp_query_procedure (gchar *proc_name,
char **proc_blurb, gchar **proc_blurb,
char **proc_help, gchar **proc_help,
char **proc_author, gchar **proc_author,
char **proc_copyright, gchar **proc_copyright,
char **proc_date, gchar **proc_date,
int *proc_type, gint *proc_type,
int *nparams, gint *nparams,
int *nreturn_vals, gint *nreturn_vals,
GParamDef **params, GParamDef **params,
GParamDef **return_vals) GParamDef **return_vals)
{ {
GParam *ret_vals; GParam *ret_vals;
int nret_vals; gint nret_vals;
int i; gint i;
int success = TRUE; gboolean success = TRUE;
ret_vals = gimp_run_procedure ("gimp_procedural_db_proc_info", ret_vals = gimp_run_procedure ("gimp_procedural_db_proc_info",
&nret_vals, &nret_vals,
@ -486,7 +486,7 @@ gimp_query_procedure (char *proc_name,
for (i = 0; i < *nparams; i++) for (i = 0; i < *nparams; i++)
{ {
GParam *rvals; GParam *rvals;
int nrvals; gint nrvals;
rvals = gimp_run_procedure ("gimp_procedural_db_proc_arg", rvals = gimp_run_procedure ("gimp_procedural_db_proc_arg",
&nrvals, &nrvals,
@ -548,10 +548,10 @@ gimp_query_procedure (char *proc_name,
} }
gint32* gint32*
gimp_query_images (int *nimages) gimp_query_images (gint *nimages)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 *images; gint32 *images;
return_vals = gimp_run_procedure ("gimp_image_list", return_vals = gimp_run_procedure ("gimp_image_list",
@ -572,17 +572,17 @@ gimp_query_images (int *nimages)
} }
void void
gimp_install_procedure (char *name, gimp_install_procedure (gchar *name,
char *blurb, gchar *blurb,
char *help, gchar *help,
char *author, gchar *author,
char *copyright, gchar *copyright,
char *date, gchar *date,
char *menu_path, gchar *menu_path,
char *image_types, gchar *image_types,
int type, gint type,
int nparams, gint nparams,
int nreturn_vals, gint nreturn_vals,
GParamDef *params, GParamDef *params,
GParamDef *return_vals) GParamDef *return_vals)
{ {
@ -607,17 +607,17 @@ gimp_install_procedure (char *name,
} }
void void
gimp_install_temp_proc (char *name, gimp_install_temp_proc (gchar *name,
char *blurb, gchar *blurb,
char *help, gchar *help,
char *author, gchar *author,
char *copyright, gchar *copyright,
char *date, gchar *date,
char *menu_path, gchar *menu_path,
char *image_types, gchar *image_types,
int type, gint type,
int nparams, gint nparams,
int nreturn_vals, gint nreturn_vals,
GParamDef *params, GParamDef *params,
GParamDef *return_vals, GParamDef *return_vals,
GRunProc run_proc) GRunProc run_proc)
@ -631,7 +631,7 @@ gimp_install_temp_proc (char *name,
} }
void void
gimp_uninstall_temp_proc (char *name) gimp_uninstall_temp_proc (gchar *name)
{ {
GPProcUninstall proc_uninstall; GPProcUninstall proc_uninstall;
gpointer hash_name; gpointer hash_name;
@ -650,13 +650,13 @@ gimp_uninstall_temp_proc (char *name)
} }
void void
gimp_register_magic_load_handler (char *name, gimp_register_magic_load_handler (gchar *name,
char *extensions, gchar *extensions,
char *prefixes, gchar *prefixes,
char *magics) gchar *magics)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_register_magic_load_handler", return_vals = gimp_run_procedure ("gimp_register_magic_load_handler",
&nreturn_vals, &nreturn_vals,
@ -670,12 +670,12 @@ gimp_register_magic_load_handler (char *name,
} }
void void
gimp_register_load_handler (char *name, gimp_register_load_handler (gchar *name,
char *extensions, gchar *extensions,
char *prefixes) gchar *prefixes)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_register_load_handler", return_vals = gimp_run_procedure ("gimp_register_load_handler",
&nreturn_vals, &nreturn_vals,
@ -688,12 +688,12 @@ gimp_register_load_handler (char *name,
} }
void void
gimp_register_save_handler (char *name, gimp_register_save_handler (gchar *name,
char *extensions, gchar *extensions,
char *prefixes) gchar *prefixes)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_register_save_handler", return_vals = gimp_run_procedure ("gimp_register_save_handler",
&nreturn_vals, &nreturn_vals,
@ -706,8 +706,8 @@ gimp_register_save_handler (char *name,
} }
GParam* GParam*
gimp_run_procedure (char *name, gimp_run_procedure (gchar *name,
int *nreturn_vals, gint *nreturn_vals,
...) ...)
{ {
GPProcRun proc_run; GPProcRun proc_run;
@ -717,7 +717,7 @@ gimp_run_procedure (char *name,
GParam *return_vals; GParam *return_vals;
va_list args; va_list args;
guchar *color; guchar *color;
int i; gint i;
proc_run.name = name; proc_run.name = name;
proc_run.nparams = 0; proc_run.nparams = 0;
@ -888,7 +888,7 @@ gimp_run_procedure (char *name,
if (!gp_proc_run_write (_writechannel, &proc_run)) if (!gp_proc_run_write (_writechannel, &proc_run))
gimp_quit (); gimp_quit ();
gimp_read_expect_msg(&msg,GP_PROC_RETURN); gimp_read_expect_msg (&msg, GP_PROC_RETURN);
proc_return = msg.data; proc_return = msg.data;
*nreturn_vals = proc_return->nparams; *nreturn_vals = proc_return->nparams;
@ -914,18 +914,19 @@ gimp_run_procedure (char *name,
} }
void void
gimp_read_expect_msg(WireMessage *msg, int type) gimp_read_expect_msg (WireMessage *msg,
gint type)
{ {
while(1) while (TRUE)
{ {
if (!wire_read_msg (_readchannel, msg)) if (!wire_read_msg (_readchannel, msg))
gimp_quit (); gimp_quit ();
if (msg->type != type) if (msg->type != type)
{ {
if(msg->type == GP_TEMP_PROC_RUN) if (msg->type == GP_TEMP_PROC_RUN || msg->type == GP_QUIT)
{ {
gimp_process_message(msg); gimp_process_message (msg);
continue; continue;
} }
else else
@ -938,9 +939,9 @@ gimp_read_expect_msg(WireMessage *msg, int type)
GParam* GParam*
gimp_run_procedure2 (char *name, gimp_run_procedure2 (gchar *name,
int *nreturn_vals, gint *nreturn_vals,
int nparams, gint nparams,
GParam *params) GParam *params)
{ {
GPProcRun proc_run; GPProcRun proc_run;
@ -981,16 +982,16 @@ gimp_run_procedure2 (char *name,
void void
gimp_destroy_params (GParam *params, gimp_destroy_params (GParam *params,
int nparams) gint nparams)
{ {
extern void _gp_params_destroy (GPParam *params, int nparams); extern void _gp_params_destroy (GPParam *params, gint nparams);
_gp_params_destroy ((GPParam*) params, nparams); _gp_params_destroy ((GPParam*) params, nparams);
} }
void void
gimp_destroy_paramdefs (GParamDef *paramdefs, gimp_destroy_paramdefs (GParamDef *paramdefs,
int nparams) gint nparams)
{ {
while (nparams--) while (nparams--)
{ {
@ -1002,31 +1003,31 @@ gimp_destroy_paramdefs (GParamDef *paramdefs,
} }
gdouble gdouble
gimp_gamma () gimp_gamma (void)
{ {
return _gamma_val; return _gamma_val;
} }
gint gboolean
gimp_install_cmap () gimp_install_cmap (void)
{ {
return _install_cmap; return _install_cmap;
} }
gint gboolean
gimp_use_xshm () gimp_use_xshm (void)
{ {
return _use_xshm; return _use_xshm;
} }
guchar* guchar*
gimp_color_cube () gimp_color_cube (void)
{ {
return _color_cube; return _color_cube;
} }
static void static void
gimp_process_message(WireMessage *msg) gimp_process_message (WireMessage *msg)
{ {
switch (msg->type) switch (msg->type)
{ {
@ -1060,7 +1061,7 @@ gimp_process_message(WireMessage *msg)
} }
static void static void
gimp_single_message() gimp_single_message (void)
{ {
WireMessage msg; WireMessage msg;
@ -1068,7 +1069,7 @@ gimp_single_message()
if (!wire_read_msg (_readchannel, &msg)) if (!wire_read_msg (_readchannel, &msg))
gimp_quit (); gimp_quit ();
gimp_process_message(&msg); gimp_process_message (&msg);
wire_destroy (&msg); wire_destroy (&msg);
} }
@ -1078,7 +1079,7 @@ gimp_extension_process (guint timeout)
{ {
#ifndef G_OS_WIN32 #ifndef G_OS_WIN32
fd_set readfds; fd_set readfds;
int select_val; gint select_val;
struct timeval tv; struct timeval tv;
struct timeval *tvp; struct timeval *tvp;
@ -1145,14 +1146,14 @@ gimp_request_wakeups (void)
#ifndef G_OS_WIN32 #ifndef G_OS_WIN32
static RETSIGTYPE static RETSIGTYPE
gimp_signal (int signum) gimp_signal (gint signum)
{ {
static int caught_fatal_sig = 0; static gboolean caught_fatal_sig = FALSE;
if (caught_fatal_sig) if (caught_fatal_sig)
kill (getpid (), signum); kill (getpid (), signum);
caught_fatal_sig = 1; caught_fatal_sig = TRUE;
fprintf (stderr, "\n%s: %s caught\n", progname, g_strsignal (signum)); fprintf (stderr, "\n%s: %s caught\n", progname, g_strsignal (signum));
@ -1179,7 +1180,9 @@ gimp_signal (int signum)
#endif #endif
static int static int
gimp_write (GIOChannel *channel, guint8 *buf, gulong count) gimp_write (GIOChannel *channel,
guint8 *buf,
gulong count)
{ {
gulong bytes; gulong bytes;
@ -1239,11 +1242,11 @@ gimp_flush (GIOChannel *channel)
} }
static void static void
gimp_loop () gimp_loop (void)
{ {
WireMessage msg; WireMessage msg;
while (1) while (TRUE)
{ {
if (!wire_read_msg (_readchannel, &msg)) if (!wire_read_msg (_readchannel, &msg))
{ {
@ -1324,8 +1327,8 @@ gimp_config (GPConfig *config)
* Use Win32 shared memory mechanisms for * Use Win32 shared memory mechanisms for
* transfering tile data * transfering tile data
*/ */
char fileMapName[128]; gchar fileMapName[128];
int tileByteSize = _gimp_tile_width * _gimp_tile_height * 4; gint tileByteSize = _gimp_tile_width * _gimp_tile_height * 4;
/* From the id, derive the file map name */ /* From the id, derive the file map name */
sprintf(fileMapName, "GIMP%d.SHM", _shm_ID); sprintf(fileMapName, "GIMP%d.SHM", _shm_ID);
@ -1368,7 +1371,7 @@ gimp_proc_run (GPProcRun *proc_run)
{ {
GPProcReturn proc_return; GPProcReturn proc_return;
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
if (PLUG_IN_INFO.run_proc) if (PLUG_IN_INFO.run_proc)
{ {
@ -1391,7 +1394,7 @@ static void
gimp_temp_proc_run (GPProcRun *proc_run) gimp_temp_proc_run (GPProcRun *proc_run)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
GRunProc run_proc; GRunProc run_proc;
run_proc = (GRunProc)g_hash_table_lookup (temp_proc_ht, (gpointer) proc_run->name); run_proc = (GRunProc)g_hash_table_lookup (temp_proc_ht, (gpointer) proc_run->name);
@ -1418,7 +1421,7 @@ void
gimp_plugin_domain_add (gchar *domain_name) gimp_plugin_domain_add (gchar *domain_name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_plugin_domain_add", return_vals = gimp_run_procedure ("gimp_plugin_domain_add",
&nreturn_vals, &nreturn_vals,
@ -1434,7 +1437,7 @@ gimp_plugin_domain_add_with_path (gchar *domain_name,
gchar *domain_path) gchar *domain_path)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_plugin_domain_add", return_vals = gimp_run_procedure ("gimp_plugin_domain_add",
&nreturn_vals, &nreturn_vals,

286
libgimp/gimp.h
View file

@ -66,10 +66,10 @@ typedef struct _GParamColor GParamColor;
typedef struct _GParamRegion GParamRegion; typedef struct _GParamRegion GParamRegion;
typedef union _GParamData GParamData; typedef union _GParamData GParamData;
typedef struct _GParam GParam; typedef struct _GParam GParam;
typedef void (* GRunProc) (char *name, typedef void (* GRunProc) (gchar *name,
int nparams, gint nparams,
GParam *param, GParam *param,
int *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GParam **return_vals);
@ -134,8 +134,8 @@ struct _GPixelRgn
struct _GParamDef struct _GParamDef
{ {
GParamType type; GParamType type;
char *name; gchar *name;
char *description; gchar *description;
}; };
struct _GParamColor struct _GParamColor
@ -300,108 +300,108 @@ void gimp_message (const gchar *message);
* The arguments are regular expressions which select * The arguments are regular expressions which select
* which procedure names will be returned in 'proc_names'. * which procedure names will be returned in 'proc_names'.
*/ */
void gimp_query_database (char *name_regexp, void gimp_query_database (gchar *name_regexp,
char *blurb_regexp, gchar *blurb_regexp,
char *help_regexp, gchar *help_regexp,
char *author_regexp, gchar *author_regexp,
char *copyright_regexp, gchar *copyright_regexp,
char *date_regexp, gchar *date_regexp,
char *proc_type_regexp, gchar *proc_type_regexp,
int *nprocs, gint *nprocs,
char ***proc_names); gchar ***proc_names);
/* Query the gimp application's procedural database /* Query the gimp application's procedural database
* regarding a particular procedure. * regarding a particular procedure.
*/ */
gint gimp_query_procedure (char *proc_name, gboolean gimp_query_procedure (gchar *proc_name,
char **proc_blurb, gchar **proc_blurb,
char **proc_help, gchar **proc_help,
char **proc_author, gchar **proc_author,
char **proc_copyright, gchar **proc_copyright,
char **proc_date, gchar **proc_date,
int *proc_type, gint *proc_type,
int *nparams, gint *nparams,
int *nreturn_vals, gint *nreturn_vals,
GParamDef **params, GParamDef **params,
GParamDef **return_vals); GParamDef **return_vals);
/* Query the gimp application regarding all open images. /* Query the gimp application regarding all open images.
* The list of open image id's is returned in 'image_ids'. * The list of open image id's is returned in 'image_ids'.
*/ */
gint32* gimp_query_images (int *nimages); gint32* gimp_query_images (gint *nimages);
/* Install a procedure in the procedure database. /* Install a procedure in the procedure database.
*/ */
void gimp_install_procedure (char *name, void gimp_install_procedure (gchar *name,
char *blurb, gchar *blurb,
char *help, gchar *help,
char *author, gchar *author,
char *copyright, gchar *copyright,
char *date, gchar *date,
char *menu_path, gchar *menu_path,
char *image_types, gchar *image_types,
int type, gint type,
int nparams, gint nparams,
int nreturn_vals, gint nreturn_vals,
GParamDef *params, GParamDef *params,
GParamDef *return_vals); GParamDef *return_vals);
/* Install a temporary procedure in the procedure database. /* Install a temporary procedure in the procedure database.
*/ */
void gimp_install_temp_proc (char *name, void gimp_install_temp_proc (gchar *name,
char *blurb, gchar *blurb,
char *help, gchar *help,
char *author, gchar *author,
char *copyright, gchar *copyright,
char *date, gchar *date,
char *menu_path, gchar *menu_path,
char *image_types, gchar *image_types,
int type, gint type,
int nparams, gint nparams,
int nreturn_vals, gint nreturn_vals,
GParamDef *params, GParamDef *params,
GParamDef *return_vals, GParamDef *return_vals,
GRunProc run_proc); GRunProc run_proc);
/* Uninstall a temporary procedure /* Uninstall a temporary procedure
*/ */
void gimp_uninstall_temp_proc (char *name); void gimp_uninstall_temp_proc (gchar *name);
/* Install a load file format handler in the procedure database. /* Install a load file format handler in the procedure database.
*/ */
void gimp_register_magic_load_handler (char *name, void gimp_register_magic_load_handler (gchar *name,
char *extensions, gchar *extensions,
char *prefixes, gchar *prefixes,
char *magics); gchar *magics);
/* Install a load file format handler in the procedure database. /* Install a load file format handler in the procedure database.
*/ */
void gimp_register_load_handler (char *name, void gimp_register_load_handler (gchar *name,
char *extensions, gchar *extensions,
char *prefixes); gchar *prefixes);
/* Install a save file format handler in the procedure database. /* Install a save file format handler in the procedure database.
*/ */
void gimp_register_save_handler (char *name, void gimp_register_save_handler (gchar *name,
char *extensions, gchar *extensions,
char *prefixes); gchar *prefixes);
/* Run a procedure in the procedure database. The parameters are /* Run a procedure in the procedure database. The parameters are
* specified via the variable length argument list. The return * specified via the variable length argument list. The return
* values are returned in the 'GParam*' array. * values are returned in the 'GParam*' array.
*/ */
GParam* gimp_run_procedure (char *name, GParam* gimp_run_procedure (gchar *name,
int *nreturn_vals, gint *nreturn_vals,
...); ...);
/* Run a procedure in the procedure database. The parameters are /* Run a procedure in the procedure database. The parameters are
* specified as an array of GParam. The return * specified as an array of GParam. The return
* values are returned in the 'GParam*' array. * values are returned in the 'GParam*' array.
*/ */
GParam* gimp_run_procedure2 (char *name, GParam* gimp_run_procedure2 (gchar *name,
int *nreturn_vals, gint *nreturn_vals,
int nparams, gint nparams,
GParam *params); GParam *params);
/* Destroy the an array of parameters. This is useful for /* Destroy the an array of parameters. This is useful for
@ -409,19 +409,19 @@ GParam* gimp_run_procedure2 (char *name,
* 'gimp_run_procedure'. * 'gimp_run_procedure'.
*/ */
void gimp_destroy_params (GParam *params, void gimp_destroy_params (GParam *params,
int nparams); gint nparams);
/* Destroy the an array of GParamDef's. This is useful for /* Destroy the an array of GParamDef's. This is useful for
* destroying the return values returned by a call to * destroying the return values returned by a call to
* 'gimp_query_procedure'. * 'gimp_query_procedure'.
*/ */
void gimp_destroy_paramdefs (GParamDef *paramdefs, void gimp_destroy_paramdefs (GParamDef *paramdefs,
int nparams); gint nparams);
gdouble gimp_gamma (void); gdouble gimp_gamma (void);
gint gimp_install_cmap (void); gboolean gimp_install_cmap (void);
gint gimp_use_xshm (void); gboolean gimp_use_xshm (void);
guchar* gimp_color_cube (void); guchar* gimp_color_cube (void);
void gimp_request_wakeups (void); void gimp_request_wakeups (void);
@ -487,11 +487,11 @@ gint32* gimp_image_get_channels (gint32 image_ID,
gint *nchannels); gint *nchannels);
guchar* gimp_image_get_cmap (gint32 image_ID, guchar* gimp_image_get_cmap (gint32 image_ID,
gint *ncolors); gint *ncolors);
gint gimp_image_get_component_active (gint32 image_ID, gboolean gimp_image_get_component_active (gint32 image_ID,
gint component); gint component);
gint gimp_image_get_component_visible (gint32 image_ID, gboolean gimp_image_get_component_visible (gint32 image_ID,
gint component); gint component);
char* gimp_image_get_filename (gint32 image_ID); gchar* gimp_image_get_filename (gint32 image_ID);
gint32* gimp_image_get_layers (gint32 image_ID, gint32* gimp_image_get_layers (gint32 image_ID,
gint *nlayers); gint *nlayers);
gint32 gimp_image_get_selection (gint32 image_ID); gint32 gimp_image_get_selection (gint32 image_ID);
@ -504,23 +504,23 @@ void gimp_image_set_cmap (gint32 image_ID,
gint ncolors); gint ncolors);
void gimp_image_set_component_active (gint32 image_ID, void gimp_image_set_component_active (gint32 image_ID,
gint component, gint component,
gint active); gboolean active);
void gimp_image_set_component_visible (gint32 image_ID, void gimp_image_set_component_visible (gint32 image_ID,
gint component, gint component,
gint visible); gboolean visible);
void gimp_image_set_filename (gint32 image_ID, void gimp_image_set_filename (gint32 image_ID,
char *name); gchar *name);
Parasite *gimp_image_parasite_find (gint32 image_ID, Parasite *gimp_image_parasite_find (gint32 image_ID,
const char *name); const gchar *name);
void gimp_image_parasite_attach (gint32 image_ID, void gimp_image_parasite_attach (gint32 image_ID,
const Parasite *p); const Parasite *p);
void gimp_image_attach_new_parasite (gint32 image_ID, void gimp_image_attach_new_parasite (gint32 image_ID,
const char *name, const gchar *name,
int flags, gint flags,
int size, gint size,
const void *data); const gpointer data);
void gimp_image_parasite_detach (gint32 image_ID, void gimp_image_parasite_detach (gint32 image_ID,
const char *name); const gchar *name);
void gimp_image_set_resolution (gint32 image_ID, void gimp_image_set_resolution (gint32 image_ID,
double xresolution, double xresolution,
double yresolution); double yresolution);
@ -645,39 +645,39 @@ gint32 gimp_layer_get_tattoo (gint32 layer_ID);
* Channels * * Channels *
****************************************/ ****************************************/
gint32 gimp_channel_new (gint32 image_ID, gint32 gimp_channel_new (gint32 image_ID,
char *name, gchar *name,
guint width, guint width,
guint height, guint height,
gdouble opacity, gdouble opacity,
guchar *color); guchar *color);
gint32 gimp_channel_copy (gint32 channel_ID); gint32 gimp_channel_copy (gint32 channel_ID);
void gimp_channel_delete (gint32 channel_ID); void gimp_channel_delete (gint32 channel_ID);
guint gimp_channel_width (gint32 channel_ID); guint gimp_channel_width (gint32 channel_ID);
guint gimp_channel_height (gint32 channel_ID); guint gimp_channel_height (gint32 channel_ID);
gint32 gimp_channel_get_image_id (gint32 channel_ID); gint32 gimp_channel_get_image_id (gint32 channel_ID);
gint32 gimp_channel_get_layer_id (gint32 channel_ID); gint32 gimp_channel_get_layer_id (gint32 channel_ID);
void gimp_channel_get_color (gint32 channel_ID, void gimp_channel_get_color (gint32 channel_ID,
guchar *red, guchar *red,
guchar *green, guchar *green,
guchar *blue); guchar *blue);
char* gimp_channel_get_name (gint32 channel_ID); gchar* gimp_channel_get_name (gint32 channel_ID);
gdouble gimp_channel_get_opacity (gint32 channel_ID); gdouble gimp_channel_get_opacity (gint32 channel_ID);
gint gimp_channel_get_show_masked (gint32 channel_ID); gint gimp_channel_get_show_masked (gint32 channel_ID);
gint gimp_channel_get_visible (gint32 channel_ID); gboolean gimp_channel_get_visible (gint32 channel_ID);
void gimp_channel_set_color (gint32 channel_ID, void gimp_channel_set_color (gint32 channel_ID,
guchar red, guchar red,
guchar green, guchar green,
guchar blue); guchar blue);
void gimp_channel_set_name (gint32 channel_ID, void gimp_channel_set_name (gint32 channel_ID,
char *name); gchar *name);
void gimp_channel_set_opacity (gint32 channel_ID, void gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity); gdouble opacity);
void gimp_channel_set_show_masked (gint32 channel_ID, void gimp_channel_set_show_masked (gint32 channel_ID,
gint show_masked); gint show_masked);
void gimp_channel_set_visible (gint32 channel_ID, void gimp_channel_set_visible (gint32 channel_ID,
gint visible); gboolean visible);
gint32 gimp_channel_get_tattoo (gint32 channel_ID); gint32 gimp_channel_get_tattoo (gint32 channel_ID);
/**************************************** /****************************************
@ -696,20 +696,20 @@ void gimp_drawable_update (gint32 drawable_ID,
void gimp_drawable_merge_shadow (gint32 drawable_ID, void gimp_drawable_merge_shadow (gint32 drawable_ID,
gint undoable); gint undoable);
gint32 gimp_drawable_image_id (gint32 drawable_ID); gint32 gimp_drawable_image_id (gint32 drawable_ID);
char* gimp_drawable_name (gint32 drawable_ID); gchar* gimp_drawable_name (gint32 drawable_ID);
guint gimp_drawable_width (gint32 drawable_ID); guint gimp_drawable_width (gint32 drawable_ID);
guint gimp_drawable_height (gint32 drawable_ID); guint gimp_drawable_height (gint32 drawable_ID);
guint gimp_drawable_bpp (gint32 drawable_ID); guint gimp_drawable_bpp (gint32 drawable_ID);
GDrawableType gimp_drawable_type (gint32 drawable_ID); GDrawableType gimp_drawable_type (gint32 drawable_ID);
gint gimp_drawable_visible (gint32 drawable_ID); gboolean gimp_drawable_visible (gint32 drawable_ID);
gint gimp_drawable_is_channel (gint32 drawable_ID); gboolean gimp_drawable_is_channel (gint32 drawable_ID);
gint gimp_drawable_is_rgb (gint32 drawable_ID); gboolean gimp_drawable_is_rgb (gint32 drawable_ID);
gint gimp_drawable_is_gray (gint32 drawable_ID); gboolean gimp_drawable_is_gray (gint32 drawable_ID);
gint gimp_drawable_has_alpha (gint32 drawable_ID); gboolean gimp_drawable_has_alpha (gint32 drawable_ID);
gint gimp_drawable_is_indexed (gint32 drawable_ID); gboolean gimp_drawable_is_indexed (gint32 drawable_ID);
gint gimp_drawable_is_layer (gint32 drawable_ID); gboolean gimp_drawable_is_layer (gint32 drawable_ID);
gint gimp_drawable_is_layer_mask(gint32 drawable_ID); gboolean gimp_drawable_is_layer_mask(gint32 drawable_ID);
gint gimp_drawable_mask_bounds (gint32 drawable_ID, gboolean gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1, gint *x1,
gint *y1, gint *y1,
gint *x2, gint *x2,
@ -732,14 +732,14 @@ GTile* gimp_drawable_get_tile2 (GDrawable *drawable,
gint x, gint x,
gint y); gint y);
Parasite* gimp_drawable_parasite_find (gint32 drawable, Parasite* gimp_drawable_parasite_find (gint32 drawable,
const char *name); const gchar *name);
void gimp_drawable_parasite_attach (gint32 drawable, void gimp_drawable_parasite_attach (gint32 drawable,
const Parasite *p); const Parasite *p);
void gimp_drawable_attach_new_parasite (gint32 drawable, void gimp_drawable_attach_new_parasite (gint32 drawable,
const char *name, const gchar *name,
int flags, gint flags,
int size, gint size,
const void *data); const gpointer data);
void gimp_drawable_parasite_detach (gint32 drawable, void gimp_drawable_parasite_detach (gint32 drawable,
const char *name); const char *name);
guchar* gimp_drawable_get_thumbnail_data (gint32 drawable_ID, guchar* gimp_drawable_get_thumbnail_data (gint32 drawable_ID,
@ -773,7 +773,7 @@ void gimp_selection_none (gint32 image_ID);
void gimp_tile_ref (GTile *tile); void gimp_tile_ref (GTile *tile);
void gimp_tile_ref_zero (GTile *tile); void gimp_tile_ref_zero (GTile *tile);
void gimp_tile_unref (GTile *tile, void gimp_tile_unref (GTile *tile,
int dirty); gint dirty);
void gimp_tile_flush (GTile *tile); void gimp_tile_flush (GTile *tile);
void gimp_tile_cache_size (gulong kilobytes); void gimp_tile_cache_size (gulong kilobytes);
void gimp_tile_cache_ntiles (gulong ntiles); void gimp_tile_cache_ntiles (gulong ntiles);
@ -866,8 +866,8 @@ void gimp_palette_set_foreground (guchar red,
* Gradients * * Gradients *
****************************************/ ****************************************/
char** gimp_gradients_get_list (gint *num_gradients); gchar** gimp_gradients_get_list (gint *num_gradients);
char* gimp_gradients_get_active (void); gchar* gimp_gradients_get_active (void);
void gimp_gradients_set_active (char *name); void gimp_gradients_set_active (char *name);
gdouble* gimp_gradients_sample_uniform (gint num_samples); gdouble* gimp_gradients_sample_uniform (gint num_samples);
gdouble* gimp_gradients_sample_custom (gint num_samples, gdouble* gimp_gradients_sample_custom (gint num_samples,
@ -877,13 +877,13 @@ gdouble* gimp_gradients_sample_custom (gint num_samples,
* Parasites * * Parasites *
****************************************/ ****************************************/
Parasite *gimp_parasite_find (const char *name); Parasite *gimp_parasite_find (const gchar *name);
void gimp_parasite_attach (const Parasite *p); void gimp_parasite_attach (const Parasite *p);
void gimp_attach_new_parasite (const char *name, void gimp_attach_new_parasite (const gchar *name,
int flags, gint flags,
int size, gint size,
const void *data); const gpointer data);
void gimp_parasite_detach (const char *name); void gimp_parasite_detach (const gchar *name);
/**************************************** /****************************************
* Help * * Help *

52
libgimp/gimpchannel.c
View file

@ -21,14 +21,14 @@
gint32 gint32
gimp_channel_new (gint32 image_ID, gimp_channel_new (gint32 image_ID,
char *name, gchar *name,
guint width, guint width,
guint height, guint height,
gdouble opacity, gdouble opacity,
guchar *color) guchar *color)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 channel_ID; gint32 channel_ID;
return_vals = gimp_run_procedure ("gimp_channel_new", return_vals = gimp_run_procedure ("gimp_channel_new",
@ -54,7 +54,7 @@ gint32
gimp_channel_copy (gint32 channel_ID) gimp_channel_copy (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_copy", return_vals = gimp_run_procedure ("gimp_channel_copy",
&nreturn_vals, &nreturn_vals,
@ -74,7 +74,7 @@ void
gimp_channel_delete (gint32 channel_ID) gimp_channel_delete (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_delete", return_vals = gimp_run_procedure ("gimp_channel_delete",
&nreturn_vals, &nreturn_vals,
@ -115,7 +115,7 @@ gimp_channel_get_color (gint32 channel_ID,
guchar *blue) guchar *blue)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_get_color", return_vals = gimp_run_procedure ("gimp_channel_get_color",
&nreturn_vals, &nreturn_vals,
@ -132,12 +132,12 @@ gimp_channel_get_color (gint32 channel_ID,
gimp_destroy_params (return_vals, nreturn_vals); gimp_destroy_params (return_vals, nreturn_vals);
} }
char* gchar*
gimp_channel_get_name (gint32 channel_ID) gimp_channel_get_name (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
char *name; gchar *name;
return_vals = gimp_run_procedure ("gimp_channel_get_name", return_vals = gimp_run_procedure ("gimp_channel_get_name",
&nreturn_vals, &nreturn_vals,
@ -157,7 +157,7 @@ gdouble
gimp_channel_get_opacity (gint32 channel_ID) gimp_channel_get_opacity (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gdouble opacity; gdouble opacity;
return_vals = gimp_run_procedure ("gimp_channel_get_opacity", return_vals = gimp_run_procedure ("gimp_channel_get_opacity",
@ -174,19 +174,19 @@ gimp_channel_get_opacity (gint32 channel_ID)
return opacity; return opacity;
} }
gint gboolean
gimp_channel_get_visible (gint32 channel_ID) gimp_channel_get_visible (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int visible; gboolean visible;
return_vals = gimp_run_procedure ("gimp_channel_get_visible", return_vals = gimp_run_procedure ("gimp_channel_get_visible",
&nreturn_vals, &nreturn_vals,
PARAM_CHANNEL, channel_ID, PARAM_CHANNEL, channel_ID,
PARAM_END); PARAM_END);
visible = -1; visible = FALSE;
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == STATUS_SUCCESS)
visible = return_vals[1].data.d_int32; visible = return_vals[1].data.d_int32;
@ -202,7 +202,7 @@ gimp_channel_set_color (gint32 channel_ID,
guchar blue) guchar blue)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar color[3]; guchar color[3];
color[0] = red; color[0] = red;
@ -220,10 +220,10 @@ gimp_channel_set_color (gint32 channel_ID,
void void
gimp_channel_set_name (gint32 channel_ID, gimp_channel_set_name (gint32 channel_ID,
char *name) gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_name", return_vals = gimp_run_procedure ("gimp_channel_set_name",
&nreturn_vals, &nreturn_vals,
@ -239,7 +239,7 @@ gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity) gdouble opacity)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_opacity", return_vals = gimp_run_procedure ("gimp_channel_set_opacity",
&nreturn_vals, &nreturn_vals,
@ -251,11 +251,11 @@ gimp_channel_set_opacity (gint32 channel_ID,
} }
void void
gimp_channel_set_visible (gint32 channel_ID, gimp_channel_set_visible (gint32 channel_ID,
gint visible) gboolean visible)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_visible", return_vals = gimp_run_procedure ("gimp_channel_set_visible",
&nreturn_vals, &nreturn_vals,
@ -270,8 +270,8 @@ gint
gimp_channel_get_show_masked (gint32 channel_ID) gimp_channel_get_show_masked (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int show_masked; gint show_masked;
return_vals = gimp_run_procedure ("gimp_channel_get_show_masked", return_vals = gimp_run_procedure ("gimp_channel_get_show_masked",
&nreturn_vals, &nreturn_vals,
@ -292,7 +292,7 @@ gimp_channel_set_show_masked (gint32 channel_ID,
gint show_masked) gint show_masked)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_show_masked", return_vals = gimp_run_procedure ("gimp_channel_set_show_masked",
&nreturn_vals, &nreturn_vals,
@ -307,8 +307,8 @@ gint32
gimp_channel_get_tattoo (gint32 channel_ID) gimp_channel_get_tattoo (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int tattoo; gint tattoo;
return_vals = gimp_run_procedure ("gimp_channel_get_tattoo", return_vals = gimp_run_procedure ("gimp_channel_get_tattoo",
&nreturn_vals, &nreturn_vals,

52
libgimp/gimpchannel_pdb.c
View file

@ -21,14 +21,14 @@
gint32 gint32
gimp_channel_new (gint32 image_ID, gimp_channel_new (gint32 image_ID,
char *name, gchar *name,
guint width, guint width,
guint height, guint height,
gdouble opacity, gdouble opacity,
guchar *color) guchar *color)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 channel_ID; gint32 channel_ID;
return_vals = gimp_run_procedure ("gimp_channel_new", return_vals = gimp_run_procedure ("gimp_channel_new",
@ -54,7 +54,7 @@ gint32
gimp_channel_copy (gint32 channel_ID) gimp_channel_copy (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_copy", return_vals = gimp_run_procedure ("gimp_channel_copy",
&nreturn_vals, &nreturn_vals,
@ -74,7 +74,7 @@ void
gimp_channel_delete (gint32 channel_ID) gimp_channel_delete (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_delete", return_vals = gimp_run_procedure ("gimp_channel_delete",
&nreturn_vals, &nreturn_vals,
@ -115,7 +115,7 @@ gimp_channel_get_color (gint32 channel_ID,
guchar *blue) guchar *blue)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_get_color", return_vals = gimp_run_procedure ("gimp_channel_get_color",
&nreturn_vals, &nreturn_vals,
@ -132,12 +132,12 @@ gimp_channel_get_color (gint32 channel_ID,
gimp_destroy_params (return_vals, nreturn_vals); gimp_destroy_params (return_vals, nreturn_vals);
} }
char* gchar*
gimp_channel_get_name (gint32 channel_ID) gimp_channel_get_name (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
char *name; gchar *name;
return_vals = gimp_run_procedure ("gimp_channel_get_name", return_vals = gimp_run_procedure ("gimp_channel_get_name",
&nreturn_vals, &nreturn_vals,
@ -157,7 +157,7 @@ gdouble
gimp_channel_get_opacity (gint32 channel_ID) gimp_channel_get_opacity (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gdouble opacity; gdouble opacity;
return_vals = gimp_run_procedure ("gimp_channel_get_opacity", return_vals = gimp_run_procedure ("gimp_channel_get_opacity",
@ -174,19 +174,19 @@ gimp_channel_get_opacity (gint32 channel_ID)
return opacity; return opacity;
} }
gint gboolean
gimp_channel_get_visible (gint32 channel_ID) gimp_channel_get_visible (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int visible; gboolean visible;
return_vals = gimp_run_procedure ("gimp_channel_get_visible", return_vals = gimp_run_procedure ("gimp_channel_get_visible",
&nreturn_vals, &nreturn_vals,
PARAM_CHANNEL, channel_ID, PARAM_CHANNEL, channel_ID,
PARAM_END); PARAM_END);
visible = -1; visible = FALSE;
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == STATUS_SUCCESS)
visible = return_vals[1].data.d_int32; visible = return_vals[1].data.d_int32;
@ -202,7 +202,7 @@ gimp_channel_set_color (gint32 channel_ID,
guchar blue) guchar blue)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar color[3]; guchar color[3];
color[0] = red; color[0] = red;
@ -220,10 +220,10 @@ gimp_channel_set_color (gint32 channel_ID,
void void
gimp_channel_set_name (gint32 channel_ID, gimp_channel_set_name (gint32 channel_ID,
char *name) gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_name", return_vals = gimp_run_procedure ("gimp_channel_set_name",
&nreturn_vals, &nreturn_vals,
@ -239,7 +239,7 @@ gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity) gdouble opacity)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_opacity", return_vals = gimp_run_procedure ("gimp_channel_set_opacity",
&nreturn_vals, &nreturn_vals,
@ -251,11 +251,11 @@ gimp_channel_set_opacity (gint32 channel_ID,
} }
void void
gimp_channel_set_visible (gint32 channel_ID, gimp_channel_set_visible (gint32 channel_ID,
gint visible) gboolean visible)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_visible", return_vals = gimp_run_procedure ("gimp_channel_set_visible",
&nreturn_vals, &nreturn_vals,
@ -270,8 +270,8 @@ gint
gimp_channel_get_show_masked (gint32 channel_ID) gimp_channel_get_show_masked (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int show_masked; gint show_masked;
return_vals = gimp_run_procedure ("gimp_channel_get_show_masked", return_vals = gimp_run_procedure ("gimp_channel_get_show_masked",
&nreturn_vals, &nreturn_vals,
@ -292,7 +292,7 @@ gimp_channel_set_show_masked (gint32 channel_ID,
gint show_masked) gint show_masked)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_channel_set_show_masked", return_vals = gimp_run_procedure ("gimp_channel_set_show_masked",
&nreturn_vals, &nreturn_vals,
@ -307,8 +307,8 @@ gint32
gimp_channel_get_tattoo (gint32 channel_ID) gimp_channel_get_tattoo (gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int tattoo; gint tattoo;
return_vals = gimp_run_procedure ("gimp_channel_get_tattoo", return_vals = gimp_run_procedure ("gimp_channel_get_tattoo",
&nreturn_vals, &nreturn_vals,

132
libgimp/gimpdrawable.c
View file

@ -65,8 +65,8 @@ void
gimp_drawable_flush (GDrawable *drawable) gimp_drawable_flush (GDrawable *drawable)
{ {
GTile *tiles; GTile *tiles;
int ntiles; gint ntiles;
int i; gint i;
if (drawable) if (drawable)
{ {
@ -112,7 +112,7 @@ gimp_drawable_update (gint32 drawable_ID,
guint height) guint height)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_update", return_vals = gimp_run_procedure ("gimp_drawable_update",
&nreturn_vals, &nreturn_vals,
@ -131,7 +131,7 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
gint undoable) gint undoable)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_merge_shadow", return_vals = gimp_run_procedure ("gimp_drawable_merge_shadow",
&nreturn_vals, &nreturn_vals,
@ -146,7 +146,7 @@ gint32
gimp_drawable_image_id (gint32 drawable_ID) gimp_drawable_image_id (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 image_ID; gint32 image_ID;
return_vals = gimp_run_procedure ("gimp_drawable_image", return_vals = gimp_run_procedure ("gimp_drawable_image",
@ -163,7 +163,7 @@ gimp_drawable_image_id (gint32 drawable_ID)
return image_ID; return image_ID;
} }
char* gchar*
gimp_drawable_name (gint32 drawable_ID) gimp_drawable_name (gint32 drawable_ID)
{ {
if (gimp_drawable_is_layer (drawable_ID)) if (gimp_drawable_is_layer (drawable_ID))
@ -175,7 +175,7 @@ guint
gimp_drawable_width (gint32 drawable_ID) gimp_drawable_width (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint width; guint width;
return_vals = gimp_run_procedure ("gimp_drawable_width", return_vals = gimp_run_procedure ("gimp_drawable_width",
@ -196,7 +196,7 @@ guint
gimp_drawable_height (gint32 drawable_ID) gimp_drawable_height (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint height; guint height;
return_vals = gimp_run_procedure ("gimp_drawable_height", return_vals = gimp_run_procedure ("gimp_drawable_height",
@ -217,7 +217,7 @@ guint
gimp_drawable_bpp (gint32 drawable_ID) gimp_drawable_bpp (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint bpp; guint bpp;
return_vals = gimp_run_procedure ("gimp_drawable_bytes", return_vals = gimp_run_procedure ("gimp_drawable_bytes",
@ -238,8 +238,8 @@ GDrawableType
gimp_drawable_type (gint32 drawable_ID) gimp_drawable_type (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_drawable_type", return_vals = gimp_run_procedure ("gimp_drawable_type",
&nreturn_vals, &nreturn_vals,
@ -255,20 +255,21 @@ gimp_drawable_type (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_visible (gint32 drawable_ID) gimp_drawable_visible (gint32 drawable_ID)
{ {
if (gimp_drawable_is_layer (drawable_ID)) if (gimp_drawable_is_layer (drawable_ID))
return gimp_layer_get_visible (drawable_ID); return gimp_layer_get_visible (drawable_ID);
return gimp_channel_get_visible (drawable_ID); return gimp_channel_get_visible (drawable_ID);
} }
gint gboolean
gimp_drawable_is_channel (gint32 drawable_ID) gimp_drawable_is_channel (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_channel", return_vals = gimp_run_procedure ("gimp_drawable_is_channel",
&nreturn_vals, &nreturn_vals,
@ -284,12 +285,12 @@ gimp_drawable_is_channel (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_rgb (gint32 drawable_ID) gimp_drawable_is_rgb (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_rgb", return_vals = gimp_run_procedure ("gimp_drawable_is_rgb",
&nreturn_vals, &nreturn_vals,
@ -305,12 +306,12 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_gray (gint32 drawable_ID) gimp_drawable_is_gray (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_gray", return_vals = gimp_run_procedure ("gimp_drawable_is_gray",
&nreturn_vals, &nreturn_vals,
@ -326,12 +327,12 @@ gimp_drawable_is_gray (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_has_alpha (gint32 drawable_ID) gimp_drawable_has_alpha (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_has_alpha", return_vals = gimp_run_procedure ("gimp_drawable_has_alpha",
&nreturn_vals, &nreturn_vals,
@ -347,12 +348,12 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_indexed (gint32 drawable_ID) gimp_drawable_is_indexed (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_indexed", return_vals = gimp_run_procedure ("gimp_drawable_is_indexed",
&nreturn_vals, &nreturn_vals,
@ -368,12 +369,12 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_layer (gint32 drawable_ID) gimp_drawable_is_layer (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_layer", return_vals = gimp_run_procedure ("gimp_drawable_is_layer",
&nreturn_vals, &nreturn_vals,
@ -389,12 +390,12 @@ gimp_drawable_is_layer (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_layer_mask (gint32 drawable_ID) gimp_drawable_is_layer_mask (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_layer_mask", return_vals = gimp_run_procedure ("gimp_drawable_is_layer_mask",
&nreturn_vals, &nreturn_vals,
@ -410,16 +411,16 @@ gimp_drawable_is_layer_mask (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_mask_bounds (gint32 drawable_ID, gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1, gint *x1,
gint *y1, gint *y1,
gint *x2, gint *x2,
gint *y2) gint *y2)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_mask_bounds", return_vals = gimp_run_procedure ("gimp_drawable_mask_bounds",
&nreturn_vals, &nreturn_vals,
@ -447,7 +448,7 @@ gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_y) gint *offset_y)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_offsets", return_vals = gimp_run_procedure ("gimp_drawable_offsets",
&nreturn_vals, &nreturn_vals,
@ -468,7 +469,7 @@ gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type) GimpFillType fill_type)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_fill", return_vals = gimp_run_procedure ("gimp_drawable_fill",
&nreturn_vals, &nreturn_vals,
@ -481,7 +482,7 @@ gimp_drawable_fill (gint32 drawable_ID,
void void
gimp_drawable_set_name (gint32 drawable_ID, gimp_drawable_set_name (gint32 drawable_ID,
char *name) gchar *name)
{ {
if (gimp_drawable_is_layer (drawable_ID)) if (gimp_drawable_is_layer (drawable_ID))
gimp_layer_set_name (drawable_ID, name); gimp_layer_set_name (drawable_ID, name);
@ -508,9 +509,9 @@ gimp_drawable_get_tile (GDrawable *drawable,
GTile *tiles; GTile *tiles;
guint right_tile; guint right_tile;
guint bottom_tile; guint bottom_tile;
int ntiles; gint ntiles;
int tile_num; gint tile_num;
int i, j, k; gint i, j, k;
if (drawable) if (drawable)
{ {
@ -579,12 +580,12 @@ gimp_drawable_get_tile2 (GDrawable *drawable,
} }
Parasite * Parasite *
gimp_drawable_parasite_find (gint32 drawable_ID, gimp_drawable_parasite_find (gint32 drawable_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *parasite; Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_drawable_parasite_find", return_vals = gimp_run_procedure ("gimp_drawable_parasite_find",
&nreturn_vals, &nreturn_vals,
@ -605,11 +606,11 @@ gimp_drawable_parasite_find (gint32 drawable_ID,
} }
void void
gimp_drawable_parasite_attach (gint32 drawable_ID, gimp_drawable_parasite_attach (gint32 drawable_ID,
const Parasite *p) const Parasite *p)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach", return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -622,12 +623,15 @@ gimp_drawable_parasite_attach (gint32 drawable_ID,
void void
gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags, gimp_drawable_attach_new_parasite (gint32 drawable,
int size, const void *data) const gchar *name,
gint flags,
gint size,
const gpointer data)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data); Parasite *p = parasite_new (name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach", return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -640,11 +644,11 @@ gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags,
} }
void void
gimp_drawable_parasite_detach (gint32 drawable_ID, gimp_drawable_parasite_detach (gint32 drawable_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach", return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach",
&nreturn_vals, &nreturn_vals,
@ -662,8 +666,8 @@ gimp_drawable_get_thumbnail_data (gint32 drawable_ID,
gint *height, gint *height,
gint *bytes) gint *bytes)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar *drawable_data = NULL; guchar *drawable_data = NULL;
return_vals = gimp_run_procedure ("gimp_drawable_thumbnail", return_vals = gimp_run_procedure ("gimp_drawable_thumbnail",

132
libgimp/gimpdrawable_pdb.c
View file

@ -65,8 +65,8 @@ void
gimp_drawable_flush (GDrawable *drawable) gimp_drawable_flush (GDrawable *drawable)
{ {
GTile *tiles; GTile *tiles;
int ntiles; gint ntiles;
int i; gint i;
if (drawable) if (drawable)
{ {
@ -112,7 +112,7 @@ gimp_drawable_update (gint32 drawable_ID,
guint height) guint height)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_update", return_vals = gimp_run_procedure ("gimp_drawable_update",
&nreturn_vals, &nreturn_vals,
@ -131,7 +131,7 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
gint undoable) gint undoable)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_merge_shadow", return_vals = gimp_run_procedure ("gimp_drawable_merge_shadow",
&nreturn_vals, &nreturn_vals,
@ -146,7 +146,7 @@ gint32
gimp_drawable_image_id (gint32 drawable_ID) gimp_drawable_image_id (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 image_ID; gint32 image_ID;
return_vals = gimp_run_procedure ("gimp_drawable_image", return_vals = gimp_run_procedure ("gimp_drawable_image",
@ -163,7 +163,7 @@ gimp_drawable_image_id (gint32 drawable_ID)
return image_ID; return image_ID;
} }
char* gchar*
gimp_drawable_name (gint32 drawable_ID) gimp_drawable_name (gint32 drawable_ID)
{ {
if (gimp_drawable_is_layer (drawable_ID)) if (gimp_drawable_is_layer (drawable_ID))
@ -175,7 +175,7 @@ guint
gimp_drawable_width (gint32 drawable_ID) gimp_drawable_width (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint width; guint width;
return_vals = gimp_run_procedure ("gimp_drawable_width", return_vals = gimp_run_procedure ("gimp_drawable_width",
@ -196,7 +196,7 @@ guint
gimp_drawable_height (gint32 drawable_ID) gimp_drawable_height (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint height; guint height;
return_vals = gimp_run_procedure ("gimp_drawable_height", return_vals = gimp_run_procedure ("gimp_drawable_height",
@ -217,7 +217,7 @@ guint
gimp_drawable_bpp (gint32 drawable_ID) gimp_drawable_bpp (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guint bpp; guint bpp;
return_vals = gimp_run_procedure ("gimp_drawable_bytes", return_vals = gimp_run_procedure ("gimp_drawable_bytes",
@ -238,8 +238,8 @@ GDrawableType
gimp_drawable_type (gint32 drawable_ID) gimp_drawable_type (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_drawable_type", return_vals = gimp_run_procedure ("gimp_drawable_type",
&nreturn_vals, &nreturn_vals,
@ -255,20 +255,21 @@ gimp_drawable_type (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_visible (gint32 drawable_ID) gimp_drawable_visible (gint32 drawable_ID)
{ {
if (gimp_drawable_is_layer (drawable_ID)) if (gimp_drawable_is_layer (drawable_ID))
return gimp_layer_get_visible (drawable_ID); return gimp_layer_get_visible (drawable_ID);
return gimp_channel_get_visible (drawable_ID); return gimp_channel_get_visible (drawable_ID);
} }
gint gboolean
gimp_drawable_is_channel (gint32 drawable_ID) gimp_drawable_is_channel (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_channel", return_vals = gimp_run_procedure ("gimp_drawable_is_channel",
&nreturn_vals, &nreturn_vals,
@ -284,12 +285,12 @@ gimp_drawable_is_channel (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_rgb (gint32 drawable_ID) gimp_drawable_is_rgb (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_rgb", return_vals = gimp_run_procedure ("gimp_drawable_is_rgb",
&nreturn_vals, &nreturn_vals,
@ -305,12 +306,12 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_gray (gint32 drawable_ID) gimp_drawable_is_gray (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_gray", return_vals = gimp_run_procedure ("gimp_drawable_is_gray",
&nreturn_vals, &nreturn_vals,
@ -326,12 +327,12 @@ gimp_drawable_is_gray (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_has_alpha (gint32 drawable_ID) gimp_drawable_has_alpha (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_has_alpha", return_vals = gimp_run_procedure ("gimp_drawable_has_alpha",
&nreturn_vals, &nreturn_vals,
@ -347,12 +348,12 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_indexed (gint32 drawable_ID) gimp_drawable_is_indexed (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_indexed", return_vals = gimp_run_procedure ("gimp_drawable_is_indexed",
&nreturn_vals, &nreturn_vals,
@ -368,12 +369,12 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_layer (gint32 drawable_ID) gimp_drawable_is_layer (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_layer", return_vals = gimp_run_procedure ("gimp_drawable_is_layer",
&nreturn_vals, &nreturn_vals,
@ -389,12 +390,12 @@ gimp_drawable_is_layer (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_is_layer_mask (gint32 drawable_ID) gimp_drawable_is_layer_mask (gint32 drawable_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_is_layer_mask", return_vals = gimp_run_procedure ("gimp_drawable_is_layer_mask",
&nreturn_vals, &nreturn_vals,
@ -410,16 +411,16 @@ gimp_drawable_is_layer_mask (gint32 drawable_ID)
return result; return result;
} }
gint gboolean
gimp_drawable_mask_bounds (gint32 drawable_ID, gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x1, gint *x1,
gint *y1, gint *y1,
gint *x2, gint *x2,
gint *y2) gint *y2)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_drawable_mask_bounds", return_vals = gimp_run_procedure ("gimp_drawable_mask_bounds",
&nreturn_vals, &nreturn_vals,
@ -447,7 +448,7 @@ gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_y) gint *offset_y)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_offsets", return_vals = gimp_run_procedure ("gimp_drawable_offsets",
&nreturn_vals, &nreturn_vals,
@ -468,7 +469,7 @@ gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type) GimpFillType fill_type)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_fill", return_vals = gimp_run_procedure ("gimp_drawable_fill",
&nreturn_vals, &nreturn_vals,
@ -481,7 +482,7 @@ gimp_drawable_fill (gint32 drawable_ID,
void void
gimp_drawable_set_name (gint32 drawable_ID, gimp_drawable_set_name (gint32 drawable_ID,
char *name) gchar *name)
{ {
if (gimp_drawable_is_layer (drawable_ID)) if (gimp_drawable_is_layer (drawable_ID))
gimp_layer_set_name (drawable_ID, name); gimp_layer_set_name (drawable_ID, name);
@ -508,9 +509,9 @@ gimp_drawable_get_tile (GDrawable *drawable,
GTile *tiles; GTile *tiles;
guint right_tile; guint right_tile;
guint bottom_tile; guint bottom_tile;
int ntiles; gint ntiles;
int tile_num; gint tile_num;
int i, j, k; gint i, j, k;
if (drawable) if (drawable)
{ {
@ -579,12 +580,12 @@ gimp_drawable_get_tile2 (GDrawable *drawable,
} }
Parasite * Parasite *
gimp_drawable_parasite_find (gint32 drawable_ID, gimp_drawable_parasite_find (gint32 drawable_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *parasite; Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_drawable_parasite_find", return_vals = gimp_run_procedure ("gimp_drawable_parasite_find",
&nreturn_vals, &nreturn_vals,
@ -605,11 +606,11 @@ gimp_drawable_parasite_find (gint32 drawable_ID,
} }
void void
gimp_drawable_parasite_attach (gint32 drawable_ID, gimp_drawable_parasite_attach (gint32 drawable_ID,
const Parasite *p) const Parasite *p)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach", return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -622,12 +623,15 @@ gimp_drawable_parasite_attach (gint32 drawable_ID,
void void
gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags, gimp_drawable_attach_new_parasite (gint32 drawable,
int size, const void *data) const gchar *name,
gint flags,
gint size,
const gpointer data)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data); Parasite *p = parasite_new (name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach", return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -640,11 +644,11 @@ gimp_drawable_attach_new_parasite (gint32 drawable, const char *name, int flags,
} }
void void
gimp_drawable_parasite_detach (gint32 drawable_ID, gimp_drawable_parasite_detach (gint32 drawable_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach", return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach",
&nreturn_vals, &nreturn_vals,
@ -662,8 +666,8 @@ gimp_drawable_get_thumbnail_data (gint32 drawable_ID,
gint *height, gint *height,
gint *bytes) gint *bytes)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar *drawable_data = NULL; guchar *drawable_data = NULL;
return_vals = gimp_run_procedure ("gimp_drawable_thumbnail", return_vals = gimp_run_procedure ("gimp_drawable_thumbnail",

170
libgimp/gimpimage.c
View file

@ -26,7 +26,7 @@ gimp_image_add_hguide (gint32 image_id,
gint32 yposition) gint32 yposition)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 guide_id; gint32 guide_id;
return_vals = gimp_run_procedure ("gimp_image_add_hguide", return_vals = gimp_run_procedure ("gimp_image_add_hguide",
@ -49,7 +49,7 @@ gimp_image_add_vguide (gint32 image_id,
gint32 xposition) gint32 xposition)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 guide_id; gint32 guide_id;
return_vals = gimp_run_procedure ("gimp_image_add_vguide", return_vals = gimp_run_procedure ("gimp_image_add_vguide",
@ -72,7 +72,7 @@ gimp_image_delete_guide (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_delete_guide", return_vals = gimp_run_procedure ("gimp_image_delete_guide",
&nreturn_vals, &nreturn_vals,
@ -88,7 +88,7 @@ gimp_image_find_next_guide (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 rtn_guide_id; gint32 rtn_guide_id;
return_vals = gimp_run_procedure ("gimp_image_find_next_guide", return_vals = gimp_run_procedure ("gimp_image_find_next_guide",
@ -111,7 +111,7 @@ gimp_image_get_guide_orientation (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
GOrientation rtn_guide_orientation; GOrientation rtn_guide_orientation;
return_vals = gimp_run_procedure ("gimp_image_get_guide_orientation", return_vals = gimp_run_procedure ("gimp_image_get_guide_orientation",
@ -134,7 +134,7 @@ gimp_image_get_guide_position (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 rtn_guide_position; gint32 rtn_guide_position;
return_vals = gimp_run_procedure ("gimp_image_get_guide_position", return_vals = gimp_run_procedure ("gimp_image_get_guide_position",
@ -163,7 +163,7 @@ gimp_image_new (guint width,
GImageType type) GImageType type)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 image_ID; gint32 image_ID;
return_vals = gimp_run_procedure ("gimp_image_new", return_vals = gimp_run_procedure ("gimp_image_new",
@ -186,7 +186,7 @@ gint32
gimp_image_duplicate (gint32 image_ID) gimp_image_duplicate (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 new_image_ID; gint32 new_image_ID;
return_vals = gimp_run_procedure ("gimp_channel_ops_duplicate", return_vals = gimp_run_procedure ("gimp_channel_ops_duplicate",
@ -207,7 +207,7 @@ void
gimp_image_delete (gint32 image_ID) gimp_image_delete (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_delete", return_vals = gimp_run_procedure ("gimp_image_delete",
&nreturn_vals, &nreturn_vals,
@ -221,8 +221,8 @@ guint
gimp_image_width (gint32 image_ID) gimp_image_width (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_image_width", return_vals = gimp_run_procedure ("gimp_image_width",
&nreturn_vals, &nreturn_vals,
@ -242,8 +242,8 @@ guint
gimp_image_height (gint32 image_ID) gimp_image_height (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_image_height", return_vals = gimp_run_procedure ("gimp_image_height",
&nreturn_vals, &nreturn_vals,
@ -263,8 +263,8 @@ GImageType
gimp_image_base_type (gint32 image_ID) gimp_image_base_type (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_image_base_type", return_vals = gimp_run_procedure ("gimp_image_base_type",
&nreturn_vals, &nreturn_vals,
@ -284,7 +284,7 @@ gint32
gimp_image_floating_selection (gint32 image_ID) gimp_image_floating_selection (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_floating_selection", return_vals = gimp_run_procedure ("gimp_image_floating_selection",
@ -307,7 +307,7 @@ gimp_image_add_channel (gint32 image_ID,
int position) int position)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_add_channel", return_vals = gimp_run_procedure ("gimp_image_add_channel",
&nreturn_vals, &nreturn_vals,
@ -322,10 +322,10 @@ gimp_image_add_channel (gint32 image_ID,
void void
gimp_image_add_layer (gint32 image_ID, gimp_image_add_layer (gint32 image_ID,
gint32 layer_ID, gint32 layer_ID,
int position) gint position)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_add_layer", return_vals = gimp_run_procedure ("gimp_image_add_layer",
&nreturn_vals, &nreturn_vals,
@ -359,7 +359,7 @@ void
gimp_image_undo_disable (gint32 image_ID) gimp_image_undo_disable (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_disable", return_vals = gimp_run_procedure ("gimp_image_undo_disable",
&nreturn_vals, &nreturn_vals,
@ -373,7 +373,7 @@ void
gimp_image_undo_enable (gint32 image_ID) gimp_image_undo_enable (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_enable", return_vals = gimp_run_procedure ("gimp_image_undo_enable",
&nreturn_vals, &nreturn_vals,
@ -387,7 +387,7 @@ void
gimp_image_undo_freeze (gint32 image_ID) gimp_image_undo_freeze (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_freeze", return_vals = gimp_run_procedure ("gimp_image_undo_freeze",
&nreturn_vals, &nreturn_vals,
@ -401,7 +401,7 @@ void
gimp_image_undo_thaw (gint32 image_ID) gimp_image_undo_thaw (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_thaw", return_vals = gimp_run_procedure ("gimp_image_undo_thaw",
&nreturn_vals, &nreturn_vals,
@ -415,7 +415,7 @@ void
gimp_undo_push_group_start (gint32 image_ID) gimp_undo_push_group_start (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_undo_push_group_start", return_vals = gimp_run_procedure ("gimp_undo_push_group_start",
&nreturn_vals, &nreturn_vals,
@ -429,7 +429,7 @@ void
gimp_undo_push_group_end (gint32 image_ID) gimp_undo_push_group_end (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_undo_push_group_end", return_vals = gimp_run_procedure ("gimp_undo_push_group_end",
&nreturn_vals, &nreturn_vals,
@ -443,7 +443,7 @@ void
gimp_image_clean_all (gint32 image_ID) gimp_image_clean_all (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_clean_all", return_vals = gimp_run_procedure ("gimp_image_clean_all",
&nreturn_vals, &nreturn_vals,
@ -457,7 +457,7 @@ gint32
gimp_image_flatten (gint32 image_ID) gimp_image_flatten (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_flatten", return_vals = gimp_run_procedure ("gimp_image_flatten",
@ -495,7 +495,7 @@ gimp_image_lower_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_lower_layer", return_vals = gimp_run_procedure ("gimp_image_lower_layer",
&nreturn_vals, &nreturn_vals,
@ -511,7 +511,7 @@ gimp_image_merge_visible_layers (gint32 image_ID,
GimpMergeType merge_type) GimpMergeType merge_type)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_merge_visible_layers", return_vals = gimp_run_procedure ("gimp_image_merge_visible_layers",
@ -535,7 +535,7 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
gint y) gint y)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_pick_correlate_layer", return_vals = gimp_run_procedure ("gimp_image_pick_correlate_layer",
@ -559,7 +559,7 @@ gimp_image_raise_channel (gint32 image_ID,
gint32 channel_ID) gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_raise_channel", return_vals = gimp_run_procedure ("gimp_image_raise_channel",
&nreturn_vals, &nreturn_vals,
@ -575,7 +575,7 @@ gimp_image_raise_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_raise_layer", return_vals = gimp_run_procedure ("gimp_image_raise_layer",
&nreturn_vals, &nreturn_vals,
@ -591,7 +591,7 @@ gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID) gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_remove_channel", return_vals = gimp_run_procedure ("gimp_image_remove_channel",
&nreturn_vals, &nreturn_vals,
@ -607,7 +607,7 @@ gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_remove_layer", return_vals = gimp_run_procedure ("gimp_image_remove_layer",
&nreturn_vals, &nreturn_vals,
@ -624,7 +624,7 @@ gimp_image_remove_layer_mask (gint32 image_ID,
gint mode) gint mode)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_remove_layer_mask", return_vals = gimp_run_procedure ("gimp_image_remove_layer_mask",
&nreturn_vals, &nreturn_vals,
@ -644,7 +644,7 @@ gimp_image_resize (gint32 image_ID,
gint offset_y) gint offset_y)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_resize", return_vals = gimp_run_procedure ("gimp_image_resize",
&nreturn_vals, &nreturn_vals,
@ -662,7 +662,7 @@ gint32
gimp_image_get_active_channel (gint32 image_ID) gimp_image_get_active_channel (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 channel_ID; gint32 channel_ID;
return_vals = gimp_run_procedure ("gimp_image_get_active_channel", return_vals = gimp_run_procedure ("gimp_image_get_active_channel",
@ -683,7 +683,7 @@ gint32
gimp_image_get_active_layer (gint32 image_ID) gimp_image_get_active_layer (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_get_active_layer", return_vals = gimp_run_procedure ("gimp_image_get_active_layer",
@ -705,7 +705,7 @@ gimp_image_get_channels (gint32 image_ID,
gint *nchannels) gint *nchannels)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 *channels; gint32 *channels;
return_vals = gimp_run_procedure ("gimp_image_get_channels", return_vals = gimp_run_procedure ("gimp_image_get_channels",
@ -731,7 +731,7 @@ gimp_image_get_cmap (gint32 image_ID,
gint *ncolors) gint *ncolors)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar *cmap; guchar *cmap;
return_vals = gimp_run_procedure ("gimp_image_get_cmap", return_vals = gimp_run_procedure ("gimp_image_get_cmap",
@ -752,13 +752,13 @@ gimp_image_get_cmap (gint32 image_ID,
return cmap; return cmap;
} }
gint gboolean
gimp_image_get_component_active (gint32 image_ID, gimp_image_get_component_active (gint32 image_ID,
gint component) gint component)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_image_get_component_active", return_vals = gimp_run_procedure ("gimp_image_get_component_active",
&nreturn_vals, &nreturn_vals,
@ -774,13 +774,13 @@ gimp_image_get_component_active (gint32 image_ID,
return result; return result;
} }
gint gboolean
gimp_image_get_component_visible (gint32 image_ID, gimp_image_get_component_visible (gint32 image_ID,
gint component) gint component)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_image_get_component_visible", return_vals = gimp_run_procedure ("gimp_image_get_component_visible",
&nreturn_vals, &nreturn_vals,
@ -796,7 +796,7 @@ gimp_image_get_component_visible (gint32 image_ID,
return result; return result;
} }
char* gchar*
gimp_image_get_filename (gint32 image_ID) gimp_image_get_filename (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
@ -822,7 +822,7 @@ gimp_image_get_layers (gint32 image_ID,
gint *nlayers) gint *nlayers)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 *layers; gint32 *layers;
return_vals = gimp_run_procedure ("gimp_image_get_layers", return_vals = gimp_run_procedure ("gimp_image_get_layers",
@ -847,7 +847,7 @@ gint32
gimp_image_get_selection (gint32 image_ID) gimp_image_get_selection (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 selection_ID; gint32 selection_ID;
return_vals = gimp_run_procedure ("gimp_image_get_selection", return_vals = gimp_run_procedure ("gimp_image_get_selection",
@ -869,7 +869,7 @@ gimp_image_set_active_channel (gint32 image_ID,
gint32 channel_ID) gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
if (channel_ID == -1) if (channel_ID == -1)
{ {
@ -895,7 +895,7 @@ gimp_image_set_active_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_active_layer", return_vals = gimp_run_procedure ("gimp_image_set_active_layer",
&nreturn_vals, &nreturn_vals,
@ -912,7 +912,7 @@ gimp_image_set_cmap (gint32 image_ID,
gint ncolors) gint ncolors)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_cmap", return_vals = gimp_run_procedure ("gimp_image_set_cmap",
&nreturn_vals, &nreturn_vals,
@ -925,12 +925,12 @@ gimp_image_set_cmap (gint32 image_ID,
} }
void void
gimp_image_set_component_active (gint32 image_ID, gimp_image_set_component_active (gint32 image_ID,
gint component, gint component,
gint active) gboolean active)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_component_active", return_vals = gimp_run_procedure ("gimp_image_set_component_active",
&nreturn_vals, &nreturn_vals,
@ -943,12 +943,12 @@ gimp_image_set_component_active (gint32 image_ID,
} }
void void
gimp_image_set_component_visible (gint32 image_ID, gimp_image_set_component_visible (gint32 image_ID,
gint component, gint component,
gint visible) gboolean visible)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_component_visible", return_vals = gimp_run_procedure ("gimp_image_set_component_visible",
&nreturn_vals, &nreturn_vals,
@ -962,10 +962,10 @@ gimp_image_set_component_visible (gint32 image_ID,
void void
gimp_image_set_filename (gint32 image_ID, gimp_image_set_filename (gint32 image_ID,
char *name) gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_filename", return_vals = gimp_run_procedure ("gimp_image_set_filename",
&nreturn_vals, &nreturn_vals,
@ -977,11 +977,11 @@ gimp_image_set_filename (gint32 image_ID,
} }
Parasite * Parasite *
gimp_image_parasite_find (gint32 image_ID, gimp_image_parasite_find (gint32 image_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *parasite; Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_image_parasite_find", return_vals = gimp_run_procedure ("gimp_image_parasite_find",
&nreturn_vals, &nreturn_vals,
@ -1006,7 +1006,7 @@ gimp_image_parasite_attach (gint32 image_ID,
const Parasite *p) const Parasite *p)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_parasite_attach", return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -1018,14 +1018,14 @@ gimp_image_parasite_attach (gint32 image_ID,
} }
void void
gimp_image_attach_new_parasite (gint32 image_ID, gimp_image_attach_new_parasite (gint32 image_ID,
const char *name, const gchar *name,
int flags, gint flags,
int size, gint size,
const void *data) const gpointer data)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data); Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_image_parasite_attach", return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
@ -1039,11 +1039,11 @@ gimp_image_attach_new_parasite (gint32 image_ID,
} }
void void
gimp_image_parasite_detach (gint32 image_ID, gimp_image_parasite_detach (gint32 image_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_parasite_detach", return_vals = gimp_run_procedure ("gimp_image_parasite_detach",
&nreturn_vals, &nreturn_vals,
@ -1060,7 +1060,7 @@ gimp_image_get_resolution (gint32 image_ID,
double *yresolution) double *yresolution)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
double xres; double xres;
double yres; double yres;
@ -1093,7 +1093,7 @@ gimp_image_set_resolution (gint32 image_ID,
double yresolution) double yresolution)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_resolution", return_vals = gimp_run_procedure ("gimp_image_set_resolution",
&nreturn_vals, &nreturn_vals,
@ -1109,7 +1109,7 @@ GimpUnit
gimp_image_get_unit (gint32 image_ID) gimp_image_get_unit (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
GimpUnit unit; GimpUnit unit;
return_vals = gimp_run_procedure ("gimp_image_get_unit", return_vals = gimp_run_procedure ("gimp_image_get_unit",
@ -1133,7 +1133,7 @@ gimp_image_set_unit (gint32 image_ID,
GimpUnit unit) GimpUnit unit)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_unit", return_vals = gimp_run_procedure ("gimp_image_set_unit",
&nreturn_vals, &nreturn_vals,
@ -1149,7 +1149,7 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID,
gint32 tattoo) gint32 tattoo)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer = 0; gint32 layer = 0;
return_vals = gimp_run_procedure ("gimp_image_get_layer_by_tattoo", return_vals = gimp_run_procedure ("gimp_image_get_layer_by_tattoo",
@ -1172,7 +1172,7 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID,
gint32 tattoo) gint32 tattoo)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 channel = 0; gint32 channel = 0;
return_vals = gimp_run_procedure ("gimp_image_get_channel_by_tattoo", return_vals = gimp_run_procedure ("gimp_image_get_channel_by_tattoo",
@ -1197,7 +1197,7 @@ gimp_image_get_thumbnail_data (gint32 image_ID,
gint *bytes) gint *bytes)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar *image_data = NULL; guchar *image_data = NULL;
return_vals = gimp_run_procedure ("gimp_image_thumbnail", return_vals = gimp_run_procedure ("gimp_image_thumbnail",
@ -1225,7 +1225,7 @@ void
gimp_image_convert_rgb (gint32 image_ID) gimp_image_convert_rgb (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_convert_rgb", return_vals = gimp_run_procedure ("gimp_convert_rgb",
&nreturn_vals, &nreturn_vals,
@ -1239,7 +1239,7 @@ void
gimp_image_convert_grayscale (gint32 image_ID) gimp_image_convert_grayscale (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_convert_grayscale", return_vals = gimp_run_procedure ("gimp_convert_grayscale",
&nreturn_vals, &nreturn_vals,
@ -1259,7 +1259,7 @@ gimp_image_convert_indexed (gint32 image_ID,
gchar *palette) gchar *palette)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_convert_indexed", return_vals = gimp_run_procedure ("gimp_convert_indexed",
&nreturn_vals, &nreturn_vals,

170
libgimp/gimpimage_pdb.c
View file

@ -26,7 +26,7 @@ gimp_image_add_hguide (gint32 image_id,
gint32 yposition) gint32 yposition)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 guide_id; gint32 guide_id;
return_vals = gimp_run_procedure ("gimp_image_add_hguide", return_vals = gimp_run_procedure ("gimp_image_add_hguide",
@ -49,7 +49,7 @@ gimp_image_add_vguide (gint32 image_id,
gint32 xposition) gint32 xposition)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 guide_id; gint32 guide_id;
return_vals = gimp_run_procedure ("gimp_image_add_vguide", return_vals = gimp_run_procedure ("gimp_image_add_vguide",
@ -72,7 +72,7 @@ gimp_image_delete_guide (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_delete_guide", return_vals = gimp_run_procedure ("gimp_image_delete_guide",
&nreturn_vals, &nreturn_vals,
@ -88,7 +88,7 @@ gimp_image_find_next_guide (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 rtn_guide_id; gint32 rtn_guide_id;
return_vals = gimp_run_procedure ("gimp_image_find_next_guide", return_vals = gimp_run_procedure ("gimp_image_find_next_guide",
@ -111,7 +111,7 @@ gimp_image_get_guide_orientation (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
GOrientation rtn_guide_orientation; GOrientation rtn_guide_orientation;
return_vals = gimp_run_procedure ("gimp_image_get_guide_orientation", return_vals = gimp_run_procedure ("gimp_image_get_guide_orientation",
@ -134,7 +134,7 @@ gimp_image_get_guide_position (gint32 image_id,
gint32 guide_id) gint32 guide_id)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 rtn_guide_position; gint32 rtn_guide_position;
return_vals = gimp_run_procedure ("gimp_image_get_guide_position", return_vals = gimp_run_procedure ("gimp_image_get_guide_position",
@ -163,7 +163,7 @@ gimp_image_new (guint width,
GImageType type) GImageType type)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 image_ID; gint32 image_ID;
return_vals = gimp_run_procedure ("gimp_image_new", return_vals = gimp_run_procedure ("gimp_image_new",
@ -186,7 +186,7 @@ gint32
gimp_image_duplicate (gint32 image_ID) gimp_image_duplicate (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 new_image_ID; gint32 new_image_ID;
return_vals = gimp_run_procedure ("gimp_channel_ops_duplicate", return_vals = gimp_run_procedure ("gimp_channel_ops_duplicate",
@ -207,7 +207,7 @@ void
gimp_image_delete (gint32 image_ID) gimp_image_delete (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_delete", return_vals = gimp_run_procedure ("gimp_image_delete",
&nreturn_vals, &nreturn_vals,
@ -221,8 +221,8 @@ guint
gimp_image_width (gint32 image_ID) gimp_image_width (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_image_width", return_vals = gimp_run_procedure ("gimp_image_width",
&nreturn_vals, &nreturn_vals,
@ -242,8 +242,8 @@ guint
gimp_image_height (gint32 image_ID) gimp_image_height (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_image_height", return_vals = gimp_run_procedure ("gimp_image_height",
&nreturn_vals, &nreturn_vals,
@ -263,8 +263,8 @@ GImageType
gimp_image_base_type (gint32 image_ID) gimp_image_base_type (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gint result;
return_vals = gimp_run_procedure ("gimp_image_base_type", return_vals = gimp_run_procedure ("gimp_image_base_type",
&nreturn_vals, &nreturn_vals,
@ -284,7 +284,7 @@ gint32
gimp_image_floating_selection (gint32 image_ID) gimp_image_floating_selection (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_floating_selection", return_vals = gimp_run_procedure ("gimp_image_floating_selection",
@ -307,7 +307,7 @@ gimp_image_add_channel (gint32 image_ID,
int position) int position)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_add_channel", return_vals = gimp_run_procedure ("gimp_image_add_channel",
&nreturn_vals, &nreturn_vals,
@ -322,10 +322,10 @@ gimp_image_add_channel (gint32 image_ID,
void void
gimp_image_add_layer (gint32 image_ID, gimp_image_add_layer (gint32 image_ID,
gint32 layer_ID, gint32 layer_ID,
int position) gint position)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_add_layer", return_vals = gimp_run_procedure ("gimp_image_add_layer",
&nreturn_vals, &nreturn_vals,
@ -359,7 +359,7 @@ void
gimp_image_undo_disable (gint32 image_ID) gimp_image_undo_disable (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_disable", return_vals = gimp_run_procedure ("gimp_image_undo_disable",
&nreturn_vals, &nreturn_vals,
@ -373,7 +373,7 @@ void
gimp_image_undo_enable (gint32 image_ID) gimp_image_undo_enable (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_enable", return_vals = gimp_run_procedure ("gimp_image_undo_enable",
&nreturn_vals, &nreturn_vals,
@ -387,7 +387,7 @@ void
gimp_image_undo_freeze (gint32 image_ID) gimp_image_undo_freeze (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_freeze", return_vals = gimp_run_procedure ("gimp_image_undo_freeze",
&nreturn_vals, &nreturn_vals,
@ -401,7 +401,7 @@ void
gimp_image_undo_thaw (gint32 image_ID) gimp_image_undo_thaw (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_undo_thaw", return_vals = gimp_run_procedure ("gimp_image_undo_thaw",
&nreturn_vals, &nreturn_vals,
@ -415,7 +415,7 @@ void
gimp_undo_push_group_start (gint32 image_ID) gimp_undo_push_group_start (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_undo_push_group_start", return_vals = gimp_run_procedure ("gimp_undo_push_group_start",
&nreturn_vals, &nreturn_vals,
@ -429,7 +429,7 @@ void
gimp_undo_push_group_end (gint32 image_ID) gimp_undo_push_group_end (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_undo_push_group_end", return_vals = gimp_run_procedure ("gimp_undo_push_group_end",
&nreturn_vals, &nreturn_vals,
@ -443,7 +443,7 @@ void
gimp_image_clean_all (gint32 image_ID) gimp_image_clean_all (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_clean_all", return_vals = gimp_run_procedure ("gimp_image_clean_all",
&nreturn_vals, &nreturn_vals,
@ -457,7 +457,7 @@ gint32
gimp_image_flatten (gint32 image_ID) gimp_image_flatten (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_flatten", return_vals = gimp_run_procedure ("gimp_image_flatten",
@ -495,7 +495,7 @@ gimp_image_lower_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_lower_layer", return_vals = gimp_run_procedure ("gimp_image_lower_layer",
&nreturn_vals, &nreturn_vals,
@ -511,7 +511,7 @@ gimp_image_merge_visible_layers (gint32 image_ID,
GimpMergeType merge_type) GimpMergeType merge_type)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_merge_visible_layers", return_vals = gimp_run_procedure ("gimp_image_merge_visible_layers",
@ -535,7 +535,7 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
gint y) gint y)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_pick_correlate_layer", return_vals = gimp_run_procedure ("gimp_image_pick_correlate_layer",
@ -559,7 +559,7 @@ gimp_image_raise_channel (gint32 image_ID,
gint32 channel_ID) gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_raise_channel", return_vals = gimp_run_procedure ("gimp_image_raise_channel",
&nreturn_vals, &nreturn_vals,
@ -575,7 +575,7 @@ gimp_image_raise_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_raise_layer", return_vals = gimp_run_procedure ("gimp_image_raise_layer",
&nreturn_vals, &nreturn_vals,
@ -591,7 +591,7 @@ gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID) gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_remove_channel", return_vals = gimp_run_procedure ("gimp_image_remove_channel",
&nreturn_vals, &nreturn_vals,
@ -607,7 +607,7 @@ gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_remove_layer", return_vals = gimp_run_procedure ("gimp_image_remove_layer",
&nreturn_vals, &nreturn_vals,
@ -624,7 +624,7 @@ gimp_image_remove_layer_mask (gint32 image_ID,
gint mode) gint mode)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_remove_layer_mask", return_vals = gimp_run_procedure ("gimp_image_remove_layer_mask",
&nreturn_vals, &nreturn_vals,
@ -644,7 +644,7 @@ gimp_image_resize (gint32 image_ID,
gint offset_y) gint offset_y)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_resize", return_vals = gimp_run_procedure ("gimp_image_resize",
&nreturn_vals, &nreturn_vals,
@ -662,7 +662,7 @@ gint32
gimp_image_get_active_channel (gint32 image_ID) gimp_image_get_active_channel (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 channel_ID; gint32 channel_ID;
return_vals = gimp_run_procedure ("gimp_image_get_active_channel", return_vals = gimp_run_procedure ("gimp_image_get_active_channel",
@ -683,7 +683,7 @@ gint32
gimp_image_get_active_layer (gint32 image_ID) gimp_image_get_active_layer (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer_ID; gint32 layer_ID;
return_vals = gimp_run_procedure ("gimp_image_get_active_layer", return_vals = gimp_run_procedure ("gimp_image_get_active_layer",
@ -705,7 +705,7 @@ gimp_image_get_channels (gint32 image_ID,
gint *nchannels) gint *nchannels)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 *channels; gint32 *channels;
return_vals = gimp_run_procedure ("gimp_image_get_channels", return_vals = gimp_run_procedure ("gimp_image_get_channels",
@ -731,7 +731,7 @@ gimp_image_get_cmap (gint32 image_ID,
gint *ncolors) gint *ncolors)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar *cmap; guchar *cmap;
return_vals = gimp_run_procedure ("gimp_image_get_cmap", return_vals = gimp_run_procedure ("gimp_image_get_cmap",
@ -752,13 +752,13 @@ gimp_image_get_cmap (gint32 image_ID,
return cmap; return cmap;
} }
gint gboolean
gimp_image_get_component_active (gint32 image_ID, gimp_image_get_component_active (gint32 image_ID,
gint component) gint component)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_image_get_component_active", return_vals = gimp_run_procedure ("gimp_image_get_component_active",
&nreturn_vals, &nreturn_vals,
@ -774,13 +774,13 @@ gimp_image_get_component_active (gint32 image_ID,
return result; return result;
} }
gint gboolean
gimp_image_get_component_visible (gint32 image_ID, gimp_image_get_component_visible (gint32 image_ID,
gint component) gint component)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
int result; gboolean result;
return_vals = gimp_run_procedure ("gimp_image_get_component_visible", return_vals = gimp_run_procedure ("gimp_image_get_component_visible",
&nreturn_vals, &nreturn_vals,
@ -796,7 +796,7 @@ gimp_image_get_component_visible (gint32 image_ID,
return result; return result;
} }
char* gchar*
gimp_image_get_filename (gint32 image_ID) gimp_image_get_filename (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
@ -822,7 +822,7 @@ gimp_image_get_layers (gint32 image_ID,
gint *nlayers) gint *nlayers)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 *layers; gint32 *layers;
return_vals = gimp_run_procedure ("gimp_image_get_layers", return_vals = gimp_run_procedure ("gimp_image_get_layers",
@ -847,7 +847,7 @@ gint32
gimp_image_get_selection (gint32 image_ID) gimp_image_get_selection (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 selection_ID; gint32 selection_ID;
return_vals = gimp_run_procedure ("gimp_image_get_selection", return_vals = gimp_run_procedure ("gimp_image_get_selection",
@ -869,7 +869,7 @@ gimp_image_set_active_channel (gint32 image_ID,
gint32 channel_ID) gint32 channel_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
if (channel_ID == -1) if (channel_ID == -1)
{ {
@ -895,7 +895,7 @@ gimp_image_set_active_layer (gint32 image_ID,
gint32 layer_ID) gint32 layer_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_active_layer", return_vals = gimp_run_procedure ("gimp_image_set_active_layer",
&nreturn_vals, &nreturn_vals,
@ -912,7 +912,7 @@ gimp_image_set_cmap (gint32 image_ID,
gint ncolors) gint ncolors)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_cmap", return_vals = gimp_run_procedure ("gimp_image_set_cmap",
&nreturn_vals, &nreturn_vals,
@ -925,12 +925,12 @@ gimp_image_set_cmap (gint32 image_ID,
} }
void void
gimp_image_set_component_active (gint32 image_ID, gimp_image_set_component_active (gint32 image_ID,
gint component, gint component,
gint active) gboolean active)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_component_active", return_vals = gimp_run_procedure ("gimp_image_set_component_active",
&nreturn_vals, &nreturn_vals,
@ -943,12 +943,12 @@ gimp_image_set_component_active (gint32 image_ID,
} }
void void
gimp_image_set_component_visible (gint32 image_ID, gimp_image_set_component_visible (gint32 image_ID,
gint component, gint component,
gint visible) gboolean visible)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_component_visible", return_vals = gimp_run_procedure ("gimp_image_set_component_visible",
&nreturn_vals, &nreturn_vals,
@ -962,10 +962,10 @@ gimp_image_set_component_visible (gint32 image_ID,
void void
gimp_image_set_filename (gint32 image_ID, gimp_image_set_filename (gint32 image_ID,
char *name) gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_filename", return_vals = gimp_run_procedure ("gimp_image_set_filename",
&nreturn_vals, &nreturn_vals,
@ -977,11 +977,11 @@ gimp_image_set_filename (gint32 image_ID,
} }
Parasite * Parasite *
gimp_image_parasite_find (gint32 image_ID, gimp_image_parasite_find (gint32 image_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *parasite; Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_image_parasite_find", return_vals = gimp_run_procedure ("gimp_image_parasite_find",
&nreturn_vals, &nreturn_vals,
@ -1006,7 +1006,7 @@ gimp_image_parasite_attach (gint32 image_ID,
const Parasite *p) const Parasite *p)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_parasite_attach", return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -1018,14 +1018,14 @@ gimp_image_parasite_attach (gint32 image_ID,
} }
void void
gimp_image_attach_new_parasite (gint32 image_ID, gimp_image_attach_new_parasite (gint32 image_ID,
const char *name, const gchar *name,
int flags, gint flags,
int size, gint size,
const void *data) const gpointer data)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data); Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_image_parasite_attach", return_vals = gimp_run_procedure ("gimp_image_parasite_attach",
@ -1039,11 +1039,11 @@ gimp_image_attach_new_parasite (gint32 image_ID,
} }
void void
gimp_image_parasite_detach (gint32 image_ID, gimp_image_parasite_detach (gint32 image_ID,
const char *name) const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_parasite_detach", return_vals = gimp_run_procedure ("gimp_image_parasite_detach",
&nreturn_vals, &nreturn_vals,
@ -1060,7 +1060,7 @@ gimp_image_get_resolution (gint32 image_ID,
double *yresolution) double *yresolution)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
double xres; double xres;
double yres; double yres;
@ -1093,7 +1093,7 @@ gimp_image_set_resolution (gint32 image_ID,
double yresolution) double yresolution)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_resolution", return_vals = gimp_run_procedure ("gimp_image_set_resolution",
&nreturn_vals, &nreturn_vals,
@ -1109,7 +1109,7 @@ GimpUnit
gimp_image_get_unit (gint32 image_ID) gimp_image_get_unit (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
GimpUnit unit; GimpUnit unit;
return_vals = gimp_run_procedure ("gimp_image_get_unit", return_vals = gimp_run_procedure ("gimp_image_get_unit",
@ -1133,7 +1133,7 @@ gimp_image_set_unit (gint32 image_ID,
GimpUnit unit) GimpUnit unit)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_image_set_unit", return_vals = gimp_run_procedure ("gimp_image_set_unit",
&nreturn_vals, &nreturn_vals,
@ -1149,7 +1149,7 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID,
gint32 tattoo) gint32 tattoo)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 layer = 0; gint32 layer = 0;
return_vals = gimp_run_procedure ("gimp_image_get_layer_by_tattoo", return_vals = gimp_run_procedure ("gimp_image_get_layer_by_tattoo",
@ -1172,7 +1172,7 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID,
gint32 tattoo) gint32 tattoo)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
gint32 channel = 0; gint32 channel = 0;
return_vals = gimp_run_procedure ("gimp_image_get_channel_by_tattoo", return_vals = gimp_run_procedure ("gimp_image_get_channel_by_tattoo",
@ -1197,7 +1197,7 @@ gimp_image_get_thumbnail_data (gint32 image_ID,
gint *bytes) gint *bytes)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
guchar *image_data = NULL; guchar *image_data = NULL;
return_vals = gimp_run_procedure ("gimp_image_thumbnail", return_vals = gimp_run_procedure ("gimp_image_thumbnail",
@ -1225,7 +1225,7 @@ void
gimp_image_convert_rgb (gint32 image_ID) gimp_image_convert_rgb (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_convert_rgb", return_vals = gimp_run_procedure ("gimp_convert_rgb",
&nreturn_vals, &nreturn_vals,
@ -1239,7 +1239,7 @@ void
gimp_image_convert_grayscale (gint32 image_ID) gimp_image_convert_grayscale (gint32 image_ID)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_convert_grayscale", return_vals = gimp_run_procedure ("gimp_convert_grayscale",
&nreturn_vals, &nreturn_vals,
@ -1259,7 +1259,7 @@ gimp_image_convert_indexed (gint32 image_ID,
gchar *palette) gchar *palette)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_convert_indexed", return_vals = gimp_run_procedure ("gimp_convert_indexed",
&nreturn_vals, &nreturn_vals,

18
libgimp/gimpparasite_pdb.c
View file

@ -22,10 +22,10 @@
#include "gimp.h" #include "gimp.h"
Parasite * Parasite *
gimp_parasite_find (const char *name) gimp_parasite_find (const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *parasite; Parasite *parasite;
return_vals = gimp_run_procedure ("gimp_parasite_find", return_vals = gimp_run_procedure ("gimp_parasite_find",
&nreturn_vals, &nreturn_vals,
@ -49,7 +49,7 @@ void
gimp_parasite_attach (const Parasite *p) gimp_parasite_attach (const Parasite *p)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_parasite_attach", return_vals = gimp_run_procedure ("gimp_parasite_attach",
&nreturn_vals, &nreturn_vals,
@ -60,11 +60,13 @@ gimp_parasite_attach (const Parasite *p)
} }
void void
gimp_attach_new_parasite (const char *name, int flags, gimp_attach_new_parasite (const gchar *name,
int size, const void *data) gint flags,
gint size,
const gpointer data)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
Parasite *p = parasite_new(name, flags, size, data); Parasite *p = parasite_new(name, flags, size, data);
return_vals = gimp_run_procedure ("gimp_parasite_attach", return_vals = gimp_run_procedure ("gimp_parasite_attach",
@ -77,10 +79,10 @@ gimp_attach_new_parasite (const char *name, int flags,
} }
void void
gimp_parasite_detach (const char *name) gimp_parasite_detach (const gchar *name)
{ {
GParam *return_vals; GParam *return_vals;
int nreturn_vals; gint nreturn_vals;
return_vals = gimp_run_procedure ("gimp_parasite_detach", return_vals = gimp_run_procedure ("gimp_parasite_detach",
&nreturn_vals, &nreturn_vals,

5
libgimp/gimpprocbrowserdialog.c
View file

@ -130,8 +130,9 @@ gimp_db_browser (void (* apply_callback) (gchar *selected_proc_name,
{ {
dbbrowser_t* dbbrowser; dbbrowser_t* dbbrowser;
GtkWidget *button; GtkWidget *hbox;
GtkWidget *hbox,*searchhbox,*vbox; GtkWidget *searchhbox;
GtkWidget *vbox;
GtkWidget *label; GtkWidget *label;
dbbrowser = g_new (dbbrowser_t, 1); dbbrowser = g_new (dbbrowser_t, 1);

5
libgimp/gimpprocview.c
View file

@ -130,8 +130,9 @@ gimp_db_browser (void (* apply_callback) (gchar *selected_proc_name,
{ {
dbbrowser_t* dbbrowser; dbbrowser_t* dbbrowser;
GtkWidget *button; GtkWidget *hbox;
GtkWidget *hbox,*searchhbox,*vbox; GtkWidget *searchhbox;
GtkWidget *vbox;
GtkWidget *label; GtkWidget *label;
dbbrowser = g_new (dbbrowser_t, 1); dbbrowser = g_new (dbbrowser_t, 1);

2
plug-ins/common/autocrop.c
View file

@ -46,8 +46,6 @@ GPlugInInfo PLUG_IN_INFO =
}; };
static gint bytes; static gint bytes;
static gint sx1, sy1, sx2, sy2;
static gint run_flag = FALSE;
MAIN() MAIN()

5
plug-ins/dbbrowser/dbbrowser_utils.c
View file

@ -130,8 +130,9 @@ gimp_db_browser (void (* apply_callback) (gchar *selected_proc_name,
{ {
dbbrowser_t* dbbrowser; dbbrowser_t* dbbrowser;
GtkWidget *button; GtkWidget *hbox;
GtkWidget *hbox,*searchhbox,*vbox; GtkWidget *searchhbox;
GtkWidget *vbox;
GtkWidget *label; GtkWidget *label;
dbbrowser = g_new (dbbrowser_t, 1); dbbrowser = g_new (dbbrowser_t, 1);

5
plug-ins/dbbrowser/gimpprocbrowser.c
View file

@ -130,8 +130,9 @@ gimp_db_browser (void (* apply_callback) (gchar *selected_proc_name,
{ {
dbbrowser_t* dbbrowser; dbbrowser_t* dbbrowser;
GtkWidget *button; GtkWidget *hbox;
GtkWidget *hbox,*searchhbox,*vbox; GtkWidget *searchhbox;
GtkWidget *vbox;
GtkWidget *label; GtkWidget *label;
dbbrowser = g_new (dbbrowser_t, 1); dbbrowser = g_new (dbbrowser_t, 1);

5
plug-ins/dbbrowser/gimpprocview.c
View file

@ -130,8 +130,9 @@ gimp_db_browser (void (* apply_callback) (gchar *selected_proc_name,
{ {
dbbrowser_t* dbbrowser; dbbrowser_t* dbbrowser;
GtkWidget *button; GtkWidget *hbox;
GtkWidget *hbox,*searchhbox,*vbox; GtkWidget *searchhbox;
GtkWidget *vbox;
GtkWidget *label; GtkWidget *label;
dbbrowser = g_new (dbbrowser_t, 1); dbbrowser = g_new (dbbrowser_t, 1);