from __future__ import division
import pygtk
pygtk.require('2.0')
import gtk
from Numeric import array, arange, sin, cos, pi
from colors import ColorDispatcher
from cbook import is_string_like
from artist import Artist


class Patch(Artist):
    """
    A patch is a 2D thingy with a face color and an edge color
    """
    
    def __init__(self,
                 edgeColor=ColorDispatcher().get('k'),
                 faceColor=ColorDispatcher().get('b'),
                 fill=1,
                 ):

        Artist.__init__(self)
        self._edgecolor = edgeColor
        self._facecolor = faceColor
        self.fill = fill
        self._linewidth=1


    def get_data_extent(self):
        """
        Return the bounding box as left, bottom, width, height in
        data coords
        """
        raise NotImplementedError, "Derived must override"

    def set_edgecolor(self, color):
        if is_string_like(color):
            color = ColorDispatcher().get(color)

        self._edgecolor = color

    def set_facecolor(self, color):
        if is_string_like(color):
            color = ColorDispatcher().get(color)
        self._facecolor = color

    def set_linewidth(self, w):
        self._linewidth = w

    def set_fill(self, b):
        self.fill = b

    def _draw(self, drawable, *args, **kwargs):
        gcFace = drawable.new_gc()
        gcFace.foreground = self._facecolor
        gcFace.line_width = self._linewidth
        self.clip_gc(gcFace)
        gcEdge = drawable.new_gc()
        gcEdge.foreground = self._edgecolor
        gcEdge.line_width = self._linewidth
        self.clip_gc(gcEdge)
        self._derived_draw(drawable, gcFace, gcEdge)

    def _derived_draw(self, drawable, gcFace, gcEdge):
        raise NotImplementedError, 'Derived must override'

class Rectangle(Patch):
    """
    Draw a rectangle with lower left at xy=(x,y) with specified
    width and height
    """

    def __init__(self, xy, width, height, *args, **kargs):
        Patch.__init__(self, *args, **kargs)

        self.xy  = xy
        self.width, self.height = width, height
        
    def _derived_draw(self, drawable, gcFace, gcEdge):
        # x,y for the Rectangle specifies the lower left, but for
        # draw_rectange it is the upper left.  So add height to
        # get upper left
        l, t  = self.transform_points_to_win(self.xy[0],
                                             self.xy[1]+self.height)
        w, h = self.transform_scale_to_win(self.width, self.height)

        if self.fill:
            drawable.draw_rectangle(gcFace, filled=1,
                                    x=l, y=t, width=w, height=h)
        drawable.draw_rectangle(gcEdge, filled=0,
                                x=l, y=t, width=w, height=h)

    def get_data_extent(self):
        """
        Return the bounding box as left, bottom, width, height in
        window coords
        """
        x, y  = self.xy[0], self.xy[1]
        w, h = self.width, self.height
        return x, y, w, h


class RegularPolygon(Patch):
    """
    A regular polygon patch.  xy is a length 2 tuple (the center)
    numVertices is the number of vertices.  Radius is the distance
    from the center to each of the vertices.  Orientation is in
    radians and rotates the polygon.
    """
    def __init__(self, xy, numVertices, radius=5, orientation=0,
                 *args, **kargs):

        Patch.__init__(self, *args, **kargs)
        self.xy = xy
        self.numVertices = numVertices
        self.radius = radius
        self.orientation = orientation
        self._compute_vertices()

    def _compute_vertices(self):

        theta = 2*pi/self.numVertices*arange(self.numVertices) + \
                self.orientation

        self.xs = self.xy[0] + self.radius*cos(theta)
        self.ys = self.xy[1] + self.radius*sin(theta)

        

    def _derived_draw(self, drawable, gcFace, gcEdge):

        xs, ys = self.transform_points_to_win(self.xs, self.ys)
        vertices = zip(xs, ys)
        if self.fill:
            drawable.draw_polygon(gcFace, filled=1,
                                  points=vertices)
        drawable.draw_polygon(gcFace, filled=0,
                              points=vertices)


    def get_data_extent(self):
        """
        Return the bounding box as left, bottom, width, height in
        data coords
        """
        xs, ys = self.xs, self.ys
        xmin, xmax = min(xs), max(xs)
        ymin, ymax = min(xy), max(ys)
        w = maxx - minx
        h = maxy - miny
        return xmin, ymax, w, h




class Circle(Patch):
    def __init__(self, xy, radius=5,
                 *args, **kargs):

        Patch.__init__(self, *args, **kargs)
        self.xy = xy
        self.radius = radius

    def _derived_draw(self, drawable, gcFace, gcEdge):
        
        x, y = self.transform_points_to_win(self.xy[0], self.xy[1])
        w, h = self.transform_scale_to_win(self.radius, self.radius)
        
        if self.fill:
            drawable.draw_arc(gcFace, 1, x-w/2, y-h/2, w, h, 0, 360*64)

        drawable.draw_arc(gcEdge, 0, x-w/2, y-h/2, w, h, 0, 360*64)
        

    def get_data_extent(self):
        """
        Return the bounding box as left, bottom, width, height in
        data coords
        """
        
        x, y = self.xy[0], self.xy[1]
        w, h = self.radius, self.radius
        return x-w, y+w, w, h