#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/graphics/charts/lineplots.py

__version__='3.3.0'

__doc__="""This module defines a very preliminary Line Plot example."""

import string, time

from reportlab.lib import colors

from reportlab.lib.validators import *

from reportlab.lib.attrmap import *

from reportlab.graphics.shapes import Drawing, Group, Rect, Line, PolyLine, Polygon, _SetKeyWordArgs

from reportlab.graphics.widgetbase import Widget, TypedPropertyCollection, PropHolder

from reportlab.graphics.charts.textlabels import Label

from reportlab.graphics.charts.axes import XValueAxis, YValueAxis, AdjYValueAxis, NormalDateXValueAxis

from reportlab.graphics.charts.utils import *

from reportlab.graphics.widgets.markers import uSymbol2Symbol, isSymbol, makeMarker

from reportlab.graphics.widgets.grids import Grid, DoubleGrid, ShadedRect, ShadedPolygon

from reportlab.pdfbase.pdfmetrics import stringWidth, getFont

from reportlab.graphics.charts.areas import PlotArea

# This might be moved again from here...

class LinePlotProperties(PropHolder):

    _attrMap = AttrMap(

        strokeWidth = AttrMapValue(isNumber, desc='Width of a line.'),

        strokeColor = AttrMapValue(isColorOrNone, desc='Color of a line.'),

        strokeDashArray = AttrMapValue(isListOfNumbersOrNone, desc='Dash array of a line.'),

        symbol = AttrMapValue(None, desc='Widget placed at data points.',advancedUsage=1),

        shader = AttrMapValue(None, desc='Shader Class.',advancedUsage=1),

        filler = AttrMapValue(None, desc='Filler Class.',advancedUsage=1),

        name = AttrMapValue(isStringOrNone, desc='Name of the line.'),

        inFill = AttrMapValue(isBoolean, desc='If true flood fill to x axis',advancedUsage=1),

        )

class InFillValue(int):

    def __new__(cls,v,yValue=None):

        self = int.__new__(cls,v)

        self.yValue = yValue

        return self

class Shader(_SetKeyWordArgs):

    _attrMap = AttrMap(BASE=PlotArea,

        vertical = AttrMapValue(isBoolean, desc='If true shade to x axis'),

        colors = AttrMapValue(SequenceOf(isColorOrNone,lo=2,hi=2), desc='(AxisColor, LineColor)'),

        )

    def shade(self, lp, g, rowNo, rowColor, row):

        c = [None,None]

        c = getattr(self,'colors',c) or c

        if not c[0]: c[0] = getattr(lp,'fillColor',colors.white)

        if not c[1]: c[1] = rowColor

class NoFiller:

    def fill(self, lp, g, rowNo, rowColor, points):

        pass

class Filler:

    '''mixin providing simple polygon fill'''

    _attrMap = AttrMap(

        fillColor = AttrMapValue(isColorOrNone, desc='filler interior color'),

        strokeColor = AttrMapValue(isColorOrNone, desc='filler edge color'),

        strokeWidth = AttrMapValue(isNumberOrNone, desc='filler edge width'),

        )

    def __init__(self,**kw):

        self.__dict__ = kw

    def fill(self, lp, g, rowNo, rowColor, points):

        g.add(Polygon(points,

            fillColor=getattr(self,'fillColor',rowColor),

            strokeColor=getattr(self,'strokeColor',rowColor),

            strokeWidth=getattr(self,'strokeWidth',0.1)))

class ShadedPolyFiller(Filler,ShadedPolygon):

    pass

class PolyFiller(Filler,Polygon):

    pass

from reportlab.graphics.charts.linecharts import AbstractLineChart

