AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/plug-ins/common/file-xpm.c

906 lines
26 KiB
C
Raw Blame History

/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* 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/>.
*/
/* XPM plugin version 1.2.7 */
/*
1.2.7 fixes saving unused transparency (bug #4560)
1.2.6 fixes crash when saving indexed images (bug #109567)
1.2.5 only creates a "None" color entry if the image has alpha (bug #108034)
1.2.4 displays an error message if saving fails (bug #87588)
1.2.3 fixes bug when running in noninteractive mode
changes alpha_threshold range from [0, 1] to [0,255] for consistency with
the threshold_alpha plugin
1.2.2 fixes bug that generated bad digits on images with more than 20000
colors. (thanks, yanele)
parses gtkrc (thanks, yosh)
doesn't load parameter screen on images that don't have alpha
1.2.1 fixes some minor bugs -- spaces in #XXXXXX strings, small typos in code.
1.2 compute color indexes so that we don't have to use XpmSaveXImage*
Previous...Inherited code from Ray Lehtiniemi, who inherited it from S & P.
*/
#include "config.h"
#include <string.h>
#include <glib/gstdio.h>
#include <gdk/gdk.h> /* For GDK_WINDOWING_WIN32 */
#ifndef GDK_WINDOWING_X11
#ifndef XPM_NO_X
#define XPM_NO_X
#endif
#else
#include <X11/Xlib.h>
#endif
#include <X11/xpm.h>
#include <libpika/pika.h>
#include <libpika/pikaui.h>
#include "libpika/stdplugins-intl.h"
#define LOAD_PROC "file-xpm-load"
#define SAVE_PROC "file-xpm-save"
#define PLUG_IN_BINARY "file-xpm"
#define PLUG_IN_ROLE "pika-file-xpm"
#define SCALE_WIDTH 125
typedef struct
{
guchar r;
guchar g;
guchar b;
} rgbkey;
typedef struct _Xpm Xpm;
typedef struct _XpmClass XpmClass;
struct _Xpm
{
PikaPlugIn parent_instance;
};
struct _XpmClass
{
PikaPlugInClass parent_class;
};
#define XPM_TYPE (xpm_get_type ())
#define XPM (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XPM_TYPE, Xpm))
GType xpm_get_type (void) G_GNUC_CONST;
static GList * xpm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xpm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * xpm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xpm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static guchar * parse_colors (XpmImage *xpm_image);
static void parse_image (PikaImage *image,
XpmImage *xpm_image,
guchar *cmap);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
G_DEFINE_TYPE (Xpm, xpm, PIKA_TYPE_PLUG_IN)
PIKA_MAIN (XPM_TYPE)
DEFINE_STD_SET_I18N
static const gchar linenoise [] =
" .+@#$%&*=-;>,')!~{]^/(_:<[}|1234567890abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ`";
/* whether the image is color or not. global so I only have to pass
* one user value to the GHFunc
*/
static gboolean color;
/* bytes per pixel. global so I only have to pass one user value
* to the GHFunc
*/
static gint cpp;
static void
xpm_class_init (XpmClass *klass)
{
PikaPlugInClass *plug_in_class = PIKA_PLUG_IN_CLASS (klass);
plug_in_class->query_procedures = xpm_query_procedures;
plug_in_class->create_procedure = xpm_create_procedure;
plug_in_class->set_i18n = STD_SET_I18N;
}
static void
xpm_init (Xpm *xpm)
{
}
static GList *
xpm_query_procedures (PikaPlugIn *plug_in)
{
GList *list = NULL;
list = g_list_append (list, g_strdup (LOAD_PROC));
list = g_list_append (list, g_strdup (SAVE_PROC));
return list;
}
static PikaProcedure *
xpm_create_procedure (PikaPlugIn *plug_in,
const gchar *name)
{
PikaProcedure *procedure = NULL;
if (! strcmp (name, LOAD_PROC))
{
procedure = pika_load_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
xpm_load, NULL, NULL);
pika_procedure_set_menu_label (procedure, _("X PixMap image"));
pika_procedure_set_documentation (procedure,
"Load files in XPM (X11 Pixmap) format.",
"Load files in XPM (X11 Pixmap) format. "
"XPM is a portable image format "
"designed to be included in C source "
"code. XLib provides utility functions "
"to read this format. Newer code should "
"however be using gdk-pixbuf-csource "
"instead. XPM supports colored images, "
"unlike the XBM format which XPM was "
"designed to replace.",
name);
pika_procedure_set_attribution (procedure,
"Spencer Kimball & Peter Mattis & "
"Ray Lehtiniemi",
"Spencer Kimball & Peter Mattis",
"1997");
pika_file_procedure_set_mime_types (PIKA_FILE_PROCEDURE (procedure),
"image/x-pixmap");
pika_file_procedure_set_extensions (PIKA_FILE_PROCEDURE (procedure),
"xpm");
pika_file_procedure_set_magics (PIKA_FILE_PROCEDURE (procedure),
"0, string,/*\\040XPM\\040*/");
}
else if (! strcmp (name, SAVE_PROC))
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
xpm_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
pika_procedure_set_menu_label (procedure, _("X PixMap image"));
pika_procedure_set_documentation (procedure,
"Export files in XPM (X11 Pixmap) format.",
"Export files in XPM (X11 Pixmap) format. "
"XPM is a portable image format "
"designed to be included in C source "
"code. XLib provides utility functions "
"to read this format. Newer code should "
"however be using gdk-pixbuf-csource "
"instead. XPM supports colored images, "
"unlike the XBM format which XPM was "
"designed to replace.",
name);
pika_procedure_set_attribution (procedure,
"Spencer Kimball & Peter Mattis & "
"Ray Lehtiniemi & Nathan Summers",
"Spencer Kimball & Peter Mattis",
"1997");
pika_file_procedure_set_format_name (PIKA_FILE_PROCEDURE (procedure),
_("XPM"));
pika_file_procedure_set_mime_types (PIKA_FILE_PROCEDURE (procedure),
"image/x-pixmap");
pika_file_procedure_set_extensions (PIKA_FILE_PROCEDURE (procedure),
"xpm");
PIKA_PROC_ARG_INT (procedure, "threshold",
_("_Threshold"),
_("Alpha threshold"),
0, 255, 127,
G_PARAM_READWRITE);
}
return procedure;
}
static PikaValueArray *
xpm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gegl_init (NULL, NULL);
image = load_image (file, &error);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
PIKA_VALUES_SET_IMAGE (return_vals, 1, image);
return return_vals;
}
static PikaValueArray *
xpm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
case PIKA_RUN_WITH_LAST_VALS:
pika_ui_init (PLUG_IN_BINARY);
export = pika_export_image (&image, &n_drawables, &drawables, "XPM",
PIKA_EXPORT_CAN_HANDLE_RGB |
PIKA_EXPORT_CAN_HANDLE_GRAY |
PIKA_EXPORT_CAN_HANDLE_INDEXED |
PIKA_EXPORT_CAN_HANDLE_ALPHA);
if (export == PIKA_EXPORT_CANCEL)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
break;
default:
break;
}
if (n_drawables != 1)
{
g_set_error (&error, G_FILE_ERROR, 0,
_("XPM format does not support multiple layers."));
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
if (run_mode == PIKA_RUN_INTERACTIVE)
{
if (pika_drawable_has_alpha (drawables[0]))
if (! save_dialog (image, procedure, G_OBJECT (config)))
status = PIKA_PDB_CANCEL;
}
if (status == PIKA_PDB_SUCCESS)
{
if (! save_image (file, image, drawables[0], G_OBJECT (config),
&error))
{
status = PIKA_PDB_EXECUTION_ERROR;
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
g_free (drawables);
}
return pika_procedure_new_return_values (procedure, status, error);
}
static PikaImage *
load_image (GFile *file,
GError **error)
{
XpmImage xpm_image;
guchar *cmap;
PikaImage *image;
pika_progress_init_printf (_("Opening '%s'"),
pika_file_get_utf8_name (file));
/* read the raw file */
switch (XpmReadFileToXpmImage (g_file_peek_path (file), &xpm_image, NULL))
{
case XpmSuccess:
break;
case XpmOpenFailed:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error opening file '%s'"),
pika_file_get_utf8_name (file));
return NULL;
case XpmFileInvalid:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"%s", _("XPM file invalid"));
return NULL;
default:
return NULL;
}
cmap = parse_colors (&xpm_image);
image = pika_image_new (xpm_image.width,
xpm_image.height,
PIKA_RGB);
/* fill it */
parse_image (image, &xpm_image, cmap);
g_free (cmap);
return image;
}
static guchar *
parse_colors (XpmImage *xpm_image)
{
#ifndef XPM_NO_X
Display *display;
Colormap colormap;
#endif
gint i, j;
guchar *cmap;
#ifndef XPM_NO_X
/* open the display and get the default color map */
display = XOpenDisplay (NULL);
if (display == NULL)
g_printerr ("Could not open display\n");
colormap = DefaultColormap (display, DefaultScreen (display));
#endif
/* alloc a buffer to hold the parsed colors */
cmap = g_new0 (guchar, 4 * xpm_image->ncolors);
/* parse each color in the file */
for (i = 0, j = 0; i < xpm_image->ncolors; i++)
{
gchar *colorspec = "None";
XpmColor *xpm_color;
#ifndef XPM_NO_X
XColor xcolor;
#else
GdkRGBA xcolor;
#endif
xpm_color = &(xpm_image->colorTable[i]);
/* pick the best spec available */
if (xpm_color->c_color)
colorspec = xpm_color->c_color;
else if (xpm_color->g_color)
colorspec = xpm_color->g_color;
else if (xpm_color->g4_color)
colorspec = xpm_color->g4_color;
else if (xpm_color->m_color)
colorspec = xpm_color->m_color;
/* parse if it's not transparent */
if (strcmp (colorspec, "None") != 0)
{
#ifndef XPM_NO_X
XParseColor (display, colormap, colorspec, &xcolor);
cmap[j++] = xcolor.red >> 8;
cmap[j++] = xcolor.green >> 8;
cmap[j++] = xcolor.blue >> 8;
#else
gdk_rgba_parse (&xcolor, colorspec);
cmap[j++] = CLAMP (xcolor.red * G_MAXUINT8, 0, G_MAXUINT8);
cmap[j++] = CLAMP (xcolor.green * G_MAXUINT8, 0, G_MAXUINT8);
cmap[j++] = CLAMP (xcolor.blue * G_MAXUINT8, 0, G_MAXUINT8);
#endif
cmap[j++] = ~0;
}
else
{
j += 4;
}
}
#ifndef XPM_NO_X
XCloseDisplay (display);
#endif
return cmap;
}
static void
parse_image (PikaImage *image,
XpmImage *xpm_image,
guchar *cmap)
{
GeglBuffer *buffer;
gint tile_height;
gint scanlines;
gint val;
guchar *buf;
guchar *dest;
guint *src;
PikaLayer *layer;
gint i;
layer = pika_layer_new (image,
_("Color"),
xpm_image->width,
xpm_image->height,
PIKA_RGBA_IMAGE,
100,
pika_image_get_default_new_layer_mode (image));
pika_image_insert_layer (image, layer, NULL, 0);
buffer = pika_drawable_get_buffer (PIKA_DRAWABLE (layer));
tile_height = pika_tile_height ();
buf = g_new (guchar, tile_height * xpm_image->width * 4);
src = xpm_image->data;
for (i = 0; i < xpm_image->height; i += tile_height)
{
gint j;
dest = buf;
scanlines = MIN (tile_height, xpm_image->height - i);
j = scanlines * xpm_image->width;
while (j--)
{
{
val = *(src++) * 4;
*(dest) = cmap[val];
*(dest+1) = cmap[val+1];
*(dest+2) = cmap[val+2];
*(dest+3) = cmap[val+3];
dest += 4;
}
if ((j % 100) == 0)
pika_progress_update ((double) i / (double) xpm_image->height);
}
gegl_buffer_set (buffer,
GEGL_RECTANGLE (0, i, xpm_image->width, scanlines), 0,
NULL, buf, GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
g_object_unref (buffer);
pika_progress_update (1.0);
}
static guint
rgbhash (rgbkey *c)
{
return ((guint)c->r) ^ ((guint)c->g) ^ ((guint)c->b);
}
static guint
compare (rgbkey *c1,
rgbkey *c2)
{
return (c1->r == c2->r) && (c1->g == c2->g) && (c1->b == c2->b);
}
static void
set_XpmImage (XpmColor *array,
guint index,
gchar *colorstring)
{
gchar *p;
gint i, charnum, indtemp;
indtemp=index;
array[index].string = p = g_new (gchar, cpp+1);
/*convert the index number to base sizeof(linenoise)-1 */
for (i = 0; i < cpp; ++i)
{
charnum = indtemp % (sizeof (linenoise) - 1);
indtemp = indtemp / (sizeof (linenoise) - 1);
*p++ = linenoise[charnum];
}
/* *p++=linenoise[indtemp]; */
*p = '\0'; /* C and its stupid null-terminated strings... */
array[index].symbolic = NULL;
array[index].m_color = NULL;
array[index].g4_color = NULL;
if (color)
{
array[index].g_color = NULL;
array[index].c_color = colorstring;
}
else
{
array[index].c_color = NULL;
array[index].g_color = colorstring;
}
}
static void
create_colormap_from_hash (gpointer gkey,
gpointer value,
gpointer user_data)
{
rgbkey *key = gkey;
gchar *string = g_new (gchar, 8);
sprintf (string, "#%02X%02X%02X", (int)key->r, (int)key->g, (int)key->b);
set_XpmImage (user_data, *((int *) value), string);
}
static void
decrement_hash_values (gpointer gkey,
gpointer value,
gpointer user_data)
{
--(*((guint*) value));
}
static gboolean
save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error)
{
GeglBuffer *buffer;
const Babl *format;
gint width;
gint height;
gint ncolors = 1;
gint *indexno;
gboolean indexed;
gboolean alpha;
gboolean alpha_used = FALSE;
XpmColor *colormap;
XpmImage *xpm_image;
guint *ibuff = NULL;
guchar *buf;
guchar *data;
GHashTable *hash = NULL;
gint i, j, k;
gint threshold;
gboolean success = FALSE;
g_object_get (config,
"threshold", &threshold,
NULL);
buffer = pika_drawable_get_buffer (drawable);
width = gegl_buffer_get_width (buffer);
height = gegl_buffer_get_height (buffer);
alpha = pika_drawable_has_alpha (drawable);
color = ! pika_drawable_is_gray (drawable);
indexed = pika_drawable_is_indexed (drawable);
switch (pika_drawable_type (drawable))
{
case PIKA_RGB_IMAGE:
format = babl_format ("R'G'B' u8");
break;
case PIKA_RGBA_IMAGE:
format = babl_format ("R'G'B'A u8");
break;
case PIKA_GRAY_IMAGE:
format = babl_format ("Y' u8");
break;
case PIKA_GRAYA_IMAGE:
format = babl_format ("Y'A u8");
break;
case PIKA_INDEXED_IMAGE:
case PIKA_INDEXEDA_IMAGE:
format = gegl_buffer_get_format (buffer);
break;
default:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported drawable type"));
g_object_unref (buffer);
return FALSE;
}
/* allocate buffer making the assumption that ibuff is 32 bit aligned... */
ibuff = g_new (guint, width * height);
hash = g_hash_table_new ((GHashFunc) rgbhash, (GCompareFunc) compare);
pika_progress_init_printf (_("Exporting '%s'"),
pika_file_get_utf8_name (file));
ncolors = alpha ? 1 : 0;
/* allocate a pixel region to work with */
buf = g_new (guchar,
pika_tile_height () * width *
babl_format_get_bytes_per_pixel (format));
/* process each row of tiles */
for (i = 0; i < height; i += pika_tile_height ())
{
gint scanlines;
/* read the next row of tiles */
scanlines = MIN (pika_tile_height(), height - i);
gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scanlines), 1.0,
format, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
data = buf;
/* process each pixel row */
for (j = 0; j < scanlines; j++)
{
/* go to the start of this row in each image */
guint *idata = ibuff + (i+j) * width;
/* do each pixel in the row */
for (k = 0; k < width; k++)
{
rgbkey *key = g_new (rgbkey, 1);
guchar a;
/* get pixel data */
key->r = *(data++);
key->g = color && !indexed ? *(data++) : key->r;
key->b = color && !indexed ? *(data++) : key->r;
a = alpha ? *(data++) : 255;
if (a < threshold)
{
*(idata++) = 0;
alpha_used = TRUE;
}
else
{
if (indexed)
{
*(idata++) = (key->r) + (alpha ? 1 : 0);
}
else
{
indexno = g_hash_table_lookup (hash, key);
if (!indexno)
{
indexno = g_new (gint, 1);
*indexno = ncolors++;
g_hash_table_insert (hash, key, indexno);
key = g_new (rgbkey, 1);
}
*(idata++) = *indexno;
}
}
}
/* kick the progress bar */
pika_progress_update ((gdouble) (i+j) / (gdouble) height);
}
}
g_free (buf);
/* remove alpha if not actually used */
if (alpha && !alpha_used)
{
gint i;
--ncolors;
for (i = 0; i < width * height; ++i)
--ibuff[i];
g_hash_table_foreach (hash, decrement_hash_values, NULL);
}
if (indexed)
{
guchar *cmap = pika_image_get_colormap (image, NULL, &ncolors);
guchar *c;
c = cmap;
if (alpha_used)
ncolors++;
colormap = g_new (XpmColor, ncolors);
cpp =
1 + (gdouble) log (ncolors) / (gdouble) log (sizeof (linenoise) - 1.0);
if (alpha_used)
set_XpmImage (colormap, 0, "None");
for (i = alpha_used ? 1 : 0; i < ncolors; i++)
{
gchar *string;
guchar r, g, b;
r = *c++;
g = *c++;
b = *c++;
string = g_new (gchar, 8);
sprintf (string, "#%02X%02X%02X", (int)r, (int)g, (int)b);
set_XpmImage (colormap, i, string);
}
g_free (cmap);
}
else
{
colormap = g_new (XpmColor, ncolors);
cpp =
1 + (gdouble) log (ncolors) / (gdouble) log (sizeof (linenoise) - 1.0);
if (alpha_used)
set_XpmImage (colormap, 0, "None");
g_hash_table_foreach (hash, create_colormap_from_hash, colormap);
}
xpm_image = g_new (XpmImage, 1);
xpm_image->width = width;
xpm_image->height = height;
xpm_image->ncolors = ncolors;
xpm_image->cpp = cpp;
xpm_image->colorTable = colormap;
xpm_image->data = ibuff;
/* do the save */
switch (XpmWriteFileFromXpmImage (g_file_peek_path (file), xpm_image, NULL))
{
case XpmSuccess:
success = TRUE;
break;
case XpmOpenFailed:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error opening file '%s'"),
pika_file_get_utf8_name (file));
break;
case XpmFileInvalid:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"%s", _("XPM file invalid"));
break;
default:
break;
}
g_object_unref (buffer);
g_free (ibuff);
if (hash)
g_hash_table_destroy (hash);
pika_progress_update (1.0);
return success;
}
static gboolean
save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config)
{
GtkWidget *dialog;
gboolean run;
dialog = pika_save_procedure_dialog_new (PIKA_SAVE_PROCEDURE (procedure),
PIKA_PROCEDURE_CONFIG (config),
image);
pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"threshold", 1.0);
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), NULL);
gtk_widget_show (dialog);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);
return run;
}
Reference in New Issue View Git Blame Copy Permalink