"""

w_list, d_list = zip(*wd_list) # d_list is currently not used.

cbook._check_in_list(["fixed", "expand", "equal"], mode=mode)

if mode == "fixed":

offsets_ = np.cumsum([0] + [w + sep for w in w_list])

offsets = offsets_[:-1]

if total is None:

total = offsets_[-1] - sep

return total, offsets

elif mode == "expand":

# This is a bit of a hack to avoid a TypeError when *total*

# is None and used in conjugation with tight layout.

if total is None:

total = 1

if len(w_list) > 1:

sep = (total - sum(w_list)) / (len(w_list) - 1)

else:

sep = 0

offsets_ = np.cumsum([0] + [w + sep for w in w_list])

offsets = offsets_[:-1]

return total, offsets

elif mode == "equal":

maxh = max(w_list)

if total is None:

if sep is None:

raise ValueError("total and sep cannot both be None when "

"using layout mode 'equal'")

total = (maxh + sep) * len(w_list)

else:

sep = total / len(w_list) - maxh

offsets = (maxh + sep) * np.arange(len(w_list))

"""

if height is None:

height = max(h for h, d in hd_list)

cbook._check_in_list(

["baseline", "left", "top", "right", "bottom", "center"], align=align)

if align == "baseline":

height_descent = max(h - d for h, d in hd_list)

descent = max(d for h, d in hd_list)

height = height_descent + descent

offsets = [0. for h, d in hd_list]

elif align in ["left", "top"]:

descent = 0.

offsets = [d for h, d in hd_list]

elif align in ["right", "bottom"]:

descent = 0.

offsets = [height - h + d for h, d in hd_list]

elif align == "center":

descent = 0.

offsets = [(height - h) * .5 + d for h, d in hd_list]

"""

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

# Clipping has not been implemented in the OffesetBox family, so

# disable the clip flag for consistency. It can always be turned back

# on to zero effect.

self.set_clip_on(False)

self._children = []

self._offset = (0, 0)

def set_figure(self, fig):

"""

martist.Artist.set_figure(self, fig)

for c in self.get_children():

c.set_figure(fig)

@martist.Artist.axes.setter

def axes(self, ax):

# TODO deal with this better

martist.Artist.axes.fset(self, ax)

for c in self.get_children():

if c is not None:

c.axes = ax

def contains(self, mouseevent):

"""

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

for c in self.get_children():

a, b = c.contains(mouseevent)

if a:

return a, b

return False, {}

def set_offset(self, xy):

"""

self._offset = xy

self.stale = True

def get_offset(self, width, height, xdescent, ydescent, renderer):

"""

return (self._offset(width, height, xdescent, ydescent, renderer)

if callable(self._offset)

else self._offset)

def set_width(self, width):

"""

self.width = width

self.stale = True

def set_height(self, height):

"""

self.height = height

self.stale = True

def get_visible_children(self):

r"""Return a list of the visible child `.Artist`\s."""

return [c for c in self._children if c.get_visible()]

def get_children(self):

r"""Return a list of the child `.Artist`\s."""

return self._children

def get_extent_offsets(self, renderer):

"""

raise NotImplementedError(

"get_extent_offsets must be overridden in derived classes.")

def get_extent(self, renderer):

"""Return a tuple ``width, height, xdescent, ydescent`` of the box."""

w, h, xd, yd, offsets = self.get_extent_offsets(renderer)

return w, h, xd, yd

def get_window_extent(self, renderer):

"""Return the bounding box (`.Bbox`) in display space."""

w, h, xd, yd, offsets = self.get_extent_offsets(renderer)

px, py = self.get_offset(w, h, xd, yd, renderer)

return mtransforms.Bbox.from_bounds(px - xd, py - yd, w, h)

def draw(self, renderer):

