def get_canvas(self, packet):
     canvas = super(AnswerSheetMask, self).get_canvas(packet)
     canvas.setStrokeColor(colors.black)
     canvas.setFillColor(colors.white)
     canvas.setLineWidth(0.2 * mm)
     canvas.setFont('Helvetica', 8)
     return canvas

 def draw_half_star (self, inner_length=1*inch, outer_length=2*inch, points=5, origin=None):
     canvas = self.canv
     canvas.setLineWidth(0)
     if not origin: canvas.translate(self.size*0.5,self.size*0.5)
     else: canvas.translate(*origin)
     canvas.setFillColor(self.fillcolor)
     canvas.setStrokeColor(self.strokecolor)
     p = canvas.beginPath()
     inner = False # Start on top
     is_origin = True
     #print 'Drawing star with radius',outer_length,'(moving origin ',origin,')'
     for theta in range(0,360,360/(points*2)):
         if 0 < theta < 180: continue
         if inner: r = inner_length
         else: r = outer_length
         x = (math.sin(math.radians(theta)) * r)
         y = (math.cos(math.radians(theta)) * r)
         #print 'POINT:',x,y
         if is_origin:
             p.moveTo(x,y)
             is_origin = False
         else:
             p.lineTo(x,y)
         inner = not inner
     p.close()
     canvas.drawPath(p,fill=1)

def printColors(canvas):  
    canvas.setFont("Helvetica",10)
    y = x = 0; dy=inch*1/2.0; dx=1*inch; w=h=dy/2  
    rdx=(dx-w)/2; rdy=h/5.0
    available_paper = 10*inch

    for name, color in colors.getAllNamedColors().iteritems():

    # for [namedcolor, name] in (  
        # 'darkseagreen', 'darkslateblue',
        #  [colors.darkblue, 'darkblue'],
        #  [colors.darkcyan, 'darkcyan'],
        #  [colors.darkolivegreen, 'darkolivegreen'],
        #  [colors.cornflower, 'cornflower'],
        #  [colors.orchid, 'orchid'],
        
        #  [colors.lavenderblush, "lavenderblush"],  
        #  [colors.lawngreen, "lawngreen"],  
        #  [colors.lemonchiffon, "lemonchiffon"],  
        #  [colors.lightblue, "lightblue"],  
        #  [colors.lightcoral, "lightcoral"]):  
        canvas.setFillColor(color)  
        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
        canvas.setFillColor(colors.black)  
        canvas.drawString(x+dx/4 + 1*inch, y+rdy, name)  
        rdy += .2*inch
        available_paper -= (y+rdy)
        if available_paper < 1*inch:
            c.showPage()
            y = x = 0; dy=inch*1/2.0; dx=1*inch; w=h=dy/2  
            rdx=(dx-w)/2; rdy=h/5.0
            available_paper = 10*inch

	def __applyCanvasOptions(self, canvas, opts):
		for opt in opts:
			if opt == 'fillColor':
				canvas.setFillColor(opts[opt])
			if opt == 'fontSize':
				canvas.setFontSize(opts[opt])
		return canvas

def orf_eus(canvas, featL, coords, color_hex, shape):
    """Draw CDS and write count."""
    xs, xe, xn, y0, yt, yb, ynt, ynb = coords
    canvas.setLineWidth(1)
    # initialize path
    pORF = canvas.beginPath()
    if shape == 'square':
        pORF.moveTo(xs,ynt)
        pORF.lineTo(xe,ynt)
        pORF.lineTo(xe,ynb)
        pORF.lineTo(xs,ynb)
        pORF.lineTo(xs,ynt)
    # draw triangle-shaped ORFS
    elif featL <= minL:
        pORF.moveTo(xs,yt)
        pORF.lineTo(xe,y0)
        pORF.lineTo(xs,yb)
        pORF.lineTo(xs,yt)
    # draw arrow-shaped ORFS
    else:
        pORF.moveTo(xs,ynt)
        pORF.lineTo(xn,ynt)
        pORF.lineTo(xn,yt)
        pORF.lineTo(xe,y0)
        pORF.lineTo(xn,yb)
        pORF.lineTo(xn,ynb)
        pORF.lineTo(xs,ynb)
        pORF.lineTo(xs,ynt)
    # evaluate function category and set fill color
    canvas.setFillColor(color_hex)
    # finalize object path
    canvas.drawPath(pORF, stroke=1, fill=1)
    pORF.close()
    canvas.setFillColor(black)

	def show(self, canvas, showframe=None):
		if self._border_width > 0.0:
			canvas.saveState()
			canvas.setStrokeColor(self._border_color)
			canvas.setLineWidth(self._border_width)
			if self._border_fill_color.lower() != 'none':
				canvas.setFillColor(self._border_fill_color)                        
			canvas.rect(self.x, 
						self.y, 
						self.width, 
						self.height, 
						stroke=self._border_type, 
						fill=self._fill_border_rect)
			canvas.restoreState()

		if self.flowable is not None:                  
			self.flowable.width = self.width-(2.0*self._padding[0])
			self.flowable.height = self.height-(2.0*self._padding[1])
			self.flowable.drawOn(canvas, self.x+self._padding[0], self.y-self._padding[1])

			if showframe is not None:
				canvas.saveState()
				canvas.setLineWidth(showframe[0])
				canvas.rect(self.x, self.y, self.width, self.height, stroke=1, fill=showframe[1])
				canvas.restoreState()

		return self

 def drawShape(self, canvas, controls, color):
     """Utlity to draw a closed shape through a list of control points;
     extends the previous proc"""
     canvas.setFillColor(color)
     p = canvas.beginPath()
     self.curveThrough(p, controls)
     p.close()
     canvas.drawPath(p, stroke=1, fill=1)

