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 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 drawBounds(self, canvas):
     """Guidelines to help me draw - not needed in production"""
     canvas.setStrokeColor(colors.red)
     canvas.rect(-100,-70,200,140)
     canvas.line(-100,0,100,0)
     canvas.line(0,70,0,-70)
     canvas.setStrokeColor(colors.black)

 def myLaterPages(canvas, doc):
     from reportlab.lib.colors import red
     PAGE_HEIGHT = canvas._pagesize[1]
     canvas.saveState()
     canvas.setStrokeColor(red)
     canvas.setLineWidth(5)
     canvas.line(66,72,66,PAGE_HEIGHT-72)
     canvas.setFont('Times-Roman',12)
     canvas.drawString(4 * inch, 0.75 * inch, "Page %d" % doc.page)
     canvas.restoreState()

 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 myFirstPage(canvas, doc):
     from reportlab.lib.colors import red
     PAGE_HEIGHT = canvas._pagesize[1]
     canvas.saveState()
     canvas.setStrokeColor(red)
     canvas.setLineWidth(5)
     canvas.line(66,72,66,PAGE_HEIGHT-72)
     canvas.setFont('Times-Bold',24)
     canvas.drawString(108, PAGE_HEIGHT-108, "TABLE OF CONTENTS DEMO")
     canvas.setFont('Times-Roman',12)
     canvas.drawString(4 * inch, 0.75 * inch, "First Page")
     canvas.restoreState()

def firma_actasIntegrales(canvas, doc):
    ##########-------------------- Pie de Pagina del reporte ###########
    canvas.saveState()
    canvas.setStrokeColor(black)
    canvas.setFont("Helvetica-BoldOblique",6.5)
    canvas.drawString(2.7*inch, 2.37*cm, 'Firma y Sello Decanato')
    canvas.drawString(4.35*inch, 2.37*cm, 'Firma y Sello Coordinación')
    #canvas.drawString(9.3*cm, 2.37*cm, 'Profesor:')
    #canvas.drawString(15*cm, 2.37*cm, u'Cédula:')
    #canvas.drawString(11.3*cm, 1.0*cm, 'Firma')
    #canvas.drawString(15*cm, 1.0*cm, 'Fecha')
    canvas.grid([2.3*inch, 4.1*inch, 5.8*inch], [0.23*inch, 1.06*inch])
    canvas.restoreState()

def header(canvas, DOC, MAPHEADERTEXT):
    """Draws the page header"""
    arcpy.AddMessage("Drawing Header...")
    canvas.saveState()
    header_top_padding = 1*cm
    logo_image_height = 50
    logo_header_gap = 0.75*cm
    indent_right = 40
    docy = PAGE_HEIGHT-60

    style_header = getSampleStyleSheet()
    style_header.add(ParagraphStyle(name='BodyT', alignment=TA_LEFT,
                                    borderPadding=(5, 10, 10), fontName='Vera',
                                    fontSize=14, spaceAfter=6,
                                    backColor=Color(0, 0.2627450980392157,
                                                    0.42745098039215684, 1),
                                    textColor=Color(1, 1, 1, 1)))
    para = Paragraph(MAPHEADERTEXT, style_header["BodyT"])

    logo_image_width, imageheight = ImageReader(IMAGE).getSize()

    aspect_ratio = imageheight/(float(logo_image_width))
    reduceby = 0.1

    while logo_image_height <= imageheight:
        logo_image_width = logo_image_width - reduceby
        imageheight = logo_image_width*aspect_ratio
        reduceby += 0.1

    para_width_total, para_height = para.wrap(DOC.width + 0.70*inch
                                              - logo_image_width
                                              - logo_header_gap,
                                              DOC.topMargin + 0.5 *inch)

    logo_y = ((para_height + imageheight) / 2) + header_top_padding
    canvas.drawImage(ImageReader(IMAGE), indent_right, PAGE_HEIGHT-logo_y,
                     logo_image_width, imageheight, mask='auto')

    para_y = para_height + header_top_padding

    para.drawOn(canvas,
                (indent_right+ 0.1*cm + logo_image_width + logo_header_gap),
                (PAGE_HEIGHT - para_y))

    canvas.setLineWidth(1.0)
    canvas.setStrokeColor(Color(0, 0.2627450980392157, 0.42745098039215684, 1))
    canvas.line(indent_right, docy, (PAGE_WIDTH - indent_right), docy)
    canvas.restoreState()

 def drawOn(self, canvas, x, y, _sW=0):
     "Tell it to draw itself on the canvas.  Do not override"
     if _sW and hasattr(self,'hAlign'):
         a = self.hAlign
         if a in ['CENTER','CENTRE']:
             x = x + 0.5*_sW
         elif a == 'RIGHT':
             x = x + _sW
         elif a != 'LEFT':
             raise ValueError, "Bad hAlign value "+str(a)
     canvas.saveState()
     canvas.translate(x, y)
     self._drawOn(canvas)
     if hasattr(self, '_showBoundary') and self._showBoundary:
         #diagnostic tool support
         canvas.setStrokeColor(gray)
         canvas.rect(0,0,self.width, self.height)
     canvas.restoreState()

    def add(self, flowable, canvas, trySplit=0):
        result = Frame.add(self, flowable, canvas, trySplit=trySplit)
        if result == 0:
            return result
        
        # Slight hack: we're assuming that trySplit==0 iff this flowable
        # is an already-split portion of another flowable. So we don't want
        # to draw a line below it, since it's not the end of an entry.
        # This assumes that this frame's parent doctemplate allowSplitting
        # has not been changed from the default.
        if trySplit == 0:
            return result

        canvas.saveState()
        canvas.setStrokeColor(colors.gray)
        fudge = flowable.getSpaceAfter() / 2.0
        canvas.line(self._x, self._y + fudge, self._x + self.width, self._y + fudge)
        canvas.restoreState()
        return result

