#Copyright ReportLab Europe Ltd. 2000-2004

#see license.txt for license details

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

"""This module defines a variety of Bar Chart components.

The basic flavors are Side-by-side, available in horizontal and

vertical versions.

Stacked and percentile bar charts to follow...

"""

__version__=''' $Id$ '''

import string, copy

from types import FunctionType, StringType

from reportlab.lib import colors

from reportlab.lib.validators import isNumber, isColor, isColorOrNone, isString,\

            isListOfStrings, SequenceOf, isBoolean, isNoneOrShape, isStringOrNone,\

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

from reportlab.lib.formatters import Formatter

from reportlab.lib.attrmap import AttrMap, AttrMapValue

from reportlab.pdfbase.pdfmetrics import stringWidth

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

from reportlab.graphics.shapes import Line, Rect, Group, Drawing, NotImplementedError

from reportlab.graphics.charts.axes import XCategoryAxis, YValueAxis, YCategoryAxis, XValueAxis

from reportlab.graphics.charts.textlabels import BarChartLabel, NA_Label, NoneOrInstanceOfNA_Label

from reportlab.graphics.charts.areas import PlotArea

class BarChartProperties(PropHolder):

    _attrMap = AttrMap(

        strokeColor = AttrMapValue(isColorOrNone, desc='Color of the bar border.'),

        fillColor = AttrMapValue(isColorOrNone, desc='Color of the bar interior area.'),

        strokeWidth = AttrMapValue(isNumber, desc='Width of the bar border.'),

        symbol = AttrMapValue(None, desc='A widget to be used instead of a normal bar.'),

        name = AttrMapValue(isString, desc='Text to be associated with a bar (eg seriesname)'),

        swatchMarker = AttrMapValue(NoneOr(isSymbol), desc="None or makeMarker('Diamond') ..."),

        )

    def __init__(self):

        self.strokeColor = None

        self.fillColor = colors.blue

        self.strokeWidth = 0.5

        self.symbol = None

# Bar chart classes.

