__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