def draw_code128_questionnaire_id(canvas, survey, id):
    # Only supports ascii for now (see also defs.py)
    barcode_value = unicode(id).encode('ascii')
    barcode = createBarcodeDrawing("Code128",
                                   value=barcode_value,
                                   barWidth=defs.code128_barwidth / 25.4 * 72.0,
                                   height=defs.code128_height / 25.4 * 72.0,
                                   quiet=False)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = defs.corner_mark_left

    barcode_y = y - defs.code128_vpad - defs.code128_height
    barcode_x = x + defs.code128_hpad

    # The barcode should be flush left.
    barcode_x = barcode_x

    renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)

    # Label
    text_x = barcode_x + barcode.width / mm / 2.0
    text_y = barcode_y + defs.code128_height + 1 + \
             defs.code128_text_font_size / 72.0 * 25.4 / 2.0

    canvas.saveState()
    canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
    canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
    canvas.restoreState()

    def A4_page_foot(self, canvas, doc):
        canvas.saveState()

        # qrcode
        qrcode = self.codeimg
        qrcode.wrap(3*cm, 3*cm)
        qrcode.drawOn(canvas, doc.width, 1.5*cm)
        # ticket order
        if self.order:
            pr = Paragraph(_('ORDER: %s') % self.order, self.styleL)
            pr.wrap(doc.width, 1*cm)
            pr.drawOn(canvas, doc.leftMargin, 1.5*cm)
        # line
        hr = HRFlowable(width="100%", thickness=0.25, hAlign='CENTER',
                        color=colors.black, vAlign='BOTTOM', dash=None,
                        spaceAfter=5)
        hr.wrap(doc.width, 1*cm)
        hr.drawOn(canvas, doc.leftMargin, 1.5*cm)
        # ticket window code
        pr = Paragraph(self.wcode, self.styleL)
        pr.wrap(doc.width, 1*cm)
        pr.drawOn(canvas, doc.leftMargin, 1.0*cm)
        # code
        pr = Paragraph(self.code, self.styleL)
        pr.wrap(doc.width, 1*cm)
        pr.drawOn(canvas, doc.width, 1.0*cm)

        canvas.restoreState()

 def render(self, canvas, doc):
     canvas.saveState()
     cnv = _rml_canvas(
         canvas, self.localcontext, doc, self.styles, images=self.images, path=self.path, title=self.canvas_title
     )
     cnv.render(self.node)
     canvas.restoreState()

    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 prepare_first_page(canvas, document):
            p1 = Paragraph(presentation.title, styles['Heading'])
            p2 = Paragraph(
                presentation.owner.get_full_name(), styles['SubHeading'])
            avail_width = width - inch
            avail_height = height - inch
            w1, h1 = p1.wrap(avail_width, avail_height)
            w2, h2 = p2.wrap(avail_width, avail_height)
            f = Frame(
                inch / 2,
                inch / 2,
                width - inch,
                height - inch,
                leftPadding=0,
                bottomPadding=0,
                rightPadding=0,
                topPadding=0
            )
            f.addFromList([p1, p2], canvas)

            document.pageTemplate.frames[0].height -= h1 + h2 + inch / 2
            document.pageTemplate.frames[1].height -= h1 + h2 + inch / 2

            canvas.saveState()
            canvas.setStrokeColorRGB(0, 0, 0)
            canvas.line(
                width / 2, inch / 2, width / 2, height - inch - h1 - h2)
            canvas.restoreState()

        def _build_header_canvas(canvas, doc):
            """
            Draw the document header.

            Local function to be passed later to output_doc.build().
            Reportlab automatically passes args when called.
            """
            # The header function to be passed later to output_doc.build()
            # Set up positions
            header_y_position = (11 * units.inch) - 45
            page_number = doc.page
            if page_number % 2 == 0:
                # Left-hand page
                page_number_x_position = 60
            else:
                # Right-hand page
                page_number_x_position = (8.5 * units.inch) - 60
            canvas.saveState()
            canvas.setFont(self.paragraph_style.fontName,
                           self.paragraph_style.fontSize)
            if self.title:
                canvas.drawCentredString((8.5 * units.inch) / 2,
                                         header_y_position,
                                         self.title)
            canvas.drawString(page_number_x_position, header_y_position,
                              str(page_number))
            canvas.restoreState()

 def beforeDrawPage(self, canvas):
     """Draws the background before anything else"""
     canvas.saveState()
     rl_obj = makerl(canvas, self.page_template)
     canvas.scale(self.page_xscale, self.page_yscale)
     canvas.doForm(rl_obj)
     canvas.restoreState()

    def myPage(canvas, doc):
        canvas.saveState()  # save the current state
        canvas.setFont('InconsolataBold', 16)  # set the font for the name
        canvas.drawString(
            .4 * inch,
            HEIGHT - (.4 * inch),
            contact['name'])  # draw the name on top left page 1
        canvas.setFont('Inconsolata', 8)  # sets the font for contact
        canvas.drawRightString(
            WIDTH - (.4 * inch),
            HEIGHT - (.4 * inch),
            contact['website'])  
        canvas.line(.4 * inch, HEIGHT - (.47 * inch), 
            WIDTH - (.4 * inch), HEIGHT - (.47 * inch))
        canvas.drawString(
            .4 * inch,
            HEIGHT - (.6 * inch),
            contact['phone'])
        canvas.drawCentredString(
			WIDTH / 2.0,
			HEIGHT - (.6 * inch),
			contact['address'])
        canvas.drawRightString(
			WIDTH - (.4 * inch),
			HEIGHT - (.6 * inch),
			contact['email'])
        # restore the state to what it was when saved
        canvas.restoreState()

