PIKApp/app/file/file-open.c

/* PIKA - Photo and Image Kooker Application
 * a rebranding of The GNU Image Manipulation Program (created with heckimp)
 * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
 *
 * Original copyright, applying to most contents (license remains unchanged): 
 * Copyright (C) 1995, 1996, 1997 Spencer Kimball and Peter Mattis
 * Copyright (C) 1997 Josh MacDonald
 *
 * file-open.c
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "config.h"

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

#include "libpikabase/pikabase.h"

#include "core/core-types.h"

#include "gegl/pika-babl.h"

#include "core/pika.h"
#include "core/pikacontext.h"
#include "core/pikadocumentlist.h"
#include "core/pikaimage.h"
#include "core/pikaimage-merge.h"
#include "core/pikaimage-undo.h"
#include "core/pikaimagefile.h"
#include "core/pikalayer.h"
#include "core/pikaparamspecs.h"
#include "core/pikaprogress.h"

#include "pdb/pikapdb.h"

#include "plug-in/pikapluginmanager-file.h"
#include "plug-in/pikapluginprocedure.h"

#include "file-import.h"
#include "file-open.h"
#include "file-remote.h"
#include "pika-file.h"

#include "pika-intl.h"


static void     file_open_sanitize_image       (PikaImage           *image,
                                                gboolean             as_new);
static void     file_open_convert_items        (PikaImage           *dest_image,
                                                const gchar         *basename,
                                                GList               *items);
static GList *  file_open_get_layers           (PikaImage           *image,
                                                gboolean             merge_visible,
                                                gint                *n_visible);
static gboolean file_open_file_proc_is_import  (PikaPlugInProcedure *file_proc);


/*  public functions  */

