Adding upstream version 2.10.22.upstream/2.10.22upstream

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

1 files changed, 531 insertions, 0 deletions

diff --git a/plug-ins/file-ico/ico-dialog.c b/plug-ins/file-ico/ico-dialog.c
new file mode 100644
index 0000000..84e9909
--- /dev/null
+++ b/plug-ins/file-ico/ico-dialog.c
@@ -0,0 +1,531 @@
+/* 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 <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+/* #define ICO_DBG */
+
+#include "ico.h"
+#include "ico-dialog.h"
+#include "ico-save.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+static void   ico_dialog_bpp_changed     (GtkWidget   *combo,
+                                          GObject     *hbox);
+static void   ico_dialog_toggle_compress (GtkWidget   *checkbox,
+                                          GObject     *hbox);
+static void   ico_dialog_check_compat    (GtkWidget   *dialog,
+                                          IcoSaveInfo *info);
+
+
+GtkWidget *
+ico_dialog_new (IcoSaveInfo *info)
+{
+  GtkWidget *dialog;
+  GtkWidget *main_vbox;
+  GtkWidget *vbox;
+  GtkWidget *frame;
+  GtkWidget *scrolled_window;
+  GtkWidget *viewport;
+  GtkWidget *warning;
+
+  dialog = gimp_export_dialog_new (_("Windows Icon"),
+                                   PLUG_IN_BINARY,
+                                   "plug-in-winicon");
+
+  /* We store an array that holds each icon's requested bit depth
+     with the dialog. It's queried when the dialog is closed so the
+     save routine knows what colormaps etc to generate in the saved
+     file. We store twice the number necessary because in the second
+     set, the color depths that are automatically suggested are stored
+     for later comparison.
+  */
+
+  g_object_set_data (G_OBJECT (dialog), "save_info", info);
+
+  main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
+  gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
+                      main_vbox, TRUE, TRUE, 0);
+  gtk_widget_show (main_vbox);
+
+  frame = gimp_frame_new (_("Icon Details"));
+  gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+                                  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+  gtk_container_add (GTK_CONTAINER (frame), scrolled_window);
+  gtk_widget_show (scrolled_window);
+
+  viewport = gtk_viewport_new (NULL, NULL);
+  gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
+  gtk_widget_show (viewport);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
+  g_object_set_data (G_OBJECT (dialog), "icons_vbox", vbox);
+  gtk_container_add (GTK_CONTAINER (viewport), vbox);
+  gtk_widget_show (vbox);
+
+  warning = g_object_new (GIMP_TYPE_HINT_BOX,
+                          "icon-name", GIMP_ICON_DIALOG_WARNING,
+                          "hint",
+                          _("Large icons and compression are not supported "
+                            "by all programs. Older applications may not "
+                            "open this file correctly."),
+                          NULL);
+  gtk_box_pack_end (GTK_BOX (main_vbox), warning, FALSE, FALSE, 0);
+  /* don't show the warning here */
+
+  g_object_set_data (G_OBJECT (dialog), "warning", warning);
+
+  return dialog;
+}
+
+static GtkWidget *
+ico_preview_new (gint32 layer)
+{
+  GtkWidget *image;
+  GdkPixbuf *pixbuf;
+  gint       width  = gimp_drawable_width (layer);
+  gint       height = gimp_drawable_height (layer);
+
+  pixbuf = gimp_drawable_get_thumbnail (layer,
+                                        MIN (width, 128), MIN (height, 128),
+                                        GIMP_PIXBUF_SMALL_CHECKS);
+  image = gtk_image_new_from_pixbuf (pixbuf);
+  g_object_unref (pixbuf);
+
+  return image;
+}
+
+/* This function creates and returns an hbox for an icon,
+   which then gets added to the dialog's main vbox. */
+static GtkWidget *
+ico_create_icon_hbox (GtkWidget   *icon_preview,
+                      gint32       layer,
+                      gint         layer_num,
+                      IcoSaveInfo *info)
+{
+  static GtkSizeGroup *size = NULL;
+
+  GtkWidget *hbox;
+  GtkWidget *vbox;
+  GtkWidget *alignment;
+  GtkWidget *combo;
+  GtkWidget *checkbox;
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+
+  alignment = gtk_alignment_new (1.0, 0.5, 0, 0);
+  gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 0);
+  gtk_widget_show (alignment);
+
+  /* To make life easier for the callbacks, we store the
+     layer's ID and stacking number with the hbox. */
+
+  g_object_set_data (G_OBJECT (hbox),
+                     "icon_layer", GINT_TO_POINTER (layer));
+  g_object_set_data (G_OBJECT (hbox),
+                     "icon_layer_num", GINT_TO_POINTER (layer_num));
+
+  g_object_set_data (G_OBJECT (hbox), "icon_preview", icon_preview);
+  gtk_container_add (GTK_CONTAINER (alignment), icon_preview);
+  gtk_widget_show (icon_preview);
+
+  if (! size)
+    size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+  gtk_size_group_add_widget (size, alignment);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+  gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
+  gtk_widget_show (vbox);
+
+  combo = gimp_int_combo_box_new (_("1 bpp, 1-bit alpha, 2-slot palette"),   1,
+                                  _("4 bpp, 1-bit alpha, 16-slot palette"),  4,
+                                  _("8 bpp, 1-bit alpha, 256-slot palette"), 8,
+                                  _("24 bpp, 1-bit alpha, no palette"),     24,
+                                  _("32 bpp, 8-bit alpha, no palette"),     32,
+                                  NULL);
+  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
+                                 info->depths[layer_num]);
+
+  g_signal_connect (combo, "changed",
+                    G_CALLBACK (ico_dialog_bpp_changed),
+                    hbox);
+
+  g_object_set_data (G_OBJECT (hbox), "icon_menu", combo);
+
+  gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
+  gtk_widget_show (combo);
+
+  checkbox = gtk_check_button_new_with_label (_("Compressed (PNG)"));
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox),
+                                info->compress[layer_num]);
+  g_signal_connect (checkbox, "toggled",
+                    G_CALLBACK (ico_dialog_toggle_compress), hbox);
+  gtk_box_pack_start (GTK_BOX (vbox), checkbox, FALSE, FALSE, 0);
+  gtk_widget_show (checkbox);
+
+  return hbox;
+}
+
+static GtkWidget *
+ico_dialog_get_layer_preview (GtkWidget *dialog,
+                              gint32     layer)
+{
+  GtkWidget *preview;
+  GtkWidget *icon_hbox;
+  gchar      key[ICO_MAXBUF];
+
+  g_snprintf (key, sizeof (key), "layer_%i_hbox", layer);
+  icon_hbox = g_object_get_data (G_OBJECT (dialog), key);
+
+  if (!icon_hbox)
+    {
+      D(("Something's wrong -- couldn't look up hbox by layer ID\n"));
+      return NULL;
+    }
+
+  preview = g_object_get_data (G_OBJECT (icon_hbox), "icon_preview");
+
+  if (!icon_hbox)
+    {
+      D(("Something's wrong -- couldn't look up preview from hbox\n"));
+      return NULL;
+    }
+
+  return preview;
+}
+
+static void
+ico_dialog_update_icon_preview (GtkWidget *dialog,
+                                gint32     layer,
+                                gint       bpp)
+{
+  GtkWidget  *preview = ico_dialog_get_layer_preview (dialog, layer);
+  GdkPixbuf  *pixbuf;
+  const Babl *format;
+  gint        w       = gimp_drawable_width (layer);
+  gint        h       = gimp_drawable_height (layer);
+
+  if (! preview)
+    return;
+
+  switch (gimp_drawable_type (layer))
+    {
+    case GIMP_RGB_IMAGE:
+      format = babl_format ("R'G'B' u8");
+      break;
+
+    case GIMP_RGBA_IMAGE:
+      format = babl_format ("R'G'B'A u8");
+      break;
+
+    case GIMP_GRAY_IMAGE:
+      format = babl_format ("Y' u8");
+      break;
+
+    case GIMP_GRAYA_IMAGE:
+      format = babl_format ("Y'A u8");
+      break;
+
+    case GIMP_INDEXED_IMAGE:
+    case GIMP_INDEXEDA_IMAGE:
+      format = gimp_drawable_get_format (layer);
+      break;
+
+    default:
+      g_return_if_reached ();
+    }
+
+  if (bpp <= 8)
+    {
+      GeglBuffer *buffer;
+      GeglBuffer *tmp;
+      gint32      image;
+      gint32      tmp_image;
+      gint32      tmp_layer;
+      guchar     *buf;
+      guchar     *cmap;
+      gint        num_colors;
+
+      image = gimp_item_get_image (layer);
+
+      tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
+      gimp_image_undo_disable (tmp_image);
+
+      if (gimp_drawable_is_indexed (layer))
+        {
+          cmap = gimp_image_get_colormap (image, &num_colors);
+          gimp_image_set_colormap (tmp_image, cmap, num_colors);
+          g_free (cmap);
+        }
+
+      tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h,
+                                  gimp_drawable_type (layer),
+                                  100,
+                                  gimp_image_get_default_new_layer_mode (tmp_image));
+      gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
+
+      buffer = gimp_drawable_get_buffer (layer);
+      tmp    = gimp_drawable_get_buffer (tmp_layer);
+
+      buf = g_malloc (w * h * 4);
+
+      gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0,
+                       format, buf,
+                       GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+      gegl_buffer_copy (buffer, NULL, GEGL_ABYSS_NONE, tmp, NULL);
+
+      g_object_unref (tmp);
+      g_object_unref (buffer);
+
+      if (gimp_drawable_is_indexed (layer))
+        gimp_image_convert_rgb (tmp_image);
+
+      gimp_image_convert_indexed (tmp_image,
+                                  GIMP_CONVERT_DITHER_FS,
+                                  GIMP_CONVERT_PALETTE_GENERATE,
+                                  1 << bpp, TRUE, FALSE, "dummy");
+
+      cmap = gimp_image_get_colormap (tmp_image, &num_colors);
+
+      if (num_colors == (1 << bpp) &&
+          ! ico_cmap_contains_black (cmap, num_colors))
+        {
+          /* Windows icons with color maps need the color black.
+           * We need to eliminate one more color to make room for black.
+           */
+          if (gimp_drawable_is_indexed (layer))
+            {
+              g_free (cmap);
+              cmap = gimp_image_get_colormap (image, &num_colors);
+              gimp_image_set_colormap (tmp_image, cmap, num_colors);
+            }
+          else if (gimp_drawable_is_gray (layer))
+            {
+              gimp_image_convert_grayscale (tmp_image);
+            }
+          else
+            {
+              gimp_image_convert_rgb (tmp_image);
+            }
+
+          tmp = gimp_drawable_get_buffer (tmp_layer);
+
+          gegl_buffer_set (tmp, GEGL_RECTANGLE (0, 0, w, h), 0,
+                           format, buf, GEGL_AUTO_ROWSTRIDE);
+
+          g_object_unref (tmp);
+
+          if (!gimp_drawable_is_rgb (layer))
+            gimp_image_convert_rgb (tmp_image);
+
+          gimp_image_convert_indexed (tmp_image,
+                                      GIMP_CONVERT_DITHER_FS,
+                                      GIMP_CONVERT_PALETTE_GENERATE,
+                                      (1 << bpp) - 1, TRUE, FALSE, "dummy");
+        }
+
+      g_free (cmap);
+      g_free (buf);
+
+      pixbuf = gimp_drawable_get_thumbnail (tmp_layer,
+                                            MIN (w, 128), MIN (h, 128),
+                                            GIMP_PIXBUF_SMALL_CHECKS);
+
+      gimp_image_delete (tmp_image);
+    }
+  else if (bpp == 24)
+    {
+      GeglBuffer *buffer;
+      GeglBuffer *tmp;
+      gint32      image;
+      gint32      tmp_image;
+      gint32      tmp_layer;
+      GimpParam  *return_vals;
+      gint        n_return_vals;
+
+      image = gimp_item_get_image (layer);
+
+      tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
+      gimp_image_undo_disable (tmp_image);
+
+      if (gimp_drawable_is_indexed (layer))
+        {
+          guchar *cmap;
+          gint    num_colors;
+
+          cmap = gimp_image_get_colormap (image, &num_colors);
+          gimp_image_set_colormap (tmp_image, cmap, num_colors);
+          g_free (cmap);
+        }
+
+      tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h,
+                                  gimp_drawable_type (layer),
+                                  100,
+                                  gimp_image_get_default_new_layer_mode (tmp_image));
+      gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
+
+      buffer = gimp_drawable_get_buffer (layer);
+      tmp    = gimp_drawable_get_buffer (tmp_layer);
+
+      gegl_buffer_copy (buffer, NULL, GEGL_ABYSS_NONE, tmp, NULL);
+
+      g_object_unref (tmp);
+      g_object_unref (buffer);
+
+      if (gimp_drawable_is_indexed (layer))
+        gimp_image_convert_rgb (tmp_image);
+
+      return_vals =
+        gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals,
+                            GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
+                            GIMP_PDB_IMAGE, tmp_image,
+                            GIMP_PDB_DRAWABLE, tmp_layer,
+                            GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD,
+                            GIMP_PDB_END);
+      gimp_destroy_params (return_vals, n_return_vals);
+
+      pixbuf = gimp_drawable_get_thumbnail (tmp_layer,
+                                            MIN (w, 128), MIN (h, 128),
+                                            GIMP_PIXBUF_SMALL_CHECKS);
+
+      gimp_image_delete (tmp_image);
+    }
+  else
+    {
+      pixbuf = gimp_drawable_get_thumbnail (layer,
+                                            MIN (w, 128), MIN (h, 128),
+                                            GIMP_PIXBUF_SMALL_CHECKS);
+    }
+
+  gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
+  g_object_unref (pixbuf);
+}
+
+void
+ico_dialog_add_icon (GtkWidget *dialog,
+                     gint32     layer,
+                     gint       layer_num)
+{
+  GtkWidget   *vbox;
+  GtkWidget   *hbox;
+  GtkWidget   *preview;
+  gchar        key[ICO_MAXBUF];
+  IcoSaveInfo *info;
+
+  vbox = g_object_get_data (G_OBJECT (dialog), "icons_vbox");
+  info = g_object_get_data (G_OBJECT (dialog), "save_info");
+
+  preview = ico_preview_new (layer);
+  hbox = ico_create_icon_hbox (preview, layer, layer_num, info);
+  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+
+  /* Let's make the hbox accessible through the layer ID */
+  g_snprintf (key, sizeof (key), "layer_%i_hbox", layer);
+  g_object_set_data (G_OBJECT (dialog), key, hbox);
+
+  ico_dialog_update_icon_preview (dialog, layer, info->depths[layer_num]);
+
+  ico_dialog_check_compat (dialog, info);
+}
+
+static void
+ico_dialog_bpp_changed (GtkWidget *combo,
+                        GObject   *hbox)
+{
+  GtkWidget   *dialog;
+  gint32       layer;
+  gint         layer_num;
+  gint         bpp;
+  IcoSaveInfo *info;
+
+  dialog = gtk_widget_get_toplevel (combo);
+
+  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &bpp);
+
+  info = g_object_get_data (G_OBJECT (dialog), "save_info");
+  g_assert (info);
+
+  layer     = GPOINTER_TO_INT (g_object_get_data (hbox, "icon_layer"));
+  layer_num = GPOINTER_TO_INT (g_object_get_data (hbox, "icon_layer_num"));
+
+  /* Update vector entry for later when we're actually saving,
+     and update the preview right away ... */
+  info->depths[layer_num] = bpp;
+  ico_dialog_update_icon_preview (dialog, layer, bpp);
+}
+
+static void
+ico_dialog_toggle_compress (GtkWidget *checkbox,
+                            GObject   *hbox)
+{
+  GtkWidget   *dialog;
+  gint         layer_num;
+  IcoSaveInfo *info;
+
+  dialog = gtk_widget_get_toplevel (checkbox);
+
+  info = g_object_get_data (G_OBJECT (dialog), "save_info");
+  g_assert (info);
+  layer_num = GPOINTER_TO_INT (g_object_get_data (hbox, "icon_layer_num"));
+
+  /* Update vector entry for later when we're actually saving */
+  info->compress[layer_num] =
+    gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbox));
+
+  ico_dialog_check_compat (dialog, info);
+}
+
+static void
+ico_dialog_check_compat (GtkWidget   *dialog,
+                         IcoSaveInfo *info)
+{
+  GtkWidget *warning;
+  gboolean   warn = FALSE;
+  gint       i;
+
+  for (i = 0; i < info->num_icons; i++)
+    {
+      if (gimp_drawable_width (info->layers[i]) > 255  ||
+          gimp_drawable_height (info->layers[i]) > 255 ||
+          info->compress[i])
+        {
+          warn = TRUE;
+          break;
+        }
+    }
+
+  warning = g_object_get_data (G_OBJECT (dialog), "warning");
+
+  gtk_widget_set_visible (warning, warn);
+}