Adding upstream version 2.10.34.upstream/2.10.34upstream

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

1 files changed, 3940 insertions, 0 deletions

diff --git a/plug-ins/common/file-ps.c b/plug-ins/common/file-ps.c
new file mode 100644
index 0000000..ee432a8
--- /dev/null
+++ b/plug-ins/common/file-ps.c
@@ -0,0 +1,3940 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ * PostScript file plugin
+ * PostScript writing and GhostScript interfacing code
+ * Copyright (C) 1997-98 Peter Kirchgessner
+ * (email: peter@kirchgessner.net, WWW: http://www.kirchgessner.net)
+ *
+ * Added controls for TextAlphaBits and GraphicsAlphaBits
+ *   George White <aa056@chebucto.ns.ca>
+ *
+ * Added Ascii85 encoding
+ *   Austin Donnelly <austin@gimp.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/>.
+ *
+ */
+
+/* Event history:
+ * V 0.90, PK, 28-Mar-97: Creation.
+ * V 0.91, PK, 03-Apr-97: Clip everything outside BoundingBox.
+ *             24-Apr-97: Multi page read support.
+ * V 1.00, PK, 30-Apr-97: PDF support.
+ * V 1.01, PK, 05-Oct-97: Parse rc-file.
+ * V 1.02, GW, 09-Oct-97: Antialiasing support.
+ *         PK, 11-Oct-97: No progress bars when running non-interactive.
+ *                        New procedure file_ps_load_setargs to set
+ *                        load-arguments non-interactively.
+ *                        If GS_OPTIONS are not set, use at least "-dSAFER"
+ * V 1.03, nn, 20-Dec-97: Initialize some variables
+ * V 1.04, PK, 20-Dec-97: Add Encapsulated PostScript output and preview
+ * V 1.05, PK, 21-Sep-98: Write b/w-images (indexed) using image-operator
+ * V 1.06, PK, 22-Dec-98: Fix problem with writing color PS files.
+ *                        Ghostview may hang when displaying the files.
+ * V 1.07, PK, 14-Sep-99: Add resolution to image
+ * V 1.08, PK, 16-Jan-2000: Add PostScript-Level 2 by Austin Donnelly
+ * V 1.09, PK, 15-Feb-2000: Force showpage on EPS-files
+ *                          Add "RunLength" compression
+ *                          Fix problem with "Level 2" toggle
+ * V 1.10, PK, 15-Mar-2000: For load EPSF, allow negative Bounding Box Values
+ *                          Save PS: don't start lines of image data with %%
+ *                          to prevent problems with stupid PostScript
+ *                          analyzer programs (Stanislav Brabec)
+ *                          Add BeginData/EndData comments
+ *                          Save PS: Set default rotation to 0
+ * V 1.11, PK, 20-Aug-2000: Fix problem with BoundingBox recognition
+ *                          for Mac files.
+ *                          Fix problem with loop when reading not all
+ *                          images of a multi page file.
+ *         PK, 31-Aug-2000: Load PS: Add checks for space in filename.
+ * V 1.12  PK, 19-Jun-2001: Fix problem with command line switch --
+ *                          (reported by Ferenc Wagner)
+ * V 1.13  PK, 07-Apr-2002: Fix problem with DOS binary EPS files
+ * V 1.14  PK, 14-May-2002: Workaround EPS files of Adb. Ill. 8.0
+ * V 1.15  PK, 04-Oct-2002: Be more accurate with using BoundingBox
+ * V 1.16  PK, 22-Jan-2004: Don't use popen(), use g_spawn_async_with_pipes()
+ *                          or g_spawn_sync().
+ * V 1.17  PK, 19-Sep-2004: Fix problem with interpretation of bounding box
+ */
+
+#include "config.h"
+
+#include <errno.h>
+#include <string.h>
+#include <time.h>
+
+#include <sys/types.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib/gstdio.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+#include <ghostscript/ierrors.h>
+#include <ghostscript/iapi.h>
+#include <ghostscript/gdevdsp.h>
+
+#define VERSIO 1.17
+static const gchar dversio[] = "v1.17  19-Sep-2004";
+
+#define LOAD_PS_PROC         "file-ps-load"
+#define LOAD_EPS_PROC        "file-eps-load"
+#define LOAD_PS_SETARGS_PROC "file-ps-load-setargs"
+#define LOAD_PS_THUMB_PROC   "file-ps-load-thumb"
+#define SAVE_PS_PROC         "file-ps-save"
+#define SAVE_EPS_PROC        "file-eps-save"
+#define PLUG_IN_BINARY       "file-ps"
+#define PLUG_IN_ROLE         "gimp-file-ps"
+
+
+#define STR_LENGTH     64
+#define MIN_RESOLUTION 5
+#define MAX_RESOLUTION 8192
+
+/* Load info */
+typedef struct
+{
+  guint     resolution;        /* resolution (dpi) at which to run ghostscript */
+  guint     width, height;     /* desired size (ghostscript may ignore this) */
+  gboolean  use_bbox;          /* 0: use width/height, 1: try to use BoundingBox */
+  gchar     pages[STR_LENGTH]; /* Pages to load (eg.: 1,3,5-7) */
+  gint      pnm_type;          /* 4: pbm, 5: pgm, 6: ppm, 7: automatic */
+  gint      textalpha;         /* antialiasing: 1,2, or 4 TextAlphaBits */
+  gint      graphicsalpha;     /* antialiasing: 1,2, or 4 GraphicsAlphaBits */
+} PSLoadVals;
+
+static PSLoadVals plvals =
+{
+  100,         /* 100 dpi                        */
+  826, 1170,   /* default width/height (A4)      */
+  TRUE,        /* try to use BoundingBox         */
+  "1",         /* pages to load                  */
+  6,           /* use ppm (color)               */
+  1,           /* don't use text antialiasing     */
+  1            /* don't use graphics antialiasing */
+};
+
+/* Widgets for width and height of PostScript image to
+*  be loaded, so that they can be updated when desired resolution is
+*  changed
+*/
+static GtkWidget *ps_width_spinbutton;
+static GtkWidget *ps_height_spinbutton;
+
+/* Save info  */
+typedef struct
+{
+  gdouble    width, height;      /* Size of image */
+  gdouble    x_offset, y_offset; /* Offset to image on page */
+  gboolean   unit_mm;            /* Unit of measure (0: inch, 1: mm) */
+  gboolean   keep_ratio;         /* Keep aspect ratio */
+  gint       rotate;             /* Rotation (0, 90, 180, 270) */
+  gint       level;              /* PostScript Level */
+  gboolean   eps;                /* Encapsulated PostScript flag */
+  gboolean   preview;            /* Preview Flag */
+  gint       preview_size;       /* Preview size */
+} PSSaveVals;
+
+static PSSaveVals psvals =
+{
+  287.0, 200.0,   /* Image size (A4) */
+  5.0, 5.0,       /* Offset */
+  TRUE,           /* Unit is mm */
+  TRUE,           /* Keep edge ratio */
+  0,              /* Rotate */
+  2,              /* PostScript Level */
+  FALSE,          /* Encapsulated PostScript flag */
+  FALSE,          /* Preview flag */
+  256             /* Preview size */
+};
+
+static const char hex[] = "0123456789abcdef";
+
+
+/* Declare some 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 gboolean  save_image       (GFile             *file,
+                                   gint32             image_ID,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+
+static gboolean  save_ps_header   (GOutputStream     *output,
+                                   GFile             *file,
+                                   GError           **error);
+static gboolean  save_ps_setup    (GOutputStream     *output,
+                                   gint32             drawable_ID,
+                                   gint               width,
+                                   gint               height,
+                                   gint               bpp,
+                                   GError           **error);
+static gboolean  save_ps_trailer  (GOutputStream     *output,
+                                   GError           **error);
+
+static gboolean  save_ps_preview  (GOutputStream     *output,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+
+static gboolean  save_gray        (GOutputStream     *output,
+                                   gint32             image_ID,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+static gboolean  save_bw          (GOutputStream     *output,
+                                   gint32             image_ID,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+static gboolean  save_index       (GOutputStream     *output,
+                                   gint32             image_ID,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+static gboolean  save_rgb         (GOutputStream     *output,
+                                   gint32             image_ID,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+
+static gboolean  print            (GOutputStream     *output,
+                                   GError           **error,
+                                   const gchar       *format,
+                                   ...) G_GNUC_PRINTF (3, 4);
+
+static gint32    create_new_image (const gchar       *filename,
+                                   guint              pagenum,
+                                   guint              width,
+                                   guint              height,
+                                   GimpImageBaseType  type,
+                                   gint32            *layer_ID);
+
+static void      check_load_vals  (void);
+static void      check_save_vals  (void);
+
+static gint      page_in_list     (gchar             *list,
+                                   guint              pagenum);
+
+static gint      get_bbox         (const gchar       *filename,
+                                   gint              *x0,
+                                   gint              *y0,
+                                   gint              *x1,
+                                   gint              *y1);
+
+static FILE    * ps_open          (const gchar       *filename,
+                                   const PSLoadVals  *loadopt,
+                                   gint              *llx,
+                                   gint              *lly,
+                                   gint              *urx,
+                                   gint              *ury,
+                                   gboolean          *is_epsf,
+                                   gchar            **tmp_filename);
+
+static void      ps_close         (FILE              *ifp,
+                                   gchar             *tmp_filename);
+
+static gboolean  skip_ps          (FILE              *ifp);
+
+static gint32    load_ps          (const gchar       *filename,
+                                   guint              pagenum,
+                                   FILE              *ifp,
+                                   gint               llx,
+                                   gint               lly,
+                                   gint               urx,
+                                   gint               ury);
+
+static void      dither_grey      (const guchar      *grey,
+                                   guchar            *bw,
+                                   gint               npix,
+                                   gint               linecount);
+
+
+/* Dialog-handling */
+
+static gint32    count_ps_pages             (const gchar *filename);
+static gboolean  load_dialog                (const gchar *filename);
+static void      load_pages_entry_callback  (GtkWidget   *widget,
+                                             gpointer     data);
+
+static gboolean  resolution_change_callback (GtkAdjustment *adjustment,
+                                             gpointer   data);
+
+typedef struct
+{
+  GtkAdjustment *adjustment[4];
+  gint           level;
+} SaveDialogVals;
+
+static gboolean  save_dialog              (void);
+static void      save_unit_toggle_update  (GtkWidget *widget,
+                                           gpointer   data);
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+  NULL,  /* init_proc  */
+  NULL,  /* quit_proc  */
+  query, /* query_proc */
+  run,   /* run_proc   */
+};
+
+
+/* The run mode */
+static GimpRunMode l_run_mode;
+
+static void compress_packbits (int            nin,
+                               unsigned char *src,
+                               int           *nout,
+                               unsigned char *dst);
+
+
+static guint32  ascii85_buf       = 0;
+static gint     ascii85_len       = 0;
+static gint     ascii85_linewidth = 0;
+
+static GimpPageSelectorTarget ps_pagemode = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
+
+static void
+ascii85_init (void)
+{
+  ascii85_len       = 0;
+  ascii85_linewidth = 0;
+}
+
+static gboolean
+ascii85_flush (GOutputStream  *output,
+               GError        **error)
+{
+  gchar    c[5];
+  gint     i;
+  gboolean zero_case = (ascii85_buf == 0);
+  GString  *string   = g_string_new (NULL);
+
+  static gint max_linewidth = 75;
+
+  for (i = 4; i >= 0; i--)
+    {
+      c[i] = (ascii85_buf % 85) + '!';
+      ascii85_buf /= 85;
+    }
+
+  /* check for special case: "!!!!!" becomes "z", but only if not
+   * at end of data. */
+  if (zero_case && (ascii85_len == 4))
+    {
+      if (ascii85_linewidth >= max_linewidth)
+        {
+          g_string_append_c (string, '\n');
+
+          ascii85_linewidth = 0;
+        }
+
+      g_string_append_c (string, 'z');
+
+      ascii85_linewidth++;
+    }
+  else
+    {
+      for (i = 0; i < ascii85_len + 1; i++)
+        {
+          if ((ascii85_linewidth >= max_linewidth) && (c[i] != '%'))
+            {
+              g_string_append_c (string, '\n');
+
+              ascii85_linewidth = 0;
+            }
+
+          g_string_append_c (string, c[i]);
+
+          ascii85_linewidth++;
+        }
+    }
+
+  ascii85_len = 0;
+  ascii85_buf = 0;
+
+  if (string->len > 0 &&
+      ! g_output_stream_write_all (output,
+                                   string->str, string->len, NULL,
+                                   NULL, error))
+    {
+      g_string_free (string, TRUE);
+
+      return FALSE;
+    }
+
+  g_string_free (string, TRUE);
+
+  return TRUE;
+}
+
+static inline gboolean
+ascii85_out (GOutputStream  *output,
+             guchar          byte,
+             GError        **error)
+{
+  if (ascii85_len == 4)
+    if (! ascii85_flush (output, error))
+      return FALSE;
+
+  ascii85_buf <<= 8;
+  ascii85_buf |= byte;
+  ascii85_len++;
+
+  return TRUE;
+}
+
+static gboolean
+ascii85_nout (GOutputStream  *output,
+              gint            n,
+              guchar         *uptr,
+              GError        **error)
+{
+  while (n-- > 0)
+    {
+      if (! ascii85_out (output, *uptr, error))
+        return FALSE;
+
+      uptr++;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+ascii85_done (GOutputStream  *output,
+              GError        **error)
+{
+  if (ascii85_len)
+    {
+      /* zero any unfilled buffer portion, then flush */
+      ascii85_buf <<= (8 * (4 - ascii85_len));
+
+      if (! ascii85_flush (output, error))
+        return FALSE;
+    }
+
+  if (! print (output, error, "~>\n"))
+    return FALSE;
+
+  return TRUE;
+}
+
+
+static void
+compress_packbits (int nin,
+                   unsigned char *src,
+                   int *nout,
+                   unsigned char *dst)
+
+{
+ unsigned char c;
+ int nrepeat, nliteral;
+ unsigned char *run_start;
+ unsigned char *start_dst = dst;
+ unsigned char *last_literal = NULL;
+
+ for (;;)
+ {
+   if (nin <= 0) break;
+
+   run_start = src;
+   c = *run_start;
+
+   /* Search repeat bytes */
+   if ((nin > 1) && (c == src[1]))
+   {
+     nrepeat = 1;
+     nin -= 2;
+     src += 2;
+     while ((nin > 0) && (c == *src))
+     {
+       nrepeat++;
+       src++;
+       nin--;
+       if (nrepeat == 127) break; /* Maximum repeat */
+     }
+
+     /* Add two-byte repeat to last literal run ? */
+     if (   (nrepeat == 1)
+         && (last_literal != NULL) && (((*last_literal)+1)+2 <= 128))
+     {
+       *last_literal += 2;
+       *(dst++) = c;
+       *(dst++) = c;
+       continue;
+     }
+
+     /* Add repeat run */
+     *(dst++) = (unsigned char)((-nrepeat) & 0xff);
+     *(dst++) = c;
+     last_literal = NULL;
+     continue;
+   }
+   /* Search literal bytes */
+   nliteral = 1;
+   nin--;
+   src++;
+
+   for (;;)
+   {
+     if (nin <= 0) break;
+
+     if ((nin >= 2) && (src[0] == src[1])) /* A two byte repeat ? */
+       break;
+
+     nliteral++;
+     nin--;
+     src++;
+     if (nliteral == 128) break; /* Maximum literal run */
+   }
+
+   /* Could be added to last literal run ? */
+   if ((last_literal != NULL) && (((*last_literal)+1)+nliteral <= 128))
+   {
+     *last_literal += nliteral;
+   }
+   else
+   {
+     last_literal = dst;
+     *(dst++) = (unsigned char)(nliteral-1);
+   }
+   while (nliteral-- > 0) *(dst++) = *(run_start++);
+ }
+ *nout = dst - start_dst;
+}
+
+
+typedef struct
+{
+  goffset eol;
+  goffset begin_data;
+} PS_DATA_POS;
+
+static PS_DATA_POS ps_data_pos = { 0, 0 };
+
+static gboolean
+ps_begin_data (GOutputStream  *output,
+               GError        **error)
+{
+  /*                                 %%BeginData: 123456789012 ASCII Bytes */
+  if (! print (output, error, "%s", "%%BeginData:                         "))
+    return FALSE;
+
+  ps_data_pos.eol = g_seekable_tell (G_SEEKABLE (output));
+
+  if (! print (output, error, "\n"))
+    return FALSE;
+
+  ps_data_pos.begin_data = g_seekable_tell (G_SEEKABLE (output));
+
+  return TRUE;
+}
+
+static gboolean
+ps_end_data (GOutputStream  *output,
+             GError        **error)
+{
+  goffset end_data;
+  gchar   s[64];
+
+  if ((ps_data_pos.begin_data > 0) && (ps_data_pos.eol > 0))
+    {
+      end_data = g_seekable_tell (G_SEEKABLE (output));
+
+      if (end_data > 0)
+        {
+          g_snprintf (s, sizeof (s),
+                      "%"G_GOFFSET_FORMAT" ASCII Bytes", end_data - ps_data_pos.begin_data);
+
+          if (! g_seekable_seek (G_SEEKABLE (output),
+                                 ps_data_pos.eol - strlen (s), G_SEEK_SET,
+                                 NULL, error))
+            return FALSE;
+
+          if (! print (output, error, "%s", s))
+            return FALSE;
+
+          if (! g_seekable_seek (G_SEEKABLE (output),
+                                 end_data, G_SEEK_SET,
+                                 NULL, error))
+            return FALSE;
+        }
+    }
+
+  if (! print (output, error, "%s\n", "%%EndData"))
+    return FALSE;
+
+  return TRUE;
+}
+
+
+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 of the file to load" }
+  };
+  static const GimpParamDef load_return_vals[] =
+  {
+    { GIMP_PDB_IMAGE, "image", "Output image" }
+  };
+
+  static const GimpParamDef set_load_args[] =
+  {
+    { GIMP_PDB_INT32,  "resolution", "Resolution to interpret image (dpi)"     },
+    { GIMP_PDB_INT32,  "width",      "Desired width"                           },
+    { GIMP_PDB_INT32,  "height",     "Desired height"                          },
+    { GIMP_PDB_INT32,  "check-bbox", "0: Use width/height, 1: Use BoundingBox" },
+    { GIMP_PDB_STRING, "pages",      "Pages to load (e.g.: 1,3,5-7)"           },
+    { GIMP_PDB_INT32,  "coloring",   "4: b/w, 5: grey, 6: color image, 7: automatic" },
+    { GIMP_PDB_INT32,  "text-alpha-bits",    "1, 2, or 4" },
+    { GIMP_PDB_INT32,  "graphic-alpha-bits", "1, 2, or 4" }
+  };
+
+  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",         "Output 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 export" },
+    { GIMP_PDB_STRING,   "filename",     "The name of the file to export the image in" },
+    { GIMP_PDB_STRING,   "raw-filename", "The name of the file to export the image in" },
+    { GIMP_PDB_FLOAT,    "width",        "Width of the image in PostScript file (0: use input image size)" },
+    { GIMP_PDB_FLOAT,    "height",       "Height of image in PostScript file (0: use input image size)" },
+    { GIMP_PDB_FLOAT,    "x-offset",     "X-offset to image from lower left corner" },
+    { GIMP_PDB_FLOAT,    "y-offset",     "Y-offset to image from lower left corner" },
+    { GIMP_PDB_INT32,    "unit",         "Unit for width/height/offset. 0: inches, 1: millimeters" },
+    { GIMP_PDB_INT32,    "keep-ratio",   "0: use width/height, 1: keep aspect ratio" },
+    { GIMP_PDB_INT32,    "rotation",     "0, 90, 180, 270" },
+    { GIMP_PDB_INT32,    "eps-flag",     "0: PostScript, 1: Encapsulated PostScript" },
+    { GIMP_PDB_INT32,    "preview",      "0: no preview, >0: max. size of preview" },
+    { GIMP_PDB_INT32,    "level",        "1: PostScript Level 1, 2: PostScript Level 2" }
+  };
+
+  gimp_install_procedure (LOAD_PS_PROC,
+                          "load PostScript documents",
+                          "load PostScript documents",
+                          "Peter Kirchgessner <peter@kirchgessner.net>",
+                          "Peter Kirchgessner",
+                          dversio,
+                          N_("PostScript document"),
+                          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_PS_PROC, "application/postscript");
+  gimp_register_magic_load_handler (LOAD_PS_PROC,
+                                    "ps",
+                                    "",
+                                    "0,string,%!,0,long,0xc5d0d3c6");
+
+  gimp_install_procedure (LOAD_EPS_PROC,
+                          "load Encapsulated PostScript images",
+                          "load Encapsulated PostScript images",
+                          "Peter Kirchgessner <peter@kirchgessner.net>",
+                          "Peter Kirchgessner",
+                          dversio,
+                          N_("Encapsulated PostScript image"),
+                          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_EPS_PROC, "image/x-eps");
+  gimp_register_magic_load_handler (LOAD_EPS_PROC,
+                                    "eps",
+                                    "",
+                                    "0,string,%!,0,long,0xc5d0d3c6");
+
+  gimp_install_procedure (LOAD_PS_SETARGS_PROC,
+                          "set additional parameters for procedure file-ps-load",
+                          "set additional parameters for procedure file-ps-load",
+                          "Peter Kirchgessner <peter@kirchgessner.net>",
+                          "Peter Kirchgessner",
+                          dversio,
+                          NULL,
+                          NULL,
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (set_load_args), 0,
+                          set_load_args, NULL);
+
+  gimp_install_procedure (LOAD_PS_THUMB_PROC,
+                          "Loads a small preview from a PostScript or PDF document",
+                          "",
+                          "Peter Kirchgessner <peter@kirchgessner.net>",
+                          "Peter Kirchgessner",
+                          dversio,
+                          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_PS_PROC,  LOAD_PS_THUMB_PROC);
+  gimp_register_thumbnail_loader (LOAD_EPS_PROC, LOAD_PS_THUMB_PROC);
+
+  gimp_install_procedure (SAVE_PS_PROC,
+                          "export image as PostScript document",
+                          "PostScript exporting handles all image types except "
+                          "those with alpha channels.",
+                          "Peter Kirchgessner <peter@kirchgessner.net>",
+                          "Peter Kirchgessner",
+                          dversio,
+                          N_("PostScript document"),
+                          "RGB, GRAY, INDEXED",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (save_args), 0,
+                          save_args, NULL);
+
+  gimp_register_file_handler_mime (SAVE_PS_PROC, "application/postscript");
+  gimp_register_file_handler_uri (SAVE_PS_PROC);
+  gimp_register_save_handler (SAVE_PS_PROC, "ps", "");
+
+  gimp_install_procedure (SAVE_EPS_PROC,
+                          "export image as Encapsulated PostScript image",
+                          "PostScript exporting handles all image types except "
+                          "those with alpha channels.",
+                          "Peter Kirchgessner <peter@kirchgessner.net>",
+                          "Peter Kirchgessner",
+                          dversio,
+                          N_("Encapsulated PostScript image"),
+                          "RGB, GRAY, INDEXED",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (save_args), 0,
+                          save_args, NULL);
+
+  gimp_register_file_handler_mime (SAVE_EPS_PROC, "application/x-eps");
+  gimp_register_file_handler_uri (SAVE_EPS_PROC);
+  gimp_register_save_handler (SAVE_EPS_PROC, "eps", "");
+}
+
+static void
+ps_set_save_size (PSSaveVals *vals,
+                  gint32      image_ID)
+{
+  gdouble  xres, yres, factor, iw, ih;
+  guint    width, height;
+  GimpUnit unit;
+
+  gimp_image_get_resolution (image_ID, &xres, &yres);
+
+  if ((xres < 1e-5) || (yres < 1e-5))
+    xres = yres = 72.0;
+
+  /* Calculate size of image in inches */
+  width  = gimp_image_width (image_ID);
+  height = gimp_image_height (image_ID);
+  iw = width  / xres;
+  ih = height / yres;
+
+  unit = gimp_image_get_unit (image_ID);
+  factor = gimp_unit_get_factor (unit);
+
+  if (factor == 0.0254 ||
+      factor == 0.254 ||
+      factor == 2.54 ||
+      factor == 25.4)
+    {
+      vals->unit_mm = TRUE;
+    }
+
+  if (vals->unit_mm)
+    {
+      iw *= 25.4;
+      ih *= 25.4;
+    }
+
+  vals->width  = iw;
+  vals->height = ih;
+}
+
+static void
+run (const gchar      *name,
+     gint              nparams,
+     const GimpParam  *param,
+     gint             *nreturn_vals,
+     GimpParam       **return_vals)
+{
+  static GimpParam   values[2];
+  GimpRunMode        run_mode;
+  GimpPDBStatusType  status        = GIMP_PDB_SUCCESS;
+  gint32             image_ID      = -1;
+  gint32             drawable_ID   = -1;
+  gint32             orig_image_ID = -1;
+  GimpExportReturn   export        = GIMP_EXPORT_CANCEL;
+  GError            *error         = NULL;
+
+  l_run_mode = run_mode = param[0].data.d_int32;
+
+  INIT_I18N ();
+  gegl_init (NULL, NULL);
+
+  *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_PS_PROC)  == 0 ||
+      strcmp (name, LOAD_EPS_PROC) == 0)
+    {
+      switch (run_mode)
+        {
+        case GIMP_RUN_INTERACTIVE:
+          /*  Possibly retrieve data  */
+          gimp_get_data (LOAD_PS_PROC, &plvals);
+
+          if (! load_dialog (param[1].data.d_string))
+            status = GIMP_PDB_CANCEL;
+          break;
+
+        case GIMP_RUN_NONINTERACTIVE:
+          /*  Make sure all the arguments are there!  */
+          if (nparams != 3)
+            status = GIMP_PDB_CALLING_ERROR;
+          else    /* Get additional interpretation arguments */
+            gimp_get_data (LOAD_PS_PROC, &plvals);
+          break;
+
+        case GIMP_RUN_WITH_LAST_VALS:
+          /* Possibly retrieve data */
+          gimp_get_data (LOAD_PS_PROC, &plvals);
+          break;
+
+        default:
+          break;
+        }
+
+      if (status == GIMP_PDB_SUCCESS)
+        {
+          check_load_vals ();
+          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;
+            }
+          else
+            {
+              status = GIMP_PDB_EXECUTION_ERROR;
+            }
+        }
+
+      /*  Store plvals data  */
+      if (status == GIMP_PDB_SUCCESS)
+        gimp_set_data (LOAD_PS_PROC, &plvals, sizeof (PSLoadVals));
+    }
+  else if (strcmp (name, LOAD_PS_THUMB_PROC) == 0)
+    {
+      if (nparams < 2)
+        {
+          status = GIMP_PDB_CALLING_ERROR;
+        }
+      else
+        {
+          gint size = param[1].data.d_int32;
+
+          /*  We should look for an embedded preview but for now we
+           *  just load the document at a small resolution and the
+           *  first page only.
+           */
+
+          plvals.resolution = size / 4;
+          plvals.width      = size;
+          plvals.height     = size;
+          strncpy (plvals.pages, "1", sizeof (plvals.pages) - 1);
+
+          check_load_vals ();
+          image_ID = load_image (param[0].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, SAVE_PS_PROC)  == 0 ||
+           strcmp (name, SAVE_EPS_PROC) == 0)
+    {
+      psvals.eps = strcmp (name, SAVE_PS_PROC);
+
+      image_ID    = orig_image_ID = param[1].data.d_int32;
+      drawable_ID = param[2].data.d_int32;
+
+      /* 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,
+                                      psvals.eps ? "EPS" : "PostScript",
+                                      GIMP_EXPORT_CAN_HANDLE_RGB  |
+                                      GIMP_EXPORT_CAN_HANDLE_GRAY |
+                                      GIMP_EXPORT_CAN_HANDLE_INDEXED);
+
+          if (export == GIMP_EXPORT_CANCEL)
+            {
+              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 (name, &psvals);
+
+          ps_set_save_size (&psvals, orig_image_ID);
+
+          /*  First acquire information with a dialog  */
+          if (! save_dialog ())
+            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
+            {
+              psvals.width        = param[5].data.d_float;
+              psvals.height       = param[6].data.d_float;
+              psvals.x_offset     = param[7].data.d_float;
+              psvals.y_offset     = param[8].data.d_float;
+              psvals.unit_mm      = (param[9].data.d_int32 != 0);
+              psvals.keep_ratio   = (param[10].data.d_int32 != 0);
+              psvals.rotate       = param[11].data.d_int32;
+              psvals.eps          = (param[12].data.d_int32 != 0);
+              psvals.preview      = (param[13].data.d_int32 != 0);
+              psvals.preview_size = param[13].data.d_int32;
+              psvals.level        = param[14].data.d_int32;
+            }
+          break;
+
+        case GIMP_RUN_WITH_LAST_VALS:
+          /*  Possibly retrieve data  */
+          gimp_get_data (name, &psvals);
+          break;
+
+        default:
+          break;
+        }
+
+      if (status == GIMP_PDB_SUCCESS)
+        {
+          if ((psvals.width == 0.0) || (psvals.height == 0.0))
+            ps_set_save_size (&psvals, orig_image_ID);
+
+          check_save_vals ();
+
+          if (save_image (g_file_new_for_uri (param[3].data.d_string),
+                          image_ID, drawable_ID,
+                          &error))
+            {
+              /*  Store psvals data  */
+              gimp_set_data (name, &psvals, sizeof (PSSaveVals));
+            }
+          else
+            {
+              status = GIMP_PDB_EXECUTION_ERROR;
+            }
+        }
+
+      if (export == GIMP_EXPORT_EXPORT)
+        gimp_image_delete (image_ID);
+    }
+  else if (strcmp (name, LOAD_PS_SETARGS_PROC) == 0)
+    {
+      /*  Make sure all the arguments are there!  */
+      if (nparams != 8)
+        {
+          status = GIMP_PDB_CALLING_ERROR;
+        }
+      else
+        {
+          plvals.resolution = param[0].data.d_int32;
+          plvals.width      = param[1].data.d_int32;
+          plvals.height     = param[2].data.d_int32;
+          plvals.use_bbox   = param[3].data.d_int32;
+          if (param[4].data.d_string != NULL)
+            strncpy (plvals.pages, param[4].data.d_string,
+                     sizeof (plvals.pages));
+          else
+            plvals.pages[0] = '\0';
+          plvals.pages[sizeof (plvals.pages) - 1] = '\0';
+          plvals.pnm_type      = param[5].data.d_int32;
+          plvals.textalpha     = param[6].data.d_int32;
+          plvals.graphicsalpha = param[7].data.d_int32;
+          check_load_vals ();
+
+          gimp_set_data (LOAD_PS_PROC, &plvals, sizeof (PSLoadVals));
+        }
+    }
+  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;
+}
+
+
+static gint32
+load_image (const gchar  *filename,
+            GError      **error)
+{
+  gint32    image_ID = 0;
+  gint32   *image_list, *nl;
+  guint     page_count;
+  FILE     *ifp;
+  gchar    *temp;
+  gint      llx, lly, urx, ury;
+  gint      k, n_images, max_images, max_pagenum;
+  gboolean  is_epsf;
+  GdkPixbuf    *pixbuf = NULL;
+  gchar        *tmp_filename = NULL;
+
+#ifdef PS_DEBUG
+  g_print ("load_image:\n resolution = %d\n", plvals.resolution);
+  g_print (" %dx%d pixels\n", plvals.width, plvals.height);
+  g_print (" BoundingBox: %d\n", plvals.use_bbox);
+  g_print (" Coloring: %d\n", plvals.pnm_type);
+  g_print (" TextAlphaBits: %d\n", plvals.textalpha);
+  g_print (" GraphicsAlphaBits: %d\n", plvals.graphicsalpha);
+#endif
+
+  gimp_progress_init_printf (_("Opening '%s'"),
+                             gimp_filename_to_utf8 (filename));
+
+  /* Try to see if PostScript file is available */
+  ifp = g_fopen (filename, "r");
+  if (ifp == 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;
+    }
+  fclose (ifp);
+
+  ifp = ps_open (filename, &plvals, &llx, &lly, &urx, &ury, &is_epsf, &tmp_filename);
+  if (!ifp)
+    {
+      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR,
+                   _("Could not interpret PostScript file '%s'"),
+                   gimp_filename_to_utf8 (filename));
+      return -1;
+    }
+
+  image_list = g_new (gint32, 10);
+  n_images = 0;
+  max_images = 10;
+
+  max_pagenum = 9999;  /* Try to get the maximum pagenumber to read */
+  if (is_epsf)
+    {
+      max_pagenum = 1;
+      /* Use pixbuf to load transparent EPS as PNGs */
+      pixbuf = gdk_pixbuf_new_from_file (tmp_filename, error);
+      if (! pixbuf)
+        return -1;
+    }
+
+  if (!page_in_list (plvals.pages, max_pagenum)) /* Is there a limit in list ? */
+    {
+      max_pagenum = -1;
+      for (temp = plvals.pages; *temp != '\0'; temp++)
+        {
+          if ((*temp < '0') || (*temp > '9'))
+            continue; /* Search next digit */
+          sscanf (temp, "%d", &k);
+          if (k > max_pagenum)
+            max_pagenum = k;
+          while ((*temp >= '0') && (*temp <= '9'))
+            temp++;
+          temp--;
+        }
+
+      if (max_pagenum < 1)
+        max_pagenum = 9999;
+    }
+
+  /* Load all images */
+  for (page_count = 1; page_count <= max_pagenum; page_count++)
+    {
+      if (page_in_list (plvals.pages, page_count))
+        {
+          image_ID = load_ps (filename, page_count, ifp, llx, lly, urx, ury);
+          if (image_ID == -1)
+            break;
+
+          gimp_image_set_resolution (image_ID,
+                                     (gdouble) plvals.resolution,
+                                     (gdouble) plvals.resolution);
+
+          if (n_images == max_images)
+            {
+              nl = (gint32 *) g_realloc (image_list,
+                                         (max_images+10)*sizeof (gint32));
+              if (nl == NULL) break;
+              image_list = nl;
+              max_images += 10;
+            }
+          image_list[n_images++] = image_ID;
+        }
+      else  /* Skip an image */
+        {
+          image_ID = -1;
+          if (! skip_ps (ifp))
+            break;
+        }
+    }
+
+  ps_close (ifp, tmp_filename);
+
+  /* EPS are now imported using pngalpha, so they can be converted
+   * to a layer with gimp_layer_new_from_pixbuf () and exported at
+   * this part of the loading process
+   */
+  if (is_epsf)
+    {
+      gint32 layer;
+
+      image_ID = gimp_image_new (urx, ury, GIMP_RGB);
+
+      gimp_image_undo_disable (image_ID);
+
+      gimp_image_set_filename (image_ID, filename);
+      gimp_image_set_resolution (image_ID,
+                                 plvals.resolution,
+                                 plvals.resolution);
+
+      layer = gimp_layer_new_from_pixbuf (image_ID, _("Rendered EPS"), pixbuf,
+                                          100,
+                                          gimp_image_get_default_new_layer_mode (image_ID),
+                                          0.0, 1.0);
+      gimp_image_insert_layer (image_ID, layer, -1, 0);
+
+      gimp_image_undo_enable (image_ID);
+
+      g_free (image_list);
+      g_object_unref (pixbuf);
+
+      return image_ID;
+    }
+
+  if (ps_pagemode == GIMP_PAGE_SELECTOR_TARGET_LAYERS)
+    {
+      for (k = 0; k < n_images; k++)
+        {
+          gchar *name;
+
+          if (k == 0)
+            {
+              image_ID = image_list[0];
+
+              name = g_strdup_printf (_("%s-pages"), filename);
+              gimp_image_set_filename (image_ID, name);
+              g_free (name);
+            }
+          else
+            {
+              gint32 current_layer;
+              gint32 tmp_ID;
+
+              tmp_ID = gimp_image_get_active_drawable (image_list[k]);
+
+              name = gimp_item_get_name (tmp_ID);
+
+              current_layer = gimp_layer_new_from_drawable (tmp_ID, image_ID);
+              gimp_item_set_name (current_layer, name);
+              gimp_image_insert_layer (image_ID, current_layer, -1, -1);
+              gimp_image_delete (image_list[k]);
+
+              g_free (name);
+            }
+        }
+
+      gimp_image_undo_enable (image_ID);
+    }
+  else
+    {
+      /* Display images in reverse order.
+       * The last will be displayed by GIMP itself
+       */
+      for (k = n_images - 1; k >= 0; k--)
+        {
+          gimp_image_undo_enable (image_list[k]);
+          gimp_image_clean_all (image_list[k]);
+
+          if (l_run_mode != GIMP_RUN_NONINTERACTIVE && k > 0)
+            gimp_display_new (image_list[k]);
+        }
+
+      image_ID = (n_images > 0) ? image_list[0] : -1;
+    }
+
+  g_free (image_list);
+
+  return image_ID;
+}
+
+
+static gboolean
+save_image (GFile   *file,
+            gint32   image_ID,
+            gint32   drawable_ID,
+            GError **error)
+{
+  GOutputStream *output;
+  GCancellable  *cancellable;
+  GimpImageType  drawable_type;
+
+  drawable_type = gimp_drawable_type (drawable_ID);
+
+  /*  Make sure we're not exporting an image with an alpha channel  */
+  if (gimp_drawable_has_alpha (drawable_ID))
+    {
+      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                   _("PostScript export cannot handle images with alpha channels"));
+      return FALSE;
+    }
+
+  switch (drawable_type)
+    {
+    case GIMP_INDEXED_IMAGE:
+    case GIMP_GRAY_IMAGE:
+    case GIMP_RGB_IMAGE:
+      break;
+
+    default:
+      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                   _("Cannot operate on unknown image types."));
+      return FALSE;
+      break;
+    }
+
+  gimp_progress_init_printf (_("Exporting '%s'"),
+                             gimp_file_get_utf8_name (file));
+
+  output = G_OUTPUT_STREAM (g_file_replace (file,
+                                            NULL, FALSE, G_FILE_CREATE_NONE,
+                                            NULL, error));
+  if (output)
+    {
+      GOutputStream *buffered;
+
+      buffered = g_buffered_output_stream_new (output);
+      g_object_unref (output);
+
+      output = buffered;
+    }
+  else
+    {
+      return FALSE;
+    }
+
+  if (! save_ps_header (output, file, error))
+    goto fail;
+
+  switch (drawable_type)
+    {
+    case GIMP_INDEXED_IMAGE:
+      if (! save_index (output, image_ID, drawable_ID, error))
+        goto fail;
+      break;
+
+    case GIMP_GRAY_IMAGE:
+      if (! save_gray (output, image_ID, drawable_ID, error))
+        goto fail;
+      break;
+
+    case GIMP_RGB_IMAGE:
+      if (! save_rgb (output, image_ID, drawable_ID, error))
+        goto fail;
+      break;
+
+    default:
+      g_return_val_if_reached (FALSE);
+    }
+
+  if (! save_ps_trailer (output, error))
+    goto fail;
+
+  if (! g_output_stream_close (output, NULL, error))
+    goto fail;
+
+  g_object_unref (output);
+
+  return TRUE;
+
+ fail:
+
+  cancellable = g_cancellable_new ();
+  g_cancellable_cancel (cancellable);
+  g_output_stream_close (output, cancellable, NULL);
+
+  g_object_unref (output);
+  g_object_unref (cancellable);
+
+  return FALSE;
+}
+
+
+/* Check (and correct) the load values plvals */
+static void
+check_load_vals (void)
+{
+  if (plvals.resolution < MIN_RESOLUTION)
+    plvals.resolution = MIN_RESOLUTION;
+  else if (plvals.resolution > MAX_RESOLUTION)
+    plvals.resolution = MAX_RESOLUTION;
+
+  if (plvals.width < 2)
+    plvals.width = 2;
+  if (plvals.height < 2)
+    plvals.height = 2;
+  plvals.use_bbox = (plvals.use_bbox != 0);
+  if (plvals.pages[0] == '\0')
+    strncpy (plvals.pages, "1-99", sizeof (plvals.pages) - 1);
+  if ((plvals.pnm_type < 4) || (plvals.pnm_type > 7))
+    plvals.pnm_type = 6;
+  if (   (plvals.textalpha != 1) && (plvals.textalpha != 2)
+      && (plvals.textalpha != 4))
+    plvals.textalpha = 1;
+  if (   (plvals.graphicsalpha != 1) && (plvals.graphicsalpha != 2)
+      && (plvals.graphicsalpha != 4))
+    plvals.graphicsalpha = 1;
+}
+
+
+/* Check (and correct) the save values psvals */
+static void
+check_save_vals (void)
+{
+  int i;
+
+  i = psvals.rotate;
+  if ((i != 0) && (i != 90) && (i != 180) && (i != 270))
+    psvals.rotate = 90;
+  if (psvals.preview_size <= 0)
+    psvals.preview = FALSE;
+}
+
+
+/* Check if a page is in a given list */
+static gint
+page_in_list (gchar *list,
+              guint  page_num)
+{
+  char tmplist[STR_LENGTH], *c0, *c1;
+  int state, start_num, end_num;
+#define READ_STARTNUM  0
+#define READ_ENDNUM    1
+#define CHK_LIST(a,b,c) {int low=(a),high=(b),swp; \
+  if ((low>0) && (high>0)) { \
+  if (low>high) {swp=low; low=high; high=swp;} \
+  if ((low<=(c))&&(high>=(c))) return (1); } }
+
+  if ((list == NULL) || (*list == '\0'))
+    return 1;
+
+  strncpy (tmplist, list, STR_LENGTH);
+  tmplist[STR_LENGTH-1] = '\0';
+
+  c0 = c1 = tmplist;
+  while (*c1)    /* Remove all whitespace and break on unsupported characters */
+    {
+      if ((*c1 >= '0') && (*c1 <= '9'))
+        {
+          *(c0++) = *c1;
+        }
+      else if ((*c1 == '-') || (*c1 == ','))
+        { /* Try to remove double occurrences of these characters */
+          if (c0 == tmplist)
+            {
+              *(c0++) = *c1;
+            }
+          else
+            {
+              if (*(c0-1) != *c1)
+                *(c0++) = *c1;
+            }
+        }
+      else
+        break;
+
+      c1++;
+    }
+
+  if (c0 == tmplist)
+    return 1;
+
+  *c0 = '\0';
+
+  /* Now we have a comma separated list like 1-4-1,-3,1- */
+
+  start_num = end_num = -1;
+  state = READ_STARTNUM;
+  for (c0 = tmplist; *c0 != '\0'; c0++)
+    {
+      switch (state)
+        {
+        case READ_STARTNUM:
+          if (*c0 == ',')
+            {
+              if ((start_num > 0) && (start_num == (int)page_num))
+                return -1;
+              start_num = -1;
+            }
+          else if (*c0 == '-')
+            {
+              if (start_num < 0) start_num = 1;
+              state = READ_ENDNUM;
+            }
+          else /* '0' - '9' */
+            {
+              if (start_num < 0) start_num = 0;
+              start_num *= 10;
+              start_num += *c0 - '0';
+            }
+          break;
+
+        case READ_ENDNUM:
+          if (*c0 == ',')
+            {
+              if (end_num < 0) end_num = 9999;
+              CHK_LIST (start_num, end_num, (int)page_num);
+              start_num = end_num = -1;
+              state = READ_STARTNUM;
+            }
+          else if (*c0 == '-')
+            {
+              CHK_LIST (start_num, end_num, (int)page_num);
+              start_num = end_num;
+              end_num = -1;
+            }
+          else /* '0' - '9' */
+            {
+              if (end_num < 0) end_num = 0;
+              end_num *= 10;
+              end_num += *c0 - '0';
+            }
+          break;
+        }
+    }
+  if (state == READ_STARTNUM)
+    {
+      if (start_num > 0)
+        return (start_num == (int) page_num);
+    }
+  else
+    {
+      if (end_num < 0) end_num = 9999;
+      CHK_LIST (start_num, end_num, (int)page_num);
+    }
+
+  return 0;
+#undef CHK_LIST
+}
+
+
+/* A function like fgets, but treats single CR-character as line break. */
+/* As a line break the newline-character is returned. */
+static char *psfgets (char *s, int size, FILE *stream)
+
+{
+  int c;
+  char *sptr = s;
+
+  if (size <= 0)
+    return NULL;
+
+  if (size == 1)
+    {
+      *s = '\0';
+      return NULL;
+    }
+
+  c = getc (stream);
+  if (c == EOF)
+    return NULL;
+
+  for (;;)
+    {
+      /* At this point we have space in sptr for at least two characters */
+      if (c == '\n')    /* Got end of line (UNIX line end) ? */
+        {
+          *(sptr++) = '\n';
+          break;
+        }
+      else if (c == '\r')  /* Got a carriage return. Check next character */
+        {
+          c = getc (stream);
+          if ((c == EOF) || (c == '\n')) /* EOF or DOS line end ? */
+            {
+              *(sptr++) = '\n';  /* Return UNIX line end */
+              break;
+            }
+          else  /* Single carriage return. Return UNIX line end. */
+            {
+              ungetc (c, stream);  /* Save the extra character */
+              *(sptr++) = '\n';
+              break;
+            }
+        }
+      else   /* no line end character */
+        {
+          *(sptr++) = (char)c;
+          size--;
+        }
+      if (size == 1)
+        break;  /* Only space for the nul-character ? */
+
+      c = getc (stream);
+      if (c == EOF)
+        break;
+    }
+
+  *sptr = '\0';
+
+  return s;
+}
+
+
+/* Get the BoundingBox of a PostScript file. On success, 0 is returned. */
+/* On failure, -1 is returned. */
+static gint
+get_bbox (const gchar *filename,
+          gint        *x0,
+          gint        *y0,
+          gint        *x1,
+          gint        *y1)
+{
+  char line[1024], *src;
+  FILE *ifp;
+  int retval = -1;
+
+  ifp = g_fopen (filename, "rb");
+  if (ifp == NULL)
+    return -1;
+
+  for (;;)
+    {
+      if (psfgets (line, sizeof (line)-1, ifp) == NULL) break;
+      if ((line[0] != '%') || (line[1] != '%')) continue;
+      src = &(line[2]);
+      while ((*src == ' ') || (*src == '\t')) src++;
+      if (strncmp (src, "BoundingBox", 11) != 0) continue;
+      src += 11;
+      while ((*src == ' ') || (*src == '\t') || (*src == ':')) src++;
+      if (strncmp (src, "(atend)", 7) == 0) continue;
+      if (sscanf (src, "%d%d%d%d", x0, y0, x1, y1) == 4)
+        retval = 0;
+      break;
+    }
+  fclose (ifp);
+
+  return retval;
+}
+
+/* Open the PostScript file. On failure, NULL is returned. */
+/* The filepointer returned will give a PNM-file generated */
+/* by the PostScript-interpreter. */
+static FILE *
+ps_open (const gchar      *filename,
+         const PSLoadVals *loadopt,
+         gint             *llx,
+         gint             *lly,
+         gint             *urx,
+         gint             *ury,
+         gboolean         *is_epsf,
+         gchar           **tmp_filename)
+{
+  const gchar  *driver;
+  GPtrArray    *cmdA;
+  gchar       **pcmdA;
+  FILE         *fd_popen = NULL;
+  FILE         *eps_file;
+  gint          width, height;
+  gint          resolution;
+  gint          x0, y0, x1, y1;
+  gint          offx = 0;
+  gint          offy = 0;
+  gboolean      is_pdf;
+  gboolean      maybe_epsf = FALSE;
+  int           code;
+  void         *instance = NULL;
+
+  resolution = loadopt->resolution;
+  *llx = *lly = 0;
+  width = loadopt->width;
+  height = loadopt->height;
+  *urx = width - 1;
+  *ury = height - 1;
+
+  /* Check if the file is a PDF. For PDF, we can't set geometry */
+  is_pdf = FALSE;
+
+  /* Check if it is a EPS-file */
+  *is_epsf = FALSE;
+
+  eps_file = g_fopen (filename, "rb");
+
+  if (eps_file != NULL)
+    {
+      gchar hdr[512];
+
+      fread (hdr, 1, sizeof(hdr), eps_file);
+      is_pdf = (strncmp (hdr, "%PDF", 4) == 0);
+
+      if (!is_pdf)  /* Check for EPSF */
+        {
+          char *adobe, *epsf;
+          int ds = 0;
+          static unsigned char doseps[5] = { 0xc5, 0xd0, 0xd3, 0xc6, 0 };
+
+          hdr[sizeof(hdr)-1] = '\0';
+          adobe = strstr (hdr, "PS-Adobe-");
+          epsf = strstr (hdr, "EPSF-");
+
+          if ((adobe != NULL) && (epsf != NULL))
+            ds = epsf - adobe;
+
+          *is_epsf = ((ds >= 11) && (ds <= 15));
+
+          /* Illustrator uses negative values in BoundingBox without marking */
+          /* files as EPSF. Try to handle that. */
+          maybe_epsf =
+            (strstr (hdr, "%%Creator: Adobe Illustrator(R) 8.0") != 0);
+
+          /* Check DOS EPS binary file */
+          if ((!*is_epsf) && (strncmp (hdr, (char *)doseps, 4) == 0))
+            *is_epsf = 1;
+        }
+
+      fclose (eps_file);
+    }
+
+  if ((!is_pdf) && (loadopt->use_bbox))    /* Try the BoundingBox ? */
+    {
+      if (get_bbox (filename, &x0, &y0, &x1, &y1) == 0)
+        {
+          if (maybe_epsf && ((x0 < 0) || (y0 < 0)))
+            *is_epsf = 1;
+
+          if (*is_epsf)  /* Handle negative BoundingBox for EPSF */
+            {
+              offx = -x0; x1 += offx; x0 += offx;
+              offy = -y0; y1 += offy; y0 += offy;
+            }
+          if ((x0 >= 0) && (y0 >= 0) && (x1 > x0) && (y1 > y0))
+            {
+               *llx = (int)((x0/72.0) * resolution + 0.0001);
+               *lly = (int)((y0/72.0) * resolution + 0.0001);
+               /* Use upper bbox values as image size */
+               width = (int)((x1/72.0) * resolution + 0.5);
+               height = (int)((y1/72.0) * resolution + 0.5);
+               /* Pixel coordinates must be one less */
+               *urx = width - 1;
+               *ury = height - 1;
+               if (*urx < *llx) *urx = *llx;
+               if (*ury < *lly) *ury = *lly;
+            }
+        }
+    }
+
+  switch (loadopt->pnm_type)
+    {
+    case 4:
+      driver = "pbmraw";
+      break;
+    case 5:
+      driver = "pgmraw";
+      break;
+    case 7:
+      driver = "pnmraw";
+      break;
+    default:
+      driver = "ppmraw";
+      break;
+    }
+
+  /* For instance, the Win32 port of ghostscript doesn't work correctly when
+   * using standard output as output file.
+   * Thus, use a real output file.
+   */
+  if (*is_epsf)
+    {
+      driver = "pngalpha";
+      *tmp_filename = gimp_temp_name ("png");
+    }
+  else
+    {
+      *tmp_filename = gimp_temp_name ("pnm");
+    }
+
+  /* Build command array */
+  cmdA = g_ptr_array_new ();
+
+  g_ptr_array_add (cmdA, g_strdup (g_get_prgname ()));
+  g_ptr_array_add (cmdA, g_strdup_printf ("-sDEVICE=%s", driver));
+  g_ptr_array_add (cmdA, g_strdup_printf ("-r%d", resolution));
+
+  if (is_pdf)
+    {
+      /* Acrobat Reader honors CropBox over MediaBox, so let's match that
+       * behavior.
+       */
+      g_ptr_array_add (cmdA, g_strdup ("-dUseCropBox"));
+    }
+  else
+    {
+      /* For PDF, we can't set geometry */
+      g_ptr_array_add (cmdA, g_strdup_printf ("-g%dx%d", width, height));
+    }
+
+  /* Antialiasing not available for PBM-device */
+  if ((loadopt->pnm_type != 4) && (loadopt->textalpha != 1))
+    g_ptr_array_add (cmdA, g_strdup_printf ("-dTextAlphaBits=%d",
+                                            loadopt->textalpha));
+  if ((loadopt->pnm_type != 4) && (loadopt->graphicsalpha != 1))
+    g_ptr_array_add (cmdA, g_strdup_printf ("-dGraphicsAlphaBits=%d",
+                                            loadopt->graphicsalpha));
+  g_ptr_array_add (cmdA, g_strdup ("-q"));
+  g_ptr_array_add (cmdA, g_strdup ("-dBATCH"));
+  g_ptr_array_add (cmdA, g_strdup ("-dNOPAUSE"));
+
+  /* If no additional options specified, use at least -dSAFER */
+  if (g_getenv ("GS_OPTIONS") == NULL)
+    g_ptr_array_add (cmdA, g_strdup ("-dSAFER"));
+
+  /* Output file name */
+  g_ptr_array_add (cmdA, g_strdup_printf ("-sOutputFile=%s", *tmp_filename));
+
+  /* Offset command for gs to get image part with negative x/y-coord. */
+  if ((offx != 0) || (offy != 0))
+    {
+      g_ptr_array_add (cmdA, g_strdup ("-c"));
+      g_ptr_array_add (cmdA, g_strdup_printf ("%d", offx));
+      g_ptr_array_add (cmdA, g_strdup_printf ("%d", offy));
+      g_ptr_array_add (cmdA, g_strdup ("translate"));
+    }
+
+  /* input file name */
+  g_ptr_array_add (cmdA, g_strdup ("-f"));
+  g_ptr_array_add (cmdA, g_strdup (filename));
+
+  if (*is_epsf)
+    {
+      g_ptr_array_add (cmdA, g_strdup ("-c"));
+      g_ptr_array_add (cmdA, g_strdup ("showpage"));
+    }
+
+  g_ptr_array_add (cmdA, g_strdup ("-c"));
+  g_ptr_array_add (cmdA, g_strdup ("quit"));
+  g_ptr_array_add (cmdA, NULL);
+
+  pcmdA = (gchar **) cmdA->pdata;
+
+#ifdef PS_DEBUG
+  {
+    gchar **p = pcmdA;
+    g_print ("Passing args (argc=%d):\n", cmdA->len - 1);
+
+    while (*p)
+      {
+        g_print ("%s\n", *p);
+        p++;
+      }
+  }
+#endif
+
+  code = gsapi_new_instance (&instance, NULL);
+  if (code == 0) {
+    code = gsapi_set_arg_encoding(instance, GS_ARG_ENCODING_UTF8);
+    code = gsapi_init_with_args (instance, cmdA->len - 1, pcmdA);
+    code = gsapi_exit (instance);
+    gsapi_delete_instance (instance);
+  }
+
+  /* Don't care about exit status of ghostscript. */
+  /* Just try to read what it wrote. */
+
+  fd_popen = g_fopen (*tmp_filename, "rb");
+
+  g_ptr_array_free (cmdA, FALSE);
+  g_strfreev (pcmdA);
+
+  return fd_popen;
+}
+
+
+/* Close the PNM-File of the PostScript interpreter */
+static void
+ps_close (FILE *ifp, gchar *tmp_filename)
+{
+ /* If a real outputfile was used, close the file and remove it. */
+  fclose (ifp);
+  g_unlink (tmp_filename);
+}
+
+
+/* Read the header of a raw PNM-file and return type (4-6) or -1 on failure */
+static gint
+read_pnmraw_type (FILE *ifp,
+                  gint *width,
+                  gint *height,
+                  gint *maxval)
+{
+  int frst, scnd, thrd;
+  gint  pnmtype;
+  gchar line[1024];
+
+  /* GhostScript may write some informational messages infront of the header. */
+  /* We are just looking at a Px\n in the input stream. */
+  frst = getc (ifp);
+  scnd = getc (ifp);
+  thrd = getc (ifp);
+  for (;;)
+    {
+      if (thrd == EOF) return -1;
+#ifdef G_OS_WIN32
+      if (thrd == '\r') thrd = getc (ifp);
+#endif
+      if ((thrd == '\n') && (frst == 'P') && (scnd >= '1') && (scnd <= '6'))
+        break;
+      frst = scnd;
+      scnd = thrd;
+      thrd = getc (ifp);
+    }
+  pnmtype = scnd - '0';
+  /* We don't use the ASCII-versions */
+  if ((pnmtype >= 1) && (pnmtype <= 3))
+    return -1;
+
+  /* Read width/height */
+  for (;;)
+    {
+      if (fgets (line, sizeof (line)-1, ifp) == NULL)
+        return -1;
+      if (line[0] != '#')
+        break;
+    }
+  if (sscanf (line, "%d%d", width, height) != 2)
+    return -1;
+
+  *maxval = 255;
+
+  if (pnmtype != 4)  /* Read maxval */
+    {
+      for (;;)
+        {
+          if (fgets (line, sizeof (line)-1, ifp) == NULL)
+            return -1;
+          if (line[0] != '#')
+            break;
+        }
+      if (sscanf (line, "%d", maxval) != 1)
+        return -1;
+    }
+
+  return pnmtype;
+}
+
+
+/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
+static gint32
+create_new_image (const gchar        *filename,
+                  guint               pagenum,
+                  guint               width,
+                  guint               height,
+                  GimpImageBaseType   type,
+                  gint32             *layer_ID)
+{
+  gint32         image_ID;
+  GimpImageType  gdtype;
+  gchar         *tmp;
+
+  switch (type)
+    {
+    case GIMP_GRAY:
+      gdtype = GIMP_GRAY_IMAGE;
+      break;
+    case GIMP_INDEXED:
+      gdtype = GIMP_INDEXED_IMAGE;
+      break;
+    case GIMP_RGB:
+    default:
+      gdtype = GIMP_RGB_IMAGE;
+    }
+
+  image_ID = gimp_image_new_with_precision (width, height, type,
+                                            GIMP_PRECISION_U8_GAMMA);
+  gimp_image_undo_disable (image_ID);
+
+  tmp = g_strdup_printf ("%s-%d", filename, pagenum);
+  gimp_image_set_filename (image_ID, tmp);
+  g_free (tmp);
+
+  tmp = g_strdup_printf (_("Page %d"), pagenum);
+  *layer_ID = gimp_layer_new (image_ID, tmp, width, height,
+                              gdtype,
+                              100,
+                              gimp_image_get_default_new_layer_mode (image_ID));
+  g_free (tmp);
+
+  gimp_image_insert_layer (image_ID, *layer_ID, -1, 0);
+
+  return image_ID;
+}
+
+
+/* Skip PNM image generated from PostScript file. */
+/* Return TRUE on success, FALSE otherwise.       */
+static gboolean
+skip_ps (FILE *ifp)
+{
+  guchar  buf[8192];
+  gsize   len;
+  gint    pnmtype, width, height, maxval, bpl;
+
+  pnmtype = read_pnmraw_type (ifp, &width, &height, &maxval);
+
+  if (pnmtype == 4)    /* Portable bitmap */
+    bpl = (width + 7) / 8;
+  else if (pnmtype == 5)
+    bpl = width;
+  else if (pnmtype == 6)
+    bpl = width * 3;
+  else
+    return FALSE;
+
+  len = bpl * height;
+  while (len)
+    {
+      gsize  bytes = fread (buf, 1, MIN (len, sizeof (buf)), ifp);
+
+      if (bytes < MIN (len, sizeof (buf)))
+        return FALSE;
+
+      len -= bytes;
+    }
+
+  return TRUE;
+}
+
+
+/* Load PNM image generated from PostScript file */
+static gint32
+load_ps (const gchar *filename,
+         guint        pagenum,
+         FILE        *ifp,
+         gint         llx,
+         gint         lly,
+         gint         urx,
+         gint         ury)
+{
+  guchar *dest;
+  guchar *data, *bitline = NULL, *byteline = NULL, *byteptr, *temp;
+  guchar bit2byte[256*8];
+  int width, height, tile_height, scan_lines, total_scan_lines;
+  int image_width, image_height;
+  int skip_left, skip_bottom;
+  int i, j, pnmtype, maxval, bpp, nread;
+  GimpImageBaseType imagetype;
+  gint32 layer_ID, image_ID;
+  GeglBuffer *buffer = NULL;
+  int err = 0, e;
+
+  pnmtype = read_pnmraw_type (ifp, &width, &height, &maxval);
+
+  if ((width == urx+1) && (height == ury+1))  /* gs respected BoundingBox ? */
+    {
+      skip_left = llx;    skip_bottom = lly;
+      image_width = width - skip_left;
+      image_height = height - skip_bottom;
+    }
+  else
+    {
+      skip_left = skip_bottom = 0;
+      image_width = width;
+      image_height = height;
+    }
+  if (pnmtype == 4)   /* Portable Bitmap */
+    {
+      imagetype = GIMP_INDEXED;
+      nread = (width+7)/8;
+      bpp = 1;
+      bitline = g_new (guchar, nread);
+      byteline = g_new (guchar, nread * 8);
+
+      /* Get an array for mapping 8 bits in a byte to 8 bytes */
+      temp = bit2byte;
+      for (j = 0; j < 256; j++)
+        for (i = 7; i >= 0; i--)
+          *(temp++) = ((j & (1 << i)) != 0);
+    }
+  else if (pnmtype == 5)  /* Portable Greymap */
+    {
+      imagetype = GIMP_GRAY;
+      nread = width;
+      bpp = 1;
+      byteline = g_new (guchar, nread);
+    }
+  else if (pnmtype == 6)  /* Portable Pixmap */
+    {
+      imagetype = GIMP_RGB;
+      nread = width * 3;
+      bpp = 3;
+      byteline = g_new (guchar, nread);
+    }
+  else
+    return -1;
+
+  image_ID = create_new_image (filename, pagenum,
+                               image_width, image_height, imagetype,
+                               &layer_ID);
+  buffer = gimp_drawable_get_buffer (layer_ID);
+
+  tile_height = gimp_tile_height ();
+  data = g_malloc (tile_height * image_width * bpp);
+
+  dest = data;
+  total_scan_lines = scan_lines = 0;
+
+  if (pnmtype == 4)   /* Read bitimage ? Must be mapped to indexed */
+    {
+      const guchar BWColorMap[2*3] = { 255, 255, 255, 0, 0, 0 };
+
+      gimp_image_set_colormap (image_ID, BWColorMap, 2);
+
+      for (i = 0; i < height; i++)
+        {
+          e = (fread (bitline, 1, nread, ifp) != nread);
+          if (total_scan_lines >= image_height)
+            continue;
+          err |= e;
+          if (err)
+            break;
+
+          j = width;   /* Map 1 byte of bitimage to 8 bytes of indexed image */
+          temp = bitline;
+          byteptr = byteline;
+          while (j >= 8)
+            {
+              memcpy (byteptr, bit2byte + *(temp++)*8, 8);
+              byteptr += 8;
+              j -= 8;
+            }
+          if (j > 0)
+            memcpy (byteptr, bit2byte + *temp*8, j);
+
+          memcpy (dest, byteline+skip_left, image_width);
+          dest += image_width;
+          scan_lines++;
+          total_scan_lines++;
+
+          if ((scan_lines == tile_height) || ((i + 1) == image_height))
+            {
+              gegl_buffer_set (buffer,
+                               GEGL_RECTANGLE (0, i-scan_lines+1,
+                                               image_width, scan_lines),
+                               0,
+                               NULL,
+                               data,
+                               GEGL_AUTO_ROWSTRIDE);
+              scan_lines = 0;
+              dest = data;
+            }
+
+          if ((i % 20) == 0)
+            gimp_progress_update ((gdouble) (i + 1) / (gdouble) image_height);
+
+          if (err)
+            break;
+        }
+    }
+  else   /* Read gray/rgb-image */
+    {
+      for (i = 0; i < height; i++)
+        {
+          e = (fread (byteline, bpp, width, ifp) != width);
+          if (total_scan_lines >= image_height)
+            continue;
+          err |= e;
+          if (err)
+            break;
+
+          memcpy (dest, byteline+skip_left*bpp, image_width*bpp);
+          dest += image_width*bpp;
+          scan_lines++;
+          total_scan_lines++;
+
+          if ((scan_lines == tile_height) || ((i + 1) == image_height))
+            {
+              gegl_buffer_set (buffer,
+                               GEGL_RECTANGLE (0, i-scan_lines+1,
+                                               image_width, scan_lines),
+                               0,
+                               NULL,
+                               data,
+                               GEGL_AUTO_ROWSTRIDE);
+              scan_lines = 0;
+              dest = data;
+            }
+
+          if ((i % 20) == 0)
+            gimp_progress_update ((gdouble) (i + 1) / (gdouble) image_height);
+
+          if (err)
+            break;
+        }
+    }
+  gimp_progress_update (1.0);
+
+  g_free (data);
+  g_free (byteline);
+  g_free (bitline);
+
+  if (err)
+    g_message ("EOF encountered on reading");
+
+  g_object_unref (buffer);
+
+  return (err ? -1 : image_ID);
+}
+
+
+/* Write out the PostScript file header */
+static gboolean
+save_ps_header (GOutputStream  *output,
+                GFile          *file,
+                GError        **error)
+{
+  gchar  *basename = g_path_get_basename (gimp_file_get_utf8_name (file));
+  time_t  cutime   = time (NULL);
+
+  if (! print (output, error,
+               "%%!PS-Adobe-3.0%s\n", psvals.eps ? " EPSF-3.0" : ""))
+    goto fail;
+
+  if (! print (output, error,
+               "%%%%Creator: GIMP PostScript file plug-in V %4.2f "
+               "by Peter Kirchgessner\n", VERSIO))
+    goto fail;
+
+  if (! print (output, error,
+               "%%%%Title: %s\n"
+               "%%%%CreationDate: %s"
+               "%%%%DocumentData: Clean7Bit\n",
+               basename, ctime (&cutime)))
+    goto fail;
+
+  if (psvals.eps || (psvals.level > 1))
+    if (! print (output, error,"%%%%LanguageLevel: 2\n"))
+      goto fail;
+
+  if (! print (output, error, "%%%%Pages: 1\n"))
+    goto fail;
+
+  g_free (basename);
+
+  return TRUE;
+
+ fail:
+
+  g_free (basename);
+
+  return FALSE;
+}
+
+
+/* Write out transformation for image */
+static gboolean
+save_ps_setup (GOutputStream  *output,
+               gint32          drawable_ID,
+               gint            width,
+               gint            height,
+               gint            bpp,
+               GError        **error)
+{
+  gdouble x_offset, y_offset, x_size, y_size;
+  gdouble urx, ury;
+  gdouble width_inch, height_inch;
+  gdouble f1, f2, dx, dy;
+  gint    xtrans, ytrans;
+  gint    i_urx, i_ury;
+  gchar   tmpbuf1[G_ASCII_DTOSTR_BUF_SIZE];
+  gchar   tmpbuf2[G_ASCII_DTOSTR_BUF_SIZE];
+
+  /* initialize */
+
+  dx = 0.0;
+  dy = 0.0;
+
+  x_offset    = psvals.x_offset;
+  y_offset    = psvals.y_offset;
+  width_inch  = fabs (psvals.width);
+  height_inch = fabs (psvals.height);
+
+  if (psvals.unit_mm)
+    {
+      x_offset /= 25.4; y_offset /= 25.4;
+      width_inch /= 25.4; height_inch /= 25.4;
+    }
+
+  if (psvals.keep_ratio)   /* Proportions to keep ? */
+    {                        /* Fit the image into the allowed size */
+      f1 = width_inch / width;
+      f2 = height_inch / height;
+      if (f1 < f2)
+        height_inch = width_inch * (gdouble) height / (gdouble) width;
+      else
+        width_inch = fabs (height_inch) * (gdouble) width / (gdouble) height;
+    }
+
+  if ((psvals.rotate == 0) || (psvals.rotate == 180))
+    {
+      x_size = width_inch;
+      y_size = height_inch;
+    }
+  else
+    {
+      y_size = width_inch;
+      x_size = height_inch;
+    }
+
+  /* Round up upper right corner only for non-integer values */
+  urx = (x_offset + x_size) * 72.0;
+  ury = (y_offset + y_size) * 72.0;
+  i_urx = (gint) urx;
+  i_ury = (gint) ury;
+  if (urx != (gdouble) i_urx) i_urx++;  /* Check for non-integer value */
+  if (ury != (gdouble) i_ury) i_ury++;
+
+  if (! print (output, error,
+               "%%%%BoundingBox: %d %d %d %d\n"
+               "%%%%EndComments\n",
+               (gint) (x_offset * 72.0), (gint) (y_offset * 72.0), i_urx, i_ury))
+    return FALSE;
+
+  if (psvals.preview && (psvals.preview_size > 0))
+    {
+      if (! save_ps_preview (output, drawable_ID, error))
+        return FALSE;
+    }
+
+  if (! print (output, error,
+               "%%%%BeginProlog\n"
+               "%% Use own dictionary to avoid conflicts\n"
+               "10 dict begin\n"
+               "%%%%EndProlog\n"
+               "%%%%Page: 1 1\n"
+               "%% Translate for offset\n"
+               "%s %s translate\n",
+               g_ascii_dtostr (tmpbuf1, sizeof (tmpbuf1), x_offset * 72.0),
+               g_ascii_dtostr (tmpbuf2, sizeof (tmpbuf2), y_offset * 72.0)))
+    return FALSE;
+
+  /* Calculate translation to startpoint of first scanline */
+  switch (psvals.rotate)
+    {
+    case   0: dx = 0.0; dy = y_size * 72.0;
+      break;
+    case  90: dx = dy = 0.0;
+      break;
+    case 180: dx = x_size * 72.0; dy = 0.0;
+      break;
+    case 270: dx = x_size * 72.0; dy = y_size * 72.0;
+      break;
+    }
+
+  if ((dx != 0.0) || (dy != 0.0))
+    {
+      if (! print (output, error,
+                   "%% Translate to begin of first scanline\n"
+                   "%s %s translate\n",
+                   g_ascii_dtostr (tmpbuf1, sizeof (tmpbuf1), dx),
+                   g_ascii_dtostr (tmpbuf2, sizeof (tmpbuf2), dy)))
+        return FALSE;
+    }
+
+  if (psvals.rotate)
+    if (! print (output, error, "%d rotate\n", (gint) psvals.rotate))
+      return FALSE;
+
+  if (! print (output, error,
+               "%s %s scale\n",
+               g_ascii_dtostr (tmpbuf1, sizeof (tmpbuf1),  72.0 * width_inch),
+               g_ascii_dtostr (tmpbuf2, sizeof (tmpbuf2), -72.0 * height_inch)))
+    return FALSE;
+
+  /* Write the PostScript procedures to read the image */
+  if (psvals.level <= 1)
+    {
+      if (! print (output, error,
+                   "%% Variable to keep one line of raster data\n"))
+        return FALSE;
+
+      if (bpp == 1)
+        {
+          if (! print (output, error,
+                       "/scanline %d string def\n", (width + 7) / 8))
+            return FALSE;
+        }
+      else
+        {
+          if (! print (output, error,
+                       "/scanline %d %d mul string def\n", width, bpp / 8))
+            return FALSE;
+        }
+    }
+
+  if (! print (output, error,
+               "%% Image geometry\n%d %d %d\n"
+               "%% Transformation matrix\n",
+               width, height, (bpp == 1) ? 1 : 8))
+    return FALSE;
+
+  xtrans = ytrans = 0;
+  if (psvals.width  < 0.0) { width  = -width;  xtrans = -width;  }
+  if (psvals.height < 0.0) { height = -height; ytrans = -height; }
+
+  if (! print (output, error,
+               "[ %d 0 0 %d %d %d ]\n", width, height, xtrans, ytrans))
+    return FALSE;
+
+  return TRUE;
+}
+
+static gboolean
+save_ps_trailer (GOutputStream  *output,
+                 GError        **error)
+{
+  return print (output, error,
+                "%%%%Trailer\n"
+                "end\n%%%%EOF\n");
+}
+
+/* Do a Floyd-Steinberg dithering on a grayscale scanline. */
+/* linecount must keep the counter for the actual scanline (0, 1, 2, ...). */
+/* If linecount is less than zero, all used memory is freed. */
+
+static void
+dither_grey (const guchar *grey,
+             guchar       *bw,
+             gint          npix,
+             gint          linecount)
+{
+  static gboolean  do_init_arrays = TRUE;
+  static gint     *fs_error = NULL;
+  static gint      limit[1278];
+  static gint      east_error[256];
+  static gint      seast_error[256];
+  static gint      south_error[256];
+  static gint      swest_error[256];
+
+  const guchar *greyptr;
+  guchar       *bwptr, mask;
+  gint         *fse;
+  gint          x, greyval, fse_inline;
+
+  if (linecount <= 0)
+    {
+      g_free (fs_error);
+
+      if (linecount < 0)
+        return;
+
+      fs_error = g_new0 (gint, npix + 2);
+
+      /* Initialize some arrays that speed up dithering */
+      if (do_init_arrays)
+        {
+          gint i;
+
+          do_init_arrays = FALSE;
+
+          for (i = 0, x = -511; x <= 766; i++, x++)
+            limit[i] = (x < 0) ? 0 : ((x > 255) ? 255 : x);
+
+          for (greyval = 0; greyval < 256; greyval++)
+            {
+              east_error[greyval] = (greyval < 128) ?
+                ((greyval * 79) >> 8) : (((greyval - 255) * 79) >> 8);
+              seast_error[greyval] = (greyval < 128) ?
+                ((greyval * 34) >> 8) : (((greyval - 255) * 34) >> 8);
+              south_error[greyval] = (greyval < 128) ?
+                ((greyval * 56) >> 8) : (((greyval - 255) * 56) >> 8);
+              swest_error[greyval] = (greyval < 128) ?
+                ((greyval * 12) >> 8) : (((greyval - 255) * 12) >> 8);
+            }
+        }
+    }
+
+  g_return_if_fail (fs_error != NULL);
+
+  memset (bw, 0, (npix + 7) / 8); /* Initialize with white */
+
+  greyptr = grey;
+  bwptr = bw;
+  mask = 0x80;
+
+  fse_inline = fs_error[1];
+
+  for (x = 0, fse = fs_error + 1; x < npix; x++, fse++)
+    {
+      greyval =
+        limit[*(greyptr++) + fse_inline + 512];  /* 0 <= greyval <= 255 */
+
+      if (greyval < 128)
+        *bwptr |= mask;  /* Set a black pixel */
+
+      /* Error distribution */
+      fse_inline = east_error[greyval] + fse[1];
+      fse[1] = seast_error[greyval];
+      fse[0] += south_error[greyval];
+      fse[-1] += swest_error[greyval];
+
+      mask >>= 1;   /* Get mask for next b/w-pixel */
+
+      if (!mask)
+        {
+          mask = 0x80;
+          bwptr++;
+        }
+    }
+}
+
+/* Write a device independent screen preview */
+static gboolean
+save_ps_preview (GOutputStream  *output,
+                 gint32          drawable_ID,
+                 GError        **error)
+{
+  GimpImageType  drawable_type;
+  GeglBuffer    *buffer = NULL;
+  const Babl    *format;
+  gint           bpp;
+  guchar        *bwptr, *greyptr;
+  gint           width, height, x, y, nbsl, out_count;
+  gint           nchar_pl = 72, src_y;
+  gdouble        f1, f2;
+  guchar        *grey, *bw, *src_row, *src_ptr;
+  guchar        *cmap;
+  gint           ncols, cind;
+
+  if (psvals.preview_size <= 0)
+    return TRUE;
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+  cmap = NULL;
+
+  drawable_type = gimp_drawable_type (drawable_ID);
+  switch (drawable_type)
+    {
+    case GIMP_GRAY_IMAGE:
+      format = babl_format ("Y' u8");
+      break;
+
+    case GIMP_INDEXED_IMAGE:
+      cmap = gimp_image_get_colormap (gimp_item_get_image (drawable_ID),
+                                      &ncols);
+      format = gimp_drawable_get_format (drawable_ID);
+      break;
+
+    case GIMP_RGB_IMAGE:
+    default:
+      format = babl_format ("R'G'B' u8");
+      break;
+    }
+
+  bpp = babl_format_get_bytes_per_pixel (format);
+
+  width = gegl_buffer_get_width (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  /* Calculate size of preview */
+  if ((width > psvals.preview_size) ||
+      (height > psvals.preview_size))
+    {
+      f1 = (gdouble) psvals.preview_size / (gdouble) width;
+      f2 = (gdouble) psvals.preview_size / (gdouble) height;
+
+      if (f1 < f2)
+        {
+          width = psvals.preview_size;
+          height *= f1;
+          if (height <= 0)
+            height = 1;
+        }
+      else
+        {
+          height = psvals.preview_size;
+          width *= f1;
+          if (width <= 0)
+            width = 1;
+        }
+    }
+
+  nbsl = (width + 7) / 8;  /* Number of bytes per scanline in bitmap */
+
+  grey    = g_new (guchar, width);
+  bw      = g_new (guchar, nbsl);
+  src_row = g_new (guchar, gegl_buffer_get_width (buffer) * bpp);
+
+  if (! print (output, error,
+               "%%%%BeginPreview: %d %d 1 %d\n",
+               width, height,
+               ((nbsl * 2 + nchar_pl - 1) / nchar_pl) * height))
+    goto fail;
+
+  for (y = 0; y < height; y++)
+    {
+      /* Get a scanline from the input image and scale it to the desired
+         width */
+      src_y = (y * gegl_buffer_get_height (buffer)) / height;
+      gegl_buffer_get (buffer,
+                       GEGL_RECTANGLE (0, src_y,
+                                       gegl_buffer_get_width (buffer), 1),
+                       1.0, format, src_row,
+                       GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+      greyptr = grey;
+      if (bpp == 3)   /* RGB-image */
+        {
+          for (x = 0; x < width; x++)
+            {                       /* Convert to grey */
+              src_ptr = src_row + ((x * gegl_buffer_get_width (buffer)) / width) * 3;
+              *(greyptr++) = (3*src_ptr[0] + 6*src_ptr[1] + src_ptr[2]) / 10;
+            }
+        }
+      else if (cmap)    /* Indexed image */
+        {
+          for (x = 0; x < width; x++)
+            {
+              src_ptr = src_row + ((x * gegl_buffer_get_width (buffer)) / width);
+              cind = *src_ptr;   /* Get color index and convert to grey */
+              src_ptr = (cind >= ncols) ? cmap : (cmap + 3*cind);
+              *(greyptr++) = (3*src_ptr[0] + 6*src_ptr[1] + src_ptr[2]) / 10;
+            }
+        }
+      else             /* Grey image */
+        {
+          for (x = 0; x < width; x++)
+            *(greyptr++) = *(src_row + ((x * gegl_buffer_get_width (buffer)) / width));
+        }
+
+      /* Now we have a grayscale line for the desired width. */
+      /* Dither it to b/w */
+      dither_grey (grey, bw, width, y);
+
+      /* Write out the b/w line */
+      out_count = 0;
+      bwptr = bw;
+      for (x = 0; x < nbsl; x++)
+        {
+          if (out_count == 0)
+            if (! print (output, error, "%% "))
+              goto fail;
+
+          if (! print (output, error, "%02x", *(bwptr++)))
+            goto fail;
+
+          out_count += 2;
+          if (out_count >= nchar_pl)
+            {
+              if (! print (output, error, "\n"))
+                goto fail;
+
+              out_count = 0;
+            }
+        }
+
+      if (! print (output, error, "\n"))
+        goto fail;
+
+      if ((y % 20) == 0)
+        gimp_progress_update ((gdouble) y / (gdouble) height);
+    }
+
+  gimp_progress_update (1.0);
+
+  if (! print (output, error, "%%%%EndPreview\n"))
+    goto fail;
+
+  dither_grey (grey, bw, width, -1);
+  g_free (src_row);
+  g_free (bw);
+  g_free (grey);
+
+  g_object_unref (buffer);
+
+  return TRUE;
+
+ fail:
+
+  g_free (src_row);
+  g_free (bw);
+  g_free (grey);
+
+  g_object_unref (buffer);
+
+  return FALSE;
+}
+
+static gboolean
+save_gray (GOutputStream  *output,
+           gint32          image_ID,
+           gint32          drawable_ID,
+           GError        **error)
+{
+  GeglBuffer *buffer = NULL;
+  const Babl *format;
+  gint        bpp;
+  gint        height, width, i, j;
+  gint        tile_height;
+  guchar     *data;
+  guchar     *src;
+  guchar     *packb = NULL;
+  gboolean    level2 = (psvals.level > 1);
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+  format = babl_format ("Y' u8");
+  bpp    = babl_format_get_bytes_per_pixel (format);
+  width  = gegl_buffer_get_width (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  tile_height = gimp_tile_height ();
+
+  /* allocate a buffer for retrieving information from the pixel region  */
+  src = data = (guchar *) g_malloc (tile_height * width * bpp);
+
+  /* Set up transformation in PostScript */
+  if (! save_ps_setup (output, drawable_ID, width, height, 1 * 8, error))
+    goto fail;
+
+  /* Write read image procedure */
+  if (! level2)
+    {
+      if (! print (output, error,
+                   "{ currentfile scanline readhexstring pop }\n"))
+        goto fail;
+    }
+  else
+    {
+      if (! print (output, error,
+                   "currentfile /ASCII85Decode filter /RunLengthDecode filter\n"))
+        goto fail;
+
+      ascii85_init ();
+
+      /* Allocate buffer for packbits data. Worst case: Less than 1% increase */
+      packb = (guchar *) g_malloc ((width * 105) / 100 + 2);
+    }
+
+  if (! ps_begin_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "image\n"))
+    goto fail;
+
+#define GET_GRAY_TILE(begin) \
+  { gint scan_lines;                                                    \
+    scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); \
+    gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scan_lines),  \
+                     1.0, format, begin,                                \
+                     GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);             \
+    src = begin; }
+
+  for (i = 0; i < height; i++)
+    {
+      if ((i % tile_height) == 0)
+        GET_GRAY_TILE (data); /* Get more data */
+
+      if (! level2)
+        {
+          for (j = 0; j < width; j++)
+            {
+              if (! print (output, error, "%c", hex[(*src) >> 4]))
+                goto fail;
+
+              if (! print (output, error, "%c", hex[(*(src++)) & 0x0f]))
+                goto fail;
+
+              if (((j + 1) % 39) == 0)
+                if (! print (output, error, "\n"))
+                  goto fail;
+           }
+
+          if (! print (output, error, "\n"))
+            goto fail;
+        }
+      else
+        {
+          gint nout;
+
+          compress_packbits (width, src, &nout, packb);
+
+          if (! ascii85_nout (output, nout, packb, error))
+            goto fail;
+
+          src += width;
+        }
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((gdouble) i / (gdouble) height);
+    }
+
+  gimp_progress_update (1.0);
+
+  if (level2)
+    {
+      /* Write EOD of RunLengthDecode filter */
+      if (! ascii85_out (output, 128, error))
+        goto fail;
+
+      if (! ascii85_done (output, error))
+        goto fail;
+    }
+
+  if (! ps_end_data (output, error))
+    return FALSE;
+
+  if (! print (output, error, "showpage\n"))
+    goto fail;
+
+  g_free (data);
+  g_free (packb);
+
+  g_object_unref (buffer);
+
+  return TRUE;
+
+ fail:
+
+  g_free (data);
+  g_free (packb);
+
+  g_object_unref (buffer);
+
+  return FALSE;
+
+#undef GET_GRAY_TILE
+}
+
+static gboolean
+save_bw (GOutputStream  *output,
+         gint32          image_ID,
+         gint32          drawable_ID,
+         GError        **error)
+{
+  GeglBuffer *buffer = NULL;
+  const Babl *format;
+  gint        bpp;
+  gint        height, width, i, j;
+  gint        ncols, nbsl, nwrite;
+  gint        tile_height;
+  guchar     *cmap, *ct;
+  guchar     *data, *src;
+  guchar     *packb = NULL;
+  guchar     *scanline, *dst, mask;
+  guchar     *hex_scanline;
+  gboolean    level2 = (psvals.level > 1);
+
+  cmap = gimp_image_get_colormap (image_ID, &ncols);
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+  format = gimp_drawable_get_format (drawable_ID);
+  bpp    = babl_format_get_bytes_per_pixel (format);
+  width  = gegl_buffer_get_width (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  tile_height = gimp_tile_height ();
+
+  /* allocate a buffer for retrieving information from the pixel region  */
+  src = data = g_new (guchar, tile_height * width * bpp);
+
+  nbsl = (width + 7) / 8;
+
+  scanline     = g_new (guchar, nbsl + 1);
+  hex_scanline = g_new (guchar, (nbsl + 1) * 2);
+
+  /* Set up transformation in PostScript */
+  if (! save_ps_setup (output, drawable_ID, width, height, 1, error))
+    goto fail;
+
+  /* Write read image procedure */
+  if (! level2)
+    {
+      if (! print (output, error,
+                   "{ currentfile scanline readhexstring pop }\n"))
+        goto fail;
+    }
+  else
+    {
+      if (! print (output, error,
+                   "currentfile /ASCII85Decode filter /RunLengthDecode filter\n"))
+        goto fail;
+
+      ascii85_init ();
+
+      /* Allocate buffer for packbits data. Worst case: Less than 1% increase */
+      packb = g_new (guchar, ((nbsl+1) * 105) / 100 + 2);
+    }
+
+  if (! ps_begin_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "image\n"))
+    goto fail;
+
+#define GET_BW_TILE(begin) \
+  { gint scan_lines;                                                    \
+    scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); \
+    gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scan_lines),  \
+                     1.0, format, begin,                                \
+                     GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);             \
+    src = begin; }
+
+  for (i = 0; i < height; i++)
+    {
+      if ((i % tile_height) == 0)
+        GET_BW_TILE (data); /* Get more data */
+
+      dst = scanline;
+      memset (dst, 0, nbsl);
+      mask = 0x80;
+
+      /* Build a bitmap for a scanline */
+      for (j = 0; j < width; j++)
+        {
+          ct = cmap + *(src++)*3;
+          if (ct[0] || ct[1] || ct[2])
+            *dst |= mask;
+
+          if (mask == 0x01)
+            {
+              mask = 0x80; dst++;
+            }
+          else
+            {
+              mask >>= 1;
+            }
+        }
+
+      if (! level2)
+        {
+          /* Convert to hexstring */
+          for (j = 0; j < nbsl; j++)
+            {
+              hex_scanline[j * 2]     = (guchar) hex[scanline[j] >> 4];
+              hex_scanline[j * 2 + 1] = (guchar) hex[scanline[j] & 0x0f];
+            }
+
+          /* Write out hexstring */
+          j = nbsl * 2;
+          dst = hex_scanline;
+
+          while (j > 0)
+            {
+              nwrite = (j > 78) ? 78 : j;
+
+              if (! g_output_stream_write_all (output,
+                                               dst, nwrite, NULL,
+                                               NULL, error))
+                goto fail;
+
+              if (! print (output, error, "\n"))
+                goto fail;
+
+              j -= nwrite;
+              dst += nwrite;
+            }
+        }
+      else
+        {
+          gint nout;
+
+          compress_packbits (nbsl, scanline, &nout, packb);
+
+          if (! ascii85_nout (output, nout, packb, error))
+            goto fail;
+        }
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((gdouble) i / (gdouble) height);
+    }
+
+  gimp_progress_update (1.0);
+
+  if (level2)
+    {
+      /* Write EOD of RunLengthDecode filter */
+      if (! ascii85_out (output, 128, error))
+        goto fail;
+
+      if (! ascii85_done (output, error))
+        goto fail;
+    }
+
+  if (! ps_end_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "showpage\n"))
+    goto fail;
+
+  g_free (hex_scanline);
+  g_free (scanline);
+  g_free (data);
+  g_free (packb);
+
+  g_object_unref (buffer);
+
+  return TRUE;
+
+ fail:
+
+  g_free (hex_scanline);
+  g_free (scanline);
+  g_free (data);
+  g_free (packb);
+
+  g_object_unref (buffer);
+
+  return FALSE;
+
+#undef GET_BW_TILE
+}
+
+static gboolean
+save_index (GOutputStream  *output,
+            gint32          image_ID,
+            gint32          drawable_ID,
+            GError        **error)
+{
+  GeglBuffer *buffer = NULL;
+  const Babl *format;
+  gint        bpp;
+  gint        height, width, i, j;
+  gint        ncols, bw;
+  gint        tile_height;
+  guchar     *cmap, *cmap_start;
+  guchar     *data, *src;
+  guchar     *packb = NULL;
+  guchar     *plane = NULL;
+  gchar       coltab[256 * 6], *ct;
+  gboolean    level2 = (psvals.level > 1);
+
+  cmap = cmap_start = gimp_image_get_colormap (image_ID, &ncols);
+
+  ct = coltab;
+  bw = 1;
+  for (j = 0; j < 256; j++)
+    {
+      if (j >= ncols)
+        {
+          memset (ct, 0, 6);
+          ct += 6;
+        }
+      else
+        {
+          bw &= ((cmap[0] == 0)   && (cmap[1] == 0)   && (cmap[2] == 0)) ||
+                ((cmap[0] == 255) && (cmap[1] == 255) && (cmap[2] == 255));
+
+          *(ct++) = (guchar) hex[(*cmap) >> 4];
+          *(ct++) = (guchar) hex[(*(cmap++)) & 0x0f];
+          *(ct++) = (guchar) hex[(*cmap) >> 4];
+          *(ct++) = (guchar) hex[(*(cmap++)) & 0x0f];
+          *(ct++) = (guchar) hex[(*cmap) >> 4];
+          *(ct++) = (guchar) hex[(*(cmap++)) & 0x0f];
+        }
+    }
+
+  if (bw)
+    return save_bw (output, image_ID, drawable_ID, error);
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+  format = gimp_drawable_get_format (drawable_ID);
+  bpp    = babl_format_get_bytes_per_pixel (format);
+  width  = gegl_buffer_get_width (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  tile_height = gimp_tile_height ();
+
+  /* allocate a buffer for retrieving information from the pixel region  */
+  src = data = (guchar *) g_malloc (tile_height * width * bpp);
+
+  /* Set up transformation in PostScript */
+  if (! save_ps_setup (output, drawable_ID, width, height, 3 * 8, error))
+    goto fail;
+
+  /* Write read image procedure */
+  if (! level2)
+    {
+      if (! print (output, error,
+                   "{ currentfile scanline readhexstring pop } false 3\n"))
+        goto fail;
+    }
+  else
+    {
+      if (! print (output, error,
+                   "%% Strings to hold RGB-samples per scanline\n"
+                   "/rstr %d string def\n"
+                   "/gstr %d string def\n"
+                   "/bstr %d string def\n",
+                   width, width, width))
+        goto fail;
+
+      if (! print (output, error,
+                   "{currentfile /ASCII85Decode filter /RunLengthDecode filter\
+ rstr readstring pop}\n"
+                   "{currentfile /ASCII85Decode filter /RunLengthDecode filter\
+ gstr readstring pop}\n"
+                   "{currentfile /ASCII85Decode filter /RunLengthDecode filter\
+ bstr readstring pop}\n"
+                   "true 3\n"))
+        goto fail;
+
+      /* Allocate buffer for packbits data. Worst case: Less than 1% increase */
+      packb = (guchar *) g_malloc ((width * 105) / 100 + 2);
+      plane = (guchar *) g_malloc (width);
+    }
+
+  if (! ps_begin_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "colorimage\n"))
+    goto fail;
+
+#define GET_INDEX_TILE(begin) \
+  { gint scan_lines;                                                    \
+    scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); \
+    gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scan_lines),  \
+                     1.0, format, begin,                                \
+                     GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);             \
+    src = begin; }
+
+  for (i = 0; i < height; i++)
+    {
+      if ((i % tile_height) == 0)
+        GET_INDEX_TILE (data); /* Get more data */
+
+      if (! level2)
+        {
+          for (j = 0; j < width; j++)
+            {
+              if (! g_output_stream_write_all (output,
+                                               coltab + (*(src++)) * 6, 6, NULL,
+                                               NULL, error))
+                goto fail;
+
+              if (((j + 1) % 13) == 0)
+                if (! print (output, error, "\n"))
+                  goto fail;
+            }
+
+          if (! print (output, error, "\n"))
+            goto fail;
+        }
+      else
+        {
+          gint rgb;
+
+          for (rgb = 0; rgb < 3; rgb++)
+            {
+              guchar *src_ptr   = src;
+              guchar *plane_ptr = plane;
+              gint    nout;
+
+              for (j = 0; j < width; j++)
+                *(plane_ptr++) = cmap_start[3 * *(src_ptr++) + rgb];
+
+              compress_packbits (width, plane, &nout, packb);
+
+              ascii85_init ();
+
+              if (! ascii85_nout (output, nout, packb, error))
+                goto fail;
+
+              /* Write EOD of RunLengthDecode filter */
+              if (! ascii85_out (output, 128, error))
+                goto fail;
+
+              if (! ascii85_done (output, error))
+                goto fail;
+            }
+
+          src += width;
+        }
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((gdouble) i / (gdouble) height);
+    }
+
+  gimp_progress_update (1.0);
+
+  if (! ps_end_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "showpage\n"))
+    goto fail;
+
+  g_free (data);
+  g_free (packb);
+  g_free (plane);
+
+  g_object_unref (buffer);
+
+  return TRUE;
+
+ fail:
+
+  g_free (data);
+  g_free (packb);
+  g_free (plane);
+
+  g_object_unref (buffer);
+
+  return FALSE;
+
+#undef GET_INDEX_TILE
+}
+
+static gboolean
+save_rgb (GOutputStream  *output,
+          gint32          image_ID,
+          gint32          drawable_ID,
+          GError        **error)
+{
+  GeglBuffer *buffer = NULL;
+  const Babl *format;
+  gint        bpp;
+  gint        height, width, tile_height;
+  gint        i, j;
+  guchar     *data, *src;
+  guchar     *packb = NULL;
+  guchar     *plane = NULL;
+  gboolean    level2 = (psvals.level > 1);
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+  format = babl_format ("R'G'B' u8");
+  bpp    = babl_format_get_bytes_per_pixel (format);
+  width  = gegl_buffer_get_width (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  tile_height = gimp_tile_height ();
+
+  /* allocate a buffer for retrieving information from the pixel region  */
+  src = data = g_new (guchar, tile_height * width * bpp);
+
+  /* Set up transformation in PostScript */
+  if (! save_ps_setup (output, drawable_ID, width, height, 3 * 8, error))
+    goto fail;
+
+  /* Write read image procedure */
+  if (! level2)
+    {
+      if (! print (output, error,
+                   "{ currentfile scanline readhexstring pop } false 3\n"))
+        goto fail;
+    }
+  else
+    {
+      if (! print (output, error,
+                   "%% Strings to hold RGB-samples per scanline\n"
+                   "/rstr %d string def\n"
+                   "/gstr %d string def\n"
+                   "/bstr %d string def\n",
+                   width, width, width))
+        goto fail;
+
+      if (! print (output, error,
+                   "{currentfile /ASCII85Decode filter /RunLengthDecode filter\
+ rstr readstring pop}\n"
+                   "{currentfile /ASCII85Decode filter /RunLengthDecode filter\
+ gstr readstring pop}\n"
+                   "{currentfile /ASCII85Decode filter /RunLengthDecode filter\
+ bstr readstring pop}\n"
+                   "true 3\n"))
+        goto fail;
+
+      /* Allocate buffer for packbits data. Worst case: Less than 1% increase */
+      packb = g_new (guchar, (width * 105) / 100 + 2);
+      plane = g_new (guchar, width);
+    }
+
+  if (! ps_begin_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "colorimage\n"))
+    goto fail;
+
+#define GET_RGB_TILE(begin) \
+  { gint scan_lines;                                                    \
+    scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); \
+    gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scan_lines),  \
+                     1.0, format, begin,                                \
+                     GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);             \
+    src = begin; }
+
+  for (i = 0; i < height; i++)
+    {
+      if ((i % tile_height) == 0)
+        GET_RGB_TILE (data); /* Get more data */
+
+      if (! level2)
+        {
+          for (j = 0; j < width; j++)
+            {
+              if (! print (output, error, "%c",
+                           hex[(*src) >> 4]))        /* Red */
+                goto fail;
+
+              if (! print (output, error, "%c",
+                           hex[(*(src++)) & 0x0f]))
+                goto fail;
+
+              if (! print (output, error, "%c",
+                           hex[(*src) >> 4]))        /* Green */
+                goto fail;
+
+              if (! print (output, error, "%c",
+                           hex[(*(src++)) & 0x0f]))
+                goto fail;
+
+              if (! print (output, error, "%c",
+                           hex[(*src) >> 4]))        /* Blue */
+                goto fail;
+
+              if (! print (output, error, "%c",
+                           hex[(*(src++)) & 0x0f]))
+                goto fail;
+
+              if (((j+1) % 13) == 0)
+                if (! print (output, error, "\n"))
+                  goto fail;
+            }
+
+          if (! print (output, error, "\n"))
+            goto fail;
+        }
+      else
+        {
+          gint rgb;
+
+          for (rgb = 0; rgb < 3; rgb++)
+            {
+              guchar *src_ptr   = src + rgb;
+              guchar *plane_ptr = plane;
+              gint    nout;
+
+              for (j = 0; j < width; j++)
+                {
+                  *(plane_ptr++) = *src_ptr;
+                  src_ptr += 3;
+                }
+
+              compress_packbits (width, plane, &nout, packb);
+
+              ascii85_init ();
+
+              if (! ascii85_nout (output, nout, packb, error))
+                goto fail;
+
+              /* Write EOD of RunLengthDecode filter */
+              if (! ascii85_out (output, 128, error))
+                goto fail;
+
+              if (! ascii85_done (output, error))
+                goto fail;
+            }
+
+          src += 3 * width;
+        }
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((gdouble) i / (gdouble) height);
+    }
+
+  gimp_progress_update (1.0);
+
+  if (! ps_end_data (output, error))
+    goto fail;
+
+  if (! print (output, error, "showpage\n"))
+    goto fail;
+
+  g_free (data);
+  g_free (packb);
+  g_free (plane);
+
+  g_object_unref (buffer);
+
+  return TRUE;
+
+ fail:
+
+  g_free (data);
+  g_free (packb);
+  g_free (plane);
+
+  g_object_unref (buffer);
+
+  return FALSE;
+
+#undef GET_RGB_TILE
+}
+
+static gboolean
+print (GOutputStream  *output,
+       GError        **error,
+       const gchar    *format,
+       ...)
+{
+  va_list  args;
+  gboolean success;
+
+  va_start (args, format);
+  success = g_output_stream_vprintf (output, NULL, NULL,
+                                     error, format, args);
+  va_end (args);
+
+  return success;
+}
+
+/*  Load interface functions  */
+
+static gint32
+count_ps_pages (const gchar *filename)
+{
+  FILE   *psfile;
+  gchar  *extension;
+  gchar   buf[1024];
+  gint32  num_pages      = 0;
+  gint32  showpage_count = 0;
+
+  extension = strrchr (filename, '.');
+  if (extension)
+    {
+      extension = g_ascii_strdown (extension + 1, -1);
+
+      if (strcmp (extension, "eps") == 0)
+        {
+          g_free (extension);
+          return 1;
+        }
+
+      g_free (extension);
+    }
+
+  psfile = g_fopen (filename, "r");
+
+  if (psfile == NULL)
+    {
+      g_message (_("Could not open '%s' for reading: %s"),
+                 gimp_filename_to_utf8 (filename), g_strerror (errno));
+      return 0;
+    }
+
+  while (num_pages == 0 && !feof (psfile))
+    {
+      fgets (buf, sizeof (buf), psfile);
+
+      if (strncmp (buf + 2, "Pages:", 6) == 0)
+        sscanf (buf + strlen ("%%Pages:"), "%d", &num_pages);
+      else if (strncmp (buf, "showpage", 8) == 0)
+        showpage_count++;
+    }
+
+  if (feof (psfile) && num_pages < 1 && showpage_count > 0)
+    num_pages = showpage_count;
+
+  fclose (psfile);
+
+  return num_pages;
+}
+
+static gboolean
+load_dialog (const gchar *filename)
+{
+  GtkWidget     *dialog;
+  GtkWidget     *main_vbox;
+  GtkWidget     *hbox;
+  GtkWidget     *frame;
+  GtkWidget     *vbox;
+  GtkWidget     *table;
+  GtkWidget     *spinbutton;
+  GtkAdjustment *adj;
+  GtkWidget     *entry    = NULL;
+  GtkWidget     *target   = NULL;
+  GtkWidget     *toggle;
+  GtkWidget     *selector = NULL;
+  gint32         page_count;
+  gchar         *range    = NULL;
+  gboolean       run;
+
+  page_count = count_ps_pages (filename);
+
+  gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+  dialog = gimp_dialog_new (_("Import from PostScript"), PLUG_IN_ROLE,
+                            NULL, 0,
+                            gimp_standard_help_func, LOAD_PS_PROC,
+
+                            _("_Cancel"), GTK_RESPONSE_CANCEL,
+                            _("_Import"), GTK_RESPONSE_OK,
+
+                            NULL);
+
+  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                           GTK_RESPONSE_OK,
+                                           GTK_RESPONSE_CANCEL,
+                                           -1);
+
+  gimp_window_set_transient (GTK_WINDOW (dialog));
+
+  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 (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                      main_vbox, TRUE, TRUE, 0);
+  gtk_widget_show (main_vbox);
+
+  if (page_count > 1)
+    {
+      selector = gimp_page_selector_new ();
+      gtk_box_pack_start (GTK_BOX (main_vbox), selector, TRUE, TRUE, 0);
+      gimp_page_selector_set_n_pages (GIMP_PAGE_SELECTOR (selector),
+                                      page_count);
+      gimp_page_selector_set_target (GIMP_PAGE_SELECTOR (selector),
+                                     ps_pagemode);
+
+      gtk_widget_show (selector);
+
+      g_signal_connect_swapped (selector, "activate",
+                                G_CALLBACK (gtk_window_activate_default),
+                                dialog);
+    }
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
+  gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+
+  /* Rendering */
+  frame = gimp_frame_new (_("Rendering"));
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_container_add (GTK_CONTAINER (frame), vbox);
+
+  /* Resolution/Width/Height/Pages labels */
+  table = gtk_table_new (4, 2, FALSE);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
+  gtk_widget_show (table);
+
+  adj = (GtkAdjustment *) gtk_adjustment_new (plvals.resolution,
+                                              MIN_RESOLUTION, MAX_RESOLUTION,
+                                              1, 10, 0);
+  spinbutton = gimp_spin_button_new (adj, 1.0, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
+                             _("Resolution:"), 0.0, 0.5,
+                             spinbutton, 1, FALSE);
+
+  g_signal_connect (adj, "value-changed",
+                    G_CALLBACK (resolution_change_callback),
+                    &plvals.resolution);
+  g_signal_connect (adj, "value-changed",
+                    G_CALLBACK (gimp_int_adjustment_update),
+                    &plvals.resolution);
+
+  adj = (GtkAdjustment *) gtk_adjustment_new (plvals.width,
+                                              1, GIMP_MAX_IMAGE_SIZE,
+                                              1, 10, 0);
+  ps_width_spinbutton = gimp_spin_button_new (adj, 1.0, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
+                             _("_Width:"), 0.0, 0.5,
+                             ps_width_spinbutton, 1, FALSE);
+
+  g_signal_connect (adj, "value-changed",
+                    G_CALLBACK (gimp_int_adjustment_update),
+                    &plvals.width);
+
+  adj = (GtkAdjustment *) gtk_adjustment_new (plvals.height,
+                                              1, GIMP_MAX_IMAGE_SIZE,
+                                              1, 10, 0);
+  ps_height_spinbutton = gimp_spin_button_new (adj, 1.0, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
+                             _("_Height:"), 0.0, 0.5,
+                             ps_height_spinbutton, 1, FALSE);
+
+  g_signal_connect (adj, "value-changed",
+                    G_CALLBACK (gimp_int_adjustment_update),
+                    &plvals.height);
+
+  if (page_count == 0)
+    {
+      entry = gtk_entry_new ();
+      gtk_widget_set_size_request (entry, 80, -1);
+      gtk_entry_set_text (GTK_ENTRY (entry), plvals.pages);
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
+                                 _("Pages:"), 0.0, 0.5,
+                                 entry, 1, FALSE);
+
+      g_signal_connect (entry, "changed",
+                        G_CALLBACK (load_pages_entry_callback),
+                        NULL);
+      gimp_help_set_help_data (GTK_WIDGET (entry),
+                               _("Pages to load (e.g.: 1-4 or 1,3,5-7)"), NULL);
+
+      target = gtk_combo_box_text_new ();
+      gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (target),
+                                      GIMP_PAGE_SELECTOR_TARGET_LAYERS,
+                                      _("Layers"));
+      gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (target),
+                                      GIMP_PAGE_SELECTOR_TARGET_IMAGES,
+                                      _("Images"));
+      gtk_combo_box_set_active (GTK_COMBO_BOX (target), (int) ps_pagemode);
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
+                                 _("Open as"), 0.0, 0.5,
+                                 target, 1, FALSE);
+    }
+
+  toggle = gtk_check_button_new_with_label (_("Try Bounding Box"));
+  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), plvals.use_bbox);
+  gtk_widget_show (toggle);
+
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &plvals.use_bbox);
+
+  gtk_widget_show (vbox);
+  gtk_widget_show (frame);
+
+  /* Coloring */
+  frame = gimp_int_radio_group_new (TRUE, _("Coloring"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &plvals.pnm_type, plvals.pnm_type,
+
+                                    _("B/W"),       4, NULL,
+                                    _("Gray"),      5, NULL,
+                                    _("Color"),     6, NULL,
+                                    _("Automatic"), 7, NULL,
+
+                                    NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
+  gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+
+  frame = gimp_int_radio_group_new (TRUE, _("Text antialiasing"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &plvals.textalpha, plvals.textalpha,
+
+                                    C_("antialiasing", "None"), 1, NULL,
+                                    _("Weak"),                  2, NULL,
+                                    _("Strong"),                4, NULL,
+
+                                    NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  frame = gimp_int_radio_group_new (TRUE, _("Graphic antialiasing"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &plvals.graphicsalpha, plvals.graphicsalpha,
+
+                                    C_("antialiasing", "None"), 1, NULL,
+                                    _("Weak"),                  2, NULL,
+                                    _("Strong"),                4, NULL,
+
+                                    NULL);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  gtk_widget_show (dialog);
+
+  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+  if (selector)
+    {
+      range = gimp_page_selector_get_selected_range (GIMP_PAGE_SELECTOR (selector));
+
+      if (strlen (range) < 1)
+        {
+          gimp_page_selector_select_all (GIMP_PAGE_SELECTOR (selector));
+          range = gimp_page_selector_get_selected_range (GIMP_PAGE_SELECTOR (selector));
+        }
+
+      strncpy (plvals.pages, range, sizeof (plvals.pages));
+      plvals.pages[strlen (range)] = '\0';
+
+      ps_pagemode = gimp_page_selector_get_target (GIMP_PAGE_SELECTOR (selector));
+    }
+  else if (page_count == 0)
+    {
+      ps_pagemode = gtk_combo_box_get_active (GTK_COMBO_BOX (target));
+    }
+  else
+    {
+      strncpy (plvals.pages, "1", 1);
+      plvals.pages[1] = '\0';
+      ps_pagemode = GIMP_PAGE_SELECTOR_TARGET_IMAGES;
+    }
+
+  gtk_widget_destroy (dialog);
+
+  return run;
+}
+
+static void
+load_pages_entry_callback (GtkWidget *widget,
+                           gpointer   data)
+{
+  gsize nelem = sizeof (plvals.pages);
+
+  strncpy (plvals.pages, gtk_entry_get_text (GTK_ENTRY (widget)), nelem);
+  plvals.pages[nelem-1] = '\0';
+}
+
+
+/*  Save interface functions  */
+
+static gboolean
+save_dialog (void)
+{
+  SaveDialogVals *vals;
+  GtkWidget      *dialog;
+  GtkWidget      *toggle;
+  GtkWidget      *frame, *uframe;
+  GtkWidget      *hbox, *vbox;
+  GtkWidget      *main_vbox[2];
+  GtkWidget      *table;
+  GtkWidget      *spinbutton;
+  GtkAdjustment  *adj;
+  gint            j;
+  gboolean        run;
+
+  vals = g_new (SaveDialogVals, 1);
+  vals->level = (psvals.level > 1);
+
+  dialog = gimp_export_dialog_new (_("PostScript"), PLUG_IN_BINARY, SAVE_PS_PROC);
+
+  /* Main hbox */
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
+  gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
+                      hbox, FALSE, FALSE, 0);
+  main_vbox[0] = main_vbox[1] = NULL;
+
+  for (j = 0; j < G_N_ELEMENTS (main_vbox); j++)
+    {
+      main_vbox[j] = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+      gtk_box_pack_start (GTK_BOX (hbox), main_vbox[j], FALSE, TRUE, 0);
+      gtk_widget_show (main_vbox[j]);
+    }
+
+  /* Image Size */
+  frame = gimp_frame_new (_("Image Size"));
+  gtk_box_pack_start (GTK_BOX (main_vbox[0]), frame, FALSE, TRUE, 0);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_container_add (GTK_CONTAINER (frame), vbox);
+
+  /* Width/Height/X-/Y-offset labels */
+  table = gtk_table_new (4, 2, FALSE);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
+  gtk_widget_show (table);
+
+  vals->adjustment[0] = (GtkAdjustment *)
+    gtk_adjustment_new (psvals.width,
+                        1e-5, GIMP_MAX_IMAGE_SIZE, 1, 10, 0);
+  spinbutton = gimp_spin_button_new (vals->adjustment[0], 1.0, 2);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
+                             _("_Width:"), 0.0, 0.5,
+                             spinbutton, 1, FALSE);
+  g_signal_connect (vals->adjustment[0], "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &psvals.width);
+
+  vals->adjustment[1] = (GtkAdjustment *)
+    gtk_adjustment_new (psvals.height,
+                        1e-5, GIMP_MAX_IMAGE_SIZE, 1, 10, 0);
+  spinbutton = gimp_spin_button_new (vals->adjustment[1], 1.0, 2);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
+                             _("_Height:"), 0.0, 0.5,
+                             spinbutton, 1, FALSE);
+  g_signal_connect (vals->adjustment[1], "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &psvals.height);
+
+  vals->adjustment[2] = (GtkAdjustment *)
+    gtk_adjustment_new (psvals.x_offset,
+                        0.0, GIMP_MAX_IMAGE_SIZE, 1, 10, 0);
+  spinbutton = gimp_spin_button_new (vals->adjustment[2], 1.0, 2);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
+                             _("_X offset:"), 0.0, 0.5,
+                             spinbutton, 1, FALSE);
+  g_signal_connect (vals->adjustment[2], "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &psvals.x_offset);
+
+  vals->adjustment[3] = (GtkAdjustment *)
+    gtk_adjustment_new (psvals.y_offset,
+                        0.0, GIMP_MAX_IMAGE_SIZE, 1, 10, 0);
+  spinbutton = gimp_spin_button_new (vals->adjustment[3], 1.0, 2);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
+                             _("_Y offset:"), 0.0, 0.5,
+                             spinbutton, 1, FALSE);
+  g_signal_connect (vals->adjustment[3], "value-changed",
+                    G_CALLBACK (gimp_double_adjustment_update),
+                    &psvals.y_offset);
+
+  toggle = gtk_check_button_new_with_mnemonic (_("_Keep aspect ratio"));
+  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), psvals.keep_ratio);
+  gtk_widget_show (toggle);
+
+  gimp_help_set_help_data (toggle,
+                           _("When toggled, the resulting image will be "
+                             "scaled to fit into the given size without "
+                             "changing the aspect ratio."),
+                           "#keep_aspect_ratio"),
+
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &psvals.keep_ratio);
+
+  /* Unit */
+  uframe = gimp_int_radio_group_new (TRUE, _("Unit"),
+                                     G_CALLBACK (save_unit_toggle_update),
+                                     vals, psvals.unit_mm,
+
+                                     _("_Inch"),       FALSE, NULL,
+                                     _("_Millimeter"), TRUE,  NULL,
+
+                                     NULL);
+
+  gtk_box_pack_start (GTK_BOX (main_vbox[0]), uframe, TRUE, TRUE, 0);
+  gtk_widget_show (uframe);
+
+  gtk_widget_show (vbox);
+  gtk_widget_show (frame);
+
+  /* Rotation */
+  frame = gimp_int_radio_group_new (TRUE, _("Rotation"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &psvals.rotate, psvals.rotate,
+
+                                    "_0",   0,   NULL,
+                                    "_90",  90,  NULL,
+                                    "_180", 180, NULL,
+                                    "_270", 270, NULL,
+
+                                    NULL);
+
+  gtk_box_pack_start (GTK_BOX (main_vbox[1]), frame, TRUE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  /* Format */
+  frame = gimp_frame_new (_("Output"));
+  gtk_box_pack_start (GTK_BOX (main_vbox[1]), frame, TRUE, TRUE, 0);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_container_add (GTK_CONTAINER (frame), vbox);
+
+  toggle = gtk_check_button_new_with_mnemonic (_("_PostScript level 2"));
+  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), vals->level);
+  gtk_widget_show (toggle);
+
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &vals->level);
+
+  toggle = gtk_check_button_new_with_mnemonic (_("_Encapsulated PostScript"));
+  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), psvals.eps);
+  gtk_widget_show (toggle);
+
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &psvals.eps);
+
+  toggle = gtk_check_button_new_with_mnemonic (_("P_review"));
+  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), psvals.preview);
+  gtk_widget_show (toggle);
+
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &psvals.preview);
+
+  /* Preview size label/entry */
+  table = gtk_table_new (1, 2, FALSE);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
+  gtk_widget_show (table);
+
+  g_object_bind_property (toggle, "active",
+                          table,  "sensitive",
+                          G_BINDING_SYNC_CREATE);
+
+  adj = (GtkAdjustment *) gtk_adjustment_new (psvals.preview_size,
+                                              0, 1024, 1, 10, 0);
+  spinbutton = gimp_spin_button_new (adj, 1.0, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
+                             _("Preview _size:"), 1.0, 0.5,
+                             spinbutton, 1, FALSE);
+  gtk_widget_show (spinbutton);
+
+  g_signal_connect (adj, "value-changed",
+                    G_CALLBACK (gimp_int_adjustment_update),
+                    &psvals.preview_size);
+
+  gtk_widget_show (vbox);
+  gtk_widget_show (frame);
+
+  gtk_widget_show (hbox);
+  gtk_widget_show (dialog);
+
+  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+  gtk_widget_destroy (dialog);
+
+  psvals.level = (vals->level) ? 2 : 1;
+
+  g_free (vals);
+
+  return run;
+}
+
+static void
+save_unit_toggle_update (GtkWidget *widget,
+                         gpointer   data)
+{
+  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
+    {
+      SaveDialogVals *vals = (SaveDialogVals *) data;
+      gdouble         factor;
+      gdouble         value;
+      gint            unit_mm;
+      gint            i;
+
+      unit_mm = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
+                                                    "gimp-item-data"));
+
+      psvals.unit_mm = unit_mm;
+
+      if (unit_mm)
+        factor = 25.4;
+      else
+        factor = 1.0 / 25.4;
+
+      for (i = 0; i < 4; i++)
+        {
+          value = gtk_adjustment_get_value (vals->adjustment[i]) * factor;
+
+          gtk_adjustment_set_value (vals->adjustment[i], value);
+        }
+    }
+}
+
+static gboolean
+resolution_change_callback (GtkAdjustment *adjustment,
+                            gpointer       data)
+{
+  guint   *old_resolution = (guint *) data;
+  gdouble  ratio;
+
+  if (*old_resolution)
+    ratio = (gdouble) gtk_adjustment_get_value (adjustment) / *old_resolution;
+  else
+    ratio = 1.0;
+
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON (ps_width_spinbutton),
+                             gtk_spin_button_get_value (GTK_SPIN_BUTTON (ps_width_spinbutton)) * ratio);
+
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON (ps_height_spinbutton),
+                             gtk_spin_button_get_value (GTK_SPIN_BUTTON (ps_height_spinbutton)) * ratio);
+
+  return TRUE;
+
+}