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 create_report():
    from reportlab.lib.pagesizes import letter
    from reportlab.pdfgen import canvas

    width, height = letter

    canvas = canvas.Canvas("form.pdf", pagesize=letter)

    canvas.setLineWidth(.3)
    canvas.setFont('Helvetica', 10)

    canvas.drawString(30, 750, 'OFFICIAL COMMUNIQUE')
    canvas.drawString(30, 735, 'OF ACME INDUSTRIES')
    canvas.drawString(500, 750, "12/12/2010")
    canvas.line(480, 747, 580, 747)

    canvas.drawString(275, 725, 'AMOUNT OWED:')
    canvas.drawString(500, 725, "$1,000.00")
    canvas.line(378, 723, 580, 723)

    canvas.drawString(30, 703, 'RECEIVED BY:')
    canvas.line(110, 700, 580, 700)
    canvas.drawString(110, 703, "JOHN DOE")

    canvas.save()

    def confidential(self, canvas):
        canvas.saveState()

        canvas.translate(18.5*cm, 27.4*cm)

        canvas.setLineWidth(3)
        canvas.setFillColorRGB(1, 0, 0)
        canvas.setStrokeGray(0.5)

        p = canvas.beginPath()
        p.moveTo(10, 0)
        p.lineTo(20, 10)
        p.lineTo(30, 0)
        p.lineTo(40, 10)
        p.lineTo(30, 20)
        p.lineTo(40, 30)
        p.lineTo(30, 40)
        p.lineTo(20, 30)
        p.lineTo(10, 40)
        p.lineTo(0, 30)
        p.lineTo(10, 20)
        p.lineTo(0, 10)

        canvas.drawPath(p, fill=1, stroke=0)

        canvas.restoreState()

    def write_pdf(self, canvas):
        canvas.setFont("Helvetica", 70)
        if self.show_title:
            canvas.drawString(70, 70, self.title)

        canvas.setFont("Helvetica", SUDOKU_FONT_SIZE)
        sudoku_offset = SUDOKU_PDF_OFFSET
        xlist = [sudoku_offset[0] + j *
                 (2 * SUDOKU_XPAD + SUDOKU_FONT_SIZE) for j in range(0, 9 + 1)]
        ylist = [sudoku_offset[1] + j *
                 (2 * SUDOKU_YPAD + SUDOKU_FONT_SIZE) for j in range(0, 9 + 1)]
        canvas.grid(xlist, ylist)
        for x in range(0, 9):
            for y in range(0, 9):
                if self.sudoku.mat[y][x] != UNKNOWN:
                    canvas.drawString(
                        sudoku_offset[0] +
                        (SUDOKU_FONT_SIZE + SUDOKU_XPAD) // 2 +
                        x * (2 * SUDOKU_XPAD + SUDOKU_FONT_SIZE) - 4,
                        sudoku_offset[1] + SUDOKU_FONT_SIZE +
                        y * (2 * SUDOKU_YPAD + SUDOKU_FONT_SIZE),
                        str(self.sudoku.mat[y][x])
                    )

        if self.show_page_number:
            canvas.setFont("Helvetica", 10)
            canvas.drawString(280, 800, str(self.page_number))

        # draw a cell
        canvas.setLineWidth(3)
        canvas.grid(xlist[::3], ylist[::3])

 def draw(self, pmlOp, pageNr, canvas, pe):
     canvas.setLineWidth(pe.mm2points(pmlOp.width))
     path = canvas.beginPath()
     path.arc( pe.x(pmlOp.x - pmlOp.radius), pe.y(pmlOp.y - pmlOp.radius),
            pe.x(pmlOp.x + pmlOp.radius), pe.y(pmlOp.y + pmlOp.radius),
            startAng=pmlOp.startAngle, extent=90)
     canvas.drawPath(path)