def addText(canvas,element,styles):
	for run in element.getElementsByTagName("sn:r"):
		if(len(run.getElementsByTagName("sn:t")) > 0):
			##TODO: support italic, bold and underlined text
			charStyle = styles["Character" + run.getAttributeNode("sn:rStyle").value]
			text=run.getElementsByTagName("sn:t")[0].firstChild.nodeValue
			canvas.setFont("Helvetica",charStyle.size)
			canvas.setFillColor(charStyle.color)
			canvas.drawString(40,810-charStyle.size,text)

 def draw_circle (self, x, y, r):
     # Test...
     canvas = self.canv
     canvas.setLineWidth(0)        
     canvas.setStrokeColor(colors.grey)
     canvas.setFillColor(colors.grey)        
     p = canvas.beginPath()
     p.circle(x,y,r)
     p.close()
     canvas.drawPath(p,fill=1)

    def drawBackground(self, canvas):
        underkant = 5.0/6.0 * inch
        # a4 format spec:
        # http://www.cl.cam.ac.uk/~mgk25/iso-paper.html
        # 210 x 297
        # faktura spek:
        # Norsk Standard Skjema F60-1
        # url: http://code.google.com/p/finfaktura/issues/detail?id=38
        canvas.saveState()
        canvas.setFillColor(yellow)

        # Yellow bits; skipping the receipt area.
        # Lag de gule feltene
        #canvas.rect(0*mm, 101*mm, 210*mm, 21*mm, stroke=0, fill=1)
        canvas.rect(0*mm, 33*mm, 210*mm, 9*mm, stroke=0, fill=1)
        canvas.rect(0*mm, 14*mm, 210*mm, 2*mm, stroke=0, fill=1)

        canvas.setFillColor(white)
        # Legg de hvite feltene oppå for "gjennomsiktighet"
        canvas.rect(80*mm, 103*mm, 36*mm, 9*mm, stroke=0, fill=1) # beløp
        canvas.rect(126*mm, 103*mm, 40*mm, 9*mm, stroke=0, fill=1) # betalerens kontonummer
        canvas.rect(170*mm, 103*mm, 31*mm, 9*mm, stroke=0, fill=1) # blankettnummer
        canvas.restoreState()

        # skillelinjer for KID
        canvas.lines([(9*mm, 16*mm, 9*mm, 30*mm), (80*mm, 16*mm, 80*mm, 30*mm)])
        # blankettnummer
        #canvas.setFont("Courier", 10)
        #blankettnr = "xxxxxxx"
        #canvas.drawString(173*mm, 105*mm, blankettnr)
        #canvas.drawString(173*mm, underkant, blankettnr)

        # Lag klammer for kontrollsiffer til sum.
        canvas.drawString(115*mm, underkant, "<")
        canvas.drawString(125*mm, underkant, ">")
        # Lag tekst som beskriver feltene.
        canvas.setFont("Helvetica-Bold", 6)
        canvas.drawString(15*mm, 98*mm, "Betalingsinformasjon")
        canvas.drawString(10*mm,30*mm,"Kundeidentifikasjon (KID)")
        canvas.drawString(82*mm,30*mm,"Kroner")
        canvas.drawString(107*mm,30*mm,"Øre")
        canvas.drawString(133*mm,30*mm,"Til konto")
        canvas.drawString(172*mm,30*mm,"Blankettnummer")
        canvas.drawString(150*mm,98*mm,"Betalings-")
        canvas.drawString(150*mm,95*mm,"frist")

        # Lag hjørneklammer rundt alle tekstfelt
        self.markField(canvas, 12*mm,64*mm, 86*mm, -21*mm, "Betalt av")
        self.markField(canvas, 110*mm,64*mm, 86*mm, -21*mm, "Betalt til")
        self.markField(canvas, 110*mm,89*mm, 86*mm, -19*mm, "Underskrift ved girering")
        self.markField(canvas, 166*mm,99*mm, 30*mm, -6*mm)    # Betalingsfrist.

        # Add the all-important "GIRO" text. It seems to do wonders for the recognition.
        canvas.setFont('Helvetica-Bold', 14)
        canvas.drawString(110*mm, 98*mm, "GIRO")

 def func(canvas, doc):
     width, height = letter
     margin = 0.66 * 72
     canvas.saveState()
     canvas.setFillColor('gray')
     #canvas.setFont('OpenSans',12)
     canvas.drawString(margin, height - margin, "CONFIDENTIAL")
     canvas.drawRightString(width - margin, height - margin, localtime(timezone.now()).strftime(date_format))
     if recipient:
         canvas.drawString(margin, margin, "Intended for: Title IX Coordinator %s" % recipient)
     canvas.restoreState()

 def render(self, canvas):
     if len(self.words) == 1:
         canvas.setFillColor(self.words[0]['color'])
         canvas.drawString(self.coords[0], self.coords[1], self.words[0]['txt'])
     elif len(self.words)>1:
         txt = canvas.beginText()
         txt.setTextOrigin(self.coords[0], self.coords[1])
         for elt in self.words:
             txt.setFillColor(elt['color'])
             txt.textOut(elt['txt'])
         canvas.drawText(txt)

 def render(self, canvas, context):
     canvas.rect(self.left_margin, self.bottom_margin,
                 self.box_width, self.box_height,
                 stroke=0, fill=1)
     canvas.setFillColor(colors.black)
     canvas.drawString(
         self.left_margin + 2 * mm, self.bottom_margin + 2 * mm,
         'ID: {}'.format(context['student']['id']))
     canvas.drawRightString(
         self.left_margin + self.box_width - 2 * mm,
         self.bottom_margin + 2 * mm,
         '(Seite {})'.format(context['page_num']))

