#Copyright ReportLab Europe Ltd. 2000-2004
#see license.txt for license details
#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/platypus/frames.py
__version__=''' $Id$ '''
__doc__="""A frame is a container for content on a page.
"""
import logging
logger = logging.getLogger('reportlab.platypus')
_geomAttr=('x1', 'y1', 'width', 'height', 'leftPadding', 'bottomPadding', 'rightPadding', 'topPadding')
from reportlab import rl_config
_FUZZ=rl_config._FUZZ
class ShowBoundaryValue:
def __init__(self,color=(0,0,0),width=0.1):
self.color = color
self.width = width
def __nonzero__(self):
return self.color is not None and self.width>=0
class Frame:
'''
A Frame is a piece of space in a document that is filled by the
"flowables" in the story. For example in a book like document most
pages have the text paragraphs in one or two frames. For generality
a page might have several frames (for example for 3 column text or
for text that wraps around a graphic).
After creation a Frame is not usually manipulated directly by the
applications program -- it is used internally by the platypus modules.
Here is a diagramatid abstraction for the definitional part of a Frame::
width x2,y2
+---------------------------------+
| l top padding r | h
| e +-------------------------+ i | e
| f | | g | i
| t | | h | g
| | | t | h
| p | | | t
| a | | p |
| d | | a |
| | | d |
| +-------------------------+ |
| bottom padding |
+---------------------------------+
(x1,y1) <-- lower left corner
NOTE!! Frames are stateful objects. No single frame should be used in
two documents at the same time (especially in the presence of multithreading.
'''
def __init__(self, x1, y1, width,height, leftPadding=6, bottomPadding=6,
rightPadding=6, topPadding=6, id=None, showBoundary=0,
overlapAttachedSpace=None,_debug=None):
self.id = id
self._debug = _debug
#these say where it goes on the page
self.__dict__['_x1'] = x1
self.__dict__['_y1'] = y1
self.__dict__['_width'] = width
self.__dict__['_height'] = height
#these create some padding.
self.__dict__['_leftPadding'] = leftPadding
self.__dict__['_bottomPadding'] = bottomPadding
self.__dict__['_rightPadding'] = rightPadding
self.__dict__['_topPadding'] = topPadding
# if we want a boundary to be shown
self.showBoundary = showBoundary
if overlapAttachedSpace is None: overlapAttachedSpace = rl_config.overlapAttachedSpace
self._oASpace = overlapAttachedSpace
self._geom()
self._reset()
def __getattr__(self,a):
if a in _geomAttr: return self.__dict__['_'+a]
raise AttributeError(a)
def __setattr__(self,a,v):
if a in _geomAttr:
self.__dict__['_'+a] = v
self._geom()
else:
self.__dict__[a] = v
def _saveGeom(self, **kwds):
if not self.__dict__.setdefault('_savedGeom',{}):
for ga in _geomAttr:
ga = '_'+ga
self.__dict__['_savedGeom'][ga] = self.__dict__[ga]
for k,v in kwds.iteritems():
setattr(self,k,v)
def _restoreGeom(self):
if self.__dict__.get('_savedGeom',None):
for ga in _geomAttr:
ga = '_'+ga
self.__dict__[ga] = self.__dict__[ga]['_savedGeom']
del self.__dict__['_savedGeom']
self._geom()
def _geom(self):
self._x2 = self._x1 + self._width
self._y2 = self._y1 + self._height
#efficiency
self._y1p = self._y1 + self._bottomPadding
#work out the available space
self._aW = self._x2 - self._x1 - self._leftPadding - self._rightPadding
self._aH = self._y2 - self._y1p - self._topPadding
def _reset(self):
self._restoreGeom()
#drawing starts at top left
self._x = self._x1 + self._leftPadding
self._y = self._y2 - self._topPadding
self._atTop = 1
self._prevASpace = 0
# these two should NOT be set on a frame.
# they are used when Indenter flowables want
# to adjust edges e.g. to do nested lists
self._leftExtraIndent = 0.0
self._rightExtraIndent = 0.0
def _getAvailableWidth(self):
return self._aW - self._leftExtraIndent - self._rightExtraIndent
def _add(self, flowable, canv, trySplit=0):
""" Draws the flowable at the current position.
Returns 1 if successful, 0 if it would not fit.
Raises a LayoutError if the object is too wide,
or if it is too high for a totally empty frame,
to avoid infinite loops"""
flowable._frame = self
flowable.canv = canv #so they can use stringWidth etc
try:
if getattr(flowable,'frameAction',None):
flowable.frameAction(self)
return 1
y = self._y
p = self._y1p
s = 0
aW = self._getAvailableWidth()
if not self._atTop:
s =flowable.getSpaceBefore()
if self._oASpace:
s = max(s-self._prevASpace,0)
h = y - p - s
if h>0:
w, h = flowable.wrap(aW, h)
else:
return 0
h += s
y -= h
if y < p-_FUZZ:
if not rl_config.allowTableBoundsErrors and ((h>self._aH or w>aW) and not trySplit):
from reportlab.platypus.doctemplate import LayoutError
raise LayoutError("Flowable %s (%sx%s points) too large for frame (%sx%s points)." % (
flowable.__class__, w,h, aW,self._aH))
return 0
else:
#now we can draw it, and update the current point.
flowable.drawOn(canv, self._x + self._leftExtraIndent, y, _sW=aW-w)
flowable.canv=canv
if self._debug: logger.debug('drew %s' % flowable.identity())
s = flowable.getSpaceAfter()
y -= s
if self._oASpace: self._prevASpace = s
if y!=self._y: self._atTop = 0
self._y = y
return 1
finally:
#sometimes canv/_frame aren't still on the flowable
for a in ('canv', '_frame'):
if hasattr(flowable,a):
delattr(flowable,a)
add = _add
def split(self,flowable,canv):
'''Ask the flowable to split using up the available space.'''
y = self._y
p = self._y1p
s = 0
if not self._atTop:
s = flowable.getSpaceBefore()
if self._oASpace:
s = max(s-self._prevASpace,0)
flowable.canv = canv #some flowables might need this
r = flowable.split(self._aW, y-p-s)
del flowable.canv
return r
def drawBoundary(self,canv):
"draw the frame boundary as a rectangle (primarily for debugging)."
from reportlab.lib.colors import Color, CMYKColor, toColor
sb = self.showBoundary
ss = type(sb) in (type(''),type(()),type([])) or isinstance(sb,Color)
w = -1
if ss:
c = toColor(sb,self)
ss = c is not self
elif isinstance(sb,ShowBoundaryValue) and sb:
c = toColor(sb.color,self)
w = sb.width
ss = c is not self
if ss:
canv.saveState()
canv.setStrokeColor(c)
if w>=0:
canv.setLineWidth(w)
canv.rect(
self._x1,
self._y1,
self._x2 - self._x1,
self._y2 - self._y1
)
if ss: canv.restoreState()
def addFromList(self, drawlist, canv):
"""Consumes objects from the front of the list until the
frame is full. If it cannot fit one object, raises
an exception."""
if self._debug: logger.debug("enter Frame.addFromlist() for frame %s" % self.id)
if self.showBoundary:
self.drawBoundary(canv)
while len(drawlist) > 0:
head = drawlist[0]
if self.add(head,canv,trySplit=0):
del drawlist[0]
else:
#leave it in the list for later
break
def add_generated_content(self,*C):
self.__dict__.setdefault('_generated_content',[]).extend(C)
def _aSpaceString(self):
return '(%s x %s%s)' % (self._getAvailableWidth(),self._aH,self._atTop and '*' or '')