def footer(canvas, DOC):
    """Draws the page footer"""
    arcpy.AddMessage("Drawing Footer...")
    canvas.saveState()
    canvas.setFont("Vera", 7.5)

    text = MAPHEADERTEXT
    date_now = datetime.datetime.now()
    date_formatted = (str(time.strftime("%b")) + " " + str(date_now.day) +
                      ", " + str(date_now.year))
    canvas.drawRightString(DOC.width - (DOC.rightMargin-2.35*inch),
                           0.5*DOC.bottomMargin, date_formatted)
    canvas.setFillGray(0.70)
    canvas.drawString(DOC.leftMargin - 25, 0.5*DOC.bottomMargin, text)
    canvas.setLineWidth(2)
    canvas.setStrokeColor(Color(0, 0.2627450980392157, 0.42745098039215684, 1))
    pagex = 47.5
    pagey = 0.75*DOC.bottomMargin
    canvas.line(pagex, pagey, (PAGE_WIDTH - pagex), pagey)
    canvas.restoreState()

	def render(self, pagemgr):
		rendered = []
		frame = None
		canvas = None
		if pagemgr is not None:
			frame = pagemgr.getcurrentframe()
			canvas = pagemgr.getcanvas()                

		basestyle = self._baseelement.getstyle()
		border = basestyle.getattribute('border',float)
		color = basestyle.getattribute('color',str)

		pos_xy, r_xy = self._baseelement.getellipse()                
		canvas_height = canvas._pagesize[1]
		pos_y = canvas_height - pos_xy[1]

		canvas.saveState()
		canvas.setStrokeColor(color)
		canvas.setLineWidth(float(border))
		canvas.ellipse(pos_xy[0], pos_y, pos_xy[0]+r_xy[0], pos_y-r_xy[1])
		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 variousshapes(canvas):
    from reportlab.lib.units import inch
    inch = int(inch)
    canvas.setStrokeGray(0.5)
    canvas.grid(range(0,int(11*inch/2),int(inch/2)), range(0,int(7*inch/2),int(inch/2)))

    rectangeHieght = .5
    # % Favorable
    favorableXposition = inch
    favorableYposition = inch
    favorableRectWidth = 1*inch

    # Favorable Rect
    canvas.setStrokeColor(green)
    canvas.setFillColor(green)
    canvas.rect(favorableXposition,favorableYposition,favorableRectWidth,rectangeHieght*favorableYposition, fill=1)

    # % Favorable Text
    canvas.setFillColor(black)
    canvas.drawString(favorableXposition+(favorableXposition/2.5),favorableYposition+(favorableYposition/5), "11")

    # % Neutral
    neutralXposition = 2*inch
    neutralYposition = 1*inch
    neutralRectWidth = 1*inch

    # Neutral Rect
    canvas.setStrokeColor(yellow)
    canvas.setFillColor(yellow)
    canvas.rect(neutralXposition,neutralYposition,neutralRectWidth,rectangeHieght*inch, fill=1)

    # % Neutral Text
    canvas.setFillColor(black)
    canvas.drawString(neutralXposition+(neutralXposition/2.5),neutralYposition+(neutralYposition/5), "22")

    # % Unfavorable
    unfavorableXposition = 3*inch
    unfavorableYposition = 1*inch
    unfavorableRectWidth = 1*inch

    # Unfavorable Rect
    canvas.setStrokeColor(red)
    canvas.setFillColor(red)
    canvas.rect(unfavorableXposition,unfavorableYposition,unfavorableRectWidth,rectangeHieght*inch, fill=1)

    # Unfavorable Text
    canvas.setFillColor(black)
    canvas.drawString(unfavorableXposition+(unfavorableXposition/2.5),unfavorableYposition+(unfavorableYposition/5), "33")

