DrawCommand Class Reference

#include <DrawCommand.h>

Inheritance diagram for DrawCommand:

Public Types
enum	OpType {   kBeginDrawPicture_OpType , kClear_OpType , kClipPath_OpType , kClipRegion_OpType ,   kClipRect_OpType , kClipRRect_OpType , kClipShader_OpType , kResetClip_OpType ,   kConcat_OpType , kConcat44_OpType , kDrawAnnotation_OpType , kDrawBitmap_OpType ,   kDrawBitmapRect_OpType , kDrawDRRect_OpType , kDrawImage_OpType , kDrawImageLattice_OpType ,   kDrawImageRect_OpType , kDrawImageRectLayer_OpType , kDrawOval_OpType , kDrawArc_OpType ,   kDrawPaint_OpType , kDrawPatch_OpType , kDrawPath_OpType , kDrawPoints_OpType ,   kDrawRect_OpType , kDrawRRect_OpType , kDrawRegion_OpType , kDrawShadow_OpType ,   kDrawTextBlob_OpType , kDrawVertices_OpType , kDrawAtlas_OpType , kDrawDrawable_OpType ,   kDrawEdgeAAQuad_OpType , kDrawEdgeAAImageSet_OpType , kEndDrawPicture_OpType , kRestore_OpType ,   kSave_OpType , kSaveLayer_OpType , kSetMatrix_OpType , kSetM44_OpType ,   kLast_OpType = kSetM44_OpType }

Public Member Functions
	DrawCommand (OpType opType)
virtual	~DrawCommand ()
bool	isVisible () const
void	setVisible (bool toggle)
virtual void	execute (SkCanvas *) const =0
virtual bool	render (SkCanvas *canvas) const
virtual void	toJSON (SkJSONWriter &writer, UrlDataManager &urlDataManager) const
OpType	getOpType () const

Static Public Member Functions
static void	WritePNG (const SkBitmap &bitmap, SkWStream &out)
static const char *	GetCommandString (OpType type)
static void	MakeJsonColor (SkJSONWriter &, const SkColor color)
static void	MakeJsonColor4f (SkJSONWriter &, const SkColor4f &color)
static void	MakeJsonPoint (SkJSONWriter &, const SkPoint &point)
static void	MakeJsonPoint (SkJSONWriter &, SkScalar x, SkScalar y)
static void	MakeJsonPoint3 (SkJSONWriter &, const SkPoint3 &point)
static void	MakeJsonRect (SkJSONWriter &, const SkRect &rect)
static void	MakeJsonIRect (SkJSONWriter &, const SkIRect &)
static void	MakeJsonMatrix (SkJSONWriter &, const SkMatrix &)
static void	MakeJsonMatrix44 (SkJSONWriter &, const SkM44 &)
static void	MakeJsonPath (SkJSONWriter &, const SkPath &path)
static void	MakeJsonRegion (SkJSONWriter &, const SkRegion &region)
static void	MakeJsonSampling (SkJSONWriter &, const SkSamplingOptions &sampling)
static void	MakeJsonPaint (SkJSONWriter &, const SkPaint &paint, UrlDataManager &urlDataManager)
static void	MakeJsonLattice (SkJSONWriter &, const SkCanvas::Lattice &lattice)
static void	flatten (const SkFlattenable *flattenable, SkJSONWriter &writer, UrlDataManager &urlDataManager)
static bool	flatten (const SkImage &image, SkJSONWriter &writer, UrlDataManager &urlDataManager)
static bool	flatten (const SkBitmap &bitmap, SkJSONWriter &writer, UrlDataManager &urlDataManager)

Static Public Attributes
static const int	kOpTypeCount = kLast_OpType + 1

Detailed Description

Definition at line 53 of file DrawCommand.h.

Member Enumeration Documentation

OpType

enum DrawCommand::OpType

