SkDevice* setBitmapDevice(const SkBitmap& bitmap, bool forLayer = false);
/**
+ * Return the current device factory, or NULL.
+ */
+ SkDeviceFactory* getDeviceFactory() const { return fDeviceFactory; }
+
+ /**
+ * Replace any existing factory with the specified factory.
+ */
+ SkDeviceFactory* setDeviceFactory(SkDeviceFactory*);
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ /**
* Copy the pixels from the device into bitmap. Returns true on success.
* If false is returned, then the bitmap parameter is left unchanged.
*/
* values in the device are completely replaced: there is no blending.
*/
void writePixels(const SkBitmap& bitmap, int x, int y);
-
+
///////////////////////////////////////////////////////////////////////////
enum SaveFlags {
@return true if the operation succeeded (e.g. did not overflow)
*/
virtual bool concat(const SkMatrix& matrix);
-
+
/** Replace the current matrix with a copy of the specified matrix.
@param matrix The matrix that will be copied into the current matrix.
*/
virtual void setMatrix(const SkMatrix& matrix);
-
+
/** Helper for setMatrix(identity). Sets the current matrix to identity.
*/
void resetMatrix();
details.
*/
void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint);
-
+
/** Draws a single pixel in the specified color.
@param x The X coordinate of which pixel to draw
@param y The Y coordiante of which pixel to draw
r.set(rect); // promotes the ints to scalars
this->drawRect(r, paint);
}
-
+
/** Draw the specified rectangle using the specified paint. The rectangle
will be filled or framed based on the Style in the paint.
@param left The left side of the rectangle to be drawn
virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
const SkPaint* paint = NULL);
-
+
/** Draw the specified bitmap, with its top/left corner at (x,y),
NOT transformed by the current matrix. Note: if the paint
contains a maskfilter that generates a mask which extends beyond the
SkScalar y, const SkPaint& paint);
/** Draw the text, with each character/glyph origin specified by the pos[]
- array. The origin is interpreted by the Align setting in the paint.
+ array. The origin is interpreted by the Align setting in the paint.
@param text The text to be drawn
@param byteLength The number of bytes to read from the text parameter
@param pos Array of positions, used to position each character
*/
virtual void drawPosText(const void* text, size_t byteLength,
const SkPoint pos[], const SkPaint& paint);
-
+
/** Draw the text, with each character/glyph origin specified by the x
coordinate taken from the xpos[] array, and the y from the constY param.
- The origin is interpreted by the Align setting in the paint.
+ The origin is interpreted by the Align setting in the paint.
@param text The text to be drawn
@param byteLength The number of bytes to read from the text parameter
@param xpos Array of x-positions, used to position each character
virtual void drawPosTextH(const void* text, size_t byteLength,
const SkScalar xpos[], SkScalar constY,
const SkPaint& paint);
-
+
/** Draw the text, with origin at (x,y), using the specified paint, along
the specified path. The paint's Align setting determins where along the
path to start the text.
canvas.
*/
virtual void drawPicture(SkPicture& picture);
-
+
/** Draws the specified shape
*/
virtual void drawShape(SkShape*);
kTriangleStrip_VertexMode,
kTriangleFan_VertexMode
};
-
+
/** Draw the array of vertices, interpreted as triangles (based on mode).
@param vmode How to interpret the array of vertices
@param vertexCount The number of points in the vertices array (and
@param indices If not null, array of indices to reference into the
vertex (texs, colors) array.
@param indexCount number of entries in the indices array (if not null)
- @param paint Specifies the shader/texture if present.
+ @param paint Specifies the shader/texture if present.
*/
virtual void drawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
virtual void drawData(const void* data, size_t length);
//////////////////////////////////////////////////////////////////////////
-
+
/** Get the current bounder object.
The bounder's reference count is unchaged.
@return the canva's bounder (or NULL).
@return the set bounder object
*/
virtual SkBounder* setBounder(SkBounder* bounder);
-
+
/** Get the current filter object. The filter's reference count is not
affected. The filter is saved/restored, just like the matrix and clip.
@return the canvas' filter (or NULL).
*/
SkDrawFilter* getDrawFilter() const;
-
+
/** Set the new filter (or NULL). Pass NULL to clear any existing filter.
As a convenience, the parameter is returned. If an existing filter
exists, its refcnt is decrement. If the new filter is not null, its
/** Initialize iterator with canvas, and set values for 1st device */
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;
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
// all of the drawBitmap variants call this guy
virtual void commonDrawBitmap(const SkBitmap&, const SkIRect*,
const SkMatrix&, const SkPaint& paint);
-
+
private:
class MCRec;
SkDeviceFactory* fDeviceFactory;
void prepareForDeviceDraw(SkDevice*, const SkMatrix&, const SkRegion&);
-
+
bool fDeviceCMDirty; // cleared by updateDeviceCMCache()
void updateDeviceCMCache();
// shared by save() and saveLayer()
int internalSave(SaveFlags flags);
void internalRestore();
-
+
/* These maintain a cache of the clip bounds in local coordinates,
(converted to 2s-compliment if floats are slow).
*/
device->ref();
device->lockPixels();
}
- fDevice = device;
+ fDevice = device;
fX = SkToS16(x);
fY = SkToS16(y);
fPaint = paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL;
}
SkDELETE(fPaint);
}
-
+
void updateMC(const SkMatrix& totalMatrix, const SkRegion& totalClip,
SkRegion* updateClip) {
int x = fX;
int y = fY;
int width = fDevice->width();
int height = fDevice->height();
-
+
if ((x | y) == 0) {
fMatrix = &totalMatrix;
fClip = totalClip;
fMatrixStorage.postTranslate(SkIntToScalar(-x),
SkIntToScalar(-y));
fMatrix = &fMatrixStorage;
-
+
totalClip.translate(-x, -y, &fClip);
}
fClip.op(0, 0, width, height, SkRegion::kIntersect_Op);
// intersect clip, but don't translate it (yet)
-
+
if (updateClip) {
updateClip->op(x, y, x + width, y + height,
SkRegion::kDifference_Op);
}
-
+
fDevice->setMatrixClip(*fMatrix, fClip);
#ifdef SK_DEBUG
SkMatrix* fMatrix; // points to either fMatrixStorage or prev MCRec
SkRegion* fRegion; // points to either fRegionStorage or prev MCRec
SkDrawFilter* fFilter; // the current filter (or null)
-
+
DeviceCM* fLayer;
/* If there are any layers in the stack, this points to the top-most
one that is at or below this level in the stack (so we know what
} else {
fMatrix = prev->fMatrix;
}
-
+
if (flags & SkCanvas::kClip_SaveFlag) {
fRegionStorage = *prev->fRegion;
fRegion = &fRegionStorage;
fTopLayer = prev->fTopLayer;
} else { // no prev
fMatrixStorage.reset();
-
+
fMatrix = &fMatrixStorage;
fRegion = &fRegionStorage;
fFilter = NULL;
SkDELETE(fLayer);
dec_rec();
}
-
+
private:
SkMatrix fMatrixStorage;
SkRegion fRegionStorage;
fCurrLayer = canvas->fMCRec->fTopLayer;
fSkipEmptyClips = skipEmptyClips;
}
-
+
bool next() {
// skip over recs with empty clips
if (fSkipEmptyClips) {
}
return false;
}
-
+
int getX() const { return fLayerX; }
int getY() const { return fLayerY; }
SkDevice* getDevice() const { return fDevice; }
fLooper->restore();
}
}
-
+
bool next() {
SkDrawFilter* filter = fFilter;
filter->restore(fCanvas, fPaint, fType);
fNeedFilterRestore = false;
}
-
+
bool result;
-
+
if (NULL != fLooper) {
result = fLooper->next();
} else {
}
return result;
}
-
+
private:
SkDrawLooper* fLooper;
SkDrawFilter* fFilter;
SkDrawFilter::Type fType;
bool fOnce;
bool fNeedFilterRestore;
-
+
};
/* Stack helper for managing a SkBounder. In the destructor, if we were
while (looper.next()) { \
SkAutoBounderCommit ac(fBounder); \
SkDrawIter iter(this);
-
+
#define ITER_END }
////////////////////////////////////////////////////////////////////////////
SkDevice* SkCanvas::getDevice() const {
// return root device
SkDeque::Iter iter(fMCStack);
- MCRec* rec = (MCRec*)iter.next();
+ MCRec* rec = (MCRec*)iter.next();
SkASSERT(rec && rec->fLayer);
return rec->fLayer->fDevice;
}
SkDevice* SkCanvas::setDevice(SkDevice* device) {
// return root device
SkDeque::Iter iter(fMCStack);
- MCRec* rec = (MCRec*)iter.next();
+ MCRec* rec = (MCRec*)iter.next();
SkASSERT(rec && rec->fLayer);
SkDevice* rootDevice = rec->fLayer->fDevice;
if (rootDevice == device) {
return device;
}
-
+
/* Notify the devices that they are going in/out of scope, so they can do
things like lock/unlock their pixels, etc.
*/
rootDevice = device;
fDeviceCMDirty = true;
-
+
/* Now we update our initial region to have the bounds of the new device,
and then intersect all of the clips in our stack with these bounds,
to ensure that we can't draw outside of the device's bounds (and trash
memory).
-
+
NOTE: this is only a partial-fix, since if the new device is larger than
the previous one, we don't know how to "enlarge" the clips in our stack,
- so drawing may be artificially restricted. Without keeping a history of
+ so drawing may be artificially restricted. Without keeping a history of
all calls to canvas->clipRect() and canvas->clipPath(), we can't exactly
reconstruct the correct clips, so this approximation will have to do.
The caller really needs to restore() back to the base if they want to
} else {
// compute our total bounds for all devices
SkIRect bounds;
-
+
bounds.set(0, 0, device->width(), device->height());
// now jam our 1st clip to be bounds, and intersect the rest with that
return device->readPixels(srcRect, bitmap);
}
+SkDeviceFactory* SkCanvas::setDeviceFactory(SkDeviceFactory* factory) {
+ SkDELETE(fDeviceFactory);
+ fDeviceFactory = factory;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
bool SkCanvas::readPixels(SkBitmap* bitmap) {
SkDevice* device = this->getDevice();
if (!device) {
const SkMatrix& totalMatrix = this->getTotalMatrix();
const SkRegion& totalClip = this->getTotalClip();
DeviceCM* layer = fMCRec->fTopLayer;
-
+
if (NULL == layer->fNext) { // only one layer
layer->updateMC(totalMatrix, totalClip, NULL);
if (fUseExternalMatrix) {
int SkCanvas::internalSave(SaveFlags flags) {
int saveCount = this->getSaveCount(); // record this before the actual save
-
+
MCRec* newTop = (MCRec*)fMCStack.push_back();
new (newTop) MCRec(fMCRec, flags); // balanced in restore()
-
+
newTop->fNext = fMCRec;
fMCRec = newTop;
-
+
return saveCount;
}
if (NULL != bounds) {
SkRect r;
-
+
this->getTotalMatrix().mapRect(&r, *bounds);
r.roundOut(&ir);
// early exit if the layer's bounds are clipped out
tmp.setDither(true);
paint = &tmp;
}
-
+
ITER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
while (iter.next()) {
iter.fDevice->drawDevice(iter, device, x - iter.getX(), y - iter.getY(),
// will see its action
void SkCanvas::resetMatrix() {
SkMatrix matrix;
-
+
matrix.reset();
this->setMatrix(matrix);
}
SkRegion base;
const SkBitmap& bm = this->getDevice()->accessBitmap(false);
base.setRect(0, 0, bm.width(), bm.height());
-
+
if (SkRegion::kReplace_Op == op) {
return fMCRec->fRegion->setPath(devPath, base);
} else {
if (fMCRec->fRegion->isEmpty()) {
return true;
}
-
+
SkScalarCompareType userT = SkScalarToCompareType(top);
SkScalarCompareType userB = SkScalarToCompareType(bottom);
-
+
// check for invalid user Y coordinates (i.e. empty)
// reed: why do we need to do this check, since it slows us down?
if (userT >= userB) {
return true;
}
-
+
// check if we are above or below the local clip bounds
const SkRectCompareType& clipR = this->getLocalClipBoundsCompareType();
return userT >= clipR.fBottom || userB <= clipR.fTop;
int inset = (kAA_EdgeType == et);
r.iset(ibounds.fLeft - inset, ibounds.fTop - inset,
ibounds.fRight + inset, ibounds.fBottom + inset);
-
+
// invert into local coordinates
inverse.mapRect(bounds, r);
}
} else {
fUseExternalMatrix = true;
fDeviceCMDirty = true; // |= (fExternalMatrix != *matrix)
-
+
fExternalMatrix = *matrix;
matrix->invert(&fExternalInverse);
}
-
+
static bool gUseExt;
if (gUseExt != fUseExternalMatrix && false) {
gUseExt = fUseExternalMatrix;
SkASSERT(pts != NULL);
ITER_BEGIN(paint, SkDrawFilter::kPoint_Type)
-
+
while (iter.next()) {
iter.fDevice->drawPoints(iter, mode, count, pts, paint);
}
-
+
ITER_END
}
return;
}
}
-
+
ITER_BEGIN(paint, SkDrawFilter::kRect_Type)
while (iter.next()) {
return;
}
}
-
+
SkMatrix matrix;
matrix.setTranslate(x, y);
this->internalDrawBitmap(bitmap, NULL, matrix, paint);
if (bitmap.width() == 0 || bitmap.height() == 0 || dst.isEmpty()) {
return;
}
-
+
// do this now, to avoid the cost of calling extract for RLE bitmaps
if (this->quickReject(dst, paint2EdgeType(paint))) {
return;
}
-
+
const SkBitmap* bitmapPtr = &bitmap;
-
+
SkMatrix matrix;
SkRect tmpSrc;
if (src) {
void SkCanvas::drawSprite(const SkBitmap& bitmap, int x, int y,
const SkPaint* paint) {
SkDEBUGCODE(bitmap.validate();)
-
+
if (reject_bitmap(bitmap)) {
return;
}
-
+
SkPaint tmp;
if (NULL == paint) {
paint = &tmp;
}
-
+
ITER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
-
+
while (iter.next()) {
iter.fDevice->drawSprite(iter, bitmap, x - iter.getX(), y - iter.getY(),
*paint);
void SkCanvas::drawPosText(const void* text, size_t byteLength,
const SkPoint pos[], const SkPaint& paint) {
ITER_BEGIN(paint, SkDrawFilter::kText_Type)
-
+
while (iter.next()) {
iter.fDevice->drawPosText(iter, text, byteLength, &pos->fX, 0, 2,
paint);
}
-
+
ITER_END
}
const SkScalar xpos[], SkScalar constY,
const SkPaint& paint) {
ITER_BEGIN(paint, SkDrawFilter::kText_Type)
-
+
while (iter.next()) {
iter.fDevice->drawPosText(iter, text, byteLength, xpos, constY, 1,
paint);
}
-
+
ITER_END
}
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
ITER_BEGIN(paint, SkDrawFilter::kPath_Type)
-
+
while (iter.next()) {
iter.fDevice->drawVertices(iter, vmode, vertexCount, verts, texs,
colors, xmode, indices, indexCount, paint);
}
-
+
ITER_END
}
void SkCanvas::drawPoint(SkScalar x, SkScalar y, const SkPaint& paint) {
SkPoint pt;
-
+
pt.set(x, y);
this->drawPoints(kPoints_PointMode, 1, &pt, paint);
}
void SkCanvas::drawPoint(SkScalar x, SkScalar y, SkColor color) {
SkPoint pt;
SkPaint paint;
-
+
pt.set(x, y);
paint.setColor(color);
this->drawPoints(kPoints_PointMode, 1, &pt, paint);
void SkCanvas::drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1,
const SkPaint& paint) {
SkPoint pts[2];
-
+
pts[0].set(x0, y0);
pts[1].set(x1, y1);
this->drawPoints(kLines_PointMode, 2, pts, paint);
SkRect r;
r.set(cx - radius, cy - radius, cx + radius, cy + radius);
-
+
if (paint.canComputeFastBounds()) {
SkRect storage;
if (this->quickReject(paint.computeFastBounds(r, &storage),
return;
}
}
-
+
SkPath path;
path.addOval(r);
this->drawPath(path, paint);
const SkPath& path, SkScalar hOffset,
SkScalar vOffset, const SkPaint& paint) {
SkMatrix matrix;
-
+
matrix.setTranslate(hOffset, vOffset);
this->drawTextOnPath(text, byteLength, path, &matrix, paint);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff