Split SkDevice into SkBaseDevice and SkBitmapDevice

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
 #define SkCanvas_DEFINED
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkClipStack.h"
 #include "SkPaint.h"
 #include "SkRefCnt.h"
 #include "SkPath.h"
 #include "SkRegion.h"
 #include "SkScalarCompare.h"
 #include "SkXfermode.h"
 
 class SkBounder;
-class SkDevice;
+class SkBaseDevice;
 class SkDraw;
 class SkDrawFilter;
 class SkMetaData;
 class SkPicture;
 class SkRRect;
 class SkSurface_Base;
 
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
@@ skipping 12 matching lines @@
 class SK_API SkCanvas : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkCanvas)
 
     SkCanvas();
 
     /** Construct a canvas with the specified device to draw into.
 
         @param device   Specifies a device for the canvas to draw into.
     */
-    explicit SkCanvas(SkDevice* device);
+    explicit SkCanvas(SkBaseDevice* device);
 
     /** Deprecated - Construct a canvas with the specified bitmap to draw into.
         @param bitmap   Specifies a bitmap for the canvas to draw into. Its
                         structure are copied to the canvas.
     */
     explicit SkCanvas(const SkBitmap& bitmap);
     virtual ~SkCanvas();
 
     SkMetaData& getMetaData();
 
     ///////////////////////////////////////////////////////////////////////////
 
     /**
      *  Trigger the immediate execution of all pending draw operations.
      */
     void flush();
 
     /**
      *  Return the width/height of the underlying device. The current drawable
      *  area may be small (due to clipping or saveLayer). For a canvas with
      *  no device, 0,0 will be returned.
      */
     SkISize getDeviceSize() const;
 
     /** Return the canvas' device object, which may be null. The device holds
         the bitmap of the pixels that the canvas draws into. The reference count
         of the returned device is not changed by this call.
     */
-    SkDevice* getDevice() const;
+    SkBaseDevice* getDevice() const;
 
     /**
      *  saveLayer() can create another device (which is later drawn onto
      *  the previous device). getTopDevice() returns the top-most device current
      *  installed. Note that this can change on other calls like save/restore,
      *  so do not access this device after subsequent canvas calls.
      *  The reference count of the device is not changed.
      *
      * @param updateMatrixClip If this is true, then before the device is
      *        returned, we ensure that its has been notified about the current
      *        matrix and clip. Note: this happens automatically when the device
      *        is drawn to, but is optional here, as there is a small perf hit
      *        sometimes.
      */
-    SkDevice* getTopDevice(bool updateMatrixClip = false) const;
+    SkBaseDevice* getTopDevice(bool updateMatrixClip = false) const;
 
     /**
      *  Shortcut for getDevice()->createCompatibleDevice(...).
      *  If getDevice() == NULL, this method does nothing, and returns NULL.
      */
-    SkDevice* createCompatibleDevice(SkBitmap::Config config,
-                                    int width, int height,
-                                    bool isOpaque);
+    SkBaseDevice* createCompatibleDevice(SkBitmap::Config config,
+                                         int width, int height,
+                                         bool isOpaque);
 
     ///////////////////////////////////////////////////////////////////////////
 
     /**
      * This enum can be used with read/writePixels to perform a pixel ops to or
      * from an 8888 config other than Skia's native config (SkPMColor). There
      * are three byte orders supported: native, BGRA, and RGBA. Each has a
      * premultiplied and unpremultiplied variant.
      *
      * Components of a 8888 pixel can be packed/unpacked from a 32bit word using
@@ skipping 866 matching lines @@
         LayerIter(SkCanvas*, bool skipEmptyClips);
         ~LayerIter();
 
         /** Return true if the iterator is done */
         bool done() const { return fDone; }
         /** Cycle to the next device */
         void next();
 
         // These reflect the current device in the iterator
 
-        SkDevice*       device() const;
+        SkBaseDevice*   device() const;
         const SkMatrix& matrix() const;
         const SkRegion& clip() const;
         const SkPaint&  paint() const;
         int             x() const;
         int             y() const;
 
     private:
         // used to embed the SkDrawIter object directly in our instance, w/o
         // having to expose that class def to the public. There is an assert
         // in our constructor to ensure that fStorage is large enough
@@ skipping 28 matching lines @@
 
     /** DEPRECATED -- use constructor(device)
 
      Marked as 'protected' to avoid new clients using this before we can
      completely remove it.
 
      Specify a device for this canvas to draw into. If it is not null, its
      reference count is incremented. If the canvas was already holding a
      device, its reference count is decremented. The new device is returned.
      */
-    virtual SkDevice* setDevice(SkDevice* device);
+    virtual SkBaseDevice* setDevice(SkBaseDevice* device);
 
 private:
     class MCRec;
 
     SkClipStack fClipStack;
     SkDeque     fMCStack;
     // points to top of stack
     MCRec*      fMCRec;
     // the first N recs that can fit here mean we won't call malloc
     uint32_t    fMCRecStorage[32];
@@ skipping 10 matching lines @@
     }
     friend class SkSurface_Base;
     friend class SkSurface_Gpu;
 
     bool fDeviceCMDirty;            // cleared by updateDeviceCMCache()
     void updateDeviceCMCache();
 
     friend class SkDrawIter;    // needs setupDrawForLayerDevice()
     friend class AutoDrawLooper;
 
-    SkDevice* createLayerDevice(SkBitmap::Config, int width, int height,
-                                bool isOpaque);
+    SkBaseDevice* createLayerDevice(SkBitmap::Config, int width, int height,
+                                    bool isOpaque);
 
-    SkDevice* init(SkDevice*);
+    SkBaseDevice* init(SkBaseDevice*);
 
     // 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,
                                 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*);
+    void internalDrawDevice(SkBaseDevice*, int x, int y, const SkPaint*);
 
     // shared by save() and saveLayer()
     int internalSave(SaveFlags flags);
     void internalRestore();
     static void DrawRect(const SkDraw& draw, const SkPaint& paint,
                          const SkRect& r, SkScalar textSize);
     static void DrawTextDecorations(const SkDraw& draw, const SkPaint& paint,
                                     const char text[], size_t byteLength,
                                     SkScalar x, SkScalar y);
 
@@ skipping 85 matching lines @@
         if (NULL != fCanvas) {
             fCanvas->endCommentGroup();
         }
     }
 
 private:
     SkCanvas* fCanvas;
 };
 
 #endif