Python reportlab.lib.styles 模块，ParagraphStyle() 实例源码

def tabla_otros(self):
        orden = self.orden_compra
        p = ParagraphStyle('parrafos', 
                           alignment = TA_CENTER,
                           fontSize = 8,
                           fontName="Times-Roman")
        sub_total = Paragraph(u"SUBTOTAL: ",p)
        igv = Paragraph(u"IGV: ",p)
        total = Paragraph(u"TOTAL: ",p)
        datos_otros = [[ Paragraph(u"LUGAR DE ENTREGA",p),  Paragraph(u"PLAZO DE ENTREGA",p),  Paragraph(u"FORMA DE PAGO",p),sub_total,orden.subtotal],
                       [Paragraph(EMPRESA.direccion(),p),Paragraph(u"INMEDIATA",p),Paragraph(orden.forma_pago.descripcion,p),igv,str(orden.igv)],
                       ['','','',total,str(orden.total)],
                       ]
        tabla_otros = Table(datos_otros,colWidths=[5.5 * cm, 5 * cm, 5 * cm, 2 * cm, 2.5 * cm])
        tabla_otros.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (2, 2), 1, colors.black),
                ('SPAN',(0,1),(0,2)),
                ('SPAN',(1,1),(1,2)),
                ('SPAN',(2,1),(2,2)),
                ('GRID', (4, 0), (4, 2), 1, colors.black),
                ('VALIGN',(0,1),(2,1),'MIDDLE'),
            ]
        ))
        return tabla_otros

def tabla_observaciones(self):
        orden = self.orden_compra
        p = ParagraphStyle('parrafos',
                           alignment = TA_JUSTIFY,
                           fontSize = 8,
                           fontName="Times-Roman")
        obs=Paragraph("OBSERVACIONES: "+orden.observaciones,p)
        observaciones = [[obs]]
        tabla_observaciones = Table(observaciones,colWidths=[20 * cm], rowHeights=1.8 * cm)
        tabla_observaciones.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (0, 2), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 8),
                ('ALIGN',(0,0),(-1,-1),'LEFT'),
                ('VALIGN',(0,0),(-1,-1),'TOP'),
            ]
        ))
        return tabla_observaciones

def cuadro_observaciones(self,pdf,y,orden):
        p = ParagraphStyle('parrafos')
        p.alignment = TA_JUSTIFY 
        p.fontSize = 10
        p.fontName="Times-Roman"
        obs=Paragraph("Observaciones: "+orden.observaciones,p)
        observaciones = [[obs]]
        tabla_observaciones = Table(observaciones,colWidths=[18.50 * cm], rowHeights=1.8 * cm)
        tabla_observaciones.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (0, 2), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 8),
                ('ALIGN',(0,0),(-1,-1),'LEFT'),
                ('VALIGN',(0,0),(-1,-1),'TOP'),
            ]
        ))
        tabla_observaciones.wrapOn(pdf, 800, 600)
        tabla_observaciones.drawOn(pdf, 40,y-58)

def tabla_encabezado(self,valorizado):
        sp = ParagraphStyle('parrafos',
                            alignment=TA_CENTER,
                            fontSize=14,
                            fontName="Times-Roman")
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT, str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50, hAlign='LEFT')
        except:
            imagen = Paragraph(u"LOGO", sp)
        if valorizado:
            titulo = Paragraph(u"REGISTRO DEL INVENTARIO PERMANENTE VALORIZADO", sp)
        else:
            titulo = Paragraph(u"REGISTRO DEL INVENTARIO PERMANENTE EN UNIDADES FÍSICAS", sp)

        encabezado = [[imagen,titulo]]
        tabla_encabezado = Table(encabezado, colWidths=[2 * cm, 23 * cm])
        return tabla_encabezado

def cuadro_observaciones(self,pdf,y,cotizacion):
        p = ParagraphStyle('parrafos')
        p.alignment = TA_JUSTIFY 
        p.fontSize = 8
        p.fontName="Times-Roman"
        obs=Paragraph("OBSERVACIONES: "+cotizacion.observaciones,p)
        observaciones = [[obs]]
        tabla_observaciones = Table(observaciones,colWidths=[18 * cm], rowHeights=1.8 * cm)
        tabla_observaciones.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (0, 2), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 8),
                ('ALIGN',(0,0),(-1,-1),'LEFT'),
                ('VALIGN',(0,0),(-1,-1),'TOP'),
            ]
        ))
        tabla_observaciones.wrapOn(pdf, 800, 600)
        tabla_observaciones.drawOn(pdf, 40,y+20)

def tabla_encabezado(self, styles):
        sp = ParagraphStyle('parrafos',
                            alignment=TA_CENTER,
                            fontSize=14,
                            fontName="Times-Roman")
        requerimiento = self.requerimiento
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT, str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50, hAlign='LEFT')
        except:
            print u"Ingresa acá  "
            imagen = Paragraph(u"LOGO", sp)
        nro = Paragraph(u"REQUERIMIENTO DE BIENES Y SERVICIOS<br/>N°" + requerimiento.codigo, sp)
        encabezado = [[imagen, nro, '']]
        tabla_encabezado = Table(encabezado, colWidths=[4 * cm, 11 * cm, 4 * cm])
        tabla_encabezado.setStyle(TableStyle(
            [
                ('ALIGN', (0, 0), (1, 0), 'CENTER'),
                ('VALIGN', (0, 0), (1, 0), 'CENTER'),
            ]
        ))
        return tabla_encabezado

