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

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.
This commit is contained in:
Michael Natterer 2019-08-10 20:25:37 +02:00
parent 4a56f1d9cc
commit a79eaaf503
15 changed files with 1212 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libgimp/Makefile.am
View File

@ -123,8 +123,6 @@ libgimp_private_sources = \
gimppixbuf.h \
gimpplugin-private.c \
gimpplugin-private.h \
gimpprocedure-private.c \
gimpprocedure-private.h \
\
gimpunit_pdb.c \
gimpunit_pdb.h \

6
libgimp/Makefile.gi
View File

@ -112,12 +112,14 @@ libgimp_introspectable_headers = \
../libgimp/gimpbrushselect.h \
../libgimp/gimpchannel.h \
../libgimp/gimpdrawable.h \
../libgimp/gimpfileprocedure.h \
../libgimp/gimpfontselect.h \
../libgimp/gimpgimprc.h \
../libgimp/gimpgradientselect.h \
../libgimp/gimpimage.h \
../libgimp/gimpimagecolorprofile.h \
../libgimp/gimplayer.h \
../libgimp/gimploadprocedure.h \
../libgimp/gimppaletteselect.h \
../libgimp/gimpparamspecs.h \
../libgimp/gimppatternselect.h \
@ -125,6 +127,7 @@ libgimp_introspectable_headers = \
../libgimp/gimpplugin.h \
../libgimp/gimpprocedure.h \
../libgimp/gimpprogress.h \
../libgimp/gimpsaveprocedure.h \
../libgimp/gimpselection.h
libgimp_introspectable = \
@ -135,12 +138,14 @@ libgimp_introspectable = \
../libgimp/gimpbrushselect.c \
../libgimp/gimpchannel.c \
../libgimp/gimpdrawable.c \
../libgimp/gimpfileprocedure.c \
../libgimp/gimpfontselect.c \
../libgimp/gimpgimprc.c \
../libgimp/gimpgradientselect.c \
../libgimp/gimpimage.c \
../libgimp/gimpimagecolorprofile.c \
../libgimp/gimplayer.c \
../libgimp/gimploadprocedure.c \
../libgimp/gimppaletteselect.c \
../libgimp/gimpparamspecs.c \
../libgimp/gimppatternselect.c \
@ -148,6 +153,7 @@ libgimp_introspectable = \
../libgimp/gimpplugin.c \
../libgimp/gimpprocedure.c \
../libgimp/gimpprogress.c \
../libgimp/gimpsaveprocedure.c \
../libgimp/gimpselection.c
libgimpui_introspectable_headers = \

3
libgimp/gimp.h
View File

@ -44,14 +44,15 @@
#include <libgimp/gimpimage.h>
#include <libgimp/gimpimagecolorprofile.h>
#include <libgimp/gimplayer.h>
#include <libgimp/gimploadprocedure.h>
#include <libgimp/gimplegacy.h>
#include <libgimp/gimppaletteselect.h>
#include <libgimp/gimpparamspecs.h>
#include <libgimp/gimppatternselect.h>
#include <libgimp/gimppdb.h>
#include <libgimp/gimpplugin.h>
#include <libgimp/gimpprocedure.h>
#include <libgimp/gimpprogress.h>
#include <libgimp/gimpsaveprocedure.h>
#include <libgimp/gimpselection.h>
#include <libgimp/gimp_pdb_headers.h>

282
libgimp/gimpfileprocedure.c Normal file
View File

