"""

Classes for including text in a figure.

"""

from __future__ import absolute_import, division, print_function

import six

from six.moves import zip

import contextlib

import logging

import math

import warnings

import weakref

import numpy as np

from . import artist, cbook, docstring, rcParams

from .artist import Artist

from .font_manager import FontProperties

from .lines import Line2D

from .patches import FancyArrowPatch, FancyBboxPatch, Rectangle

from .textpath import TextPath # Unused, but imported by others.

from .transforms import (

Affine2D, Bbox, BboxBase, BboxTransformTo, IdentityTransform, Transform)

_log = logging.getLogger(__name__)

def _process_text_args(override, fontdict=None, **kwargs):

"Return an override dict. See :func:`~pyplot.text' docstring for info"

if fontdict is not None:

override.update(fontdict)

override.update(kwargs)

return override

@contextlib.contextmanager

def _wrap_text(textobj):

"""Temporarily inserts newlines to the text if the wrap option is enabled.

"""

if textobj.get_wrap():

old_text = textobj.get_text()

try:

textobj.set_text(textobj._get_wrapped_text())

yield textobj

finally:

textobj.set_text(old_text)

else:

yield textobj

# Extracted from Text's method to serve as a function

def get_rotation(rotation):

"""

Return the text angle as float. The returned

angle is between 0 and 360 deg.

*rotation* may be 'horizontal', 'vertical', or a numeric value in degrees.

"""

try:

angle = float(rotation)

except (ValueError, TypeError):

isString = isinstance(rotation, six.string_types)

if ((isString and rotation == 'horizontal') or rotation is None):

angle = 0.

elif (isString and rotation == 'vertical'):

angle = 90.

else:

raise ValueError("rotation is {0} expected either 'horizontal'"

" 'vertical', numeric value or"

"None".format(rotation))

return angle % 360

def _get_textbox(text, renderer):

"""

Calculate the bounding box of the text. Unlike

:meth:`matplotlib.text.Text.get_extents` method, The bbox size of

the text before the rotation is calculated.

"""

# TODO : This function may move into the Text class as a method. As a

# matter of fact, The information from the _get_textbox function

# should be available during the Text._get_layout() call, which is

# called within the _get_textbox. So, it would better to move this

# function as a method with some refactoring of _get_layout method.

projected_xs = []

projected_ys = []

theta = np.deg2rad(text.get_rotation())

tr = Affine2D().rotate(-theta)

_, parts, d = text._get_layout(renderer)

for t, wh, x, y in parts:

w, h = wh

xt1, yt1 = tr.transform_point((x, y))

yt1 -= d

xt2, yt2 = xt1 + w, yt1 + h

projected_xs.extend([xt1, xt2])

projected_ys.extend([yt1, yt2])

xt_box, yt_box = min(projected_xs), min(projected_ys)

w_box, h_box = max(projected_xs) - xt_box, max(projected_ys) - yt_box

tr = Affine2D().rotate(theta)

x_box, y_box = tr.transform_point((xt_box, yt_box))

return x_box, y_box, w_box, h_box

class Text(Artist):

"""

Handle storing and drawing of text in window or data coordinates.

"""

zorder = 3

_cached = cbook.maxdict(50)

def __repr__(self):

return "Text(%g,%g,%s)" % (self._x, self._y, repr(self._text))

def __init__(self,

x=0, y=0, text='',

color=None, # defaults to rc params

verticalalignment='baseline',

horizontalalignment='left',

multialignment=None,

fontproperties=None, # defaults to FontProperties()

rotation=None,

linespacing=None,

rotation_mode=None,

usetex=None, # defaults to rcParams['text.usetex']

wrap=False,

**kwargs

):

"""

Create a :class:`~matplotlib.text.Text` instance at *x*, *y*

with string *text*.

Valid kwargs are

%(Text)s

"""

Artist.__init__(self)

self._x, self._y = x, y

if color is None:

color = rcParams['text.color']

if fontproperties is None:

