reportlab/pdfbase/pdfdoc.py
author rgbecker
Wed, 25 Oct 2000 08:57:46 +0000
changeset 494 54257447cfe9
parent 484 cc20a344973c
child 500 58d712fef651
permissions -rwxr-xr-x
Changed to indirect copyright

#copyright ReportLab Inc. 2000
#see license.txt for license details
#history http://cvs.sourceforge.net/cgi-bin/cvsweb.cgi/reportlab/pdfbase/pdfdoc.py?cvsroot=reportlab
#$Header: /tmp/reportlab/reportlab/pdfbase/pdfdoc.py,v 1.30 2000/10/25 08:57:45 rgbecker Exp $
__version__=''' $Id: pdfdoc.py,v 1.30 2000/10/25 08:57:45 rgbecker Exp $ '''
__doc__=""" 
PDFgen is a library to generate PDF files containing text and graphics.  It is the 
foundation for a complete reporting solution in Python.  

The module pdfdoc.py handles the 'outer structure' of PDF documents, ensuring that
all objects are properly cross-referenced and indexed to the nearest byte.  The 
'inner structure' - the page descriptions - are presumed to be generated before 
each page is saved.
pdfgen.py calls this and provides a 'canvas' object to handle page marking operators.
piddlePDF calls pdfgen and offers a high-level interface.

2000-10-13 gmcm Packagize
"""
"""extremely anally  retentive structured version of pdfdoc"""

DEFAULT_ENCODING = 'WinAnsiEncoding' #hack here for a system wide change
ALLOWED_ENCODINGS = ('WinAnsiEncoding', 'MacRomanEncoding')

PDFError = 'PDFError'

StandardEnglishFonts = [
    'Courier', 'Courier-Bold', 'Courier-Oblique', 'Courier-BoldOblique',  
    'Helvetica', 'Helvetica-Bold', 'Helvetica-Oblique', 
    'Helvetica-BoldOblique',
    'Times-Roman', 'Times-Bold', 'Times-Italic', 'Times-BoldItalic',
    'Symbol','ZapfDingbats']

# set this flag to get more vertical whitespace (and larger files)
LongFormat = 1

# XXXX stream filters need to be added

# __InternalName__ is a special attribute that can only be set by the Document arbitrator
__InternalName__ = "__InternalName__"

# __RefOnly__ marks reference only elements that must be formatted on top level
__RefOnly__ = "__RefOnly__"

# __Comment__ provides a (one line) comment to inline with an object ref, if present
#   if it is more than one line then percentize it...
__Comment__ = "__Comment__"
DoComments = 1

# name for standard font dictionary
BasicFonts = "BasicFonts"

# name for the pages object
Pages = "Pages"

### generic utilities

import string, types
from reportlab.pdfbase import pdfutils
from reportlab.pdfbase.pdfutils import LINEEND   # this constant needed in both

# for % substitutions
LINEENDDICT = {"LINEEND": LINEEND, "PERCENT": "%"}

def markfilename(filename):
	# with the Mac, we need to tag the file in a special
	#way so the system knows it is a PDF file.
	#This supplied by Joe Strout
	import os
	if os.name == 'mac':
		import macfs
		try: 
			macfs.FSSpec(filename).SetCreatorType('CARO','PDF ')
		except:
			pass

def format(element, document, toplevel=0):
    """Indirection step for formatting.
       Ensures that document parameters alter behaviour
       of formatting for all elements.
    """
    from types import InstanceType
    if type(element) is InstanceType:
        if not toplevel and hasattr(element, __RefOnly__):
            # the object cannot be a component at non top level.
            # make a reference to it and return it's format
            R = document.Reference(element)
            return R.format(document)
        else:
            try:
                fmt = element.format
            except:
                raise AttributeError, "%s has no format operation" % element
            f = fmt(document)
            if DoComments and hasattr(element, __Comment__):
                f = "%s%s%s%s" % ("% ", element.__Comment__, LINEEND, f)
            return f
    else:
        return str(element)

def indent(s, IND=LINEEND+" "):
    return string.replace(s, LINEEND, IND)

### the global document structure manager