def tabla_datos(self, styles):
        requerimiento = self.requerimiento
        izquierda = ParagraphStyle('parrafos',
                                   alignment=TA_LEFT,
                                   fontSize=10,
                                   fontName="Times-Roman")
        solicitado = Paragraph(u"SOLICITADO POR: " + requerimiento.solicitante.nombre_completo(), izquierda)
        oficina = Paragraph(u"OFICINA: " + requerimiento.oficina.nombre, izquierda)
        motivo = Paragraph(u"MOTIVO: " + requerimiento.motivo, izquierda)
        fecha = Paragraph(u"FECHA DE REQUERIMIENTO: " + requerimiento.fecha.strftime('%d/%m/%Y'), izquierda)
        mes = Paragraph(u"MES EN QUE SE NECESITA: " + requerimiento.get_mes_display(), izquierda)
        para_stock = Paragraph(u"AÑO EN QUE SE NECESITA: " + str(requerimiento.annio), izquierda)
        if requerimiento.entrega_directa_solicitante:
            entrega = Paragraph(u"ENTREGA DIRECTAMENTE AL SOLICITANTE: SI", izquierda)
        else:
            entrega = Paragraph(u"ENTREGA DIRECTAMENTE AL SOLICITANTE: NO", izquierda)
        datos = [[solicitado, oficina], [motivo], [fecha, mes], [para_stock, entrega]]
        tabla_datos = Table(datos, colWidths=[11 * cm, 9 * cm])
        style = TableStyle(
            [
                ('SPAN', (0, 1), (1, 1)),
            ]
        )
        tabla_datos.setStyle(style)
        return tabla_datos

def tabla_observaciones(self):
        movimiento = self.movimiento
        p = ParagraphStyle('parrafos',
                           alignment = TA_JUSTIFY,
                           fontSize = 8,
                           fontName="Times-Roman")
        obs=Paragraph("OBSERVACIONES: "+movimiento.observaciones,p)
        observaciones = [[obs]]
        tabla_observaciones = Table(observaciones,colWidths=[20 * cm], rowHeights=1.8 * cm)
        tabla_observaciones.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (0, 2), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 8),
                ('ALIGN',(0,0),(-1,-1),'LEFT'),
                ('VALIGN',(0,0),(-1,-1),'TOP'),
            ]
        ))
        return tabla_observaciones

def tabla_encabezado_consolidado(self, grupos):
        sp = ParagraphStyle('parrafos',
                            alignment=TA_CENTER,
                            fontSize=14,
                            fontName="Times-Roman")
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT, str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50, hAlign='LEFT')
        except:
            imagen = Paragraph(u"LOGO", sp)
        if grupos:
            titulo = Paragraph(u"RESUMEN MENSUAL DE ALMACÉN POR GRUPOS Y CUENTAS", sp)
        else:
            titulo = Paragraph(u"RESUMEN MENSUAL DE ALMACÉN POR PRODUCTOS", sp)

        encabezado = [[imagen,titulo]]
        tabla_encabezado = Table(encabezado, colWidths=[2 * cm, 23 * cm])
        style = TableStyle(
            [
                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
            ]
        )
        tabla_encabezado.setStyle(style)
        return tabla_encabezado

def run():
        objects_to_draw = []
        from reportlab.lib.styles import ParagraphStyle
        #from paragraph import Paragraph
        from reportlab.platypus.doctemplate import SimpleDocTemplate

        #need a style
        normal = ParagraphStyle('normal')
        normal.firstLineIndent = 18
        normal.spaceBefore = 6
        from reportlab.lib.randomtext import randomText
        import random
        for i in range(15):
            height = 0.5 + (2*random.random())
            box = XBox(6 * inch, height * inch, 'Box Number %d' % i)
            objects_to_draw.append(box)
            para = Paragraph(randomText(), normal)
            objects_to_draw.append(para)

        SimpleDocTemplate('doctemplate.pdf').build(objects_to_draw,
            onFirstPage=myFirstPage,onLaterPages=myLaterPages)

def test2(canv,testpara):
    #print test_program; return
    from reportlab.lib.units import inch
    from reportlab.lib.styles import ParagraphStyle
    from reportlab.lib import rparsexml
    parsedpara = rparsexml.parsexmlSimple(testpara,entityReplacer=None)
    S = ParagraphStyle("Normal", None)
    P = Para(S, parsedpara)
    (w, h) = P.wrap(5*inch, 10*inch)
    print("wrapped as", (h,w))
    canv.saveState()
    canv.translate(1*inch, 1*inch)
    canv.rect(0,0,5*inch,10*inch, fill=0, stroke=1)
    P.canv = canv
    canv.saveState()
    P.draw()
    canv.restoreState()
    canv.setStrokeColorRGB(1, 0, 0)
    #canv.translate(0, 3*inch)
    canv.rect(0,0,w,h, fill=0, stroke=1)
    canv.restoreState()
    canv.showPage()

def Attendance(self,div_id,student_id) :

        attnd=self.DB.Score_and_Roll('3',div_id,10,student_id)[1][6]


        if attnd==None or attnd=='':
            return '' # zero %

        if self.working_days.isdigit():

            max=int(self.working_days)
            perc=attnd*100/max
            perc=str(round(perc,1))

            style1=ParagraphStyle(name='normal',fontSize = 8,alignment = TA_RIGHT)        

            perc=Paragraph('<font size=7>'+perc+'</font>',style1)
            #perc=RotatedPara(perc,style1)
            return  perc

        return 0