class LinePlot(AbstractLineChart):

    """Line plot with multiple lines.

    Both x- and y-axis are value axis (so there are no seperate

    X and Y versions of this class).

    """

    _attrMap = AttrMap(BASE=PlotArea,

        reversePlotOrder = AttrMapValue(isBoolean, desc='If true reverse plot order.',advancedUsage=1),

        lineLabelNudge = AttrMapValue(isNumber, desc='Distance between a data point and its label.',advancedUsage=1),

        lineLabels = AttrMapValue(None, desc='Handle to the list of data point labels.'),

        lineLabelFormat = AttrMapValue(None, desc='Formatting string or function used for data point labels.'),

        lineLabelArray = AttrMapValue(None, desc='explicit array of line label values, must match size of data if present.'),

        joinedLines = AttrMapValue(isNumber, desc='Display data points joined with lines if true.'),

        strokeColor = AttrMapValue(isColorOrNone, desc='Color used for background border of plot area.'),

        fillColor = AttrMapValue(isColorOrNone, desc='Color used for background interior of plot area.'),

        lines = AttrMapValue(None, desc='Handle of the lines.'),

        xValueAxis = AttrMapValue(None, desc='Handle of the x axis.'),

        yValueAxis = AttrMapValue(None, desc='Handle of the y axis.'),

        data = AttrMapValue(None, desc='Data to be plotted, list of (lists of) x/y tuples.'),

        annotations = AttrMapValue(None, desc='list of callables, will be called with self, xscale, yscale.',advancedUsage=1),

        behindAxes = AttrMapValue(isBoolean, desc='If true use separate line group.',advancedUsage=1),

        gridFirst = AttrMapValue(isBoolean, desc='If true use draw grids before axes.',advancedUsage=1),

        )

    def __init__(self):

        PlotArea.__init__(self)

        self.reversePlotOrder = 0

        self.xValueAxis = XValueAxis()

        self.yValueAxis = YValueAxis()

        # this defines two series of 3 points.  Just an example.

        self.data = [

            ((1,1), (2,2), (2.5,1), (3,3), (4,5)),

            ((1,2), (2,3), (2.5,2), (3,4), (4,6))

            ]

        self.lines = TypedPropertyCollection(LinePlotProperties)

        self.lines.strokeWidth = 1

        self.lines[0].strokeColor = colors.red

        self.lines[1].strokeColor = colors.blue

        self.lineLabels = TypedPropertyCollection(Label)

        self.lineLabelFormat = None

        self.lineLabelArray = None

        # this says whether the origin is inside or outside

        # the bar - +10 means put the origin ten points

        # above the tip of the bar if value > 0, or ten

        # points inside if bar value < 0.  This is different

        # to label dx/dy which are not dependent on the

        # sign of the data.

        self.lineLabelNudge = 10

        # if you have multiple series, by default they butt

        # together.

        # New line chart attributes.

        self.joinedLines = 1 # Connect items with straight lines.

        #private attributes

        self._inFill = None

        self.annotations = []

        self.behindAxes = 0

        self.gridFirst = 0

    def demo(self):

        """Shows basic use of a line chart."""

        drawing = Drawing(400, 200)

        data = [

            ((1,1), (2,2), (2.5,1), (3,3), (4,5)),

            ((1,2), (2,3), (2.5,2), (3.5,5), (4,6))

            ]

        lp = LinePlot()

        lp.x = 50

        lp.y = 50

        lp.height = 125

        lp.width = 300

        lp.data = data

        lp.joinedLines = 1

        lp.lineLabelFormat = '%2.0f'

        lp.strokeColor = colors.black

        lp.lines[0].strokeColor = colors.red

        lp.lines[0].symbol = makeMarker('FilledCircle')

        lp.lines[1].strokeColor = colors.blue

        lp.lines[1].symbol = makeMarker('FilledDiamond')

        lp.xValueAxis.valueMin = 0

        lp.xValueAxis.valueMax = 5

        lp.xValueAxis.valueStep = 1

        lp.yValueAxis.valueMin = 0

        lp.yValueAxis.valueMax = 7

        lp.yValueAxis.valueStep = 1

        drawing.add(lp)

        return drawing

    def calcPositions(self):

        """Works out where they go.

        Sets an attribute _positions which is a list of

        lists of (x, y) matching the data.

        """

        self._seriesCount = len(self.data)

        self._rowLength = max(list(map(len,self.data)))

        self._positions = []

        for rowNo in range(len(self.data)):

            line = []

            for colNo in range(len(self.data[rowNo])):

                datum = self.data[rowNo][colNo] # x,y value

                if isinstance(datum[0],str):

                    x = self.xValueAxis.scale(mktime(mkTimeTuple(datum[0])))

                else:

                    x = self.xValueAxis.scale(datum[0])

                y = self.yValueAxis.scale(datum[1])

                line.append((x, y))

            self._positions.append(line)

    def _innerDrawLabel(self, rowNo, colNo, x, y):

        "Draw a label for a given item in the list."

        labelFmt = self.lineLabelFormat

        labelValue = self.data[rowNo][colNo][1] ###

        if labelFmt is None:

            labelText = None

        elif isinstance(labelFmt,str):

            if labelFmt == 'values':

                labelText = self.lineLabelArray[rowNo][colNo]

            else:

                labelText = labelFmt % labelValue

        elif hasattr(labelFmt,'__call__'):

            if not hasattr(labelFmt,'__labelFmtEX__'):

                labelText = labelFmt(labelValue)

            else:

                labelText = labelFmt(self,rowNo,colNo,x,y)

        else:

            raise ValueError("Unknown formatter type %s, expected string or function"% labelFmt)

        if labelText:

            label = self.lineLabels[(rowNo, colNo)]

            if not label.visible: return

            #hack to make sure labels are outside the bar

            if y > 0:

                label.setOrigin(x, y + self.lineLabelNudge)

            else:

                label.setOrigin(x, y - self.lineLabelNudge)

            label.setText(labelText)

        else:

            label = None

        return label

    def drawLabel(self, G, rowNo, colNo, x, y):

        '''Draw a label for a given item in the list.

        G must have an add method'''

        G.add(self._innerDrawLabel(rowNo,colNo,x,y))

    def makeLines(self):

        g = Group()

        yA = self.yValueAxis

        xA = self.xValueAxis

        bubblePlot = getattr(self,'_bubblePlot',None)

        if bubblePlot:

            bubbleR = min(yA._bubbleRadius,xA._bubbleRadius)

            bubbleMax = xA._bubbleMax

        labelFmt = self.lineLabelFormat

        P = list(range(len(self._positions)))

        if self.reversePlotOrder: P.reverse()

        inFill = getattr(self,'_inFill',None)

        lines = self.lines

        styleCount = len(lines)

        if inFill or [rowNo for rowNo in P if getattr(lines[rowNo%styleCount],'inFill',False)]:

            inFillY = getattr(inFill,'yValue',None)

            if inFillY is None:

                inFillY = xA._y

            else:

                inFillY = yA.scale(inFillY)

            inFillX0 = yA._x

            inFillX1 = inFillX0 + xA._length

            inFillG = getattr(self,'_inFillG',g)

        lG = getattr(self,'_lineG',g)

        # Iterate over data rows.

        for rowNo in P:

            row = self._positions[rowNo]

            styleRowNo = rowNo % styleCount

            rowStyle = lines[styleRowNo]

            rowColor = getattr(rowStyle,'strokeColor',None)

            dash = getattr(rowStyle, 'strokeDashArray', None)

            if hasattr(rowStyle, 'strokeWidth'):

                width = rowStyle.strokeWidth

            elif hasattr(lines, 'strokeWidth'):

                width = lines.strokeWidth

            else:

                width = None

            # Iterate over data columns.

            if self.joinedLines:

                points = []

                for xy in row:

                    points += [xy[0], xy[1]]

                if inFill or getattr(rowStyle,'inFill',False):

                    fpoints = [inFillX0,inFillY] + points + [inFillX1,inFillY]

                    filler = getattr(rowStyle, 'filler', None)

                    if filler:

                        filler.fill(self,inFillG,rowNo,rowColor,fpoints)

                    else:

                        inFillG.add(Polygon(fpoints,fillColor=rowColor,strokeColor=rowColor,strokeWidth=width or 0.1))

                if inFill in (None,0,2):

                    line = PolyLine(points,strokeColor=rowColor,strokeLineCap=0,strokeLineJoin=1)

                    if width:

                        line.strokeWidth = width

                    if dash:

                        line.strokeDashArray = dash

                    lG.add(line)

            if hasattr(rowStyle, 'symbol'):

                uSymbol = rowStyle.symbol

            elif hasattr(lines, 'symbol'):

                uSymbol = lines.symbol

            else:

                uSymbol = None

            if uSymbol:

                if bubblePlot: drow = self.data[rowNo]

                for j,xy in enumerate(row):

                    if (styleRowNo,j) in lines:

                        juSymbol = getattr(lines[styleRowNo,j],'symbol',uSymbol)

                    else:

                        juSymbol = uSymbol

                    if juSymbol is uSymbol:

                        symbol = uSymbol

                        symColor = rowColor

                    else:

                        symbol = juSymbol

                        symColor = getattr(symbol,'fillColor',rowColor)

                    symbol = uSymbol2Symbol(symbol,xy[0],xy[1],symColor)

                    if symbol:

                        if bubblePlot:

                            symbol.size = bubbleR*(drow[j][2]/bubbleMax)**0.5

                        g.add(symbol)

            else:

                if bubblePlot: drow = self.data[rowNo]

                for j,xy in enumerate(row):

                    juSymbol = getattr(lines[styleRowNo,j],'symbol',None)

                    if not juSymbol: continue

                    symColor = getattr(juSymbol,'fillColor',getattr(juSymbol,'strokeColor',rowColor))

                    symbol = uSymbol2Symbol(juSymbol,xy[0],xy[1],symColor)

                    if symbol:

                        if bubblePlot:

                            symbol.size = bubbleR*(drow[j][2]/bubbleMax)**0.5

                        g.add(symbol)

            # Draw data labels.

            for colNo in range(len(row)):

                x1, y1 = row[colNo]

                self.drawLabel(g, rowNo, colNo, x1, y1)

            shader = getattr(rowStyle, 'shader', None)

            if shader: shader.shade(self,g,rowNo,rowColor,row)

        return g

    def draw(self):

        yA = self.yValueAxis

        xA = self.xValueAxis

        if getattr(self,'_bubblePlot',None):

            yA._bubblePlot = xA._bubblePlot = 1

        yA.setPosition(self.x, self.y, self.height)

        if yA: yA.joinAxis = xA

        if xA: xA.joinAxis = yA

        yA.configure(self.data)

        # if zero is in chart, put x axis there, otherwise use bottom.

        xAxisCrossesAt = yA.scale(0)

        if ((xAxisCrossesAt > self.y + self.height) or (xAxisCrossesAt < self.y)):

            y = self.y

        else:

            y = xAxisCrossesAt

        xA.setPosition(self.x, y, self.width)

        xA.configure(self.data)

        self.calcPositions()

        g = Group()

        g.add(self.makeBackground())

        if self._inFill or self.behindAxes:

            xA._joinToAxis()

            if self._inFill:

                self._inFillG = Group()

                g.add(self._inFillG)

            if self.behindAxes:

                self._lineG = Group()

                g.add(self._lineG)

        xA._joinToAxis()

        yA._joinToAxis()

        xAex = xA.visibleAxis and [xA._y] or []

        yAex = yA.visibleAxis and [yA._x] or []

        skipGrid = getattr(xA,'skipGrid','none')

        if skipGrid!=None:

            if skipGrid in ('both','top'):

                yAex.append(xA._x+xA._length)

            if skipGrid in ('both','bottom'):

                yAex.append(xA._x)

        skipGrid = getattr(yA,'skipGrid','none')

        if skipGrid!=None:

            if skipGrid in ('both','top'):

                xAex.append(yA._y+yA._length)

            if skipGrid in ('both','bottom'):

                xAex.append(yA._y)

        if self.gridFirst:

            xA.makeGrid(g,parent=self,dim=yA.getGridDims,exclude=yAex)

            yA.makeGrid(g,parent=self,dim=xA.getGridDims,exclude=xAex)

        g.add(xA.draw())

        g.add(yA.draw())

        if not self.gridFirst:

            xAdgl = getattr(xA,'drawGridLast',False)

            yAdgl = getattr(yA,'drawGridLast',False)

            if not xAdgl: xA.makeGrid(g,parent=self,dim=yA.getGridDims,exclude=yAex)

            if not yAdgl: yA.makeGrid(g,parent=self,dim=xA.getGridDims,exclude=xAex)

        annotations = getattr(self,'annotations',[])

        for a in annotations:

            if getattr(a,'beforeLines',None):

                g.add(a(self,xA.scale,yA.scale))

        g.add(self.makeLines())

        if not self.gridFirst:

            if xAdgl: xA.makeGrid(g,parent=self,dim=yA.getGridDims,exclude=yAex)

            if yAdgl: yA.makeGrid(g,parent=self,dim=xA.getGridDims,exclude=xAex)

        for a in annotations:

            if not getattr(a,'beforeLines',None):

                g.add(a(self,xA.scale,yA.scale))

        return g

    def addCrossHair(self,name,xv,yv,strokeColor=colors.black,strokeWidth=1,beforeLines=True):

        from reportlab.graphics.shapes import Group, Line

        annotations = [a for a in getattr(self,'annotations',[]) if getattr(a,'name',None)!=name]

        def annotation(self,xScale,yScale):

            x = xScale(xv)

            y = yScale(yv)

            g = Group()

            xA = xScale.__self__ #the x axis

            g.add(Line(xA._x,y,xA._x+xA._length,y,strokeColor=strokeColor,strokeWidth=strokeWidth))

            yA = yScale.__self__ #the y axis

            g.add(Line(x,yA._y,x,yA._y+yA._length,strokeColor=strokeColor,strokeWidth=strokeWidth))

            return g

        annotation.beforeLines = beforeLines

        annotations.append(annotation)

        self.annotations = annotations