class PDFDocument:
    objectcounter = 0
    inObject = None
    # set this to define filters 
    defaultStreamFilters = None
    pageCounter = 1
    def __init__(self, encoding=DEFAULT_ENCODING, dummyoutline=0):
        #self.defaultStreamFilters = [PDFBase85Encode, PDFZCompress] # for testing!
        #self.defaultStreamFilters = [PDFZCompress] # for testing!
        self.encoding = encoding
        # mapping of internal identifier ("Page001") to PDF objectnumber and generation number (34, 0)
        self.idToObjectNumberAndVersion = {}
        # mapping of internal identifier ("Page001") to PDF object (PDFPage instance)
        self.idToObject = {}
        # internal id to file location
        self.idToOffset = {}
        # number to id
        self.numberToId = {}
        cat = self.Catalog = self._catalog = PDFCatalog()
        pages = self.Pages = PDFPages()
        cat.Pages = pages
        if dummyoutline:
            outlines = PDFOutlines0()
        else:
            outlines = PDFOutlines()
        self.Outlines = self.outline = outlines
        cat.Outlines = outlines
        self.info = self.Info = PDFInfo()
        self.Reference(self.Catalog)
        self.Reference(self.Info)
        # make std fonts (this could be made optional
        self.fontMapping = {}
        MakeStandardEnglishFontObjects(self, encoding)

    def SaveToFile(self, filename, canvas):
        # prepare outline
        outline = self.outline
        outline.prepare(self, canvas)
        from types import StringType
        if type(filename) is StringType:
            myfile = 1
            f = open(filename, "wb")
        else:
            myfile = 0
            f = filename # IT BETTER BE A FILE-LIKE OBJECT!
        txt = self.format()
        f.write(txt)
        if myfile:
            f.close()
            markfilename(filename) # do platform specific file junk
        
    def inPage(self):
        """specify the current object as a page (enables reference binding and other page features)"""
        if self.inObject is not None:
            if self.inObject=="page": return
            raise ValueError, "can't go in page already in object %s" % self.inObject
        self.inObject = "page"

    def inForm(self):
        """specify that we are in a form xobject (disable page features, etc)"""
        if self.inObject not in ["form", None]:
            raise ValueError, "can't go in form already in object %s" % self.inObject
        self.inObject = "form"
        # don't need to do anything else, I think...        

    def getInternalFontName(self, psfontname):
        fm = self.fontMapping
        if fm.has_key(psfontname):
            return fm[psfontname]
        else:
            raise PDFError, "Font %s not available in document" % repr(psfontname)

    def thisPageName(self):
        return "Page"+repr(self.pageCounter)

    def thisPageRef(self):
        return PDFObjectReference(self.thisPageName())

    def addPage(self, page):
        name = self.thisPageName()
        self.Reference(page, name)
        self.Pages.addPage(page)
        self.pageCounter = self.pageCounter+1
        self.inObject = None

    def formName(self, externalname):
        return "FormXob.%s" % externalname
    
    def addForm(self, name, form):
        """add a Form XObject."""
        # XXX should check that name is a legal PDF name
        if self.inObject != "form":
            self.inForm()
        self.Reference(form, self.formName(name))
        self.inObject = None

    def annotationName(self, externalname):
        return "Annot.%s"%externalname
    
    def addAnnotation(self, name, annotation):
        self.Reference(annotation, self.annotationName(name))
        
    def refAnnotation(self, name):
        internalname = self.annotationName(name)
        return PDFObjectReference(internalname)
        
    def setTitle(self, title):
        "embeds in PDF file"
        self.info.title = title
        
    def setAuthor(self, author):
        "embedded in PDF file"
        self.info.author = author
            
    def setSubject(self, subject):
        "embeds in PDF file"
        self.info.subject = subject

    def getAvailableFonts(self):
        fontnames = self.fontMapping.keys()
        fontnames.sort()
        return fontnames
    
    def format(self):
        # register the Catalog/INfo and then format the objects one by one until exhausted
        # (possible infinite loop if there is a bug that continually makes new objects/refs...)
        cat = self.Catalog
        info = self.Info
        self.Reference(self.Catalog)
        self.Reference(self.Info)
        # make std fonts (this could be made optional
        counter = 0 # start at first object (object 1 after preincrement)
        ids = [] # the collection of object ids in object number order
        numbertoid = self.numberToId
        idToNV = self.idToObjectNumberAndVersion
        idToOb = self.idToObject
        idToOf = self.idToOffset
        ### note that new entries may be "appended" DURING FORMATTING
        done = None
        File = PDFFile() # output collector
        while done is None:
            counter = counter+1 # do next object...
            if numbertoid.has_key(counter):
                id = numbertoid[counter]
                #printidToOb
                obj = idToOb[id]
                IO = PDFIndirectObject(id, obj)
                IOf = IO.format(self)
                # add a comment to the PDF output
                if DoComments:
                    File.add("%% %s %s %s" % (repr(id), repr(repr(obj)[:50]), LINEEND))
                offset = File.add(IOf)
                idToOf[id] = offset
                ids.append(id)
            else:
                done = 1
        # sanity checks (must happen AFTER formatting)
        lno = len(numbertoid)
        if counter-1!=lno:
            raise ValueError, "counter %s doesn't match number to id dictionary %s" %(counter, lno)
        # now add the xref
        xref = PDFCrossReferenceTable()
        xref.addsection(0, ids)
        xreff = xref.format(self)
        xrefoffset = File.add(xreff)
        # now add the trailer
        trailer = PDFTrailer(
            startxref = xrefoffset,
            Size = lno,
            Root = self.Reference(cat),
            Info = self.Reference(info)
            )
        trailerf = trailer.format(self)
        File.add(trailerf)
        # return string format for pdf file
        return File.format(self)
    
    def hasForm(self, name):
        """test for existence of named form"""
        internalname = self.formName(name)
        try:
            test = self.idToObject[internalname]          
        except:
            return 0
        else:
            return internalname

    def xobjDict(self, formnames):
        """construct an xobject dict (for inclusion in a resource dict, usually)
           from a list of form names (images not yet supported)"""
        D = {}
        for name in formnames:
            internalname = self.formName(name)
            reference = PDFObjectReference(internalname)
            D[internalname] = reference
        #print "xobjDict D", D
        return PDFDictionary(D)
        
    def Reference(self, object, name=None):
        ### note references may "grow" during the final formatting pass: don't use d.keys()!
        # don't make references to other references, or non instances
        from types import InstanceType
        #print"object type is ", type(object)
        tob = type(object)
        if (tob is not InstanceType) or (tob is InstanceType and object.__class__ is PDFObjectReference):
            return object
        idToObject = self.idToObject
        if hasattr(object, __InternalName__):
            # already registered
            intname = object.__InternalName__
            if name is not None and name!=intname:
                raise ValueError, "attempt to reregister object %s with new name %s" % (
                    repr(intname), repr(name))
            if not idToObject.has_key(intname):
                raise ValueError, "object named but not registered"
            return PDFObjectReference(intname)
        # otherwise register the new object
        objectcounter = self.objectcounter = self.objectcounter+1
        if name is None:
            name = "R"+repr(objectcounter)
        if idToObject.has_key(name):
            raise ValueError, "redefining named object: "+repr(name)
        object.__InternalName__ = name
        self.idToObjectNumberAndVersion[name] = (objectcounter, 0)
        self.numberToId[objectcounter] = name
        idToObject[name] = object
        return PDFObjectReference(name)

### chapter 4 Objects

PDFtrue = "true"
PDFfalse = "false"
PDFnull = "null"

def PDFnumber(n):
    return n

def PDFString(str):
    # might need to change this to class for encryption
    return "(%s)" % pdfutils._escape(str)
    
def PDFName(data):
    # might need to change this to class for encryption
    # first convert the name
    ldata = list(data)
    index = 0
    for thischar in data:
        if 0x21<=ord(thischar)<=0x7e and thischar not in "%()<>{}[]#":
            pass # no problemo
        else:
            hexord = hex(ord(thischar))[2:] # forget the 0x thing...
            ldata[index] = "#"+hexord
        index = index+1
    data = string.join(ldata, "")
    return "/%s" % data
    
class PDFDictionary:

    multiline = LongFormat
    def __init__(self, dict=None):
        """dict should be namestring to value eg "a": 122 NOT pdfname to value NOT "/a":122"""
        if dict is None:
            self.dict = {}
        else:
            self.dict = dict.copy()
    def __setitem__(self, name, value):
        self.dict[name] = value
    def Reference(name, document):
        ob = self.dict[name]
        self.dict[name] = document.Reference(ob)
    def format(self, document):
        dict = self.dict
        keys = dict.keys()
        keys.sort()
        L = []
        a = L.append
        for k in keys:
            v = dict[k]
            fv = format(v, document)
            fk = format(PDFName(k), document)
            a(fk)
            a(" "+fv)
        #L = map(str, L)
        if self.multiline:
            Lj = string.join(L, LINEEND)
            Lj = indent(Lj)
        else:
            Lj = L
            # break up every 6 elements anyway
            for i in range(6, len(Lj), 6):
                Lj.insert(i,LINEEND)
            Lj = string.join(L, " ")
        return "<< %s >>" % Lj

