gimp/app/pdb/fileops_cmds.c

/* The GIMP -- an image manipulation program
 * Copyright (C) 1995-2003 Spencer Kimball and Peter Mattis
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/* NOTE: This file is autogenerated by pdbgen.pl. */

#include "config.h"

#include <gdk-pixbuf/gdk-pixbuf.h>

#include <glib.h>

#ifdef G_OS_WIN32
#include <process.h>
#endif

#include <string.h>
#include <sys/types.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif


#include <glib-object.h>

#include "libgimpbase/gimpbase.h"
#include "libgimpconfig/gimpconfig.h"
#include "libgimpthumb/gimpthumb.h"

#include "pdb-types.h"
#include "procedural_db.h"
#include "core/gimpparamspecs.h"

#include "config/gimpbaseconfig.h"
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "core/gimpimagefile.h"
#include "core/gimplayer.h"
#include "file/file-open.h"
#include "file/file-utils.h"
#include "plug-in/plug-in-proc-def.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-ins.h"

static ProcRecord file_load_proc;
static ProcRecord file_load_layer_proc;
static ProcRecord file_load_thumbnail_proc;
static ProcRecord file_save_proc;
static ProcRecord file_save_thumbnail_proc;
static ProcRecord temp_name_proc;
static ProcRecord register_magic_load_handler_proc;
static ProcRecord register_load_handler_proc;
static ProcRecord register_save_handler_proc;
static ProcRecord register_file_handler_mime_proc;
static ProcRecord register_thumbnail_loader_proc;

