asp.net pdf viewer component : How to view pdf thumbnails in Library application class asp.net html winforms ajax reportlab-userguide9-part1297

Image.draw(self)
I = RotatedImage('../images/replogo.gif')
I.hAlign = 'CENTER'
produces
User Guide
Chapter 10 Writing your own Flowable Objects
Page 91
How to view pdf thumbnails in - Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
cannot view pdf thumbnails in; view pdf thumbnails in
How to view pdf thumbnails in - VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
create thumbnail from pdf; pdf no thumbnail
Chapter 11 Graphics
11.1 Introduction
ReportLab Graphics is one of the sub-packages to the ReportLab library. It started off as a stand-alone set of
programs, but is now a fully integrated part of the ReportLab toolkit that allows you to use its powerful
charting and graphics features to improve your PDF forms and reports.
11.2 General Concepts
In this section we will present some of the more fundamental principles of the graphics library, which will
show-up later in various places.
Drawings and Renderers
Drawing is a platform-independent description of a collection of shapes. It is not directly associated with
PDF, Postscript or any other output format. Fortunately, most vector graphics systems have followed the
Postscript model and it is possible to describe shapes unambiguously.
A drawing contains a number of primitive Shapes. Normal shapes are those widely known as rectangles,
circles, lines, etc. One special (logic) shape is a Group, which can hold other shapes and apply a
transformation to them. Groups represent composites of shapes and allow to treat the composite as if it were
a single shape. Just about anything can be built up from a small number of basic shapes.
The package provides several Renderers which know how to draw a drawing into different formats. These
include PDF (renderPDF), Postscript (renderPS), and bitmap output (renderPM). The bitmap renderer uses
Raph Levien's libart rasterizer and Fredrik Lundh's Python Imaging Library (PIL). The SVG renderer makes
use of Python's standard library XML modules, so you don't need to install the XML-SIG's additional
package named PyXML. If you have the right extensions installed, you can generate drawings in bitmap
form for the web as well as vector form for PDF documents, and get "identical output".
The PDF renderer has special "privileges" - a Drawing object is also a Flowable and, hence, can be placed
directly in the story of any Platypus document, or drawn directly on a Canvas with one line of code. In
addition, the PDF renderer has a utility function to make a one-page PDF document quickly.
The SVG renderer is special as it is still pretty experimental. The SVG code it generates is not really
optimised in any way and maps only the features available in ReportLab Graphics (RLG) to SVG. This
means there is no support for SVG animation, interactivity, scripting or more sophisticated clipping, masking
or graduation shapes. So, be careful, and please report any bugs you find!
Coordinate System
The Y-direction in our X-Y coordinate system points from the bottom up. This is consistent with PDF,
Postscript and mathematical notation. It also appears to be more natural for people, especially when working
with charts. Note that in other graphics models (such as SVG) the Y-coordinate points down. For the SVG
renderer this is actually no problem as it will take your drawings and flip things as needed, so your SVG
output looks just as expected.
The X-coordinate points, as usual, from left to right. So far there doesn't seem to be any model advocating
the opposite direction - at least not yet (with interesting exceptions, as it seems, for Arabs looking at time
series charts...).
Getting Started
Let's create a simple drawing containing the string "Hello World" and some special characters, displayed on
top of a coloured rectangle. After creating it we will save the drawing to a standalone PDF file.
from reportlab.lib import colors
from reportlab.graphics.shapes import *
User Guide
Chapter 11 Graphics
Page 92
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Ability to show PDF page thumbnails for quick navigation. Easy to search PDF text in whole PDF document. C# HTML5 PDF Viewer: View PDF Online.
can't view pdf thumbnails; pdf first page thumbnail
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Ability to show PDF page thumbnails for quick navigation. Easy to search PDF text in whole PDF document. VB.NET HTML5 PDF Viewer: View PDF Online.
pdf thumbnail viewer; enable pdf thumbnails
d = Drawing(400, 200)
d.add(Rect(50, 50, 300, 100, fillColor=colors.yellow))
d.add(String(150,100, 'Hello World', fontSize=18, fillColor=colors.red))
d.add(String(180,86, 'Special characters \
\xc2\xa2\xc2\xa9\xc2\xae\xc2\xa3\xce\xb1\xce\xb2',
fillColor=colors.red))
from reportlab.graphics import renderPDF
renderPDF.drawToFile(d, 'example1.pdf', 'My First Drawing')
This will produce a PDF file containing the following graphic:
Hello World
Special characters ¢©®£ab
Figure 11-1: 'Hello World'
Each renderer is allowed to do whatever is appropriate for its format, and may have whatever API is needed.
If it refers to a file format, it usually has a drawToFile function, and that's all you need to know about the
renderer. Let's save the same drawing in Encapsulated Postscript format:
from reportlab.graphics import renderPS
renderPS.drawToFile(d, 'example1.eps')
This will produce an EPS file with the identical drawing, which may be imported into publishing tools such
as Quark Express. If we wanted to generate the same drawing as a bitmap file for a website, say, all we need
to do is write code like this:
from reportlab.graphics import renderPM
renderPM.drawToFile(d, 'example1.png', 'PNG')
Many other bitmap formats, like GIF, JPG, TIFF, BMP and PPN are genuinely available, making it unlikely
you'll need to add external postprocessing steps to convert to the final format you need.
To produce an SVG file containing the identical drawing, which may be imported into graphical editing tools
such as Illustrator all we need to do is write code like this:
from reportlab.graphics import renderSVG
renderSVG.drawToFile(d, 'example1.svg')
Attribute Verification
Python is very dynamic and lets us execute statements at run time that can easily be the source for
unexpected behaviour. One subtle 'error' is when assigning to an attribute that the framework doesn't know
about because the used attribute's name contains a typo. Python lets you get away with it (adding a new
attribute to an object, say), but the graphics framework will not detect this 'typo' without taking special
counter-measures.
User Guide
Chapter 11 Graphics
Page 93
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
Easy to search PDF text in whole PDF document in VB.NET WPF program. PDF thumbnails for navigation in .NET project. VB.NET WPF PDF Viewer: View PDF Document.
how to show pdf thumbnails in; show pdf thumbnail in html
C# WPF PDF Viewer SDK to view PDF document in C#.NET
Users can view any page by using view page button. Easy to search PDF text in whole PDF document. PDF thumbnails for navigation in .NET WPF Console application.
create pdf thumbnail; show pdf thumbnails in
There are two verification techniques to avoid this situation. The default is for every object to check every
assignment at run time, such that you can only assign to 'legal' attributes. This is what happens by default. As
this imposes a small performance penalty, this behaviour can be turned off when you need it to be.
>>> r = Rect(10,10,200,100, fillColor=colors.red)
>>>
>>> r.fullColor = colors.green # note the typo
>>> r.x = 'not a number'       # illegal argument type
>>> del r.width                # that should confuse it
These statements would be caught by the compiler in a statically typed language, but Python lets you get
away with it. The first error could leave you staring at the picture trying to figure out why the colors were
wrong. The second error would probably become clear only later, when some back-end tries to draw the
rectangle. The third, though less likely, results in an invalid object that would not know how to draw itself.
>>> r = shapes.Rect(10,10,200,80)
>>> r.fullColor = colors.green
Traceback (most recent call last):
File "<interactive input>", line 1, in ?
File "C:\code\users\andy\graphics\shapes.py", line 254, in __setattr__
validateSetattr(self,attr,value)    #from reportlab.lib.attrmap
File "C:\code\users\andy\lib\attrmap.py", line 74, in validateSetattr
raise AttributeError, "Illegal attribute '%s' in class %s" % (name, obj.__class__.__name__)
AttributeError: Illegal attribute 'fullColor' in class Rect
>>>
This imposes a performance penalty, so this behaviour can be turned off when you need it to be. To do this,
you should use the following lines of code before you first import reportlab.graphics.shapes:
>>> import reportlab.rl_config
>>> reportlab.rl_config.shapeChecking = 0
>>> from reportlab.graphics import shapes
>>>
Once you turn off shapeChecking, the classes are actually built without the verification hook; code
should get faster, then. Currently the penalty seems to be about 25% on batches of charts, so it is hardly
worth disabling. However, if we move the renderers to C in future (which is eminently possible), the
remaining 75% would shrink to almost nothing and the saving from verification would be significant.
Each object, including the drawing itself, has a verify() method. This either succeeds, or raises an
exception. If you turn off automatic verification, then you should explicitly call verify() in testing when
developing the code, or perhaps once in a batch process.
Property Editing
A cornerstone of the reportlab/graphics which we will cover below is that you can automatically document
widgets. This means getting hold of all of their editable properties, including those of their subcomponents.
Another goal is to be able to create GUIs and config files for drawings. A generic GUI can be built to show
all editable properties of a drawing, and let you modify them and see the results. The Visual Basic or Delphi
development environment are good examples of this kind of thing. In a batch charting application, a file
could list all the properties of all the components in a chart, and be merged with a database query to make a
batch of charts.
To support these applications we have two interfaces, getProperties and setProperties, as well
as a convenience method dumpProperties. The first returns a dictionary of the editable properties of an
object; the second sets them en masse. If an object has publicly exposed 'children' then one can recursively
set and get their properties too. This will make much more sense when we look at Widgets later on, but we
need to put the support into the base of the framework.
>>> r = shapes.Rect(0,0,200,100)
>>> import pprint
>>> pprint.pprint(r.getProperties())
{'fillColor': Color(0.00,0.00,0.00),
'height': 100,
'rx': 0,
'ry': 0,
User Guide
Chapter 11 Graphics
Page 94
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Support of converting from any single one PDF page and multiple pages. Thumbnails can be created from PDF pages. Support for customizing image size.
pdf thumbnail creator; no pdf thumbnails in
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Embedded page thumbnails.
how to make a thumbnail from pdf; show pdf thumbnails
'strokeColor': Color(0.00,0.00,0.00),
'strokeDashArray': None,
'strokeLineCap': 0,
'strokeLineJoin': 0,
'strokeMiterLimit': 0,
'strokeWidth': 1,
'width': 200,
'x': 0,
'y': 0}
>>> r.setProperties({'x':20, 'y':30, 'strokeColor': colors.red})
>>> r.dumpProperties()
fillColor = Color(0.00,0.00,0.00)
height = 100
rx = 0
ry = 0
strokeColor = Color(1.00,0.00,0.00)
strokeDashArray = None
strokeLineCap = 0
strokeLineJoin = 0
strokeMiterLimit = 0
strokeWidth = 1
width = 200
x = 20
y = 30
>>>  
Note: pprint is the standard Python library module that allows you to 'pretty print' output over multiple
lines rather than having one very long line.
These three methods don't seem to do much here, but as we will see they make our widgets framework much
more powerful when dealing with non-primitive objects.
Naming Children
You can add objects to the Drawing and Group objects. These normally go into a list of contents.
However, you may also give objects a name when adding them. This allows you to refer to and possibly
change any element of a drawing after constructing it.
>>> d = shapes.Drawing(400, 200)
>>> s = shapes.String(10, 10, 'Hello World')
>>> d.add(s, 'caption')
>>> s.caption.text
'Hello World'
>>>
Note that you can use the same shape instance in several contexts in a drawing; if you choose to use the same
Circle object in many locations (e.g. a scatter plot) and use different names to access it, it will still be a
shared object and the changes will be global.
This provides one paradigm for creating and modifying interactive drawings.
11.3 Charts
The motivation for much of this is to create a flexible chart package. This section presents a treatment of the
ideas behind our charting model, what the design goals are and what components of the chart package
already exist.
Design Goals
Here are some of the design goals:
Make simple top-level use really simple
It should be possible to create a simple chart with minimum lines of code, yet have it 'do the right
things' with sensible automatic settings. The pie chart snippets above do this. If a real chart has
many subcomponents, you still should not need to interact with them unless you want to customize
what they do.
Allow precise positioning
User Guide
Chapter 11 Graphics
Page 95
C# PDF File Compress Library: Compress reduce PDF size in C#.net
by large enterprises and organizations to distribute and view documents. size, images size reducing can help to reduce PDF file size Embedded page thumbnails.
enable pdf thumbnail preview; view pdf thumbnails
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
Converter control easy to create thumbnails from PDF pages. Selection for compressing to multiple image formats. Cut and paste any areas in PDF pages to images.
pdf files thumbnail preview; create thumbnail jpeg from pdf
An absolute requirement in publishing and graphic design is to control the placing and style of every
element. We will try to have properties that specify things in fixed sizes and proportions of the
drawing, rather than having automatic resizing. Thus, the 'inner plot rectangle' will not magically
change when you make the font size of the y labels bigger, even if this means your labels can spill
out of the left edge of the chart rectangle. It is your job to preview the chart and choose sizes and
spaces which will work.
Some things do need to be automatic. For example, if you want to fit N bars into a 200 point space
and don't know N in advance, we specify bar separation as a percentage of the width of a bar rather
than a point size, and let the chart work it out. This is still deterministic and controllable.
Control child elements individually or as a group
We use smart collection classes that let you customize a group of things, or just one of them. For
example you can do this in our experimental pie chart:
d = Drawing(400,200)
pc = Pie()
pc.x = 150
pc.y = 50
pc.data = [10,20,30,40,50,60]
pc.labels = ['a','b','c','d','e','f']
pc.slices.strokeWidth=0.5
pc.slices[3].popout = 20
pc.slices[3].strokeWidth = 2
pc.slices[3].strokeDashArray = [2,2]
pc.slices[3].labelRadius = 1.75
pc.slices[3].fontColor = colors.red
d.add(pc, '')
pc.slices[3] actually lazily creates a little object which holds information about the slice in question;
this will be used to format a fourth slice at draw-time if there is one.
Only expose things you should change
It would be wrong from a statistical viewpoint to let you directly adjust the angle of one of the pie
wedges in the above example, since that is determined by the data. So not everything will be
exposed through the public properties. There may be 'back doors' to let you violate this when you
really need to, or methods to provide advanced functionality, but in general properties will be
orthogonal.
Composition and component based
Charts are built out of reusable child widgets. A Legend is an easy-to-grasp example. If you need a
specialized type of legend (e.g. circular colour swatches), you should subclass the standard Legend
widget. Then you could either do something like...
c = MyChartWithLegend()
c.legend = MyNewLegendClass()    # just change it
c.legend.swatchRadius = 5    # set a property only relevant to the new one
c.data = [10,20,30]     and then configure as usual...
...or create/modify your own chart or drawing class which creates one of these by default. This is
also very relevant for time series charts, where there can be many styles of x axis.
Top level chart classes will create a number of such components, and then either call methods or set
private properties to tell them their height and position - all the stuff which should be done for you
and which you cannot customise. We are working on modelling what the components should be and
will publish their APIs here as a consensus emerges.
Multiples
A corollary of the component approach is that you can create diagrams with multiple charts, or
custom data graphics. Our favourite example of what we are aiming for is the weather report in our
gallery contributed by a user; we'd like to make it easy to create such drawings, hook the building
blocks up to their legends, and feed that data in a consistent way.
User Guide
Chapter 11 Graphics
Page 96
(If you want to see the image, it is available on our website here)
Overview
A chart or plot is an object which is placed on a drawing; it is not itself a drawing. You can thus control
where it goes, put several on the same drawing, or add annotations.
Charts have two axes; axes may be Value or Category axes. Axes in turn have a Labels property which lets
you configure all text labels or each one individually. Most of the configuration details which vary from chart
to chart relate to axis properties, or axis labels.
Objects expose properties through the interfaces discussed in the previous section; these are all optional and
are there to let the end user configure the appearance. Things which must be set for a chart to work, and
essential communication between a chart and its components, are handled through methods.
You can subclass any chart component and use your replacement instead of the original provided you
implement the essential methods and properties.
11.4 Labels
A label is a string of text attached to some chart element. They are used on axes, for titles or alongside axes,
or attached to individual data points. Labels may contain newline characters, but only one font.
The text and 'origin' of a label are typically set by its parent object. They are accessed by methods rather than
properties. Thus, the X axis decides the 'reference point' for each tickmark label and the numeric or date text
for each label. However, the end user can set properties of the label (or collection of labels) directly to affect
its position relative to this origin and all of its formatting.
from reportlab.graphics import shapes
from reportlab.graphics.charts.textlabels import Label
d = Drawing(200, 100)
# mark the origin of the label
d.add(Circle(100,90, 5, fillColor=colors.green))
lab = Label()
lab.setOrigin(100,90)
lab.boxAnchor = 'ne'
lab.angle = 45
lab.dx = 0
lab.dy = -20
lab.boxStrokeColor = colors.green
lab.setText('Some
Multi-Line
Label')
d.add(lab)
Some
Multi-Line
Label
Figure 11-2: Label example
In the drawing above, the label is defined relative to the green blob. The text box should have its north-east
corner ten points down from the origin, and be rotated by 45 degrees about that corner.
At present labels have the following properties, which we believe are sufficient for all charts we have seen to
date:
User Guide
Chapter 11 Graphics
Page 97
Property
Meaning
dx
The label's x displacement.
dy
The label's y displacement.
angle
The angle of rotation (counterclockwise) applied to the label.
boxAnchor
The label's box anchor, one of 'n', 'e', 'w', 's', 'ne', 'nw', 'se', 'sw'.
textAnchor
The place where to anchor the label's text, one of 'start', 'middle', 'end'.
boxFillColor
The fill color used in the label's box.
boxStrokeColor
The stroke color used in the label's box.
boxStrokeWidth
The line width of the label's box.
fontName
The label's font name.
fontSize
The label's font size.
leading
The leading value of the label's text lines.
x
The X-coordinate of the reference point.
y
The Y-coordinate of the reference point.
width
The label's width.
height
The label's height.
Table 11-4 - Label properties
To see many more examples of Label objects with different combinations of properties, please have a look
into the ReportLab test suite in the folder tests, run the script test_charts_textlabels.py and
look at the PDF document it generates!
11.5 Axes
We identify two basic kinds of axes - Value and Category ones. Both come in horizontal and vertical flavors.
Both can be subclassed to make very specific kinds of axis. For example, if you have complex rules for
which dates to display in a time series application, or want irregular scaling, you override the axis and make a
new one.
Axes are responsible for determining the mapping from data to image coordinates; transforming points on
request from the chart; drawing themselves and their tickmarks, gridlines and axis labels.
This drawing shows two axes, one of each kind, which have been created directly without reference to any
chart:
User Guide
Chapter 11 Graphics
Page 98
Beer
Wine
Meat
Cannelloni
10
20
30
40
Figure 11-3: Two isolated axes
Here is the code that created them:
from reportlab.graphics import shapes
from reportlab.graphics.charts.axes import XCategoryAxis,YValueAxis
drawing = Drawing(400, 200)
data = [(10, 20, 30, 40), (15, 22, 37, 42)]
xAxis = XCategoryAxis()
xAxis.setPosition(75, 75, 300)
xAxis.configure(data)
xAxis.categoryNames = ['Beer', 'Wine', 'Meat''Cannelloni']
xAxis.labels.boxAnchor = 'n'
xAxis.labels[3].dy = -15
xAxis.labels[3].angle = 30
xAxis.labels[3].fontName = 'Times-Bold'
yAxis = YValueAxis()
yAxis.setPosition(50, 50, 125)
yAxis.configure(data)
drawing.add(xAxis)
drawing.add(yAxis)
Remember that, usually, you won't have to create axes directly; when using a standard chart, it comes with
ready-made axes. The methods are what the chart uses to configure it and take care of the geometry.
However, we will talk through them in detail below. The orthogonally dual axes to those we describe have
essentially the same properties, except for those refering to ticks.
XCategoryAxis class
A Category Axis doesn't really have a scale; it just divides itself into equal-sized buckets. It is simpler than a
value axis. The chart (or programmer) sets its location with the method setPosition(x, y,
length). The next stage is to show it the data so that it can configure itself. This is easy for a category axis
- it just counts the number of data points in one of the data series. The reversed attribute (if 1) indicates
that the categories should be reversed. When the drawing is drawn, the axis can provide some help to the
chart with its scale() method, which tells the chart where a given category begins and ends on the page.
We have not yet seen any need to let people override the widths or positions of categories.
An XCategoryAxis has the following editable properties:
Property
Meaning
User Guide
Chapter 11 Graphics
Page 99
visible
Should the axis be drawn at all? Sometimes you don't want
to display one or both axes, but they still need to be there as
they manage the scaling of points.
strokeColor
Color of the axis
strokeDashArray
Whether to draw axis with a dash and, if so, what kind.
Defaults to None
strokeWidth
Width of axis in points
tickUp
How far above the axis should the tick marks protrude?
(Note that making this equal to chart height gives you a gridline)
tickDown
How far below the axis should the tick mark protrude?
categoryNames
Either None, or a list of strings. This should have the
same length as each data series.
labels
A collection of labels for the tick marks. By default the 'north'
of each text label (i.e top centre) is positioned 5 points down
from the centre of each category on the axis. You may redefine
any property of the whole label group or of any one label. If
categoryNames=None, no labels are drawn.
title
Not Implemented Yet. This needs to be like a label, but also
lets you set the text directly. It would have a default
location below the axis.
Table 11-5 - XCategoryAxis properties
YValueAxis
The left axis in the diagram is a YValueAxis. A Value Axis differs from a Category Axis in that each point
along its length corresponds to a y value in chart space. It is the job of the axis to configure itself, and to
convert Y values from chart space to points on demand to assist the parent chart in plotting.
setPosition(x, y, length) and configure(data) work exactly as for a category axis. If you
have not fully specified the maximum, minimum and tick interval, then configure() results in the axis
choosing suitable values. Once configured, the value axis can convert y data values to drawing space with the
scale() method. Thus:
>>> yAxis = YValueAxis()
>>> yAxis.setPosition(50, 50, 125)
>>> data = [(10, 20, 30, 40),(15, 22, 37, 42)]
>>> yAxis.configure(data)
>>> yAxis.scale(10)  # should be bottom of chart
50.0
>>> yAxis.scale(40)  # should be near the top
167.1875
>>>
By default, the highest data point is aligned with the top of the axis, the lowest with the bottom of the axis,
and the axis choose 'nice round numbers' for its tickmark points. You may override these settings with the
properties below.
Property
Meaning
visible
Should the axis be drawn at all? Sometimes you don't want
to display one or both axes, but they still need to be there as
they manage the scaling of points.
strokeColor
Color of the axis
strokeDashArray
Whether to draw axis with a dash and, if so, what kind.
Defaults to None
User Guide
Chapter 11 Graphics
Page 100
Documents you may be interested
Documents you may be interested