def drawHnecLogo(canvas, doc):
    # draws the greyscale hnec logo
    # on the canvas directly, so we don't have to deal with flowables
    canvas.saveState()
    canvas.drawImage(ImageReader(hnec_logo(greyscale=True)), 3.5*cm, A4[1]-3.8*cm, width=4*cm,
                     height=1*cm)
    canvas.restoreState()

def el_encogedor_de_fuentes_de_doraemon(canvas, fuente, tamannoini, xini, xfin, y, texto, alineacion = -1):
    """
    Comenzando por el tamaño inicial "tamannoini", encoge el texto 
    hasta que quepa en los límites fijados y después lo escribe.
    Convierte el texto por si está en una codificación no soportada.
    Al finalizar, devuelve las propiedades de texto del canvas a 
    su estado original y la fuente a su tamaño inicial.
    NO AVANZA LÍNEA.
    Si alineacion == -1: Alineación a la izquierda. Si 0, centrado y si 1, a la derecha.
    """
    # PLAN: No estaría mal pasar un tamaño mínimo de fuente, y si se alcanza o se supera, cortar la línea con 
    # agregarFila y el último tamaño de fuente válido. Claro que entonces habría que devolver también las líneas 
    # avanzadas, etc...
    canvas.saveState()
    size = tamannoini
    texto = escribe(texto)
    while canvas.stringWidth(texto, fuente, size) > (xfin - xini) and size > 4:
        size -= 1
    canvas.setFont(fuente, size)
    if alineacion == -1:
        canvas.drawString(xini, y, texto)
    elif alineacion == 1:
        canvas.drawRightString(xfin, y, texto)
    elif alineacion == 0:
        canvas.drawCentredString((xfin + xini) / 2.0, y, texto)
    else:
        print "geninformes.py::el_encogedor_de_fuentes_de_doraemon -> Error alineación. Uso alineación a la izquierda por defecto."
        canvas.drawString(xini, y, texto)
    canvas.restoreState()