fontproperties = FontProperties()

elif isinstance(fontproperties, six.string_types):

fontproperties = FontProperties(fontproperties)

self.set_text(text)

self.set_color(color)

self.set_usetex(usetex)

self.set_wrap(wrap)

self._verticalalignment = verticalalignment

self._horizontalalignment = horizontalalignment

self._multialignment = multialignment

self._rotation = rotation

self._fontproperties = fontproperties

self._bbox_patch = None # a FancyBboxPatch instance

self._renderer = None

if linespacing is None:

linespacing = 1.2 # Maybe use rcParam later.

self._linespacing = linespacing

self.set_rotation_mode(rotation_mode)

self.update(kwargs)

def update(self, kwargs):

"""

Update properties from a dictionary.

"""

# Update bbox last, as it depends on font properties.

sentinel = object() # bbox can be None, so use another sentinel.

bbox = kwargs.pop("bbox", sentinel)

super(Text, self).update(kwargs)

if bbox is not sentinel:

self.set_bbox(bbox)

def __getstate__(self):

d = super(Text, self).__getstate__()

# remove the cached _renderer (if it exists)

d['_renderer'] = None

return d

def contains(self, mouseevent):

"""Test whether the mouse event occurred in the patch.

In the case of text, a hit is true anywhere in the

axis-aligned bounding-box containing the text.

Returns True or False.

"""

if callable(self._contains):

return self._contains(self, mouseevent)

if not self.get_visible() or self._renderer is None:

return False, {}

l, b, w, h = self.get_window_extent().bounds

r, t = l + w, b + h

x, y = mouseevent.x, mouseevent.y

inside = (l <= x <= r and b <= y <= t)

cattr = {}

# if the text has a surrounding patch, also check containment for it,

# and merge the results with the results for the text.

if self._bbox_patch:

patch_inside, patch_cattr = self._bbox_patch.contains(mouseevent)

inside = inside or patch_inside

cattr["bbox_patch"] = patch_cattr

return inside, cattr

def _get_xy_display(self):

'get the (possibly unit converted) transformed x, y in display coords'

x, y = self.get_unitless_position()

return self.get_transform().transform_point((x, y))

def _get_multialignment(self):

if self._multialignment is not None:

return self._multialignment

else:

return self._horizontalalignment

def get_rotation(self):

'return the text angle as float in degrees'

return get_rotation(self._rotation) # string_or_number -> number

def set_rotation_mode(self, m):

"""

Set text rotation mode.

.. ACCEPTS: [ None | "default" | "anchor" ]

Parameters

----------

m : ``None`` or ``"default"`` or ``"anchor"``

If ``None`` or ``"default"``, the text will be first rotated, then

aligned according to their horizontal and vertical alignments. If

``"anchor"``, then alignment occurs before rotation.

"""

if m is None or m in ["anchor", "default"]:

self._rotation_mode = m

else:

raise ValueError("Unknown rotation_mode : %s" % repr(m))

self.stale = True

def get_rotation_mode(self):

"get text rotation mode"

return self._rotation_mode

def update_from(self, other):

'Copy properties from other to self'

Artist.update_from(self, other)

self._color = other._color

self._multialignment = other._multialignment

self._verticalalignment = other._verticalalignment

self._horizontalalignment = other._horizontalalignment

self._fontproperties = other._fontproperties.copy()

self._rotation = other._rotation

self._picker = other._picker

self._linespacing = other._linespacing

self.stale = True

def _get_layout(self, renderer):

"""

return the extent (bbox) of the text together with

multiple-alignment information. Note that it returns an extent

of a rotated text when necessary.

"""

key = self.get_prop_tup(renderer=renderer)

if key in self._cached:

return self._cached[key]

horizLayout = []

thisx, thisy = 0.0, 0.0

xmin, ymin = 0.0, 0.0

width, height = 0.0, 0.0

lines = self.get_text().split('\n')

whs = np.zeros((len(lines), 2))

horizLayout = np.zeros((len(lines), 4))

