testsuites/vstf/vstf_scripts/vstf/controller/reporters/report/pdf/element.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10
  11 __doc__ = """
  12 it contains the base element for pdf
  13 eImage is used to draw picture on the pdf document
  14 eDataTable is used to draw table on the pdf document
  15 eGraphicsTable is used to draw plot on the pdf document
  16 eParagraph is used to draw text on the pdf document
  17 """
  18 from reportlab.platypus import Image, Table
  19 from reportlab.graphics.shapes import Drawing
  20 from reportlab.graphics.charts.lineplots import LinePlot
  21 from reportlab.graphics.charts.linecharts import HorizontalLineChart
  22 from reportlab.platypus.paragraph import Paragraph
  23 from reportlab.graphics.widgets.markers import makeMarker
  24 from reportlab.graphics.charts.legends import Legend
  25 from reportlab.graphics.charts.textlabels import Label
  26 from reportlab.graphics.charts.axes import XValueAxis
  27 from reportlab.graphics.shapes import Group
  28 from reportlab.graphics.charts.barcharts import VerticalBarChart
  29 from vstf.controller.reporters.report.pdf.styles import *
  30
  31
  32 class eImage(Image):
  33     """ an image(digital picture)which contains the function of auto zoom picture """
  34
  35     def __init__(
  36             self,
  37             filename,
  38             width=None,
  39             height=None,
  40             kind='direct',
  41             mask="auto",
  42             lazy=1,
  43             hAlign='CENTRE',
  44             vAlign='BOTTOM'):
  45         Image.__init__(self, filename, None, None, kind, mask, lazy)
  46         print height, width
  47         print self.drawHeight, self.drawWidth
  48         if self.drawWidth * height > self.drawHeight * width:
  49             self.drawHeight = width * self.drawHeight / self.drawWidth
  50             self.drawWidth = width
  51         else:
  52             self.drawWidth = height * self.drawWidth / self.drawHeight
  53             self.drawHeight = height
  54         self.hAlign = hAlign
  55         self.vAlign = vAlign
  56         print self.drawHeight, self.drawWidth
  57
  58
  59 class eTable(object):
  60     """ an abstract table class, which is contains the base functions to create table """
  61
  62     def __init__(self, data, style=TableStyle(name="default")):
  63         self._tablestyle = style
  64         self._table = []
  65         self._spin = False
  66         self._colWidths = None
  67         self._data = self.analysisData(data)
  68         if self._data:
  69             self.create()
  70
  71     def analysisData(self, data):
  72         raise NotImplementedError("abstract eTable")
  73
  74     def create(self):
  75         self._table = Table(self._data, style=self._style, splitByRow=1)
  76         self._table.hAlign = self._tablestyle.table_hAlign
  77         self._table.vAlign = self._tablestyle.table_vAlign
  78         self._table.colWidths = self._tablestyle.table_colWidths
  79         if self._spin or self._colWidths:
  80             self._table.colWidths = self._colWidths
  81         self._table.rowHeights = self._tablestyle.table_rowHeights
  82
  83     @property
  84     def table(self):
  85         return self._table
  86
  87
  88 class eCommonTable(eTable):
  89
  90     def analysisData(self, data):
  91         self._style = [
  92             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
  93             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
  94             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
  95             ('BOX', (0, 0), (-1, -1), 1.2, colors.black)
  96         ]
  97         return data
  98
  99
 100 class eConfigTable(eTable):
 101
 102     def analysisData(self, data):
 103         self._style = [
 104             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 105             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 106             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 107             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 108             ('SPAN', (2, 0), (3, 0)),
 109             ('SPAN', (2, 1), (3, 1)),
 110             ('SPAN', (2, 8), (3, 8)),
 111             ('SPAN', (2, 9), (3, 9)),
 112             ('SPAN', (2, 10), (3, 10)),
 113             ('SPAN', (0, 0), (0, 7)),
 114             ('SPAN', (0, 8), (0, 10)),
 115             ('SPAN', (0, 11), (0, 19)),
 116             ('SPAN', (1, 2), (1, 6)),
 117             ('SPAN', (1, 12), (1, 13)),
 118             ('SPAN', (1, 14), (1, 16)),
 119             ('SPAN', (1, 17), (1, 19)),
 120             ('SPAN', (2, 3), (2, 6))
 121         ]
 122         return data
 123
 124
 125 class eSummaryTable(eTable):
 126
 127     def analysisData(self, data):
 128         self._style = [
 129             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 130             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 131             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 132             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 133             ('SPAN', (0, 0), (0, 1)),
 134             ('SPAN', (1, 0), (4, 0)),
 135             ('SPAN', (5, 0), (-1, 0))
 136         ]
 137         return data
 138
 139
 140 class eGitInfoTable(eTable):
 141
 142     def analysisData(self, data):
 143         self._style = [
 144             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 145             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 146             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 147             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 148             ('SPAN', (0, 0), (0, 2)),
 149             ('SPAN', (0, 3), (0, 5)),
 150             ('SPAN', (0, 6), (0, 8))
 151         ]
 152         return data
 153
 154
 155 class eScenarioTable(eTable):
 156
 157     def analysisData(self, data):
 158         self._style = [
 159             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 160             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 161             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 162             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 163             ('ALIGN', (2, 1), (-1, -1), 'LEFT'),
 164             ('SPAN', (0, 1), (0, 6)),
 165             ('SPAN', (0, 7), (0, 12)),
 166             ('SPAN', (0, 13), (0, 16)),
 167             ('SPAN', (0, 17), (0, 20))
 168         ]
 169         return data
 170
 171
 172 class eOptionsTable(eTable):
 173
 174     def analysisData(self, data):
 175         self._style = [
 176             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 177             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 178             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 179             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 180             ('SPAN', (2, 0), (4, 0)),
 181             ('SPAN', (2, 1), (4, 1)),
 182             ('SPAN', (0, 0), (0, -1)),
 183             ('SPAN', (1, 2), (1, 16)),
 184             ('SPAN', (1, 17), (1, 19)),
 185             ('SPAN', (1, 20), (1, 22)),
 186             ('SPAN', (1, 23), (1, 24)),
 187             ('SPAN', (2, 2), (2, 4)),
 188             ('SPAN', (2, 5), (2, 12)),
 189             ('SPAN', (2, 13), (2, 16)),
 190             ('SPAN', (2, 17), (2, 19)),
 191             ('SPAN', (2, 20), (2, 22)),
 192             ('SPAN', (2, 23), (2, 24))
 193         ]
 194         return data
 195
 196
 197 class eProfileTable(eTable):
 198
 199     def analysisData(self, data):
 200         self._style = [
 201             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 202             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 203             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 204             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 205             ('SPAN', (0, 1), (0, -1)),
 206             ('SPAN', (1, 0), (2, 0)),
 207         ]
 208         return data
 209
 210
 211 class eDataTable(eTable):
 212
 213     def analysisData(self, data):
 214         result = data
 215         self._style = [
 216             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 217             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
 218             ('LEADING', (0, 0), (-1, -1), 18),
 219             ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
 220             ('BOX', (0, 0), (-1, -1), 1, colors.black),
 221             ('LINEBEFORE', (1, 0), (1, -1), 0.8, colors.black),
 222             # ('LINEBEFORE', (3, 0), (3, -1), 1, colors.black),
 223             # ('LINEBEFORE', (5, 0), (5, -1), 1, colors.black),
 224             ('LINEBELOW', (0, 0), (-1, 0), 0.8, colors.black),
 225             # ('SPAN', (0, 0), (0, 1)),
 226             # ('SPAN', (1, 0), (2, 0)),
 227             # ('SPAN', (3, 0), (4, 0))
 228         ]
 229         if self._spin is True:
 230             print "start spin"
 231             result = map(list, zip(*result))
 232             style = []
 233             for value in self._style:
 234                 value = list(value)
 235                 value[1] = (value[1][1], value[1][0])
 236                 value[2] = (value[2][1], value[2][0])
 237                 if value[0] == 'LINEBELOW':
 238                     value[0] = 'LINEAFTER'
 239                 elif value[0] == 'LINEBEFORE':
 240                     value[0] = 'LINEABOVE'
 241                 value = tuple(value)
 242                 style.append(value)
 243             self._style = style
 244         return result
 245
 246
 247 class eGraphicsTable(eTable):
 248
 249     def analysisData(self, data):
 250         self._style = [
 251             ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
 252             ('VALIGN', (0, 0), (-1, -1), 'MIDDLE')
 253         ]
 254         return data
 255
 256
 257 class noScaleXValueAxis(XValueAxis):
 258
 259     def __init__(self):
 260         XValueAxis.__init__(self)
 261
 262     def makeTickLabels(self):
 263         g = Group()
 264         if not self.visibleLabels:
 265             return g
 266
 267         f = self._labelTextFormat  # perhaps someone already set it
 268         if f is None:
 269             f = self.labelTextFormat or (self._allIntTicks() and '%.0f' or str)
 270         elif f is str and self._allIntTicks():
 271             f = '%.0f'
 272         elif hasattr(f, 'calcPlaces'):
 273             f.calcPlaces(self._tickValues)
 274         post = self.labelTextPostFormat
 275         scl = self.labelTextScale
 276         pos = [self._x, self._y]
 277         d = self._dataIndex
 278         pos[1 - d] = self._labelAxisPos()
 279         labels = self.labels
 280         if self.skipEndL != 'none':
 281             if self.isXAxis:
 282                 sk = self._x
 283             else:
 284                 sk = self._y
 285             if self.skipEndL == 'start':
 286                 sk = [sk]
 287             else:
 288                 sk = [sk, sk + self._length]
 289                 if self.skipEndL == 'end':
 290                     del sk[0]
 291         else:
 292             sk = []
 293
 294         nticks = len(self._tickValues)
 295         nticks1 = nticks - 1
 296         for i, tick in enumerate(self._tickValues):
 297             label = i - nticks
 298             if label in labels:
 299                 label = labels[label]
 300             else:
 301                 label = labels[i]
 302             if f and label.visible:
 303                 v = self.scale(i)
 304                 if sk:
 305                     for skv in sk:
 306                         if abs(skv - v) < 1e-6:
 307                             v = None
 308                             break
 309                 if v is not None:
 310                     if scl is not None:
 311                         t = tick * scl
 312                     else:
 313                         t = tick
 314                     if isinstance(f, str):
 315                         txt = f % t
 316                     elif isSeq(f):
 317                         # it's a list, use as many items as we get
 318                         if i < len(f):
 319                             txt = f[i]
 320                         else:
 321                             txt = ''
 322                     elif hasattr(f, '__call__'):
 323                         if isinstance(f, TickLabeller):
 324                             txt = f(self, t)
 325                         else:
 326                             txt = f(t)
 327                     else:
 328                         raise ValueError('Invalid labelTextFormat %s' % f)
 329                     if post:
 330                         txt = post % txt
 331                     pos[d] = v
 332                     label.setOrigin(*pos)
 333                     label.setText(txt)
 334
 335                     # special property to ensure a label doesn't project beyond
 336                     # the bounds of an x-axis
 337                     if self.keepTickLabelsInside:
 338                         if isinstance(
 339                                 self, XValueAxis):  # not done yet for y axes
 340                             a_x = self._x
 341                             if not i:  # first one
 342                                 x0, y0, x1, y1 = label.getBounds()
 343                                 if x0 < a_x:
 344                                     label = label.clone(dx=label.dx + a_x - x0)
 345                             if i == nticks1:  # final one
 346                                 a_x1 = a_x + self._length
 347                                 x0, y0, x1, y1 = label.getBounds()
 348                                 if x1 > a_x1:
 349                                     label = label.clone(
 350                                         dx=label.dx - x1 + a_x1)
 351                     g.add(label)
 352
 353         return g
 354
 355     def ___calcScaleFactor(self):
 356         """Calculate the axis' scale factor.
 357         This should be called only *after* the axis' range is set.
 358         Returns a number.
 359         """
 360         self._scaleFactor = self._length / (len(self._tickValues) + 1)
 361         return self._scaleFactor
 362
 363     def scale(self, value):
 364         """Converts a numeric value to a plotarea position.
 365         The chart first configures the axis, then asks it to
 366         """
 367         assert self._configured, "Axis cannot scale numbers before it is configured"
 368         if value is None:
 369             value = 0
 370         # this could be made more efficient by moving the definition of org and
 371         # sf into the configuration
 372         org = (self._x, self._y)[self._dataIndex]
 373         sf = self._length / (len(self._tickValues) + 1)
 374         if self.reverseDirection:
 375             sf = -sf
 376             org += self._length
 377         return org + sf * (value + 1)
 378
 379
 380 class noScaleLinePlot(LinePlot):
 381
 382     def __init__(self):
 383         LinePlot.__init__(self)
 384         self.xValueAxis = noScaleXValueAxis()
 385
 386     def calcPositions(self):
 387         """Works out where they go.
 388
 389         Sets an attribute _positions which is a list of
 390         lists of (x, y) matching the data.
 391         """
 392         self._seriesCount = len(self.data)
 393         self._rowLength = max(map(len, self.data))
 394
 395         self._positions = []
 396         for rowNo in range(len(self.data)):
 397             line = []
 398             len_row = len(self.data[rowNo])
 399             for colNo in range(len_row):
 400                 datum = self.data[rowNo][colNo]  # x, y value
 401                 x = self.x + self.width / (len_row + 1) * (colNo + 1)
 402                 self.xValueAxis.labels[colNo].x = self.x + \
 403                     self.width / (len_row + 1) * (colNo + 1)
 404                 y = self.yValueAxis.scale(datum[1])
 405                 #               print self.width, " ", x
 406                 line.append((x, y))
 407             self._positions.append(line)
 408
 409
 410 # def _innerDrawLabel(self, rowNo, colNo, x, y):
 411 #        return None
 412 class eLinePlot(object):
 413
 414     def __init__(self, data, style):
 415         self._lpstyle = style
 416         self._linename = data[0]
 417         self._data = self.analysisData(data[1:])
 418         if self._data:
 419             self.create()
 420
 421     @property
 422     def draw(self):
 423         return self._draw
 424
 425     def analysisData(self, data):
 426         columns = len(data)
 427         # print data
 428         data = map(list, zip(*data))
 429         rows = len(data)
 430
 431         for i in range(rows):
 432             for j in range(columns):
 433                 data[i][j] = float(data[i][j])
 434         self._linename = self._linename[1:]
 435         """
 436         delcnt = 0
 437         delrows = []
 438         for i in range(columns):
 439             delrows.append(0.0)
 440         del_line = [self._linename[0]]
 441         for i in range(rows):
 442            for j in range(columns):
 443               data[i][j] = float(data[i][j])
 444            if data[i] == delrows:
 445                delcnt += 1
 446                del_line.append(self._linename[i])
 447         for i in range(delcnt):
 448             data.remove(delrows)
 449         for name in del_line:
 450             self._linename.remove(name)
 451
 452         rows = len(data)
 453         """
 454         # print rows
 455         # print data
 456         xvalueSteps = data[0]
 457         xvalueMin = data[0][0]
 458         xvalueMax = data[0][0]
 459         yvalueMin = data[1][0]
 460         yvalueMax = data[1][0]
 461         yvalueSteps = []
 462         result = []
 463         for j in range(columns):
 464             if xvalueMin > data[0][j]:
 465                 xvalueMin = data[0][j]
 466             if xvalueMax < data[0][j]:
 467                 xvalueMax = data[0][j]
 468
 469         for i in range(rows - 1):
 470             lst = []
 471             for j in range(columns):
 472                 lst.append((data[0][j], data[i + 1][j]))
 473                 if yvalueMin > data[i + 1][j]:
 474                     yvalueMin = data[i + 1][j]
 475                 if yvalueMax < data[i + 1][j]:
 476                     yvalueMax = data[i + 1][j]
 477                 yvalueSteps.append(int(data[i + 1][j] * 2.5) / 2.5)
 478             result.append(tuple(lst))
 479         xvalueMin = int(xvalueMin) / 100 * 100
 480         xvalueMax = int(xvalueMax) / 100 * 100 + 200
 481         yvalueMin = int(yvalueMin) * 1.0 - 1
 482         if yvalueMin < 0:
 483             yvalueMin = 0.0
 484         yvalueMax = int(yvalueMax) + 2.0
 485         yvalueSteps.append(yvalueMin)
 486         yvalueSteps.append(yvalueMax)
 487         yvalueSteps = {}.fromkeys(yvalueSteps).keys()
 488
 489         self._xvalue = (xvalueMin, xvalueMax, xvalueSteps)
 490         self._yvalue = (yvalueMin, yvalueMax, yvalueSteps)
 491         print result
 492         return result
 493
 494     def create(self):
 495         lpw = self._lpstyle.width
 496         lph = self._lpstyle.height
 497         draw = Drawing(lpw, lph)
 498         line_cnts = len(self._linename)
 499         #        lp = noScaleLinePlot()
 500         lp = LinePlot()
 501         lg_line = (line_cnts + 3) / 4
 502         lp.x = self._lpstyle.left
 503         lp.y = self._lpstyle.bottom
 504
 505         lp.height = lph - self._lpstyle.bottom * (lg_line + 1.5)
 506         lp.width = lpw - lp.x * 2
 507         lp.data = self._data
 508         lp.joinedLines = 1
 509         lp.strokeWidth = self._lpstyle.strokeWidth
 510         line_cnts = len(self._data)
 511         sytle_cnts = len(self._lpstyle.linestyle)
 512         color_paris = []
 513         for i in range(line_cnts):
 514             styleIndex = i % sytle_cnts
 515             lp.lines[i].strokeColor = self._lpstyle.linestyle[styleIndex][0]
 516             lp.lines[i].symbol = makeMarker(
 517                 self._lpstyle.linestyle[styleIndex][1])
 518             lp.lines[i].strokeWidth = self._lpstyle.linestyle[styleIndex][2]
 519             color_paris.append(
 520                 (self._lpstyle.linestyle[styleIndex][0], self._linename[i]))
 521         #            lp.lineLabels[i].strokeColor = self._lpstyle.linestyle[styleIndex][0]
 522
 523         lp.lineLabelFormat = self._lpstyle.format[0]
 524
 525         lp.strokeColor = self._lpstyle.strokeColor
 526
 527         lp.xValueAxis.valueMin, lp.xValueAxis.valueMax, lp.xValueAxis.valueSteps = self._xvalue
 528         #       valueMin, valueMax, xvalueSteps = self._xvalue
 529         #       lp.xValueAxis.valueStep = (lp.xValueAxis.valueMax - lp.xValueAxis.valueMin)/len(xvalueSteps)
 530         #       lp.xValueAxis.valueSteps = map(lambda x: str(x), xvalueSteps)
 531
 532         lp.yValueAxis.valueMin, lp.yValueAxis.valueMax, lp.yValueAxis.valueSteps = self._yvalue
 533
 534         #       lp.xValueAxis.forceZero = 0
 535         #       lp.xValueAxis.avoidBoundFrac = 1
 536         #       lp.xValueAxis.tickDown = 3
 537         #       lp.xValueAxis.visibleGrid = 1
 538         #       lp.xValueAxis.categoryNames = '64 256 512 1400 1500 4096'.split(' ')
 539
 540         lp.xValueAxis.labelTextFormat = self._lpstyle.format[1]
 541         lp.yValueAxis.labelTextFormat = self._lpstyle.format[2]
 542
 543         delsize = int(lp.xValueAxis.valueMax / 2000)
 544         lp.xValueAxis.labels.fontSize = self._lpstyle.labelsfont
 545         lp.xValueAxis.labels.angle = 25
 546
 547         lp.yValueAxis.labels.fontSize = self._lpstyle.labelsfont
 548         lp.lineLabels.fontSize = self._lpstyle.labelsfont - delsize
 549         draw.add(lp)
 550
 551         lg = Legend()
 552         lg.colorNamePairs = color_paris
 553         lg.fontName = 'Helvetica'
 554         lg.fontSize = 7
 555
 556         lg.x = self._lpstyle.left * 3
 557         lg.y = self._lpstyle.bottom * (1 + lg_line) + lp.height
 558
 559         lg.dxTextSpace = 5
 560         lg.dy = 5
 561         lg.dx = 20
 562         lg.deltax = 60
 563         lg.deltay = 0
 564         lg.columnMaximum = 1
 565         lg.alignment = 'right'
 566         draw.add(lg)
 567         self._draw = draw
 568
 569
 570 class eHorizontalLineChart(object):
 571
 572     def __init__(self, data, style):
 573         self._lcstyle = style
 574         if len(data) < 1:
 575             return
 576         self._linename = data[0]
 577         self._data = self.analysisData(data[1:])
 578         if self._data:
 579             self.create()
 580
 581     @property
 582     def draw(self):
 583         return self._draw
 584
 585     def analysisData(self, data):
 586         columns = len(data)
 587         data = map(list, zip(*data))
 588         self._catNames = data[0]
 589         self._linename = self._linename[1:]
 590         data = data[1:]
 591         rows = len(data)
 592
 593         yvalueMin = float(data[0][0])
 594         yvalueMax = float(data[0][0])
 595         yvalueSteps = []
 596         result = []
 597
 598         for rowNo in range(rows):
 599             for columnNo in range(columns):
 600                 data[rowNo][columnNo] = float(data[rowNo][columnNo])
 601                 if yvalueMin > data[rowNo][columnNo]:
 602                     yvalueMin = data[rowNo][columnNo]
 603                 if yvalueMax < data[rowNo][columnNo]:
 604                     yvalueMax = data[rowNo][columnNo]
 605                 yvalueSteps.append(int(data[rowNo][columnNo] * 1.0) / 1.0)
 606             result.append(tuple(data[rowNo]))
 607
 608         yvalueMin = int(yvalueMin) * 1.0 - 1
 609         if yvalueMin < 0:
 610             yvalueMin = 0.0
 611         yvalueMax = int(yvalueMax) + 2.0
 612         yvalueSteps.append(yvalueMin)
 613         yvalueSteps.append(yvalueMax)
 614         yvalueSteps = {}.fromkeys(yvalueSteps).keys()
 615
 616         self._value = (yvalueMin, yvalueMax, yvalueSteps)
 617         print result
 618         return result
 619
 620     def create(self):
 621         dw = self._lcstyle.width
 622         dh = self._lcstyle.height
 623         draw = Drawing(dw, dh)
 624
 625         lc = HorizontalLineChart()
 626         line_cnts = len(self._linename)
 627
 628         lg_line = (line_cnts + 3) / 4
 629         lc.height = dh - self._lcstyle.bottom * (lg_line + 1.5)
 630         lc.width = dw - lc.x * 2
 631         lc.x = self._lcstyle.left
 632         lc.y = self._lcstyle.bottom
 633
 634         lc.data = self._data
 635
 636         lc.strokeColor = self._lcstyle.strokeColor
 637         lc.strokeWidth = self._lcstyle.strokeWidth
 638         lc.useAbsolute = 1
 639         lc.groupSpacing = lc.width * 2.0 / len(self._catNames)
 640         lc.joinedLines = 1
 641         lc.lineLabelFormat = self._lcstyle.format[0]
 642
 643         lc.valueAxis.valueMin, lc.valueAxis.valueMax, lc.valueAxis.valueSteps = self._value
 644         lc.valueAxis.labelTextFormat = self._lcstyle.format[1]
 645         lc.valueAxis.labels.fontSize = self._lcstyle.labelsfont
 646
 647         lc.categoryAxis.categoryNames = self._catNames
 648         lc.categoryAxis.labels.boxAnchor = 'ne'
 649         lc.categoryAxis.labels.dx = lc.width / 2.0 / len(self._catNames)
 650         lc.categoryAxis.labels.dy = -6
 651         lc.categoryAxis.labels.angle = 10
 652         lc.categoryAxis.labels.fontSize = self._lcstyle.labelsfont
 653         #        lc.categoryAxis.visibleGrid = 1
 654         #        lc.categoryAxis.tickUp = 100
 655         #        lc.categoryAxis.tickDown = 50
 656         #        lc.categoryAxis.gridEnd = dh
 657         sytle_cnts = len(self._lcstyle.linestyle)
 658         color_paris = []
 659         for i in range(line_cnts):
 660             styleIndex = i % sytle_cnts
 661             lc.lines[i].strokeColor = self._lcstyle.linestyle[styleIndex][0]
 662             lc.lines[i].symbol = makeMarker(
 663                 self._lcstyle.linestyle[styleIndex][1])
 664             lc.lines[i].strokeWidth = self._lcstyle.linestyle[styleIndex][2]
 665             color_paris.append(
 666                 (self._lcstyle.linestyle[styleIndex][0], self._linename[i]))
 667
 668         lc.lineLabels.fontSize = self._lcstyle.labelsfont - 2
 669
 670         draw.add(lc)
 671
 672         lg = Legend()
 673         lg.colorNamePairs = color_paris
 674         lg.fontName = 'Helvetica'
 675         lg.fontSize = 7
 676         #        lg.x = dw /2
 677         #        lg.y = self._lcstyle.bottom *(1.5 + lg_line)
 678
 679         lg.x = self._lcstyle.left * 3
 680         lg.y = self._lcstyle.bottom * (1 + lg_line) + lc.height
 681
 682         lg.dxTextSpace = 5
 683         lg.dy = 5
 684         lg.dx = 20
 685         lg.deltax = 60
 686         lg.deltay = 0
 687         lg.columnMaximum = 1
 688         lg.alignment = 'right'
 689         draw.add(lg)
 690         self._draw = draw
 691
 692
 693 class eBarChartColumn(object):
 694
 695     def __init__(self, data, style):
 696         self._bcstyle = style
 697         if len(data) < 4:
 698             return
 699         self._data = self.analysisData(data)
 700         if self._data:
 701             self.create()
 702
 703     @property
 704     def draw(self):
 705         return self._draw
 706
 707     def analysisData(self, data):
 708         self._ytitle = data[0]
 709         self._name = data[1]
 710         self._bar = data[2]
 711         bar_data = data[3]
 712         result = []
 713         for bar in bar_data:
 714             bar = map(lambda x: float(x), bar)
 715             result.append(tuple(bar))
 716         return result
 717
 718     def create(self):
 719         dw = self._bcstyle.width
 720         dh = self._bcstyle.height
 721         draw = Drawing(dw, dh)
 722
 723         bc = VerticalBarChart()
 724         bar_cnt = len(self._bar)
 725         lg_line = (bar_cnt + 3) / 4
 726
 727         bc.width = dw - self._bcstyle.left - self._bcstyle.right
 728         bc.height = dh - self._bcstyle.top - self._bcstyle.bottom
 729         if bar_cnt > 1:
 730             bc.height -= lg_line * 15
 731
 732         bc.x = self._bcstyle.left
 733         bc.y = self._bcstyle.bottom
 734         color_paris = []
 735         for i in range(bar_cnt):
 736             bc.bars[i].fillColor = self._bcstyle.pillarstyle[self._bar[i]][0]
 737             color_paris.append(
 738                 (self._bcstyle.pillarstyle[
 739                     self._bar[i]][0],
 740                     self._bar[i]))
 741
 742         bc.fillColor = self._bcstyle.background
 743         bc.barLabels.fontName = 'Helvetica'
 744         bc.barLabelFormat = self._bcstyle.pillarstyle[self._bar[0]][1]
 745         bc.barLabels.fontSize = self._bcstyle.labelsfont
 746         bc.barLabels.dy = self._bcstyle.labelsfont
 747         bc.valueAxis.labels.fontName = 'Helvetica'
 748         bc.valueAxis.labels.fontSize = self._bcstyle.labelsfont
 749         bc.valueAxis.forceZero = 1
 750         bc.valueAxis.valueMin = 0
 751
 752         bc.data = self._data
 753         bc.barSpacing = self._bcstyle.barSpacing
 754         bc.groupSpacing = self._bcstyle.groupSpacing / bar_cnt
 755         bc.valueAxis.avoidBoundFrac = 1
 756         bc.valueAxis.gridEnd = dw - self._bcstyle.right
 757         bc.valueAxis.tickLeft = self._bcstyle.tick
 758         bc.valueAxis.visibleGrid = 1
 759         bc.categoryAxis.categoryNames = self._name
 760         bc.categoryAxis.tickDown = self._bcstyle.tick
 761         bc.categoryAxis.labels.fontName = 'Helvetica'
 762         bc.categoryAxis.labels.fontSize = self._bcstyle.labelsfont
 763         bc.categoryAxis.labels.dy = -27
 764         bc.categoryAxis.labels.angle = -90
 765         draw.add(bc)
 766         lb = Label()
 767         lb.fontName = 'Helvetica'
 768         lb.fontSize = 7
 769         lb.x = 12
 770         lb.y = 80
 771         lb.angle = 90
 772         lb.textAnchor = 'middle'
 773         lb.maxWidth = 100
 774         lb.height = 20
 775         lb._text = self._ytitle
 776         draw.add(lb)
 777         if bar_cnt > 1:
 778             lg = Legend()
 779             lg.colorNamePairs = color_paris
 780             lg.fontName = 'Helvetica'
 781             lg.fontSize = 7
 782
 783             lg.x = self._bcstyle.left + bc.width / (bar_cnt + 1)
 784             lg.y = dh - self._bcstyle.top - lg_line * 5
 785
 786             lg.dxTextSpace = 5
 787             lg.dy = 5
 788             lg.dx = 25
 789             lg.deltax = 80
 790             lg.deltay = 0
 791             lg.columnMaximum = 1
 792             lg.alignment = 'right'
 793             draw.add(lg)
 794
 795         self._draw = draw
 796
 797
 798 class eParagraph(object):
 799
 800     def __init__(self, data, style):
 801         self._pstyle = style
 802         self._data = self.analysisData(data)
 803         self.create()
 804
 805     def analysisData(self, data):
 806         result = ""
 807         for dstr in data:
 808             if self._pstyle.name == 'ps_body':
 809                 #               dstr = "<i>" + dstr + "</i><br/>"
 810                 dstr = dstr + "<br/>"
 811             else:
 812                 dstr = dstr + "<br/>"
 813             result += dstr
 814         return result
 815
 816     def create(self):
 817         self._para = Paragraph(self._data, self._pstyle)
 818
 819     @property
 820     def para(self):
 821         return self._para