# stream filters are objects to support round trip and
# possibly in the future also support parameters
class PDFStreamFilterZCompress:
    pdfname = "FlateDecode"
    def encode(self, text):
        try:
            from zlib import compress
        except:
            raise ImportError, "cannot z-compress zlib unavailable"
        return compress(text)
    def decode(self, encoded):
        try:
            from zlib import decompress
        except:
            raise ImportError, "cannot z-compress zlib unavailable"
        return decompress(encoded)

# need only one of these, unless we implement parameters later
PDFZCompress = PDFStreamFilterZCompress()    

class PDFStreamFilterBase85Encode:
    pdfname = "ASCII85Decode"
    def encode(self, text):
        from pdfutils import _AsciiBase85Encode, _wrap
        return _wrap(_AsciiBase85Encode(text))
    def decode(self, text):
        from pdfutils import _AsciiBase85Decode
        return _AsciiBase85Decode(text)
    
# need only one of these too
PDFBase85Encode = PDFStreamFilterBase85Encode()

STREAMFMT = ("%(dictionary)s%(LINEEND)s" # dictionary
             "stream" # stream keyword
             "%(LINEEND)s" # a line end (could be just a \n)
             "%(content)s" # the content, with no lineend
             "endstream%(LINEEND)s" # the endstream keyword
             )
class PDFStream:
    '''set dictionary elements explicitly stream.dictionary[name]=value'''
    ### compression stuff not implemented yet
    __RefOnly__ = 1 # must be at top level
    def __init__(self, dictionary=None, content=None):
        if dictionary is None:
            dictionary = PDFDictionary()
        self.dictionary = dictionary
        self.content = content
        self.filters = None
    def format(self, document):
        dictionary = self.dictionary
        content = self.content
        filters = self.filters
        if self.content is None:
            raise ValueError, "stream content not set"
        if filters is None:
            filters = document.defaultStreamFilters
        if filters is not None:
            # apply filters in reverse order listed
            rf = list(filters)
            rf.reverse()
            fnames = []
            for f in rf:
                #print "*****************content:"; print repr(content[:200])
                #print "*****************filter", f.pdfname
                content = f.encode(content)
                fnames.insert(0, PDFName(f.pdfname))
            #print "*****************finally:"; print content[:200]
            #print "****** FILTERS", fnames
            #stop
            dictionary["Filter"] = PDFArray(fnames)
        fc = format(content, document)
        #print "type(content)", type(content)
        #if fc!=content: burp
        # set dictionary length parameter
        dictionary["Length"] = len(content)
        fd = format(dictionary, document)
        sdict = LINEENDDICT.copy()
        sdict["dictionary"] = fd
        sdict["content"] = fc
        return STREAMFMT % sdict

def teststream(content=None):
    #content = "" # test
    if content is None:
        content = teststreamcontent
    content = string.strip(content)
    content = string.replace(content, "\n", LINEEND) + LINEEND
    S = PDFStream()
    S.content = content
    S.filters = [PDFBase85Encode, PDFZCompress]
    # nothing else needed...
    S.__Comment__ = "test stream"
    return S

teststreamcontent = """
1 0 0 1 0 0 cm BT /F9 12 Tf 14.4 TL ET
1.00 0.00 1.00 rg
n 72.00 72.00 432.00 648.00 re B*
"""       
class PDFArray:
    multiline = LongFormat
    def __init__(self, sequence):
        self.sequence = list(sequence)
    def References(self, document):
        """make all objects in sequence references"""
        self.sequence = map(document.Reference, self.sequence)
    def format(self, document):
        #ssequence = map(str, self.sequence)
        sequence = self.sequence
        fsequence = []
        for elt in sequence:
            felt = format(elt, document)
            fsequence.append(felt)
        if self.multiline:
            Lj = string.join(fsequence, LINEEND)
            Lj = indent(Lj)
        else:
            # break up every 10 elements anyway
            Lj = fsequence
            breakline = LINEEND+" "
            for i in range(10, len(Lj), 10):
                Lj.insert(i,breakline)
            Lj = string.join(Lj)
        return "[ %s ]" % Lj

INDIRECTOBFMT = ("%(n)s %(v)s obj%(LINEEND)s"
                 "%(content)s" "%(LINEEND)s"
                 "endobj" "%(LINEEND)s")

class PDFIndirectObject:
    __RefOnly__ = 1
    def __init__(self, name, content):
        self.name = name
        self.content = content
    def format(self, document):
        name = self.name
        (n, v) = document.idToObjectNumberAndVersion[name]
        content = self.content
        fcontent = format(content, document, toplevel=1) # yes this is at top level
        sdict = LINEENDDICT.copy()
        sdict["n"] = n
        sdict["v"] = v
        sdict["content"] = fcontent
        return INDIRECTOBFMT % sdict

class PDFObjectReference:
    def __init__(self, name):
        self.name = name
    def format(self, document):
        name = self.name
        (n, v) = document.idToObjectNumberAndVersion[name]
        return "%s %s R" % (n,v)

### chapter 5

PDFHeader = ("%PDF-1.3"+LINEEND+"%í춾  "+LINEEND)

class PDFFile:
    ### just accumulates strings: keeps track of current offset
    def __init__(self):
        self.strings = []
        self.offset = 0
        self.add(PDFHeader)
    def add(self, s):
        """should be constructed as late as possible, return position where placed"""
        result = self.offset
        self.offset = result+len(s)
        self.strings.append(s)
        return result
    def format(self, document):
        return string.join(self.strings, "")

XREFFMT = '%0.10d %0.5d n'    

