/* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis * * GIMP Plug-in for Windows Icon files. * Copyright (C) 2002 Christian Kreibich . * * 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 . */ #include "config.h" #include #include #include /* #define ICO_DBG */ #include "ico.h" #include "ico-load.h" #include "ico-save.h" #include "libgimp/stdplugins-intl.h" #define LOAD_PROC "file-ico-load" #define LOAD_THUMB_PROC "file-ico-load-thumb" #define SAVE_PROC "file-ico-save" static void query (void); static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals); const GimpPlugInInfo PLUG_IN_INFO = { NULL, /* init_proc */ NULL, /* quit_proc */ query, /* query_proc */ run, /* run_proc */ }; MAIN () 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 entered" } }; 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", "Width of full-sized image" }, { GIMP_PDB_INT32, "image-height", "Height of full-sized image" } }; 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 save" }, { GIMP_PDB_STRING, "filename", "The name of the file to save the image in" }, { GIMP_PDB_STRING, "raw-filename", "The name entered" }, }; gimp_install_procedure (LOAD_PROC, "Loads files of Windows ICO file format", "Loads files of Windows ICO file format", "Christian Kreibich ", "Christian Kreibich ", "2002", N_("Microsoft Windows icon"), 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, "image/x-ico"); gimp_register_magic_load_handler (LOAD_PROC, "ico", "", "0,string,\\000\\001\\000\\000,0,string,\\000\\002\\000\\000"); gimp_install_procedure (LOAD_THUMB_PROC, "Loads a preview from an Windows ICO file", "", "Dom Lachowicz, Sven Neumann", "Sven Neumann ", "2005", 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, "Saves files in Windows ICO file format", "Saves files in Windows ICO file format", "Christian Kreibich ", "Christian Kreibich ", "2002", N_("Microsoft Windows icon"), "*", GIMP_PLUGIN, G_N_ELEMENTS (save_args), 0, save_args, NULL); gimp_register_file_handler_mime (SAVE_PROC, "image/x-ico"); gimp_register_save_handler (SAVE_PROC, "ico", ""); } static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[4]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpExportReturn export = GIMP_EXPORT_CANCEL; GError *error = NULL; INIT_I18N (); run_mode = param[0].data.d_int32; *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) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 3) status = GIMP_PDB_CALLING_ERROR; break; default: break; } if (status == GIMP_PDB_SUCCESS) { gint32 image_ID; image_ID = ico_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; } else { status = GIMP_PDB_EXECUTION_ERROR; } } } else if (strcmp (name, LOAD_THUMB_PROC) == 0) { if (nparams < 2) { status = GIMP_PDB_CALLING_ERROR; } else { const gchar *filename = param[0].data.d_string; gint width = param[1].data.d_int32; gint height = param[1].data.d_int32; gint32 image_ID; image_ID = ico_load_thumbnail_image (filename, &width, &height, &error); if (image_ID != -1) { *nreturn_vals = 4; 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; values[3].type = GIMP_PDB_INT32; values[3].data.d_int32 = height; } else { status = GIMP_PDB_EXECUTION_ERROR; } } } else if (strcmp (name, SAVE_PROC) == 0) { gchar *file_name; gint32 image_ID; image_ID = param[1].data.d_int32; file_name = param[3].data.d_string; switch (run_mode) { case GIMP_RUN_INTERACTIVE: break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams < 5) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: break; default: break; } if (status == GIMP_PDB_SUCCESS) { status = ico_save_image (file_name, image_ID, run_mode, &error); } if (export == GIMP_EXPORT_EXPORT) gimp_image_delete (image_ID); } else { 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; } gint ico_rowstride (gint width, gint bpp) { switch (bpp) { case 1: if ((width % 32) == 0) return width / 8; else return 4 * (width/32 + 1); break; case 4: if ((width % 8) == 0) return width / 2; else return 4 * (width/8 + 1); break; case 8: if ((width % 4) == 0) return width; else return 4 * (width/4 + 1); break; case 24: if (((width*3) % 4) == 0) return width * 3; else return 4 * (width*3/4+1); case 32: return width * 4; default: g_warning ("invalid bitrate: %d\n", bpp); g_assert_not_reached (); return width * (bpp/8); } } guint8 * ico_alloc_map (gint width, gint height, gint bpp, gint *length) { gint len = 0; guint8 *map = NULL; len = ico_rowstride (width, bpp) * height; *length = len; map = g_new0 (guint8, len); return map; }