diff options
Diffstat (limited to 'plug-ins/common/file-xmc.c')
| -rw-r--r-- | plug-ins/common/file-xmc.c | 2492 |
1 files changed, 2492 insertions, 0 deletions
diff --git a/plug-ins/common/file-xmc.c b/plug-ins/common/file-xmc.c new file mode 100644 index 0000000..a5c41f7 --- /dev/null +++ b/plug-ins/common/file-xmc.c @@ -0,0 +1,2492 @@ +/* + * X11 Mouse Cursor (XMC) plug-in for GIMP + * + * Copyright 2008-2009 Takeshi Matsuyama <tksmashiw@gmail.com> + * + * Special thanks: Alexia Death, Sven Neumann, Martin Nordholts + * and all community members. + */ + +/* + * 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/>. + */ + +/* + * Todo: if drawable->bpp != 4 in save_image for GIMP-2.8? + * Todo: support for "gimp-metadata" parasite. + * "xmc-copyright" and "xmc-license" may be deprecated in future? + */ + +/* + * This plug-in use these four parasites. + * "hot-spot" common with file-xbm plug-in + * "xmc-copyright" original, store contents of type1 comment chunk of Xcursor + * "xmc-license" original, store contents of type2 comment chunk of Xcursor + * "gimp-comment" common, store contents of type3 comment chunk of Xcursor + */ + +/* *** Caution: Size vs Dimension *** + * + * In this file, "size" and "dimension" are used in definitely + * different contexts. "Size" means nominal size of Xcursor which is + * used to determine which frame depends on which animation sequence + * and which sequence is really used. (for more detail, please read + * Xcursor(3).) On the other hand, "Dimension" simply means width + * and/or height. + */ + +#include "config.h" + +#include <stdlib.h> +#include <string.h> +#include <errno.h> + +#include <glib/gstdio.h> +#include <glib/gprintf.h> + +#include <libgimp/gimp.h> +#include <libgimp/gimpui.h> + +#include <X11/Xlib.h> +#include <X11/Xcursor/Xcursor.h> + +#include "libgimp/stdplugins-intl.h" + +/* For debug */ +/* #define XMC_DEBUG */ +#ifdef XMC_DEBUG +# define DM_XMC(...) g_fprintf(stderr, __VA_ARGS__) +#else +# define DM_XMC(...) +#endif + +/* + * Constants... + */ + +#define LOAD_PROC "file-xmc-load" +#define LOAD_THUMB_PROC "file-xmc-load-thumb" +#define SAVE_PROC "file-xmc-save" + +#define PLUG_IN_BINARY "file-xmc" +#define PLUG_IN_ROLE "gimp-file-xmc" + +/* We use "xmc" as the file extension of X cursor for convenience */ +#define XCURSOR_EXTENSION "xmc" +#define XCURSOR_MIME_TYPE "image/x-xcursor" + +/* The maximum dimension of Xcursor which is fully supported in any + * environments. This is defined on line 59 of xcursorint.h in + * libXcursor source code. Make sure this is about dimensions (width + * and height) not about nominal size despite of it's name. + * + * As of 2018, this macro still exists in libXCursor codebase, but I am + * unsure how far this restriction is enforced since this is a very low + * max dimension for today's displays. Therefore our code will not + * enforce this value anymore, but only warn about possible + * incompatibilities when using higher values. + */ +#define MAX_BITMAP_CURSOR_SIZE 64 + +/* The maximum dimension of each frame of X cursor we want to save + * should be MAX_BITMAP_CURSOR_SIZE but about loading, xhot(& yhot) of + * each frame varies from 0 to MAX_BITMAP_CURSOR_SIZE-1, so we need to + * set the maximum dimension of image no less than + * MAX_BITMAP_CURSOR_SIZE * 2( -1 to be precise) to remain hotspots on + * the same coordinates. + * + * We use four times value (256 for saving, 512 for loading) as a + * limitation because some cursors generated by CursorXP/FX to X11 + * Mouse Theme Converter is very large. + * + * The biggest cursor I found is "watch" of OuterLimits which size is + * 213x208. If you found bigger one, please tell me ;-) + */ +#define MAX_LOAD_DIMENSION 512 +#define MAX_SAVE_DIMENSION 256 + +/* The maximum number of different nominal sizes in one cursor this + * plug-in can treat. This is based on the number of cursor size which + * gnome-appearance-properties supports.(12,16,24,32,36,40,48,64) + * ref. capplets/common/gnome-theme-info.c in source of + * gnome-control-center + */ +#define MAX_SIZE_NUM 8 + +/* cursor delay is guint32 defined in Xcursor.h */ +#define CURSOR_MAX_DELAY 100000000 +#define CURSOR_DEFAULT_DELAY 50 +#define CURSOR_MINIMUM_DELAY 5 + +#define div_255(x) (((x) + 0x80 + (((x) + 0x80) >> 8)) >> 8) +#define READ32(f, e) read32 ((f), (e)); if (*(e)) return -1; +#define DISPLAY_DIGIT(x) ((x) > 100) ? 3 : ((x) > 10) ? 2 : 1 + +/* + * Structures... + */ + +typedef struct +{ + gboolean crop; + gint size; + gboolean size_replace; + gint32 delay; + gboolean delay_replace; +} XmcSaveVals; + +/* + * Local functions... + */ + +static void query (void); + +static void run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals); + +static gint32 load_image (const gchar *filename, + GError **error); + +static gint32 load_thumbnail (const gchar *filename, + gint32 thumb_size, + gint32 *width, + gint32 *height, + gint32 *num_layers, + GError **error); + +static guint32 read32 (FILE *f, + GError **error); + +static gboolean save_image (const gchar *filename, + gint32 image_ID, + gint32 drawable_ID, + gint32 orig_image_ID, + GError **error); + +static gboolean save_dialog (const gint32 image_ID, + GeglRectangle *hotspotRange); + +static void comment_entry_callback (GtkWidget *widget, + gchar **commentp); + +static void text_view_callback (GtkTextBuffer *buffer, + gchar **commentp); + +static gboolean load_default_hotspot (const gint32 image_ID, + GeglRectangle *hotspotRange); + +static inline guint32 separate_alpha (guint32 pixel); + +static inline guint32 premultiply_alpha (guint32 pixel); + +static XcursorComments *set_cursor_comments (void); + +static void load_comments (const gint32 image_ID); + +static gboolean set_comment_to_pname (const gint32 image_ID, + const gchar *content, + const gchar *pname); + +static gchar *get_comment_from_pname (const gint32 image_ID, + const gchar *pname); + +static gboolean set_hotspot_to_parasite (gint32 image_ID); + +static gboolean get_hotspot_from_parasite (gint32 image_ID); + +static void set_size_and_delay (const gchar *framename, + guint32 *sizep, + guint32 *delayp, + GRegex *re, + gboolean *size_warnp); + +static gchar *make_framename (guint32 size, + guint32 delay, + guint indent, + GError **errorp); + +static void get_cropped_region (GeglRectangle *retrun_rgn, + GeglBuffer *buffer); + +static inline gboolean pix_is_opaque (guint32 pix); + +static GeglRectangle * get_intersection_of_frames (gint32 image_ID); + +static gboolean pix_in_region (gint32 x, + gint32 y, + GeglRectangle *xmcrp); + +static void find_hotspots_and_dimensions (XcursorImages *xcIs, + gint32 *xhot, + gint32 *yhot, + gint32 *width, + gint32 *height); + +/* + * Globals... + */ + +const GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, + NULL, + query, + run +}; + +static XmcSaveVals xmcvals = +{ + /* saved in pdb after this plug-in's process has gone. */ + FALSE, /* crop */ + 32, /* size */ + FALSE, /* size_replace */ + CURSOR_DEFAULT_DELAY, /* delay */ + FALSE /* delay_replace */ +}; + +static struct +{ + /* saved as parasites of original image after this plug-in's process has gone.*/ + gint32 x; /* hotspot x */ + gint32 y; /* hotspot y */ + gchar *comments[3]; /* copyright, license, other */ +} xmcparas = {0,}; + +/* parasites correspond to XcursorComment type */ +static const gchar *parasiteName[3] = { "xmc-copyright", + "xmc-license", + "gimp-comment" }; + +/* + * 'main()' - Main entry - just call gimp_main()... + */ + +MAIN () + + +/* + * 'query()' - Respond to a plug-in query... + */ + +static void +query (void) +{ + static const GimpParamDef load_args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_STRING, "raw-filename", "The name of the file to load" } + }; + static const GimpParamDef load_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Output image" } + }; + + static const GimpParamDef thumb_args[] = + { + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size" } + }; + static const GimpParamDef thumb_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Thumbnail image" }, + { GIMP_PDB_INT32, "image-width", "The width of image" }, + { GIMP_PDB_INT32, "image-height", "The height of image" }, + { GIMP_PDB_INT32, "image-type", "The color type of image"}, + { GIMP_PDB_INT32, "image-num-layers", "The number of layeres" } + }; + + static const GimpParamDef save_args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_IMAGE, "image", "Input image" }, + { GIMP_PDB_DRAWABLE, "drawable", "Drawable to export" }, + { GIMP_PDB_STRING, "filename", "The name of the file to export the image in" }, + { GIMP_PDB_STRING, "raw-filename", "The name entered" }, + /* following elements are XMC specific options */ + { GIMP_PDB_INT32, "x_hot", "X-coordinate of hot spot" }, + { GIMP_PDB_INT32, "y_hot", "Y-coordinate of hot spot\n" + "Use (-1, -1) to keep original hot spot."}, + { GIMP_PDB_INT32, "crop", "Auto-crop or not" }, + { GIMP_PDB_INT32, "size", "Default nominal size" }, + { GIMP_PDB_INT32, "size_replace", "Replace existent size or not." }, + { GIMP_PDB_INT32, "delay", "Default delay" }, + { GIMP_PDB_INT32, "delay_replace","Replace existent delay or not."}, + { GIMP_PDB_STRING, "copyright", "Copyright information." }, + { GIMP_PDB_STRING, "license", "License information." }, + { GIMP_PDB_STRING, "other", "Other comment.(taken from " + "\"gimp-comment\" parasite)" } + }; + + gimp_install_procedure (LOAD_PROC, + "Loads files of X11 Mouse Cursor file format", + "This plug-in loads X11 Mouse Cursor (XMC) files.", + "Takeshi Matsuyama <tksmashiw@gmail.com>", + "Takeshi Matsuyama", + "26 May 2009", + N_("X11 Mouse Cursor"), + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (load_args), + G_N_ELEMENTS (load_return_vals), + load_args, + load_return_vals); + + gimp_register_file_handler_mime (LOAD_PROC, XCURSOR_MIME_TYPE); + gimp_register_magic_load_handler (LOAD_PROC, + XCURSOR_EXTENSION, + "", + "0,string,Xcur"); + + gimp_install_procedure (LOAD_THUMB_PROC, + "Loads only first frame of X11 Mouse Cursor's " + "animation sequence which nominal size is the closest " + "of thumb-size to be used as a thumbnail", + "", + "Takeshi Matsuyama <tksmashiw@gmail.com>", + "Takeshi Matsuyama", + "26 May 2009", + NULL, + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (thumb_args), + G_N_ELEMENTS (thumb_return_vals), + thumb_args, + thumb_return_vals); + + gimp_register_thumbnail_loader (LOAD_PROC, LOAD_THUMB_PROC); + + gimp_install_procedure (SAVE_PROC, + "Exports files of X11 cursor file", + "This plug-in exports X11 Mouse Cursor (XMC) files", + "Takeshi Matsuyama <tksmashiw@gmail.com>", + "Takeshi Matsuyama", + "26 May 2009", + N_("X11 Mouse Cursor"), + "RGBA", + GIMP_PLUGIN, + G_N_ELEMENTS (save_args), 0, + save_args, NULL); + + gimp_register_file_handler_mime (SAVE_PROC, XCURSOR_MIME_TYPE); + gimp_register_save_handler (SAVE_PROC, XCURSOR_EXTENSION, ""); +} + +/* + * 'run()' - Run the plug-in... + */ + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + static GimpParam values[6]; + GimpRunMode run_mode; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + gint32 image_ID; + gint32 drawable_ID; + gint32 orig_image_ID; + GimpExportReturn export = GIMP_EXPORT_CANCEL; + GeglRectangle *hotspotRange = NULL; + gint32 width, height; + gint32 num_layers; + GError *error = NULL; + gint i; + + INIT_I18N (); + gegl_init (NULL, NULL); + + DM_XMC ("run: start.\n"); + *nreturn_vals = 1; + *return_vals = values; + + values[0].type = GIMP_PDB_STATUS; + values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; + + if (strcmp (name, LOAD_PROC) == 0) + { + DM_XMC ("Starting to load file.\tparam.data=%s\n", + param[1].data.d_string); + image_ID = load_image (param[1].data.d_string, &error); + + if (image_ID != -1) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_IMAGE; + values[1].data.d_image = image_ID; + DM_XMC ("LOAD_PROC successfully load image. image_ID=%i\n", image_ID); + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + } + else if (strcmp (name, LOAD_THUMB_PROC) == 0) + { + DM_XMC ("Starting to load thumbnail.\tfilename=%s\tthumb-size=%d\n", + param[0].data.d_string, param[1].data.d_int32); + image_ID = load_thumbnail (param[0].data.d_string, + param[1].data.d_int32, + &width, + &height, + &num_layers, + &error); + + if (image_ID != -1) + { + *nreturn_vals = 6; + values[1].type = GIMP_PDB_IMAGE; + values[1].data.d_image = image_ID; + values[2].type = GIMP_PDB_INT32; + values[2].data.d_int32 = width; /* width */ + values[3].type = GIMP_PDB_INT32; + values[3].data.d_int32 = height; /* height */ + /* This will not work on GIMP 2.6, but not harmful. */ + values[4].type = GIMP_PDB_INT32; + values[4].data.d_int32 = GIMP_RGBA_IMAGE; /* type */ + values[5].type = GIMP_PDB_INT32; + values[5].data.d_int32 = num_layers; /* num_layers */ + + DM_XMC ("LOAD_THUMB_PROC successfully load image. image_ID=%i\n", image_ID); + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + } + else if (strcmp (name, SAVE_PROC) == 0) + { + DM_XMC ("run: export %s\n", name); + run_mode = param[0].data.d_int32; + image_ID = orig_image_ID = param[1].data.d_int32; + drawable_ID = param[2].data.d_int32; + hotspotRange = get_intersection_of_frames (image_ID); + + if (! hotspotRange) + { + g_set_error (&error, 0, 0, + _("Cannot set the hot spot!\n" + "You must arrange layers so that all of them have an intersection.")); + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; + + return; + } + + /* eventually export the image */ + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + case GIMP_RUN_WITH_LAST_VALS: + gimp_ui_init (PLUG_IN_BINARY, FALSE); + + export = gimp_export_image (&image_ID, &drawable_ID, "XMC", + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS | + GIMP_EXPORT_NEEDS_ALPHA); + + if (export == GIMP_EXPORT_CANCEL) + { + *nreturn_vals = 1; + values[0].data.d_status = GIMP_PDB_CANCEL; + + return; + } + break; + + default: + break; + } + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + /* + * Possibly retrieve data... + */ + gimp_get_data (SAVE_PROC, &xmcvals); + load_comments (image_ID); + + load_default_hotspot (image_ID, hotspotRange); + + if (! save_dialog (image_ID, hotspotRange)) + status = GIMP_PDB_CANCEL; + break; + + case GIMP_RUN_NONINTERACTIVE: + /* + * Make sure all the arguments are there! + */ + if (nparams != 15) + { + status = GIMP_PDB_CALLING_ERROR; + } + else + { + if (pix_in_region (param[5].data.d_int32, param[6].data.d_int32, + hotspotRange)) + { /* if passed hotspot is acceptable, use that ones. */ + xmcparas.x = param[5].data.d_int32; + xmcparas.y = param[6].data.d_int32; + } + else + { + load_default_hotspot (image_ID, hotspotRange); + /* you can purposely choose non acceptable values for hotspot + to use cursor's original values. */ + } + xmcvals.crop = param[7].data.d_int32; + xmcvals.size = param[8].data.d_int32; + xmcvals.size_replace = param[9].data.d_int32; + /* load delay */ + if (param[10].data.d_int32 < CURSOR_MINIMUM_DELAY) + { + xmcvals.delay = CURSOR_DEFAULT_DELAY; + } + else + { + xmcvals.delay = param[10].data.d_int32; + } + xmcvals.delay_replace = param[11].data.d_int32; + load_comments (image_ID); + for (i = 0; i < 3; ++i) + { + if (param[i + 12].data.d_string && + g_utf8_validate (param[i + 12].data.d_string, -1, NULL)) + { + xmcparas.comments[i] = g_strdup (param[i + 12].data.d_string); + } + } + } + break; + + case GIMP_RUN_WITH_LAST_VALS: + /* Possibly retrieve data... */ + gimp_get_data (SAVE_PROC, &xmcvals); + load_comments (image_ID); + load_default_hotspot (image_ID, hotspotRange); + break; + + default: + break; + } + if (status == GIMP_PDB_SUCCESS) + { + if (save_image (param[3].data.d_string, image_ID, + drawable_ID, orig_image_ID, &error)) + { + gimp_set_data (SAVE_PROC, &xmcvals, sizeof (XmcSaveVals)); + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + } + + if (export == GIMP_EXPORT_EXPORT) + gimp_image_delete (image_ID); + + g_free (hotspotRange); + + for (i = 0; i < 3 ; ++i) + { + g_free (xmcparas.comments[i]); + xmcparas.comments[i] = NULL; + } + } + else + { + DM_XMC ("name=%s\n", name); + status = GIMP_PDB_CALLING_ERROR; + } + + if (status != GIMP_PDB_SUCCESS && error) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + } + + values[0].data.d_status = status; + DM_XMC ("run: finish\n"); +} + + +/* + * 'load_image()' - Load a X cursor image into a new image window. + */ + +static gint32 +load_image (const gchar *filename, + GError **error) +{ + FILE *fp; + gint32 image_ID; + gint32 layer_ID; + GeglBuffer *buffer; + XcursorComments *commentsp; /* pointer to comments */ + XcursorImages *imagesp; /* pointer to images*/ + guint32 delay; /* use guint32 instead CARD32(in X11/Xmd.h) */ + gchar *framename; /* name of layer */ + guint32 *tmppixel; /* pixel data (guchar * bpp = guint32) */ + gint img_width; + gint img_height; + gint i, j; + + gimp_progress_init_printf (_("Opening '%s'"), + gimp_filename_to_utf8 (filename)); + + /* Open the file and check it is a valid X cursor */ + + fp = g_fopen (filename, "rb"); + + if (fp == NULL) + { + g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), + _("Could not open '%s' for reading: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return -1; + } + + if (! XcursorFileLoad (fp, &commentsp, &imagesp)) + { + g_set_error (error, 0, 0, _("'%s' is not a valid X cursor."), + gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + + /* check dimension is valid. */ + + for (i = 0; i < imagesp->nimage; i++) + { + if (imagesp->images[i]->width > MAX_LOAD_DIMENSION) + { + g_set_error (error, 0, 0, + _("Frame %d of '%s' is too wide for an X cursor."), + i + 1, gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + if (imagesp->images[i]->height > MAX_LOAD_DIMENSION) + { + g_set_error (error, 0, 0, + _("Frame %d of '%s' is too high for an X cursor."), + i + 1, gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + } + + find_hotspots_and_dimensions (imagesp, + &xmcparas.x, &xmcparas.y, + &img_width, &img_height); + + DM_XMC ("xhot=%i,\tyhot=%i,\timg_width=%i,\timg_height=%i\n", + xmcparas.x, xmcparas.y, img_width, img_height); + + image_ID = gimp_image_new (img_width, img_height, GIMP_RGB); + + gimp_image_set_filename (image_ID, filename); + + if (! set_hotspot_to_parasite (image_ID)) + { + fclose (fp); + return -1; + } + + /* Temporary buffer */ + tmppixel = g_new (guint32, img_width * img_height); + + /* load each frame to each layer one by one */ + for (i = 0; i < imagesp->nimage; i++) + { + gint width = imagesp->images[i]->width; + gint height = imagesp->images[i]->height; + + delay = imagesp->images[i]->delay; + + if (delay < CURSOR_MINIMUM_DELAY) + { + delay = CURSOR_DEFAULT_DELAY; + } + + DM_XMC ("images[%i]->delay=%i\twidth=%d\theight=%d\n", + i ,delay, imagesp->images[i]->width, imagesp->images[i]->height); + + framename = make_framename (imagesp->images[i]->size, delay, + DISPLAY_DIGIT (imagesp->nimage), error); + if (! framename) + { + fclose (fp); + return -1; + } + + layer_ID = gimp_layer_new (image_ID, framename, width, height, + GIMP_RGBA_IMAGE, + 100, + gimp_image_get_default_new_layer_mode (image_ID)); + gimp_image_insert_layer (image_ID, layer_ID, -1, 0); + + /* Adjust layer position to let hotspot sit on the same point. */ + gimp_item_transform_translate (layer_ID, + xmcparas.x - imagesp->images[i]->xhot, + xmcparas.y - imagesp->images[i]->yhot); + + g_free (framename); + + /* Get the buffer for our load... */ + + buffer = gimp_drawable_get_buffer (layer_ID); + + /* set color to each pixel */ + for (j = 0; j < width * height; j++) + { + tmppixel[j] = separate_alpha (imagesp->images[i]->pixels[j]); + } + + /* set pixel */ + gegl_buffer_set (buffer, GEGL_RECTANGLE (0, 0, width, height), 0, + NULL, tmppixel, GEGL_AUTO_ROWSTRIDE); + + gimp_progress_update ((i + 1) / imagesp->nimage); + + g_object_unref (buffer); + } + + g_free (tmppixel); + + gimp_progress_update (1.0); + + /* Comment parsing */ + + if (commentsp) + { + for (i = 0; i < commentsp->ncomment; ++i) + { + DM_XMC ("comment type=%d\tcomment=%s\n", + commentsp->comments[i]->comment_type, + commentsp->comments[i]->comment); + if (! set_comment_to_pname (image_ID, + commentsp->comments[i]->comment, + parasiteName[commentsp->comments[i]->comment_type -1])) + { + DM_XMC ("Failed to write %ith comment.\n", i); + fclose (fp); + return -1; + } + } + } + + DM_XMC ("Comment parsing done.\n"); + XcursorImagesDestroy (imagesp); + XcursorCommentsDestroy (commentsp); + fclose (fp); + + gimp_progress_end (); + + return image_ID; +} + +/* + * load_thumbnail + */ + +static gint32 +load_thumbnail (const gchar *filename, + gint32 thumb_size, + gint32 *thumb_width, + gint32 *thumb_height, + gint32 *thumb_num_layers, + GError **error) +{ + /* Return only one frame for thumbnail. + * We select first frame of an animation sequence which nominal size is the + * closest of thumb_size. + */ + + XcursorImages *xcIs = NULL; /* use to find the dimensions of thumbnail */ + XcursorImage *xcI; /* temporary pointer to XcursorImage */ + guint32 *positions; /* array of the offsets of image chunks */ + guint32 size; /* nominal size */ + guint32 diff; /* difference between thumb_size and current size */ + guint32 min_diff = XCURSOR_IMAGE_MAX_SIZE; /* minimum value of diff */ + guint32 type; /* chunk type */ + FILE *fp = NULL; + gint32 image_ID = -1; + gint32 layer_ID; + GeglBuffer *buffer; + guint32 *tmppixel; /* pixel data (guchar * bpp = guint32) */ + guint32 ntoc = 0; /* the number of table of contents */ + gint sel_num = -1; /* the index of selected image chunk */ + gint width; + gint height; + gint i; + + g_return_val_if_fail (thumb_width, -1); + g_return_val_if_fail (thumb_height, -1); + g_return_val_if_fail (thumb_num_layers, -1); + + *thumb_width = 0; + *thumb_height = 0; + *thumb_num_layers = 0; + + fp = g_fopen (filename, "rb"); + + if (fp == NULL) + { + g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), + _("Could not open '%s' for reading: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return -1; + } + + /* From this line, we make a XcursorImages struct so that we can find out the + * width and height of entire image. + * We can use XcursorFileLoadImages (fp, thumb_size) from libXcursor instead + * of this ugly code but XcursorFileLoadImages loads all pixel data of the + * image chunks on memory thus we should not use it. + */ + + /* find which image chunk is preferred to load. */ + + /* skip magic, headersize, version */ + fseek (fp, 12, SEEK_SET); + /* read the number of chunks */ + ntoc = READ32 (fp, error) + if (ntoc > (G_MAXUINT32 / sizeof (guint32))) + { + g_set_error (error, 0, 0, + "'%s' seems to have an incorrect toc size.", + gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + positions = g_malloc (ntoc * sizeof (guint32)); + + /* enter list of toc(table of contents) */ + for (; ntoc > 0; --ntoc) + { + /* read entry type */ + type = READ32 (fp, error) + if (type != XCURSOR_IMAGE_TYPE) + { + /* not a image */ + + /* skip rest of this content */ + fseek (fp, 8, SEEK_CUR); + } + else + { + /* this content is image */ + + size = READ32 (fp, error) + positions[*thumb_num_layers] = READ32 (fp, error) + /* is this image is more preferred than selected before? */ + diff = MAX (thumb_size, size) - MIN (thumb_size, size); + if (diff < min_diff) + {/* the image size is closer than current selected image */ + min_diff = diff; + sel_num = *thumb_num_layers; + } + ++*thumb_num_layers; + } + } + + if (sel_num < 0) + { + g_set_error (error, 0, 0, + _("there is no image chunk in \"%s\"."), + gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + + /* get width and height of entire image */ + + /* Let's make XcursorImages */ + xcIs = XcursorImagesCreate (*thumb_num_layers); + xcIs->nimage = *thumb_num_layers; + for (i = 0; i < xcIs->nimage; ++i) + { + /* make XcursorImage with no pixel buffer */ + xcI = XcursorImageCreate (0, 0); + /* go to the image chunk header */ + fseek (fp, positions[i], SEEK_SET); + /* skip chunk header */ + fseek (fp, 16, SEEK_CUR); + /* read properties of this image to determine entire image dimensions */ + xcI->width = READ32 (fp, error) + xcI->height = READ32 (fp, error) + xcI->xhot = READ32 (fp, error) + xcI->yhot = READ32 (fp, error) + + xcIs->images[i] = xcI; + } + + DM_XMC ("selected size is %i or %i\n", + thumb_size - min_diff, thumb_size + min_diff); + + /* get entire image dimensions */ + find_hotspots_and_dimensions (xcIs, NULL, NULL, thumb_width, thumb_height); + + DM_XMC ("width=%i\theight=%i\tnum-layers=%i\n", + *thumb_width, *thumb_height, xcIs->nimage); + + /* dimension check */ + if (*thumb_width > MAX_LOAD_DIMENSION) + { + g_set_error (error, 0, 0, + _("'%s' is too wide for an X cursor."), + gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + + if (*thumb_height > MAX_LOAD_DIMENSION) + { + g_set_error (error, 0, 0, + _("'%s' is too high for an X cursor."), + gimp_filename_to_utf8 (filename)); + fclose (fp); + return -1; + } + + /* create new image! */ + + width = xcIs->images[sel_num]->width; + height = xcIs->images[sel_num]->height; + + image_ID = gimp_image_new (width, height, GIMP_RGB); + + layer_ID = gimp_layer_new (image_ID, NULL, width, height, + GIMP_RGBA_IMAGE, + 100, + gimp_image_get_default_new_layer_mode (image_ID)); + + gimp_image_insert_layer (image_ID, layer_ID, -1, 0); + + /* + * Get the drawable and set the pixel region for our load... + */ + + buffer = gimp_drawable_get_buffer (layer_ID); + + /* Temporary buffer */ + tmppixel = g_new (guint32, width * height); + + /* copy the chunk data to tmppixel */ + fseek (fp, positions[sel_num], SEEK_SET); + fseek (fp, 36, SEEK_CUR); /* skip chunk header(16bytes), xhot, yhot, width, height, delay */ + + for (i = 0; i < width * height; i++) + { + tmppixel[i] = READ32 (fp, error) + /* get back separate alpha */ + tmppixel[i] = separate_alpha (tmppixel[i]); + } + + /* set pixel */ + gegl_buffer_set (buffer, GEGL_RECTANGLE (0, 0, width, height), 0, + NULL, tmppixel, GEGL_AUTO_ROWSTRIDE); + + /* free tmppixel */ + g_free(tmppixel); + g_free (positions); + fclose (fp); + + g_object_unref (buffer); + + return image_ID; +} + +/* read guint32 value from f despite of host's byte order. */ +static guint32 +read32 (FILE *f, + GError **error) +{ + guchar p[4]; + guint32 ret; + + if (fread (p, 1, 4, f) != 4) + { + g_set_error (error, 0, 0, _("A read error occurred.")); + return 0; + } + +#if G_BYTE_ORDER == G_LITTLE_ENDIAN + ret = p[0] + (p[1]<<8) + (p[2]<<16) + (p[3]<<24); +#elif G_BYTE_ORDER == G_BIG_ENDIAN + ret = p[3] + (p[2]<<8) + (p[1]<<16) + (p[0]<<24); +#elif G_BYTE_ORDER == G_PDP_ENDIAN + ret = p[2] + (p[3]<<8) + (p[0]<<16) + (p[1]<<24); +#else + g_return_val_if_rearched (); +#endif + + return ret; +} + +/* 'save_dialog ()' + */ +static gboolean +save_dialog (const gint32 image_ID, + GeglRectangle *hotspotRange) +{ + GtkWidget *dialog; + GtkWidget *frame; + GtkWidget *table; + GtkWidget *box; + GtkAdjustment *adjustment; + GtkWidget *alignment; + GtkWidget *tmpwidget; + GtkWidget *label; + GtkTextBuffer *textbuffer; + GValue val = G_VALUE_INIT; + gint x1, x2, y1, y2; + gboolean run; + + g_value_init (&val, G_TYPE_DOUBLE); + dialog = gimp_export_dialog_new (_("X11 Mouse Cursor"), + PLUG_IN_BINARY, SAVE_PROC); + + /* + * parameter settings + */ + frame = gimp_frame_new (_("XMC Options")); + gtk_container_set_border_width (GTK_CONTAINER (frame), 12); + gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)), + frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + table = gtk_table_new (9, 3, FALSE); + gtk_widget_show (table); + gtk_table_set_col_spacings (GTK_TABLE (table), 6); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_container_set_border_width (GTK_CONTAINER (table), 12); + gtk_container_add (GTK_CONTAINER (frame), table); + + /* + * Hotspot + */ + /* label "Hot spot _X:" + spinbox */ + x1 = hotspotRange->x; + x2 = hotspotRange->width + hotspotRange->x - 1; + + adjustment = (GtkAdjustment *) + gtk_adjustment_new (xmcparas.x, x1, x2, 1, 5, 0); + tmpwidget = gimp_spin_button_new (adjustment, 1.0, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tmpwidget), TRUE); + g_value_set_double (&val, 1.0); + g_object_set_property (G_OBJECT (tmpwidget), "xalign", &val);/* align right*/ + gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, + _("Hot spot _X:"), 0, 0.5, tmpwidget, 1, TRUE); + gtk_widget_show (tmpwidget); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_int_adjustment_update), + &xmcparas.x); + + gimp_help_set_help_data (tmpwidget, + _("Enter the X coordinate of the hot spot. " + "The origin is top left corner."), + NULL); + + /* label "Y:" + spinbox */ + y1 = hotspotRange->y; + y2 = hotspotRange->height + hotspotRange->y - 1; + + adjustment = (GtkAdjustment *) + gtk_adjustment_new (xmcparas.y, y1, y2, 1, 5, 0); + tmpwidget = gimp_spin_button_new (adjustment, 1.0, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tmpwidget), TRUE); + g_value_set_double (&val, 1.0); + g_object_set_property (G_OBJECT (tmpwidget), "xalign", &val);/* align right*/ + gimp_table_attach_aligned (GTK_TABLE (table), 1, 0, + "_Y:", 1.0, 0.5, tmpwidget, 1, TRUE); + gtk_widget_show (tmpwidget); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_int_adjustment_update), + &xmcparas.y); + + gimp_help_set_help_data (tmpwidget, + _("Enter the Y coordinate of the hot spot. " + "The origin is top left corner."), + NULL); + + /* + * Auto-crop + */ + /* check button */ + tmpwidget = + gtk_check_button_new_with_mnemonic (_("_Auto-Crop all frames.")); + gtk_table_attach (GTK_TABLE (table), + tmpwidget, 0, 3, 1, 2, GTK_FILL, 0, 0, 10); + gtk_widget_show (tmpwidget); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpwidget), + xmcvals.crop); + gtk_widget_show (tmpwidget); + g_signal_connect (tmpwidget, "toggled", + G_CALLBACK (gimp_toggle_button_update), + &xmcvals.crop); + /* tooltip */ + gimp_help_set_help_data (tmpwidget, + _("Remove the empty borders of all frames.\n" + "This reduces the file size and may fix " + "the problem that some large cursors disorder " + "the screen.\n" + "Uncheck if you plan to edit the exported " + "cursor using other programs."), + NULL); + + /* + * size + */ + tmpwidget = + gimp_int_combo_box_new ("12px", 12, "16px", 16, + "24px", 24, "32px", 32, + "36px", 36, "40px", 40, + "48px", 48, "64px", 64, NULL); + gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (tmpwidget), + 32, + G_CALLBACK (gimp_int_combo_box_get_active), + &xmcvals.size); + gtk_widget_show (tmpwidget); + /* tooltip */ + gimp_help_set_help_data (tmpwidget, + _("Choose the nominal size of frames.\n" + "If you don't have plans to make multi-sized " + "cursor, or you have no idea, leave it \"32px\".\n" + "Nominal size has no relation with the actual " + "size (width or height).\n" + "It is only used to determine which frame depends " + "on which animation sequence, and which sequence " + "is used based on the value of " + "\"gtk-cursor-theme-size\"."), + NULL); + + gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, + _("_Size:"), 0, 0.5, tmpwidget, 3, TRUE); + /* Replace size ? */ + tmpwidget = + gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (gimp_radio_button_update), + &xmcvals.size_replace, xmcvals.size_replace, + _("_Use this value only for a frame which size " + "is not specified."), + FALSE, NULL, + _("_Replace the size of all frames even if it " + "is specified."), + TRUE, NULL, + NULL); + alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0); + gtk_widget_show (alignment); + gtk_table_attach (GTK_TABLE (table), alignment, 0, 3, 3, 4, 0, 0, 0, 0); + gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 6, 20, 0); /*padding left*/ + gtk_container_add (GTK_CONTAINER (alignment), tmpwidget); + gtk_widget_show (tmpwidget); + + /* + * delay + */ + /* spin button */ + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, _("_Delay:"), + 0, 0.5, box, 3, TRUE); + gtk_widget_show (box); + + gimp_help_set_help_data (box, + _("Enter time span in milliseconds in which " + "each frame is rendered."), + NULL); + + adjustment = (GtkAdjustment *) + gtk_adjustment_new (xmcvals.delay, CURSOR_MINIMUM_DELAY, + CURSOR_MAX_DELAY, 1, 5, 0); + tmpwidget = gimp_spin_button_new (adjustment, 1.0, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tmpwidget), TRUE); + g_value_set_double (&val, 1.0); + g_object_set_property (G_OBJECT (tmpwidget), "xalign", &val);/* align right*/ + gtk_box_pack_start (GTK_BOX (box), tmpwidget, TRUE, TRUE, 0); + gtk_widget_show (tmpwidget); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_int_adjustment_update), + &xmcvals.delay); + + /* appended "ms" */ + tmpwidget = gtk_label_new ("ms"); + gtk_label_set_xalign (GTK_LABEL (tmpwidget), 0.0); /*align left*/ + gtk_box_pack_start (GTK_BOX (box), tmpwidget, TRUE, TRUE, 0); + gtk_widget_show (tmpwidget); + + /* Replace delay? */ + tmpwidget = + gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (gimp_radio_button_update), + &xmcvals.delay_replace, xmcvals.delay_replace, + _("_Use this value only for a frame which delay " + "is not specified."), + FALSE, NULL, + _("_Replace the delay of all frames even if it " + "is specified."), + TRUE, NULL, + NULL); + alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0); + gtk_widget_show (alignment); + gtk_table_attach (GTK_TABLE (table), alignment, 0, 3, 5, 6, 0, 0, 0, 0); + gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 6, 20, 0); /*padding left*/ + gtk_container_add (GTK_CONTAINER (alignment), tmpwidget); + gtk_widget_show (tmpwidget); + + /* + * Copyright + */ + tmpwidget = gtk_entry_new (); + /* Maximum length will be clamped to 65536 */ + gtk_entry_set_max_length (GTK_ENTRY (tmpwidget), XCURSOR_COMMENT_MAX_LEN); + + if (xmcparas.comments[0]) + { + gtk_entry_set_text (GTK_ENTRY (tmpwidget), + gimp_any_to_utf8 (xmcparas.comments[0], - 1, NULL)); + /* show warning if comment is over 65535 characters + * because gtk_entry can hold only that. */ + if (strlen (gtk_entry_get_text (GTK_ENTRY (tmpwidget))) >= 65535) + g_message (_("The part of copyright information " + "that exceeded 65535 characters was removed.")); + } + + g_signal_connect (tmpwidget, "changed", + G_CALLBACK (comment_entry_callback), + xmcparas.comments); + gtk_widget_show (tmpwidget); + /* tooltip */ + gimp_help_set_help_data (tmpwidget, + _("Enter copyright information."), + NULL); + gimp_table_attach_aligned (GTK_TABLE (table), 0, 6, _("_Copyright:"), + 0, 0.5, tmpwidget, 3, FALSE); + /* + * License + */ + tmpwidget = gtk_entry_new (); + /* Maximum length will be clamped to 65536 */ + gtk_entry_set_max_length (GTK_ENTRY (tmpwidget), XCURSOR_COMMENT_MAX_LEN); + + if (xmcparas.comments[1]) + { + gtk_entry_set_text (GTK_ENTRY (tmpwidget), + gimp_any_to_utf8 (xmcparas.comments[1], - 1, NULL)); + /* show warning if comment is over 65535 characters + * because gtk_entry can hold only that. */ + if (strlen (gtk_entry_get_text (GTK_ENTRY (tmpwidget))) >= 65535) + g_message (_("The part of license information " + "that exceeded 65535 characters was removed.")); + } + + g_signal_connect (tmpwidget, "changed", + G_CALLBACK (comment_entry_callback), + xmcparas.comments + 1); + gtk_widget_show (tmpwidget); + /* tooltip */ + gimp_help_set_help_data (tmpwidget, + _("Enter license information."), + NULL); + gimp_table_attach_aligned (GTK_TABLE (table), 0, 7, _("_License:"), + 0, 0.5, tmpwidget, 3, FALSE); + /* + * Other + */ + /* We use gtk_text_view for "Other" while "Copyright" & "License" is entered + * in gtk_entry because We want allow '\n' for "Other". */ + label = gtk_label_new_with_mnemonic (_("_Other:")); + gtk_widget_show (label); + gtk_label_set_xalign (GTK_LABEL (label), 0.0); /*align top-left*/ + gtk_label_set_yalign (GTK_LABEL (label), 0.0); /*align top-left*/ + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 8, 9, GTK_FILL, 0, 0, 0); + /* content of Other */ + /* scrolled window */ + box = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (box), + GTK_SHADOW_IN); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (box), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_table_attach (GTK_TABLE (table), box, 1, 3, 8, 9, GTK_FILL, 0, 0, 0); + gtk_widget_show (box); + /* textbuffer */ + textbuffer = gtk_text_buffer_new (NULL); + if (xmcparas.comments[2]) + gtk_text_buffer_set_text (textbuffer, + gimp_any_to_utf8 (xmcparas.comments[2], -1, NULL), + -1); + g_signal_connect (textbuffer, "changed", + G_CALLBACK (text_view_callback), + xmcparas.comments + 2); + /* textview */ + tmpwidget = + gtk_text_view_new_with_buffer (GTK_TEXT_BUFFER (textbuffer)); + gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (tmpwidget), FALSE); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (tmpwidget), GTK_WRAP_WORD); + g_object_unref (textbuffer); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (tmpwidget), GTK_WRAP_WORD); + gtk_container_add (GTK_CONTAINER (box), tmpwidget); + gtk_widget_show (tmpwidget); + /* tooltip */ + gimp_help_set_help_data (tmpwidget, + _("Enter other comment if you want."), + NULL); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), tmpwidget); + + /* + * all widget is prepared. Let's show dialog. + */ + gtk_widget_show (dialog); + + run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); + + gtk_widget_destroy (dialog); + + return run; +} + +/* + * callback function of gtk_entry for "copyright" and "license". + * "other" is processed by text_view_callback + */ +static void +comment_entry_callback (GtkWidget *widget, + gchar **commentp) +{ + const gchar *text; + + g_return_if_fail (commentp); + + text = gtk_entry_get_text (GTK_ENTRY (widget)); + + /* This will not happen because sizeof(gtk_entry) < XCURSOR_COMMENT_MAX_LEN */ + g_return_if_fail (strlen (text) <= XCURSOR_COMMENT_MAX_LEN); + + g_free (*commentp); + *commentp = g_strdup (text); +} + +static void +text_view_callback (GtkTextBuffer *buffer, + gchar **commentp) +{ + GtkTextIter start_iter; + GtkTextIter end_iter; + gchar *text; + + g_return_if_fail (commentp != NULL); + + gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter); + text = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE); + + if (strlen (text) > XCURSOR_COMMENT_MAX_LEN) + { + g_message (_("Comment is limited to %d characters."), + XCURSOR_COMMENT_MAX_LEN); + + gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, + XCURSOR_COMMENT_MAX_LEN - 1); + gtk_text_buffer_get_end_iter (buffer, &end_iter); + + gtk_text_buffer_delete (buffer, &start_iter, &end_iter); + } + else + { + g_free (*commentp); + *commentp = g_strdup (text); + } +} + +/** + * Set default hotspot based on hotspotRange. +**/ +static gboolean +load_default_hotspot (const gint32 image_ID, + GeglRectangle *hotspotRange) +{ + + g_return_val_if_fail (hotspotRange, FALSE); + + if ( /* if we cannot load hotspot correctly */ + ! get_hotspot_from_parasite (image_ID) || + /* ,or hostspot is out of range */ + ! pix_in_region (xmcparas.x, xmcparas.y, hotspotRange)) + { + /* then use top left point of hotspotRange as fallback. */ + xmcparas.x = hotspotRange->x; + xmcparas.y = hotspotRange->y; + } + + return TRUE; +} + +/* + * 'save_image ()' - Save the specified image to X cursor file. + */ + +static gboolean +save_image (const gchar *filename, + gint32 image_ID, + gint32 drawable_ID, + gint32 orig_image_ID, + GError **error) +{ + FILE *fp; /* File pointer */ + gboolean dimension_warn = FALSE; /* become TRUE if even one + * of the dimensions of the + * frames of the cursor is + * over + * MAX_BITMAP_CURSOR_SIZE */ + gboolean size_warn = FALSE; /* become TRUE if even one + * of the nominal size of + * the frames is not + * supported by + * gnome-appearance-properties */ + GRegex *re; /* used to get size and delay from + * framename */ + XcursorComments *commentsp; /* pointer to comments */ + XcursorImages *imagesp; /* pointer to images */ + gint32 *layers; /* Array of layer */ + gint32 *orig_layers; /* Array of layer of orig_image */ + gint nlayers; /* Number of layers */ + gchar *framename; /* framename of a layer */ + GeglRectangle save_rgn; /* region to save */ + gint layer_xoffset, layer_yoffset; + /* temporary buffer which store pixel data (guchar * bpp = guint32) */ + guint32 pixelbuf[SQR (MAX_SAVE_DIMENSION)]; + gint i, j; /* Looping vars */ + + /* This will be used in set_size_and_delay function later. To + * define this in that function is easy to read but place here to + * reduce overheads. + */ + re = g_regex_new ("[(][ 0]*(\\d+)[ ]*(px|ms)[ ]*[)]", + G_REGEX_CASELESS | G_REGEX_OPTIMIZE, + 0, + NULL); + + gimp_progress_init_printf (_("Saving '%s'"), + gimp_filename_to_utf8 (filename)); + + /* + * Open the file pointer. + */ + DM_XMC ("Open the file pointer.\n"); + fp = g_fopen (filename, "wb"); + if (fp == NULL) + { + g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), + _("Could not open '%s' for writing: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return FALSE; + } + + /* get layers */ + orig_layers = gimp_image_get_layers (orig_image_ID, &nlayers); + layers = gimp_image_get_layers (image_ID, &nlayers); + + /* create new XcursorImages. */ + imagesp = XcursorImagesCreate (nlayers); + if (!imagesp) + { + DM_XMC ("Failed to XcursorImagesCreate!\n"); + fclose (fp); + return FALSE; + } + imagesp->nimage = nlayers; + + /* XcursorImages also have `name' member but it is not used as long as I know. + We leave it NULL here. */ + + /* + * Now we start to convert each layer to a XcurosrImage one by one. + */ + for (i = 0; i < nlayers; i++) + { + GeglBuffer *buffer; + const Babl *format; + gint width; + gint height; + + buffer = gimp_drawable_get_buffer (layers[nlayers - 1 - i]); + + width = gegl_buffer_get_width (buffer); + height = gegl_buffer_get_height (buffer); + + format = babl_format ("R'G'B'A u8"); + + /* get framename of this layer */ + framename = gimp_item_get_name (layers[nlayers - 1 - i]); + /* get offset of this layer. */ + gimp_drawable_offsets (layers[nlayers - 1 - i], &layer_xoffset, &layer_yoffset); + + /* + * layer dimension check. + */ + DM_XMC ("layer size check.\n"); + /* We allow to save a cursor which dimensions are no more than + * MAX_SAVE_DIMENSION but after auto-cropping, we warn (only + * warn, don't stop) if dimension is over + * MAX_BITMAP_CURSOR_SIZE. + */ + if (width > MAX_SAVE_DIMENSION) + { + g_set_error (error, 0, 0, + _("Frame '%s' is too wide. Please reduce to no more than %dpx."), + gimp_any_to_utf8 (framename, -1, NULL), + MAX_SAVE_DIMENSION); + fclose (fp); + return FALSE; + } + + if (height > MAX_SAVE_DIMENSION) + { + g_set_error (error, 0, 0, + _("Frame '%s' is too high. Please reduce to no more than %dpx."), + gimp_any_to_utf8 (framename, -1, NULL), + MAX_SAVE_DIMENSION); + fclose (fp); + return FALSE; + } + + if (height == 0 || width == 0) + { + g_set_error (error, 0, 0, + _("Width and/or height of frame '%s' is zero!"), + gimp_any_to_utf8 (framename, -1, NULL)); + fclose (fp); + return FALSE; + } + + if (xmcvals.crop) /* with auto-cropping */ + { + /* get the region of auto-cropped area. */ + DM_XMC ("get_cropped_region\n"); + get_cropped_region (&save_rgn, buffer); + + /* don't forget save_rgn's origin is not a entire image + * but a layer which we are doing on. + */ + + if (save_rgn.width == 0 || save_rgn.height == 0) + {/* perfectly transparent frames become 1x1px transparent pixel. */ + DM_XMC ("get_cropped_region return 0.\n"); + imagesp->images[i] = XcursorImageCreate (1, 1); + if (!imagesp->images[i]) + { + DM_XMC ("Failed to XcursorImageCreate.\n"); + fclose (fp); + return FALSE; + } + imagesp->images[i]->pixels[0] = 0x0; + imagesp->images[i]->xhot = 0; + imagesp->images[i]->yhot = 0; + set_size_and_delay (framename, &(imagesp->images[i]->size), + &(imagesp->images[i]->delay), re, + &size_warn); + continue; + } + /* OK save_rgn is not 0x0 */ + /* is hotspot in save_rgn ? */ + if (! pix_in_region (xmcparas.x - layer_xoffset, + xmcparas.y - layer_yoffset, + &save_rgn)) + { /* if hotspot is not on save_rgn */ + g_set_error (error, 0, 0, + _("Cannot export the cursor because the hot spot " + "is not on frame '%s'.\n" + "Try to change the hot spot position, " + "layer geometry or export without auto-crop."), + gimp_any_to_utf8 (framename, -1, NULL)); + fclose (fp); + return FALSE; + } + } + else /* if without auto-cropping... */ + { + /* set save_rgn for the case not to auto-crop */ + save_rgn.width = width; + save_rgn.height = height; + save_rgn.x = 0; + save_rgn.y = 0; + } + + /* We warn if the dimension of the layer is over MAX_BITMAP_CURSOR_SIZE. */ + if (! dimension_warn) + { + if (save_rgn.width > MAX_BITMAP_CURSOR_SIZE || + save_rgn.height > MAX_BITMAP_CURSOR_SIZE) + { + dimension_warn = TRUE; + /* actual warning is done after the cursor is successfully saved.*/ + } + } + /* + * Create new XcursorImage. + */ + DM_XMC ("create new xcursorimage.\twidth=%i\theight=%i\n", + save_rgn.width, save_rgn.height); + imagesp->images[i] = XcursorImageCreate (save_rgn.width, save_rgn.height); + /* Cursor width & height is automatically set by function */ + /* XcursorImageCreate, so no need to set manually. */ + if (!imagesp->images[i]) + { + DM_XMC ("Failed to XcursorImageCreate.\n"); + fclose (fp); + return FALSE; + } + /* + ** set images[i]'s xhot & yhot. + */ + /* [Cropped layer's hotspot] = + [image's hotspot] - [layer's offset] - [save_rgn's offset]. */ + DM_XMC ("xhot=%i\tsave_rgn->xoffset=%i\tlayer_xoffset=%i\n", + xmcparas.x, layer_xoffset, save_rgn.x); + DM_XMC ("yhot=%i\tsave_rgn->yoffset=%i\tlayer_yoffset=%i\n", + xmcparas.y, layer_yoffset, save_rgn.y); + imagesp->images[i]->xhot = xmcparas.x - layer_xoffset - save_rgn.x; + imagesp->images[i]->yhot = xmcparas.y - layer_yoffset - save_rgn.y; + DM_XMC ("images[%i]->xhot=%i\tyhot=%i\n", i, + imagesp->images[i]->xhot, imagesp->images[i]->yhot); + + /* + * set images[i]->pixels + */ + /* get image data to pixelbuf. */ + gegl_buffer_get (buffer, + GEGL_RECTANGLE (save_rgn.x, save_rgn.y, + save_rgn.width, save_rgn.height), 1.0, + format, pixelbuf, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + /*convert pixel date to XcursorPixel. */ + g_assert (save_rgn.width * save_rgn.height < SQR (MAX_SAVE_DIMENSION)); + for (j = 0; j < save_rgn.width * save_rgn.height; j++) + { + imagesp->images[i]->pixels[j] = premultiply_alpha (pixelbuf[j]); + } + + /* + * get back size & delay from framename. + */ + set_size_and_delay (framename, &(imagesp->images[i]->size), + &(imagesp->images[i]->delay), re, &size_warn); + + /* + * All property of this XcursorImage is loaded. + */ + + /* set the layer name of original image with the saved value */ + g_free (framename); + framename = make_framename (imagesp->images[i]->size, + imagesp->images[i]->delay, + DISPLAY_DIGIT (imagesp->nimage), + error); + if (! framename) + { + fclose (fp); + return FALSE; + } + + gimp_item_set_name (orig_layers[nlayers - 1 - i], framename); + g_free (framename); + + g_object_unref (buffer); + + gimp_progress_update ((i + 1) / imagesp->nimage); + } + + gimp_progress_update (1.0); + + /* + * comment parsing + */ + commentsp = set_cursor_comments (); + +#ifdef XMC_DEBUG + DM_XMC ("imagesp->nimage=%i\tname=%s\n", imagesp->nimage, imagesp->name); + for (i = 0; i < imagesp->nimage; ++i) + { + DM_XMC ("\timages[%i]->size=%i\n\ + \twidth=%i\n\ + \theight=%i\n\ + \txhot=%i\n\ + \tyhot=%i\n\ + \tdelay=%i\n\ + \t*pixels=%p\n", + i, + imagesp->images[i]->size, + imagesp->images[i]->width, + imagesp->images[i]->height, + imagesp->images[i]->xhot, + imagesp->images[i]->yhot, + imagesp->images[i]->delay, + imagesp->images[i]->pixels); + } + + if (commentsp) + { + for (i = 0; i < commentsp->ncomment; ++i) + { + DM_XMC ("comment type=%d\tcomment=%s\n", + commentsp->comments[i]->comment_type, + commentsp->comments[i]->comment); + } + } +#endif + + /* + * save cursor to file *fp. + */ + + if (commentsp) + { + if (! XcursorFileSave (fp, commentsp, imagesp)) + { + DM_XMC ("Failed to XcursorFileSave.\t%p\t%p\t%p\n", + fp, commentsp, imagesp); + fclose (fp); + return FALSE; + } + + } + else /* if no comments exist */ + { + if (! XcursorFileSaveImages (fp, imagesp)) + { + DM_XMC ("Failed to XcursorFileSaveImages.\t%p\t%p\n", fp, imagesp); + fclose (fp); + return FALSE; + } + } + + /* actual warning about dimensions */ + if (dimension_warn) + { + g_message (_("Your cursor was successfully exported but it contains one or " + "more frames whose width or height is more than %ipx, " + "a historical max dimension value for X bitmap cursors.\n" + "It might be unsupported by some environments."), + MAX_BITMAP_CURSOR_SIZE); + } + if (size_warn) + { + g_message (_("Your cursor was successfully exported but it contains one " + "or more frames whose nominal size is not supported by " + "GNOME settings.\n" + "You can satisfy it by checking \"Replace the size of all " + "frames...\" in the export dialog, or your cursor may not " + "appear in GNOME settings.")); + } + /* + * Done with the file... + */ + g_regex_unref (re); + DM_XMC ("fp=%p\n", fp); + fclose (fp); + DM_XMC ("%i frames written.\n", imagesp->nimage); + XcursorImagesDestroy (imagesp); + DM_XMC ("Xcursor destroyed.\n"); + XcursorCommentsDestroy (commentsp); /* this is safe even if commentsp is NULL. */ + gimp_progress_end (); + + /* Save the comment back to the original image */ + for (i = 0; i < 3; i++) + { + gimp_image_detach_parasite (orig_image_ID, parasiteName[i]); + + if (xmcparas.comments[i]) + { + if (! set_comment_to_pname (orig_image_ID, + xmcparas.comments[i], parasiteName[i])) + { + DM_XMC ("Failed to write back %ith comment to orig_image.\n", i); + } + } + } + /* Save hotspot back to the original image */ + set_hotspot_to_parasite (orig_image_ID); + + return TRUE; +} + +static inline guint32 +separate_alpha (guint32 pixel) +{ + guint alpha, red, green, blue; + guint32 retval; + +#if G_BYTE_ORDER != G_LITTLE_ENDIAN + pixel = GUINT32_TO_LE (pixel); +#endif + + blue = pixel & 0xff; + green = (pixel>>8) & 0xff; + red = (pixel>>16) & 0xff; + alpha = (pixel>>24) & 0xff; + + if (alpha == 0) + return 0; + + /* resume separate alpha data. */ + red = MIN (red * 255 / alpha, 255); + blue = MIN (blue * 255 / alpha, 255); + green = MIN (green * 255 / alpha, 255); + + retval = red + (green<<8) + (blue<<16) + (alpha<<24); + +#if G_BYTE_ORDER != G_LITTLE_ENDIAN + pixel = GUINT32_FROM_LE (pixel); +#endif + + return retval; +} + +static inline guint32 +premultiply_alpha (guint32 pixel) +{ + guint alpha, red, green, blue; + guint32 retval; + +#if G_BYTE_ORDER != G_LITTLE_ENDIAN + pixel = GUINT32_TO_LE (pixel); +#endif + + red = pixel & 0xff; + green = (pixel >> 8) & 0xff; + blue = (pixel >> 16) & 0xff; + alpha = (pixel >> 24) & 0xff; + + /* premultiply alpha + (see "premultiply_data" function at line 154 of xcursorgen.c) */ + red = div_255 (red * alpha); + green = div_255 (green * alpha); + blue = div_255 (blue * alpha); + + retval = blue + (green << 8) + (red << 16) + (alpha << 24); + +#if G_BYTE_ORDER != G_LITTLE_ENDIAN + pixel = GUINT32_FROM_LE (pixel); +#endif + + return retval; +} + +/* set comments to cursor from xmcparas.comments. + * don't forget to XcursorCommentsDestroy returned pointer later. + */ +static XcursorComments * +set_cursor_comments (void) +{ + gint i; + guint gcomlen, arraylen; + GArray *xcCommentsArray; + XcursorComment *(xcCommentp[3]) = {NULL,}; + XcursorComments *xcCommentsp; + + xcCommentsArray = g_array_new (FALSE, FALSE, sizeof (XcursorComment *)); + + for (i = 0; i < 3; ++i) + { + if (xmcparas.comments[i]) + { + gcomlen = strlen (xmcparas.comments[i]); + if (gcomlen > 0) + { + xcCommentp[i] = XcursorCommentCreate (i + 1, gcomlen); + /* first argument of XcursorCommentCreate is comment_type + defined in Xcursor.h as enumerator. + i + 1 is appropriate when we dispose parasiteName before MAIN(). */ + if (!xcCommentp[i]) + { + g_warning ("Cannot create xcCommentp[%i]\n", i); + return NULL; + } + else + { + g_stpcpy (xcCommentp[i]->comment, xmcparas.comments[i]); + g_array_append_val (xcCommentsArray, xcCommentp[i]); + } + } + } + } + + arraylen = xcCommentsArray->len; + + if (arraylen == 0) + return NULL; + + xcCommentsp = XcursorCommentsCreate (arraylen); + xcCommentsp->ncomment = arraylen; + + for (i = 0; i < arraylen; ++i) + { + xcCommentsp->comments[i] = + g_array_index (xcCommentsArray, XcursorComment* ,i); + } + + return xcCommentsp; +} + +/* Load xmcparas.comments from three parasites named as "xmc-copyright", + * "xmc-license","gimp-comment". + * This alignment sequence is depends on the definition of comment_type + * in Xcursor.h . + * Don't forget to g_free each element of xmcparas.comments later. + */ +static void +load_comments (const gint32 image_ID) +{ + gint i; + + g_return_if_fail (image_ID != -1); + + for (i = 0; i < 3; ++i) + xmcparas.comments[i] = get_comment_from_pname (image_ID, parasiteName[i]); +} + +/* Set content to a parasite named as pname. if parasite already + * exists, append the new one to the old one with "\n" + */ +static gboolean +set_comment_to_pname (const gint32 image_ID, + const gchar *content, + const gchar *pname) +{ + gboolean ret = FALSE; + gchar *tmpstring, *joind; + GimpParasite *parasite; + + g_return_val_if_fail (image_ID != -1, FALSE); + g_return_val_if_fail (content, FALSE); + + parasite = gimp_image_get_parasite (image_ID, pname); + if (! parasite) + { + parasite = gimp_parasite_new (pname, GIMP_PARASITE_PERSISTENT, + strlen (content) + 1, content); + } + else + { + tmpstring = g_strndup (gimp_parasite_data (parasite), + gimp_parasite_data_size (parasite)); + gimp_parasite_free (parasite); + joind = g_strjoin ("\n", tmpstring, content, NULL); + g_free (tmpstring); + parasite = gimp_parasite_new (pname, GIMP_PARASITE_PERSISTENT, + strlen (joind) + 1, joind); + g_free (joind); + } + + if (parasite) + { + ret = gimp_image_attach_parasite (image_ID, parasite); + gimp_parasite_free (parasite); + } + + return ret; +} + +/* get back comment from parasite name, don't forget to call + * g_free(returned pointer) later + */ +static gchar * +get_comment_from_pname (const gint32 image_ID, + const gchar *pname) +{ + gchar *string = NULL; + GimpParasite *parasite; + glong length; + + g_return_val_if_fail (image_ID != -1, NULL); + + parasite = gimp_image_get_parasite (image_ID, pname); + length = gimp_parasite_data_size (parasite); + + if (parasite) + { + if (length > XCURSOR_COMMENT_MAX_LEN) + { + length = XCURSOR_COMMENT_MAX_LEN; + g_message (_("The parasite \"%s\" is too long for an X cursor " + "comment. It was cut off to fit."), + gimp_any_to_utf8 (pname, -1,NULL)); + } + + string = g_strndup (gimp_parasite_data (parasite), length); + gimp_parasite_free (parasite); + } + + return string; +} + +/* Set hotspot to "hot-spot" parasite which format is common with that + * of file-xbm. + */ +static gboolean +set_hotspot_to_parasite (gint32 image_ID) +{ + gboolean ret = FALSE; + gchar *tmpstr; + GimpParasite *parasite; + + g_return_val_if_fail (image_ID != -1, FALSE); + + tmpstr = g_strdup_printf ("%d %d", xmcparas.x, xmcparas.y); + parasite = gimp_parasite_new ("hot-spot", + GIMP_PARASITE_PERSISTENT, + strlen (tmpstr) + 1, + tmpstr); + g_free (tmpstr); + + if (parasite) + { + ret = gimp_image_attach_parasite (image_ID, parasite); + gimp_parasite_free (parasite); + } + + return ret; +} + +/* Get back xhot & yhot from "hot-spot" parasite. + * If succeed, hotspot coordinate is set to xmcparas.x, xmcparas.y and + * return TRUE. + * If "hot-spot" is not found or broken, return FALSE. + */ +static gboolean +get_hotspot_from_parasite (gint32 image_ID) +{ + GimpParasite *parasite; + + g_return_val_if_fail (image_ID != -1, FALSE); + + DM_XMC ("function: getHotsopt\n"); + + parasite = gimp_image_get_parasite (image_ID, "hot-spot"); + if (!parasite) /* cannot find a parasite named "hot-spot". */ + { + return FALSE; + } + + if (sscanf (gimp_parasite_data (parasite), + "%i %i", &xmcparas.x, &xmcparas.y) < 2) + { /*cannot load hotspot.(parasite is broken?) */ + return FALSE; + } + + /*OK, hotspot is set to *xhotp & *yhotp. */ + return TRUE; +} + +/* Set size to sizep, delay to delayp from drawable's framename. + */ +static void +set_size_and_delay (const gchar *framename, + guint32 *sizep, + guint32 *delayp, + GRegex *re, + gboolean *size_warnp) +{ + guint32 size = 0; + guint32 delay = 0; + gchar *digits = NULL; + gchar *suffix = NULL; + GMatchInfo *info = NULL; + + g_return_if_fail (framename); + g_return_if_fail (sizep); + g_return_if_fail (delayp); + g_return_if_fail (re); + + DM_XMC ("function: set_size_and_delay\tframename=%s\n", framename); + + /* re is defined at the start of save_image() as + [(] : open parenthesis + [ ]* : ignore zero or more spaces + (\\d+) : the number we want to get out + [ ]* : ignore zero or more spaces + (px|ms) : whether "px"(size) or "ms"(delay) + [ ]* : ignore zero or more spaces + [)] : close parenthesis + This is intended to match for the animation-play plug-in. */ + + g_regex_match (re, framename, 0, &info); + + while (g_match_info_matches (info)) + { + digits = g_match_info_fetch (info, 1); + suffix = g_match_info_fetch (info, 2); + + if (g_ascii_strcasecmp (suffix, "px") == 0) + { + if (!size) /* substitute it only for the first time */ + { + if (strlen (digits) > 8) /* too large number should be clamped */ + { + g_message (_("Your cursor was successfully exported but it contains one or " + "more frames whose size is over 8 digits.\n" + "We clamped it to %dpx. You should check the exported cursor."), + MAX_BITMAP_CURSOR_SIZE); + size = MAX_BITMAP_CURSOR_SIZE; + } + else + { + size = atoi (digits); + } + } + } + else /* suffix is "ms" */ + { + if (!delay) /* substitute it only for the first time */ + { + if (strlen (digits) > 8) /* too large number should be clamped */ + delay = CURSOR_MAX_DELAY; + else + delay = MIN (CURSOR_MAX_DELAY, atoi (digits)); + } + } + + g_free (digits); + g_free (suffix); + + g_match_info_next (info, NULL); + } + + g_match_info_free (info); + + /* if size is not set, or size_replace is TRUE, set default size + * (which was chosen in save dialog) */ + if (size == 0 || xmcvals.size_replace == TRUE) + { + size = xmcvals.size; + } + else if (! *size_warnp && + size != 12 && size != 16 && size != 24 && size != 32 && + size != 36 && size != 40 && size != 48 && size != 64 && + size != 96) + { /* if the size is different from these values, we warn about it after + successfully saving because gnome-appearance-properties only support + them. */ + *size_warnp = TRUE; + } + + *sizep = size; + + /* if delay is not set, or delay_replace is TRUE, set default delay + * (which was chosen in save dialog) */ + if (delay == 0 || xmcvals.delay_replace == TRUE) + { + delay = xmcvals.delay; + } + + *delayp = delay; + + DM_XMC ("set_size_and_delay return\tsize=%i\tdelay=%i\n", size, delay); +} + +/* Return framename as format: "([x]px)_[i] ([t]ms) (replace)" + * where [x] is nominal size, [t] is delay passed as argument respectively, + * and [i] is an index separately counted by [x]. + * This format is compatible with "animation-play" plug-in. + * Don't forget to g_free returned framename later. + */ +static gchar * +make_framename (guint32 size, + guint32 delay, + guint indent, + GError **errorp) +{ + static struct + { + guint32 size; + guint count; + } Counter[MAX_SIZE_NUM + 1] = {{0,}}; + + int i; /* loop index */ + + /* don't pass 0 for size. */ + g_return_val_if_fail (size > 0, NULL); + + /* "count" member of Counter's element means how many time corresponding + "size" is passed to this function. The size member of the last element + of Counter must be 0, so Counter can have MAX_SIZE_NUM elements at most. + This is not a smart way but rather simple than using dynamic method. */ + + for (i = 0; Counter[i].size != size; ++i) + { + if (Counter[i].size == 0) /* the end of Counter elements */ + { + if (i > MAX_SIZE_NUM) + { + g_set_error (errorp, 0, 0, + /* translators: the %i is *always* 8 here */ + _("Sorry, this plug-in cannot handle a cursor " + "which contains over %i different nominal sizes."), + MAX_SIZE_NUM); + return NULL; + } + else /* append new element which "size" is given value. */ + { + Counter[i].size = size; + break; + } + } + } + + Counter[i].count += 1; + + return g_strdup_printf ("(%dpx)_%0*d (%dms) (replace)", size, indent, + Counter[i].count, delay); +} + +/* Get the region which is maintained when auto-crop. + */ +static void +get_cropped_region (GeglRectangle *return_rgn, + GeglBuffer *buffer) +{ + gint width = gegl_buffer_get_width (buffer); + gint height = gegl_buffer_get_height (buffer); + guint32 *buf = g_malloc (MAX (width, height) * sizeof (guint32)); + const Babl *format = babl_format ("R'G'B'A u8"); + guint i, j; + + g_return_if_fail (GEGL_IS_BUFFER (buffer)); + + DM_XMC ("function:get_cropped_region\n"); + + DM_XMC ("getTrim:\tMAX=%i\tpr->w=%i\tpr->h=%i\n", sizeof (buf)/4, pr->w, pr->h); + + /* find left border. */ + for (i = 0; i < width; ++i) + { + DM_XMC ("i=%i width=%i\n", i, width); + + gegl_buffer_get (buffer, GEGL_RECTANGLE (i, 0, 1, height), 1.0, + format, buf, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + for (j = 0; j < height; ++j) + { + if (pix_is_opaque (buf[j])) /* if a opaque pixel exist. */ + { + return_rgn->x = i; + goto find_right; + } + } + } + + /* pr has no opaque pixel. */ + return_rgn->width = 0; + return; + + /* find right border. */ + find_right: + for (i = 0; i < width ; ++i) + { + DM_XMC ("width-1-i=%i height=%i\n", width - 1 - i, height); + + gegl_buffer_get (buffer, GEGL_RECTANGLE (width - 1 - i, 0, 1, height), 1.0, + format, buf, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + for (j = 0; j < height; ++j) + { + if (pix_is_opaque (buf[j])) /* if a opaque pixel exist. */ + { + return_rgn->width = width - i - return_rgn->x; + goto find_top; + } + } + } + g_return_if_reached (); + + /* find top border. */ + find_top: + for (j = 0; j < height; ++j) + { + DM_XMC ("j=%i width=%i\n", j, width); + + gegl_buffer_get (buffer, GEGL_RECTANGLE (0, j, width, 1), 1.0, + format, buf, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + for (i = 0; i < width; ++i) + { + if (pix_is_opaque (buf[i])) /* if a opaque pixel exist. */ + { + return_rgn->y = j; + goto find_bottom; + } + } + } + + g_return_if_reached (); + + /* find bottom border. */ + find_bottom: + for (j = 0; j < height; ++j) + { + DM_XMC ("height-1-j=%i width=%i\n", height - 1 - j, width); + + gegl_buffer_get (buffer, GEGL_RECTANGLE (0, height - 1 - j, width, 1), 1.0, + format, buf, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + for (i = 0; i < width; ++i) + { + if (pix_is_opaque (buf[i])) /* if a opaque pixel exist. */ + { + return_rgn->height = height - j - return_rgn->y; + goto end_trim; + } + } + } + + g_return_if_reached (); + + end_trim: + DM_XMC ("width=%i\theight=%i\txoffset=%i\tyoffset=%i\n", + return_rgn->width, return_rgn->height, + return_rgn->x, return_rgn->y); + + g_free (buf); +} + +/* Return true if alpha of pix is not 0. + */ +static inline gboolean +pix_is_opaque (guint32 pix) +{ +#if G_BYTE_ORDER != G_LITTLE_ENDIAN + pix = GUINT32_TO_LE (pix); +#endif + + return ((pix >> 24) != 0); +} + +/* Get the intersection of the all layers of the image specified by image_ID. + * if the intersection is empty return NULL. + * don't forget to g_free returned pointer later. + */ +static GeglRectangle * +get_intersection_of_frames (gint32 image_ID) +{ + GeglRectangle *iregion; + gint i; + gint32 x1 = G_MININT32, x2 = G_MAXINT32; + gint32 y1 = G_MININT32, y2 = G_MAXINT32; + gint32 x_off, y_off; + gint nlayers; + gint *layers; + + g_return_val_if_fail (image_ID != -1, FALSE); + + layers = gimp_image_get_layers (image_ID, &nlayers); + + for (i = 0; i < nlayers; ++i) + { + if (! gimp_drawable_offsets (layers[i], &x_off, &y_off)) + return NULL; + + x1 = MAX (x1, x_off); + y1 = MAX (y1, y_off); + x2 = MIN (x2, x_off + gimp_drawable_width (layers[i]) - 1); + y2 = MIN (y2, y_off + gimp_drawable_height (layers[i]) - 1); + } + + if (x1 > x2 || y1 > y2) + return NULL; + + /* OK intersection exists. */ + iregion = g_new (GeglRectangle, 1); + iregion->x = x1; + iregion->y = y1; + iregion->width = x2 - x1 + 1; + iregion->height = y2 - y1 + 1; + + return iregion; +} + +/* If (x,y) is in xmcrp, return TRUE. + */ +static gboolean +pix_in_region (gint32 x, + gint32 y, + GeglRectangle *xmcrp) +{ + g_return_val_if_fail (xmcrp, FALSE); + + if (x < xmcrp->x || y < xmcrp->y || + x >= xmcrp->x + xmcrp->width || y >= xmcrp->y + xmcrp->height) + return FALSE; + else + return TRUE; +} + +/** + * Find out xhot, yhot, width and height of the Xcursor specified by xcIs. + * Use NULL for the value you don't want to return. +**/ +static void +find_hotspots_and_dimensions (XcursorImages *xcIs, + gint32 *xhotp, + gint32 *yhotp, + gint32 *widthp, + gint32 *heightp) +{ + gint32 dw, dh; /* the distance between hotspot and right(bottom) border */ + gint32 max_xhot; + gint32 max_yhot; /* the maximum value of xhot(yhot) */ + gint i; + + g_return_if_fail (xcIs); + + max_xhot = max_yhot = dw = dh = 0; + + for (i = 0; i < xcIs->nimage; ++i) + { + /* xhot of entire image is the maximum value of xhot of all frames */ + max_xhot = MAX (xcIs->images[i]->xhot, max_xhot); + /* same for yhot */ + max_yhot = MAX (xcIs->images[i]->yhot, max_yhot); + /* the maximum distance between right border and xhot */ + dw = MAX (dw, xcIs->images[i]->width - xcIs->images[i]->xhot); + /* the maximum distance between bottom border and yhot */ + dh = MAX (dh, xcIs->images[i]->height - xcIs->images[i]->yhot); + } + + if (xhotp) + *xhotp = max_xhot; + if (yhotp) + *yhotp = max_yhot; + if (widthp) + *widthp = dw + max_xhot; + if (heightp) + *heightp = dh + max_yhot; +} |