Home | History | Annotate | Download | only in pdf
      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 
     22 class SkPDFArray;
     23 class SkPDFDevice;
     24 class SkPDFDict;
     25 class SkPDFFont;
     26 class SkPDFFormXObject;
     27 class SkPDFGlyphSetMap;
     28 class SkPDFGraphicState;
     29 class SkPDFObject;
     30 class SkPDFShader;
     31 class SkPDFStream;
     32 
     33 // Private classes.
     34 struct ContentEntry;
     35 struct GraphicStateEntry;
     36 
     37 /** \class SkPDFDevice
     38 
     39     The drawing context for the PDF backend.
     40 */
     41 class SkPDFDevice : public SkDevice {
     42 public:
     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 
    173 protected:
    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 
    179 private:
    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