def annotpdf():
txtbox.insert(0.0, "PDF File annotation started\n\n")
print(input_pdffile_reader.getDocumentInfo())
input_pdffile_total_page = input_pdffile_reader.getNumPages()
print(input_pdffile_total_page)
output_pdffile_name = os.path.basename(import_file_path)
temp_name = output_pdffile_name.split(".")
output_pdffile_name = temp_name[0] + "_With_page_no.pdf"
print("New file name : " + output_pdffile_name)
output_pdffile_conn = open(
os.path.dirname(import_file_path) + "/" + output_pdffile_name, 'wb')
out_pdffile_writer = PyPDF2.PdfFileWriter()
# intermidiate_pdffile = io.BytesIO()
# intermidiate_pdffile_canvas = Canvas(intermidiate_pdffile, pagesize = A4)
# intermidiate_pdffile_canvas.drawString(6.9 * inch, 0.5 * inch, "page number 1")
# intermidiate_pdffile_canvas.save()
# intermidiate_pdffile.seek(0)
# intermidiate_pdffile_reader = PyPDF2.PdfFileReader(intermidiate_pdffile)
# input_pdffile_reader_page = input_pdffile_reader.getPage(0)
# input_pdffile_reader_page.mergePage(intermidiate_pdffile_reader.getPage(0))
for i in range(input_pdffile_reader.getNumPages()):
intermidiate_pdffile = io.BytesIO()
intermidiate_pdffile_canvas = Canvas(intermidiate_pdffile, pagesize=A4)
intermidiate_pdffile_canvas.drawString(
6.9 * inch, 0.2 * inch,
"Page " + str(i + 1) + " of " + str(input_pdffile_total_page))
intermidiate_pdffile_canvas.save()
intermidiate_pdffile.seek(0)
intermidiate_pdffile_reader = PyPDF2.PdfFileReader(
intermidiate_pdffile)
input_pdffile_reader_page = input_pdffile_reader.getPage(i)
input_pdffile_reader_page.mergePage(
intermidiate_pdffile_reader.getPage(0))
out_pdffile_writer.addPage(input_pdffile_reader_page)
# out_pdffile_writer.addPage(input_pdffile_reader_page)
out_pdffile_writer.write(output_pdffile_conn)
output_pdffile_conn.close()
txtbox.insert(0.0, "PDF File annotation finished.\n\n")
txtbox.insert(0.0, "Annotated PDF file created on above path ^\n\n")
txtbox.insert(
0.0,
os.path.dirname(import_file_path) + "/" + output_pdffile_name + "\n\n")
def encryptPdfInMemory(inputPDF,
userPassword,
ownerPassword=None,
canPrint=1,
canModify=1,
canCopy=1,
canAnnotate=1,
strength=40):
"""accepts a PDF file 'as a byte array in memory'; return encrypted one.
This is a high level convenience and does not touch the hard disk in any way.
If you are encrypting the same file over and over again, it's better to use
pageCatcher and cache the results."""
try:
from rlextra.pageCatcher.pageCatcher import storeFormsInMemory, restoreFormsInMemory
except ImportError:
raise ImportError(
'''reportlab.lib.pdfencrypt.encryptPdfInMemory failed because rlextra cannot be imported.
See https://www.reportlab.com/downloads''')
(bboxInfo, pickledForms) = storeFormsInMemory(inputPDF, all=1, BBoxes=1)
names = list(bboxInfo.keys())
firstPageSize = bboxInfo['PageForms0'][2:]
#now make a new PDF document
buf = getBytesIO()
canv = Canvas(buf, pagesize=firstPageSize)
# set a standard ID while debugging
if CLOBBERID:
canv._doc._ID = "[(xxxxxxxxxxxxxxxx)(xxxxxxxxxxxxxxxx)]"
formNames = restoreFormsInMemory(pickledForms, canv)
for formName in formNames:
canv.setPageSize(bboxInfo[formName][2:])
canv.doForm(formName)
canv.showPage()
encryptCanvas(canv,
userPassword,
ownerPassword,
canPrint,
canModify,
canCopy,
canAnnotate,
strength=strength)
canv.save()
return buf.getvalue()
def test(filename):
# Convert HTML to "Reportlab Story" structure
story = pisa.pisaStory("""
<h1>Sample</h1>
<p>Hello <b>World</b>!</p>
""" * 20).story
# Draw to Canvas
c = Canvas(filename)
f = Frame(inch, inch, 6 * inch, 9 * inch, showBoundary=1)
f.addFromList(story, c)
c.save()
# Show PDF
pisa.startViewer(filename)
def go(inpfn, firstpage, lastpage):
firstpage, lastpage = int(firstpage), int(lastpage)
outfn = 'subset_%s_to_%s.%s' % (firstpage, lastpage,
os.path.basename(inpfn))
pages = PdfReader(inpfn).pages
pages = [pagexobj(x) for x in pages[firstpage - 1:lastpage]]
canvas = Canvas(outfn)
for page in pages:
canvas.setPageSize(tuple(page.BBox[2:]))
canvas.doForm(makerl(canvas, page))
canvas.showPage()
canvas.save()
def review():
from reportlab.platypus import Paragraph
from reportlab.lib import colors
from reportlab.pdfgen.canvas import Canvas
c = Canvas("out/review.pdf", landscape(A4))
c.setFont("Helvetica-Bold", 36)
c.setFillColorRGB(1, 0.47, 0)
c.drawString(1 * cm, 19 * cm, "Review")
c.setFont("Helvetica-Bold", 18)
c.setFillColor(colors.black)
c.drawString(1 * cm, 17 * cm, "Story")
p = Paragraph("<para bulletanchor=start>qsdqsdqsdqdqdqddq<br/>kljkjlkjkj</para>", styles["Normal"], bulletText='\xe2\x80\xa2')
p.wrap(10 *cm, 4 * cm)
p.drawOn(c, 1 * cm, 15 * cm)
c.save()
def test_single_page_inline_image(eight_by_eight, outdir):
filename = outdir / 'image-mono-inline.pdf'
pdf = Canvas(str(filename), pagesize=(8 * 72, 6 * 72))
# Draw image in a 72x72 pt or 1"x1" area
pdf.drawInlineImage(eight_by_eight, 0, 0, width=72, height=72)
pdf.showPage()
pdf.save()
info = pdfinfo.PdfInfo(filename)
print(info)
pdfimage = info[0].images[0]
assert isclose(pdfimage.dpi.x, 8)
assert pdfimage.color == Colorspace.gray
assert pdfimage.width == 8
def assembly_guide(
underlay_def: UnderlayDefinition, marker_def: GlueMarkDefinition
) -> pdf.PageObject:
packet = BytesIO()
canvas = Canvas(packet, pagesize=underlay_def.page_size)
grid(canvas, underlay_def, marker_def)
alignment_markers(canvas, underlay_def, marker_def)
sort_markers(canvas, underlay_def, marker_def)
canvas.save()
packet.seek(0)
underlay = PdfFileReader(packet)
return underlay.pages[0]
def report_demo(self, df_path, scales_path):
my_canvas = Canvas("report_demo.pdf", pagesize=letter)
df = DataLoader().load_month_adv(df_path)
# Header
GeneralReport().add_header(my_canvas)
#Get data
GeneralReport().generate_imgs(df, "scale_path")
# Add info to canvas
GeneralReport().insert_data_in_canvas(my_canvas)
# Save canvas
my_canvas.save()
def test_single_page_inline_image():
filename = os.path.join(TEST_OUTPUT, 'image-mono-inline.pdf')
pdf = Canvas(filename, pagesize=(8 * 72, 6 * 72))
with NamedTemporaryFile() as im_tmp:
im = Image.new('1', (8, 8), 0)
for n in range(8):
im.putpixel((n, n), 1)
im.save(im_tmp.name, format='PNG')
# Draw image in a 72x72 pt or 1"x1" area
pdf.drawInlineImage(im_tmp.name, 0, 0, width=72, height=72)
pdf.showPage()
pdf.save()
with pytest.raises(NotImplementedError):
pageinfo.pdf_get_all_pageinfo(filename)
def _simple_subset_generation(fn, npages, alter=0):
c = Canvas(outputfile(fn))
c.setFont('Helvetica', 30)
c.drawString(100, 700, 'Unicode TrueType Font Test %d pages' % npages)
# Draw a table of Unicode characters
for p in xrange(npages):
for fontName in ('Vera', 'VeraBI'):
c.setFont(fontName, 10)
for i in xrange(32):
for j in xrange(32):
ch = utf8(i * 32 + j + p * alter)
c.drawString(80 + j * 13 + int(j / 16) * 4,
600 - i * 13 - int(i / 8) * 8, ch)
c.showPage()
c.save()
def get2(self, request, *args, **kwargs):
buffer = io.BytesIO()
canvas = Canvas(buffer)
# 내용을 채운다
canvas.drawString(40, 40, "canvas.drawString")
canvas.drawAlignedString(40, 80, "canvas.drawAlignedString")
canvas.drawCentredString(40, 120, "canvas.drawCentredString")
canvas.showPage()
canvas.save()
file_name = "hello.pdf"
buffer.seek(0)
return FileResponse(buffer, as_attachment=True, filename=file_name)
def start_canvas(self, filename=None):
"""Sets the PDF canvas"""
# Canvas for multiple canvas
if self.multiple_canvas:
filename = os.path.join(
self.temp_directory,
filename or self.temp_file_name % (self.temp_files_counter),
)
# Appends this filename to the temp files list
self.temp_files.append(filename)
# Increments the counter for the next file
self.temp_files_counter += 1
self.canvas = Canvas(filename=filename,
pagesize=self.report.page_size)
# Canvas for single canvas
else:
filename = filename or self.filename
self.canvas = Canvas(filename=filename,
pagesize=self.report.page_size)
def create_canvas(cords, color, packet):
# create a new PDF with Reportlab
c = Canvas(packet, pagesize=letter)
#c.drawString(10, 100, "Hello world")
cmyk_color = get_color_with_opacity(color, 40) # 40% opacity
c.setFillColor(cmyk_color)
x1 = cords[0]
y1 = cords[1]
x2 = cords[2]
y2 = cords[3]
#rect arguments are(x,y,width,height)
c.rect(x1, y1, x2 - x1, y2 - y1, fill=True, stroke=False)
c.save()
return c
def testMalColor(self):
'''attempt to test may inputs via span etc etc'''
styNormal = ParagraphStyle('normal')
ofn = outputfile('dumbo.txt')
canv = Canvas(outputfile('testMalColor.pdf'))
self.assertRaises(
ValueError, Paragraph,
'''<span color="toColor(open(%s,'w').write('dumber and dumber'))">AAA</span>'''
% ofn, styNormal)
self.assertFalse(os.path.isfile(ofn),
"toColor managed to create a file %s :(" % repr(ofn))
self.assertRaises(
ValueError, Paragraph,
'''<span color="(lambda fc=(lambda n: [c for c in ().__class__.__bases__[0].__subclasses__() if c.__name__ == n][0]): fc('function')(fc('code')(0,0,0,0,'KABOOM',(), (),(),'','',0,''),{})())()">AAA</span>''',
styNormal)
def result2pdf(result, reportfilename):
'''Write HDR 2nd check output to a PDF report.
Input: list of strings (report text).'''
# Lines per page
lpp = 48
# Pages needed in report
pages = ceil(len(result) / float(lpp))
print '# of pages:', pages
pdf = Canvas(reportfilename, pagesize=letter)
report = pdf.beginText(inch * 1, inch * 10)
# Single page report
if len(result) < lpp:
for line in result:
report.textLine(line)
pdf.drawText(report)
pdf.showPage()
# Or create a multi-page report
else:
page = 1
l = 0
while page < pages:
# Reset page contents
report = pdf.beginText(inch * 1, inch * 10)
while l < lpp * page:
print 'l:', l
report.textLine(result[l])
l += 1
pdf.drawText(report)
pdf.showPage()
page += 1
# Print last page
# Reset page contents
report = pdf.beginText(inch * 1, inch * 10)
for line in result[int(pages - 1) * lpp:]:
report.textLine(line)
pdf.drawText(report)
pdf.showPage()
pdf.save()
def make_pdf(deck_name):
global successful_images
global prog_bar
global mutex
c = Canvas(f'{deck_name}.pdf', pagesize=LEGAL)
num_pages = ceil(len(successful_images) / 9)
if num_pages <= 0:
num_pages = 1
for current_page in range(num_pages):
if current_page != num_pages:
num_items = len(successful_images[(current_page *
9):((current_page + 1) * 9)])
else:
num_items = len(successful_images[current_page * 9:])
for i in range(num_items):
if i in [0, 3, 6]:
x_align = 0.25
elif i in [1, 4, 7]:
x_align = 3
else:
x_align = 5.75
if i in [0, 1, 2]:
y_align = 0.25
elif i in [3, 4, 5]:
y_align = 4
else:
y_align = 7.75
img_name = successful_images[i + (current_page * 9)]
c.drawImage(img_name,
x_align * inch,
y_align * inch,
width=2.5 * inch,
height=3.48 * inch)
# To explain:
# Downloading the images is 50% of the work because our "max" is 2* number of images,
# therefore we need to figure out how much of the overall "max" value our pages take up
# we do this by taking half the max value i.e., 50% and then adding the ammount equivalent to
# half of the percentage of the pages we are done with
mutex.acquire()
additional_percent = (current_page / num_pages) / 2
new_value = floor((prog_bar.maxval / 2) +
(additional_percent * prog_bar.maxval))
prog_bar.update(new_value)
mutex.release()
c.showPage()
c.save()
def create_pdf(filename, budgets):
w, h = A4
canvas = Canvas('/tmp/' + filename, pagesize=A4)
canvas.setFont('Helvetica', 14)
textobject = canvas.beginText(50, h - 50)
textobject.textLine('Creado el: ' + filename.replace('pdf', ''))
textobject.moveCursor(125, 10)
textobject.textLine('Presupuesto de Tratamientos EDENT')
textobject.moveCursor(-75, 100)
for budget in budgets:
textobject.textLine(budget['name'] + ' : Q' + budget['price'])
textobject.moveCursor(0, 15)
textobject.moveCursor(250, 30)
textobject.textLine('Total: Q' + str(get_total(budgets)))
canvas.drawText(textobject)
canvas.save()
def split(path, number_of_pages, output):
pdf_obj = PdfReader(path)
my_canvas = Canvas(output)
# create page objects
pages = pdf_obj.pages[0:number_of_pages]
pages = [pagexobj(page) for page in pages]
for page in pages:
my_canvas.setPageSize((page.BBox[2], page.BBox[3]))
my_canvas.doForm(makerl(my_canvas, page))
my_canvas.showPage()
# write the new PDF to disk
my_canvas.save()
def _build_omr_layer(self, marks):
self.ensure_one()
padding_x = 4.2 * mm
padding_y = 8.5 * mm
top_mark_x = self.omr_top_mark_x * mm
top_mark_y = self.omr_top_mark_y * mm
mark_y_spacing = 4 * mm
mark_width = 6.5 * mm
marks_height = (len(marks) - 1) * mark_y_spacing
logger.debug(
"Mailer DS-75i OMR Settings: 1=%s 2=%s",
str((297 * mm - top_mark_y) / mm),
str((top_mark_x + mark_width / 2) / mm + 0.5),
)
omr_buffer = BytesIO()
omr_canvas = Canvas(omr_buffer)
omr_canvas.setLineWidth(0.2 * mm)
# add a white background for the omr code
omr_canvas.setFillColor(white)
omr_canvas.rect(
x=top_mark_x - padding_x,
y=top_mark_y - marks_height - padding_y,
width=mark_width + 2 * padding_x,
height=marks_height + 2 * padding_y,
fill=True,
stroke=False,
)
for offset, mark in enumerate(marks):
mark_y = top_mark_y - offset * mark_y_spacing
if mark:
omr_canvas.line(top_mark_x, mark_y, top_mark_x + mark_width,
mark_y)
# Close the PDF object cleanly.
omr_canvas.showPage()
omr_canvas.save()
# move to the beginning of the BytesIO buffer
omr_buffer.seek(0)
omr_pdf = PdfFileReader(omr_buffer)
return omr_pdf.getPage(0)
def _generate_pattern(image, flip=True):
template = image_ops.generate_template(image, flip=flip)
image_buf = BytesIO()
template.save(image_buf, format="PNG")
bead_counts = image_ops.count_beads(image)
# Start PDF
data = BytesIO()
# bottomup is forced because reportlab treats images that way?
# Or we could flip the image ourselves and still specify the bottom
# right corner?
canvas = Canvas(data, bottomup=1, pagesize=letter)
# page 1: packing list and instructions
y = 10 * inch
color_count = len(bead_counts.keys())
column = 0
left_margin = 0.5 * inch
for index, color_name in enumerate(sorted(bead_counts.keys())):
if column == 0 and index >= color_count / 2.0:
column = 1
left_margin = 4.25 * inch
y = 10 * inch
count = bead_counts[color_name]
color_file = color_name.replace(" ", "_") + ".png"
canvas.drawInlineImage(
f"data/color_images/bitmap/{color_file}",
x=left_margin+0.5*inch, y=y-0.04*inch,
width=0.2*inch, height=0.2*inch
)
canvas.drawCentredString(left_margin+0.25*inch, y, str(count))
canvas.drawString(left_margin+0.75*inch, y, color_name)
y -= 0.2 * inch
canvas.showPage()
# page 2: template
canvas.drawInlineImage(
template,
x=0.25*inch, y=0.5*inch,
width=8*inch, height=10*inch,
)
canvas.showPage()
# Finalize and return
canvas.save()
data.seek(0)
return data.read()
def jpg_to_pdf(self, jpg_root_dir, save_path):
'''
将jpg图片书籍转换为pdf文档
:param jpg_root_dir: jpg图片书籍根目录
:param save_path: 保存文件夹
:return: 是否转换成功
'''
try:
if not os.path.isdir(jpg_root_dir):
raise Exception('文件夹：%s 不存在！' % jpg_root_dir)
self.__book_name = os.path.split(jpg_root_dir)[1]
pdf_path = os.path.join(save_path, self.__book_name + '.pdf')
if os.path.exists(pdf_path):
print('文件：%s 已存在，停止下载《%s》！' % (pdf_path, self.__book_name))
return True
value_path = os.path.join(jpg_root_dir,
'正文页/' + self.__book_items['正文页'][0] % 1)
if not os.path.isfile(value_path):
raise Exception('文件夹：%s 无法被识别！' % jpg_root_dir)
img = Image.open(value_path)
canvas = Canvas(pdf_path, pagesize=img.size)
print('开始转换《%s》...' % self.__book_name)
for key, value in zip(self.__book_items.keys(),
self.__book_items.values()):
key_path = os.path.join(jpg_root_dir, key)
if os.path.isdir(key_path):
print('正在转换%s...' % key)
ii = 1
while True:
value_path = os.path.join(key_path, value[0] % ii)
if not os.path.isfile(value_path):
self.__set_book_items(key, 1, ii - 1)
break
canvas.drawImage(value_path, 0, 0, img.size[0],
img.size[1])
canvas.showPage()
ii += 1
else:
self.__set_book_items(key, 1, 0)
canvas.save()
print('《%s》转换完毕！' % self.__book_name)
return True
except Exception as ex:
print(ex)
return False
def test6(self):
"""test of single/multi-frag text and shrinkSpace calculation"""
pagesize = (200 + 20, 400)
canv = Canvas(outputfile('test_platypus_breaking_lelegaifax.pdf'),
pagesize=pagesize)
f = Frame(10,
0,
200,
400,
showBoundary=ShowBoundaryValue(dashArray=(1, 1)),
leftPadding=0,
rightPadding=0,
topPadding=0,
bottomPadding=0)
style = ParagraphStyle(
'normal',
fontName='Helvetica',
fontSize=11.333628,
spaceBefore=20,
hyphenationLang='en-US',
alignment=TA_JUSTIFY,
spaceShrinkage=0.05,
)
text1 = """My recent use case was the preparation"""
text2 = """<span color='red'>My </span> recent use case was the preparation"""
ix0 = len(canv._code)
f.addFromList([
Paragraph(text1, style),
Paragraph(text2, style),
], canv)
self.assertEqual(
canv._code[ix0:],
[
'q', '0 0 0 RG', '.1 w', '[1 1] 0 d', 'n 10 0 200 400 re S',
'Q', 'q', '1 0 0 1 10 388 cm', 'q', '0 0 0 rg',
'BT 1 0 0 1 0 .666372 Tm /F1 11.33363 Tf 12 TL -0.157537 Tw'
' (My recent use case was the preparation) Tj T* 0 Tw ET', 'Q',
'Q', 'q', '1 0 0 1 10 356 cm', 'q',
'BT 1 0 0 1 0 .666372 Tm -0.157537 Tw 12 TL /F1 11.33363 Tf 1 0 0 rg'
' (My ) Tj 0 0 0 rg (recent use case was the preparation) Tj T* 0 Tw ET',
'Q', 'Q'
],
'Lele Gaifax bug example did not produce the right code',
)
canv.showPage()
canv.save()
def post_detail(request, pk):
post = get_object_or_404(Post, pk=pk)
cash = GoTender.objects.filter(
published_date__lte=timezone.now()).order_by('-published_date')
#if request.user.is_authenticated:
path = str(post.pk) + '.pdf'
pats = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
pas = pats + "/media/docs/" + path
canvas = Canvas(pas, pagesize=A4)
pdfmetrics.registerFont(TTFont('FreeSans', 'FreeSans.ttf'))
canvas.setFont('FreeSans', 12)
author_text = 'Автор: ' + str(post.author)
title_text = str(post.title)
opis_text = 'Описание: ' + str(post.text)
city_p_text = 'Место поставки: ' + 'г. ' + str(post.supply)
reg_text = 'Регион закупки: ' + str(post.region)
cost_text = 'Стоимость: ' + str(post.cost) + ' руб.'
start_text = 'Дата размещения: ' + str(post.start)
end_text = 'Окончание приёма предложений: ' + str(post.ending)
comp_text = 'Компания: ' + str(post.compania)
inn_text = 'Инн: ' + str(post.inn)
kpp_text = 'Кпп: ' + str(post.kpp)
phone_text = 'Телефон: ' + str(post.phone)
number_text = '№' + str(post.pk)
canvas.drawString(10, 820, number_text)
canvas.drawString(10, 800, author_text)
canvas.drawString(100, 770, title_text)
canvas.drawString(10, 730, opis_text)
canvas.drawString(10, 680, city_p_text)
canvas.drawString(10, 660, reg_text)
canvas.drawString(10, 620, cost_text)
canvas.drawString(10, 580, start_text)
canvas.drawString(10, 560, end_text)
canvas.drawString(10, 520, comp_text)
canvas.drawString(10, 500, inn_text)
canvas.drawString(10, 480, kpp_text)
canvas.drawString(10, 460, phone_text)
canvas.showPage()
canvas.save()
return render(request, 'detail.html', {
'post': post,
'cash': cash,
'path': path
})
def save_design_nodes(graph: nx.DiGraph, savedir: str, symbols_dir: str):
pg_w = pagesizes.A5[0]
pg_h = pagesizes.A5[1]
dirs_btm_padding = 10 * units.mm
symbol_w = 100 * units.mm
symbol_h = 100 * units.mm
dir_symbol_w = 20 * units.mm
dir_symbol_h = 20 * units.mm
meta_font_size = 5 * units.mm
fontname = 'Helvetica'
fn = os.path.join(savedir, 'uzly.pdf')
canvas = Canvas(fn, pagesize=(pg_w, pg_h))
canvas.setTitle('Uzly')
for n in graph:
kind = graph.nodes[n]['kind']
hl_y = 2 * dirs_btm_padding + dir_symbol_h
canvas.line(0, hl_y, pg_w, hl_y)
symbol_fn = os.path.join(symbols_dir, f'SSL{n + 1:02d}.svg')
symbol = fit_size(svglib.svg2rlg(symbol_fn), symbol_w, symbol_h)
renderPDF.draw(symbol, canvas, (pg_w - symbol_w) / 2,
(pg_h + hl_y - symbol_h) / 2)
if kind == NodeKind.PEEK_ALL:
text = '*'
elif kind == NodeKind.PEEK_ONE:
text = '1'
else:
raise ValueError()
canvas.setFont(fontname, meta_font_size)
# canvas.drawRightString(pg_w - 5 * units.mm, pg_h - 9 * units.mm, text)
nbnum = len(graph[n])
for i in range(nbnum - 1):
x = (i + 1) * pg_w / nbnum
canvas.line(x, 0, x, 2 * dirs_btm_padding + dir_symbol_h)
for nb, nbd in graph[n].items():
symbol_fn = os.path.join(symbols_dir, f'SSL{nb + 1:02d}.svg')
o = nbd['order']
x = (o + 0.5) * pg_w / nbnum - dir_symbol_w / 2
y = dirs_btm_padding
symbol = fit_size(svglib.svg2rlg(symbol_fn), dir_symbol_w,
dir_symbol_h)
renderPDF.draw(symbol, canvas, x, y)
canvas.showPage()
canvas.save()
def test0(self):
"A basic document drawing some strings"
# if they do not have the Japanese font files, go away quietly
from reportlab.pdfbase.cidfonts import UnicodeCIDFont, findCMapFile
pdfmetrics.registerFont(UnicodeCIDFont('STSong-Light'))
c = Canvas(outputfile('test_multibyte_chs.pdf'))
c.setFont('Helvetica', 30)
c.drawString(100,700, 'Simplified Chinese Font Support')
c.setFont('Helvetica', 10)
c.drawString(100,680, 'Short sample: "China - Zhang Ziyi" (famous actress)')
# the two typefaces
hBoxText(u'\u4e2d\u56fd - \u7ae0\u5b50\u6021',
c,
100,
660,
'STSong-Light',
)
c.setFont('Helvetica',10)
c.drawCentredString(297, 36, 'Page %d' % c.getPageNumber())
c.showPage()
## # full kuten chart in EUC
## c.setFont('Helvetica', 18)
## c.drawString(72,750, 'Characters available in GB 2312-80, EUC encoding')
## y = 600
## enc = 'GB_EUC_H'
## for row in range(1, 95):
## KutenRowCodeChart(row, 'STSong-Light',enc).drawOn(c, 72, y)
## y = y - 125
## if y < 50:
## c.setFont('Helvetica',10)
## c.drawCentredString(297, 36, 'Page %d' % c.getPageNumber())
## c.showPage()
## y = 700
##
c.save()
if VERBOSE:
print 'saved '+outputfile('test_multibyte_chs.pdf')
def test0(self):
"This should open in full screen mode."
import os
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.colors import PCMYKColor, PCMYKColorSep
filename = 'test_pdfgen_overprint.pdf'
desc = "Overprint/knockout tests for ReportLab library"
black = PCMYKColor(0,0,0,100)
cyan = PCMYKColorSep(100,0,0,0,spotName='myCyan')
magenta = PCMYKColorSep(0,100,0,0,spotName='myMagenta')
c = Canvas(filename)
c.setFillColor(black)
c.setFont('Helvetica', 20)
c.drawString(100, 700, desc)
c.setFont('Helvetica', 10)
c.drawString(100, 670, "To view this page properly you probably need to enable 'overprint preview' in Acrobat Reader")
c.drawString(100, 658, "or use a tool like Illustrator, Quark or Acrobat to view separated plates. Starting in")
c.drawString(100, 646, "Acrobat Reader 9 there is a setting that lets you turn on the overprint preview, although")
c.drawString(100, 634, "it's not on by default (Preferences > Page Display > Use Overprint Preview: Always).")
c.drawString(100, 616, "In the top example, the magenta rectangle overprints the cyan one. In the lower one, it")
c.drawString(100, 604, "'knocks out' the cyan underneath which is the default in PDF. This means that the overlap")
c.drawString(100, 592, "area of the first example should show blue, because the two colours merge. However, in many")
c.drawString(100, 580, "PDF viewers and cheap printers, both examples will probably look the same - magenta")
c.drawString(100, 568, "rectangle knocks out part of the cyan one.")
c.drawString(100, 550, "If you can view the separated CMYK plates in a tool like Illustrator, on the cyan plate")
c.drawString(100, 538, "you should see the top rectangle as complete and the bottom one has a chunk knocked out of")
c.drawString(100, 526, "the top right corner.")
c.setFillOverprint(True)
c.setFillColor(cyan)
c.rect(100, 300, 200, 100, fill=True, stroke=False)
c.setFillColor(magenta)
c.rect(200, 350, 200, 100, fill=True, stroke=False)
c.setFillOverprint(False)
c.setFillColor(cyan)
c.rect(100, 100, 200, 100, fill=True, stroke=False)
c.setFillColor(magenta)
c.rect(200, 150, 200, 100, fill=True, stroke=False)
c.save()
assert os.path.exists(filename)
def draw(self, invoice, stream):
""" Draws the invoice """
# embed unicode font
pdfmetrics.registerFont(
TTFont('FreeSans', join(STATIC_DIR, 'FreeSans.ttf'))
)
addMapping('FreeSans', 0, 0, 'FreeSans')
self.baseline = -2*cm
canvas = Canvas(stream, pagesize=A4)
canvas.setCreator("django-invoice")
canvas.setAuthor(smart_text(invoice.contractor))
canvas.setTitle(smart_text(invoice))
canvas.translate(0, 29.7*cm)
canvas.setFont(self.FONT_NAME, 10)
canvas.saveState()
self.draw_header(invoice, canvas)
canvas.restoreState()
canvas.saveState()
self.draw_subscriber(invoice, canvas)
canvas.restoreState()
canvas.saveState()
self.draw_contractor(invoice, canvas)
canvas.restoreState()
canvas.saveState()
self.draw_info(invoice, canvas)
canvas.restoreState()
canvas.saveState()
self.draw_items(invoice, canvas)
canvas.restoreState()
canvas.saveState()
self.draw_footer(invoice, canvas)
canvas.restoreState()
canvas.showPage()
canvas.save()
canvas = None
self.baseline = 0
def createPDF(id, forename, surname, category):
#Creating file
canvas = Canvas(f"reconocimiento-{id}.pdf", pagesize=letter)
width, height = letter
#Background image and rectangle for information
bg_im = ImageReader("assets/bg_image.jpg")
logo = ImageReader("assets/logo.png")
canvas.drawImage(image=bg_im, x=0, y=0, width=width, height=height)
canvas.drawImage(image=logo,
x=inch / 2,
y=height - 1.5 * inch,
width=inch,
height=inch)
gray50transparent = Color(160, 160, 160, alpha=0.75)
canvas.setFillColor(gray50transparent)
canvas.rect(0.5 * inch,
2 * inch,
width - inch,
height - 4 * inch,
fill=True,
stroke=False)
#Text
canvas.setFont('Helvetica', 20)
canvas.setFillColor(Color(0, 0, 0, alpha=1)) #Black
canvas.drawCentredString(width / 2, 8 * inch,
"Torneo de Programación Competitiva")
canvas.drawCentredString(width / 2, 7.5 * inch,
"Copa Guadalajara 2021")
canvas.drawCentredString(width / 2, 6 * inch,
"Se otorga el reconocimiento a:")
canvas.setFont('Helvetica-Bold', 20)
canvas.drawCentredString(width / 2, 5.5 * inch,
f'{forename} {surname}')
canvas.setFont('Helvetica', 20)
canvas.drawCentredString(
width / 2, 4 * inch,
f"Por su participación en la categoría {category}")
canvas.drawCentredString(width / 2, 3.5 * inch,
'en la copa de programación competitiva')
canvas.drawCentredString(width / 2, 3 * inch, 'Guadalajara 2021.')
#Closing file
canvas.save()
def __init__(self,
filename,
logo_filename=LOGO_FILENAME,
from_address=Address(**settings.INVOICE_FROM_ADDRESS),
to_address=None,
project_name='',
invoice_date=None,
invoice_number='',
terms=settings.INVOICE_TERMS,
due_date=None,
date_start=None,
date_end=None,
bank_name=settings.BANK_NAME,
bank_address=Address(**settings.BANK_ADDRESS),
account_number=settings.BANK_ACCOUNT_NUMBER,
routing_number=settings.BANK_ROUTING_NUMBER,
swift_code=settings.BANK_SWIFT_CODE,
applied_credit=None,
subtotal=None,
tax_rate=None,
applied_tax=None,
total=None):
self.canvas = Canvas(filename)
self.canvas.setFontSize(DEFAULT_FONT_SIZE)
self.logo_filename = os.path.join(os.getcwd(), logo_filename)
self.from_address = from_address
self.to_address = to_address
self.project_name = project_name
self.invoice_date = invoice_date
self.invoice_number = invoice_number
self.terms = terms
self.due_date = due_date
self.date_start = date_start
self.date_end = date_end
self.bank_name = bank_name
self.bank_address = bank_address
self.account_number = account_number
self.routing_number = routing_number
self.swift_code = swift_code
self.applied_credit = applied_credit
self.subtotal = subtotal
self.tax_rate = tax_rate
self.applied_tax = applied_tax
self.total = total
self.items = []
def pdf_demo_7(file):
c = Canvas(file, pagesize=A4)
# Coordinates are in points. 1 point = 1/72 inch. 0, 0 is bottom left corner of page
for ptx in range(0, int(A4[0]), 2 * 72):
for pty in range(0, int(A4[1]), 2 * 72):
c.drawString(ptx, pty, f"({ptx}pt, {pty}pt)")
c.line(ptx - 5, pty, ptx + 5, pty)
c.line(ptx, pty - 5, ptx, pty + 5)
# save everything on current page and move to next page
c.showPage()
for mmx in range(0, int(A4[0] // mm), 50):
for mmy in range(0, int(A4[1] // mm), 50):
c.drawString(mmx * mm, mmy * mm, f"({mmx}mm, {mmy}mm)")
c.line((mmx - 2) * mm, mmy * mm, (mmx + 2) * mm, mmy * mm)
c.line(mmx * mm, (mmy - 2) * mm, mmx * mm, (mmy + 2) * mm)
# save both pages to file
c.save()
