dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/libgimp/gimploadprocedure.c

474 lines
15 KiB
C
Raw Normal View History

libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimploadprocedure.c
* Copyright (C) 2019 Michael Natterer <mitch@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/>.
*/
#include "config.h"
#include "gimp.h"
pdb, libgimp: move the old file proc registering API to gimplegacy.[ch] Also, #define GIMP_DISABLE_COMPAT_CRUFT in all GimpPlugIn related files to prevent accidential use of the old API.
2019-08-11 19:21:55 +08:00
Issue #3912: Object proxy management not happy with bindings. We cannot be 100% sure generically (i.e. for all possible bindings available with GObject Introspection) if bindings add their own reference to objects or not. Clearly we have cases when they always do (Lua, Javascript), cases when they do only in certain conditions (global Python variables) and cases when they don't (Vala). What we know for sure is that in these script languages, developers don't manually manage memory anyway. So the additional reference is not their fact. So let's just maintain a list of automatic memory managed binding languages, among the few we officially support (i.e. the ones for which we have working test plug-ins) and verify by executable extension if the plug-in is written in one of these. Both keeping a manually-updated list and verifying by extension are not so pretty solution, but for now it will do.
2023-10-15 22:34:11 +08:00
#include "libgimpbase/gimpwire.h" /* FIXME kill this include */
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
#include "gimploadprocedure.h"
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
#include "gimppdb_pdb.h"
Issue #3912: Object proxy management not happy with bindings. We cannot be 100% sure generically (i.e. for all possible bindings available with GObject Introspection) if bindings add their own reference to objects or not. Clearly we have cases when they always do (Lua, Javascript), cases when they do only in certain conditions (global Python variables) and cases when they don't (Vala). What we know for sure is that in these script languages, developers don't manually manage memory anyway. So the additional reference is not their fact. So let's just maintain a list of automatic memory managed binding languages, among the few we officially support (i.e. the ones for which we have working test plug-ins) and verify by executable extension if the plug-in is written in one of these. Both keeping a manually-updated list and verifying by extension are not so pretty solution, but for now it will do.
2023-10-15 22:34:11 +08:00
#include "gimpplugin-private.h"
libgimp: all _gimp_procedure_config_begin|end_*() functions made private. Since now all GimpProcedure and subclasses run these before and after the relevant run() functions, there is no need to keep these public.
2023-10-15 23:01:47 +08:00
#include "gimpprocedureconfig-private.h"
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
#include "libgimp-intl.h"
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
/**
* GimpLoadProcedure:
*
* A [class@Procedure] subclass that makes it easier to write file load
* procedures.
*
* It automatically adds the standard
*
* ( [enum@RunMode], [iface@Gio.File] )
*
* arguments and the standard
*
* ( [class@Image] )
*
* return value of a load procedure. It is possible to add additional
* arguments.
*
* When invoked via [method@Procedure.run], it unpacks these standard
* arguments and calls @run_func which is a [callback@RunImageFunc]. The
* "args" [struct@ValueArray] of [callback@RunImageFunc] only contains
* additionally added arguments.
*/
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
typedef struct _GimpLoadProcedurePrivate
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
{
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
GimpRunLoadFunc run_func;
gpointer run_data;
GDestroyNotify run_data_destroy;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
gboolean handles_raw;
gchar *thumbnail_proc;
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
} GimpLoadProcedurePrivate;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
static void gimp_load_procedure_constructed (GObject *object);
static void gimp_load_procedure_finalize (GObject *object);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
static void gimp_load_procedure_install (GimpProcedure *procedure);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
static GimpValueArray *
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
gimp_load_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args);
static GimpProcedureConfig *
gimp_load_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args,
gint n_args);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
G_DEFINE_TYPE_WITH_PRIVATE (GimpLoadProcedure, gimp_load_procedure, GIMP_TYPE_FILE_PROCEDURE)
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
#define parent_class gimp_load_procedure_parent_class
static void
gimp_load_procedure_class_init (GimpLoadProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *procedure_class = GIMP_PROCEDURE_CLASS (klass);
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
object_class->constructed = gimp_load_procedure_constructed;
object_class->finalize = gimp_load_procedure_finalize;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
procedure_class->install = gimp_load_procedure_install;
procedure_class->run = gimp_load_procedure_run;
procedure_class->create_config = gimp_load_procedure_create_config;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
static void
gimp_load_procedure_init (GimpLoadProcedure *procedure)
{
}
static void
gimp_load_procedure_constructed (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
plug-ins: Port argument macros to functions With the new API introduced int d1c4457f, we next need to port all plug-ins using the argument macros to functions. This will allow us to remove the macros as part of the 3.0 API clean-up.
2024-06-13 00:53:12 +08:00
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to load",
GIMP_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"Output image",
TRUE,
GIMP_PARAM_READWRITE);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
static void
gimp_load_procedure_finalize (GObject *object)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedure *procedure = GIMP_LOAD_PROCEDURE (object);
GimpLoadProcedurePrivate *priv;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv = gimp_load_procedure_get_instance_private (procedure);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
if (priv->run_data_destroy)
priv->run_data_destroy (priv->run_data);
g_clear_pointer (&priv->thumbnail_proc, g_free);
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_load_procedure_install (GimpProcedure *procedure)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedurePrivate *priv;
GimpLoadProcedure *load_proc = GIMP_LOAD_PROCEDURE (procedure);
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *mime_types;
gint priority;
priv = gimp_load_procedure_get_instance_private (load_proc);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_load_handler (gimp_procedure_get_name (procedure),
gimp_file_procedure_get_extensions (file_proc),
gimp_file_procedure_get_prefixes (file_proc),
gimp_file_procedure_get_magics (file_proc));
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
Change the "handles uri" flag of file procedures to "handle remote" And always pass URIs to all file procedures, the ones what didn't register as "handles remove" will only ever get local file:// URIs. Change all file plug-ins (also legacy ones) to expect URIs instead of filenames, and convert to local paths in the plug-in. The wire protocol should now be almost 100% clean of non-UTF-8 strings.
2019-08-19 18:05:12 +08:00
if (gimp_file_procedure_get_handles_remote (file_proc))
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_handles_remote (gimp_procedure_get_name (procedure));
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
mime_types = gimp_file_procedure_get_mime_types (file_proc);
if (mime_types)
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_mime_types (gimp_procedure_get_name (procedure),
mime_types);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
priority = gimp_file_procedure_get_priority (file_proc);
if (priority != 0)
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_priority (gimp_procedure_get_name (procedure),
priority);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
if (priv->handles_raw)
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_handles_raw (gimp_procedure_get_name (procedure));
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
if (priv->thumbnail_proc)
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_thumbnail_loader (gimp_procedure_get_name (procedure),
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv->thumbnail_proc);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
#define ARG_OFFSET 2
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
static GimpValueArray *
gimp_load_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedurePrivate *priv;
GimpPlugIn *plug_in;
GimpLoadProcedure *load_proc = GIMP_LOAD_PROCEDURE (procedure);
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpProcedureConfig *config;
GimpImage *image = NULL;
GimpMetadata *metadata = NULL;
gchar *mimetype = NULL;
GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL;
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GimpRunMode run_mode;
GFile *file;
gint i;
priv = gimp_load_procedure_get_instance_private (load_proc);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
pdb, app, libgimp, plug-ins: replace most PDB filenames/URIs by GFile and in an attack of madness, changes almost all file plug-in code to use GFile instead of filenames, which means passing the GFile down to the bottom and get its filename at the very end where it's actually needed.
2019-09-12 03:48:34 +08:00
run_mode = GIMP_VALUES_GET_ENUM (args, 0);
file = GIMP_VALUES_GET_FILE (args, 1);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
remaining = gimp_value_array_new (gimp_value_array_length (args) - ARG_OFFSET);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
for (i = ARG_OFFSET; i < gimp_value_array_length (args); i++)
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
{
GValue *value = gimp_value_array_index (args, i);
gimp_value_array_append (remaining, value);
}
libgimp: reimplement gimp_procedure_run_config() for public usage. Previous gimp_procedure_run_config() was in fact only good for private usage inside the various run() methods for the different GimpProcedure subtypes. The problem with this implementation is that the returned config object is not complete. For instance, for a GimpLoadProcedure, the "run-mode" and "file" properties are not part of the config object so you cannot call a GimpLoadProcedure with any of the gimp_procedure_run*() functions. Note: we had some working usage, e.g. in file-openraster, but only because it was running the load procedure as a GimpPDBProcedure whose returned config object was indeed always complete! As a consequence, I rename gimp_procedure_run_config() as an internal-only function _gimp_procedure_create_run_config() and I create a new gimp_procedure_run_config() which always return a full config with all arguments.
2024-05-02 03:47:55 +08:00
config = _gimp_procedure_create_run_config (procedure);
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
mimetype = (gchar *) gimp_file_procedure_get_mime_types (GIMP_FILE_PROCEDURE (procedure));
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
if (mimetype != NULL)
{
char *delim;
mimetype = g_strdup (mimetype);
mimetype = g_strstrip (mimetype);
delim = strstr (mimetype, ",");
if (delim)
*delim = '\0';
/* Though docs only writes about the list being comma-separated, our
* code apparently also split by spaces.
*/
delim = strstr (mimetype, " ");
if (delim)
*delim = '\0';
delim = strstr (mimetype, "\t");
if (delim)
*delim = '\0';
metadata = gimp_metadata_load_from_file (file, NULL);
g_free (mimetype);
}
else
{
flags = GIMP_METADATA_LOAD_NONE;
}
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
if (metadata == NULL)
metadata = gimp_metadata_new ();
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp: all _gimp_procedure_config_begin|end_*() functions made private. Since now all GimpProcedure and subclasses run these before and after the relevant run() functions, there is no need to keep these public.
2023-10-15 23:01:47 +08:00
_gimp_procedure_config_begin_run (config, image, run_mode, remaining);
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
return_values = priv->run_func (procedure, run_mode,
file, metadata, &flags,
config, priv->run_data);
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
if (return_values != NULL &&
gimp_value_array_length (return_values) > 0 &&
G_VALUE_HOLDS_ENUM (gimp_value_array_index (return_values, 0)))
status = GIMP_VALUES_GET_ENUM (return_values, 0);
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp: all _gimp_procedure_config_begin|end_*() functions made private. Since now all GimpProcedure and subclasses run these before and after the relevant run() functions, there is no need to keep these public.
2023-10-15 23:01:47 +08:00
_gimp_procedure_config_end_run (config, status);
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
if (status == GIMP_PDB_SUCCESS)
{
if (gimp_value_array_length (return_values) < 2 ||
! GIMP_VALUE_HOLDS_IMAGE (gimp_value_array_index (return_values, 1)))
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
{
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
GError *error = NULL;
status = GIMP_PDB_EXECUTION_ERROR;
g_set_error (&error, GIMP_PLUG_IN_ERROR, 0,
_("This file loading plug-in returned SUCCESS as a status without an image. "
"This is a bug in the plug-in code. Contact the plug-in developer."));
gimp_value_array_unref (return_values);
return_values = gimp_procedure_new_return_values (procedure, status, error);
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
}
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
else
{
image = GIMP_VALUES_GET_IMAGE (return_values, 1);
}
}
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
if (image != NULL && metadata != NULL && flags != GIMP_METADATA_LOAD_NONE)
gimp_image_metadata_load_finish (image, NULL, metadata, flags);
libgimp, libgimpbase: new gimp_load_procedure_new2() for run() function using… … a GimpProcedureConfig for arguments. This also factorizes the code to load metadata. By default, a GimpLoadProcedure will try and load metadata from a file (if Exiv2 knows the format). The run() function will be allowed to edit the GimpMetadata object but also the load flags before it is actually attached to the image, allowing plug-ins to have custom metadata handling code when needed.
2023-08-06 00:58:57 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
/* This is debug printing to help plug-in developers figure out best
* practices.
*/
Issue #3912: Object proxy management not happy with bindings. We cannot be 100% sure generically (i.e. for all possible bindings available with GObject Introspection) if bindings add their own reference to objects or not. Clearly we have cases when they always do (Lua, Javascript), cases when they do only in certain conditions (global Python variables) and cases when they don't (Vala). What we know for sure is that in these script languages, developers don't manually manage memory anyway. So the additional reference is not their fact. So let's just maintain a list of automatic memory managed binding languages, among the few we officially support (i.e. the ones for which we have working test plug-ins) and verify by executable extension if the plug-in is written in one of these. Both keeping a manually-updated list and verifying by extension are not so pretty solution, but for now it will do.
2023-10-15 22:34:11 +08:00
plug_in = gimp_procedure_get_plug_in (procedure);
if (G_OBJECT (config)->ref_count > 1 &&
_gimp_plug_in_manage_memory_manually (plug_in))
libgimp: GimpSaveProcedure to GimpExportProcedure This patch continues porting save API to export for the 3.0 release.
2024-04-20 11:08:57 +08:00
g_printerr ("%s: ERROR: the GimpExportProcedureConfig object was refed "
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
"by plug-in, it MUST NOT do that!\n", G_STRFUNC);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp, plug-ins: rename gimp_load_procedure_new2() as gimp_load_procedure_new(). All C load procedures are now moved to the new API.
2023-08-06 09:21:27 +08:00
g_object_unref (config);
g_clear_object (&metadata);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
gimp_value_array_unref (remaining);
return return_values;
}
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
static GimpProcedureConfig *
gimp_load_procedure_create_config (GimpProcedure *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 GIMP_PROCEDURE_CLASS (parent_class)->create_config (procedure,
args,
n_args);
}
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
/* public functions */
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
/**
* gimp_load_procedure_new:
* @plug_in: a #GimpPlugIn.
* @name: the new procedure's name.
* @proc_type: the new procedure's #GimpPDBProcType.
* @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 load procedure named @name which will call @run_func
* when invoked.
*
* See gimp_procedure_new() for information about @proc_type.
*
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* Returns: (transfer full): a new #GimpProcedure.
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
*
* Since: 3.0
**/
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
GimpProcedure *
gimp_load_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
GimpRunLoadFunc run_func,
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
gpointer run_data,
GDestroyNotify run_data_destroy)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedure *procedure;
GimpLoadProcedurePrivate *priv;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL);
Properly prefix the values of enum GimpPDBProcType to be GIMP_PDB_PROC_TYPE_PLUGIN, _EXTENSION etc.
2019-08-30 18:52:28 +08:00
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_INTERNAL, NULL);
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_EXTENSION, NULL);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
g_return_val_if_fail (run_func != NULL, NULL);
procedure = g_object_new (GIMP_TYPE_LOAD_PROCEDURE,
"plug-in", plug_in,
"name", name,
"procedure-type", proc_type,
NULL);
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv = gimp_load_procedure_get_instance_private (procedure);
priv->run_func = run_func;
priv->run_data = run_data;
priv->run_data_destroy = run_data_destroy;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
return GIMP_PROCEDURE (procedure);
}
/**
* gimp_load_procedure_set_handles_raw:
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* @procedure: A load procedure object.
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
* @handles_raw: The procedure's handles raw flag.
*
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* Registers a load procedure as capable of handling raw digital camera loads.
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
*
libgimp: Fix casing in documentation
2024-04-24 19:34:01 +08:00
* Note that you cannot call this function on [class@VectorLoadProcedure]
app, libgimp, pdb: new GimpVectorLoadProcedure class. It's still basic but will help to share code for support of various vector-able formats, such as the logic for dimensioning them, but also the generated GUI. Not only this, but we are paving the way for the link layers (though it'll be after GIMP 3, we want plug-in procedures' API to stay stable) by giving a way for a plug-in procedure to advertize a vector format support. This way, the core will know when a source file is vector and can be directly reloaded at any target size (right now, in my MR for link layers, the list of "vector" formats is hardcoded, which is not reliable).
2024-04-23 05:11:37 +08:00
* subclass objects.
*
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
* Since: 3.0
**/
void
gimp_load_procedure_set_handles_raw (GimpLoadProcedure *procedure,
gint handles_raw)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedurePrivate *priv;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
g_return_if_fail (GIMP_IS_LOAD_PROCEDURE (procedure));
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv = gimp_load_procedure_get_instance_private (procedure);
priv->handles_raw = handles_raw;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
/**
* gimp_load_procedure_get_handles_raw:
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* @procedure: A load procedure object.
*
* Returns the procedure's 'handles raw' flag as set with
* [method@GimpLoadProcedure.set_handles_raw].
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
*
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* Returns: The procedure's 'handles raw' flag.
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
*
* Since: 3.0
**/
gint
gimp_load_procedure_get_handles_raw (GimpLoadProcedure *procedure)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedurePrivate *priv;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
g_return_val_if_fail (GIMP_IS_LOAD_PROCEDURE (procedure), 0);
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv = gimp_load_procedure_get_instance_private (procedure);
return priv->handles_raw;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
/**
* gimp_load_procedure_set_thumbnail_loader:
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* @procedure: A load procedure object.
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
* @thumbnail_proc: The name of the thumbnail load procedure.
*
* 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.
*
* Since: 3.0
**/
void
gimp_load_procedure_set_thumbnail_loader (GimpLoadProcedure *procedure,
const gchar *thumbnail_proc)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedurePrivate *priv;
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
g_return_if_fail (GIMP_IS_LOAD_PROCEDURE (procedure));
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv = gimp_load_procedure_get_instance_private (procedure);
g_free (priv->thumbnail_proc);
priv->thumbnail_proc = g_strdup (thumbnail_proc);
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
}
/**
* gimp_load_procedure_get_thumbnail_loader:
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* @procedure: A load procedure object.
*
* Returns the procedure's thumbnail loader procedure as set with
* [method@GimpLoadProcedure.set_thumbnail_loader].
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
*
libgimp: Migrate gtk-doc annotations to gi-docgen Move some of the documentation from the constructor to the class itself, so that it show up more prevalently.
2021-12-30 02:08:22 +08:00
* Returns: The procedure's thumbnail loader procedure
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
*
* Since: 3.0
**/
const gchar *
gimp_load_procedure_get_thumbnail_loader (GimpLoadProcedure *procedure)
{
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
GimpLoadProcedurePrivate *priv;
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
g_return_val_if_fail (GIMP_IS_LOAD_PROCEDURE (procedure), NULL);
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
priv = gimp_load_procedure_get_instance_private (procedure);
return priv->thumbnail_proc;
pdb, libgimp: add gimp_load_procedure_set_thumbnail_loader() and move the old API to gimplegacy.[ch]
2019-08-11 20:27:41 +08:00
}