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