root/trunk/dabo/lib/reportWriter.py

# -*- coding: utf-8 -*-
import copy
import datetime

import decimal
Decimal = decimal.Decimal

import locale
import sys
import os
######################################################
# Very first thing: check for required libraries:
_failedLibs = []
for lib in ("reportlab", "PIL"):
    try:
        __import__(lib)
    except ImportError:
        _failedLibs.append(lib)

if len(_failedLibs) > 0:
    msg = """
The Dabo Report Writer has dependencies on libraries you
don't appear to have installed. You still need:

    %s

PIL is the Python Imaging Library available from
http://www.pythonware.com/products/pil

reportlab is the ReportLab toolkit available from
http://www.reportlab.org

If you are on a Debian Linux system, just issue:
sudo apt-get install python-reportlab
sudo apt-get install python-imaging

    """ % "\n\t".join(_failedLibs)

    raise ImportError(msg)
del(_failedLibs)
#######################################################

import cStringIO
import reportlab.pdfgen.canvas as canvas
import reportlab.graphics.shapes as shapes
import reportlab.lib.pagesizes as pagesizes
import reportlab.lib.units as units
import reportlab.lib.styles as styles
import reportlab.platypus as platypus
#import reportlab.lib.colors as colors
from dabo.lib.xmltodict import xmltodict
from dabo.lib.xmltodict import dicttoxml
from dabo.dLocalize import _
from dabo.lib.caselessDict import CaselessDict
from reportlab.lib.utils import ImageReader
from PIL import Image as PILImage
import reportUtils

# The below block tried to use the experimental para.Paragraph which
# handles more html tags, including hyperlinks. However, I couldn't 
# get it to work... among other things, para doesn't accept None as
# the availableHeight argument to wrap().
if False:
    try:
        from reportlab.platypus.para import Paragraph as ParaClass
    except ImportError:
        print "No Para class, using Paragraph."
        ParaClass = platypus.Paragraph
else:
    ParaClass = platypus.Paragraph


def toPropDict(dataType, default, doc):
    return {"dataType": dataType, "default": default, "doc": doc}


class ReportObjectCollection(list):
    """Abstract ordered list of things like variables, groups, and band objects."""

    def __init__(self, parent=None, *args, **kwargs):
        super(ReportObjectCollection, self).__init__(*args, **kwargs)
        self.parent = parent

    def addObject(self, cls):
        obj = cls(self)
        self.append(obj)
        return obj

    def getPropDoc(self, prop):
        return ""

    def _getDesProps(self):
        return {}

    DesignerProps = property(_getDesProps, None, None,
        _("""Returns a dict of editable properties for the control, with the 
        prop names as the keys, and the value for each another dict, 
        containing the following keys: 'type', which controls how to display
        and edit the property, and 'readonly', which will prevent editing
        when True. (dict)""") )


class Variables(ReportObjectCollection): pass
class Groups(ReportObjectCollection): pass
class Objects(ReportObjectCollection): pass


