| OLD | NEW |
|---|
| (Empty) |
| 1 | |
| 2 /* | |
| 3 * Copyright 2012 Google Inc. | |
| 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 #include "SkObjectParser.h" | |
| 10 #include "SkData.h" | |
| 11 #include "SkFontDescriptor.h" | |
| 12 #include "SkRRect.h" | |
| 13 #include "SkShader.h" | |
| 14 #include "SkStream.h" | |
| 15 #include "SkStringUtils.h" | |
| 16 #include "SkTypeface.h" | |
| 17 #include "SkUtils.h" | |
| 18 | |
| 19 /* TODO(chudy): Replace all std::strings with char */ | |
| 20 | |
| 21 SkString* SkObjectParser::BitmapToString(const SkBitmap& bitmap) { | |
| 22 SkString* mBitmap = new SkString("SkBitmap: "); | |
| 23 mBitmap->append("W: "); | |
| 24 mBitmap->appendS32(bitmap.width()); | |
| 25 mBitmap->append(" H: "); | |
| 26 mBitmap->appendS32(bitmap.height()); | |
| 27 | |
| 28 const char* gConfigStrings[] = { | |
| 29 "None", "A1", "A8", "Index8", "RGB565", "ARGB4444", "ARGB8888", "RLE8" | |
| 30 }; | |
| 31 SkASSERT(SkBitmap::kConfigCount == 8); | |
| 32 | |
| 33 mBitmap->append(" Config: "); | |
| 34 mBitmap->append(gConfigStrings[bitmap.getConfig()]); | |
| 35 | |
| 36 if (bitmap.isOpaque()) { | |
| 37 mBitmap->append(" opaque"); | |
| 38 } else { | |
| 39 mBitmap->append(" not-opaque"); | |
| 40 } | |
| 41 | |
| 42 if (bitmap.isImmutable()) { | |
| 43 mBitmap->append(" immutable"); | |
| 44 } else { | |
| 45 mBitmap->append(" not-immutable"); | |
| 46 } | |
| 47 | |
| 48 if (bitmap.isVolatile()) { | |
| 49 mBitmap->append(" volatile"); | |
| 50 } else { | |
| 51 mBitmap->append(" not-volatile"); | |
| 52 } | |
| 53 | |
| 54 mBitmap->append(" genID: "); | |
| 55 mBitmap->appendS32(bitmap.getGenerationID()); | |
| 56 | |
| 57 return mBitmap; | |
| 58 } | |
| 59 | |
| 60 SkString* SkObjectParser::BoolToString(bool doAA) { | |
| 61 SkString* mBool = new SkString("Bool doAA: "); | |
| 62 if (doAA) { | |
| 63 mBool->append("True"); | |
| 64 } else { | |
| 65 mBool->append("False"); | |
| 66 } | |
| 67 return mBool; | |
| 68 } | |
| 69 | |
| 70 SkString* SkObjectParser::CustomTextToString(const char* text) { | |
| 71 SkString* mText = new SkString(text); | |
| 72 return mText; | |
| 73 } | |
| 74 | |
| 75 SkString* SkObjectParser::IntToString(int x, const char* text) { | |
| 76 SkString* mInt = new SkString(text); | |
| 77 mInt->append(" "); | |
| 78 mInt->appendScalar(SkIntToScalar(x)); | |
| 79 return mInt; | |
| 80 } | |
| 81 | |
| 82 SkString* SkObjectParser::IRectToString(const SkIRect& rect) { | |
| 83 SkString* mRect = new SkString("SkIRect: "); | |
| 84 mRect->append("L: "); | |
| 85 mRect->appendS32(rect.left()); | |
| 86 mRect->append(", T: "); | |
| 87 mRect->appendS32(rect.top()); | |
| 88 mRect->append(", R: "); | |
| 89 mRect->appendS32(rect.right()); | |
| 90 mRect->append(", B: "); | |
| 91 mRect->appendS32(rect.bottom()); | |
| 92 return mRect; | |
| 93 } | |
| 94 | |
| 95 SkString* SkObjectParser::MatrixToString(const SkMatrix& matrix) { | |
| 96 SkString* str = new SkString("SkMatrix: "); | |
| 97 #ifdef SK_DEVELOPER | |
| 98 matrix.toString(str); | |
| 99 #endif | |
| 100 return str; | |
| 101 } | |
| 102 | |
| 103 SkString* SkObjectParser::PaintToString(const SkPaint& paint) { | |
| 104 SkString* str = new SkString; | |
| 105 #ifdef SK_DEVELOPER | |
| 106 paint.toString(str); | |
| 107 #endif | |
| 108 return str; | |
| 109 } | |
| 110 | |
| 111 SkString* SkObjectParser::PathToString(const SkPath& path) { | |
| 112 SkString* mPath = new SkString("Path ("); | |
| 113 | |
| 114 static const char* gFillStrings[] = { | |
| 115 "Winding", "EvenOdd", "InverseWinding", "InverseEvenOdd" | |
| 116 }; | |
| 117 | |
| 118 mPath->append(gFillStrings[path.getFillType()]); | |
| 119 mPath->append(", "); | |
| 120 | |
| 121 static const char* gConvexityStrings[] = { | |
| 122 "Unknown", "Convex", "Concave" | |
| 123 }; | |
| 124 SkASSERT(SkPath::kConcave_Convexity == 2); | |
| 125 | |
| 126 mPath->append(gConvexityStrings[path.getConvexity()]); | |
| 127 mPath->append(", "); | |
| 128 | |
| 129 if (path.isRect(NULL)) { | |
| 130 mPath->append("isRect, "); | |
| 131 } else { | |
| 132 mPath->append("isNotRect, "); | |
| 133 } | |
| 134 | |
| 135 mPath->appendS32(path.countVerbs()); | |
| 136 mPath->append("V, "); | |
| 137 mPath->appendS32(path.countPoints()); | |
| 138 mPath->append("P): "); | |
| 139 | |
| 140 static const char* gVerbStrings[] = { | |
| 141 "Move", "Line", "Quad", "Conic", "Cubic", "Close", "Done" | |
| 142 }; | |
| 143 static const int gPtsPerVerb[] = { 1, 1, 2, 2, 3, 0, 0 }; | |
| 144 static const int gPtOffsetPerVerb[] = { 0, 1, 1, 1, 1, 0, 0 }; | |
| 145 SkASSERT(SkPath::kDone_Verb == 6); | |
| 146 | |
| 147 SkPath::Iter iter(const_cast<SkPath&>(path), false); | |
| 148 SkPath::Verb verb; | |
| 149 SkPoint points[4]; | |
| 150 | |
| 151 for(verb = iter.next(points, false); | |
| 152 verb != SkPath::kDone_Verb; | |
| 153 verb = iter.next(points, false)) { | |
| 154 | |
| 155 mPath->append(gVerbStrings[verb]); | |
| 156 mPath->append(" "); | |
| 157 | |
| 158 for (int i = 0; i < gPtsPerVerb[verb]; ++i) { | |
| 159 mPath->append("("); | |
| 160 mPath->appendScalar(points[gPtOffsetPerVerb[verb]+i].fX); | |
| 161 mPath->append(", "); | |
| 162 mPath->appendScalar(points[gPtOffsetPerVerb[verb]+i].fY); | |
| 163 mPath->append(")"); | |
| 164 } | |
| 165 | |
| 166 if (SkPath::kConic_Verb == verb) { | |
| 167 mPath->append("("); | |
| 168 mPath->appendScalar(iter.conicWeight()); | |
| 169 mPath->append(")"); | |
| 170 } | |
| 171 | |
| 172 mPath->append(" "); | |
| 173 } | |
| 174 | |
| 175 SkString* boundStr = SkObjectParser::RectToString(path.getBounds(), " Bou
nd: "); | |
| 176 | |
| 177 if (NULL != boundStr) { | |
| 178 mPath->append(*boundStr); | |
| 179 SkDELETE(boundStr); | |
| 180 } | |
| 181 | |
| 182 return mPath; | |
| 183 } | |
| 184 | |
| 185 SkString* SkObjectParser::PointsToString(const SkPoint pts[], size_t count) { | |
| 186 SkString* mPoints = new SkString("SkPoints pts[]: "); | |
| 187 for (unsigned int i = 0; i < count; i++) { | |
| 188 mPoints->append("("); | |
| 189 mPoints->appendScalar(pts[i].fX); | |
| 190 mPoints->append(","); | |
| 191 mPoints->appendScalar(pts[i].fY); | |
| 192 mPoints->append(")"); | |
| 193 } | |
| 194 return mPoints; | |
| 195 } | |
| 196 | |
| 197 SkString* SkObjectParser::PointModeToString(SkCanvas::PointMode mode) { | |
| 198 SkString* mMode = new SkString("SkCanvas::PointMode: "); | |
| 199 if (mode == SkCanvas::kPoints_PointMode) { | |
| 200 mMode->append("kPoints_PointMode"); | |
| 201 } else if (mode == SkCanvas::kLines_PointMode) { | |
| 202 mMode->append("kLines_Mode"); | |
| 203 } else if (mode == SkCanvas::kPolygon_PointMode) { | |
| 204 mMode->append("kPolygon_PointMode"); | |
| 205 } | |
| 206 return mMode; | |
| 207 } | |
| 208 | |
| 209 SkString* SkObjectParser::RectToString(const SkRect& rect, const char* title) { | |
| 210 | |
| 211 SkString* mRect = new SkString; | |
| 212 | |
| 213 if (NULL == title) { | |
| 214 mRect->append("SkRect: "); | |
| 215 } else { | |
| 216 mRect->append(title); | |
| 217 } | |
| 218 mRect->append("("); | |
| 219 mRect->appendScalar(rect.left()); | |
| 220 mRect->append(", "); | |
| 221 mRect->appendScalar(rect.top()); | |
| 222 mRect->append(", "); | |
| 223 mRect->appendScalar(rect.right()); | |
| 224 mRect->append(", "); | |
| 225 mRect->appendScalar(rect.bottom()); | |
| 226 mRect->append(")"); | |
| 227 return mRect; | |
| 228 } | |
| 229 | |
| 230 SkString* SkObjectParser::RRectToString(const SkRRect& rrect, const char* title)
{ | |
| 231 | |
| 232 SkString* mRRect = new SkString; | |
| 233 | |
| 234 if (NULL == title) { | |
| 235 mRRect->append("SkRRect ("); | |
| 236 if (rrect.isEmpty()) { | |
| 237 mRRect->append("empty"); | |
| 238 } else if (rrect.isRect()) { | |
| 239 mRRect->append("rect"); | |
| 240 } else if (rrect.isOval()) { | |
| 241 mRRect->append("oval"); | |
| 242 } else if (rrect.isSimple()) { | |
| 243 mRRect->append("simple"); | |
| 244 } else { | |
| 245 SkASSERT(rrect.isComplex()); | |
| 246 mRRect->append("complex"); | |
| 247 } | |
| 248 mRRect->append("): "); | |
| 249 } else { | |
| 250 mRRect->append(title); | |
| 251 } | |
| 252 mRRect->append("("); | |
| 253 mRRect->appendScalar(rrect.rect().left()); | |
| 254 mRRect->append(", "); | |
| 255 mRRect->appendScalar(rrect.rect().top()); | |
| 256 mRRect->append(", "); | |
| 257 mRRect->appendScalar(rrect.rect().right()); | |
| 258 mRRect->append(", "); | |
| 259 mRRect->appendScalar(rrect.rect().bottom()); | |
| 260 mRRect->append(") radii: ("); | |
| 261 for (int i = 0; i < 4; ++i) { | |
| 262 const SkVector& radii = rrect.radii((SkRRect::Corner) i); | |
| 263 mRRect->appendScalar(radii.fX); | |
| 264 mRRect->append(", "); | |
| 265 mRRect->appendScalar(radii.fY); | |
| 266 if (i < 3) { | |
| 267 mRRect->append(", "); | |
| 268 } | |
| 269 } | |
| 270 mRRect->append(")"); | |
| 271 return mRRect; | |
| 272 } | |
| 273 | |
| 274 SkString* SkObjectParser::RegionOpToString(SkRegion::Op op) { | |
| 275 SkString* mOp = new SkString("SkRegion::Op: "); | |
| 276 if (op == SkRegion::kDifference_Op) { | |
| 277 mOp->append("kDifference_Op"); | |
| 278 } else if (op == SkRegion::kIntersect_Op) { | |
| 279 mOp->append("kIntersect_Op"); | |
| 280 } else if (op == SkRegion::kUnion_Op) { | |
| 281 mOp->append("kUnion_Op"); | |
| 282 } else if (op == SkRegion::kXOR_Op) { | |
| 283 mOp->append("kXOR_Op"); | |
| 284 } else if (op == SkRegion::kReverseDifference_Op) { | |
| 285 mOp->append("kReverseDifference_Op"); | |
| 286 } else if (op == SkRegion::kReplace_Op) { | |
| 287 mOp->append("kReplace_Op"); | |
| 288 } else { | |
| 289 mOp->append("Unknown Type"); | |
| 290 } | |
| 291 return mOp; | |
| 292 } | |
| 293 | |
| 294 SkString* SkObjectParser::RegionToString(const SkRegion& region) { | |
| 295 SkString* mRegion = new SkString("SkRegion: Data unavailable."); | |
| 296 return mRegion; | |
| 297 } | |
| 298 | |
| 299 SkString* SkObjectParser::SaveFlagsToString(SkCanvas::SaveFlags flags) { | |
| 300 SkString* mFlags = new SkString("SkCanvas::SaveFlags: "); | |
| 301 if(flags == SkCanvas::kMatrixClip_SaveFlag) { | |
| 302 mFlags->append("kMatrixClip_SaveFlag"); | |
| 303 } else if (flags == SkCanvas::kClip_SaveFlag) { | |
| 304 mFlags->append("kClip_SaveFlag"); | |
| 305 } else if (flags == SkCanvas::kHasAlphaLayer_SaveFlag) { | |
| 306 mFlags->append("kHasAlphaLayer_SaveFlag"); | |
| 307 } else if (flags == SkCanvas::kFullColorLayer_SaveFlag) { | |
| 308 mFlags->append("kFullColorLayer_SaveFlag"); | |
| 309 } else if (flags == SkCanvas::kClipToLayer_SaveFlag) { | |
| 310 mFlags->append("kClipToLayer_SaveFlag"); | |
| 311 } else if (flags == SkCanvas::kMatrixClip_SaveFlag) { | |
| 312 mFlags->append("kMatrixClip_SaveFlag"); | |
| 313 } else if (flags == SkCanvas::kARGB_NoClipLayer_SaveFlag) { | |
| 314 mFlags->append("kARGB_NoClipLayer_SaveFlag"); | |
| 315 } else if (flags == SkCanvas::kARGB_ClipLayer_SaveFlag) { | |
| 316 mFlags->append("kARGB_ClipLayer_SaveFlag"); | |
| 317 } else { | |
| 318 mFlags->append("Data Unavailable"); | |
| 319 } | |
| 320 return mFlags; | |
| 321 } | |
| 322 | |
| 323 SkString* SkObjectParser::ScalarToString(SkScalar x, const char* text) { | |
| 324 SkString* mScalar = new SkString(text); | |
| 325 mScalar->append(" "); | |
| 326 mScalar->appendScalar(x); | |
| 327 return mScalar; | |
| 328 } | |
| 329 | |
| 330 SkString* SkObjectParser::TextToString(const void* text, size_t byteLength, | |
| 331 SkPaint::TextEncoding encoding) { | |
| 332 | |
| 333 SkString* decodedText = new SkString(); | |
| 334 switch (encoding) { | |
| 335 case SkPaint::kUTF8_TextEncoding: { | |
| 336 decodedText->append("UTF-8: "); | |
| 337 decodedText->append((const char*)text, byteLength); | |
| 338 break; | |
| 339 } | |
| 340 case SkPaint::kUTF16_TextEncoding: { | |
| 341 decodedText->append("UTF-16: "); | |
| 342 size_t sizeNeeded = SkUTF16_ToUTF8((uint16_t*)text, byteLength / 2,
NULL); | |
| 343 char* utf8 = new char[sizeNeeded]; | |
| 344 SkUTF16_ToUTF8((uint16_t*)text, byteLength / 2, utf8); | |
| 345 decodedText->append(utf8, sizeNeeded); | |
| 346 delete utf8; | |
| 347 break; | |
| 348 } | |
| 349 case SkPaint::kUTF32_TextEncoding: { | |
| 350 decodedText->append("UTF-32: "); | |
| 351 const SkUnichar* begin = (const SkUnichar*)text; | |
| 352 const SkUnichar* end = (const SkUnichar*)((const char*)text + byteLe
ngth); | |
| 353 for (const SkUnichar* unichar = begin; unichar < end; ++unichar) { | |
| 354 decodedText->appendUnichar(*unichar); | |
| 355 } | |
| 356 break; | |
| 357 } | |
| 358 case SkPaint::kGlyphID_TextEncoding: { | |
| 359 decodedText->append("GlyphID: "); | |
| 360 const uint16_t* begin = (const uint16_t*)text; | |
| 361 const uint16_t* end = (const uint16_t*)((const char*)text + byteLeng
th); | |
| 362 for (const uint16_t* glyph = begin; glyph < end; ++glyph) { | |
| 363 decodedText->append("0x"); | |
| 364 decodedText->appendHex(*glyph); | |
| 365 decodedText->append(" "); | |
| 366 } | |
| 367 break; | |
| 368 } | |
| 369 default: | |
| 370 decodedText->append("Unknown text encoding."); | |
| 371 break; | |
| 372 } | |
| 373 | |
| 374 return decodedText; | |
| 375 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 16638014:
Expose debugger backend classes externally. (Closed)
Base URL: https://skia.googlecode.com/svn/trunk