code: """
  ===========
  Path Editor
  ===========
  
  Sharing events across GUIs.
  
  This example demonstrates a cross-GUI application using Matplotlib event
  handling to interact with and modify objects on the canvas.
  """
  import numpy as np
  import matplotlib.path as mpath
  import matplotlib.patches as mpatches
  import matplotlib.pyplot as plt
  
  Path = mpath.Path
  
  fig, ax = plt.subplots()
  
  pathdata = [
      (Path.MOVETO, (1.58, -2.57)),
      (Path.CURVE4, (0.35, -1.1)),
      (Path.CURVE4, (-1.75, 2.0)),
      (Path.CURVE4, (0.375, 2.0)),
      (Path.LINETO, (0.85, 1.15)),
      (Path.CURVE4, (2.2, 3.2)),
      (Path.CURVE4, (3, 0.05)),
      (Path.CURVE4, (2.0, -0.5)),
      (Path.CLOSEPOLY, (1.58, -2.57)),
      ]
  
  codes, verts = zip(*pathdata)
  path = mpath.Path(verts, codes)
  patch = mpatches.PathPatch(path, facecolor='green', edgecolor='yellow', alpha=0.5)
  ax.add_patch(patch)
  
  
  class PathInteractor:
      """
      An path editor.
  
      Key-bindings
  
        't' toggle vertex markers on and off.  When vertex markers are on,
            you can move them, delete them
  
  
      """
  
      showverts = True
      epsilon = 5  # max pixel distance to count as a vertex hit
  
      def __init__(self, pathpatch):
  
          self.ax = pathpatch.axes
          canvas = self.ax.figure.canvas
          self.pathpatch = pathpatch
          self.pathpatch.set_animated(True)
  
          x, y = zip(*self.pathpatch.get_path().vertices)
  
          self.line, = ax.plot(x, y, marker='o', markerfacecolor='r', animated=True)
  
          self._ind = None  # the active vert
  
          canvas.mpl_connect('draw_event', self.draw_callback)
          canvas.mpl_connect('button_press_event', self.button_press_callback)
          canvas.mpl_connect('key_press_event', self.key_press_callback)
          canvas.mpl_connect('button_release_event', self.button_release_callback)
          canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
          self.canvas = canvas
  
      def draw_callback(self, event):
          self.background = self.canvas.copy_from_bbox(self.ax.bbox)
          self.ax.draw_artist(self.pathpatch)
          self.ax.draw_artist(self.line)
          self.canvas.blit(self.ax.bbox)
  
      def pathpatch_changed(self, pathpatch):
          """This method is called whenever the pathpatch object is called."""
          # only copy the artist props to the line (except visibility)
          vis = self.line.get_visible()
          plt.Artist.update_from(self.line, pathpatch)
          self.line.set_visible(vis)  # don't use the pathpatch visibility state
  
      def get_ind_under_point(self, event):
          """
          Return the index of the point closest to the event position or *None*
          if no point is within ``self.epsilon`` to the event position.
          """
          # display coords
          xy = np.asarray(self.pathpatch.get_path().vertices)
          xyt = self.pathpatch.get_transform().transform(xy)
          xt, yt = xyt[:, 0], xyt[:, 1]
          d = np.sqrt((xt - event.x)**2 + (yt - event.y)**2)
          ind = d.argmin()
  
          if d[ind] >= self.epsilon:
              ind = None
  
          return ind
  
      def button_press_callback(self, event):
          """Callback for mouse button presses."""
          if not self.showverts:
              return
          if event.inaxes is None:
              return
          if event.button != 1:
              return
          self._ind = self.get_ind_under_point(event)
  
      def button_release_callback(self, event):
          """Callback for mouse button releases."""
          if not self.showverts:
              return
          if event.button != 1:
              return
          self._ind = None
  
      def key_press_callback(self, event):
          """Callback for key presses."""
          if not event.inaxes:
              return
          if event.key == 't':
              self.showverts = not self.showverts
              self.line.set_visible(self.showverts)
              if not self.showverts:
                  self._ind = None
  
          self.canvas.draw()
  
      def motion_notify_callback(self, event):
          """Callback for mouse movements."""
          if not self.showverts:
              return
          if self._ind is None:
              return
          if event.inaxes is None:
              return
          if event.button != 1:
              return
          x, y = event.xdata, event.ydata
  
          vertices = self.pathpatch.get_path().vertices
  
          vertices[self._ind] = x, y
          self.line.set_data(zip(*vertices))
  
          self.canvas.restore_region(self.background)
          self.ax.draw_artist(self.pathpatch)
          self.ax.draw_artist(self.line)
          self.canvas.blit(self.ax.bbox)
  
  
  interactor = PathInteractor(patch)
  ax.set_title('drag vertices to update path')
  ax.set_xlim(-3, 4)
  ax.set_ylim(-3, 4)
  
  plt.show()
   """
  =================
  Fancytextbox Demo
  =================
  
  """
  import matplotlib.pyplot as plt
  
  plt.text(0.6, 0.7, "eggs", size=50, rotation=30.,
           ha="center", va="center",
           bbox=dict(boxstyle="round",
                     ec=(1., 0.5, 0.5),
                     fc=(1., 0.8, 0.8),
                     )
           )
  
  plt.text(0.55, 0.6, "spam", size=50, rotation=-25.,
           ha="right", va="top",
           bbox=dict(boxstyle="square",
                     ec=(1., 0.5, 0.5),
                     fc=(1., 0.8, 0.8),
                     )
           )
  
  plt.show()
  
apis: matplotlib.pyplot.subplots matplotlib.pyplot.show matplotlib.path.Path matplotlib.patches.PathPatch numpy.sqrt matplotlib.pyplot.Artist.update_from
apis: matplotlib.pyplot.show