PikaImage *
file_open_image (Pika                *pika,
                 PikaContext         *context,
                 PikaProgress        *progress,
                 GFile               *file,
                 gboolean             as_new,
                 PikaPlugInProcedure *file_proc,
                 PikaRunMode          run_mode,
                 PikaPDBStatusType   *status,
                 const gchar        **mime_type,
                 GError             **error)
{
  PikaValueArray *return_vals;
  GFile          *orig_file;
  PikaImage      *image       = NULL;
  GFile          *local_file  = NULL;
  gboolean        mounted     = TRUE;
  GError         *my_error    = NULL;

  g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
  g_return_val_if_fail (PIKA_IS_CONTEXT (context), NULL);
  g_return_val_if_fail (progress == NULL || PIKA_IS_PROGRESS (progress), NULL);
  g_return_val_if_fail (G_IS_FILE (file), NULL);
  g_return_val_if_fail (status != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  *status = PIKA_PDB_EXECUTION_ERROR;

  orig_file = file;

  if (! g_file_is_native (file) &&
      ! file_remote_mount_file (pika, file, progress, &my_error))
    {
      if (my_error)
        {
          g_printerr ("%s: mounting remote volume failed, trying to download "
                      "the file: %s\n",
                      G_STRFUNC, my_error->message);
          g_clear_error (&my_error);

          mounted = FALSE;
        }
      else
        {
          *status = PIKA_PDB_CANCEL;

          return NULL;
        }
    }

  /* FIXME enable these tests for remote files again, needs testing */
  if (g_file_is_native (file) &&
      g_file_query_exists (file, NULL))
    {
      GFileInfo *info;

      info = g_file_query_info (file,
                                G_FILE_ATTRIBUTE_STANDARD_TYPE ","
                                G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
                                G_FILE_QUERY_INFO_NONE,
                                NULL, error);
      if (! info)
        return NULL;

      if (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) != G_FILE_TYPE_REGULAR)
        {
          g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                               _("Not a regular file"));
          g_object_unref (info);
          return NULL;
        }

      if (! g_file_info_get_attribute_boolean (info,
                                               G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
        {
          g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                               _("Permission denied"));
          g_object_unref (info);
          return NULL;
        }

      g_object_unref (info);
    }

  if (! file_proc)
    file_proc = pika_plug_in_manager_file_procedure_find (pika->plug_in_manager,
                                                          PIKA_FILE_PROCEDURE_GROUP_OPEN,
                                                          file, error);

  if (! file_proc || ! file_proc->handles_remote || ! mounted)
    {
      gchar *my_path = g_file_get_path (file);

      if (! my_path)
        {
          g_clear_error (error);

          local_file = file_remote_download_image (pika, file, progress,
                                                   &my_error);

          if (! local_file)
            {
              if (my_error)
                g_propagate_error (error, my_error);
              else
                *status = PIKA_PDB_CANCEL;

              return NULL;
            }

          /*  if we don't have a file proc yet, try again on the local
           *  file
           */
          if (! file_proc)
            file_proc = pika_plug_in_manager_file_procedure_find (pika->plug_in_manager,
                                                                  PIKA_FILE_PROCEDURE_GROUP_OPEN,
                                                                  local_file, error);

          file = local_file;
        }

      g_free (my_path);
    }

  if (! file_proc)
    {
      if (local_file)
        {
          g_file_delete (local_file, NULL, NULL);
          g_object_unref (local_file);
        }

      return NULL;
    }

  if (progress)
    g_object_add_weak_pointer (G_OBJECT (progress), (gpointer) &progress);

  return_vals =
    pika_pdb_execute_procedure_by_name (pika->pdb,
                                        context, progress, error,
                                        pika_object_get_name (file_proc),
                                        PIKA_TYPE_RUN_MODE, run_mode,
                                        G_TYPE_FILE,        file,
                                        G_TYPE_NONE);

  if (progress)
    g_object_remove_weak_pointer (G_OBJECT (progress), (gpointer) &progress);

  *status = g_value_get_enum (pika_value_array_index (return_vals, 0));

  if (*status == PIKA_PDB_SUCCESS && ! file_proc->generic_file_proc)
    image = g_value_get_object (pika_value_array_index (return_vals, 1));

  /*  set the file on all images, plug-ins are not required to do it
   *  any longer
   */
  if (image)
    pika_image_set_file (image, orig_file);

  if (local_file)
    {
      g_file_delete (local_file, NULL, NULL);
      g_object_unref (local_file);
    }

  if (*status == PIKA_PDB_SUCCESS)
    {
      if (image)
        {
          /* Only set the load procedure if it hasn't already been set. */
          if (! pika_image_get_load_proc (image))
            pika_image_set_load_proc (image, file_proc);

          file_proc = pika_image_get_load_proc (image);

          if (mime_type)
            *mime_type = g_slist_nth_data (file_proc->mime_types_list, 0);
        }
      else if (! file_proc->generic_file_proc)
        {
          if (error && ! *error)
            g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                         _("%s plug-in returned SUCCESS but did not "
                           "return an image"),
                         pika_procedure_get_label (PIKA_PROCEDURE (file_proc)));

          *status = PIKA_PDB_EXECUTION_ERROR;
        }
    }
  else if (*status != PIKA_PDB_CANCEL)
    {
      if (error && ! *error)
        g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                     _("%s plug-in could not open image"),
                     pika_procedure_get_label (PIKA_PROCEDURE (file_proc)));
    }

  pika_value_array_unref (return_vals);

  if (image)
    {
      pika_image_undo_disable (image);

      if (file_open_file_proc_is_import (file_proc))
        {
          file_import_image (image, context, orig_file,
                             run_mode == PIKA_RUN_INTERACTIVE,
                             progress);
        }

      /* Enables undo again */
      file_open_sanitize_image (image, as_new);
    }

  return image;
}