class ReportObject(CaselessDict):
    """Abstract report object, such as a drawable object, a variable, or a group."""
    def __init__(self, parent=None, *args, **kwargs):
        super(ReportObject, self).__init__(*args, **kwargs)
        self.parent = parent
        self.initAvailableProps()
        self.insertRequiredElements()

    def __getattr__(self, att):
        rw = self.Report.reportWriter

        # 1) Try mapping the requested attribute to the reportWriter. This will handle
        #    things like 'self.Application'.
        try:
            return getattr(rw, att)
        except AttributeError:
            pass

        # 2) Try mapping to a variable (self.ord_amount -> self.Variables["ord_amount"])
        if self.Variables.has_key(att):
            return self.Variables.get(att)

        # 3) Try mapping to a field in the dataset (self.ordid -> self.Record["ordid"])
        if self.Record.has_key(att):
            return self.Record.get(att)

        raise AttributeError("Can't get attribute '%s'." % att)


    def initAvailableProps(self):
        self.AvailableProps["Comment"] = toPropDict(str, "", 
                """You can add a comment here, the report will ignore it.""")

    def insertRequiredElements(self):
        """Insert any missing required elements into the object."""
        pass

    def addElement(self, cls):
        """Add a new element, replacing existing one of same name."""
        obj = cls(self)
        self[obj.__class__.__name__] = obj
        return obj

    def addObject(self, cls, collectionClass=Objects):
        obj = cls(self)
        collectionName = Objects.__name__
        objects = self.get(collectionName, collectionClass(self))
        objects.append(obj)
        self[collectionName] = objects
        return obj

    def getMemento(self, start=None):
        """Return a copy of all the key/values of this and all sub-objects."""
        if start is None:
            start = self
        m = {"type": start.__class__.__name__}

        for k, v in start.items():
            if isinstance(v, dict):
                m[k] = self.getMemento(v)
            elif isinstance(v, list):
                m[k] = []
                for c in v:
                    m[k].append(self.getMemento(c))
            else:
                m[k] = v
        return m            


    def getProp(self, prop, evaluate=True, returnException=False):
        """Return the value of the property.

        If defined, it will be eval()'d. Otherwise, the default will be returned.
        If there isn't a default, an exception will be raised as the object isn't
        set up to have the passed prop.
        """
        def getDefault():
            if self.AvailableProps.has_key(prop):
                val = self.AvailableProps[prop]["default"]
                if not evaluate:
                    # defaults are not stringified:
                    val = repr(val)
                return val
            else:
                raise ValueError("Property name '%s' unrecognized." % prop)

        if self.has_key(prop):
            if not evaluate or prop == "type":
                return self[prop]
            try:
                return eval(self[prop])
            except Exception, e:
                # eval() failed. Return the default or the exception string.
                if returnException:
                    return e
                return getDefault()
        else:
            # The prop isn't defined, use the default.
            return getDefault()


    def setProp(self, prop, val):
        """Update the value of the property."""
        if not self.AvailableProps.has_key(prop):
            raise ValueError("Property '%s' doesn't exist." % prop)
        self[prop] = val


    def getPropVal(self, propName):
        return self.getProp(propName, evaluate=False)

    def getPropDoc(self, propName):
        return self.AvailableProps[propName]["doc"]

    def updatePropVal(self, propName, propVal):
        self.setProp(str(propName), str(propVal))


    def _getAvailableProps(self):
        if hasattr(self, "_AvailableProps"):
            val = self._AvailableProps
        else:
            val = self._AvailableProps = CaselessDict()
        return val

    def _setAvailableProps(self, val):
        self._AvailableProps = val


    def _getBands(self):
        return self.Report.reportWriter.Bands


    def _getDesProps(self):
        strType = {"type" : str, "readonly" : False, "alsoDirectEdit": True}
        props = self.AvailableProps.keys()
        desProps = {}
        for prop in props:
            desProps[prop] = strType.copy()
            if "color" in prop.lower():
                desProps[prop]["customEditor"] = "editColor"
