def textwrap(s, width=78, asian=False):
"""
Wraps the unicode string `s`, and returns a list of strings.
`width`
The number of half-width characters that fit on a line.
`asian`
True if we should make ambiguous width characters full-width, as is
done in Asian encodings.
"""
import unicodedata
glyphs = [ ]
for c in str(s):
eaw = unicodedata.east_asian_width(c)
if (eaw == "F") or (eaw == "W"):
gwidth = 20
elif (eaw == "A"):
if asian:
gwidth = 20
else:
gwidth = 10
else:
gwidth = 10
g = textsupport.Glyph()
g.character = ord(c)
g.ascent = 10
g.line_spacing = 10
g.width = gwidth
g.advance = gwidth
glyphs.append(g)
textsupport.annotate_unicode(glyphs, False, 2)
renpy.text.texwrap.linebreak_tex(glyphs, width * 10, width * 10, False)
return textsupport.linebreak_list(glyphs)
def textwrap(s, width=78, asian=False):
"""
Wraps the unicode string `s`, and returns a list of strings.
`width`
The number of half-width characters that fit on a line.
`asian`
True if we should make ambiguous width characters full-width, as is
done in Asian encodings.
"""
import unicodedata
glyphs = [ ]
for c in unicode(s):
eaw = unicodedata.east_asian_width(c)
if (eaw == "F") or (eaw =="W"):
gwidth = 20
elif (eaw == "A"):
if asian:
gwidth = 20
else:
gwidth = 10
else:
gwidth = 10
g = textsupport.Glyph()
g.character = ord(c)
g.ascent = 10
g.line_spacing = 10
g.width = gwidth
g.advance = gwidth
glyphs.append(g)
textsupport.annotate_unicode(glyphs, False, 2)
renpy.text.texwrap.linebreak_tex(glyphs, width * 10, width * 10, False)
return textsupport.linebreak_list(glyphs)
def __init__(self, text, width, height, renders, size_only=False):
"""
`text`
The text object this layout is associated with.
`width`, `height`
The height of the laid-out text.
`renders`
A map from displayable to its render.
`size_only`
If true, layout will stop once the size field is filled
out. The object will only be suitable for sizing, as it
will be missing the textures required to render it.
"""
style = text.style
self.line_overlap_split = style.line_overlap_split
# Do we have any hyperlinks in this text? Set by segment.
self.has_hyperlinks = False
# Do we have any ruby in the text?
self.has_ruby = False
# Slow text that is not before the start segment is displayed
# instantaneously. Text after the end segment is not displayed
# at all. These are controlled by the {_start} and {_end} tags.
self.start_segment = None
self.end_segment = None
self.width = width
self.height = height
# Figure out outlines and other info.
outlines, xborder, yborder, xoffset, yoffset = self.figure_outlines(
style)
self.outlines = outlines
self.xborder = xborder
self.yborder = yborder
self.xoffset = xoffset
self.yoffset = yoffset
# Adjust the borders by the outlines.
width -= self.xborder
height -= self.yborder
# The greatest x coordinate of the text.
maxx = 0
# The current y, which becomes the maximum height once all paragraphs
# have been rendered.
y = 0
# A list of glyphs - all the glyphs we know of.
all_glyphs = []
# A list of (segment, glyph_list) pairs for all paragraphs.
par_seg_glyphs = []
# A list of Line objects.
lines = []
# The time at which the next glyph will be displayed.
gt = 0.0
# True if we've encountered the end segment while assigning times.
ended = False
# 2. Breaks the text into a list of paragraphs, where each paragraph is
# represented as a list of (Segment, text string) tuples.
#
# This takes information from the various styles that apply to the text,
# and so needs to be redone when the style of the text changes.
self.paragraphs = self.segment(text.tokens, style, renders)
first_indent = style.first_indent
rest_indent = style.rest_indent
for p in self.paragraphs:
# RTL - apply RTL to the text of each segment, then
# reverse the order of the segments in each paragraph.
if renpy.config.rtl:
p, rtl = self.rtl_paragraph(p)
else:
rtl = False
# 3. Convert each paragraph into a Segment, glyph list. (Store this
# to use when we draw things.)
# A list of glyphs in the line.
line_glyphs = []
# A list of (segment, list of glyph) pairs.
seg_glyphs = []
for ts, s in p:
glyphs = ts.glyphs(s)
t = (ts, glyphs)
seg_glyphs.append(t)
par_seg_glyphs.append(t)
line_glyphs.extend(glyphs)
all_glyphs.extend(glyphs)
# RTL - Reverse each line, segment, so that we can use LTR
# linebreaking algorithms.
if rtl:
line_glyphs.reverse()
for ts, glyphs in seg_glyphs:
glyphs.reverse()
# Tag the glyphs that are eligible for line breaking, and if
# they should be included or excluded from the end of a line.
language = style.language
if language == "unicode" or language == "eastasian":
textsupport.annotate_unicode(line_glyphs, False, 0)
elif language == "korean-with-spaces":
textsupport.annotate_unicode(line_glyphs, True, 0)
elif language == "western":
textsupport.annotate_western(line_glyphs)
elif language == "japanese-loose":
textsupport.annotate_unicode(line_glyphs, False, 1)
elif language == "japanese-normal":
textsupport.annotate_unicode(line_glyphs, False, 2)
elif language == "japanese-strict":
textsupport.annotate_unicode(line_glyphs, False, 3)
else:
raise Exception("Unknown language: {0}".format(language))
# Break the paragraph up into lines.
layout = style.layout
if layout == "tex":
texwrap.linebreak_tex(line_glyphs, width - first_indent,
width - rest_indent, False)
elif layout == "subtitle" or layout == "tex-subtitle":
texwrap.linebreak_tex(line_glyphs, width - first_indent,
width - rest_indent, True)
elif layout == "greedy":
textsupport.linebreak_greedy(line_glyphs, width - first_indent,
width - rest_indent)
elif layout == "nobreak":
textsupport.linebreak_nobreak(line_glyphs)
else:
raise Exception("Unknown layout: {0}".format(layout))
for ts, glyphs in seg_glyphs:
# Only assign a time if we're past the start segment.
if self.start_segment is not None:
if self.start_segment is ts:
self.start_segment = None
else:
continue
if ts is self.end_segment:
ended = True
if ended:
textsupport.assign_times(gt, 0.0, glyphs)
else:
gt = ts.assign_times(gt, glyphs)
# RTL - Reverse the glyphs in each line, back to RTL order,
# now that we have lines.
if rtl:
line_glyphs = textsupport.reverse_lines(line_glyphs)
# Taking into account indentation, kerning, justification, and text_align,
# lay out the X coordinate of each glyph.
w = textsupport.place_horizontal(line_glyphs, 0, first_indent,
rest_indent)
if w > maxx:
maxx = w
# Figure out the line height, line spacing, and the y coordinate of each
# glyph.
l, y = textsupport.place_vertical(line_glyphs, y,
style.line_spacing,
style.line_leading)
lines.extend(l)
# Figure out the indent of the next paragraph.
if not style.newline_indent:
first_indent = rest_indent
if style.line_spacing < 0:
if renpy.config.broken_line_spacing:
y += -style.line_spacing * len(lines)
else:
y += -style.line_spacing
lines[-1].height = y - lines[-1].y
if style.min_width > maxx + self.xborder:
maxx = style.min_width - self.xborder
maxx = math.ceil(maxx)
textsupport.align_and_justify(lines, maxx, style.text_align,
style.justify)
# Figure out the size of the texture. (This is a little over-sized,
# but it simplifies the code to not have to care about borders on a
# per-outline basis.)
sw, sh = size = (maxx + self.xborder, y + self.yborder)
self.size = size
# If we only care about the size, we're done.
if size_only:
return
# Place ruby.
if self.has_ruby:
textsupport.place_ruby(all_glyphs, style.ruby_style.yoffset, sw,
sh)
# Check for glyphs that are being drawn out of bounds, because the font
# or anti-aliasing or whatever makes them bigger than the bounding box. If
# we have them, grow the b
bounds = (0, 0, maxx, y)
for ts, glyphs in par_seg_glyphs:
bounds = ts.bounds(glyphs, bounds)
self.add_left = max(-bounds[0], 0)
self.add_top = max(-bounds[1], 0)
self.add_right = max(bounds[2] - maxx, 0)
self.add_bottom = max(bounds[3] - y, 0)
sw += self.add_left * 10 + self.add_right
sh += self.add_top + self.add_bottom
# A map from (outline, color) to a texture.
self.textures = {}
di = DrawInfo()
for o, color, _xo, _yo in self.outlines:
key = (o, color)
if key in self.textures:
continue
# Create the texture.
surf = renpy.display.pgrender.surface((sw, sh), True)
di.surface = surf
di.override_color = color
di.outline = o
if color == None:
self.displayable_blits = []
di.displayable_blits = self.displayable_blits
else:
di.displayable_blits = None
for ts, glyphs in par_seg_glyphs:
if ts is self.end_segment:
break
ts.draw(glyphs, di, self.add_left, self.add_top)
renpy.display.draw.mutated_surface(surf)
tex = renpy.display.draw.load_texture(surf)
self.textures[key] = tex
# Compute the max time for all lines, and the max max time.
self.max_time = textsupport.max_times(lines)
# Store the lines, so we have them for typeout.
self.lines = lines
# Store the hyperlinks, if any.
if self.has_hyperlinks:
self.hyperlinks = textsupport.hyperlink_areas(lines)
else:
self.hyperlinks = []
# Log an overflow if the laid out width or height is larger than the
# size of the provided area.
if renpy.config.debug_text_overflow:
ow, oh = self.size
if ow > width or oh > height:
filename, line = renpy.exports.get_filename_line()
renpy.display.to_log.write("")
renpy.display.to_log.write(
"File \"%s\", line %d, text overflow:", filename, line)
renpy.display.to_log.write(
" Available: (%d, %d) Laid-out: (%d, %d)", width,
height, sw, sh)
renpy.display.to_log.write(" Text: %r", text.text)
def __init__(self, text, width, height, renders, size_only=False):
"""
`text`
The text object this layout is associated with.
`width`, `height`
The height of the laid-out text.
`renders`
A map from displayable to its render.
`size_only`
If true, layout will stop once the size field is filled
out. The object will only be suitable for sizing, as it
will be missing the textures required to render it.
"""
style = text.style
self.line_overlap_split = style.line_overlap_split
# Do we have any hyperlinks in this text? Set by segment.
self.has_hyperlinks = False
# Do we have any ruby in the text?
self.has_ruby = False
# Slow text that is not before the start segment is displayed
# instantaneously. Text after the end segment is not displayed
# at all. These are controlled by the {_start} and {_end} tags.
self.start_segment = None
self.end_segment = None
self.width = width
self.height = height
# Figure out outlines and other info.
outlines, xborder, yborder, xoffset, yoffset = self.figure_outlines(style)
self.outlines = outlines
self.xborder = xborder
self.yborder = yborder
self.xoffset = xoffset
self.yoffset = yoffset
# Adjust the borders by the outlines.
width -= self.xborder
height -= self.yborder
# The greatest x coordinate of the text.
maxx = 0
# The current y, which becomes the maximum height once all paragraphs
# have been rendered.
y = 0
# A list of glyphs - all the glyphs we know of.
all_glyphs = [ ]
# A list of (segment, glyph_list) pairs for all paragraphs.
par_seg_glyphs = [ ]
# A list of Line objects.
lines = [ ]
# The time at which the next glyph will be displayed.
gt = 0.0
# True if we've encountered the end segment while assigning times.
ended = False
# 2. Breaks the text into a list of paragraphs, where each paragraph is
# represented as a list of (Segment, text string) tuples.
#
# This takes information from the various styles that apply to the text,
# and so needs to be redone when the style of the text changes.
self.paragraphs = self.segment(text.tokens, style, renders)
first_indent = style.first_indent
rest_indent = style.rest_indent
for p in self.paragraphs:
# RTL - apply RTL to the text of each segment, then
# reverse the order of the segments in each paragraph.
if renpy.config.rtl:
p, rtl = self.rtl_paragraph(p)
else:
rtl = False
# 3. Convert each paragraph into a Segment, glyph list. (Store this
# to use when we draw things.)
# A list of glyphs in the line.
line_glyphs = [ ]
# A list of (segment, list of glyph) pairs.
seg_glyphs = [ ]
for ts, s in p:
glyphs = ts.glyphs(s)
t = (ts, glyphs)
seg_glyphs.append(t)
par_seg_glyphs.append(t)
line_glyphs.extend(glyphs)
all_glyphs.extend(glyphs)
# RTL - Reverse each line, segment, so that we can use LTR
# linebreaking algorithms.
if rtl:
line_glyphs.reverse()
for ts, glyphs in seg_glyphs:
glyphs.reverse()
# Tag the glyphs that are eligible for line breaking, and if
# they should be included or excluded from the end of a line.
language = style.language
if language == "unicode" or language == "eastasian":
textsupport.annotate_unicode(line_glyphs, False, 0)
elif language == "korean-with-spaces":
textsupport.annotate_unicode(line_glyphs, True, 0)
elif language == "western":
textsupport.annotate_western(line_glyphs)
elif language == "japanese-loose":
textsupport.annotate_unicode(line_glyphs, False, 1)
elif language == "japanese-normal":
textsupport.annotate_unicode(line_glyphs, False, 2)
elif language == "japanese-strict":
textsupport.annotate_unicode(line_glyphs, False, 3)
else:
raise Exception("Unknown language: {0}".format(language))
# Break the paragraph up into lines.
layout = style.layout
if layout == "tex":
texwrap.linebreak_tex(line_glyphs, width - first_indent, width - rest_indent, False)
elif layout == "subtitle" or layout == "tex-subtitle":
texwrap.linebreak_tex(line_glyphs, width - first_indent, width - rest_indent, True)
elif layout == "greedy":
textsupport.linebreak_greedy(line_glyphs, width - first_indent, width - rest_indent)
elif layout == "nobreak":
textsupport.linebreak_nobreak(line_glyphs)
else:
raise Exception("Unknown layout: {0}".format(layout))
for ts, glyphs in seg_glyphs:
# Only assign a time if we're past the start segment.
if self.start_segment is not None:
if self.start_segment is ts:
self.start_segment = None
else:
continue
if ts is self.end_segment:
ended = True
if ended:
textsupport.assign_times(gt, 0.0, glyphs)
else:
gt = ts.assign_times(gt, glyphs)
# RTL - Reverse the glyphs in each line, back to RTL order,
# now that we have lines.
if rtl:
line_glyphs = textsupport.reverse_lines(line_glyphs)
# Taking into account indentation, kerning, justification, and text_align,
# lay out the X coordinate of each glyph.
w = textsupport.place_horizontal(line_glyphs, 0, first_indent, rest_indent)
if w > maxx:
maxx = w
# Figure out the line height, line spacing, and the y coordinate of each
# glyph.
l, y = textsupport.place_vertical(line_glyphs, y, style.line_spacing, style.line_leading)
lines.extend(l)
# Figure out the indent of the next paragraph.
if not style.newline_indent:
first_indent = rest_indent
if style.line_spacing < 0:
if renpy.config.broken_line_spacing:
y += -style.line_spacing * len(lines)
else:
y += -style.line_spacing
lines[-1].height = y - lines[-1].y
if style.min_width > maxx + self.xborder:
maxx = style.min_width - self.xborder
maxx = math.ceil(maxx)
textsupport.align_and_justify(lines, maxx, style.text_align, style.justify)
# Figure out the size of the texture. (This is a little over-sized,
# but it simplifies the code to not have to care about borders on a
# per-outline basis.)
sw, sh = size = (maxx + self.xborder, y + self.yborder)
self.size = size
# If we only care about the size, we're done.
if size_only:
return
# Place ruby.
if self.has_ruby:
textsupport.place_ruby(all_glyphs, style.ruby_style.yoffset, sw, sh)
# Check for glyphs that are being drawn out of bounds, because the font
# or anti-aliasing or whatever makes them bigger than the bounding box. If
# we have them, grow the b
bounds = (0, 0, maxx, y)
for ts, glyphs in par_seg_glyphs:
bounds = ts.bounds(glyphs, bounds)
self.add_left = max(-bounds[0], 0)
self.add_top = max(-bounds[1], 0)
self.add_right = max(bounds[2] - maxx, 0)
self.add_bottom = max(bounds[3] - y, 0)
sw += self.add_left * 10 + self.add_right
sh += self.add_top + self.add_bottom
# A map from (outline, color) to a texture.
self.textures = { }
di = DrawInfo()
for o, color, _xo, _yo in self.outlines:
key = (o, color)
if key in self.textures:
continue
# Create the texture.
surf = renpy.display.pgrender.surface((sw, sh), True)
di.surface = surf
di.override_color = color
di.outline = o
if color == None:
self.displayable_blits = [ ]
di.displayable_blits = self.displayable_blits
else:
di.displayable_blits = None
for ts, glyphs in par_seg_glyphs:
if ts is self.end_segment:
break
ts.draw(glyphs, di, self.add_left, self.add_top)
renpy.display.draw.mutated_surface(surf)
tex = renpy.display.draw.load_texture(surf)
self.textures[key] = tex
# Compute the max time for all lines, and the max max time.
self.max_time = textsupport.max_times(lines)
# Store the lines, so we have them for typeout.
self.lines = lines
# Store the hyperlinks, if any.
if self.has_hyperlinks:
self.hyperlinks = textsupport.hyperlink_areas(lines)
else:
self.hyperlinks = [ ]
# Log an overflow if the laid out width or height is larger than the
# size of the provided area.
if renpy.config.debug_text_overflow:
ow, oh = self.size
if ow > width or oh > height:
filename, line = renpy.exports.get_filename_line()
renpy.display.to_log.write("")
renpy.display.to_log.write("File \"%s\", line %d, text overflow:", filename, line)
renpy.display.to_log.write(" Available: (%d, %d) Laid-out: (%d, %d)", width, height, sw, sh)
renpy.display.to_log.write(" Text: %r", text.text)