class PDFCrossReferenceSubsection:
    def __init__(self, firstentrynumber, idsequence):
        self.firstentrynumber = firstentrynumber
        self.idsequence = idsequence
    def format(self, document):
        """id sequence should represent contiguous object nums else error. free numbers not supported (yet)"""
        firstentrynumber = self.firstentrynumber
        idsequence = self.idsequence
        entries = list(idsequence)
        nentries = len(idsequence)
        # special case: object number 0 is always free
        taken = {}
        if firstentrynumber==0:
            taken[0] = "standard free entry"
            nentries = nentries+1
            entries.insert(0, "0000000000 65535 f")
        idToNV = document.idToObjectNumberAndVersion
        idToOffset = document.idToOffset
        lastentrynumber = firstentrynumber+nentries-1
        for id in idsequence:
            (num, version) = idToNV[id]
            if taken.has_key(num):
                raise ValueError, "object number collision %s %s %s" % (num, repr(id), repr(taken[id]))
            if num>lastentrynumber or num<firstentrynumber:
                raise ValueError, "object number %s not in range %s..%s" % (num, firstentrynumber, lastentrynumber)
            # compute position in list
            rnum = num-firstentrynumber
            taken[num] = id
            offset = idToOffset[id]
            entries[num] = XREFFMT % (offset, version)
        # now add the initial line
        firstline = "%s %s" % (firstentrynumber, nentries)
        entries.insert(0, firstline)
        # make sure it ends with a LINEEND
        entries.append("")
        if LINEEND=="\n" or LINEEND=="\r":
            reflineend = " "+LINEEND # as per spec
        elif LINEEND=="\r\n":
            reflineend = LINEEND
        else:
            raise ValueError, "bad end of line! %s" % repr(LINEEND)
        return string.join(entries, LINEEND)

class PDFCrossReferenceTable:

    def __init__(self):
        self.sections = []
    def addsection(self, firstentry, ids):
        section = PDFCrossReferenceSubsection(firstentry, ids)
        self.sections.append(section)
    def format(self, document):
        sections = self.sections
        if not sections:
            raise ValueError, "no crossref sections"
        L = ["xref"+LINEEND]
        for s in self.sections:
            fs = format(s, document)
            L.append(fs)
        return string.join(L, "")

TRAILERFMT = ("trailer%(LINEEND)s"
              "%(dict)s%(LINEEND)s"
              "startxref%(LINEEND)s"
              "%(startxref)s%(LINEEND)s"
              "%(PERCENT)s%(PERCENT)sEOF")

class PDFTrailer:

    def __init__(self, startxref, Size=None, Prev=None, Root=None, Info=None, ID=None, Encrypt=None):
        self.startxref = startxref
        if Size is None or Root is None:
            raise ValueError, "Size and Root keys required"
        dict = self.dict = PDFDictionary()
        for (n,v) in [("Size", Size), ("Prev", Prev), ("Root", Root),
                      ("Info", Info), ("Id", ID), ("Encrypt", Encrypt)]:
            if v is not None:
                dict[n] = v
    def format(self, document):
        fdict = format(self.dict, document)
        D = LINEENDDICT.copy()
        D["dict"] = fdict
        D["startxref"] = self.startxref
        return TRAILERFMT % D

#### XXXX skipping incremental update,
#### encryption

#### chapter 6, doc structure

class PDFCatalog:
    __Comment__ = "Document Root"
    __RefOnly__ = 1
    # to override, set as attributes
    __Defaults__ = {"Type": PDFName("Catalog"),
                "PageMode": PDFName("UseNone"),
                }
    __NoDefault__ = string.split("""
        Dests Outlines Pages Threads AcroForm Names OpenActions PageMode URI
        ViewerPreferences PageLabels PageLayout JavaScript StructTreeRoot SpiderInfo"""
                                 )
    __Refs__ = __NoDefault__ # make these all into references, if present
    
    def format(self, document):
        self.check_format(document)
        defaults = self.__Defaults__
        Refs = self.__Refs__
        D = {}
        for k in defaults.keys():
            default = defaults[k]
            v = None
            if hasattr(self, k) and getattr(self,k) is not None:
                v = getattr(self, k)
            elif default is not None:
                v = default
            if v is not None:
                D[k] = v
        for k in self.__NoDefault__:
            if hasattr(self, k):
                v = getattr(self,k)
                if v is not None:
                    D[k] = v
        # force objects to be references where required
        for k in Refs:
            if D.has_key(k):
                #print"k is", k, "value", D[k]
                D[k] = document.Reference(D[k])
        dict = PDFDictionary(D)
        return format(dict, document)

    def showOutline(self):
        self.PageMode = PDFName("UseOutlines")

    def showFullScreen(self):
        self.PageMode = PDFName("FullScreen")
        
    def check_format(self, document):
        """for use in subclasses"""
        pass

# not yet implementing
#  ViewerPreferences, PageLabelDictionaries,

class PDFPages(PDFCatalog):
    """PAGES TREE WITH ONE INTERNAL NODE, FOR "BALANCING" CHANGE IMPLEMENATION"""
    __Comment__ = "page tree"
    __RefOnly__ = 1
    # note: could implement page attribute inheritance...
    __Defaults__ = {"Type": PDFName("Pages"),
                    }
    __NoDefault__ = string.split("Kids Count Parent")
    __Refs__ = ["Parent"]
    def __init__(self):
        self.pages = []
    def __getitem__(self, item):
        return self.pages[item]
    def addPage(self, page):
        self.pages.append(page)
    def check_format(self, document):
        # convert all pages to page references
        pages = self.pages
        kids = PDFArray(self.pages)
        # make sure all pages are references
        kids.References(document)
        self.Kids = kids
        self.Count = len(pages)

