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