@ -0,0 +1,282 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpfileprocedure.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"
#include "gimpfileprocedure.h"
struct _GimpFileProcedurePrivate
{
gchar *mime_types;
gchar *extensions;
gchar *prefixes;
gchar *magics;
gint priority;
};
static void gimp_file_procedure_constructed (GObject *object);
static void gimp_file_procedure_finalize (GObject *object);
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GimpFileProcedure, gimp_file_procedure,
GIMP_TYPE_PROCEDURE)
#define parent_class gimp_file_procedure_parent_class
static void
gimp_file_procedure_class_init (GimpFileProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = gimp_file_procedure_constructed;
object_class->finalize = gimp_file_procedure_finalize;
}
static void
gimp_file_procedure_init (GimpFileProcedure *procedure)
{
procedure->priv = gimp_file_procedure_get_instance_private (procedure);
}
static void
gimp_file_procedure_constructed (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE));
}
static void
gimp_file_procedure_finalize (GObject *object)
{
GimpFileProcedure *procedure = GIMP_FILE_PROCEDURE (object);
g_clear_pointer (&procedure->priv->mime_types, g_free);
g_clear_pointer (&procedure->priv->extensions, g_free);
g_clear_pointer (&procedure->priv->prefixes, g_free);
g_clear_pointer (&procedure->priv->magics, g_free);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/* public functions */
/**
* gimp_file_procedure_set_mime_types:
* @procedure: A #GimpFileProcedure.
* @mime_types: A comma-separated list of MIME types, such as "image/jpeg".
*
* Associates MIME types with a file handler procedure.
*
* Registers MIME types for a file handler procedure. This allows GIMP
* to determine the MIME type of the file opened or saved using this
* procedure. It is recommended that only one MIME type is registered
* per file procedure; when registering more than one MIME type, GIMP
* will associate the first one with files opened or saved with this
* procedure.
*
* Since: 3.0
**/
void
gimp_file_procedure_set_mime_types (GimpFileProcedure *procedure,
const gchar *mime_types)
{
g_return_if_fail (GIMP_IS_FILE_PROCEDURE (procedure));
g_free (procedure->priv->mime_types);
procedure->priv->mime_types = g_strdup (mime_types);
}
/**
* gimp_file_procedure_get_mime_types:
* @procedure: A #GimpFileProcedure.
*
* Returns: The procedure's mime-type as set with
* gimp_file_procedure_set_mime_types().
*
* Since: 3.0
**/
const gchar *
gimp_file_procedure_get_mime_types (GimpFileProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_FILE_PROCEDURE (procedure), NULL);
return procedure->priv->mime_types;
}
/**
* gimp_file_procedure_set_extensions:
* @procedure: A #GimpFileProcedure.
* @extensions: A comma separated list of extensions this procedure can
* handle (i.e. "jpg,jpeg").
*
* Since: 3.0
**/
void
gimp_file_procedure_set_extensions (GimpFileProcedure *procedure,
const gchar *extensions)
{
g_return_if_fail (GIMP_IS_FILE_PROCEDURE (procedure));
g_free (procedure->priv->extensions);
procedure->priv->extensions = g_strdup (extensions);
}
/**
* gimp_file_procedure_get_extensions:
* @procedure: A #GimpFileProcedure.
*
* Returns: The procedure's extensions as set with
* gimp_file_procedure_set_extensions().
*
* Since: 3.0
**/
const gchar *
gimp_file_procedure_get_extensions (GimpFileProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_FILE_PROCEDURE (procedure), NULL);
return procedure->priv->extensions;
}
/**
* gimp_file_procedure_set_prefixes:
* @procedure: A #GimpFileProcedure.
* @prefixes: A comma separated list of prefixes this procedure can
* handle (i.e. "http:,ftp:").
*
* It should almost never be neccessary to register prefixes with file
* procedures, because most sorty of URIs should be handled by GIO.
*
* Since: 3.0
**/
void
gimp_file_procedure_set_prefixes (GimpFileProcedure *procedure,
const gchar *prefixes)
{
g_return_if_fail (GIMP_IS_FILE_PROCEDURE (procedure));
g_free (procedure->priv->prefixes);
procedure->priv->prefixes = g_strdup (prefixes);
}
/**
* gimp_file_procedure_get_prefixes:
* @procedure: A #GimpFileProcedure.
*
* Returns: The procedure's prefixes as set with
* gimp_file_procedure_set_prefixes().
*
* Since: 3.0
**/
const gchar *
gimp_file_procedure_get_prefixes (GimpFileProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_FILE_PROCEDURE (procedure), NULL);
return procedure->priv->prefixes;
}
/**
* gimp_file_procedure_set_magics:
* @procedure: A #GimpFileProcedure.
* @magics: A comma separated list of magic file information this procedure
* can hande (i.e. "0,string,GIF").
*
* Since: 3.0
**/
void
gimp_file_procedure_set_magics (GimpFileProcedure *procedure,
const gchar *magics)
{
g_return_if_fail (GIMP_IS_FILE_PROCEDURE (procedure));
g_free (procedure->priv->magics);
procedure->priv->magics = g_strdup (magics);
}
/**
* gimp_file_procedure_get_magics:
* @procedure: A #GimpFileProcedure.
*
* Returns: The procedure's magics as set with
* gimp_file_procedure_set_magics().
*
* Since: 3.0
**/
const gchar *
gimp_file_procedure_get_magics (GimpFileProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_FILE_PROCEDURE (procedure), NULL);
return procedure->priv->magics;
}
/**
* gimp_file_procedure_set_priority:
* @procedure: A #GimpFileProcedure.
* @priority: The procedure's priority.
*
* Sets the priority of a file handler procedure. When more than one
* procedure matches a given file, the procedure with the lowest
* priority is used; if more than one procedure has the lowest
* priority, it is unspecified which one of them is used. The default
* priority for file handler procedures is 0.
*
* Since: 3.0
**/
void
gimp_file_procedure_set_priority (GimpFileProcedure *procedure,
gint priority)
{
g_return_if_fail (GIMP_IS_FILE_PROCEDURE (procedure));
procedure->priv->priority = priority;
}
/**
* gimp_file_procedure_get_priority:
* @procedure: A #GimpFileProcedure.
*
* Returns: The procedure's priority as set with
* gimp_file_procedure_set_priority().
*
* Since: 3.0
**/
gint
gimp_file_procedure_get_priority (GimpFileProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_FILE_PROCEDURE (procedure), 0);
return procedure->priv->priority;
}

82
libgimp/gimpfileprocedure.h Normal file
View File