def gen_team_pdf(team_tuples: list):
    global _reged
    if not _reged:
        pdfmetrics.registerFont(TTFont('my_font', options.options.ttf_font_name))
        _reged = True
    buf = io.BytesIO()
    canv = canvas.Canvas(buf, pagesize=A4_TRANSVERSE)
    style = ParagraphStyle(name='default', fontName='my_font', fontSize=options.options.pdf_font_size,
                           alignment=1, leading=options.options.pdf_font_size * 1.2)
    for index, team in team_tuples:
        paragraph = Paragraph('Team {0}<br />{1}'.format(index, team['team_name']), style)
        w, h = paragraph.wrap(A4_TRANSVERSE[0] - 50, A4_TRANSVERSE[1] - 50)
        paragraph.drawOn(canv, (A4_TRANSVERSE[0] - w) / 2, (A4_TRANSVERSE[1] - h) / 2)
        canv.showPage()

    canv.save()
    return buf.getvalue()

def __init__(self, config, request, output, download_server):

        self.config = config
        self.client = config.client
        self.c_asdf = self.client.asdf.data

        self.request_id = str(request['_id'])
        self.request = request
        self.output = output

        self.assets_dir = os.path.join(config.source_dir, 'geo-hpc/assets')

        self.download_server = download_server

        self.doc = 0

        # container for the 'Flowable' objects
        self.Story = []

        self.styles = getSampleStyleSheet()
        self.styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))
        self.styles.add(ParagraphStyle(name='Center', alignment=TA_CENTER))

def main():
    import sys
    import urllib2
    from cStringIO import StringIO
    from reportlab.platypus import SimpleDocTemplate, Image, Paragraph, PageBreak
    from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet

    #This is needed because ReportLab accepts the StringIO as a file-like object,
    #but doesn't accept urllib2.urlopen's return value
    def get_image(url):
        u = urllib2.urlopen(url)
        return StringIO(u.read())

    styles = getSampleStyleSheet()
    styleN = ParagraphStyle(styles['Normal'])

    # build doc

    if len(sys.argv) > 1:
        fn = sys.argv[1]
    else:
        fn = "filename.pdf"
    doc = SimpleDocTemplate(open(fn, "wb"))
    elements = [
        Paragraph("Hello,", styleN),
        Image(get_image("http://www.red-dove.com/images/rdclogo.gif")),
        PageBreak(),
        Paragraph("world!", styleN),
        Image(get_image("http://www.python.org/images/python-logo.gif")),
    ]
    doc.build(elements, canvasmaker=NumberedCanvas)

def Style(name, font='Helvetica', size=12, leading=None, color=colors.black):
    return ParagraphStyle(
        name,
        fontName=font,
        fontSize=size,
        leading=leading or size * LEADING_FACTOR,
        textColor=color
    )

def get_style(self):
        stylesheet = StyleSheet1()
        stylesheet.add(ParagraphStyle(name='Normal', fontName='Helvetica', fontSize=12, leading=14))
        stylesheet.add(ParagraphStyle(name='Title', fontName='Helvetica-Bold', fontSize=14, leading=16))
        stylesheet.add(ParagraphStyle(name='Speaker', fontName='Helvetica-Oblique', fontSize=12, leading=14))
        stylesheet.add(ParagraphStyle(name='Meta', fontName='Helvetica', fontSize=10, leading=12))
        return stylesheet

def tabla_encabezado(self, styles):
        orden_compra = self.orden_compra
        sp = ParagraphStyle('parrafos',
                            alignment = TA_CENTER,
                            fontSize = 14,
                            fontName="Times-Roman")
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT,str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50,hAlign='LEFT')
        except:
            imagen = Paragraph(u"LOGO", sp)

        nro = Paragraph(u"ORDEN DE COMPRA", sp)
        ruc = Paragraph("R.U.C."+EMPRESA.ruc, sp)
        encabezado = [[imagen,nro,ruc],['',u"N°"+orden_compra.codigo,EMPRESA.distrito + " " + orden_compra.fecha.strftime('%d de %b de %Y')]]
        tabla_encabezado = Table(encabezado,colWidths=[4 * cm, 9 * cm, 6 * cm])
        tabla_encabezado.setStyle(TableStyle(
            [
                ('ALIGN',(0,0),(2,1),'CENTER'),
                ('VALIGN',(0,0),(2,0),'CENTER'),
                ('VALIGN',(1,1),(2,1),'TOP'),
                ('SPAN',(0,0),(0,1)),  

            ]
        ))
        return tabla_encabezado

def tabla_datos(self, styles):
        orden = self.orden_compra
        izquierda = ParagraphStyle('parrafos',
                            alignment = TA_LEFT,
                            fontSize = 10,
                            fontName="Times-Roman")
        cotizacion = orden.cotizacion
        if cotizacion is None:
            proveedor = orden.proveedor
        else:
            proveedor = orden.cotizacion.proveedor
        razon_social_proveedor = Paragraph(u"SEÑOR(ES): "+proveedor.razon_social, izquierda)
        ruc_proveedor = Paragraph(u"R.U.C.: "+proveedor.ruc, izquierda)
        direccion = Paragraph(u"DIRECCIÓN: "+proveedor.direccion, izquierda)
        try:
            telefono = Paragraph(u"TELÉFONO: "+proveedor.telefono, izquierda)
        except:
            telefono = Paragraph(u"TELÉFONO: -", izquierda)
        try:
            referencia = Paragraph(u"REFERENCIA: "+orden.cotizacion.requerimiento.codigo+" - "+orden.cotizacion.requerimiento.oficina.nombre, izquierda)
        except:
            referencia = Paragraph(u"REFERENCIA: ",izquierda)
        proceso = Paragraph(u"PROCESO: "+orden.proceso, izquierda)
        nota = Paragraph(u"Sírvase remitirnos según especificaciones que detallamos lo siguiente: ", izquierda)
        datos = [[razon_social_proveedor,ruc_proveedor],[direccion,telefono],[referencia,''],[proceso,''],[nota,'']]
        tabla_detalle = Table(datos,colWidths=[11* cm, 9 * cm])        
        tabla_detalle.setStyle(TableStyle(
            [
                ('SPAN',(0,2),(1,2)),                        
            ]
        ))
        return tabla_detalle

