315 lines
12 KiB
C++
315 lines
12 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef SkDevice_DEFINED
|
|
#define SkDevice_DEFINED
|
|
|
|
#include "SkRefCnt.h"
|
|
#include "SkBitmap.h"
|
|
#include "SkCanvas.h"
|
|
#include "SkColor.h"
|
|
|
|
class SkClipStack;
|
|
class SkDevice;
|
|
class SkDraw;
|
|
struct SkIRect;
|
|
class SkMatrix;
|
|
class SkMetaData;
|
|
class SkRegion;
|
|
|
|
/** \class SkDeviceFactory
|
|
|
|
Devices that extend SkDevice should also provide a SkDeviceFactory class
|
|
to pass into SkCanvas. Doing so will eliminate the need to extend
|
|
SkCanvas as well.
|
|
*/
|
|
class SK_API SkDeviceFactory : public SkRefCnt {
|
|
public:
|
|
SkDeviceFactory();
|
|
virtual ~SkDeviceFactory();
|
|
virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
|
|
int height, bool isOpaque, bool isLayer) = 0;
|
|
};
|
|
|
|
class SkRasterDeviceFactory : public SkDeviceFactory {
|
|
public:
|
|
virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
|
|
int height, bool isOpaque, bool isLayer);
|
|
};
|
|
|
|
class SK_API SkDevice : public SkRefCnt {
|
|
public:
|
|
SkDevice(SkCanvas*);
|
|
/** Construct a new device, extracting the width/height/config/isOpaque values from
|
|
the bitmap. If transferPixelOwnership is true, and the bitmap claims to own its
|
|
own pixels (getOwnsPixels() == true), then transfer this responsibility to the
|
|
device, and call setOwnsPixels(false) on the bitmap.
|
|
|
|
Subclasses may override the destructor, which is virtual, even though this class
|
|
doesn't have one. SkRefCnt does.
|
|
|
|
@param bitmap A copy of this bitmap is made and stored in the device
|
|
*/
|
|
SkDevice(SkCanvas*, const SkBitmap& bitmap, bool forOffscreen);
|
|
virtual ~SkDevice();
|
|
|
|
/**
|
|
* Return the factory that will create this subclass of SkDevice.
|
|
* The returned factory is cached by the device, and so its reference count
|
|
* is not changed by this call.
|
|
*/
|
|
SkDeviceFactory* getDeviceFactory();
|
|
|
|
enum Capabilities {
|
|
kGL_Capability = 0x1, //!< mask indicating GL support
|
|
kVector_Capability = 0x2, //!< mask indicating a vector representation
|
|
kAll_Capabilities = 0x3
|
|
};
|
|
virtual uint32_t getDeviceCapabilities() { return 0; }
|
|
|
|
/** Return the width of the device (in pixels).
|
|
*/
|
|
virtual int width() const { return fBitmap.width(); }
|
|
/** Return the height of the device (in pixels).
|
|
*/
|
|
virtual int height() const { return fBitmap.height(); }
|
|
|
|
/**
|
|
* Return the device's origin: its offset in device coordinates from
|
|
* the default origin in its canvas' matrix/clip
|
|
*/
|
|
const SkIPoint& getOrigin() const { return fOrigin; }
|
|
|
|
/** Return the bitmap config of the device's pixels
|
|
*/
|
|
SkBitmap::Config config() const { return fBitmap.getConfig(); }
|
|
/** Returns true if the device's bitmap's config treats every pixels as
|
|
implicitly opaque.
|
|
*/
|
|
bool isOpaque() const { return fBitmap.isOpaque(); }
|
|
|
|
/** Return the bounds of the device
|
|
*/
|
|
void getBounds(SkIRect* bounds) const;
|
|
|
|
/** Return true if the specified rectangle intersects the bounds of the
|
|
device. If sect is not NULL and there is an intersection, sect returns
|
|
the intersection.
|
|
*/
|
|
bool intersects(const SkIRect& r, SkIRect* sect = NULL) const;
|
|
|
|
/** Return the bitmap associated with this device. Call this each time you need
|
|
to access the bitmap, as it notifies the subclass to perform any flushing
|
|
etc. before you examine the pixels.
|
|
@param changePixels set to true if the caller plans to change the pixels
|
|
@return the device's bitmap
|
|
*/
|
|
const SkBitmap& accessBitmap(bool changePixels);
|
|
|
|
/** Clears the entire device to the specified color (including alpha).
|
|
* Ignores the clip.
|
|
*/
|
|
virtual void clear(SkColor color);
|
|
|
|
/**
|
|
* Deprecated name for clear.
|
|
*/
|
|
void eraseColor(SkColor eraseColor) { this->clear(eraseColor); }
|
|
|
|
/** Called when this device is installed into a Canvas. Balanaced by a call
|
|
to unlockPixels() when the device is removed from a Canvas.
|
|
*/
|
|
virtual void lockPixels();
|
|
virtual void unlockPixels();
|
|
|
|
/** Return the device's associated texture, or NULL. If returned, it may be
|
|
drawn into another device
|
|
*/
|
|
virtual SkGpuTexture* accessTexture() { return NULL; }
|
|
|
|
/**
|
|
* Called with the correct matrix and clip before this device is drawn
|
|
* to using those settings. If your subclass overrides this, be sure to
|
|
* call through to the base class as well.
|
|
*
|
|
* The clipstack is another view of the clip. It records the actual
|
|
* geometry that went into building the region. It is present for devices
|
|
* that want to parse it, but is not required: the region is a complete
|
|
* picture of the current clip. (i.e. if you regionize all of the geometry
|
|
* in the clipstack, you will arrive at an equivalent region to the one
|
|
* passed in).
|
|
*/
|
|
virtual void setMatrixClip(const SkMatrix&, const SkRegion&,
|
|
const SkClipStack&);
|
|
|
|
/**
|
|
* Observer interface for listening to the calls to
|
|
* SkDevice::setMatrixClip(...). Users of SkDevice instances should
|
|
* implement matrixClipChanged(...) to receive notifications.
|
|
*/
|
|
class SkMatrixClipObserver : public SkRefCnt {
|
|
public:
|
|
virtual void matrixClipChanged(const SkMatrix&, const SkRegion&,
|
|
const SkClipStack&) = 0;
|
|
};
|
|
|
|
/** Assign the clip observer. Note that an extra reference is added to the
|
|
* observer, and removed at SkDevice construction, or re-assignment of a
|
|
* different observer.
|
|
*/
|
|
void setMatrixClipObserver(SkMatrixClipObserver* observer);
|
|
|
|
/** Return the device's associated SkMatrixClipObserver, or NULL.
|
|
* If non-null is returned, the reference count of the object is not
|
|
* modified.
|
|
*/
|
|
SkMatrixClipObserver* getMatrixClipObserver() const {
|
|
return fMatrixClipObserver;
|
|
}
|
|
|
|
/** Called when this device gains focus (i.e becomes the current device
|
|
for drawing).
|
|
*/
|
|
virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&,
|
|
const SkClipStack&) {}
|
|
|
|
/** Causes any deferred drawing to the device to be completed.
|
|
*/
|
|
virtual void flush() {}
|
|
|
|
/**
|
|
* Copy the pixels from the device into bitmap. Returns true on success.
|
|
* If false is returned, then the bitmap parameter is left unchanged.
|
|
* The bitmap parameter is treated as output-only, and will be completely
|
|
* overwritten (if the method returns true).
|
|
*/
|
|
virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
|
|
|
|
/**
|
|
* Similar to draw sprite, this method will copy the pixels in bitmap onto
|
|
* the device, with the top/left corner specified by (x, y). The pixel
|
|
* values in the device are completely replaced: there is no blending.
|
|
*/
|
|
virtual void writePixels(const SkBitmap& bitmap, int x, int y);
|
|
|
|
/** These are called inside the per-device-layer loop for each draw call.
|
|
When these are called, we have already applied any saveLayer operations,
|
|
and are handling any looping from the paint, and any effects from the
|
|
DrawFilter.
|
|
*/
|
|
virtual void drawPaint(const SkDraw&, const SkPaint& paint);
|
|
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
|
|
const SkPoint[], const SkPaint& paint);
|
|
virtual void drawRect(const SkDraw&, const SkRect& r,
|
|
const SkPaint& paint);
|
|
/**
|
|
* If pathIsMutable, then the implementation is allowed to cast path to a
|
|
* non-const pointer and modify it in place (as an optimization). Canvas
|
|
* may do this to implement helpers such as drawOval, by placing a temp
|
|
* path on the stack to hold the representation of the oval.
|
|
*
|
|
* If prePathMatrix is not null, it should logically be applied before any
|
|
* stroking or other effects. If there are no effects on the paint that
|
|
* affect the geometry/rasterization, then the pre matrix can just be
|
|
* pre-concated with the current matrix.
|
|
*/
|
|
virtual void drawPath(const SkDraw&, const SkPath& path,
|
|
const SkPaint& paint,
|
|
const SkMatrix* prePathMatrix = NULL,
|
|
bool pathIsMutable = false);
|
|
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
|
|
const SkIRect* srcRectOrNull,
|
|
const SkMatrix& matrix, const SkPaint& paint);
|
|
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
|
|
int x, int y, const SkPaint& paint);
|
|
virtual void drawText(const SkDraw&, const void* text, size_t len,
|
|
SkScalar x, SkScalar y, const SkPaint& paint);
|
|
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
|
|
const SkScalar pos[], SkScalar constY,
|
|
int scalarsPerPos, const SkPaint& paint);
|
|
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
|
|
const SkPath& path, const SkMatrix* matrix,
|
|
const SkPaint& paint);
|
|
#ifdef ANDROID
|
|
virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
|
|
const SkPoint pos[], const SkPaint& paint,
|
|
const SkPath& path, const SkMatrix* matrix);
|
|
#endif
|
|
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
|
|
const SkPoint verts[], const SkPoint texs[],
|
|
const SkColor colors[], SkXfermode* xmode,
|
|
const uint16_t indices[], int indexCount,
|
|
const SkPaint& paint);
|
|
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
|
|
const SkPaint&);
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
SkMetaData& getMetaData();
|
|
|
|
struct TextFlags {
|
|
uint32_t fFlags; // SkPaint::getFlags()
|
|
SkPaint::Hinting fHinting;
|
|
};
|
|
|
|
/**
|
|
* Device may filter the text flags for drawing text here. If it wants to
|
|
* make a change to the specified values, it should write them into the
|
|
* textflags parameter (output) and return true. If the paint is fine as
|
|
* is, then ignore the textflags parameter and return false.
|
|
*
|
|
* The baseclass SkDevice filters based on its depth and blitters.
|
|
*/
|
|
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*);
|
|
|
|
protected:
|
|
/**
|
|
* subclasses must override this to return a new (or ref'd) instance of
|
|
* a device factory that will create this subclass of device. This value
|
|
* is cached, so it should get called at most once for a given instance.
|
|
*/
|
|
virtual SkDeviceFactory* onNewDeviceFactory();
|
|
|
|
/** Update as needed the pixel value in the bitmap, so that the caller can access
|
|
the pixels directly. Note: only the pixels field should be altered. The config/width/height/rowbytes
|
|
must remain unchanged.
|
|
*/
|
|
virtual void onAccessBitmap(SkBitmap*);
|
|
|
|
SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
|
|
// just for subclasses, to assign a custom pixelref
|
|
SkPixelRef* setPixelRef(SkPixelRef* pr, size_t offset) {
|
|
fBitmap.setPixelRef(pr, offset);
|
|
return pr;
|
|
}
|
|
|
|
private:
|
|
friend class SkCanvas;
|
|
// just called by SkCanvas when built as a layer
|
|
void setOrigin(int x, int y) { fOrigin.set(x, y); }
|
|
|
|
SkCanvas* fCanvas;
|
|
SkBitmap fBitmap;
|
|
SkIPoint fOrigin;
|
|
SkMetaData* fMetaData;
|
|
|
|
SkMatrixClipObserver* fMatrixClipObserver;
|
|
|
|
SkDeviceFactory* fCachedDeviceFactory;
|
|
};
|
|
|
|
#endif
|