def myLaterPages(canvas, doc):

        PAGE_HEIGHT,PAGE_WIDTH = letter
        canvas.saveState()
        canvas.setPageSize(landscape(letter))

        canvas.drawImage(frunt_pag2, 0,0, PAGE_WIDTH,PAGE_HEIGHT )

        canvas.setStrokeColorRGB(0,1,1,alpha=0.1)

        ficha_no = doc.page-1
        #canvas.setStrokeColorRGB(0.7,0.7,0.7)
        canvas.setFillColorRGB(0,0,0)

        SHOW_GRID = False

        if SHOW_GRID:
            n = 5
            s = 200
            canvas.setFillColorRGB(0,0,1)
            canvas.setFont('Helvetica',1)
            for x in range(s):
               for y in range(s):
                  canvas.rect(x*n,y*n, width=n, height=n, stroke=1)
                  canvas.drawString(x*n,y*n,"%s,%s" % ((x*n),(y*n)) )

            # for i in range(s):
            #     x= i*n
            #     y=x
            #     canvas.drawString(x,0,"%s" % (x)) #horizontal
            #     canvas.drawString(0,y+1,"%s" % (x)) # vertical
            #     canvas.drawString(x,600,"%s" % (x)) #horizontal
            #     canvas.drawString(990,y,"%s" % (x)) # vertical
            #
            #     canvas.setStrokeColorRGB(0,0,1,alpha=0.7)
            #     canvas.setFont('Helvetica',1)
            #     for i in range(610):
            #         #canvas.rect(35,i*2, width=0.5, height=0.5, stroke=1)
            #         canvas.drawString(35,i,"%s -" % (i,) )

        canvas.setFont('Helvetica',7)
        LINE_1 = 508

        #fecha_elaboracion = doc.fecha_elaboracion
        #if not fecha_elaboracion:
        #    fecha_elaboracion = datetime.today()

        canvas.drawCentredString(137,LINE_1,str(fecha_elaboracion.year))
        canvas.drawCentredString(162,LINE_1,str(fecha_elaboracion.month))
        canvas.drawCentredString(180,LINE_1,str(fecha_elaboracion.day))

        canvas.drawCentredString(290,LINE_1,"VALLE DEL CAUCA")

        canvas.drawCentredString(740,LINE_1,"Ficha No. %s" % (int(ficha_no)+int(no_ficha_inicial)-1))

        canvas.setFont('Helvetica',5)
        canvas.drawString(75,115, "Elaboro: %s" % elaboro)
        canvas.drawString(215,115, "Reviso: %s" % reviso)

        canvas.restoreState()

    def process(self):
        kwargs = dict(self.getAttributeValues(attrMapping=self.attrMapping))
        preserve = kwargs.pop('preserveAspectRatio')
        show = kwargs.pop('showBoundary')

        if preserve:
            imgX, imgY = kwargs['image'].getSize()

            # Scale image correctly, if width and/or height were specified
            if 'width' in kwargs and 'height' not in kwargs:
                kwargs['height'] = imgY * kwargs['width'] / imgX
            elif 'height' in kwargs and 'width' not in kwargs:
                kwargs['width'] = imgX * kwargs['height'] / imgY
            elif 'width' in kwargs and 'height' in kwargs:
                if float(kwargs['width'])/kwargs['height'] > float(imgX)/imgY:
                    kwargs['width'] = imgX * kwargs['height'] / imgY
                else:
                    kwargs['height'] = imgY * kwargs['width'] / imgX

        canvas = attr.getManager(self, interfaces.ICanvasManager).canvas
        getattr(canvas, self.callable)(**kwargs)

        if show:
            width = kwargs.get('width', kwargs['image'].getSize()[0])
            height = kwargs.get('height', kwargs['image'].getSize()[1])
            canvas.rect(kwargs['x'], kwargs['y'], width, height)

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 render(self, canvas, context):
        canvas.rect(self.left_margin, self.bottom_margin,
                    self.box_width, self.box_height,
                    stroke=1, fill=1)

        data = [
            ('Last name:', context['student']['last_name']),
            ('Name:', context['student']['first_name']),
            ('Teacher:', '{} {}'.format(context['teacher']['last_name'],
                                        context['teacher']['first_name'])),
            ('ID:', context['student']['id']),
            ('School:', context['school']),
        ]

        t = Table(data, (30 * mm, self.box_width - 32 * mm),
                  [(self.box_height - 3 * mm) / len(data)] * len(data))
        s = TableStyle([
            ('FONTSIZE', (0, 0), (-1, -1), 8),
            ('LEFTPADDING', (0, 0), (0, -1), 13),
            ('BACKGROUND', (0, 0), (-1, -1), colors.white),
        ])
        t.setStyle(s)
        f = Frame(self.left_margin, self.bottom_margin,
                  self.box_width, self.box_height,
                  leftPadding=1 * mm, rightPadding=1 * mm,
                  topPadding=2.5 * mm, bottomPadding=0 * mm)
        f.addFromList([t], canvas)

    def draw_debug_outline(self, config ):
        """draw an outline around the box"""
        canvas = self.canvas

        # don't muck up the external state
        canvas.saveState()

        # discreet - but visible
        canvas.setStrokeColorRGB( 0.9, 0.7, 0.7 )
        canvas.setFillColorRGB(   0.6, 0.6, 0.6 )
        canvas.setFont( 'Helvetica', 8 )

        # draw a box to show the extent
        canvas.rect(
            config['x'], config['y'], config['w'], config['h'], 
            stroke=1, fill=0,
        )
        
        # put in some debug info
        canvas.drawRightString(
            config['x'] + config['w'],
            config['y'] + 4,
            ', '.join(config['content'])
        )
        
        # restore state
        canvas.restoreState()

 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 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 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 draw_tubeoffset(self, canvas):
     txt = {'de': 'Rohrüberstand: {0}cm', 'en': 'Clearance: {0}cm'}
     txt = txt[self.lang].format(self.offset)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

 def draw_amount(self, canvas):
     txt = {'de': 'Stückzahl: {0}', 'en': 'Amount: {0}'}
     txt = txt[self.lang].format(self.amount)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

 def draw_connector(self, canvas):
     txt = {'de': 'Anschluss: {0}', 'en': 'Connector: {0}'}
     txt = txt[self.lang].format(self.connector)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

 def draw_cable(self, canvas):
     txt = {'de': 'Kabellänge: {0}', 'en': 'Cablelength: {0}'}
     txt = txt[self.lang].format(self.cable)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

 def draw_tubelength(self, canvas):
     txt = {'de': 'Rohrlänge: {0}cm', 'en': 'Tubelength: {0}cm'}
     txt = txt[self.lang].format(self.tube)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