"""

width, height, xdescent, ydescent, offsets = self.get_extent_offsets(

renderer)

px, py = self.get_offset(width, height, xdescent, ydescent, renderer)

for c, (ox, oy) in zip(self.get_visible_children(), offsets):

c.set_offset((px + ox, py + oy))

c.draw(renderer)

bbox_artist(self, renderer, fill=False, props=dict(pad=0.))

def __init__(self, pad=None, sep=None, width=None, height=None,

align=None, mode=None,

children=None):

"""

super().__init__()

self.height = height

self.width = width

self.sep = sep

self.pad = pad

self.mode = mode

self.align = align

"""

def __init__(self, pad=None, sep=None, width=None, height=None,

align="baseline", mode="fixed",

children=None):

"""

super().__init__(pad, sep, width, height, align, mode, children)

def get_extent_offsets(self, renderer):

# docstring inherited

dpicor = renderer.points_to_pixels(1.)

pad = self.pad * dpicor

sep = self.sep * dpicor

if self.width is not None:

for c in self.get_visible_children():

if isinstance(c, PackerBase) and c.mode == "expand":

c.set_width(self.width)

whd_list = [c.get_extent(renderer)

for c in self.get_visible_children()]

whd_list = [(w, h, xd, (h - yd)) for w, h, xd, yd in whd_list]

wd_list = [(w, xd) for w, h, xd, yd in whd_list]

width, xdescent, xoffsets = _get_aligned_offsets(wd_list,

self.width,

self.align)

pack_list = [(h, yd) for w, h, xd, yd in whd_list]

height, yoffsets_ = _get_packed_offsets(pack_list, self.height,

sep, self.mode)

yoffsets = yoffsets_ + [yd for w, h, xd, yd in whd_list]

ydescent = height - yoffsets[0]

yoffsets = height - yoffsets

yoffsets = yoffsets - ydescent

