mirror of
https://gitlab.gnome.org/GNOME/gimp.git
synced 2025-07-04 01:43:24 +00:00
8b6d90700a
The original reason to skip these was because the new _list_ API were
introspected basically to a similar function signature, except with a
useless return value, at least in pygobject binding where the list size
was also returned.
Though it seems that in fact, only the docstring was wrong. The real
signature was apparently already the same.
See: https://gitlab.gnome.org/GNOME/pygobject/-/issues/352
Therefore since the _get_ naming is more consistent compared to other
existing function, let's re-integrate the _get_ functions for array of
items or images.
This basically reverts commit 15ec254148.
240 lines
8 KiB
Python
Executable file
240 lines
8 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
|
|
# Gimp-Python - allows the writing of Gimp plugins in Python.
|
|
# Copyright (C) 2003, 2005 Manish Singh <yosh@gimp.org>
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
import string
|
|
import struct
|
|
import os.path
|
|
import sys
|
|
|
|
import gi
|
|
gi.require_version('Gimp', '3.0')
|
|
from gi.repository import Gimp
|
|
gi.require_version('GimpUi', '3.0')
|
|
from gi.repository import GimpUi
|
|
from gi.repository import GObject
|
|
from gi.repository import GLib
|
|
from gi.repository import Gio
|
|
|
|
def N_(message): return message
|
|
def _(message): return GLib.dgettext(None, message)
|
|
|
|
|
|
escape_table = {
|
|
'&': '&',
|
|
'<': '<',
|
|
'>': '>',
|
|
'"': '"'
|
|
}
|
|
|
|
style_def = """body {
|
|
width: 100%%;
|
|
font-size: %dpx;
|
|
background-color: #000000;
|
|
color: #ffffff;
|
|
}
|
|
"""
|
|
|
|
preamble = """<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>CSS Color XHTML written by GIMP</title>
|
|
%s
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
</head>
|
|
<body>
|
|
<pre>
|
|
"""
|
|
|
|
postamble = """\n</pre>\n</body>\n</html>\n"""
|
|
|
|
def export_colorxhtml(procedure, run_mode, image, file, metadata, config, data):
|
|
if file is None:
|
|
error = 'No file given'
|
|
return procedure.new_return_values(Gimp.PDBStatusType.CALLING_ERROR,
|
|
GLib.Error(error))
|
|
|
|
if run_mode == Gimp.RunMode.INTERACTIVE:
|
|
|
|
gi.require_version('Gtk', '3.0')
|
|
from gi.repository import Gtk
|
|
|
|
GimpUi.init ("file-colorxhtml-export")
|
|
|
|
dialog = GimpUi.ProcedureDialog.new(procedure, config, _("Save as colored HTML text..."))
|
|
|
|
dialog.fill_frame("file-frame", "source-file", False, "aux-file")
|
|
# Set the characters text field as not enabled when the user chooses a file
|
|
dialog.set_sensitive("characters", True, config, "source-file", True)
|
|
|
|
dialog.fill(["characters", "file-frame", "font-size", "separate"])
|
|
|
|
if not dialog.run():
|
|
return procedure.new_return_values(Gimp.PDBStatusType.CANCEL,
|
|
GLib.Error())
|
|
|
|
source_file = config.get_property("source-file")
|
|
characters = config.get_property("characters")
|
|
size = config.get_property("font-size");
|
|
separate = config.get_property("separate")
|
|
aux_file = config.get_property("aux-file")
|
|
|
|
if source_file and aux_file:
|
|
characters = aux_file.get_path()
|
|
|
|
#For now, work with a single layer
|
|
layer = image.get_layers()[0]
|
|
|
|
width = layer.get_width()
|
|
height = layer.get_height()
|
|
bpp = layer.get_bpp()
|
|
|
|
html = open(file.peek_path(), 'w')
|
|
|
|
if separate:
|
|
dirname, cssfile = os.path.split(file.peek_path())
|
|
cssfile = os.path.splitext(cssfile)[0] + '.css'
|
|
cssname = os.path.join(dirname, cssfile)
|
|
|
|
css = open(cssname, 'w')
|
|
|
|
if source_file:
|
|
characters_file = open(characters, 'r')
|
|
chars = characters_file.read()
|
|
characters_file.close()
|
|
else:
|
|
chars = characters
|
|
|
|
# Remove unprintable characters from "chars".
|
|
# TODO: This only handles ascii files. It would be nice to handle unicode
|
|
# files, so this could work for any language.
|
|
goodchars = string.digits + string.ascii_letters + string.punctuation
|
|
badchars = ''.join(chr(i) for i in range(256) if chr(i) not in goodchars)
|
|
allchars = str.maketrans('', '', badchars)
|
|
chars = chars.translate(allchars)
|
|
|
|
data = [escape_table.get(c, c) for c in chars]
|
|
|
|
if data:
|
|
data.reverse()
|
|
else:
|
|
data = list('X' * 80)
|
|
|
|
Gimp.progress_init(_("Saving as colored XHTML"))
|
|
|
|
style = style_def % size
|
|
|
|
if separate:
|
|
ss = '<link rel="stylesheet" type="text/css" href="%s" />' % cssfile
|
|
css.write(style)
|
|
else:
|
|
ss = '<style type="text/css">\n%s</style>' % style
|
|
|
|
html.write(preamble % ss)
|
|
|
|
colors = {}
|
|
chars = []
|
|
|
|
for y in range(0, height):
|
|
|
|
# The characters in "chars" will be used to draw the next row.
|
|
# Lets fill "chars" with data so it has at least enough characters.
|
|
while len(chars) < width:
|
|
chars[0:0] = data
|
|
|
|
for x in range(0, width):
|
|
pixel_color = layer.get_pixel(x, y)
|
|
pixel_rgb = pixel_color.get_rgba()
|
|
pixel_tuple = (int(pixel_rgb[0] * 255),
|
|
int(pixel_rgb[1] * 255),
|
|
int(pixel_rgb[2] * 255))
|
|
|
|
color = '%02x%02x%02x' % pixel_tuple
|
|
style = 'background-color:black; color:#%s;' % color
|
|
char = chars.pop()
|
|
|
|
if separate:
|
|
if color not in colors:
|
|
css.write('span.N%s { %s }\n' % (color, style))
|
|
colors[color] = 1
|
|
|
|
html.write('<span class="N%s">%s</span>' % (color, char))
|
|
|
|
else:
|
|
html.write('<span style="%s">%s</span>' % (style, char))
|
|
|
|
html.write('\n')
|
|
|
|
Gimp.progress_update(y / float(height))
|
|
|
|
html.write(postamble)
|
|
|
|
html.close()
|
|
if separate:
|
|
css.close()
|
|
|
|
return Gimp.ValueArray.new_from_values([
|
|
GObject.Value(Gimp.PDBStatusType, Gimp.PDBStatusType.SUCCESS)
|
|
])
|
|
|
|
|
|
class ColorXhtml(Gimp.PlugIn):
|
|
## GimpPlugIn virtual methods ##
|
|
def do_set_i18n(self, procname):
|
|
return True, 'gimp30-python', None
|
|
|
|
def do_query_procedures(self):
|
|
return [ 'file-colorxhtml-export' ]
|
|
|
|
def do_create_procedure(self, name):
|
|
procedure = None
|
|
if name == 'file-colorxhtml-export':
|
|
procedure = Gimp.ExportProcedure.new(self, name,
|
|
Gimp.PDBProcType.PLUGIN,
|
|
False, export_colorxhtml, None)
|
|
procedure.set_image_types("RGB")
|
|
procedure.set_documentation (
|
|
_("Save as colored HTML text"),
|
|
"Saves the image as colored XHTML text (based on Perl version by Marc Lehmann)",
|
|
name)
|
|
procedure.set_menu_label(_("Colored HTML text"))
|
|
procedure.set_attribution("Manish Singh and Carol Spears",
|
|
"(c) GPL V3.0 or later",
|
|
"2003")
|
|
|
|
procedure.set_extensions ("html,xhtml");
|
|
|
|
procedure.add_boolean_argument ("source-file",
|
|
_("Rea_d characters from file"),
|
|
_("Read characters from file, if true, or use text entry"),
|
|
False, GObject.ParamFlags.READWRITE)
|
|
procedure.add_string_argument ("characters", _("Charac_ters"),
|
|
_("Characters that will be used as colored pixels."),
|
|
"foo", GObject.ParamFlags.READWRITE)
|
|
procedure.add_int_argument ("font-size", _("Fo_nt size in pixels"),
|
|
_("Font size in pixels"), 5, 100, 10,
|
|
GObject.ParamFlags.READWRITE)
|
|
procedure.add_boolean_argument ("separate", _("_Write a separate CSS file"),
|
|
_("Write a separate CSS file"),
|
|
False, GObject.ParamFlags.READWRITE)
|
|
#GUI only, used to create a widget to open a file if source-file is enabled
|
|
procedure.add_file_aux_argument ("aux-file", _("Choose File"),
|
|
"", GObject.ParamFlags.READWRITE)
|
|
|
|
return procedure
|
|
|
|
Gimp.main(ColorXhtml.__gtype__, sys.argv)
|