From 004a0b996ff8f269451e07346f71a129a1f3fbaf Mon Sep 17 00:00:00 2001 From: pinky <> Date: Thu, 7 Dec 2006 13:41:40 +0000 Subject: New trunk bzr revid: pinky-3f10ee12cea3c4c75cef44ab04ad33ef47432907 --- bin/reportlab/tools/pythonpoint/README | 29 + bin/reportlab/tools/pythonpoint/__init__.py | 3 + bin/reportlab/tools/pythonpoint/customshapes.py | 298 ++++++ bin/reportlab/tools/pythonpoint/demos/htu.xml | 96 ++ bin/reportlab/tools/pythonpoint/demos/leftlogo.a85 | 53 + bin/reportlab/tools/pythonpoint/demos/leftlogo.gif | Bin 0 -> 2198 bytes bin/reportlab/tools/pythonpoint/demos/lj8100.jpg | Bin 0 -> 12463 bytes bin/reportlab/tools/pythonpoint/demos/monterey.xml | 306 ++++++ bin/reportlab/tools/pythonpoint/demos/outline.gif | Bin 0 -> 12918 bytes bin/reportlab/tools/pythonpoint/demos/pplogo.gif | Bin 0 -> 3429 bytes bin/reportlab/tools/pythonpoint/demos/python.gif | Bin 0 -> 125666 bytes .../tools/pythonpoint/demos/pythonpoint.xml | 1051 ++++++++++++++++++ bin/reportlab/tools/pythonpoint/demos/spectrum.png | Bin 0 -> 1855 bytes .../tools/pythonpoint/demos/vertpython.gif | Bin 0 -> 20910 bytes bin/reportlab/tools/pythonpoint/pythonpoint.dtd | 275 +++++ bin/reportlab/tools/pythonpoint/pythonpoint.py | 1129 ++++++++++++++++++++ bin/reportlab/tools/pythonpoint/stdparser.py | 834 +++++++++++++++ bin/reportlab/tools/pythonpoint/styles/__init__.py | 3 + bin/reportlab/tools/pythonpoint/styles/horrible.py | 101 ++ bin/reportlab/tools/pythonpoint/styles/htu.py | 158 +++ bin/reportlab/tools/pythonpoint/styles/modern.py | 120 +++ .../tools/pythonpoint/styles/projection.py | 106 ++ bin/reportlab/tools/pythonpoint/styles/standard.py | 132 +++ 23 files changed, 4694 insertions(+) create mode 100644 bin/reportlab/tools/pythonpoint/README create mode 100644 bin/reportlab/tools/pythonpoint/__init__.py create mode 100644 bin/reportlab/tools/pythonpoint/customshapes.py create mode 100644 bin/reportlab/tools/pythonpoint/demos/htu.xml create mode 100644 bin/reportlab/tools/pythonpoint/demos/leftlogo.a85 create mode 100644 bin/reportlab/tools/pythonpoint/demos/leftlogo.gif create mode 100644 bin/reportlab/tools/pythonpoint/demos/lj8100.jpg create mode 100644 bin/reportlab/tools/pythonpoint/demos/monterey.xml create mode 100644 bin/reportlab/tools/pythonpoint/demos/outline.gif create mode 100644 bin/reportlab/tools/pythonpoint/demos/pplogo.gif create mode 100644 bin/reportlab/tools/pythonpoint/demos/python.gif create mode 100644 bin/reportlab/tools/pythonpoint/demos/pythonpoint.xml create mode 100644 bin/reportlab/tools/pythonpoint/demos/spectrum.png create mode 100644 bin/reportlab/tools/pythonpoint/demos/vertpython.gif create mode 100644 bin/reportlab/tools/pythonpoint/pythonpoint.dtd create mode 100755 bin/reportlab/tools/pythonpoint/pythonpoint.py create mode 100644 bin/reportlab/tools/pythonpoint/stdparser.py create mode 100644 bin/reportlab/tools/pythonpoint/styles/__init__.py create mode 100644 bin/reportlab/tools/pythonpoint/styles/horrible.py create mode 100644 bin/reportlab/tools/pythonpoint/styles/htu.py create mode 100644 bin/reportlab/tools/pythonpoint/styles/modern.py create mode 100644 bin/reportlab/tools/pythonpoint/styles/projection.py create mode 100644 bin/reportlab/tools/pythonpoint/styles/standard.py (limited to 'bin/reportlab/tools/pythonpoint') diff --git a/bin/reportlab/tools/pythonpoint/README b/bin/reportlab/tools/pythonpoint/README new file mode 100644 index 00000000000..f6d8808bdab --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/README @@ -0,0 +1,29 @@ +PythonPoint is a utility for generating PDF slides from +a simple XML format - "PythonPoint Markup Language". + +This is early days. It lets you produce quite sophisticated +output, but the DTD will undoubtedly evolve and change. +However, I want people to be able to use it this summer so am +releasing now. + +It is part of the ReportLab distribution; if you have managed +to run the ReportLab tests, and have installed the Python +Imaging Library, usage should be straightforward. PIL is not +required to make slides, but the demo will have a few blanks if +you omit it. + +To use, cd to the pythonpoint directory and execute: + pythonpoint.py pythonpoint.xml +This will create pythonpoint.pdf, which is your manual. + +You can also try 'monterey.xml', which is a talk I gave +at the O'Reilly Open Source conference in Monterey +in summer 1999. + +We have issues to resolve over module load paths; +the easiest solution for now is to put the PythonPoint +directory on your path; work in a new directory; +and explicitly include the paths to any custom shapes, +and style sheets you use. + +- Andy Robinson, 6 April 2000 \ No newline at end of file diff --git a/bin/reportlab/tools/pythonpoint/__init__.py b/bin/reportlab/tools/pythonpoint/__init__.py new file mode 100644 index 00000000000..c4b994f848b --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/__init__.py @@ -0,0 +1,3 @@ +#Copyright ReportLab Europe Ltd. 2000-2004 +#see license.txt for license details +#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/tools/pythonpoint/__init__.py diff --git a/bin/reportlab/tools/pythonpoint/customshapes.py b/bin/reportlab/tools/pythonpoint/customshapes.py new file mode 100644 index 00000000000..792823e3cb8 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/customshapes.py @@ -0,0 +1,298 @@ +#Copyright ReportLab Europe Ltd. 2000-2004 +#see license.txt for license details +#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/tools/pythonpoint/customshapes.py +__version__=''' $Id$ ''' + +# xml parser stuff for PythonPoint +# PythonPoint Markup Language! + +__doc__=""" +This demonstrates a custom shape for use with the tag. +The shape must fulfil a very simple interface, which may change in +future. + +The XML tag currently has this form: + + +PythonPoint will look in the given module for the given class, +evaluate the arguments string and pass it to the constructor. +Then, it will call + + object.drawOn(canvas) + +Thus your object must be fully defined by the constructor. +For this one, we pass three argumenyts: x, y and scale. +This does a five-tile jigsaw over which words can be overlaid; +based on work done for a customer's presentation. +""" + + +import reportlab.pdfgen.canvas +from reportlab.lib import colors +from reportlab.lib.corp import RL_CorpLogo +from reportlab.graphics.shapes import Drawing + +## custom shape for use with PythonPoint. + +class Jigsaw: + """This draws a jigsaw patterm. By default it is centred on 0,0 + and has dimensions of 200 x 140; use the x/y/scale attributes + to move it around.""" + #Using my usual bulldozer coding style - I am sure a mathematician could + #derive an elegant way to draw this, but I just took a ruler, guessed at + #the control points, and reflected a few lists at the interactive prompt. + + def __init__(self, x, y, scale=1): + self.width = 200 + self.height = 140 + self.x = x + self.y = y + self.scale = scale + + + def drawOn(self, canvas): + canvas.saveState() + + canvas.setFont('Helvetica-Bold',24) + canvas.drawString(600, 100, 'A Custom Shape') + + canvas.translate(self.x, self.y) + canvas.scale(self.scale, self.scale) + self.drawBounds(canvas) + + self.drawCentre(canvas) + self.drawTopLeft(canvas) + self.drawBottomLeft(canvas) + self.drawBottomRight(canvas) + self.drawTopRight(canvas) + + canvas.restoreState() + + + def curveThrough(self, path, pointlist): + """Helper to curve through set of control points.""" + assert len(pointlist) % 3 == 1, "No. of points must be 3n+1 for integer n" + (x,y) = pointlist[0] + path.moveTo(x, y) + idx = 1 + while idx < len(pointlist)-2: + p1, p2, p3 = pointlist[idx:idx+3] + path.curveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]) + idx = idx + 3 + + + def drawShape(self, canvas, controls, color): + """Utlity to draw a closed shape through a list of control points; + extends the previous proc""" + canvas.setFillColor(color) + p = canvas.beginPath() + self.curveThrough(p, controls) + p.close() + canvas.drawPath(p, stroke=1, fill=1) + + + def drawBounds(self, canvas): + """Guidelines to help me draw - not needed in production""" + canvas.setStrokeColor(colors.red) + canvas.rect(-100,-70,200,140) + canvas.line(-100,0,100,0) + canvas.line(0,70,0,-70) + canvas.setStrokeColor(colors.black) + + + def drawCentre(self, canvas): + controls = [ (0,50), #top + + #top right edge - duplicated for that corner piece + (5,50),(10,45),(10,40), + (10,35),(15,30),(20,30), + (25,30),(30,25),(30,20), + (30,15),(35,10),(40,10), + (45,10),(50,5),(50,0), + + #bottom right edge + (50, -5), (45,-10), (40,-10), + (35,-10), (30,-15), (30, -20), + (30,-25), (25,-30), (20,-30), + (15,-30), (10,-35), (10,-40), + (10,-45),(5,-50),(0,-50), + + #bottom left + (-5,-50),(-10,-45),(-10,-40), + (-10,-35),(-15,-30),(-20,-30), + (-25,-30),(-30,-25),(-30,-20), + (-30,-15),(-35,-10),(-40,-10), + (-45,-10),(-50,-5),(-50,0), + + #top left + (-50,5),(-45,10),(-40,10), + (-35,10),(-30,15),(-30,20), + (-30,25),(-25,30),(-20,30), + (-15,30),(-10,35),(-10,40), + (-10,45),(-5,50),(0,50) + + ] + + self.drawShape(canvas, controls, colors.yellow) + + + def drawTopLeft(self, canvas): + controls = [(-100,70), + (-100,69),(-100,1),(-100,0), + (-99,0),(-91,0),(-90,0), + + #jigsaw interlock - 4 sections + (-90,5),(-92,5),(-92,10), + (-92,15), (-85,15), (-80,15), + (-75,15),(-68,15),(-68,10), + (-68,5),(-70,5),(-70,0), + (-69,0),(-51,0),(-50,0), + + #five distinct curves + (-50,5),(-45,10),(-40,10), + (-35,10),(-30,15),(-30,20), + (-30,25),(-25,30),(-20,30), + (-15,30),(-10,35),(-10,40), + (-10,45),(-5,50),(0,50), + + (0,51),(0,69),(0,70), + (-1,70),(-99,70),(-100,70) + ] + self.drawShape(canvas, controls, colors.teal) + + + def drawBottomLeft(self, canvas): + + controls = [(-100,-70), + (-99,-70),(-1,-70),(0,-70), + (0,-69),(0,-51),(0,-50), + + #wavyline + (-5,-50),(-10,-45),(-10,-40), + (-10,-35),(-15,-30),(-20,-30), + (-25,-30),(-30,-25),(-30,-20), + (-30,-15),(-35,-10),(-40,-10), + (-45,-10),(-50,-5),(-50,0), + + #jigsaw interlock - 4 sections + + (-51, 0), (-69, 0), (-70, 0), + (-70, 5), (-68, 5), (-68, 10), + (-68, 15), (-75, 15), (-80, 15), + (-85, 15), (-92, 15), (-92, 10), + (-92, 5), (-90, 5), (-90, 0), + + (-91,0),(-99,0),(-100,0) + + ] + self.drawShape(canvas, controls, colors.green) + + + def drawBottomRight(self, canvas): + + controls = [ (100,-70), + (100,-69),(100,-1),(100,0), + (99,0),(91,0),(90,0), + + #jigsaw interlock - 4 sections + (90, -5), (92, -5), (92, -10), + (92, -15), (85, -15), (80, -15), + (75, -15), (68, -15), (68, -10), + (68, -5), (70, -5), (70, 0), + (69, 0), (51, 0), (50, 0), + + #wavyline + (50, -5), (45,-10), (40,-10), + (35,-10), (30,-15), (30, -20), + (30,-25), (25,-30), (20,-30), + (15,-30), (10,-35), (10,-40), + (10,-45),(5,-50),(0,-50), + + (0,-51), (0,-69), (0,-70), + (1,-70),(99,-70),(100,-70) + + ] + self.drawShape(canvas, controls, colors.navy) + + + def drawBottomLeft(self, canvas): + + controls = [(-100,-70), + (-99,-70),(-1,-70),(0,-70), + (0,-69),(0,-51),(0,-50), + + #wavyline + (-5,-50),(-10,-45),(-10,-40), + (-10,-35),(-15,-30),(-20,-30), + (-25,-30),(-30,-25),(-30,-20), + (-30,-15),(-35,-10),(-40,-10), + (-45,-10),(-50,-5),(-50,0), + + #jigsaw interlock - 4 sections + + (-51, 0), (-69, 0), (-70, 0), + (-70, 5), (-68, 5), (-68, 10), + (-68, 15), (-75, 15), (-80, 15), + (-85, 15), (-92, 15), (-92, 10), + (-92, 5), (-90, 5), (-90, 0), + + (-91,0),(-99,0),(-100,0) + + ] + self.drawShape(canvas, controls, colors.green) + + + def drawTopRight(self, canvas): + controls = [(100, 70), + (99, 70), (1, 70), (0, 70), + (0, 69), (0, 51), (0, 50), + (5, 50), (10, 45), (10, 40), + (10, 35), (15, 30), (20, 30), + (25, 30), (30, 25), (30, 20), + (30, 15), (35, 10), (40, 10), + (45, 10), (50, 5), (50, 0), + (51, 0), (69, 0), (70, 0), + (70, -5), (68, -5), (68, -10), + (68, -15), (75, -15), (80, -15), + (85, -15), (92, -15), (92, -10), + (92, -5), (90, -5), (90, 0), + (91, 0), (99, 0), (100, 0) + ] + + self.drawShape(canvas, controls, colors.magenta) + + +class Logo: + """This draws a ReportLab Logo.""" + + def __init__(self, x, y, width, height): + logo = RL_CorpLogo() + logo.x = x + logo.y = y + logo.width = width + logo.height = height + self.logo = logo + + def drawOn(self, canvas): + logo = self.logo + x, y = logo.x, logo.y + w, h = logo.width, logo.height + D = Drawing(w, h) + D.add(logo) + D.drawOn(canvas, 0, 0) + + +def run(): + c = reportlab.pdfgen.canvas.Canvas('customshape.pdf') + + J = Jigsaw(300, 540, 2) + J.drawOn(c) + c.save() + + +if __name__ == '__main__': + run() \ No newline at end of file diff --git a/bin/reportlab/tools/pythonpoint/demos/htu.xml b/bin/reportlab/tools/pythonpoint/demos/htu.xml new file mode 100644 index 00000000000..56cb92457dc --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/demos/htu.xml @@ -0,0 +1,96 @@ + + + + +
+ + + © 2002, H. Turgut UYAR + + + + + + New features in PythonPoint + H. Turgut Uyar + uyar@cs.itu.edu.tr + + + + + TrueType Support + + + PythonPoint can read UTF-8 encoded input files and produce + correct output (provided your font has all necessary + characters). That enables you, for example, to have native (in my + case, Turkish) characters in your document: + + +  0 ^  1 _ + + + + + + Effects + + + Paragraphs, images, tables and geometric shapes can now have + effectname, effectdirection, effectdimension, effectmotion and + effectduration attributes: + A paragraph + + + Col1,Col2,Col3 + Row1Col1,Row1Col2,Row1Col3 + Row2Col1,Row2Col2,Row2Col3 +
+ + + String + + + + + Printing + + + Be careful when using effects: A new slide is created for + each effect, so DON'T print the resulting PDF file. + new command-line option: --printout + produces printable PDF + + + + + New Paragraph Styles + + + Bullet2 - Second level bullets + Here's an example + Or an example with a longer text to see + how it wraps at the end of each line + Author and EMail + See the cover page for examples + They have to be in the style file, so either use + the htu style file or edit your style file + + + + + ToDo + + + Unicode chars in the outline + + +
+ diff --git a/bin/reportlab/tools/pythonpoint/demos/leftlogo.a85 b/bin/reportlab/tools/pythonpoint/demos/leftlogo.a85 new file mode 100644 index 00000000000..7d55afcf348 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/demos/leftlogo.a85 @@ -0,0 +1,53 @@ +BI +/W 103 /H 68 /BPC 8 /CS /RGB /F [/A85 /Fl] +ID +Gb"/*cYjIe']/l*^;)UQj:Ec+nd!,-,*G/5;0"E.+@qg.\92h2HbiE)jC5*M +$a,@:RoXB@WPjMu=[F;88l[?@OO=6qV,HNNiL#(cac+!&rF)2^DHJ?_:WQkn +1[fb`hOBr--B>FoSDXMt35Gnj6n\3XT8sf/Y%-NPLqg'pmQ+*EiV6D:,$akf +!i2MA/A-"n[R.R)S!ePi$u('8mrCG8[3:WLlB[amBYAS4hR2*f7tR;&\%]Ld +ZX5^f6Qj@\h7^FuQ(">[ml32FWhJG;Z)t2oADV4[H6GbW.mH`MDlesQZO5+Q5)]OWf2G9[ +U9W99*2'#PD+cIXnp"J"(BrY^=(rg;ITf("c#0"S<;fjK,APV+p9p+05LO&X +jQNf`8c26f]J54N'k#I9=Bt4]e&6gN'#S[nK3*VhQ!`PpXcJ0i:J_2rC@=>X\5dUbEcCZ?\6O)+F/35ZJD6R$H^-Z!R +5;8=l//9SUkC;LhQ*?di<'6e&/BNIqm(%(SDYXJ +p%%Z+J.IshkX$tLPOD'"jSV#/6iY?QI>8P-%o0k3`e#X33RJS`f'D!D2rTJ- +(4Znb03&koo>X[bKs.qpBOkU,KCCO3S$2.Gr@e8E=$On&hUiAB2[.;G@FQf7_K1&D6RJ.Ih@-56Ss&B1q:\)MgJ8P4Sa-(Fm +J"d8Z]Mf`Q$G^\tK@pQWQs3iRB[KP=+H&@+iH@XGFQ'#n!DJ$)Mc?"U#od!oYl3En7nT"7UC,,Q&Hr +9.SPlHak6s)J0;k;hQC:k82'=COeskp&dB-#@RrY1B=H^'L=,;9uJssq%XGf +h/fXmq>1G\?k6ZH*GSk&M)?&TJ?rYW.9f!gdM2&:Kr51A3^MX?GV'T@$h)Da +-RIIcpl8fhiQr=`\k[7;3`X"d!or(jb1YM>"Ppi`,67@]M"d ++mXd;WRE"IKX@n&dNNV/55(]`==+_r?K5bp?$^4Pn/[2ncL(/l#CfSYAg:iN +@3j5R$qtm;AIF7k%^ak'%4Z1354d"1VT\g]cm[^hI.Yf>DcLS\rq+As2F?LI +'gq+/_o9&kK,4@]qbdfA8FauP;!N'$5J@1P/\Th=9i^\b$/-6-kL#$E&39t% +/O[1Fm`/F?!q;%bB')DM`KY&D!,6)lG5TQ88ejHiTWKt;3_8:@M!NnP'D2s$ +2Q25"dX)7pQ%VUq+r1%.iMQiLR#&.@\:Pe96FEbkgLu`Fb;!#d,DPC-H/d?u +^']=P86?6qr/@_/T-T0?,+>brI`?=13["Y(3DYSMX7UAUk0'!l!aPN4$e\f&(i2TTrbVuOYhc05Rko:?UP09gLc(-/ni'Q6T.B&8]k +#a_e\0FTMV`IT;W7M>_'NT_f=~> +EI diff --git a/bin/reportlab/tools/pythonpoint/demos/leftlogo.gif b/bin/reportlab/tools/pythonpoint/demos/leftlogo.gif new file mode 100644 index 00000000000..2d9c990ba7a Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/leftlogo.gif differ diff --git a/bin/reportlab/tools/pythonpoint/demos/lj8100.jpg b/bin/reportlab/tools/pythonpoint/demos/lj8100.jpg new file mode 100644 index 00000000000..be3c6183d3b Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/lj8100.jpg differ diff --git a/bin/reportlab/tools/pythonpoint/demos/monterey.xml b/bin/reportlab/tools/pythonpoint/demos/monterey.xml new file mode 100644 index 00000000000..41bd979fa67 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/demos/monterey.xml @@ -0,0 +1,306 @@ + + + + + + +
+ + + + + + + + + Printing with Python + + + + Andy Robinson, Robinson Analytics Ltd. + + + O'Reilly Python Conference, Monterey, 24th August 1999 + + + + + + + Background to the project: + + + London-based consultant and corporate developer + + + want to do neat Python stuff in the daytime + + + working for many years on financial modelling + + + this is one of 6 modules in that system + + + quickest to deliver, offers very wide benefits + + + 25% of architecture done, but already very useful + + + Release early, release often! + + + + + + + + Goal: + + + A Reporting Package on the Next Curve... + + + Report on objects, not databases + + + Scalable to million page runs + + + Light enough to embed in any application + + + Allow reuse of graphical objects across reports + + + Open and extensible on several levels + + + Publication quality + + + Support all the world's languages - one day + + + + + + + Portable Document Format + + + The New PostScript + + + Free readers on all platforms + + + Better than paper - view it, email it, print it + + + 'Final Form' for documents + + + High end solution - no limits to quality + + + ...but you can't learn it in Notepad! + + + + + + + + + PDFgen and PIDDLE + + + + + + + Layer One - PDFgen + + + makes PDF documents from pure Python + + + wraps up PDF document structure + + + exposes nice effects - page transitions, outline trees (RSN!) + + + low level graphics promitives (postscript imaging model) + + + Fine control of text placement + + + Supports Asian text + + + Supports coordinate transformations and clipping + + + ...a foundation for other apps to build on + + + + + + + PDFgen Image Support + + + Python Imaging Library and zlib do all the work - many formats. + Images cached (like .pyc files) - very fast builds possible. + + + + + + + + Layer Two: PIDDLE + + + Plug In Drawing, Does Little Else + + + Easy Graphics Library + + + Abstract Canvas Interface + + + Pluggable Back Ends + + + Same code can do viewing and printing + + + Standard set of test patterns + + + Uses Python Imaging Library + + + Back ends includeTkinter, wxPython, Mac, Pythonwin, PDF, PostScript, + OpenGL, Adobe Illustrator and PIL. Really easy to add a new one! + + + + + + + Layer Three: PLATYPUS + + + "Page Layout And Typography Using Scripts" + + + Trying to work out the API now. Key Concepts: + + + Drawable objects - can 'wrap to fit' + + + Frames on page + + + Frame consumes from a list of drawables until full + + + Document Models e.g. SimpleFlowDocument + + + XSL Flow Object model may be a good target + + + + + + + Drawable Objects + + + Next layer of PIDDLE extensibility. + Each draws in its own coodinate system + + + paragraph, image, table + + + chart libraries + + + diagrams + + + Open Source - let people contribute new ones. + Anything you could have in a view can be a new + drawable type. + + + + + + + Style Sheet Driven + + + Styles use instance inheritance + + + Paragraph Styles - Style Sheet Compulsory! + + + Text Styles within a paragraph + + + Table and Table Cell Styles + + + + + + + Vision + + + XML to PDF in one step + + + Publish to web and print from same source + + + Financial and Scientific reporting tool + + + Embedded reporting engine + + + Volume reporting tool for business + + + + + + + PythonPoint + + + How I made this presentation... + + + +
+ diff --git a/bin/reportlab/tools/pythonpoint/demos/outline.gif b/bin/reportlab/tools/pythonpoint/demos/outline.gif new file mode 100644 index 00000000000..4a294b59277 Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/outline.gif differ diff --git a/bin/reportlab/tools/pythonpoint/demos/pplogo.gif b/bin/reportlab/tools/pythonpoint/demos/pplogo.gif new file mode 100644 index 00000000000..d0344497ca5 Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/pplogo.gif differ diff --git a/bin/reportlab/tools/pythonpoint/demos/python.gif b/bin/reportlab/tools/pythonpoint/demos/python.gif new file mode 100644 index 00000000000..c68e1e4ec37 Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/python.gif differ diff --git a/bin/reportlab/tools/pythonpoint/demos/pythonpoint.xml b/bin/reportlab/tools/pythonpoint/demos/pythonpoint.xml new file mode 100644 index 00000000000..15d1ad709b5 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/demos/pythonpoint.xml @@ -0,0 +1,1051 @@ + + + + + PythonPoint Demonstration + Andy Robinson + Reportlab Sample Applications +
+ + + +
+ diff --git a/bin/reportlab/tools/pythonpoint/demos/spectrum.png b/bin/reportlab/tools/pythonpoint/demos/spectrum.png new file mode 100644 index 00000000000..06747655056 Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/spectrum.png differ diff --git a/bin/reportlab/tools/pythonpoint/demos/vertpython.gif b/bin/reportlab/tools/pythonpoint/demos/vertpython.gif new file mode 100644 index 00000000000..5e5c60c3308 Binary files /dev/null and b/bin/reportlab/tools/pythonpoint/demos/vertpython.gif differ diff --git a/bin/reportlab/tools/pythonpoint/pythonpoint.dtd b/bin/reportlab/tools/pythonpoint/pythonpoint.dtd new file mode 100644 index 00000000000..ec876f68387 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/pythonpoint.dtd @@ -0,0 +1,275 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/reportlab/tools/pythonpoint/pythonpoint.py b/bin/reportlab/tools/pythonpoint/pythonpoint.py new file mode 100755 index 00000000000..18ef842be0a --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/pythonpoint.py @@ -0,0 +1,1129 @@ +#! /usr/bin/python2.3 + +""" +This is PythonPoint! + +The idea is a simple markup languages for describing presentation +slides, and other documents which run page by page. I expect most +of it will be reusable in other page layout stuff. + +Look at the sample near the top, which shows how the presentation +should be coded up. + +The parser, which is in a separate module to allow for multiple +parsers, turns the XML sample into an object tree. There is a +simple class hierarchy of items, the inner levels of which create +flowable objects to go in the frames. These know how to draw +themselves. + +The currently available 'Presentation Objects' are: + + The main hierarchy... + PPPresentation + PPSection + PPSlide + PPFrame + + PPAuthor, PPTitle and PPSubject are optional + + Things to flow within frames... + PPPara - flowing text + PPPreformatted - text with line breaks and tabs, for code.. + PPImage + PPTable - bulk formatted tabular data + PPSpacer + + Things to draw directly on the page... + PPRect + PPRoundRect + PPDrawingElement - user base class for graphics + PPLine + PPEllipse + +Features added by H. Turgut Uyar +- TrueType support (actually, just an import in the style file); + this also enables the use of Unicode symbols +- para, image, table, line, rectangle, roundrect, ellipse, polygon + and string elements can now have effect attributes + (careful: new slide for each effect!) +- added printout mode (no new slides for effects, see item above) +- added a second-level bullet: Bullet2 +- small bugfixes in handleHiddenSlides: + corrected the outlineEntry of included hidden slide + and made sure to include the last slide even if hidden + +Recently added features are: + +- file globbing +- package structure +- named colors throughout (using names from reportlab/lib/colors.py) +- handout mode with arbitrary number of columns per page +- stripped off pages hidden in the outline tree (hackish) +- new tag for speaker notes (paragraphs only) +- new tag for syntax-colorized Python code +- reformatted pythonpoint.xml and monterey.xml demos +- written/extended DTD +- arbitrary font support +- print proper speaker notes (TODO) +- fix bug with partially hidden graphics (TODO) +- save in combined presentation/handout mode (TODO) +- add pyRXP support (TODO) +""" + +import os, sys, imp, string, pprint, getopt, glob + +from reportlab import rl_config +from reportlab.lib import styles +from reportlab.lib import colors +from reportlab.lib.units import cm +from reportlab.lib.utils import getStringIO +from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY +from reportlab.pdfbase import pdfmetrics +from reportlab.pdfgen import canvas +from reportlab.platypus.doctemplate import SimpleDocTemplate +from reportlab.platypus.flowables import Flowable +from reportlab.platypus.xpreformatted import PythonPreformatted +from reportlab.platypus import Preformatted, Paragraph, Frame, \ + Image, Table, TableStyle, Spacer + + +USAGE_MESSAGE = """\ +PythonPoint - a tool for making presentations in PDF. + +Usage: + pythonpoint.py [options] file1.xml [file2.xml [...]] + + where options can be any of these: + + -h / --help prints this message + -n / --notes leave room for comments + -v / --verbose verbose mode + -s / --silent silent mode (NO output) + --handout produce handout document + --printout produce printout document + --cols specify number of columns + on handout pages (default: 2) + +To create the PythonPoint user guide, do: + pythonpoint.py pythonpoint.xml +""" + + +##################################################################### +# This should probably go into reportlab/lib/fonts.py... +##################################################################### + +class FontNameNotFoundError(Exception): + pass + + +class FontFilesNotFoundError(Exception): + pass + + +##def findFontName(path): +## "Extract a Type-1 font name from an AFM file." +## +## f = open(path) +## +## found = 0 +## while not found: +## line = f.readline()[:-1] +## if not found and line[:16] == 'StartCharMetrics': +## raise FontNameNotFoundError, path +## if line[:8] == 'FontName': +## fontName = line[9:] +## found = 1 +## +## return fontName +## +## +##def locateFilesForFontWithName(name): +## "Search known paths for AFM/PFB files describing T1 font with given name." +## +## join = os.path.join +## splitext = os.path.splitext +## +## afmFile = None +## pfbFile = None +## +## found = 0 +## while not found: +## for p in rl_config.T1SearchPath: +## afmFiles = glob.glob(join(p, '*.[aA][fF][mM]')) +## for f in afmFiles: +## T1name = findFontName(f) +## if T1name == name: +## afmFile = f +## found = 1 +## break +## if afmFile: +## break +## break +## +## if afmFile: +## pfbFile = glob.glob(join(splitext(afmFile)[0] + '.[pP][fF][bB]'))[0] +## +## return afmFile, pfbFile +## +## +##def registerFont(name): +## "Register Type-1 font for future use." +## +## rl_config.warnOnMissingFontGlyphs = 0 +## rl_config.T1SearchPath.append(r'C:\Programme\Python21\reportlab\test') +## +## afmFile, pfbFile = locateFilesForFontWithName(name) +## if not afmFile and not pfbFile: +## raise FontFilesNotFoundError +## +## T1face = pdfmetrics.EmbeddedType1Face(afmFile, pfbFile) +## T1faceName = name +## pdfmetrics.registerTypeFace(T1face) +## T1font = pdfmetrics.Font(name, T1faceName, 'WinAnsiEncoding') +## pdfmetrics.registerFont(T1font) + + +def registerFont0(sourceFile, name, path): + "Register Type-1 font for future use, simple version." + + rl_config.warnOnMissingFontGlyphs = 0 + + p = os.path.join(os.path.dirname(sourceFile), path) + afmFiles = glob.glob(p + '.[aA][fF][mM]') + pfbFiles = glob.glob(p + '.[pP][fF][bB]') + assert len(afmFiles) == len(pfbFiles) == 1, FontFilesNotFoundError + + T1face = pdfmetrics.EmbeddedType1Face(afmFiles[0], pfbFiles[0]) + T1faceName = name + pdfmetrics.registerTypeFace(T1face) + T1font = pdfmetrics.Font(name, T1faceName, 'WinAnsiEncoding') + pdfmetrics.registerFont(T1font) + +##################################################################### + + +def checkColor(col): + "Converts a color name to an RGB tuple, if possible." + + if type(col) == type('') and col in dir(colors): + col = getattr(colors, col) + col = (col.red, col.green, col.blue) + + return col + + +def handleHiddenSlides(slides): + """Filters slides from a list of slides. + + In a sequence of hidden slides all but the last one are + removed. Also, the slide before the sequence of hidden + ones is removed. + + This assumes to leave only those slides in the handout + that also appear in the outline, hoping to reduce se- + quences where each new slide only adds one new line + to a list of items... + """ + + itd = indicesToDelete = map(lambda s:s.outlineEntry == None, slides) + + for i in range(len(itd)-1): + if itd[i] == 1: + if itd[i+1] == 0: + itd[i] = 0 + if i > 0 and itd[i-1] == 0: + itd[i-1] = 1 + + itd[len(itd)-1] = 0 + + for i in range(len(itd)): + if slides[i].outlineEntry: + curOutlineEntry = slides[i].outlineEntry + if itd[i] == 1: + slides[i].delete = 1 + else: + slides[i].outlineEntry = curOutlineEntry + slides[i].delete = 0 + + slides = filter(lambda s:s.delete == 0, slides) + + return slides + + +def makeSlideTable(slides, pageSize, docWidth, numCols): + """Returns a table containing a collection of SlideWrapper flowables. + """ + + slides = handleHiddenSlides(slides) + + # Set table style. + tabStyle = TableStyle( + [('GRID', (0,0), (-1,-1), 0.25, colors.black), + ('ALIGN', (0,0), (-1,-1), 'CENTRE') + ]) + + # Build table content. + width = docWidth/numCols + height = width * pageSize[1]/pageSize[0] + matrix = [] + row = [] + for slide in slides: + sw = SlideWrapper(width, height, slide, pageSize) + if (len(row)) < numCols: + row.append(sw) + else: + matrix.append(row) + row = [] + row.append(sw) + if len(row) > 0: + for i in range(numCols-len(row)): + row.append('') + matrix.append(row) + + # Make Table flowable. + t = Table(matrix, + [width + 5]*len(matrix[0]), + [height + 5]*len(matrix)) + t.setStyle(tabStyle) + + return t + + +class SlideWrapper(Flowable): + """A Flowable wrapping a PPSlide object. + """ + + def __init__(self, width, height, slide, pageSize): + Flowable.__init__(self) + self.width = width + self.height = height + self.slide = slide + self.pageSize = pageSize + + + def __repr__(self): + return "SlideWrapper(w=%s, h=%s)" % (self.width, self.height) + + + def draw(self): + "Draw the slide in our relative coordinate system." + + slide = self.slide + pageSize = self.pageSize + canv = self.canv + + canv.saveState() + canv.scale(self.width/pageSize[0], self.height/pageSize[1]) + slide.effectName = None + slide.drawOn(self.canv) + canv.restoreState() + + +class PPPresentation: + def __init__(self): + self.sourceFilename = None + self.filename = None + self.outDir = None + self.description = None + self.title = None + self.author = None + self.subject = None + self.notes = 0 # different printing mode + self.handout = 0 # prints many slides per page + self.printout = 0 # remove hidden slides + self.cols = 0 # columns per handout page + self.slides = [] + self.effectName = None + self.showOutline = 1 #should it be displayed when opening? + self.compression = rl_config.pageCompression + self.pageDuration = None + #assume landscape + self.pageWidth = rl_config.defaultPageSize[1] + self.pageHeight = rl_config.defaultPageSize[0] + self.verbose = rl_config.verbose + + + def saveAsPresentation(self): + """Write the PDF document, one slide per page.""" + if self.verbose: + print 'saving presentation...' + pageSize = (self.pageWidth, self.pageHeight) + if self.sourceFilename: + filename = os.path.splitext(self.sourceFilename)[0] + '.pdf' + if self.outDir: filename = os.path.join(self.outDir,os.path.basename(filename)) + if self.verbose: + print filename + #canv = canvas.Canvas(filename, pagesize = pageSize) + outfile = getStringIO() + if self.notes: + #translate the page from landscape to portrait + pageSize= pageSize[1], pageSize[0] + canv = canvas.Canvas(outfile, pagesize = pageSize) + canv.setPageCompression(self.compression) + canv.setPageDuration(self.pageDuration) + if self.title: + canv.setTitle(self.title) + if self.author: + canv.setAuthor(self.author) + if self.subject: + canv.setSubject(self.subject) + + slideNo = 0 + for slide in self.slides: + #need diagnostic output if something wrong with XML + slideNo = slideNo + 1 + if self.verbose: + print 'doing slide %d, id = %s' % (slideNo, slide.id) + if self.notes: + #frame and shift the slide + #canv.scale(0.67, 0.67) + scale_amt = (min(pageSize)/float(max(pageSize)))*.95 + #canv.translate(self.pageWidth / 6.0, self.pageHeight / 3.0) + #canv.translate(self.pageWidth / 2.0, .025*self.pageHeight) + canv.translate(.025*self.pageHeight, (self.pageWidth/2.0) + 5) + #canv.rotate(90) + canv.scale(scale_amt, scale_amt) + canv.rect(0,0,self.pageWidth, self.pageHeight) + slide.drawOn(canv) + canv.showPage() + + #ensure outline visible by default + if self.showOutline: + canv.showOutline() + + canv.save() + return self.savetofile(outfile, filename) + + + def saveAsHandout(self): + """Write the PDF document, multiple slides per page.""" + + styleSheet = getSampleStyleSheet() + h1 = styleSheet['Heading1'] + bt = styleSheet['BodyText'] + + if self.sourceFilename : + filename = os.path.splitext(self.sourceFilename)[0] + '.pdf' + + outfile = getStringIO() + doc = SimpleDocTemplate(outfile, pagesize=rl_config.defaultPageSize, showBoundary=0) + doc.leftMargin = 1*cm + doc.rightMargin = 1*cm + doc.topMargin = 2*cm + doc.bottomMargin = 2*cm + multiPageWidth = rl_config.defaultPageSize[0] - doc.leftMargin - doc.rightMargin - 50 + + story = [] + orgFullPageSize = (self.pageWidth, self.pageHeight) + t = makeSlideTable(self.slides, orgFullPageSize, multiPageWidth, self.cols) + story.append(t) + +## #ensure outline visible by default +## if self.showOutline: +## doc.canv.showOutline() + + doc.build(story) + return self.savetofile(outfile, filename) + + def savetofile(self, pseudofile, filename): + """Save the pseudo file to disk and return its content as a + string of text.""" + pseudofile.flush() + content = pseudofile.getvalue() + pseudofile.close() + if filename : + outf = open(filename, "wb") + outf.write(content) + outf.close() + return content + + + + def save(self): + "Save the PDF document." + + if self.handout: + return self.saveAsHandout() + else: + return self.saveAsPresentation() + + +#class PPSection: +# """A section can hold graphics which will be drawn on all +# pages within it, before frames and other content are done. +# In other words, a background template.""" +# def __init__(self, name): +# self.name = name +# self.graphics = [] +# +# def drawOn(self, canv): +# for graphic in self.graphics: +### graphic.drawOn(canv) +# +# name = str(hash(graphic)) +# internalname = canv._doc.hasForm(name) +# +# canv.saveState() +# if not internalname: +# canv.beginForm(name) +# graphic.drawOn(canv) +# canv.endForm() +# canv.doForm(name) +# else: +# canv.doForm(name) +# canv.restoreState() + + +definedForms = {} + +class PPSection: + """A section can hold graphics which will be drawn on all + pages within it, before frames and other content are done. + In other words, a background template.""" + + def __init__(self, name): + self.name = name + self.graphics = [] + + def drawOn(self, canv): + for graphic in self.graphics: + graphic.drawOn(canv) + continue + name = str(hash(graphic)) + #internalname = canv._doc.hasForm(name) + if definedForms.has_key(name): + internalname = 1 + else: + internalname = None + definedForms[name] = 1 + if not internalname: + canv.beginForm(name) + canv.saveState() + graphic.drawOn(canv) + canv.restoreState() + canv.endForm() + canv.doForm(name) + else: + canv.doForm(name) + + +class PPNotes: + def __init__(self): + self.content = [] + + def drawOn(self, canv): + print self.content + + +class PPSlide: + def __init__(self): + self.id = None + self.title = None + self.outlineEntry = None + self.outlineLevel = 0 # can be higher for sub-headings + self.effectName = None + self.effectDirection = 0 + self.effectDimension = 'H' + self.effectMotion = 'I' + self.effectDuration = 1 + self.frames = [] + self.notes = [] + self.graphics = [] + self.section = None + + def drawOn(self, canv): + if self.effectName: + canv.setPageTransition( + effectname=self.effectName, + direction = self.effectDirection, + dimension = self.effectDimension, + motion = self.effectMotion, + duration = self.effectDuration + ) + + if self.outlineEntry: + #gets an outline automatically + self.showOutline = 1 + #put an outline entry in the left pane + tag = self.title + canv.bookmarkPage(tag) + canv.addOutlineEntry(tag, tag, self.outlineLevel) + + if self.section: + self.section.drawOn(canv) + + for graphic in self.graphics: + graphic.drawOn(canv) + + for frame in self.frames: + frame.drawOn(canv) + +## # Need to draw the notes *somewhere*... +## for note in self.notes: +## print note + + +class PPFrame: + def __init__(self, x, y, width, height): + self.x = x + self.y = y + self.width = width + self.height = height + self.content = [] + self.showBoundary = 0 + + def drawOn(self, canv): + #make a frame + frame = Frame( self.x, + self.y, + self.width, + self.height + ) + frame.showBoundary = self.showBoundary + + #build a story for the frame + story = [] + for thingy in self.content: + #ask it for any flowables + story.append(thingy.getFlowable()) + #draw it + frame.addFromList(story,canv) + + +class PPPara: + """This is a placeholder for a paragraph.""" + def __init__(self): + self.rawtext = '' + self.style = None + + def escapeAgain(self, text): + """The XML has been parsed once, so '>' became '>' + in rawtext. We need to escape this to get back to + something the Platypus parser can accept""" + pass + + def getFlowable(self): +## print 'rawText for para:' +## print repr(self.rawtext) + p = Paragraph( + self.rawtext, + getStyles()[self.style], + self.bulletText + ) + return p + + +class PPPreformattedText: + """Use this for source code, or stuff you do not want to wrap""" + def __init__(self): + self.rawtext = '' + self.style = None + + def getFlowable(self): + return Preformatted(self.rawtext, getStyles()[self.style]) + + +class PPPythonCode: + """Use this for colored Python source code""" + def __init__(self): + self.rawtext = '' + self.style = None + + def getFlowable(self): + return PythonPreformatted(self.rawtext, getStyles()[self.style]) + + +class PPImage: + """Flowing image within the text""" + def __init__(self): + self.filename = None + self.width = None + self.height = None + + def getFlowable(self): + return Image(self.filename, self.width, self.height) + + +class PPTable: + """Designed for bulk loading of data for use in presentations.""" + def __init__(self): + self.rawBlocks = [] #parser stuffs things in here... + self.fieldDelim = ',' #tag args can override + self.rowDelim = '\n' #tag args can override + self.data = None + self.style = None #tag args must specify + self.widths = None #tag args can override + self.heights = None #tag args can override + + def getFlowable(self): + self.parseData() + t = Table( + self.data, + self.widths, + self.heights) + if self.style: + t.setStyle(getStyles()[self.style]) + + return t + + def parseData(self): + """Try to make sense of the table data!""" + rawdata = string.strip(string.join(self.rawBlocks, '')) + lines = string.split(rawdata, self.rowDelim) + #clean up... + lines = map(string.strip, lines) + self.data = [] + for line in lines: + cells = string.split(line, self.fieldDelim) + self.data.append(cells) + + #get the width list if not given + if not self.widths: + self.widths = [None] * len(self.data[0]) + if not self.heights: + self.heights = [None] * len(self.data) + +## import pprint +## print 'table data:' +## print 'style=',self.style +## print 'widths=',self.widths +## print 'heights=',self.heights +## print 'fieldDelim=',repr(self.fieldDelim) +## print 'rowDelim=',repr(self.rowDelim) +## pprint.pprint(self.data) + + +class PPSpacer: + def __init__(self): + self.height = 24 #points + + def getFlowable(self): + return Spacer(72, self.height) + + + ############################################################# + # + # The following are things you can draw on a page directly. + # + ############################################################## + +##class PPDrawingElement: +## """Base class for something which you draw directly on the page.""" +## def drawOn(self, canv): +## raise "NotImplementedError", "Abstract base class!" + + +class PPFixedImage: + """You place this on the page, rather than flowing it""" + def __init__(self): + self.filename = None + self.x = 0 + self.y = 0 + self.width = None + self.height = None + + def drawOn(self, canv): + if self.filename: + x, y = self.x, self.y + w, h = self.width, self.height + canv.drawImage(self.filename, x, y, w, h) + + +class PPRectangle: + def __init__(self, x, y, width, height): + self.x = x + self.y = y + self.width = width + self.height = height + self.fillColor = None + self.strokeColor = (1,1,1) + self.lineWidth=0 + + def drawOn(self, canv): + canv.saveState() + canv.setLineWidth(self.lineWidth) + if self.fillColor: + r,g,b = checkColor(self.fillColor) + canv.setFillColorRGB(r,g,b) + if self.strokeColor: + r,g,b = checkColor(self.strokeColor) + canv.setStrokeColorRGB(r,g,b) + canv.rect(self.x, self.y, self.width, self.height, + stroke=(self.strokeColor<>None), + fill = (self.fillColor<>None) + ) + canv.restoreState() + + +class PPRoundRect: + def __init__(self, x, y, width, height, radius): + self.x = x + self.y = y + self.width = width + self.height = height + self.radius = radius + self.fillColor = None + self.strokeColor = (1,1,1) + self.lineWidth=0 + + def drawOn(self, canv): + canv.saveState() + canv.setLineWidth(self.lineWidth) + if self.fillColor: + r,g,b = checkColor(self.fillColor) + canv.setFillColorRGB(r,g,b) + if self.strokeColor: + r,g,b = checkColor(self.strokeColor) + canv.setStrokeColorRGB(r,g,b) + canv.roundRect(self.x, self.y, self.width, self.height, + self.radius, + stroke=(self.strokeColor<>None), + fill = (self.fillColor<>None) + ) + canv.restoreState() + + +class PPLine: + def __init__(self, x1, y1, x2, y2): + self.x1 = x1 + self.y1 = y1 + self.x2 = x2 + self.y2 = y2 + self.fillColor = None + self.strokeColor = (1,1,1) + self.lineWidth=0 + + def drawOn(self, canv): + canv.saveState() + canv.setLineWidth(self.lineWidth) + if self.strokeColor: + r,g,b = checkColor(self.strokeColor) + canv.setStrokeColorRGB(r,g,b) + canv.line(self.x1, self.y1, self.x2, self.y2) + canv.restoreState() + + +class PPEllipse: + def __init__(self, x1, y1, x2, y2): + self.x1 = x1 + self.y1 = y1 + self.x2 = x2 + self.y2 = y2 + self.fillColor = None + self.strokeColor = (1,1,1) + self.lineWidth=0 + + def drawOn(self, canv): + canv.saveState() + canv.setLineWidth(self.lineWidth) + if self.strokeColor: + r,g,b = checkColor(self.strokeColor) + canv.setStrokeColorRGB(r,g,b) + if self.fillColor: + r,g,b = checkColor(self.fillColor) + canv.setFillColorRGB(r,g,b) + canv.ellipse(self.x1, self.y1, self.x2, self.y2, + stroke=(self.strokeColor<>None), + fill = (self.fillColor<>None) + ) + canv.restoreState() + + +class PPPolygon: + def __init__(self, pointlist): + self.points = pointlist + self.fillColor = None + self.strokeColor = (1,1,1) + self.lineWidth=0 + + def drawOn(self, canv): + canv.saveState() + canv.setLineWidth(self.lineWidth) + if self.strokeColor: + r,g,b = checkColor(self.strokeColor) + canv.setStrokeColorRGB(r,g,b) + if self.fillColor: + r,g,b = checkColor(self.fillColor) + canv.setFillColorRGB(r,g,b) + + path = canv.beginPath() + (x,y) = self.points[0] + path.moveTo(x,y) + for (x,y) in self.points[1:]: + path.lineTo(x,y) + path.close() + canv.drawPath(path, + stroke=(self.strokeColor<>None), + fill=(self.fillColor<>None)) + canv.restoreState() + + +class PPString: + def __init__(self, x, y): + self.text = '' + self.x = x + self.y = y + self.align = TA_LEFT + self.font = 'Times-Roman' + self.size = 12 + self.color = (0,0,0) + self.hasInfo = 0 # these can have data substituted into them + + def normalizeText(self): + """It contains literal XML text typed over several lines. + We want to throw away + tabs, newlines and so on, and only accept embedded string + like '\n'""" + lines = string.split(self.text, '\n') + newtext = [] + for line in lines: + newtext.append(string.strip(line)) + #accept all the '\n' as newlines + + self.text = newtext + + def drawOn(self, canv): + # for a string in a section, this will be drawn several times; + # so any substitution into the text should be in a temporary + # variable + if self.hasInfo: + # provide a dictionary of stuff which might go into + # the string, so they can number pages, do headers + # etc. + info = {} + info['title'] = canv._doc.info.title + info['author'] = canv._doc.info.author + info['subject'] = canv._doc.info.subject + info['page'] = canv.getPageNumber() + drawText = self.text % info + else: + drawText = self.text + + if self.color is None: + return + lines = string.split(string.strip(drawText), '\\n') + canv.saveState() + + canv.setFont(self.font, self.size) + + r,g,b = checkColor(self.color) + canv.setFillColorRGB(r,g,b) + cur_y = self.y + for line in lines: + if self.align == TA_LEFT: + canv.drawString(self.x, cur_y, line) + elif self.align == TA_CENTER: + canv.drawCentredString(self.x, cur_y, line) + elif self.align == TA_RIGHT: + canv.drawRightString(self.x, cur_y, line) + cur_y = cur_y - 1.2*self.size + + canv.restoreState() + +class PPDrawing: + def __init__(self): + self.drawing = None + def getFlowable(self): + return self.drawing + +class PPFigure: + def __init__(self): + self.figure = None + def getFlowable(self): + return self.figure + +def getSampleStyleSheet(): + from reportlab.tools.pythonpoint.styles.standard import getParagraphStyles + return getParagraphStyles() + + +#make a singleton and a function to access it +_styles = None +def getStyles(): + global _styles + if not _styles: + _styles = getSampleStyleSheet() + return _styles + + +def setStyles(newStyleSheet): + global _styles + _styles = newStyleSheet + + +##def test(): +## p = stdparser.PPMLParser() +## p.feed(sample) +## p.getPresentation().save() +## p.close() + +_pyRXP_Parser = None +def validate(rawdata): + global _pyRXP_Parser + if not _pyRXP_Parser: + try: + import pyRXP + except ImportError: + return + from reportlab.lib.utils import open_and_read, _RL_DIR, rl_isfile + dtd = 'pythonpoint.dtd' + if not rl_isfile(dtd): + dtd = os.path.join(_RL_DIR,'tools','pythonpoint','pythonpoint.dtd') + if not rl_isfile(dtd): return + def eocb(URI,dtdText=open_and_read(dtd),dtd=dtd): + if os.path.basename(URI)=='pythonpoint.dtd': return dtd,dtdText + return URI + _pyRXP_Parser = pyRXP.Parser(eoCB=eocb) + return _pyRXP_Parser.parse(rawdata) + +def process(datafile, notes=0, handout=0, printout=0, cols=0, verbose=0, outDir=None, datafilename=None, fx=1): + "Process one PythonPoint source file." + if not hasattr(datafile, "read"): + if not datafilename: datafilename = datafile + datafile = open(datafile) + else: + if not datafilename: datafilename = "PseudoFile" + rawdata = datafile.read() + + #if pyRXP present, use it to check and get line numbers for errors... + validate(rawdata) + + return _process(rawdata, datafilename, notes, handout, printout, cols, verbose, outDir, fx) + +def _process(rawdata, datafilename, notes=0, handout=0, printout=0, cols=0, verbose=0, outDir=None, fx=1): + #print 'inner process fx=%d' % fx + from reportlab.tools.pythonpoint.stdparser import PPMLParser + parser = PPMLParser() + parser.fx = fx + parser.sourceFilename = datafilename + parser.feed(rawdata) + pres = parser.getPresentation() + pres.sourceFilename = datafilename + pres.outDir = outDir + pres.notes = notes + pres.handout = handout + pres.printout = printout + pres.cols = cols + pres.verbose = verbose + + if printout: + pres.slides = handleHiddenSlides(pres.slides) + + #this does all the work + pdfcontent = pres.save() + + if verbose: + print 'saved presentation %s.pdf' % os.path.splitext(datafilename)[0] + parser.close() + + return pdfcontent +##class P: +## def feed(self, text): +## parser = stdparser.PPMLParser() +## d = pyRXP.parse(text) +## +## +##def process2(datafilename, notes=0, handout=0, cols=0): +## "Process one PythonPoint source file." +## +## import pyRXP, pprint +## +## rawdata = open(datafilename).read() +## d = pyRXP.parse(rawdata) +## pprint.pprint(d) + + +def handleOptions(): + # set defaults + from reportlab import rl_config + options = {'cols':2, + 'handout':0, + 'printout':0, + 'help':0, + 'notes':0, + 'fx':1, + 'verbose':rl_config.verbose, + 'silent':0, + 'outDir': None} + + args = sys.argv[1:] + args = filter(lambda x: x and x[0]=='-',args) + filter(lambda x: not x or x[0]!='-',args) + try: + shortOpts = 'hnvsx' + longOpts = string.split('cols= outdir= handout help notes printout verbose silent nofx') + optList, args = getopt.getopt(args, shortOpts, longOpts) + except getopt.error, msg: + options['help'] = 1 + + if not args and os.path.isfile('pythonpoint.xml'): + args = ['pythonpoint.xml'] + + # Remove leading dashes (max. two). + for i in range(len(optList)): + o, v = optList[i] + while o[0] == '-': + o = o[1:] + optList[i] = (o, v) + + if o == 'cols': options['cols'] = int(v) + elif o=='outdir': options['outDir'] = v + + if filter(lambda ov: ov[0] == 'handout', optList): + options['handout'] = 1 + + if filter(lambda ov: ov[0] == 'printout', optList): + options['printout'] = 1 + + if optList == [] and args == [] or \ + filter(lambda ov: ov[0] in ('h', 'help'), optList): + options['help'] = 1 + + if filter(lambda ov: ov[0] in ('n', 'notes'), optList): + options['notes'] = 1 + + if filter(lambda ov: ov[0] in ('x', 'nofx'), optList): + options['fx'] = 0 + + if filter(lambda ov: ov[0] in ('v', 'verbose'), optList): + options['verbose'] = 1 + + #takes priority over verbose. Used by our test suite etc. + #to ensure no output at all + if filter(lambda ov: ov[0] in ('s', 'silent'), optList): + options['silent'] = 1 + options['verbose'] = 0 + + + return options, args + +def main(): + options, args = handleOptions() + + if options['help']: + print USAGE_MESSAGE + sys.exit(0) + + if options['verbose'] and options['notes']: + print 'speaker notes mode' + + if options['verbose'] and options['handout']: + print 'handout mode' + + if options['verbose'] and options['printout']: + print 'printout mode' + + if not options['fx']: + print 'suppressing special effects' + for fileGlobs in args: + files = glob.glob(fileGlobs) + for datafile in files: + if os.path.isfile(datafile): + file = os.path.join(os.getcwd(), datafile) + notes, handout, printout, cols, verbose, fx = options['notes'], options['handout'], options['printout'], options['cols'], options['verbose'], options['fx'] + process(file, notes, handout, printout, cols, verbose, options['outDir'], fx=fx) + else: + print 'Data file not found:', datafile + +if __name__ == '__main__': + main() diff --git a/bin/reportlab/tools/pythonpoint/stdparser.py b/bin/reportlab/tools/pythonpoint/stdparser.py new file mode 100644 index 00000000000..dffe1693d0e --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/stdparser.py @@ -0,0 +1,834 @@ +""" +Parser for PythonPoint using the xmllib.py in the standard Python +distribution. Slow, but always present. We intend to add new parsers +as Python 2.x and the XML package spread in popularity and stabilise. + +The parser has a getPresentation method; it is called from +pythonpoint.py. +""" + +import string, imp, sys, os, copy +from reportlab.lib.utils import SeqTypes +from reportlab.lib import xmllib +from reportlab.lib import colors +from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY +from reportlab.lib.utils import recursiveImport +from reportlab.tools.pythonpoint import pythonpoint +from reportlab.platypus import figures + + +def getModule(modulename,fromPath='reportlab.tools.pythonpoint.styles'): + """Get a module containing style declarations. + + Search order is: + reportlab/tools/pythonpoint/ + reportlab/tools/pythonpoint/styles/ + ./ + """ + + try: + exec 'from reportlab.tools.pythonpoint import '+modulename + return eval(modulename) + except ImportError: + try: + exec 'from reportlab.tools.pythonpoint.styles import '+modulename + return eval(modulename) + except ImportError: + exec 'import '+modulename + return eval(modulename) + + +class PPMLParser(xmllib.XMLParser): + attributes = { + #this defines the available attributes for all objects, + #and their default values. Although these don't have to + #be strings, the ones parsed from the XML do, so + #everything is a quoted string and the parser has to + #convert these to numbers where appropriate. + 'stylesheet': { + 'path':'None', + 'module':'None', + 'function':'getParagraphStyles' + }, + 'frame': { + 'x':'0', + 'y':'0', + 'width':'0', + 'height':'0', + 'border':'false', + 'leftmargin':'0', #this is ignored + 'topmargin':'0', #this is ignored + 'rightmargin':'0', #this is ignored + 'bottommargin':'0', #this is ignored + }, + 'slide': { + 'id':'None', + 'title':'None', + 'effectname':'None', # Split, Blinds, Box, Wipe, Dissolve, Glitter + 'effectdirection':'0', # 0,90,180,270 + 'effectdimension':'H', # H or V - horizontal or vertical + 'effectmotion':'I', # Inwards or Outwards + 'effectduration':'1', #seconds, + 'outlineentry':'None', + 'outlinelevel':'0' # 1 is a child, 2 is a grandchild etc. + }, + 'para': { + 'style':'Normal', + 'bullettext':'', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'image': { + 'filename':'', + 'width':'None', + 'height':'None', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'table': { + 'widths':'None', + 'heights':'None', + 'fieldDelim':',', + 'rowDelim':'\n', + 'style':'None', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'rectangle': { + 'x':'0', + 'y':'0', + 'width':'100', + 'height':'100', + 'fill':'None', + 'stroke':'(0,0,0)', + 'linewidth':'0', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'roundrect': { + 'x':'0', + 'y':'0', + 'width':'100', + 'height':'100', + 'radius':'6', + 'fill':'None', + 'stroke':'(0,0,0)', + 'linewidth':'0', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'line': { + 'x1':'0', + 'y1':'0', + 'x2':'100', + 'y2':'100', + 'stroke':'(0,0,0)', + 'width':'0', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'ellipse': { + 'x1':'0', + 'y1':'0', + 'x2':'100', + 'y2':'100', + 'stroke':'(0,0,0)', + 'fill':'None', + 'linewidth':'0', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'polygon': { + 'points':'(0,0),(50,0),(25,25)', + 'stroke':'(0,0,0)', + 'linewidth':'0', + 'stroke':'(0,0,0)', + 'fill':'None', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'string':{ + 'x':'0', + 'y':'0', + 'color':'(0,0,0)', + 'font':'Times-Roman', + 'size':'12', + 'align':'left', + 'effectname':'None', + 'effectdirection':'0', + 'effectdimension':'H', + 'effectmotion':'I', + 'effectduration':'1' + }, + 'customshape':{ + 'path':'None', + 'module':'None', + 'class':'None', + 'initargs':'None' + } + } + + def __init__(self): + self.presentations = [] + #yes, I know a generic stack would be easier... + #still, testing if we are 'in' something gives + #a degree of validation. + self._curPres = None + self._curSection = None + self._curSlide = None + self._curFrame = None + self._curPara = None #the only places we are interested in + self._curPrefmt = None + self._curPyCode = None + self._curString = None + self._curTable = None + self._curTitle = None + self._curAuthor = None + self._curSubject = None + self.fx = 1 + xmllib.XMLParser.__init__(self) + + + def _arg(self,tag,args,name): + "What's this for???" + if args.has_key(name): + v = args[name] + else: + if self.attributes.has_key(tag): + v = self.attributes[tag][name] + else: + v = None + return v + + + def ceval(self,tag,args,name): + if args.has_key(name): + v = args[name] + else: + if self.attributes.has_key(tag): + v = self.attributes[tag][name] + else: + return None + + # handle named colors (names from reportlab.lib.colors) + if name in ('color', 'stroke', 'fill'): + v = str(pythonpoint.checkColor(v)) + + return eval(v) + + + def getPresentation(self): + return self._curPres + + + def handle_data(self, data): + #the only data should be paragraph text, preformatted para + #text, 'string text' for a fixed string on the page, + #or table data + + if self._curPara: + self._curPara.rawtext = self._curPara.rawtext + data + elif self._curPrefmt: + self._curPrefmt.rawtext = self._curPrefmt.rawtext + data + elif self._curPyCode: + self._curPyCode.rawtext = self._curPyCode.rawtext + data + elif self._curString: + self._curString.text = self._curString.text + data + elif self._curTable: + self._curTable.rawBlocks.append(data) + elif self._curTitle <> None: # need to allow empty strings, + # hence explicitly testing for None + self._curTitle = self._curTitle + data + elif self._curAuthor <> None: + self._curAuthor = self._curAuthor + data + elif self._curSubject <> None: + self._curSubject = self._curSubject + data + + + def handle_cdata(self, data): + #just append to current paragraph text, so we can quote XML + if self._curPara: + self._curPara.rawtext = self._curPara.rawtext + data + elif self._curPrefmt: + self._curPrefmt.rawtext = self._curPrefmt.rawtext + data + elif self._curPyCode: + self._curPyCode.rawtext = self._curPyCode.rawtext + data + elif self._curString: + self._curString.text = self._curString.text + data + elif self._curTable: + self._curTable.rawBlocks.append(data) + elif self._curAuthor <> None: + self._curAuthor = self._curAuthor + data + elif self._curSubject <> None: + self._curSubject = self._curSubject + data + + + def start_presentation(self, args): + self._curPres = pythonpoint.PPPresentation() + self._curPres.filename = self._arg('presentation',args,'filename') + self._curPres.effectName = self._arg('presentation',args,'effect') + self._curPres.pageDuration = self._arg('presentation',args,'pageDuration') + + h = self._arg('presentation',args,'pageHeight') + if h: + self._curPres.pageHeight = h + w = self._arg('presentation',args,'pageWidth') + if w: + self._curPres.pageWidth = w + #print 'page size =', self._curPres.pageSize + + + def end_presentation(self): + pass +## print 'Fully parsed presentation',self._curPres.filename + + + def start_title(self, args): + self._curTitle = '' + + + def end_title(self): + self._curPres.title = self._curTitle + self._curTitle = None + + + def start_author(self, args): + self._curAuthor = '' + + + def end_author(self): + self._curPres.author = self._curAuthor + self._curAuthor = None + + + def start_subject(self, args): + self._curSubject = '' + + + def end_subject(self): + self._curPres.subject = self._curSubject + self._curSubject = None + + + def start_stylesheet(self, args): + #makes it the current style sheet. + path = self._arg('stylesheet',args,'path') + if path=='None': path = [] + if type(path) not in SeqTypes: path = [path] + path.append('styles') + path.append(os.getcwd()) + modulename = self._arg('stylesheet', args, 'module') + funcname = self._arg('stylesheet', args, 'function') + try: + found = imp.find_module(modulename, path) + (file, pathname, description) = found + mod = imp.load_module(modulename, file, pathname, description) + except ImportError: + #last gasp + mod = getModule(modulename) + + #now get the function + func = getattr(mod, funcname) + pythonpoint.setStyles(func()) +## print 'set global stylesheet to %s.%s()' % (modulename, funcname) + + + def end_stylesheet(self): + pass + + + def start_section(self, args): + name = self._arg('section',args,'name') + self._curSection = pythonpoint.PPSection(name) + + + def end_section(self): + self._curSection = None + + + def start_slide(self, args): + s = pythonpoint.PPSlide() + s.id = self._arg('slide',args,'id') + s.title = self._arg('slide',args,'title') + a = self._arg('slide',args,'effectname') + if a <> 'None': + s.effectName = a + s.effectDirection = self.ceval('slide',args,'effectdirection') + s.effectDimension = self._arg('slide',args,'effectdimension') + s.effectDuration = self.ceval('slide',args,'effectduration') + s.effectMotion = self._arg('slide',args,'effectmotion') + + #HACK - may not belong here in the long run... + #by default, use the slide title for the outline entry, + #unless it is specified as an arg. + a = self._arg('slide',args,'outlineentry') + if a == "Hide": + s.outlineEntry = None + elif a <> 'None': + s.outlineEntry = a + else: + s.outlineEntry = s.title + + s.outlineLevel = self.ceval('slide',args,'outlinelevel') + + #let it know its section, which may be none + s.section = self._curSection + self._curSlide = s + + + def end_slide(self): + self._curPres.slides.append(self._curSlide) + self._curSlide = None + + + def start_frame(self, args): + self._curFrame = pythonpoint.PPFrame( + self.ceval('frame',args,'x'), + self.ceval('frame',args,'y'), + self.ceval('frame',args,'width'), + self.ceval('frame',args,'height') + ) + if self._arg('frame',args,'border')=='true': + self._curFrame.showBoundary = 1 + + + def end_frame(self): + self._curSlide.frames.append(self._curFrame) + self._curFrame = None + + + def start_notes(self, args): + name = self._arg('notes',args,'name') + self._curNotes = pythonpoint.PPNotes() + + + def end_notes(self): + self._curSlide.notes.append(self._curNotes) + self._curNotes = None + + + def start_registerFont(self, args): + name = self._arg('font',args,'name') + path = self._arg('font',args,'path') + pythonpoint.registerFont0(self.sourceFilename, name, path) + + + def end_registerFont(self): + pass + + + def pack_slide(self, element, args): + if self.fx: + effectName = self._arg(element,args,'effectname') + if effectName <> 'None': + curSlide = copy.deepcopy(self._curSlide) + if self._curFrame: + curFrame = copy.deepcopy(self._curFrame) + curSlide.frames.append(curFrame) + self._curPres.slides.append(curSlide) + self._curSlide.effectName = effectName + self._curSlide.effectDirection = self.ceval(element,args,'effectdirection') + self._curSlide.effectDimension = self._arg(element,args,'effectdimension') + self._curSlide.effectDuration = self.ceval(element,args,'effectduration') + self._curSlide.effectMotion = self._arg(element,args,'effectmotion') + self._curSlide.outlineEntry = None + + def start_para(self, args): + self.pack_slide('para', args) + self._curPara = pythonpoint.PPPara() + self._curPara.style = self._arg('para',args,'style') + + # hack - bullet character if bullet style + bt = self._arg('para',args,'bullettext') + if bt == '': + if self._curPara.style == 'Bullet': + bt = '\267' # Symbol Font bullet character, reasonable default + elif self._curPara.style == 'Bullet2': + bt = '\267' # second-level bullet + else: + bt = None + + self._curPara.bulletText = bt + + + def end_para(self): + if self._curFrame: + self._curFrame.content.append(self._curPara) + self._curPara = None + elif self._curNotes: + self._curNotes.content.append(self._curPara) + self._curPara = None + + + def start_prefmt(self, args): + self._curPrefmt = pythonpoint.PPPreformattedText() + self._curPrefmt.style = self._arg('prefmt',args,'style') + + + def end_prefmt(self): + self._curFrame.content.append(self._curPrefmt) + self._curPrefmt = None + + + def start_pycode(self, args): + self._curPyCode = pythonpoint.PPPythonCode() + self._curPyCode.style = self._arg('pycode',args,'style') + + + def end_pycode(self): + self._curFrame.content.append(self._curPyCode) + self._curPyCode = None + + + def start_image(self, args): + self.pack_slide('image',args) + sourceFilename = self.sourceFilename # XXX + filename = self._arg('image',args,'filename') + filename = os.path.join(os.path.dirname(sourceFilename), filename) + self._curImage = pythonpoint.PPImage() + self._curImage.filename = filename + self._curImage.width = self.ceval('image',args,'width') + self._curImage.height = self.ceval('image',args,'height') + + + def end_image(self): + self._curFrame.content.append(self._curImage) + self._curImage = None + + + def start_table(self, args): + self.pack_slide('table',args) + self._curTable = pythonpoint.PPTable() + self._curTable.widths = self.ceval('table',args,'widths') + self._curTable.heights = self.ceval('table',args,'heights') + #these may contain escapes like tabs - handle with + #a bit more care. + if args.has_key('fieldDelim'): + self._curTable.fieldDelim = eval('"' + args['fieldDelim'] + '"') + if args.has_key('rowDelim'): + self._curTable.rowDelim = eval('"' + args['rowDelim'] + '"') + if args.has_key('style'): + self._curTable.style = args['style'] + + + def end_table(self): + self._curFrame.content.append(self._curTable) + self._curTable = None + + + def start_spacer(self, args): + """No contents so deal with it here.""" + sp = pythonpoint.PPSpacer() + sp.height = eval(args['height']) + self._curFrame.content.append(sp) + + + def end_spacer(self): + pass + + + ## the graphics objects - go into either the current section + ## or the current slide. + def start_fixedimage(self, args): + sourceFilename = self.sourceFilename + filename = self._arg('image',args,'filename') + filename = os.path.join(os.path.dirname(sourceFilename), filename) + img = pythonpoint.PPFixedImage() + img.filename = filename + img.x = self.ceval('fixedimage',args,'x') + img.y = self.ceval('fixedimage',args,'y') + img.width = self.ceval('fixedimage',args,'width') + img.height = self.ceval('fixedimage',args,'height') + self._curFixedImage = img + + + def end_fixedimage(self): + if self._curSlide: + self._curSlide.graphics.append(self._curFixedImage) + elif self._curSection: + self._curSection.graphics.append(self._curFixedImage) + self._curFixedImage = None + + + def start_rectangle(self, args): + self.pack_slide('rectangle', args) + rect = pythonpoint.PPRectangle( + self.ceval('rectangle',args,'x'), + self.ceval('rectangle',args,'y'), + self.ceval('rectangle',args,'width'), + self.ceval('rectangle',args,'height') + ) + rect.fillColor = self.ceval('rectangle',args,'fill') + rect.strokeColor = self.ceval('rectangle',args,'stroke') + self._curRectangle = rect + + + def end_rectangle(self): + if self._curSlide: + self._curSlide.graphics.append(self._curRectangle) + elif self._curSection: + self._curSection.graphics.append(self._curRectangle) + self._curRectangle = None + + + def start_roundrect(self, args): + self.pack_slide('roundrect', args) + rrect = pythonpoint.PPRoundRect( + self.ceval('roundrect',args,'x'), + self.ceval('roundrect',args,'y'), + self.ceval('roundrect',args,'width'), + self.ceval('roundrect',args,'height'), + self.ceval('roundrect',args,'radius') + ) + rrect.fillColor = self.ceval('roundrect',args,'fill') + rrect.strokeColor = self.ceval('roundrect',args,'stroke') + self._curRoundRect = rrect + + + def end_roundrect(self): + if self._curSlide: + self._curSlide.graphics.append(self._curRoundRect) + elif self._curSection: + self._curSection.graphics.append(self._curRoundRect) + self._curRoundRect = None + + + def start_line(self, args): + self.pack_slide('line', args) + self._curLine = pythonpoint.PPLine( + self.ceval('line',args,'x1'), + self.ceval('line',args,'y1'), + self.ceval('line',args,'x2'), + self.ceval('line',args,'y2') + ) + self._curLine.strokeColor = self.ceval('line',args,'stroke') + + + def end_line(self): + if self._curSlide: + self._curSlide.graphics.append(self._curLine) + elif self._curSection: + self._curSection.graphics.append(self._curLine) + self._curLine = None + + + def start_ellipse(self, args): + self.pack_slide('ellipse', args) + self._curEllipse = pythonpoint.PPEllipse( + self.ceval('ellipse',args,'x1'), + self.ceval('ellipse',args,'y1'), + self.ceval('ellipse',args,'x2'), + self.ceval('ellipse',args,'y2') + ) + self._curEllipse.strokeColor = self.ceval('ellipse',args,'stroke') + self._curEllipse.fillColor = self.ceval('ellipse',args,'fill') + + + def end_ellipse(self): + if self._curSlide: + self._curSlide.graphics.append(self._curEllipse) + elif self._curSection: + self._curSection.graphics.append(self._curEllipse) + self._curEllipse = None + + + def start_polygon(self, args): + self.pack_slide('polygon', args) + self._curPolygon = pythonpoint.PPPolygon(self.ceval('polygon',args,'points')) + self._curPolygon.strokeColor = self.ceval('polygon',args,'stroke') + self._curPolygon.fillColor = self.ceval('polygon',args,'fill') + + + def end_polygon(self): + if self._curSlide: + self._curSlide.graphics.append(self._curPolygon) + elif self._curSection: + self._curSection.graphics.append(self._curPolygon) + self._curEllipse = None + + + def start_string(self, args): + self.pack_slide('string', args) + self._curString = pythonpoint.PPString( + self.ceval('string',args,'x'), + self.ceval('string',args,'y') + ) + self._curString.color = self.ceval('string',args,'color') + self._curString.font = self._arg('string',args,'font') + self._curString.size = self.ceval('string',args,'size') + if args['align'] == 'left': + self._curString.align = TA_LEFT + elif args['align'] == 'center': + self._curString.align = TA_CENTER + elif args['align'] == 'right': + self._curString.align = TA_RIGHT + elif args['align'] == 'justify': + self._curString.align = TA_JUSTIFY + #text comes later within the tag + + + def end_string(self): + #controller should have set the text + if self._curSlide: + self._curSlide.graphics.append(self._curString) + elif self._curSection: + self._curSection.graphics.append(self._curString) + self._curString = None + + + def start_infostring(self, args): + # like a string, but lets them embed page no, author etc. + self.start_string(args) + self._curString.hasInfo = 1 + + + def end_infostring(self): + self.end_string() + + + def start_customshape(self, args): + #loads one + path = self._arg('customshape',args,'path') + if path=='None': + path = [] + else: + path=[path] + + # add package root folder and input file's folder to path + path.append(os.path.dirname(self.sourceFilename)) + path.append(os.path.dirname(pythonpoint.__file__)) + + modulename = self._arg('customshape',args,'module') + funcname = self._arg('customshape',args,'class') + try: + found = imp.find_module(modulename, path) + (file, pathname, description) = found + mod = imp.load_module(modulename, file, pathname, description) + except ImportError: + mod = getModule(modulename) + + #now get the function + + func = getattr(mod, funcname) + initargs = self.ceval('customshape',args,'initargs') + self._curCustomShape = apply(func, initargs) + + + def end_customshape(self): + if self._curSlide: + self._curSlide.graphics.append(self._curCustomShape) + elif self._curSection: + self._curSection.graphics.append(self._curCustomShape) + self._curCustomShape = None + + + + def start_drawing(self, args): + #loads one + + moduleName = args["module"] + funcName = args["constructor"] + + showBoundary = int(args.get("showBoundary", "0")) + + hAlign = args.get("hAlign", "CENTER") + + + # the path for the imports should include: + # 1. document directory + # 2. python path if baseDir not given, or + # 3. baseDir if given + try: + dirName = sdict["baseDir"] + except: + dirName = None + importPath = [os.getcwd()] + if dirName is None: + importPath.extend(sys.path) + else: + importPath.insert(0, dirName) + + modul = recursiveImport(moduleName, baseDir=importPath) + func = getattr(modul, funcName) + drawing = func() + + drawing.hAlign = hAlign + if showBoundary: + drawing._showBoundary = 1 + + self._curDrawing = pythonpoint.PPDrawing() + self._curDrawing.drawing = drawing + + + def end_drawing(self): + self._curFrame.content.append(self._curDrawing) + self._curDrawing = None + + + def start_pageCatcherFigure(self, args): + filename = args["filename"] + pageNo = int(args["pageNo"]) + width = float(args.get("width", "595")) + height = float(args.get("height", "842")) + + + fig = figures.PageCatcherFigureNonA4(filename, pageNo, args.get("caption", ""), width, height) + sf = args.get('scaleFactor', None) + if sf: sf = float(sf) + border = not (args.get('border', None) in ['0','no']) + + fig.scaleFactor = sf + fig.border = border + + #self.ceval('pageCatcherFigure',args,'scaleFactor'), + #initargs = self.ceval('customshape',args,'initargs') + self._curFigure = pythonpoint.PPFigure() + self._curFigure.figure = fig + + + + def end_pageCatcherFigure(self): + self._curFrame.content.append(self._curFigure) + self._curFigure = None + + ## intra-paragraph XML should be allowed through into PLATYPUS + def unknown_starttag(self, tag, attrs): + if self._curPara: + echo = '<%s' % tag + for (key, value) in attrs.items(): + echo = echo + ' %s="%s"' % (key, value) + echo = echo + '>' + self._curPara.rawtext = self._curPara.rawtext + echo + else: + print 'Unknown start tag %s' % tag + + + def unknown_endtag(self, tag): + if self._curPara: + self._curPara.rawtext = self._curPara.rawtext + ''% tag + else: + print 'Unknown end tag %s' % tag diff --git a/bin/reportlab/tools/pythonpoint/styles/__init__.py b/bin/reportlab/tools/pythonpoint/styles/__init__.py new file mode 100644 index 00000000000..e67468fd9ee --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/styles/__init__.py @@ -0,0 +1,3 @@ +#Copyright ReportLab Europe Ltd. 2000-2004 +#see license.txt for license details +#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/tools/pythonpoint/styles/__init__.py diff --git a/bin/reportlab/tools/pythonpoint/styles/horrible.py b/bin/reportlab/tools/pythonpoint/styles/horrible.py new file mode 100644 index 00000000000..b608fdb5771 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/styles/horrible.py @@ -0,0 +1,101 @@ +#Copyright ReportLab Europe Ltd. 2000-2004 +#see license.txt for license details +#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/tools/pythonpoint/styles/horrible.py +__version__=''' $Id$ ''' +# style_modern.py +__doc__="""This is an example style sheet. You can create your own, and +have them loaded by the presentation. A style sheet is just a +dictionary, where they keys are style names and the values are +ParagraphStyle objects. + +You must provide a function called "getParagraphStyles()" to +return it. In future, we can put things like LineStyles, +TableCellStyles etc. in the same modules. + +You might wish to have two parallel style sheets, one for colour +and one for black and white, so you can switch your presentations +easily. + +A style sheet MUST define a style called 'Normal'. +""" + +from reportlab.lib import styles, enums +def getParagraphStyles(): + """Returns a dictionary of styles based on Helvetica""" + stylesheet = {} + + para = styles.ParagraphStyle('Normal', None) #the ancestor of all + para.fontName = 'Courier' + para.fontSize = 24 + para.leading = 28 + stylesheet['Normal'] = para + + para = ParagraphStyle('BodyText', stylesheet['Normal']) + para.spaceBefore = 12 + stylesheet['BodyText'] = para + + para = ParagraphStyle('BigCentered', stylesheet['Normal']) + para.spaceBefore = 12 + para.alignment = enums.TA_CENTER + stylesheet['BigCentered'] = para + + para = ParagraphStyle('Italic', stylesheet['BodyText']) + para.fontName = 'Courier-Oblique' + stylesheet['Italic'] = para + + para = ParagraphStyle('Title', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 48 + para.Leading = 58 + para.spaceAfter = 36 + para.alignment = enums.TA_CENTER + stylesheet['Title'] = para + + para = ParagraphStyle('Heading1', stylesheet['Normal']) + para.fontName = 'Courier-Bold' + para.fontSize = 36 + para.leading = 44 + para.spaceAfter = 36 + para.alignment = enums.TA_CENTER + stylesheet['Heading1'] = para + + para = ParagraphStyle('Heading2', stylesheet['Normal']) + para.fontName = 'Courier-Bold' + para.fontSize = 28 + para.leading = 34 + para.spaceBefore = 24 + para.spaceAfter = 12 + stylesheet['Heading2'] = para + + para = ParagraphStyle('Heading3', stylesheet['Normal']) + para.fontName = 'Courier-BoldOblique' + para.spaceBefore = 24 + para.spaceAfter = 12 + stylesheet['Heading3'] = para + + para = ParagraphStyle('Bullet', stylesheet['Normal']) + para.firstLineIndent = -18 + para.leftIndent = 72 + para.spaceBefore = 6 + #para.bulletFontName = 'Symbol' + para.bulletFontSize = 24 + para.bulletIndent = 36 + stylesheet['Bullet'] = para + + para = ParagraphStyle('Definition', stylesheet['Normal']) + #use this for definition lists + para.firstLineIndent = 0 + para.leftIndent = 72 + para.bulletIndent = 0 + para.spaceBefore = 12 + para.bulletFontName = 'Couruer-BoldOblique' + stylesheet['Definition'] = para + + para = ParagraphStyle('Code', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + stylesheet['Code'] = para + + return stylesheet \ No newline at end of file diff --git a/bin/reportlab/tools/pythonpoint/styles/htu.py b/bin/reportlab/tools/pythonpoint/styles/htu.py new file mode 100644 index 00000000000..bc79a7ba68e --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/styles/htu.py @@ -0,0 +1,158 @@ +from reportlab.lib import styles +from reportlab.lib import colors +from reportlab.lib.units import cm +from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY +from reportlab.platypus import Preformatted, Paragraph, Frame, \ + Image, Table, TableStyle, Spacer +from reportlab.pdfbase import pdfmetrics +from reportlab.pdfbase.ttfonts import TTFont + + +def getParagraphStyles(): + """Returns a dictionary of styles to get you started. + + We will provide a way to specify a module of these. Note that + this just includes TableStyles as well as ParagraphStyles for any + tables you wish to use. + """ + + pdfmetrics.registerFont(TTFont('Verdana','verdana.ttf')) + pdfmetrics.registerFont(TTFont('Verdana-Bold','verdanab.ttf')) + pdfmetrics.registerFont(TTFont('Verdana-Italic','verdanai.ttf')) + pdfmetrics.registerFont(TTFont('Verdana-BoldItalic','verdanaz.ttf')) + pdfmetrics.registerFont(TTFont('Arial Narrow','arialn.ttf')) + pdfmetrics.registerFont(TTFont('Arial Narrow-Bold','arialnb.ttf')) + pdfmetrics.registerFont(TTFont('Arial Narrow-Italic','arialni.ttf')) + pdfmetrics.registerFont(TTFont('Arial Narrow-BoldItalic','arialnbi.ttf')) + + stylesheet = {} + ParagraphStyle = styles.ParagraphStyle + + para = ParagraphStyle('Normal', None) #the ancestor of all + para.fontName = 'Verdana' + para.fontSize = 28 + para.leading = 32 + para.spaceAfter = 6 + stylesheet['Normal'] = para + + #This one is spaced out a bit... + para = ParagraphStyle('BodyText', stylesheet['Normal']) + para.spaceBefore = 12 + stylesheet['BodyText'] = para + + #Indented, for lists + para = ParagraphStyle('Indent', stylesheet['Normal']) + para.leftIndent = 60 + para.firstLineIndent = 0 + stylesheet['Indent'] = para + + para = ParagraphStyle('Centered', stylesheet['Normal']) + para.alignment = TA_CENTER + stylesheet['Centered'] = para + + para = ParagraphStyle('BigCentered', stylesheet['Normal']) + para.fontSize = 32 + para.alignment = TA_CENTER + para.spaceBefore = 12 + para.spaceAfter = 12 + stylesheet['BigCentered'] = para + + para = ParagraphStyle('Italic', stylesheet['BodyText']) + para.fontName = 'Verdana-Italic' + stylesheet['Italic'] = para + + para = ParagraphStyle('Title', stylesheet['Normal']) + para.fontName = 'Arial Narrow-Bold' + para.fontSize = 48 + para.leading = 58 + para.alignment = TA_CENTER + stylesheet['Title'] = para + + para = ParagraphStyle('Heading1', stylesheet['Normal']) + para.fontName = 'Arial Narrow-Bold' + para.fontSize = 40 + para.leading = 44 + para.alignment = TA_CENTER + stylesheet['Heading1'] = para + + para = ParagraphStyle('Heading2', stylesheet['Normal']) + para.fontName = 'Verdana' + para.fontSize = 32 + para.leading = 36 + para.spaceBefore = 32 + para.spaceAfter = 12 + stylesheet['Heading2'] = para + + para = ParagraphStyle('Heading3', stylesheet['Normal']) + para.fontName = 'Verdana' + para.spaceBefore = 20 + para.spaceAfter = 6 + stylesheet['Heading3'] = para + + para = ParagraphStyle('Heading4', stylesheet['Normal']) + para.fontName = 'Verdana-BoldItalic' + para.spaceBefore = 6 + stylesheet['Heading4'] = para + + para = ParagraphStyle('Bullet', stylesheet['Normal']) + para.firstLineIndent = 0 + para.leftIndent = 56 + para.spaceBefore = 6 + para.bulletFontName = 'Symbol' + para.bulletFontSize = 24 + para.bulletIndent = 20 + stylesheet['Bullet'] = para + + para = ParagraphStyle('Bullet2', stylesheet['Normal']) + para.firstLineIndent = 0 + para.leftIndent = 80 + para.spaceBefore = 6 + para.fontSize = 24 + para.bulletFontName = 'Symbol' + para.bulletFontSize = 20 + para.bulletIndent = 60 + stylesheet['Bullet2'] = para + + para = ParagraphStyle('Definition', stylesheet['Normal']) + #use this for definition lists + para.firstLineIndent = 0 + para.leftIndent = 60 + para.bulletIndent = 0 + para.bulletFontName = 'Verdana-BoldItalic' + para.bulletFontSize = 24 + stylesheet['Definition'] = para + + para = ParagraphStyle('Code', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + stylesheet['Code'] = para + + para = ParagraphStyle('PythonCode', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + stylesheet['Code'] = para + + para = ParagraphStyle('Small', stylesheet['Normal']) + para.fontSize = 12 + para.leading = 14 + stylesheet['Small'] = para + + #now for a table + ts = TableStyle([ + ('FONT', (0,0), (-1,-1), 'Arial Narrow', 22), + ('LINEABOVE', (0,1), (-1,1), 2, colors.green), + ('LINEABOVE', (0,2), (-1,-1), 0.25, colors.black), + ('LINEBELOW', (0,-1), (-1,-1), 2, colors.green), + ('LINEBEFORE', (0,1), (-1,-1), 2, colors.black), + ('LINEAFTER', (0,1), (-1,-1), 2, colors.black), + ('ALIGN', (4,1), (-1,-1), 'RIGHT'), #all numeric cells right aligned + ('TEXTCOLOR', (0,2), (0,-1), colors.black), + ('BACKGROUND', (0,1), (-1,1), colors.Color(0,0.7,0.7)) + ]) + stylesheet['table1'] = ts + + return stylesheet diff --git a/bin/reportlab/tools/pythonpoint/styles/modern.py b/bin/reportlab/tools/pythonpoint/styles/modern.py new file mode 100644 index 00000000000..a2fbca19ef0 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/styles/modern.py @@ -0,0 +1,120 @@ +#Copyright ReportLab Europe Ltd. 2000-2004 +#see license.txt for license details +#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/tools/pythonpoint/styles/modern.py +__version__=''' $Id$ ''' +# style_modern.py +__doc__="""This is an example style sheet. You can create your own, and +have them loaded by the presentation. A style sheet is just a +dictionary, where they keys are style names and the values are +ParagraphStyle objects. + +You must provide a function called "getParagraphStyles()" to +return it. In future, we can put things like LineStyles, +TableCellStyles etc. in the same modules. + +You might wish to have two parallel style sheets, one for colour +and one for black and white, so you can switch your presentations +easily. + +A style sheet MUST define a style called 'Normal'. +""" + +from reportlab.lib import styles +from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY + +def getParagraphStyles(): + """Returns a dictionary of styles based on Helvetica""" + stylesheet = {} + ParagraphStyle = styles.ParagraphStyle + + para = ParagraphStyle('Normal', None) #the ancestor of all + para.fontName = 'Helvetica' + para.fontSize = 24 + para.leading = 28 + stylesheet['Normal'] = para + + para = ParagraphStyle('BodyText', stylesheet['Normal']) + para.spaceBefore = 12 + stylesheet['BodyText'] = para + + para = ParagraphStyle('Indent', stylesheet['Normal']) + para.leftIndent = 36 + para.firstLineIndent = 0 + stylesheet['Indent'] = para + + para = ParagraphStyle('Centered', stylesheet['Normal']) + para.alignment = TA_CENTER + stylesheet['Centered'] = para + + para = ParagraphStyle('BigCentered', stylesheet['Normal']) + para.spaceBefore = 12 + para.alignment = TA_CENTER + stylesheet['BigCentered'] = para + + para = ParagraphStyle('Italic', stylesheet['BodyText']) + para.fontName = 'Helvetica-Oblique' + stylesheet['Italic'] = para + + para = ParagraphStyle('Title', stylesheet['Normal']) + para.fontName = 'Helvetica' + para.fontSize = 48 + para.Leading = 58 + para.spaceAfter = 36 + para.alignment = TA_CENTER + stylesheet['Title'] = para + + para = ParagraphStyle('Heading1', stylesheet['Normal']) + para.fontName = 'Helvetica-Bold' + para.fontSize = 36 + para.leading = 44 + para.spaceAfter = 36 + para.alignment = TA_CENTER + stylesheet['Heading1'] = para + + para = ParagraphStyle('Heading2', stylesheet['Normal']) + para.fontName = 'Helvetica-Bold' + para.fontSize = 28 + para.leading = 34 + para.spaceBefore = 24 + para.spaceAfter = 12 + stylesheet['Heading2'] = para + + para = ParagraphStyle('Heading3', stylesheet['Normal']) + para.fontName = 'Helvetica-BoldOblique' + para.spaceBefore = 24 + para.spaceAfter = 12 + stylesheet['Heading3'] = para + + para = ParagraphStyle('Bullet', stylesheet['Normal']) + para.firstLineIndent = -18 + para.leftIndent = 72 + para.spaceBefore = 6 + para.bulletFontName = 'Symbol' + para.bulletFontSize = 24 + para.bulletIndent = 36 + stylesheet['Bullet'] = para + + para = ParagraphStyle('Bullet2', stylesheet['Bullet']) + para.firstLineIndent = 0 + para.bulletIndent = 72 + para.leftIndent = 108 + stylesheet['Bullet2'] = para + + + para = ParagraphStyle('Definition', stylesheet['Normal']) + #use this for definition lists + para.firstLineIndent = 0 + para.leftIndent = 72 + para.bulletIndent = 0 + para.spaceBefore = 12 + para.bulletFontName = 'Helvetica-BoldOblique' + stylesheet['Definition'] = para + + para = ParagraphStyle('Code', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + stylesheet['Code'] = para + + return stylesheet \ No newline at end of file diff --git a/bin/reportlab/tools/pythonpoint/styles/projection.py b/bin/reportlab/tools/pythonpoint/styles/projection.py new file mode 100644 index 00000000000..a3c818556d0 --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/styles/projection.py @@ -0,0 +1,106 @@ +"""This is an example style sheet. You can create your own, and +have them loaded by the presentation. A style sheet is just a +dictionary, where they keys are style names and the values are +ParagraphStyle objects. + +You must provide a function called "getParagraphStyles()" to +return it. In future, we can put things like LineStyles, +TableCellStyles etc. in the same modules. + +You might wish to have two parallel style sheets, one for colour +and one for black and white, so you can switch your presentations +easily. + +A style sheet MUST define a style called 'Normal'. +""" + +from reportlab.lib import styles +from reportlab.lib.colors import * +from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY + + +def getParagraphStyles(): + """Returns a dictionary of styles based on Helvetica""" + + stylesheet = {} + ParagraphStyle = styles.ParagraphStyle + + para = ParagraphStyle('Normal', None) #the ancestor of all + para.fontName = 'Helvetica-Bold' + para.fontSize = 24 + para.leading = 28 + para.textColor = white + stylesheet['Normal'] = para + + para = ParagraphStyle('BodyText', stylesheet['Normal']) + para.spaceBefore = 12 + stylesheet['BodyText'] = para + + para = ParagraphStyle('BigCentered', stylesheet['Normal']) + para.spaceBefore = 12 + para.alignment = TA_CENTER + stylesheet['BigCentered'] = para + + para = ParagraphStyle('Italic', stylesheet['BodyText']) + para.fontName = 'Helvetica-Oblique' + para.textColor = white + stylesheet['Italic'] = para + + para = ParagraphStyle('Title', stylesheet['Normal']) + para.fontName = 'Helvetica' + para.fontSize = 48 + para.Leading = 58 + para.spaceAfter = 36 + para.alignment = TA_CENTER + stylesheet['Title'] = para + + para = ParagraphStyle('Heading1', stylesheet['Normal']) + para.fontName = 'Helvetica-Bold' + para.fontSize = 48# 36 + para.leading = 44 + para.spaceAfter = 36 + para.textColor = green + para.alignment = TA_LEFT + stylesheet['Heading1'] = para + + para = ParagraphStyle('Heading2', stylesheet['Normal']) + para.fontName = 'Helvetica-Bold' + para.fontSize = 28 + para.leading = 34 + para.spaceBefore = 24 + para.spaceAfter = 12 + stylesheet['Heading2'] = para + + para = ParagraphStyle('Heading3', stylesheet['Normal']) + para.fontName = 'Helvetica-BoldOblique' + para.spaceBefore = 24 + para.spaceAfter = 12 + stylesheet['Heading3'] = para + + para = ParagraphStyle('Bullet', stylesheet['Normal']) + para.firstLineIndent = -18 + para.leftIndent = 72 + para.spaceBefore = 6 + para.bulletFontName = 'Symbol' + para.bulletFontSize = 24 + para.bulletIndent = 36 + stylesheet['Bullet'] = para + + para = ParagraphStyle('Definition', stylesheet['Normal']) + #use this for definition lists + para.firstLineIndent = 0 + para.leftIndent = 72 + para.bulletIndent = 0 + para.spaceBefore = 12 + para.bulletFontName = 'Helvetica-BoldOblique' + stylesheet['Definition'] = para + + para = ParagraphStyle('Code', stylesheet['Normal']) + para.fontName = 'Courier-Bold' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + para.textColor = chartreuse + stylesheet['Code'] = para + + return stylesheet \ No newline at end of file diff --git a/bin/reportlab/tools/pythonpoint/styles/standard.py b/bin/reportlab/tools/pythonpoint/styles/standard.py new file mode 100644 index 00000000000..c525964585d --- /dev/null +++ b/bin/reportlab/tools/pythonpoint/styles/standard.py @@ -0,0 +1,132 @@ +from reportlab.lib import styles +from reportlab.lib import colors +from reportlab.lib.units import cm +from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY +from reportlab.platypus import Preformatted, Paragraph, Frame, \ + Image, Table, TableStyle, Spacer + + +def getParagraphStyles(): + """Returns a dictionary of styles to get you started. + + We will provide a way to specify a module of these. Note that + this just includes TableStyles as well as ParagraphStyles for any + tables you wish to use. + """ + + stylesheet = {} + ParagraphStyle = styles.ParagraphStyle + + para = ParagraphStyle('Normal', None) #the ancestor of all + para.fontName = 'Times-Roman' + para.fontSize = 24 + para.leading = 28 + stylesheet['Normal'] = para + + #This one is spaced out a bit... + para = ParagraphStyle('BodyText', stylesheet['Normal']) + para.spaceBefore = 12 + stylesheet['BodyText'] = para + + #Indented, for lists + para = ParagraphStyle('Indent', stylesheet['Normal']) + para.leftIndent = 36 + para.firstLineIndent = 0 + stylesheet['Indent'] = para + + para = ParagraphStyle('Centered', stylesheet['Normal']) + para.alignment = TA_CENTER + stylesheet['Centered'] = para + + para = ParagraphStyle('BigCentered', stylesheet['Normal']) + para.spaceBefore = 12 + para.alignment = TA_CENTER + stylesheet['BigCentered'] = para + + para = ParagraphStyle('Italic', stylesheet['BodyText']) + para.fontName = 'Times-Italic' + stylesheet['Italic'] = para + + para = ParagraphStyle('Title', stylesheet['Normal']) + para.fontName = 'Times-Roman' + para.fontSize = 48 + para.leading = 58 + para.alignment = TA_CENTER + stylesheet['Title'] = para + + para = ParagraphStyle('Heading1', stylesheet['Normal']) + para.fontName = 'Times-Bold' + para.fontSize = 36 + para.leading = 44 + para.alignment = TA_CENTER + stylesheet['Heading1'] = para + + para = ParagraphStyle('Heading2', stylesheet['Normal']) + para.fontName = 'Times-Bold' + para.fontSize = 28 + para.leading = 34 + para.spaceBefore = 24 + stylesheet['Heading2'] = para + + para = ParagraphStyle('Heading3', stylesheet['Normal']) + para.fontName = 'Times-BoldItalic' + para.spaceBefore = 24 + stylesheet['Heading3'] = para + + para = ParagraphStyle('Heading4', stylesheet['Normal']) + para.fontName = 'Times-BoldItalic' + para.spaceBefore = 6 + stylesheet['Heading4'] = para + + para = ParagraphStyle('Bullet', stylesheet['Normal']) + para.firstLineIndent = 0 + para.leftIndent = 56 + para.spaceBefore = 6 + para.bulletFontName = 'Symbol' + para.bulletFontSize = 24 + para.bulletIndent = 20 + stylesheet['Bullet'] = para + + para = ParagraphStyle('Definition', stylesheet['Normal']) + #use this for definition lists + para.firstLineIndent = 0 + para.leftIndent = 72 + para.bulletIndent = 0 + para.spaceBefore = 12 + para.bulletFontName = 'Helvetica-BoldOblique' + para.bulletFontSize = 24 + stylesheet['Definition'] = para + + para = ParagraphStyle('Code', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + stylesheet['Code'] = para + + para = ParagraphStyle('PythonCode', stylesheet['Normal']) + para.fontName = 'Courier' + para.fontSize = 16 + para.leading = 18 + para.leftIndent = 36 + stylesheet['PythonCode'] = para + + para = ParagraphStyle('Small', stylesheet['Normal']) + para.fontSize = 12 + para.leading = 14 + stylesheet['Small'] = para + + #now for a table + ts = TableStyle([ + ('FONT', (0,0), (-1,-1), 'Times-Roman', 24), + ('LINEABOVE', (0,0), (-1,0), 2, colors.green), + ('LINEABOVE', (0,1), (-1,-1), 0.25, colors.black), + ('LINEBELOW', (0,-1), (-1,-1), 2, colors.green), + ('LINEBEFORE', (-1,0), (-1,-1), 2, colors.black), + ('ALIGN', (1,1), (-1,-1), 'RIGHT'), #all numeric cells right aligned + ('TEXTCOLOR', (0,1), (0,-1), colors.red), + ('BACKGROUND', (0,0), (-1,0), colors.Color(0,0.7,0.7)) + ]) + stylesheet['table1'] = ts + + return stylesheet -- cgit v1.2.3