def tabla_detalle(self):
        orden = self.orden_compra
        encabezados = ['Item', 'Cantidad', 'Unidad', u'Descripción','Precio','Total']
        detalles = DetalleOrdenCompra.objects.filter(orden=orden).order_by('pk')
        sp = ParagraphStyle('parrafos')
        sp.alignment = TA_JUSTIFY 
        sp.fontSize = 8
        sp.fontName="Times-Roman"        
        lista_detalles = []
        for detalle in detalles:
            try:
                tupla_producto = [Paragraph(str(detalle.nro_detalle),sp), 
                                  Paragraph(str(detalle.cantidad), sp),
                                  Paragraph(detalle.detalle_cotizacion.detalle_requerimiento.producto.unidad_medida.descripcion,sp),
                                  Paragraph(detalle.detalle_cotizacion.detalle_requerimiento.producto.descripcion, sp),
                                  Paragraph(str(detalle.precio),sp),
                                  Paragraph(str(detalle.valor),sp)]
            except:
                tupla_producto = [Paragraph(str(detalle.nro_detalle),sp), 
                                  Paragraph(str(detalle.cantidad), sp),
                                  Paragraph(detalle.producto.unidad_medida.descripcion,sp),
                                  Paragraph(detalle.producto.descripcion, sp),
                                  Paragraph(str(detalle.precio),sp),
                                  Paragraph(str(detalle.valor),sp)]
            lista_detalles.append(tupla_producto)
        adicionales = [('','','','','')] * (15-len(lista_detalles))
        tabla_detalle = Table([encabezados] + lista_detalles + adicionales,colWidths=[0.8 * cm, 2 * cm, 2.5 * cm,10.2* cm, 2 * cm, 2.5 * cm])
        style = TableStyle(
            [
                ('ALIGN',(0,0),(4,0),'CENTER'),
                ('GRID', (0, 0), (-1, -1), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 7),  
                ('ALIGN',(4,1),(-1,-1),'LEFT'), 
                ('VALIGN',(0,0),(-1,-1),'TOP'),          
            ]
        )
        tabla_detalle.setStyle(style)
        return tabla_detalle

def imprimir(self):
        y=300
        buffer = self.buffer
        izquierda = ParagraphStyle('parrafos',
                                   alignment = TA_LEFT,
                                   fontSize = 10,
                                   fontName="Times-Roman")
        doc = SimpleDocTemplate(buffer,
                                rightMargin=50,
                                leftMargin=50,
                                topMargin=20,
                                bottomMargin=50,
                                pagesize=self.pagesize)

        elements = [] 
        styles = getSampleStyleSheet()        
        elements.append(self.tabla_encabezado(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_datos(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_detalle())
        elements.append(Spacer(1,0.25 * cm))
        elements.append(self.tabla_total_letras())        
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_otros())
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_observaciones())
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_afectacion_presupuestal())
        linea_firma = Line(280, y-250, 470, y-250)
        d = Drawing(100, 1)
        d.add(linea_firma)
        elements.append(d)
        doc.build(elements)
        pdf = buffer.getvalue()
        buffer.close()
        return pdf

def cuadro_observaciones(self,pdf,y,orden):
        p = ParagraphStyle('parrafos')
        p.alignment = TA_JUSTIFY 
        p.fontSize = 10
        p.fontName="Times-Roman"
        obs=Paragraph("Observaciones: "+orden.observaciones,p)
        observaciones = [[obs]]
        tabla_observaciones = Table(observaciones,colWidths=[18.50 * cm], rowHeights=1.8 * cm)
        tabla_observaciones.setStyle(TableStyle(
            [
                ('GRID', (0, 0), (0, 2), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 8),
                ('ALIGN',(0,0),(-1,-1),'LEFT'),
                ('VALIGN',(0,0),(-1,-1),'TOP'),
            ]
        ))
        tabla_observaciones.wrapOn(pdf, 800, 600)
        tabla_observaciones.drawOn(pdf, 40,y-58)

def detalle(self,pdf,y,conformidad):
        encabezados = ('ITEM', 'DETALLE DEL SERVICIO')
        p = ParagraphStyle('parrafos')
        p.alignment = TA_JUSTIFY 
        p.fontSize = 9
        p.fontName="Times-Roman"
        detalles = []
        cont = 0
        for detalle in DetalleConformidadServicio.objects.filter(conformidad=conformidad):
            descripcion = detalle.detalle_orden_servicios.detalle_cotizacion.detalle_requerimiento.producto.descripcion+'-'+detalle.detalle_orden_servicios.detalle_cotizacion.detalle_requerimiento.uso
            if len(descripcion)>58:
                cont = cont + 1
            detalles.append((detalle.nro_detalle, Paragraph(descripcion,p)))
        adicionales = [('','')]*(8-cont-len(detalles))
        detalle_orden = Table([encabezados] + detalles + adicionales,colWidths=[0.8 * cm, 17* cm])
        detalle_orden.setStyle(TableStyle(
            [
                ('ALIGN',(0,0),(1,0),'CENTER'),
                ('GRID', (0, 0), (-1, -1), 1, colors.black), 
                #('LINEBELOW', (0,1), (5,-1), 0, colors.black),                  
                ('FONTSIZE', (0, 0), (-1, -1), 8),  
                ('ALIGN',(1,1),(-1,-1),'RIGHT'),           
            ]
        ))
        detalle_orden.wrapOn(pdf, 800, 600)
        detalle_orden.drawOn(pdf, 40,y+75)

