###############################################################################

#

#	ReportLab Public License Version 1.0

#

#   Except for the change of names the spirit and intention of this

#   license is the same as that of Python

#

#	(C) Copyright ReportLab Inc. 1998-2000.

#

#

# All Rights Reserved

#

# Permission to use, copy, modify, and distribute this software and its

# documentation for any purpose and without fee is hereby granted, provided

# that the above copyright notice appear in all copies and that both that

# copyright notice and this permission notice appear in supporting

# documentation, and that the name of ReportLab not be used

# in advertising or publicity pertaining to distribution of the software

# without specific, written prior permission. 

# 

#

# Disclaimer

#

# ReportLab Inc. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,

# IN NO EVENT SHALL ReportLab BE LIABLE FOR ANY SPECIAL, INDIRECT

# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

# PERFORMANCE OF THIS SOFTWARE. 

#

###############################################################################

#	$Log: pdfdoc.py,v $

#	Revision 1.28  2000/10/18 16:37:22  aaron_watters

#	undid last checkin and added an option for a default outline (different fix)

#	Revision 1.27  2000/10/18 16:26:17  aaron_watters

#	moved the outline preprocessing step into the format method (fixes testing error)

#	

#	Revision 1.26  2000/10/18 05:03:21  aaron_watters

#	complete revision of pdfdoc.  Not finished (compression missing, testing needed)

#	I got Robin's last change in at the last moment :)

#	

#	Revision 1.24  2000/09/08 10:04:08  rgbecker

#	Paul Eddington's unix tell() returns a LongIntType bugfix

#	

#	Revision 1.23  2000/08/24 02:26:04  aaron_watters

#	change to PDFLiteral to support "lazy string conversions" (to support lazy crosslinks)

#	

#	Revision 1.22  2000/08/09 10:57:52  rgbecker

#	Andy's Symbol/Zapf font fix

#	

#	Revision 1.21  2000/06/26 15:58:22  rgbecker

#	Simple fix to widths problem

#	

#	Revision 1.20  2000/06/23 17:51:22  aaron_watters

#	/Producer (ReportLab http://www.reportlab.com) in document

#	

#	Revision 1.19  2000/06/01 09:44:26  rgbecker

#	SaveToFile: only close the file if we opened it.

#	Aggregated from types imports to module level.

#	

#	Revision 1.18  2000/04/28 17:33:44  andy_robinson

#	Added font encoding support and changed default encoding to WinAnsi

#	

#	Revision 1.17  2000/04/28 09:08:42  rgbecker

#	Fix typo in SaveToFile

#	

#	Revision 1.16  2000/04/27 18:11:56  rgbecker

#	Dinu's SaveFile patch

#	

#	Revision 1.15  2000/04/25 20:19:07  aaron_watters

#	added support for closed outline entries

#	

#	Revision 1.14  2000/04/18 19:50:30  aaron_watters

#	Minor support for inPage/inForm api elimination in canvas

#	

#	Revision 1.13  2000/04/15 15:00:09  aaron_watters

#	added support for addOutlineEntry0 api

#	

#	Revision 1.12  2000/04/06 09:52:02  andy_robinson

#	Removed some old comments; tweaks to experimental Outline methods.

#	

#	Revision 1.11  2000/04/02 02:52:39  aaron_watters

#	added support for outline trees

#	

#	Revision 1.10  2000/03/24 21:03:51  aaron_watters

#	Added forms, destinations, linkages and other features

#	

#	Revision 1.7  2000/02/23 15:09:23  rgbecker

#	Memory leak fixes

#	

#	Revision 1.6  2000/02/17 12:36:25  rgbecker

#	added _HAVE_ZLIB to stop compression being set without zlib

#	

#	Revision 1.5  2000/02/17 02:07:23  rgbecker

#	Docstring & other fixes

#	

#	Revision 1.4  2000/02/16 09:42:50  rgbecker

#	Conversion to reportlab package

#	

#	Revision 1.3  2000/02/15 17:55:59  rgbecker

#	License text fixes

#	

#	Revision 1.2  2000/02/15 15:47:09  rgbecker

#	Added license, __version__ and Logi comment

#	

__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.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):

    # 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)