class LinePlot3D(LinePlot):

    _attrMap = AttrMap(BASE=LinePlot,

        theta_x = AttrMapValue(isNumber, desc='dx/dz'),

        theta_y = AttrMapValue(isNumber, desc='dy/dz'),

        zDepth = AttrMapValue(isNumber, desc='depth of an individual series'),

        zSpace = AttrMapValue(isNumber, desc='z gap around series'),

        )

    theta_x = .5

    theta_y = .5

    zDepth = 10

    zSpace = 3

    def calcPositions(self):

        LinePlot.calcPositions(self)

        nSeries = self._seriesCount

        zSpace = self.zSpace

        zDepth = self.zDepth

        if self.xValueAxis.style=='parallel_3d':

            _3d_depth = nSeries*zDepth+(nSeries+1)*zSpace

        else:

            _3d_depth = zDepth + 2*zSpace

        self._3d_dx = self.theta_x*_3d_depth

        self._3d_dy = self.theta_y*_3d_depth

    def _calc_z0(self,rowNo):

        zSpace = self.zSpace

        if self.xValueAxis.style=='parallel_3d':

            z0 = rowNo*(self.zDepth+zSpace)+zSpace

        else:

            z0 = zSpace

        return z0

    def _zadjust(self,x,y,z):

        return x+z*self.theta_x, y+z*self.theta_y

    def makeLines(self):

        bubblePlot = getattr(self,'_bubblePlot',None)

        assert not bubblePlot, "_bubblePlot not supported for 3d yet"

        #if bubblePlot:

        #   yA = self.yValueAxis

        #   xA = self.xValueAxis

        #   bubbleR = min(yA._bubbleRadius,xA._bubbleRadius)

        #   bubbleMax = xA._bubbleMax