def drawCalendarPage(c, year, month):
    width = landscape(A4)[0] - 20*mm
    height = landscape(A4)[1] - 20*mm

    # leave 1cm margin on page
    drawable_h = height - titlesize - 5*mm
    c.translate(10*mm, 10*mm)
    
    # draw rounded background rect
    c.saveState()
    c.setStrokeColor(framefgcolor)
    c.setFillColor(framebgcolor)
    c.roundRect(0, 0, width, drawable_h, 5*mm, fill=1)
    c.restoreState()

    # place header 5mm from the left/right border sides
    c.saveState()
    c.translate(5*mm, height - titlesize) 
    drawHeader(c, year, month, width - 10*mm, titlesize)
    c.restoreState()

    # draw grid with a 5mm margin to the border
    c.saveState()
    c.translate(5*mm, 5*mm)
    drawGrid(c, year, month, width - 10*mm, drawable_h - 10*mm)
    c.restoreState()

    # show the page
    c.showPage()
    return

def print_cards():
    #LETTER = (8.5, 11)
    LETTER = (11, 8.5)
    DPI = 72
    # Set print margins
    MARGIN = 0.5
    x_offset = int(MARGIN * DPI)
    y_offset = int(MARGIN * DPI)
    CARDSIZE = (int(2.49 * DPI), int(3.48 * DPI))
    #scale = CARDSIZE[0] / 375.0  # Default cardsize in px
    cards = convert_to_cards(session['cardtext'])
    byte_io = BytesIO()
    from reportlab.pdfgen import canvas
    canvas = canvas.Canvas(byte_io, pagesize=landscape(letter))
    WIDTH, HEIGHT = landscape(letter)
    #draw = ImageDraw.Draw(sheet)
    for card in cards:
        image = create_card_img(card,session["do_google"])
        image_reader = ImageReader(image)
        canvas.drawImage(image_reader,
                         x_offset,
                         y_offset,
                         width=CARDSIZE[0],
                         height=CARDSIZE[1])
        x_offset += CARDSIZE[0] + 5  # 5 px border around cards
        if x_offset + CARDSIZE[0] > LETTER[0] * DPI:
            x_offset = int(MARGIN * DPI)
            y_offset += CARDSIZE[1] + 5
        if y_offset + CARDSIZE[1] > LETTER[1] * DPI:
            x_offset = int(MARGIN * DPI)
            y_offset = int(MARGIN * DPI)
            canvas.showPage()
    canvas.save()
    byte_io.seek(0)
    return send_file(byte_io, mimetype='application/pdf')

def conpdf(f_jpg):
    f_pdf = filename+'.pdf'
    (w, h) = landscape(A4)
    c = canvas.Canvas(f_pdf, pagesize = landscape(A4))
    c.drawImage(f, 0, 0, w, h)
    c.save()
    print "okkkkkkkk."

 def __init__(self, buffer, pagesize):
   self.buffer = buffer
   if pagesize == 'A4':
     self.pagesize = landscape(A4)
   elif pagesize == 'Letter':
     self.pagesize = landscape(letter)
     self.width, self.height = self.pagesize

def bmp2pdf():
    """ bmp -> pdf
    """
    c = canvas.Canvas('bmp2pdf.pdf', pagesize=landscape(A4))
    (w, h) = landscape(A4)
    width, height = letter
    #c.drawImage(filename, inch, height - 2 * inch) # Who needs consistency?
    c.drawImage('bmp2pdf.bmp', 0, 0, w, h)
    c.showPage()
    c.save()

def drawCoverPage(c, filename):
    width = landscape(A4)[0] - 20*mm
    height = landscape(A4)[1] - 20*mm

    # leave 1cm margin on page
    drawable_h = height - titlesize - 5*mm

    # draw image
    c.drawImage(filename, 10*mm, 10*mm, width=width, height=height,
                preserveAspectRatio=True)

    # show the page
    c.showPage()

def StringIO2pdf():
    """ bmp -> StringIO -> ImageReader -> pdf
    """
    with open('bmp2pdf.bmp', 'rb') as f:
        buf = StringIO.StringIO(f.read())
        ir = ImageReader(buf)
        c = canvas.Canvas('StringIO2pdf.pdf', pagesize=landscape(A4))
        (w, h) = landscape(A4)
        width, height = letter
        #c.drawImage(filename, inch, height - 2 * inch) # Who needs consistency?
        c.drawImage(ir, 0, 0, w, h)
        c.showPage()
        c.save()

 def get_frame(self, debug, side='Left'): # or Right
     x1 = 0
     if side == 'Right':
         x1 = landscape(letter)[0]/2
     return Frame(x1=x1,
                  y1=0,
                  width=landscape(letter)[0]/2,
                  height=landscape(letter)[1],
                  leftPadding=self.left_padding,
                  bottomPadding=DEFAULT_PADDING,
                  rightPadding=self.right_padding,
                  topPadding=DEFAULT_PADDING,
                  showBoundary=debug)

def createPDF(pdf, texts):
    page = pagesizes.landscape(pagesizes.A4)
    pdf.setFillColorRGB(0.0, 0.0, 0.0)
    pdf.setPageSize(page)
    for text in texts:
        centerString(pdf, page, text)
        pdf.showPage()

 def render(self):
     elements = []
     
     self.styles['Title'].alignment = TA_LEFT
     self.styles['Title'].fontName = self.styles['Heading2'].fontName = "Helvetica"
     self.styles["Normal"].fontName = "Helvetica"
     self.styles["Normal"].fontSize = 10
     self.styles["Normal"].fontWeight = "BOLD"
         
     filename = self.filename + datetime.now().strftime("%Y%m%d%H%M%S") + ".pdf"
     doc = SimpleDocTemplate(filename)
     
     elements.append(Paragraph(self.title, self.styles['Title']))
     
     clinics = Provider.objects.values('clinic').distinct()
     
     for data in self.data:
         elements.append(data)
     
     #elements.append(Paragraph("Created: %s" % datetime.now().strftime("%d/%m/%Y"), styles["Normal"]))        
     if self.landscape is True:
         doc.pagesize = landscape(A4)
     
     doc.build(elements, onFirstPage=self.myFirstPage, onLaterPages=self.myLaterPages)
     
     response = HttpResponse(mimetype='application/pdf')
     response['Cache-Control'] = ""
     response['Content-Disposition'] = "attachment; filename=%s" % filename
     response.write(open(filename).read())
     os.remove(filename)
     return response

def generate_sertificate(first_name, last_name, employment, pdf_file_name):
    attendee_name = first_name + ' ' + last_name
    c = canvas.Canvas(pdf_file_name, pagesize=landscape(letter))

    # header text
    c.setFont('Helvetica', 48, leading=None)
    c.drawCentredString(415, 500, 'Employee Certificate')
    c.setFont('Helvetica', 24, leading=None)
    c.drawCentredString(415, 450, 'This certificate is presented to:')
    # attendee name
    c.setFont('Helvetica-Bold', 34, leading=None)
    c.drawCentredString(415, 395, attendee_name)
    # for completing the...
    c.setFont('Helvetica', 24, leading=None)
    c.drawCentredString(415, 350, 'who holds the position in the IT company of:')
    # employment
    c.setFont('Helvetica', 20, leading=None)
    c.drawCentredString(415, 310, employment)
    # image of seal
    seal = 'certificate.ico'
    c.drawImage(seal, 350, 150, width=100, height=100)

    c.showPage()

    c.save()

    def write_string_to_pdf(self, participants_name):
        outputfiletemp = 'output/testoutput.pdf'
        pdf1File = open('templates/participants.pdf', 'rb')
        pdf1Reader = PyPDF2.PdfFileReader(pdf1File)
        pdfWriter = PyPDF2.PdfFileWriter()

        packet = StringIO.StringIO()

        cv=canvas.Canvas(packet, pagesize=letter)
        cv.setPageSize(landscape(letter))
        #create a string
        cv.drawString(350, 300, participants_name)
        #save to string
        cv.save()
        #write to a file
        with open(outputfiletemp,'wb') as fp:
            fp.write(packet.getvalue())

        certFirstPage = pdf1Reader.getPage(0)
        pdfWatermarkReader = PyPDF2.PdfFileReader(open(outputfiletemp, 'rb'))
        certFirstPage.mergePage(pdfWatermarkReader.getPage(0))
        pdfWriter.addPage(certFirstPage)

        pdfOutputFile = open('output/pyconph2015_certificate_' + participants_name + '.pdf', 'wb')
        pdfWriter.write(pdfOutputFile)
        pdfOutputFile.close()
        pdf1File.close()

def reporte_proveedores(request):
    print ("Genero el PDF");
    response = HttpResponse(content_type='application/pdf')
    pdf_name = "proveedores.pdf"  # llamado clientes
    # la linea 26 es por si deseas descargar el pdf a tu computadora
    # response['Content-Disposition'] = 'attachment; filename=%s' % pdf_name
    buff = BytesIO()
    doc = SimpleDocTemplate(buff,
                            pagesize=landscape(legal),
                            rightMargin=40,
                            leftMargin=40,
                            topMargin=60,
                            bottomMargin=18,
                            )
    proveedores = []
    styles = getSampleStyleSheet()
    header = Paragraph("Listado de Proveedores", styles['Heading1'])
    proveedores.append(header)
    headings = ('No. Proveedor','Nombre','RFC','Giro','Direccion','Ciudad','Estado','Pais','Telefono','Correo','Comentario')
    allproveedores = [(p.num_proveedor, p.nombre, p.RFC ,p.giro ,p.direccion ,p.ciudad ,p.estado ,p.pais ,p.telefono ,p.correo ,p.comentario) for p in Proveedor.objects.all()]
    print (allproveedores);

    t = Table([headings] + allproveedores)
    t.setStyle(TableStyle(
        [
            ('GRID', (0, 0), (12, -1), 1, colors.dodgerblue),
            ('LINEBELOW', (0, 0), (-1, 0), 2, colors.darkblue),
            ('BACKGROUND', (0, 0), (-1, 0), colors.dodgerblue)
        ]
    ))
    proveedores.append(t)
    doc.build(proveedores)
    response.write(buff.getvalue())
    buff.close()
    return response

    def __init__(self, filename, title_left, title_right, portrait=True):
        if portrait is True:
            page_size = A4
            column_width = 8*cm
        else:
            page_size = landscape(A4)
            column_width = 13*cm
        SimpleDocTemplate.__init__(self, filename, pagesize=page_size,
                                   topMargin=0*cm,
                                   leftMargin=2 * cm,
                                   rightMargin=2 * cm,
                                   bottomMargin=0.5 * cm,
                                   )
        self.fileName = filename
        im1 = Image(settings.MEDIA_ROOT + 'logo_EPC.png', width=170, height=80, hAlign=TA_LEFT)
        data = list()
        data.append([im1, ''])
        data.append([Spacer(0, 0.5*cm)])

        data.append([title_left, title_right])
        t = Table(data, colWidths=[column_width]*2, hAlign=TA_LEFT)
        t.setStyle(
            TableStyle(
                [
                    ('SIZE', (0, 0), (-1, -1), 9),
                    ('FONT', (0, 0), (-1, 0), 'Helvetica-Bold'),
                    ('ALIGN', (0, 0), (0, 0), 'LEFT'),
                    ('ALIGN', (1, 0), (-1, -1), 'RIGHT'),
                    ('LINEABOVE', (0, 0), (-1, -1), 0.5, colors.black),
                    ('LINEBELOW', (0, -1), (-1, -1), 0.5, colors.black),
                ]
            )
        )
        self.flowable.append(t)

 def __init__(self,filename):
     self.filename = r"%s" % filename
     self.myold = oldpdf(self.filename)
     self.canvas_obj = canvas.Canvas(self.filename,pagesize=pagesizes.landscape(letter))
     self.canvas_obj.grid(self.make_listx(),self.make_listy())
     self.canvas_obj.setFont("Times-Roman", self.fontsize_to_fit)
     self.label_axes()

	def render(self):
		resp = HttpResponse(content_type='application/pdf')

		registerFont(TTFont('DejaVu Serif', "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSerif.ttf"))
		pagesize = self.orientation=='portrait' and A4 or landscape(A4)
		doc = SimpleDocTemplate(resp, pagesize=pagesize)

		story = []

		story.append(Paragraph(self.title, getSampleStyleSheet()['title']))

		tbldata = [self.headers]
		tbldata.extend(self.rows)
		t = Table(tbldata, splitByRow=1, repeatRows=1)
		style = [
			("FONTNAME", (0, 0), (-1, -1), "DejaVu Serif"),
			]
		if self.borders:
			style.extend([
			('GRID', (0,0), (-1, -1), 1, colors.black),
			('BACKGROUND', (0,0), (-1,0), colors.lightgrey),
			])
		t.setStyle(TableStyle(style))
		story.append(t)

		doc.build(story)

		return resp