Enumerator
kBeginDrawPicture_OpType
kClear_OpType
kClipPath_OpType
kClipRegion_OpType
kClipRect_OpType
kClipRRect_OpType
kClipShader_OpType
kResetClip_OpType
kConcat_OpType
kConcat44_OpType
kDrawAnnotation_OpType
kDrawBitmap_OpType
kDrawBitmapRect_OpType
kDrawDRRect_OpType
kDrawImage_OpType
kDrawImageLattice_OpType
kDrawImageRect_OpType
kDrawImageRectLayer_OpType
kDrawOval_OpType
kDrawArc_OpType
kDrawPaint_OpType
kDrawPatch_OpType
kDrawPath_OpType
kDrawPoints_OpType
kDrawRect_OpType
kDrawRRect_OpType
kDrawRegion_OpType
kDrawShadow_OpType
kDrawTextBlob_OpType
kDrawVertices_OpType
kDrawAtlas_OpType
kDrawDrawable_OpType
kDrawEdgeAAQuad_OpType
kDrawEdgeAAImageSet_OpType
kEndDrawPicture_OpType
kRestore_OpType
kSave_OpType
kSaveLayer_OpType
kSetMatrix_OpType
kSetM44_OpType
kLast_OpType

Definition at line 55 of file DrawCommand.h.

                {
        kBeginDrawPicture_OpType,
        kClear_OpType,
        kClipPath_OpType,
        kClipRegion_OpType,
        kClipRect_OpType,
        kClipRRect_OpType,
        kClipShader_OpType,
        kResetClip_OpType,
        kConcat_OpType,
        kConcat44_OpType,
        kDrawAnnotation_OpType,
        kDrawBitmap_OpType,
        kDrawBitmapRect_OpType,
        kDrawDRRect_OpType,
        kDrawImage_OpType,
        kDrawImageLattice_OpType,
        kDrawImageRect_OpType,
        kDrawImageRectLayer_OpType, // unique to DebugCanvas
        kDrawOval_OpType,
        kDrawArc_OpType,
        kDrawPaint_OpType,
        kDrawPatch_OpType,
        kDrawPath_OpType,
        kDrawPoints_OpType,
        kDrawRect_OpType,
        kDrawRRect_OpType,
        kDrawRegion_OpType,
        kDrawShadow_OpType,
        kDrawTextBlob_OpType,
        kDrawVertices_OpType,
        kDrawAtlas_OpType,
        kDrawDrawable_OpType,
        kDrawEdgeAAQuad_OpType,
        kDrawEdgeAAImageSet_OpType,
        kEndDrawPicture_OpType,
        kRestore_OpType,
        kSave_OpType,
        kSaveLayer_OpType,
        kSetMatrix_OpType,
        kSetM44_OpType,
 
        kLast_OpType = kSetM44_OpType
    };

Constructor & Destructor Documentation

DrawCommand()

DrawCommand::DrawCommand

(

OpType

opType

)

Definition at line 232 of file DrawCommand.cpp.

: fOpType(type), fVisible(true) {}

~DrawCommand()

virtual DrawCommand::~DrawCommand ( )

inlinevirtual

Definition at line 106 of file DrawCommand.h.

{}

Member Function Documentation

execute()

virtual void DrawCommand::execute ( SkCanvas *  ) const

pure virtual

Implemented in RestoreCommand, ClearCommand, ClipPathCommand, ClipRegionCommand, ClipRectCommand, ClipRRectCommand, ClipShaderCommand, ResetClipCommand, ConcatCommand, Concat44Command, DrawAnnotationCommand, DrawImageCommand, DrawImageLatticeCommand, DrawImageRectCommand, DrawImageRectLayerCommand, DrawOvalCommand, DrawArcCommand, DrawPaintCommand, DrawBehindCommand, DrawPathCommand, BeginDrawPictureCommand, EndDrawPictureCommand, DrawPointsCommand, DrawRegionCommand, DrawTextBlobCommand, DrawPatchCommand, DrawRectCommand, DrawRRectCommand, DrawDRRectCommand, DrawVerticesCommand, DrawAtlasCommand, SaveCommand, SaveLayerCommand, SetMatrixCommand, SetM44Command, DrawShadowCommand, DrawDrawableCommand, DrawEdgeAAQuadCommand, and DrawEdgeAAImageSetCommand.

flatten() [1/3]

bool DrawCommand::flatten ( const SkBitmap &  bitmap, SkJSONWriter &  writer, UrlDataManager &  urlDataManager  )

static

