1

# coding: utf-8

     2

     3

"""

     4

    PDF output

     5

"""

     6

     7

from reportlab import platypus as rlpp

     8

from reportlab.lib.units import inch

     9

from reportlab.lib import pagesizes, styles

    10

    11

from cStringIO import StringIO

    12

import itertools

    13

import logging

    14

import datetime

    15

    16

    17

log = logging.getLogger('svv.pdf')

    18

    19

class Styles (object) :

    20

    """

    21

        Simple stylesheet

    22

    """

    23

    24

    samplestyles = styles.getSampleStyleSheet()

    25

    26

    # normal text

    27

    h1 = styles.ParagraphStyle('Heading1', samplestyles['h1'],

    28

            fontName        = 'Times-Bold',

    29

            fontSize        = 22,

    30

            spaceBefore     = 0,

    31

            spaceAfter      = 0,

    32

    33

    )

    34

    35

    h2 = styles.ParagraphStyle('Heading2', samplestyles['h2'],

    36

            fontName        = 'Times-Bold',

    37

            fontSize        = 14,

    38

            spaceBefore     = 6,

    39

            spaceAfter      = 0,

    40

    )

    41

    42

    h3 = styles.ParagraphStyle('Heading3', samplestyles['h3'],

    43

            fontName        = 'Times-Italic',

    44

            fontSize        = 12,

    45

            spaceBefore     = 0,

    46

            spaceAfter      = 0,

    47

    )

    48

    49

    text = styles.ParagraphStyle('Text', samplestyles['Normal'],

    50

    51

    )

    52

    53

    # list indent level

    54

    list_indent = inch / 4

    55

    56

    # root title

    57

    list_h1 = styles.ParagraphStyle('ListHeading1', samplestyles['h1'],

    58

            bulletIndent    = 0,

    59

            leftIndent      = 0,

    60

    )

    61

    62

    # section

    63

    list_h2 = styles.ParagraphStyle('ListHeading2', samplestyles['h2'],

    64

            bulletIndent    = 0,

    65

            leftIndent      = list_indent,

    66

            fontName        = 'Times-Bold',

    67

            fontSize        = 10,

    68

            leading         = 12,

    69

            spaceBefore     = 6,

    70

            spaceAfter      = 0,

    71

    )

    72

    73

    # segment

    74

    list_h3 = styles.ParagraphStyle('ListHeading3', samplestyles['h3'],

    75

            bulletIndent    = 0,

    76

            leftIndent      = list_indent,

    77

            fontName        = 'Times-Italic',

    78

            fontSize        = 10,

    79

            leading         = 12,

    80

            spaceBefore     = 0,

    81

            spaceAfter      = 0,

    82

    )

    83

    84

    # infot

    85

    list_text = styles.ParagraphStyle('ListText', samplestyles['Normal'],

    86

            bulletIndent    = 0,

    87

            leftIndent      = list_indent,

    88

    )

    89

    90