def tabla_detalle(self):
        requerimiento = self.requerimiento
        encabezados = ['Nro', 'Cantidad', 'Unidad', u'Descripción', 'Uso']
        detalles = DetalleRequerimiento.objects.filter(requerimiento=requerimiento)
        sp = ParagraphStyle('parrafos')
        sp.alignment = TA_JUSTIFY
        sp.fontSize = 8
        sp.fontName = "Times-Roman"
        lista_detalles = []
        for detalle in detalles:
            tupla_producto = [Paragraph(str(detalle.nro_detalle), sp),
                              Paragraph(str(detalle.cantidad), sp),
                              Paragraph(detalle.producto.unidad_medida.descripcion, sp),
                              Paragraph(detalle.producto.descripcion, sp),
                              Paragraph(detalle.uso, sp)]
            lista_detalles.append(tupla_producto)
        adicionales = [('', '', '', '', '')] * (15 - len(detalles))
        tabla_detalle = Table([encabezados] + lista_detalles, colWidths=[0.8 * cm, 2 * cm, 2.5 * cm, 7 * cm, 7.7 * cm])
        style = TableStyle(
            [
                ('ALIGN', (0, 0), (4, 0), 'CENTER'),
                ('GRID', (0, 0), (-1, -1), 1, colors.black),
                ('FONTSIZE', (0, 0), (-1, -1), 7),
                ('ALIGN', (4, 1), (-1, -1), 'LEFT'),
                ('VALIGN', (0, 0), (-1, -1), 'TOP'),
            ]
        )
        tabla_detalle.setStyle(style)
        return tabla_detalle

def obtener_firma(self, firma_trabajador):
        p = ParagraphStyle('parrafos',
                           alignment=TA_CENTER,
                           fontSize=8,
                           fontName="Times-Roman")
        if firma_trabajador != '':
            archivo_firma = os.path.join(settings.MEDIA_ROOT, str(firma_trabajador))
            firma = Image(archivo_firma, width=90, height=50, hAlign='CENTER')
        else:
            firma = Paragraph(u"Firma No Encontrada", p)
        return firma

def tabla_encabezado(self, styles):
        movimiento = self.movimiento        
        sp = ParagraphStyle('parrafos',
                            alignment = TA_CENTER,
                            fontSize = 14,
                            fontName="Times-Roman")
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT,str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50,hAlign='LEFT')
        except:
            imagen = Paragraph(u"LOGO", sp)

        if movimiento.tipo_movimiento.incrementa:
            nota = Paragraph(u"NOTA DE INGRESO N°", sp)
        else:
            nota = Paragraph(u"NOTA DE SALIDA N°", sp)
        id_movimiento = Paragraph(movimiento.id_movimiento, sp)
        fecha = Paragraph("FECHA: "+movimiento.fecha_operacion.strftime('%d/%m/%y'), sp)        
        encabezado = [[imagen,nota,fecha],
                      ['',id_movimiento,'']
                      ]
        tabla_encabezado = Table(encabezado,colWidths=[4 * cm, 9 * cm, 6 * cm])
        tabla_encabezado.setStyle(TableStyle(
            [
                ('VALIGN',(0,0),(2,0),'CENTER'),
                ('VALIGN',(1,1),(2,1),'TOP'),                
                ('SPAN',(0,0),(0,1)),                        
            ]
        ))
        return tabla_encabezado

def tabla_datos(self, styles):
        movimiento = self.movimiento
        izquierda = ParagraphStyle('parrafos',
                            alignment = TA_LEFT,
                            fontSize = 10,
                            fontName="Times-Roman")
        try:
            if movimiento.referencia.cotizacion is not None:
                proveedor = Paragraph(u"PROVEEDOR: "+movimiento.referencia.cotizacion.proveedor.razon_social,izquierda)
            else:
                proveedor = Paragraph(u"PROVEEDOR: "+movimiento.referencia.proveedor.razon_social,izquierda)
        except:
            proveedor = Paragraph(u"PROVEEDOR:",izquierda)
        operacion = Paragraph(u"OPERACIÓN: "+movimiento.tipo_movimiento.descripcion,izquierda)
        almacen = Paragraph(u"ALMACÉN: "+movimiento.almacen.codigo+"-"+movimiento.almacen.descripcion,izquierda)
        try:
            orden_compra = Paragraph(u"ORDEN DE COMPRA: "+movimiento.referencia.codigo,izquierda)
        except:
            orden_compra = Paragraph(u"REFERENCIA: -",izquierda)
        try:
            documento = Paragraph(u"DOCUMENTO: "+movimiento.tipo_documento.descripcion + " SERIE:" + movimiento.serie + u" NÚMERO:" + movimiento.numero,
                                  izquierda)
        except:
            documento = ""
        try:
            pedido = Paragraph(u"PEDIDO: "+movimiento.pedido.codigo, izquierda)
        except:
            pedido = ""
        encabezado = [[operacion,''],
                      [almacen,''],
                      [proveedor,''],
                      [orden_compra,''],
                      [documento,''],
                      [pedido,'']]
        tabla_datos = Table(encabezado,colWidths=[11 * cm, 9 * cm])
        tabla_datos.setStyle(TableStyle(
            [

            ]
        ))
        return tabla_datos