# Find full vertical extent of font,

# including ascenders and descenders:

tmp, lp_h, lp_bl = renderer.get_text_width_height_descent('lp',

self._fontproperties,

ismath=False)

offsety = (lp_h - lp_bl) * self._linespacing

baseline = 0

for i, line in enumerate(lines):

clean_line, ismath = self.is_math_text(line, self.get_usetex())

if clean_line:

w, h, d = renderer.get_text_width_height_descent(clean_line,

self._fontproperties,

ismath=ismath)

else:

w, h, d = 0, 0, 0

# For multiline text, increase the line spacing when the

# text net-height(excluding baseline) is larger than that

# of a "l" (e.g., use of superscripts), which seems

# what TeX does.

h = max(h, lp_h)

d = max(d, lp_bl)

whs[i] = w, h

baseline = (h - d) - thisy

thisy -= max(offsety, (h - d) * self._linespacing)

horizLayout[i] = thisx, thisy, w, h

thisy -= d

width = max(width, w)

descent = d

ymin = horizLayout[-1][1]

ymax = horizLayout[0][1] + horizLayout[0][3]

height = ymax - ymin

xmax = xmin + width

# get the rotation matrix

M = Affine2D().rotate_deg(self.get_rotation())

offsetLayout = np.zeros((len(lines), 2))

offsetLayout[:] = horizLayout[:, 0:2]

# now offset the individual text lines within the box

if len(lines) > 1: # do the multiline aligment

malign = self._get_multialignment()

if malign == 'center':

offsetLayout[:, 0] += width / 2.0 - horizLayout[:, 2] / 2.0

elif malign == 'right':

offsetLayout[:, 0] += width - horizLayout[:, 2]

# the corners of the unrotated bounding box

cornersHoriz = np.array(

[(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)], float)

cornersHoriz[:, 1] -= descent

# now rotate the bbox

cornersRotated = M.transform(cornersHoriz)

txs = cornersRotated[:, 0]

tys = cornersRotated[:, 1]

# compute the bounds of the rotated box

xmin, xmax = txs.min(), txs.max()

ymin, ymax = tys.min(), tys.max()

width = xmax - xmin

height = ymax - ymin

# Now move the box to the target position offset the display

# bbox by alignment

halign = self._horizontalalignment

valign = self._verticalalignment

rotation_mode = self.get_rotation_mode()

if rotation_mode != "anchor":

# compute the text location in display coords and the offsets

# necessary to align the bbox with that location

if halign == 'center':

offsetx = (xmin + width / 2.0)

elif halign == 'right':

offsetx = (xmin + width)

else:

offsetx = xmin

if valign == 'center':

offsety = (ymin + height / 2.0)

elif valign == 'top':

offsety = (ymin + height)

elif valign == 'baseline':

offsety = (ymin + height) - baseline

elif valign == 'center_baseline':

offsety = ymin + height - baseline / 2.0

else:

offsety = ymin

else:

xmin1, ymin1 = cornersHoriz[0]

xmax1, ymax1 = cornersHoriz[2]

if halign == 'center':

offsetx = (xmin1 + xmax1) / 2.0

elif halign == 'right':

offsetx = xmax1

else:

offsetx = xmin1

if valign == 'center':

offsety = (ymin1 + ymax1) / 2.0

elif valign == 'top':

offsety = ymax1

elif valign == 'baseline':

offsety = ymax1 - baseline

elif valign == 'center_baseline':

offsety = (ymin1 + ymax1 - baseline) / 2.0

else:

offsety = ymin1

offsetx, offsety = M.transform_point((offsetx, offsety))

xmin -= offsetx

ymin -= offsety

bbox = Bbox.from_bounds(xmin, ymin, width, height)

# now rotate the positions around the first x,y position

xys = M.transform(offsetLayout)

xys -= (offsetx, offsety)

xs, ys = xys[:, 0], xys[:, 1]

ret = bbox, list(zip(lines, whs, xs, ys)), descent

self._cached[key] = ret

