Plumb in "bleed" flag

include/core/SkCanvas.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkCanvas_DEFINED
@@ skipping 649 matching lines @@
         were in a Shader with CLAMP mode. Thus the color outside of the original
         width/height will be the edge color replicated.
         @param bitmap   The bitmap to be drawn
         @param left     The position of the left side of the bitmap being drawn
         @param top      The position of the top side of the bitmap being drawn
         @param paint    The paint used to draw the bitmap, or NULL
     */
     virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                             const SkPaint* paint = NULL);
 
+    enum DrawBitmapRectFlags {
+        kNone_DrawBitmapRectflag            = 0x0,

[reed1, 2013/07/29 15:53:35]

kClamp instead of kNone?

+        /** 
+         *  When filtering is enabled, allow the color samples outside of
+         *  the src rect (but still in the src bitmap) to bleed into the 
+         *  drawn portion
+         */
+        kBleed_DrawBitmapRectFlag            = 0x1,
+    };
+
     /** Draw the specified bitmap, with the specified matrix applied (before the
         canvas' matrix is applied).
         @param bitmap   The bitmap to be drawn
         @param src      Optional: specify the subset of the bitmap to be drawn
         @param dst      The destination rectangle where the scaled/translated
                         image will be drawn
         @param paint    The paint used to draw the bitmap, or NULL
     */
     virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
                                       const SkRect& dst,
-                                      const SkPaint* paint);
+                                      const SkPaint* paint = NULL,
+                                      DrawBitmapRectFlags flags = kNone_DrawBitmapRectflag);
 
     void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst,
-                        const SkPaint* paint) {
-        this->drawBitmapRectToRect(bitmap, NULL, dst, paint);
+                        const SkPaint* paint = NULL) {
+        this->drawBitmapRectToRect(bitmap, NULL, dst, paint, kNone_DrawBitmapRectflag);
     }
 
     void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* isrc,
-                        const SkRect& dst, const SkPaint* paint = NULL) {
+                        const SkRect& dst, const SkPaint* paint = NULL,
+                        DrawBitmapRectFlags flags = kNone_DrawBitmapRectflag) {
         SkRect realSrcStorage;
         SkRect* realSrcPtr = NULL;
         if (isrc) {
             realSrcStorage.set(*isrc);
             realSrcPtr = &realSrcStorage;
         }
-        this->drawBitmapRectToRect(bitmap, realSrcPtr, dst, paint);
+        this->drawBitmapRectToRect(bitmap, realSrcPtr, dst, paint, flags);
     }
 
     virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
                                   const SkPaint* paint = NULL);
 
     /**
      *  Draw the bitmap stretched differentially to fit into dst.
      *  center is a rect within the bitmap, and logically divides the bitmap
      *  into 9 sections (3x3). For example, if the middle pixel of a [5x5]
      *  bitmap is the "center", then the center-rect should be [2, 2, 3, 3].
@@ skipping 352 matching lines @@
 
     SkDevice* createLayerDevice(SkBitmap::Config, int width, int height,
                                 bool isOpaque);
 
     SkDevice* init(SkDevice*);
 
     // internal methods are not virtual, so they can safely be called by other
     // canvas apis, without confusing subclasses (like SkPictureRecording)
     void internalDrawBitmap(const SkBitmap&, const SkMatrix& m, const SkPaint* paint);
     void internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
-                                const SkRect& dst, const SkPaint* paint);
+                                const SkRect& dst, const SkPaint* paint,
+                                DrawBitmapRectFlags flags);
     void internalDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
                                 const SkRect& dst, const SkPaint* paint);
     void internalDrawPaint(const SkPaint& paint);
     int internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
                           SaveFlags, bool justForImageFilter);
     void internalDrawDevice(SkDevice*, int x, int y, const SkPaint*);
 
     // shared by save() and saveLayer()
     int internalSave(SaveFlags flags);
     void internalRestore();
@@ skipping 91 matching lines @@
         if (NULL != fCanvas) {
             fCanvas->endCommentGroup();
         }
     }
 
 private:
     SkCanvas* fCanvas;
 };
 
 #endif