def footer(canvas, doc):
    canvas.saveState()
    P = Paragraph("ReadyMade Report",
                  styleN)
    w, h = P.wrap(doc.width, doc.bottomMargin)
    P.drawOn(canvas, doc.leftMargin, h)
    canvas.restoreState()

	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 draw_code128_global_id(canvas, survey):
    if survey.global_id is None:
        raise AssertionError

    # Only allow ascii
    barcode_value = survey.global_id.encode('ascii')

    barcode = createBarcodeDrawing("Code128",
                                   value=barcode_value,
                                   barWidth=defs.code128_barwidth / 25.4 * 72.0,
                                   height=defs.code128_height / 25.4 * 72.0,
                                   quiet=False)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = (survey.defs.paper_width - defs.corner_mark_right + defs.corner_mark_left) / 2

    barcode_y = y - defs.code128_vpad - defs.code128_height
    barcode_x = x

    # Center
    barcode_x = barcode_x - barcode.width / mm / 2.0

    renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)

    # Label
    text_x = barcode_x + barcode.width / mm / 2.0
    text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0

    canvas.saveState()
    canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
    canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
    canvas.restoreState()

def draw_code128_sdaps_info(canvas, survey, page):
    # The page number is one based here already
    # The survey_id is a 32bit number, which means we need
    # 10 decimal digits to encode it, then we need to encode the
    # the page with at least 3 digits(just in case someone is insane enough
    # to have a questionnaire with more than 99 pages.
    # So use 10+4 digits

    barcode_value = "%010d%04d" % (survey.survey_id, page)
    barcode = createBarcodeDrawing("Code128",
                                   value=barcode_value,
                                   barWidth=defs.code128_barwidth / 25.4 * 72.0,
                                   height=defs.code128_height / 25.4 * 72.0,
                                   quiet=False)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = survey.defs.paper_width - defs.corner_mark_right

    barcode_y = y - defs.code128_vpad - defs.code128_height
    barcode_x = x - defs.code128_hpad

    # The barcode should be flush left.
    barcode_x = barcode_x - barcode.width / mm

    renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)

    # Label
    text_x = barcode_x + barcode.width / mm / 2.0
    text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0

    canvas.saveState()
    canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
    canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
    canvas.restoreState()

 def onLaterPages(self, canvas, doc):
     canvas.saveState()
     self.set_header(canvas, doc)
     self.set_footer(canvas, doc)
     if self.show_creation_date:
         self.set_creation_date(canvas, doc)
     canvas.restoreState()

def on_later_pages(canvas, DOC):
    """Draws header and footer on every page"""
    if DOC.page > 1:
        canvas.saveState()
        header(canvas, DOC, MAPHEADERTEXT)
        footer(canvas, DOC)
        canvas.restoreState()

    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 _header_footer(canvas,doc):
        #guardamos el estado de nuestro canvas , para poder dibujar en el 
        canvas.saveState()
        canvas.setTitle("Cotizacion Cliente")
        styles = getSampleStyleSheet()

        #header
        header = Image('/home/borbolla/metrology/static_media/assets/images/borbolla_metrology_logo.jpg' )
        header.drawHeight = 60
        header.drawWidth = 424
        header.hAlign = 'RIGHT'
        w , h = header.wrap(doc.width , doc.topMargin)
        header.drawOn(canvas , doc.leftMargin , 700)
        
        marcas = Image('/home/borbolla/metrology/static_media/assets/images/marcas.png' )
        marcas.drawWidth = 90
        marcas.drawHeight = 477
        marcas.drawOn(canvas , 20,200) 
        
        marcas2 = Image('/home/borbolla/metrology/static_media/assets/images/logo.png' )
        marcas2.drawWidth = 116
        marcas2.drawHeight = 34
        marcas2.drawOn(canvas , 20,150) 

        # Footer
        footer = Paragraph('www.borbollametrology.com', styles['Normal'])
        w, h = footer.wrap(doc.width, doc.bottomMargin)
        footer.drawOn(canvas, doc.leftMargin, h)
 
        # Release the canvas
        canvas.restoreState()

def mylaterpages(canvas, doc):
    canvas.saveState()
    canvas.line(0 * inch, 0.01 * inch, 11.69 * inch, 0.01 * inch)
    canvas.line(0 * inch, 0 * inch, 0 * inch, 8.24 * inch)
    canvas.line(11.69 * inch, 0 * inch, 11.69 * inch, 8.24 * inch)
    canvas.line(0 * inch, 8.24 * inch, 11.69 * inch, 8.24 * inch)
    canvas.restoreState()

    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()