return ret

def set_bbox(self, rectprops):

"""

Draw a bounding box around self. rectprops are any settable

properties for a FancyBboxPatch, e.g., facecolor='red', alpha=0.5.

t.set_bbox(dict(facecolor='red', alpha=0.5))

The default boxstyle is 'square'. The mutation

scale of the FancyBboxPatch is set to the fontsize.

ACCEPTS: FancyBboxPatch prop dict

"""

if rectprops is not None:

props = rectprops.copy()

boxstyle = props.pop("boxstyle", None)

pad = props.pop("pad", None)

if boxstyle is None:

boxstyle = "square"

if pad is None:

pad = 4 # points

pad /= self.get_size() # to fraction of font size

else:

if pad is None:

pad = 0.3

# boxstyle could be a callable or a string

if (isinstance(boxstyle, six.string_types)

and "pad" not in boxstyle):

boxstyle += ",pad=%0.2f" % pad

bbox_transmuter = props.pop("bbox_transmuter", None)

self._bbox_patch = FancyBboxPatch(

(0., 0.),

1., 1.,

boxstyle=boxstyle,

bbox_transmuter=bbox_transmuter,

transform=IdentityTransform(),

**props)

else:

self._bbox_patch = None

self._update_clip_properties()

def get_bbox_patch(self):

"""

Return the bbox Patch object. Returns None if the

FancyBboxPatch is not made.

"""

return self._bbox_patch

def update_bbox_position_size(self, renderer):

"""

Update the location and the size of the bbox. This method

should be used when the position and size of the bbox needs to

be updated before actually drawing the bbox.

"""

if self._bbox_patch:

trans = self.get_transform()

# don't use self.get_unitless_position here, which refers to text

# position in Text, and dash position in TextWithDash:

posx = float(self.convert_xunits(self._x))

posy = float(self.convert_yunits(self._y))

posx, posy = trans.transform_point((posx, posy))

x_box, y_box, w_box, h_box = _get_textbox(self, renderer)

self._bbox_patch.set_bounds(0., 0., w_box, h_box)

theta = np.deg2rad(self.get_rotation())

tr = Affine2D().rotate(theta)

tr = tr.translate(posx + x_box, posy + y_box)

self._bbox_patch.set_transform(tr)

fontsize_in_pixel = renderer.points_to_pixels(self.get_size())

self._bbox_patch.set_mutation_scale(fontsize_in_pixel)

def _draw_bbox(self, renderer, posx, posy):

""" Update the location and the size of the bbox

(FancyBboxPatch), and draw

"""

x_box, y_box, w_box, h_box = _get_textbox(self, renderer)

self._bbox_patch.set_bounds(0., 0., w_box, h_box)

theta = np.deg2rad(self.get_rotation())

tr = Affine2D().rotate(theta)

tr = tr.translate(posx + x_box, posy + y_box)

self._bbox_patch.set_transform(tr)

fontsize_in_pixel = renderer.points_to_pixels(self.get_size())

self._bbox_patch.set_mutation_scale(fontsize_in_pixel)

self._bbox_patch.draw(renderer)

def _update_clip_properties(self):

clipprops = dict(clip_box=self.clipbox,

clip_path=self._clippath,

clip_on=self._clipon)

if self._bbox_patch:

bbox = self._bbox_patch.update(clipprops)

def set_clip_box(self, clipbox):

"""

Set the artist's clip :class:`~matplotlib.transforms.Bbox`.

ACCEPTS: a :class:`matplotlib.transforms.Bbox` instance

"""

super(Text, self).set_clip_box(clipbox)

self._update_clip_properties()

def set_clip_path(self, path, transform=None):