class PDFPage(PDFCatalog):
    __Comment__ = "Page dictionary"
    # all PDF attributes can be set explicitly
    # if this flag is set, the "usual" behavior will be suppressed
    Override_default_compilation = 0
    __RefOnly__ = 1
    __Defaults__ = {"Type": PDFName("Page"),
                   # "Parent": PDFObjectReference(Pages),  # no! use document.Pages
                    }
    __NoDefault__ = string.split(""" Parent
        MediaBox Resources Contents CropBox Rotate Thumb Annots B Dur Hid Trans AA
        PieceInfo LastModified SeparationInfo ArtBox TrimBox BleedBox ID PZ
    """)
    __Refs__ = string.split("""
        Contents Parent ID
    """)
    pagewidth = 595
    pageheight = 842
    stream = None
    hasImages = 0
    compression = 0
    XObjects = None
    # transitionstring?
    # xobjects?
    # annotations
    def __init__(self):
        # set all nodefaults to None
        for name in self.__NoDefault__:
            setattr(self, name, None)
    def setCompression(self, onoff):
        self.compression = onoff
    def setStream(self, code):
        if self.Override_default_compilation:
            raise ValueError, "overridden! must set stream explicitly"
        from types import ListType
        if type(code) is ListType:
            code = string.join(code, LINEEND)+LINEEND
        self.stream = code
        
    def check_format(self, document):
        # set up parameters unless usual behaviour is suppressed
        if self.Override_default_compilation:
            return   
        self.MediaBox = self.MediaBox or PDFArray([0, 0, self.pagewidth, self.pageheight])
        if not self.Annots:
            self.Annots = None
        else:
            #print self.Annots
            #raise ValueError, "annotations not reimplemented yet"
            if type(self.Annots) is not types.InstanceType:
                self.Annots = PDFArray(self.Annots)
        if not self.Contents:
            stream = self.stream
            if not stream:
                self.Contents = teststream()
            else:
                S = PDFStream()
                if self.compression:
                    S.filters = [PDFZCompress, PDFBase85Encode]
                S.content = stream
                S.__Comment__ = "page stream"
                self.Contents = S
        if not self.Resources:
            resources = PDFResourceDictionary()
            # fonts!
            resources.basicFonts()
            if self.hasImages:
                resources.allProcs()
            else:
                resources.basicProcs()
            if self.XObjects:
                #print "XObjects", self.XObjects.dict
                resources.XObject = self.XObjects
            self.Resources = resources
        if not self.Parent:
            pages = document.Pages
            self.Parent = document.Reference(pages)

def testpage(document):
    P = PDFPage()
    P.Contents = teststream()
    pages = document.Pages
    P.Parent = document.Reference(pages)
    P.MediaBox = PDFArray([0, 0, 595, 841])
    resources = PDFResourceDictionary()
    resources.allProcs() # enable all procsets
    resources.basicFonts()
    P.Resources = resources
    pages.addPage(P)

#### DUMMY OUTLINES IMPLEMENTATION FOR testing

DUMMYOUTLINE = """
<<
  /Count
      0
  /Type
      /Outlines
>>"""

class PDFOutlines0:
    __Comment__ = "TEST OUTLINE!"
    text = string.replace(DUMMYOUTLINE, "\n", LINEEND)
    __RefOnly__ = 1
    def format(self, document):
        return self.text
        

class OutlineEntryObject:
	"an entry in an outline"
	Title = Dest = Parent = Prev = Next = First = Last = Count = None
	def format(self, document):
		D = {}
		D["Title"] = PDFString(self.Title)
		D["Parent"] = self.Parent
		D["Dest"] = self.Dest
		for n in ("Prev", "Next", "First", "Last", "Count"):
			v = getattr(self, n)
			if v is not None:
				D[n] = v
		PD = PDFDictionary(D)
		return PD.format(document)


class PDFOutlines:
	"""takes a recursive list of outline destinations
	   like
		   out = PDFOutline1()
		   out.setNames(canvas, # requires canvas for name resolution
			 "chapter1dest",
			 ("chapter2dest",
			  ["chapter2section1dest",
			   "chapter2section2dest",
			   "chapter2conclusiondest"]
			 ), # end of chapter2 description
			 "chapter3dest",
			 ("chapter4dest", ["c4s1", "c4s2"])
			 )
	   Higher layers may build this structure incrementally. KISS at base level.
	"""
	# first attempt, many possible features missing.
	#no init for now
	mydestinations = ready = None
	counter = 0
	currentlevel = -1 # ie, no levels yet
	
	def __init__(self):
		self.destinationnamestotitles = {}
		self.destinationstotitles = {}
		self.levelstack = []
		self.buildtree = []
		self.closedict = {} # dictionary of "closed" destinations in the outline

	def addOutlineEntry(self, destinationname, level=0, title=None, closed=None):
		"""destinationname of None means "close the tree" """
		from types import IntType, TupleType
		if destinationname is None and level!=0:
			raise ValueError, "close tree must have level of 0"
		if type(level) is not IntType: raise ValueError, "level must be integer, got %s" % type(level)
		if level<0: raise ValueError, "negative levels not allowed"
		if title is None: title = destinationname
		currentlevel = self.currentlevel
		stack = self.levelstack
		tree = self.buildtree
		# adjust currentlevel and stack to match level
		if level>currentlevel:
			if level>currentlevel+1:
				raise ValueError, "can't jump from outline level %s to level %s, need intermediates" %(currentlevel, level)
			level = currentlevel = currentlevel+1
			stack.append([])
		while level<currentlevel:
			# pop off levels to match
			current = stack[-1]
			del stack[-1]
			previous = stack[-1]
			lastinprevious = previous[-1]
			if type(lastinprevious) is TupleType:
				(name, sectionlist) = lastinprevious
				raise ValueError, "cannot reset existing sections: " + repr(lastinprevious)
			else:
				name = lastinprevious
				sectionlist = current
				previous[-1] = (name, sectionlist)
			#sectionlist.append(current)
			currentlevel = currentlevel-1
		if destinationname is None: return
		stack[-1].append(destinationname)
		self.destinationnamestotitles[destinationname] = title
		if closed: self.closedict[destinationname] = 1
		self.currentlevel = level
		
	def setDestinations(self, destinationtree):
		self.mydestinations = destinationtree
		
	def format(self, document):
		D = {}
		D["Type"] = PDFName("Outlines")
		c = self.count
		D["Count"] = c
		if c!=0:
		    D["First"] = self.first
		    D["Last"] = self.last
		PD = PDFDictionary(D)
		return PD.format(document)
		
	def setNames(self, canvas, *nametree):
		desttree = self.translateNames(canvas, nametree)
		self.setDestinations(desttree)
		
	def setNameList(self, canvas, nametree):
		"Explicit list so I don't need to do apply(...) in the caller"
		desttree = self.translateNames(canvas, nametree)
		self.setDestinations(desttree)
		
	def translateNames(self, canvas, object):
		"recursively translate tree of names into tree of destinations"
		from types import StringType, ListType, TupleType
		Ot = type(object)
		destinationnamestotitles = self.destinationnamestotitles
		destinationstotitles = self.destinationstotitles
		closedict = self.closedict
		if Ot is StringType:
			destination = canvas._bookmarkReference(object)
			title = object
			if destinationnamestotitles.has_key(object):
				title = destinationnamestotitles[object]
			else:
				destinationnamestotitles[title] = title
			destinationstotitles[destination] = title
			if closedict.has_key(object):
				closedict[destination] = 1 # mark destination closed
			return {object: canvas._bookmarkReference(object)} # name-->ref
		if Ot is ListType or Ot is TupleType:
			L = []
			for o in object:
				L.append(self.translateNames(canvas, o))
			if Ot is TupleType:
				return tuple(L)
			return L
		raise "in outline, destination name must be string: got a %s" % Ot

	def prepare(self, document, canvas):
		"""prepare all data structures required for save operation (create related objects)"""
		if self.mydestinations is None:
			if self.levelstack:
				self.addOutlineEntry(None) # close the tree
				destnames = self.levelstack[0]
				#from pprint import pprint; pprint(destnames); stop
				self.mydestinations = self.translateNames(canvas, destnames)
			else:
				self.first = self.last = None
				self.count = 0
				self.ready = 1
				return
		#self.first = document.objectReference("Outline.First")
		#self.last = document.objectReference("Outline.Last")
		# XXXX this needs to be generalized for closed entries!
		self.count = count(self.mydestinations, self.closedict)
		(self.first, self.last) = self.maketree(document, self.mydestinations, toplevel=1)
		self.ready = 1

	def maketree(self, document, destinationtree, Parent=None, toplevel=0):
		from types import ListType, TupleType, DictType
		tdestinationtree = type(destinationtree)
		if toplevel:
			levelname = "Outline"
			Parent = document.Reference(document.Outlines)
		else:
			self.count = self.count+1
			levelname = "Outline.%s" % self.count
			if Parent is None:
				raise ValueError, "non-top level outline elt parent must be specified"
		if tdestinationtree is not ListType and tdestinationtree is not TupleType:
			raise ValueError, "destinationtree must be list or tuple, got %s"
		nelts = len(destinationtree)
		lastindex = nelts-1
		lastelt = firstref = lastref = None
		destinationnamestotitles = self.destinationnamestotitles
		closedict = self.closedict
		for index in range(nelts):
			eltobj = OutlineEntryObject()
			eltobj.Parent = Parent
			eltname = "%s.%s" % (levelname, index)
			eltref = document.Reference(eltobj, eltname)
			#document.add(eltname, eltobj)
			if lastelt is not None:
				lastelt.Next = eltref
				eltobj.Prev = lastref
			if firstref is None:
				firstref = eltref
			lastref = eltref
			lastelt = eltobj # advance eltobj
			lastref = eltref
			elt = destinationtree[index]
			te = type(elt)
			if te is DictType:
				# simple leaf {name: dest}
				leafdict = elt
			elif te is TupleType:
				# leaf with subsections: ({name: ref}, subsections) XXXX should clean up (see count(...))
				try:
					(leafdict, subsections) = elt
				except:
					raise ValueError, "destination tree elt tuple should have two elts, got %s" % len(elt)
				eltobj.Count = count(subsections, closedict)
				(eltobj.First, eltobj.Last) = self.maketree(document, subsections, eltref)
			else:
				raise ValueError, "destination tree elt should be dict or tuple, got %s" % te
			try:
				[(Title, Dest)] = leafdict.items()
			except:
				raise ValueError, "bad outline leaf dictionary, should have one entry "+str(elt)
			eltobj.Title = destinationnamestotitles[Title]
			eltobj.Dest = Dest
			if te is TupleType and closedict.has_key(Dest):
				# closed subsection, count should be negative
				eltobj.Count = -eltobj.Count
		return (firstref, lastref)
		
def count(tree, closedict=None): 
	"""utility for outline: recursively count leaves in a tuple/list tree"""
	from operator import add
	from types import TupleType, ListType
	tt = type(tree)
	if tt is TupleType:
		# leaf with subsections XXXX should clean up this structural usage
		(leafdict, subsections) = tree
		[(Title, Dest)] = leafdict.items()
		if closedict and closedict.has_key(Dest):
			return 1 # closed tree element
	if tt is TupleType or tt is ListType:
		#return reduce(add, map(count, tree))
		counts = []
		for e in tree:
			counts.append(count(e, closedict))
		return reduce(add, counts)
	return 1
	
	

#### dummy info
DUMMYINFO = """
<</Title (testing)
/Author (arw)
/CreationDate (D:20001012220652)
/Producer (ReportLab http://www.reportlab.com)
/Subject (this file generated by an alpha test module)
>>
"""
class PDFInfo0:
    __Comment__ = "TEST INFO STRUCTURE"
    text = string.replace(DUMMYINFO, "\n", LINEEND)
    __RefOnly__ = 1
    def format(self, document):
        return self.text

class PDFInfo:
    """PDF documents can have basic information embedded, viewable from
    File | Document Info in Acrobat Reader.  If this is wrong, you get
    Postscript errors while printing, even though it does not print."""
    def __init__(self):
        self.title = "untitled"
        self.author = "anonymous"
        self.subject = "unspecified"
        #now = time.localtime(time.time())
        #self.datestr = '%04d%02d%02d%02d%02d%02d' % tuple(now[0:6])
        
    def format(self, document):
        D = {}
        D["Title"] = PDFString(self.title)
        D["Author"] = PDFString(self.author)
        D["CreationDate"] = PDFDate()
        D["Producer"] = PDFString("ReporLab http://www.reportlab.com")
        D["Subject"] = PDFString(self.subject)
        PD = PDFDictionary(D)
        return PD.format(document)

# skipping thumbnails, etc


class Annotation:
    """superclass for all annotations."""
    defaults = [("Type", PDFName("Annot"),)]
    required = ("Type", "Rect", "Contents", "Subtype")
    permitted = required+(
      "Border", "C", "T", "M", "F", "H", "BS", "AA", "AS", "Popup", "P")
    def cvtdict(self, d):
        """transform dict args from python form to pdf string rep as needed"""
        Rect = d["Rect"]
        if type(Rect) is not types.StringType:
            d["Rect"] = PDFArray(Rect)
        d["Contents"] = PDFString(d["Contents"])
        return d
    def AnnotationDict(self, **kw):
        d = {}
        for (name,val) in self.defaults:
            d[name] = val
        d.update(kw)
        for name in self.required:
            if not d.has_key(name):
                raise ValueError, "keyword argument %s missing" % name
        d = self.cvtdict(d)
        permitted = self.permitted
        for name in d.keys():
            if name not in permitted:
                raise ValueError, "bad annotation dictionary name %s" % name
        return PDFDictionary(d)
    def Dict(self):
        raise ValueError, "DictString undefined for virtual superclass Annotation, must overload"
        # but usually
        #return self.AnnotationDict(self, Rect=(a,b,c,d)) or whatever
    def format(self, document):
        D = self.Dict()
        return D.format(document)

