1
2/*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10#ifndef SkPDFDevice_DEFINED
11#define SkPDFDevice_DEFINED
12
13#include "SkDevice.h"
14#include "SkBitmap.h"
15#include "SkCanvas.h"
16#include "SkPaint.h"
17#include "SkPath.h"
18#include "SkPicture.h"
19#include "SkRect.h"
20#include "SkRefCnt.h"
21#include "SkStream.h"
22#include "SkTDArray.h"
23#include "SkTemplates.h"
24
25class SkPDFArray;
26class SkPDFDevice;
27class SkPDFDict;
28class SkPDFFont;
29class SkPDFFormXObject;
30class SkPDFGlyphSetMap;
31class SkPDFGraphicState;
32class SkPDFObject;
33class SkPDFResourceDict;
34class SkPDFShader;
35class SkPDFStream;
36class SkRRect;
37template <typename T> class SkTSet;
38
39// Private classes.
40struct ContentEntry;
41struct GraphicStateEntry;
42struct NamedDestination;
43
44/** \class SkPDFDevice
45
46    The drawing context for the PDF backend.
47*/
48class SkPDFDevice : public SkBaseDevice {
49public:
50    /** Create a PDF drawing context with the given width and height.
51     *  72 points/in means letter paper is 612x792.
52     *  @param pageSize Page size in points.
53     *  @param contentSize The content size of the page in points. This will be
54     *         combined with the initial transform to determine the drawing area
55     *         (as reported by the width and height methods). Anything outside
56     *         of the drawing area will be clipped.
57     *  @param initialTransform The initial transform to apply to the page.
58     *         This may be useful to, for example, move the origin in and
59     *         over a bit to account for a margin, scale the canvas,
60     *         or apply a rotation.  Note1: the SkPDFDevice also applies
61     *         a scale+translate transform to move the origin from the
62     *         bottom left (PDF default) to the top left.  Note2: drawDevice
63     *         (used by layer restore) draws the device after this initial
64     *         transform is applied, so the PDF device does an
65     *         inverse scale+translate to accommodate the one that SkPDFDevice
66     *         always does.
67     */
68    // Deprecated, please use SkDocument::CreatePdf() instead.
69    SK_API SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
70                       const SkMatrix& initialTransform);
71    SK_API virtual ~SkPDFDevice();
72
73    virtual void clear(SkColor color) SK_OVERRIDE;
74
75    /** These are called inside the per-device-layer loop for each draw call.
76     When these are called, we have already applied any saveLayer operations,
77     and are handling any looping from the paint, and any effects from the
78     DrawFilter.
79     */
80    virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
81    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
82                            size_t count, const SkPoint[],
83                            const SkPaint& paint) SK_OVERRIDE;
84    virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint);
85    virtual void drawOval(const SkDraw&, const SkRect& oval, const SkPaint& paint) SK_OVERRIDE;
86    virtual void drawRRect(const SkDraw&, const SkRRect& rr, const SkPaint& paint) SK_OVERRIDE;
87    virtual void drawPath(const SkDraw&, const SkPath& origpath,
88                          const SkPaint& paint, const SkMatrix* prePathMatrix,
89                          bool pathIsMutable) SK_OVERRIDE;
90    virtual void drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
91                                const SkRect* src, const SkRect& dst,
92                                const SkPaint& paint,
93                                SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
94    virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
95                            const SkMatrix& matrix, const SkPaint&) SK_OVERRIDE;
96    virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap, int x, int y,
97                            const SkPaint& paint) SK_OVERRIDE;
98    virtual void drawText(const SkDraw&, const void* text, size_t len,
99                          SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
100    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
101                             const SkScalar pos[], SkScalar constY,
102                             int scalarsPerPos, const SkPaint&) SK_OVERRIDE;
103    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
104                                const SkPath& path, const SkMatrix* matrix,
105                                const SkPaint& paint) SK_OVERRIDE;
106    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
107                              int vertexCount, const SkPoint verts[],
108                              const SkPoint texs[], const SkColor colors[],
109                              SkXfermode* xmode, const uint16_t indices[],
110                              int indexCount, const SkPaint& paint) SK_OVERRIDE;
111    virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
112                            const SkPaint&) SK_OVERRIDE;
113
114    virtual void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
115    virtual void onDetachFromCanvas() SK_OVERRIDE;
116    virtual SkImageInfo imageInfo() const SK_OVERRIDE;
117
118    enum DrawingArea {
119        kContent_DrawingArea,  // Drawing area for the page content.
120        kMargin_DrawingArea,   // Drawing area for the margin content.
121    };
122
123    /** Sets the drawing area for the device. Subsequent draw calls are directed
124     *  to the specific drawing area (margin or content). The default drawing
125     *  area is the content drawing area.
126     *
127     *  Currently if margin content is drawn and then a complex (for PDF) xfer
128     *  mode is used, like SrcIn, Clear, etc, the margin content will get
129     *  clipped. A simple way to avoid the bug is to always draw the margin
130     *  content last.
131     */
132    SK_API void setDrawingArea(DrawingArea drawingArea);
133
134    /** Sets the DCTEncoder for images.
135     *  @param encoder The encoder to encode a bitmap as JPEG (DCT).
136     *         Result of encodings are cached, if the encoder changes the
137     *         behaivor dynamically and an image is added to a second catalog,
138     *         we will likely use the result of the first encoding call.
139     *         By returning false from the encoder function, the encoder result
140     *         is not used.
141     *         Callers might not want to encode small images, as the time spent
142     *         encoding and decoding might not be worth the space savings,
143     *         if any at all.
144     */
145    void setDCTEncoder(SkPicture::EncodeBitmap encoder) {
146        fEncoder = encoder;
147    }
148
149    // PDF specific methods.
150
151    /** Returns the resource dictionary for this device.
152     */
153    SK_API SkPDFResourceDict* getResourceDict();
154
155    /** Get the fonts used on this device.
156     */
157    SK_API const SkTDArray<SkPDFFont*>& getFontResources() const;
158
159    /** Add our named destinations to the supplied dictionary.
160     *  @param dict  Dictionary to add destinations to.
161     *  @param page  The PDF object representing the page for this device.
162     */
163    void appendDestinations(SkPDFDict* dict, SkPDFObject* page);
164
165    /** Returns a copy of the media box for this device. The caller is required
166     *  to unref() this when it is finished.
167     */
168    SK_API SkPDFArray* copyMediaBox() const;
169
170    /** Get the annotations from this page, or NULL if there are none.
171     */
172    SK_API SkPDFArray* getAnnotations() const { return fAnnotations; }
173
174    /** Returns a SkStream with the page contents.  The caller is responsible
175        for a reference to the returned value.
176        DEPRECATED: use copyContentToData()
177     */
178    SK_API SkStream* content() const;
179
180    /** Returns a SkStream with the page contents.  The caller is responsible
181     *  for calling data->unref() when it is finished.
182     */
183    SK_API SkData* copyContentToData() const;
184
185    SK_API const SkMatrix& initialTransform() const {
186        return fInitialTransform;
187    }
188
189    /** Returns a SkPDFGlyphSetMap which represents glyph usage of every font
190     *  that shows on this device.
191     */
192    const SkPDFGlyphSetMap& getFontGlyphUsage() const {
193        return *(fFontGlyphUsage.get());
194    }
195
196
197    /**
198     *  rasterDpi - the DPI at which features without native PDF support
199     *              will be rasterized (e.g. draw image with perspective,
200     *              draw text with perspective, ...)
201     *              A larger DPI would create a PDF that reflects the original
202     *              intent with better fidelity, but it can make for larger
203     *              PDF files too, which would use more memory while rendering,
204     *              and it would be slower to be processed or sent online or
205     *              to printer.
206     */
207    void setRasterDpi(SkScalar rasterDpi) {
208        fRasterDpi = rasterDpi;
209    }
210
211protected:
212    virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE {
213        return fLegacyBitmap;
214    }
215
216    virtual SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
217
218private:
219    // TODO(vandebo): push most of SkPDFDevice's state into a core object in
220    // order to get the right access levels without using friend.
221    friend class ScopedContentEntry;
222
223    SkISize fPageSize;
224    SkISize fContentSize;
225    SkMatrix fInitialTransform;
226    SkClipStack fExistingClipStack;
227    SkRegion fExistingClipRegion;
228    SkPDFArray* fAnnotations;
229    SkPDFResourceDict* fResourceDict;
230    SkTDArray<NamedDestination*> fNamedDestinations;
231
232    SkTDArray<SkPDFGraphicState*> fGraphicStateResources;
233    SkTDArray<SkPDFObject*> fXObjectResources;
234    SkTDArray<SkPDFFont*> fFontResources;
235    SkTDArray<SkPDFObject*> fShaderResources;
236
237    SkAutoTDelete<ContentEntry> fContentEntries;
238    ContentEntry* fLastContentEntry;
239    SkAutoTDelete<ContentEntry> fMarginContentEntries;
240    ContentEntry* fLastMarginContentEntry;
241    DrawingArea fDrawingArea;
242
243    const SkClipStack* fClipStack;
244
245    // Accessor and setter functions based on the current DrawingArea.
246    SkAutoTDelete<ContentEntry>* getContentEntries();
247    ContentEntry* getLastContentEntry();
248    void setLastContentEntry(ContentEntry* contentEntry);
249
250    // Glyph ids used for each font on this device.
251    SkAutoTDelete<SkPDFGlyphSetMap> fFontGlyphUsage;
252
253    SkPicture::EncodeBitmap fEncoder;
254    SkScalar fRasterDpi;
255
256    SkBitmap fLegacyBitmap;
257
258    SkPDFDevice(const SkISize& layerSize, const SkClipStack& existingClipStack,
259                const SkRegion& existingClipRegion);
260
261    // override from SkBaseDevice
262    virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE;
263
264    void init();
265    void cleanUp(bool clearFontUsage);
266    SkPDFFormXObject* createFormXObjectFromDevice();
267
268    void drawFormXObjectWithMask(int xObjectIndex,
269                                 SkPDFFormXObject* mask,
270                                 const SkClipStack* clipStack,
271                                 const SkRegion& clipRegion,
272                                 SkXfermode::Mode mode,
273                                 bool invertClip);
274
275    // If the paint or clip is such that we shouldn't draw anything, this
276    // returns NULL and does not create a content entry.
277    // setUpContentEntry and finishContentEntry can be used directly, but
278    // the preferred method is to use the ScopedContentEntry helper class.
279    ContentEntry* setUpContentEntry(const SkClipStack* clipStack,
280                                    const SkRegion& clipRegion,
281                                    const SkMatrix& matrix,
282                                    const SkPaint& paint,
283                                    bool hasText,
284                                    SkPDFFormXObject** dst);
285    void finishContentEntry(SkXfermode::Mode xfermode,
286                            SkPDFFormXObject* dst,
287                            SkPath* shape);
288    bool isContentEmpty();
289
290    void populateGraphicStateEntryFromPaint(const SkMatrix& matrix,
291                                            const SkClipStack& clipStack,
292                                            const SkRegion& clipRegion,
293                                            const SkPaint& paint,
294                                            bool hasText,
295                                            GraphicStateEntry* entry);
296    int addGraphicStateResource(SkPDFGraphicState* gs);
297    int addXObjectResource(SkPDFObject* xObject);
298
299    void updateFont(const SkPaint& paint, uint16_t glyphID,
300                    ContentEntry* contentEntry);
301    int getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID);
302
303    void internalDrawPaint(const SkPaint& paint, ContentEntry* contentEntry);
304    void internalDrawBitmap(const SkMatrix& matrix,
305                            const SkClipStack* clipStack,
306                            const SkRegion& clipRegion,
307                            const SkBitmap& bitmap,
308                            const SkIRect* srcRect,
309                            const SkPaint& paint);
310
311    /** Helper method for copyContentToData. It is responsible for copying the
312     *  list of content entries |entry| to |data|.
313     */
314    void copyContentEntriesToData(ContentEntry* entry, SkWStream* data) const;
315
316#ifdef SK_PDF_USE_PATHOPS
317    bool handleInversePath(const SkDraw& d, const SkPath& origPath,
318                           const SkPaint& paint, bool pathIsMutable,
319                           const SkMatrix* prePathMatrix = NULL);
320#endif
321    bool handleRectAnnotation(const SkRect& r, const SkMatrix& matrix,
322                              const SkPaint& paint);
323    bool handlePointAnnotation(const SkPoint* points, size_t count,
324                               const SkMatrix& matrix, const SkPaint& paint);
325    SkPDFDict* createLinkAnnotation(const SkRect& r, const SkMatrix& matrix);
326    void handleLinkToURL(SkData* urlData, const SkRect& r,
327                         const SkMatrix& matrix);
328    void handleLinkToNamedDest(SkData* nameData, const SkRect& r,
329                               const SkMatrix& matrix);
330    void defineNamedDestination(SkData* nameData, const SkPoint& point,
331                                const SkMatrix& matrix);
332
333    typedef SkBaseDevice INHERITED;
334
335    // TODO(edisonn): Only SkDocument_PDF and SkPDFImageShader should be able to create
336    // an SkPDFDevice
337    //friend class SkDocument_PDF;
338    //friend class SkPDFImageShader;
339};
340
341#endif
342