def labeller(cName, cLen, canvas, Y_map) :
    """Label baselines with genome/contig name and size."""
    canvas.setFillColor(black)
    y0 = Y_map
    x0 = -pNsize                # retreat into the left margin to write out name and size
    y1 = y0 + ck_vsp/10         # bump name up a bit from BL level
    y2 = y0 - ck_vsp            # bump size down a bit from BL level
    pLenStr = str(float(cLen)/1000) # converts number to suitable form
    canvas.setFont(bFont,LfSize)
    canvas.drawString(x0,y1,cName)
    canvas.setFont(rFont,NfSize)
    canvas.drawString(x0,y2,pLenStr+' kb')

 def _add_registration_details(self, canvas):
     start_posn = self.start_posn
     reg_detail_dict = {t[0]:t[1] for t in REG_STATUS_OPTIONS}
     canvas.setFillColor(colors.blue)
     canvas.setFont('Helvetica', 10)
     canvas.drawString(0.5*inch, start_posn,
                       'Section D: Registration Details')
     canvas.setLineWidth(1)
     canvas.setFillColor(colors.black)
     canvas.rect(0.5*inch, start_posn-1.3*inch,
                 PAGE_WIDTH-inch, 1.2*inch)
     canvas.line(2.5*inch, start_posn-1.3*inch,
                 2.5*inch, start_posn-0.1*inch)
     canvas.drawString(0.7*inch, start_posn-0.3*inch,
                       'Registration Status:')
     canvas.drawString(2.7*inch, start_posn-0.3*inch,
                       reg_detail_dict[self.details['registration_status']])
     canvas.line(0.5*inch, start_posn-0.4*inch,
                 PAGE_WIDTH-0.5*inch, start_posn-0.4*inch)
     canvas.drawString(0.7*inch, start_posn-0.6*inch, 'Pre-Tax Price:')
     try:
         price = float(self.details['pre_tax_price'])
         gst, hst, qst, inv_total = self._calculate_tax_total(price)
         price = '${:0,.2f}'.format(price)
     except ValueError:
         if self.details['pre_tax_price'] == '':
             price = gst = hst = qst = inv_total = '$0.00'
         else:
             price = 'ERROR: Price Entered Incorrectly'
             gst = hst = qst = inv_total = '?????'
     canvas.drawString(2.7*inch, start_posn-0.6*inch, price)
     canvas.line(0.5*inch, start_posn-0.7*inch,
                 PAGE_WIDTH-0.5*inch, start_posn-0.7*inch)
     canvas.drawString(0.7*inch, start_posn-0.9*inch, 'Taxes:')
     tax_info = ''
     if self.event.gst_charged:
         tax_info += 'GST: ' + gst + ' / '
     if self.event.hst_charged:
         tax_info += 'HST: ' + hst + ' / '
     if self.event.qst_charged:
         tax_info += 'QST: ' + qst + ' / '
     if len(tax_info) > 0:
         tax_info = tax_info[:-3]
     else:
         tax_info = 'No tax charged'
     canvas.drawString(2.7*inch, start_posn-0.9*inch, tax_info)
     canvas.line(0.5*inch, start_posn-1.0*inch,
                 PAGE_WIDTH-0.5*inch, start_posn-1.0*inch)
     canvas.setFont('Helvetica-Bold', 10)
     canvas.drawString(0.7*inch, start_posn-1.2*inch, 'Total Invoice:')
     canvas.drawString(2.7*inch, start_posn-1.2*inch, inv_total)
     self.start_posn = start_posn - 1.55 * inch

	def printBandOutline(self, canvas, text):
		""" Draw a dotted rectangle around the entire band, and type a small faded
		caption at the origin of the band.
		"""
		canvas.saveState()
		canvas.setLineWidth(0.1)
		canvas.setStrokeColorRGB(0.8, 0.5, 0.7)
		canvas.setDash(1, 2)
		canvas.rect(self.x, self.y, self.width, self.height)
		canvas.setFont("Helvetica", 8)
		canvas.setFillColor((0.6, 0.8, 0.7))
		canvas.drawString(self.x, self.y, text)
		canvas.restoreState()

