src/third_party/skia/include/core/SkDrawLooper.h

   1
   2 /*
   3  * Copyright 2011 The Android Open Source Project
   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 SkDrawLooper_DEFINED
  11 #define SkDrawLooper_DEFINED
  12
  13 #include "SkBlurTypes.h"
  14 #include "SkFlattenable.h"
  15 #include "SkPoint.h"
  16 #include "SkColor.h"
  17
  18 class SkCanvas;
  19 class SkPaint;
  20 struct SkRect;
  21 class SkString;
  22
  23 /** \class SkDrawLooper
  24     Subclasses of SkDrawLooper can be attached to a SkPaint. Where they are,
  25     and something is drawn to a canvas with that paint, the looper subclass will
  26     be called, allowing it to modify the canvas and/or paint for that draw call.
  27     More than that, via the next() method, the looper can modify the draw to be
  28     invoked multiple times (hence the name loop-er), allow it to perform effects
  29     like shadows or frame/fills, that require more than one pass.
  30 */
  31 class SK_API SkDrawLooper : public SkFlattenable {
  32 public:
  33     SK_DECLARE_INST_COUNT(SkDrawLooper)
  34
  35     /**
  36      *  Holds state during a draw. Users call next() until it returns false.
  37      *
  38      *  Subclasses of SkDrawLooper should create a subclass of this object to
  39      *  hold state specific to their subclass.
  40      */
  41     class SK_API Context : ::SkNoncopyable {
  42     public:
  43         Context() {}
  44         virtual ~Context() {}
  45
  46         /**
  47          *  Called in a loop on objects returned by SkDrawLooper::createContext().
  48          *  Each time true is returned, the object is drawn (possibly with a modified
  49          *  canvas and/or paint). When false is finally returned, drawing for the object
  50          *  stops.
  51          *
  52          *  On each call, the paint will be in its original state, but the
  53          *  canvas will be as it was following the previous call to next() or
  54          *  createContext().
  55          *
  56          *  The implementation must ensure that, when next() finally returns
  57          *  false, the canvas has been restored to the state it was
  58          *  initially, before createContext() was first called.
  59          */
  60         virtual bool next(SkCanvas* canvas, SkPaint* paint) = 0;
  61     };
  62
  63     /**
  64      *  Called right before something is being drawn. Returns a Context
  65      *  whose next() method should be called until it returns false.
  66      *  The caller has to ensure that the storage pointer provides enough
  67      *  memory for the Context. The required size can be queried by calling
  68      *  contextSize(). It is also the caller's responsibility to destroy the
  69      *  object after use.
  70      */
  71     virtual Context* createContext(SkCanvas*, void* storage) const = 0;
  72
  73     /**
  74       *  Returns the number of bytes needed to store subclasses of Context (belonging to the
  75       *  corresponding SkDrawLooper subclass).
  76       */
  77     virtual size_t contextSize() const = 0;
  78
  79
  80     /**
  81      * The fast bounds functions are used to enable the paint to be culled early
  82      * in the drawing pipeline. If a subclass can support this feature it must
  83      * return true for the canComputeFastBounds() function.  If that function
  84      * returns false then computeFastBounds behavior is undefined otherwise it
  85      * is expected to have the following behavior. Given the parent paint and
  86      * the parent's bounding rect the subclass must fill in and return the
  87      * storage rect, where the storage rect is with the union of the src rect
  88      * and the looper's bounding rect.
  89      */
  90     virtual bool canComputeFastBounds(const SkPaint& paint) const;
  91     virtual void computeFastBounds(const SkPaint& paint,
  92                                    const SkRect& src, SkRect* dst) const;
  93
  94     struct BlurShadowRec {
  95         SkScalar        fSigma;
  96         SkVector        fOffset;
  97         SkColor         fColor;
  98         SkBlurStyle     fStyle;
  99         SkBlurQuality   fQuality;
 100     };
 101     /**
 102      *  If this looper can be interpreted as having two layers, such that
 103      *      1. The first layer (bottom most) just has a blur and translate
 104      *      2. The second layer has no modifications to either paint or canvas
 105      *      3. No other layers.
 106      *  then return true, and if not null, fill out the BlurShadowRec).
 107      *
 108      *  If any of the above are not met, return false and ignore the BlurShadowRec parameter.
 109      */
 110     virtual bool asABlurShadow(BlurShadowRec*) const;
 111
 112     SK_TO_STRING_PUREVIRT()
 113     SK_DEFINE_FLATTENABLE_TYPE(SkDrawLooper)
 114
 115 protected:
 116     SkDrawLooper() {}
 117 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
 118     SkDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) {}
 119 #endif
 120
 121 private:
 122     typedef SkFlattenable INHERITED;
 123 };
 124
 125 #endif