@ -0,0 +1,82 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpfileprocedure.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_FILE_PROCEDURE_H__
#define __GIMP_FILE_PROCEDURE_H__
#include <libgimp/gimpprocedure.h>
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
#define GIMP_TYPE_FILE_PROCEDURE (gimp_file_procedure_get_type ())
#define GIMP_FILE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_FILE_PROCEDURE, GimpFileProcedure))
#define GIMP_FILE_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_FILE_PROCEDURE, GimpFileProcedureClass))
#define GIMP_IS_FILE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_FILE_PROCEDURE))
#define GIMP_IS_FILE_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_FILE_PROCEDURE))
#define GIMP_FILE_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_FILE_PROCEDURE, GimpFileProcedureClass))
typedef struct _GimpFileProcedure GimpFileProcedure;
typedef struct _GimpFileProcedureClass GimpFileProcedureClass;
typedef struct _GimpFileProcedurePrivate GimpFileProcedurePrivate;
struct _GimpFileProcedure
{
GimpProcedure parent_instance;
GimpFileProcedurePrivate *priv;
};
struct _GimpFileProcedureClass
{
GimpProcedureClass parent_class;
};
GType gimp_file_procedure_get_type (void) G_GNUC_CONST;
void gimp_file_procedure_set_mime_types (GimpFileProcedure *procedure,
const gchar *mime_types);
const gchar * gimp_file_procedure_get_mime_types (GimpFileProcedure *procedure);
void gimp_file_procedure_set_extensions (GimpFileProcedure *procedure,
const gchar *extensions);
const gchar * gimp_file_procedure_get_extensions (GimpFileProcedure *procedure);
void gimp_file_procedure_set_prefixes (GimpFileProcedure *procedure,
const gchar *prefixes);
const gchar * gimp_file_procedure_get_prefixes (GimpFileProcedure *procedure);
void gimp_file_procedure_set_magics (GimpFileProcedure *procedure,
const gchar *magics);
const gchar * gimp_file_procedure_get_magics (GimpFileProcedure *procedure);
void gimp_file_procedure_set_priority (GimpFileProcedure *procedure,
gint priority);
gint gimp_file_procedure_get_priority (GimpFileProcedure *procedure);
G_END_DECLS
#endif /* __GIMP_FILE_PROCEDURE_H__ */

258
libgimp/gimploadprocedure.c Normal file
View File

@ -0,0 +1,258 @@
/* 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"
#include "gimploadprocedure.h"
struct _GimpLoadProcedurePrivate
{
GimpLoadFunc run_func;
gpointer run_data;
GDestroyNotify run_data_destroy;
gboolean handles_raw;
};
static void gimp_load_procedure_constructed (GObject *object);
static void gimp_load_procedure_finalize (GObject *object);
static void gimp_load_procedure_install (GimpProcedure *procedure);
static GimpValueArray *
gimp_load_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args);
G_DEFINE_TYPE_WITH_PRIVATE (GimpLoadProcedure, gimp_load_procedure,
GIMP_TYPE_FILE_PROCEDURE)
#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);
object_class->constructed = gimp_load_procedure_constructed;
object_class->finalize = gimp_load_procedure_finalize;
procedure_class->install = gimp_load_procedure_install;
procedure_class->run = gimp_load_procedure_run;
}
static void
gimp_load_procedure_init (GimpLoadProcedure *procedure)
{
procedure->priv = gimp_load_procedure_get_instance_private (procedure);
}
static void
gimp_load_procedure_constructed (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("uri",
"URI",
"The URI of the file "
"to load",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("raw-uri",
"Raw URI",
"The URI of the file "
"to load",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("image",
"Image",
"Output image",
FALSE,
GIMP_PARAM_READWRITE));
}
static void
gimp_load_procedure_finalize (GObject *object)
{
GimpLoadProcedure *procedure = GIMP_LOAD_PROCEDURE (object);
if (procedure->priv->run_data_destroy)
procedure->priv->run_data_destroy (procedure->priv->run_data);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_load_procedure_install (GimpProcedure *procedure)
{
GimpLoadProcedure *load_proc = GIMP_LOAD_PROCEDURE (procedure);
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *mime_types;
gint priority;
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
if (gimp_file_procedure_get_magics (file_proc))
{
gimp_register_magic_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));
}
else
{
gimp_register_load_handler (gimp_procedure_get_name (procedure),
gimp_file_procedure_get_extensions (file_proc),
gimp_file_procedure_get_prefixes (file_proc));
}
gimp_register_file_handler_uri (gimp_procedure_get_name (procedure));
mime_types = gimp_file_procedure_get_mime_types (file_proc);
if (mime_types)
gimp_register_file_handler_mime (gimp_procedure_get_name (procedure),
mime_types);
priority = gimp_file_procedure_get_priority (file_proc);
if (priority != 0)
gimp_register_file_handler_priority (gimp_procedure_get_name (procedure),
priority);
if (load_proc->priv->handles_raw)
gimp_register_file_handler_raw (gimp_procedure_get_name (procedure));
}
static GimpValueArray *
gimp_load_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
GimpLoadProcedure *load_proc = GIMP_LOAD_PROCEDURE (procedure);
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpRunMode run_mode;
const gchar *uri;
GFile *file;
gint i;
run_mode = g_value_get_enum (gimp_value_array_index (args, 0));
uri = g_value_get_string (gimp_value_array_index (args, 1));
/* raw_uri = g_value_get_string (gimp_value_array_index (args, 2)); */
file = g_file_new_for_uri (uri);
remaining = gimp_value_array_new (gimp_value_array_length (args) - 3);
for (i = 3; i < gimp_value_array_length (args); i++)
{
GValue *value = gimp_value_array_index (args, i);
gimp_value_array_append (remaining, value);
}
return_values = load_proc->priv->run_func (procedure,
run_mode,
file,
remaining,
load_proc->priv->run_data);
gimp_value_array_unref (remaining);
g_object_unref (file);
return return_values;
}
/* public functions */
GimpProcedure *
gimp_load_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpLoadFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy)
{
GimpLoadProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL);
g_return_val_if_fail (proc_type != GIMP_INTERNAL, NULL);
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);
procedure->priv->run_func = run_func;
procedure->priv->run_data = run_data;
procedure->priv->run_data_destroy = run_data_destroy;
return GIMP_PROCEDURE (procedure);
}
/**
* gimp_load_procedure_set_handles_raw:
* @procedure: A #GimpLoadProcedure.
* @handles_raw: The procedure's handles raw flag.
*
* Registers a load loader procedure as capable of handling raw
* digital camera loads.
*
* Since: 3.0
**/
void
gimp_load_procedure_set_handles_raw (GimpLoadProcedure *procedure,
gint handles_raw)
{
g_return_if_fail (GIMP_IS_LOAD_PROCEDURE (procedure));
procedure->priv->handles_raw = handles_raw;
}
/**
* gimp_load_procedure_get_handles_raw:
* @procedure: A #GimpLoadProcedure.
*
* Returns: The procedure's handles raw flag as set with
* gimp_load_procedure_set_handles_raw().
*
* Since: 3.0
**/
gint
gimp_load_procedure_get_handles_raw (GimpLoadProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_LOAD_PROCEDURE (procedure), 0);
return procedure->priv->handles_raw;
}