Definition at line 732 of file DrawCommand.cpp.

                                                          {
    sk_sp<SkImage> image(bitmap.asImage());
    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_COLOR, color_type_name(bitmap.colorType()));
    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_ALPHA, alpha_type_name(bitmap.alphaType()));
    // Image will appear to have no uses, TODO(nifong): provide the user with a useful explanation
    bool success = flatten(*image, writer, urlDataManager);
    return success;
}

flatten() [2/3]

void DrawCommand::flatten ( const SkFlattenable *  flattenable, SkJSONWriter &  writer, UrlDataManager &  urlDataManager  )

static

Definition at line 630 of file DrawCommand.cpp.

                                                               {
    SkBinaryWriteBuffer buffer({});  // TODO(kjlubick, bungeman) feed SkSerialProcs through API
    flattenable->flatten(buffer);
    void* data = sk_malloc_throw(buffer.bytesWritten());
    buffer.writeToMemory(data);
    SkString url =
            encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager);
    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_NAME, flattenable->getTypeName());
    writer.appendString(DEBUGCANVAS_ATTRIBUTE_DATA, url);
 
    writer.beginObject(DEBUGCANVAS_ATTRIBUTE_VALUES);
    JsonWriteBuffer jsonBuffer(&writer, &urlDataManager);
    flattenable->flatten(jsonBuffer);
    writer.endObject();  // values
 
    sk_free(data);
}

flatten() [3/3]

bool DrawCommand::flatten ( const SkImage &  image, SkJSONWriter &  writer, UrlDataManager &  urlDataManager  )

static

Definition at line 661 of file DrawCommand.cpp.

                                                          {
    // For MSKP files, there is no need to encode the image,
    // just report its id.
    if (urlDataManager.hasImageIndex()) {
        writer.appendName(DEBUGCANVAS_ATTRIBUTE_IMAGE_INDEX);
        writer.appendU64(urlDataManager.lookupImage(&image));
        return true;
    }
 
    writer.beginObject(DEBUGCANVAS_ATTRIBUTE_IMAGE);
    size_t       rowBytes = 4 * image.width();
    SkAutoMalloc buffer(rowBytes * image.height());
    SkImageInfo  dstInfo =
            SkImageInfo::Make(image.dimensions(), kN32_SkColorType, kPremul_SkAlphaType);
    // "cheat" for this debug tool and use image's context
    GrDirectContext* dContext = nullptr;
#if defined(SK_GANESH)
    dContext = GrAsDirectContext(as_IB(&image)->context());
#endif
    if (!image.readPixels(dContext, dstInfo, buffer.get(), rowBytes, 0, 0)) {
        SkDebugf("DrawCommand::flatten SkImage: readPixels failed\n");
        writer.endObject();
        return false;
    }
 
    SkBitmap bm;
    bm.installPixels(dstInfo, buffer.get(), rowBytes);
 
    SkDynamicMemoryWStream out;
    DrawCommand::WritePNG(bm, out);
    sk_sp<SkData> encoded = out.detachAsData();
    if (encoded == nullptr) {
        SkDebugf("DrawCommand::flatten SkImage: could not encode image as PNG\n");
        writer.endObject();
        return false;
    }
    auto dataPtr = encoded->data();
    if (!dataPtr) {
      SkDebugf("DrawCommand::flatten SkImage: encoding as PNG produced zero length data\n");
      writer.endObject();
      return false;
    }
    SkString url = encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager);
    writer.appendString(DEBUGCANVAS_ATTRIBUTE_DATA, url);
    writer.endObject();
    return true;
}

GetCommandString()

const char * DrawCommand::GetCommandString ( OpType  type )

static

