diff options
Diffstat (limited to '')
| -rw-r--r-- | libgimpbase/gimpprotocol.c | 1934 |
1 files changed, 1934 insertions, 0 deletions
diff --git a/libgimpbase/gimpprotocol.c b/libgimpbase/gimpprotocol.c new file mode 100644 index 0000000..ded796b --- /dev/null +++ b/libgimpbase/gimpprotocol.c @@ -0,0 +1,1934 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball + * + * This library is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <glib-object.h> + +#include "gimpbasetypes.h" + +#include "gimpparasite.h" +#include "gimpprotocol.h" +#include "gimpwire.h" + + +static void _gp_quit_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_quit_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_quit_destroy (GimpWireMessage *msg); + +static void _gp_config_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_config_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_config_destroy (GimpWireMessage *msg); + +static void _gp_tile_req_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_tile_req_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_tile_req_destroy (GimpWireMessage *msg); + +static void _gp_tile_ack_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_tile_ack_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_tile_ack_destroy (GimpWireMessage *msg); + +static void _gp_tile_data_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_tile_data_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_tile_data_destroy (GimpWireMessage *msg); + +static void _gp_proc_run_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_run_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_run_destroy (GimpWireMessage *msg); + +static void _gp_proc_return_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_return_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_return_destroy (GimpWireMessage *msg); + +static void _gp_temp_proc_run_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_temp_proc_run_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_temp_proc_run_destroy (GimpWireMessage *msg); + +static void _gp_temp_proc_return_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_temp_proc_return_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_temp_proc_return_destroy (GimpWireMessage *msg); + +static void _gp_proc_install_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_install_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_install_destroy (GimpWireMessage *msg); + +static void _gp_proc_uninstall_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_uninstall_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_proc_uninstall_destroy (GimpWireMessage *msg); + +static void _gp_extension_ack_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_extension_ack_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_extension_ack_destroy (GimpWireMessage *msg); + +static void _gp_params_read (GIOChannel *channel, + GPParam **params, + guint *nparams, + gpointer user_data); +static void _gp_params_write (GIOChannel *channel, + GPParam *params, + gint nparams, + gpointer user_data); + +static void _gp_has_init_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_has_init_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data); +static void _gp_has_init_destroy (GimpWireMessage *msg); + + + +void +gp_init (void) +{ + gimp_wire_register (GP_QUIT, + _gp_quit_read, + _gp_quit_write, + _gp_quit_destroy); + gimp_wire_register (GP_CONFIG, + _gp_config_read, + _gp_config_write, + _gp_config_destroy); + gimp_wire_register (GP_TILE_REQ, + _gp_tile_req_read, + _gp_tile_req_write, + _gp_tile_req_destroy); + gimp_wire_register (GP_TILE_ACK, + _gp_tile_ack_read, + _gp_tile_ack_write, + _gp_tile_ack_destroy); + gimp_wire_register (GP_TILE_DATA, + _gp_tile_data_read, + _gp_tile_data_write, + _gp_tile_data_destroy); + gimp_wire_register (GP_PROC_RUN, + _gp_proc_run_read, + _gp_proc_run_write, + _gp_proc_run_destroy); + gimp_wire_register (GP_PROC_RETURN, + _gp_proc_return_read, + _gp_proc_return_write, + _gp_proc_return_destroy); + gimp_wire_register (GP_TEMP_PROC_RUN, + _gp_temp_proc_run_read, + _gp_temp_proc_run_write, + _gp_temp_proc_run_destroy); + gimp_wire_register (GP_TEMP_PROC_RETURN, + _gp_temp_proc_return_read, + _gp_temp_proc_return_write, + _gp_temp_proc_return_destroy); + gimp_wire_register (GP_PROC_INSTALL, + _gp_proc_install_read, + _gp_proc_install_write, + _gp_proc_install_destroy); + gimp_wire_register (GP_PROC_UNINSTALL, + _gp_proc_uninstall_read, + _gp_proc_uninstall_write, + _gp_proc_uninstall_destroy); + gimp_wire_register (GP_EXTENSION_ACK, + _gp_extension_ack_read, + _gp_extension_ack_write, + _gp_extension_ack_destroy); + gimp_wire_register (GP_HAS_INIT, + _gp_has_init_read, + _gp_has_init_write, + _gp_has_init_destroy); +} + +gboolean +gp_quit_write (GIOChannel *channel, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_QUIT; + msg.data = NULL; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_config_write (GIOChannel *channel, + GPConfig *config, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_CONFIG; + msg.data = config; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_tile_req_write (GIOChannel *channel, + GPTileReq *tile_req, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_TILE_REQ; + msg.data = tile_req; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_tile_ack_write (GIOChannel *channel, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_TILE_ACK; + msg.data = NULL; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_tile_data_write (GIOChannel *channel, + GPTileData *tile_data, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_TILE_DATA; + msg.data = tile_data; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_proc_run_write (GIOChannel *channel, + GPProcRun *proc_run, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_PROC_RUN; + msg.data = proc_run; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_proc_return_write (GIOChannel *channel, + GPProcReturn *proc_return, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_PROC_RETURN; + msg.data = proc_return; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_temp_proc_run_write (GIOChannel *channel, + GPProcRun *proc_run, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_TEMP_PROC_RUN; + msg.data = proc_run; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_temp_proc_return_write (GIOChannel *channel, + GPProcReturn *proc_return, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_TEMP_PROC_RETURN; + msg.data = proc_return; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_proc_install_write (GIOChannel *channel, + GPProcInstall *proc_install, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_PROC_INSTALL; + msg.data = proc_install; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_proc_uninstall_write (GIOChannel *channel, + GPProcUninstall *proc_uninstall, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_PROC_UNINSTALL; + msg.data = proc_uninstall; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_extension_ack_write (GIOChannel *channel, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_EXTENSION_ACK; + msg.data = NULL; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +gboolean +gp_has_init_write (GIOChannel *channel, + gpointer user_data) +{ + GimpWireMessage msg; + + msg.type = GP_HAS_INIT; + msg.data = NULL; + + if (! gimp_wire_write_msg (channel, &msg, user_data)) + return FALSE; + + if (! gimp_wire_flush (channel, user_data)) + return FALSE; + + return TRUE; +} + +/* quit */ + +static void +_gp_quit_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_quit_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_quit_destroy (GimpWireMessage *msg) +{ +} + +/* config */ + +static void +_gp_config_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPConfig *config = g_slice_new0 (GPConfig); + + if (! _gimp_wire_read_int32 (channel, + &config->version, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &config->tile_width, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &config->tile_height, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &config->shm_ID, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->check_size, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->check_type, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->show_help_button, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->use_cpu_accel, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->use_opencl, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->export_exif, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->export_xmp, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->export_iptc, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->export_profile, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int8 (channel, + (guint8 *) &config->show_tooltips, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &config->min_colors, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &config->gdisp_ID, 1, user_data)) + goto cleanup; + + if (! _gimp_wire_read_string (channel, + &config->app_name, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &config->wm_class, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &config->display_name, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &config->monitor_number, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &config->timestamp, 1, user_data)) + goto cleanup; + + if (config->version < 0x0017) + goto end; + + if (! _gimp_wire_read_string (channel, + &config->icon_theme_dir, 1, user_data)) + goto cleanup; + + if (config->version < 0x0019) + goto end; + + if (! _gimp_wire_read_int64 (channel, + &config->tile_cache_size, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &config->swap_path, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &config->num_processors, 1, + user_data)) + goto cleanup; + + if (config->version < 0x001A) + goto end; + + if (! _gimp_wire_read_string (channel, + &config->swap_compression, 1, user_data)) + goto cleanup; + + end: + msg->data = config; + return; + + cleanup: + g_free (config->app_name); + g_free (config->wm_class); + g_free (config->display_name); + g_free (config->icon_theme_dir); + g_free (config->swap_path); + g_free (config->swap_compression); + g_slice_free (GPConfig, config); +} + +static void +_gp_config_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPConfig *config = msg->data; + + if (! _gimp_wire_write_int32 (channel, + &config->version, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &config->tile_width, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &config->tile_height, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &config->shm_ID, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->check_size, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->check_type, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->show_help_button, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->use_cpu_accel, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->use_opencl, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->export_exif, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->export_xmp, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->export_iptc, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->export_profile, 1, + user_data)) + return; + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) &config->show_tooltips, 1, + user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &config->min_colors, 1, + user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &config->gdisp_ID, 1, + user_data)) + return; + if (! _gimp_wire_write_string (channel, + &config->app_name, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &config->wm_class, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &config->display_name, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &config->monitor_number, 1, + user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &config->timestamp, 1, + user_data)) + return; + + if (config->version < 0x0017) + return; + + if (! _gimp_wire_write_string (channel, + &config->icon_theme_dir, 1, user_data)) + return; + + if (config->version < 0x0019) + return; + + if (! _gimp_wire_write_int64 (channel, + &config->tile_cache_size, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &config->swap_path, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &config->num_processors, 1, + user_data)) + return; + + if (config->version < 0x001A) + return; + + if (! _gimp_wire_write_string (channel, + &config->swap_compression, 1, user_data)) + return; +} + +static void +_gp_config_destroy (GimpWireMessage *msg) +{ + GPConfig *config = msg->data; + + if (config) + { + g_free (config->app_name); + g_free (config->wm_class); + g_free (config->display_name); + g_free (config->icon_theme_dir); + g_free (config->swap_path); + g_free (config->swap_compression); + g_slice_free (GPConfig, config); + } +} + +/* tile_req */ + +static void +_gp_tile_req_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPTileReq *tile_req = g_slice_new0 (GPTileReq); + + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &tile_req->drawable_ID, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_req->tile_num, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_req->shadow, 1, user_data)) + goto cleanup; + + msg->data = tile_req; + return; + + cleanup: + g_slice_free (GPTileReq, tile_req); + msg->data = NULL; +} + +static void +_gp_tile_req_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPTileReq *tile_req = msg->data; + + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &tile_req->drawable_ID, 1, + user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_req->tile_num, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_req->shadow, 1, user_data)) + return; +} + +static void +_gp_tile_req_destroy (GimpWireMessage *msg) +{ + GPTileReq *tile_req = msg->data; + + if (tile_req) + g_slice_free (GPTileReq, msg->data); +} + +/* tile_ack */ + +static void +_gp_tile_ack_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_tile_ack_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_tile_ack_destroy (GimpWireMessage *msg) +{ +} + +/* tile_data */ + +static void +_gp_tile_data_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPTileData *tile_data = g_slice_new0 (GPTileData); + + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &tile_data->drawable_ID, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_data->tile_num, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_data->shadow, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_data->bpp, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_data->width, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_data->height, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &tile_data->use_shm, 1, user_data)) + goto cleanup; + + if (!tile_data->use_shm) + { + guint length = tile_data->width * tile_data->height * tile_data->bpp; + + tile_data->data = g_new (guchar, length); + + if (! _gimp_wire_read_int8 (channel, + (guint8 *) tile_data->data, length, + user_data)) + goto cleanup; + } + + msg->data = tile_data; + return; + + cleanup: + g_free (tile_data->data); + g_slice_free (GPTileData, tile_data); + msg->data = NULL; +} + +static void +_gp_tile_data_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPTileData *tile_data = msg->data; + + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &tile_data->drawable_ID, 1, + user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_data->tile_num, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_data->shadow, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_data->bpp, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_data->width, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_data->height, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &tile_data->use_shm, 1, user_data)) + return; + + if (!tile_data->use_shm) + { + guint length = tile_data->width * tile_data->height * tile_data->bpp; + + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) tile_data->data, length, + user_data)) + return; + } +} + +static void +_gp_tile_data_destroy (GimpWireMessage *msg) +{ + GPTileData *tile_data = msg->data; + + if (tile_data) + { + if (tile_data->data) + { + g_free (tile_data->data); + tile_data->data = NULL; + } + + g_slice_free (GPTileData, tile_data); + } +} + +/* proc_run */ + +static void +_gp_proc_run_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcRun *proc_run = g_slice_new0 (GPProcRun); + + if (! _gimp_wire_read_string (channel, &proc_run->name, 1, user_data)) + goto cleanup; + + _gp_params_read (channel, + &proc_run->params, (guint *) &proc_run->nparams, + user_data); + + msg->data = proc_run; + return; + + cleanup: + g_slice_free (GPProcRun, proc_run); + msg->data = NULL; +} + +static void +_gp_proc_run_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcRun *proc_run = msg->data; + + if (! _gimp_wire_write_string (channel, &proc_run->name, 1, user_data)) + return; + + _gp_params_write (channel, proc_run->params, proc_run->nparams, user_data); +} + +static void +_gp_proc_run_destroy (GimpWireMessage *msg) +{ + GPProcRun *proc_run = msg->data; + + if (proc_run) + { + gp_params_destroy (proc_run->params, proc_run->nparams); + + g_free (proc_run->name); + g_slice_free (GPProcRun, proc_run); + } +} + +/* proc_return */ + +static void +_gp_proc_return_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcReturn *proc_return = g_slice_new0 (GPProcReturn); + + if (! _gimp_wire_read_string (channel, &proc_return->name, 1, user_data)) + goto cleanup; + + _gp_params_read (channel, + &proc_return->params, (guint *) &proc_return->nparams, + user_data); + + msg->data = proc_return; + return; + + cleanup: + g_slice_free (GPProcReturn, proc_return); + msg->data = NULL; +} + +static void +_gp_proc_return_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcReturn *proc_return = msg->data; + + if (! _gimp_wire_write_string (channel, &proc_return->name, 1, user_data)) + return; + + _gp_params_write (channel, + proc_return->params, proc_return->nparams, user_data); +} + +static void +_gp_proc_return_destroy (GimpWireMessage *msg) +{ + GPProcReturn *proc_return = msg->data; + + if (proc_return) + { + gp_params_destroy (proc_return->params, proc_return->nparams); + + g_free (proc_return->name); + g_slice_free (GPProcReturn, proc_return); + } +} + +/* temp_proc_run */ + +static void +_gp_temp_proc_run_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + _gp_proc_run_read (channel, msg, user_data); +} + +static void +_gp_temp_proc_run_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + _gp_proc_run_write (channel, msg, user_data); +} + +static void +_gp_temp_proc_run_destroy (GimpWireMessage *msg) +{ + _gp_proc_run_destroy (msg); +} + +/* temp_proc_return */ + +static void +_gp_temp_proc_return_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + _gp_proc_return_read (channel, msg, user_data); +} + +static void +_gp_temp_proc_return_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + _gp_proc_return_write (channel, msg, user_data); +} + +static void +_gp_temp_proc_return_destroy (GimpWireMessage *msg) +{ + _gp_proc_return_destroy (msg); +} + +/* proc_install */ + +static void +_gp_proc_install_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcInstall *proc_install = g_slice_new0 (GPProcInstall); + gint i; + + if (! _gimp_wire_read_string (channel, + &proc_install->name, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->blurb, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->help, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->author, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->copyright, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->date, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->menu_path, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->image_types, 1, user_data)) + goto cleanup; + + if (! _gimp_wire_read_int32 (channel, + &proc_install->type, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &proc_install->nparams, 1, user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &proc_install->nreturn_vals, 1, user_data)) + goto cleanup; + + proc_install->params = g_new0 (GPParamDef, proc_install->nparams); + + for (i = 0; i < proc_install->nparams; i++) + { + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &proc_install->params[i].type, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->params[i].name, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->params[i].description, 1, + user_data)) + goto cleanup; + } + + proc_install->return_vals = g_new0 (GPParamDef, proc_install->nreturn_vals); + + for (i = 0; i < proc_install->nreturn_vals; i++) + { + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &proc_install->return_vals[i].type, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->return_vals[i].name, 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_string (channel, + &proc_install->return_vals[i].description, 1, + user_data)) + goto cleanup; + } + + msg->data = proc_install; + return; + + cleanup: + g_free (proc_install->name); + g_free (proc_install->blurb); + g_free (proc_install->help); + g_free (proc_install->author); + g_free (proc_install->copyright); + g_free (proc_install->date); + g_free (proc_install->menu_path); + g_free (proc_install->image_types); + + if (proc_install->params) + { + for (i = 0; i < proc_install->nparams; i++) + { + if (!proc_install->params[i].name) + break; + + g_free (proc_install->params[i].name); + g_free (proc_install->params[i].description); + } + + g_free (proc_install->params); + } + + if (proc_install->return_vals) + { + for (i = 0; i < proc_install->nreturn_vals; i++) + { + if (!proc_install->return_vals[i].name) + break; + + g_free (proc_install->return_vals[i].name); + g_free (proc_install->return_vals[i].description); + } + + g_free (proc_install->return_vals); + } + + g_slice_free (GPProcInstall, proc_install); + msg->data = NULL; +} + +static void +_gp_proc_install_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcInstall *proc_install = msg->data; + gint i; + + if (! _gimp_wire_write_string (channel, + &proc_install->name, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->blurb, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->help, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->author, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->copyright, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->date, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->menu_path, 1, user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->image_types, 1, user_data)) + return; + + if (! _gimp_wire_write_int32 (channel, + &proc_install->type, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &proc_install->nparams, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, + &proc_install->nreturn_vals, 1, user_data)) + return; + + for (i = 0; i < proc_install->nparams; i++) + { + if (! _gimp_wire_write_int32 (channel, + (guint32 *) &proc_install->params[i].type, 1, + user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->params[i].name, 1, + user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->params[i].description, 1, + user_data)) + return; + } + + for (i = 0; i < proc_install->nreturn_vals; i++) + { + if (! _gimp_wire_write_int32 (channel, + (guint32 *) &proc_install->return_vals[i].type, 1, + user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->return_vals[i].name, 1, + user_data)) + return; + if (! _gimp_wire_write_string (channel, + &proc_install->return_vals[i].description, 1, + user_data)) + return; + } +} + +static void +_gp_proc_install_destroy (GimpWireMessage *msg) +{ + GPProcInstall *proc_install = msg->data; + + if (proc_install) + { + gint i; + + g_free (proc_install->name); + g_free (proc_install->blurb); + g_free (proc_install->help); + g_free (proc_install->author); + g_free (proc_install->copyright); + g_free (proc_install->date); + g_free (proc_install->menu_path); + g_free (proc_install->image_types); + + for (i = 0; i < proc_install->nparams; i++) + { + g_free (proc_install->params[i].name); + g_free (proc_install->params[i].description); + } + + for (i = 0; i < proc_install->nreturn_vals; i++) + { + g_free (proc_install->return_vals[i].name); + g_free (proc_install->return_vals[i].description); + } + + g_free (proc_install->params); + g_free (proc_install->return_vals); + g_slice_free (GPProcInstall, proc_install); + } +} + +/* proc_uninstall */ + +static void +_gp_proc_uninstall_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcUninstall *proc_uninstall = g_slice_new0 (GPProcUninstall); + + if (! _gimp_wire_read_string (channel, &proc_uninstall->name, 1, user_data)) + goto cleanup; + + msg->data = proc_uninstall; + return; + + cleanup: + g_slice_free (GPProcUninstall, proc_uninstall); +} + +static void +_gp_proc_uninstall_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ + GPProcUninstall *proc_uninstall = msg->data; + + if (! _gimp_wire_write_string (channel, &proc_uninstall->name, 1, user_data)) + return; +} + +static void +_gp_proc_uninstall_destroy (GimpWireMessage *msg) +{ + GPProcUninstall *proc_uninstall = msg->data; + + if (proc_uninstall) + { + g_free (proc_uninstall->name); + g_slice_free (GPProcUninstall, proc_uninstall); + } +} + +/* extension_ack */ + +static void +_gp_extension_ack_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_extension_ack_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_extension_ack_destroy (GimpWireMessage *msg) +{ +} + +/* params */ + +static void +_gp_params_read (GIOChannel *channel, + GPParam **params, + guint *nparams, + gpointer user_data) +{ + gint i, j; + + if (! _gimp_wire_read_int32 (channel, (guint32 *) nparams, 1, user_data)) + return; + + if (*nparams == 0) + { + *params = NULL; + return; + } + + *params = g_new0 (GPParam, *nparams); + + for (i = 0; i < *nparams; i++) + { + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].type, 1, + user_data)) + goto cleanup; + + switch ((*params)[i].type) + { + case GIMP_PDB_INT32: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_int32, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_INT16: + if (! _gimp_wire_read_int16 (channel, + (guint16 *) &(*params)[i].data.d_int16, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_INT8: + if (! _gimp_wire_read_int8 (channel, + &(*params)[i].data.d_int8, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_FLOAT: + if (! _gimp_wire_read_double (channel, + &(*params)[i].data.d_float, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_STRING: + if (! _gimp_wire_read_string (channel, + &(*params)[i].data.d_string, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_INT32ARRAY: + (*params)[i-1].data.d_int32 = MAX (0, (*params)[i-1].data.d_int32); + (*params)[i].data.d_int32array = g_new (gint32, + (*params)[i-1].data.d_int32); + + if (! _gimp_wire_read_int32 (channel, + (guint32 *) (*params)[i].data.d_int32array, + (*params)[i-1].data.d_int32, + user_data)) + { + g_free ((*params)[i].data.d_int32array); + goto cleanup; + } + break; + + case GIMP_PDB_INT16ARRAY: + (*params)[i-1].data.d_int32 = MAX (0, (*params)[i-1].data.d_int32); + (*params)[i].data.d_int16array = g_new (gint16, + (*params)[i-1].data.d_int32); + if (! _gimp_wire_read_int16 (channel, + (guint16 *) (*params)[i].data.d_int16array, + (*params)[i-1].data.d_int32, + user_data)) + { + g_free ((*params)[i].data.d_int16array); + goto cleanup; + } + break; + + case GIMP_PDB_INT8ARRAY: + (*params)[i-1].data.d_int32 = MAX (0, (*params)[i-1].data.d_int32); + (*params)[i].data.d_int8array = g_new (guint8, + (*params)[i-1].data.d_int32); + if (! _gimp_wire_read_int8 (channel, + (*params)[i].data.d_int8array, + (*params)[i-1].data.d_int32, + user_data)) + { + g_free ((*params)[i].data.d_int8array); + goto cleanup; + } + break; + + case GIMP_PDB_FLOATARRAY: + (*params)[i-1].data.d_int32 = MAX (0, (*params)[i-1].data.d_int32); + (*params)[i].data.d_floatarray = g_new (gdouble, + (*params)[i-1].data.d_int32); + if (! _gimp_wire_read_double (channel, + (*params)[i].data.d_floatarray, + (*params)[i-1].data.d_int32, + user_data)) + { + g_free ((*params)[i].data.d_floatarray); + goto cleanup; + } + break; + + case GIMP_PDB_STRINGARRAY: + (*params)[i-1].data.d_int32 = MAX (0, (*params)[i-1].data.d_int32); + (*params)[i].data.d_stringarray = g_new0 (gchar *, + (*params)[i-1].data.d_int32); + if (! _gimp_wire_read_string (channel, + (*params)[i].data.d_stringarray, + (*params)[i-1].data.d_int32, + user_data)) + { + for (j = 0; j < (*params)[i-1].data.d_int32; j++) + g_free (((*params)[i].data.d_stringarray)[j]); + g_free ((*params)[i].data.d_stringarray); + goto cleanup; + } + break; + + case GIMP_PDB_COLOR: + if (! _gimp_wire_read_color (channel, + &(*params)[i].data.d_color, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_ITEM: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_item, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_DISPLAY: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_display, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_IMAGE: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_image, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_LAYER: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_layer, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_CHANNEL: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_channel, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_DRAWABLE: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_drawable, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_SELECTION: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_selection, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_COLORARRAY: + (*params)[i].data.d_colorarray = g_new (GimpRGB, + (*params)[i-1].data.d_int32); + if (! _gimp_wire_read_color (channel, + (*params)[i].data.d_colorarray, + (*params)[i-1].data.d_int32, + user_data)) + { + g_free ((*params)[i].data.d_colorarray); + goto cleanup; + } + break; + + case GIMP_PDB_VECTORS: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_vectors, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_PARASITE: + if (! _gimp_wire_read_string (channel, + &(*params)[i].data.d_parasite.name, 1, + user_data)) + goto cleanup; + if ((*params)[i].data.d_parasite.name == NULL) + { + /* we have a null parasite */ + (*params)[i].data.d_parasite.data = NULL; + break; + } + if (! _gimp_wire_read_int32 (channel, + &((*params)[i].data.d_parasite.flags), 1, + user_data)) + goto cleanup; + if (! _gimp_wire_read_int32 (channel, + &((*params)[i].data.d_parasite.size), 1, + user_data)) + goto cleanup; + if ((*params)[i].data.d_parasite.size > 0) + { + (*params)[i].data.d_parasite.data = + g_malloc ((*params)[i].data.d_parasite.size); + if (! _gimp_wire_read_int8 (channel, + (*params)[i].data.d_parasite.data, + (*params)[i].data.d_parasite.size, + user_data)) + { + g_free ((*params)[i].data.d_parasite.data); + goto cleanup; + } + } + else + (*params)[i].data.d_parasite.data = NULL; + break; + + case GIMP_PDB_STATUS: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_status, 1, + user_data)) + goto cleanup; + break; + + case GIMP_PDB_END: + break; + } + } + + return; + + cleanup: + *nparams = 0; + g_free (*params); + *params = NULL; +} + +static void +_gp_params_write (GIOChannel *channel, + GPParam *params, + gint nparams, + gpointer user_data) +{ + gint i; + + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) &nparams, 1, user_data)) + return; + + for (i = 0; i < nparams; i++) + { + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].type, 1, + user_data)) + return; + + switch (params[i].type) + { + case GIMP_PDB_INT32: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_int32, 1, + user_data)) + return; + break; + + case GIMP_PDB_INT16: + if (! _gimp_wire_write_int16 (channel, + (const guint16 *) ¶ms[i].data.d_int16, 1, + user_data)) + return; + break; + + case GIMP_PDB_INT8: + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) ¶ms[i].data.d_int8, 1, + user_data)) + return; + break; + + case GIMP_PDB_FLOAT: + if (! _gimp_wire_write_double (channel, + ¶ms[i].data.d_float, 1, + user_data)) + return; + break; + + case GIMP_PDB_STRING: + if (! _gimp_wire_write_string (channel, + ¶ms[i].data.d_string, 1, + user_data)) + return; + break; + + case GIMP_PDB_INT32ARRAY: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) params[i].data.d_int32array, + params[i-1].data.d_int32, + user_data)) + return; + break; + + case GIMP_PDB_INT16ARRAY: + if (! _gimp_wire_write_int16 (channel, + (const guint16 *) params[i].data.d_int16array, + params[i-1].data.d_int32, + user_data)) + return; + break; + + case GIMP_PDB_INT8ARRAY: + if (! _gimp_wire_write_int8 (channel, + (const guint8 *) params[i].data.d_int8array, + params[i-1].data.d_int32, + user_data)) + return; + break; + + case GIMP_PDB_FLOATARRAY: + if (! _gimp_wire_write_double (channel, + params[i].data.d_floatarray, + params[i-1].data.d_int32, + user_data)) + return; + break; + + case GIMP_PDB_STRINGARRAY: + if (! _gimp_wire_write_string (channel, + params[i].data.d_stringarray, + params[i-1].data.d_int32, + user_data)) + return; + break; + + case GIMP_PDB_COLOR: + if (! _gimp_wire_write_color (channel, + ¶ms[i].data.d_color, 1, user_data)) + return; + break; + + case GIMP_PDB_ITEM: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_item, 1, + user_data)) + return; + break; + + case GIMP_PDB_DISPLAY: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_display, 1, + user_data)) + return; + break; + + case GIMP_PDB_IMAGE: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_image, 1, + user_data)) + return; + break; + + case GIMP_PDB_LAYER: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_layer, 1, + user_data)) + return; + break; + + case GIMP_PDB_CHANNEL: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_channel, 1, + user_data)) + return; + break; + + case GIMP_PDB_DRAWABLE: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_drawable, 1, + user_data)) + return; + break; + + case GIMP_PDB_SELECTION: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_selection, 1, + user_data)) + return; + break; + + case GIMP_PDB_COLORARRAY: + if (! _gimp_wire_write_color (channel, + params[i].data.d_colorarray, + params[i-1].data.d_int32, + user_data)) + return; + break; + + case GIMP_PDB_VECTORS: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_vectors, 1, + user_data)) + return; + break; + + case GIMP_PDB_PARASITE: + { + GimpParasite *p = ¶ms[i].data.d_parasite; + + if (p->name == NULL) + { + /* write a null string to signal a null parasite */ + _gimp_wire_write_string (channel, &p->name, 1, user_data); + break; + } + + if (! _gimp_wire_write_string (channel, &p->name, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, &p->flags, 1, user_data)) + return; + if (! _gimp_wire_write_int32 (channel, &p->size, 1, user_data)) + return; + if (p->size > 0) + { + if (! _gimp_wire_write_int8 (channel, + p->data, p->size, user_data)) + return; + } + } + break; + + case GIMP_PDB_STATUS: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_status, 1, + user_data)) + return; + break; + + case GIMP_PDB_END: + break; + } + } +} + +void +gp_params_destroy (GPParam *params, + gint nparams) +{ + gint i; + + for (i = 0; i < nparams; i++) + { + switch (params[i].type) + { + case GIMP_PDB_INT32: + case GIMP_PDB_INT16: + case GIMP_PDB_INT8: + case GIMP_PDB_FLOAT: + case GIMP_PDB_COLOR: + case GIMP_PDB_ITEM: + case GIMP_PDB_DISPLAY: + case GIMP_PDB_IMAGE: + case GIMP_PDB_LAYER: + case GIMP_PDB_CHANNEL: + case GIMP_PDB_DRAWABLE: + case GIMP_PDB_SELECTION: + case GIMP_PDB_VECTORS: + case GIMP_PDB_STATUS: + break; + + case GIMP_PDB_STRING: + g_free (params[i].data.d_string); + break; + + case GIMP_PDB_INT32ARRAY: + g_free (params[i].data.d_int32array); + break; + + case GIMP_PDB_INT16ARRAY: + g_free (params[i].data.d_int16array); + break; + + case GIMP_PDB_INT8ARRAY: + g_free (params[i].data.d_int8array); + break; + + case GIMP_PDB_FLOATARRAY: + g_free (params[i].data.d_floatarray); + break; + + case GIMP_PDB_STRINGARRAY: + if ((i > 0) && (params[i-1].type == GIMP_PDB_INT32)) + { + gint count = params[i-1].data.d_int32; + gint j; + + for (j = 0; j < count; j++) + g_free (params[i].data.d_stringarray[j]); + + g_free (params[i].data.d_stringarray); + } + break; + + case GIMP_PDB_COLORARRAY: + g_free (params[i].data.d_colorarray); + break; + + case GIMP_PDB_PARASITE: + if (params[i].data.d_parasite.name) + g_free (params[i].data.d_parasite.name); + if (params[i].data.d_parasite.data) + g_free (params[i].data.d_parasite.data); + break; + + case GIMP_PDB_END: + break; + } + } + + g_free (params); +} + +/* has_init */ + +static void +_gp_has_init_read (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_has_init_write (GIOChannel *channel, + GimpWireMessage *msg, + gpointer user_data) +{ +} + +static void +_gp_has_init_destroy (GimpWireMessage *msg) +{ +} |