95
libgimp/gimploadprocedure.h Normal file
View File

@ -0,0 +1,95 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimploadprocedure.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_LOAD_PROCEDURE_H__
#define __GIMP_LOAD_PROCEDURE_H__
#include <libgimp/gimpfileprocedure.h>
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
/**
* GimpLoadFunc:
* @procedure: the #GimpProcedure that runs.
* @run_mode: the #GimpRunMode.
* @file: the #GFile to load from.
* @args: the @procedure's remaining arguments.
* @run_data: the run_data given in gimp_load_procedure_new().
*
* The load function is run during the lifetime of the GIMP session,
* each time a plug-in load procedure is called.
*
* Returns: (transfer full): the @procedure's return values.
*
* Since: 3.0
**/
typedef GimpValueArray * (* GimpLoadFunc) (GimpProcedure *procedure,
GimpRunMode run_mode,
GFile *file,
const GimpValueArray *args,
gpointer run_data);
#define GIMP_TYPE_LOAD_PROCEDURE (gimp_load_procedure_get_type ())
#define GIMP_LOAD_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_LOAD_PROCEDURE, GimpLoadProcedure))
#define GIMP_LOAD_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LOAD_PROCEDURE, GimpLoadProcedureClass))
#define GIMP_IS_LOAD_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_LOAD_PROCEDURE))
#define GIMP_IS_LOAD_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LOAD_PROCEDURE))
#define GIMP_LOAD_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_LOAD_PROCEDURE, GimpLoadProcedureClass))
typedef struct _GimpLoadProcedure GimpLoadProcedure;
typedef struct _GimpLoadProcedureClass GimpLoadProcedureClass;
typedef struct _GimpLoadProcedurePrivate GimpLoadProcedurePrivate;
struct _GimpLoadProcedure
{
GimpFileProcedure parent_instance;
GimpLoadProcedurePrivate *priv;
};
struct _GimpLoadProcedureClass
{
GimpFileProcedureClass parent_class;
};
GType gimp_load_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_load_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpLoadFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy);
void gimp_load_procedure_set_handles_raw (GimpLoadProcedure *procedure,
gboolean handles_raw);
gboolean gimp_load_procedure_get_handles_raw (GimpLoadProcedure *procedure);
G_END_DECLS
#endif /* __GIMP_LOAD_PROCEDURE_H__ */

3
libgimp/gimpplugin-private.c
View File