"""

Set the artist's clip path, which may be:

* a :class:`~matplotlib.patches.Patch` (or subclass) instance

* a :class:`~matplotlib.path.Path` instance, in which case

an optional :class:`~matplotlib.transforms.Transform`

instance may be provided, which will be applied to the

path before using it for clipping.

* *None*, to remove the clipping path

For efficiency, if the path happens to be an axis-aligned

rectangle, this method will set the clipping box to the

corresponding rectangle and set the clipping path to *None*.

ACCEPTS: [ (:class:`~matplotlib.path.Path`,

:class:`~matplotlib.transforms.Transform`) |

:class:`~matplotlib.patches.Patch` | None ]

"""

super(Text, self).set_clip_path(path, transform)

self._update_clip_properties()

def set_clip_on(self, b):

"""

Set whether artist uses clipping.

When False, artists will be visible outside of the axes, which can lead

to unexpected results.

Parameters

----------

b : bool

.. ACCEPTS: bool

"""

super(Text, self).set_clip_on(b)

self._update_clip_properties()

def get_wrap(self):

"""Returns the wrapping state for the text."""

return self._wrap

def set_wrap(self, wrap):

"""Sets the wrapping state for the text.

Parameters

----------

wrap : bool

.. ACCEPTS: bool

"""

self._wrap = wrap

def _get_wrap_line_width(self):

"""

Returns the maximum line width for wrapping text based on the

current orientation.

"""

x0, y0 = self.get_transform().transform(self.get_position())

figure_box = self.get_figure().get_window_extent()

# Calculate available width based on text alignment

alignment = self.get_horizontalalignment()

self.set_rotation_mode('anchor')

rotation = self.get_rotation()

left = self._get_dist_to_box(rotation, x0, y0, figure_box)

right = self._get_dist_to_box(

(180 + rotation) % 360,

x0,

y0,

figure_box)

if alignment == 'left':

line_width = left

elif alignment == 'right':

line_width = right

else:

line_width = 2 * min(left, right)

return line_width

def _get_dist_to_box(self, rotation, x0, y0, figure_box):

"""

Returns the distance from the given points, to the boundaries

of a rotated box in pixels.

"""

if rotation > 270:

quad = rotation - 270

h1 = y0 / math.cos(math.radians(quad))

h2 = (figure_box.x1 - x0) / math.cos(math.radians(90 - quad))

elif rotation > 180:

quad = rotation - 180

h1 = x0 / math.cos(math.radians(quad))

h2 = y0 / math.cos(math.radians(90 - quad))

elif rotation > 90:

quad = rotation - 90

h1 = (figure_box.y1 - y0) / math.cos(math.radians(quad))

h2 = x0 / math.cos(math.radians(90 - quad))

else:

h1 = (figure_box.x1 - x0) / math.cos(math.radians(rotation))

h2 = (figure_box.y1 - y0) / math.cos(math.radians(90 - rotation))

return min(h1, h2)

def _get_rendered_text_width(self, text):

"""

Returns the width of a given text string, in pixels.

"""

w, h, d = self._renderer.get_text_width_height_descent(

text,

self.get_fontproperties(),

False)

return math.ceil(w)

def _get_wrapped_text(self):

"""

Return a copy of the text with new lines added, so that

the text is wrapped relative to the parent figure.

"""

# Not fit to handle breaking up latex syntax correctly, so

# ignore latex for now.

if self.get_usetex():

return self.get_text()

# Build the line incrementally, for a more accurate measure of length

line_width = self._get_wrap_line_width()

wrapped_str = ""

line = ""

for word in self.get_text().split(' '):

# New lines in the user's test need to force a split, so that it's

# not using the longest current line width in the line being built

sub_words = word.split('\n')

for i in range(len(sub_words)):

current_width = self._get_rendered_text_width(

line + ' ' + sub_words[i])

# Split long lines, and each newline found in the current word

if current_width > line_width or i > 0:

wrapped_str += line + '\n'

line = ""

if line == "":

line = sub_words[i]

else:

line += ' ' + sub_words[i]

return wrapped_str + line

@artist.allow_rasterization

def draw(self, renderer):

"""

Draws the :class:`Text` object to the given *renderer*.

"""

if renderer is not None:

self._renderer = renderer

if not self.get_visible():

return