## 2006/1/30: The commented code below makes a dropdown list for the standard 
#             fonts. However, it blows away the user being able to type in a
#             font that isn't in the standard list. Same with the other props.
#             We need to get a combobox editor working, so that the user can 
#             free-form type as well as select a predefined value from the list.
#           if prop.lower() == "fontname":
#               desProps[prop]["type"] = list
#               desProps[prop]["values"] = ['"Courier"', '"Courier-Bold"', 
#                       '"Courier-Oblique"', '"Courier-BoldOblique"', '"Helvetica"', 
#                       '"Helvetica-Bold"', '"Helvetica-Oblique"', '"Helvetica-BoldOblique"',
#                       '"Times-Roman"', '"Times-Bold"', '"Times-Italic"', 
#                       '"Times-BoldItalic"', '"Symbol"', '"ZapfDingbats"']
#           if prop.lower() == "hanchor":
#               desProps[prop]["type"] = list
#               desProps[prop]["values"] = ['"Left"', '"Center"', '"Right"'] 
#           if prop.lower() == "vanchor":
#               desProps[prop]["type"] = list
#               desProps[prop]["values"] = ['"Bottom"', '"Middle"', '"Top"']
#           if prop.lower() == "orientation" and self.__class__.__name__ == "Page":
#               desProps[prop]["type"] = list
#               desProps[prop]["values"] = ['"Portrait"', '"Landscape"']
        return desProps


    def _getRecord(self):
        if hasattr(self.Report, "_liveRecord"):
            return self.Report._liveRecord
        return {}


    def _getReport(self):
        parent = self
        while not isinstance(parent, Report):
            parent = parent.parent
        return parent


    def _getVariables(self):
        return self.Report.reportWriter.Variables


    AvailableProps = property(_getAvailableProps, _setAvailableProps)
    Bands = property(_getBands)

    DesignerProps = property(_getDesProps, None, None,
        _("""Returns a dict of editable properties for the control, with the 
        prop names as the keys, and the value for each another dict, 
        containing the following keys: 'type', which controls how to display
        and edit the property, and 'readonly', which will prevent editing
        when True. (dict)""") )

    Record = property(_getRecord)
    Report = property(_getReport)
    Variables = property(_getVariables)


class Drawable(ReportObject):
    """Abstract drawable report object, such as a rectangle or string."""
    def initAvailableProps(self):
        super(Drawable, self).initAvailableProps()

        self.AvailableProps["DesignerLock"] = toPropDict(bool, False, 
                """Specifies whether the object's geometry can be changed interactively.

                Setting designerLock to True protects you from accidentally changing
                the size and position of the object with the mouse at design time.""")

        self.AvailableProps["x"] = toPropDict(float, 0.0, 
                """Specifies the horizontal position of the object, relative to hAnchor.""")

        self.AvailableProps["y"] = toPropDict(float, 0.0, 
                """Specifies the vertical position of the object, relative to vAnchor.""")

        self.AvailableProps["Width"] = toPropDict(float, 55.0, 
                """Specifies the width of the object.""")

        self.AvailableProps["Height"] = toPropDict(float, 18.0, 
                """Specifies the height of the object.""")

        self.AvailableProps["Rotation"] = toPropDict(float, 0.0, 
                """Specifies the rotation of the object, in degrees.""")

        self.AvailableProps["hAnchor"] = toPropDict(str, "left", 
                """Specifies where horizontal position is relative to.

                Must evaluate to 'left', 'center', or 'right'.""")

        self.AvailableProps["vAnchor"] = toPropDict(str, "bottom", 
                """Specifies where vertical position is relative to.

                Must evaluate to 'bottom', 'middle', or 'top'.""")

        self.AvailableProps["Show"] = toPropDict(bool, None, 
                """Determines if the object is shown on the report.

                Specify an expression that evaluates to True or False. If False,
                the object will not be shown on the report. Otherwise, it will.
                Just like all other properties, your expression will be evaluated
                every time this object is to be printed.
                """)


class Report(ReportObject):
    """Represents the report."""

    def initAvailableProps(self):
        super(Report, self).initAvailableProps()

        self.AvailableProps["Title"] = toPropDict(str, "", 
                """Specifies the title of the report.""")

        self.AvailableProps["ColumnCount"] = toPropDict(int, 1, 
                """Specifies the number of columns to divide the report into.""")

    def insertRequiredElements(self):
        """Insert any missing required elements into the report form."""
        self.setdefault("Title", "")
        self.setdefault("Page", Page(self))
        self.setdefault("PageHeader", PageHeader(self))
        self.setdefault("Detail", Detail(self))
        self.setdefault("PageFooter", PageFooter(self))
        self.setdefault("PageBackground", PageBackground(self))
        self.setdefault("PageForeground", PageForeground(self))
        self.setdefault("Groups", Groups(self))
        self.setdefault("Variables", Variables(self))