def tabla_detalle(self):
        movimiento = self.movimiento
        encabezados = ['Item', 'Cantidad', 'Unidad', u'Descripción','Precio','Total']
        detalles = DetalleMovimiento.objects.filter(movimiento=movimiento).order_by('pk')
        sp = ParagraphStyle('parrafos')
        sp.alignment = TA_JUSTIFY 
        sp.fontSize = 8
        sp.fontName="Times-Roman"        
        lista_detalles = []
        for detalle in detalles:
            tupla_producto = [str(detalle.nro_detalle),
                              format(detalle.cantidad,'.5f'),
                              str(detalle.producto.unidad_medida.codigo),
                              detalle.producto.descripcion,
                              format(detalle.precio,'.5f'),
                              format(detalle.valor,'.5f')]
            lista_detalles.append(tupla_producto)
        adicionales = [('','','','','')] * (15-len(lista_detalles))
        tabla_detalle = Table([encabezados] + lista_detalles,colWidths=[1.5 * cm, 2.5 * cm, 1.5 * cm,10* cm, 2 * cm, 2.5 * cm])
        style = TableStyle(
            [
                ('GRID', (0, 0), (-1, -1), 1, colors.black), 
                ('FONTSIZE', (0, 0), (-1, -1), 8),  
                ('ALIGN',(4,0),(-1,-1),'RIGHT'),            
            ]
        )
        tabla_detalle.setStyle(style)
        return tabla_detalle

def tabla_firmas(self):
        movimiento = self.movimiento
        izquierda = ParagraphStyle('parrafos',
                            alignment = TA_CENTER,
                            fontSize = 8,
                            fontName="Times-Roman")
        nombre_oficina_administracion = Paragraph(OFICINA_ADMINISTRACION.nombre,izquierda)
        nombre_oficina_logistica = Paragraph(LOGISTICA.nombre,izquierda)
        if movimiento.tipo_movimiento.incrementa:            
            total = [[nombre_oficina_administracion,'', nombre_oficina_logistica]]
            tabla_firmas = Table(total,colWidths=[7 * cm,4 * cm,7 * cm])
            tabla_firmas.setStyle(TableStyle(
                [
                    ("LINEABOVE", (0,0), (0,0), 1, colors.black),
                    ("LINEABOVE", (2,0), (2,0), 1, colors.black),
                    ('VALIGN',(0,0),(-1,-1),'TOP'),
                ]
            ))
        else:
            solicitante = Paragraph('SOLICITANTE',izquierda)
            total = [[nombre_oficina_administracion,'',nombre_oficina_logistica,'',solicitante]]
            tabla_firmas = Table(total,colWidths=[5 * cm, 1 * cm, 5 * cm, 1 * cm, 5 * cm])
            tabla_firmas.setStyle(TableStyle(
                [
                    ("LINEABOVE", (0,0), (0,0), 1, colors.black),
                    ("LINEABOVE", (2,0), (2,0), 1, colors.black),
                    ("LINEABOVE", (4,0), (4,0), 1, colors.black),
                    #("LINEABOVE", (2,0), (2,0), 1, colors.black),
                    ('VALIGN',(0,0),(-1,-1),'TOP'),
                ]
            ))

        return tabla_firmas

def imprimir(self):
        y=300
        buffer = self.buffer
        izquierda = ParagraphStyle('parrafos',
                                   alignment = TA_LEFT,
                                   fontSize = 10,
                                   fontName="Times-Roman")
        doc = SimpleDocTemplate(buffer,
                                rightMargin=50,
                                leftMargin=50,
                                topMargin=20,
                                bottomMargin=50,
                                pagesize=self.pagesize)

        elements = [] 
        styles = getSampleStyleSheet()        
        elements.append(self.tabla_encabezado(styles))
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_datos(styles))        
        elements.append(Spacer(1, 0.25 * cm))
        elements.append(self.tabla_detalle())
        elements.append(Spacer(1,0.25 * cm))
        elements.append(self.tabla_total())   
        elements.append(Spacer(1, 0.25 * cm))     
        elements.append(self.tabla_observaciones())
        elements.append(Spacer(1, 4 * cm))
        elements.append(self.tabla_firmas())        
        doc.build(elements, onFirstPage=self.pie_pagina, onLaterPages=self.pie_pagina)
        pdf = buffer.getvalue()
        buffer.close()
        return pdf