void
register_fileops_procs (Gimp *gimp)
{
  ProcRecord *procedure;

  /*
   * file_load
   */
  procedure = procedural_db_init_proc (&file_load_proc, 3, 1);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_INT32,
                              g_param_spec_enum ("run-mode",
                                                 "run mode",
                                                 "The run mode: { GIMP_RUN_INTERACTIVE (0), GIMP_RUN_NONINTERACTIVE (1) }",
                                                 GIMP_TYPE_RUN_MODE,
                                                 GIMP_RUN_INTERACTIVE,
                                                 GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("filename",
                                                      "filename",
                                                      "The name of the file to load",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("raw-filename",
                                                      "raw filename",
                                                      "The name as entered by the user",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_IMAGE,
                                  gimp_param_spec_image_id ("image",
                                                            "image",
                                                            "The output image",
                                                            gimp,
                                                            GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * file_load_layer
   */
  procedure = procedural_db_init_proc (&file_load_layer_proc, 3, 1);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_INT32,
                              g_param_spec_enum ("run-mode",
                                                 "run mode",
                                                 "The run mode: { GIMP_RUN_INTERACTIVE (0), GIMP_RUN_NONINTERACTIVE (1) }",
                                                 GIMP_TYPE_RUN_MODE,
                                                 GIMP_RUN_INTERACTIVE,
                                                 GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_IMAGE,
                              gimp_param_spec_image_id ("image",
                                                        "image",
                                                        "Destination image",
                                                        gimp,
                                                        GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("filename",
                                                      "filename",
                                                      "The name of the file to load",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_LAYER,
                                  gimp_param_spec_item_id ("layer",
                                                           "layer",
                                                           "The layer created when loading the image file",
                                                           gimp,
                                                           GIMP_TYPE_LAYER,
                                                           GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * file_load_thumbnail
   */
  procedure = procedural_db_init_proc (&file_load_thumbnail_proc, 1, 4);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("filename",
                                                      "filename",
                                                      "The name of the file that owns the thumbnail to load",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_INT32,
                                  g_param_spec_int ("width",
                                                    "width",
                                                    "The width of the thumbnail",
                                                    G_MININT32, G_MAXINT32, 0,
                                                    GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_INT32,
                                  g_param_spec_int ("height",
                                                    "height",
                                                    "The height of the thumbnail",
                                                    G_MININT32, G_MAXINT32, 0,
                                                    GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_INT32,
                                  g_param_spec_int ("thumb-data-count",
                                                    "thumb data count",
                                                    "The number of bytes in thumbnail data",
                                                    0, G_MAXINT32, 0,
                                                    GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_INT8ARRAY,
                                  g_param_spec_pointer ("thumb-data",
                                                        "thumb data",
                                                        "The thumbnail data",
                                                        GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * file_save
   */
  procedure = procedural_db_init_proc (&file_save_proc, 5, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_INT32,
                              g_param_spec_enum ("run-mode",
                                                 "run mode",
                                                 "The run mode: { GIMP_RUN_INTERACTIVE (0), GIMP_RUN_NONINTERACTIVE (1) }",
                                                 GIMP_TYPE_RUN_MODE,
                                                 GIMP_RUN_INTERACTIVE,
                                                 GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_IMAGE,
                              gimp_param_spec_image_id ("image",
                                                        "image",
                                                        "Input image",
                                                        gimp,
                                                        GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_DRAWABLE,
                              gimp_param_spec_item_id ("drawable",
                                                       "drawable",
                                                       "Drawable to save",
                                                       gimp,
                                                       GIMP_TYPE_DRAWABLE,
                                                       GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("filename",
                                                      "filename",
                                                      "The name of the file to save the image in",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("raw-filename",
                                                      "raw filename",
                                                      "The name as entered by the user",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * file_save_thumbnail
   */
  procedure = procedural_db_init_proc (&file_save_thumbnail_proc, 2, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_IMAGE,
                              gimp_param_spec_image_id ("image",
                                                        "image",
                                                        "The image",
                                                        gimp,
                                                        GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("filename",
                                                      "filename",
                                                      "The name of the file the thumbnail belongs to",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * temp_name
   */
  procedure = procedural_db_init_proc (&temp_name_proc, 1, 1);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("extension",
                                                      "extension",
                                                      "The extension the file will have",
                                                      TRUE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_return_value (procedure,
                                  GIMP_PDB_STRING,
                                  gimp_param_spec_string ("name",
                                                          "name",
                                                          "The new temp filename",
                                                          FALSE, FALSE,
                                                          NULL,
                                                          GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * register_magic_load_handler
   */
  procedure = procedural_db_init_proc (&register_magic_load_handler_proc, 4, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("procedure-name",
                                                      "procedure name",
                                                      "The name of the procedure to be used for loading",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("extensions",
                                                      "extensions",
                                                      "comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("prefixes",
                                                      "prefixes",
                                                      "comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("magics",
                                                      "magics",
                                                      "comma separated list of magic file information this handler can load (i.e. \"0,string,GIF\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_register (gimp, procedure);

  /*
   * register_load_handler
   */
  procedure = procedural_db_init_proc (&register_load_handler_proc, 3, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("procedure-name",
                                                      "procedure name",
                                                      "The name of the procedure to be used for loading",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("extensions",
                                                      "extensions",
                                                      "comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("prefixes",
                                                      "prefixes",
                                                      "comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_register (gimp, procedure);

  /*
   * register_save_handler
   */
  procedure = procedural_db_init_proc (&register_save_handler_proc, 3, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("procedure-name",
                                                      "procedure name",
                                                      "The name of the procedure to be used for saving",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("extensions",
                                                      "extensions",
                                                      "comma separated list of extensions this handler can save (i.e. \"jpg,jpeg\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("prefixes",
                                                      "prefixes",
                                                      "comma separated list of prefixes this handler can save (i.e. \"http:,ftp:\")",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
  procedural_db_register (gimp, procedure);

  /*
   * register_file_handler_mime
   */
  procedure = procedural_db_init_proc (&register_file_handler_mime_proc, 2, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("procedure-name",
                                                      "procedure name",
                                                      "The name of the procedure to associate a MIME type with.",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("mime-type",
                                                      "mime type",
                                                      "A single MIME type, like for example \"image/jpeg\".",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

  /*
   * register_thumbnail_loader
   */
  procedure = procedural_db_init_proc (&register_thumbnail_loader_proc, 2, 0);
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("load-proc",
                                                      "load proc",
                                                      "The name of the procedure the thumbnail loader with.",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_add_argument (procedure,
                              GIMP_PDB_STRING,
                              gimp_param_spec_string ("thumb-proc",
                                                      "thumb proc",
                                                      "The name of the thumbnail load procedure.",
                                                      FALSE, FALSE,
                                                      NULL,
                                                      GIMP_PARAM_READWRITE));
  procedural_db_register (gimp, procedure);

}

static gboolean
fileops_register_magic_load_handler (Gimp        *gimp,
                                     const gchar *procedure_name,
                                     const gchar *extensions,
                                     const gchar *prefixes,
                                     const gchar *magics)
{
  ProcRecord    *proc;
  PlugInProcDef *file_proc;
  gchar         *canonical;
  gboolean       success = FALSE;

  canonical = gimp_canonicalize_identifier (procedure_name);

  proc = procedural_db_lookup (gimp, canonical);

  if (proc && ((proc->num_args < 3) ||
	       (proc->num_values < 1) ||
	       (proc->args[0].arg_type != GIMP_PDB_INT32) ||
	       (proc->args[1].arg_type != GIMP_PDB_STRING) ||
	       (proc->args[2].arg_type != GIMP_PDB_STRING) ||
	       (proc->values[0].arg_type != GIMP_PDB_IMAGE)))
    {
      g_message ("load handler \"%s\" does not take the standard load handler args",
		 canonical);
      goto done;
    }

  file_proc = plug_ins_file_register_magic (gimp, canonical,
                                            extensions, prefixes, magics);

  if (! file_proc)
    {
      g_message ("attempt to register nonexistent load handler \"%s\"",
		 canonical);
      goto done;
    }

  if (! g_slist_find (gimp->load_procs, file_proc))
    gimp->load_procs = g_slist_prepend (gimp->load_procs, file_proc);

  success = TRUE;

done:
  g_free (canonical);

  return success;
}

static Argument *
file_load_invoker (ProcRecord   *proc_record,
                   Gimp         *gimp,
                   GimpContext  *context,
                   GimpProgress *progress,
                   Argument     *args)
{
  Argument         *new_args;
  Argument         *return_vals;
  PlugInProcDef    *file_proc;
  const ProcRecord *proc;
  gchar            *uri;
  gint              i;

  uri = file_utils_filename_to_uri (gimp->load_procs,
                                    args[1].value.pdb_pointer, NULL);

  if (! uri)
    return procedural_db_return_values (proc_record, FALSE);

  file_proc = file_utils_find_proc (gimp->load_procs, uri);

  g_free (uri);

  if (! file_proc)
    return procedural_db_return_values (proc_record, FALSE);

  proc = plug_in_proc_def_get_proc (file_proc);

  new_args = g_new0 (Argument, proc->num_args);
  memcpy (new_args, args, sizeof (Argument) * 3);

  for (i = 3; i < proc->num_args; i++)
    {
      new_args[i].arg_type = proc->args[i].arg_type;
      if (proc->args[i].arg_type == GIMP_PDB_STRING)
        new_args[i].value.pdb_pointer = g_strdup ("");
    }

  return_vals = procedural_db_execute (gimp, context, progress,
                                       proc->name, new_args);
  g_free (new_args);

  return return_vals;
}

static ProcRecord file_load_proc =
{
  "gimp-file-load",
  "gimp-file-load",
  "Loads an image file by invoking the right load handler.",
  "This procedure invokes the correct file load handler using magic if possible, and falling back on the file's extension and/or prefix if not. The name of the file to load is typically a full pathname, and the name entered is what the user actually typed before prepending a directory path. The reason for this is that if the user types http://www.xcf/~gimp/ he wants to fetch a URL, and the full pathname will not look like a URL.\"",
  "Josh MacDonald",
  "Josh MacDonald",
  "1997",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { file_load_invoker } }
};

static Argument *
file_load_layer_invoker (ProcRecord   *proc_record,
                         Gimp         *gimp,
                         GimpContext  *context,
                         GimpProgress *progress,
                         Argument     *args)
{
  gboolean success = TRUE;
  Argument *return_vals;
  gint32 run_mode;
  GimpImage *image;
  gchar *filename;
  GimpLayer *layer = NULL;

  run_mode = args[0].value.pdb_int;
  if (run_mode < GIMP_RUN_INTERACTIVE || run_mode > GIMP_RUN_NONINTERACTIVE)
    success = FALSE;

  image = gimp_image_get_by_ID (gimp, args[1].value.pdb_int);
  if (! GIMP_IS_IMAGE (image))
    success = FALSE;

  filename = (gchar *) args[2].value.pdb_pointer;
  if (filename == NULL)
    success = FALSE;

  if (success)
    {
      gchar *uri = file_utils_filename_to_uri (gimp->load_procs,
                                               filename, NULL);

      if (uri)
        {
          GimpPDBStatusType status;

          layer = file_open_layer (gimp, context, progress,
                                   image, uri, run_mode, NULL, &status, NULL);

          if (! layer)
            success = FALSE;
        }
      else
        success = FALSE;
    }

  return_vals = procedural_db_return_values (proc_record, success);

  if (success)
    return_vals[1].value.pdb_int = layer ? gimp_item_get_ID (GIMP_ITEM (layer)) : -1;

  return return_vals;
}

static ProcRecord file_load_layer_proc =
{
  "gimp-file-load-layer",
  "gimp-file-load-layer",
  "Loads an image file as a layer into an already opened image.",
  "This procedure behaves like the file-load procedure but opens the specified image as a layer into an already opened image.",
  "Sven Neumann <sven@gimp.org>",
  "Sven Neumann",
  "2005",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { file_load_layer_invoker } }
};

static Argument *
file_load_thumbnail_invoker (ProcRecord   *proc_record,
                             Gimp         *gimp,
                             GimpContext  *context,
                             GimpProgress *progress,
                             Argument     *args)
{
  gboolean success = TRUE;
  Argument *return_vals;
  gchar *filename;
  gint32 width = 0;
  gint32 height = 0;
  gint32 thumb_data_count = 0;
  guint8 *thumb_data = NULL;

  filename = (gchar *) args[0].value.pdb_pointer;
  if (filename == NULL)
    success = FALSE;

  if (success)
    {
      GimpThumbnail *thumbnail = NULL;
      GdkPixbuf     *pixbuf    = NULL;
      gchar         *uri;

      uri = g_filename_to_uri (filename, NULL, NULL);

      if (uri)
        {
          thumbnail = gimp_thumbnail_new ();
          gimp_thumbnail_set_uri (thumbnail, uri);

          pixbuf = gimp_thumbnail_load_thumb (thumbnail,
                                              GIMP_THUMBNAIL_SIZE_NORMAL,
                                              NULL);
        }

      if (pixbuf)
        {
          width  = gdk_pixbuf_get_width (pixbuf);
          height = gdk_pixbuf_get_height (pixbuf);

          if (gdk_pixbuf_get_n_channels (pixbuf) != 3)
            {
              GdkPixbuf *tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
                                               width, height);

              gdk_pixbuf_composite_color (pixbuf, tmp,
                                          0, 0, width, height, 0, 0, 1.0, 1.0,
                                          GDK_INTERP_NEAREST, 255,
                                          0, 0, GIMP_CHECK_SIZE_SM,
                                          0x66666666, 0x99999999);

              g_object_unref (pixbuf);
              pixbuf = tmp;
            }

          thumb_data_count = 3 * width * height;
          thumb_data       = g_memdup (gdk_pixbuf_get_pixels (pixbuf),
                                       thumb_data_count);

          g_object_unref (pixbuf);
        }
      else
        success = FALSE;

      g_free (uri);
    }

  return_vals = procedural_db_return_values (proc_record, success);

  if (success)
    {
      return_vals[1].value.pdb_int = width;
      return_vals[2].value.pdb_int = height;
      return_vals[3].value.pdb_int = thumb_data_count;
      return_vals[4].value.pdb_pointer = thumb_data;
    }

  return return_vals;
}

static ProcRecord file_load_thumbnail_proc =
{
  "gimp-file-load-thumbnail",
  "gimp-file-load-thumbnail",
  "Loads the thumbnail for a file.",
  "This procedure tries to load a thumbnail that belongs to the file with the given filename. This name is a full pathname. The returned data is an array of colordepth 3 (RGB), regardless of the image type. Width and height of the thumbnail are also returned. Don't use this function if you need a thumbnail of an already opened image, use gimp_image_thumbnail instead.",
  "Adam D. Moss, Sven Neumann",
  "Adam D. Moss, Sven Neumann",
  "1999-2003",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { file_load_thumbnail_invoker } }
};

static Argument *
file_save_invoker (ProcRecord   *proc_record,
                   Gimp         *gimp,
                   GimpContext  *context,
                   GimpProgress *progress,
                   Argument     *args)
{
  Argument         *new_args;
  Argument         *return_vals;
  PlugInProcDef    *file_proc;
  const ProcRecord *proc;
  gchar            *uri;
  gint              i;

  uri = file_utils_filename_to_uri (gimp->load_procs,
                                    args[3].value.pdb_pointer, NULL);

  if (! uri)
    return procedural_db_return_values (proc_record, FALSE);

  file_proc = file_utils_find_proc (gimp->save_procs, uri);

  g_free (uri);

  if (! file_proc)
    return procedural_db_return_values (proc_record, FALSE);

  proc = plug_in_proc_def_get_proc (file_proc);

  new_args = g_new0 (Argument, proc->num_args);
  memcpy (new_args, args, sizeof (Argument) * 5);

  for (i = 5; i < proc->num_args; i++)
    {
      new_args[i].arg_type = proc->args[i].arg_type;
      if (proc->args[i].arg_type == GIMP_PDB_STRING)
        new_args[i].value.pdb_pointer = g_strdup ("");
    }

  return_vals = procedural_db_execute (gimp, context, progress,
                                       proc->name, new_args);
  g_free (new_args);

  return return_vals;
}

static ProcRecord file_save_proc =
{
  "gimp-file-save",
  "gimp-file-save",
  "Saves a file by extension.",
  "This procedure invokes the correct file save handler according to the file's extension and/or prefix. The name of the file to save is typically a full pathname, and the name entered is what the user actually typed before prepending a directory path. The reason for this is that if the user types http://www.xcf/~gimp/ she wants to fetch a URL, and the full pathname will not look like a URL.",
  "Josh MacDonald",
  "Josh MacDonald",
  "1997",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { file_save_invoker } }
};

static Argument *
file_save_thumbnail_invoker (ProcRecord   *proc_record,
                             Gimp         *gimp,
                             GimpContext  *context,
                             GimpProgress *progress,
                             Argument     *args)
{
  gboolean success = TRUE;
  GimpImage *image;
  gchar *filename;

  image = gimp_image_get_by_ID (gimp, args[0].value.pdb_int);
  if (! GIMP_IS_IMAGE (image))
    success = FALSE;

  filename = (gchar *) args[1].value.pdb_pointer;
  if (filename == NULL)
    success = FALSE;

  if (success)
    {
      const gchar *image_uri = gimp_object_get_name (GIMP_OBJECT (image));

      if (image_uri)
        {
          gchar *uri = g_filename_to_uri (filename, NULL, NULL);

          if (uri)
            {
              if (! strcmp (uri, image_uri))
                {
                  GimpImagefile *imagefile;

                  imagefile = gimp_imagefile_new (gimp, uri);
                  success = gimp_imagefile_save_thumbnail (imagefile, NULL, image);
                  g_object_unref (imagefile);
                }
              else
                success = FALSE;

              g_free (uri);
            }
          else
            success = FALSE;
        }
      else
        success = FALSE;
    }

  return procedural_db_return_values (proc_record, success);
}

static ProcRecord file_save_thumbnail_proc =
{
  "gimp-file-save-thumbnail",
  "gimp-file-save-thumbnail",
  "Saves a thumbnail for the given image",
  "This procedure saves a thumbnail for the given image according to the Free Desktop Thumbnail Managing Standard. The thumbnail is saved so that it belongs to the file with the given filename. This means you have to save the image under this name first, otherwise this procedure will fail. This procedure may become useful if you want to explicitely save a thumbnail with a file.",
  "Josh MacDonald",
  "Josh MacDonald",
  "1997",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { file_save_thumbnail_invoker } }
};

static Argument *
temp_name_invoker (ProcRecord   *proc_record,
                   Gimp         *gimp,
                   GimpContext  *context,
                   GimpProgress *progress,
                   Argument     *args)
{
  gboolean success = TRUE;
  Argument *return_vals;
  gchar *extension;
  gchar *name = NULL;

  extension = (gchar *) args[0].value.pdb_pointer;
  if (extension == NULL)
    success = FALSE;

  if (success)
    {
      static gint  id = 0;
      static gint  pid;
      gchar       *filename;
      gchar       *path;

      if (id == 0)
        pid = getpid ();

      filename = g_strdup_printf ("gimp_temp_%d%d.%s",
                                  pid, id++, extension);

      path = gimp_config_path_expand (GIMP_BASE_CONFIG (gimp->config)->temp_path,
                                      TRUE, NULL);

      name = g_build_filename (path, filename, NULL);

      g_free (path);
      g_free (filename);
    }

  return_vals = procedural_db_return_values (proc_record, success);

  if (success)
    return_vals[1].value.pdb_pointer = name;

  return return_vals;
}

static ProcRecord temp_name_proc =
{
  "gimp-temp-name",
  "gimp-temp-name",
  "Generates a unique filename.",
  "Generates a unique filename using the temp path supplied in the user's gimprc.",
  "Josh MacDonald",
  "Josh MacDonald",
  "1997",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { temp_name_invoker } }
};

static Argument *
register_magic_load_handler_invoker (ProcRecord   *proc_record,
                                     Gimp         *gimp,
                                     GimpContext  *context,
                                     GimpProgress *progress,
                                     Argument     *args)
{
  gboolean success = TRUE;
  gchar *procedure_name;
  gchar *extensions;
  gchar *prefixes;
  gchar *magics;

  procedure_name = (gchar *) args[0].value.pdb_pointer;
  if (procedure_name == NULL || !g_utf8_validate (procedure_name, -1, NULL))
    success = FALSE;

  extensions = (gchar *) args[1].value.pdb_pointer;

  prefixes = (gchar *) args[2].value.pdb_pointer;

  magics = (gchar *) args[3].value.pdb_pointer;

  if (success)
    {
      success = fileops_register_magic_load_handler (gimp,
                                                     procedure_name,
                                                     extensions, prefixes, magics);
    }

  return procedural_db_return_values (proc_record, success);
}

static ProcRecord register_magic_load_handler_proc =
{
  "gimp-register-magic-load-handler",
  "gimp-register-magic-load-handler",
  "Registers a file load handler procedure.",
  "Registers a procedural database procedure to be called to load files of a particular file format using magic file information.",
  "Spencer Kimball & Peter Mattis",
  "Spencer Kimball & Peter Mattis",
  "1995-1996",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { register_magic_load_handler_invoker } }
};

static Argument *
register_load_handler_invoker (ProcRecord   *proc_record,
                               Gimp         *gimp,
                               GimpContext  *context,
                               GimpProgress *progress,
                               Argument     *args)
{
  gboolean success = TRUE;
  gchar *procedure_name;
  gchar *extensions;
  gchar *prefixes;

  procedure_name = (gchar *) args[0].value.pdb_pointer;
  if (procedure_name == NULL || !g_utf8_validate (procedure_name, -1, NULL))
    success = FALSE;

  extensions = (gchar *) args[1].value.pdb_pointer;

  prefixes = (gchar *) args[2].value.pdb_pointer;

  if (success)
    {
      success = fileops_register_magic_load_handler (gimp,
                                                     procedure_name,
                                                     extensions, prefixes, NULL);
    }

  return procedural_db_return_values (proc_record, success);
}

static ProcRecord register_load_handler_proc =
{
  "gimp-register-load-handler",
  "gimp-register-load-handler",
  "Registers a file load handler procedure.",
  "Registers a procedural database procedure to be called to load files of a particular file format.",
  "Spencer Kimball & Peter Mattis",
  "Spencer Kimball & Peter Mattis",
  "1995-1996",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { register_load_handler_invoker } }
};

static Argument *
register_save_handler_invoker (ProcRecord   *proc_record,
                               Gimp         *gimp,
                               GimpContext  *context,
                               GimpProgress *progress,
                               Argument     *args)
{
  gboolean success = TRUE;
  gchar *procedure_name;
  gchar *extensions;
  gchar *prefixes;

  procedure_name = (gchar *) args[0].value.pdb_pointer;
  if (procedure_name == NULL || !g_utf8_validate (procedure_name, -1, NULL))
    success = FALSE;

  extensions = (gchar *) args[1].value.pdb_pointer;

  prefixes = (gchar *) args[2].value.pdb_pointer;

  if (success)
    {
      ProcRecord    *proc;
      PlugInProcDef *file_proc;
      gchar         *canonical;

      success = FALSE;

      canonical = gimp_canonicalize_identifier (procedure_name);

      proc = procedural_db_lookup (gimp, canonical);

      if (proc && ((proc->num_args < 5) ||
                   (proc->args[0].arg_type != GIMP_PDB_INT32) ||
                   (proc->args[1].arg_type != GIMP_PDB_IMAGE) ||
                   (proc->args[2].arg_type != GIMP_PDB_DRAWABLE) ||
                   (proc->args[3].arg_type != GIMP_PDB_STRING) ||
                   (proc->args[4].arg_type != GIMP_PDB_STRING)))
        {
          g_message ("save handler \"%s\" does not take the standard save handler args",
                     canonical);
          goto done;
        }

      file_proc = plug_ins_file_register_magic (gimp, canonical,
                                                extensions, prefixes, NULL);

      if (! file_proc)
        {
          g_message ("attempt to register nonexistent save handler \"%s\"",
                     canonical);
          goto done;
        }

      if (! g_slist_find (gimp->save_procs, file_proc))
        gimp->save_procs = g_slist_prepend (gimp->save_procs, file_proc);

      success = TRUE;

    done:
      g_free (canonical);
    }

  return procedural_db_return_values (proc_record, success);
}

static ProcRecord register_save_handler_proc =
{
  "gimp-register-save-handler",
  "gimp-register-save-handler",
  "Registers a file save handler procedure.",
  "Registers a procedural database procedure to be called to save files in a particular file format.",
  "Spencer Kimball & Peter Mattis",
  "Spencer Kimball & Peter Mattis",
  "1995-1996",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { register_save_handler_invoker } }
};

static Argument *
register_file_handler_mime_invoker (ProcRecord   *proc_record,
                                    Gimp         *gimp,
                                    GimpContext  *context,
                                    GimpProgress *progress,
                                    Argument     *args)
{
  gboolean success = TRUE;
  gchar *procedure_name;
  gchar *mime_type;

  procedure_name = (gchar *) args[0].value.pdb_pointer;
  if (procedure_name == NULL || !g_utf8_validate (procedure_name, -1, NULL))
    success = FALSE;

  mime_type = (gchar *) args[1].value.pdb_pointer;
  if (mime_type == NULL || !g_utf8_validate (mime_type, -1, NULL))
    success = FALSE;

  if (success)
    {
      gchar *canonical;

      canonical = gimp_canonicalize_identifier (procedure_name);

      if (! plug_ins_file_register_mime (gimp, canonical, mime_type))
        success = FALSE;

      g_free (canonical);
    }

  return procedural_db_return_values (proc_record, success);
}

static ProcRecord register_file_handler_mime_proc =
{
  "gimp-register-file-handler-mime",
  "gimp-register-file-handler-mime",
  "Associates a MIME type with a file handler procedure.",
  "Registers a MIME type for a file handler procedure. This allows GIMP to determine the MIME type of the file opened or saved using this procedure.",
  "Sven Neumann <sven@gimp.org>",
  "Sven Neumann",
  "2004",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { register_file_handler_mime_invoker } }
};

static Argument *
register_thumbnail_loader_invoker (ProcRecord   *proc_record,
                                   Gimp         *gimp,
                                   GimpContext  *context,
                                   GimpProgress *progress,
                                   Argument     *args)
{
  gboolean success = TRUE;
  gchar *load_proc;
  gchar *thumb_proc;

  load_proc = (gchar *) args[0].value.pdb_pointer;
  if (load_proc == NULL || !g_utf8_validate (load_proc, -1, NULL))
    success = FALSE;

  thumb_proc = (gchar *) args[1].value.pdb_pointer;
  if (thumb_proc == NULL || !g_utf8_validate (thumb_proc, -1, NULL))
    success = FALSE;

  if (success)
    {
      gchar *canonical;

      canonical = gimp_canonicalize_identifier (load_proc);

      if (! plug_ins_file_register_thumb_loader (gimp, canonical, thumb_proc))
        success = FALSE;

      g_free (canonical);
    }

  return procedural_db_return_values (proc_record, success);
}

static ProcRecord register_thumbnail_loader_proc =
{
  "gimp-register-thumbnail-loader",
  "gimp-register-thumbnail-loader",
  "Associates a thumbnail loader with a file load procedure.",
  "Some file formats allow for embedded thumbnails, other file formats contain a scalable image or provide the image data in different resolutions. A file plug-in for such a format may register a special procedure that allows GIMP to load a thumbnail preview of the image. This procedure is then associated with the standard load procedure using this function.",
  "Sven Neumann <sven@gimp.org>",
  "Sven Neumann",
  "2004",
  NULL,
  GIMP_INTERNAL,
  0, NULL, 0, NULL,
  { { register_thumbnail_loader_invoker } }
};