Definition at line 234 of file DrawCommand.cpp.

                                                     {
    switch (type) {
        case kBeginDrawPicture_OpType: return "BeginDrawPicture";
        case kClear_OpType: return "DrawClear";
        case kClipPath_OpType: return "ClipPath";
        case kClipRegion_OpType: return "ClipRegion";
        case kClipRect_OpType: return "ClipRect";
        case kClipRRect_OpType: return "ClipRRect";
        case kResetClip_OpType: return "ResetClip";
        case kConcat_OpType: return "Concat";
        case kConcat44_OpType: return "Concat44";
        case kDrawAnnotation_OpType: return "DrawAnnotation";
        case kDrawBitmap_OpType: return "DrawBitmap";
        case kDrawBitmapRect_OpType: return "DrawBitmapRect";
        case kDrawDRRect_OpType: return "DrawDRRect";
        case kDrawImage_OpType: return "DrawImage";
        case kDrawImageLattice_OpType: return "DrawImageLattice";
        case kDrawImageRect_OpType: return "DrawImageRect";
        case kDrawImageRectLayer_OpType: return "DrawImageRectLayer";
        case kDrawOval_OpType: return "DrawOval";
        case kDrawPaint_OpType: return "DrawPaint";
        case kDrawPatch_OpType: return "DrawPatch";
        case kDrawPath_OpType: return "DrawPath";
        case kDrawArc_OpType: return "DrawArc";
        case kDrawPoints_OpType: return "DrawPoints";
        case kDrawRect_OpType: return "DrawRect";
        case kDrawRRect_OpType: return "DrawRRect";
        case kDrawRegion_OpType: return "DrawRegion";
        case kDrawShadow_OpType: return "DrawShadow";
        case kDrawTextBlob_OpType: return "DrawTextBlob";
        case kDrawVertices_OpType: return "DrawVertices";
        case kDrawAtlas_OpType: return "DrawAtlas";
        case kDrawDrawable_OpType: return "DrawDrawable";
        case kDrawEdgeAAQuad_OpType: return "DrawEdgeAAQuad";
        case kDrawEdgeAAImageSet_OpType: return "DrawEdgeAAImageSet";
        case kEndDrawPicture_OpType: return "EndDrawPicture";
        case kRestore_OpType: return "Restore";
        case kSave_OpType: return "Save";
        case kSaveLayer_OpType: return "SaveLayer";
        case kSetMatrix_OpType: return "SetMatrix";
        case kSetM44_OpType: return "SetM44";
        default:
            SkDebugf("OpType error 0x%08x\n", type);
            SkASSERT(0);
            break;
    }
    SkDEBUGFAIL("DrawType UNUSED\n");
    return nullptr;
}

getOpType()

OpType DrawCommand::getOpType ( ) const

inline

Definition at line 143 of file DrawCommand.h.

{ return fOpType; }

isVisible()

bool DrawCommand::isVisible ( ) const

inline

Definition at line 108 of file DrawCommand.h.

{ return fVisible; }

MakeJsonColor()

void DrawCommand::MakeJsonColor ( SkJSONWriter &  writer, const SkColor  color  )

static

Definition at line 400 of file DrawCommand.cpp.

                                                                         {
    writer.beginArray(nullptr, false);
    writer.appendS32(SkColorGetA(color));
    writer.appendS32(SkColorGetR(color));
    writer.appendS32(SkColorGetG(color));
    writer.appendS32(SkColorGetB(color));
    writer.endArray();
}

MakeJsonColor4f()

void DrawCommand::MakeJsonColor4f ( SkJSONWriter &  writer, const SkColor4f &  color  )

static

Definition at line 409 of file DrawCommand.cpp.

                                                                              {
    writer.beginArray(nullptr, false);
    writer.appendFloat(color.fA);
    writer.appendFloat(color.fR);
    writer.appendFloat(color.fG);
    writer.appendFloat(color.fB);
    writer.endArray();
}

MakeJsonIRect()

void DrawCommand::MakeJsonIRect ( SkJSONWriter &  writer, const SkIRect &  rect  )

static

Definition at line 449 of file DrawCommand.cpp.

                                                                         {
    writer.beginArray(nullptr, false);
    writer.appendS32(rect.left());
    writer.appendS32(rect.top());
    writer.appendS32(rect.right());
    writer.appendS32(rect.bottom());
    writer.endArray();
}

MakeJsonLattice()

void DrawCommand::MakeJsonLattice ( SkJSONWriter &  writer, const SkCanvas::Lattice &  lattice  )

static

