dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/python/palette-to-gradient.py

159 lines
6.5 KiB
Python
Raw Normal View History

app: when interpreter not found in interpreter DB, leave shebang as-is. In particular, if the shebang is `#!/usr/bin/env lang` and we have not registered a specific interpreter for `lang`, the system should leave the env tool search the right interpreter for us. We only bypass env when we set our own explicit interpreter. Apply this to palette-to-gradient.py plug-in.
2019-07-29 20:01:46 +08:00
#!/usr/bin/env python3
plug-ins: port Python plug-in palette-to-gradient to introspected API. Localization still doesn't work, but this is normal (po-python is not installed). I will later make the proper tests for this. Other than this, it is a pretty simple port. It lost all particularities and facilities of pygimp, but the fact that it now works similarly to the C API is quite nice too. It still uses the legacy API for plug-ins though and will have to be ported further when the new API will be stable. Also I still haven't figured out why we need to return the number of returned values. With the proper annotations, an array length parameter disappears in introspected Python (because it is useless as Python lists know their length). But it would seem that this annotation doesn't work the same for returned values, which is a bit sad as it creates ugly redundancy. It can be noted that I an going to move all Python plug-ins from plug-ins/pygimp/plug-ins/ to plug-ins/python/. The whole pygimp/ subdirectory will actually be deleted eventually (I keep it around for now as reference) as Python plug-in should not need to be considered particularly from now on. They can just be considered as generic executables.
2019-07-29 00:29:42 +08:00
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
import gi
gi.require_version('Gimp', '3.0')
from gi.repository import Gimp
plug-ins: Show GUI for Palette to Gradient Also shows GUI for Palette to Repeating Gradient function
2023-01-15 03:00:48 +08:00
gi.require_version('GimpUi', '3.0')
from gi.repository import GimpUi
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
from gi.repository import GObject
from gi.repository import GLib
from gi.repository import Gio
plug-ins: Show GUI for Palette to Gradient Also shows GUI for Palette to Repeating Gradient function
2023-01-15 03:00:48 +08:00
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
plug-ins: port Python plug-in palette-to-gradient to introspected API. Localization still doesn't work, but this is normal (po-python is not installed). I will later make the proper tests for this. Other than this, it is a pretty simple port. It lost all particularities and facilities of pygimp, but the fact that it now works similarly to the C API is quite nice too. It still uses the legacy API for plug-ins though and will have to be ported further when the new API will be stable. Also I still haven't figured out why we need to return the number of returned values. With the proper annotations, an array length parameter disappears in introspected Python (because it is useless as Python lists know their length). But it would seem that this annotation doesn't work the same for returned values, which is a bit sad as it creates ugly redundancy. It can be noted that I an going to move all Python plug-ins from plug-ins/pygimp/plug-ins/ to plug-ins/python/. The whole pygimp/ subdirectory will actually be deleted eventually (I keep it around for now as reference) as Python plug-in should not need to be considered particularly from now on. They can just be considered as generic executables.
2019-07-29 00:29:42 +08:00
import sys
plug-ins, libgimp: override set_i18n() for all our core plug-ins. Hence avoiding the stderr messages. These are going to be localized with centrally installed catalogs "gimp*-std-plugins", "gimp*-script-fu" and "gimp*-python". We now handle core plug-in localizations differently and in particular, with kind of a reverse logic: - We don't consider "gimp*-std-plugins" to be the default catalog anymore. It made sense in the old world where we would consider the core plug-ins to be the most important and numerous ones. But we want to push a world where people are even more encouraged to develop their own plug-ins. These won't use the standard catalog anymore (because there are nearly no reasons that the strings are the same, it's only a confusing logic). So let's explicitly set the standard catalogs with DEFINE_STD_SET_I18N macro (which maps to a different catalog for script-fu plug-ins). - Doing something similar for Python plug-ins which have again their own catalog. - Getting rid of the INIT_I18N macro since now all the locale domain binding is done automatically by libgimp when using the set_i18n() method infrastructure.
2022-05-26 06:59:36 +08:00
def N_(message): return message
def _(message): return GLib.dgettext(None, message)
plug-ins: port Python plug-in palette-to-gradient to introspected API. Localization still doesn't work, but this is normal (po-python is not installed). I will later make the proper tests for this. Other than this, it is a pretty simple port. It lost all particularities and facilities of pygimp, but the fact that it now works similarly to the C API is quite nice too. It still uses the legacy API for plug-ins though and will have to be ported further when the new API will be stable. Also I still haven't figured out why we need to return the number of returned values. With the proper annotations, an array length parameter disappears in introspected Python (because it is useless as Python lists know their length). But it would seem that this annotation doesn't work the same for returned values, which is a bit sad as it creates ugly redundancy. It can be noted that I an going to move all Python plug-ins from plug-ins/pygimp/plug-ins/ to plug-ins/python/. The whole pygimp/ subdirectory will actually be deleted eventually (I keep it around for now as reference) as Python plug-in should not need to be considered particularly from now on. They can just be considered as generic executables.
2019-07-29 00:29:42 +08:00
def make_gradient(palette, num_segments, num_colors):
Fix plugins to use new GimpResource.
2022-09-06 07:28:35 +08:00
# name the gradient same as the source palette
# For now, the name of a resource is the same as the ID
plug-ins: forgotten Python plug-ins had to be ported to new Gimp.Procedure.new(). There was also one case of port to updated GimpResource API to get the name of a palette.
2023-06-17 05:36:11 +08:00
palette_name = palette.get_name()
Fix plugins to use new GimpResource.
2022-09-06 07:28:35 +08:00
gradient = Gimp.Gradient.new(palette_name)
# assert gradient is valid but is has only one segment
assert gradient.get_number_of_segments() == 1
# split one segment into desired count
# index is zero-based
gradient.segment_range_split_uniform( 0, 0, num_segments)
plug-ins: port Python plug-in palette-to-gradient to introspected API. Localization still doesn't work, but this is normal (po-python is not installed). I will later make the proper tests for this. Other than this, it is a pretty simple port. It lost all particularities and facilities of pygimp, but the fact that it now works similarly to the C API is quite nice too. It still uses the legacy API for plug-ins though and will have to be ported further when the new API will be stable. Also I still haven't figured out why we need to return the number of returned values. With the proper annotations, an array length parameter disappears in introspected Python (because it is useless as Python lists know their length). But it would seem that this annotation doesn't work the same for returned values, which is a bit sad as it creates ugly redundancy. It can be noted that I an going to move all Python plug-ins from plug-ins/pygimp/plug-ins/ to plug-ins/python/. The whole pygimp/ subdirectory will actually be deleted eventually (I keep it around for now as reference) as Python plug-in should not need to be considered particularly from now on. They can just be considered as generic executables.
2019-07-29 00:29:42 +08:00
for color_number in range(0,num_segments):
if color_number == num_colors - 1:
color_number_next = 0
else:
color_number_next = color_number + 1
plug-ins: Fix Palette and Gradient functions Resolves #11083 Per bootchk, changes in function calls to palette_entry_get_color () and gradient_segment_get_left_color () were broken in Python scripts due to GelColor being used post Color Space Invasion. This patch fixes the calls and returns.
2024-03-21 21:06:39 +08:00
color_left = palette.entry_get_color(color_number)
color_right = palette.entry_get_color(color_number_next)
gradient.segment_set_left_color(color_number, color_left)
gradient.segment_set_right_color(color_number, color_right)
Fix plugins to use new GimpResource.
2022-09-06 07:28:35 +08:00
# Side effects on the context. Probably not what most would expect.
plug-ins: port Python plug-in palette-to-gradient to introspected API. Localization still doesn't work, but this is normal (po-python is not installed). I will later make the proper tests for this. Other than this, it is a pretty simple port. It lost all particularities and facilities of pygimp, but the fact that it now works similarly to the C API is quite nice too. It still uses the legacy API for plug-ins though and will have to be ported further when the new API will be stable. Also I still haven't figured out why we need to return the number of returned values. With the proper annotations, an array length parameter disappears in introspected Python (because it is useless as Python lists know their length). But it would seem that this annotation doesn't work the same for returned values, which is a bit sad as it creates ugly redundancy. It can be noted that I an going to move all Python plug-ins from plug-ins/pygimp/plug-ins/ to plug-ins/python/. The whole pygimp/ subdirectory will actually be deleted eventually (I keep it around for now as reference) as Python plug-in should not need to be considered particularly from now on. They can just be considered as generic executables.
2019-07-29 00:29:42 +08:00
Gimp.context_set_gradient(gradient)
plug-ins: use new gimp_procedure_add_*_from_property() in Python. Since GParamSpec are not working fine (cf. pygobject#227), we have this trick of initializing new arguments or return values with properties. Use this trick in the palette-to-gradient plug-in.
2019-08-03 04:48:38 +08:00
return gradient
plug-ins: port Python plug-in palette-to-gradient to introspected API. Localization still doesn't work, but this is normal (po-python is not installed). I will later make the proper tests for this. Other than this, it is a pretty simple port. It lost all particularities and facilities of pygimp, but the fact that it now works similarly to the C API is quite nice too. It still uses the legacy API for plug-ins though and will have to be ported further when the new API will be stable. Also I still haven't figured out why we need to return the number of returned values. With the proper annotations, an array length parameter disappears in introspected Python (because it is useless as Python lists know their length). But it would seem that this annotation doesn't work the same for returned values, which is a bit sad as it creates ugly redundancy. It can be noted that I an going to move all Python plug-ins from plug-ins/pygimp/plug-ins/ to plug-ins/python/. The whole pygimp/ subdirectory will actually be deleted eventually (I keep it around for now as reference) as Python plug-in should not need to be considered particularly from now on. They can just be considered as generic executables.
2019-07-29 00:29:42 +08:00
plug-ins: forgotten Python plug-ins had to be ported to new Gimp.Procedure.new(). There was also one case of port to updated GimpResource API to get the name of a palette.
2023-06-17 05:36:11 +08:00
def run(procedure, config, data):
plug-ins: add a "palette" argument to palette-to-gradient. Older palette-to-gradient used to have a palette argument. Bring it back. The logics is that if the string is empty or None, the procedure will use the currently selected palette. Otherwise it will try to transform the named palette into a gradient and will fail with an error if this palette does not exist.
2019-08-06 06:26:22 +08:00
# Get the parameters
plug-ins: forgotten Python plug-ins had to be ported to new Gimp.Procedure.new(). There was also one case of port to updated GimpResource API to get the name of a palette.
2023-06-17 05:36:11 +08:00
run_mode = config.get_property("run-mode")
plug-ins: Show GUI for Palette to Gradient Also shows GUI for Palette to Repeating Gradient function
2023-01-15 03:00:48 +08:00
if run_mode == Gimp.RunMode.INTERACTIVE:
GimpUi.init(procedure.get_name())
dialog = GimpUi.ProcedureDialog(procedure=procedure, config=config)
# Add palette button
dialog.fill (["palette"])
if not dialog.run():
dialog.destroy()
return procedure.new_return_values(Gimp.PDBStatusType.CANCEL, GLib.Error())
plug-ins: forgotten Python plug-ins had to be ported to new Gimp.Procedure.new(). There was also one case of port to updated GimpResource API to get the name of a palette.
2023-06-17 05:36:11 +08:00
dialog.destroy()
plug-ins: Show GUI for Palette to Gradient Also shows GUI for Palette to Repeating Gradient function
2023-01-15 03:00:48 +08:00
plug-ins: forgotten Python plug-ins had to be ported to new Gimp.Procedure.new(). There was also one case of port to updated GimpResource API to get the name of a palette.
2023-06-17 05:36:11 +08:00
palette = config.get_property("palette")
plug-ins: Show GUI for Palette to Gradient Also shows GUI for Palette to Repeating Gradient function
2023-01-15 03:00:48 +08:00
if palette is None or not palette.is_valid():
if palette is not None:
sys.stderr.write(f'Invalid palette id: {palette.get_id()}\n')
sys.stderr.write('This should not happen. Please report to GIMP project.\n')
sys.stderr.write('Falling back to context palette instead.\n')
plug-ins: add a "palette" argument to palette-to-gradient. Older palette-to-gradient used to have a palette argument. Bring it back. The logics is that if the string is empty or None, the procedure will use the currently selected palette. Otherwise it will try to transform the named palette into a gradient and will fail with an error if this palette does not exist.
2019-08-06 06:26:22 +08:00
palette = Gimp.context_get_palette()
plug-ins: forgotten Python plug-ins had to be ported to new Gimp.Procedure.new(). There was also one case of port to updated GimpResource API to get the name of a palette.
2023-06-17 05:36:11 +08:00
config.set_property("palette", palette)
Fix plugins to use new GimpResource.
2022-09-06 07:28:35 +08:00
num_colors = palette.get_color_count()
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
if procedure.get_name() == 'python-fu-palette-to-gradient':
num_segments = num_colors - 1
else: # 'python-fu-palette-to-gradient-repeating'
num_segments = num_colors
gradient = make_gradient(palette, num_segments, num_colors)
# XXX: for the error parameter, we want to return None.
# Unfortunately even though the argument is (nullable), pygobject
# looks like it may have a bug. So workaround is to just set a
# generic GLib.Error() since anyway the error won't be process with
# GIMP_PDB_SUCCESS status.
# See pygobject#351
retval = procedure.new_return_values(Gimp.PDBStatusType.SUCCESS, GLib.Error())
plug-ins: use new gimp_procedure_add_*_from_property() in Python. Since GParamSpec are not working fine (cf. pygobject#227), we have this trick of initializing new arguments or return values with properties. Use this trick in the palette-to-gradient plug-in.
2019-08-03 04:48:38 +08:00
# XXX: I don't try to get the GValue with retval.index(1) because it
# actually return a string (cf. pygobject#353). Just create a new
# GValue and replace the default one with this one.
Fix plugins to use new GimpResource.
2022-09-06 07:28:35 +08:00
# This comment dates from when resources are strings:
# value = GObject.Value(GObject.TYPE_STRING, gradient)
value = GObject.Value(Gimp.Gradient, gradient)
plug-ins: use new gimp_procedure_add_*_from_property() in Python. Since GParamSpec are not working fine (cf. pygobject#227), we have this trick of initializing new arguments or return values with properties. Use this trick in the palette-to-gradient plug-in.
2019-08-03 04:48:38 +08:00
retval.remove(1)
retval.insert(1, value)
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
return retval
class PaletteToGradient (Gimp.PlugIn):
plug-ins: use new gimp_procedure_add_*_from_property() in Python. Since GParamSpec are not working fine (cf. pygobject#227), we have this trick of initializing new arguments or return values with properties. Use this trick in the palette-to-gradient plug-in.
2019-08-03 04:48:38 +08:00
## GimpPlugIn virtual methods ##
plug-ins, libgimp: override set_i18n() for all our core plug-ins. Hence avoiding the stderr messages. These are going to be localized with centrally installed catalogs "gimp*-std-plugins", "gimp*-script-fu" and "gimp*-python". We now handle core plug-in localizations differently and in particular, with kind of a reverse logic: - We don't consider "gimp*-std-plugins" to be the default catalog anymore. It made sense in the old world where we would consider the core plug-ins to be the most important and numerous ones. But we want to push a world where people are even more encouraged to develop their own plug-ins. These won't use the standard catalog anymore (because there are nearly no reasons that the strings are the same, it's only a confusing logic). So let's explicitly set the standard catalogs with DEFINE_STD_SET_I18N macro (which maps to a different catalog for script-fu plug-ins). - Doing something similar for Python plug-ins which have again their own catalog. - Getting rid of the INIT_I18N macro since now all the locale domain binding is done automatically by libgimp when using the set_i18n() method infrastructure.
2022-05-26 06:59:36 +08:00
def do_set_i18n(self, procname):
return True, 'gimp30-python', None
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
def do_query_procedures(self):
return ['python-fu-palette-to-gradient',
libgimp, plug-ins: remove n_procedures from (init|query)_procedures(). The way currently implemented plug-ins are, they are already NULL-terminating the returned arrays. Since a procedure name cannot be NULL itself by definition, defining the array length by a terminal NULL is enough. There is no need to also add a n_procedures parameters which is just one more possible bug source, even more as we were already expecting the NULL termination by using g_strfreev() to free the memory. Anyway a length parameter does not bring any advantage since a plug-in can still "lie" about its array size (just as it can forget to NULL-terminate it) and when this happens, the plug-in will segfault. That's it, it's just a plug-in programming error. Last but not least, some binding seem to have issues with returned array setting an (out) parameter as the length. In pygobject at least, the length parameter doesn't disappear and we end up with this ugly signature: > In [3]: Gimp.PlugIn.do_query_procedures.__doc__ > Out[3]: 'query_procedures(self) -> list, n_procedures:int' See bug report pygobject#352. To avoid this, we should either set both the array and the length as (out) parameters or just set the returned array as NULL-terminated (which is the solution I chose).
2019-08-02 19:36:11 +08:00
'python-fu-palette-to-gradient-repeating']
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
def do_create_procedure(self, name):
procedure = Gimp.Procedure.new(self, name,
Gimp.PDBProcType.PLUGIN,
plug-ins: use new gimp_procedure_add_*_from_property() in Python. Since GParamSpec are not working fine (cf. pygobject#227), we have this trick of initializing new arguments or return values with properties. Use this trick in the palette-to-gradient plug-in.
2019-08-03 04:48:38 +08:00
run, None)
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
if name == 'python-fu-palette-to-gradient':
plug-ins: properly localize core Python plug-ins. - Set the "gimp30-python" Gettext domain and bind it to the proper locale directory as installed by GIMP. - Localize various strings with gettext. - Remove calls to self.set_translation_domain() in do_query_procedures(). This is technically wrong right now but I am going to get rid of the menu item localization for plug-ins done by the core.
2022-05-26 06:26:25 +08:00
procedure.set_menu_label(_("Palette to _Gradient"))
procedure.set_documentation(_("Create a gradient using colors from the palette"),
_("Create a new gradient using colors from the palette."),
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
"")
elif name == 'python-fu-palette-to-gradient-repeating':
plug-ins: properly localize core Python plug-ins. - Set the "gimp30-python" Gettext domain and bind it to the proper locale directory as installed by GIMP. - Localize various strings with gettext. - Remove calls to self.set_translation_domain() in do_query_procedures(). This is technically wrong right now but I am going to get rid of the menu item localization for plug-ins done by the core.
2022-05-26 06:26:25 +08:00
procedure.set_menu_label(_("Palette to _Repeating Gradient"))
procedure.set_documentation(_("Create a repeating gradient using colors from the palette"),
_("Create a new repeating gradient using colors from the palette."),
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
"")
else:
procedure = None
if procedure is not None:
procedure.set_attribution("Carol Spears, reproduced from previous work by Adrian Likins and Jeff Trefftz",
"Carol Spears", "2006")
python: Port arguments code to use functions This patch ports the first-party Python plug-ins to use the new argument API. This restores the ability to add dropdown menus from enums and Gimp.Choice parameters, and also allows defaults to be set for custom datatypes like Gegl.Color.
2024-06-07 11:09:43 +08:00
procedure.add_enum_argument ("run-mode", _("Run mode"),
_("The run mode"), Gimp.RunMode,
Gimp.RunMode.NONINTERACTIVE,
GObject.ParamFlags.READWRITE)
procedure.add_palette_argument ("palette", _("_Palette"),
plug-ins: Allow Python GUI resources to be empty Resolves #11772 While ba79fd00 fixed the number of arguments in the resource arguments, setting them to False prevented the GUI from opening if the gradient wasn't set. This patch switches the value to True to fix the problem.
2024-07-08 03:19:16 +08:00
_("Palette"), True,
python: Port arguments code to use functions This patch ports the first-party Python plug-ins to use the new argument API. This restores the ability to add dropdown menus from enums and Gimp.Choice parameters, and also allows defaults to be set for custom datatypes like Gegl.Color.
2024-06-07 11:09:43 +08:00
GObject.ParamFlags.READWRITE)
procedure.add_gradient_return_value ("new-gradient", _("The newly created gradient"),
_("The newly created gradient"),
GObject.ParamFlags.READWRITE)
plug-ins: use new gimp_procedure_add_*_from_property() in Python. Since GParamSpec are not working fine (cf. pygobject#227), we have this trick of initializing new arguments or return values with properties. Use this trick in the palette-to-gradient plug-in.
2019-08-03 04:48:38 +08:00
menus: move menus to submenus of tab menu Fixes #9883 There were menus that put their entries directly in the tab menu rather than in a submenu. This moves them to submenus to bring back GIMP 2.10 behavior. Stray entries added by scripts are also moved to the right submenu.
2024-02-25 07:13:01 +08:00
procedure.add_menu_path ('<Palettes>/Palettes Menu')
plug-ins: start porting palette-to-gradient to new GimpPlugIn API. Several aspects of the new API are kind of broken in the Python binding, especially the arguments. So this first version has no arguments at all. This also means it cannot be installed in "<Palettes>" menu for the time being. This is work-in-progress and the missing parts will be uncommented later when we figure out how to fix the problems.
2019-08-02 02:34:14 +08:00
return procedure
Gimp.main(PaletteToGradient.__gtype__, sys.argv)