+++ /dev/null
-##############################################################################
-# Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-##############################################################################
-
-
-__doc__ = """
-it contains the base element for pdf
-eImage is used to draw picture on the pdf document
-eDataTable is used to draw table on the pdf document
-eGraphicsTable is used to draw plot on the pdf document
-eParagraph is used to draw text on the pdf document
-"""
-from reportlab.platypus import Image, Table
-from reportlab.graphics.shapes import Drawing
-from reportlab.graphics.charts.lineplots import LinePlot
-from reportlab.graphics.charts.linecharts import HorizontalLineChart
-from reportlab.platypus.paragraph import Paragraph
-from reportlab.graphics.widgets.markers import makeMarker
-from reportlab.graphics.charts.legends import Legend
-from reportlab.graphics.charts.textlabels import Label
-from reportlab.graphics.charts.axes import XValueAxis
-from reportlab.graphics.shapes import Group
-from reportlab.graphics.charts.barcharts import VerticalBarChart
-from vstf.controller.reporters.report.pdf.styles import *
-
-
-class eImage(Image):
- """ an image(digital picture)which contains the function of auto zoom picture """
-
- def __init__(
- self,
- filename,
- width=None,
- height=None,
- kind='direct',
- mask="auto",
- lazy=1,
- hAlign='CENTRE',
- vAlign='BOTTOM'):
- Image.__init__(self, filename, None, None, kind, mask, lazy)
- print height, width
- print self.drawHeight, self.drawWidth
- if self.drawWidth * height > self.drawHeight * width:
- self.drawHeight = width * self.drawHeight / self.drawWidth
- self.drawWidth = width
- else:
- self.drawWidth = height * self.drawWidth / self.drawHeight
- self.drawHeight = height
- self.hAlign = hAlign
- self.vAlign = vAlign
- print self.drawHeight, self.drawWidth
-
-
-class eTable(object):
- """ an abstract table class, which is contains the base functions to create table """
-
- def __init__(self, data, style=TableStyle(name="default")):
- self._tablestyle = style
- self._table = []
- self._spin = False
- self._colWidths = None
- self._data = self.analysisData(data)
- if self._data:
- self.create()
-
- def analysisData(self, data):
- raise NotImplementedError("abstract eTable")
-
- def create(self):
- self._table = Table(self._data, style=self._style, splitByRow=1)
- self._table.hAlign = self._tablestyle.table_hAlign
- self._table.vAlign = self._tablestyle.table_vAlign
- self._table.colWidths = self._tablestyle.table_colWidths
- if self._spin or self._colWidths:
- self._table.colWidths = self._colWidths
- self._table.rowHeights = self._tablestyle.table_rowHeights
-
- @property
- def table(self):
- return self._table
-
-
-class eCommonTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1.2, colors.black)
- ]
- return data
-
-
-class eConfigTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('SPAN', (2, 0), (3, 0)),
- ('SPAN', (2, 1), (3, 1)),
- ('SPAN', (2, 8), (3, 8)),
- ('SPAN', (2, 9), (3, 9)),
- ('SPAN', (2, 10), (3, 10)),
- ('SPAN', (0, 0), (0, 7)),
- ('SPAN', (0, 8), (0, 10)),
- ('SPAN', (0, 11), (0, 19)),
- ('SPAN', (1, 2), (1, 6)),
- ('SPAN', (1, 12), (1, 13)),
- ('SPAN', (1, 14), (1, 16)),
- ('SPAN', (1, 17), (1, 19)),
- ('SPAN', (2, 3), (2, 6))
- ]
- return data
-
-
-class eSummaryTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('SPAN', (0, 0), (0, 1)),
- ('SPAN', (1, 0), (4, 0)),
- ('SPAN', (5, 0), (-1, 0))
- ]
- return data
-
-
-class eGitInfoTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('SPAN', (0, 0), (0, 2)),
- ('SPAN', (0, 3), (0, 5)),
- ('SPAN', (0, 6), (0, 8))
- ]
- return data
-
-
-class eScenarioTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('ALIGN', (2, 1), (-1, -1), 'LEFT'),
- ('SPAN', (0, 1), (0, 6)),
- ('SPAN', (0, 7), (0, 12)),
- ('SPAN', (0, 13), (0, 16)),
- ('SPAN', (0, 17), (0, 20))
- ]
- return data
-
-
-class eOptionsTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('SPAN', (2, 0), (4, 0)),
- ('SPAN', (2, 1), (4, 1)),
- ('SPAN', (0, 0), (0, -1)),
- ('SPAN', (1, 2), (1, 16)),
- ('SPAN', (1, 17), (1, 19)),
- ('SPAN', (1, 20), (1, 22)),
- ('SPAN', (1, 23), (1, 24)),
- ('SPAN', (2, 2), (2, 4)),
- ('SPAN', (2, 5), (2, 12)),
- ('SPAN', (2, 13), (2, 16)),
- ('SPAN', (2, 17), (2, 19)),
- ('SPAN', (2, 20), (2, 22)),
- ('SPAN', (2, 23), (2, 24))
- ]
- return data
-
-
-class eProfileTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('SPAN', (0, 1), (0, -1)),
- ('SPAN', (1, 0), (2, 0)),
- ]
- return data
-
-
-class eDataTable(eTable):
-
- def analysisData(self, data):
- result = data
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
- ('LEADING', (0, 0), (-1, -1), 18),
- ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
- ('BOX', (0, 0), (-1, -1), 1, colors.black),
- ('LINEBEFORE', (1, 0), (1, -1), 0.8, colors.black),
- # ('LINEBEFORE', (3, 0), (3, -1), 1, colors.black),
- # ('LINEBEFORE', (5, 0), (5, -1), 1, colors.black),
- ('LINEBELOW', (0, 0), (-1, 0), 0.8, colors.black),
- # ('SPAN', (0, 0), (0, 1)),
- # ('SPAN', (1, 0), (2, 0)),
- # ('SPAN', (3, 0), (4, 0))
- ]
- if self._spin is True:
- print "start spin"
- result = map(list, zip(*result))
- style = []
- for value in self._style:
- value = list(value)
- value[1] = (value[1][1], value[1][0])
- value[2] = (value[2][1], value[2][0])
- if value[0] == 'LINEBELOW':
- value[0] = 'LINEAFTER'
- elif value[0] == 'LINEBEFORE':
- value[0] = 'LINEABOVE'
- value = tuple(value)
- style.append(value)
- self._style = style
- return result
-
-
-class eGraphicsTable(eTable):
-
- def analysisData(self, data):
- self._style = [
- ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
- ('VALIGN', (0, 0), (-1, -1), 'MIDDLE')
- ]
- return data
-
-
-class noScaleXValueAxis(XValueAxis):
-
- def __init__(self):
- XValueAxis.__init__(self)
-
- def makeTickLabels(self):
- g = Group()
- if not self.visibleLabels:
- return g
-
- f = self._labelTextFormat # perhaps someone already set it
- if f is None:
- f = self.labelTextFormat or (self._allIntTicks() and '%.0f' or str)
- elif f is str and self._allIntTicks():
- f = '%.0f'
- elif hasattr(f, 'calcPlaces'):
- f.calcPlaces(self._tickValues)
- post = self.labelTextPostFormat
- scl = self.labelTextScale
- pos = [self._x, self._y]
- d = self._dataIndex
- pos[1 - d] = self._labelAxisPos()
- labels = self.labels
- if self.skipEndL != 'none':
- if self.isXAxis:
- sk = self._x
- else:
- sk = self._y
- if self.skipEndL == 'start':
- sk = [sk]
- else:
- sk = [sk, sk + self._length]
- if self.skipEndL == 'end':
- del sk[0]
- else:
- sk = []
-
- nticks = len(self._tickValues)
- nticks1 = nticks - 1
- for i, tick in enumerate(self._tickValues):
- label = i - nticks
- if label in labels:
- label = labels[label]
- else:
- label = labels[i]
- if f and label.visible:
- v = self.scale(i)
- if sk:
- for skv in sk:
- if abs(skv - v) < 1e-6:
- v = None
- break
- if v is not None:
- if scl is not None:
- t = tick * scl
- else:
- t = tick
- if isinstance(f, str):
- txt = f % t
- elif isSeq(f):
- # it's a list, use as many items as we get
- if i < len(f):
- txt = f[i]
- else:
- txt = ''
- elif hasattr(f, '__call__'):
- if isinstance(f, TickLabeller):
- txt = f(self, t)
- else:
- txt = f(t)
- else:
- raise ValueError('Invalid labelTextFormat %s' % f)
- if post:
- txt = post % txt
- pos[d] = v
- label.setOrigin(*pos)
- label.setText(txt)
-
- # special property to ensure a label doesn't project beyond
- # the bounds of an x-axis
- if self.keepTickLabelsInside:
- if isinstance(
- self, XValueAxis): # not done yet for y axes
- a_x = self._x
- if not i: # first one
- x0, y0, x1, y1 = label.getBounds()
- if x0 < a_x:
- label = label.clone(dx=label.dx + a_x - x0)
- if i == nticks1: # final one
- a_x1 = a_x + self._length
- x0, y0, x1, y1 = label.getBounds()
- if x1 > a_x1:
- label = label.clone(
- dx=label.dx - x1 + a_x1)
- g.add(label)
-
- return g
-
- def ___calcScaleFactor(self):
- """Calculate the axis' scale factor.
- This should be called only *after* the axis' range is set.
- Returns a number.
- """
- self._scaleFactor = self._length / (len(self._tickValues) + 1)
- return self._scaleFactor
-
- def scale(self, value):
- """Converts a numeric value to a plotarea position.
- The chart first configures the axis, then asks it to
- """
- assert self._configured, "Axis cannot scale numbers before it is configured"
- if value is None:
- value = 0
- # this could be made more efficient by moving the definition of org and
- # sf into the configuration
- org = (self._x, self._y)[self._dataIndex]
- sf = self._length / (len(self._tickValues) + 1)
- if self.reverseDirection:
- sf = -sf
- org += self._length
- return org + sf * (value + 1)
-
-
-class noScaleLinePlot(LinePlot):
-
- def __init__(self):
- LinePlot.__init__(self)
- self.xValueAxis = noScaleXValueAxis()
-
- 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(map(len, self.data))
-
- self._positions = []
- for rowNo in range(len(self.data)):
- line = []
- len_row = len(self.data[rowNo])
- for colNo in range(len_row):
- datum = self.data[rowNo][colNo] # x, y value
- x = self.x + self.width / (len_row + 1) * (colNo + 1)
- self.xValueAxis.labels[colNo].x = self.x + \
- self.width / (len_row + 1) * (colNo + 1)
- y = self.yValueAxis.scale(datum[1])
- # print self.width, " ", x
- line.append((x, y))
- self._positions.append(line)
-
-
-# def _innerDrawLabel(self, rowNo, colNo, x, y):
-# return None
-class eLinePlot(object):
-
- def __init__(self, data, style):
- self._lpstyle = style
- self._linename = data[0]
- self._data = self.analysisData(data[1:])
- if self._data:
- self.create()
-
- @property
- def draw(self):
- return self._draw
-
- def analysisData(self, data):
- columns = len(data)
- # print data
- data = map(list, zip(*data))
- rows = len(data)
-
- for i in range(rows):
- for j in range(columns):
- data[i][j] = float(data[i][j])
- self._linename = self._linename[1:]
- """
- delcnt = 0
- delrows = []
- for i in range(columns):
- delrows.append(0.0)
- del_line = [self._linename[0]]
- for i in range(rows):
- for j in range(columns):
- data[i][j] = float(data[i][j])
- if data[i] == delrows:
- delcnt += 1
- del_line.append(self._linename[i])
- for i in range(delcnt):
- data.remove(delrows)
- for name in del_line:
- self._linename.remove(name)
-
- rows = len(data)
- """
- # print rows
- # print data
- xvalueSteps = data[0]
- xvalueMin = data[0][0]
- xvalueMax = data[0][0]
- yvalueMin = data[1][0]
- yvalueMax = data[1][0]
- yvalueSteps = []
- result = []
- for j in range(columns):
- if xvalueMin > data[0][j]:
- xvalueMin = data[0][j]
- if xvalueMax < data[0][j]:
- xvalueMax = data[0][j]
-
- for i in range(rows - 1):
- lst = []
- for j in range(columns):
- lst.append((data[0][j], data[i + 1][j]))
- if yvalueMin > data[i + 1][j]:
- yvalueMin = data[i + 1][j]
- if yvalueMax < data[i + 1][j]:
- yvalueMax = data[i + 1][j]
- yvalueSteps.append(int(data[i + 1][j] * 2.5) / 2.5)
- result.append(tuple(lst))
- xvalueMin = int(xvalueMin) / 100 * 100
- xvalueMax = int(xvalueMax) / 100 * 100 + 200
- yvalueMin = int(yvalueMin) * 1.0 - 1
- if yvalueMin < 0:
- yvalueMin = 0.0
- yvalueMax = int(yvalueMax) + 2.0
- yvalueSteps.append(yvalueMin)
- yvalueSteps.append(yvalueMax)
- yvalueSteps = {}.fromkeys(yvalueSteps).keys()
-
- self._xvalue = (xvalueMin, xvalueMax, xvalueSteps)
- self._yvalue = (yvalueMin, yvalueMax, yvalueSteps)
- print result
- return result
-
- def create(self):
- lpw = self._lpstyle.width
- lph = self._lpstyle.height
- draw = Drawing(lpw, lph)
- line_cnts = len(self._linename)
- # lp = noScaleLinePlot()
- lp = LinePlot()
- lg_line = (line_cnts + 3) / 4
- lp.x = self._lpstyle.left
- lp.y = self._lpstyle.bottom
-
- lp.height = lph - self._lpstyle.bottom * (lg_line + 1.5)
- lp.width = lpw - lp.x * 2
- lp.data = self._data
- lp.joinedLines = 1
- lp.strokeWidth = self._lpstyle.strokeWidth
- line_cnts = len(self._data)
- sytle_cnts = len(self._lpstyle.linestyle)
- color_paris = []
- for i in range(line_cnts):
- styleIndex = i % sytle_cnts
- lp.lines[i].strokeColor = self._lpstyle.linestyle[styleIndex][0]
- lp.lines[i].symbol = makeMarker(
- self._lpstyle.linestyle[styleIndex][1])
- lp.lines[i].strokeWidth = self._lpstyle.linestyle[styleIndex][2]
- color_paris.append(
- (self._lpstyle.linestyle[styleIndex][0], self._linename[i]))
- # lp.lineLabels[i].strokeColor = self._lpstyle.linestyle[styleIndex][0]
-
- lp.lineLabelFormat = self._lpstyle.format[0]
-
- lp.strokeColor = self._lpstyle.strokeColor
-
- lp.xValueAxis.valueMin, lp.xValueAxis.valueMax, lp.xValueAxis.valueSteps = self._xvalue
- # valueMin, valueMax, xvalueSteps = self._xvalue
- # lp.xValueAxis.valueStep = (lp.xValueAxis.valueMax - lp.xValueAxis.valueMin)/len(xvalueSteps)
- # lp.xValueAxis.valueSteps = map(lambda x: str(x), xvalueSteps)
-
- lp.yValueAxis.valueMin, lp.yValueAxis.valueMax, lp.yValueAxis.valueSteps = self._yvalue
-
- # lp.xValueAxis.forceZero = 0
- # lp.xValueAxis.avoidBoundFrac = 1
- # lp.xValueAxis.tickDown = 3
- # lp.xValueAxis.visibleGrid = 1
- # lp.xValueAxis.categoryNames = '64 256 512 1400 1500 4096'.split(' ')
-
- lp.xValueAxis.labelTextFormat = self._lpstyle.format[1]
- lp.yValueAxis.labelTextFormat = self._lpstyle.format[2]
-
- delsize = int(lp.xValueAxis.valueMax / 2000)
- lp.xValueAxis.labels.fontSize = self._lpstyle.labelsfont
- lp.xValueAxis.labels.angle = 25
-
- lp.yValueAxis.labels.fontSize = self._lpstyle.labelsfont
- lp.lineLabels.fontSize = self._lpstyle.labelsfont - delsize
- draw.add(lp)
-
- lg = Legend()
- lg.colorNamePairs = color_paris
- lg.fontName = 'Helvetica'
- lg.fontSize = 7
-
- lg.x = self._lpstyle.left * 3
- lg.y = self._lpstyle.bottom * (1 + lg_line) + lp.height
-
- lg.dxTextSpace = 5
- lg.dy = 5
- lg.dx = 20
- lg.deltax = 60
- lg.deltay = 0
- lg.columnMaximum = 1
- lg.alignment = 'right'
- draw.add(lg)
- self._draw = draw
-
-
-class eHorizontalLineChart(object):
-
- def __init__(self, data, style):
- self._lcstyle = style
- if len(data) < 1:
- return
- self._linename = data[0]
- self._data = self.analysisData(data[1:])
- if self._data:
- self.create()
-
- @property
- def draw(self):
- return self._draw
-
- def analysisData(self, data):
- columns = len(data)
- data = map(list, zip(*data))
- self._catNames = data[0]
- self._linename = self._linename[1:]
- data = data[1:]
- rows = len(data)
-
- yvalueMin = float(data[0][0])
- yvalueMax = float(data[0][0])
- yvalueSteps = []
- result = []
-
- for rowNo in range(rows):
- for columnNo in range(columns):
- data[rowNo][columnNo] = float(data[rowNo][columnNo])
- if yvalueMin > data[rowNo][columnNo]:
- yvalueMin = data[rowNo][columnNo]
- if yvalueMax < data[rowNo][columnNo]:
- yvalueMax = data[rowNo][columnNo]
- yvalueSteps.append(int(data[rowNo][columnNo] * 1.0) / 1.0)
- result.append(tuple(data[rowNo]))
-
- yvalueMin = int(yvalueMin) * 1.0 - 1
- if yvalueMin < 0:
- yvalueMin = 0.0
- yvalueMax = int(yvalueMax) + 2.0
- yvalueSteps.append(yvalueMin)
- yvalueSteps.append(yvalueMax)
- yvalueSteps = {}.fromkeys(yvalueSteps).keys()
-
- self._value = (yvalueMin, yvalueMax, yvalueSteps)
- print result
- return result
-
- def create(self):
- dw = self._lcstyle.width
- dh = self._lcstyle.height
- draw = Drawing(dw, dh)
-
- lc = HorizontalLineChart()
- line_cnts = len(self._linename)
-
- lg_line = (line_cnts + 3) / 4
- lc.height = dh - self._lcstyle.bottom * (lg_line + 1.5)
- lc.width = dw - lc.x * 2
- lc.x = self._lcstyle.left
- lc.y = self._lcstyle.bottom
-
- lc.data = self._data
-
- lc.strokeColor = self._lcstyle.strokeColor
- lc.strokeWidth = self._lcstyle.strokeWidth
- lc.useAbsolute = 1
- lc.groupSpacing = lc.width * 2.0 / len(self._catNames)
- lc.joinedLines = 1
- lc.lineLabelFormat = self._lcstyle.format[0]
-
- lc.valueAxis.valueMin, lc.valueAxis.valueMax, lc.valueAxis.valueSteps = self._value
- lc.valueAxis.labelTextFormat = self._lcstyle.format[1]
- lc.valueAxis.labels.fontSize = self._lcstyle.labelsfont
-
- lc.categoryAxis.categoryNames = self._catNames
- lc.categoryAxis.labels.boxAnchor = 'ne'
- lc.categoryAxis.labels.dx = lc.width / 2.0 / len(self._catNames)
- lc.categoryAxis.labels.dy = -6
- lc.categoryAxis.labels.angle = 10
- lc.categoryAxis.labels.fontSize = self._lcstyle.labelsfont
- # lc.categoryAxis.visibleGrid = 1
- # lc.categoryAxis.tickUp = 100
- # lc.categoryAxis.tickDown = 50
- # lc.categoryAxis.gridEnd = dh
- sytle_cnts = len(self._lcstyle.linestyle)
- color_paris = []
- for i in range(line_cnts):
- styleIndex = i % sytle_cnts
- lc.lines[i].strokeColor = self._lcstyle.linestyle[styleIndex][0]
- lc.lines[i].symbol = makeMarker(
- self._lcstyle.linestyle[styleIndex][1])
- lc.lines[i].strokeWidth = self._lcstyle.linestyle[styleIndex][2]
- color_paris.append(
- (self._lcstyle.linestyle[styleIndex][0], self._linename[i]))
-
- lc.lineLabels.fontSize = self._lcstyle.labelsfont - 2
-
- draw.add(lc)
-
- lg = Legend()
- lg.colorNamePairs = color_paris
- lg.fontName = 'Helvetica'
- lg.fontSize = 7
- # lg.x = dw /2
- # lg.y = self._lcstyle.bottom *(1.5 + lg_line)
-
- lg.x = self._lcstyle.left * 3
- lg.y = self._lcstyle.bottom * (1 + lg_line) + lc.height
-
- lg.dxTextSpace = 5
- lg.dy = 5
- lg.dx = 20
- lg.deltax = 60
- lg.deltay = 0
- lg.columnMaximum = 1
- lg.alignment = 'right'
- draw.add(lg)
- self._draw = draw
-
-
-class eBarChartColumn(object):
-
- def __init__(self, data, style):
- self._bcstyle = style
- if len(data) < 4:
- return
- self._data = self.analysisData(data)
- if self._data:
- self.create()
-
- @property
- def draw(self):
- return self._draw
-
- def analysisData(self, data):
- self._ytitle = data[0]
- self._name = data[1]
- self._bar = data[2]
- bar_data = data[3]
- result = []
- for bar in bar_data:
- bar = map(lambda x: float(x), bar)
- result.append(tuple(bar))
- return result
-
- def create(self):
- dw = self._bcstyle.width
- dh = self._bcstyle.height
- draw = Drawing(dw, dh)
-
- bc = VerticalBarChart()
- bar_cnt = len(self._bar)
- lg_line = (bar_cnt + 3) / 4
-
- bc.width = dw - self._bcstyle.left - self._bcstyle.right
- bc.height = dh - self._bcstyle.top - self._bcstyle.bottom
- if bar_cnt > 1:
- bc.height -= lg_line * 15
-
- bc.x = self._bcstyle.left
- bc.y = self._bcstyle.bottom
- color_paris = []
- for i in range(bar_cnt):
- bc.bars[i].fillColor = self._bcstyle.pillarstyle[self._bar[i]][0]
- color_paris.append(
- (self._bcstyle.pillarstyle[
- self._bar[i]][0],
- self._bar[i]))
-
- bc.fillColor = self._bcstyle.background
- bc.barLabels.fontName = 'Helvetica'
- bc.barLabelFormat = self._bcstyle.pillarstyle[self._bar[0]][1]
- bc.barLabels.fontSize = self._bcstyle.labelsfont
- bc.barLabels.dy = self._bcstyle.labelsfont
- bc.valueAxis.labels.fontName = 'Helvetica'
- bc.valueAxis.labels.fontSize = self._bcstyle.labelsfont
- bc.valueAxis.forceZero = 1
- bc.valueAxis.valueMin = 0
-
- bc.data = self._data
- bc.barSpacing = self._bcstyle.barSpacing
- bc.groupSpacing = self._bcstyle.groupSpacing / bar_cnt
- bc.valueAxis.avoidBoundFrac = 1
- bc.valueAxis.gridEnd = dw - self._bcstyle.right
- bc.valueAxis.tickLeft = self._bcstyle.tick
- bc.valueAxis.visibleGrid = 1
- bc.categoryAxis.categoryNames = self._name
- bc.categoryAxis.tickDown = self._bcstyle.tick
- bc.categoryAxis.labels.fontName = 'Helvetica'
- bc.categoryAxis.labels.fontSize = self._bcstyle.labelsfont
- bc.categoryAxis.labels.dy = -27
- bc.categoryAxis.labels.angle = -90
- draw.add(bc)
- lb = Label()
- lb.fontName = 'Helvetica'
- lb.fontSize = 7
- lb.x = 12
- lb.y = 80
- lb.angle = 90
- lb.textAnchor = 'middle'
- lb.maxWidth = 100
- lb.height = 20
- lb._text = self._ytitle
- draw.add(lb)
- if bar_cnt > 1:
- lg = Legend()
- lg.colorNamePairs = color_paris
- lg.fontName = 'Helvetica'
- lg.fontSize = 7
-
- lg.x = self._bcstyle.left + bc.width / (bar_cnt + 1)
- lg.y = dh - self._bcstyle.top - lg_line * 5
-
- lg.dxTextSpace = 5
- lg.dy = 5
- lg.dx = 25
- lg.deltax = 80
- lg.deltay = 0
- lg.columnMaximum = 1
- lg.alignment = 'right'
- draw.add(lg)
-
- self._draw = draw
-
-
-class eParagraph(object):
-
- def __init__(self, data, style):
- self._pstyle = style
- self._data = self.analysisData(data)
- self.create()
-
- def analysisData(self, data):
- result = ""
- for dstr in data:
- if self._pstyle.name == 'ps_body':
- # dstr = "<i>" + dstr + "</i><br/>"
- dstr = dstr + "<br/>"
- else:
- dstr = dstr + "<br/>"
- result += dstr
- return result
-
- def create(self):
- self._para = Paragraph(self._data, self._pstyle)
-
- @property
- def para(self):
- return self._para
Code Review / bottlenecks.git / blobdiff