def _header_footer(self, canvas, doc):
        canvas.saveState()
        sp = ParagraphStyle('parrafos',
                            alignment=TA_CENTER,
                            fontSize=14,
                            fontName="Times-Roman")
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT, str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50, hAlign='LEFT')
        except:
            imagen = Paragraph(u"LOGO", sp)
        ruc_empresa = "RUC: " + EMPRESA.ruc
        if self.grupos:
            titulo = Paragraph(u"RESUMEN MENSUAL DE ALMACÉN POR GRUPOS Y CUENTAS", sp)
        else:
            titulo = Paragraph(u"RESUMEN MENSUAL DE ALMACÉN", sp)
        periodo = "PERIODO: " + self.desde.strftime('%d/%m/%Y') + ' - ' + self.hasta.strftime('%d/%m/%Y')
        pagina  = u"Página " + str(doc.page) + " de " + str(self.total_paginas)
        encabezado = [[imagen, titulo, pagina],[ruc_empresa,periodo,""]]
        tabla_encabezado = Table(encabezado, colWidths=[3 * cm, 20 * cm, 3 * cm])
        style = TableStyle(
            [
                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
            ]
        )
        tabla_encabezado.setStyle(style)
        tabla_encabezado.wrapOn(canvas, 50, 510)
        tabla_encabezado.drawOn(canvas, 50, 510)
        canvas.restoreState()

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

        sp = ParagraphStyle('parrafos',
                            alignment=TA_CENTER,
                            fontSize=14,
                            fontName="Times-Roman")
        try:
            archivo_imagen = os.path.join(settings.MEDIA_ROOT, str(EMPRESA.logo))
            imagen = Image(archivo_imagen, width=90, height=50, hAlign='LEFT')
        except:
            imagen = Paragraph(u"LOGO", sp)
        ruc_empresa = "RUC: " + EMPRESA.ruc
        if self.valorizado:
            titulo = Paragraph(u"REGISTRO DEL INVENTARIO PERMANENTE VALORIZADO", sp)
        else:
            titulo = Paragraph(u"REGISTRO DEL INVENTARIO PERMANENTE EN UNIDADES FÍSICAS",sp)
        pagina = u"Página " + str(doc.page) + " de " + str(self.total_paginas)
        encabezado = [[imagen, titulo, pagina], [ruc_empresa, "", ""]]
        tabla_encabezado = Table(encabezado, colWidths=[3 * cm, 20 * cm, 3 * cm])
        style = TableStyle(
            [
                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
            ]
        )
        tabla_encabezado.setStyle(style)
        tabla_encabezado.wrapOn(canvas, 50, 510)
        tabla_encabezado.drawOn(canvas, 50, 510)
        canvas.restoreState()

def __init__(self, records, Lang):
        self.records, self.Lang = records, Lang
        styles = getSampleStyleSheet()
        styles.add(ParagraphStyle(name='Justify', wordWrap=True))
        styles.add(
            ParagraphStyle(
                name='Pre',
                wordWrap=True,
                fontName=FONT_FAMILY,
                fontSize=FONT_SIZE['rightpane'],
                spaceAfter=FONT_SIZE['rightpane']))
        self.style = styles['Justify']
        self.style_pre = styles['Pre']

def _getCaptionPara(self):
        caption = self.caption
        captionFont = self.captionFont
        captionSize = self.captionSize
        captionTextColor = self.captionTextColor
        captionBackColor = self.captionBackColor
        captionAlign = self.captionAlign
        captionPosition = self.captionPosition
        if self._captionData!=(caption,captionFont,captionSize,captionTextColor,captionBackColor,captionAlign,captionPosition):
            self._captionData = (caption,captionFont,captionSize,captionTextColor,captionBackColor,captionAlign,captionPosition)
            if isinstance(caption,Paragraph):
                self.captionPara = caption
            elif isinstance(caption,strTypes):
                self.captionStyle = ParagraphStyle(
                    'Caption',
                    fontName=captionFont,
                    fontSize=captionSize,
                    leading=1.2*captionSize,
                    textColor = captionTextColor,
                    backColor = captionBackColor,
                    #seems to be getting ignored
                    spaceBefore=self.captionGap,
                    alignment=TA_LEFT if captionAlign=='left' else TA_RIGHT if captionAlign=='right' else TA_CENTER,
                    )
                #must build paragraph now to get sequencing in synch with rest of story
                self.captionPara = Paragraph(self.caption, self.captionStyle)
            else:
                raise ValueError('Figure caption of type %r is not a string or Paragraph' % type(caption))

def demo1(canvas):
    frame = Frame(
                    2*inch,     # x
                    4*inch,     # y at bottom
                    4*inch,     # width
                    5*inch,     # height
                    showBoundary = 1  # helps us see what's going on
                    )
    bodyStyle = ParagraphStyle('Body', fontName=_baseFontName, fontSize=24, leading=28, spaceBefore=6)
    para1 = Paragraph('Spam spam spam spam. ' * 5, bodyStyle)
    para2 = Paragraph('Eggs eggs eggs. ' * 5, bodyStyle)
    mydata = [para1, para2]

    #this does the packing and drawing.  The frame will consume
    #items from the front of the list as it prints them
    frame.addFromList(mydata,canvas)

def getLevelStyle(self, n):
        '''Returns the style for level n, generating and caching styles on demand if not present.'''
        try:
            return self.levelStyles[n]
        except IndexError:
            prevstyle = self.getLevelStyle(n-1)
            self.levelStyles.append(ParagraphStyle(
                    name='%s-%d-indented' % (prevstyle.name, n),
                    parent=prevstyle,
                    firstLineIndent = prevstyle.firstLineIndent+delta,
                    leftIndent = prevstyle.leftIndent+delta))
            return self.levelStyles[n]

def getLevelStyle(self, n):
        '''Returns the style for level n, generating and caching styles on demand if not present.'''
        if not hasattr(self.textStyle, '__iter__'):
            self.textStyle = [self.textStyle]
        try:
            return self.textStyle[n]
        except IndexError:
            self.textStyle = list(self.textStyle)
            prevstyle = self.getLevelStyle(n-1)
            self.textStyle.append(ParagraphStyle(
                    name='%s-%d-indented' % (prevstyle.name, n),
                    parent=prevstyle,
                    firstLineIndent = prevstyle.firstLineIndent+.2*cm,
                    leftIndent = prevstyle.leftIndent+.2*cm))
            return self.textStyle[n]

def __init__(self, textPattern, targetKey):
        self.textPattern = textPattern
        self.target = targetKey
        self.paraStyle = ParagraphStyle('tmp')
        self._lastPageNum = None
        self._pageNum = -999
        self._para = None