class Page(ReportObject):
    """Represents the page."""
    def initAvailableProps(self):
        super(Page, self).initAvailableProps()
        self.AvailableProps["MarginBottom"] = toPropDict(float, ".5 in", 
                """Specifies the page's bottom margin.""")

        self.AvailableProps["MarginLeft"] = toPropDict(float, ".5 in", 
                """Specifies the page's left margin.""")

        self.AvailableProps["MarginTop"] = toPropDict(float, ".5 in", 
                """Specifies the page's top margin.""")

        self.AvailableProps["MarginRight"] = toPropDict(float, ".5 in", 
                """Specifies the page's right margin.""")

        self.AvailableProps["Orientation"] = toPropDict(str, "portrait", 
                """Specifies the page orientation.

                Must evaluate to one of 'portrait' or 'landscape'.""")

        self.AvailableProps["Size"] = toPropDict(str, "letter", 
                """Specifies the page size.

                This is a tuple of (width, heigth) such as:
                  ('8 in', '5.5 in')

                You may also use, in place of the tuple,  some common 
                identifiers such as:
                  'Letter'
                  'A4'

                See also the Orientation property, which merely swaps
                the width and height values. """)


class Group(ReportObject):
    """Represents report groups."""
    def initAvailableProps(self):
        super(Group, self).initAvailableProps()
        self.AvailableProps["expr"] = toPropDict(str, None, 
                """Specifies the group expression.

                When the value of the group expression changes, a new group will
                be started.""")

        self.AvailableProps["StartOnNewPage"] = toPropDict(bool, False, 
                _("""Specifies whether new groups should begin on a new page."""))

        self.AvailableProps["ReprintHeaderOnNewPage"] = toPropDict(bool, False, 
                _("""Specifies whether the group header gets reprinted on new pages."""))

        self.AvailableProps["ResetPageNumber"] = toPropDict(bool, False, 
                _("""Specifies whether the page number gets reset with a new group."""))

    def insertRequiredElements(self):
        if not self.has_key("GroupHeader"):
            self["GroupHeader"] = GroupHeader(self)
        if not self.has_key("GroupFooter"):
            self["GroupFooter"] = GroupFooter(parent=self)

class Variable(ReportObject):
    """Represents report variables."""
    def initAvailableProps(self):
        super(Variable, self).initAvailableProps()
        self.AvailableProps["InitialValue"] = toPropDict(str, None, 
                """Specifies the variable's initial value.""")

        self.AvailableProps["expr"] = toPropDict(str, None, 
                """Specifies the variable expression.

                At every new record in the cursor, the variable expression will be
                evaluated.""")

        self.AvailableProps["Name"] = toPropDict(str, None, 
                """Specifies the name of the variable.""")

        self.AvailableProps["ResetAt"] = toPropDict(str, None, 
                """Specifies when to reset the variable to the initial value.

                Typically, this will match a particular group expression.""")



class Band(ReportObject):
    """Abstract band."""
    def initAvailableProps(self):
        super(Band, self).initAvailableProps()
        self.AvailableProps["Height"] = toPropDict(float, 0.0, 
                """Specifies the height of the band.

                If the height evaluates to None, the height of the band will size
                itself dynamically at runtime.""")

        self.AvailableProps["DesignerLock"] = toPropDict(bool, False, 
                """Specifies whether the band height can be changed interactively.

                Setting designerLock to True protects you from accidentally changing
                the height of the band with the mouse at design time.""")

    def insertRequiredElements(self):
        """Insert any missing required elements into the band."""
        self.setdefault("Objects", Objects(self))

    def _getBandName(self):
        name = self.__class__.__name__
        return "%s%s" % (name[0].lower(), name[1:])
        

class PageBackground(Band): pass
class PageHeader(Band): pass
class Detail(Band): pass
class PageFooter(Band): pass
class GroupHeader(Band): pass
class GroupFooter(Band): pass
class PageForeground(Band): pass