def colors2(canvas): 
    from reportlab.lib.units import inch 
    
    x = 0; dx = 0.4*inch 
    for i in range(4): 
        for color in (colors.pink, colors.green, colors.brown): 
            canvas.setFillColor(color) 
            canvas.rect(x,0,dx,3*inch,stroke=0,fill=1) 
            x = x+dx 
    canvas.setFillColor(colors.white) 
    canvas.setStrokeColor(colors.white) 
    canvas.setFont("Helvetica-Bold", 85) 
    canvas.drawCentredString(2.75*inch, 1.3*inch, "OPEN") 
    return
    
    
    textobject = canvas.beginText() 
    textobject.setTextOrigin(inch, 2.5*inch) 
    textobject.setFont("Helvetica-Oblique", 14) 
    for line in lyrics: 
        textobject.textLine(line) 
    textobject.setFillGray(0.4) 
    textobject.textLines(''' 
    With many apologies to the Beach Boys 
    and anyone else who finds this objectionable 
    ''') 
    canvas.drawText(textobject) 
    
    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 cmyk in [(1,0,0,0), (0,1,0,0), (0,0,1,0), (0,0,0,1), (0,0,0,0)]: 
        c,m,y1,k = cmyk 
        canvas.setFillColorCMYK(c,m,y1,k) 
        canvas.rect(x+rdx, y+rdy, w, h, fill=1) 
        canvas.setFillColor(black) 
        canvas.drawCentredString(x+dx/2, y+texty, "c%s m%s y%s k%s"%cmyk) 
        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) 

def drawFirstPage(canvas, doc):
    canvas.saveState()

    # Title text
    tobj = canvas.beginText()
    tobj.setTextOrigin(doc.leftMargin, doc.pagesize[1]-doc.topMargin-24)
    tobj.setFont('Helvetica-Bold', 32)
    tobj.setLeading(22)
    firstr = '/'.join(doc.firs)
    tobj.textLine('NavPlot')
    tobj.setFont('Helvetica', 16)
    tobj.textLine('%s Navigation warnings for: %s' % (firstr, doc.dateStr))
    canvas.drawText(tobj)

    # Small print
    canvas.setFont('Helvetica', 10)
    canvas.drawString(doc.leftMargin, doc.bottomMargin,
        "IMPORTANT: Do not rely on this map - check NOTAM's from an official "\
        "source. Data "+UTF8_COPYRIGHT_SIGN+' '+doc.copyright_holder)

    # Clipping rectangle for the map
    path = canvas.beginPath()
    path.rect(doc.leftMargin, doc.bottomMargin+doc.bottomOffset, doc.mapwidth,
              doc.mapheight)
    canvas.clipPath(path)

    # Drawing style for the map
    canvas.setLineWidth(0.5)
    canvas.setFillColor(gray)

    # Draw the other map stuff. Coordinate file must be in mapinfo format.
    # Coast line from http://rimmer.ngdc.noaa.gov/mgg/coast/getcoast.html
    moveFlag = True
    path = canvas.beginPath()

    map_data = doc.map_data
    for lin in map_data.splitlines():
        if lin[0] != '#':
            lon, lat = map(float, lin.split('\t'))
            x, y = doc.latlon2xy(lat, lon)
            if moveFlag:
                path.moveTo(x, y)
                moveFlag = False
            else:
                path.lineTo(x, y)
        else:
            moveFlag = True
    canvas.setStrokeColor(darkgray)
    canvas.drawPath(path)

    # Draw some gliding sites
    canvas.setStrokeColor(gray)
    delta = 2.5*mm
    for gs in GLIDING_SITES:
        x, y = doc.latlon2xy(*GLIDING_SITES[gs])
        canvas.lines(((x, y+delta, x, y-delta), (x-delta, y, x+delta, y)))
        canvas.drawString(x+mm, y+mm, gs)

    # Draw NOTAM areas
    canvas.setStrokeColor(blue)
    canvas.setFillColor(black)
    canvas.setLineWidth(0.5)
    for n, notam in enumerate(doc.notams):
        x, y = doc.latlon2xy(notam[0], notam[1])
        radius = notam[2]/60.0*doc.scale
        canvas.circle(x, y, radius)
        if radius/mm < 3:
            x1 = x + radius/1.41 + mm/2
            y1 = y + radius/1.41 + mm/2
            canvas.line(x, y, x1, y1)
            canvas.drawString(x1, y1, str(n+1))
        else:
            canvas.drawCentredString(x, y-3, str(n+1))

    canvas.restoreState()