if self.get_text() == '':

return

renderer.open_group('text', self.get_gid())

with _wrap_text(self) as textobj:

bbox, info, descent = textobj._get_layout(renderer)

trans = textobj.get_transform()

# don't use textobj.get_position here, which refers to text

# position in Text, and dash position in TextWithDash:

posx = float(textobj.convert_xunits(textobj._x))

posy = float(textobj.convert_yunits(textobj._y))

posx, posy = trans.transform_point((posx, posy))

if not np.isfinite(posx) or not np.isfinite(posy):

_log.warning("posx and posy should be finite values")

return

canvasw, canvash = renderer.get_canvas_width_height()

# draw the FancyBboxPatch

if textobj._bbox_patch:

textobj._draw_bbox(renderer, posx, posy)

gc = renderer.new_gc()

gc.set_foreground(textobj.get_color())

gc.set_alpha(textobj.get_alpha())

gc.set_url(textobj._url)

textobj._set_gc_clip(gc)

angle = textobj.get_rotation()

for line, wh, x, y in info:

mtext = textobj if len(info) == 1 else None

x = x + posx

y = y + posy

if renderer.flipy():

y = canvash - y

clean_line, ismath = textobj.is_math_text(line,

self.get_usetex())

if textobj.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

textrenderer = PathEffectRenderer(

textobj.get_path_effects(), renderer)

else:

textrenderer = renderer

if textobj.get_usetex():

textrenderer.draw_tex(gc, x, y, clean_line,

textobj._fontproperties, angle,

mtext=mtext)

else:

textrenderer.draw_text(gc, x, y, clean_line,

textobj._fontproperties, angle,

ismath=ismath, mtext=mtext)

gc.restore()

renderer.close_group('text')

self.stale = False

def get_color(self):

"Return the color of the text"

return self._color

def get_fontproperties(self):

"Return the :class:`~font_manager.FontProperties` object"

return self._fontproperties

def get_font_properties(self):

'alias for get_fontproperties'

return self.get_fontproperties()

def get_family(self):

"Return the list of font families used for font lookup"

return self._fontproperties.get_family()

def get_fontfamily(self):

'alias for get_family'

return self.get_family()

def get_name(self):

"Return the font name as string"

return self._fontproperties.get_name()

def get_style(self):

"Return the font style as string"

return self._fontproperties.get_style()

def get_size(self):

"Return the font size as integer"

return self._fontproperties.get_size_in_points()

def get_variant(self):

"Return the font variant as a string"

return self._fontproperties.get_variant()

def get_fontvariant(self):

'alias for get_variant'

return self.get_variant()

def get_weight(self):

"Get the font weight as string or number"

return self._fontproperties.get_weight()

def get_fontname(self):

'alias for get_name'

return self.get_name()

def get_fontstyle(self):

'alias for get_style'

return self.get_style()

def get_fontsize(self):

'alias for get_size'

return self.get_size()

def get_fontweight(self):

'alias for get_weight'

return self.get_weight()

def get_stretch(self):

'Get the font stretch as a string or number'

return self._fontproperties.get_stretch()

def get_fontstretch(self):

'alias for get_stretch'

return self.get_stretch()

def get_ha(self):

'alias for get_horizontalalignment'

return self.get_horizontalalignment()

def get_horizontalalignment(self):

"""

Return the horizontal alignment as string. Will be one of

'left', 'center' or 'right'.

"""

return self._horizontalalignment

def get_unitless_position(self):

"Return the unitless position of the text as a tuple (*x*, *y*)"

# This will get the position with all unit information stripped away.

# This is here for convenience since it is done in several locations.

x = float(self.convert_xunits(self._x))

y = float(self.convert_yunits(self._y))

return x, y

def get_position(self):

"Return the position of the text as a tuple (*x*, *y*)"

# This should return the same data (possible unitized) as was

# specified with 'set_x' and 'set_y'.

return self._x, self._y

def get_prop_tup(self, renderer=None):