def test_08_table(self):
        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
        from reportlab.platypus import SimpleDocTemplate, Spacer, Paragraph, Table
        from reportlab.lib.units import inch
        from reportlab.lib.enums import TA_JUSTIFY
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont
        from reportlab.lib import fonts, colors

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        stylesheet = getSampleStyleSheet()

        elements = []
        doc = SimpleDocTemplate("demo.pdf")

        elements.append(Paragraph('<font name="chsFont">AUT OOM????</font>', stylesheet['Title']))
        elements.append(Spacer(1,12))

        stylesheet.add(ParagraphStyle(name="Justify", alignment=TA_JUSTIFY))
        stylesheet['Justify'].contName = 'chsFont'

        data  = []
        data.append(["???","???","???"])
        data.append(["120","6","50"])
        ts = [('INNERGRID',(0,0),(-1,-1),0.25, colors.black),("BOX",(0,0),(-1,-1),0.25,colors.black),('FONT',(0,0),(-1,-1), 'chsFont')]
        table = Table(data, 2.1*inch, 0.24*inch, ts)
        elements.append(table)

        doc.build(elements)

def _unpaid_list_header(canvas, doc, event):
        canvas.saveState()
        canvas.drawImage(LOGO_PATH, 0.45 * inch, PAGE_HEIGHT - inch * 0.75,
                         height=0.5 * inch, width=1.875*inch)
        canvas.setLineWidth(2)
        canvas.line(0.45 * inch, PAGE_HEIGHT - inch * 0.8,
                    PAGE_WIDTH - 0.45 * inch, PAGE_HEIGHT - inch * 0.8)
        canvas.setLineWidth(1)
        canvas.line(0.45 * inch, PAGE_HEIGHT - inch * 0.84,
                    PAGE_WIDTH - 0.45 * inch, PAGE_HEIGHT - inch * 0.84)
        canvas.setFont('Helvetica-Bold', 18)
        canvas.drawCentredString(PAGE_WIDTH/2, PAGE_HEIGHT - inch * 1.15,
                                 'UNPAID DELEGATE LIST')
        canvas.line(PAGE_WIDTH / 2 - inch * 1.5, PAGE_HEIGHT - inch * 1.18,
                    PAGE_WIDTH / 2 + inch * 1.5, PAGE_HEIGHT - inch * 1.18)
        style = ParagraphStyle(
            name='textStyle',
            fontName='Helvetica',
            fontSize=11,
            leading=13,
            alignment=TA_LEFT,
        )
        boilerplate = Paragraph(
            'The undersigned acknowledges having attended "<b>' + \
                event.title + \
                '</b>" that ran beginning on ' + \
                event.date_begins.strftime('%-d %B, %Y') + \
                ', and has received all materials and related benefits of ' \
                'said conference.',
            style
        )
        h = boilerplate.wrap(doc.width, inch * 1.5)[1]
        boilerplate.drawOn(canvas, doc.leftMargin, PAGE_HEIGHT - inch * 1.25 - h)

        canvas.restoreState()

def Set_Consolidation(self):

        style1=ParagraphStyle(name='normal',fontSize = 8,alignment = TA_CENTER)


        t1=Paragraph('<font size=6 >Boys</font>',style1)
        t2=Paragraph('<font size=6>Girls</font>',style1)
        t3=Paragraph('<font size=6>Total</font>',style1)
        t4=Paragraph('<font size= 7>Total No of Students</font>',style1)
        t5=Paragraph('<font size= 7>No of Students Promoted</font>',style1)
        t6=Paragraph('<font size= 7>No of Students Detained</font>',style1)
        t7=Paragraph('<font size=7 >Percetage of Promotion</font>',style1)

        t8=Paragraph('<font size=8 >Place :</font>',style1)
        t9=Paragraph('<font size=8 >Date :</font>',style1)
        t10=Paragraph('<font size=8 >School Seal</font>',style1)
        t11=Paragraph('<font size=8 >Name and Signature of Class Teacher</font>',style1)
        t12=Paragraph('<font size=8 >Signature of Head of the School</font>',style1)

        pass_percentage='0'
        try:
            pass_percentage=round((self.passed_no*100)/self.total_no,2)
            pass_percentage=str(pass_percentage)
            splt=pass_percentage.split('.')
        except:
            print 'nopass percnt'
        if len(splt)==2:
            pass_percentage=splt[0]+"."+splt[1][:2]         

        self.total_no=Paragraph('<font size=7 >'+str(self.total_no)+'</font>',style1)
        self.passed_no=Paragraph('<font size=7 >'+str(self.passed_no)+'</font>',style1)
        self.failed_no=Paragraph('<font size=7 >'+str(self.failed_no)+'</font>',style1)
        pass_percentage=Paragraph('<font size=7 >'+str(pass_percentage)+'</font>',style1)

        row1=['','',t1,t2,t3,'','','']
        row2=[t8,t4,'  ','',self.total_no,'','','']
        row3=['',t5,'  ','',self.passed_no,'','','']
        row4=[t9,t6,'  ','',self.failed_no,t10,t11,t12]
        row5=['',t7,'  ','',pass_percentage,'','','']

        self.CONSOLIDATION=[row1,row2,row3,row4,row5]

def Format_Adm_No(self,ad_no):

        style = getSampleStyleSheet()
        normal = style["Normal"]

        style1=ParagraphStyle(name='normal',fontSize = 8,alignment = TA_CENTER)


        ad_text= Paragraph('<font size=6>'+str(ad_no)+'</font>',style1)
        return verticaltext(str(ad_no))