Definition at line 972 of file DrawCommand.cpp.

                                                                                      {
    writer.beginObject();
    writer.appendS32(DEBUGCANVAS_ATTRIBUTE_LATTICEXCOUNT, lattice.fXCount);
    writer.appendS32(DEBUGCANVAS_ATTRIBUTE_LATTICEYCOUNT, lattice.fYCount);
    if (nullptr != lattice.fBounds) {
        writer.appendName(DEBUGCANVAS_ATTRIBUTE_BOUNDS);
        MakeJsonIRect(writer, *lattice.fBounds);
    }
    writer.beginArray(DEBUGCANVAS_ATTRIBUTE_LATTICEXDIVS);
    for (int i = 0; i < lattice.fXCount; i++) {
        writer.appendS32(lattice.fXDivs[i]);
    }
    writer.endArray();  // xdivs
    writer.beginArray(DEBUGCANVAS_ATTRIBUTE_LATTICEYDIVS);
    for (int i = 0; i < lattice.fYCount; i++) {
        writer.appendS32(lattice.fYDivs[i]);
    }
    writer.endArray();  // ydivs
    if (nullptr != lattice.fRectTypes) {
        writer.beginArray(DEBUGCANVAS_ATTRIBUTE_LATTICEFLAGS);
        int flagCount = 0;
        for (int row = 0; row < lattice.fYCount + 1; row++) {
            writer.beginArray();
            for (int column = 0; column < lattice.fXCount + 1; column++) {
                writer.appendS32(lattice.fRectTypes[flagCount++]);
            }
            writer.endArray();  // row
        }
        writer.endArray();
    }
    writer.endObject();
}

MakeJsonMatrix()

void DrawCommand::MakeJsonMatrix ( SkJSONWriter &  writer, const SkMatrix &  matrix  )

static

Definition at line 468 of file DrawCommand.cpp.

                                                                             {
    writer.beginArray();
    for (int r = 0; r < 3; ++r) {
        writer.beginArray(nullptr, false);
        for (int c = 0; c < 3; ++c) {
            writer.appendFloat(matrix[r * 3 + c]);
        }
        writer.endArray();
    }
    writer.endArray();
}

MakeJsonMatrix44()

void DrawCommand::MakeJsonMatrix44 ( SkJSONWriter &  writer, const SkM44 &  matrix  )

static

Definition at line 480 of file DrawCommand.cpp.

                                                                            {
    writer.beginArray();
    for (int r = 0; r < 4; ++r) {
        writer.beginArray(nullptr, false);
        for (int c = 0; c < 4; ++c) {
            writer.appendFloat(matrix.rc(r, c));
        }
        writer.endArray();
    }
    writer.endArray();
}

MakeJsonPaint()

void DrawCommand::MakeJsonPaint ( SkJSONWriter &  writer, const SkPaint &  paint, UrlDataManager &  urlDataManager  )

static

