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 "SkCanvas.h"
14#include "SkDevice.h"
15#include "SkPaint.h"
16#include "SkPath.h"
17#include "SkRect.h"
18#include "SkRefCnt.h"
19#include "SkStream.h"
20#include "SkTScopedPtr.h"
21
22class SkPDFArray;
23class SkPDFDevice;
24class SkPDFDict;
25class SkPDFFont;
26class SkPDFFormXObject;
27class SkPDFGlyphSetMap;
28class SkPDFGraphicState;
29class SkPDFObject;
30class SkPDFShader;
31class SkPDFStream;
32
33// Private classes.
34struct ContentEntry;
35struct GraphicStateEntry;
36
37/** \class SkPDFDevice
38
39    The drawing context for the PDF backend.
40*/
41class SkPDFDevice : public SkDevice {
42public:
43    /** Create a PDF drawing context with the given width and height.
44     *  72 points/in means letter paper is 612x792.
45     *  @param pageSize Page size in points.
46     *  @param contentSize The content size of the page in points. This will be
47     *         combined with the initial transform to determine the drawing area
48     *         (as reported by the width and height methods). Anything outside
49     *         of the drawing area will be clipped.
50     *  @param initialTransform The initial transform to apply to the page.
51     *         This may be useful to, for example, move the origin in and
52     *         over a bit to account for a margin, scale the canvas,
53     *         or apply a rotation.  Note1: the SkPDFDevice also applies
54     *         a scale+translate transform to move the origin from the
55     *         bottom left (PDF default) to the top left.  Note2: drawDevice
56     *         (used by layer restore) draws the device after this initial
57     *         transform is applied, so the PDF device does an
58     *         inverse scale+translate to accommodate the one that SkPDFDevice
59     *         always does.
60     */
61    // TODO(vandebo): The sizes should be SkSize and not SkISize.
62    SK_API SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
63                       const SkMatrix& initialTransform);
64    SK_API virtual ~SkPDFDevice();
65
66    virtual uint32_t getDeviceCapabilities() SK_OVERRIDE;
67
68    virtual void clear(SkColor color) SK_OVERRIDE;
69
70    /** These are called inside the per-device-layer loop for each draw call.
71     When these are called, we have already applied any saveLayer operations,
72     and are handling any looping from the paint, and any effects from the
73     DrawFilter.
74     */
75    virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
76    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
77                            size_t count, const SkPoint[],
78                            const SkPaint& paint) SK_OVERRIDE;
79    virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint);
80    virtual void drawPath(const SkDraw&, const SkPath& origpath,
81                          const SkPaint& paint, const SkMatrix* prePathMatrix,
82                          bool pathIsMutable) SK_OVERRIDE;
83    virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
84                            const SkIRect* srcRectOrNull,
85                            const SkMatrix& matrix, const SkPaint&) SK_OVERRIDE;
86    virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap, int x, int y,
87                            const SkPaint& paint) SK_OVERRIDE;
88    virtual void drawText(const SkDraw&, const void* text, size_t len,
89                          SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
90    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
91                             const SkScalar pos[], SkScalar constY,
92                             int scalarsPerPos, const SkPaint&) SK_OVERRIDE;
93    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
94                                const SkPath& path, const SkMatrix* matrix,
95                                const SkPaint& paint) SK_OVERRIDE;
96    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
97                              int vertexCount, const SkPoint verts[],
98                              const SkPoint texs[], const SkColor colors[],
99                              SkXfermode* xmode, const uint16_t indices[],
100                              int indexCount, const SkPaint& paint) SK_OVERRIDE;
101    virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
102                            const SkPaint&) SK_OVERRIDE;
103
104    virtual void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
105    virtual void onDetachFromCanvas() SK_OVERRIDE;
106
107    enum DrawingArea {
108        kContent_DrawingArea,  // Drawing area for the page content.
109        kMargin_DrawingArea,   // Drawing area for the margin content.
110    };
111
112    /** Sets the drawing area for the device. Subsequent draw calls are directed
113     *  to the specific drawing area (margin or content). The default drawing
114     *  area is the content drawing area.
115     *
116     *  Currently if margin content is drawn and then a complex (for PDF) xfer
117     *  mode is used, like SrcIn, Clear, etc, the margin content will get
118     *  clipped. A simple way to avoid the bug is to always draw the margin
119     *  content last.
120     */
121    SK_API void setDrawingArea(DrawingArea drawingArea);
122
123    // PDF specific methods.
124
125    /** Returns the resource dictionary for this device.
126     */
127    SK_API SkPDFDict* getResourceDict();
128
129    /** Get the list of resources (PDF objects) used on this page.
130     *  @param resourceList A list to append the resources to.
131     *  @param recursive    If recursive is true, get the resources of the
132     *                      device's resources recursively. (Useful for adding
133     *                      objects to the catalog.)
134     */
135    SK_API void getResources(SkTDArray<SkPDFObject*>* resourceList,
136                             bool recursive) const;
137
138    /** Get the fonts used on this device.
139     */
140    SK_API const SkTDArray<SkPDFFont*>& getFontResources() const;
141
142    /** Returns a copy of the media box for this device. The caller is required
143     *  to unref() this when it is finished.
144     */
145    SK_API SkPDFArray* copyMediaBox() const;
146
147    /** Get the annotations from this page, or NULL if there are none.
148     */
149    SK_API SkPDFArray* getAnnotations() const { return fAnnotations; }
150
151    /** Returns a SkStream with the page contents.  The caller is responsible
152        for a reference to the returned value.
153        DEPRECATED: use copyContentToData()
154     */
155    SK_API SkStream* content() const;
156
157    /** Returns a SkStream with the page contents.  The caller is responsible
158     *  for calling data->unref() when it is finished.
159     */
160    SK_API SkData* copyContentToData() const;
161
162    SK_API const SkMatrix& initialTransform() const {
163        return fInitialTransform;
164    }
165
166    /** Returns a SkPDFGlyphSetMap which represents glyph usage of every font
167     *  that shows on this device.
168     */
169    const SkPDFGlyphSetMap& getFontGlyphUsage() const {
170        return *(fFontGlyphUsage.get());
171    }
172
173protected:
174    virtual bool onReadPixels(const SkBitmap& bitmap, int x, int y,
175                              SkCanvas::Config8888) SK_OVERRIDE;
176
177    virtual bool allowImageFilter(SkImageFilter*) SK_OVERRIDE;
178
179private:
180    // TODO(vandebo): push most of SkPDFDevice's state into a core object in
181    // order to get the right access levels without using friend.
182    friend class ScopedContentEntry;
183
184    SkISize fPageSize;
185    SkISize fContentSize;
186    SkMatrix fInitialTransform;
187    SkClipStack fExistingClipStack;
188    SkRegion fExistingClipRegion;
189    SkPDFArray* fAnnotations;
190    SkPDFDict* fResourceDict;
191
192    SkTDArray<SkPDFGraphicState*> fGraphicStateResources;
193    SkTDArray<SkPDFObject*> fXObjectResources;
194    SkTDArray<SkPDFFont*> fFontResources;
195    SkTDArray<SkPDFObject*> fShaderResources;
196
197    SkTScopedPtr<ContentEntry> fContentEntries;
198    ContentEntry* fLastContentEntry;
199    SkTScopedPtr<ContentEntry> fMarginContentEntries;
200    ContentEntry* fLastMarginContentEntry;
201    DrawingArea fDrawingArea;
202
203    const SkClipStack* fClipStack;
204
205    // Accessor and setter functions based on the current DrawingArea.
206    SkTScopedPtr<ContentEntry>* getContentEntries();
207    ContentEntry* getLastContentEntry();
208    void setLastContentEntry(ContentEntry* contentEntry);
209
210    // Glyph ids used for each font on this device.
211    SkTScopedPtr<SkPDFGlyphSetMap> fFontGlyphUsage;
212
213    SkPDFDevice(const SkISize& layerSize, const SkClipStack& existingClipStack,
214                const SkRegion& existingClipRegion);
215
216    // override from SkDevice
217    virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
218                                               int width, int height,
219                                               bool isOpaque,
220                                               Usage usage) SK_OVERRIDE;
221
222    void init();
223    void cleanUp(bool clearFontUsage);
224    SkPDFFormXObject* createFormXObjectFromDevice();
225
226    // Clear the passed clip from all existing content entries.
227    void clearClipFromContent(const SkClipStack* clipStack,
228                              const SkRegion& clipRegion);
229    void drawFormXObjectWithClip(SkPDFFormXObject* form,
230                                 const SkClipStack* clipStack,
231                                 const SkRegion& clipRegion,
232                                 bool invertClip);
233
234    // If the paint or clip is such that we shouldn't draw anything, this
235    // returns NULL and does not create a content entry.
236    // setUpContentEntry and finishContentEntry can be used directly, but
237    // the preferred method is to use the ScopedContentEntry helper class.
238    ContentEntry* setUpContentEntry(const SkClipStack* clipStack,
239                                    const SkRegion& clipRegion,
240                                    const SkMatrix& matrix,
241                                    const SkPaint& paint,
242                                    bool hasText,
243                                    SkPDFFormXObject** dst);
244    void finishContentEntry(SkXfermode::Mode xfermode,
245                            SkPDFFormXObject* dst);
246    bool isContentEmpty();
247
248    void populateGraphicStateEntryFromPaint(const SkMatrix& matrix,
249                                            const SkClipStack& clipStack,
250                                            const SkRegion& clipRegion,
251                                            const SkPaint& paint,
252                                            bool hasText,
253                                            GraphicStateEntry* entry);
254    int addGraphicStateResource(SkPDFGraphicState* gs);
255
256    void updateFont(const SkPaint& paint, uint16_t glyphID,
257                    ContentEntry* contentEntry);
258    int getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID);
259
260    void internalDrawPaint(const SkPaint& paint, ContentEntry* contentEntry);
261    void internalDrawBitmap(const SkMatrix& matrix,
262                            const SkClipStack* clipStack,
263                            const SkRegion& clipRegion,
264                            const SkBitmap& bitmap,
265                            const SkIRect* srcRect,
266                            const SkPaint& paint);
267
268    /** Helper method for copyContentToData. It is responsible for copying the
269     *  list of content entries |entry| to |data|.
270     */
271    void copyContentEntriesToData(ContentEntry* entry, SkWStream* data) const;
272
273    bool handleAnnotations(const SkRect& r, const SkMatrix& matrix,
274                           const SkPaint& paint);
275
276    typedef SkDevice INHERITED;
277};
278
279#endif
280