class BarChart(PlotArea):

    "Abstract base class, unusable by itself."

    _attrMap = AttrMap(BASE=PlotArea,

        useAbsolute = AttrMapValue(isNumber, desc='Flag to use absolute spacing values.'),

        barWidth = AttrMapValue(isNumber, desc='The width of an individual bar.'),

        groupSpacing = AttrMapValue(isNumber, desc='Width between groups of bars.'),

        barSpacing = AttrMapValue(isNumber, desc='Width between individual bars.'),

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

        valueAxis = AttrMapValue(None, desc='Handle of the value axis.'),

        categoryAxis = AttrMapValue(None, desc='Handle of the category axis.'),

        data = AttrMapValue(None, desc='Data to be plotted, list of (lists of) numbers.'),

        barLabels = AttrMapValue(None, desc='Handle to the list of bar labels.'),

        barLabelFormat = AttrMapValue(None, desc='Formatting string or function used for bar labels.'),

        barLabelCallOut = AttrMapValue(None, desc='Callout function(label)\nlabel._callOutInfo = (self,g,rowNo,colNo,x,y,width,height,x00,y00,x0,y0)'),

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

        reversePlotOrder = AttrMapValue(isBoolean, desc='If true, reverse common category plot order.'),

        naLabel = AttrMapValue(NoneOrInstanceOfNA_Label, desc='Label to use for N/A values.'),

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

        )

    def makeSwatchSample(self, rowNo, x, y, width, height):

        baseStyle = self.bars

        styleIdx = rowNo % len(baseStyle)

        style = baseStyle[styleIdx]

        strokeColor = getattr(style, 'strokeColor', getattr(baseStyle,'strokeColor',None))

        fillColor = getattr(style, 'fillColor', getattr(baseStyle,'fillColor',None))

        strokeDashArray = getattr(style, 'strokeDashArray', getattr(baseStyle,'strokeDashArray',None))

        strokeWidth = getattr(style, 'strokeWidth', getattr(style, 'strokeWidth',None))

        swatchMarker = getattr(style, 'swatchMarker', getattr(baseStyle, 'swatchMarker',None))

        if swatchMarker:

            return uSymbol2Symbol(swatchMarker,x+width/2.,y+height/2.,fillColor)

        return Rect(x,y,width,height,strokeWidth=strokeWidth,strokeColor=strokeColor,

                    strokeDashArray=strokeDashArray,fillColor=fillColor)

    def getSeriesName(self,i,default=None):

        '''return series name i or default'''

        return getattr(self.bars[i],'name',default)

    def __init__(self):

        assert self.__class__.__name__ not in ('BarChart','BarChart3D'), 'Abstract Class %s Instantiated' % self.__class__.__name__

        if self._flipXY:

            self.categoryAxis = YCategoryAxis()

            self.valueAxis = XValueAxis()

        else:

            self.categoryAxis = XCategoryAxis()

            self.valueAxis = YValueAxis()

        PlotArea.__init__(self)

        self.barSpacing = 0

        self.reversePlotOrder = 0

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

        self.data = [(100,110,120,130),

                    (70, 80, 85, 90)]

        # control bar spacing. is useAbsolute = 1 then

        # the next parameters are in points; otherwise

        # they are 'proportions' and are normalized to

        # fit the available space.  Half a barSpacing

        # is allocated at the beginning and end of the

        # chart.

        self.useAbsolute = 0   #- not done yet

        self.barWidth = 10

        self.groupSpacing = 5

        self.barSpacing = 0

        self.barLabels = TypedPropertyCollection(BarChartLabel)

        self.barLabels.boxAnchor = 'c'

        self.barLabels.textAnchor = 'middle'

        self.barLabelFormat = None

        self.barLabelArray = 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.barLabels.nudge = 0

        # if you have multiple series, by default they butt

        # together.

        # we really need some well-designed default lists of

        # colors e.g. from Tufte.  These will be used in a

        # cycle to set the fill color of each series.

        self.bars = TypedPropertyCollection(BarChartProperties)

        self.bars.strokeWidth = 1

        self.bars.strokeColor = colors.black

        self.bars[0].fillColor = colors.red

        self.bars[1].fillColor = colors.green

        self.bars[2].fillColor = colors.blue

    def demo(self):

        """Shows basic use of a bar chart"""

        if self.__class__.__name__=='BarChart':

            raise NotImplementedError, 'Abstract Class BarChart has no demo'

        drawing = Drawing(200, 100)

        bc = self.__class__()

        drawing.add(bc)

        return drawing

    def _getConfigureData(self):

        cA = self.categoryAxis

        data = self.data

        if cA.style not in ('parallel','parallel_3d'):

            _data = data

            data = max(map(len,_data))*[0]

            for d in _data:

                for i in xrange(len(d)):

                    data[i] = data[i] + (d[i] or 0)

            data = list(_data) + [data]

        self._configureData = data

    def _getMinMax(self):

        '''Attempt to return the data range'''

        self._getConfigureData()

        self.valueAxis._setRange(self._configureData)

        return self.valueAxis._valueMin, self.valueAxis._valueMax

    def _drawBegin(self,org,length):

        '''Position and configure value axis, return crossing value'''

        vA = self.valueAxis

        vA.setPosition(self.x, self.y, length)

        self._getConfigureData()

        vA.configure(self._configureData)

        # if zero is in chart, put the other axis there, otherwise use low

        crossesAt = vA.scale(0)

        if crossesAt > org+length or crossesAt<org:

            crossesAt = org

        return crossesAt

    def _drawFinish(self):

        '''finalize the drawing of a barchart'''

        cA = self.categoryAxis

        vA = self.valueAxis

        cA.configure(self._configureData)

        self.calcBarPositions()

        g = Group()

        g.add(self.makeBackground())

        # ensure any axes have correct spacing set

        # for grids. It sucks that we have to do

        # this here.

        if self._flipXY == 0:

            vA.gridStart = cA._x

            vA.gridEnd = cA._x+cA._length

            cA.gridStart = vA._y

            cA.gridEnd = vA._y+vA._length

        else:

            cA.gridStart = vA._x

            cA.gridEnd = vA._x+vA._length

            vA.gridStart = cA._y

            vA.gridEnd = cA._y+cA._length

        cA.makeGrid(g,parent=self)

        vA.makeGrid(g,parent=self)

        g.add(self.makeBars())

        g.add(cA)

        g.add(vA)

        for a in getattr(self,'annotations',()): g.add(a(self,cA.scale,vA.scale))

        del self._configureData

        return g

    def calcBarPositions(self):

        """Works out where they go. default vertical.

        Sets an attribute _barPositions which is a list of

        lists of (x, y, width, height) matching the data.

        """

        flipXY = self._flipXY

        if flipXY:

            org = self.y

        else:

            org = self.x

        cA = self.categoryAxis

        cScale = cA.scale

        data = self.data

        seriesCount = self._seriesCount = len(data)

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

        groupSpacing, barSpacing, barWidth = self.groupSpacing, self.barSpacing, self.barWidth

        style = self.categoryAxis.style

        if style=='parallel':

            groupWidth = groupSpacing+(seriesCount*barWidth)+(seriesCount-1)*barSpacing

            bGap = barWidth+barSpacing

        else:

            accum = rowLength*[0]

            groupWidth = groupSpacing+barWidth

            bGap = 0

        self._groupWidth = groupWidth

        useAbsolute = self.useAbsolute

        if useAbsolute:

            # bar dimensions are absolute

            normFactor = 1.0

        else:

            # bar dimensions are normalized to fit.  How wide

            # notionally is one group of bars?

            availWidth = cScale(0)[1]

            normFactor = availWidth/float(groupWidth)

            if self.debug:

                print '%d series, %d points per series' % (seriesCount, self._rowLength)

                print 'width = %d group + (%d bars * %d barWidth) + (%d gaps * %d interBar) = %d total' % (

                    groupSpacing, seriesCount, barWidth,

                    seriesCount-1, barSpacing, groupWidth)

        # 'Baseline' correction...

        vA = self.valueAxis

        vScale = vA.scale

        vm, vM = vA._valueMin, vA._valueMax

        if vm <= 0 <= vM:

            baseLine = vScale(0)

        elif 0 < vm:

            baseLine = vScale(vm)

        elif vM < 0:

            baseLine = vScale(vM)

        self._baseLine = baseLine

        COLUMNS = range(max(map(len,data)))

        if useAbsolute:

            _cScale = cA._scale

        self._normFactor = normFactor

        width = self.barWidth*normFactor

        self._barPositions = []

        reversePlotOrder = self.reversePlotOrder

        for rowNo in range(seriesCount):

            barRow = []

            if reversePlotOrder:

                xVal = seriesCount-1 - rowNo

            else:

                xVal = rowNo

            xVal = 0.5*groupSpacing+xVal*bGap

            for colNo in COLUMNS:

                datum = data[rowNo][colNo]

                # Ufff...

                if useAbsolute:

                    x = groupWidth*_cScale(colNo) + xVal + org

                else:

                    (g, gW) = cScale(colNo)

                    x = g + normFactor*xVal

                if datum is None:

                    height = None

                    y = baseLine

                else:

                    if style not in ('parallel','parallel_3d'):

                        y = vScale(accum[colNo])

                        if y<baseLine: y = baseLine

                        accum[colNo] = accum[colNo] + datum

                        datum = accum[colNo]

                    else:

                        y = baseLine

                    height = vScale(datum) - y

                    if -1e-8<height<=1e-8:

                        height = 1e-8

                        if datum<-1e-8: height = -1e-8

                barRow.append(flipXY and (y,x,height,width) or (x, y, width, height))

            self._barPositions.append(barRow)

    def _getLabelText(self, rowNo, colNo):

        '''return formatted label text'''

        labelFmt = self.barLabelFormat

        if labelFmt is None:

            labelText = None

        elif labelFmt == 'values':

            labelText = self.barLabelArray[rowNo][colNo]

        elif type(labelFmt) is StringType:

            labelText = labelFmt % self.data[rowNo][colNo]

        elif callable(labelFmt):

            labelText = labelFmt(self.data[rowNo][colNo])

        else:

            msg = "Unknown formatter type %s, expected string or function" % labelFmt

            raise Exception, msg

        return labelText

    def _labelXY(self,label,x,y,width,height):

        'Compute x, y for a label'

        nudge = label.nudge

        anti = getattr(label,'boxTarget','normal')=='anti'

        if anti: nudge = -nudge

        if self._flipXY:

            value = width

            if anti: value = 0

            return x + value + (width>=0 and 1 or -1)*nudge, y + 0.5*height

        else:

            value = height

            if anti: value = 0

            return x + 0.5*width, y + value + (height>=0 and 1 or -1)*nudge

    def _addBarLabel(self, g, rowNo, colNo, x, y, width, height):

        text = self._getLabelText(rowNo,colNo)

        if text:

            self._addLabel(text, self.barLabels[(rowNo, colNo)], g, rowNo, colNo, x, y, width, height)

    def _addNABarLabel(self, g, rowNo, colNo, x, y, width, height):

        na = self.naLabel

        if na and na.text:

            na = copy.copy(na)

            v = self.valueAxis._valueMax<=0 and -1e-8 or 1e-8

            if width is None: width = v

            if height is None: height = v

            self._addLabel(na.text, na, g, rowNo, colNo, x, y, width, height)

    def _addLabel(self, text, label, g, rowNo, colNo, x, y, width, height):

        if label.visible:

            labelWidth = stringWidth(text, label.fontName, label.fontSize)

            x0, y0 = self._labelXY(label,x,y,width,height)

            flipXY = self._flipXY

            if flipXY:

                pm = width

            else:

                pm = height

            label._pmv = pm #the plus minus val

            fixedEnd = getattr(label,'fixedEnd', None)

            if fixedEnd is not None:

                v = fixedEnd._getValue(self,pm)

                x00, y00 = x0, y0

                if flipXY:

                    x0 = v

                else:

                    y0 = v

            else:

                if flipXY:

                    x00 = x0

                    y00 = y+height/2.0

                else:

                    x00 = x+width/2.0

                    y00 = y0

            fixedStart = getattr(label,'fixedStart', None)

            if fixedStart is not None:

                v = fixedStart._getValue(self,pm)

                if flipXY:

                    x00 = v

                else:

                    y00 = v

            if pm<0:

                if flipXY:

                    dx = -2*label.dx

                    dy = 0

                else:

                    dy = -2*label.dy

                    dx = 0

            else:

                dy = dx = 0

            label.setOrigin(x0+dx, y0+dy)

            label.setText(text)

            sC, sW = label.lineStrokeColor, label.lineStrokeWidth

            if sC and sW: g.insert(0,Line(x00,y00,x0,y0, strokeColor=sC, strokeWidth=sW))

            g.add(label)

            alx = getattr(self,'barLabelCallOut',None)

            if alx:

                label._callOutInfo = (self,g,rowNo,colNo,x,y,width,height,x00,y00,x0,y0)

                alx(label)

                del label._callOutInfo

    def _makeBar(self,g,x,y,width,height,rowNo,style):

        r = Rect(x, y, width, height)

        r.strokeWidth = style.strokeWidth

        r.fillColor = style.fillColor

        r.strokeColor = style.strokeColor

        g.add(r)

    def _makeBars(self,g,lg):

        lenData = len(self.data)

        bars = self.bars

        for rowNo in range(lenData):

            row = self._barPositions[rowNo]

            styleCount = len(bars)

            styleIdx = rowNo % styleCount

            rowStyle = bars[styleIdx]

            for colNo in range(len(row)):

                barPos = row[colNo]

                style = bars.has_key((styleIdx,colNo)) and bars[(styleIdx,colNo)] or rowStyle

                (x, y, width, height) = barPos

                if None in (width,height):

                    self._addNABarLabel(lg,rowNo,colNo,x,y,width,height)

                    continue

                # Draw a rectangular symbol for each data item,

                # or a normal colored rectangle.

                symbol = None

                if hasattr(style, 'symbol'):

                    symbol = copy.deepcopy(style.symbol)

                elif hasattr(self.bars, 'symbol'):

                    symbol = self.bars.symbol

                if symbol:

                    symbol.x = x

                    symbol.y = y

                    symbol.width = width

                    symbol.height = height

                    g.add(symbol)

                elif abs(width)>1e-7 and abs(height)>=1e-7 and (style.fillColor is not None or style.strokeColor is not None):

                    self._makeBar(g,x,y,width,height,rowNo,style)

                self._addBarLabel(lg,rowNo,colNo,x,y,width,height)

    def makeBars(self):

        g = Group()

        lg = Group()

        self._makeBars(g,lg)

        g.add(lg)

        return g

    def _desiredCategoryAxisLength(self):

        '''for dynamically computing the desired category axis length'''

        style = self.categoryAxis.style

        data = self.data

        n = len(data)

        m = max(map(len,data))

        if style=='parallel':

            groupWidth = (n-1)*self.barSpacing+n*self.barWidth

        else:

            groupWidth = self.barWidth

        return m*(self.groupSpacing+groupWidth)

    def draw(self):

        cA, vA = self.categoryAxis, self.valueAxis

        if vA: ovAjA, vA.joinAxis = vA.joinAxis, cA

        if cA: ocAjA, cA.joinAxis = cA.joinAxis, vA

        if self._flipXY: