def test_pdf(self):
canvas = GeoCanvas(StringIO())
registration = PDFArray([
PDFArray(map(PDFString, ['200', '400', '-180', '-90'])),
PDFArray(map(PDFString, ['200', '600', '-180', '90'])),
PDFArray(map(PDFString, ['400', '600', '180', '90'])),
PDFArray(map(PDFString, ['400', '400', '180', '-90']))
])
canvas.rect(200, 400, 200, 200, stroke=1)
canvas.addGeo(Registration=registration)
self.assertTrue('LGIDict' in canvas.getpdfdata())
canvas.save()
def SelectField(title,
value,
options,
xmin,
ymin,
xmax,
ymax,
page,
font="Helvetica-Bold",
fontsize=9,
R=0,
G=0,
B=0.627):
#print "ARGS", (title, value, options, xmin, ymin, xmax, ymax, page, font, fontsize, R, G, B)
from reportlab.pdfbase.pdfdoc import PDFString, PDFName, PDFArray
if value not in options:
raise ValueError("value %s must be one of options %s" %
(repr(value), repr(options)))
fontname = FORMFONTNAMES[font]
optionstrings = list(map(PDFString, options))
optionarray = PDFArray(optionstrings)
return PDFPattern(SelectFieldPattern,
Options=optionarray,
Selected=PDFString(value),
Page=page,
Name=PDFString(title),
xmin=xmin,
ymin=ymin,
xmax=xmax,
ymax=ymax,
fontname=PDFName(fontname),
fontsize=fontsize,
R=R,
G=G,
B=B)
def makeStream(self, width, height, stream, **D):
D['Matrix'] = PDFArray([1.0, 0.0, 0.0, 1.0, 0.0, 0.0])
D['BBox'] = PDFArray([0, 0, width, height])
D['Subtype'] = PDFName('Form')
D['Type'] = PDFName('XObject')
D['FormType'] = 1
s = PDFStream(
PDFDictionary(D),
stream,
filters=[PDFStreamFilterZCompress()]
if self.canv._doc.compression else None,
)
#compute a lookup string
s._af_refstr = stream + '\n'.join(
('%s=%r' % (k, _pdfObjToStr(v)) for k, v in sorted(D.items())))
return s
def bsPDF(borderWidth, borderStyle, dashLen):
d = dict(W=borderWidth, S=PDFName(_bsStyles[borderStyle]))
if borderStyle == 'dashed':
if not dashLen:
dashLen = [3]
elif not isinstance(dashLen, (list, tuple)):
dashLen = [dashLen]
d['D'] = PDFArray(dashLen)
return PDFDictionary(d)
def format(self, document):
from reportlab.pdfbase.pdfdoc import PDFArray
proxy = PDFPattern(FormPattern,
Resources=getattr(self, 'resources', None)
or FormResources(),
NeedAppearances=getattr(self, 'needAppearances',
'false'),
fields=PDFArray(self.fields),
SigFlags=getattr(self, 'sigFlags', 0))
return proxy.format(document)
def format(self, doc):
d = dict(Fields=PDFArray([self.getRef(f) for f in self.fields]), )
if self.fonts:
F = [self.fontRef(f) for f in self.fonts]
d['DA'] = PDFString('/%s 0 Tf 0 g' % list(self.fonts.keys())[0])
d['DR'] = PDFFromString(
'<< /Encoding\n<<\n/RLAFencoding\n%s\n>>\n%s\n>>' %
(self.encRefStr, '\n'.join(F)))
r = PDFDictionary(d).format(doc)
return r
def format(self, doc):
d = dict(Fields=PDFArray([self.getRef(f) for f in self.fields]), )
if self.sigFlags: d['SigFlags'] = self.sigFlags
if self.fonts:
FK = list(sorted(self.fonts.keys()))
F = [self.fontRef(f) for f in FK]
d['DA'] = PDFString('/%s 0 Tf 0 g' % FK[0])
d['DR'] = PDFFromString(
'<< /Encoding\n<<\n/RLAFencoding\n%s\n>>\n%s\n>>' %
(self.encRefStr, '\n'.join(F)))
d.update(self.extras)
r = PDFDictionary(d).format(doc)
return r
def format(self,doc):
kids = self.kids
d = len(kids)
if d<2: raise ValueError('RadioGroup:%s has %d < 2 RadioBoxes' % (self.T,d))
d = dict(
Ff=self.Ff,
Kids = PDFArray([k for k in self.kids]),
FT = PDFName('Btn'),
T = PDFString(self.T),
#DA = PDFString('0 g'),
)
if self.V: d['V'] = PDFName(self.V)
if self.TU: d['TU'] =PDFString(self.TU)
r = PDFDictionary(d).format(doc)
return r
def convert(point):
"""Convert lat/lon to screen coordinates"""
lon = point[0]
lat = point[1]
x = map_width - ((maxx - lon) * x_ratio)
y = map_height - ((maxy - lat) * y_ratio)
# Python turtle graphics start in the middle of the screen
# so we must offset the points so they are centered
x = x + 100
y = y + 400
return [x, y]
# Set up our map labels
canvas.setFont("Helvetica", 20)
canvas.drawString(250, 500, "COLORADO")
# Use smaller text for cities
canvas.setFont("Helvetica", 8)
# Draw points and label the cities
for city in cities:
pixel = convert(city[POINTS])
print(pixel)
# Place a point for the city
canvas.circle(pixel[0], pixel[1], 5, stroke=1, fill=1)
# Label the city
canvas.drawString(pixel[0] + 10, pixel[1], city[NAME] + ", Population: " + str(city[POP]))
# A series of registration point pairs (pixel x, pixel y, x, y)
# to spatially enable the PDF. We only need to do the state boundary.
# The cities will be contained with in it.
registration = PDFArray([
PDFArray(map(PDFString, ['100', '400', '{}'.format(minx), '{}'.format(maxy)])),
PDFArray(map(PDFString, ['500', '400', '{}'.format(maxx), '{}'.format(maxy)])),
PDFArray(map(PDFString, ['100', '150', '{}'.format(minx), '{}'.format(miny)])),
PDFArray(map(PDFString, ['500', '150', '{}'.format(maxx), '{}'.format(miny)]))
])
# Add the map registration
canvas.addGeo(Registration=registration)
# Save our geopdf
canvas.save()
def _textfield(
self,
value='',
fillColor=None,
borderColor=None,
textColor=None,
borderWidth=1,
borderStyle='solid',
width=120,
height=36,
x=0,
y=0,
tooltip=None,
name=None,
annotationFlags='print',
fieldFlags='',
forceBorder=False,
relative=False,
maxlen=100,
fontName=None,
fontSize=None,
wkind=None,
options=None,
dashLen=3,
):
rFontName, iFontName = self.makeFont(fontName)
if fontSize is None:
fontSize = 12
textColor, borderColor, fillColor = self.stdColors(
textColor, borderColor, fillColor)
canv = self.canv
if relative:
x, y = self.canv.absolutePosition(x, y)
doc = canv._doc
rFontName = '<</%s %s>>' % (iFontName, rFontName)
Ff = makeFlags(fieldFlags, fieldFlagValues)
if wkind != 'textfield':
#options must be a list of pairs (label value)
#value must be a list of the values
FT = 'Ch'
if wkind == 'choice':
Ff |= fieldFlagValues['combo'] #just in case
V = []
Opt = []
AP = []
I = []
TF = []
if not isinstance(options, (list, tuple)):
raise TypeError('%s options=%r is wrong type' %
(wkind, options))
for v in options:
if isStr(v):
Opt.append(PDFString(v))
l = v
elif isinstance(v, (list, tuple)):
if len(v) == 1:
v = l = v[0]
else:
l, v = v
Opt.append(PDFArray([PDFString(v), PDFString(l)]))
else:
raise TypeError('%s option %r is wrong type' % (wkind, v))
AP.append(v)
TF.append(l)
Opt = PDFArray(Opt)
if value:
if not isinstance(value, (list, tuple)):
value = [value]
for v in value:
if v not in AP:
if v not in TF:
raise ValueError(
'%s value %r is not in option\nvalues %r\nor labels %r'
% (wkind, v, AP, TF))
else:
v = AP[TF.index(v)]
I.append(AP.index(v))
V.append(PDFString(v))
I.sort()
if not (Ff
& fieldFlagValues['multiSelect']) or len(value) == 1:
if wkind == 'choice':
value = TF[I[0]]
else:
value = value[:1]
V = V[:1]
V = V[0] if len(V) == 1 else PDFArray(V)
lbextras = dict(labels=TF, I=I, wkind=wkind)
else:
V = PDFString(value)
else:
I = Opt = []
lbextras = {}
FT = 'Tx'
if not isStr(value):
raise TypeError('textfield value=%r is wrong type' % value)
V = PDFString(value)
AP = {}
for key in 'N':
tC, bC, fC = self.varyColors(key, textColor, borderColor,
fillColor)
ap = self.txAP(key,
value,
iFontName,
rFontName,
fontSize,
fillColor=fC,
borderColor=bC,
textColor=tC,
borderWidth=borderWidth,
borderStyle=borderStyle,
width=width,
height=height,
dashLen=dashLen,
**lbextras)
if ap._af_refstr in self._refMap:
ref = self._refMap[ap._af_refstr]
else:
ref = self.getRef(ap)
self._refMap[ap._af_refstr] = ref
AP[key] = ref
TF = dict(
FT=PDFName(FT),
P=doc.thisPageRef(),
V=V,
#AS = PDFName(value),
DV=V,
Rect=PDFArray((x, y, x + width, y + height)),
AP=PDFDictionary(AP),
Subtype=PDFName('Widget'),
Type=PDFName('Annot'),
F=makeFlags(annotationFlags, annotationFlagValues),
Ff=Ff,
#H=PDFName('N'),
DA=PDFString(
'/%s %d Tf %s' %
(iFontName, fontSize, self.streamFillColor(textColor))),
)
if Opt: TF['Opt'] = Opt
if I: TF['I'] = PDFArray(I)
if maxlen:
TF['MaxLen'] = maxlen
if tooltip:
TF['TU'] = PDFString(tooltip)
if not name:
name = 'AFF%03d' % len(self.fields)
TF['T'] = PDFString(name)
MK = dict(BG=PDFArray(self.colorTuple(fillColor)), )
# Acrobat seems to draw a thin border when BS is defined, so only
# include this if there actually is a border to draw
if borderWidth:
TF['BS'] = bsPDF(borderWidth, borderStyle, dashLen)
MK['BC'] = PDFArray(self.colorTuple(borderColor))
TF['MK'] = PDFDictionary(MK)
TF = PDFDictionary(TF)
self.canv._addAnnotation(TF)
self.fields.append(self.getRef(TF))
self.checkForceBorder(x, y, width, height, forceBorder, 'square',
borderStyle, borderWidth, borderColor, fillColor)
def radio(
self,
value=None,
selected=False,
buttonStyle='circle',
shape='circle',
fillColor=None,
borderColor=None,
textColor=None,
borderWidth=1,
borderStyle='solid',
size=20,
x=0,
y=0,
tooltip=None,
name=None,
annotationFlags='print',
fieldFlags='noToggleToOff required radio',
forceBorder=False,
relative=False,
dashLen=3,
):
if name not in self._radios:
group = RadioGroup(name, tooltip=tooltip, fieldFlags=fieldFlags)
group._ref = self.getRef(group)
self._radios[name] = group
self.fields.append(group._ref)
else:
group = self._radios[name]
fieldFlags = makeFlags(fieldFlags, fieldFlagValues)
if fieldFlags != group.Ff:
raise ValueError('radio.%s.%s created with different flags' %
(name, value))
if not value:
raise ValueError('bad value %r for radio.%s' % (value, name))
initialValue = value if selected else 'Off'
textColor, borderColor, fillColor = self.stdColors(
textColor, borderColor, fillColor)
if initialValue == value:
if group.V is not None:
if group.V != value:
raise ValueError(
'radio.%s.%s sets initial value conflicting with %s' %
(name, value, group.V))
else:
group.V = value
canv = self.canv
if relative:
x, y = self.canv.absolutePosition(x, y)
doc = canv._doc
AP = {}
for key in 'NDR':
APV = {}
tC, bC, fC = self.varyColors(key, textColor, borderColor,
fillColor)
for v in (value, 'Off'):
ap = self.checkboxAP(
key,
'Yes' if v == value else 'Off',
buttonStyle=buttonStyle,
shape=shape,
fillColor=fC,
borderColor=bC,
textColor=tC,
borderWidth=borderWidth,
borderStyle=borderStyle,
size=size,
dashLen=dashLen,
)
if ap._af_refstr in self._refMap:
ref = self._refMap[ap._af_refstr]
else:
ref = self.getRef(ap)
self._refMap[ap._af_refstr] = ref
APV[v] = ref
AP[key] = PDFDictionary(APV)
del APV
RB = dict(
FT=PDFName('Btn'),
P=doc.thisPageRef(),
AS=PDFName(initialValue),
#DV = PDFName(initialValue),
Rect=PDFArray((x, y, x + size, y + size)),
AP=PDFDictionary(AP),
Subtype=PDFName('Widget'),
Type=PDFName('Annot'),
F=makeFlags(annotationFlags, annotationFlagValues),
Parent=group._ref,
#DA = PDFString('1 g '+(self.streamFillColor(fillColor) if fillColor else '-0.25 0.75 -0.25 rg'))
H=PDFName('N'),
)
#RB['T'] = PDFString(name)
MK = dict(
CA='(%s)' % ZDSyms[buttonStyle],
BC=PDFArray(self.colorTuple(borderColor)),
BG=PDFArray(self.colorTuple(fillColor)),
)
if borderWidth: RB['BS'] = bsPDF(borderWidth, borderStyle, dashLen)
RB['MK'] = PDFDictionary(MK)
RB = PDFDictionary(RB)
self.canv._addAnnotation(RB)
group.kids.append(self.getRef(RB))
self.checkForceBorder(x, y, size, size, forceBorder, shape,
borderStyle, borderWidth, borderColor, fillColor)
def checkbox(
self,
checked=False,
buttonStyle='check',
shape='square',
fillColor=None,
borderColor=None,
textColor=None,
borderWidth=1,
borderStyle='solid',
size=20,
x=0,
y=0,
tooltip=None,
name=None,
annotationFlags='print',
fieldFlags='required',
forceBorder=False,
relative=False,
dashLen=3,
):
initialValue = 'Yes' if checked else 'Off'
textColor, borderColor, fillColor = self.stdColors(
textColor, borderColor, fillColor)
canv = self.canv
if relative:
x, y = self.canv.absolutePosition(x, y)
doc = canv._doc
AP = {}
for key in 'NDR':
APV = {}
tC, bC, fC = self.varyColors(key, textColor, borderColor,
fillColor)
for value in ('Yes', 'Off'):
ap = self.checkboxAP(
key,
value,
buttonStyle=buttonStyle,
shape=shape,
fillColor=fC,
borderColor=bC,
textColor=tC,
borderWidth=borderWidth,
borderStyle=borderStyle,
size=size,
dashLen=dashLen,
)
if ap._af_refstr in self._refMap:
ref = self._refMap[ap._af_refstr]
else:
ref = self.getRef(ap)
self._refMap[ap._af_refstr] = ref
APV[value] = ref
AP[key] = PDFDictionary(APV)
del APV
CB = dict(
FT=PDFName('Btn'),
P=doc.thisPageRef(),
V=PDFName(initialValue),
AS=PDFName(initialValue),
#DV = PDFName(initialValue),
Rect=PDFArray((x, y, x + size, y + size)),
AP=PDFDictionary(AP),
Subtype=PDFName('Widget'),
Type=PDFName('Annot'),
F=makeFlags(annotationFlags, annotationFlagValues),
Ff=makeFlags(fieldFlags, fieldFlagValues),
H=PDFName('N'),
)
if tooltip:
CB['TU'] = PDFString(tooltip)
if not name:
name = 'AFF%03d' % len(self.fields)
if borderWidth: CB['BS'] = bsPDF(borderWidth, borderStyle, dashLen)
CB['T'] = PDFString(name)
MK = dict(
CA='(%s)' % ZDSyms[buttonStyle],
BC=PDFArray(self.colorTuple(borderColor)),
BG=PDFArray(self.colorTuple(fillColor)),
)
CB['MK'] = PDFDictionary(MK)
CB = PDFDictionary(CB)
self.canv._addAnnotation(CB)
self.fields.append(self.getRef(CB))
self.checkForceBorder(x, y, size, size, forceBorder, shape,
borderStyle, borderWidth, borderColor, fillColor)
def format(self, document):
from reportlab.pdfbase.pdfdoc import PDFArray
proxy = PDFPattern(FormPattern,
Resources=GLOBALRESOURCES,
fields=PDFArray(self.fields))
return proxy.format(document)
def _startPage(self):
# now get ready for the next one
super(GeoCanvas, self)._startPage()
self.LGIDict = PDFArray([])
class GeoCanvas(canvas.Canvas):
LGIDict = PDFArray([])
def _startPage(self):
# now get ready for the next one
super(GeoCanvas, self)._startPage()
self.LGIDict = PDFArray([])
def showPage(self):
"""Close the current page and possibly start on a new page."""
# ensure a space at the end of the stream - Acrobat does
# not mind, but Ghostscript dislikes 'Qendstream' even if
# the length marker finishes after 'Q'
pageWidth = self._pagesize[0]
pageHeight = self._pagesize[1]
cM = self._cropMarks
code = self._code
if cM:
bw = max(0, getattr(cM, 'borderWidth', 36))
if bw:
markLast = getattr(cM, 'markLast', 1)
ml = min(bw, max(0, getattr(cM, 'markLength', 18)))
mw = getattr(cM, 'markWidth', 0.5)
mc = getattr(cM, 'markColor', black)
mg = 2 * bw - ml
cx0 = len(code)
if ml and mc:
self.saveState()
self.setStrokeColor(mc)
self.setLineWidth(mw)
self.lines([
(bw, 0, bw, ml),
(pageWidth + bw, 0, pageWidth + bw, ml),
(bw, pageHeight + mg, bw, pageHeight + 2 * bw),
(pageWidth + bw, pageHeight + mg, pageWidth + bw, pageHeight + 2 * bw),
(0, bw, ml, bw),
(pageWidth + mg, bw, pageWidth + 2 * bw, bw),
(0, pageHeight + bw, ml, pageHeight + bw),
(pageWidth + mg, pageHeight + bw, pageWidth + 2 * bw, pageHeight + bw)
])
self.restoreState()
if markLast:
# if the marks are to be drawn after the content
# save the code we just drew for later use
L = code[cx0:]
del code[cx0:]
cx0 = len(code)
bleedW = max(0, getattr(cM, 'bleedWidth', 0))
self.saveState()
self.translate(bw - bleedW, bw - bleedW)
if bleedW:
# scale everything
self.scale(1 + (2.0 * bleedW) / pageWidth, 1 + (2.0 * bleedW) / pageHeight)
# move our translation/expansion code to the beginning
C = code[cx0:]
del code[cx0:]
code[0:0] = C
self.restoreState()
if markLast:
code.extend(L)
pageWidth = 2 * bw + pageWidth
pageHeight = 2 * bw + pageHeight
code.append(' ')
page = pdfdoc.PDFPage()
page.__NoDefault__ = """Parent
MediaBox Resources Contents CropBox Rotate Thumb Annots B Dur Hid Trans AA
PieceInfo LastModified SeparationInfo ArtBox TrimBox BleedBox ID PZ
Trans LGIDict""".split()
page.pagewidth = pageWidth
page.pageheight = pageHeight
if getattr(self, 'LGIDict', None):
if len(self.LGIDict.sequence) == 1:
page.LGIDict = self.LGIDict.sequence[0]
else:
page.LGIDict = self.LGIDict
page.Rotate = self._pageRotation
page.hasImages = self._currentPageHasImages
page.setPageTransition(self._pageTransition)
page.setCompression(self._pageCompression)
if self._pageDuration is not None:
page.Dur = self._pageDuration
strm = self._psCommandsBeforePage + [self._preamble] + code + self._psCommandsAfterPage
page.setStream(strm)
self._setColorSpace(page)
self._setExtGState(page)
self._setXObjects(page)
self._setShadingUsed(page)
self._setAnnotations(page)
self._doc.addPage(page)
if self._onPage:
self._onPage(self._pageNumber)
self._startPage()
def addGeo(self, **kwargs):
"""
Adds the LGIDict to the document.
:param kwargs: Keyword arguments that are used to update the LGI Dictionary.
"""
lgi = LGIDict()
lgi.dict.update(kwargs)
if not lgi.is_valid():
return
pdf_obj = lgi.format(self._doc)
self.LGIDict.sequence.append(pdf_obj)
return pdf_obj
canvas.drawString(250, 500, "COLORADO")
# Use smaller text for cities
canvas.setFont("Helvetica", 8)
# Draw points and label the cities
for city in cities:
pixel = convert(city[POINTS])
print(pixel)
# Place a point for the city
canvas.circle(pixel[0], pixel[1], 5, stroke=1, fill=1)
# Label the city
canvas.drawString(pixel[0] + 10, pixel[1], city[NAME] + ", Population: " + str(city[POP]))
# A series of registration point pairs (pixel x, pixel y, x, y)
# to spatially enable the PDF. We only need to do the state boundary.
# The cities will be contained with in it.
registration = PDFArray([
PDFArray(map(PDFString, ['100', '400', '{}'.format(minx), '{}'.format(maxy)])),
PDFArray(map(PDFString, ['500', '400', '{}'.format(maxx), '{}'.format(maxy)])),
PDFArray(map(PDFString, ['100', '150', '{}'.format(minx), '{}'.format(miny)])),
PDFArray(map(PDFString, ['500', '150', '{}'.format(maxx), '{}'.format(miny)]))
])
# Add the map registration
canvas.addGeo(Registration=registration)
# Save our geopdf
canvas.save()
