1 2This file contains a mapping from where these documumentation examples 3should be inserted into the headers. 4 5########################################################################### 6 7[AutoCanvasRestore_SkCanvas_star] 8SkAutoCanvasRestore 9SkAutoCanvasRestore(SkCanvas* canvas, bool doSave); 10 11[AutoCanvasRestore_restore] 12SkAutoCanvasRestore 13void restore(); 14 15[Bitmap_ComputeIsOpaque] 16SkBitmap 17static bool ComputeIsOpaque(const SkBitmap& bm); 18 19[Bitmap_empty_constructor] 20SkBitmap 21SkBitmap(); 22 23[Bitmap_move_SkBitmap] 24SkBitmap 25SkBitmap(SkBitmap&& src); 26 27[Bitmap_copy_const_SkBitmap] 28SkBitmap 29SkBitmap(const SkBitmap& src); 30 31[Bitmap_allocN32Pixels] 32SkBitmap 33void allocN32Pixels(int width, int height, bool isOpaque = false); 34 35[Bitmap_HeapAllocator_allocPixelRef] 36SkBitmap 37bool allocPixelRef(SkBitmap* bitmap) override; 38 39[Bitmap_allocPixels_3] 40SkBitmap 41void allocPixels(); 42 43[Bitmap_allocPixels_4] 44SkBitmap 45void allocPixels(Allocator* allocator); 46 47[Bitmap_allocPixels_2] 48SkBitmap 49void allocPixels(const SkImageInfo& info); 50 51[Bitmap_allocPixels] 52SkBitmap 53void allocPixels(const SkImageInfo& info, size_t rowBytes); 54 55[Bitmap_allocPixelsFlags] 56SkBitmap 57void allocPixelsFlags(const SkImageInfo& info, uint32_t flags); 58 59[Pixmap_alphaType] 60SkBitmap 61SkAlphaType alphaType() const; 62 63[Bitmap_bounds] 64SkBitmap 65SkIRect bounds() const; 66 67[Bitmap_bytesPerPixel] 68SkBitmap 69int bytesPerPixel() const; 70 71[Bitmap_colorSpace] 72SkBitmap 73SkColorSpace* colorSpace() const; 74 75[Bitmap_colorType] 76SkBitmap 77SkColorType colorType() const; 78 79[Bitmap_computeByteSize] 80SkBitmap 81size_t computeByteSize() const; 82 83[Bitmap_dimensions] 84SkBitmap 85SkISize dimensions() const; 86 87[Bitmap_drawsNothing] 88SkBitmap 89bool drawsNothing() const; 90 91[Bitmap_empty] 92SkBitmap 93bool empty() const; 94 95[Bitmap_erase] 96SkBitmap 97void erase(SkColor c, const SkIRect& area) const; 98 99[Bitmap_eraseARGB] 100SkBitmap 101void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const; 102 103[Bitmap_eraseColor] 104SkBitmap 105void eraseColor(SkColor c) const; 106 107[Bitmap_extractAlpha] 108SkBitmap 109bool extractAlpha(SkBitmap* dst) const; 110 111[Bitmap_extractAlpha_3] 112SkBitmap 113bool extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator, SkIPoint* offset) const; 114 115[Bitmap_extractAlpha_2] 116SkBitmap 117bool extractAlpha(SkBitmap* dst, const SkPaint* paint, SkIPoint* offset) const; 118 119[Bitmap_extractSubset] 120SkBitmap 121bool extractSubset(SkBitmap* dst, const SkIRect& subset) const; 122 123[Bitmap_getAddr] 124SkBitmap 125void* getAddr(int x, int y) const; 126 127[Bitmap_getAddr16] 128SkBitmap 129uint16_t* getAddr16(int x, int y) const; 130 131[Bitmap_getAddr32] 132SkBitmap 133uint32_t* getAddr32(int x, int y) const; 134 135[Bitmap_getAddr8] 136SkBitmap 137uint8_t* getAddr8(int x, int y) const; 138 139[Bitmap_getBounds_2] 140SkBitmap 141void getBounds(SkIRect* bounds) const; 142 143[Bitmap_getBounds] 144SkBitmap 145void getBounds(SkRect* bounds) const; 146 147[Bitmap_getColor] 148SkBitmap 149SkColor getColor(int x, int y) const; 150 151[Bitmap_getGenerationID] 152SkBitmap 153uint32_t getGenerationID() const; 154 155[Bitmap_getPixels] 156SkBitmap 157void* getPixels() const; 158 159[Bitmap_getSubset] 160SkBitmap 161SkIRect getSubset() const; 162 163[Bitmap_height] 164SkBitmap 165int height() const; 166 167[Bitmap_info] 168SkBitmap 169const SkImageInfo& info() const; 170 171[Bitmap_installPixels_2] 172SkBitmap 173bool installPixels(const SkImageInfo& info, void* pixels, size_t rowBytes); 174 175[Bitmap_installPixels] 176SkBitmap 177bool installPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, void (*releaseProc) (void* addr, void* context) , void* context); 178 179[Bitmap_installPixels_3] 180SkBitmap 181bool installPixels(const SkPixmap& pixmap); 182 183[Bitmap_isImmutable] 184SkBitmap 185bool isImmutable() const; 186 187[Bitmap_isNull] 188SkBitmap 189bool isNull() const; 190 191[Bitmap_isOpaque] 192SkBitmap 193bool isOpaque() const; 194 195[Bitmap_isVolatile] 196SkBitmap 197bool isVolatile() const; 198 199[Bitmap_notifyPixelsChanged] 200SkBitmap 201void notifyPixelsChanged() const; 202 203[Bitmap_move_operator] 204SkBitmap 205SkBitmap& operator=(SkBitmap&& src); 206 207[Bitmap_copy_operator] 208SkBitmap 209SkBitmap& operator=(const SkBitmap& src); 210 211[Bitmap_peekPixels] 212SkBitmap 213bool peekPixels(SkPixmap* pixmap) const; 214 215[Bitmap_pixelRef] 216SkBitmap 217SkPixelRef* pixelRef() const; 218 219[Bitmap_pixelRefOrigin] 220SkBitmap 221SkIPoint pixelRefOrigin() const; 222 223[Bitmap_pixmap] 224SkBitmap 225const SkPixmap& pixmap() const; 226 227[Bitmap_readPixels] 228SkBitmap 229bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY) const; 230 231[Bitmap_readPixels_3] 232SkBitmap 233bool readPixels(const SkPixmap& dst) const; 234 235[Bitmap_readPixels_2] 236SkBitmap 237bool readPixels(const SkPixmap& dst, int srcX, int srcY) const; 238 239[Bitmap_readyToDraw] 240SkBitmap 241bool readyToDraw() const; 242 243[Bitmap_refColorSpace] 244SkBitmap 245sk_sp<SkColorSpace> refColorSpace() const; 246 247[Bitmap_reset] 248SkBitmap 249void reset(); 250 251[Bitmap_rowBytes] 252SkBitmap 253size_t rowBytes() const; 254 255[Bitmap_rowBytesAsPixels] 256SkBitmap 257int rowBytesAsPixels() const; 258 259[Bitmap_setAlphaType] 260SkBitmap 261bool setAlphaType(SkAlphaType alphaType); 262 263[Bitmap_setImmutable] 264SkBitmap 265void setImmutable(); 266 267[Bitmap_setInfo] 268SkBitmap 269bool setInfo(const SkImageInfo& imageInfo, size_t rowBytes = 0); 270 271[Bitmap_setIsVolatile] 272SkBitmap 273void setIsVolatile(bool isVolatile); 274 275[Bitmap_setPixelRef] 276SkBitmap 277void setPixelRef(sk_sp<SkPixelRef> pixelRef, int dx, int dy); 278 279[Bitmap_setPixels] 280SkBitmap 281void setPixels(void* pixels); 282 283[Bitmap_shiftPerPixel] 284SkBitmap 285int shiftPerPixel() const; 286 287[Bitmap_swap] 288SkBitmap 289void swap(SkBitmap& other); 290 291[Bitmap_tryAllocN32Pixels] 292SkBitmap 293bool tryAllocN32Pixels(int width, int height, bool isOpaque = false); 294 295[Bitmap_tryAllocPixels_3] 296SkBitmap 297bool tryAllocPixels(); 298 299[Bitmap_tryAllocPixels_4] 300SkBitmap 301bool tryAllocPixels(Allocator* allocator); 302 303[Bitmap_tryAllocPixels_2] 304SkBitmap 305bool tryAllocPixels(const SkImageInfo& info); 306 307[Bitmap_tryAllocPixels] 308SkBitmap 309bool tryAllocPixels(const SkImageInfo& info, size_t rowBytes); 310 311[Bitmap_tryAllocPixelsFlags] 312SkBitmap 313bool tryAllocPixelsFlags(const SkImageInfo& info, uint32_t flags); 314 315[Bitmap_width] 316SkBitmap 317int width() const; 318 319[Bitmap_writePixels_2] 320SkBitmap 321bool writePixels(const SkPixmap& src); 322 323[Bitmap_writePixels] 324SkBitmap 325bool writePixels(const SkPixmap& src, int dstX, int dstY); 326 327[BlendMode_Name] 328SkBlendMode 329const char* SkBlendMode_Name(SkBlendMode blendMode); 330 331[Clear] 332[Color] 333[Color_Burn] 334[Color_Dodge] 335[Darken] 336[Difference] 337[Dst] 338[Dst_Atop] 339[Dst_In] 340[Dst_Out] 341[Dst_Over] 342[Exclusion] 343[Hard_Light] 344[Hue] 345[Lighten] 346[Luminosity] 347[Modulate] 348[Multiply] 349[Overlay] 350[Plus] 351[Saturation] 352[Screen] 353[Soft_Light] 354[Src] 355[Src_Atop] 356[Src_In] 357[Src_Out] 358[Src_Over] 359[Xor] 360SkBlendMode 361enum class SkBlendMode { kClear, kSrc, kDst, kSrcOver, kDstOver, kSrcIn, kDstIn, kSrcOut, kDstOut, kSrcATop, kDstATop, kXor, kPlus, kModulate, kScreen, kLastCoeffMode = kScreen, kOverlay, kDarken, kLighten, kColorDodge, kColorBurn, kHardLight, kSoftLight, kDifference, kExclusion, kMultiply, kLastSeparableMode = kMultiply, kHue, kSaturation, kColor, kLuminosity, kLastMode = kLuminosity, }; const char* SkBlendMode_Name(SkBlendMode blendMode); 362 363[Canvas_MakeRasterDirect] 364SkCanvas 365static std::unique_ptr<SkCanvas> MakeRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes, const SkSurfaceProps* props = nullptr); 366 367[Canvas_MakeRasterDirectN32] 368SkCanvas 369static std::unique_ptr<SkCanvas> MakeRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes); 370 371[Canvas_SaveLayerRec] 372SkCanvas 373struct SaveLayerRec { SaveLayerRec(); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, SaveLayerFlags saveLayerFlags); const SkRect* fBounds = nullptr; const SkPaint* fPaint = nullptr; const SkImageFilter* fBackdrop = nullptr; const SkImage* fClipMask = nullptr; const SkMatrix* fClipMatrix = nullptr; SaveLayerFlags fSaveLayerFlags = 0; }; 374 375[Canvas_SaveLayerRec_SaveLayerRec] 376SkCanvas 377SaveLayerRec(); 378 379[Canvas_SaveLayerRec_const_SkRect_star_const_SkPaint_star] 380SkCanvas 381SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0); 382 383[Canvas_SaveLayerRec_const_SkRect_star_const_SkPaint_star_const_SkImageFilter_star] 384SkCanvas 385SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, SaveLayerFlags saveLayerFlags); 386 387[Canvas_copy_const_SkBitmap] 388SkCanvas 389explicit SkCanvas(const SkBitmap& bitmap); 390 391[Canvas_empty_constructor] 392SkCanvas 393SkCanvas(); 394 395[Canvas_const_SkBitmap_const_SkSurfaceProps] 396SkCanvas 397SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props); 398 399[Canvas_int_int_const_SkSurfaceProps_star] 400SkCanvas 401SkCanvas(int width, int height, const SkSurfaceProps* props = nullptr); 402 403[Canvas_accessTopLayerPixels_a] 404[Canvas_accessTopLayerPixels_b] 405SkCanvas 406void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin = nullptr); 407 408[Canvas_accessTopRasterHandle] 409SkCanvas 410SkRasterHandleAllocator::Handle accessTopRasterHandle() const; 411 412[Canvas_clear] 413SkCanvas 414void clear(SkColor color); 415 416[Canvas_clipPath_2] 417SkCanvas 418void clipPath(const SkPath& path, SkClipOp op); 419 420[Canvas_clipPath] 421SkCanvas 422void clipPath(const SkPath& path, SkClipOp op, bool doAntiAlias); 423 424[Canvas_clipPath_3] 425SkCanvas 426void clipPath(const SkPath& path, bool doAntiAlias = false); 427 428[Canvas_clipRRect_2] 429SkCanvas 430void clipRRect(const SkRRect& rrect, SkClipOp op); 431 432[Canvas_clipRRect] 433SkCanvas 434void clipRRect(const SkRRect& rrect, SkClipOp op, bool doAntiAlias); 435 436[Canvas_clipRRect_3] 437SkCanvas 438void clipRRect(const SkRRect& rrect, bool doAntiAlias = false); 439 440[Canvas_clipRect_2] 441SkCanvas 442void clipRect(const SkRect& rect, SkClipOp op); 443 444[Canvas_clipRect] 445SkCanvas 446void clipRect(const SkRect& rect, SkClipOp op, bool doAntiAlias); 447 448[Canvas_clipRect_3] 449SkCanvas 450void clipRect(const SkRect& rect, bool doAntiAlias = false); 451 452[Canvas_clipRegion] 453SkCanvas 454void clipRegion(const SkRegion& deviceRgn, SkClipOp op = SkClipOp::kIntersect); 455 456[Canvas_concat] 457SkCanvas 458void concat(const SkMatrix& matrix); 459 460[Canvas_drawAnnotation_2] 461SkCanvas 462void drawAnnotation(const SkRect& rect, const char key[], SkData* value); 463 464[Canvas_drawAnnotation_2] 465SkCanvas 466void drawAnnotation(const SkRect& rect, const char key[], const sk_sp<SkData>& value); 467 468[Canvas_drawArc_a] 469[Canvas_drawArc_b] 470SkCanvas 471void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint); 472 473[Canvas_drawAtlas] 474SkCanvas 475void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint); 476 477[Canvas_drawAtlas_3] 478SkCanvas 479void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint); 480 481[Canvas_drawAtlas_2] 482SkCanvas 483void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint); 484 485[Canvas_drawAtlas_4] 486SkCanvas 487void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint); 488 489[Canvas_drawBitmap] 490SkCanvas 491void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint = nullptr); 492 493[Canvas_drawBitmapLattice] 494SkCanvas 495void drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr); 496 497[Canvas_drawBitmapRect_2] 498SkCanvas 499void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 500 501[Canvas_drawBitmapRect_3] 502SkCanvas 503void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 504 505[Canvas_drawBitmapRect] 506SkCanvas 507void drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 508 509[Canvas_drawCircle_2] 510SkCanvas 511void drawCircle(SkPoint center, SkScalar radius, const SkPaint& paint); 512 513[Canvas_drawCircle] 514SkCanvas 515void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint); 516 517[Canvas_drawColor] 518SkCanvas 519void drawColor(SkColor color, SkBlendMode mode = SkBlendMode::kSrcOver); 520 521[Canvas_drawDRRect_a] 522[Canvas_drawDRRect_b] 523SkCanvas 524void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint); 525 526[Canvas_drawDrawable_2] 527SkCanvas 528void drawDrawable(SkDrawable* drawable, SkScalar x, SkScalar y); 529 530[Canvas_drawDrawable] 531SkCanvas 532void drawDrawable(SkDrawable* drawable, const SkMatrix* matrix = nullptr); 533 534[Canvas_drawIRect] 535SkCanvas 536void drawIRect(const SkIRect& rect, const SkPaint& paint); 537 538[Canvas_drawImage] 539SkCanvas 540void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr); 541 542[Canvas_drawImage_2] 543SkCanvas 544void drawImage(const sk_sp<SkImage>& image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr); 545 546[Canvas_drawImageNine] 547SkCanvas 548void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr); 549 550[Canvas_drawImageNine] 551SkCanvas 552void drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr); 553 554[Canvas_drawImageNine_2] 555SkCanvas 556void drawImageNine(const sk_sp<SkImage>& image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr); 557 558[Canvas_drawImageRect_2] 559SkCanvas 560void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 561 562[Canvas_drawImageRect_3] 563SkCanvas 564void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint); 565 566[Canvas_drawImageRect] 567SkCanvas 568void drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 569 570[Canvas_drawImageRect_5] 571SkCanvas 572void drawImageRect(const sk_sp<SkImage>& image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 573 574[Canvas_drawImageRect_6] 575SkCanvas 576void drawImageRect(const sk_sp<SkImage>& image, const SkRect& dst, const SkPaint* paint); 577 578[Canvas_drawImageRect_4] 579SkCanvas 580void drawImageRect(const sk_sp<SkImage>& image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); 581 582[Canvas_drawLine_2] 583SkCanvas 584void drawLine(SkPoint p0, SkPoint p1, const SkPaint& paint); 585 586[Canvas_drawLine] 587SkCanvas 588void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint); 589 590[Canvas_drawOval] 591SkCanvas 592void drawOval(const SkRect& oval, const SkPaint& paint); 593 594[Canvas_drawPaint] 595SkCanvas 596void drawPaint(const SkPaint& paint); 597 598[Canvas_drawPatch] 599SkCanvas 600void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint); 601 602[Canvas_drawPatch_2_a] 603[Canvas_drawPatch_2_b] 604SkCanvas 605void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], const SkPaint& paint); 606 607[Canvas_drawPath] 608SkCanvas 609void drawPath(const SkPath& path, const SkPaint& paint); 610 611[Canvas_drawPicture_2] 612SkCanvas 613void drawPicture(const SkPicture* picture); 614 615[Canvas_drawPicture_3] 616SkCanvas 617void drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint); 618 619[Canvas_drawPicture_2] 620SkCanvas 621void drawPicture(const sk_sp<SkPicture>& picture); 622 623[Canvas_drawPicture_4] 624SkCanvas 625void drawPicture(const sk_sp<SkPicture>& picture, const SkMatrix* matrix, const SkPaint* paint); 626 627[Canvas_drawPoint_2] 628SkCanvas 629void drawPoint(SkPoint p, const SkPaint& paint); 630 631[Canvas_drawPoint] 632SkCanvas 633void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint); 634 635[Canvas_drawPoints] 636SkCanvas 637void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint); 638 639[Canvas_drawPosText] 640SkCanvas 641void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint& paint); 642 643[Canvas_drawPosTextH] 644SkCanvas 645void drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, const SkPaint& paint); 646 647[Canvas_drawRRect] 648SkCanvas 649void drawRRect(const SkRRect& rrect, const SkPaint& paint); 650 651[Canvas_drawRect] 652SkCanvas 653void drawRect(const SkRect& rect, const SkPaint& paint); 654 655[Canvas_drawRegion] 656SkCanvas 657void drawRegion(const SkRegion& region, const SkPaint& paint); 658 659[Canvas_drawRoundRect] 660SkCanvas 661void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, const SkPaint& paint); 662 663[Canvas_drawString_2] 664SkCanvas 665void drawString(const SkString& string, SkScalar x, SkScalar y, const SkPaint& paint); 666 667[Canvas_drawString] 668SkCanvas 669void drawString(const char* string, SkScalar x, SkScalar y, const SkPaint& paint); 670 671[Canvas_drawText] 672SkCanvas 673void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint); 674 675[Canvas_drawTextBlob] 676SkCanvas 677void drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint); 678 679[Canvas_drawTextBlob_2] 680SkCanvas 681void drawTextBlob(const sk_sp<SkTextBlob>& blob, SkScalar x, SkScalar y, const SkPaint& paint); 682 683[Canvas_drawTextRSXform] 684SkCanvas 685void drawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[], const SkRect* cullRect, const SkPaint& paint); 686 687[Canvas_drawVertices] 688SkCanvas 689void drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint); 690 691[Canvas_drawVertices_2] 692SkCanvas 693void drawVertices(const sk_sp<SkVertices>& vertices, SkBlendMode mode, const SkPaint& paint); 694 695[Canvas_PointMode] 696SkCanvas 697enum PointMode { kPoints_PointMode, kLines_PointMode, kPolygon_PointMode, }; 698 699[Canvas_kInitWithPrevious_SaveLayerFlag] 700SkCanvas 701enum SaveLayerFlagsSet { kPreserveLCDText_SaveLayerFlag = 1 << 1, kInitWithPrevious_SaveLayerFlag = 1 << 2, }; 702 703[Canvas_SrcRectConstraint] 704SkCanvas 705enum SrcRectConstraint { kStrict_SrcRectConstraint, kFast_SrcRectConstraint, }; 706 707[Canvas_getBaseLayerSize] 708SkCanvas 709virtual SkISize getBaseLayerSize() const; 710 711[Canvas_getDeviceClipBounds] 712SkCanvas 713SkIRect getDeviceClipBounds() const; 714 715[Canvas_getDeviceClipBounds_2] 716SkCanvas 717bool getDeviceClipBounds(SkIRect* bounds) const; 718 719[Canvas_getGrContext] 720SkCanvas 721virtual GrContext* getGrContext(); 722 723[Canvas_getLocalClipBounds] 724SkCanvas 725SkRect getLocalClipBounds() const; 726 727[Canvas_getLocalClipBounds_2] 728SkCanvas 729bool getLocalClipBounds(SkRect* bounds) const; 730 731[Canvas_getProps] 732SkCanvas 733bool getProps(SkSurfaceProps* props) const; 734 735[Canvas_getSaveCount] 736SkCanvas 737int getSaveCount() const; 738 739[Canvas_getTotalMatrix] 740[Clip] 741SkCanvas 742const SkMatrix& getTotalMatrix() const; 743 744[Canvas_imageInfo] 745SkCanvas 746SkImageInfo imageInfo() const; 747 748[Canvas_isClipEmpty] 749SkCanvas 750virtual bool isClipEmpty() const; 751 752[Canvas_isClipRect] 753SkCanvas 754virtual bool isClipRect() const; 755 756[Canvas_makeSurface] 757SkCanvas 758sk_sp<SkSurface> makeSurface(const SkImageInfo& info, const SkSurfaceProps* props = nullptr); 759 760[Canvas_peekPixels] 761SkCanvas 762bool peekPixels(SkPixmap* pixmap); 763 764[Canvas_quickReject_2] 765SkCanvas 766bool quickReject(const SkPath& path) const; 767 768[Canvas_quickReject] 769SkCanvas 770bool quickReject(const SkRect& rect) const; 771 772[Canvas_readPixels_3] 773SkCanvas 774bool readPixels(const SkBitmap& bitmap, int srcX, int srcY); 775 776[Canvas_readPixels_a] 777[Canvas_readPixels_b] 778SkCanvas 779bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY); 780 781[Canvas_readPixels_2] 782SkCanvas 783bool readPixels(const SkPixmap& pixmap, int srcX, int srcY); 784 785[Canvas_resetMatrix] 786SkCanvas 787void resetMatrix(); 788 789[Canvas_restore] 790SkCanvas 791void restore(); 792 793[Canvas_restoreToCount] 794SkCanvas 795void restoreToCount(int saveCount); 796 797[Canvas_rotate] 798SkCanvas 799void rotate(SkScalar degrees); 800 801[Canvas_rotate_2] 802SkCanvas 803void rotate(SkScalar degrees, SkScalar px, SkScalar py); 804 805[Canvas_save] 806SkCanvas 807int save(); 808 809[Canvas_saveLayer_3] 810SkCanvas 811int saveLayer(const SaveLayerRec& layerRec); 812 813[Canvas_saveLayer_2] 814SkCanvas 815int saveLayer(const SkRect& bounds, const SkPaint* paint); 816 817[Canvas_saveLayer] 818SkCanvas 819int saveLayer(const SkRect* bounds, const SkPaint* paint); 820 821[Canvas_saveLayerAlpha] 822SkCanvas 823int saveLayerAlpha(const SkRect* bounds, U8CPU alpha); 824 825[Canvas_saveLayerPreserveLCDTextRequests] 826SkCanvas 827int saveLayerPreserveLCDTextRequests(const SkRect* bounds, const SkPaint* paint); 828 829[Canvas_scale] 830SkCanvas 831void scale(SkScalar sx, SkScalar sy); 832 833[Canvas_setMatrix] 834SkCanvas 835void setMatrix(const SkMatrix& matrix); 836 837[Canvas_skew] 838SkCanvas 839void skew(SkScalar sx, SkScalar sy); 840 841[Canvas_translate] 842SkCanvas 843void translate(SkScalar dx, SkScalar dy); 844 845[Canvas_writePixels_2] 846[State_Stack_a] 847[State_Stack_b] 848SkCanvas 849bool writePixels(const SkBitmap& bitmap, int x, int y); 850 851[Canvas_writePixels] 852SkCanvas 853bool writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y); 854 855[Canvas_destructor] 856SkCanvas 857virtual ~SkCanvas(); 858 859[ColorGetA] 860SkColor 861#define SkColorGetA(color) (((color) >> 24) & 0xFF) color; 862 863[ColorGetB] 864SkColor 865#define SkColorGetB(color) (((color) >> 0) & 0xFF) color; 866 867[ColorGetG] 868SkColor 869#define SkColorGetG(color) (((color) >> 8) & 0xFF) color; 870 871[ColorGetR] 872SkColor 873#define SkColorGetR(color) (((color) >> 16) & 0xFF) color; 874 875[ColorSetA] 876SkColor 877static constexpr inline SkColor SkColorSetA(SkColor c, U8CPU a); 878 879[ColorSetRGB] 880SkColor 881#define SkColorSetRGB(r, g, b) SkColorSetARGB(0xFF, r, g, b) r g b; 882 883[ColorSetARGB] 884SkColor 885static constexpr inline SkColor SkColorSetARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b); 886 887[ColorToHSV] 888SkColor 889static void SkColorToHSV(SkColor color, SkScalar hsv[3]); 890 891[HSVToColor] 892SkColor 893SkColor SkHSVToColor(U8CPU alpha, const SkScalar hsv[3]); 894 895[HSVToColor_2] 896SkColor 897static SkColor SkHSVToColor(const SkScalar hsv[3]); 898 899[PreMultiplyARGB] 900SkColor 901SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b); 902 903[PreMultiplyColor] 904SkColor 905SkPMColor SkPreMultiplyColor(SkColor c); 906 907[RGBToHSV] 908SkColor 909void SkRGBToHSV(U8CPU red, U8CPU green, U8CPU blue, SkScalar hsv[3]); 910 911[Alpha_Constants_a] 912[Alpha_Constants_b] 913SkColor 914constexpr SkAlpha SK_AlphaTRANSPARENT = 0x00; constexpr SkAlpha SK_AlphaOPAQUE = 0xFF; 915 916[Color_Constants_a] 917[Color_Constants_b] 918[Color_Constants_c] 919[Color_Constants_d] 920SkColor 921constexpr SkColor SK_ColorTRANSPARENT; constexpr SkColor SK_ColorBLACK; constexpr SkColor SK_ColorDKGRAY; constexpr SkColor SK_ColorGRAY; constexpr SkColor SK_ColorLTGRAY; constexpr SkColor SK_ColorWHITE; constexpr SkColor SK_ColorRED; constexpr SkColor SK_ColorGREEN; constexpr SkColor SK_ColorBLUE; constexpr SkColor SK_ColorYELLOW; constexpr SkColor SK_ColorCYAN; constexpr SkColor SK_ColorMAGENTA; 922 923[RGBA4f_FromColor] 924SkColor4f 925static SkRGBA4f FromColor(SkColor color); 926 927[RGBA4f_notequal1_operator] 928SkColor4f 929bool operator!=(const SkRGBA4f& other) const; 930 931[RGBA4f_equal1_operator] 932SkColor4f 933bool operator==(const SkRGBA4f& other) const; 934 935[RGBA4f_toSkColor] 936SkColor4f 937SkColor toSkColor() const; 938 939[RGBA4f_vec] 940SkColor4f 941const float* vec() const; 942 943[RGBA4f_vec_2] 944SkColor4f 945float* vec(); 946 947[Font_breakText] 948SkFont 949size_t breakText(const void* text, size_t length, SkTextEncoding encoding, SkScalar maxWidth, SkScalar* measuredWidth = nullptr) const; 950 951[IPoint_Make] 952SkIPoint 953static constexpr SkIPoint Make(int32_t x, int32_t y); 954 955[IPoint_equals] 956SkIPoint 957bool equals(int32_t x, int32_t y) const; 958 959[IPoint_isZero] 960SkIPoint 961bool isZero() const; 962 963[IPoint_notequal_operator] 964SkIPoint 965bool operator!=(const SkIPoint& a, const SkIPoint& b); 966 967[IPoint_add_operator] 968SkIPoint 969SkIPoint operator+(const SkIPoint& a, const SkIVector& b); 970 971[IPoint_addto_operator] 972SkIPoint 973void operator+=(const SkIVector& v); 974 975[IPoint_minus_operator] 976SkIPoint 977SkIPoint operator-() const; 978 979[IPoint_subtract_operator] 980SkIPoint 981SkIVector operator-(const SkIPoint& a, const SkIPoint& b); 982 983[IPoint_subtractfrom_operator] 984SkIPoint 985void operator-=(const SkIVector& v); 986 987[IPoint_equal_operator] 988SkIPoint 989bool operator==(const SkIPoint& a, const SkIPoint& b); 990 991[IPoint_set] 992SkIPoint 993void set(int32_t x, int32_t y); 994 995[IPoint_x] 996SkIPoint 997int32_t x() const; 998 999[IPoint_y] 1000SkIPoint 1001int32_t y() const; 1002 1003[IRect_Intersects] 1004SkIRect 1005static bool Intersects(const SkIRect& a, const SkIRect& b); 1006 1007[IRect_IntersectsNoEmptyCheck] 1008SkIRect 1009static bool IntersectsNoEmptyCheck(const SkIRect& a, const SkIRect& b); 1010 1011[IRect_MakeEmpty] 1012SkIRect 1013static constexpr SkIRect MakeEmpty(); 1014 1015[IRect_MakeLTRB] 1016SkIRect 1017static constexpr SkIRect MakeLTRB(int32_t l, int32_t t, int32_t r, int32_t b); 1018 1019[IRect_MakeSize] 1020SkIRect 1021static constexpr SkIRect MakeSize(const SkISize& size); 1022 1023[IRect_MakeWH] 1024SkIRect 1025static constexpr SkIRect MakeWH(int32_t w, int32_t h); 1026 1027[IRect_MakeXYWH] 1028SkIRect 1029static constexpr SkIRect MakeXYWH(int32_t x, int32_t y, int32_t w, int32_t h); 1030 1031[IRect_adjust] 1032SkIRect 1033void adjust(int32_t dL, int32_t dT, int32_t dR, int32_t dB); 1034 1035[IRect_bottom] 1036SkIRect 1037int32_t bottom() const; 1038 1039[IRect_contains_3] 1040SkIRect 1041bool contains(const SkIRect& r) const; 1042 1043[IRect_contains_4] 1044SkIRect 1045bool contains(const SkRect& r) const; 1046 1047[IRect_contains_2] 1048SkIRect 1049bool contains(int32_t left, int32_t top, int32_t right, int32_t bottom) const; 1050 1051[IRect_contains] 1052SkIRect 1053bool contains(int32_t x, int32_t y) const; 1054 1055[IRect_containsNoEmptyCheck_2] 1056SkIRect 1057bool containsNoEmptyCheck(const SkIRect& r) const; 1058 1059[IRect_containsNoEmptyCheck] 1060SkIRect 1061bool containsNoEmptyCheck(int32_t left, int32_t top, int32_t right, int32_t bottom) const; 1062 1063[IRect_height] 1064SkIRect 1065int32_t height() const; 1066 1067[IRect_height64] 1068SkIRect 1069int64_t height64() const; 1070 1071[IRect_inset] 1072SkIRect 1073void inset(int32_t dx, int32_t dy); 1074 1075[IRect_intersect_2] 1076SkIRect 1077bool intersect(const SkIRect& a, const SkIRect& b); 1078 1079[IRect_intersect] 1080SkIRect 1081bool intersect(const SkIRect& r); 1082 1083[IRect_intersect_3] 1084SkIRect 1085bool intersect(int32_t left, int32_t top, int32_t right, int32_t bottom); 1086 1087[IRect_intersectNoEmptyCheck] 1088SkIRect 1089bool intersectNoEmptyCheck(const SkIRect& a, const SkIRect& b); 1090 1091[IRect_isEmpty] 1092SkIRect 1093bool isEmpty() const; 1094 1095[IRect_isEmpty64] 1096SkIRect 1097bool isEmpty64() const; 1098 1099[IRect_join_2] 1100SkIRect 1101void join(const SkIRect& r); 1102 1103[IRect_join] 1104SkIRect 1105void join(int32_t left, int32_t top, int32_t right, int32_t bottom); 1106 1107[IRect_left] 1108SkIRect 1109int32_t left() const; 1110 1111[IRect_makeInset] 1112SkIRect 1113SkIRect makeInset(int32_t dx, int32_t dy) const; 1114 1115[IRect_makeOffset] 1116SkIRect 1117SkIRect makeOffset(int32_t dx, int32_t dy) const; 1118 1119[IRect_makeOutset] 1120SkIRect 1121SkIRect makeOutset(int32_t dx, int32_t dy) const; 1122 1123[IRect_makeSorted] 1124SkIRect 1125SkIRect makeSorted() const; 1126 1127[IRect_offset_2] 1128SkIRect 1129void offset(const SkIPoint& delta); 1130 1131[IRect_offset] 1132SkIRect 1133void offset(int32_t dx, int32_t dy); 1134 1135[IRect_offsetTo] 1136SkIRect 1137void offsetTo(int32_t newX, int32_t newY); 1138 1139[IRect_notequal_operator] 1140SkIRect 1141bool operator!=(const SkIRect& a, const SkIRect& b); 1142 1143[IRect_equal_operator] 1144SkIRect 1145bool operator==(const SkIRect& a, const SkIRect& b); 1146 1147[IRect_outset] 1148SkIRect 1149void outset(int32_t dx, int32_t dy); 1150 1151[IRect_right] 1152SkIRect 1153int32_t right() const; 1154 1155[IRect_set] 1156SkIRect 1157void set(int32_t left, int32_t top, int32_t right, int32_t bottom); 1158 1159[IRect_setEmpty] 1160SkIRect 1161void setEmpty(); 1162 1163[IRect_setLTRB] 1164SkIRect 1165void setLTRB(int32_t left, int32_t top, int32_t right, int32_t bottom); 1166 1167[IRect_setXYWH] 1168SkIRect 1169void setXYWH(int32_t x, int32_t y, int32_t width, int32_t height); 1170 1171[IRect_size] 1172SkIRect 1173SkISize size() const; 1174 1175[IRect_sort] 1176SkIRect 1177void sort(); 1178 1179[IRect_top] 1180SkIRect 1181int32_t top() const; 1182 1183[IRect_width] 1184SkIRect 1185int32_t width() const; 1186 1187[IRect_width64] 1188SkIRect 1189int64_t width64() const; 1190 1191[IRect_x] 1192SkIRect 1193int32_t x() const; 1194 1195[IRect_y] 1196SkIRect 1197int32_t y() const; 1198 1199[Image_MakeBackendTextureFromSkImage] 1200SkImage 1201static bool MakeBackendTextureFromSkImage(GrContext* context, sk_sp<SkImage> image, GrBackendTexture* backendTexture, BackendTextureReleaseProc* backendTextureReleaseProc); 1202 1203[Image_MakeCrossContextFromPixmap] 1204SkImage 1205static sk_sp<SkImage> MakeCrossContextFromPixmap(GrContext* context, const SkPixmap& pixmap, bool buildMips, bool limitToMaxTextureSize = false); 1206 1207[Image_MakeFromAdoptedTexture] 1208SkImage 1209static sk_sp<SkImage> MakeFromAdoptedTexture(GrContext* context, const GrBackendTexture& backendTexture, GrSurfaceOrigin surfaceOrigin, SkColorType colorType, SkAlphaType alphaType = kPremul_SkAlphaType, sk_sp<SkColorSpace> colorSpace = nullptr); 1210 1211[Image_MakeFromBitmap] 1212SkImage 1213static sk_sp<SkImage> MakeFromBitmap(const SkBitmap& bitmap); 1214 1215[Image_MakeFromEncoded] 1216SkImage 1217static sk_sp<SkImage> MakeFromEncoded(sk_sp<SkData> encoded, const SkIRect* subset = nullptr); 1218 1219[Image_MakeFromGenerator] 1220SkImage 1221static sk_sp<SkImage> MakeFromGenerator(std::unique_ptr<SkImageGenerator> imageGenerator, const SkIRect* subset = nullptr); 1222 1223[Image_MakeFromPicture] 1224SkImage 1225static sk_sp<SkImage> MakeFromPicture(sk_sp<SkPicture> picture, const SkISize& dimensions, const SkMatrix* matrix, const SkPaint* paint, BitDepth bitDepth, sk_sp<SkColorSpace> colorSpace); 1226 1227[Image_MakeFromRaster] 1228SkImage 1229static sk_sp<SkImage> MakeFromRaster(const SkPixmap& pixmap, RasterReleaseProc rasterReleaseProc, ReleaseContext releaseContext); 1230 1231[Image_MakeFromTexture] 1232SkImage 1233static sk_sp<SkImage> MakeFromTexture(GrContext* context, const GrBackendTexture& backendTexture, GrSurfaceOrigin origin, SkColorType colorType, SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace); 1234 1235[Image_MakeFromTexture_2] 1236SkImage 1237static sk_sp<SkImage> MakeFromTexture(GrContext* context, const GrBackendTexture& backendTexture, GrSurfaceOrigin origin, SkColorType colorType, SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace, TextureReleaseProc textureReleaseProc, ReleaseContext releaseContext); 1238 1239[Image_MakeRasterCopy] 1240SkImage 1241static sk_sp<SkImage> MakeRasterCopy(const SkPixmap& pixmap); 1242 1243[Image_MakeRasterData] 1244SkImage 1245static sk_sp<SkImage> MakeRasterData(const SkImageInfo& info, sk_sp<SkData> pixels, size_t rowBytes); 1246 1247[Image_alphaType] 1248SkImage 1249SkAlphaType alphaType() const; 1250 1251[Image_bounds] 1252SkImage 1253SkIRect bounds() const; 1254 1255[Image_colorSpace] 1256SkImage 1257SkColorSpace* colorSpace() const; 1258 1259[Image_colorType] 1260SkImage 1261SkColorType colorType() const; 1262 1263[Image_dimensions] 1264SkImage 1265SkISize dimensions() const; 1266 1267[Image_encodeToData_2] 1268SkImage 1269sk_sp<SkData> encodeToData() const; 1270 1271[Image_encodeToData] 1272SkImage 1273sk_sp<SkData> encodeToData(SkEncodedImageFormat encodedImageFormat, int quality) const; 1274 1275[Image_getBackendTexture] 1276SkImage 1277GrBackendTexture getBackendTexture(bool flushPendingGrContextIO, GrSurfaceOrigin* origin = nullptr) const; 1278 1279[Image_height] 1280SkImage 1281int height() const; 1282 1283[Image_isAlphaOnly] 1284SkImage 1285bool isAlphaOnly() const; 1286 1287[Image_isLazyGenerated_a] 1288[Image_isLazyGenerated_b] 1289SkImage 1290bool isLazyGenerated() const; 1291 1292[Image_isOpaque] 1293SkImage 1294bool isOpaque() const; 1295 1296[Image_isTextureBacked] 1297SkImage 1298bool isTextureBacked() const; 1299 1300[Image_isValid] 1301SkImage 1302bool isValid(GrContext* context) const; 1303 1304[Image_makeColorSpace] 1305SkImage 1306sk_sp<SkImage> makeColorSpace(sk_sp<SkColorSpace> target) const; 1307 1308[Image_makeNonTextureImage] 1309SkImage 1310sk_sp<SkImage> makeNonTextureImage() const; 1311 1312[Image_makeRasterImage] 1313SkImage 1314sk_sp<SkImage> makeRasterImage() const; 1315 1316[Image_makeShader] 1317SkImage 1318sk_sp<SkShader> makeShader(SkShader::TileMode tileMode1, SkShader::TileMode tileMode2, const SkMatrix* localMatrix = nullptr) const; 1319 1320[Image_makeShader_2] 1321SkImage 1322sk_sp<SkShader> makeShader(const SkMatrix* localMatrix = nullptr) const; 1323 1324[Image_makeSubset] 1325SkImage 1326sk_sp<SkImage> makeSubset(const SkIRect& subset) const; 1327 1328[Image_makeTextureImage] 1329SkImage 1330sk_sp<SkImage> makeTextureImage(GrContext* context, SkColorSpace* dstColorSpace, GrMipmapped mipMapped = GrMipmapped::kNo) const; 1331 1332[Image_makeWithFilter] 1333SkImage 1334sk_sp<SkImage> makeWithFilter(const SkImageFilter* filter, const SkIRect& subset, const SkIRect& clipBounds, SkIRect* outSubset, SkIPoint* offset) const; 1335 1336[Image_peekPixels] 1337SkImage 1338bool peekPixels(SkPixmap* pixmap) const; 1339 1340[Image_readPixels] 1341SkImage 1342bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint = kAllow_CachingHint) const; 1343 1344[Image_readPixels_2] 1345SkImage 1346bool readPixels(const SkPixmap& dst, int srcX, int srcY, CachingHint cachingHint = kAllow_CachingHint) const; 1347 1348[Image_refColorSpace] 1349SkImage 1350sk_sp<SkColorSpace> refColorSpace() const; 1351 1352[Image_refEncodedData] 1353SkImage 1354sk_sp<SkData> refEncodedData() const; 1355 1356[Image_scalePixels] 1357SkImage 1358bool scalePixels(const SkPixmap& dst, SkFilterQuality filterQuality, CachingHint cachingHint = kAllow_CachingHint) const; 1359 1360[Image_uniqueID] 1361SkImage 1362uint32_t uniqueID() const; 1363 1364[Image_width] 1365SkImage 1366int width() const; 1367 1368[ImageInfo_ByteSizeOverflowed] 1369SkImageInfo 1370static bool ByteSizeOverflowed(size_t byteSize); 1371 1372[ImageInfo_Make] 1373SkImageInfo 1374static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at, sk_sp<SkColorSpace> cs = nullptr); 1375 1376[ImageInfo_MakeA8] 1377SkImageInfo 1378static SkImageInfo MakeA8(int width, int height); 1379 1380[ImageInfo_MakeN32] 1381SkImageInfo 1382static SkImageInfo MakeN32(int width, int height, SkAlphaType at, sk_sp<SkColorSpace> cs = nullptr); 1383 1384[ImageInfo_MakeN32Premul_2] 1385SkImageInfo 1386static SkImageInfo MakeN32Premul(const SkISize& size); 1387 1388[ImageInfo_MakeN32Premul] 1389SkImageInfo 1390static SkImageInfo MakeN32Premul(int width, int height, sk_sp<SkColorSpace> cs = nullptr); 1391 1392[ImageInfo_MakeS32] 1393SkImageInfo 1394static SkImageInfo MakeS32(int width, int height, SkAlphaType at); 1395 1396[ImageInfo_MakeUnknown_2] 1397SkImageInfo 1398static SkImageInfo MakeUnknown(); 1399 1400[ImageInfo_MakeUnknown] 1401SkImageInfo 1402static SkImageInfo MakeUnknown(int width, int height); 1403 1404[ColorTypeBytesPerPixel] 1405SkImageInfo 1406int SkColorTypeBytesPerPixel(SkColorType ct); 1407 1408[ColorTypeIsAlwaysOpaque] 1409SkImageInfo 1410bool SkColorTypeIsAlwaysOpaque(SkColorType ct); 1411 1412[ColorTypeValidateAlphaType] 1413SkImageInfo 1414bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType, SkAlphaType* canonical = nullptr); 1415 1416[ImageInfo_empty_constructor] 1417SkImageInfo 1418SkImageInfo(); 1419 1420[ImageInfo_alphaType] 1421SkImageInfo 1422SkAlphaType alphaType() const; 1423 1424[ImageInfo_bounds] 1425SkImageInfo 1426SkIRect bounds() const; 1427 1428[ImageInfo_bytesPerPixel] 1429SkImageInfo 1430int bytesPerPixel() const; 1431 1432[ImageInfo_colorSpace] 1433SkImageInfo 1434SkColorSpace* colorSpace() const; 1435 1436[ImageInfo_colorType] 1437SkImageInfo 1438SkColorType colorType() const; 1439 1440[ImageInfo_computeByteSize] 1441SkImageInfo 1442size_t computeByteSize(size_t rowBytes) const; 1443 1444[ImageInfo_computeMinByteSize] 1445SkImageInfo 1446size_t computeMinByteSize() const; 1447 1448[ImageInfo_computeOffset] 1449SkImageInfo 1450size_t computeOffset(int x, int y, size_t rowBytes) const; 1451 1452[ImageInfo_dimensions] 1453SkImageInfo 1454SkISize dimensions() const; 1455 1456[Alpha_Type_Opaque] 1457SkImageInfo 1458enum SkAlphaType { kUnknown_SkAlphaType, kOpaque_SkAlphaType, kPremul_SkAlphaType, kUnpremul_SkAlphaType, kLastEnum_SkAlphaType = kUnpremul_SkAlphaType, }; 1459 1460[Color_Type_ARGB_4444] 1461[Color_Type_Alpha_8] 1462[Color_Type_BGRA_8888] 1463[Color_Type_Gray_8] 1464[Color_Type_RGBA_1010102] 1465[Color_Type_RGBA_8888] 1466[Color_Type_RGBA_F16] 1467[Color_Type_RGB_101010] 1468[Color_Type_RGB_565] 1469[Color_Type_RGB_888] 1470SkImageInfo 1471enum SkColorType { kUnknown_SkColorType, kAlpha_8_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kRGB_888x_SkColorType, kBGRA_8888_SkColorType, kRGBA_1010102_SkColorType, kRGB_101010x_SkColorType, kGray_8_SkColorType, kRGBA_F16_SkColorType, kRGBA_F32_SkColorType, kLastEnum_SkColorType = kRGBA_F32_SkColorType, kN32_SkColorType = kBGRA_8888_SkColorType, kN32_SkColorType = kRGBA_8888_SkColorType, }; 1472 1473[ImageInfo_gammaCloseToSRGB] 1474SkImageInfo 1475bool gammaCloseToSRGB() const; 1476 1477[ImageInfo_height] 1478SkImageInfo 1479int height() const; 1480 1481[ImageInfo_isEmpty] 1482SkImageInfo 1483bool isEmpty() const; 1484 1485[ImageInfo_isOpaque] 1486SkImageInfo 1487bool isOpaque() const; 1488 1489[ImageInfo_makeAlphaType] 1490SkImageInfo 1491SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const; 1492 1493[ImageInfo_makeColorSpace] 1494SkImageInfo 1495SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const; 1496 1497[ImageInfo_makeColorType] 1498SkImageInfo 1499SkImageInfo makeColorType(SkColorType newColorType) const; 1500 1501[ImageInfo_makeWH] 1502SkImageInfo 1503SkImageInfo makeWH(int newWidth, int newHeight) const; 1504 1505[ImageInfo_minRowBytes] 1506SkImageInfo 1507size_t minRowBytes() const; 1508 1509[ImageInfo_minRowBytes64] 1510SkImageInfo 1511uint64_t minRowBytes64() const; 1512 1513[ImageInfo_notequal1_operator] 1514SkImageInfo 1515bool operator!=(const SkImageInfo& other) const; 1516 1517[ImageInfo_equal1_operator] 1518SkImageInfo 1519bool operator==(const SkImageInfo& other) const; 1520 1521[ImageInfo_refColorSpace] 1522SkImageInfo 1523sk_sp<SkColorSpace> refColorSpace() const; 1524 1525[ImageInfo_reset] 1526SkImageInfo 1527void reset(); 1528 1529[ImageInfo_shiftPerPixel] 1530SkImageInfo 1531int shiftPerPixel() const; 1532 1533[Alpha_Type_Premul] 1534SkImageInfo 1535stored color = original color * alpha / max alpha; 1536 1537[Alpha_Type_Unpremul] 1538SkImageInfo 1539stored color = original color * alpha / max alpha; 1540 1541[ImageInfo_validRowBytes] 1542SkImageInfo 1543bool validRowBytes(size_t rowBytes) const; 1544 1545[ImageInfo_width] 1546SkImageInfo 1547int width() const; 1548 1549[Matrix_Concat] 1550SkMatrix 1551static SkMatrix Concat(const SkMatrix& a, const SkMatrix& b); 1552 1553[Matrix_I] 1554SkMatrix 1555static const SkMatrix& I(); 1556 1557[Matrix_063] 1558SkMatrix 1559| sx 0 0 | | J K L | | sx*J sx*K sx*L | I(divx, divy) * Matrix = | 0 sy 0 | | M N O | = | sy*M sy*N sy*O | | 0 0 1 | | P Q R | | P Q R |; 1560 1561[Matrix_InvalidMatrix] 1562SkMatrix 1563static const SkMatrix& InvalidMatrix(); 1564 1565[Matrix_MakeAll] 1566SkMatrix 1567static SkMatrix MakeAll(SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2); 1568 1569[Matrix_MakeRectToRect] 1570SkMatrix 1571static SkMatrix MakeRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf); 1572 1573[Matrix_MakeScale_2] 1574SkMatrix 1575static SkMatrix MakeScale(SkScalar scale); 1576 1577[Matrix_MakeScale] 1578SkMatrix 1579static SkMatrix MakeScale(SkScalar sx, SkScalar sy); 1580 1581[Matrix_MakeTrans] 1582SkMatrix 1583static SkMatrix MakeTrans(SkScalar dx, SkScalar dy); 1584 1585[Matrix_SetAffineIdentity] 1586SkMatrix 1587static void SetAffineIdentity(SkScalar affine[6]); 1588 1589[Matrix_asAffine] 1590SkMatrix 1591bool asAffine(SkScalar affine[6]) const; 1592 1593[Matrix_cheapEqualTo] 1594SkMatrix 1595bool cheapEqualTo(const SkMatrix& m) const; 1596 1597[Matrix_decomposeScale] 1598SkMatrix 1599bool decomposeScale(SkSize* scale, SkMatrix* remaining = nullptr) const; 1600 1601[Matrix_dirtyMatrixTypeCache] 1602SkMatrix 1603void dirtyMatrixTypeCache(); 1604 1605[Matrix_dump] 1606SkMatrix 1607void dump() const; 1608 1609[Matrix_ScaleToFit] 1610SkMatrix 1611enum ScaleToFit { kFill_ScaleToFit, kStart_ScaleToFit, kCenter_ScaleToFit, kEnd_ScaleToFit, }; 1612 1613[Matrix_TypeMask] 1614SkMatrix 1615enum TypeMask { kIdentity_Mask = 0, kTranslate_Mask = 0x01, kScale_Mask = 0x02, kAffine_Mask = 0x04, kPerspective_Mask = 0x08, }; 1616 1617[Matrix_fixedStepInX] 1618SkMatrix 1619SkVector fixedStepInX(SkScalar y) const; 1620 1621[Matrix_get] 1622SkMatrix 1623SkScalar get(int index) const; 1624 1625[Matrix_get9] 1626SkMatrix 1627void get9(SkScalar buffer[9]) const; 1628 1629[Matrix_getMaxScale] 1630SkMatrix 1631SkScalar getMaxScale() const; 1632 1633[Matrix_getMinMaxScales] 1634SkMatrix 1635bool getMinMaxScales(SkScalar scaleFactors[2]) const; 1636 1637[Matrix_getMinScale] 1638SkMatrix 1639SkScalar getMinScale() const; 1640 1641[Matrix_getPerspX] 1642SkMatrix 1643SkScalar getPerspX() const; 1644 1645[Matrix_getPerspY] 1646SkMatrix 1647SkScalar getPerspY() const; 1648 1649[Matrix_getScaleX] 1650SkMatrix 1651SkScalar getScaleX() const; 1652 1653[Matrix_getScaleY] 1654SkMatrix 1655SkScalar getScaleY() const; 1656 1657[Matrix_getSkewX] 1658SkMatrix 1659SkScalar getSkewX() const; 1660 1661[Matrix_getSkewY] 1662SkMatrix 1663SkScalar getSkewY() const; 1664 1665[Matrix_getTranslateX] 1666SkMatrix 1667SkScalar getTranslateX() const; 1668 1669[Matrix_getTranslateY] 1670SkMatrix 1671SkScalar getTranslateY() const; 1672 1673[Matrix_getType] 1674SkMatrix 1675TypeMask getType() const; 1676 1677[Matrix_hasPerspective] 1678SkMatrix 1679bool hasPerspective() const; 1680 1681[Matrix_invert] 1682SkMatrix 1683bool invert(SkMatrix* inverse) const; 1684 1685[Matrix_isFinite] 1686SkMatrix 1687bool isFinite() const; 1688 1689[Matrix_isFixedStepInX] 1690SkMatrix 1691bool isFixedStepInX() const; 1692 1693[Matrix_isIdentity] 1694SkMatrix 1695bool isIdentity() const; 1696 1697[Matrix_isScaleTranslate] 1698SkMatrix 1699bool isScaleTranslate() const; 1700 1701[Matrix_isSimilarity] 1702SkMatrix 1703bool isSimilarity(SkScalar tol = SK_ScalarNearlyZero) const; 1704 1705[Matrix_isTranslate] 1706SkMatrix 1707bool isTranslate() const; 1708 1709[Matrix_mapHomogeneousPoints] 1710SkMatrix 1711void mapHomogeneousPoints(SkPoint3 dst[], const SkPoint3 src[], int count) const; 1712 1713[Matrix_mapPoints] 1714SkMatrix 1715void mapPoints(SkPoint dst[], const SkPoint src[], int count) const; 1716 1717[Matrix_mapPoints_2] 1718SkMatrix 1719void mapPoints(SkPoint pts[], int count) const; 1720 1721[Matrix_mapRadius] 1722SkMatrix 1723SkScalar mapRadius(SkScalar radius) const; 1724 1725[Matrix_mapRect_3] 1726SkMatrix 1727SkRect mapRect(const SkRect& src) const; 1728 1729[Matrix_mapRect] 1730SkMatrix 1731bool mapRect(SkRect* dst, const SkRect& src) const; 1732 1733[Matrix_mapRect_2] 1734SkMatrix 1735bool mapRect(SkRect* rect) const; 1736 1737[Matrix_mapRectScaleTranslate] 1738SkMatrix 1739void mapRectScaleTranslate(SkRect* dst, const SkRect& src) const; 1740 1741[Matrix_mapRectToQuad] 1742SkMatrix 1743void mapRectToQuad(SkPoint dst[4], const SkRect& rect) const; 1744 1745[Matrix_mapVector_2] 1746SkMatrix 1747SkVector mapVector(SkScalar dx, SkScalar dy) const; 1748 1749[Matrix_mapVector] 1750SkMatrix 1751void mapVector(SkScalar dx, SkScalar dy, SkVector* result) const; 1752 1753[Matrix_mapVectors] 1754SkMatrix 1755void mapVectors(SkVector dst[], const SkVector src[], int count) const; 1756 1757[Matrix_mapVectors_2] 1758SkMatrix 1759void mapVectors(SkVector vecs[], int count) const; 1760 1761[Matrix_mapXY_2] 1762SkMatrix 1763SkPoint mapXY(SkScalar x, SkScalar y) const; 1764 1765[Matrix_mapXY] 1766SkMatrix 1767void mapXY(SkScalar x, SkScalar y, SkPoint* result) const; 1768 1769[Matrix_notequal_operator] 1770SkMatrix 1771bool operator!=(const SkMatrix& a, const SkMatrix& b); 1772 1773[Matrix_equal_operator] 1774SkMatrix 1775bool operator==(const SkMatrix& a, const SkMatrix& b); 1776 1777[Matrix_array_operator] 1778SkMatrix 1779SkScalar operator[](int index) const; 1780 1781[Matrix_dirtyMatrixTypeCache] 1782SkMatrix 1783SkScalar& operator[](int index); 1784 1785[Matrix_postConcat] 1786SkMatrix 1787void postConcat(const SkMatrix& other); 1788 1789[Matrix_postRotate_2] 1790SkMatrix 1791void postRotate(SkScalar degrees); 1792 1793[Matrix_postRotate] 1794SkMatrix 1795void postRotate(SkScalar degrees, SkScalar px, SkScalar py); 1796 1797[Matrix_postScale_2] 1798SkMatrix 1799void postScale(SkScalar sx, SkScalar sy); 1800 1801[Matrix_postScale] 1802SkMatrix 1803void postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py); 1804 1805[Matrix_postSkew_2] 1806SkMatrix 1807void postSkew(SkScalar kx, SkScalar ky); 1808 1809[Matrix_postSkew] 1810SkMatrix 1811void postSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py); 1812 1813[Matrix_postTranslate] 1814SkMatrix 1815void postTranslate(SkScalar dx, SkScalar dy); 1816 1817[Matrix_preConcat] 1818SkMatrix 1819void preConcat(const SkMatrix& other); 1820 1821[Matrix_preRotate_2] 1822SkMatrix 1823void preRotate(SkScalar degrees); 1824 1825[Matrix_preRotate] 1826SkMatrix 1827void preRotate(SkScalar degrees, SkScalar px, SkScalar py); 1828 1829[Matrix_preScale_2] 1830SkMatrix 1831void preScale(SkScalar sx, SkScalar sy); 1832 1833[Matrix_preScale] 1834SkMatrix 1835void preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py); 1836 1837[Matrix_preSkew_2] 1838SkMatrix 1839void preSkew(SkScalar kx, SkScalar ky); 1840 1841[Matrix_preSkew] 1842SkMatrix 1843void preSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py); 1844 1845[Matrix_preTranslate] 1846SkMatrix 1847void preTranslate(SkScalar dx, SkScalar dy); 1848 1849[Matrix_preservesAxisAlignment] 1850SkMatrix 1851bool preservesAxisAlignment() const; 1852 1853[Matrix_preservesRightAngles] 1854SkMatrix 1855bool preservesRightAngles(SkScalar tol = SK_ScalarNearlyZero) const; 1856 1857[Matrix_rectStaysRect] 1858SkMatrix 1859bool rectStaysRect() const; 1860 1861[Matrix_reset] 1862SkMatrix 1863void reset(); 1864 1865[Matrix_set] 1866SkMatrix 1867void set(int index, SkScalar value); 1868 1869[Matrix_set9] 1870SkMatrix 1871void set9(const SkScalar buffer[9]); 1872 1873[Matrix_setAffine] 1874SkMatrix 1875void setAffine(const SkScalar affine[6]); 1876 1877[Matrix_setAll] 1878SkMatrix 1879void setAll(SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar persp0, SkScalar persp1, SkScalar persp2); 1880 1881[Matrix_setConcat] 1882SkMatrix 1883void setConcat(const SkMatrix& a, const SkMatrix& b); 1884 1885[Matrix_setIdentity] 1886SkMatrix 1887void setIdentity(); 1888 1889[Matrix_setPerspX] 1890SkMatrix 1891void setPerspX(SkScalar v); 1892 1893[Matrix_setPerspY] 1894SkMatrix 1895void setPerspY(SkScalar v); 1896 1897[Matrix_setPolyToPoly] 1898SkMatrix 1899bool setPolyToPoly(const SkPoint src[], const SkPoint dst[], int count); 1900 1901[Matrix_setRSXform] 1902SkMatrix 1903SkMatrix& setRSXform(const SkRSXform& rsxForm); 1904 1905[Matrix_setRectToRect] 1906SkMatrix 1907bool setRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf); 1908 1909[Matrix_setRotate_2] 1910SkMatrix 1911void setRotate(SkScalar degrees); 1912 1913[Matrix_setRotate] 1914SkMatrix 1915void setRotate(SkScalar degrees, SkScalar px, SkScalar py); 1916 1917[Matrix_setScale_2] 1918SkMatrix 1919void setScale(SkScalar sx, SkScalar sy); 1920 1921[Matrix_setScale] 1922SkMatrix 1923void setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py); 1924 1925[Matrix_setScaleTranslate] 1926SkMatrix 1927void setScaleTranslate(SkScalar sx, SkScalar sy, SkScalar tx, SkScalar ty); 1928 1929[Matrix_setScaleX] 1930SkMatrix 1931void setScaleX(SkScalar v); 1932 1933[Matrix_setScaleY] 1934SkMatrix 1935void setScaleY(SkScalar v); 1936 1937[Matrix_setSinCos_2] 1938SkMatrix 1939void setSinCos(SkScalar sinValue, SkScalar cosValue); 1940 1941[Matrix_setSinCos] 1942SkMatrix 1943void setSinCos(SkScalar sinValue, SkScalar cosValue, SkScalar px, SkScalar py); 1944 1945[Matrix_setSkew_2] 1946SkMatrix 1947void setSkew(SkScalar kx, SkScalar ky); 1948 1949[Matrix_setSkew] 1950SkMatrix 1951void setSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py); 1952 1953[Matrix_setSkewX] 1954SkMatrix 1955void setSkewX(SkScalar v); 1956 1957[Matrix_setSkewY] 1958SkMatrix 1959void setSkewY(SkScalar v); 1960 1961[Matrix_setTranslate] 1962SkMatrix 1963void setTranslate(SkScalar dx, SkScalar dy); 1964 1965[Matrix_setTranslate_2] 1966SkMatrix 1967void setTranslate(const SkVector& v); 1968 1969[Matrix_setTranslateX] 1970SkMatrix 1971void setTranslateX(SkScalar v); 1972 1973[Matrix_setTranslateY] 1974SkMatrix 1975void setTranslateY(SkScalar v); 1976 1977[MemberIndex] 1978SkMatrix 1979static constexpr int kMScaleX = 0; static constexpr int kMSkewX = 1; static constexpr int kMTransX = 2; static constexpr int kMSkewY = 3; static constexpr int kMScaleY = 4; static constexpr int kMTransY = 5; static constexpr int kMPersp0 = 6; static constexpr int kMPersp1 = 7; static constexpr int kMPersp2 = 8; 1980 1981[Paint_empty_constructor] 1982SkPaint 1983SkPaint(); 1984 1985[Paint_move_SkPaint] 1986SkPaint 1987SkPaint(SkPaint&& paint); 1988 1989[Paint_copy_const_SkPaint] 1990SkPaint 1991SkPaint(const SkPaint& paint); 1992 1993[Paint_containsText] 1994SkPaint 1995bool containsText(const void* text, size_t byteLength) const; 1996 1997[Paint_countText] 1998SkPaint 1999int countText(const void* text, size_t byteLength) const; 2000 2001[Paint_getAlpha] 2002SkPaint 2003uint8_t getAlpha() const; 2004 2005[Paint_getColor] 2006SkPaint 2007SkColor getColor() const; 2008 2009[Paint_getColor4f] 2010SkPaint 2011SkColor4f getColor4f() const; 2012 2013[Paint_getColorFilter] 2014SkPaint 2015SkColorFilter* getColorFilter() const; 2016 2017[Paint_getFillPath_2] 2018[Shader_Methods_a] 2019[Shader_Methods_b] 2020SkPaint 2021bool getFillPath(const SkPath& src, SkPath* dst) const; 2022 2023[Paint_getFillPath] 2024SkPaint 2025bool getFillPath(const SkPath& src, SkPath* dst, const SkRect* cullRect, SkScalar resScale = 1) const; 2026 2027[Paint_getFilterQuality] 2028SkPaint 2029SkFilterQuality getFilterQuality() const; 2030 2031[Paint_getFlags] 2032SkPaint 2033uint32_t getFlags() const; 2034 2035[Paint_getFontMetrics] 2036SkPaint 2037SkScalar getFontMetrics(SkFontMetrics* metrics) const; 2038 2039[Paint_getFontSpacing] 2040SkPaint 2041SkScalar getFontSpacing() const; 2042 2043[Paint_getHinting] 2044SkPaint 2045SkFontHinting getHinting() const; 2046 2047[Paint_getImageFilter] 2048SkPaint 2049SkImageFilter* getImageFilter() const; 2050 2051[Paint_getMaskFilter] 2052SkPaint 2053SkMaskFilter* getMaskFilter() const; 2054 2055[Paint_getPathEffect] 2056SkPaint 2057SkPathEffect* getPathEffect() const; 2058 2059[Paint_getPosTextPath] 2060SkPaint 2061void getPosTextPath(const void* text, size_t length, const SkPoint pos[], SkPath* path) const; 2062 2063[Paint_getShader] 2064SkPaint 2065SkShader* getShader() const; 2066 2067[Paint_getStrokeCap] 2068SkPaint 2069Cap getStrokeCap() const; 2070 2071[Paint_getStrokeJoin] 2072SkPaint 2073Join getStrokeJoin() const; 2074 2075[Paint_getStrokeMiter] 2076SkPaint 2077SkScalar getStrokeMiter() const; 2078 2079[Paint_getStrokeWidth] 2080SkPaint 2081SkScalar getStrokeWidth() const; 2082 2083[Paint_getStyle] 2084SkPaint 2085Style getStyle() const; 2086 2087[Paint_getTextEncoding] 2088SkPaint 2089SkTextEncoding getTextEncoding() const; 2090 2091[Paint_getTextPath] 2092SkPaint 2093void getTextPath(const void* text, size_t length, SkScalar x, SkScalar y, SkPath* path) const; 2094 2095[Paint_getTextScaleX] 2096SkPaint 2097SkScalar getTextScaleX() const; 2098 2099[Paint_getTextSize] 2100SkPaint 2101SkScalar getTextSize() const; 2102 2103[Paint_getTextSkewX] 2104SkPaint 2105SkScalar getTextSkewX() const; 2106 2107[Paint_getTextWidths] 2108SkPaint 2109int getTextWidths(const void* text, size_t byteLength, SkScalar widths[], SkRect bounds[] = nullptr) const; 2110 2111[Paint_getTypeface] 2112SkPaint 2113SkTypeface* getTypeface() const; 2114 2115[Paint_isAntiAlias] 2116SkPaint 2117bool isAntiAlias() const; 2118 2119[Paint_isAutohinted] 2120SkPaint 2121bool isAutohinted() const; 2122 2123[Paint_isDither] 2124SkPaint 2125bool isDither() const; 2126 2127[Paint_isEmbeddedBitmapText] 2128SkPaint 2129bool isEmbeddedBitmapText() const; 2130 2131[Paint_isFakeBoldText] 2132SkPaint 2133bool isFakeBoldText() const; 2134 2135[Paint_isLCDRenderText] 2136SkPaint 2137bool isLCDRenderText() const; 2138 2139[Paint_isLinearText] 2140SkPaint 2141bool isLinearText() const; 2142 2143[Paint_setBlendMode] 2144SkPaint 2145bool isSrcOver() const; 2146 2147[Paint_isSubpixelText] 2148SkPaint 2149bool isSubpixelText() const; 2150 2151[Paint_measureText_2] 2152SkPaint 2153SkScalar measureText(const void* text, size_t length) const; 2154 2155[Paint_measureText] 2156SkPaint 2157SkScalar measureText(const void* text, size_t length, SkRect* bounds) const; 2158 2159[Paint_nothingToDraw] 2160SkPaint 2161bool nothingToDraw() const; 2162 2163[Paint_notequal_operator] 2164SkPaint 2165bool operator!=(const SkPaint& a, const SkPaint& b); 2166 2167[Paint_move_operator] 2168SkPaint 2169SkPaint& operator=(SkPaint&& paint); 2170 2171[Paint_copy_operator] 2172SkPaint 2173SkPaint& operator=(const SkPaint& paint); 2174 2175[Paint_equal_operator] 2176SkPaint 2177bool operator==(const SkPaint& a, const SkPaint& b); 2178 2179[Paint_refColorFilter] 2180SkPaint 2181sk_sp<SkColorFilter> refColorFilter() const; 2182 2183[Paint_refImageFilter] 2184SkPaint 2185sk_sp<SkImageFilter> refImageFilter() const; 2186 2187[Paint_refMaskFilter] 2188SkPaint 2189sk_sp<SkMaskFilter> refMaskFilter() const; 2190 2191[Paint_refPathEffect] 2192SkPaint 2193sk_sp<SkPathEffect> refPathEffect() const; 2194 2195[Paint_refShader] 2196SkPaint 2197sk_sp<SkShader> refShader() const; 2198 2199[Paint_refTypeface] 2200SkPaint 2201sk_sp<SkTypeface> refTypeface() const; 2202 2203[Paint_reset] 2204SkPaint 2205void reset(); 2206 2207[Paint_setARGB] 2208SkPaint 2209void setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b); 2210 2211[Paint_setAlpha] 2212SkPaint 2213void setAlpha(U8CPU a); 2214 2215[Dither_a] 2216[Dither_b] 2217[Paint_setAntiAlias] 2218SkPaint 2219void setAntiAlias(bool aa); 2220 2221[Fake_Bold] 2222[Paint_setAutohinted] 2223SkPaint 2224void setAutohinted(bool useAutohinter); 2225 2226[Paint_setBlendMode] 2227[Path_Effect_Methods] 2228SkPaint 2229void setBlendMode(SkBlendMode mode); 2230 2231[Paint_setColor] 2232SkPaint 2233void setColor(SkColor color); 2234 2235[Paint_setColor4f] 2236SkPaint 2237void setColor4f(const SkColor4f& color, SkColorSpace* colorSpace); 2238 2239[Blend_Mode_Methods] 2240[Paint_setColorFilter] 2241SkPaint 2242void setColorFilter(sk_sp<SkColorFilter> colorFilter); 2243 2244[Device_Text] 2245[Paint_setDither] 2246SkPaint 2247void setDither(bool dither); 2248 2249[Paint_setEmbeddedBitmapText] 2250SkPaint 2251void setEmbeddedBitmapText(bool useEmbeddedBitmapText); 2252 2253[Filter_Quality_Methods] 2254[Paint_setFakeBoldText] 2255SkPaint 2256void setFakeBoldText(bool fakeBoldText); 2257 2258[Color_Methods] 2259[Paint_setFilterQuality] 2260SkPaint 2261void setFilterQuality(SkFilterQuality quality); 2262 2263[Anti_Alias] 2264[Paint_setFlags] 2265SkPaint 2266void setFlags(uint32_t flags); 2267 2268[Paint_setHinting] 2269SkPaint 2270void setHinting(SkFontHinting hintingLevel); 2271 2272[Paint_setLCDRenderText] 2273SkPaint 2274void setLCDRenderText(bool lcdText); 2275 2276[Paint_setLinearText] 2277SkPaint 2278void setLinearText(bool linearText); 2279 2280[Paint_setMaskFilter] 2281[Typeface_Methods] 2282SkPaint 2283void setMaskFilter(sk_sp<SkMaskFilter> maskFilter); 2284 2285[Mask_Filter_Methods] 2286[Paint_setPathEffect] 2287SkPaint 2288void setPathEffect(sk_sp<SkPathEffect> pathEffect); 2289 2290[Color_Filter_Methods] 2291[Paint_setShader] 2292SkPaint 2293void setShader(sk_sp<SkShader> shader); 2294 2295[Paint_setStrokeCap_a] 2296[Paint_setStrokeCap_b] 2297SkPaint 2298void setStrokeCap(Cap cap); 2299 2300[Paint_setStrokeJoin] 2301SkPaint 2302void setStrokeJoin(Join join); 2303 2304[Paint_setStrokeMiter] 2305SkPaint 2306void setStrokeMiter(SkScalar miter); 2307 2308[Miter_Limit] 2309[Paint_setStrokeWidth] 2310SkPaint 2311void setStrokeWidth(SkScalar width); 2312 2313[Paint_setStyle] 2314[Stroke_Width] 2315SkPaint 2316void setStyle(Style style); 2317 2318[Paint_setSubpixelText] 2319SkPaint 2320void setSubpixelText(bool subpixelText); 2321 2322[Paint_setTextEncoding] 2323SkPaint 2324void setTextEncoding(SkTextEncoding encoding); 2325 2326[Paint_setTextScaleX] 2327[Text_Skew_X] 2328SkPaint 2329void setTextScaleX(SkScalar scaleX); 2330 2331[Paint_setTextSize] 2332[Text_Scale_X] 2333SkPaint 2334void setTextSize(SkScalar textSize); 2335 2336[Paint_setTextSkewX] 2337[Text_Encoding] 2338SkPaint 2339void setTextSkewX(SkScalar skewX); 2340 2341[Image_Filter_Methods] 2342[Paint_setTypeface] 2343SkPaint 2344void setTypeface(sk_sp<SkTypeface> typeface); 2345 2346[Paint_053] 2347SkPaint 2348static constexpr int kCapCount = kLast_Cap + 1; 2349 2350[Paint_057] 2351SkPaint 2352static constexpr int kJoinCount = kLast_Join + 1; 2353 2354[Paint_textToGlyphs] 2355SkPaint 2356int textToGlyphs(const void* text, size_t byteLength, SkGlyphID glyphs[]) const; 2357 2358[Path_ConvertConicToQuads] 2359SkPath 2360static int ConvertConicToQuads(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2, SkScalar w, SkPoint pts[], int pow2); 2361 2362[Path_ConvertToNonInverseFillType] 2363SkPath 2364static FillType ConvertToNonInverseFillType(FillType fill); 2365 2366[Path_IsCubicDegenerate] 2367SkPath 2368static bool IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2, const SkPoint& p3, const SkPoint& p4, bool exact); 2369 2370[Path_IsInverseFillType] 2371SkPath 2372static bool IsInverseFillType(FillType fill); 2373 2374[Path_IsLineDegenerate] 2375SkPath 2376static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact); 2377 2378[Path_IsQuadDegenerate] 2379SkPath 2380static bool IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2, const SkPoint& p3, bool exact); 2381 2382[Path_Iter_Iter] 2383SkPath 2384Iter(); 2385 2386[Path_Iter_const_SkPath] 2387SkPath 2388Iter(const SkPath& path, bool forceClose); 2389 2390[Path_empty_constructor] 2391SkPath 2392SkPath(); 2393 2394[Path_copy_const_SkPath] 2395SkPath 2396SkPath(const SkPath& path); 2397 2398[Path_addArc] 2399SkPath 2400SkPath& addArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle); 2401 2402[Path_addCircle] 2403SkPath 2404SkPath& addCircle(SkScalar x, SkScalar y, SkScalar radius, Direction dir = kCW_Direction); 2405 2406[Path_addOval] 2407SkPath 2408SkPath& addOval(const SkRect& oval, Direction dir = kCW_Direction); 2409 2410[Path_addOval_2] 2411SkPath 2412SkPath& addOval(const SkRect& oval, Direction dir, unsigned start); 2413 2414[Path_addPath_2] 2415SkPath 2416SkPath& addPath(const SkPath& src, AddPathMode mode = kAppend_AddPathMode); 2417 2418[Path_addPath] 2419SkPath 2420SkPath& addPath(const SkPath& src, SkScalar dx, SkScalar dy, AddPathMode mode = kAppend_AddPathMode); 2421 2422[Path_addPath_3] 2423SkPath 2424SkPath& addPath(const SkPath& src, const SkMatrix& matrix, AddPathMode mode = kAppend_AddPathMode); 2425 2426[Path_addPoly] 2427SkPath 2428SkPath& addPoly(const SkPoint pts[], int count, bool close); 2429 2430[Path_addPoly_2] 2431SkPath 2432SkPath& addPoly(const std::initializer_list<SkPoint>& list, bool close); 2433 2434[Path_addRRect] 2435SkPath 2436SkPath& addRRect(const SkRRect& rrect, Direction dir = kCW_Direction); 2437 2438[Path_addRRect_2] 2439SkPath 2440SkPath& addRRect(const SkRRect& rrect, Direction dir, unsigned start); 2441 2442[Path_addRect_3] 2443SkPath 2444SkPath& addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, Direction dir = kCW_Direction); 2445 2446[Path_addRect] 2447SkPath 2448SkPath& addRect(const SkRect& rect, Direction dir = kCW_Direction); 2449 2450[Path_addRect_2] 2451SkPath 2452SkPath& addRect(const SkRect& rect, Direction dir, unsigned start); 2453 2454[Path_addRoundRect] 2455SkPath 2456SkPath& addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, Direction dir = kCW_Direction); 2457 2458[Path_addRoundRect_2] 2459SkPath 2460SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[], Direction dir = kCW_Direction); 2461 2462[Path_arcTo_4] 2463SkPath 2464SkPath& arcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep, SkScalar x, SkScalar y); 2465 2466[Path_arcTo_2_a] 2467[Path_arcTo_2_b] 2468[Path_arcTo_2_c] 2469SkPath 2470SkPath& arcTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar radius); 2471 2472[Path_arcTo_3] 2473SkPath 2474SkPath& arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius); 2475 2476[Path_rArcTo] 2477SkPath 2478SkPath& arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep, const SkPoint xy); 2479 2480[Path_arcTo] 2481SkPath 2482SkPath& arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool forceMoveTo); 2483 2484[Path_close] 2485SkPath 2486SkPath& close(); 2487 2488[Path_computeTightBounds] 2489SkPath 2490SkRect computeTightBounds() const; 2491 2492[Path_conicTo] 2493SkPath 2494SkPath& conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w); 2495 2496[Path_conicTo_2] 2497SkPath 2498SkPath& conicTo(const SkPoint& p1, const SkPoint& p2, SkScalar w); 2499 2500[Path_Iter_conicWeight] 2501SkPath 2502SkScalar conicWeight() const; 2503 2504[Path_conservativelyContainsRect] 2505SkPath 2506bool conservativelyContainsRect(const SkRect& rect) const; 2507 2508[Path_contains] 2509SkPath 2510bool contains(SkScalar x, SkScalar y) const; 2511 2512[Path_countPoints] 2513SkPath 2514int countPoints() const; 2515 2516[Path_countVerbs] 2517SkPath 2518int countVerbs() const; 2519 2520[Path_cubicTo] 2521SkPath 2522SkPath& cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3); 2523 2524[Path_cubicTo_2] 2525SkPath 2526SkPath& cubicTo(const SkPoint& p1, const SkPoint& p2, const SkPoint& p3); 2527 2528[Path_dump_2] 2529SkPath 2530void dump() const; 2531 2532[Path_dump] 2533SkPath 2534void dump(SkWStream* stream, bool forceClose, bool dumpAsHex) const; 2535 2536[Path_dumpHex] 2537SkPath 2538void dumpHex() const; 2539 2540[Path_AddPathMode] 2541SkPath 2542enum AddPathMode { kAppend_AddPathMode, kExtend_AddPathMode, }; 2543 2544[Path_ArcSize] 2545SkPath 2546enum ArcSize { kSmall_ArcSize, kLarge_ArcSize, }; 2547 2548[Path_Convexity] 2549SkPath 2550enum Convexity : uint8_t { kUnknown_Convexity, kConvex_Convexity, kConcave_Convexity, }; 2551 2552[Path_Direction] 2553SkPath 2554enum Direction : int { kCW_Direction, kCCW_Direction, }; 2555 2556[Path_FillType_a] 2557[Path_FillType_b] 2558SkPath 2559enum FillType { kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType, kInverseEvenOdd_FillType, }; 2560 2561[Path_SegmentMask] 2562SkPath 2563enum SegmentMask { kLine_SegmentMask = 1 << 0, kQuad_SegmentMask = 1 << 1, kConic_SegmentMask = 1 << 2, kCubic_SegmentMask = 1 << 3, }; 2564 2565[Path_Verb] 2566SkPath 2567enum Verb { kMove_Verb, kLine_Verb, kQuad_Verb, kConic_Verb, kCubic_Verb, kClose_Verb, kDone_Verb, }; 2568 2569[Path_getBounds] 2570SkPath 2571const SkRect& getBounds() const; 2572 2573[Path_getConvexity] 2574SkPath 2575Convexity getConvexity() const; 2576 2577[Path_getConvexityOrUnknown] 2578SkPath 2579Convexity getConvexityOrUnknown() const; 2580 2581[Path_getFillType] 2582SkPath 2583FillType getFillType() const; 2584 2585[Path_getGenerationID] 2586SkPath 2587uint32_t getGenerationID() const; 2588 2589[Path_getLastPt] 2590SkPath 2591bool getLastPt(SkPoint* lastPt) const; 2592 2593[Path_getPoint] 2594SkPath 2595SkPoint getPoint(int index) const; 2596 2597[Path_getPoints] 2598SkPath 2599int getPoints(SkPoint points[], int max) const; 2600 2601[Path_getSegmentMasks] 2602SkPath 2603uint32_t getSegmentMasks() const; 2604 2605[Path_getVerbs] 2606SkPath 2607int getVerbs(uint8_t verbs[], int max) const; 2608 2609[Path_incReserve] 2610SkPath 2611void incReserve(int extraPtCount); 2612 2613[Path_interpolate] 2614SkPath 2615bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const; 2616 2617[Path_Iter_isCloseLine] 2618SkPath 2619bool isCloseLine() const; 2620 2621[Path_Iter_isClosedContour] 2622SkPath 2623bool isClosedContour() const; 2624 2625[Path_Iter] 2626SkPath 2627class Iter { Iter(); Iter(const SkPath& path, bool forceClose); void setPath(const SkPath& path, bool forceClose); Verb next(SkPoint pts[4], bool doConsumeDegenerates = true, bool exact = false); SkScalar conicWeight() const; bool isCloseLine() const; bool isClosedContour() const; }; 2628 2629[Path_isConvex] 2630SkPath 2631bool isConvex() const; 2632 2633[Path_isEmpty] 2634SkPath 2635bool isEmpty() const; 2636 2637[Path_isFinite] 2638SkPath 2639bool isFinite() const; 2640 2641[Path_isInterpolatable] 2642SkPath 2643bool isInterpolatable(const SkPath& compare) const; 2644 2645[Path_isInverseFillType_2] 2646SkPath 2647bool isInverseFillType() const; 2648 2649[Path_isLastContourClosed] 2650SkPath 2651bool isLastContourClosed() const; 2652 2653[Path_isLine] 2654SkPath 2655bool isLine(SkPoint line[2]) const; 2656 2657[Path_isNestedFillRects] 2658SkPath 2659bool isNestedFillRects(SkRect rect[2], Direction dirs[2] = nullptr) const; 2660 2661[Path_isOval] 2662SkPath 2663bool isOval(SkRect* bounds) const; 2664 2665[Path_isRRect] 2666SkPath 2667bool isRRect(SkRRect* rrect) const; 2668 2669[Path_isRect] 2670SkPath 2671bool isRect(SkRect* rect, bool* isClosed = nullptr, Direction* direction = nullptr) const; 2672 2673[Path_isVolatile] 2674SkPath 2675bool isVolatile() const; 2676 2677[Path_lineTo] 2678SkPath 2679SkPath& lineTo(SkScalar x, SkScalar y); 2680 2681[Path_lineTo_2] 2682SkPath 2683SkPath& lineTo(const SkPoint& p); 2684 2685[Path_moveTo] 2686SkPath 2687SkPath& moveTo(SkScalar x, SkScalar y); 2688 2689[Path_moveTo_2] 2690SkPath 2691SkPath& moveTo(const SkPoint& p); 2692 2693[Path_Iter_next] 2694SkPath 2695Verb next(SkPoint pts[4], bool doConsumeDegenerates = true, bool exact = false); 2696 2697[Path_offset_2] 2698SkPath 2699void offset(SkScalar dx, SkScalar dy); 2700 2701[Path_offset] 2702SkPath 2703void offset(SkScalar dx, SkScalar dy, SkPath* dst) const; 2704 2705[Path_notequal_operator] 2706SkPath 2707bool operator!=(const SkPath& a, const SkPath& b); 2708 2709[Path_copy_operator] 2710SkPath 2711SkPath& operator=(const SkPath& path); 2712 2713[Path_equal_operator] 2714SkPath 2715bool operator==(const SkPath& a, const SkPath& b); 2716 2717[Path_quadTo] 2718SkPath 2719SkPath& quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2); 2720 2721[Path_quadTo_2] 2722SkPath 2723SkPath& quadTo(const SkPoint& p1, const SkPoint& p2); 2724 2725[Path_rArcTo] 2726SkPath 2727SkPath& rArcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep, SkScalar dx, SkScalar dy); 2728 2729[Cubic] 2730[Path_rConicTo] 2731SkPath 2732SkPath& rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, SkScalar w); 2733 2734[Arc] 2735[Path_rCubicTo] 2736SkPath 2737SkPath& rCubicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, SkScalar dx3, SkScalar dy3); 2738 2739[Path_rLineTo] 2740[Quad_a] 2741[Quad_b] 2742SkPath 2743SkPath& rLineTo(SkScalar dx, SkScalar dy); 2744 2745[Path_rMoveTo] 2746SkPath 2747SkPath& rMoveTo(SkScalar dx, SkScalar dy); 2748 2749[Conic_Weight_a] 2750[Conic_Weight_b] 2751[Conic_Weight_c] 2752[Path_rQuadTo] 2753SkPath 2754SkPath& rQuadTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2); 2755 2756[Path_readFromMemory] 2757SkPath 2758size_t readFromMemory(const void* buffer, size_t length); 2759 2760[Path_reset] 2761SkPath 2762SkPath& reset(); 2763 2764[Path_reverseAddPath] 2765SkPath 2766SkPath& reverseAddPath(const SkPath& src); 2767 2768[Path_rewind] 2769SkPath 2770SkPath& rewind(); 2771 2772[Path_serialize] 2773SkPath 2774sk_sp<SkData> serialize() const; 2775 2776[Path_setConvexity] 2777SkPath 2778void setConvexity(Convexity convexity); 2779 2780[Path_setFillType] 2781SkPath 2782void setFillType(FillType ft); 2783 2784[Path_setIsVolatile] 2785SkPath 2786void setIsVolatile(bool isVolatile); 2787 2788[Path_setLastPt] 2789SkPath 2790void setLastPt(SkScalar x, SkScalar y); 2791 2792[Path_setLastPt_2] 2793SkPath 2794void setLastPt(const SkPoint& p); 2795 2796[Path_Iter_setPath] 2797SkPath 2798void setPath(const SkPath& path, bool forceClose); 2799 2800[Path_swap] 2801SkPath 2802void swap(SkPath& other); 2803 2804[Path_toggleInverseFillType] 2805SkPath 2806void toggleInverseFillType(); 2807 2808[Path_transform_2] 2809SkPath 2810void transform(const SkMatrix& matrix); 2811 2812[Path_transform] 2813SkPath 2814void transform(const SkMatrix& matrix, SkPath* dst) const; 2815 2816[Path_updateBoundsCache] 2817SkPath 2818void updateBoundsCache() const; 2819 2820[Path_writeToMemory] 2821SkPath 2822size_t writeToMemory(void* buffer) const; 2823 2824[Path_destructor] 2825SkPath 2826~SkPath(); 2827 2828[Picture_MakeFromData] 2829SkPicture 2830static sk_sp<SkPicture> MakeFromData(const SkData* data, const SkDeserialProcs* procs = nullptr); 2831 2832[Picture_serialize_2] 2833SkPicture 2834static sk_sp<SkPicture> MakeFromData(const void* data, size_t size, const SkDeserialProcs* procs = nullptr); 2835 2836[Picture_MakeFromStream] 2837SkPicture 2838static sk_sp<SkPicture> MakeFromStream(SkStream* stream, const SkDeserialProcs* procs = nullptr); 2839 2840[Picture_MakePlaceholder] 2841SkPicture 2842static sk_sp<SkPicture> MakePlaceholder(SkRect cull); 2843 2844[Picture_AbortCallback_abort] 2845SkPicture 2846virtual bool abort() = 0; 2847 2848[Picture_approximateBytesUsed] 2849SkPicture 2850virtual size_t approximateBytesUsed() const = 0; 2851 2852[Picture_approximateOpCount] 2853SkPicture 2854virtual int approximateOpCount() const = 0; 2855 2856[Picture_cullRect] 2857SkPicture 2858virtual SkRect cullRect() const = 0; 2859 2860[Picture_playback] 2861SkPicture 2862virtual void playback(SkCanvas* canvas, AbortCallback* callback = nullptr) const = 0; 2863 2864[Picture_serialize] 2865SkPicture 2866sk_sp<SkData> serialize(const SkSerialProcs* procs = nullptr) const; 2867 2868[Picture_serialize_2] 2869SkPicture 2870void serialize(SkWStream* stream, const SkSerialProcs* procs = nullptr) const; 2871 2872[Picture_uniqueID] 2873SkPicture 2874uint32_t uniqueID() const; 2875 2876[Pixmap_empty_constructor] 2877SkPixmap 2878SkPixmap(); 2879 2880[Pixmap_const_SkImageInfo_const_star] 2881SkPixmap 2882SkPixmap(const SkImageInfo& info, const void* addr, size_t rowBytes); 2883 2884[Pixmap_addr] 2885SkPixmap 2886const void* addr() const; 2887 2888[Pixmap_addr_2] 2889SkPixmap 2890const void* addr(int x, int y) const; 2891 2892[Pixmap_addr16] 2893SkPixmap 2894const uint16_t* addr16() const; 2895 2896[Pixmap_addr16_2] 2897SkPixmap 2898const uint16_t* addr16(int x, int y) const; 2899 2900[Pixmap_addr32] 2901SkPixmap 2902const uint32_t* addr32() const; 2903 2904[Pixmap_addr32_2] 2905SkPixmap 2906const uint32_t* addr32(int x, int y) const; 2907 2908[Pixmap_addr64] 2909SkPixmap 2910const uint64_t* addr64() const; 2911 2912[Pixmap_addr64_2] 2913SkPixmap 2914const uint64_t* addr64(int x, int y) const; 2915 2916[Pixmap_addr8] 2917SkPixmap 2918const uint8_t* addr8() const; 2919 2920[Pixmap_addr8_2] 2921SkPixmap 2922const uint8_t* addr8(int x, int y) const; 2923 2924[Pixmap_addrF16] 2925SkPixmap 2926const uint16_t* addrF16() const; 2927 2928[Pixmap_addrF16_2] 2929SkPixmap 2930const uint16_t* addrF16(int x, int y) const; 2931 2932[Pixmap_alphaType] 2933SkPixmap 2934SkAlphaType alphaType() const; 2935 2936[Pixmap_bounds] 2937SkPixmap 2938SkIRect bounds() const; 2939 2940[Pixmap_colorSpace] 2941SkPixmap 2942SkColorSpace* colorSpace() const; 2943 2944[Pixmap_colorType] 2945SkPixmap 2946SkColorType colorType() const; 2947 2948[Pixmap_computeByteSize] 2949SkPixmap 2950size_t computeByteSize() const; 2951 2952[Pixmap_computeIsOpaque] 2953SkPixmap 2954bool computeIsOpaque() const; 2955 2956[Pixmap_erase_2] 2957SkPixmap 2958bool erase(SkColor color) const; 2959 2960[Pixmap_erase] 2961SkPixmap 2962bool erase(SkColor color, const SkIRect& subset) const; 2963 2964[Pixmap_erase_3] 2965SkPixmap 2966bool erase(const SkColor4f& color, const SkIRect* subset = nullptr) const; 2967 2968[Pixmap_extractSubset] 2969SkPixmap 2970bool extractSubset(SkPixmap* subset, const SkIRect& area) const; 2971 2972[Pixmap_getColor] 2973SkPixmap 2974SkColor getColor(int x, int y) const; 2975 2976[Pixmap_height] 2977SkPixmap 2978int height() const; 2979 2980[Pixmap_info] 2981SkPixmap 2982const SkImageInfo& info() const; 2983 2984[Pixmap_isOpaque] 2985SkPixmap 2986bool isOpaque() const; 2987 2988[Pixmap_readPixels] 2989SkPixmap 2990bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes) const; 2991 2992[Pixmap_readPixels_2] 2993SkPixmap 2994bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY) const; 2995 2996[Pixmap_readPixels_4] 2997SkPixmap 2998bool readPixels(const SkPixmap& dst) const; 2999 3000[Pixmap_readPixels_3] 3001SkPixmap 3002bool readPixels(const SkPixmap& dst, int srcX, int srcY) const; 3003 3004[Pixmap_reset] 3005SkPixmap 3006void reset(); 3007 3008[Pixmap_reset_2] 3009SkPixmap 3010void reset(const SkImageInfo& info, const void* addr, size_t rowBytes); 3011 3012[Pixmap_rowBytes] 3013SkPixmap 3014size_t rowBytes() const; 3015 3016[Pixmap_rowBytesAsPixels] 3017SkPixmap 3018int rowBytesAsPixels() const; 3019 3020[Pixmap_scalePixels] 3021SkPixmap 3022bool scalePixels(const SkPixmap& dst, SkFilterQuality filterQuality) const; 3023 3024[Pixmap_setColorSpace] 3025SkPixmap 3026void setColorSpace(sk_sp<SkColorSpace> colorSpace); 3027 3028[Pixmap_shiftPerPixel] 3029SkPixmap 3030int shiftPerPixel() const; 3031 3032[Pixmap_width] 3033SkPixmap 3034int width() const; 3035 3036[Pixmap_writable_addr] 3037SkPixmap 3038void* writable_addr() const; 3039 3040[Pixmap_writable_addr_2] 3041SkPixmap 3042void* writable_addr(int x, int y) const; 3043 3044[Pixmap_writable_addr16] 3045SkPixmap 3046uint16_t* writable_addr16(int x, int y) const; 3047 3048[Pixmap_writable_addr32] 3049SkPixmap 3050uint32_t* writable_addr32(int x, int y) const; 3051 3052[Pixmap_writable_addr64] 3053SkPixmap 3054uint64_t* writable_addr64(int x, int y) const; 3055 3056[Pixmap_writable_addr8] 3057SkPixmap 3058uint8_t* writable_addr8(int x, int y) const; 3059 3060[Pixmap_writable_addrF16] 3061SkPixmap 3062uint16_t* writable_addrF16(int x, int y) const; 3063 3064[Point_CrossProduct] 3065SkPoint 3066static SkScalar CrossProduct(const SkVector& a, const SkVector& b); 3067 3068[Point_Distance] 3069SkPoint 3070static SkScalar Distance(const SkPoint& a, const SkPoint& b); 3071 3072[Point_DotProduct] 3073SkPoint 3074static SkScalar DotProduct(const SkVector& a, const SkVector& b); 3075 3076[Point_Length] 3077SkPoint 3078static SkScalar Length(SkScalar x, SkScalar y); 3079 3080[Point_Make] 3081SkPoint 3082static constexpr SkPoint Make(SkScalar x, SkScalar y); 3083 3084[Point_Normalize] 3085SkPoint 3086static SkScalar Normalize(SkVector* vec); 3087 3088[Point_Offset_2] 3089SkPoint 3090static void Offset(SkPoint points[], int count, SkScalar dx, SkScalar dy); 3091 3092[Point_Offset] 3093SkPoint 3094static void Offset(SkPoint points[], int count, const SkVector& offset); 3095 3096[Point_cross] 3097SkPoint 3098SkScalar cross(const SkVector& vec) const; 3099 3100[Point_distanceToOrigin] 3101SkPoint 3102SkScalar distanceToOrigin() const; 3103 3104[Point_dot] 3105SkPoint 3106SkScalar dot(const SkVector& vec) const; 3107 3108[Point_equals] 3109SkPoint 3110bool equals(SkScalar x, SkScalar y) const; 3111 3112[Point_isFinite] 3113SkPoint 3114bool isFinite() const; 3115 3116[Point_isZero] 3117SkPoint 3118bool isZero() const; 3119 3120[Point_iset_2] 3121SkPoint 3122void iset(const SkIPoint& p); 3123 3124[Point_iset] 3125SkPoint 3126void iset(int32_t x, int32_t y); 3127 3128[Point_length_2] 3129SkPoint 3130SkScalar length() const; 3131 3132[Point_negate] 3133SkPoint 3134void negate(); 3135 3136[Point_normalize_2] 3137SkPoint 3138bool normalize(); 3139 3140[Point_offset_3] 3141SkPoint 3142void offset(SkScalar dx, SkScalar dy); 3143 3144[Point_notequal_operator] 3145SkPoint 3146bool operator!=(const SkPoint& a, const SkPoint& b); 3147 3148[Point_multiply_operator] 3149SkPoint 3150SkPoint operator*(SkScalar scale) const; 3151 3152[Point_multiplyby_operator] 3153SkPoint 3154SkPoint& operator*=(SkScalar scale); 3155 3156[Point_add_operator] 3157SkPoint 3158SkPoint operator+(const SkPoint& a, const SkVector& b); 3159 3160[Point_addto_operator] 3161SkPoint 3162void operator+=(const SkVector& v); 3163 3164[Point_minus_operator] 3165SkPoint 3166SkPoint operator-() const; 3167 3168[Point_subtract_operator] 3169SkPoint 3170SkVector operator-(const SkPoint& a, const SkPoint& b); 3171 3172[Point_subtractfrom_operator] 3173SkPoint 3174void operator-=(const SkVector& v); 3175 3176[Point_equal_operator] 3177SkPoint 3178bool operator==(const SkPoint& a, const SkPoint& b); 3179 3180[Point_scale] 3181SkPoint 3182void scale(SkScalar scale, SkPoint* dst) const; 3183 3184[Point_scale_2] 3185SkPoint 3186void scale(SkScalar value); 3187 3188[Point_set] 3189SkPoint 3190void set(SkScalar x, SkScalar y); 3191 3192[Point_setAbs] 3193SkPoint 3194void setAbs(const SkPoint& pt); 3195 3196[Point_setLength] 3197SkPoint 3198bool setLength(SkScalar length); 3199 3200[Point_setLength_2] 3201SkPoint 3202bool setLength(SkScalar x, SkScalar y, SkScalar length); 3203 3204[Point_setNormalize] 3205SkPoint 3206bool setNormalize(SkScalar x, SkScalar y); 3207 3208[Point_x] 3209SkPoint 3210SkScalar x() const; 3211 3212[Point_y] 3213SkPoint 3214SkScalar y() const; 3215 3216[RRect_MakeEmpty] 3217SkRRect 3218static SkRRect MakeEmpty(); 3219 3220[RRect_MakeOval] 3221SkRRect 3222static SkRRect MakeOval(const SkRect& oval); 3223 3224[RRect_MakeRect] 3225SkRRect 3226static SkRRect MakeRect(const SkRect& r); 3227 3228[RRect_MakeRectXY] 3229SkRRect 3230static SkRRect MakeRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad); 3231 3232[RRect_empty_constructor] 3233SkRRect 3234SkRRect(); 3235 3236[RRect_copy_const_SkRRect] 3237SkRRect 3238SkRRect(const SkRRect& rrect); 3239 3240[RRect_contains] 3241SkRRect 3242bool contains(const SkRect& rect) const; 3243 3244[RRect_dump_2] 3245SkRRect 3246void dump() const; 3247 3248[RRect_dump] 3249SkRRect 3250void dump(bool asHex) const; 3251 3252[RRect_dumpHex] 3253SkRRect 3254void dumpHex() const; 3255 3256[RRect_Corner] 3257SkRRect 3258enum Corner { kUpperLeft_Corner, kUpperRight_Corner, kLowerRight_Corner, kLowerLeft_Corner, }; 3259 3260[RRect_Type] 3261SkRRect 3262enum Type { kEmpty_Type, kRect_Type, kOval_Type, kSimple_Type, kNinePatch_Type, kComplex_Type, kLastType = kComplex_Type, }; 3263 3264[RRect_getBounds] 3265SkRRect 3266const SkRect& getBounds() const; 3267 3268[RRect_getSimpleRadii] 3269SkRRect 3270SkVector getSimpleRadii() const; 3271 3272[RRect_getType] 3273SkRRect 3274Type getType() const; 3275 3276[RRect_height] 3277SkRRect 3278SkScalar height() const; 3279 3280[RRect_inset_2] 3281SkRRect 3282void inset(SkScalar dx, SkScalar dy); 3283 3284[RRect_inset] 3285SkRRect 3286void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const; 3287 3288[RRect_isComplex] 3289SkRRect 3290bool isComplex() const; 3291 3292[RRect_isEmpty] 3293SkRRect 3294bool isEmpty() const; 3295 3296[RRect_isNinePatch] 3297SkRRect 3298bool isNinePatch() const; 3299 3300[RRect_isOval] 3301SkRRect 3302bool isOval() const; 3303 3304[RRect_isRect] 3305SkRRect 3306bool isRect() const; 3307 3308[RRect_isSimple] 3309SkRRect 3310bool isSimple() const; 3311 3312[RRect_isValid] 3313SkRRect 3314bool isValid() const; 3315 3316[RRect_makeOffset] 3317SkRRect 3318SkRRect makeOffset(SkScalar dx, SkScalar dy) const; 3319 3320[RRect_offset] 3321SkRRect 3322void offset(SkScalar dx, SkScalar dy); 3323 3324[RRect_notequal_operator] 3325SkRRect 3326bool operator!=(const SkRRect& a, const SkRRect& b); 3327 3328[RRect_copy_operator] 3329SkRRect 3330SkRRect& operator=(const SkRRect& rrect); 3331 3332[RRect_equal_operator] 3333SkRRect 3334bool operator==(const SkRRect& a, const SkRRect& b); 3335 3336[RRect_outset_2] 3337SkRRect 3338void outset(SkScalar dx, SkScalar dy); 3339 3340[RRect_outset] 3341SkRRect 3342void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const; 3343 3344[RRect_radii] 3345SkRRect 3346SkVector radii(Corner corner) const; 3347 3348[RRect_readFromMemory] 3349SkRRect 3350size_t readFromMemory(const void* buffer, size_t length); 3351 3352[RRect_rect] 3353SkRRect 3354const SkRect& rect() const; 3355 3356[RRect_setEmpty] 3357SkRRect 3358void setEmpty(); 3359 3360[RRect_setNinePatch] 3361SkRRect 3362void setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad, SkScalar rightRad, SkScalar bottomRad); 3363 3364[RRect_setOval] 3365SkRRect 3366void setOval(const SkRect& oval); 3367 3368[RRect_setRect] 3369SkRRect 3370void setRect(const SkRect& rect); 3371 3372[RRect_setRectRadii] 3373SkRRect 3374void setRectRadii(const SkRect& rect, const SkVector radii[4]); 3375 3376[RRect_setRectXY] 3377SkRRect 3378void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad); 3379 3380[RRect_transform] 3381SkRRect 3382bool transform(const SkMatrix& matrix, SkRRect* dst) const; 3383 3384[RRect_type_2] 3385SkRRect 3386Type type() const; 3387 3388[RRect_width] 3389SkRRect 3390SkScalar width() const; 3391 3392[RRect_writeToMemory] 3393SkRRect 3394size_t writeToMemory(void* buffer) const; 3395 3396[Rect_Intersects] 3397SkRect 3398static bool Intersects(const SkRect& a, const SkRect& b); 3399 3400[Rect_Make_2] 3401SkRect 3402static SkRect Make(const SkIRect& irect); 3403 3404[Rect_Make] 3405SkRect 3406static SkRect Make(const SkISize& size); 3407 3408[Rect_MakeEmpty] 3409SkRect 3410static constexpr SkRect MakeEmpty(); 3411 3412[Rect_MakeIWH] 3413SkRect 3414static SkRect MakeIWH(int w, int h); 3415 3416[Rect_MakeLTRB] 3417SkRect 3418static constexpr SkRect MakeLTRB(SkScalar l, SkScalar t, SkScalar r, SkScalar b); 3419 3420[Rect_MakeSize] 3421SkRect 3422static constexpr SkRect MakeSize(const SkSize& size); 3423 3424[Rect_MakeWH] 3425SkRect 3426static constexpr SkRect MakeWH(SkScalar w, SkScalar h); 3427 3428[Rect_MakeXYWH] 3429SkRect 3430static constexpr SkRect MakeXYWH(SkScalar x, SkScalar y, SkScalar w, SkScalar h); 3431 3432[Rect_asScalars] 3433SkRect 3434const SkScalar* asScalars() const; 3435 3436[Rect_bottom] 3437SkRect 3438SkScalar bottom() const; 3439 3440[Rect_centerX] 3441SkRect 3442SkScalar centerX() const; 3443 3444[Rect_centerY] 3445SkRect 3446SkScalar centerY() const; 3447 3448[Rect_contains] 3449SkRect 3450bool contains(SkScalar x, SkScalar y) const; 3451 3452[Rect_contains_3] 3453SkRect 3454bool contains(const SkIRect& r) const; 3455 3456[Rect_contains_2] 3457SkRect 3458bool contains(const SkRect& r) const; 3459 3460[Rect_dump_2] 3461SkRect 3462void dump() const; 3463 3464[Rect_dump] 3465SkRect 3466void dump(bool asHex) const; 3467 3468[Rect_dumpHex] 3469SkRect 3470void dumpHex() const; 3471 3472[Rect_height] 3473SkRect 3474SkScalar height() const; 3475 3476[Rect_inset] 3477SkRect 3478void inset(SkScalar dx, SkScalar dy); 3479 3480[Rect_intersect_2] 3481SkRect 3482bool intersect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom); 3483 3484[Rect_intersect_3] 3485SkRect 3486bool intersect(const SkRect& a, const SkRect& b); 3487 3488[Rect_intersect] 3489SkRect 3490bool intersect(const SkRect& r); 3491 3492[Rect_intersects_3] 3493SkRect 3494bool intersects(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom) const; 3495 3496[Rect_intersects_2] 3497SkRect 3498bool intersects(const SkRect& r) const; 3499 3500[Rect_isEmpty] 3501SkRect 3502bool isEmpty() const; 3503 3504[Rect_isFinite] 3505SkRect 3506bool isFinite() const; 3507 3508[Rect_isSorted] 3509SkRect 3510bool isSorted() const; 3511 3512[Rect_iset] 3513SkRect 3514void iset(int left, int top, int right, int bottom); 3515 3516[Rect_isetWH] 3517SkRect 3518void isetWH(int width, int height); 3519 3520[Rect_join] 3521SkRect 3522void join(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom); 3523 3524[Rect_join_2] 3525SkRect 3526void join(const SkRect& r); 3527 3528[Rect_joinNonEmptyArg] 3529SkRect 3530void joinNonEmptyArg(const SkRect& r); 3531 3532[Rect_joinPossiblyEmptyRect] 3533SkRect 3534void joinPossiblyEmptyRect(const SkRect& r); 3535 3536[Rect_left] 3537SkRect 3538SkScalar left() const; 3539 3540[Rect_makeInset] 3541SkRect 3542SkRect makeInset(SkScalar dx, SkScalar dy) const; 3543 3544[Rect_makeOffset] 3545SkRect 3546SkRect makeOffset(SkScalar dx, SkScalar dy) const; 3547 3548[Rect_makeOutset] 3549SkRect 3550SkRect makeOutset(SkScalar dx, SkScalar dy) const; 3551 3552[Rect_makeSorted] 3553SkRect 3554SkRect makeSorted() const; 3555 3556[Rect_offset] 3557SkRect 3558void offset(SkScalar dx, SkScalar dy); 3559 3560[Rect_offset_2] 3561SkRect 3562void offset(const SkPoint& delta); 3563 3564[Rect_offsetTo] 3565SkRect 3566void offsetTo(SkScalar newX, SkScalar newY); 3567 3568[Rect_notequal_operator] 3569SkRect 3570bool operator!=(const SkRect& a, const SkRect& b); 3571 3572[Rect_equal_operator] 3573SkRect 3574bool operator==(const SkRect& a, const SkRect& b); 3575 3576[Rect_outset] 3577SkRect 3578void outset(SkScalar dx, SkScalar dy); 3579 3580[Rect_right] 3581SkRect 3582SkScalar right() const; 3583 3584[Rect_round_2] 3585SkRect 3586SkIRect round() const; 3587 3588[Rect_round] 3589SkRect 3590void round(SkIRect* dst) const; 3591 3592[Rect_roundIn] 3593SkRect 3594void roundIn(SkIRect* dst) const; 3595 3596[Rect_roundOut_3] 3597SkRect 3598SkIRect roundOut() const; 3599 3600[Rect_roundOut] 3601SkRect 3602void roundOut(SkIRect* dst) const; 3603 3604[Rect_roundOut_2] 3605SkRect 3606void roundOut(SkRect* dst) const; 3607 3608[Rect_set_2] 3609SkRect 3610void set(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom); 3611 3612[Rect_set] 3613SkRect 3614void set(const SkIRect& src); 3615 3616[Rect_set_3] 3617SkRect 3618void set(const SkPoint pts[], int count); 3619 3620[Rect_set_4] 3621SkRect 3622void set(const SkPoint& p0, const SkPoint& p1); 3623 3624[Rect_setBounds] 3625SkRect 3626void setBounds(const SkPoint pts[], int count); 3627 3628[Rect_setBoundsCheck] 3629SkRect 3630bool setBoundsCheck(const SkPoint pts[], int count); 3631 3632[Rect_setBoundsNoCheck] 3633SkRect 3634void setBoundsNoCheck(const SkPoint pts[], int count); 3635 3636[Rect_setEmpty] 3637SkRect 3638void setEmpty(); 3639 3640[Rect_setLTRB] 3641SkRect 3642void setLTRB(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom); 3643 3644[Rect_setWH] 3645SkRect 3646void setWH(SkScalar width, SkScalar height); 3647 3648[Rect_setXYWH] 3649SkRect 3650void setXYWH(SkScalar x, SkScalar y, SkScalar width, SkScalar height); 3651 3652[Rect_sort] 3653SkRect 3654void sort(); 3655 3656[Rect_toQuad] 3657SkRect 3658void toQuad(SkPoint quad[4]) const; 3659 3660[Rect_top] 3661SkRect 3662SkScalar top() const; 3663 3664[Rect_width] 3665SkRect 3666SkScalar width() const; 3667 3668[Rect_x] 3669SkRect 3670SkScalar x() const; 3671 3672[Rect_y] 3673SkRect 3674SkScalar y() const; 3675 3676[Region_Cliperator_const_SkRegion_const_SkIRect] 3677SkRegion 3678Cliperator(const SkRegion& region, const SkIRect& clip); 3679 3680[Region_Iterator_Iterator] 3681SkRegion 3682Iterator(); 3683 3684[Region_Iterator_copy_const_SkRegion] 3685SkRegion 3686Iterator(const SkRegion& region); 3687 3688[Region_copy_const_SkIRect] 3689SkRegion 3690explicit SkRegion(const SkIRect& rect); 3691 3692[Region_empty_constructor] 3693SkRegion 3694SkRegion(); 3695 3696[Region_copy_const_SkRegion] 3697SkRegion 3698SkRegion(const SkRegion& region); 3699 3700[Region_Spanerator_const_SkRegion_int_int_int] 3701SkRegion 3702Spanerator(const SkRegion& region, int y, int left, int right); 3703 3704[Region_computeRegionComplexity] 3705SkRegion 3706int computeRegionComplexity() const; 3707 3708[Region_contains_2] 3709SkRegion 3710bool contains(const SkIRect& other) const; 3711 3712[Region_contains_3] 3713SkRegion 3714bool contains(const SkRegion& other) const; 3715 3716[Region_contains] 3717SkRegion 3718bool contains(int32_t x, int32_t y) const; 3719 3720[Region_Iterator_done] 3721SkRegion 3722bool done() const; 3723 3724[Region_Cliperator_done] 3725SkRegion 3726bool done(); 3727 3728[Region_Op] 3729SkRegion 3730enum Op { kDifference_Op, kIntersect_Op, kUnion_Op, kXOR_Op, kReverseDifference_Op, kReplace_Op, kLastOp = kReplace_Op, }; 3731 3732[Region_getBoundaryPath] 3733SkRegion 3734bool getBoundaryPath(SkPath* path) const; 3735 3736[Region_getBounds] 3737SkRegion 3738const SkIRect& getBounds() const; 3739 3740[Region_intersects] 3741SkRegion 3742bool intersects(const SkIRect& rect) const; 3743 3744[Region_intersects_2] 3745SkRegion 3746bool intersects(const SkRegion& other) const; 3747 3748[Region_isComplex] 3749SkRegion 3750bool isComplex() const; 3751 3752[Region_isEmpty] 3753SkRegion 3754bool isEmpty() const; 3755 3756[Region_isRect] 3757SkRegion 3758bool isRect() const; 3759 3760[Region_Spanerator_next] 3761SkRegion 3762bool next(int* left, int* right); 3763 3764[Region_Cliperator_next] 3765SkRegion 3766void next(); 3767 3768[Region_Iterator_next] 3769SkRegion 3770void next(); 3771 3772[Region_op_1] 3773SkRegion 3774bool op(const SkIRect& rect, Op op); 3775 3776[Region_op_4] 3777SkRegion 3778bool op(const SkIRect& rect, const SkRegion& rgn, Op op); 3779 3780[Region_op_3] 3781SkRegion 3782bool op(const SkRegion& rgn, Op op); 3783 3784[Region_op_5] 3785SkRegion 3786bool op(const SkRegion& rgn, const SkIRect& rect, Op op); 3787 3788[Region_op_6] 3789SkRegion 3790bool op(const SkRegion& rgna, const SkRegion& rgnb, Op op); 3791 3792[Region_op_2] 3793SkRegion 3794bool op(int left, int top, int right, int bottom, Op op); 3795 3796[Region_notequal1_operator] 3797SkRegion 3798bool operator!=(const SkRegion& other) const; 3799 3800[Region_copy_operator] 3801SkRegion 3802SkRegion& operator=(const SkRegion& region); 3803 3804[Region_equal1_operator] 3805SkRegion 3806bool operator==(const SkRegion& other) const; 3807 3808[Region_quickContains] 3809SkRegion 3810bool quickContains(const SkIRect& r) const; 3811 3812[Region_quickContains_2] 3813SkRegion 3814bool quickContains(int32_t left, int32_t top, int32_t right, int32_t bottom) const; 3815 3816[Region_quickReject] 3817SkRegion 3818bool quickReject(const SkIRect& rect) const; 3819 3820[Region_quickReject_2] 3821SkRegion 3822bool quickReject(const SkRegion& rgn) const; 3823 3824[Region_readFromMemory] 3825SkRegion 3826size_t readFromMemory(const void* buffer, size_t length); 3827 3828[Region_Cliperator_rect] 3829[Region_Iterator_rect] 3830SkRegion 3831const SkIRect& rect() const; 3832 3833[Region_Iterator_reset] 3834SkRegion 3835void reset(const SkRegion& region); 3836 3837[Region_Iterator_rewind] 3838SkRegion 3839bool rewind(); 3840 3841[Region_Iterator_rgn] 3842SkRegion 3843const SkRegion* rgn() const; 3844 3845[Region_set] 3846SkRegion 3847bool set(const SkRegion& src); 3848 3849[Region_setEmpty] 3850SkRegion 3851bool setEmpty(); 3852 3853[Region_setPath] 3854SkRegion 3855bool setPath(const SkPath& path, const SkRegion& clip); 3856 3857[Region_setRect] 3858SkRegion 3859bool setRect(const SkIRect& rect); 3860 3861[Region_setRect_2] 3862SkRegion 3863bool setRect(int32_t left, int32_t top, int32_t right, int32_t bottom); 3864 3865[Region_setRects] 3866SkRegion 3867bool setRects(const SkIRect rects[], int count); 3868 3869[Region_setRegion] 3870SkRegion 3871bool setRegion(const SkRegion& region); 3872 3873[Region_swap] 3874SkRegion 3875void swap(SkRegion& other); 3876 3877[Region_translate] 3878SkRegion 3879void translate(int dx, int dy); 3880 3881[Region_translate_2] 3882SkRegion 3883void translate(int dx, int dy, SkRegion* dst) const; 3884 3885[Region_writeToMemory] 3886SkRegion 3887size_t writeToMemory(void* buffer) const; 3888 3889[Region_destructor] 3890SkRegion 3891~SkRegion(); 3892 3893[Surface_MakeFromBackendTexture] 3894SkSurface 3895static sk_sp<SkSurface> MakeFromBackendTexture(GrContext* context, const GrBackendTexture& backendTexture, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp<SkColorSpace> colorSpace, const SkSurfaceProps* surfaceProps); 3896 3897[Surface_MakeNull] 3898SkSurface 3899static sk_sp<SkSurface> MakeNull(int width, int height); 3900 3901[Surface_MakeRaster_2] 3902SkSurface 3903static sk_sp<SkSurface> MakeRaster(const SkImageInfo& imageInfo, const SkSurfaceProps* props = nullptr); 3904 3905[Surface_MakeRaster] 3906SkSurface 3907static sk_sp<SkSurface> MakeRaster(const SkImageInfo& imageInfo, size_t rowBytes, const SkSurfaceProps* surfaceProps); 3908 3909[Surface_MakeRasterDirect] 3910SkSurface 3911static sk_sp<SkSurface> MakeRasterDirect(const SkImageInfo& imageInfo, void* pixels, size_t rowBytes, const SkSurfaceProps* surfaceProps = nullptr); 3912 3913[Surface_MakeRasterDirectReleaseProc] 3914SkSurface 3915static sk_sp<SkSurface> MakeRasterDirectReleaseProc(const SkImageInfo& imageInfo, void* pixels, size_t rowBytes, void (*releaseProc) (void* pixels, void* context) , void* context, const SkSurfaceProps* surfaceProps = nullptr); 3916 3917[Surface_MakeRasterN32Premul] 3918SkSurface 3919static sk_sp<SkSurface> MakeRasterN32Premul(int width, int height, const SkSurfaceProps* surfaceProps = nullptr); 3920 3921[Surface_MakeRenderTarget_3] 3922SkSurface 3923static sk_sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted, const SkImageInfo& imageInfo); 3924 3925[Surface_MakeRenderTarget] 3926SkSurface 3927static sk_sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted, const SkImageInfo& imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps* surfaceProps, bool shouldCreateWithMips = false); 3928 3929[Surface_MakeRenderTarget_2] 3930SkSurface 3931static sk_sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted, const SkImageInfo& imageInfo, int sampleCount, const SkSurfaceProps* props); 3932 3933[Surface_characterize] 3934SkSurface 3935bool characterize(SkSurfaceCharacterization* characterization) const; 3936 3937[Surface_draw_2] 3938SkSurface 3939bool draw(SkDeferredDisplayList* deferredDisplayList); 3940 3941[Surface_draw] 3942SkSurface 3943void draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint); 3944 3945[Surface_notifyContentWillChange] 3946SkSurface 3947uint32_t generationID(); 3948 3949[Surface_getCanvas] 3950SkSurface 3951SkCanvas* getCanvas(); 3952 3953[Surface_height] 3954SkSurface 3955int height() const; 3956 3957[Surface_makeImageSnapshot] 3958SkSurface 3959sk_sp<SkImage> makeImageSnapshot(); 3960 3961[Surface_makeImageSnapshot_2] 3962SkSurface 3963sk_sp<SkImage> makeImageSnapshot(const SkIRect& bounds); 3964 3965[Surface_makeSurface] 3966SkSurface 3967sk_sp<SkSurface> makeSurface(const SkImageInfo& imageInfo); 3968 3969[Surface_notifyContentWillChange] 3970SkSurface 3971void notifyContentWillChange(ContentChangeMode mode); 3972 3973[Surface_peekPixels] 3974SkSurface 3975bool peekPixels(SkPixmap* pixmap); 3976 3977[Surface_props] 3978SkSurface 3979const SkSurfaceProps& props() const; 3980 3981[Surface_readPixels_3] 3982SkSurface 3983bool readPixels(const SkBitmap& dst, int srcX, int srcY); 3984 3985[Surface_readPixels_2] 3986SkSurface 3987bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY); 3988 3989[Surface_readPixels] 3990SkSurface 3991bool readPixels(const SkPixmap& dst, int srcX, int srcY); 3992 3993[Surface_width] 3994SkSurface 3995int width() const; 3996 3997[Surface_writePixels_2] 3998SkSurface 3999void writePixels(const SkBitmap& src, int dstX, int dstY); 4000 4001[Surface_writePixels] 4002SkSurface 4003void writePixels(const SkPixmap& src, int dstX, int dstY); 4004 4005[TextBlob_Deserialize] 4006SkTextBlob 4007static sk_sp<SkTextBlob> Deserialize(const void* data, size_t size, const SkDeserialProcs& procs); 4008 4009[TextBlob_MakeFromString] 4010SkTextBlob 4011static sk_sp<SkTextBlob> MakeFromString(const char* string, const SkFont& font, SkTextEncoding encoding = SkTextEncoding::kUTF8); 4012 4013[TextBlob_MakeFromText] 4014SkTextBlob 4015static sk_sp<SkTextBlob> MakeFromText(const void* text, size_t byteLength, const SkFont& font, SkTextEncoding encoding = SkTextEncoding::kUTF8); 4016 4017[TextBlob_bounds] 4018SkTextBlob 4019const SkRect& bounds() const; 4020 4021[TextBlob_getIntercepts] 4022SkTextBlob 4023int getIntercepts(const SkScalar bounds[2], SkScalar intervals[], const SkPaint* paint = nullptr) const; 4024 4025[TextBlob_serialize] 4026SkTextBlob 4027size_t serialize(const SkSerialProcs& procs, void* memory, size_t memory_size) const; 4028 4029[TextBlob_serialize_2] 4030SkTextBlob 4031sk_sp<SkData> serialize(const SkSerialProcs& procs) const; 4032 4033[TextBlob_uniqueID] 4034SkTextBlob 4035uint32_t uniqueID() const; 4036 4037[TextBlobBuilder_empty_constructor] 4038SkTextBlobBuilder 4039SkTextBlobBuilder(); 4040 4041[TextBlobBuilder_allocRun] 4042SkTextBlobBuilder 4043const RunBuffer& allocRun(const SkFont& font, int count, SkScalar x, SkScalar y, const SkRect* bounds = nullptr); 4044 4045[TextBlobBuilder_allocRunPos] 4046SkTextBlobBuilder 4047const RunBuffer& allocRunPos(const SkFont& font, int count, const SkRect* bounds = nullptr); 4048 4049[TextBlobBuilder_allocRunPosH] 4050SkTextBlobBuilder 4051const RunBuffer& allocRunPosH(const SkFont& font, int count, SkScalar y, const SkRect* bounds = nullptr); 4052 4053[TextBlobBuilder_make] 4054SkTextBlobBuilder 4055sk_sp<SkTextBlob> make(); 4056 4057