class TextAnnotation(Annotation):
    permitted = Annotation.permitted + (
        "Open", "Name", "AP")
    def __init__(self, Rect, Contents, **kw):
        self.Rect = Rect
        self.Contents = Contents
        self.otherkw = kw
    def Dict(self):
        d = {}
        d.update(self.otherkw)
        d["Rect"] = self.Rect
        d["Contents"] = self.Contents
        d["Subtype"] = "/Text"
        return apply(self.AnnotationDict, (), d)
        
class LinkAnnotation(Annotation):
    
    permitted = Annotation.permitted + (
        "Dest", "A", "PA")
    def __init__(self, Rect, Contents, Destination, Border="[0 0 1]", **kw):
        self.Border = Border
        self.Rect = Rect
        self.Contents = Contents
        self.Destination = Destination
        self.otherkw = kw
        
    def dummyDictString(self): # old, testing
        return """
          << /Type /Annot /Subtype /Link /Rect [71 717 190 734] /Border [16 16 1]
             /Dest [23 0 R /Fit] >>
             """
             
    def Dict(self):
        d = {}
        d.update(self.otherkw)
        d["Border"] = self.Border
        d["Rect"] = self.Rect
        d["Contents"] = self.Contents
        d["Subtype"] = "/Link"
        d["Dest"] = self.Destination
        return apply(self.AnnotationDict, (), d)
        

# skipping names tree

# skipping actions

# skipping names trees

# skipping to chapter 7

class PDFRectangle:
    def __init__(self, llx, lly, urx, ury):
        self.llx, self.lly, self.ulx, self.ury = llx, lly, urx, ury
    def format(self, document):
        A = PDFArray([self.llx, self.lly, self.ulx, self.ury])
        return format(A, document)

DATEFMT = '%04d%02d%02d%02d%02d%02d'
import time
(nowyyyy, nowmm, nowdd, nowhh, nowm, nows) = tuple(time.localtime(time.time())[:6])

class PDFDate:
    # gmt offset not yet suppported
    def __init__(self, yyyy=nowyyyy, mm=nowmm, dd=nowdd, hh=nowhh, m=nowm, s=nows):
        self.yyyy=yyyy; self.mm=mm; self.dd=dd; self.hh=hh; self.m=m; self.s=s
    def format(self, doc):
        S = PDFString(DATEFMT % (self.yyyy, self.mm, self.dd, self.hh, self.m, self.s))
        return format(S, doc)

  
class Destination:
    """not a pdfobject!  This is a placeholder that can delegates
       to a pdf object only after it has been defined by the methods
       below.  EG a Destination can refer to Appendix A before it has been
       defined, but only if Appendix A is explicitly noted as a destination
       and resolved before the document is generated...
       For example the following sequence causes resolution before doc generation.
          d = Destination()
          d.fit() # or other format defining method call
          d.setPage(p)
       (at present setPageRef is called on generation of the page).
    """
    representation = format = page = None
    def __init__(self,name):
        self.name = name
    def format(self, document):
        f = self.fmt
        if f is None: raise ValueError, "format not resolved %s" % self.name
        p = self.page
        if p is None: raise ValueError, "Page reference unbound %s" % self.name
        f.page = p
        return f.format(document)
    def xyz(self, left, top, zoom):  # see pdfspec mar 11 99 pp184+
        self.fmt = PDFDestinationXYZ(None, left, top, zoom)
    def fit(self):
        self.fmt = PDFDestinationFit(None)
    def fitb(self):
        self.fmt = PDFDestinationFitB(None)
    def fith(self, top):
        self.fmt = PDFDestinationFitH(None,top)
    def fitv(self, left):
        self.fmt = PDFDestinationFitV(None, left)
    def fitbh(self, top):
        self.fmt = PDFDestinationFitBH(None, top)
    def fitbv(self, left):
        self.fmt = PDFDestinationFitBV(None, left)
    def fitr(self, left, bottom, right, top):
        self.fmt = PDFDestinationFitR(None, left, bottom, right, top)
    def setPage(self, page):
        self.page = page
        #self.fmt.page = page # may not yet be defined!
            
class PDFDestinationXYZ:
    typename = "XYZ"
    def __init__(self, page, left, top, zoom):
        self.page = page; self.top=top; self.zoom=zoom
    def format(self, document):
        pageref = document.Reference(self.page)
        A = PDFArray( [ pageref, PDFName(self.typename), self.left, self.top, self.zoom ] )
        return format(A, document)
    
class PDFDestinationFit:
    typename = "Fit"
    def __init__(self, page):
        self.page = page
    def format(self, document):
        pageref = document.Reference(self.page)
        A = PDFArray( [ pageref, PDFName(self.typename) ] )
        return format(A, document)

class PDFDestinationFitB(PDFDestinationFit):
    typename = "FitB"
    
class PDFDestinationFitH:
    typename = "FitH"
    def __init__(self, page, top):
        self.page = page; self.top=top
    def format(self, document):
        pageref = document.Reference(self.page)
        A = PDFArray( [ pageref, PDFName(self.typename), self.top ] )
        return format(A, document)

class PDFDestinationFitBH(PDFDestinationFitH):
    typename = "FitBH"
    
class PDFDestinationFitV:
    typename = "FitV"
    def __init__(self, page, left):
        self.page = page; self.left=left
    def format(self, document):
        pageref = document.Reference(self.page)
        A = PDFArray( [ pageref, PDFName(self.typename), self.left ] )
        return format(A, document)

class PDFDestinationBV(PDFDestinationFitV):
    typename = "FitBV"

class PDFDestinationFitR:
    typename = "FitR"
    def __init__(self, page, left, bottom, right, top):
        self.page = page; self.left=left; self.bottom=bottom; self.right=right; self.top=top
    def format(self, document):
        pageref = document.Reference(self.page)
        A = PDFArray( [ pageref, PDFName(self.typename), self.left, self.bottom, self.right, self.top] )
        return format(A, document)

# named destinations need nothing

# skipping filespecs

