/* 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 Spencer Kimball and Peter Mattis * * pikathumbnailprocedure.c * Copyright (C) 2019 Michael Natterer * * 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 . */ #include "config.h" #include "pika.h" #include "libpikabase/pikawire.h" /* FIXME kill this include */ #include "pikaplugin-private.h" #include "pikathumbnailprocedure.h" #include "pikaprocedureconfig-private.h" struct _PikaThumbnailProcedurePrivate { PikaRunThumbnailFunc run_func; gpointer run_data; GDestroyNotify run_data_destroy; }; static void pika_thumbnail_procedure_constructed (GObject *object); static void pika_thumbnail_procedure_finalize (GObject *object); static PikaValueArray * pika_thumbnail_procedure_run (PikaProcedure *procedure, const PikaValueArray *args); static PikaProcedureConfig * pika_thumbnail_procedure_create_config (PikaProcedure *procedure, GParamSpec **args, gint n_args); G_DEFINE_TYPE_WITH_PRIVATE (PikaThumbnailProcedure, pika_thumbnail_procedure, PIKA_TYPE_PROCEDURE) #define parent_class pika_thumbnail_procedure_parent_class static void pika_thumbnail_procedure_class_init (PikaThumbnailProcedureClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); PikaProcedureClass *procedure_class = PIKA_PROCEDURE_CLASS (klass); object_class->constructed = pika_thumbnail_procedure_constructed; object_class->finalize = pika_thumbnail_procedure_finalize; procedure_class->run = pika_thumbnail_procedure_run; procedure_class->create_config = pika_thumbnail_procedure_create_config; } static void pika_thumbnail_procedure_init (PikaThumbnailProcedure *procedure) { procedure->priv = pika_thumbnail_procedure_get_instance_private (procedure); } static void pika_thumbnail_procedure_constructed (GObject *object) { PikaProcedure *procedure = PIKA_PROCEDURE (object); G_OBJECT_CLASS (parent_class)->constructed (object); PIKA_PROC_ARG_FILE (procedure, "file", "File", "The file to load the thumbnail from", PIKA_PARAM_READWRITE); PIKA_PROC_ARG_INT (procedure, "thumb-size", "Thumb Size", "Preferred thumbnail size", 16, 2014, 256, PIKA_PARAM_READWRITE); PIKA_PROC_VAL_IMAGE (procedure, "image", "Image", "Thumbnail image", TRUE, PIKA_PARAM_READWRITE); PIKA_PROC_VAL_INT (procedure, "image-width", "Image width", "Width of the full-sized image (0 for unknown)", 0, PIKA_MAX_IMAGE_SIZE, 0, PIKA_PARAM_READWRITE); PIKA_PROC_VAL_INT (procedure, "image-height", "Image height", "Height of the full-sized image (0 for unknown)", 0, PIKA_MAX_IMAGE_SIZE, 0, PIKA_PARAM_READWRITE); PIKA_PROC_VAL_ENUM (procedure, "image-type", "Image type", "Type of the image", PIKA_TYPE_IMAGE_TYPE, PIKA_RGB_IMAGE, PIKA_PARAM_READWRITE); PIKA_PROC_VAL_INT (procedure, "num-layers", "Num layers", "Number of layers in the image", 1, G_MAXINT, 1, PIKA_PARAM_READWRITE); } static void pika_thumbnail_procedure_finalize (GObject *object) { PikaThumbnailProcedure *procedure = PIKA_THUMBNAIL_PROCEDURE (object); if (procedure->priv->run_data_destroy) procedure->priv->run_data_destroy (procedure->priv->run_data); G_OBJECT_CLASS (parent_class)->finalize (object); } #define ARG_OFFSET 2 static PikaValueArray * pika_thumbnail_procedure_run (PikaProcedure *procedure, const PikaValueArray *args) { PikaPlugIn *plug_in; PikaThumbnailProcedure *thumbnail_proc = PIKA_THUMBNAIL_PROCEDURE (procedure); PikaValueArray *remaining; PikaValueArray *return_values; PikaProcedureConfig *config; GFile *file; gint size; PikaPDBStatusType status = PIKA_PDB_EXECUTION_ERROR; gint i; file = PIKA_VALUES_GET_FILE (args, 0); size = PIKA_VALUES_GET_INT (args, 1); remaining = pika_value_array_new (pika_value_array_length (args) - ARG_OFFSET); for (i = ARG_OFFSET; i < pika_value_array_length (args); i++) { GValue *value = pika_value_array_index (args, i); pika_value_array_append (remaining, value); } config = pika_procedure_create_config (procedure); _pika_procedure_config_begin_run (config, NULL, PIKA_RUN_NONINTERACTIVE, remaining); pika_value_array_unref (remaining); return_values = thumbnail_proc->priv->run_func (procedure, file, size, config, thumbnail_proc->priv->run_data); if (return_values != NULL && pika_value_array_length (return_values) > 0 && G_VALUE_HOLDS_ENUM (pika_value_array_index (return_values, 0))) status = PIKA_VALUES_GET_ENUM (return_values, 0); _pika_procedure_config_end_run (config, status); /* This is debug printing to help plug-in developers figure out best * practices. */ plug_in = pika_procedure_get_plug_in (procedure); if (G_OBJECT (config)->ref_count > 1 && _pika_plug_in_manage_memory_manually (plug_in)) g_printerr ("%s: ERROR: the PikaThumbnailProcedure config object was refed " "by plug-in, it MUST NOT do that!\n", G_STRFUNC); g_object_unref (config); return return_values; } static PikaProcedureConfig * pika_thumbnail_procedure_create_config (PikaProcedure *procedure, GParamSpec **args, gint n_args) { if (n_args > ARG_OFFSET) { args += ARG_OFFSET; n_args -= ARG_OFFSET; } else { args = NULL; n_args = 0; } return PIKA_PROCEDURE_CLASS (parent_class)->create_config (procedure, args, n_args); } /* public functions */ /** * pika_thumbnail_procedure_new: * @plug_in: a #PikaPlugIn. * @name: the new procedure's name. * @proc_type: the new procedure's #PikaPDBProcType. * @run_func: the run function for the new procedure. * @run_data: user data passed to @run_func. * @run_data_destroy: (nullable): free function for @run_data, or %NULL. * * Creates a new thumbnail procedure named @name which will call @run_func * when invoked. * * See pika_procedure_new() for information about @proc_type. * * #PikaThumbnailProcedure is a #PikaProcedure subclass that makes it easier * to write file thumbnail procedures. * * It automatically adds the standard * * (#GFile, size) * * arguments and the standard * * (#PikaImage, image-width, image-height, #PikaImageType, num-layers) * * return value of a thumbnail procedure. It is possible to add * additional arguments. * * When invoked via pika_procedure_run(), it unpacks these standard * arguments and calls @run_func which is a #PikaRunThumbnailFunc. The * "args" #PikaValueArray of #PikaRunThumbnailFunc only contains * additionally added arguments. * * #PikaRunThumbnailFunc must pika_value_array_truncate() the returned * #PikaValueArray to the number of return values it actually uses. * * Returns: a new #PikaProcedure. * * Since: 3.0 **/ PikaProcedure * pika_thumbnail_procedure_new (PikaPlugIn *plug_in, const gchar *name, PikaPDBProcType proc_type, PikaRunThumbnailFunc run_func, gpointer run_data, GDestroyNotify run_data_destroy) { PikaThumbnailProcedure *procedure; g_return_val_if_fail (PIKA_IS_PLUG_IN (plug_in), NULL); g_return_val_if_fail (pika_is_canonical_identifier (name), NULL); g_return_val_if_fail (proc_type != PIKA_PDB_PROC_TYPE_INTERNAL, NULL); g_return_val_if_fail (proc_type != PIKA_PDB_PROC_TYPE_EXTENSION, NULL); g_return_val_if_fail (run_func != NULL, NULL); procedure = g_object_new (PIKA_TYPE_THUMBNAIL_PROCEDURE, "plug-in", plug_in, "name", name, "procedure-type", proc_type, NULL); procedure->priv->run_func = run_func; procedure->priv->run_data = run_data; procedure->priv->run_data_destroy = run_data_destroy; return PIKA_PROCEDURE (procedure); }