src/third_party/skia/include/pdf/SkPDFDevice.h

   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
  25 class SkPDFArray;
  26 class SkPDFDevice;
  27 class SkPDFDict;
  28 class SkPDFFont;
  29 class SkPDFFormXObject;
  30 class SkPDFGlyphSetMap;
  31 class SkPDFGraphicState;
  32 class SkPDFObject;
  33 class SkPDFResourceDict;
  34 class SkPDFShader;
  35 class SkPDFStream;
  36 class SkRRect;
  37 template <typename T> class SkTSet;
  38
  39 // Private classes.
  40 struct ContentEntry;
  41 struct GraphicStateEntry;
  42 struct NamedDestination;
  43
  44 /** \class SkPDFDevice
  45
  46     The drawing context for the PDF backend.
  47 */
  48 class SkPDFDevice : public SkBaseDevice {
  49 public:
  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
 211 protected:
 212     virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE {
 213         return fLegacyBitmap;
 214     }
 215
 216     virtual SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
 217
 218 private:
 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