Definition at line 928 of file DrawCommand.cpp.

                                                                {
    writer.beginObject();
    store_scalar(writer, DEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
    store_scalar(writer,
                 DEBUGCANVAS_ATTRIBUTE_STROKEMITER,
                 paint.getStrokeMiter(),
                 SkPaintDefaults_MiterLimit);
    store_bool(writer, DEBUGCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
    store_bool(writer, DEBUGCANVAS_ATTRIBUTE_DITHER, paint.isDither(), false);
 
    apply_paint_color(paint, writer);
    apply_paint_style(paint, writer);
    apply_paint_blend_mode(paint, writer);
    apply_paint_cap(paint, writer);
    apply_paint_join(paint, writer);
    apply_paint_patheffect(paint, writer, urlDataManager);
    apply_paint_maskfilter(paint, writer, urlDataManager);
    apply_flattenable(DEBUGCANVAS_ATTRIBUTE_SHADER, paint.getShader(), writer, urlDataManager);
    apply_flattenable(
            DEBUGCANVAS_ATTRIBUTE_IMAGEFILTER, paint.getImageFilter(), writer, urlDataManager);
    apply_flattenable(
            DEBUGCANVAS_ATTRIBUTE_COLORFILTER, paint.getColorFilter(), writer, urlDataManager);
    writer.endObject();  // paint
}

MakeJsonPath()

void DrawCommand::MakeJsonPath ( SkJSONWriter &  writer, const SkPath &  path  )

static

Definition at line 492 of file DrawCommand.cpp.

                                                                       {
    writer.beginObject();
 
    SkDynamicMemoryWStream wstream;
    path.dump(&wstream, false);
    auto data = wstream.detachAsData();
    writer.appendString(DEBUGCANVAS_ATTRIBUTE_DUMP,
                        static_cast<const char*>(data->data()), data->size());
 
    switch (path.getFillType()) {
        case SkPathFillType::kWinding:
            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_WINDING);
            break;
        case SkPathFillType::kEvenOdd:
            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_EVENODD);
            break;
        case SkPathFillType::kInverseWinding:
            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,
                                 DEBUGCANVAS_FILLTYPE_INVERSEWINDING);
            break;
        case SkPathFillType::kInverseEvenOdd:
            writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,
                                 DEBUGCANVAS_FILLTYPE_INVERSEEVENODD);
            break;
    }
    writer.beginArray(DEBUGCANVAS_ATTRIBUTE_VERBS);
    SkPath::Iter iter(path, false);
    SkPoint      pts[4];
    SkPath::Verb verb;
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        if (verb == SkPath::kClose_Verb) {
            writer.appendNString(DEBUGCANVAS_VERB_CLOSE);
            continue;
        }
        writer.beginObject();  // verb
        switch (verb) {
            case SkPath::kLine_Verb: {
                writer.appendName(DEBUGCANVAS_VERB_LINE);
                MakeJsonPoint(writer, pts[1]);
                break;
            }
            case SkPath::kQuad_Verb: {
                writer.beginArray(DEBUGCANVAS_VERB_QUAD);
                MakeJsonPoint(writer, pts[1]);
                MakeJsonPoint(writer, pts[2]);
                writer.endArray();  // quad coords
                break;
            }
            case SkPath::kCubic_Verb: {
                writer.beginArray(DEBUGCANVAS_VERB_CUBIC);
                MakeJsonPoint(writer, pts[1]);
                MakeJsonPoint(writer, pts[2]);
                MakeJsonPoint(writer, pts[3]);
                writer.endArray();  // cubic coords
                break;
            }
            case SkPath::kConic_Verb: {
                writer.beginArray(DEBUGCANVAS_VERB_CONIC);
                MakeJsonPoint(writer, pts[1]);
                MakeJsonPoint(writer, pts[2]);
                writer.appendFloat(iter.conicWeight());
                writer.endArray();  // conic coords
                break;
            }
            case SkPath::kMove_Verb: {
                writer.appendName(DEBUGCANVAS_VERB_MOVE);
                MakeJsonPoint(writer, pts[0]);
                break;
            }
            case SkPath::kClose_Verb:
            case SkPath::kDone_Verb:
                // Unreachable
                break;
        }
        writer.endObject();  // verb
    }
    writer.endArray();   // verbs
    writer.endObject();  // path
}

MakeJsonPoint() [1/2]

void DrawCommand::MakeJsonPoint ( SkJSONWriter &  writer, const SkPoint &  point  )

static

Definition at line 418 of file DrawCommand.cpp.

                                                                          {
    writer.beginArray(nullptr, false);
    writer.appendFloat(point.x());
    writer.appendFloat(point.y());
    writer.endArray();
}

MakeJsonPoint() [2/2]

void DrawCommand::MakeJsonPoint ( SkJSONWriter &  writer, SkScalar  x, SkScalar  y  )

static

Definition at line 425 of file DrawCommand.cpp.

                                                                            {
    writer.beginArray(nullptr, false);
    writer.appendFloat(x);
    writer.appendFloat(y);
    writer.endArray();
}

MakeJsonPoint3()

void DrawCommand::MakeJsonPoint3 ( SkJSONWriter &  writer, const SkPoint3 &  point  )

static

Definition at line 432 of file DrawCommand.cpp.

                                                                            {
    writer.beginArray(nullptr, false);
    writer.appendFloat(point.x());
    writer.appendFloat(point.y());
    writer.appendFloat(point.z());
    writer.endArray();
}

MakeJsonRect()

void DrawCommand::MakeJsonRect ( SkJSONWriter &  writer, const SkRect &  rect  )

static

