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

991 lines
40 KiB
C
Raw Normal View History

libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpprocedure-params.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
* Library 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/>.
*/
#if !defined (__GIMP_H_INSIDE__) && !defined (GIMP_COMPILATION)
#error "Only <libgimp/gimp.h> can be included directly."
#endif
#ifndef __GIMP_PROCEDURE_PARAMS_H__
#define __GIMP_PROCEDURE_PARAMS_H__
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
/**
* SECTION: gimpprocedure-params
* @title: GimpProcedure-params
* @short_description: Macros and defines to add procedure arguments
* and return values.
*
* Macros and defines to add procedure arguments and return values.
**/
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* boolean */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_BOOLEAN(procedure, name, nick, blurb, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_boolean (name, nick, blurb,\
default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_BOOLEAN(procedure, name, nick, blurb, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_boolean (name, nick, blurb,\
default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_BOOLEAN(procedure, name, nick, blurb, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_boolean (name, nick, blurb,\
default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_BOOLEAN(args, n) \
g_value_get_boolean (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_BOOLEAN(args, n, value) \
g_value_set_boolean (gimp_value_array_index (args, n), value)
/* int */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_INT(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_int (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_INT(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_int (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_INT(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_int (name, nick, blurb,\
min, max, default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_INT(args, n) \
g_value_get_int (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_INT(args, n, value) \
g_value_set_int (gimp_value_array_index (args, n), value)
/* uint */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_UINT(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_uint (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_UINT(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_uint (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_UINT(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_uint (name, nick, blurb,\
min, max, default,\
flags))
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
#define GIMP_VALUES_GET_UINT(args, n) \
g_value_get_uint (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_UINT(args, n, value) \
g_value_set_uint (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* uchar */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_UCHAR(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_uchar (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_UCHAR(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_uchar (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_UCHAR(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_uchar (name, nick, blurb,\
min, max, default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_UCHAR(args, n) \
g_value_get_uchar (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_UCHAR(args, n, value) \
g_value_set_uchar (gimp_value_array_index (args, n), value)
/* unit */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_UNIT(procedure, name, nick, blurb, pixels, percent, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_unit (name, nick, blurb,\
pixels, percent, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_UNIT(procedure, name, nick, blurb, pixels, percent, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_unit (name, nick, blurb,\
pixels, percent, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_UNIT(procedure, name, nick, blurb, pixels, percent, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_unit (name, nick, blurb,\
pixels, percent, default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* double */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_DOUBLE(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_double (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_DOUBLE(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_double (name, nick, blurb,\
min, max, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_DOUBLE(procedure, name, nick, blurb, min, max, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_double (name, nick, blurb,\
min, max, default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_DOUBLE(args, n) \
g_value_get_double (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_DOUBLE(args, n, value) \
g_value_set_double (gimp_value_array_index (args, n), value)
/* enum */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_ENUM(procedure, name, nick, blurb, enum_type, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_enum (name, nick, blurb,\
enum_type, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_ENUM(procedure, name, nick, blurb, enum_type, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_enum (name, nick, blurb,\
enum_type, default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_ENUM(procedure, name, nick, blurb, enum_type, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_enum (name, nick, blurb,\
enum_type, default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_ENUM(args, n) \
g_value_get_enum (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_ENUM(args, n, value) \
g_value_set_enum (gimp_value_array_index (args, n), value)
app, libgimp: new GimpChoice procedure argument. These will replace the int arguments used in place of enums. The problem of int arguments used as list of choices is that it makes calling PDB functions very opaque. This is especially bad when a list is long, so you constantly have to refer to the documentation to understand what a series of numbers mean in argument lists. And the second issue is that plug-in developers have to manually maintain a list of values both in the GUI and in the documentation string. This help text may get out-of-sync, may end up with missing values or whatnot. Also if it is used as tooltips, it makes for very weird tooltips in the graphical interface, with an overlong technical list of int-values mapping which should ideally only be made visible in the PDB procedure browser listing.
2023-08-03 05:55:33 +08:00
/* choice */
#define GIMP_PROC_ARG_CHOICE(procedure, name, nick, blurb, choice, default, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_choice (name, nick, blurb,\
choice, default,\
flags))
#define GIMP_PROC_AUX_ARG_CHOICE(procedure, name, nick, blurb, choice, default, flags) \
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_choice (name, nick, blurb,\
choice, default,\
flags))
#define GIMP_PROC_VAL_CHOICE(procedure, name, nick, blurb, enum_type, default, flags) \
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_choice (name, nick, blurb,\
choice, default,\
flags))
#define GIMP_VALUES_GET_CHOICE(args, n) \
g_value_get_int (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_CHOICE(args, n, value) \
g_value_set_int (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* string */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_STRING(procedure, name, nick, blurb, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_string (name, nick, blurb,\
default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_STRING(procedure, name, nick, blurb, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_string (name, nick, blurb,\
default,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_STRING(procedure, name, nick, blurb, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_string (name, nick, blurb,\
default,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_STRING(args, n) \
g_value_get_string (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_STRING(args, n) \
g_value_dup_string (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_STRING(args, n, value) \
g_value_set_string (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_TAKE_STRING(args, n, value) \
g_value_take_string (gimp_value_array_index (args, n), value)
libgimp: add macros for GeglColor arguments for GimpProcedure.
2024-02-15 06:46:03 +08:00
/* color */
/* TODO:
* 1. has_alpha is currently bogus and doesn't do anything yet.
* 2. Also wouldn't none_ok be useful for color arguments (accepting a NULL
* GeglColor)?
* 3. GEGL also provides a gegl_param_spec_color_from_string() allowing to
* initialize the default with a list of standard colors. Wouldn't it be
* interesting to also have this?
*/
#define GIMP_PROC_ARG_COLOR(procedure, name, nick, blurb, has_alpha, default, flags) \
gimp_procedure_add_argument (procedure,\
gegl_param_spec_color (name, nick, blurb,\
default, \
flags))
#define GIMP_PROC_AUX_ARG_COLOR(procedure, name, nick, blurb, has_alpha, default, flags) \
gimp_procedure_add_aux_argument (procedure,\
gegl_param_spec_color (name, nick, blurb,\
default, \
flags))
#define GIMP_PROC_VAL_COLOR(procedure, name, nick, blurb, has_alpha, default, flags) \
gimp_procedure_add_return_value (procedure,\
gegl_param_spec_color (name, nick, blurb,\
default, \
flags))
#define GIMP_VALUES_GET_COLOR(args, n, value) \
g_value_get_object (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_SET_COLOR(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* rgb */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_RGB(procedure, name, nick, blurb, has_alpha, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_rgb (name, nick, blurb,\
has_alpha, default, \
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_RGB(procedure, name, nick, blurb, has_alpha, default, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_rgb (name, nick, blurb,\
has_alpha, default, \
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_RGB(procedure, name, nick, blurb, has_alpha, default, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_rgb (name, nick, blurb,\
has_alpha, default, \
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_RGB(args, n, value) \
gimp_value_get_rgb (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_SET_RGB(args, n, value) \
gimp_value_set_rgb (gimp_value_array_index (args, n), value)
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
/* parasite */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_PARASITE(procedure, name, nick, blurb, flags) \
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_parasite (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_PARASITE(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_parasite (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_PARASITE(procedure, name, nick, blurb, flags) \
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_parasite (name, nick, blurb,\
flags))
#define GIMP_VALUES_GET_PARASITE(args, n) \
g_value_get_boxed (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_PARASITE(args, n) \
g_value_dup_boxed (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_PARASITE(args, n, value) \
g_value_set_boxed (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_TAKE_PARASITE(args, n, value) \
g_value_take_boxed (gimp_value_array_index (args, n), value)
/* param */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_PARAM(procedure, name, nick, blurb, param_type, flags) \
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
gimp_procedure_add_argument (procedure,\
g_param_spec_param (name, nick, blurb, param_type, \
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_PARAM(procedure, name, nick, blurb, param_type, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_param (name, nick, blurb, param_type, \
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_PARAM(procedure, name, nick, blurb, param_type, flags) \
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
gimp_procedure_add_return_value (procedure,\
g_param_spec_param (name, nick, blurb, param_type, \
flags))
#define GIMP_VALUES_GET_PARAM(args, n) \
g_value_get_param (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_PARAM(args, n) \
g_value_dup_param (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_PARAM(args, n, value) \
g_value_set_param (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_TAKE_PARAM(args, n, value) \
g_value_take_param (gimp_value_array_index (args, n), value)
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
/* bytes */
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
#define GIMP_PROC_ARG_BYTES(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_BYTES, flags))
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
#define GIMP_PROC_AUX_ARG_BYTES(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_BYTES, flags))
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
#define GIMP_PROC_VAL_BYTES(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_BYTES, flags))
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
#define GIMP_VALUES_GET_BYTES(args, n) \
g_value_get_boxed (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
#define GIMP_VALUES_DUP_BYTES(args, n) \
g_value_dup_boxed (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
app, libgimp*, pdb, plug-ins: reimplement generic inter-process transient window. Having windows ID as guint32 is a mistake. Different systems have different protocols. In Wayland in particular, Windows handles are exchanged as strings. What this commit does is the following: In core: - get_window_id() virtual function in core GimpProgress is changed to return a GBytes, as a generic "data" to represent a window differently on different systems. - All implementations of get_window_id() in various classes implementing this interface are updated accordingly: * GimpSubProgress * GimpDisplay returns the handle of its shell. * GimpDisplayShell now creates its window handle at construction with libgimpwidget's gimp_widget_set_native_handle() and simply return this handle every time it's requested. * GimpFileDialog also creates its window handle at construction with gimp_widget_set_native_handle(). - gimp_window_set_transient_for() in core is changed to take a GimpProgress as argument (instead of a guint32 ID), requests and process the ID itself, according to the running platform. In particular, the following were improved: * Unlike old code, it will work even if the window is not visible yet. In such a case, the function simply adds a signal handler to set transient at mapping. It makes it easier to use it at construction in a reliable way. * It now works for Wayland too, additionally to X11. - GimpPdbProgress now exchanges a GBytes too with the command GIMP_PROGRESS_COMMAND_GET_WINDOW. - display_get_window_id() in gimp-gui.h also returns a GBytes now. PDB/libgimp: - gimp_display_get_window_handle() and gimp_progress_get_window_handle() now return a GBytes to represent a window handle in an opaque way (depending on the running platform). In libgimp: - GimpProgress's get_window() virtual function changed to return a GBytes and renamed get_window_handle(). - In particular GimpProgressBar is the only implementation of get_window_handle(). It creates its handle at object construction with libgimpwidget's gimp_widget_set_native_handle() and the virtual method's implementation simply returns the GBytes. In libgimpUi: - gimp_ui_get_display_window() and gimp_ui_get_progress_window() were removed. We should not assume anymore that it is possible to create a GdkWindow to be used. For instance this is not possible with Wayland which has its own way to set a window transient with a string handle. - gimp_window_set_transient_for_display() and gimp_window_set_transient() now use an internal implementation similar to core gimp_window_set_transient_for(), with the same improvements (works even at construction when the window is not visible yet + works for Wayland too). In libgimpwidgets: - New gimp_widget_set_native_handle() is a helper function used both in core and libgimp* libraries for widgets which we want to be usable as possible parents. It takes care of getting the relevant window handle (depending on the running platform) and stores it in a given pointer, either immediately or after a callback once the widget is mapped. So it can be used at construction. Also it sets a handle for X11 or Wayland. In plug-ins: - Screenshot uses the new gimp_progress_get_window_handle() directly now in its X11 code path and creates out of it a GdkWindows itself with gdk_x11_window_foreign_new_for_display(). Our inter-process transient implementation only worked for X11, and with this commit, it works for Wayland too. There is code for Windows but it is currently disabled as it apparently hangs (there is a comment in-code which links to this old report: https://bugzilla.gnome.org/show_bug.cgi?id=359538). NikcDC tested yesterday with re-enabling the code and said they experienced a freeze. ;-( Finally there is no infrastructure yet to make this work on macOS and apparently there is no implementation of window handle in GDK for macOS that I could find. I'm not sure if macOS doesn't have this concept of setting transient on another processus's window or GDK is simply lacking the implementation.
2023-08-14 20:23:06 +08:00
#define GIMP_VALUES_SET_BYTES(args, n, value) \
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
g_value_set_boxed (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpUint8Array in favor of GBytes GLib has a specific type for byte arrays: `GBytes` (and it's underlying GType `G_TYPE_BYTES`). By using this type, we can avoid having a `GimpUint8Array` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GBytes`, we allow other languages to pass on byte arrays as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with byte arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2023-05-24 05:37:46 +08:00
#define GIMP_VALUES_TAKE_BYTES(args, n, value, length) \
g_value_take_boxed (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* int32 array */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_INT32_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_int32_array (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_INT32_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_int32_array (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_INT32_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_int32_array (name, nick, blurb,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_INT32_ARRAY(args, n) \
gimp_value_get_int32_array (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_INT32_ARRAY(args, n) \
gimp_value_dup_int32_array (gimp_value_array_index (args, n))
libgimp: fix GIMP_VALUES_(SET|TAKE)_*_ARRAY() macros. A length argument is required by corresponding gimp_value_set_*_array() functions.
2019-08-30 06:32:18 +08:00
#define GIMP_VALUES_SET_INT32_ARRAY(args, n, value, length) \
gimp_value_set_int32_array (gimp_value_array_index (args, n), value, length)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: fix GIMP_VALUES_(SET|TAKE)_*_ARRAY() macros. A length argument is required by corresponding gimp_value_set_*_array() functions.
2019-08-30 06:32:18 +08:00
#define GIMP_VALUES_TAKE_INT32_ARRAY(args, n, value, length) \
gimp_value_take_int32_array (gimp_value_array_index (args, n), value, length)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* float array */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_FLOAT_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_float_array (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_FLOAT_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_float_array (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_FLOAT_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_float_array (name, nick, blurb,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_FLOAT_ARRAY(args, n) \
gimp_value_get_float_array (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_FLOAT_ARRAY(args, n) \
gimp_value_dup_float_array (gimp_value_array_index (args, n))
libgimp: fix GIMP_VALUES_(SET|TAKE)_*_ARRAY() macros. A length argument is required by corresponding gimp_value_set_*_array() functions.
2019-08-30 06:32:18 +08:00
#define GIMP_VALUES_SET_FLOAT_ARRAY(args, n, value, length) \
gimp_value_set_float_array (gimp_value_array_index (args, n), value, length)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: fix GIMP_VALUES_(SET|TAKE)_*_ARRAY() macros. A length argument is required by corresponding gimp_value_set_*_array() functions.
2019-08-30 06:32:18 +08:00
#define GIMP_VALUES_TAKE_FLOAT_ARRAY(args, n, value, length) \
gimp_value_take_float_array (gimp_value_array_index (args, n), value, length)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
/* string array (strv) */
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_PROC_ARG_STRV(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_STRV, flags))
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_PROC_AUX_ARG_STRV(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_STRV, flags))
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_PROC_VAL_STRV(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
g_param_spec_boxed (name, nick, blurb,\
G_TYPE_STRV, flags))
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_VALUES_GET_STRV(args, n) \
g_value_get_boxed (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_VALUES_DUP_STRV(args, n) \
g_value_dup_boxed (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_VALUES_SET_STRV(args, n, value) \
g_value_set_boxed (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
Remove GimpStringArray in favor of GStrv GLib has a specific type of NULL-terminated string arrays: `G_TYPE_STRV`, which is the `GType` of `char**` aka `GStrv`. By using this type, we can avoid having a `GimpStringArray` which is a bit cumbersome to use for both the C API, as well as bindings. By using `GStrv`, we allow other languages to pass on string lists as they are used to, while the bindings will make sure to do the right thing. In the end, it makes the API a little bit simpler for everyone, and reduces confusion for people who are used to working with string arrays in other C/GLib based code (and not having 2 different types to denote the same thing). Related: https://gitlab.gnome.org/GNOME/gimp/-/issues/5919
2020-12-24 04:15:43 +08:00
#define GIMP_VALUES_TAKE_STRV(args, n, value) \
g_value_take_boxed (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* rgb array */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_RGB_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_rgb_array (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_RGB_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_rgb_array (name, nick, blurb,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_RGB_ARRAY(procedure, name, nick, blurb, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_rgb_array (name, nick, blurb,\
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_RGB_ARRAY(args, n) \
gimp_value_get_rgb_array (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_RGB_ARRAY(args, n) \
gimp_value_dup_rgb_array (gimp_value_array_index (args, n))
libgimp: fix GIMP_VALUES_(SET|TAKE)_*_ARRAY() macros. A length argument is required by corresponding gimp_value_set_*_array() functions.
2019-08-30 06:32:18 +08:00
#define GIMP_VALUES_SET_RGB_ARRAY(args, n, value, length) \
gimp_value_set_rgb_array (gimp_value_array_index (args, n), value, length)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: fix GIMP_VALUES_(SET|TAKE)_*_ARRAY() macros. A length argument is required by corresponding gimp_value_set_*_array() functions.
2019-08-30 06:32:18 +08:00
#define GIMP_VALUES_TAKE_RGB_ARRAY(args, n, value, length) \
gimp_value_take_rgb_array (gimp_value_array_index (args, n), value, length)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
/* object array */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_OBJECT_ARRAY(procedure, name, nick, blurb, object_type, flags) \
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
gimp_procedure_add_argument (procedure,\
gimp_param_spec_object_array (name, nick, blurb,\
object_type, flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_OBJECT_ARRAY(procedure, name, nick, blurb, object_type, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_object_array (name, nick, blurb,\
object_type, flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_OBJECT_ARRAY(procedure, name, nick, blurb, object_type, flags) \
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
gimp_procedure_add_return_value (procedure,\
libgimp: fix copy/paste errors in GIMP_VALUES_FOO_OBJECT_ARRAY()
2019-09-05 20:38:20 +08:00
gimp_param_spec_object_array (name, nick, blurb,\
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
object_type, flags))
#define GIMP_VALUES_GET_OBJECT_ARRAY(args, n) \
(gpointer) gimp_value_get_object_array (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_OBJECT_ARRAY(args, n) \
(gpointer) gimp_value_dup_object_array (gimp_value_array_index (args, n))
libgimp: fix copy/paste errors in GIMP_VALUES_FOO_OBJECT_ARRAY()
2019-09-05 20:38:20 +08:00
#define GIMP_VALUES_SET_OBJECT_ARRAY(args, n, object_type, value, length) \
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
gimp_value_set_object_array (gimp_value_array_index (args, n),\
libgimp: fix copy/paste errors in GIMP_VALUES_FOO_OBJECT_ARRAY()
2019-09-05 20:38:20 +08:00
object_type, (gpointer) value, length)
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
libgimp: fix copy/paste errors in GIMP_VALUES_FOO_OBJECT_ARRAY()
2019-09-05 20:38:20 +08:00
#define GIMP_VALUES_TAKE_OBJECT_ARRAY(args, n, object_type, value, length) \
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
gimp_value_take_object_array (gimp_value_array_index (args, n),\
libgimp: fix copy/paste errors in GIMP_VALUES_FOO_OBJECT_ARRAY()
2019-09-05 20:38:20 +08:00
object_type, (gpointer) value, length)
libgimp: add object array convenience macros to gimpprocedure-params.h
2019-09-05 17:40:29 +08:00
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* display */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_DISPLAY(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_display (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_DISPLAY(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_display (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_DISPLAY(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_display (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
#define GIMP_VALUES_GET_DISPLAY(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_DISPLAY_ID(args, n) \
gimp_display_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add missing stuff to gimpprocedure-params.h Add some accessors, and the complete set of macros for GimpParasite and GParamSpec.
2019-09-04 08:39:02 +08:00
#define GIMP_VALUES_SET_DISPLAY(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* image */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_IMAGE(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_image (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_IMAGE(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_image (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_IMAGE(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_image (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_IMAGE(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_IMAGE_ID(args, n) \
gimp_image_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_IMAGE(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* item */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_ITEM(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_item (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_ITEM(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_item (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_ITEM(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_item (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_ITEM(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_ITEM_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_ITEM(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* drawable */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_DRAWABLE(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_drawable (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_DRAWABLE(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_drawable (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_DRAWABLE(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_drawable (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_DRAWABLE(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_DRAWABLE_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_DRAWABLE(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* layer */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_LAYER(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_layer (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_LAYER(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_layer (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_LAYER(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_layer (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_LAYER(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_LAYER_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_LAYER(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
app, libgimp, pdb, plug-ins: new GimpTextLayer class in libgimp. Now text layers are proper types, which means that the binding API will also be nicer (e.g. `txt_layer.set_text('hello world')` in Python). This commit also adds the param specs allowing to create plug-in procedures with text layer parameters. Finally it fixes the few calls in file-pdf-save (apparently the only plug-in using specific text layer API right now) with explicit type conversion.
2022-09-30 22:21:47 +08:00
/* text layer */
#define GIMP_PROC_ARG_TEXT_LAYER(procedure, name, nick, blurb, none_ok, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_text_layer (name, nick, blurb,\
none_ok,\
flags))
#define GIMP_PROC_AUX_ARG_TEXT_LAYER(procedure, name, nick, blurb, none_ok, flags) \
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_text_layer (name, nick, blurb,\
none_ok,\
flags))
#define GIMP_PROC_VAL_TEXT_LAYER(procedure, name, nick, blurb, none_ok, flags) \
gimp_procedure_add_return_value (procedure,\
gimp_param_spec_text_layer (name, nick, blurb,\
none_ok,\
flags))
#define GIMP_VALUES_GET_TEXT_LAYER(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_GET_TEXT_LAYER_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
#define GIMP_VALUES_SET_TEXT_LAYER(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* channel */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_CHANNEL(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_channel (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_CHANNEL(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_channel (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_CHANNEL(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_channe (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_CHANNEL(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_CHANNEL_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_CHANNEL(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* layer mask */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_LAYER_MASK(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_layer_mask (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_LAYER_MASK(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_layer_mask (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_LAYER_MASK(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_layer_mask (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_LAYER_MASK(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_LAYER_MASK_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_LAYER_MASK(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* selection */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_SELECTION(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_selection (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_SELECTION(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_selection (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_SELECTION(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_selection (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_SELECTION(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_SELECTION_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_SELECTION(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
/* vectors */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_VECTORS(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_argument (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_vectors (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_VECTORS(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
gimp_param_spec_vectors (name, nick, blurb,\
none_ok,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_VECTORS(procedure, name, nick, blurb, none_ok, flags) \
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
gimp_procedure_add_return_value (procedure,\
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
gimp_param_spec_vectors (name, nick, blurb,\
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
none_ok,\
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
flags))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_GET_VECTORS(args, n) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_get_object (gimp_value_array_index (args, n))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add convenience macros GIMP_VALUES_GET_FOO_ID() becuse some plug-ins really want the ID for good reasons and not the object, and code looks so much nicer when the entire list of arguments is extracted using the macros.
2019-09-05 19:22:37 +08:00
#define GIMP_VALUES_GET_VECTORS_ID(args, n) \
gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n)))
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
#define GIMP_VALUES_SET_VECTORS(args, n, value) \
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add a gazillion of macros to gimpprocedure-params.h that make dealing with value arrays easier and shorter, e.g. g_value_get_boolean (gimp_value_array_index (args, n)): becomes: GIMP_VALUES_GET_BOOLEAN (args, n);
2019-08-20 07:00:47 +08:00
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +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
/* file */
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_ARG_FILE(procedure, name, nick, blurb, flags) \
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
gimp_procedure_add_argument (procedure,\
g_param_spec_object (name, nick, blurb,\
G_TYPE_FILE,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_AUX_ARG_FILE(procedure, name, nick, blurb, flags) \
libgimp: add macros for adding aux args to gimpprocedure-params.h
2019-09-24 21:11:50 +08:00
gimp_procedure_add_aux_argument (procedure,\
g_param_spec_object (name, nick, blurb,\
G_TYPE_FILE,\
flags))
libgimp: fix all GIMP_PROC_ARG,AUX_ARG,VAL_FOO() macros They all had "class" as first argument (copied from gimpconfig-params.h) and only worked accidentially because all functions they are used in happen to have the right local "procedure" variable...
2019-10-03 04:17:37 +08:00
#define GIMP_PROC_VAL_FILE(procedure, name, nick, blurb, none_ok, flags) \
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
gimp_procedure_add_return_value (procedure,\
g_param_spec_object (name, nick, blurb,\
G_TYPE_FILE,\
flags))
#define GIMP_VALUES_GET_FILE(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_FILE(args, n) \
g_value_dup_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_FILE(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_TAKE_FILE(args, n, value) \
g_value_take_object (gimp_value_array_index (args, n), value)
2.99 libgimp: add GimpResource, GimpBrush, GimpPropWidgetBrush So procedures can declare args and GimpProcedureDialog show chooser widgets Fix so is no error dialog on id_is_valid for resources Palette.pdb changes and testing Memory mgt changes Gradient pdb Font and Pattern tests Test brush, palette Cleanup, remove generator Rebase, edit docs, install test-dialog.py Whitespace, and fix failed distcheck Fix some clang-format, fix fail distcheck Fix distcheck Cleanup from review Jehan
2022-09-06 07:28:35 +08:00
/* Resource */
libgimp*: support having procedure arguments of generic type GimpResource.
2023-08-17 02:48:32 +08:00
#define GIMP_PROC_ARG_RESOURCE(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_resource (name, nick, blurb,\
GIMP_TYPE_RESOURCE,\
flags))
libgimp: API refactor GUI for GimpResource Simplifies chooser widgets (e.g. GimpBrushSelect) by eliminating attributes (e.g. opacity) of chosen resource. See #8745, but this commit fixes that by first refactoring the code. Refactors GUI widgets (e.g. GimpBrushSelectButton and GimpBrushSelect etc.) Refactor by "Extract class" GimpResourceSelectButton from GimpBrushSelectButton etc. This moves common code into an inherited class (formerly called GimpSelectButton) but the subclasses still exist. The subclasses mainly just do drawing now. Refactor by "Extract module" GimpResourceSelect from GimpBrushSelect etc. Moves common code into one file, generic at runtime on type of GimpResource, that is, the new code dispatches on type i.e. switch statements. In the future, when core is changed some of that can be deleted. The files gimpbrushselect.[c,h] etc. are deleted. The module adapts the API from core to the API of callbacks to libgimp. Note that core is running the resource chooser (select) widgets remotely. Core is still calling back over the wire via PDB with more attributes than necessary. The new design gets the attributes from the resource themselves, instead of receiving them from core callback. The libgimp side adapts by discarding unneeded attributes. In the future, core (running choosers for plugins) can be simplified also. Fix gimp_prop_chooser_brush_new same as other resources. Finish changes, and clean style. Annotations
2022-10-16 03:11:05 +08:00
#define GIMP_PROC_ARG_BRUSH(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_brush (name, nick, blurb,\
GIMP_TYPE_BRUSH,\
flags))
#define GIMP_PROC_ARG_FONT(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_font (name, nick, blurb,\
GIMP_TYPE_FONT,\
flags))
#define GIMP_PROC_ARG_GRADIENT(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_gradient (name, nick, blurb,\
GIMP_TYPE_GRADIENT,\
flags))
#define GIMP_PROC_ARG_PALETTE(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_palette (name, nick, blurb,\
GIMP_TYPE_PALETTE,\
flags))
#define GIMP_PROC_ARG_PATTERN(procedure, name, nick, blurb, flags) \
gimp_procedure_add_argument (procedure,\
gimp_param_spec_pattern (name, nick, blurb,\
GIMP_TYPE_PATTERN,\
flags))
pdb: GimpResource: add is_editable(), rename(), duplicate(). delete() and remove the API from its subclasses.
2023-06-06 22:33:36 +08:00
#define GIMP_VALUES_GET_RESOURCE(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_RESOURCE(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
2.99 libgimp: add GimpResource, GimpBrush, GimpPropWidgetBrush So procedures can declare args and GimpProcedureDialog show chooser widgets Fix so is no error dialog on id_is_valid for resources Palette.pdb changes and testing Memory mgt changes Gradient pdb Font and Pattern tests Test brush, palette Cleanup, remove generator Rebase, edit docs, install test-dialog.py Whitespace, and fix failed distcheck Fix some clang-format, fix fail distcheck Fix distcheck Cleanup from review Jehan
2022-09-06 07:28:35 +08:00
#define GIMP_VALUES_GET_BRUSH(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_BRUSH(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_GET_FONT(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_FONT(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_GET_GRADIENT(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_GRADIENT(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_GET_PALETTE(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_PALETTE(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
#define GIMP_VALUES_GET_PATTERN(args, n) \
g_value_get_object (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_PATTERN(args, n, value) \
g_value_set_object (gimp_value_array_index (args, n), value)
libgimp: add gimpprocedure-params.h which looks much like gimpconfig-params.h and contains macros (e.g. GIMP_PROC_ARG_BOOLEAN() and GIMP_PROC_VAL_BOOLEAN()) for all GimpProcedure argument and return value types supported by the protocol, and makes the boilerplate of setting up a procedure more readable and much less indented. This file is C-only and not introspected.
2019-08-19 15:56:20 +08:00
G_END_DECLS
#endif /* __GIMP_PROCEDURE_PARAMS_H__ */