@ -31,7 +31,6 @@
#include "gimpgpparams.h"
#include "gimpplugin-private.h"
#include "gimpplugin_pdb.h"
#include "gimpprocedure-private.h"
/* local function prototpes */
@ -185,7 +184,7 @@ gimp_plug_in_register (GimpPlugIn *plug_in,
procedure = gimp_plug_in_create_procedure (plug_in, name);
if (procedure)
{
_gimp_procedure_register (procedure);
GIMP_PROCEDURE_GET_CLASS (procedure)->install (procedure);
g_object_unref (procedure);
}
else

5
libgimp/gimpplugin.c
View File

@ -31,7 +31,6 @@
#include "gimpplugin-private.h"
#include "gimpplugin_pdb.h"
#include "gimpprocedure-private.h"
/**
@ -393,7 +392,7 @@ gimp_plug_in_add_temp_procedure (GimpPlugIn *plug_in,
g_list_prepend (plug_in->priv->temp_procedures,
g_object_ref (procedure));
_gimp_procedure_register (procedure);
GIMP_PROCEDURE_GET_CLASS (procedure)->install (procedure);
}
/**
@ -419,7 +418,7 @@ gimp_plug_in_remove_temp_procedure (GimpPlugIn *plug_in,
if (procedure)
{
_gimp_procedure_unregister (procedure);
GIMP_PROCEDURE_GET_CLASS (procedure)->uninstall (procedure);
plug_in->priv->temp_procedures =
g_list_remove (plug_in->priv->temp_procedures,

182
libgimp/gimpprocedure-private.c
View File

@ -1,182 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
*
* gimpprocedure-private.c
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gimp.h"
#include "libgimpbase/gimpprotocol.h"
#include "libgimpbase/gimpwire.h"
#include "gimpgpparams.h"
#include "gimpplugin-private.h"
#include "gimpplugin_pdb.h"
#include "gimpprocedure-private.h"
/* public functions */
void
_gimp_procedure_register (GimpProcedure *procedure)
{
GParamSpec **args;
GParamSpec **return_vals;
gint n_args;
gint n_return_vals;
GList *list;
GimpPlugIn *plug_in;
GPProcInstall proc_install;
GimpIconType icon_type;
guint8 *icon_data = NULL;
gsize icon_data_length = 0;
gint i;
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
args = gimp_procedure_get_arguments (procedure, &n_args);
return_vals = gimp_procedure_get_return_values (procedure, &n_return_vals);
proc_install.name = (gchar *) gimp_procedure_get_name (procedure);
proc_install.blurb = (gchar *) gimp_procedure_get_blurb (procedure);
proc_install.help = (gchar *) gimp_procedure_get_help (procedure);
proc_install.help_id = (gchar *) gimp_procedure_get_help_id (procedure);
proc_install.authors = (gchar *) gimp_procedure_get_authors (procedure);
proc_install.copyright = (gchar *) gimp_procedure_get_copyright (procedure);
proc_install.date = (gchar *) gimp_procedure_get_date (procedure);
proc_install.menu_label = (gchar *) gimp_procedure_get_menu_label (procedure);
proc_install.image_types = (gchar *) gimp_procedure_get_image_types (procedure);
proc_install.type = gimp_procedure_get_proc_type (procedure);
proc_install.nparams = n_args;
proc_install.nreturn_vals = n_return_vals;
proc_install.params = g_new0 (GPParamDef, n_args);
proc_install.return_vals = g_new0 (GPParamDef, n_return_vals);
for (i = 0; i < n_args; i++)
{
_gimp_param_spec_to_gp_param_def (args[i],
&proc_install.params[i]);
}
for (i = 0; i < n_return_vals; i++)
{
_gimp_param_spec_to_gp_param_def (return_vals[i],
&proc_install.return_vals[i]);
}
plug_in = gimp_procedure_get_plug_in (procedure);
if (! gp_proc_install_write (_gimp_plug_in_get_write_channel (plug_in),
&proc_install, plug_in))
gimp_quit ();
icon_type = gimp_procedure_get_icon_type (procedure);
switch (icon_type)
{
case GIMP_ICON_TYPE_ICON_NAME:
{
icon_data = (guint8 *) gimp_procedure_get_icon_name (procedure);
if (icon_data)
icon_data_length = strlen ((gchar *) icon_data) + 1;
}
break;
case GIMP_ICON_TYPE_PIXBUF:
{
GdkPixbuf *pixbuf = gimp_procedure_get_icon_pixbuf (procedure);
if (pixbuf)
gdk_pixbuf_save_to_buffer (pixbuf,
(gchar **) &icon_data, &icon_data_length,
"png", NULL, NULL);
}
break;
case GIMP_ICON_TYPE_IMAGE_FILE:
{
GFile *file = gimp_procedure_get_icon_file (procedure);
if (file)
{
icon_data = (guchar *) g_file_get_uri (file);
icon_data_length = strlen ((gchar *) icon_data) + 1;
}
}
break;
}
if (icon_data)
_gimp_plugin_icon_register (gimp_procedure_get_name (procedure),
icon_type, icon_data_length, icon_data);
switch (icon_type)
{
case GIMP_ICON_TYPE_ICON_NAME:
break;
case GIMP_ICON_TYPE_PIXBUF:
case GIMP_ICON_TYPE_IMAGE_FILE:
g_free (icon_data);
break;
}
g_free (proc_install.params);
g_free (proc_install.return_vals);
for (list = gimp_procedure_get_menu_paths (procedure);
list;
list = g_list_next (list))
{
_gimp_plugin_menu_register (gimp_procedure_get_name (procedure),
list->data);
}
}
void
_gimp_procedure_unregister (GimpProcedure *procedure)
{
GimpPlugIn *plug_in;
GPProcUninstall proc_uninstall;
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
proc_uninstall.name = (gchar *) gimp_procedure_get_name (procedure);
plug_in = gimp_procedure_get_plug_in (procedure);
if (! gp_proc_uninstall_write (_gimp_plug_in_get_write_channel (plug_in),
&proc_uninstall, plug_in))
gimp_quit ();
}
void
_gimp_procedure_extension_ready (GimpProcedure *procedure)
{
GimpPlugIn *plug_in;
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
plug_in = gimp_procedure_get_plug_in (procedure);
if (! gp_extension_ack_write (_gimp_plug_in_get_write_channel (plug_in),
plug_in))
gimp_quit ();
}

35
libgimp/gimpprocedure-private.h
View File

@ -1,35 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
*
* gimpprocedure-private.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_PROCEDURE_PRIVATE_H__
#define __GIMP_PROCEDURE_PRIVATE_H__
G_BEGIN_DECLS
void _gimp_procedure_register (GimpProcedure *procedure);
void _gimp_procedure_unregister (GimpProcedure *procedure);
void _gimp_procedure_extension_ready (GimpProcedure *procedure);
G_END_DECLS
#endif /* __GIMP_PROCEDURE_H__ */

190
libgimp/gimpprocedure.c
View File

@ -25,8 +25,13 @@
#include "gimp.h"
#include "libgimpbase/gimpprotocol.h"
#include "libgimpbase/gimpwire.h"
#include "gimpgpparams.h"
#include "gimppdb-private.h"
#include "gimpprocedure-private.h"
#include "gimpplugin-private.h"
#include "gimpplugin_pdb.h"
#include "libgimp-intl.h"
@ -76,31 +81,33 @@ struct _GimpProcedurePrivate
};
static void gimp_procedure_constructed (GObject *object);
static void gimp_procedure_finalize (GObject *object);
static void gimp_procedure_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_procedure_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_procedure_constructed (GObject *object);
static void gimp_procedure_finalize (GObject *object);
static void gimp_procedure_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_procedure_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_procedure_real_install (GimpProcedure *procedure);
static void gimp_procedure_real_uninstall (GimpProcedure *procedure);
static GimpValueArray *
gimp_procedure_real_run (GimpProcedure *procedure,
const GimpValueArray *args);
gimp_procedure_real_run (GimpProcedure *procedure,
const GimpValueArray *args);
static gboolean gimp_procedure_validate_args (GimpProcedure *procedure,
GParamSpec **param_specs,
gint n_param_specs,
const GimpValueArray *args,
gboolean return_vals,
GError **error);
static gboolean gimp_procedure_validate_args (GimpProcedure *procedure,
GParamSpec **param_specs,
gint n_param_specs,
const GimpValueArray *args,
gboolean return_vals,
GError **error);
static void gimp_procedure_set_icon (GimpProcedure *procedure,
GimpIconType icon_type,
gconstpointer icon_data);
static void gimp_procedure_set_icon (GimpProcedure *procedure,
GimpIconType icon_type,
gconstpointer icon_data);
G_DEFINE_TYPE_WITH_PRIVATE (GimpProcedure, gimp_procedure, G_TYPE_OBJECT)
@ -120,6 +127,8 @@ gimp_procedure_class_init (GimpProcedureClass *klass)
object_class->set_property = gimp_procedure_set_property;
object_class->get_property = gimp_procedure_get_property;
klass->install = gimp_procedure_real_install;
klass->uninstall = gimp_procedure_real_uninstall;
klass->run = gimp_procedure_real_run;
props[PROP_PLUG_IN] =
@ -269,6 +278,135 @@ gimp_procedure_get_property (GObject *object,
}
}
static void
gimp_procedure_real_install (GimpProcedure *procedure)
{
GParamSpec **args;
GParamSpec **return_vals;
gint n_args;
gint n_return_vals;
GList *list;
GimpPlugIn *plug_in;
GPProcInstall proc_install;
GimpIconType icon_type;
guint8 *icon_data = NULL;
gsize icon_data_length = 0;
gint i;
args = gimp_procedure_get_arguments (procedure, &n_args);
return_vals = gimp_procedure_get_return_values (procedure, &n_return_vals);
proc_install.name = (gchar *) gimp_procedure_get_name (procedure);
proc_install.blurb = (gchar *) gimp_procedure_get_blurb (procedure);
proc_install.help = (gchar *) gimp_procedure_get_help (procedure);
proc_install.help_id = (gchar *) gimp_procedure_get_help_id (procedure);
proc_install.authors = (gchar *) gimp_procedure_get_authors (procedure);
proc_install.copyright = (gchar *) gimp_procedure_get_copyright (procedure);
proc_install.date = (gchar *) gimp_procedure_get_date (procedure);
proc_install.menu_label = (gchar *) gimp_procedure_get_menu_label (procedure);
proc_install.image_types = (gchar *) gimp_procedure_get_image_types (procedure);
proc_install.type = gimp_procedure_get_proc_type (procedure);
proc_install.nparams = n_args;
proc_install.nreturn_vals = n_return_vals;
proc_install.params = g_new0 (GPParamDef, n_args);
proc_install.return_vals = g_new0 (GPParamDef, n_return_vals);
for (i = 0; i < n_args; i++)
{
_gimp_param_spec_to_gp_param_def (args[i],
&proc_install.params[i]);
}
for (i = 0; i < n_return_vals; i++)
{
_gimp_param_spec_to_gp_param_def (return_vals[i],
&proc_install.return_vals[i]);
}
plug_in = gimp_procedure_get_plug_in (procedure);
if (! gp_proc_install_write (_gimp_plug_in_get_write_channel (plug_in),
&proc_install, plug_in))
gimp_quit ();
icon_type = gimp_procedure_get_icon_type (procedure);
switch (icon_type)
{
case GIMP_ICON_TYPE_ICON_NAME:
{
icon_data = (guint8 *) gimp_procedure_get_icon_name (procedure);
if (icon_data)
icon_data_length = strlen ((gchar *) icon_data) + 1;
}
break;
case GIMP_ICON_TYPE_PIXBUF:
{
GdkPixbuf *pixbuf = gimp_procedure_get_icon_pixbuf (procedure);
if (pixbuf)
gdk_pixbuf_save_to_buffer (pixbuf,
(gchar **) &icon_data, &icon_data_length,
"png", NULL, NULL);
}
break;
case GIMP_ICON_TYPE_IMAGE_FILE:
{
GFile *file = gimp_procedure_get_icon_file (procedure);
if (file)
{
icon_data = (guchar *) g_file_get_uri (file);
icon_data_length = strlen ((gchar *) icon_data) + 1;
}
}
break;
}
if (icon_data)
_gimp_plugin_icon_register (gimp_procedure_get_name (procedure),
icon_type, icon_data_length, icon_data);
switch (icon_type)
{
case GIMP_ICON_TYPE_ICON_NAME:
break;
case GIMP_ICON_TYPE_PIXBUF:
case GIMP_ICON_TYPE_IMAGE_FILE:
g_free (icon_data);
break;
}
g_free (proc_install.params);
g_free (proc_install.return_vals);
for (list = gimp_procedure_get_menu_paths (procedure);
list;
list = g_list_next (list))
{
_gimp_plugin_menu_register (gimp_procedure_get_name (procedure),
list->data);
}
}
static void
gimp_procedure_real_uninstall (GimpProcedure *procedure)
{
GimpPlugIn *plug_in;
GPProcUninstall proc_uninstall;
proc_uninstall.name = (gchar *) gimp_procedure_get_name (procedure);
plug_in = gimp_procedure_get_plug_in (procedure);
if (! gp_proc_uninstall_write (_gimp_plug_in_get_write_channel (plug_in),
&proc_uninstall, plug_in))
gimp_quit ();
}
static GimpValueArray *
gimp_procedure_real_run (GimpProcedure *procedure,
const GimpValueArray *args)
@ -1239,10 +1377,16 @@ gimp_procedure_run (GimpProcedure *procedure,
void
gimp_procedure_extension_ready (GimpProcedure *procedure)
{
GimpPlugIn *plug_in;
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_return_if_fail (procedure->priv->proc_type == GIMP_EXTENSION);
_gimp_procedure_extension_ready (procedure);
plug_in = gimp_procedure_get_plug_in (procedure);
if (! gp_extension_ack_write (_gimp_plug_in_get_write_channel (plug_in),
plug_in))
gimp_quit ();
}

7
libgimp/gimpprocedure.h
View File

@ -71,8 +71,11 @@ struct _GimpProcedureClass
{
GObjectClass parent_class;
GimpValueArray * (* run) (GimpProcedure *procedure,
const GimpValueArray *args);
void (* install) (GimpProcedure *procedure);
void (* uninstall) (GimpProcedure *procedure);
GimpValueArray * (* run) (GimpProcedure *procedure,
const GimpValueArray *args);
/* Padding for future expansion */
void (*_gimp_reserved1) (void);

217
libgimp/gimpsaveprocedure.c Normal file
View File

@ -0,0 +1,217 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveprocedure.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"
#include "gimpsaveprocedure.h"
struct _GimpSaveProcedurePrivate
{
GimpSaveFunc run_func;
gpointer run_data;
GDestroyNotify run_data_destroy;
};
static void gimp_save_procedure_constructed (GObject *object);
static void gimp_save_procedure_finalize (GObject *object);
static void gimp_save_procedure_install (GimpProcedure *procedure);
static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args);
G_DEFINE_TYPE_WITH_PRIVATE (GimpSaveProcedure, gimp_save_procedure,
GIMP_TYPE_FILE_PROCEDURE)
#define parent_class gimp_save_procedure_parent_class
static void
gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *procedure_class = GIMP_PROCEDURE_CLASS (klass);
object_class->constructed = gimp_save_procedure_constructed;
object_class->finalize = gimp_save_procedure_finalize;
procedure_class->install = gimp_save_procedure_install;
procedure_class->run = gimp_save_procedure_run;
}
static void
gimp_save_procedure_init (GimpSaveProcedure *procedure)
{
procedure->priv = gimp_save_procedure_get_instance_private (procedure);
}
static void
gimp_save_procedure_constructed (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"Image",
"The image to save",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"Drawable",
"The drawable "
"to save",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("uri",
"URI",
"The URI of the file "
"to save to",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("raw-uri",
"Raw URI",
"The URI of the file "
"to save to",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
}
static void
gimp_save_procedure_finalize (GObject *object)
{
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object);
if (procedure->priv->run_data_destroy)
procedure->priv->run_data_destroy (procedure->priv->run_data);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_save_procedure_install (GimpProcedure *procedure)
{
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *mime_types;
gint priority;
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
gimp_register_save_handler (gimp_procedure_get_name (procedure),
gimp_file_procedure_get_extensions (file_proc),
gimp_file_procedure_get_prefixes (file_proc));
gimp_register_file_handler_uri (gimp_procedure_get_name (procedure));
mime_types = gimp_file_procedure_get_mime_types (file_proc);
if (mime_types)
gimp_register_file_handler_mime (gimp_procedure_get_name (procedure),
mime_types);
priority = gimp_file_procedure_get_priority (file_proc);
if (priority != 0)
gimp_register_file_handler_priority (gimp_procedure_get_name (procedure),
priority);
}
static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
GimpSaveProcedure *save_proc = GIMP_SAVE_PROCEDURE (procedure);
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpRunMode run_mode;
gint32 image_id;
gint32 drawable_id;
const gchar *uri;
GFile *file;
gint i;
run_mode = g_value_get_enum (gimp_value_array_index (args, 0));
image_id = gimp_value_get_image_id (gimp_value_array_index (args, 1));
drawable_id = gimp_value_get_drawable_id (gimp_value_array_index (args, 2));
uri = g_value_get_string (gimp_value_array_index (args, 3));
/* raw_uri = g_value_get_string (gimp_value_array_index (args, 4)); */
file = g_file_new_for_uri (uri);
remaining = gimp_value_array_new (gimp_value_array_length (args) - 5);
for (i = 5; i < gimp_value_array_length (args); i++)
{
GValue *value = gimp_value_array_index (args, i);
gimp_value_array_append (remaining, value);
}
return_values = save_proc->priv->run_func (procedure,
run_mode,
image_id, drawable_id,
file,
remaining,
save_proc->priv->run_data);
gimp_value_array_unref (remaining);
g_object_unref (file);
return return_values;
}
/* public functions */
GimpProcedure *
gimp_save_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpSaveFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy)
{
GimpSaveProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL);
g_return_val_if_fail (proc_type != GIMP_INTERNAL, NULL);
g_return_val_if_fail (run_func != NULL, NULL);
procedure = g_object_new (GIMP_TYPE_SAVE_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 GIMP_PROCEDURE (procedure);
}