class ListItem (object) :

    91

    """

    92

        Indented/nested list

    93

    """

    94

    95

    @classmethod

    96

    def seq (cls) :

    97

        """

    98

            List numbering.

    99

   100

            Fixed as numeric only for now

   101

        """

   102

   103

        for idx in itertools.count(1) :

   104

            yield "%d." % (idx, )

   105

   106

   107

    def __init__ (self, title, title_style, text, subseq=None, sublist=None, 

   108

            text_style=Styles.list_text, indent=Styles.list_indent) :

   109

        """

   110

                title       - title to display as first line

   111

                title_style - paragraph style for title line

   112

                text        - multi-line texto to display on first or previous lines

   113

                subseq      - sequence of bullet-texts to use for items in sublist

   114

                sublist     - sequence of sub-nodes

   115

   116

                text_style  - paragraph style for text lines

   117

                indent      - indentation for text and sub-lists

   118

        """

   119

   120

        self.title = title

   121

        self.title_style = title_style

   122

        self.text = text

   123

   124

        self.subseq = subseq

   125

        self.sublist = sublist

   126

   127

        self.text_style = text_style

   128

        self.indent = indent

   129

   130

    def render_pdf (self, bullet=None) :

   131

        """

   132

            Yield a series of PDF flowables for this list node and sub-nodes, useable for pdf.DocTemplateBase.build()

   133

   134

                bullet      - bullet text to use for this item's paragraph

   135

        """

   136

   137

        # first line, with possible bullet

   138

        if self.title :

   139

            yield rlpp.Paragraph(self.title, self.title_style, bullet)

   140

   141

        elif self.text :

   142

            yield rlpp.Paragraph(self.text, self.text_style, bullet)

   143

   144

        # indented text after title

   145

        if self.title and self.text :

   146

            yield rlpp.Paragraph(self.text, self.text_style)

   147

   148

        if self.sublist :

   149

            # following lines, indented

   150

            yield rlpp.Indenter(self.indent)

   151

   152

            # sub-items

   153

            for item in self.sublist :

   154

                # get (optional) bullet for item

   155

                bullet = next(self.subseq, None) if self.subseq else None

   156

   157

                # render item as series of elements

   158

                for element in item.render_pdf(bullet) :

   159

                    yield element

   160

   161

            # de-dent

   162

            yield rlpp.Indenter(-self.indent)

   163

   164

   165

   166

class SignatureBlock (rlpp.Flowable) :

   167

    """

   168

        A signature block, with multiple sets of multiple pre-fillied fields.

   169

    """

   170

   171

    # vertical space per field

   172

    FIELD_HEIGHT = 2 * inch / 4

   173

   174

    # horizontal offset from top of field to field line

   175

    FIELD_OFFSET = FIELD_HEIGHT / 2

   176

   177

    # maximum width to scale columns to

   178

    COL_WIDTH_MAX = 4 * inch

   179

   180

    # empty space to leave below the fields

   181

    PADDING_BOTTOM = inch / 2

   182

   183

    def __init__ (self, cols, fields, values={}, fullheight=None) :

   184

        """

   185

            cols        - Column titles

   186

            fields      - Fields titles, describing the horizontal fields

   187

            values      - Pre-filled values as a {(col, field): value} dict

   188

            fullheight  - Consume full vertical height to place at bottom of page

   189

   190

            desc/value strings can contain formatting codes:

   191

   192

                column      - title of the current column

   193

                today       - today's date in %d/%m/%Y format

   194

        """

   195

   196

        self.cols = cols

   197

        self.fields = fields

   198

        self.values = values

   199

        self.fullheight = fullheight

   200

   201

    def wrap (self, width, height) :

   202

        """

   203

            Calculate how much space we use up, returning (width, height)

   204

        """

   205

   206

        self.width = width

   207

   208

        self.height = len(self.fields) * self.FIELD_HEIGHT

   209

   210

        if self.fullheight :

   211

            # consume all available height, to place us at the bottom

   212

            self.height = max(self.height, height)

   213

   214

        return self.width, self.height

   215

   216

    def formatString (self, text, col_title) :

   217

        """

   218

            Format display string using context parameters

   219

        """

   220

   221

        # XXX: the canvas.drawString we use here does support unicode?

   222

        return text % dict(

   223

                column      = col_title,

   224

                today       = datetime.date.today().strftime("%d/%m/%Y"),

   225

        )

   226

   227

    # text above field line

   228

    VALUE_FONT = "Courier-Bold"

   229

    VALUE_FONT_SIZE = 14

   230

    VALUE_OFFSET = inch / 12

   231

   232

    # text below field line

   233

    TITLE_FONT = "Times-Italic"

   234

    TITLE_FONT_SIZE = 10

   235

    TITLE_OFFSET = inch / 8

   236

   237

    def draw (self) :

   238

        """

   239

            Render full block onto our canvas

   240

        """

   241

   242

        # target canvas

   243

        canvas = self.canv

   244

   245

        col_width = min(self.width / len(self.cols), self.COL_WIDTH_MAX)

   246

        col_margin = col_width * 0.1

   247

        col_height = len(self.fields) * self.FIELD_HEIGHT + self.PADDING_BOTTOM

   248

   249

        for field_idx, (field_title) in enumerate(self.fields) :

   250

            h = self.FIELD_HEIGHT

   251

            y = col_height - h * (field_idx + 1)

   252

   253

            for col_idx, (col_title) in enumerate(self.cols) :

   254

                w = col_width

   255

                x = w * col_idx

   256

                value = self.values.get((col_title, field_title))

   257

                title = field_title

   258

   259

                value = self.formatString(value, col_title) if value else None

   260

                title = self.formatString(title, col_title) if title else None

   261

   262

                if value :

   263

                    canvas.setFont(self.VALUE_FONT, self.VALUE_FONT_SIZE)

   264

                    canvas.drawString(x + col_margin + self.VALUE_OFFSET, y - self.FIELD_OFFSET + 2, value)

   265

   266

                # field line

   267

                canvas.line(x + col_margin, y - self.FIELD_OFFSET, x + w - col_margin, y - h / 2)

   268

   269

                # desc text

   270

                canvas.setFont(self.TITLE_FONT, self.TITLE_FONT_SIZE)

   271

                canvas.drawString(x + col_margin + self.TITLE_OFFSET, y - self.FIELD_OFFSET - self.TITLE_FONT_SIZE, title)

   272

   273