def draw_lines(canvas, nib_width, partitions, gap, nrulings, top_margin, pagesize):
    "Draws lines and separators on the page"
    line_height = sum((float(x) for x in partitions.split(",")),0.0) # Sum of the ascenders, descenders and body
    line_height += gap # Add the gap
    canvas.rect(1*mm, 1*mm, pagesize[0], top_margin * mm * nib_width, stroke = 0, fill = 1)
    for i in range(nrulings):
        position = (top_margin * mm * nib_width) + (i * line_height * nib_width * mm) # Margin + position for the current line
        offset = draw_line_set(canvas, position, nib_width, partitions, pagesize)
        canvas.rect(1*mm, offset, pagesize[0], gap * nib_width * mm, stroke = 0, 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 draw(self):
     canvas = self.canv
     # Texte label
     canvas.setFillColorRGB(0, 0, 0)
     canvas.setFont("Helvetica", 9)
     canvas.drawString(15, 1, "%s : %s" % (self.label, minutesEnHeures(self.totalHeures)))
     # Carré de couleur
     if self.couleur != None :
         r, g, b = ConvertCouleur(FormateCouleur(self.couleur))
         canvas.setFillColorRGB(r, g, b)
         canvas.rect(0, 0, 10, 10, fill=1)

 def draw_footer(self, canvas):
     canvas.saveState()
     footerwidth = self.dina4[0] - (2 * self.left)
     canvas.setFillColorCMYK(1, 0.5, 0, 0)
     canvas.rect(0, 0, width=self.dina4[0], height=50, fill=True)
     canvas.setFillColorCMYK(0, 0, 0, 0)
     canvas.setFont(self.font_bold, 14)
     x = self.dina4[0]/2
     canvas.drawCentredString(x, 25, 'www.imko.de')
     canvas.linkURL('http://www.imko.de', (0, 50, self.dina4[1], 0))
     canvas.restoreState()

def draw_codebox(canvas, x, y, code):
    if 0:
        assert isinstance(canvas, reportlab.pdfgen.canvas.Canvas)
    size = defs.codebox_step * mm
    length = defs.codebox_length  # 2 Bytes
    canvas.saveState()
    canvas.translate(x, y)
    canvas.rect(0, 0, defs.codebox_width * mm, defs.codebox_height * mm)
    for i in range(length):
        if code & (1 << i):
            canvas.rect((length - i - 1) * size, 0, size, defs.codebox_height * mm, stroke=1, fill=1)
    canvas.restoreState()

 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 myFirstPage(canvas, doc):
        PAGE_HEIGHT,PAGE_WIDTH = letter
        canvas.saveState()
        canvas.drawImage(fondo, 0,0, PAGE_HEIGHT, PAGE_WIDTH )
        canvas.setStrokeColorRGB(1,0,1,alpha=0.1)
        #canvas.setPageSize(landscape(letter))
        canvas.setFont('Arial', 10)
        canvas.drawString(150, 579, cuenta_cobro.nombre_dependencia)
        canvas.drawString(215, 558, cuenta_cobro.fecha_transaccion)
        canvas.drawString(284, 538, cuenta_cobro.nombre_adquiriente)
        canvas.drawString(90, 513,  cuenta_cobro.nit_adquiriente)
        canvas.drawString(230, 513, cuenta_cobro.direccion_adquiriente)
        canvas.drawString(492, 513, cuenta_cobro.telefono_adquiriente)
        canvas.drawString(120, 488, cuenta_cobro.ciudad_adquiriente)
        #
        canvas.drawString(285, 474, cuenta_cobro.nombre_beneficiario)
        canvas.drawString(140, 448, cuenta_cobro.documento_beneficiario)
        canvas.drawString(365, 448, cuenta_cobro.direccion_beneficiario)
        canvas.drawString(120, 425, cuenta_cobro.telefono_beneficiario)
        canvas.drawString(360, 425, cuenta_cobro.email_beneficiario)
        canvas.drawString(115, 410, cuenta_cobro.ciudad_beneficiario)

        cuenta_cobro.objeto_contrato = textwrap.fill(cuenta_cobro.objeto_contrato, 80)

        textobject = canvas.beginText()
        textobject.setTextOrigin(63, 365)
        textobject.textLines(cuenta_cobro.objeto_contrato)
        canvas.drawText(textobject)

        canvas.drawString(117, 297, cuenta_cobro.no_rpc)
        canvas.drawString(242, 297, cuenta_cobro.no_cdp)
        canvas.drawString(392, 297, cuenta_cobro.valor_contrato)

        canvas.drawString(127, 282, cuenta_cobro.concepto)
        canvas.drawString(127, 268, cuenta_cobro.valor_concepto)
        canvas.drawString(95, 255, cuenta_cobro.valor_concepto_letras)

        SHOW_GRID = False
        if SHOW_GRID:
             n = 5
             s = 200
             #canvas.setStrokeGray(0.90)
             #canvas.setFillGray(0.90)
             canvas.setStrokeColorRGB(0,1,1,alpha=0.1)

             canvas.setFillColorRGB(1,0,1)
             canvas.setFont('Arial',1)
             for x in range(s):
                for y in range(s):
                   canvas.rect(x*n,y*n, width=n, height=n, stroke=1)
                   canvas.drawString(x*n,y*n,"%s,%s" % ((x*n),(y*n)) )
        canvas.restoreState()