95
libgimp/gimpsaveprocedure.h Normal file
View File

@ -0,0 +1,95 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveprocedure.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_SAVE_PROCEDURE_H__
#define __GIMP_SAVE_PROCEDURE_H__
#include <libgimp/gimpfileprocedure.h>
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
/**
* GimpSaveFunc:
* @procedure: the #GimpProcedure that runs.
* @run_mode: the #GimpRunMode.
* @image_id: the image to save.
* @drawable_id: the drawable to save.
* @file: the #GFile to save to.
* @args: the @procedure's remaining arguments.
* @run_data: the run_data given in gimp_save_procedure_new().
*
* The save function is run during the lifetime of the GIMP session,
* each time a plug-in save procedure is called.
*
* Returns: (transfer full): the @procedure's return values.
*
* Since: 3.0
**/
typedef GimpValueArray * (* GimpSaveFunc) (GimpProcedure *procedure,
GimpRunMode run_mode,
gint32 image_id,
gint32 drawable_id,
GFile *file,
const GimpValueArray *args,
gpointer run_data);
#define GIMP_TYPE_SAVE_PROCEDURE (gimp_save_procedure_get_type ())
#define GIMP_SAVE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_SAVE_PROCEDURE, GimpSaveProcedure))
#define GIMP_SAVE_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_SAVE_PROCEDURE, GimpSaveProcedureClass))
#define GIMP_IS_SAVE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_SAVE_PROCEDURE))
#define GIMP_IS_SAVE_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_SAVE_PROCEDURE))
#define GIMP_SAVE_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SAVE_PROCEDURE, GimpSaveProcedureClass))
typedef struct _GimpSaveProcedure GimpSaveProcedure;
typedef struct _GimpSaveProcedureClass GimpSaveProcedureClass;
typedef struct _GimpSaveProcedurePrivate GimpSaveProcedurePrivate;
struct _GimpSaveProcedure
{
GimpFileProcedure parent_instance;
GimpSaveProcedurePrivate *priv;
};
struct _GimpSaveProcedureClass
{
GimpFileProcedureClass parent_class;
};
GType gimp_save_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_save_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpSaveFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy);
G_END_DECLS
#endif /* __GIMP_SAVE_PROCEDURE_H__ */