def __to_pdf(tempFile, breakdown, building, begin_ts, end_ts):
    doc = SimpleDocTemplate(tempFile, pagesize=landscape(A4), leftMargin=MARGIN,
                            rightMargin=MARGIN, topMargin=MARGIN,
                            bottomMargin=MARGIN,
                            title=u'Lista de întreținere %s' % building.name,
                            author='www.habitam.ro')
    flowables = []
    sc_title_style = ParagraphStyle(name='staircase_title', alignment=TA_CENTER)
                         
    for sc in building.apartment_groups():
        if sc == building:
            continue
        sc_title = Paragraph(u'Lista de întreținere scara %s' % 
                             sc.name, sc_title_style)
        data = __list_data(sc, breakdown, building.services())
    
        table = Table(data, repeatRows=1)
        table.setStyle(TableStyle([
                        ('FONT', (0, 0), (-1, 0), 'Helvetica-Bold'),
                        ('VALIGN', (0, 0), (0, -1), 'TOP'),
                        ('FONTSIZE', (0, 0), (-1, -1), __FONT_SIZE__),
                        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black),
                        ('BOX', (0, 0), (-1, -1), 0.25, colors.black)
                       ]))

        flowables.extend([Spacer(1, .5 * cm), sc_title,
                          Spacer(1, cm), table,
                          Spacer(1, .5 * cm), signatures(__FONT_SIZE__),
                          PageBreak()])
    
    doc.habitam_building = building
    doc.habitam_month = begin_ts.strftime('%B %Y')
    doc.habitam_display = date.today().strftime('%d %B %Y')
    doc.build(flowables, onFirstPage=__list_format, onLaterPages=__list_format)

def print_big_list(data):
    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'inline; filename="RECAP.pdf"'

    doc = SimpleDocTemplate(response, rightMargin=20, leftMargin=20, topMargin=20, bottomMargin=20)
    doc.pagesize = landscape(A4)
    elements = []

    t = Table(data, colWidths=(None, None, 300, 60))

    # Styling the titles and the grid
    style = TableStyle([('FONT', (0, 0), (-1, 0), 'Helvetica-Bold'),
                        ('VALIGN', (0, 0), (-1, 0), 'MIDDLE'),
                        ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
                        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.grey),
                        ('BOX', (0, 0), (-1, -1), 0.25, colors.grey),
                        ])

    t.setStyle(style)

    # we color lines alternatively
    for each in range(len(data)):
        if each % 2 == 0:
            bg_color = colors.white
        else:
            bg_color = colors.lightblue

        t.setStyle(TableStyle([('BACKGROUND', (0, each), (-1, each), bg_color)]))

    # Send the data and build the file
    elements.append(t)
    doc.build(elements)

    return response

    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 run(self):
        """
        Run the report
        """
        def make_landscape(canvas,doc):
            canvas.setPageSize(landscape(A4))

        # file initialization in buffer !!!!
        self.doc = BaseDocTemplate(self.buffer,
                                   showBoundary=1,   # margines
                                   pagesize=landscape(A4))

        # create the frames. Here you can adjust the margins
        frame = Frame(self.doc.leftMargin-65,
                      self.doc.bottomMargin - 50,
                      self.doc.width + 125,
                      self.doc.height + 110, id='first_frame')

        # add the PageTempaltes to the BaseDocTemplate.
        # You can also modify those to adjust the margin if you need more control over the Frames.
        self.doc.addPageTemplates(PageTemplate(id='first_page',
                                               frames=frame,
                                               onPage=make_landscape))

        self.create_text()
        self.create_table()
        self.create_footer()
        self.doc.build(self.story)