Home | History | Annotate | Download | only in debugger 
      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* gColorTypeStrings[] = {
     29         "None", "A8", "565", "4444", "RGBA", "BGRA", "Index8"
     30     };
     31     SkASSERT(kLastEnum_SkColorType + 1 == SK_ARRAY_COUNT(gColorTypeStrings));
     32 
     33     mBitmap->append(" ColorType: ");
     34     mBitmap->append(gColorTypeStrings[bitmap.colorType()]);
     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 #ifndef SK_IGNORE_TO_STRING
     98     matrix.toString(str);
     99 #endif
    100     return str;
    101 }
    102 
    103 SkString* SkObjectParser::PaintToString(const SkPaint& paint) {
    104     SkString* str = new SkString;
    105 #ifndef SK_IGNORE_TO_STRING
    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(), "    Bound: ");
    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 if (rrect.isNinePatch()) {
    245             mRRect->append("nine-patch");
    246         } else {
    247             SkASSERT(rrect.isComplex());
    248             mRRect->append("complex");
    249         }
    250         mRRect->append("): ");
    251     } else {
    252         mRRect->append(title);
    253     }
    254     mRRect->append("(");
    255     mRRect->appendScalar(rrect.rect().left());
    256     mRRect->append(", ");
    257     mRRect->appendScalar(rrect.rect().top());
    258     mRRect->append(", ");
    259     mRRect->appendScalar(rrect.rect().right());
    260     mRRect->append(", ");
    261     mRRect->appendScalar(rrect.rect().bottom());
    262     mRRect->append(") radii: (");
    263     for (int i = 0; i < 4; ++i) {
    264         const SkVector& radii = rrect.radii((SkRRect::Corner) i);
    265         mRRect->appendScalar(radii.fX);
    266         mRRect->append(", ");
    267         mRRect->appendScalar(radii.fY);
    268         if (i < 3) {
    269             mRRect->append(", ");
    270         }
    271     }
    272     mRRect->append(")");
    273     return mRRect;
    274 }
    275 
    276 SkString* SkObjectParser::RegionOpToString(SkRegion::Op op) {
    277     SkString* mOp = new SkString("SkRegion::Op: ");
    278     if (op == SkRegion::kDifference_Op) {
    279         mOp->append("kDifference_Op");
    280     } else if (op == SkRegion::kIntersect_Op) {
    281         mOp->append("kIntersect_Op");
    282     } else if (op == SkRegion::kUnion_Op) {
    283         mOp->append("kUnion_Op");
    284     } else if (op == SkRegion::kXOR_Op) {
    285         mOp->append("kXOR_Op");
    286     } else if (op == SkRegion::kReverseDifference_Op) {
    287         mOp->append("kReverseDifference_Op");
    288     } else if (op == SkRegion::kReplace_Op) {
    289         mOp->append("kReplace_Op");
    290     } else {
    291         mOp->append("Unknown Type");
    292     }
    293     return mOp;
    294 }
    295 
    296 SkString* SkObjectParser::RegionToString(const SkRegion& region) {
    297     SkString* mRegion = new SkString("SkRegion: Data unavailable.");
    298     return mRegion;
    299 }
    300 
    301 SkString* SkObjectParser::SaveFlagsToString(SkCanvas::SaveFlags flags) {
    302     SkString* mFlags = new SkString("SkCanvas::SaveFlags: ");
    303     if (flags & SkCanvas::kMatrix_SaveFlag) {
    304         mFlags->append("kMatrix_SaveFlag ");
    305     }
    306     if (flags & SkCanvas::kClip_SaveFlag) {
    307         mFlags->append("kClip_SaveFlag ");
    308     }
    309     if (flags & SkCanvas::kHasAlphaLayer_SaveFlag) {
    310         mFlags->append("kHasAlphaLayer_SaveFlag ");
    311     }
    312     if (flags & SkCanvas::kFullColorLayer_SaveFlag) {
    313         mFlags->append("kFullColorLayer_SaveFlag ");
    314     }
    315     if (flags & SkCanvas::kClipToLayer_SaveFlag) {
    316         mFlags->append("kClipToLayer_SaveFlag ");
    317     }
    318     return mFlags;
    319 }
    320 
    321 SkString* SkObjectParser::ScalarToString(SkScalar x, const char* text) {
    322     SkString* mScalar = new SkString(text);
    323     mScalar->append(" ");
    324     mScalar->appendScalar(x);
    325     return mScalar;
    326 }
    327 
    328 SkString* SkObjectParser::TextToString(const void* text, size_t byteLength,
    329                                        SkPaint::TextEncoding encoding) {
    330 
    331     SkString* decodedText = new SkString();
    332     switch (encoding) {
    333         case SkPaint::kUTF8_TextEncoding: {
    334             decodedText->append("UTF-8: ");
    335             decodedText->append((const char*)text, byteLength);
    336             break;
    337         }
    338         case SkPaint::kUTF16_TextEncoding: {
    339             decodedText->append("UTF-16: ");
    340             size_t sizeNeeded = SkUTF16_ToUTF8((uint16_t*)text,
    341                                                 SkToS32(byteLength / 2),
    342                                                 NULL);
    343             SkAutoSTMalloc<0x100, char> utf8(sizeNeeded);
    344             SkUTF16_ToUTF8((uint16_t*)text, SkToS32(byteLength / 2), utf8);
    345             decodedText->append(utf8, sizeNeeded);
    346             break;
    347         }
    348         case SkPaint::kUTF32_TextEncoding: {
    349             decodedText->append("UTF-32: ");
    350             const SkUnichar* begin = (const SkUnichar*)text;
    351             const SkUnichar* end = (const SkUnichar*)((const char*)text + byteLength);
    352             for (const SkUnichar* unichar = begin; unichar < end; ++unichar) {
    353                 decodedText->appendUnichar(*unichar);
    354             }
    355             break;
    356         }
    357         case SkPaint::kGlyphID_TextEncoding: {
    358             decodedText->append("GlyphID: ");
    359             const uint16_t* begin = (const uint16_t*)text;
    360             const uint16_t* end = (const uint16_t*)((const char*)text + byteLength);
    361             for (const uint16_t* glyph = begin; glyph < end; ++glyph) {
    362                 decodedText->append("0x");
    363                 decodedText->appendHex(*glyph);
    364                 decodedText->append(" ");
    365             }
    366             break;
    367         }
    368         default:
    369             decodedText->append("Unknown text encoding.");
    370             break;
    371     }
    372 
    373     return decodedText;
    374 }
    375