epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
robertphillips@google.com | 53238bc | 2013-08-30 13:12:10 +0000 | [diff] [blame] | 7 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 8 | #include "SkDevice.h" |
reed | e010f1c | 2014-09-17 10:49:38 -0700 | [diff] [blame] | 9 | #include "SkDeviceProperties.h" |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 10 | #include "SkDraw.h" |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 11 | #include "SkDrawFilter.h" |
reed@google.com | a7d9485 | 2011-03-30 21:23:07 +0000 | [diff] [blame] | 12 | #include "SkMetaData.h" |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 13 | #include "SkPatchUtils.h" |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 14 | #include "SkPathMeasure.h" |
| 15 | #include "SkRasterClip.h" |
fmalita | 8483326 | 2014-09-19 11:40:51 -0700 | [diff] [blame] | 16 | #include "SkShader.h" |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 17 | #include "SkTextBlob.h" |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 18 | #include "SkTextToPathIter.h" |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 19 | |
robertphillips@google.com | 1f2f338 | 2013-08-29 11:54:56 +0000 | [diff] [blame] | 20 | SkBaseDevice::SkBaseDevice() |
reed | 4a8126e | 2014-09-22 07:29:03 -0700 | [diff] [blame] | 21 | : fLeakyProperties(SkNEW_ARGS(SkDeviceProperties, (SkDeviceProperties::kLegacyLCD_InitType))) |
bungeman@google.com | 532470f | 2013-01-22 19:25:14 +0000 | [diff] [blame] | 22 | #ifdef SK_DEBUG |
| 23 | , fAttachedToCanvas(false) |
robertphillips@google.com | 40a1ae4 | 2012-07-13 15:36:15 +0000 | [diff] [blame] | 24 | #endif |
| 25 | { |
reed@google.com | af951c9 | 2011-06-16 19:10:39 +0000 | [diff] [blame] | 26 | fOrigin.setZero(); |
| 27 | fMetaData = NULL; |
robertphillips@google.com | 1f2f338 | 2013-08-29 11:54:56 +0000 | [diff] [blame] | 28 | } |
| 29 | |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 30 | SkBaseDevice::SkBaseDevice(const SkDeviceProperties& dp) |
| 31 | : fLeakyProperties(SkNEW_ARGS(SkDeviceProperties, (dp))) |
| 32 | #ifdef SK_DEBUG |
| 33 | , fAttachedToCanvas(false) |
| 34 | #endif |
| 35 | { |
| 36 | fOrigin.setZero(); |
| 37 | fMetaData = NULL; |
| 38 | } |
| 39 | |
robertphillips@google.com | 1f2f338 | 2013-08-29 11:54:56 +0000 | [diff] [blame] | 40 | SkBaseDevice::~SkBaseDevice() { |
reed | e010f1c | 2014-09-17 10:49:38 -0700 | [diff] [blame] | 41 | SkDELETE(fLeakyProperties); |
| 42 | SkDELETE(fMetaData); |
reed@google.com | a7d9485 | 2011-03-30 21:23:07 +0000 | [diff] [blame] | 43 | } |
| 44 | |
robertphillips@google.com | 1f2f338 | 2013-08-29 11:54:56 +0000 | [diff] [blame] | 45 | SkMetaData& SkBaseDevice::getMetaData() { |
reed@google.com | a7d9485 | 2011-03-30 21:23:07 +0000 | [diff] [blame] | 46 | // metadata users are rare, so we lazily allocate it. If that changes we |
| 47 | // can decide to just make it a field in the device (rather than a ptr) |
| 48 | if (NULL == fMetaData) { |
| 49 | fMetaData = new SkMetaData; |
| 50 | } |
| 51 | return *fMetaData; |
| 52 | } |
| 53 | |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 54 | SkImageInfo SkBaseDevice::imageInfo() const { |
reed | f252f64 | 2014-06-14 04:24:56 -0700 | [diff] [blame] | 55 | return SkImageInfo::MakeUnknown(); |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 56 | } |
| 57 | |
robertphillips@google.com | 1f2f338 | 2013-08-29 11:54:56 +0000 | [diff] [blame] | 58 | const SkBitmap& SkBaseDevice::accessBitmap(bool changePixels) { |
| 59 | const SkBitmap& bitmap = this->onAccessBitmap(); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 60 | if (changePixels) { |
junov@chromium.org | 1f9767c | 2012-02-07 16:27:57 +0000 | [diff] [blame] | 61 | bitmap.notifyPixelsChanged(); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 62 | } |
junov@chromium.org | 1f9767c | 2012-02-07 16:27:57 +0000 | [diff] [blame] | 63 | return bitmap; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 64 | } |
| 65 | |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 66 | SkPixelGeometry SkBaseDevice::CreateInfo::AdjustGeometry(const SkImageInfo& info, |
reed | 1182d9a | 2015-03-13 07:16:09 -0700 | [diff] [blame^] | 67 | TileUsage tileUsage, |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 68 | SkPixelGeometry geo) { |
reed | 1182d9a | 2015-03-13 07:16:09 -0700 | [diff] [blame^] | 69 | switch (tileUsage) { |
| 70 | case kPossible_TileUsage: |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 71 | break; |
reed | 1182d9a | 2015-03-13 07:16:09 -0700 | [diff] [blame^] | 72 | case kNever_TileUsage: |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 73 | if (info.alphaType() != kOpaque_SkAlphaType) { |
| 74 | geo = kUnknown_SkPixelGeometry; |
| 75 | } |
| 76 | break; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 77 | } |
| 78 | return geo; |
| 79 | } |
| 80 | |
| 81 | void SkBaseDevice::initForRootLayer(SkPixelGeometry geo) { |
| 82 | // For now we don't expect to change the geometry for the root-layer, but we make the call |
| 83 | // anyway to document logically what is going on. |
| 84 | // |
| 85 | fLeakyProperties->setPixelGeometry(CreateInfo::AdjustGeometry(this->imageInfo(), |
reed | 1182d9a | 2015-03-13 07:16:09 -0700 | [diff] [blame^] | 86 | kPossible_TileUsage, |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 87 | geo)); |
reed | 4a8126e | 2014-09-22 07:29:03 -0700 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | SkSurface* SkBaseDevice::newSurface(const SkImageInfo&, const SkSurfaceProps&) { return NULL; } |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 91 | |
| 92 | const void* SkBaseDevice::peekPixels(SkImageInfo*, size_t*) { return NULL; } |
commit-bot@chromium.org | ed9806f | 2014-02-21 02:32:36 +0000 | [diff] [blame] | 93 | |
| 94 | void SkBaseDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer, |
| 95 | const SkRRect& inner, const SkPaint& paint) { |
| 96 | SkPath path; |
| 97 | path.addRRect(outer); |
| 98 | path.addRRect(inner); |
| 99 | path.setFillType(SkPath::kEvenOdd_FillType); |
| 100 | |
| 101 | const SkMatrix* preMatrix = NULL; |
| 102 | const bool pathIsMutable = true; |
| 103 | this->drawPath(draw, path, paint, preMatrix, pathIsMutable); |
| 104 | } |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 105 | |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 106 | void SkBaseDevice::drawPatch(const SkDraw& draw, const SkPoint cubics[12], const SkColor colors[4], |
| 107 | const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) { |
| 108 | SkPatchUtils::VertexData data; |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 109 | |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 110 | SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, draw.fMatrix); |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 111 | |
| 112 | // It automatically adjusts lodX and lodY in case it exceeds the number of indices. |
dandov | 45f7842 | 2014-08-15 06:06:47 -0700 | [diff] [blame] | 113 | // If it fails to generate the vertices, then we do not draw. |
| 114 | if (SkPatchUtils::getVertexData(&data, cubics, colors, texCoords, lod.width(), lod.height())) { |
| 115 | this->drawVertices(draw, SkCanvas::kTriangles_VertexMode, data.fVertexCount, data.fPoints, |
| 116 | data.fTexCoords, data.fColors, xmode, data.fIndices, data.fIndexCount, |
| 117 | paint); |
| 118 | } |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 119 | } |
| 120 | |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 121 | void SkBaseDevice::drawTextBlob(const SkDraw& draw, const SkTextBlob* blob, SkScalar x, SkScalar y, |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 122 | const SkPaint &paint, SkDrawFilter* drawFilter) { |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 123 | |
fmalita | 8483326 | 2014-09-19 11:40:51 -0700 | [diff] [blame] | 124 | SkPaint runPaint = paint; |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 125 | |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 126 | SkTextBlob::RunIterator it(blob); |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 127 | for (;!it.done(); it.next()) { |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 128 | size_t textLen = it.glyphCount() * sizeof(uint16_t); |
| 129 | const SkPoint& offset = it.offset(); |
| 130 | // applyFontToPaint() always overwrites the exact same attributes, |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 131 | // so it is safe to not re-seed the paint for this reason. |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 132 | it.applyFontToPaint(&runPaint); |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 133 | |
| 134 | if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) { |
| 135 | // A false return from filter() means we should abort the current draw. |
| 136 | runPaint = paint; |
| 137 | continue; |
| 138 | } |
| 139 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 140 | runPaint.setFlags(this->filterTextFlags(runPaint)); |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 141 | |
| 142 | switch (it.positioning()) { |
| 143 | case SkTextBlob::kDefault_Positioning: |
fmalita | 05c4a43 | 2014-09-29 06:29:53 -0700 | [diff] [blame] | 144 | this->drawText(draw, it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint); |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 145 | break; |
| 146 | case SkTextBlob::kHorizontal_Positioning: |
fmalita | 05c4a43 | 2014-09-29 06:29:53 -0700 | [diff] [blame] | 147 | this->drawPosText(draw, it.glyphs(), textLen, it.pos(), 1, |
| 148 | SkPoint::Make(x, y + offset.y()), runPaint); |
| 149 | break; |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 150 | case SkTextBlob::kFull_Positioning: |
fmalita | 05c4a43 | 2014-09-29 06:29:53 -0700 | [diff] [blame] | 151 | this->drawPosText(draw, it.glyphs(), textLen, it.pos(), 2, |
| 152 | SkPoint::Make(x, y), runPaint); |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 153 | break; |
| 154 | default: |
| 155 | SkFAIL("unhandled positioning mode"); |
| 156 | } |
| 157 | |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 158 | if (drawFilter) { |
| 159 | // A draw filter may change the paint arbitrarily, so we must re-seed in this case. |
| 160 | runPaint = paint; |
| 161 | } |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 162 | } |
| 163 | } |
| 164 | |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 165 | bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) { |
| 166 | #ifdef SK_DEBUG |
| 167 | SkASSERT(info.width() > 0 && info.height() > 0); |
| 168 | SkASSERT(dstP); |
| 169 | SkASSERT(rowBytes >= info.minRowBytes()); |
| 170 | SkASSERT(x >= 0 && y >= 0); |
skia.committer@gmail.com | db0c875 | 2014-03-18 03:02:11 +0000 | [diff] [blame] | 171 | |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 172 | const SkImageInfo& srcInfo = this->imageInfo(); |
| 173 | SkASSERT(x + info.width() <= srcInfo.width()); |
| 174 | SkASSERT(y + info.height() <= srcInfo.height()); |
| 175 | #endif |
| 176 | return this->onReadPixels(info, dstP, rowBytes, x, y); |
| 177 | } |
| 178 | |
commit-bot@chromium.org | 4ef54f8 | 2014-03-17 17:03:18 +0000 | [diff] [blame] | 179 | bool SkBaseDevice::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, |
| 180 | int x, int y) { |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 181 | #ifdef SK_DEBUG |
| 182 | SkASSERT(info.width() > 0 && info.height() > 0); |
| 183 | SkASSERT(pixels); |
| 184 | SkASSERT(rowBytes >= info.minRowBytes()); |
| 185 | SkASSERT(x >= 0 && y >= 0); |
| 186 | |
| 187 | const SkImageInfo& dstInfo = this->imageInfo(); |
| 188 | SkASSERT(x + info.width() <= dstInfo.width()); |
| 189 | SkASSERT(y + info.height() <= dstInfo.height()); |
| 190 | #endif |
| 191 | return this->onWritePixels(info, pixels, rowBytes, x, y); |
| 192 | } |
| 193 | |
| 194 | bool SkBaseDevice::onWritePixels(const SkImageInfo&, const void*, size_t, int, int) { |
| 195 | return false; |
| 196 | } |
| 197 | |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 198 | bool SkBaseDevice::onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) { |
commit-bot@chromium.org | 2cccf83 | 2014-03-12 03:04:08 +0000 | [diff] [blame] | 199 | return false; |
| 200 | } |
| 201 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 202 | void* SkBaseDevice::accessPixels(SkImageInfo* info, size_t* rowBytes) { |
| 203 | SkImageInfo tmpInfo; |
| 204 | size_t tmpRowBytes; |
| 205 | if (NULL == info) { |
| 206 | info = &tmpInfo; |
| 207 | } |
| 208 | if (NULL == rowBytes) { |
| 209 | rowBytes = &tmpRowBytes; |
| 210 | } |
| 211 | return this->onAccessPixels(info, rowBytes); |
| 212 | } |
| 213 | |
| 214 | void* SkBaseDevice::onAccessPixels(SkImageInfo* info, size_t* rowBytes) { |
| 215 | return NULL; |
| 216 | } |
| 217 | |
reed | d5fa1a4 | 2014-08-09 11:08:05 -0700 | [diff] [blame] | 218 | bool SkBaseDevice::EXPERIMENTAL_drawPicture(SkCanvas*, const SkPicture*, const SkMatrix*, |
| 219 | const SkPaint*) { |
commit-bot@chromium.org | 145d1c0 | 2014-03-16 19:46:36 +0000 | [diff] [blame] | 220 | // The base class doesn't perform any accelerated picture rendering |
| 221 | return false; |
| 222 | } |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 223 | |
| 224 | ////////////////////////////////////////////////////////////////////////////////////////// |
| 225 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 226 | static void morphpoints(SkPoint dst[], const SkPoint src[], int count, |
| 227 | SkPathMeasure& meas, const SkMatrix& matrix) { |
| 228 | SkMatrix::MapXYProc proc = matrix.getMapXYProc(); |
| 229 | |
| 230 | for (int i = 0; i < count; i++) { |
| 231 | SkPoint pos; |
| 232 | SkVector tangent; |
| 233 | |
| 234 | proc(matrix, src[i].fX, src[i].fY, &pos); |
| 235 | SkScalar sx = pos.fX; |
| 236 | SkScalar sy = pos.fY; |
| 237 | |
| 238 | if (!meas.getPosTan(sx, &pos, &tangent)) { |
| 239 | // set to 0 if the measure failed, so that we just set dst == pos |
| 240 | tangent.set(0, 0); |
| 241 | } |
| 242 | |
| 243 | /* This is the old way (that explains our approach but is way too slow |
| 244 | SkMatrix matrix; |
| 245 | SkPoint pt; |
| 246 | |
| 247 | pt.set(sx, sy); |
| 248 | matrix.setSinCos(tangent.fY, tangent.fX); |
| 249 | matrix.preTranslate(-sx, 0); |
| 250 | matrix.postTranslate(pos.fX, pos.fY); |
| 251 | matrix.mapPoints(&dst[i], &pt, 1); |
| 252 | */ |
| 253 | dst[i].set(pos.fX - SkScalarMul(tangent.fY, sy), |
| 254 | pos.fY + SkScalarMul(tangent.fX, sy)); |
| 255 | } |
| 256 | } |
| 257 | |
| 258 | /* TODO |
| 259 | |
| 260 | Need differentially more subdivisions when the follow-path is curvy. Not sure how to |
| 261 | determine that, but we need it. I guess a cheap answer is let the caller tell us, |
| 262 | but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out. |
| 263 | */ |
| 264 | static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas, |
| 265 | const SkMatrix& matrix) { |
| 266 | SkPath::Iter iter(src, false); |
| 267 | SkPoint srcP[4], dstP[3]; |
| 268 | SkPath::Verb verb; |
| 269 | |
| 270 | while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) { |
| 271 | switch (verb) { |
| 272 | case SkPath::kMove_Verb: |
| 273 | morphpoints(dstP, srcP, 1, meas, matrix); |
| 274 | dst->moveTo(dstP[0]); |
| 275 | break; |
| 276 | case SkPath::kLine_Verb: |
| 277 | // turn lines into quads to look bendy |
| 278 | srcP[0].fX = SkScalarAve(srcP[0].fX, srcP[1].fX); |
| 279 | srcP[0].fY = SkScalarAve(srcP[0].fY, srcP[1].fY); |
| 280 | morphpoints(dstP, srcP, 2, meas, matrix); |
| 281 | dst->quadTo(dstP[0], dstP[1]); |
| 282 | break; |
| 283 | case SkPath::kQuad_Verb: |
| 284 | morphpoints(dstP, &srcP[1], 2, meas, matrix); |
| 285 | dst->quadTo(dstP[0], dstP[1]); |
| 286 | break; |
| 287 | case SkPath::kCubic_Verb: |
| 288 | morphpoints(dstP, &srcP[1], 3, meas, matrix); |
| 289 | dst->cubicTo(dstP[0], dstP[1], dstP[2]); |
| 290 | break; |
| 291 | case SkPath::kClose_Verb: |
| 292 | dst->close(); |
| 293 | break; |
| 294 | default: |
| 295 | SkDEBUGFAIL("unknown verb"); |
| 296 | break; |
| 297 | } |
| 298 | } |
| 299 | } |
| 300 | |
| 301 | void SkBaseDevice::drawTextOnPath(const SkDraw& draw, const void* text, size_t byteLength, |
| 302 | const SkPath& follow, const SkMatrix* matrix, |
| 303 | const SkPaint& paint) { |
| 304 | SkASSERT(byteLength == 0 || text != NULL); |
| 305 | |
| 306 | // nothing to draw |
| 307 | if (text == NULL || byteLength == 0 || draw.fRC->isEmpty()) { |
| 308 | return; |
| 309 | } |
| 310 | |
| 311 | SkTextToPathIter iter((const char*)text, byteLength, paint, true); |
| 312 | SkPathMeasure meas(follow, false); |
| 313 | SkScalar hOffset = 0; |
| 314 | |
| 315 | // need to measure first |
| 316 | if (paint.getTextAlign() != SkPaint::kLeft_Align) { |
| 317 | SkScalar pathLen = meas.getLength(); |
| 318 | if (paint.getTextAlign() == SkPaint::kCenter_Align) { |
| 319 | pathLen = SkScalarHalf(pathLen); |
| 320 | } |
| 321 | hOffset += pathLen; |
| 322 | } |
| 323 | |
| 324 | const SkPath* iterPath; |
| 325 | SkScalar xpos; |
| 326 | SkMatrix scaledMatrix; |
| 327 | SkScalar scale = iter.getPathScale(); |
| 328 | |
| 329 | scaledMatrix.setScale(scale, scale); |
| 330 | |
| 331 | while (iter.next(&iterPath, &xpos)) { |
| 332 | if (iterPath) { |
| 333 | SkPath tmp; |
| 334 | SkMatrix m(scaledMatrix); |
| 335 | |
| 336 | tmp.setIsVolatile(true); |
| 337 | m.postTranslate(xpos + hOffset, 0); |
| 338 | if (matrix) { |
| 339 | m.postConcat(*matrix); |
| 340 | } |
| 341 | morphpath(&tmp, *iterPath, meas, m); |
| 342 | this->drawPath(draw, tmp, iter.getPaint(), NULL, true); |
| 343 | } |
| 344 | } |
| 345 | } |
| 346 | |
| 347 | ////////////////////////////////////////////////////////////////////////////////////////// |
| 348 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 349 | uint32_t SkBaseDevice::filterTextFlags(const SkPaint& paint) const { |
| 350 | uint32_t flags = paint.getFlags(); |
| 351 | |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 352 | if (!paint.isLCDRenderText() || !paint.isAntiAlias()) { |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 353 | return flags; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 354 | } |
| 355 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 356 | if (kUnknown_SkPixelGeometry == fLeakyProperties->pixelGeometry() |
| 357 | || this->onShouldDisableLCD(paint)) { |
| 358 | |
| 359 | flags &= ~SkPaint::kLCDRenderText_Flag; |
| 360 | flags |= SkPaint::kGenA8FromLCD_Flag; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 361 | } |
| 362 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 363 | return flags; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 364 | } |
| 365 | |