class PageTemplate (rlpp.PageTemplate) :

   274

    """

   275

        A single-frame page with header and footer.

   276

    """

   277

   278

    # vertical space available for footer/header, fixed because we can't really flow text vertically

   279

    HEADER_HEIGHT = 1 * inch

   280

    FOOTER_HEIGHT = 1 * inch

   281

   282

    COL_FONT_SIZE = 8

   283

    COL_TITLE_FONT_NAME, COL_TITLE_FONT_SIZE = COL_TITLE_FONT = ("Times-Bold", COL_FONT_SIZE)

   284

    COL_TEXT_FONT_NAME, COL_TEXT_FONT_SIZE = COL_TEXT_FONT = ("Times-Roman", COL_FONT_SIZE)

   285

   286

   287

    def __init__ (self, id='page', page_size=pagesizes.A4, margin=inch, header_columns=None, footer_columns=None) :

   288

        """

   289

                id          - identifier for this page template

   290

                page_size   - the (width, height) of this page

   291

                margin      - the base margin to use between elements

   292

   293

                header_columns  - (title, text) list of header columns

   294

                footer_columnss - (title, text) list of footer columns

   295

        """

   296

   297

        self.page_width, self.page_height = self.page_size = page_size

   298

        self.margin = margin

   299

   300

        self.header_height = self.HEADER_HEIGHT

   301

        self.footer_height = self.FOOTER_HEIGHT

   302

   303

        # calculate frame

   304

        self.frame_left = self.margin

   305

        self.frame_bottom = self.footer_height + self.margin / 2

   306

        self.frame_top = self.page_height - self.header_height - self.margin / 2

   307

        self.frame_right = self.page_width - self.margin

   308

   309

        self.frame = rlpp.Frame(self.frame_left, self.frame_bottom, self.frame_right - self.frame_left, self.frame_top - self.frame_bottom)

   310

   311

        # init base template

   312

        rlpp.PageTemplate.__init__(self, id, frames=[self.frame])

   313

   314

        self.header_columns = header_columns

   315

        self.footer_columns = footer_columns

   316

   317

   318

    def fmt_string (self, text) :

   319

        """

   320

            Prepare a string for display by handling format codes

   321

        """

   322

   323

        return unicode(text % dict(

   324

            today = datetime.date.today().strftime("%d / %m / %Y"),

   325

        ))

   326

   327

    def draw_column (self, canvas, x, y, width, title, lines, gray=None) :

   328

        """

   329

            Draw a column in the specified position, with the specified lines of text

   330

        """

   331

   332

        text = canvas.beginText(x, y)

   333

   334

        # grayscale text?

   335

        if gray :

   336

            text.setFillGray(gray)

   337

   338

        # title

   339

        text.setFont(*self.COL_TITLE_FONT)

   340

        text.textLine(self.fmt_string(title))

   341

   342

        # lines

   343

        text.setFont(*self.COL_TEXT_FONT)

   344

   345

        # XXX: textobject's textLine fails at unicode, but textLine should work...

   346

        for line in lines :

   347

            text.textLine(self.fmt_string(line))

   348

   349

        # draw out

   350

        canvas.drawText(text)

   351

   352

   353

    def draw_columns (self, canvas, x, y, width, columns, **opts) :

   354

        """

   355

            Draw a series of columns in the specified position

   356

        """

   357

   358

        col_count = len(columns)

   359

        col_width = width / col_count

   360

   361

        x_base = x

   362

   363

        for col_idx, (col_data) in enumerate(columns) :

   364

            x = x_base + (col_idx * col_width)

   365

   366

            # draw column data at correct offset inside our space

   367

            self.draw_column(canvas, x, y - self.COL_FONT_SIZE, col_width, *col_data, **opts)

   368

   369

   370

    def draw_header (self, canvas) :

   371

        """

   372

            Draw page header

   373

        """

   374

   375

        # offsets

   376

        x = self.margin

   377

        h = self.footer_height - self.margin / 4

   378

        w = self.page_width - self.margin * 2

   379

   380

        # spacer

   381

        y = self.page_height - self.footer_height

   382

   383

        canvas.setLineWidth(0.5)

   384

        canvas.line(x - self.margin / 2, y, self.page_width - self.margin / 2, y)

   385

   386

        # columns

   387

        y = self.page_height - self.margin / 4

   388

   389

        self.draw_columns(canvas, x, y, w, self.header_columns)

   390

   391

   392

    def draw_footer (self, canvas) :

   393

        """

   394

            Draw page footer

   395

        """

   396

   397

        # offsets

   398

        x = self.margin

   399

        y = self.footer_height

   400

        w = self.page_width - self.margin * 2

   401

   402

        # spacer

   403

        canvas.setLineWidth(0.5)

   404

        canvas.line(x - self.margin / 2, y, self.page_width - self.margin / 2, y)

   405

   406

        # columns

   407

        self.draw_columns(canvas, x, y - inch / 8, w, self.footer_columns, gray=0.4)

   408

   409

   410

    def beforeDrawPage (self, canvas, document) :

   411

        """

   412

            Draw page headers/footers

   413

        """

   414

   415

        self.draw_header(canvas)

   416

        self.draw_footer(canvas)

   417

   418

class DocumentTemplate (rlpp.BaseDocTemplate) :

   419

    def __init__ (self, page_templates, title, author, page_size=pagesizes.A4) :

   420

        """

   421

            Initialize with fixed list of needed PageTemplates.

   422

        """

   423

   424

        # we supply the file later

   425

        rlpp.BaseDocTemplate.__init__(self, filename=None, 

   426

                pageTemplates=page_templates, title=title, author=author,

   427

                pageSize=page_size

   428

        )

   429

   430

    def render_buf (self, elements) :

   431

        """

   432

            Build the document using the given list of Flowables, returning a StringIO containing the PDF.

   433

        """

   434

   435

        buf = StringIO()

   436

   437

        # build

   438

        self.build(elements, buf)

   439

   440

        # prepare for read

   441

        buf.seek(0)

   442

   443

        return buf

   444

   445

    def render_string (self, elements) :

   446

        """

   447

            Build the document using the given list of Flowables, returning the PDF as a single str.

   448

        """

   449

   450

        # render

   451

        buf = self.render_buf(elements)

   452

   453

        # binary data out

   454

        return buf.getvalue()

   455