summaryrefslogtreecommitdiffstats
path: root/app/xcf/xcf-save.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/xcf/xcf-save.c')
-rw-r--r--app/xcf/xcf-save.c2271
1 files changed, 2271 insertions, 0 deletions
diff --git a/app/xcf/xcf-save.c b/app/xcf/xcf-save.c
new file mode 100644
index 0000000..a1c4f71
--- /dev/null
+++ b/app/xcf/xcf-save.c
@@ -0,0 +1,2271 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <zlib.h>
+
+#include <cairo.h>
+#include <gegl.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpcolor/gimpcolor.h"
+
+#include "core/core-types.h"
+
+#include "gegl/gimp-babl-compat.h"
+#include "gegl/gimp-gegl-tile-compat.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpchannel.h"
+#include "core/gimpdrawable.h"
+#include "core/gimpgrid.h"
+#include "core/gimpguide.h"
+#include "core/gimpimage.h"
+#include "core/gimpimage-colormap.h"
+#include "core/gimpimage-grid.h"
+#include "core/gimpimage-guides.h"
+#include "core/gimpimage-metadata.h"
+#include "core/gimpimage-private.h"
+#include "core/gimpimage-sample-points.h"
+#include "core/gimpimage-symmetry.h"
+#include "core/gimplayer.h"
+#include "core/gimplayermask.h"
+#include "core/gimpparasitelist.h"
+#include "core/gimpprogress.h"
+#include "core/gimpsamplepoint.h"
+#include "core/gimpsymmetry.h"
+
+#include "operations/layer-modes/gimp-layer-modes.h"
+
+#include "text/gimptextlayer.h"
+#include "text/gimptextlayer-xcf.h"
+
+#include "vectors/gimpanchor.h"
+#include "vectors/gimpstroke.h"
+#include "vectors/gimpbezierstroke.h"
+#include "vectors/gimpvectors.h"
+#include "vectors/gimpvectors-compat.h"
+
+#include "xcf-private.h"
+#include "xcf-read.h"
+#include "xcf-save.h"
+#include "xcf-seek.h"
+#include "xcf-write.h"
+
+#include "gimp-intl.h"
+
+
+static gboolean xcf_save_image_props (XcfInfo *info,
+ GimpImage *image,
+ GError **error);
+static gboolean xcf_save_layer_props (XcfInfo *info,
+ GimpImage *image,
+ GimpLayer *layer,
+ GError **error);
+static gboolean xcf_save_channel_props (XcfInfo *info,
+ GimpImage *image,
+ GimpChannel *channel,
+ GError **error);
+static gboolean xcf_save_prop (XcfInfo *info,
+ GimpImage *image,
+ PropType prop_type,
+ GError **error,
+ ...);
+static gboolean xcf_save_layer (XcfInfo *info,
+ GimpImage *image,
+ GimpLayer *layer,
+ GError **error);
+static gboolean xcf_save_channel (XcfInfo *info,
+ GimpImage *image,
+ GimpChannel *channel,
+ GError **error);
+static gboolean xcf_save_buffer (XcfInfo *info,
+ GeglBuffer *buffer,
+ GError **error);
+static gboolean xcf_save_level (XcfInfo *info,
+ GeglBuffer *buffer,
+ GError **error);
+static gboolean xcf_save_tile (XcfInfo *info,
+ GeglBuffer *buffer,
+ GeglRectangle *tile_rect,
+ const Babl *format,
+ GError **error);
+static gboolean xcf_save_tile_rle (XcfInfo *info,
+ GeglBuffer *buffer,
+ GeglRectangle *tile_rect,
+ const Babl *format,
+ guchar *rlebuf,
+ GError **error);
+static gboolean xcf_save_tile_zlib (XcfInfo *info,
+ GeglBuffer *buffer,
+ GeglRectangle *tile_rect,
+ const Babl *format,
+ GError **error);
+static gboolean xcf_save_parasite (XcfInfo *info,
+ GimpParasite *parasite,
+ GError **error);
+static gboolean xcf_save_parasite_list (XcfInfo *info,
+ GimpParasiteList *parasite,
+ GError **error);
+static gboolean xcf_save_old_paths (XcfInfo *info,
+ GimpImage *image,
+ GError **error);
+static gboolean xcf_save_vectors (XcfInfo *info,
+ GimpImage *image,
+ GError **error);
+
+
+/* private convenience macros */
+#define xcf_write_int32_check_error(info, data, count) G_STMT_START { \
+ xcf_write_int32 (info, data, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_offset_check_error(info, data, count) G_STMT_START { \
+ xcf_write_offset (info, data, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_zero_offset_check_error(info, count) G_STMT_START { \
+ xcf_write_zero_offset (info, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_int8_check_error(info, data, count) G_STMT_START { \
+ xcf_write_int8 (info, data, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_float_check_error(info, data, count) G_STMT_START { \
+ xcf_write_float (info, data, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_string_check_error(info, data, count) G_STMT_START { \
+ xcf_write_string (info, data, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_component_check_error(info, bpc, data, count) G_STMT_START { \
+ xcf_write_component (info, bpc, data, count, &tmp_error); \
+ if (tmp_error) \
+ { \
+ g_propagate_error (error, tmp_error); \
+ return FALSE; \
+ } \
+ } G_STMT_END
+
+#define xcf_write_prop_type_check_error(info, prop_type) G_STMT_START { \
+ guint32 _prop_int32 = prop_type; \
+ xcf_write_int32_check_error (info, &_prop_int32, 1); \
+ } G_STMT_END
+
+#define xcf_check_error(x) G_STMT_START { \
+ if (! (x)) \
+ return FALSE; \
+ } G_STMT_END
+
+#define xcf_progress_update(info) G_STMT_START \
+ { \
+ progress++; \
+ if (info->progress) \
+ gimp_progress_set_value (info->progress, \
+ (gdouble) progress / (gdouble) max_progress); \
+ } G_STMT_END
+
+
+gboolean
+xcf_save_image (XcfInfo *info,
+ GimpImage *image,
+ GError **error)
+{
+ GList *all_layers;
+ GList *all_channels;
+ GList *list;
+ goffset saved_pos;
+ goffset offset;
+ guint32 value;
+ guint n_layers;
+ guint n_channels;
+ guint progress = 0;
+ guint max_progress;
+ gchar version_tag[16];
+ GError *tmp_error = NULL;
+
+ /* write out the tag information for the image */
+ if (info->file_version > 0)
+ {
+ g_snprintf (version_tag, sizeof (version_tag),
+ "gimp xcf v%03d", info->file_version);
+ }
+ else
+ {
+ strcpy (version_tag, "gimp xcf file");
+ }
+
+ xcf_write_int8_check_error (info, (guint8 *) version_tag, 14);
+
+ /* write out the width, height and image type information for the image */
+ value = gimp_image_get_width (image);
+ xcf_write_int32_check_error (info, (guint32 *) &value, 1);
+
+ value = gimp_image_get_height (image);
+ xcf_write_int32_check_error (info, (guint32 *) &value, 1);
+
+ value = gimp_image_get_base_type (image);
+ xcf_write_int32_check_error (info, &value, 1);
+
+ if (info->file_version >= 4)
+ {
+ value = gimp_image_get_precision (image);
+ xcf_write_int32_check_error (info, &value, 1);
+ }
+
+ /* determine the number of layers and channels in the image */
+ all_layers = gimp_image_get_layer_list (image);
+ all_channels = gimp_image_get_channel_list (image);
+
+ /* check and see if we have to save out the selection */
+ if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
+ {
+ all_channels = g_list_append (all_channels, gimp_image_get_mask (image));
+ }
+
+ n_layers = (guint) g_list_length (all_layers);
+ n_channels = (guint) g_list_length (all_channels);
+
+ max_progress = 1 + n_layers + n_channels;
+
+ /* write the property information for the image */
+ xcf_check_error (xcf_save_image_props (info, image, error));
+
+ xcf_progress_update (info);
+
+ /* 'saved_pos' is the next slot in the offset table */
+ saved_pos = info->cp;
+
+ /* write an empty offset table */
+ xcf_write_zero_offset_check_error (info, n_layers + n_channels + 2);
+
+ /* 'offset' is where we will write the next layer or channel */
+ offset = info->cp;
+
+ for (list = all_layers; list; list = g_list_next (list))
+ {
+ GimpLayer *layer = list->data;
+
+ /* seek back to the next slot in the offset table and write the
+ * offset of the layer
+ */
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ xcf_write_offset_check_error (info, &offset, 1);
+
+ /* remember the next slot in the offset table */
+ saved_pos = info->cp;
+
+ /* seek to the layer offset and save the layer */
+ xcf_check_error (xcf_seek_pos (info, offset, error));
+ xcf_check_error (xcf_save_layer (info, image, layer, error));
+
+ /* the next layer's offset is after the layer we just wrote */
+ offset = info->cp;
+
+ xcf_progress_update (info);
+ }
+
+ /* skip a '0' in the offset table to indicate the end of the layer
+ * offsets
+ */
+ saved_pos += info->bytes_per_offset;
+
+ for (list = all_channels; list; list = g_list_next (list))
+ {
+ GimpChannel *channel = list->data;
+
+ /* seek back to the next slot in the offset table and write the
+ * offset of the channel
+ */
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ xcf_write_offset_check_error (info, &offset, 1);
+
+ /* remember the next slot in the offset table */
+ saved_pos = info->cp;
+
+ /* seek to the channel offset and save the channel */
+ xcf_check_error (xcf_seek_pos (info, offset, error));
+ xcf_check_error (xcf_save_channel (info, image, channel, error));
+
+ /* the next channels's offset is after the channel we just wrote */
+ offset = info->cp;
+
+ xcf_progress_update (info);
+ }
+
+ /* there is already a '0' at the end of the offset table to indicate
+ * the end of the channel offsets
+ */
+
+ g_list_free (all_layers);
+ g_list_free (all_channels);
+
+ return ! g_output_stream_is_closed (info->output);
+}
+
+static gboolean
+xcf_save_image_props (XcfInfo *info,
+ GimpImage *image,
+ GError **error)
+{
+ GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
+ GimpParasite *grid_parasite = NULL;
+ GimpParasite *meta_parasite = NULL;
+ GList *symmetry_parasites = NULL;
+ GList *iter;
+ GimpUnit unit = gimp_image_get_unit (image);
+ gdouble xres;
+ gdouble yres;
+
+ gimp_image_get_resolution (image, &xres, &yres);
+
+ /* check and see if we should save the colormap property */
+ if (gimp_image_get_colormap (image))
+ xcf_check_error (xcf_save_prop (info, image, PROP_COLORMAP, error,
+ gimp_image_get_colormap_size (image),
+ gimp_image_get_colormap (image)));
+
+ if (info->compression != COMPRESS_NONE)
+ xcf_check_error (xcf_save_prop (info, image, PROP_COMPRESSION, error,
+ info->compression));
+
+ if (gimp_image_get_guides (image))
+ xcf_check_error (xcf_save_prop (info, image, PROP_GUIDES, error,
+ gimp_image_get_guides (image)));
+
+ if (gimp_image_get_sample_points (image))
+ {
+ /* save the new property before the old one, so loading can skip
+ * the latter
+ */
+ xcf_check_error (xcf_save_prop (info, image, PROP_SAMPLE_POINTS, error,
+ gimp_image_get_sample_points (image)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_OLD_SAMPLE_POINTS, error,
+ gimp_image_get_sample_points (image)));
+ }
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_RESOLUTION, error,
+ xres, yres));
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_TATTOO, error,
+ gimp_image_get_tattoo_state (image)));
+
+ if (unit < gimp_unit_get_number_of_built_in_units ())
+ xcf_check_error (xcf_save_prop (info, image, PROP_UNIT, error, unit));
+
+ if (gimp_container_get_n_children (gimp_image_get_vectors (image)) > 0)
+ {
+ if (gimp_vectors_compat_is_compatible (image))
+ xcf_check_error (xcf_save_prop (info, image, PROP_PATHS, error));
+ else
+ xcf_check_error (xcf_save_prop (info, image, PROP_VECTORS, error));
+ }
+
+ if (unit >= gimp_unit_get_number_of_built_in_units ())
+ xcf_check_error (xcf_save_prop (info, image, PROP_USER_UNIT, error, unit));
+
+ if (gimp_image_get_grid (image))
+ {
+ GimpGrid *grid = gimp_image_get_grid (image);
+
+ grid_parasite = gimp_grid_to_parasite (grid);
+ gimp_parasite_list_add (private->parasites, grid_parasite);
+ }
+
+ if (gimp_image_get_metadata (image))
+ {
+ GimpMetadata *metadata = gimp_image_get_metadata (image);
+ gchar *meta_string;
+
+ meta_string = gimp_metadata_serialize (metadata);
+
+ if (meta_string)
+ {
+ meta_parasite = gimp_parasite_new ("gimp-image-metadata",
+ GIMP_PARASITE_PERSISTENT,
+ strlen (meta_string) + 1,
+ meta_string);
+ gimp_parasite_list_add (private->parasites, meta_parasite);
+ g_free (meta_string);
+ }
+ }
+
+ if (g_list_length (gimp_image_symmetry_get (image)))
+ {
+ GimpParasite *parasite = NULL;
+ GimpSymmetry *symmetry;
+
+ for (iter = gimp_image_symmetry_get (image); iter; iter = g_list_next (iter))
+ {
+ symmetry = GIMP_SYMMETRY (iter->data);
+ if (G_TYPE_FROM_INSTANCE (symmetry) == GIMP_TYPE_SYMMETRY)
+ /* Do not save the identity symmetry. */
+ continue;
+ parasite = gimp_symmetry_to_parasite (GIMP_SYMMETRY (iter->data));
+ gimp_parasite_list_add (private->parasites, parasite);
+ symmetry_parasites = g_list_prepend (symmetry_parasites, parasite);
+ }
+ }
+
+ if (gimp_parasite_list_length (private->parasites) > 0)
+ {
+ xcf_check_error (xcf_save_prop (info, image, PROP_PARASITES, error,
+ private->parasites));
+ }
+
+ if (grid_parasite)
+ {
+ gimp_parasite_list_remove (private->parasites,
+ gimp_parasite_name (grid_parasite));
+ gimp_parasite_free (grid_parasite);
+ }
+
+ if (meta_parasite)
+ {
+ gimp_parasite_list_remove (private->parasites,
+ gimp_parasite_name (meta_parasite));
+ gimp_parasite_free (meta_parasite);
+ }
+
+ for (iter = symmetry_parasites; iter; iter = g_list_next (iter))
+ {
+ GimpParasite *parasite = iter->data;
+
+ gimp_parasite_list_remove (private->parasites,
+ gimp_parasite_name (parasite));
+ }
+ g_list_free_full (symmetry_parasites,
+ (GDestroyNotify) gimp_parasite_free);
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_END, error));
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_layer_props (XcfInfo *info,
+ GimpImage *image,
+ GimpLayer *layer,
+ GError **error)
+{
+ GimpParasiteList *parasites;
+ gint offset_x;
+ gint offset_y;
+
+ if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
+ xcf_check_error (xcf_save_prop (info, image, PROP_GROUP_ITEM, error));
+
+ if (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)))
+ {
+ GList *path;
+
+ path = gimp_item_get_path (GIMP_ITEM (layer));
+ xcf_check_error (xcf_save_prop (info, image, PROP_ITEM_PATH, error,
+ path));
+ g_list_free (path);
+ }
+
+ if (layer == gimp_image_get_active_layer (image))
+ xcf_check_error (xcf_save_prop (info, image, PROP_ACTIVE_LAYER, error));
+
+ if (layer == gimp_image_get_floating_selection (image))
+ {
+ info->floating_sel_drawable = gimp_layer_get_floating_sel_drawable (layer);
+ xcf_check_error (xcf_save_prop (info, image, PROP_FLOATING_SELECTION,
+ error));
+ }
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_OPACITY, error,
+ gimp_layer_get_opacity (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_FLOAT_OPACITY, error,
+ gimp_layer_get_opacity (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_VISIBLE, error,
+ gimp_item_get_visible (GIMP_ITEM (layer))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LINKED, error,
+ gimp_item_get_linked (GIMP_ITEM (layer))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_COLOR_TAG, error,
+ gimp_item_get_color_tag (GIMP_ITEM (layer))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_CONTENT, error,
+ gimp_item_get_lock_content (GIMP_ITEM (layer))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_ALPHA, error,
+ gimp_layer_get_lock_alpha (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_POSITION, error,
+ gimp_item_get_lock_position (GIMP_ITEM (layer))));
+
+ if (gimp_layer_get_mask (layer))
+ {
+ xcf_check_error (xcf_save_prop (info, image, PROP_APPLY_MASK, error,
+ gimp_layer_get_apply_mask (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_EDIT_MASK, error,
+ gimp_layer_get_edit_mask (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_SHOW_MASK, error,
+ gimp_layer_get_show_mask (layer)));
+ }
+ else
+ {
+ xcf_check_error (xcf_save_prop (info, image, PROP_APPLY_MASK, error,
+ FALSE));
+ xcf_check_error (xcf_save_prop (info, image, PROP_EDIT_MASK, error,
+ FALSE));
+ xcf_check_error (xcf_save_prop (info, image, PROP_SHOW_MASK, error,
+ FALSE));
+ }
+
+ gimp_item_get_offset (GIMP_ITEM (layer), &offset_x, &offset_y);
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_OFFSETS, error,
+ offset_x, offset_y));
+ xcf_check_error (xcf_save_prop (info, image, PROP_MODE, error,
+ gimp_layer_get_mode (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_BLEND_SPACE, error,
+ gimp_layer_get_mode (layer),
+ gimp_layer_get_blend_space (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_COMPOSITE_SPACE, error,
+ gimp_layer_get_mode (layer),
+ gimp_layer_get_composite_space (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_COMPOSITE_MODE, error,
+ gimp_layer_get_mode (layer),
+ gimp_layer_get_composite_mode (layer)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_TATTOO, error,
+ gimp_item_get_tattoo (GIMP_ITEM (layer))));
+
+ if (GIMP_IS_TEXT_LAYER (layer) && GIMP_TEXT_LAYER (layer)->text)
+ {
+ GimpTextLayer *text_layer = GIMP_TEXT_LAYER (layer);
+ guint32 flags = gimp_text_layer_get_xcf_flags (text_layer);
+
+ gimp_text_layer_xcf_save_prepare (text_layer);
+
+ if (flags)
+ xcf_check_error (xcf_save_prop (info,
+ image, PROP_TEXT_LAYER_FLAGS, error,
+ flags));
+ }
+
+ if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
+ {
+ gint32 flags = 0;
+
+ if (gimp_viewable_get_expanded (GIMP_VIEWABLE (layer)))
+ flags |= XCF_GROUP_ITEM_EXPANDED;
+
+ xcf_check_error (xcf_save_prop (info,
+ image, PROP_GROUP_ITEM_FLAGS, error,
+ flags));
+ }
+
+ parasites = gimp_item_get_parasites (GIMP_ITEM (layer));
+
+ if (gimp_parasite_list_length (parasites) > 0)
+ {
+ xcf_check_error (xcf_save_prop (info, image, PROP_PARASITES, error,
+ parasites));
+ }
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_END, error));
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_channel_props (XcfInfo *info,
+ GimpImage *image,
+ GimpChannel *channel,
+ GError **error)
+{
+ GimpParasiteList *parasites;
+
+ if (channel == gimp_image_get_active_channel (image))
+ xcf_check_error (xcf_save_prop (info, image, PROP_ACTIVE_CHANNEL, error));
+
+ if (channel == gimp_image_get_mask (image))
+ xcf_check_error (xcf_save_prop (info, image, PROP_SELECTION, error));
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_OPACITY, error,
+ gimp_channel_get_opacity (channel)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_FLOAT_OPACITY, error,
+ gimp_channel_get_opacity (channel)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_VISIBLE, error,
+ gimp_item_get_visible (GIMP_ITEM (channel))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LINKED, error,
+ gimp_item_get_linked (GIMP_ITEM (channel))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_COLOR_TAG, error,
+ gimp_item_get_color_tag (GIMP_ITEM (channel))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_CONTENT, error,
+ gimp_item_get_lock_content (GIMP_ITEM (channel))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_POSITION, error,
+ gimp_item_get_lock_position (GIMP_ITEM (channel))));
+ xcf_check_error (xcf_save_prop (info, image, PROP_SHOW_MASKED, error,
+ gimp_channel_get_show_masked (channel)));
+ xcf_check_error (xcf_save_prop (info, image, PROP_COLOR, error,
+ &channel->color));
+ xcf_check_error (xcf_save_prop (info, image, PROP_FLOAT_COLOR, error,
+ &channel->color));
+ xcf_check_error (xcf_save_prop (info, image, PROP_TATTOO, error,
+ gimp_item_get_tattoo (GIMP_ITEM (channel))));
+
+ parasites = gimp_item_get_parasites (GIMP_ITEM (channel));
+
+ if (gimp_parasite_list_length (parasites) > 0)
+ {
+ xcf_check_error (xcf_save_prop (info, image, PROP_PARASITES, error,
+ parasites));
+ }
+
+ xcf_check_error (xcf_save_prop (info, image, PROP_END, error));
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_prop (XcfInfo *info,
+ GimpImage *image,
+ PropType prop_type,
+ GError **error,
+ ...)
+{
+ guint32 size;
+ va_list args;
+ GError *tmp_error = NULL;
+
+ va_start (args, error);
+
+ switch (prop_type)
+ {
+ case PROP_END:
+ size = 0;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+ break;
+
+ case PROP_COLORMAP:
+ {
+ guint32 n_colors = va_arg (args, guint32);
+ guchar *colors = va_arg (args, guchar *);
+
+ size = 4 + n_colors * 3;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &n_colors, 1);
+ xcf_write_int8_check_error (info, colors, n_colors * 3);
+ }
+ break;
+
+ case PROP_ACTIVE_LAYER:
+ case PROP_ACTIVE_CHANNEL:
+ case PROP_SELECTION:
+ case PROP_GROUP_ITEM:
+ size = 0;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+ break;
+
+ case PROP_FLOATING_SELECTION:
+ size = info->bytes_per_offset;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ info->floating_sel_offset = info->cp;
+ xcf_write_zero_offset_check_error (info, 1);
+ break;
+
+ case PROP_OPACITY:
+ {
+ gdouble opacity = va_arg (args, gdouble);
+ guint32 uint_opacity = opacity * 255.999;
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &uint_opacity, 1);
+ }
+ break;
+
+ case PROP_FLOAT_OPACITY:
+ {
+ gfloat opacity = va_arg (args, gdouble);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_float_check_error (info, &opacity, 1);
+ }
+ break;
+
+ case PROP_MODE:
+ {
+ gint32 mode = va_arg (args, gint32);
+
+ size = 4;
+
+ if (mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
+ mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, (guint32 *) &mode, 1);
+ }
+ break;
+
+ case PROP_BLEND_SPACE:
+ {
+ GimpLayerMode mode = va_arg (args, GimpLayerMode);
+ gint32 blend_space = va_arg (args, gint32);
+
+ G_STATIC_ASSERT (GIMP_LAYER_COLOR_SPACE_AUTO == 0);
+
+ /* if blend_space is AUTO, save the negative of the actual value AUTO
+ * maps to for the given mode, so that we can correctly load it even if
+ * the mapping changes in the future.
+ */
+ if (blend_space == GIMP_LAYER_COLOR_SPACE_AUTO)
+ blend_space = -gimp_layer_mode_get_blend_space (mode);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, (guint32 *) &blend_space, 1);
+ }
+ break;
+
+ case PROP_COMPOSITE_SPACE:
+ {
+ GimpLayerMode mode = va_arg (args, GimpLayerMode);
+ gint32 composite_space = va_arg (args, gint32);
+
+ G_STATIC_ASSERT (GIMP_LAYER_COLOR_SPACE_AUTO == 0);
+
+ /* if composite_space is AUTO, save the negative of the actual value
+ * AUTO maps to for the given mode, so that we can correctly load it
+ * even if the mapping changes in the future.
+ */
+ if (composite_space == GIMP_LAYER_COLOR_SPACE_AUTO)
+ composite_space = -gimp_layer_mode_get_composite_space (mode);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, (guint32 *) &composite_space, 1);
+ }
+ break;
+
+ case PROP_COMPOSITE_MODE:
+ {
+ GimpLayerMode mode = va_arg (args, GimpLayerMode);
+ gint32 composite_mode = va_arg (args, gint32);
+
+ G_STATIC_ASSERT (GIMP_LAYER_COMPOSITE_AUTO == 0);
+
+ /* if composite_mode is AUTO, save the negative of the actual value
+ * AUTO maps to for the given mode, so that we can correctly load it
+ * even if the mapping changes in the future.
+ */
+ if (composite_mode == GIMP_LAYER_COMPOSITE_AUTO)
+ composite_mode = -gimp_layer_mode_get_composite_mode (mode);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, (guint32 *) &composite_mode, 1);
+ }
+ break;
+
+ case PROP_VISIBLE:
+ {
+ guint32 visible = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &visible, 1);
+ }
+ break;
+
+ case PROP_LINKED:
+ {
+ guint32 linked = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &linked, 1);
+ }
+ break;
+
+ case PROP_COLOR_TAG:
+ {
+ guint32 color_tag = va_arg (args, gint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &color_tag, 1);
+ }
+ break;
+
+ case PROP_LOCK_CONTENT:
+ {
+ guint32 lock_content = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &lock_content, 1);
+ }
+ break;
+
+ case PROP_LOCK_ALPHA:
+ {
+ guint32 lock_alpha = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &lock_alpha, 1);
+ }
+ break;
+
+ case PROP_LOCK_POSITION:
+ {
+ guint32 lock_position = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &lock_position, 1);
+ }
+ break;
+
+ case PROP_APPLY_MASK:
+ {
+ guint32 apply_mask = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &apply_mask, 1);
+ }
+ break;
+
+ case PROP_EDIT_MASK:
+ {
+ guint32 edit_mask = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &edit_mask, 1);
+ }
+ break;
+
+ case PROP_SHOW_MASK:
+ {
+ guint32 show_mask = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &show_mask, 1);
+ }
+ break;
+
+ case PROP_SHOW_MASKED:
+ {
+ guint32 show_masked = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &show_masked, 1);
+ }
+ break;
+
+ case PROP_OFFSETS:
+ {
+ gint32 offsets[2];
+
+ offsets[0] = va_arg (args, gint32);
+ offsets[1] = va_arg (args, gint32);
+
+ size = 8;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, (guint32 *) offsets, 2);
+ }
+ break;
+
+ case PROP_COLOR:
+ {
+ GimpRGB *color = va_arg (args, GimpRGB *);
+ guchar col[3];
+
+ gimp_rgb_get_uchar (color, &col[0], &col[1], &col[2]);
+
+ size = 3;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int8_check_error (info, col, 3);
+ }
+ break;
+
+ case PROP_FLOAT_COLOR:
+ {
+ GimpRGB *color = va_arg (args, GimpRGB *);
+ gfloat col[3];
+
+ col[0] = color->r;
+ col[1] = color->g;
+ col[2] = color->b;
+
+ size = 3 * 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_float_check_error (info, col, 3);
+ }
+ break;
+
+ case PROP_COMPRESSION:
+ {
+ guint8 compression = (guint8) va_arg (args, guint32);
+
+ size = 1;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int8_check_error (info, &compression, 1);
+ }
+ break;
+
+ case PROP_GUIDES:
+ {
+ GList *guides = va_arg (args, GList *);
+ gint n_guides = g_list_length (guides);
+ GList *iter;
+
+ for (iter = guides; iter; iter = g_list_next (iter))
+ {
+ /* Do not save custom guides. */
+ if (gimp_guide_is_custom (GIMP_GUIDE (iter->data)))
+ n_guides--;
+ }
+
+ if (n_guides > 0)
+ {
+ size = n_guides * (4 + 1);
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ for (; guides; guides = g_list_next (guides))
+ {
+ GimpGuide *guide = guides->data;
+ gint32 position = gimp_guide_get_position (guide);
+ gint8 orientation;
+
+ if (gimp_guide_is_custom (guide))
+ continue;
+
+ switch (gimp_guide_get_orientation (guide))
+ {
+ case GIMP_ORIENTATION_HORIZONTAL:
+ orientation = XCF_ORIENTATION_HORIZONTAL;
+ break;
+
+ case GIMP_ORIENTATION_VERTICAL:
+ orientation = XCF_ORIENTATION_VERTICAL;
+ break;
+
+ default:
+ g_warning ("%s: skipping guide with bad orientation",
+ G_STRFUNC);
+ continue;
+ }
+
+ xcf_write_int32_check_error (info, (guint32 *) &position, 1);
+ xcf_write_int8_check_error (info, (guint8 *) &orientation, 1);
+ }
+ }
+ }
+ break;
+
+ case PROP_SAMPLE_POINTS:
+ {
+ GList *sample_points = va_arg (args, GList *);
+ gint n_sample_points = g_list_length (sample_points);
+
+ size = n_sample_points * (5 * 4);
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ for (; sample_points; sample_points = g_list_next (sample_points))
+ {
+ GimpSamplePoint *sample_point = sample_points->data;
+ gint32 x, y;
+ GimpColorPickMode pick_mode;
+ guint32 padding[2] = { 0, };
+
+ gimp_sample_point_get_position (sample_point, &x, &y);
+ pick_mode = gimp_sample_point_get_pick_mode (sample_point);
+
+ xcf_write_int32_check_error (info, (guint32 *) &x, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &y, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &pick_mode, 1);
+ xcf_write_int32_check_error (info, (guint32 *) padding, 2);
+ }
+ }
+ break;
+
+ case PROP_OLD_SAMPLE_POINTS:
+ {
+ GList *sample_points = va_arg (args, GList *);
+ gint n_sample_points = g_list_length (sample_points);
+
+ size = n_sample_points * (4 + 4);
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ for (; sample_points; sample_points = g_list_next (sample_points))
+ {
+ GimpSamplePoint *sample_point = sample_points->data;
+ gint32 x, y;
+
+ gimp_sample_point_get_position (sample_point, &x, &y);
+
+ xcf_write_int32_check_error (info, (guint32 *) &x, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &y, 1);
+ }
+ }
+ break;
+
+ case PROP_RESOLUTION:
+ {
+ gfloat resolution[2];
+
+ resolution[0] = va_arg (args, double);
+ resolution[1] = va_arg (args, double);
+
+ size = 2 * 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_float_check_error (info, resolution, 2);
+ }
+ break;
+
+ case PROP_TATTOO:
+ {
+ guint32 tattoo = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &tattoo, 1);
+ }
+ break;
+
+ case PROP_PARASITES:
+ {
+ GimpParasiteList *list = va_arg (args, GimpParasiteList *);
+
+ if (gimp_parasite_list_persistent_length (list) > 0)
+ {
+ goffset base;
+ goffset pos;
+
+ size = 0;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+
+ /* because we don't know how much room the parasite list
+ * will take we save the file position and write the
+ * length later
+ */
+ pos = info->cp;
+ xcf_write_int32_check_error (info, &size, 1);
+
+ base = info->cp;
+
+ xcf_check_error (xcf_save_parasite_list (info, list, error));
+
+ size = info->cp - base;
+
+ /* go back to the saved position and write the length */
+ xcf_check_error (xcf_seek_pos (info, pos, error));
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_check_error (xcf_seek_pos (info, base + size, error));
+ }
+ }
+ break;
+
+ case PROP_UNIT:
+ {
+ guint32 unit = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &unit, 1);
+ }
+ break;
+
+ case PROP_PATHS:
+ {
+ goffset base;
+ goffset pos;
+
+ size = 0;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+
+ /* because we don't know how much room the paths list will
+ * take we save the file position and write the length later
+ */
+ pos = info->cp;
+ xcf_write_int32_check_error (info, &size, 1);
+
+ base = info->cp;
+
+ xcf_check_error (xcf_save_old_paths (info, image, error));
+
+ size = info->cp - base;
+
+ /* go back to the saved position and write the length */
+ xcf_check_error (xcf_seek_pos (info, pos, error));
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_check_error (xcf_seek_pos (info, base + size, error));
+ }
+ break;
+
+ case PROP_USER_UNIT:
+ {
+ GimpUnit unit = va_arg (args, guint32);
+ const gchar *unit_strings[5];
+ gfloat factor;
+ guint32 digits;
+
+ /* write the entire unit definition */
+ unit_strings[0] = gimp_unit_get_identifier (unit);
+ factor = gimp_unit_get_factor (unit);
+ digits = gimp_unit_get_digits (unit);
+ unit_strings[1] = gimp_unit_get_symbol (unit);
+ unit_strings[2] = gimp_unit_get_abbreviation (unit);
+ unit_strings[3] = gimp_unit_get_singular (unit);
+ unit_strings[4] = gimp_unit_get_plural (unit);
+
+ size =
+ 2 * 4 +
+ strlen (unit_strings[0]) ? strlen (unit_strings[0]) + 5 : 4 +
+ strlen (unit_strings[1]) ? strlen (unit_strings[1]) + 5 : 4 +
+ strlen (unit_strings[2]) ? strlen (unit_strings[2]) + 5 : 4 +
+ strlen (unit_strings[3]) ? strlen (unit_strings[3]) + 5 : 4 +
+ strlen (unit_strings[4]) ? strlen (unit_strings[4]) + 5 : 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_float_check_error (info, &factor, 1);
+ xcf_write_int32_check_error (info, &digits, 1);
+ xcf_write_string_check_error (info, (gchar **) unit_strings, 5);
+ }
+ break;
+
+ case PROP_VECTORS:
+ {
+ goffset base;
+ goffset pos;
+
+ size = 0;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+
+ /* because we don't know how much room the paths list will
+ * take we save the file position and write the length later
+ */
+ pos = info->cp;
+ xcf_write_int32_check_error (info, &size, 1);
+
+ base = info->cp;
+
+ xcf_check_error (xcf_save_vectors (info, image, error));
+
+ size = info->cp - base;
+
+ /* go back to the saved position and write the length */
+ xcf_check_error (xcf_seek_pos (info, pos, error));
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_check_error (xcf_seek_pos (info, base + size, error));
+ }
+ break;
+
+ case PROP_TEXT_LAYER_FLAGS:
+ {
+ guint32 flags = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ xcf_write_int32_check_error (info, &flags, 1);
+ }
+ break;
+
+ case PROP_ITEM_PATH:
+ {
+ GList *path = va_arg (args, GList *);
+
+ size = 4 * g_list_length (path);
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+
+ while (path)
+ {
+ guint32 index = GPOINTER_TO_UINT (path->data);
+
+ xcf_write_int32_check_error (info, &index, 1);
+
+ path = g_list_next (path);
+ }
+ }
+ break;
+
+ case PROP_GROUP_ITEM_FLAGS:
+ {
+ guint32 flags = va_arg (args, guint32);
+
+ size = 4;
+
+ xcf_write_prop_type_check_error (info, prop_type);
+ xcf_write_int32_check_error (info, &size, 1);
+ xcf_write_int32_check_error (info, &flags, 1);
+ }
+ break;
+ }
+
+ va_end (args);
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_layer (XcfInfo *info,
+ GimpImage *image,
+ GimpLayer *layer,
+ GError **error)
+{
+ goffset saved_pos;
+ goffset offset;
+ guint32 value;
+ const gchar *string;
+ GError *tmp_error = NULL;
+
+ /* check and see if this is the drawable that the floating
+ * selection is attached to.
+ */
+ if (GIMP_DRAWABLE (layer) == info->floating_sel_drawable)
+ {
+ saved_pos = info->cp;
+ xcf_check_error (xcf_seek_pos (info, info->floating_sel_offset, error));
+ xcf_write_offset_check_error (info, &saved_pos, 1);
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ }
+
+ /* write out the width, height and image type information for the layer */
+ value = gimp_item_get_width (GIMP_ITEM (layer));
+ xcf_write_int32_check_error (info, &value, 1);
+
+ value = gimp_item_get_height (GIMP_ITEM (layer));
+ xcf_write_int32_check_error (info, &value, 1);
+
+ value = gimp_babl_format_get_image_type (gimp_drawable_get_format (GIMP_DRAWABLE (layer)));
+ xcf_write_int32_check_error (info, &value, 1);
+
+ /* write out the layers name */
+ string = gimp_object_get_name (layer);
+ xcf_write_string_check_error (info, (gchar **) &string, 1);
+
+ /* write out the layer properties */
+ xcf_save_layer_props (info, image, layer, error);
+
+ /* write out the layer tile hierarchy */
+ offset = info->cp + 2 * info->bytes_per_offset;
+ xcf_write_offset_check_error (info, &offset, 1);
+
+ saved_pos = info->cp;
+
+ /* write a zero layer mask offset */
+ xcf_write_zero_offset_check_error (info, 1);
+
+ xcf_check_error (xcf_save_buffer (info,
+ gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)),
+ error));
+
+ offset = info->cp;
+
+ /* write out the layer mask */
+ if (gimp_layer_get_mask (layer))
+ {
+ GimpLayerMask *mask = gimp_layer_get_mask (layer);
+
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ xcf_write_offset_check_error (info, &offset, 1);
+
+ xcf_check_error (xcf_seek_pos (info, offset, error));
+ xcf_check_error (xcf_save_channel (info, image, GIMP_CHANNEL (mask),
+ error));
+ }
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_channel (XcfInfo *info,
+ GimpImage *image,
+ GimpChannel *channel,
+ GError **error)
+{
+ goffset saved_pos;
+ goffset offset;
+ guint32 value;
+ const gchar *string;
+ GError *tmp_error = NULL;
+
+ /* check and see if this is the drawable that the floating
+ * selection is attached to.
+ */
+ if (GIMP_DRAWABLE (channel) == info->floating_sel_drawable)
+ {
+ saved_pos = info->cp;
+ xcf_check_error (xcf_seek_pos (info, info->floating_sel_offset, error));
+ xcf_write_offset_check_error (info, &saved_pos, 1);
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ }
+
+ /* write out the width and height information for the channel */
+ value = gimp_item_get_width (GIMP_ITEM (channel));
+ xcf_write_int32_check_error (info, &value, 1);
+
+ value = gimp_item_get_height (GIMP_ITEM (channel));
+ xcf_write_int32_check_error (info, &value, 1);
+
+ /* write out the channels name */
+ string = gimp_object_get_name (channel);
+ xcf_write_string_check_error (info, (gchar **) &string, 1);
+
+ /* write out the channel properties */
+ xcf_save_channel_props (info, image, channel, error);
+
+ /* write out the channel tile hierarchy */
+ offset = info->cp + info->bytes_per_offset;
+ xcf_write_offset_check_error (info, &offset, 1);
+
+ xcf_check_error (xcf_save_buffer (info,
+ gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
+ error));
+
+ return TRUE;
+}
+
+static gint
+xcf_calc_levels (gint size,
+ gint tile_size)
+{
+ gint levels;
+
+ levels = 1;
+ while (size > tile_size)
+ {
+ size /= 2;
+ levels += 1;
+ }
+
+ return levels;
+}
+
+
+static gboolean
+xcf_save_buffer (XcfInfo *info,
+ GeglBuffer *buffer,
+ GError **error)
+{
+ const Babl *format;
+ goffset saved_pos;
+ goffset offset;
+ guint32 width;
+ guint32 height;
+ guint32 bpp;
+ gint i;
+ gint nlevels;
+ gint tmp1, tmp2;
+ GError *tmp_error = NULL;
+
+ format = gegl_buffer_get_format (buffer);
+
+ width = gegl_buffer_get_width (buffer);
+ height = gegl_buffer_get_height (buffer);
+ bpp = babl_format_get_bytes_per_pixel (format);
+
+ xcf_write_int32_check_error (info, (guint32 *) &width, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &height, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &bpp, 1);
+
+ tmp1 = xcf_calc_levels (width, XCF_TILE_WIDTH);
+ tmp2 = xcf_calc_levels (height, XCF_TILE_HEIGHT);
+ nlevels = MAX (tmp1, tmp2);
+
+ /* 'saved_pos' is the next slot in the offset table */
+ saved_pos = info->cp;
+
+ /* write an empty offset table */
+ xcf_write_zero_offset_check_error (info, nlevels + 1);
+
+ /* 'offset' is where we will write the next level */
+ offset = info->cp;
+
+ for (i = 0; i < nlevels; i++)
+ {
+ /* seek back to the next slot in the offset table and write the
+ * offset of the level
+ */
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ xcf_write_offset_check_error (info, &offset, 1);
+
+ /* remember the next slot in the offset table */
+ saved_pos = info->cp;
+
+ /* seek to the level offset and save the level */
+ xcf_check_error (xcf_seek_pos (info, offset, error));
+
+ if (i == 0)
+ {
+ /* write out the level. */
+ xcf_check_error (xcf_save_level (info, buffer, error));
+ }
+ else
+ {
+ /* fake an empty level */
+ tmp1 = 0;
+ width /= 2;
+ height /= 2;
+ xcf_write_int32_check_error (info, (guint32 *) &width, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &height, 1);
+
+ /* NOTE: this should be an offset, not an int32! however...
+ * since there are already 64-bit-offsets XCFs out there in
+ * which this field is 32-bit, and since it's not actually
+ * being used, we're going to keep this field 32-bit for the
+ * dummy levels, to remain consistent. if we ever make use
+ * of levels above the first, we should turn this field into
+ * an offset, and bump the xcf version.
+ */
+ xcf_write_int32_check_error (info, (guint32 *) &tmp1, 1);
+ }
+
+ /* the next level's offset if after the level we just wrote */
+ offset = info->cp;
+ }
+
+ /* there is already a '0' at the end of the offset table to indicate
+ * the end of the level offsets
+ */
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_level (XcfInfo *info,
+ GeglBuffer *buffer,
+ GError **error)
+{
+ const Babl *format;
+ goffset *offset_table;
+ goffset *next_offset;
+ goffset saved_pos;
+ goffset offset;
+ goffset max_data_length;
+ guint32 width;
+ guint32 height;
+ gint bpp;
+ gint n_tile_rows;
+ gint n_tile_cols;
+ guint ntiles;
+ gint i;
+ guchar *rlebuf = NULL;
+ GError *tmp_error = NULL;
+
+ format = gegl_buffer_get_format (buffer);
+
+ width = gegl_buffer_get_width (buffer);
+ height = gegl_buffer_get_height (buffer);
+ bpp = babl_format_get_bytes_per_pixel (format);
+
+ xcf_write_int32_check_error (info, (guint32 *) &width, 1);
+ xcf_write_int32_check_error (info, (guint32 *) &height, 1);
+
+ saved_pos = info->cp;
+
+ /* maximal allowable size of on-disk tile data. make it somewhat bigger than
+ * the uncompressed tile size, to allow for the possibility of negative
+ * compression. xcf_load_level() enforces this limit.
+ */
+ max_data_length = XCF_TILE_WIDTH * XCF_TILE_HEIGHT * bpp *
+ XCF_TILE_MAX_DATA_LENGTH_FACTOR /* = 1.5, currently */;
+
+ /* allocate a temporary buffer to store the rle data before it is
+ * written to disk
+ */
+ if (info->compression == COMPRESS_RLE)
+ rlebuf = g_alloca (max_data_length);
+
+ n_tile_rows = gimp_gegl_buffer_get_n_tile_rows (buffer, XCF_TILE_HEIGHT);
+ n_tile_cols = gimp_gegl_buffer_get_n_tile_cols (buffer, XCF_TILE_WIDTH);
+
+ ntiles = n_tile_rows * n_tile_cols;
+
+ /* allocate an offset table so we don't have to seek back after each
+ * tile, see bug #686862. allocate ntiles + 1 slots because a zero
+ * offset indicates the offset table's end.
+ * Do not use g_alloca since it may cause Stack Overflow on
+ * large images, see issue #6138.
+ */
+ offset_table = g_malloc0 ((ntiles + 1) * sizeof (goffset));
+ next_offset = offset_table;
+
+ /* 'saved_pos' is the offset of the tile offset table */
+ saved_pos = info->cp;
+
+ /* write an empty offset table */
+ xcf_write_zero_offset_check_error (info, ntiles + 1);
+
+ /* 'offset' is where we will write the next tile */
+ offset = info->cp;
+
+ for (i = 0; i < ntiles; i++)
+ {
+ GeglRectangle rect;
+
+ /* store the offset in the table and increment the next pointer */
+ *next_offset++ = offset;
+
+ gimp_gegl_buffer_get_tile_rect (buffer,
+ XCF_TILE_WIDTH, XCF_TILE_HEIGHT,
+ i, &rect);
+
+ /* write out the tile. */
+ switch (info->compression)
+ {
+ case COMPRESS_NONE:
+ xcf_check_error (xcf_save_tile (info, buffer, &rect, format,
+ error));
+ break;
+ case COMPRESS_RLE:
+ xcf_check_error (xcf_save_tile_rle (info, buffer, &rect, format,
+ rlebuf, error));
+ break;
+ case COMPRESS_ZLIB:
+ xcf_check_error (xcf_save_tile_zlib (info, buffer, &rect, format,
+ error));
+ break;
+ case COMPRESS_FRACTAL:
+ g_warning ("xcf: fractal compression unimplemented");
+ g_free (offset_table);
+ return FALSE;
+ }
+
+ /* make sure the on-disk tile data didn't end up being too big.
+ * xcf_load_level() would refuse to load the file if it did.
+ */
+ if (info->cp < offset || info->cp - offset > max_data_length)
+ {
+ g_message ("xcf: invalid tile data length: %" G_GOFFSET_FORMAT,
+ info->cp - offset);
+ g_free (offset_table);
+ return FALSE;
+ }
+
+ /* the next tile's offset is after the tile we just wrote */
+ offset = info->cp;
+ }
+
+ /* seek back to the offset table and write it */
+ xcf_check_error (xcf_seek_pos (info, saved_pos, error));
+ xcf_write_offset_check_error (info, offset_table, ntiles + 1);
+
+ /* seek to the end of the file */
+ xcf_check_error (xcf_seek_pos (info, offset, error));
+
+ g_free (offset_table);
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_tile (XcfInfo *info,
+ GeglBuffer *buffer,
+ GeglRectangle *tile_rect,
+ const Babl *format,
+ GError **error)
+{
+ gint bpp = babl_format_get_bytes_per_pixel (format);
+ gint tile_size = bpp * tile_rect->width * tile_rect->height;
+ guchar *tile_data = g_alloca (tile_size);
+ GError *tmp_error = NULL;
+
+ gegl_buffer_get (buffer, tile_rect, 1.0, format, tile_data,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ if (info->file_version <= 11)
+ {
+ xcf_write_int8_check_error (info, tile_data, tile_size);
+ }
+ else
+ {
+ gint n_components = babl_format_get_n_components (format);
+
+ xcf_write_component_check_error (info, bpp / n_components, tile_data,
+ tile_size / bpp * n_components);
+ }
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_tile_rle (XcfInfo *info,
+ GeglBuffer *buffer,
+ GeglRectangle *tile_rect,
+ const Babl *format,
+ guchar *rlebuf,
+ GError **error)
+{
+ gint bpp = babl_format_get_bytes_per_pixel (format);
+ gint tile_size = bpp * tile_rect->width * tile_rect->height;
+ guchar *tile_data = g_alloca (tile_size);
+ gint len = 0;
+ gint i, j;
+ GError *tmp_error = NULL;
+
+ gegl_buffer_get (buffer, tile_rect, 1.0, format, tile_data,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ if (info->file_version >= 12)
+ {
+ gint n_components = babl_format_get_n_components (format);
+
+ xcf_write_to_be (bpp / n_components, tile_data,
+ tile_size / bpp * n_components);
+ }
+
+ for (i = 0; i < bpp; i++)
+ {
+ const guchar *data = tile_data + i;
+ gint state = 0;
+ gint length = 0;
+ gint count = 0;
+ gint size = tile_rect->width * tile_rect->height;
+ guint last = -1;
+
+ while (size > 0)
+ {
+ switch (state)
+ {
+ case 0:
+ /* in state 0 we try to find a long sequence of
+ * matching values.
+ */
+ if ((length == 32768) ||
+ ((size - length) <= 0) ||
+ ((length > 1) && (last != *data)))
+ {
+ count += length;
+
+ if (length >= 128)
+ {
+ rlebuf[len++] = 127;
+ rlebuf[len++] = (length >> 8);
+ rlebuf[len++] = length & 0x00FF;
+ rlebuf[len++] = last;
+ }
+ else
+ {
+ rlebuf[len++] = length - 1;
+ rlebuf[len++] = last;
+ }
+
+ size -= length;
+ length = 0;
+ }
+ else if ((length == 1) && (last != *data))
+ {
+ state = 1;
+ }
+ break;
+
+ case 1:
+ /* in state 1 we try and find a long sequence of
+ * non-matching values.
+ */
+ if ((length == 32768) ||
+ ((size - length) == 0) ||
+ ((length > 0) && (last == *data) &&
+ ((size - length) == 1 || last == data[bpp])))
+ {
+ const guchar *t;
+
+ /* if we came here because of a new run, backup one */
+ if (!((length == 32768) || ((size - length) == 0)))
+ {
+ length--;
+ data -= bpp;
+ }
+
+ count += length;
+ state = 0;
+
+ if (length >= 128)
+ {
+ rlebuf[len++] = 255 - 127;
+ rlebuf[len++] = (length >> 8);
+ rlebuf[len++] = length & 0x00FF;
+ }
+ else
+ {
+ rlebuf[len++] = 255 - (length - 1);
+ }
+
+ t = data - length * bpp;
+
+ for (j = 0; j < length; j++)
+ {
+ rlebuf[len++] = *t;
+ t += bpp;
+ }
+
+ size -= length;
+ length = 0;
+ }
+ break;
+ }
+
+ if (size > 0)
+ {
+ length += 1;
+ last = *data;
+ data += bpp;
+ }
+ }
+
+ if (count != (tile_rect->width * tile_rect->height))
+ g_message ("xcf: uh oh! xcf rle tile saving error: %d", count);
+ }
+
+ xcf_write_int8_check_error (info, rlebuf, len);
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_tile_zlib (XcfInfo *info,
+ GeglBuffer *buffer,
+ GeglRectangle *tile_rect,
+ const Babl *format,
+ GError **error)
+{
+ gint bpp = babl_format_get_bytes_per_pixel (format);
+ gint tile_size = bpp * tile_rect->width * tile_rect->height;
+ guchar *tile_data = g_alloca (tile_size);
+ /* The buffer for compressed data. */
+ guchar *buf = g_alloca (tile_size);
+ GError *tmp_error = NULL;
+ z_stream strm;
+ int action;
+ int status;
+
+ gegl_buffer_get (buffer, tile_rect, 1.0, format, tile_data,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ if (info->file_version >= 12)
+ {
+ gint n_components = babl_format_get_n_components (format);
+
+ xcf_write_to_be (bpp / n_components, tile_data,
+ tile_size / bpp * n_components);
+ }
+
+ /* allocate deflate state */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+
+ status = deflateInit (&strm, Z_DEFAULT_COMPRESSION);
+ if (status != Z_OK)
+ return FALSE;
+
+ strm.next_in = tile_data;
+ strm.avail_in = tile_size;
+ strm.next_out = buf;
+ strm.avail_out = tile_size;
+
+ action = Z_NO_FLUSH;
+
+ while (status == Z_OK || status == Z_BUF_ERROR)
+ {
+ if (strm.avail_in == 0)
+ {
+ /* Finish the encoding. */
+ action = Z_FINISH;
+ }
+
+ status = deflate (&strm, action);
+
+ if (status == Z_STREAM_END || status == Z_BUF_ERROR)
+ {
+ size_t write_size = tile_size - strm.avail_out;
+
+ xcf_write_int8_check_error (info, buf, write_size);
+
+ /* Reset next_out and avail_out. */
+ strm.next_out = buf;
+ strm.avail_out = tile_size;
+ }
+ else if (status != Z_OK)
+ {
+ g_printerr ("xcf: tile compression failed: %s", zError (status));
+ deflateEnd (&strm);
+ return FALSE;
+ }
+ }
+
+ deflateEnd (&strm);
+ return TRUE;
+}
+
+static gboolean
+xcf_save_parasite (XcfInfo *info,
+ GimpParasite *parasite,
+ GError **error)
+{
+ if (gimp_parasite_is_persistent (parasite))
+ {
+ guint32 value;
+ const gchar *string;
+ GError *tmp_error = NULL;
+
+ string = gimp_parasite_name (parasite);
+ xcf_write_string_check_error (info, (gchar **) &string, 1);
+
+ value = gimp_parasite_flags (parasite);
+ xcf_write_int32_check_error (info, &value, 1);
+
+ value = gimp_parasite_data_size (parasite);
+ xcf_write_int32_check_error (info, &value, 1);
+
+ xcf_write_int8_check_error (info,
+ gimp_parasite_data (parasite),
+ gimp_parasite_data_size (parasite));
+ }
+
+ return TRUE;
+}
+
+typedef struct
+{
+ XcfInfo *info;
+ GError *error;
+} XcfParasiteData;
+
+static void
+xcf_save_parasite_func (gchar *key,
+ GimpParasite *parasite,
+ XcfParasiteData *data)
+{
+ if (! data->error)
+ xcf_save_parasite (data->info, parasite, &data->error);
+}
+
+static gboolean
+xcf_save_parasite_list (XcfInfo *info,
+ GimpParasiteList *list,
+ GError **error)
+{
+ XcfParasiteData data;
+
+ data.info = info;
+ data.error = NULL;
+
+ gimp_parasite_list_foreach (list, (GHFunc) xcf_save_parasite_func, &data);
+
+ if (data.error)
+ {
+ g_propagate_error (error, data.error);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_old_paths (XcfInfo *info,
+ GimpImage *image,
+ GError **error)
+{
+ GimpVectors *active_vectors;
+ guint32 num_paths;
+ guint32 active_index = 0;
+ GList *list;
+ GError *tmp_error = NULL;
+
+ /* Write out the following:-
+ *
+ * last_selected_row (gint)
+ * number_of_paths (gint)
+ *
+ * then each path:-
+ */
+
+ num_paths = gimp_container_get_n_children (gimp_image_get_vectors (image));
+
+ active_vectors = gimp_image_get_active_vectors (image);
+
+ if (active_vectors)
+ active_index = gimp_container_get_child_index (gimp_image_get_vectors (image),
+ GIMP_OBJECT (active_vectors));
+
+ xcf_write_int32_check_error (info, &active_index, 1);
+ xcf_write_int32_check_error (info, &num_paths, 1);
+
+ for (list = gimp_image_get_vectors_iter (image);
+ list;
+ list = g_list_next (list))
+ {
+ GimpVectors *vectors = list->data;
+ gchar *name;
+ guint32 locked;
+ guint8 state;
+ guint32 version;
+ guint32 pathtype;
+ guint32 tattoo;
+ GimpVectorsCompatPoint *points;
+ guint32 num_points;
+ guint32 closed;
+ gint i;
+
+ /*
+ * name (string)
+ * locked (gint)
+ * state (gchar)
+ * closed (gint)
+ * number points (gint)
+ * version (gint)
+ * pathtype (gint)
+ * tattoo (gint)
+ * then each point.
+ */
+
+ points = gimp_vectors_compat_get_points (vectors,
+ (gint32 *) &num_points,
+ (gint32 *) &closed);
+
+ /* if no points are generated because of a faulty path we should
+ * skip saving the path - this is unfortunately impossible, because
+ * we already saved the number of paths and I won't start seeking
+ * around to fix that cruft */
+
+ name = (gchar *) gimp_object_get_name (vectors);
+ locked = gimp_item_get_linked (GIMP_ITEM (vectors));
+ state = closed ? 4 : 2; /* EDIT : ADD (editing state, 1.2 compat) */
+ version = 3;
+ pathtype = 1; /* BEZIER (1.2 compat) */
+ tattoo = gimp_item_get_tattoo (GIMP_ITEM (vectors));
+
+ xcf_write_string_check_error (info, &name, 1);
+ xcf_write_int32_check_error (info, &locked, 1);
+ xcf_write_int8_check_error (info, &state, 1);
+ xcf_write_int32_check_error (info, &closed, 1);
+ xcf_write_int32_check_error (info, &num_points, 1);
+ xcf_write_int32_check_error (info, &version, 1);
+ xcf_write_int32_check_error (info, &pathtype, 1);
+ xcf_write_int32_check_error (info, &tattoo, 1);
+
+ for (i = 0; i < num_points; i++)
+ {
+ gfloat x;
+ gfloat y;
+
+ x = points[i].x;
+ y = points[i].y;
+
+ /*
+ * type (gint)
+ * x (gfloat)
+ * y (gfloat)
+ */
+
+ xcf_write_int32_check_error (info, &points[i].type, 1);
+ xcf_write_float_check_error (info, &x, 1);
+ xcf_write_float_check_error (info, &y, 1);
+ }
+
+ g_free (points);
+ }
+
+ return TRUE;
+}
+
+static gboolean
+xcf_save_vectors (XcfInfo *info,
+ GimpImage *image,
+ GError **error)
+{
+ GimpVectors *active_vectors;
+ guint32 version = 1;
+ guint32 active_index = 0;
+ guint32 num_paths;
+ GList *list;
+ GList *stroke_list;
+ GError *tmp_error = NULL;
+
+ /* Write out the following:-
+ *
+ * version (gint)
+ * active_index (gint)
+ * num_paths (gint)
+ *
+ * then each path:-
+ */
+
+ active_vectors = gimp_image_get_active_vectors (image);
+
+ if (active_vectors)
+ active_index = gimp_container_get_child_index (gimp_image_get_vectors (image),
+ GIMP_OBJECT (active_vectors));
+
+ num_paths = gimp_container_get_n_children (gimp_image_get_vectors (image));
+
+ xcf_write_int32_check_error (info, &version, 1);
+ xcf_write_int32_check_error (info, &active_index, 1);
+ xcf_write_int32_check_error (info, &num_paths, 1);
+
+ for (list = gimp_image_get_vectors_iter (image);
+ list;
+ list = g_list_next (list))
+ {
+ GimpVectors *vectors = list->data;
+ GimpParasiteList *parasites;
+ const gchar *name;
+ guint32 tattoo;
+ guint32 visible;
+ guint32 linked;
+ guint32 num_parasites;
+ guint32 num_strokes;
+
+ /*
+ * name (string)
+ * tattoo (gint)
+ * visible (gint)
+ * linked (gint)
+ * num_parasites (gint)
+ * num_strokes (gint)
+ *
+ * then each parasite
+ * then each stroke
+ */
+
+ name = gimp_object_get_name (vectors);
+ visible = gimp_item_get_visible (GIMP_ITEM (vectors));
+ linked = gimp_item_get_linked (GIMP_ITEM (vectors));
+ tattoo = gimp_item_get_tattoo (GIMP_ITEM (vectors));
+ parasites = gimp_item_get_parasites (GIMP_ITEM (vectors));
+ num_parasites = gimp_parasite_list_persistent_length (parasites);
+ num_strokes = g_queue_get_length (vectors->strokes);
+
+ xcf_write_string_check_error (info, (gchar **) &name, 1);
+ xcf_write_int32_check_error (info, &tattoo, 1);
+ xcf_write_int32_check_error (info, &visible, 1);
+ xcf_write_int32_check_error (info, &linked, 1);
+ xcf_write_int32_check_error (info, &num_parasites, 1);
+ xcf_write_int32_check_error (info, &num_strokes, 1);
+
+ xcf_check_error (xcf_save_parasite_list (info, parasites, error));
+
+ for (stroke_list = g_list_first (vectors->strokes->head);
+ stroke_list;
+ stroke_list = g_list_next (stroke_list))
+ {
+ GimpStroke *stroke = stroke_list->data;
+ guint32 stroke_type;
+ guint32 closed;
+ guint32 num_axes;
+ GArray *control_points;
+ gint i;
+
+ guint32 type;
+ gfloat coords[6];
+
+ /*
+ * stroke_type (gint)
+ * closed (gint)
+ * num_axes (gint)
+ * num_control_points (gint)
+ *
+ * then each control point.
+ */
+
+ if (GIMP_IS_BEZIER_STROKE (stroke))
+ {
+ stroke_type = XCF_STROKETYPE_BEZIER_STROKE;
+ num_axes = 2; /* hardcoded, might be increased later */
+ }
+ else
+ {
+ g_printerr ("Skipping unknown stroke type!\n");
+ continue;
+ }
+
+ control_points = gimp_stroke_control_points_get (stroke,
+ (gint32 *) &closed);
+
+ xcf_write_int32_check_error (info, &stroke_type, 1);
+ xcf_write_int32_check_error (info, &closed, 1);
+ xcf_write_int32_check_error (info, &num_axes, 1);
+ xcf_write_int32_check_error (info, &control_points->len, 1);
+
+ for (i = 0; i < control_points->len; i++)
+ {
+ GimpAnchor *anchor;
+
+ anchor = & (g_array_index (control_points, GimpAnchor, i));
+
+ type = anchor->type;
+ coords[0] = anchor->position.x;
+ coords[1] = anchor->position.y;
+ coords[2] = anchor->position.pressure;
+ coords[3] = anchor->position.xtilt;
+ coords[4] = anchor->position.ytilt;
+ coords[5] = anchor->position.wheel;
+
+ /*
+ * type (gint)
+ *
+ * the first num_axis elements of:
+ * [0] x (gfloat)
+ * [1] y (gfloat)
+ * [2] pressure (gfloat)
+ * [3] xtilt (gfloat)
+ * [4] ytilt (gfloat)
+ * [5] wheel (gfloat)
+ */
+
+ xcf_write_int32_check_error (info, &type, 1);
+ xcf_write_float_check_error (info, coords, num_axes);
+ }
+
+ g_array_free (control_points, TRUE);
+ }
+ }
+
+ return TRUE;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-18 18:25:12 +0000