def drawCode(canvas, code):
    """Draws a block of text at current point, indented and in Courier"""
    canvas.addLiteral("36 0 Td")
    canvas.setFillColor(colors.blue)
    canvas.setFont("Courier", 10)

    t = canvas.beginText()
    t.textLines(code)
    c.drawText(t)

    canvas.setFillColor(colors.black)
    canvas.addLiteral("-36 0 Td")
    canvas.setFont("Times-Roman", 10)

 def func(canvas, doc):
     width, height = letter
     margin = 0.66 * 72
     canvas.saveState()
     canvas.setFillColor('gray')
     canvas.drawString(margin, height - margin, "CONFIDENTIAL")
     canvas.drawRightString(
         width - margin, height - margin, str(timezone.now()))
     canvas.drawString(
         margin, margin,
         f"Intended for: Title IX Coordinator {recipient}",
     )
     canvas.restoreState()

def encabezado(canvas,nro,copia=False):
     from reportlab.lib.colors import white, darkblue,black
     x=740

     canvas.setFillColor(darkblue)
     canvas.rect(30,x,85,60,fill=True,stroke=False)

     canvas.setFillColor(white)
     canvas.setStrokeColor(white)
     canvas.setFont("Helvetica-Bold", 35)
     canvas.drawString(40, x+25, "MIS")

     canvas.setFillColor(white)
     canvas.setStrokeColor(white)
     canvas.setFont("Helvetica-Bold", 12)
     canvas.drawString(37,x+10, "PARAGUAY")

     canvas.setFillColor(black)
     canvas.setStrokeColor(black)
     canvas.setFont("Helvetica-Bold", 11)
     canvas.drawString(130, x+47, "MIS Implants Paraguay")
     canvas.drawString(130, x+31, "América 192 c/ Mcal. López")
     canvas.drawString(130, x+15, "Tel.: +59521 21 213193")
     canvas.drawString(130, x+2, "www.misimplants.com.py")

     canvas.setFont("Helvetica-Bold", 18)
     canvas.drawString(350, x+17, "Nro. "+str(nro))

def colorsRGB(canvas):
    from reportlab.lib import colors
    from reportlab.lib.units import inch
    black = colors.black
    y = x = 0; dy=inch*3/4.0; dx=inch*5.5/5; w=h=dy/2; rdx=(dx-w)/2
    rdy=h/5.0; texty=h+2*rdy
    canvas.setFont("Helvetica",10)
    for [namedcolor, name] in (
            [colors.lavenderblush, "lavenderblush"],
            [colors.lawngreen, "lawngreen"],
            [colors.lemonchiffon, "lemonchiffon"],
            [colors.lightblue, "lightblue"],
            [colors.lightcoral, "lightcoral"]):
        canvas.setFillColor(namedcolor)
        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
        canvas.setFillColor(black)
        canvas.drawCentredString(x+dx/2, y+texty, name)
        x = x+dx
    y = y + dy; x = 0
    for rgb in [(1,0,0), (0,1,0), (0,0,1), (0.5,0.3,0.1), (0.4,0.5,0.3)]:
        r,g,b = rgb
        canvas.setFillColorRGB(r,g,b)
        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
        canvas.setFillColor(black)
        canvas.drawCentredString(x+dx/2, y+texty, "r%s g%s b%s"%rgb)
        x = x+dx
    y = y + dy; x = 0
    for gray in (0.0, 0.25, 0.50, 0.75, 1.0):
        canvas.setFillGray(gray)
        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
        canvas.setFillColor(black)
        canvas.drawCentredString(x+dx/2, y+texty, "gray: %s"%gray)
        x = x+dx