def ref_ticker(canvas, feature, cLen, Y0, nudge, offset):
    """Draw contig separators."""
    # get contig name
    name = feature.qualifiers.get('id')[0]
    # take start and end points
    location = feature.location
    Zs = location.nofuzzy_start
    Ze = location.nofuzzy_end
    # calculate loop offset coordinates
    loop_offZs = offset_coord(Zs, cLen, offset)
    loop_offZe = offset_coord(Ze, cLen, offset)
    # calculate nudge offset coordinates
    offZs = nudge_coord(loop_offZs, nudge)
    offZe = nudge_coord(loop_offZe, nudge)
    xs, xe = offZs*u, offZe*u
    xmid = (xe+xs)/2
    # set Y axis coordinates
    y0 = Y0+dop*3
    # draw
    canvas.setLineWidth(2)
    ttl = canvas.beginPath()
    ttl.moveTo(xs,y0+w)
    ttl.lineTo(xs,y0+w+h*2)
    ttl.lineTo(xe,y0+w+h*2)
    ttl.lineTo(xe,y0+w)
    canvas.drawPath(ttl, stroke=1, fill=0)
    canvas.setFont(bFont, NfSize)
    canvas.drawCentredString(xmid, y0+h*5, name)
    canvas.setFont(rFont, NfSize)
    ttl.close()

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 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 contig_ticker(canvas, feature, cLen, Y0, offset, offset_mode):
    """Draw contig separators."""
    # get contig name
    name = feature.qualifiers.get('id')[0]
    # take start and end points
    location = feature.location
    Zs = location.nofuzzy_start
    Ze = location.nofuzzy_end
    # calculate offset coordinates
    if offset_mode == 'loop':
        offZs = offset_coord(Zs, cLen, offset)
        offZe = offset_coord(Ze, cLen, offset)
    elif offset_mode == 'nudge':
        offZs = nudge_coord(Zs, offset)
        offZe = nudge_coord(Ze, offset)
    else:
        offZs = Zs
        offZe = Ze
    xs, xe = offZs*u, offZe*u
    # set Y axis coordinates
    y0 = Y0-dop*3.5
    # draw
    canvas.setLineWidth(2)
    ttl = canvas.beginPath()
    ttl.moveTo(xs,y0)
    ttl.lineTo(xs,y0-h*4)
    ttl.lineTo(xs+dop,y0-h*4)
    canvas.drawPath(ttl, stroke=1, fill=0)
    canvas.setFont(bFont, NfSize)
    canvas.drawString(xs+dop*2, y0-h*4.5, name)
    canvas.setFont(rFont, SfSize)
    canvas.drawString(xs+dop*2,y0-h*8,"".join(["[",str(Zs),"-",str(Ze),"]"]))
    canvas.setFont(rFont, NfSize)
    ttl.close()

    def __init__(self, pt_ID, amount):
	self.amount = amount
	self.pt_ID = pt_ID
	from reportlab.lib.pagesizes import letter
	from reportlab.pdfgen import canvas
	
	canvas = canvas.Canvas("/home/mb/Desktop/GECKO/EMR_outputs/%s/Other/rcpt-%s.pdf" % \
						(self.pt_ID, EMR_utilities.dateToday()), pagesize=letter)
	canvas.setLineWidth(.3)
	canvas.setFont('Helvetica', 12)
 
	canvas.drawString(30,750,'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
	canvas.drawString(30,735,'RENDERED AT BARRON FAMILY MEDICINE')
	canvas.drawString(500,750,"%s" % EMR_utilities.dateToday())
	canvas.line(480,747,580,747)
 
	canvas.drawString(275,725,'AMOUNT PAID:')
	canvas.drawString(500,725,"$%s" % self.amount)
	canvas.line(378,723,580,723)
 
	canvas.drawString(30,703,'RECEIVED BY:')
	canvas.line(120,700,580,700)
	canvas.drawString(120,703,"MICHAEL BARRON MD")
 
	canvas.save()

 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 __init__(self, pt_ID, amount):
	self.amount = amount
	self.pt_ID = pt_ID
	from reportlab.lib.pagesizes import letter
	from reportlab.pdfgen import canvas
	
	lt = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (settings.LINUXPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
	at = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (settings.APPLEPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
	wt = "%s\EMR_outputs\%s\Other\rcpt-%s.pdf" % (settings.WINPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
	filename = EMR_utilities.platformText(lt, at, wt)
	canvas = canvas.Canvas(filename, pagesize=letter)
	canvas.setLineWidth(.3)
	canvas.setFont('Helvetica', 12)
 
	canvas.drawString(30,750,'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
	canvas.drawString(30,735,'RENDERED AT BARRON FAMILY MEDICINE')
	canvas.drawString(500,750,"%s" % EMR_utilities.dateToday())
	canvas.line(480,747,580,747)
 
	canvas.drawString(275,725,'AMOUNT PAID:')
	canvas.drawString(500,725,"$%s" % self.amount)
	canvas.line(378,723,580,723)
 
	canvas.drawString(30,703,'RECEIVED BY:')
	canvas.line(120,700,580,700)
	canvas.drawString(120,703, settings.NAME)
 
	canvas.save()

def spacer_ticker(canvas, feature, cLen, Y0, nudge, offset, side):
    """Draw separator indicators."""
    # take start and end points
    location = feature.location
    Zs = location.nofuzzy_start
    Ze = location.nofuzzy_end
    # calculate loop offset coordinates
    loop_offZs = offset_coord(Zs, cLen, offset)
    loop_offZe = offset_coord(Ze, cLen, offset)
    # calculate nudge offset coordinates
    offZs = nudge_coord(loop_offZs, nudge)
    offZe = nudge_coord(loop_offZe, nudge)
    xs, xe = offZs*u, offZe*u
    # set Y axis coordinates
    y0 = Y0-dop*3.5
    if side == 'low':
        yT1 = y0-h*4
    else:
        yT1 = y0+h*4
    # draw
    canvas.setLineWidth(2)
    ttl = canvas.beginPath()
    ttl.moveTo(xs,y0)
    ttl.lineTo(xs,yT1)
    ttl.lineTo(xe,yT1)
    ttl.lineTo(xe,y0)
    canvas.drawPath(ttl, stroke=1, fill=0)
    ttl.close()

    def beforeDrawPage(self, canvas, doc):
        if self.background != None:
            self.background.draw_on(canvas)

        (width, height) = canvas._pagesize
        canvas.setLineWidth(0.2 * cm)
        canvas.line(cm, height - (2*cm), width - cm, height - (2*cm))
        canvas.line(cm, (2*cm), width - cm, (2*cm))

def framePage(canvas, title, pos):
    canvas.setFont('Times-Roman', 15)
    canvas.drawString(inch, pos * inch, title)
    canvas.setFont('Times-Roman', 10)
    canvas.drawCentredString(4.135 * inch, 0.75 * inch,
                            'Página %d' % canvas.getPageNumber())
    #reset carefully afterwards
    canvas.setLineWidth(1)
    canvas.setStrokeColorRGB(0, 0, 0)

 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 draw_header(canvas):
    """ Draws the invoice header """
    canvas.setStrokeColorRGB(176/255., 196/255., 222/255.)
    # canvas.setStrokeColorRGB(0.9, 0.5, 0.2)
    canvas.setFillColorRGB(0.2, 0.2, 0.2)
    canvas.setFont('Helvetica', 16)
    canvas.drawString(18 * cm, -1 * cm, 'Invoice')
    if consultant_logo_filename:
        canvas.drawInlineImage(consultant_logo_filename, 1 * cm, -1 * cm, 250, 16)
    canvas.setLineWidth(4)
    canvas.line(0, -1.25 * cm, 21.7 * cm, -1.25 * cm)

 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 draw(self):
        canvas = self.canv
        couleurDate = None
        positionSeparation = 20
        
        # Couleur de la case Date de la journée
        if AFFICHER_VACANCES == True and self.dateDD in LISTE_VACANCES : couleurDate = COULEUR_VACANCES
        if AFFICHER_WE == True and (self.dateDD.weekday() == 5 or self.dateDD.weekday() == 6) : couleurDate = COULEUR_WE
        if AFFICHER_FERIES == True and self.dateDD in LISTE_FERIES : couleurDate = COULEUR_FERIES
        
        if couleurDate != None :
            r, g, b = ConvertCouleur(couleurDate)
            canvas.setFillColorRGB(r, g, b)
            canvas.rect(0, 0, positionSeparation, self.hauteurCase, fill=1, stroke=False)
        
        # Texte date
        canvas.setFillColorRGB(0, 0, 0)
        canvas.setFont("Helvetica", 7)
        canvas.drawRightString(positionSeparation-2, 2, self.labelDate)
        
        # Trait séparation Date et Heures
        canvas.setLineWidth(0.25)
        canvas.line(positionSeparation, 0, positionSeparation, self.hauteurCase)
        
        # Si aucune présence ce jour -là
        if len(self.dictBarres) == 0 : return

        # Récup du nbre total d'heure de la journée
        totalJour = self.dictBarres["totalJour"]
        
        # Transformation du nombre d'heures par catégorie en pourcentage
        listeCategories = []
        for IDcategorie, nbreHeures in self.dictBarres.items():
            if IDcategorie != "totalJour" :
                largeurBarre = nbreHeures * 1.0 * (self.largeurCase-positionSeparation-0.25) / totalJour
                listeCategories.append( (largeurBarre, IDcategorie) )
        listeCategories.sort()
        
        # Création des graphes
        if AFFICHER_COULEUR_CATEGORIES == True :
            positionTemp = positionSeparation+0.25
            for largeurBarre, IDcategorie in listeCategories :
                r, g, b = ConvertCouleur(FormateCouleur(DICT_CATEGORIES[IDcategorie][2]))
                canvas.setFillColorRGB(r, g, b)
                canvas.rect(positionTemp, 0, largeurBarre, self.hauteurCase, fill=1, stroke=False)
                positionTemp += largeurBarre
        
        # Label Total Heure de la journée
        if AFFICHER_HEURES == True :
            canvas.setFillColorRGB(0, 0, 0)
            canvas.setFont("Helvetica", 7)
            canvas.drawRightString(self.largeurCase-2, 2, "%s" % minutesEnHeures(totalJour))