class PDFResourceDictionary:
    """each element *could* be reset to a reference if desired"""
    def __init__(self):
        self.ColorSpace = {}
        self.XObject = {}
        self.ExtGState = {}
        self.Font = {}
        self.Pattern = {}
        self.ProcSet = []
        self.Properties = {}
        self.Shading = {}
        # ?by default define the basicprocs
        self.basicProcs()
    stdprocs = map(PDFName, string.split("PDF Text ImageB ImageC ImageI"))
    dict_attributes = ("ColorSpace", "XObject", "ExtGState", "Font", "Pattern", "Properties", "Shading")
    def allProcs(self):
        # define all standard procsets
        self.ProcSet = self.stdprocs
    def basicProcs(self):
        self.ProcSet = self.stdprocs[:2] # just PDF and Text
    def basicFonts(self):
        self.Font = PDFObjectReference(BasicFonts)
    def format(self, document):
        D = {}
        from types import ListType, DictType
        for dname in self.dict_attributes:
            v = getattr(self, dname)
            if type(v) is DictType:
                if v:
                    dv = PDFDictionary(v)
                    D[dname] = dv
            else:
                D[dname] = v
        v = self.ProcSet
        dname = "ProcSet"
        if type(v) is ListType:
            if v:
                dv = PDFArray(v)
                D[dname] = dv
        else:
            D[dname] = v
        DD = PDFDictionary(D)
        return format(DD, document)

class PDFType1Font:
    """no init: set attributes explicitly"""
    __RefOnly__ = 1
    # note! /Name appears to be an undocumented attribute....
    name_attributes = string.split("Type Subtype BaseFont ToUnicode Name")
    Type = "Font"
    Subtype = "Type1"
    # these attributes are assumed to already be of the right type
    local_attributes = string.split("FirstChar LastChar Widths Encoding FontDescriptor")
    def format(self, document):
        D = {}
        for name in self.name_attributes:
            if hasattr(self, name):
                value = getattr(self, name)
                D[name] = PDFName(value)
        for name in self.local_attributes:
            if hasattr(self, name):
                value = getattr(self, name)
                D[name] = value
        #print D
        PD = PDFDictionary(D)
        return PD.format(document)

def MakeStandardEnglishFontObjects(document, encoding=DEFAULT_ENCODING):
    # make the standard fonts and the standard font dictionary
    if encoding not in ALLOWED_ENCODINGS:
        raise ValueError, "bad encoding %s" % repr(encoding)
    D = {}
    count = 1
    fontmapping = document.fontMapping
    for name in StandardEnglishFonts:
        F = PDFType1Font()
        F.BaseFont = name
        F.Encoding = PDFName(DEFAULT_ENCODING)
        F.__Comment__ = "Standard English Font %s" % repr(name)
        fname = "F"+repr(count)
        F.Name = fname
        R = document.Reference(F, fname)
        D[fname] = R
        fontmapping[name] = "/"+fname # record the external to internal name map (NOT REALLY A PDFNAME: PAGE DESC)
        count = count+1
    DD = PDFDictionary(D)
    DD.__Comment__ = "The standard fonts dictionary"
    DDR = document.Reference(DD, BasicFonts)
    return DDR

class PDFTrueTypeFont(PDFType1Font):
    Subtype = "TrueType"
    #local_attributes = string.split("FirstChar LastChar Widths Encoding FontDescriptor") #same

class PDFMMType1Font(PDFType1Font):
    Subtype = "MMType1"

class PDFType3Font(PDFType1Font):
    Subtype = "Type3"
    local_attributes = string.split(
        "FirstChar LastChar Widths CharProcs FontBBox FontMatrix Resources Encoding")

class PDFType0Font(PDFType1Font):
    Subtype = "Type0"
    local_attributes = string.split(
        "DescendantFonts Encoding")

class PDFCIDFontType0(PDFType1Font):
    Subtype = "CIDFontType0"
    local_attributes = string.split(
        "CIDSystemInfo FontDescriptor DW W DW2 W2 Registry Ordering Supplement")

class PDFCIDFontType0(PDFType1Font):
    Subtype = "CIDFontType2"
    local_attributes = string.split(
        "BaseFont CIDToGIDMap CIDSystemInfo FontDescriptor DW W DW2 W2")

class PDFEncoding(PDFType1Font):
    Type = "Encoding"
    name_attributes = string.split("Type BaseEncoding")
    # these attributes are assumed to already be of the right type
    local_attributes = ["Differences"]

# skipping CMaps

class PDFFormXObject:
    # like page requires .info set by some higher level (doc)
    # XXXX any resource used in a form must be propagated up to the page that (recursively) uses
    #   the form!! (not implemented yet).
    XObjects = Annots = BBox = Matrix = Contents = stream = Resources = None
    hasImages = 1 # probably should change
    compression = 0
    def __init__(self, lowerx, lowery, upperx, uppery):
        #not done
        self.lowerx = lowerx; self.lowery=lowery; self.upperx=upperx; self.uppery=uppery
        
    def setStreamList(self, data):
        if type(data) is types.ListType:
            data = string.join(data, LINEEND)
        self.stream = data
        
    def format(self, document):
        self.BBox = self.BBox or PDFArray([self.lowerx, self.lowery, self.upperx, self.uppery])
        self.Matrix = self.Matrix or PDFArray([1, 0, 0, 1, 0, 0])
        if not self.Annots:
            self.Annots = None
        else:
            raise ValueError, "annotations not reimplemented yet"
        if not self.Contents:
            stream = self.stream
            if not stream:
                self.Contents = teststream()
            else:
                S = PDFStream()
                S.content = stream
                # need to add filter stuff (?)
                S.__Comment__ = "xobject form stream"
                self.Contents = S
        if not self.Resources:
            resources = PDFResourceDictionary()
            # fonts!
            resources.basicFonts()
            if self.hasImages:
                resources.allProcs()
            else:
                resources.basicProcs()
        if self.compression:
            self.Contents.filters = [PDFBase85Encode, PDFZCompress]
        sdict = self.Contents.dictionary
        sdict["Type"] = PDFName("XObject")
        sdict["Subtype"] = PDFName("Form")
        sdict["FormType"] = 1
        sdict["BBox"] = self.BBox
        sdict["Matrix"] = self.Matrix
        sdict["Resources"] = resources
        return self.Contents.format(document)

if __name__=="__main__":
    # first test
    print "line end is", repr(LINEEND)
    print "PDFName", PDFName("test")
    D = PDFDocument(dummyoutline=1)
    print "PDFDict", PDFDictionary({"this":1}).format(D)
    testpage(D)
    txt = D.format()
    fn = "test.pdf"
    f = open(fn, "wb")
    f.write(txt)
    print "wrote", fn