class Rectangle(Drawable):
    """Represents a rectangle."""
    def initAvailableProps(self):
        super(Rect, self).initAvailableProps()
        self.AvailableProps["FillColor"] = toPropDict(tuple, None, 
                """Specifies the fill color.

                If None, the fill color will be transparent.""")

        self.AvailableProps["StrokeWidth"] = toPropDict(float, 1, 
                """Specifies the width of the stroke, in points.""")

        self.AvailableProps["StrokeColor"] = toPropDict(tuple, (0, 0, 0), 
                """Specifies the stroke color.""")

        self.AvailableProps["StrokeDashArray"] = toPropDict(tuple, None, 
                """Specifies the stroke dash.

                For instance, (1,1) will give you a dotted look, (1,1,5,1) will
                give you a dash-dot look.""")

## backwards compatibility:
Rect = Rectangle

class String(Drawable):
    """Represents a text string."""
    def initAvailableProps(self):
        super(String, self).initAvailableProps()
        self.AvailableProps["expr"] = toPropDict(str, None, 
                """Specifies the string to print.""")

        self.AvailableProps["BorderWidth"] = toPropDict(float, 0, 
                """Specifies the width of the border around the string.""")

        self.AvailableProps["BorderColor"] = toPropDict(tuple, (0, 0, 0), 
                """Specifies the border color.""")

        self.AvailableProps["Align"] = toPropDict(str, "left", 
                """Specifies the string alignment.

                This must evaluate to one of 'left', 'center', or 'right'.""")

        self.AvailableProps["FontName"] = toPropDict(str, "Helvetica", 
                """Specifies the font name, boldface, and italics all in one.

                There are only a handful of reliable selections:
                    Courier
                    Courier-Bold
                    Courier-Oblique
                    Courier-BoldOblique

                    Helvetica
                    Helvetica-Bold
                    Helvetica-Oblique
                    Helvetica-BoldOblique

                    Times-Roman
                    Times-Bold
                    Times-Italic
                    Times-BoldItalic

                    Symbol

                    ZapfDingbats

                Please note that for predictable cross-platform results, you need to
                stick to the fonts above. Otherwise, you'll need to ensure any TTF
                fonts you specify are distributed to all systems that create the 
                reports. If you specify a font name that doesn't exist, the Dabo report
                writer will default to 'Helvetica'.
                """)

        self.AvailableProps["FontSize"] = toPropDict(float, 10, 
                """Specifies the size of the font, in points.""")

        self.AvailableProps["FontColor"] = toPropDict(tuple, (0, 0, 0), 
                """Specifies the color of the text.""")

        self.AvailableProps["ScalePercent"] = toPropDict(tuple, (100.0, 100.0), 
                """Specifies the scaling of the string. Set to (150,100) to make it wide.""")


class Image(Drawable):
    """Represents an image."""
    def initAvailableProps(self):
        super(Image, self).initAvailableProps()
        self.AvailableProps["expr"] = toPropDict(str, "", 
                """Specifies the image to use.""")

        self.AvailableProps["BorderWidth"] = toPropDict(float, 0, 
                """Specifies the width of the image border.""")

        self.AvailableProps["BorderColor"] = toPropDict(tuple, (0, 0, 0), 
                """Specifies the color of the image border.""")

        self.AvailableProps["ImageMask"] = toPropDict(tuple, None, 
                """Specifies the image mask.""")

        self.AvailableProps["ScaleMode"] = toPropDict(str, "scale", 
                """Specifies how to handle frame and image of differing size.

                "scale" will change the image size to fit the frame. "clip" will
                display the image in the frame as-is.""")

class BarGraph(Drawable):
        """Represents a bar graph"""
    def initAvailableProps(self):
        super(BarGraph, self).initAvailableProps()

        self.AvailableProps["expr"] = toPropDict(list, [], 
                """Specifies the data to display on the graph.""")

        self