def __init__(self, ticksize=5., tick_out=False, **kwargs):
     self.set_ticksize(ticksize)
     self.set_tick_out(tick_out)
     self.clear()
     Line2D.__init__(self, [0.], [0.], **kwargs)
     self.set_color('black')
     self.set_visible_axes('all')

	def draw(self, renderer):
		x, y = self.get_data()

		if len(x) == 2 or len(y) == 2:
			xlim = self.axes.get_xlim()
			ylim = self.axes.get_ylim()

			x0, y0 = x[0], y[0]
			x1, y1 = x[1], y[1]

			if x0 == x1:	# vertical
				x, y = (x0, x0), ylim
			elif y0 == y1:	# horizontal
				x, y = xlim, (y0, y0)
			else:
				# coeff != 0
				coeff = float(y1 - y0) / (x1 - x0)

				minx = (ylim[0] - y0) / coeff + x0
				maxx = (ylim[1] - y0) / coeff + x0
				miny = coeff * (xlim[0] - x0) + y0
				maxy = coeff * (xlim[1] - x0) + y0

				if coeff > 0:
					x = max(minx, xlim[0]), min(maxx, xlim[1])
					y = max(miny, ylim[0]), min(maxy, ylim[1])
				else:
					x = max(maxx, xlim[0]), min(minx, xlim[1])
					y = min(miny, ylim[1]), max(maxy, ylim[0])


			self.set_data(x, y)

		Line2D.draw(self, renderer)

    def draw(self, renderer):
        """Draw the line and arrowhead using the passed renderer.
        """
        # if self._invalid:
        #     self.recache()
        renderer.open_group('arrowline2d')
        if not self._visible:
            return

        Line2D.draw(self, renderer)

        if self._arrow is not None:
            gc = renderer.new_gc()
            self._set_gc_clip(gc)
            gc.set_foreground(self._arrowedgecolor)
            gc.set_linewidth(self._arrowedgewidth)
            gc.set_alpha(self._alpha)
            funcname = self.arrows.get(self._arrow, '_draw_nothing')
        if funcname != '_draw_nothing':
            tpath, affine = self._transformed_path\
                                .get_transformed_points_and_affine()
            arrow_func = getattr(self, funcname)
            arrow_func(renderer, gc, tpath, affine.frozen())

        renderer.close_group('arrowline2d')

 def __init__(self, ticksize=None, tick_out=False, **kwargs):
     if ticksize is None:
         ticksize = rcParams["xtick.major.size"]
     self.set_ticksize(ticksize)
     self.set_tick_out(tick_out)
     # FIXME: tick_out is incompatible with Matplotlib tickdir option
     self.clear()
     line2d_kwargs = {"color": rcParams["xtick.color"], "linewidth": rcParams["xtick.major.width"]}
     line2d_kwargs.update(kwargs)
     Line2D.__init__(self, [0.0], [0.0], **line2d_kwargs)
     self.set_visible_axes("all")
     self._display_minor_ticks = False

    def __init__(self, *args, **kwargs):
        """Initialize the line and arrow.

        See the top-level class documentation.
        """
        self._arrow = kwargs.pop('arrow', '-')
        self._arrowsize = kwargs.pop('arrowsize', 2 * 4)
        self._arrowedgecolor = kwargs.pop('arrowedgecolor', 'b')
        self._arrowfacecolor = kwargs.pop('arrowfacecolor', 'b')
        self._arrowedgewidth = kwargs.pop('arrowedgewidth', 4)
        self._arrowheadwidth = kwargs.pop('arrowheadwidth', self._arrowsize)
        self._arrowheadlength = kwargs.pop('arrowheadlength', self._arrowsize)
        Line2D.__init__(self, *args, **kwargs)

 def __init__(self, ticksize=None, tick_out=None, **kwargs):
     if ticksize is None:
         ticksize = rcParams['xtick.major.size']
     self.set_ticksize(ticksize)
     self.set_minor_ticksize(rcParams['xtick.minor.size'])
     self.set_tick_out(rcParams['xtick.direction'] == 'out')
     self.clear()
     line2d_kwargs = {'color': rcParams['xtick.color'],
                      'linewidth': rcParams['xtick.major.width']}
     line2d_kwargs.update(kwargs)
     Line2D.__init__(self, [0.], [0.], **line2d_kwargs)
     self.set_visible_axes('all')
     self._display_minor_ticks = False

 def __init__(self, ticksize=None, tick_out=False, **kwargs):
     if ticksize is None:
         ticksize = rcParams['xtick.major.size']
     self.set_ticksize(ticksize)
     self.set_tick_out(tick_out)
     # FIXME: tick_out is incompatible with Matplotlib tickdir option
     self.clear()
     line2d_kwargs = {
         'color': rcParams['xtick.color'],
         'linewidth': rcParams['xtick.major.width']
     }
     line2d_kwargs.update(kwargs)
     Line2D.__init__(self, [0.], [0.], **line2d_kwargs)
     self.set_visible_axes('all')

 def __init__(self, ticksize=None, tick_out=None, **kwargs):
     if ticksize is None:
         ticksize = rcParams['xtick.major.size']
     self.set_ticksize(ticksize)
     self.set_tick_out(rcParams.get('xtick.direction', 'in') == 'out')
     self.clear()
     line2d_kwargs = {'color': rcParams['xtick.color'],
                      # For the linewidth we need to set a default since old versions of
                      # matplotlib don't have this.
                      'linewidth': rcParams.get('xtick.major.width', 1)}
     line2d_kwargs.update(kwargs)
     Line2D.__init__(self, [0.], [0.], **line2d_kwargs)
     self.set_visible_axes('all')
     self._display_minor_ticks = False

 def __init__(self, ticksize=None, tick_out=None, **kwargs):
     if ticksize is None:
         ticksize = rcParams["xtick.major.size"]
     self.set_ticksize(ticksize)
     self.set_tick_out(rcParams.get("xtick.direction", "in") == "out")
     self.clear()
     line2d_kwargs = {
         "color": rcParams["xtick.color"],
         # For the linewidth we need to set a default since old versions of
         # matplotlib don't have this.
         "linewidth": rcParams.get("xtick.major.width", 1),
     }
     line2d_kwargs.update(kwargs)
     Line2D.__init__(self, [0.0], [0.0], **line2d_kwargs)
     self.set_visible_axes("all")
     self._display_minor_ticks = False

 def __init__(self, xfield = None, yfield = None, canvas = None, *args, **kwargs):
     self.canvas = canvas
     self.original_xfield = xfield
     self.original_yfield = yfield
     self.current_xfield = xfield
     self.current_yfield = yfield
     self.press = None
     self.draggable = False
     self.color = "b"
     self.marker = "None"
     self.xscale = 1.0
     self.yscale = 1.0
     self.xoffset = 0
     self.yoffset = 0
     Line2D.__init__(self, 
                     self.current_xfield.to_list(), 
                     self.current_yfield.to_list(),
                     *args,**kwargs)

 def __init__(self, path, *args, **kwargs):
     Line2D.__init__(self, [], [], *args, **kwargs)
     self._path = path
     self._invalid = False

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

 def __init__(self, **attrs):
     styles = {'color': '0.5', 'linestyle': '-', 'linewidth': 1}
     styles.update(attrs)
     Line2D.__init__(self, [], [], **styles)

 def set_data(self, *args, **kwargs):
     Line2D.set_data(self, *args, **kwargs)
     if self._invalid:
         self.recache()
     self.xorig = np.array(self._x)
     self.yorig = np.array(self._y)

 def __init__(self, ax, *args, **kwargs):
     Line2D.__init__(self, *args, **kwargs)
     self.ax = ax

 def __init__(self, path, *kl, **kw):
     Line2D.__init__(self, [], [], *kl, **kw)
     self._path = path
     self._invalid = False

 def set_data(self, *args, **kwargs):
     Line2D.set_data(self, *args, **kwargs)
     self.xorig = npy.array(self._x)
     self.yorig = npy.array(self._y)

        
=======
    def __init__(self, ticksize=None, tick_out=False, **kwargs):
        if ticksize is None:
            ticksize = rcParams['xtick.major.size']
>>>>>>> upstream/master
        self.set_ticksize(ticksize)
        self.set_tick_out(tick_out)
        # FIXME: tick_out is incompatible with Matplotlib tickdir option
        self.clear()
        line2d_kwargs = {
            'color': rcParams['xtick.color'],
            'linewidth': rcParams['xtick.major.width']
        }
        line2d_kwargs.update(kwargs)
        Line2D.__init__(self, [0.], [0.], **line2d_kwargs)
        self.set_visible_axes('all')

    def set_tick_out(self, tick_out):
        
        """
        set True if tick need to be rotated by 180 degree.
        """
        self._tick_out = tick_out

    def get_tick_out(self):
        
        """
        Return True if the tick will be rotated by 180 degree.
        """
        return self._tick_out

 def set_color(self, color):
     self.color = color
     ret = Line2D.set_color(self, color)
     if self.canvas: self.canvas.draw()
     return ret

 def set_marker(self, marker):
     self.marker = marker
     ret = Line2D.set_marker(self, marker)
     if self.canvas: self.canvas.draw()
     return ret