return (width + 2 * pad, height + 2 * pad,

xdescent + pad, ydescent + pad,

"""

def __init__(self, pad=None, sep=None, width=None, height=None,

align="baseline", mode="fixed",

children=None):

"""

super().__init__(pad, sep, width, height, align, mode, children)

def get_extent_offsets(self, renderer):

# docstring inherited

dpicor = renderer.points_to_pixels(1.)

pad = self.pad * dpicor

sep = self.sep * dpicor

whd_list = [c.get_extent(renderer)

for c in self.get_visible_children()]

if not whd_list:

return 2 * pad, 2 * pad, pad, pad, []

if self.height is None:

height_descent = max(h - yd for w, h, xd, yd in whd_list)

ydescent = max(yd for w, h, xd, yd in whd_list)

height = height_descent + ydescent

else:

height = self.height - 2 * pad # width w/o pad

hd_list = [(h, yd) for w, h, xd, yd in whd_list]

height, ydescent, yoffsets = _get_aligned_offsets(hd_list,

self.height,

self.align)

pack_list = [(w, xd) for w, h, xd, yd in whd_list]

width, xoffsets_ = _get_packed_offsets(pack_list, self.width,

sep, self.mode)

xoffsets = xoffsets_ + [xd for w, h, xd, yd in whd_list]

xdescent = whd_list[0][2]

xoffsets = xoffsets - xdescent

return (width + 2 * pad, height + 2 * pad,

xdescent + pad, ydescent + pad,

"""

def __init__(self, child, pad=None, draw_frame=False, patch_attrs=None):

"""

super().__init__()

self.pad = pad

self._children = [child]

self.patch = FancyBboxPatch(

xy=(0.0, 0.0), width=1., height=1.,

facecolor='w', edgecolor='k',

mutation_scale=1, # self.prop.get_size_in_points(),

snap=True,

visible=draw_frame,

boxstyle="square,pad=0",

)

if patch_attrs is not None:

self.patch.update(patch_attrs)

def get_extent_offsets(self, renderer):

# docstring inherited.

dpicor = renderer.points_to_pixels(1.)

pad = self.pad * dpicor

w, h, xd, yd = self._children[0].get_extent(renderer)

return (w + 2 * pad, h + 2 * pad, xd + pad, yd + pad,

[(0, 0)])

def draw(self, renderer):

# docstring inherited

width, height, xdescent, ydescent, offsets = self.get_extent_offsets(

renderer)

px, py = self.get_offset(width, height, xdescent, ydescent, renderer)

for c, (ox, oy) in zip(self.get_visible_children(), offsets):

c.set_offset((px + ox, py + oy))

self.draw_frame(renderer)

for c in self.get_visible_children():

c.draw(renderer)

#bbox_artist(self, renderer, fill=False, props=dict(pad=0.))

self.stale = False

def update_frame(self, bbox, fontsize=None):

self.patch.set_bounds(bbox.x0, bbox.y0, bbox.width, bbox.height)

if fontsize:

self.patch.set_mutation_scale(fontsize)

self.stale = True

def draw_frame(self, renderer):

# update the location and size of the legend

self.update_frame(self.get_window_extent(renderer))

"""

def __init__(self, width, height, xdescent=0.,

ydescent=0., clip=False):

"""

super().__init__()

self.width = width

self.height = height

self.xdescent = xdescent

self.ydescent = ydescent

self._clip_children = clip

self.offset_transform = mtransforms.Affine2D()

self.dpi_transform = mtransforms.Affine2D()

@property

def clip_children(self):

"""

return self._clip_children

@clip_children.setter

def clip_children(self, val):

self._clip_children = bool(val)

self.stale = True

def get_transform(self):

"""

return self.dpi_transform + self.offset_transform

def set_transform(self, t):

"""

def set_offset(self, xy):

"""

self._offset = xy

self.offset_transform.clear()

self.offset_transform.translate(xy[0], xy[1])

self.stale = True

def get_offset(self):

"""Return offset of the container."""

return self._offset

def get_window_extent(self, renderer):

"""Return the bounding box in display space."""

w, h, xd, yd = self.get_extent(renderer)

ox, oy = self.get_offset() # w, h, xd, yd)

return mtransforms.Bbox.from_bounds(ox - xd, oy - yd, w, h)

def get_extent(self, renderer):

"""Return width, height, xdescent, ydescent of box."""

dpi_cor = renderer.points_to_pixels(1.)

return (self.width * dpi_cor, self.height * dpi_cor,

self.xdescent * dpi_cor, self.ydescent * dpi_cor)

def add_artist(self, a):

"""Add an `.Artist` to the container box."""

self._children.append(a)

if not a.is_transform_set():

a.set_transform(self.get_transform())

if self.axes is not None:

a.axes = self.axes

fig = self.figure

if fig is not None:

a.set_figure(fig)

def draw(self, renderer):

# docstring inherited

dpi_cor = renderer.points_to_pixels(1.)

self.dpi_transform.clear()

self.dpi_transform.scale(dpi_cor)

# At this point the DrawingArea has a transform

# to the display space so the path created is

# good for clipping children

tpath = mtransforms.TransformedPath(

mpath.Path([[0, 0], [0, self.height],

[self.width, self.height],

[self.width, 0]]),

self.get_transform())

for c in self._children:

if self._clip_children and not (c.clipbox or c._clippath):

c.set_clip_path(tpath)

c.draw(renderer)

bbox_artist(self, renderer, fill=False, props=dict(pad=0.))

"""

def __init__(self, s,

textprops=None,

multilinebaseline=None,

minimumdescent=True,

):

"""

if textprops is None:

textprops = {}

textprops.setdefault("va", "baseline")

self._text = mtext.Text(0, 0, s, **textprops)

OffsetBox.__init__(self)

self._children = [self._text]

self.offset_transform = mtransforms.Affine2D()

self._baseline_transform = mtransforms.Affine2D()

self._text.set_transform(self.offset_transform +

self._baseline_transform)

self._multilinebaseline = multilinebaseline

self._minimumdescent = minimumdescent

def set_text(self, s):

"""Set the text of this area as a string."""

self._text.set_text(s)

self.stale = True

def get_text(self):

"""Return the string representation of this area's text."""

return self._text.get_text()

def set_multilinebaseline(self, t):

"""

self._multilinebaseline = t

self.stale = True

def get_multilinebaseline(self):

"""

return self._multilinebaseline

def set_minimumdescent(self, t):

"""

self._minimumdescent = t

self.stale = True

def get_minimumdescent(self):

"""

return self._minimumdescent

def set_transform(self, t):

"""

def set_offset(self, xy):

"""

self._offset = xy

self.offset_transform.clear()

self.offset_transform.translate(xy[0], xy[1])

self.stale = True

def get_offset(self):

"""Return offset of the container."""

return self._offset

def get_window_extent(self, renderer):

"""Return the bounding box in display space."""

w, h, xd, yd = self.get_extent(renderer)

ox, oy = self.get_offset() # w, h, xd, yd)

return mtransforms.Bbox.from_bounds(ox - xd, oy - yd, w, h)

def get_extent(self, renderer):

_, h_, d_ = renderer.get_text_width_height_descent(

"lp", self._text._fontproperties, ismath=False)

bbox, info, d = self._text._get_layout(renderer)

w, h = bbox.width, bbox.height

self._baseline_transform.clear()

if len(info) > 1 and self._multilinebaseline:

d_new = 0.5 * h - 0.5 * (h_ - d_)

self._baseline_transform.translate(0, d - d_new)

d = d_new

else: # single line

h_d = max(h_ - d_, h - d)

if self.get_minimumdescent():

## to have a minimum descent, #i.e., "l" and "p" have same

## descents.

d = max(d, d_)

#else:

# d = d

h = h_d + d

return w, h, 0., d

def draw(self, renderer):

# docstring inherited

self._text.draw(renderer)

bbox_artist(self, renderer, fill=False, props=dict(pad=0.))

"""

def __init__(self, aux_transform):

self.aux_transform = aux_transform

OffsetBox.__init__(self)

self.offset_transform = mtransforms.Affine2D()

# ref_offset_transform makes offset_transform always relative to the

# lower-left corner of the bbox of its children.

self.ref_offset_transform = mtransforms.Affine2D()

def add_artist(self, a):

"""Add an `.Artist` to the container box."""

self._children.append(a)

a.set_transform(self.get_transform())

self.stale = True

def get_transform(self):

"""

return (self.aux_transform

+ self.ref_offset_transform

+ self.offset_transform)

def set_transform(self, t):

"""

def set_offset(self, xy):

"""

self._offset = xy

self.offset_transform.clear()

self.offset_transform.translate(xy[0], xy[1])

self.stale = True

def get_offset(self):

"""Return offset of the container."""

return self._offset

def get_window_extent(self, renderer):

"""Return the bounding box in display space."""

w, h, xd, yd = self.get_extent(renderer)

ox, oy = self.get_offset() # w, h, xd, yd)

return mtransforms.Bbox.from_bounds(ox - xd, oy - yd, w, h)

def get_extent(self, renderer):

# clear the offset transforms

_off = self.offset_transform.get_matrix() # to be restored later

self.ref_offset_transform.clear()

self.offset_transform.clear()

# calculate the extent

bboxes = [c.get_window_extent(renderer) for c in self._children]

ub = mtransforms.Bbox.union(bboxes)

# adjust ref_offset_transform

self.ref_offset_transform.translate(-ub.x0, -ub.y0)

# restor offset transform

self.offset_transform.set_matrix(_off)

return ub.width, ub.height, 0., 0.

def draw(self, renderer):

# docstring inherited

for c in self._children:

c.draw(renderer)

bbox_artist(self, renderer, fill=False, props=dict(pad=0.))