/**
 * file_open_thumbnail:
 * @pika:
 * @context:
 * @progress:
 * @file:         an image file
 * @size:         requested size of the thumbnail
 * @mime_type:    return location for image MIME type
 * @image_width:  return location for image width
 * @image_height: return location for image height
 * @format:       return location for image format (set to NULL if unknown)
 * @num_layers:   return location for number of layers
 *                (set to -1 if the number of layers is not known)
 * @error:
 *
 * Attempts to load a thumbnail by using a registered thumbnail loader.
 *
 * Returns: the thumbnail image
 */
PikaImage *
file_open_thumbnail (Pika           *pika,
                     PikaContext    *context,
                     PikaProgress   *progress,
                     GFile          *file,
                     gint            size,
                     const gchar   **mime_type,
                     gint           *image_width,
                     gint           *image_height,
                     const Babl    **format,
                     gint           *num_layers,
                     GError        **error)
{
  PikaPlugInProcedure *file_proc;
  PikaProcedure       *procedure;

  g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
  g_return_val_if_fail (PIKA_IS_CONTEXT (context), NULL);
  g_return_val_if_fail (progress == NULL || PIKA_IS_PROGRESS (progress), NULL);
  g_return_val_if_fail (G_IS_FILE (file), NULL);
  g_return_val_if_fail (mime_type != NULL, NULL);
  g_return_val_if_fail (image_width != NULL, NULL);
  g_return_val_if_fail (image_height != NULL, NULL);
  g_return_val_if_fail (format != NULL, NULL);
  g_return_val_if_fail (num_layers != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  *image_width  = 0;
  *image_height = 0;
  *format       = NULL;
  *num_layers   = -1;

  file_proc = pika_plug_in_manager_file_procedure_find (pika->plug_in_manager,
                                                        PIKA_FILE_PROCEDURE_GROUP_OPEN,
                                                        file, NULL);

  if (! file_proc || ! file_proc->thumb_loader)
    return NULL;

  procedure = pika_pdb_lookup_procedure (pika->pdb, file_proc->thumb_loader);

  if (procedure && procedure->num_args >= 2 && procedure->num_values >= 1)
    {
      PikaPDBStatusType  status;
      PikaValueArray    *return_vals;
      PikaImage         *image = NULL;
      gchar             *uri   = NULL;

      uri = g_file_get_uri (file);

      return_vals =
        pika_pdb_execute_procedure_by_name (pika->pdb,
                                            context, progress, error,
                                            pika_object_get_name (procedure),
                                            G_TYPE_FILE, file,
                                            G_TYPE_INT,  size,
                                            G_TYPE_NONE);

      g_free (uri);

      status = g_value_get_enum (pika_value_array_index (return_vals, 0));

      if (status == PIKA_PDB_SUCCESS &&
          PIKA_VALUE_HOLDS_IMAGE (pika_value_array_index (return_vals, 1)))
        {
          image = g_value_get_object (pika_value_array_index (return_vals, 1));

          if (pika_value_array_length (return_vals) >= 3 &&
              G_VALUE_HOLDS_INT (pika_value_array_index (return_vals, 2)) &&
              G_VALUE_HOLDS_INT (pika_value_array_index (return_vals, 3)))
            {
              *image_width =
                MAX (0, g_value_get_int (pika_value_array_index (return_vals, 2)));

              *image_height =
                MAX (0, g_value_get_int (pika_value_array_index (return_vals, 3)));

              if (pika_value_array_length (return_vals) >= 5 &&
                  G_VALUE_HOLDS_INT (pika_value_array_index (return_vals, 4)))
                {
                  gint value = g_value_get_int (pika_value_array_index (return_vals, 4));

                  switch (value)
                    {
                    case PIKA_RGB_IMAGE:
                      *format = pika_babl_format (PIKA_RGB,
                                                  PIKA_PRECISION_U8_NON_LINEAR,
                                                  FALSE, NULL);
                      break;

                    case PIKA_RGBA_IMAGE:
                      *format = pika_babl_format (PIKA_RGB,
                                                  PIKA_PRECISION_U8_NON_LINEAR,
                                                  TRUE, NULL);
                      break;

                    case PIKA_GRAY_IMAGE:
                      *format = pika_babl_format (PIKA_GRAY,
                                                  PIKA_PRECISION_U8_NON_LINEAR,
                                                  FALSE, NULL);
                      break;

                    case PIKA_GRAYA_IMAGE:
                      *format = pika_babl_format (PIKA_GRAY,
                                                  PIKA_PRECISION_U8_NON_LINEAR,
                                                  TRUE, NULL);
                      break;

                    case PIKA_INDEXED_IMAGE:
                    case PIKA_INDEXEDA_IMAGE:
                      {
                        const Babl *rgb;
                        const Babl *rgba;

                        babl_new_palette ("-pika-indexed-format-dummy",
                                          &rgb, &rgba);

                        if (value == PIKA_INDEXED_IMAGE)
                          *format = rgb;
                        else
                          *format = rgba;
                      }
                      break;

                    default:
                      break;
                    }
                }

              if (pika_value_array_length (return_vals) >= 6 &&
                  G_VALUE_HOLDS_INT (pika_value_array_index (return_vals, 5)))
                {
                  *num_layers =
                    MAX (0, g_value_get_int (pika_value_array_index (return_vals, 5)));
                }
            }

          if (image)
            {
              file_open_sanitize_image (image, FALSE);

              *mime_type = g_slist_nth_data (file_proc->mime_types_list, 0);

#ifdef PIKA_UNSTABLE
              g_printerr ("opened thumbnail at %d x %d\n",
                          pika_image_get_width  (image),
                          pika_image_get_height (image));
#endif
            }
        }

      pika_value_array_unref (return_vals);

      return image;
    }

  return NULL;
}

PikaImage *
file_open_with_display (Pika               *pika,
                        PikaContext        *context,
                        PikaProgress       *progress,
                        GFile              *file,
                        gboolean            as_new,
                        GObject            *monitor,
                        PikaPDBStatusType  *status,
                        GError            **error)
{
  return file_open_with_proc_and_display (pika, context, progress,
                                          file, as_new, NULL,
                                          monitor,
                                          status, error);
}

PikaImage *
file_open_with_proc_and_display (Pika                *pika,
                                 PikaContext         *context,
                                 PikaProgress        *progress,
                                 GFile               *file,
                                 gboolean             as_new,
                                 PikaPlugInProcedure *file_proc,
                                 GObject             *monitor,
                                 PikaPDBStatusType   *status,
                                 GError             **error)
{
  PikaImage   *image;
  const gchar *mime_type = NULL;
  PikaRunMode  run_mode  = PIKA_RUN_INTERACTIVE;

  g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
  g_return_val_if_fail (PIKA_IS_CONTEXT (context), NULL);
  g_return_val_if_fail (progress == NULL || PIKA_IS_PROGRESS (progress), NULL);
  g_return_val_if_fail (G_IS_FILE (file), NULL);
  g_return_val_if_fail (monitor == NULL || G_IS_OBJECT (monitor), NULL);
  g_return_val_if_fail (status != NULL, NULL);

  if (pika->no_interface)
    run_mode = PIKA_RUN_NONINTERACTIVE;

  image = file_open_image (pika, context, progress,
                           file,
                           as_new,
                           file_proc,
                           run_mode,
                           status,
                           &mime_type,
                           error);

  if (image)
    {
      /* If the file was imported we want to set the layer name to the
       * file name. For now, assume that multi-layered imported images
       * have named the layers already, so only rename the layer of
       * single-layered imported files. Note that this will also
       * rename already named layers from e.g. single-layered PSD
       * files. To solve this properly, we would need new file plug-in
       * API.
       */
      if (! file_proc)
        file_proc = pika_image_get_load_proc (image);

      if (file_open_file_proc_is_import (file_proc) &&
          pika_image_get_n_layers (image) == 1)
        {
          PikaObject *layer = pika_image_get_layer_iter (image)->data;
          gchar      *basename;

          basename = g_path_get_basename (pika_file_get_utf8_name (file));

          pika_item_rename (PIKA_ITEM (layer), basename, NULL);
          pika_image_undo_free (image);
          pika_image_clean_all (image);

          g_free (basename);
        }

      if (pika_create_display (image->pika, image, PIKA_UNIT_PIXEL, 1.0,
                               monitor))
        {
          /*  the display owns the image now  */
          g_object_unref (image);
        }

      if (! as_new)
        {
          PikaDocumentList *documents = PIKA_DOCUMENT_LIST (pika->documents);
          PikaImagefile    *imagefile;
          GFile            *any_file;

          imagefile = pika_document_list_add_file (documents, file, mime_type);

          /*  can only create a thumbnail if the passed file and the
           *  resulting image's file match. Use any_file() here so we
           *  create thumbnails for both XCF and imported images.
           */
          any_file = pika_image_get_any_file (image);

          if (any_file && g_file_equal (file, any_file))
            {
              /*  no need to save a thumbnail if there's a good one already  */
              if (! pika_imagefile_check_thumbnail (imagefile))
                {
                  pika_imagefile_save_thumbnail (imagefile, mime_type, image,
                                                 NULL);
                }
            }
        }

      /*  announce that we opened this image  */
      pika_image_opened (image->pika, file);
    }

  return image;
}

GList *
file_open_layers (Pika                *pika,
                  PikaContext         *context,
                  PikaProgress        *progress,
                  PikaImage           *dest_image,
                  gboolean             merge_visible,
                  GFile               *file,
                  PikaRunMode          run_mode,
                  PikaPlugInProcedure *file_proc,
                  PikaPDBStatusType   *status,
                  GError             **error)
{
  PikaImage   *new_image;
  GList       *layers    = NULL;
  const gchar *mime_type = NULL;

  g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
  g_return_val_if_fail (PIKA_IS_CONTEXT (context), NULL);
  g_return_val_if_fail (progress == NULL || PIKA_IS_PROGRESS (progress), NULL);
  g_return_val_if_fail (PIKA_IS_IMAGE (dest_image), NULL);
  g_return_val_if_fail (G_IS_FILE (file), NULL);
  g_return_val_if_fail (status != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  new_image = file_open_image (pika, context, progress,
                               file, FALSE,
                               file_proc,
                               run_mode,
                               status, &mime_type, error);

  if (new_image)
    {
      gint n_visible = 0;

      pika_image_undo_disable (new_image);

      layers = file_open_get_layers (new_image, merge_visible, &n_visible);

      if (merge_visible && n_visible > 1)
        {
          g_list_free (layers);

          layers = pika_image_merge_visible_layers (new_image, context,
                                                    PIKA_CLIP_TO_IMAGE,
                                                    FALSE, FALSE,
                                                    NULL);
          layers = g_list_copy (layers);
        }

      if (layers)
        {
          gchar *basename;

          basename = g_path_get_basename (pika_file_get_utf8_name (file));
          file_open_convert_items (dest_image, basename, layers);
          g_free (basename);

          pika_document_list_add_file (PIKA_DOCUMENT_LIST (pika->documents),
                                       file, mime_type);
        }
      else
        {
          g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                               _("Image doesn't contain any layers"));
          *status = PIKA_PDB_EXECUTION_ERROR;
        }

      g_object_unref (new_image);
    }

  return g_list_reverse (layers);
}


/*  This function is called for filenames passed on the command-line
 *  or from the D-Bus service.
 */
gboolean
file_open_from_command_line (Pika     *pika,
                             GFile    *file,
                             gboolean  as_new,
                             GObject  *monitor)

{
  PikaImage         *image;
  PikaDisplay       *display;
  PikaPDBStatusType  status;
  gboolean           success = FALSE;
  GError            *error   = NULL;

  g_return_val_if_fail (PIKA_IS_PIKA (pika), FALSE);
  g_return_val_if_fail (G_IS_FILE (file), FALSE);
  g_return_val_if_fail (monitor == NULL || G_IS_OBJECT (monitor), FALSE);

  display = pika_get_empty_display (pika);

  /* show the progress in the last opened display, see bug #704896 */
  if (! display)
    display = pika_context_get_display (pika_get_user_context (pika));

  if (display)
    g_object_add_weak_pointer (G_OBJECT (display), (gpointer) &display);

  image = file_open_with_display (pika,
                                  pika_get_user_context (pika),
                                  PIKA_PROGRESS (display),
                                  file, as_new,
                                  monitor,
                                  &status, &error);

  if (image)
    {
      success = TRUE;

      g_object_set_data_full (G_OBJECT (pika), PIKA_FILE_OPEN_LAST_FILE_KEY,
                              g_object_ref (file),
                              (GDestroyNotify) g_object_unref);
    }
  else if (status != PIKA_PDB_SUCCESS && status != PIKA_PDB_CANCEL && display)
    {
      pika_message (pika, G_OBJECT (display), PIKA_MESSAGE_ERROR,
                    _("Opening '%s' failed: %s"),
                    pika_file_get_utf8_name (file), error->message);
      g_clear_error (&error);
    }

  if (display)
    g_object_remove_weak_pointer (G_OBJECT (display), (gpointer) &display);

  return success;
}


/*  private functions  */

static void
file_open_sanitize_image (PikaImage *image,
                          gboolean   as_new)
{
  if (as_new)
    pika_image_set_file (image, NULL);

  /* clear all undo steps */
  pika_image_undo_free (image);

  /* make sure that undo is enabled */
  while (! pika_image_undo_is_enabled (image))
    pika_image_undo_thaw (image);

  /* Set the image to clean. Note that export dirtiness is not set to
   * clean here; we can only consider export clean after the first
   * export
   */
  pika_image_clean_all (image);

  /* Make sure the projection is completely constructed from valid
   * layers, this is needed in case something triggers projection or
   * image preview creation before all layers are loaded, see bug #767663.
   */
  pika_image_invalidate_all (image);

  /* Make sure all image states are up-to-date */
  pika_image_flush (image);
}

/* Converts items from one image to another */
static void
file_open_convert_items (PikaImage   *dest_image,
                         const gchar *basename,
                         GList       *items)
{
  GList *list;

  for (list = items; list; list = g_list_next (list))
    {
      PikaItem *src = list->data;
      PikaItem *item;

      item = pika_item_convert (src, dest_image, G_TYPE_FROM_INSTANCE (src));

      if (g_list_length (items) == 1)
        {
          pika_object_set_name (PIKA_OBJECT (item), basename);
        }
      else
        {
          pika_object_set_name (PIKA_OBJECT (item),
                                pika_object_get_name (src));
        }

      list->data = item;
    }
}

static GList *
file_open_get_layers (PikaImage *image,
                      gboolean   merge_visible,
                      gint      *n_visible)
{
  GList *iter   = NULL;
  GList *layers = NULL;

  for (iter = pika_image_get_layer_iter (image);
       iter;
       iter = g_list_next (iter))
    {
      PikaItem *item = iter->data;

      if (! merge_visible)
        layers = g_list_prepend (layers, item);

      if (pika_item_get_visible (item))
        {
          if (n_visible)
            (*n_visible)++;

          if (! layers)
            layers = g_list_prepend (layers, item);
        }
    }

  return layers;
}

static gboolean
file_open_file_proc_is_import (PikaPlugInProcedure *file_proc)
{
  return !(file_proc &&
           file_proc->mime_types &&
           strcmp (file_proc->mime_types, "image/x-xcf") == 0);
}