Definition at line 440 of file DrawCommand.cpp.

                                                                       {
    writer.beginArray(nullptr, false);
    writer.appendFloat(rect.left());
    writer.appendFloat(rect.top());
    writer.appendFloat(rect.right());
    writer.appendFloat(rect.bottom());
    writer.endArray();
}

MakeJsonRegion()

void DrawCommand::MakeJsonRegion ( SkJSONWriter &  writer, const SkRegion &  region  )

static

Definition at line 572 of file DrawCommand.cpp.

                                                                             {
    // TODO: Actually serialize the rectangles, rather than just devolving to path
    SkPath path;
    region.getBoundaryPath(&path);
    MakeJsonPath(writer, path);
}

MakeJsonSampling()

void DrawCommand::MakeJsonSampling ( SkJSONWriter &  writer, const SkSamplingOptions &  sampling  )

static

Definition at line 579 of file DrawCommand.cpp.

                                                                                          {
    writer.beginObject();
    writer.appendS32("maxAniso", sampling.maxAniso);
    writer.appendBool("useCubic", sampling.useCubic);
    writer.appendS32("filter", (int)sampling.filter);
    writer.appendS32("mipmap", (int)sampling.mipmap);
    writer.appendFloat("cubic.B", sampling.cubic.B);
    writer.appendFloat("cubic.C", sampling.cubic.C);
    writer.endObject();
}

render()

virtual bool DrawCommand::render ( SkCanvas *  canvas ) const

inlinevirtual

Reimplemented in ClipPathCommand, ClipRRectCommand, ClipShaderCommand, DrawImageCommand, DrawImageLatticeCommand, DrawImageRectCommand, DrawImageRectLayerCommand, DrawOvalCommand, DrawArcCommand, DrawPaintCommand, DrawBehindCommand, DrawPathCommand, BeginDrawPictureCommand, DrawPointsCommand, DrawRegionCommand, DrawTextBlobCommand, DrawRRectCommand, DrawDRRectCommand, and DrawShadowCommand.

Definition at line 114 of file DrawCommand.h.

{ return false; }

setVisible()

void DrawCommand::setVisible ( bool  toggle )

inline

Definition at line 110 of file DrawCommand.h.

{ fVisible = toggle; }

toJSON()

void DrawCommand::toJSON ( SkJSONWriter &  writer, UrlDataManager &  urlDataManager  ) const

virtual

Reimplemented in ClearCommand, ClipPathCommand, ClipRegionCommand, ClipRectCommand, ClipRRectCommand, ClipShaderCommand, ConcatCommand, Concat44Command, DrawAnnotationCommand, DrawImageCommand, DrawImageLatticeCommand, DrawImageRectCommand, DrawImageRectLayerCommand, DrawOvalCommand, DrawArcCommand, DrawPaintCommand, DrawBehindCommand, DrawPathCommand, DrawPointsCommand, DrawRegionCommand, DrawTextBlobCommand, DrawPatchCommand, DrawRectCommand, DrawRRectCommand, DrawDRRectCommand, SaveLayerCommand, SetMatrixCommand, SetM44Command, and DrawShadowCommand.

Definition at line 284 of file DrawCommand.cpp.

                                                                                   {
    writer.appendCString(DEBUGCANVAS_ATTRIBUTE_COMMAND, this->GetCommandString(fOpType));
    writer.appendBool(DEBUGCANVAS_ATTRIBUTE_VISIBLE, this->isVisible());
}

WritePNG()

void DrawCommand::WritePNG ( const SkBitmap &  bitmap, SkWStream &  out  )

static

Definition at line 650 of file DrawCommand.cpp.

                                                                 {
    SkPixmap pm;
    SkAssertResult(bitmap.peekPixels(&pm));
 
    SkPngEncoder::Options options;
    options.fZLibLevel   = 1;
    options.fFilterFlags = SkPngEncoder::FilterFlag::kNone;
    SkPngEncoder::Encode(&out, pm, options);
}

Member Data Documentation

kOpTypeCount

const int DrawCommand::kOpTypeCount = kLast_OpType + 1

static

Definition at line 100 of file DrawCommand.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/tools/debugger/DrawCommand.h
• third_party/skia/tools/debugger/DrawCommand.cpp