def render(canvas, bounding_box=False, pg=None):
    assert canvas._pagesize == pagesizes.A4

    # query setup
    query = (
        "SELECT othernames, surname, ticket_id, vip "
        "FROM tickets "
        "WHERE paid IS NOT NULL AND"
        "   printed IS NULL "
        "ORDER BY user_id, surname, othernames"
    )

    cur = pg.cursor(True)
    cur.execute(query)

    # constants
    start = (11.93 * units.mm, 24 * units.mm)
    size = (41 * units.mm, 17.5 * units.mm)
    delta = (48.35 * units.mm, 21.2 * units.mm)
    count = (4, 12)

    bar_height = size[1] / 4.0 - 1 * units.mm
    bar_width = 0.71 * units.mm

    coord_positions = [[start[n] + i * delta[n] for i in range(count[n])] for n in (0, 1)]

    ticket_types = {
        True: {"entry_time": "8:00pm", "type_string": "VIP"},
        False: {"entry_time": "8:30pm", "type_string": "Standard"},
    }

    # position iterator stuff
    positions = list(itertools.product(*coord_positions))
    pos_enum = itertools.cycle(range(len(positions)))

    # page counting
    per_page = count[0] * count[1]
    pages = cur.rowcount // per_page
    if cur.rowcount % per_page:
        pages += 1

    page = 0

    # util
    def centred_text(canvas, x, y, row, what):
        x_centre = x + size[0] / 2.0
        canvas.saveState()

        for font_size in range(12, 5, -1):
            canvas.setFontSize(font_size)
            if canvas.stringWidth(what) < size[0]:
                break
        else:
            print("Warning: text", what, "too wide")

        offset = row * size[1] / 4.0
        canvas.drawCentredString(x_centre, y + offset, what)
        canvas.restoreState()

    # go
    for pos_n, ticket in itertools.izip(pos_enum, cur):
        if pos_n == 0:
            if page != 0:
                canvas.showPage()

            page += 1

            footer = "Barcodes page {0} of {1}".format(page, pages)
            canvas.drawCentredString(pagesizes.A4[0] / 2.0, 20, footer)

        ticket.update(ticket_types[ticket["vip"]])
        name = "{othernames} {surname}".format(**ticket)
        barcode_value = "{ticket_id:04d}".format(**ticket)
        num_type = "{ticket_id:04d}      {type_string}".format(**ticket)
        entry_time = "Entry time: {entry_time}".format(**ticket)

        x, y = positions[pos_n]

        barcode = code128.Code128(barcode_value, barWidth=bar_width, barHeight=bar_height, quiet=False)
        x_offset = (size[0] - barcode.width) / 2
        if x_offset < 0:
            raise ValueError("barcode too wide")
        barcode.drawOn(canvas, x + x_offset, y + 2 * size[1] / 4.0)

        centred_text(canvas, x, y, 3, name)
        centred_text(canvas, x, y, 1, num_type)
        centred_text(canvas, x, y, 0, entry_time)

        if bounding_box:
            canvas.setStrokeColor(colors.red)
            canvas.rect(x, y, size[0], size[1], stroke=1, fill=0)
            canvas.setStrokeColor(colors.black)

    # last page
    canvas.showPage()

    # cleanup
    cur.close()

 def setShade(canvas, c):
     rlcolor = Color(c,c,c)
     canvas.setFillColor(rlcolor)
     canvas.setStrokeColor(rlcolor)