Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 345 insertions, 0 deletions

diff --git a/plug-ins/file-ico/ico.c b/plug-ins/file-ico/ico.c
new file mode 100644
index 0000000..6c15c22
--- /dev/null
+++ b/plug-ins/file-ico/ico.c
@@ -0,0 +1,345 @@
+/* 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 <christian@whoop.org>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+/* #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@whoop.org>",
+                          "Christian Kreibich <christian@whoop.org>",
+                          "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");
+  /* We do not set magics here, since that interferes with certain types
+     of TGA images. */
+  gimp_register_load_handler (LOAD_PROC,
+                              "ico",
+                              "");
+
+  gimp_install_procedure (LOAD_THUMB_PROC,
+                          "Loads a preview from an Windows ICO file",
+                          "",
+                          "Dom Lachowicz, Sven Neumann",
+                          "Sven Neumann <sven@gimp.org>",
+                          "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@whoop.org>",
+                          "Christian Kreibich <christian@whoop.org>",
+                          "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 ();
+  gegl_init (NULL, NULL);
+
+  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;
+}