"""

Return a hashable tuple of properties.

Not intended to be human readable, but useful for backends who

want to cache derived information about text (e.g., layouts) and

need to know if the text has changed.

"""

x, y = self.get_unitless_position()

renderer = renderer or self._renderer

return (x, y, self.get_text(), self._color,

self._verticalalignment, self._horizontalalignment,

hash(self._fontproperties),

self._rotation, self._rotation_mode,

self.figure.dpi, weakref.ref(renderer),

self._linespacing

)

def get_text(self):

"Get the text as string"

return self._text

def get_va(self):

'alias for :meth:`getverticalalignment`'

return self.get_verticalalignment()

def get_verticalalignment(self):

"""

Return the vertical alignment as string. Will be one of

'top', 'center', 'bottom' or 'baseline'.

"""

return self._verticalalignment

def get_window_extent(self, renderer=None, dpi=None):

'''

Return a :class:`~matplotlib.transforms.Bbox` object bounding

the text, in display units.

In addition to being used internally, this is useful for

specifying clickable regions in a png file on a web page.

*renderer* defaults to the _renderer attribute of the text

object. This is not assigned until the first execution of

:meth:`draw`, so you must use this kwarg if you want

to call :meth:`get_window_extent` prior to the first

:meth:`draw`. For getting web page regions, it is

simpler to call the method after saving the figure.

*dpi* defaults to self.figure.dpi; the renderer dpi is

irrelevant. For the web application, if figure.dpi is not

the value used when saving the figure, then the value that

was used must be specified as the *dpi* argument.

'''

#return _unit_box

if not self.get_visible():

return Bbox.unit()

if dpi is not None:

dpi_orig = self.figure.dpi

self.figure.dpi = dpi

if self.get_text() == '':

tx, ty = self._get_xy_display()

return Bbox.from_bounds(tx, ty, 0, 0)

if renderer is not None:

self._renderer = renderer

if self._renderer is None:

self._renderer = self.figure._cachedRenderer

if self._renderer is None:

raise RuntimeError('Cannot get window extent w/o renderer')

bbox, info, descent = self._get_layout(self._renderer)

x, y = self.get_unitless_position()

x, y = self.get_transform().transform_point((x, y))

bbox = bbox.translated(x, y)

if dpi is not None:

self.figure.dpi = dpi_orig

return bbox

def set_backgroundcolor(self, color):

"""

Set the background color of the text by updating the bbox.

.. seealso::

:meth:`set_bbox`

To change the position of the bounding box.

ACCEPTS: any matplotlib color

"""

if self._bbox_patch is None:

self.set_bbox(dict(facecolor=color, edgecolor=color))

else:

self._bbox_patch.update(dict(facecolor=color))

self._update_clip_properties()

self.stale = True

def set_color(self, color):

"""

Set the foreground color of the text

ACCEPTS: any matplotlib color

"""

# Make sure it is hashable, or get_prop_tup will fail.

try:

hash(color)

except TypeError:

color = tuple(color)

self._color = color

self.stale = True

def set_ha(self, align):

'alias for set_horizontalalignment'

self.set_horizontalalignment(align)

def set_horizontalalignment(self, align):

"""

Set the horizontal alignment to one of

ACCEPTS: [ 'center' | 'right' | 'left' ]

"""

legal = ('center', 'right', 'left')

if align not in legal:

raise ValueError('Horizontal alignment must be one of %s' %

str(legal))

self._horizontalalignment = align

self.stale = True

def set_ma(self, align):

'alias for set_multialignment'

self.set_multialignment(align)

def set_multialignment(self, align):

"""

Set the alignment for multiple lines layout. The layout of the

bounding box of all the lines is determined bu the horizontalalignment

and verticalalignment properties, but the multiline text within that

box can be

ACCEPTS: ['left' | 'right' | 'center' ]

"""

legal = ('center', 'right', 'left')

if align not in legal:

raise ValueError('Horizontal alignment must be one of %s' %

str(legal))

self._multialignment = align

self.stale = True