argb colorSpace _floatToInt8valuetoARGB32alphaopacityredgreenblue withValues withAlpha withOpacitywithRed withGreenwithBlue_linearizeColorComponentcomputeLuminancelerp alphaBlendgetAlphaFromOpacity==hashCodetoStringclearsrcdstsrcOverdstOversrcIndstInsrcOutdstOutsrcATopdstATopxorplusmodulatescreenoverlaydarkenlighten colorDodge colorBurn hardLight softLight difference exclusionmultiplyhue saturationcolor luminositynonelowmediumhighbuttroundsquaremiterbevelfillstrokehardEdge antiAliasantiAliasWithSaveLayer_data_kIsAntiAliasIndex_kColorRedIndex_kColorGreenIndex_kColorBlueIndex_kColorAlphaIndex_kColorSpaceIndex_kBlendModeIndex _kStyleIndex_kStrokeWidthIndex_kStrokeCapIndex_kStrokeJoinIndex_kStrokeMiterLimitIndex_kFilterQualityIndex_kMaskFilterIndex_kMaskFilterBlurStyleIndex_kMaskFilterSigmaIndex_kInvertColorIndex_kIsAntiAliasOffset_kColorRedOffset_kColorGreenOffset_kColorBlueOffset_kColorAlphaOffset_kColorSpaceOffset_kBlendModeOffset _kStyleOffset_kStrokeWidthOffset_kStrokeCapOffset_kStrokeJoinOffset_kStrokeMiterLimitOffset_kFilterQualityOffset_kMaskFilterOffset_kMaskFilterBlurStyleOffset_kMaskFilterSigmaOffset_kInvertColorOffset_kDataByteCount_objects_ensureObjectsInitialized _kShaderIndex_kColorFilterIndex_kImageFilterIndex _kObjectCount isAntiAlias_kColorDefault_kBlendModeDefault blendModestyle strokeWidth strokeCap strokeJoin_kStrokeMiterLimitDefaultstrokeMiterLimit maskFilter filterQualityshader colorFilter imageFilter invertColorssRGB extendedSRGB displayP3rawRgbarawStraightRgba rawUnmodifiedrawExtendedRgba128pngrgba8888bgra8888 rgbaFloat32_imageonCreate onDispose _debugStackwidthheight _disposeddispose debugDisposed toByteDatadebugGetOpenHandleStackTracesclone isCloneOf _toByteData_dispose_handlesdurationimage frameCountrepetitionCount getNextFrame_cachedFrameCount _frameCount_cachedRepetitionCount_repetitionCount _getNextFramenonZeroevenOdd intersectunionreverseDifferencefillTypemoveTorelativeMoveTolineTorelativeLineToquadraticBezierTorelativeQuadraticBezierTocubicTorelativeCubicToconicTorelativeConicToarcTo arcToPointrelativeArcToPointaddRectaddOvaladdArc addPolygonaddRRectaddRSuperellipseaddPathextendWithPathcloseresetcontainsshift transform getBoundscombinecomputeMetrics _constructor_clone _getFillType _setFillType_arcTo _arcToPoint_relativeArcToPoint_addRect_addOval_addArc _addPolygon _addRRect_addRSuperellipse_addPath_addPathWithMatrix_extendWithPath_extendWithPathAndMatrix _contains_shift _transform _getBounds_oppositionvectorangle _iteratoriterator _pathMetric _pathMeasurecurrentmoveNextlengthisClosed contourIndex_measuregetTangentForOffset extractPath_length _getPosTan _extractPath _isClosed _nextContour_nativeNextContourcurrentContourIndexnormalsolidouterinner_style_sigma _TypeNone _TypeBlurchildvalues_color _blendMode_matrix_type _kTypeMode _kTypeMatrix_kTypeLinearToSrgbGamma_kTypeSrgbToLinearGamma_toNativeImageFilter_toNativeColorFilter_shortDescriptioncreator _initMode _initMatrix_initLinearToSrgbGamma_initSrgbToLinearGammaisShaderFilterSupporteddata nativeFiltersigmaXsigmaYtileMode _modeStringradiusXradiusY innerFilter outerFilter_equals _initBlur _initDilate _initErode_initColorFilter _initComposed _initShader_debugDisposedclamprepeatedmirrordecal _initLinear _initRadial _initConical _initSweep_validateColorStops_initWithImage _debugName fromAsset_shaderRegistry_reinitializeShader_uniformFloatCount _samplerCount_initFromAssetfragmentShader_kEmptyFloat32List_floatssetFloatsetImageSampler_setImageSampler_validateSamplers_validateImageFilter triangles triangleStrip triangleFan_initpointslinespolygonsave saveLayerrestorerestoreToCount getSaveCount translatescalerotateskew getTransformclipRect clipRRectclipRSuperellipseclipPathgetLocalClipBoundsgetDestinationClipBounds drawColordrawLine drawPaintdrawRect drawRRect drawDRRectdrawRSuperellipsedrawOval drawCircledrawArcdrawPath drawImage drawImageRect drawImageNine drawPicture drawParagraph drawPoints drawRawPoints drawVertices drawAtlas drawRawAtlas drawShadow _recorder_sorted_saveLayerWithoutBounds _saveLayer_scale _getTransform _clipRect _clipRRect_clipRSuperellipse _clipPath_getLocalClipBounds_getDestinationClipBounds _drawColor _drawLine _drawPaint _drawRect _drawRRect _drawDRRect_drawRSuperellipse _drawOval _drawCircle_drawArc _drawPath _drawImage_drawImageRect_drawImageNine _drawPicture _drawPoints _drawVertices _drawAtlas _drawShadowtoImage toImageSyncapproximateBytesUsed_toImage _toImageSync isRecording endRecording _endRecording_canvas_kBytesPerShadow _kColorOffset _kXOffset _kYOffset _kBlurOffsetoffset blurRadiusconvertRadiusToSigma blurSigmatoPaintlerpList_encodeShadows fromUint8List fromFilePath _initFromFileencoded bytesPerPixelinstantiateCodec _initEncoded_initRaw_width _getWidth_height _getHeight_bytesPerPixel_getBytesPerPixel_instantiateCodecmessagestacka _rectIsValid _rrectIsValid_rsuperellipseIsValid_offsetIsValid_matrix4IsValid_radiusIsValid _scaleAlphaColor BlendMode FilterQuality StrokeCap StrokeJoin PaintingStyleClipPaint ColorSpace_colorSpaceToIndex_indexToColorSpaceImageByteFormat PixelFormatImageEventCallbackImage_Image _wrapImageImageDecoderCallback FrameInfoCodec _NativeCodecinstantiateImageCodecinstantiateImageCodecFromBufferinstantiateImageCodecWithSize_getDefaultImageSizeTargetImageSizeCallbackTargetImageSizedecodeImageFromList_decodeImageFromListAsyncdecodeImageFromPixels PathFillType PathOperation EngineLayer_NativeEngineLayerPath _NativePathTangent PathMetricsPathMetricIterator PathMetric _PathMeasure BlurStyle MaskFilter_ColorTransform_IdentityColorTransform_ClampTransform_MatrixColorTransform_getColorTransform ColorFilter _ColorFilter ImageFilter_MatrixImageFilter_GaussianBlurImageFilter_DilateImageFilter_ErodeImageFilter_ComposeImageFilter_FragmentShaderImageFilter _ImageFilterShaderTileMode_encodeWideColorList_encodeColorList_encodePointList_encodeTwoPointsGradient ImageShaderFragmentProgramFragmentShader VertexModeVertices PointModeClipOpCanvas _NativeCanvasPictureEventCallbackPicture_NativePicturePictureRecorder_NativePictureRecorderShadowImmutableBufferImageDescriptor_NativeImageDescriptor _Callback_CallbackWithError _Callbacker_CallbackerWithError _futurize_futurizeWithErrorPictureRasterizationExceptiondartuiboolRecthasNaNRRect RSuperellipseOffsetdxisNaNdy Float64ListlengtheverydoublevalueisFiniteRadiusxy withValuesalpha clampDoubleanewsRGBint _fromARGBCfromRGBO _fromRGBOCfromARGBround Deprecatedfromredgreenblue colorSpace transformmathpow extendedSRGBHSVColormaterialColors transparentCurves elasticInOutAnimationController _lerpDoublergboverrideObject identical runtimeTypehashStringtoStringAsFixedsrcdstclear saveLayerrestore blendModesrcOverdstInsrcOutsrcIndstOutdstATopdstOversrcATopplusmultiplyscreenoverlaymodulate hardLight colorDodge colorBurncolor exclusion difference luminosityhue softLight saturationblurBackdropFilternonelowmediumhigh filterQualitymatrix drawImage drawImageRect drawImageNine drawAtlas strokeCapAsquare strokeWidthbuttdrawPath drawPoints strokeJoinstrokeMiterLimitstyle drawCircle isAntiAliashardEdge antiAliasantiAliasWithSaveLayerbuffer asUint32ListsetAll_data_objectstoListpragmaByteDataListfilledgetInt32_kFakeHostEndiansetInt32 getFloat32 setFloat32indexvaluesfillstrokemiterbevel _TypeNone _TypeBlur_style_sigma debugDisposed_validateSamplers Exception _debugNamecreator_toNativeColorFilter_toNativeImageFilterfromEnvironmenttoString StringBufferwrite toByteDatarawExtendedRgba128 displayP3 ArgumentErrorvoidwidgets StackTracecurrent_handlesaddcallMemoryAllocations _disposedcontainsremoveisEmptydispose StateErrorformatrawRgbaFutureUnsupportedErrormaphandle _debugStack__imageNativeFieldWrapperClass1NativeInt32PointerVoidsymbolisLeaf Uint8Listerrorencodedcallback asByteDataHandleSetwidthheight getNextFramecloneDurationimage Completersync decodeError completeErrorcompleteduration millisecondsdurationMillisecondsfuture fromUint8List targetWidth targetHeightallowUpscaling getTargetSizeintrinsicWidthintrinsicHeightinstantiateCodecthenrawrowBytes pixelFormatcodec frameInfofillTypecombinereverseDifferencexor intersect SceneBuilderclipPath_clonenonZerozero fromCircle_op extractPathIterableDoublelefttoprightbottomBoolradiusrotationlargeArc clockwise Float32List _getValue32_native_NativeRSuperellipsematrix4fromLTRB forceClosedgetTangentForOffsetcossinatan2computeMetricslineTomoveTo IterableBaseIterator RangeError _nextContourcurrentContourIndexisClosedcloseaddRectstartWithMoveTo nextContour maskFilter drawShadow colorFilterfromColorFiltermodelinearToSrgbGammasrgbToLinearGamma_type _listEquals_matrix_color _blendModehashAll _kTypeMode _kTypeMatrixfromList_kTypeLinearToSrgbGamma_kTypeSrgbToLinearGamma ImageFilteredpushBackdropFilterpushImageFiltersigmaXsigmaYtileModeradiusXradiusYMatrix4 diagonal3data innerFilterinner outerFilterouter_impellerEnabled_floats_validateImageFiltershaderclampmirrorrepeateddecaldilateerodecomposed_shortDescriptionhashCode nativeFilterpaintingGradientLinearGradientRadialGradient BoxDecorationlinearradiali Int32ListNoSuchMethodError colorStopsfocal focalRadiuspi startAngleendAngle isNotEmptyUripath encodeFull microtask _fromAssetMap_initFromAsset debugNamefragmentShader_uniformFloatCount _samplerCount drawVertices triangles triangleStrip triangleFan Uint16ListcolorstextureCoordinatesindices drawRawPointsclipRectSceneRendererBinding createCanvas PictureLayertoImage endRecording CustomPainterpaintsy doAntiAliasarcTo ParagraphlayoutParagraphStyleParagraphBuilder TextAlignParagraphConstraintspointslinespolygon RSTransformscosssintxty isRecording_canvascullRectlargestminmaxclipOpUint32stack_NativeParagraph _needsLayout_paint addPicture drawPicture onDisposeUint64createPictureRecorder _recorderonCreate TextStylenormaloffset blurRadiusscalelerp shadowIndex_kColorDefaultconvertRadiusToSigma_init_length _initFromFile _initEncodedTt toImageSyncwritelnNativeFieldWrapperClass1Codec EngineLayerPath IterableBaseIterator_ColorTransform ImageFilterShaderCanvasPicturePictureRecorderImageDescriptor ExceptionjdVDJPt$vj<΀-FyC4ӄb^mop 3ˇ jy{| 7vxyLj܊Ck $t DHTfnrdhvzǐ/ې8>io _Ւۓ!nٓ:ɔޔLM+;ARXfޖ#sy $=Xr͘ޘߙ%+xԙCIGH7NTyƝCIڝY.JKr/0Utu ƠǠHaߡ`"mIߤ1}Ȧ+xƧa~ԧOUƨ'([aԩK}DE}ܫݬ#gMjpЮ$9L]pï 2MdƯ̰ d6lrűCɳ+Yߴ JcWr%+c}.Nnt _}߹RMS޺.{S4ҾpG}ȿ߿@@+@3@@@W@y@@@AAKAAAAABBBBKBBBC*CuCDDODDDEE2EKEQExEEEEFF?F~FFFFGG;GlGGGHHSHHHHHHI+I1I\IIIIIIJ J3J9JeJyJJJJJJK$K(K)K5KpKqK}KL9L;L<LoLsLM M)M-M~MNNhNOOGOKOOP7PPQQeQQRER`RdRRSISST9TzT~TTTU8UUV'VvVVVVVWAWRWcWWX X XPXVXXXXXY>YDYYYYYZDZKZLZZZZZ[5[;[[[[[\/\\\\]]$]]]]]]^^P^V^^_ _5_@_A__`#`1`7`v`|`aa!a'asayaaab-b{bbcc cXcccdd_dhdide eZe`eeefDfJfffgggZgggh3h9hhhi*i0iiiijjj\jbjjk2k8kkkklllTlolullmm`mmmmmn[nfngnnno>oDooooop;pppqqqXqqrFrrrrrsEsKssst@titottu&u,u<uBuuuv2vIvUvVvvvwwwbwwwx5xxxxyLyyyzzzxz~zzzz{={Y{{{|%|T|Z||}J}i}o}~~7~=~~~~~8 ,2{Jio.9:u{CI _BOPb/|(.g)67LRbhMdjjxy(?EDQR]cDJ#K S*0@F?FGP}C!'pvDJG X=CSY "023'nrqRVHgky}4On;<RXCI*u{DYcdRX'rxbF089tz L |Kkuwx7;IM/ek"r~J/5}CT]^KQ _py{| "m{|/78| GQSTx|SHDJ x>bno3KQrx3žE×_{PVř&zƿ)F`bcǥǩ"jȀȋȌ$bhɶNjʺ .|˥˩˪)t`e͵deΆ΢.Vπϩ&KvП)TшѸ'cң!aӟUԕ'gչEFև/Kfgו.Yحخ 9ـلم٥Fڊڎڏ17W]ms۹28܀ܕܩGݖ#_f*o߳^bc)/q4:@t=x|} !ek)NW] B6R378y![a[akw}W 2WZ@-QW/5AMSci759:Uv'ny&nB>DHI;Ai489dJP`f Tk2EO_ 3=uyzUvb)/34ou1C]!BMUb$hpvz{  V       X \ ] i      ( D m      ! J o w   5 ? N t |     1YqwNflSkq8PVn48{BFy}6bh?w6 Ia{1=[g  LdG#./OU5p'-BHVtV!,4>TUgm  W   !D!P!V!f!l!"""""Y"l"# #=#I#J##$$'$($x$%%I%X%Z%[%%%%%&;&?&&&&'G''($(2(6(()))*).))**`*n*****++.+2+3+T+p++++,,Y,z,,,,-2-u-----..2.3.u...../#/)/z///01000001'1=1t111111222g2}2222223 3k3o3p33344 4R4445;5T556=667 797=7>7z7788G8M8899i999:::4:B:j:y::::;#;E;K;;;;6>>>>?B?k?q?@ @ @&@\@b@p@@@@AA@A_AAAAB<BBBBCCC CBCvCCD/DsDDDE E;EAE^ExE~EEEEEFF&F,FGFMFpFFFFFFFGAGGGGGHHnHHIII-IXI\I]IIIJBJJK+KuKKKLL2L4L5LOLLLLM;M]MyMMMMMNBN]N^NNOIOyOOOOOOPPP?PPPQ QQ4Q@QXQQRR?RFR\RlRpRqRRS#S?S@SiSjSSSST TTT)TJT~TTTTTU$U(UdU~UUVVcVVWW!WZW^WjWvWWXX\XXYY/YPYVY^YbYxY|YYYZZPZZZ[D[[[[[\\3\9\w\\\]]]T]o]p]]]]^9^N^P^Q^q^u^^^__0_G_m_____``-`.`V`\````a>anaaabb bWb|bbbbbc+cFcKcccccccdddndddddeee_eeeeff.fCfcf}fffg$g.gggvgggh+h8hChKhShlhhhhhhi?iiiiiijjgjijjjjjk0k~kkklEl`llmm\mmn nnZnnoCoop/pwppqqKqqqr(r4rYrmrrrrs s5sAs_ssssssst!tqtttu:uuuvvgvsvwvw w\wwxHxxyyyiyzz?zCzzzzz{{d{{||"|6|K|i|n||||}B}j}t}}}}~?~F~K~M~N~q~u~~`;QU<}lA EI/WKS.V{$FHI!BONf$s^ _Isy Y]ARow'+y,} U@(dhL 1Fdi_+o.~"Hd#'^rb%&hnOZ\] !U[5;KQ>DGTU?t}~V9?/5~m/84FHI!".vV"aMc=C6f} (LMcp :;~DC*+p9B=> Ty].s(vw%IOa¨ eÛ<āćcŊŐ$pvƉƞƿfǫDZ:Ȉ^ɬ+Efʁʜʷʽʾ78z˨ˮNij̲.o͵=IOλ+1ϡUVШжм 06}ѱѲ7Gefҳ^dӱ*lmԳ/5ՂGH֍$h׃דה1PV؞ؤ Ixٕٖ-.ciڹQېۖ6܈m{!4:ފ[߇nuyzL2|R%rR>0dj@BC.s(NO[A`aR~45A5GKcdpUVbIJVMNZ-.:*|_z278DWl - <Pdx0Kf*:JZkrvw7K_sMQR+Gg $tu59:$;RWXd"_`l NO[R (PQ op|-#GK   @ V e t         ^ w x       V       * ; ? @      . \ {    #$0Ep>BCOnpq#3dj ^39n$*z9%6{T04;qr+EEf~='Wjp , w   !;!!"&"t""""#3#f#g###$6$$$$$%%V%%%%&&&^&&'B'{''((n((((()2)Y)_))***N*T**+ +++[+a++,5,,,,,----O----..E.F.j.v...////{////0$0o0v0011#10111112.2/222333F3333344464H4^4p44444445F5M5q5u5v5666-62666677"7(797=7>7778 88R8r8t8u8889/909}999::e::::;;;~;;;;;;;:>>>>?>?D?j?p???@@@!@8@9@@@A*A+A7AZAAAAAAABPBRBSBtBBBBCCCdCfCgCCCCD(D?DhDDDEE EEEEKE\EEEEEEFFFvFG+GOGVGZG\G]GGHIHNH`HvHHHHHI.IIJ JJJ+JVJtJJKKSKmKKLLFLaLLM MM%M?M\MzMMNN'NBNJNlNNNOOBOeOOOOOP+PQPlPPPPPPQ!QpQR R;R?RRRS S^SSSTGTtTTTTUUU^UUUV V5V;VnVVWW:W@WWWWX/XFX]XtXXXXXXXXXY0YLYhYYYYYZAZGZUZZZZ[[([2[8[[[\\<\b\\\\\]] ]8]T]U]]]]^^^D^E^^^^___A_B_Y_x____``T````a aXaYaaaaabb+bDbrbbbbc&cJccccd)d/d3d4d@dcddddde#eEemeqere~eef f$f%f1fRfgf~fffg#gUgygggggggh h!h8hqhhhii3ieitjjjjjj[j_jjkLkbkkllHlLlMllllm'mlmmmmmnn+nInMnNnnnno o@oAooop/p`papppqTq~qqqqqqrrfrrs)sTsqssst-ttttu5u{uv vvvTvvw4w8w9w}wwxx9xTxxxxxyYy]y^yyyz4zYzzz{{7{={{|)|y|||}8}d}j}~~~#~1~^~d~~~~~~~7c ^$A$O %nv`>ef  <+7no{?kgij3OPd8Pl &*+7 5IO+-.`(_`l*VjpJGHT<PV1$0ghtGHTw>BCOYZf+,8[(,-t*.~P59:'X\]7K{b $^bc7[_`F(<\`a'9=89rE'(oO^.JXYxy,<]pz Z7=#-134A7<;?MQ/Y_lr bN iSGMSnt$9?jtuph-689p˜PsÖù%MĨ=wŠž(Gfj{}~ƻ,E^wǐǡǣǤBUYgk ?Eɔ/~ p˒˘#̆Mͳ͹Jekθ K^o~Ϙ϶@|ЏмCmѳ"&'rҒҘ8ӂ"s9ou;֟ \ע׽cأةCٍ*Obuڈڢ3Zۖ۩F܉܊Kݏݥݸ6GP]kޢ%:M`p߆ߠ߸-KQ%+zdVx~w<FioOat.U{:d2DTcjnoAEb}Dhl %*+6I^lz:M`x"0G\uz{ ckx W6|Sag!'m 'CRcuZ`t %CIMNZmOy}Rw(=AkEY45z[q=>YAW_cd=LMGAGKLh#$<>?rvC  U   % P       : ; {     0 ~   g     0Ojtz7bH)/V:KQ7;<rxf Itxy\gOSr   ^b)*xA ]:O M  !6!!"""="A""#%#G#K##$,$}$%%A%x%%&&`&&'('.'{'''(I(((()H)))***n*++\++,@,P,V,,,---d-..R.y.....///U///0T0Z0j00011l12222'2/2B2L2233p333334464K4a4j44445575=556&6q6667=77778B889)9z9:::U::;>;w;};<'>w>>>?8?H?]?z?????@@s@|@@AAAmAAAAB9BqBBC.C{CCCCCCDD[DaDeDfDDEEE)ENEeE~EEEEF F"F2FJF]FgFwF{F|FFG1GMGNGhGiGGHHH8HLH\HxHHHIIIIIcIgIIIJJJfJJJK<KKKKKKL2L8LzLLLLLMM.M9M;M<MMMMMMN N NCNPNRNSNNNOOXO\OOP>P[P_PPQ-Q1Q~QQQQR6RRS#SmSSST6TNTTTTUFUUV2VuV{VVW&W'WoWuWWWWXXCXRXSXXYDYYYYZ?ZZ[#[m[s[[[[\>\\]*]O]U]]^=^^_)_q___`` ``H`p```a'a`azaaaaabIbbbbbc9cacxccd(dBdJdTdZdde;eAeOe|eef f:fQffgg ggghghh:h@hdhjhhhiKiij6jjkkkkkkkklClellllm1mPmVmmmn(n:n;nno6o<o{ooppApcpdppq3qhqnqqqqrJrrrsrs ss#sis{ssstttituu-uPuQuuvvvWvvvw!wowwx x xYxpxvxxyyynyyyz/zCzzz{ {{g{m{{| |Q|||}*}L}R}}}~~S~~EF NTNOEV\UF9U[9EKYz.hh'-sJ/0&,|ngtzbKQ.IhieOs@fl<lOrxR{|ho+xgX) UP'-|0C#q NT=$=bc#oO?(uBHD]C&,<BEKH_eH+v\*v9:~. cUEKAjVDJ8>&.4b˜ž6<N}Þ 3Rnī-[ʼnŚů&MW]lt~ƄJ]tLJǠǨǮqȏȰȶOɃɭ1Omʳ 5iˬ*V`fu}̇̍!TZjp;0IcwΈ΍Ύ)ς){ ZѢѨ9djҸTӡRciwԌԵQWհ6ֆ&Bׇ 4jؓغq&hڔ>JkY_m܂$*Xݎݔ ,2DscL5eEH (D&]' O[| !17 &:KPQ 5;lpq'8HZmrs+p ,D` $()5c}OUYZp056BEFR8ijvCDP;ghtk)-.~9S04EUgzAEF:lklx?~?CD3Z@AMMNZu)./;[/0<f:@DE  # D \ a b n      a     + M       6 M d       & t x y   :[sxy' &7GYlRVW;SXYe%8J\m )5CQWv9QVWc6#I]n7=AB6Njop|!K_o~ -4M (6DR`n|%;Obw<^+;J[m % + / 0 ; P e z         !!!!>!a!s!!!!!!" "#"D"\"x"}"~"""####\####$&$R$v$$$$$%5%%%%%&&Y&_&&&''-'N'f'y'''''((^(b(c(((())#)D)\)a)b)n))))))**!*'*I****+*+0+}+++++,D,,,,,--=-s---.#.W..../%/+/,/O//000=0S0f0z000001 111.1|1111111122 242E2K2|2}223 3&3D33334e4n4t4444455$595F5T5~55556 6666"676L6Z6h6u666666667767N7j7|77777778 8a88899)9-9J9`9o99999999:(:g:h::::;3;u;;<<<`<<<<=.=4===> >>8>>>>?%?U?V???@$@s@@AA`AAAB,BEBKBBBBC,COCaCbCCCDD,D-DvD|DDEE!E"ErEEEFF*F+F7FhFFFFFGEGbG|GGGGGGGHJHHHHHIIJIPIQIvIIIIJ9JJJJJJJJJKK/K3K4KKKLLLL L,LGL[LkLLLLMM M!M-MMMMMMMN-N1NvNNNNO4OOPPaPPPQ+QrQQRR7RmRnRRRS:SqSST T T:T@TTU U:U<U=UUUUUVV7V8VDVoVpV|VVVVW3WOWnWWXXAXUXYXZXXXYY YYXYZY[YpYtYYYYZ*ZuZZZZ[+[D[U[[[\\\C\g\\\] ]4]5]e]k]]]]^5^;^^__._/_____```;``aaaaYa_aaabb"b_bbbcchcccdddYd]d^ddde9e=e>eneteff&f,fRffg4gghhkhhii$i9iqiiiiiiijj)j8jOjjjkkkkkkRkXkkkll9lLlRlhl~llmmDmJmmmmnn nn#n$n0nSnunnnnnoooo'oeofopp pZpuppppq q q$qqqqqqrrOrirrrsrrs,s-s|ssssssttGtItJttttu8u[u\uuvvEvwvvvvwww@w~wx xVxxyy7ysyyyyzz zzzCzIzzz{+{`{{{{{||| | |a||}}P}Q}}}~.~K~Z~[~z~{~~~.>_r| \@ (8<=cg(.~>.Ld}%h<@Akq*<=ou9?,2}/W!"[a#qB`~^v+~5Q`p"#/Z[kl67  e*0e4s01[!wxK{|;?7A^aB:I G].6C`fl~\Zp4CVH}3KL6Og1yCa/// An immutable color value in ARGB format. /// /// Consider the light teal of the [Flutter logo](https://flutter.dev/brand). It /// is fully opaque, with a red [r] channel value of `0.2588` (or `0x42` or `66` /// as an 8-bit value), a green [g] channel value of `0.6471` (or `0xA5` or /// `165` as an 8-bit value), and a blue [b] channel value of `0.9608` (or /// `0xF5` or `245` as an 8-bit value). In a common [CSS hex color syntax](https://developer.mozilla.org/en-US/docs/Web/CSS/hex-color) /// for RGB color values, it would be described as `#42A5F5`. /// /// Here are some ways it could be constructed: /// /// ```dart /// const Color c1 = Color.from(alpha: 1.0, red: 0.2588, green: 0.6471, blue: 0.9608); /// const Color c2 = Color(0xFF42A5F5); /// const Color c3 = Color.fromARGB(0xFF, 0x42, 0xA5, 0xF5); /// const Color c4 = Color.fromARGB(255, 66, 165, 245); /// const Color c5 = Color.fromRGBO(66, 165, 245, 1.0); /// ``` /// /// If you are having a problem with [Color.new] wherein it seems your color is /// just not painting, check to make sure you are specifying the full 8 /// hexadecimal digits. If you only specify six, then the leading two digits are /// assumed to be zero, which means fully-transparent: /// /// ```dart /// const Color c1 = Color(0xFFFFFF); // fully transparent white (invisible) /// const Color c2 = Color(0xFFFFFFFF); // fully opaque white (visible) /// /// // Or use double-based channel values: /// const Color c3 = Color.from(alpha: 1.0, red: 1.0, green: 1.0, blue: 1.0); /// ``` /// /// [Color]'s color components are stored as floating-point values. Care should /// be taken if one does not want the literal equality provided by `operator==`. /// To test equality inside of Flutter tests consider using [`isSameColorAs`][]. /// /// See also: /// /// * [Colors](https://api.flutter.dev/flutter/material/Colors-class.html), /// which defines the colors found in the Material Design specification. /// * [`isSameColorAs`][], /// a Matcher to handle floating-point deltas when checking [Color] equality. /// /// [`isSameColorAs`]: https://api.flutter.dev/flutter/flutter_test/isSameColorAs.html`/// Construct an [ColorSpace.sRGB] color from the lower 32 bits of an [int]. /// /// The bits are interpreted as follows: /// /// * Bits 24-31 are the alpha value. /// * Bits 16-23 are the red value. /// * Bits 8-15 are the green value. /// * Bits 0-7 are the blue value. /// /// In other words, if AA is the alpha value in hex, RR the red value in hex, /// GG the green value in hex, and BB the blue value in hex, a color can be /// expressed as `Color(0xAARRGGBB)`. /// /// For example, to get a fully opaque orange, you would use `const /// Color(0xFFFF9000)` (`FF` for the alpha, `FF` for the red, `90` for the /// green, and `00` for the blue). /// /// {@template dart.ui.Color.componentsStoredAsFloatingPoint} /// > [!NOTE] /// > Each color is stored as floating-point color components, where the final /// > value of each component is approximated by storing `c / 255`, where `c` /// is one of the four components (alpha, red, green, blue). /// {@endtemplate}  I  #-'03:DEO/// Construct a color with floating-point color components. /// /// Color components allows arbitrary bit depths for color components to be be /// supported. The values are interpreted relative to the [ColorSpace] /// argument. /// /// ## Example /// /// ```dart /// // Fully opaque maximum red color /// const Color c1 = Color.from(alpha: 1.0, red: 1.0, green: 0.0, blue: 0.0); /// /// // Partially transparent moderately blue and green color /// const Color c2 = Color.from(alpha: 0.5, red: 0.0, green: 0.5, blue: 0.5); /// /// // Fully transparent color /// const Color c3 = Color.from(alpha: 0.0, red: 0.0, green: 0.0, blue: 0.0); /// ``` (98ARQ\mlv!|{ʘƘ֘Ԙؘe/// Construct an sRGB color from the lower 8 bits of four integers. /// /// * `a` is the alpha value, with 0 being transparent and 255 being fully /// opaque. /// * `r` is [red], from 0 to 255. /// * `g` is [green], from 0 to 255. /// * `b` is [blue], from 0 to 255. /// /// Out of range values are brought into range using modulo 255. /// /// See also [fromRGBO], which takes the alpha value as a floating point /// value. /// /// {@macro dart.ui.Color.componentsStoredAsFloatingPoint}   (D),/25?@JPUV`Va felqpu zy雷Û؛ɛ֛Лʛқڛߛ%*+3+/// Create an sRGB color from red, green, blue, and opacity, similar to /// `rgba()` in CSS. /// /// * `r` is [red], from 0 to 255. /// * `g` is [green], from 0 to 255. /// * `b` is [blue], from 0 to 255. /// * `opacity` is alpha channel of this color as a double, with 0.0 being /// transparent and 1.0 being fully opaque. /// /// Out of range values are brought into range using modulo 255. /// /// See also [fromARGB], which takes the opacity as an integer value. /// /// {@macro dart.ui.Color.componentsStoredAsFloatingPoint}498;@?BGFIQP _cdnorux  '%!)64C8A;9=EM5$/// The alpha channel of this color.3"/// The red channel of this color.5$/// The green channel of this color.4,,#/// The blue channel of this color.2@hh"/// The color space of this color.Ɂʀ/// A 32 bit value representing this color. /// /// This getter is a _stub_. It is recommended instead to use the explicit /// [toARGB32] method.cdno/// The alpha channel of this color in an 8 bit value. /// /// A value of 0 means this color is fully transparent. A value of 255 means /// this color is fully opaque.ȨɨӨԩ*/// The alpha channel of this color as a double. /// /// A value of 0.0 means this color is fully transparent. A value of 1.0 means /// this color is fully opaque.֩ש4/// The red channel of this color in an 8 bit value.MNX{Y  6/// The green channel of this color in an 8 bit value.G5/// The blue channel of this color in an 8 bit value.K+DK?K?K+K,wN2g/// Returns a 32-bit value representing this color. /// /// The returned value is compatible with the default constructor /// ([Color.new]) but does _not_ guarantee to result in the same color due to /// [imprecisions in numeric conversions](https://en.wikipedia.org/wiki/Floating-point_error_mitigation). /// /// Unlike accessing the floating point equivalent channels individually /// ([a], [r], [g], [b]), this method is intentionally _lossy_, and scales /// each channel using `(channel * 255.0).round() & 0xff`. /// /// While useful for storing a 32-bit integer value, prefer accessing the /// individual channels (and storing the double equivalent) where higher /// precision is required. /// /// The bits are assigned as follows: /// /// * Bits 24-31 represents the [a] channel as an 8-bit unsigned integer. /// * Bits 16-23 represents the [r] channel as an 8-bit unsigned integer. /// * Bits 8-15 represents the [g] channel as an 8-bit unsigned integer. /// * Bits 0-7 represents the [b] channel as an 8-bit unsigned integer. /// /// > [!WARNING] /// > The value returned by this getter implicitly converts floating-point /// > component values (such as `0.5`) into their 8-bit equivalent by using /// > the [toARGB32] method; the returned value is not guaranteed to be stable /// > across different platforms or executions due to the complexity of /// > floating-point math.߅ ,,(/// Returns a new color with the provided components updated. /// /// Each component ([alpha], [red], [green], [blue]) represents a /// floating-point value; see [Color.from] for details and examples. /// /// If [colorSpace] is provided, and is different than the current color /// space, the component values are updated before transforming them to the /// provided [ColorSpace]. /// /// Example: /// ```dart /// import 'dart:ui'; /// /// Create a color with 50% opacity. /// Color makeTransparent(Color color) => color.withValues(alpha: 0.5); /// ```= FEP YXa jit }| /// Returns a new color that matches this color with the alpha channel /// replaced with `a` (which ranges from 0 to 255). /// /// Out of range values will have unexpected effects.  /// Returns a new color that matches this color with the alpha channel /// replaced with the given `opacity` (which ranges from 0.0 to 1.0). /// /// Out of range values will have unexpected effects.! ˲ֳ̲׳RR/// Returns a new color that matches this color with the red channel replaced /// with `r` (which ranges from 0 to 255). /// /// Out of range values will have unexpected effects.Z_^ __/// Returns a new color that matches this color with the green channel /// replaced with `g` (which ranges from 0 to 255). /// /// Out of range values will have unexpected effects.inmkk/// Returns a new color that matches this color with the blue channel replaced /// with `b` (which ranges from 0 to 255). /// /// Out of range values will have unexpected effects.tyxŷ"!`ʀ/// Returns a brightness value between 0 for darkest and 1 for lightest. /// /// Represents the relative luminance of the color. This value is computationally /// expensive to calculate. /// /// See . ""/// Linearly interpolate between two colors. /// /// This is intended to be fast but as a result may be ugly. Consider /// [HSVColor] or writing custom logic for interpolating colors. /// /// If either color is null, this function linearly interpolates from a /// transparent instance of the other color. This is usually preferable to /// interpolating from [material.Colors.transparent] (`const /// Color(0x00000000)`), which is specifically transparent _black_. /// /// The `t` argument represents position on the timeline, with 0.0 meaning /// that the interpolation has not started, returning `a` (or something /// equivalent to `a`), 1.0 meaning that the interpolation has finished, /// returning `b` (or something equivalent to `b`), and values in between /// meaning that the interpolation is at the relevant point on the timeline /// between `a` and `b`. The interpolation can be extrapolated beyond 0.0 and /// 1.0, so negative values and values greater than 1.0 are valid (and can /// easily be generated by curves such as [Curves.elasticInOut]). Each channel /// will be clamped to the range 0 to 255. /// /// Values for `t` are usually obtained from an [Animation], such as /// an [AnimationController].'/.198;CBB DD/// Combine the foreground color as a transparent color over top /// of a background color, and return the resulting combined color. /// /// This uses standard alpha blending ("SRC over DST") rules to produce a /// blended color from two colors. This can be used as a performance /// enhancement when trying to avoid needless alpha blending compositing /// operations for two things that are solid colors with the same shape, but /// overlay each other: instead, just paint one with the combined color.D)D0D/D;DBDAHIiIiw/// Returns an alpha value representative of the provided [opacity] value. /// /// The [opacity] value may not be null.I}IIIсVIII IIIIKsKKKsKtcJ/// A description of the style to use when drawing on a [Canvas]. /// /// Most APIs on [Canvas] take a [Paint] object to describe the style /// to use for that operation.$fȂȂȇY/// Constructs an empty [Paint] object with all fields initialized to /// their defaults.ȎPUVZV/// Constructs a new [Paint] object with the same fields as [other]. /// /// Any changes made to the object returned will not affect [other], and /// changes to [other] will not affect the object returned. /// /// Backends (for example web versus native) may have different performance /// characteristics. If the code is performance-sensitive, consider profiling /// and falling back to reusing a single [Paint] object if necessary.[ ba,ΈLγγ ΈΉΏΠΐλ'+0$AASX&ii}ς%ϓϓϦϫ&ϼϼ&%#(!99HM'^^sx%ЉЉМС'вв-*%+'<<PV0ggфъ,ћћѴѺ(>!$)8::]M`e<vvҝҋҠҥ:ҶҶ< #<44[I^c:ttәӈӜӡ2ӲӲ>:**O>RW<hhԏ}ԒԗHԨԨB! $)<::aOdiNzzճ՘նջF>?,B։%֚֚֬13\\128I9"'+0'AAV["ll|,=3 ذ++i/// Whether to apply anti-aliasing to lines and images drawn on the /// canvas. /// /// Defaults to true.ܡܡ/// The color to use when stroking or filling a shape. /// /// Defaults to opaque black. /// /// See also: /// /// * [style], which controls whether to stroke or fill (or both). /// * [colorFilter], which overrides [color]. /// * [shader], which overrides [color] with more elaborate effects. /// /// This color is not used when compositing. To colorize a layer, use /// [colorFilter].߃/// A blend mode to apply when a shape is drawn or a layer is composited. /// /// The source colors are from the shape being drawn (e.g. from /// [Canvas.drawPath]) or layer being composited (the graphics that were drawn /// between the [Canvas.saveLayer] and [Canvas.restore] calls), after applying /// the [colorFilter], if any. /// /// The destination colors are from the background onto which the shape or /// layer is being composited. /// /// Defaults to [BlendMode.srcOver]. /// /// See also: /// /// * [Canvas.saveLayer], which uses its [Paint]'s [blendMode] to composite /// the layer when [Canvas.restore] is called. /// * [BlendMode], which discusses the user of [Canvas.saveLayer] with /// [blendMode].#k/// Whether to paint inside shapes, the edges of shapes, or both. /// /// Defaults to [PaintingStyle.fill].擁i秀/// How wide to make edges drawn when [style] is set to /// [PaintingStyle.stroke]. The width is given in logical pixels measured in /// the direction orthogonal to the direction of the path. /// /// Defaults to 0.0, which correspond to a hairline width.菁FF/// The kind of finish to place on the end of lines drawn when /// [style] is set to [PaintingStyle.stroke]. /// /// Defaults to [StrokeCap.butt], i.e. no caps.:+/// The kind of finish to place on the joins between segments. /// /// This applies to paths drawn when [style] is set to [PaintingStyle.stroke], /// It does not apply to points drawn as lines with [Canvas.drawPoints]. /// /// Defaults to [StrokeJoin.miter], i.e. sharp corners. /// /// Some examples of joins: /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/miter_4_join.mp4} /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/round_join.mp4} /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/bevel_join.mp4} /// /// The centers of the line segments are colored in the diagrams above to /// highlight the joins, but in normal usage the join is the same color as the /// line. /// /// See also: /// /// * [strokeMiterLimit] to control when miters are replaced by bevels when /// this is set to [StrokeJoin.miter]. /// * [strokeCap] to control what is drawn at the ends of the stroke. /// * [StrokeJoin] for the definitive list of stroke joins.r$$/// The limit for miters to be drawn on segments when the join is set to /// [StrokeJoin.miter] and the [style] is set to [PaintingStyle.stroke]. If /// this limit is exceeded, then a [StrokeJoin.bevel] join will be drawn /// instead. This may cause some 'popping' of the corners of a path if the /// angle between line segments is animated, as seen in the diagrams below. /// /// This limit is expressed as a limit on the length of the miter. /// /// Defaults to 4.0. Using zero as a limit will cause a [StrokeJoin.bevel] /// join to be used all the time. /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/miter_0_join.mp4} /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/miter_4_join.mp4} /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/miter_6_join.mp4} /// /// The centers of the line segments are colored in the diagrams above to /// highlight the joins, but in normal usage the join is the same color as the /// line. /// /// See also: /// /// * [strokeJoin] to control the kind of finish to place on the joins /// between segments. /// * [strokeCap] to control what is drawn at the ends of the stroke. _loadImage(int width, int height) { /// final Completer completer = Completer(); /// decodeImageFromPixels( /// Uint8List.fromList(List.filled(width * height * 4, 0xFF)), /// width, /// height, /// PixelFormat.rgba8888, /// // Don't worry about disposing or cloning this image - responsibility /// // is transferred to the caller, and that is safe since this method /// // will not touch it again. /// (Image image) => completer.complete(image), /// ); /// return completer.future; /// } /// /// Future main() async { /// final Image image = await _loadImage(5, 5); /// // Make sure to clone the image, because MyHolder might dispose it /// // and we need to access it again. /// final MyImageHolder holder = MyImageHolder(image.clone()); /// final MyImageHolder holder2 = MyImageHolder(image.clone()); /// // Now we dispose it because we won't need it again. /// image.dispose(); /// /// final PictureRecorder recorder = PictureRecorder(); /// final Canvas canvas = Canvas(recorder); /// /// holder.draw(canvas); /// holder.dispose(); /// /// canvas.translate(50, 50); /// holder2.draw(canvas); /// holder2.dispose(); /// } /// /// class MyImageHolder { /// MyImageHolder(this.image); /// /// final Image image; /// /// void draw(Canvas canvas) { /// canvas.drawImage(image, Offset.zero, Paint()); /// } /// /// void dispose() => image.dispose(); /// } /// ``` /// /// The returned object behaves identically to this image. Calling /// [dispose] on it will only dispose the underlying native resources if it /// is the last remaining handle.I_KKɂR/// Returns true if `other` is a [clone] of this and thus shares the same /// underlying image memory, even if this or `other` is [dispose]d. /// /// This method may return false for two images that were decoded from the /// same underlying asset, if they are not sharing the same memory. For /// example, if the same file is decoded using [instantiateImageCodec] twice, /// or the same bytes are decoded using [decodeImageFromPixels] twice, there /// will be two distinct [Image]s that render the same but do not share /// underlying memory, and so will not be treated as clones of each other.K KKK3LLKKL5LZLZM_'M{MMMMM_M`MfMwMgPPPQSB%SSSSSeSfS^SdS_MfMMMMMMMMMMMMMMMMMMMMMMMhNUNUMMMNNMN NN NNNNN@N!NN#N:N4N<SlbSSSlSmSsSSzStSSSSSSSSSSSN`NrNrN~0NNNNNPPP9/// Returns an error message on failure, null on success.P PPP+PPPAPBPHPvPPPIPXPuPYP`PePaPhPoPwPP~PxPQ dQQRsS3S3k/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).RRRSRRRSRSSSSS!SS SS9SSSSL5L6L<LML=T_[[/// Information for a single frame of an animation. /// /// To obtain an instance of the [FrameInfo] interface, see /// [Codec.getNextFrame]. /// /// The recipient of an instance of this class is responsible for calling /// [Image.dispose] on [image]. To share the image with other interested /// parties, use [Image.clone]. If the [FrameInfo] object itself is passed to /// another method or object, that method or object must assume it is /// responsible for disposing the image when done, and the passer must not /// access the [image] after that point. /// /// For example, the following code sample is incorrect: /// /// ```dart /// /// BAD /// Future nextFrameRoutine(ui.Codec codec) async { /// final ui.FrameInfo frameInfo = await codec.getNextFrame(); /// _cacheImage(frameInfo); /// // ERROR - _cacheImage is now responsible for disposing the image, and /// // the image may not be available any more for this drawing routine. /// _drawImage(frameInfo); /// // ERROR again - the previous methods might or might not have created /// // handles to the image. /// frameInfo.image.dispose(); /// } /// ``` /// /// Correct usage is: /// /// ```dart /// /// GOOD /// Future nextFrameRoutine(ui.Codec codec) async { /// final ui.FrameInfo frameInfo = await codec.getNextFrame(); /// _cacheImage(frameInfo.image.clone(), frameInfo.duration); /// _drawImage(frameInfo.image.clone(), frameInfo.duration); /// // This method is done with its handle, and has passed handles to its /// // clients already. /// // The image will live until those clients dispose of their handles, and /// // this one must not be disposed since it will not be used again. /// frameInfo.image.dispose(); /// } /// ```[ρ\\\\\/// This class is created by the engine, and should not be instantiated /// or extended directly. /// /// To obtain an instance of the [FrameInfo] interface, see /// [Codec.getNextFrame].\\\\\\\Ԁ]e]e{/// The duration this frame should be shown. /// /// A zero duration indicates that the frame should be shown indefinitely.]r^G^G/// The [Image] object for this frame. /// /// This object must be disposed by the recipient of this frame info. /// /// To share this image with other interested parties, use [Image.clone].^Q>_?_?/// A handle to an image codec. /// /// This class is created by the engine, and should not be instantiated /// or extended directly. /// /// To obtain an instance of the [Codec] interface, see /// [instantiateImageCodec]._I9_w_w#/// Number of frames in this image._``/// Number of times to repeat the animation. /// /// * 0 when the animation should be played once. /// * -1 for infinity repetitions.`0aaa//// Fetches the next animation frame. /// /// Wraps back to the first frame after returning the last frame. /// /// The returned future can complete with an error if the decoding has failed. /// /// The caller of this method is responsible for disposing the /// [FrameInfo.image] on the returned object.abb/// Release the resources used by this object. The object is no longer usable /// after this method is called. /// /// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).bbbcccccccccdddcDccccdqddddd#dAd*d$d2d@d3d:d?d;dBdldIdCdKdfd`dhdSdddde{ereree ee-eeee,ee&e+e'e.e]e5e/e7eWeQeYe)eeeehiRiR9/// Returns an error message on failure, null on success.i`,iihhhihhiiiiiiiii=i&i i(ifiiiiiiiiiiiiiiiiiiiiiijjjiif /// A specification of the size to which an image should be decoded. /// /// See also: /// /// * [TargetImageSizeCallback], a callback that returns instances of this /// class when consulted by image decoding methods such as /// [instantiateImageCodecWithSize].ρnn}/// Creates a new instance of this class. /// /// The `width` and `height` may both be null, but if they're non-null, they /// must be positive.  ҁ/// The width into which to load the image. /// /// If this is non-null, the image will be decoded into the specified width. /// If this is null and [height] is also null, the image will be decoded into /// its intrinsic size. If this is null and [height] is non-null, the image /// will be decoded into a width that maintains its intrinsic aspect ratio /// while respecting the [height] value. /// /// If this value is non-null, it must be positive.܁/// The height into which to load the image. /// /// If this is non-null, the image will be decoded into the specified height. /// If this is null and [width] is also null, the image will be decoded into /// its intrinsic size. If this is null and [width] is non-null, the image /// will be decoded into a height that maintains its intrinsic aspect ratio /// while respecting the [width] value. /// /// If this value is non-null, it must be positive.EP/// A handle for the framework to hold and retain an engine layer across frames.&;;/// Release the resources used by this object. The object is no longer usable /// after this method is called. /// /// EngineLayers indirectly retain platform specific graphics resources. Some /// of these resources, such as images, may be memory intensive. It is /// important to dispose of EngineLayer objects that will no longer be used as /// soon as possible to avoid retaining these resources until the next /// garbage collection. /// /// Once this EngineLayer is disposed, it is no longer eligible for use as a /// retained layer, and must not be passed as an `oldLayer` to any of the /// [SceneBuilder] methods which accept that parameter. /// /// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).IITT} a/// This class is created by the engine, and should not be instantiated /// or extended directly.$l$%017T=8ESFMRNUt\V^\\/// A complex, one-dimensional subset of a plane. /// /// A path consists of a number of sub-paths, and a _current point_. /// /// Sub-paths consist of segments of various types, such as lines, /// arcs, or beziers. Sub-paths can be open or closed, and can /// self-intersect. /// /// Closed sub-paths enclose a (possibly discontiguous) region of the /// plane based on the current [fillType]. /// /// The _current point_ is initially at the origin. After each /// operation adding a segment to a sub-path, the current point is /// updated to the end of that segment. /// /// Paths can be drawn on canvases using [Canvas.drawPath], and can /// used to create clip regions using [Canvas.clipPath].i/// Creates a copy of another [Path]. /// /// This copy is fast and does not require additional memory unless either /// the `source` path or the path returned by this constructor are modified. /// Determines how the interior of this path is calculated. /// /// Defaults to the non-zero winding rule, [PathFillType.nonZero].*!..7EDOU2/// Starts a new sub-path at the given coordinate.rE/// Starts a new sub-path at the given offset from the current point.    twwO/// Adds a straight line segment from the current point to the given /// point.~t/// Adds a straight line segment from the current point to the point /// at the given offset from the current point.# +*. 65=q/// Adds a quadratic bezier segment that curves from the current /// point to the given point (x2,y2), using the control point /// (x1,y1). /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_quadratic_to.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_quadratic_to_dark.png#gh-dark-mode-only)    '/// Adds a quadratic bezier segment that curves from the current /// point to the point at the offset (x2,y2) from the current point, /// using the control point at the offset (x1,y1) from the current /// point.    &%-r/// Adds a cubic bezier segment that curves from the current point /// to the given point (x3,y3), using the control points (x1,y1) and /// (x2,y2). /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_cubic_to.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_cubic_to_dark.png#gh-dark-mode-only)      =/// Adds a cubic bezier segment that curves from the current point /// to the point at the offset (x3,y3) from the current point, using /// the control points at the offsets (x1,y1) and (x2,y2) from the /// current point.      #"& .-1 98@bdd/// Adds a bezier segment that curves from the current point to the /// given point (x2,y2), using the control points (x1,y1) and the /// weight w. If the weight is greater than 1, then the curve is a /// hyperbola; if the weight equals 1, it's a parabola; and if it is /// less than 1, it is an ellipse. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_conic_to.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_conic_to_dark.png#gh-dark-mode-only)l tsw ~  //w/// Adds a bezier segment that curves from the current point to the /// point at the offset (x2,y2) from the current point, using the /// control point at the offset (x1,y1) from the current point and /// the weight w. If the weight is greater than 1, then the curve is /// a hyperbola; if the weight equals 1, it's a parabola; and if it /// is less than 1, it is an ellipse.? GFJ RQU ]\` hgksryrââ/// If the `forceMoveTo` argument is false, adds a straight line /// segment and an arc segment. /// /// If the `forceMoveTo` argument is true, starts a new sub-path /// consisting of an arc segment. /// /// In either case, the arc segment consists of the arc that follows /// the edge of the oval bounded by the given rectangle, from /// startAngle radians around the oval up to startAngle + sweepAngle /// radians around the oval, with zero radians being the point on /// the right hand side of the oval that crosses the horizontal line /// that intersects the center of the rectangle and with positive /// angles going clockwise around the oval. /// /// The line segment added if `forceMoveTo` is false starts at the /// current point and ends at the start of the arc.è îíóûú&}}p/// Appends up to four conic curves weighted to describe an oval of `radius` /// and rotated by `rotation` (measured in degrees and clockwise). /// /// The first curve begins from the last point in the path and the last ends /// at `arcEnd`. The curves follow a path in a direction determined by /// `clockwise` and `largeArc` in such a way that the sweep angle /// is always less than 360 degrees. /// /// A simple line is appended if either radii are zero or the last /// point in the path is `arcEnd`. The radii are scaled to fit the last path /// point if both are greater than zero but too small to describe an arc. ///ƍ ƕƔƢƪƩƲƸƹ /// Appends up to four conic curves weighted to describe an oval of `radius` /// and rotated by `rotation` (measured in degrees and clockwise). /// /// The last path point is described by (px, py). /// /// The first curve begins from the last point in the path and the last ends /// at `arcEndDelta.dx + px` and `arcEndDelta.dy + py`. The curves follow a /// path in a direction determined by `clockwise` and `largeArc` /// in such a way that the sweep angle is always less than 360 degrees. /// /// A simple line is appended if either radii are zero, or, both /// `arcEndDelta.dx` and `arcEndDelta.dy` are zero. The radii are scaled to /// fit the last path point if both are greater than zero but too small to /// describe an arc./76IQPjrqʅʋʊʠʦʥY_`|ʕʱv##Y/// Adds a new sub-path that consists of four lines that outline the /// given rectangle.+ 10:.UU /// Adds a new sub-path that consists of a curve that forms the /// ellipse that fills the given rectangle. /// /// To add a circle, pass an appropriate rectangle as `oval`. [Rect.fromCircle] /// can be used to easily describe the circle's center [Offset] and radius.] cbl/// Adds a new sub-path with one arc segment that consists of the arc /// that follows the edge of the oval bounded by the given /// rectangle, from startAngle radians around the oval up to /// startAngle + sweepAngle radians around the oval, with zero /// radians being the point on the right hand side of the oval that /// crosses the horizontal line that intersects the center of the /// rectangle and with positive angles going clockwise around the /// oval. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_add_arc.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_add_arc_dark.png#gh-dark-mode-only) /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_add_arc_ccw.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_add_arc_ccw_dark.png#gh-dark-mode-only)# )(.65AIHXXфф/// Adds a new sub-path with a sequence of line segments that connect the given /// points. /// /// If `close` is true, a final line segment will be added that connects the /// last point to the first point. /// /// The `points` argument is interpreted as offsets from the origin.яѝќѤ ѪѩѴNN/// Adds a new sub-path that consists of the straight lines and /// curves needed to form the rounded rectangle described by the /// argument.W ^]hv/// Adds a new sub-path that consists of curves needed to form the rounded /// superellipse described by the argument.Q11/// Adds the sub-paths of `path`, offset by `offset`, to this path. /// /// If `matrix4` is specified, the path will be transformed by this matrix /// after the matrix is translated by the given offset. The matrix is a 4x4 /// matrix stored in column major order.9 ?>D LKTbao/// Adds the sub-paths of `path`, offset by `offset`, to this path. /// The current sub-path is extended with the first sub-path /// of `path`, connecting them with a lineTo if necessary. /// /// If `matrix4` is specified, the path will be transformed by this matrix /// after the matrix is translated by the given `offset`. The matrix is a 4x4 /// matrix stored in column major order.  '&/=<JՀ/// Closes the last sub-path, as if a straight line had been drawn /// from the current point to the first point of the sub-path.ေ׊׊/// Clears the [Path] object of all sub-paths, returning it to the /// same state it had when it was created. The _current point_ is /// reset to the origin.זqF/// Tests to see if the given point is within the path. (That is, whether the /// point would be in the visible portion of the path if the path was used /// with [Canvas.clipPath].) /// /// The `point` argument is interpreted as an offset from the origin. /// /// Returns true if the point is in the path, and false otherwise.  j/// Returns a copy of the path with all the segments of every /// sub-path translated by the given offset.م ٌٍ٘  k/// Returns a copy of the path with all the segments of every /// sub-path transformed by the given matrix.$#0ǃ0/// Computes the bounding rectangle for this path. /// /// A path containing only axis-aligned points on the same straight line will /// have no area, and therefore `Rect.isEmpty` will return true for such a /// path. Consider checking `rect.width + rect.height > 0.0` instead, or /// using the [computeMetrics] API to check the path length. /// /// For many more elaborate paths, the bounds may be inaccurate. For example, /// when a path contains a circle, the points used to compute the bounds are /// the circle's implied control points, which form a square around the circle; /// if the circle has a transformation applied using [transform] then that /// square is rotated, and the (axis-aligned, non-rotated) bounding box /// therefore ends up grossly overestimating the actual area covered by the /// circle.ׂ  0/// Combines the two paths according to the manner specified by the given /// `operation`. /// /// The resulting path will be constructed from non-overlapping contours. The /// curve order is reduced where possible so that cubics may be turned into /// quadratics, and quadratics maybe turned into lines.(76A GFM SR|M/// Creates a [PathMetrics] object for this path, which can describe various /// properties about the contours of the path. /// /// A [Path] is made up of zero or more contours. A contour is made up of /// connected curves and segments, created via methods like [lineTo], /// [cubicTo], [arcTo], [quadraticBezierTo], their relative counterparts, as /// well as the add* methods such as [addRect]. Creating a new [Path] starts /// a new contour once it has any drawing instructions, and another new /// contour is started for each [moveTo] instruction. /// /// A [PathMetric] object describes properties of an individual contour, /// such as its length, whether it is closed, what the tangent vector of a /// particular offset along the path is. It also provides a method for /// creating sub-paths: [PathMetric.extractPath]. /// /// Calculating [PathMetric] objects is not trivial. The [PathMetrics] object /// returned by this method is a lazy [Iterable], meaning it only performs /// calculations when the iterator is moved to the next [PathMetric]. Callers /// that wish to memoize this iterable can easily do so by using /// [Iterable.toList] on the result of this method. In particular, callers /// looking for information about how many contours are in the path should /// either store the result of `path.computeMetrics().length`, or should use /// `path.computeMetrics().toList()` so they can repeatedly check the length, /// since calling `Iterable.length` causes traversal of the entire iterable. /// /// In particular, callers should be aware that [PathMetrics.length] is the /// number of contours, **not the length of the path**. To get the length of /// a contour in a path, use [PathMetric.length]. /// /// If `forceClosed` is set to true, the contours of the path will be measured /// as if they had been closed, even if they were not explicitly closed.$*)7C,NNO%/// Create a new empty [Path] object.‣u遀/// Avoids creating a new native backing for the path for methods that will /// create it later, such as [Path.from], [shift] and [transform].QMnnQRJ3Vj88? ED&pPP ?93;c cdjpkxyꀓbbiqps{z* ) #+P2,4JDL쁀 %$( 0/778CDJwPKXvY`eahpxy΀[[j rqu }| I?9A$$6 >=A IHL TSW _^ f( 0/3 ;:> FEI QPfgrsyzX    $#' /.2 :9= EDXYdekqlyzL   ('+ 326 >=A IHLMXY_e`mnuzv}P     "*)PQ\]cidqry~z0    01<=CIDQRY^Zaiqy 117 =<BJIU]\hnm !4      &% \ [$ '/7?GOW]ick~:PKK[ cbpxw:;>//@HGT\[hpo|  Ё4<;OUTjpo#)*F_{yN"";CBOWVckjw~ yzˀ T    TU[a\ijqvry!22: @?!"44= EDJ RQV ^]d lk"w wx<      (0/?GF<=CIDQRY^ZaiqyZtkkv Z[Ҁ22>KJR XW  brss| bcu00:GF QbbsQRbbt".- ',(/P608S  aajwv|  65 $ '/7O>8@2?>D LKO WVZgf rg  rs݀[[kxw}     !I-'/ & & D Q P Z  b a i  q p x    o                         o n n      7   ( 6 ) 0 5 1 8 \ ? 9 A V P X zz      z {  f f p x w z      ,    +      % - T 4 . 6 N H P         B            B C I ~ O J W } X _ d ` g o w      ր                               &77&'g   !'i-(5h6=B>ELQMT[`\cj}qksuE(XXEFqD))/// The geometric description of a tangent: the angle at a point. /// /// See also: /// * [PathMetric.getTangentForOffset], which returns the tangent of an offset along a path.5V/// Creates a [Tangent] with the given values. /// /// The arguments must not be null.  R/// Creates a [Tangent] based on the angle rather than the vector. /// /// The [vector] is computed to be the unit vector at the given angle, interpreted /// as clockwise radians from the x axis. ߀/// Position of the tangent. /// /// When used with [PathMetric.getTangentForOffset], this represents the precise /// position that the given offset along the path corresponds to./// The vector of the curve at [position]. /// /// When used with [PathMetric.getTangentForOffset], this is the vector of the /// curve that is at the given offset along the path (i.e. the direction of the /// curve at [position]).+/// The direction of the curve at [position]. /// /// When used with [PathMetric.getTangentForOffset], this is the angle of the /// curve that is the given offset along the path (i.e. the direction of the /// curve at [position]). /// /// This value is in radians, with 0.0 meaning pointing along the x axis in /// the positive x-axis direction, positive numbers pointing downward toward /// the negative y-axis, i.e. in a clockwise direction, and negative numbers /// pointing upward toward the positive y-axis, i.e. in a counter-clockwise /// direction.#/// An iterable collection of [PathMetric] objects describing a [Path]. /// /// A [PathMetrics] object is created by using the [Path.computeMetrics] method, /// and represents the path as it stood at the time of the call. Subsequent /// modifications of the path do not affect the [PathMetrics] object. /// /// Each path metric corresponds to a segment, or contour, of a path. /// /// For example, a path consisting of a [Path.lineTo], a [Path.moveTo], and /// another [Path.lineTo] will contain two contours and thus be represented by /// two [PathMetric] objects. /// /// This iterable does not memoize. Callers who need to traverse the list /// multiple times, or who need to randomly access elements of the list, should /// use [toList] on this object.   )+=>?n@LmRMUbt$;܃KKh/// Used by [PathMetrics] to track iteration from one segment of a path to the /// next for measurement.(※q""/// Utilities for measuring a [Path] and extracting sub-paths. /// /// Iterate over the object returned by [Path.computeMetrics] to obtain /// [PathMetric] objects. Callers that want to randomly access elements or /// iterate multiple times should use `path.computeMetrics().toList()`, since /// [PathMetrics] does not memoize. /// /// Once created, the metrics are only valid for the path as it was specified /// when [Path.computeMetrics] was called. If additional contours are added or /// any contours are updated, the metrics need to be recomputed. Previously /// created metrics will still refer to a snapshot of the path at the time they /// were computed, rather than to the actual metrics for the new mutations to /// the path.""""""" """"""""""""#"## # ##0####F#9#H#P#Q#i+$$ /// Return the total length of the current contour. /// /// The length may be calculated from an approximation of the geometry /// originally added. For this reason, it is not recommended to rely on /// this property for mathematically correct lengths of common shapes.$A%%ҁ!/// Whether the contour is closed. /// /// Returns true if the contour ends with a call to [Path.close] (which may /// have been implied when using methods like [Path.addRect]) or if /// `forceClosed` was specified as true in the call to [Path.computeMetrics]. /// Returns false otherwise.%߂((/// The zero-based index of the contour. /// /// [Path] objects are made up of zero or more contours. The first contour is /// created once a drawing command (e.g. [Path.lineTo]) is issued. A /// [Path.moveTo] command after a drawing command may create a new contour, /// although it may not if optimizations are applied that determine the move /// command did not actually result in moving the pen. /// /// This property is only valid with reference to its original iterator and /// the contours of the path at the time the path's metrics were computed. If /// additional contours were added or existing contours updated, this metric /// will be invalid for the current state of the path.((((,**/// Computes the position of the current contour at the given offset, and the /// angle of the path at that point. /// /// For example, calling this method with a distance of 1.41 for a line from /// 0.0,0.0 to 2.0,2.0 would give a point 1.0,1.0 and the angle 45 degrees /// (but in radians). /// /// Returns null if the contour has zero [length]. /// /// The distance is clamped to the [length] of the current contour.***+++/// Given a start and end distance, return the intervening segment(s). /// /// `start` and `end` are clamped to legal values (0..[length]) /// Begin the segment with a moveTo if `startWithMoveTo` is true.+ ,,, ,,,,,,,,w,,,,-_---Q[-Q-Q-]-^-k-j-p-v-u78X8X/// The index of the current contour in the list of contours in the path. /// /// [nextContour] will increment this to the zero based index.8n8o -... .-.,.2.8.7---------------.---.H.O.O.V.[.Z/////////#/I/+/$/3/H/4/;/@/</C/J/y/Q/K/S/s/m/u/////////1112 2222$2#111111111111111111121l26262B2G2F2T 2\2[2b 2j2i2o2u2t234(4(4: 4@4?4L4Q4P4b 4j4i4t 4|4{44433333333333333333343334444445x555555x5y55555555555555555556667@}777@7A7G7d7M7H7U7c7V7]7b7^7e77l7f7n777;_<</// A mask filter to apply to shapes as they are painted. A mask filter is a /// function that takes a bitmap of color pixels, and returns another bitmap of /// color pixels. /// /// Instances of this class are used with [Paint.maskFilter] on [Paint] objects.= ?????悥/// Creates a mask filter that takes the shape being drawn and blurs it. /// /// This is commonly used to approximate shadows. /// /// The `style` argument controls the kind of effect to draw; see [BlurStyle]. /// /// The `sigma` argument controls the size of the effect. It is the standard /// deviation of the Gaussian blur to apply. The value must be greater than /// zero. The sigma corresponds to very roughly half the radius of the effect /// in pixels. /// /// A blur is an expensive operation and should therefore be used sparingly. /// /// The arguments must not be null. /// /// See also: /// /// * [Canvas.drawShadow], which is a more efficient way to draw shadows.? ??? ??@ @@@#@0@0@@@@@AAAA<AAAAA-AGAGAJ ARAQA-A.AZBBAABS_BbBbBv:B|B|B BBBBBBBBB BBCCOC&C&C0 C7C6C=CICHCCCgCmCmC"CCCC CCCCCC.CCC DDD DDCCEIEEEM:EdEdEy/// Row-major.Ez EEEEEEEEE EEEEEEEPЙKRR/// A description of a color filter to apply when drawing a shape or compositing /// a layer with a particular [Paint]. A color filter is a function that takes /// two colors, and outputs one color. When applied during compositing, it is /// independently applied to each pixel of the layer being drawn before the /// entire layer is merged with the destination. /// /// Instances of this class are used with [Paint.colorFilter] on [Paint] /// objects.R‚PT|TTTT/// Creates a color filter that applies the blend mode given as the second /// argument. The source color is the one given as the first argument, and the /// destination color is the one from the layer being composited. /// /// The output of this filter is then composited into the background according /// to the [Paint.blendMode], using the output of this filter as the source /// and the background as the destination.T TTTTT TTTTTTTTTUTUU=\\\\\և7/// Construct a color filter from a 4x5 row-major matrix. The matrix is /// interpreted as a 5x5 matrix, where the fifth row is the identity /// configuration. /// /// Every pixel's color value, represented as an `[R, G, B, A]`, is matrix /// multiplied to create a new color: /// /// | R' | | a00 a01 a02 a03 a04 | | R | /// | G' | | a10 a11 a12 a13 a14 | | G | /// | B' | = | a20 a21 a22 a23 a24 | * | B | /// | A' | | a30 a31 a32 a33 a34 | | A | /// | 1 | | 0 0 0 0 1 | | 1 | /// /// The matrix is in row-major order and the translation column is specified /// in unnormalized, 0...255, space. For example, the identity matrix is: /// /// ```dart /// const ColorFilter identity = ColorFilter.matrix([ /// 1, 0, 0, 0, 0, /// 0, 1, 0, 0, 0, /// 0, 0, 1, 0, 0, /// 0, 0, 0, 1, 0, /// ]); /// ``` /// /// ## Examples /// /// An inversion color matrix: /// /// ```dart /// const ColorFilter invert = ColorFilter.matrix([ /// -1, 0, 0, 0, 255, /// 0, -1, 0, 0, 255, /// 0, 0, -1, 0, 255, /// 0, 0, 0, 1, 0, /// ]); /// ``` /// /// A sepia-toned color matrix (values based on the [Filter Effects Spec](https://www.w3.org/TR/filter-effects-1/#sepiaEquivalent)): /// /// ```dart /// const ColorFilter sepia = ColorFilter.matrix([ /// 0.393, 0.769, 0.189, 0, 0, /// 0.349, 0.686, 0.168, 0, 0, /// 0.272, 0.534, 0.131, 0, 0, /// 0, 0, 0, 1, 0, /// ]); /// ``` /// /// A greyscale color filter (values based on the [Filter Effects Spec](https://www.w3.org/TR/filter-effects-1/#grayscaleEquivalent)): /// /// ```dart /// const ColorFilter greyscale = ColorFilter.matrix([ /// 0.2126, 0.7152, 0.0722, 0, 0, /// 0.2126, 0.7152, 0.0722, 0, 0, /// 0.2126, 0.7152, 0.0722, 0, 0, /// 0, 0, 0, 1, 0, /// ]); /// ```\\\ \\]]] ]].]&]0]D]>]F]W]]]]]W/// Construct a color filter that applies the sRGB gamma curve to the RGB /// channels. ]]]]]^^^ ^^)^#^+^G^^^^^d/// Creates a color filter that applies the inverse of the sRGB gamma curve /// to the RGB channels. ^^^^^^__ __&_ _(_D_Q_Q_[_l_l_z_________`!`#`#`2`V,`g`g``,```eteeeteuf'f>f>f'f(aVaaaaa[aiaid6:dPdPdS d[dZd6d7g-ggggjbkmkmD/// A [ColorFilter] that is backed by a native DlColorFilter. /// /// This is a private class, rather than being the implementation of the public /// ColorFilter, because we want ColorFilter to be const constructible and /// efficiently comparable, so that widgets can check for ColorFilter equality to /// avoid repainting.kkkkkkk kk kkkkkkkkkklOlOl[l\lbl\lc lilh lslylllzlllllllmmmmm mm m-m3mhmBm4m;m<mEmPmQmmmmmmm mm mmnmmmmmmmnPnno/// The original Dart object that created the native wrapper, which retains /// the values used for the filter.n]o0o0nnnnnnnnnooooo oCooo ooo oooCoDoJouoPoKoXotoYo`oeoaohooovoo}owoooooހp?p?pKpXpWooop ooop oopopp p-pp ppcpppcpdpjppppkpxppyppppppppppppqdqdpppqppqqqqqqqqRqqq qLqFqNqscsc/// A filter operation to apply to a raster image. /// /// See also: /// /// * [BackdropFilter], a widget that applies [ImageFilter] to its rendering. /// * [ImageFiltered], a widget that applies [ImageFilter] to its children. /// * [SceneBuilder.pushBackdropFilter], which is the low-level API for using /// this class as a backdrop filter. /// * [SceneBuilder.pushImageFilter], which is the low-level API for using /// this class as a child layer filter.ssssssst7tBtCtGtC9/// Creates an image filter that applies a Gaussian blur.tItQtPt^tftetst~t}tYtnt$uuuuu/// Creates an image filter that dilates each input pixel's channel values /// to the max value within the given radii along the x and y axes.uuuuuuuuv%vvvvv/// Create a filter that erodes each input pixel's channel values /// to the minimum channel value within the given radii along the x and y axes.vvvvvvvvw;!x%x0x1x7x1/// Creates an image filter that applies a matrix transformation. /// /// For example, applying a positive scale matrix (see [Matrix4.diagonal3]) /// when used with [BackdropFilter] would magnify the background image.x=xJxIxX2xgxfxvxxy`zcznzozvzo/// Composes the `inner` filter with `outer`, to combine their effects. /// /// Creates a single [ImageFilter] that when applied, has the same effect as /// subsequently applying `inner` and `outer`, i.e., /// result = outer(inner(source)).zxzzzzz{ /// Creates an image filter from a [FragmentShader]. /// /// The fragment shader provided here has additional requirements to be used /// by the engine for filtering. The first uniform value must be a vec2, this /// will be set by the engine to the size of the bound texture. There must /// also be at least one sampler2D uniform, the first of which will be set by /// the engine to contain the filter input. /// /// When Impeller uses the OpenGL(ES) backend, the y-axis direction is /// reversed. Custom fragment shaders must invert the y-axis on /// GLES or they will render upside-down. /// /// For example, the following is a valid fragment shader that can be used /// with this API. Note that the uniform names are not required to have any /// particular value. /// /// ```glsl /// #include /// /// uniform vec2 u_size; /// uniform float u_time; /// /// uniform sampler2D u_texture_input; /// /// out vec4 frag_color; /// /// void main() { /// vec2 uv = FlutterFragCoord().xy / u_size; /// // Reverse y axis for OpenGL backend. /// #ifdef IMPELLER_TARGET_OPENGLES /// uv.y = 1.0 - uv.y /// #endif /// frag_color = texture(u_texture_input, uv) * u_time; /// /// } /// /// ``` /// /// This API is only supported when using the Impeller rendering engine. On /// other backends a [UnsupportedError] will be thrown. To check at runtime /// whether this API is suppored use [isShaderFilterSupported]. rrE/// Whether [ImageFilter.shader] is supported on the current backend.@$MM ^>F>>PRa`fut!@#($qLqrQ))-@FF-.M,,/ 76jpp_++5EEf>~~=-SDD-.<@T܁ .44bCbbtv@ bIyybc>@77J "!LBLL]_nmv?JHaaJK>@I 3L33FHWVcrqB!jyjkEFYYEF&@??&'_Jddg onJKZ(   @//>JKQVR50\@uu\]Q.HHK SR.///06T<7DSEMUr\V^+  )/// An [ImageFilter] that is backed by a native DlImageFilter. /// /// This is a private class, rather than being the implementation of the public /// ImageFilter, because we want ImageFilter to be efficiently comparable, so that /// widgets can check for ImageFilter equality to avoid repainting.R9/// Creates an image filter that applies a Gaussian blur.<܀/// Creates an image filter that dilates each input pixel's channel values /// to the max value within the given radii along the x and y axes. _/// Create a filter that erodes each input pixel's channel values /// to the minimum channel value within the given radii along the x and y axes.,$.dpqwq/// Creates an image filter that applies a matrix transformation. /// /// For example, applying a positive scale matrix (see [Matrix4.diagonal3]) /// when used with [BackdropFilter] would magnify the background image.xe//// Converts a color filter to an image filter.bv0/// Composes `_innerFilter` with `_outerFilter`.܀!    o/// The original Dart object that created the native wrapper, which retains /// the values used for the filter.c]cdjpkxyĀMMW _^f nmu zy; 1+3  '/.;;<BoHCPnQX]Y`hp|v~퀜UUanmv{z   !C("* **+1l72?k@GLHOV[W^ejfmys{__k{z* ) #($+M2,4z/// Base class for objects such as [Gradient] and [ImageShader] which /// correspond to shaders as used by [Paint.shader].ʀLRSTSa/// This class is created by the engine, and should not be instantiated /// or extended directly.017H8[``q{y/// Whether [dispose] has been called. /// /// This must only be used when asserts are enabled. Otherwise, it will throw./// Release the resources used by this object. The object is no longer usable /// after this method is called. /// /// The underlying memory allocated by this object will be retained beyond /// this call if it is still needed by another object that has not been /// disposed. For example, a [Picture] that has not been disposed that /// refers to an [ImageShader] may keep its underlying resources alive. /// /// Classes that override this method must call `super.dispose()`.Ǥs@/// A shader (as used by [Paint.shader]) that renders a color gradient. /// /// There are several types of gradients, represented by the various constructors /// on this class. /// /// See also: /// /// * [Gradient](https://api.flutter.dev/flutter/painting/Gradient-class.html), the class in the [painting] library. /// MUV\V /// Creates a linear gradient from `from` to `to`. /// /// If `colorStops` is provided, `colorStops[i]` is a number from 0.0 to 1.0 /// that specifies where `color[i]` begins in the gradient. If `colorStops` is /// not provided, then only two stops, at 0.0 and 1.0, are implied (and /// `color` must therefore only have two entries). Stop values less than 0.0 /// will be rounded up to 0.0 and stop values greater than 1.0 will be rounded /// down to 1.0. Each stop value must be greater than or equal to the previous /// stop value. Stop values that do not meet this criteria will be rounded up /// to the previous stop value. /// /// The behavior before `from` and after `to` is described by the `tileMode` /// argument. For details, see the [TileMode] enum. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_clamp_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_decal_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_mirror_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_repeated_linear.png) /// /// If `from`, `to`, `colors`, or `tileMode` are null, or if `colors` or /// `colorStops` contain null values, this constructor will throw a /// [NoSuchMethodError]. /// /// If `matrix4` is provided, the gradient fill will be transformed by the /// specified 4x4 matrix relative to the local coordinate system. `matrix4` must /// be a column-major matrix packed into a list of 16 values.b jis {zςϏώϜϫϪϺ"!$*=+9<:GMy^VNYapxqЃЈЉЊЋ)QYZ`Z/// Creates a radial gradient centered at `center` that ends at `radius` /// distance from the center. /// /// If `colorStops` is provided, `colorStops[i]` is a number from 0.0 to 1.0 /// that specifies where `color[i]` begins in the gradient. If `colorStops` is /// not provided, then only two stops, at 0.0 and 1.0, are implied (and /// `color` must therefore only have two entries). Stop values less than 0.0 /// will be rounded up to 0.0 and stop values greater than 1.0 will be rounded /// down to 1.0. Each stop value must be greater than or equal to the previous /// stop value. Stop values that do not meet this criteria will be rounded up /// to the previous stop value. /// /// The behavior before and after the radius is described by the `tileMode` /// argument. For details, see the [TileMode] enum. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_clamp_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_decal_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_mirror_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_repeated_radial.png) /// /// If `center`, `radius`, `colors`, or `tileMode` are null, or if `colors` or /// `colorStops` contain null values, this constructor will throw a /// [NoSuchMethodError]. /// /// If `matrix4` is provided, the gradient fill will be transformed by the /// specified 4x4 matrix relative to the local coordinate system. `matrix4` must /// be a column-major matrix packed into a list of 16 values. /// /// If `focal` is provided and not equal to `center` and `focalRadius` is /// provided and not equal to 0.0, the generated shader will be a two point /// conical radial gradient, with `focal` being the center of the focal /// circle and `focalRadius` being the radius of that circle. If `focal` is /// provided and not equal to `center`, at least one of the two offsets must /// not be equal to [Offset.zero].f nmy ځڀڌڙژڦڵڴ" ! .:@WAOVPagۓxphs{ۊےۋ۝ۣۢۤۥߊQYZ_Z3/// Creates a sweep gradient centered at `center` that starts at `startAngle` /// and ends at `endAngle`. /// /// `startAngle` and `endAngle` should be provided in radians, with zero /// radians being the horizontal line to the right of the `center` and with /// positive angles going clockwise around the `center`. /// /// If `colorStops` is provided, `colorStops[i]` is a number from 0.0 to 1.0 /// that specifies where `color[i]` begins in the gradient. If `colorStops` is /// not provided, then only two stops, at 0.0 and 1.0, are implied (and /// `color` must therefore only have two entries). Stop values less than 0.0 /// will be rounded up to 0.0 and stop values greater than 1.0 will be rounded /// down to 1.0. Each stop value must be greater than or equal to the previous /// stop value. Stop values that do not meet this criteria will be rounded up /// to the previous stop value. /// /// The behavior before `startAngle` and after `endAngle` is described by the /// `tileMode` argument. For details, see the [TileMode] enum. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_clamp_sweep.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_decal_sweep.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_mirror_sweep.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_repeated_sweep.png) /// /// If `center`, `colors`, `tileMode`, `startAngle`, or `endAngle` are null, /// or if `colors` or `colorStops` contain null values, this constructor will /// throw a [NoSuchMethodError]. /// /// If `matrix4` is provided, the gradient fill will be transformed by the /// specified 4x4 matrix relative to the local coordinate system. `matrix4` must /// be a column-major matrix packed into a list of 16 values.e mlx"&%&  5;R<JQK\bxncpqZqrx~yρUUfsr  C'!)C||  A@ #+3:BjNHP-,, > FEQ YXdlk|    -.4?:GOV[Wdr`" '&4<;KSR`nm +&34;@<CKS[cjrz}bb=/// A shader (as used by [Paint.shader]) that tiles an image.EEP/// Creates an image-tiling shader. /// /// The first argument specifies the image to render. The /// [decodeImageFromList] function can be used to decode an image from bytes /// into the form expected here. (In production code, starting from /// [instantiateImageCodec] may be preferable.) /// /// The second and third arguments specify the [TileMode] for the x direction /// and y direction respectively. [TileMode.repeated] can be used for tiling /// images. /// /// The fourth argument gives the matrix to apply to the effect. The /// expression `Matrix4.identity().storage` creates a [Float64List] /// prepopulated with the identity matrix. /// /// All the arguments are required and must not be null, except for /// [filterQuality]. If [filterQuality] is not specified at construction time /// it will be deduced from the environment where it is used, such as from /// [Paint.filterQuality].V ]\g qpy )*0A1PEaaPQ]  L K!(-)07>EM{YS[ k/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).yzތ_ƀ/// An instance of [FragmentProgram] creates [Shader] objects (as used by /// [Paint.shader]). /// /// For more information, see the website /// [documentation]( https://docs.flutter.dev/development/ui/advanced/shaders).!&'1'2:9 ((WHI/G08N7ssNOUfV27+//// Creates a fragment program from the asset with key [assetKey]. /// /// The asset must be a file produced as the output of the `impellerc` /// compiler. The constructed object should then be reused via the /// [fragmentShader] method to create [Shader] objects that can be used by /// [Paint.shader].O[[owva&&'-T5.=S>EJFMU~\V^1/// Returns a fresh instance of [FragmentShader].? 0 0/// A [Shader] generated from a [FragmentProgram]. /// /// Instances of this class can be obtained from the /// [FragmentProgram.fragmentShader] method. The float uniforms list is /// initialized to the size expected by the shader and is zero-filled. Uniforms /// of float type can then be set by calling [setFloat]. Sampler uniforms are /// set by calling [setImageSampler]. /// /// A [FragmentShader] can be re-used, and this is an efficient way to avoid /// allocating and re-initializing the uniform buffer and samplers. However, /// if two [FragmentShader] objects with different float uniforms or samplers /// are required to exist simultaneously, they must be obtained from two /// different calls to [FragmentProgram.fragmentShader]. R R ` a b a c t s }            . . =< V V k v x w }(    /// Sets the float uniform at [index] to [value]. /// /// All uniforms defined in a fragment shader that are not samplers must be /// set through this method. This includes floats and vec2, vec3, and vec4. /// The correct index for each uniform is determined by the order of the /// uniforms as defined in the fragment program, ignoring any samplers. For /// data types that are composed of multiple floats such as a vec4, more than /// one call to [setFloat] is required. /// /// For example, given the following uniforms in a fragment program: /// /// ```glsl /// uniform float uScale; /// uniform sampler2D uTexture; /// uniform vec2 uMagnitude; /// uniform vec4 uColor; /// ``` /// /// Then the corresponding Dart code to correctly initialize these uniforms /// is: /// /// ```dart /// void updateShader(ui.FragmentShader shader, Color color, ui.Image image) { /// shader.setFloat(0, 23); // uScale /// shader.setFloat(1, 114); // uMagnitude x /// shader.setFloat(2, 83); // uMagnitude y /// /// // Convert color to premultiplied opacity. /// shader.setFloat(3, color.red / 255 * color.opacity); // uColor r /// shader.setFloat(4, color.green / 255 * color.opacity); // uColor g /// shader.setFloat(5, color.blue / 255 * color.opacity); // uColor b /// shader.setFloat(6, color.opacity); // uColor a /// /// // initialize sampler uniform. /// shader.setImageSampler(0, image); /// } /// ``` /// /// Note how the indexes used does not count the `sampler2D` uniform. This /// uniform will be set separately with [setImageSampler], with the index starting /// over at 0. /// /// Any float uniforms that are left uninitialized will default to `0`.  >9=CKJV^]iony /// Draws the given [Path] with the given [Paint]. /// /// Whether this shape is filled or stroked (or both) is controlled by /// [Paint.style]. If the path is filled, then sub-paths within it are /// implicitly closed (see [Path.close]).  WW/// Draws the given [Image] into the canvas with its top-left corner at the /// given [Offset]. The image is composited into the canvas using the given [Paint].a hgn vu} JJ/// Draws the subset of the given image described by the `src` argument into /// the canvas in the axis-aligned rectangle given by the `dst` argument. /// /// This might sample from outside the `src` rect by up to half the width of /// an applied filter. /// /// Multiple calls to this method with different arguments (from the same /// image) can be batched into a single call to [drawAtlas] to improve /// performance.X _^ekjouty Q/// Draws the given [Image] into the canvas using the given [Paint]. /// /// The image is drawn in nine portions described by splitting the image by /// drawing two horizontal lines and two vertical lines, where the `center` /// argument describes the rectangle formed by the four points where these /// four lines intersect each other. (This forms a 3-by-3 grid of regions, /// the center region being described by the `center` argument.) /// /// The four regions in the corners are drawn, without scaling, in the four /// corners of the destination rectangle described by `dst`. The remaining /// five regions are drawn by stretching them to fit such that they exactly /// cover the destination rectangle while maintaining their relative /// positions.   ߀DD[/// Draw the given picture onto the canvas. To create a picture, see /// [PictureRecorder].PYXeI||/// Draws the text in the given [Paragraph] into this canvas at the given /// [Offset]. /// /// The [Paragraph] object must have had [Paragraph.layout] called on it /// first. /// /// To align the text, set the `textAlign` on the [ParagraphStyle] object /// passed to the [ParagraphBuilder.new] constructor. For more details see /// [TextAlign] and the discussion at [ParagraphStyle.new]. /// /// If the text is left aligned or justified, the left margin will be at the /// position specified by the `offset` argument's [Offset.dx] coordinate. /// /// If the text is right aligned or justified, the right margin will be at the /// position described by adding the [ParagraphConstraints.width] given to /// [Paragraph.layout], to the `offset` argument's [Offset.dx] coordinate. /// /// If the text is centered, the centering axis will be at the position /// described by adding half of the [ParagraphConstraints.width] given to /// [Paragraph.layout], to the `offset` argument's [Offset.dx] coordinate. dd/// Draws a sequence of points according to the given [PointMode]. /// /// The `points` argument is interpreted as offsets from the origin. /// /// The `paint` is used for each point ([PointMode.points]) or line /// ([PointMode.lines] or [PointMode.polygon]), ignoring [Paint.style]. /// /// See also: /// /// * [drawRawPoints], which takes `points` as a [Float32List] rather than a /// [List].ozy O/// Draws a sequence of points according to the given [PointMode]. /// /// The `points` argument is interpreted as a list of pairs of floating point /// numbers, where each pair represents an x and y offset from the origin. /// /// The `paint` is used for each point ([PointMode.points]) or line /// ([PointMode.lines] or [PointMode.polygon]), ignoring [Paint.style]. /// /// See also: /// /// * [drawPoints], which takes `points` as a [List] rather than a /// [List]. ;/// Draws a set of [Vertices] onto the canvas as one or more triangles. /// /// The [Paint.color] property specifies the default color to use for the /// triangles. /// /// The [Paint.shader] property, if set, overrides the color entirely, /// replacing it with the colors from the specified [ImageShader], [Gradient], /// or other shader. /// /// The `blendMode` parameter is used to control how the colors in the /// `vertices` are combined with the colors in the `paint`. If there are no /// colors specified in `vertices` then the `blendMode` has no effect. If /// there are colors in the `vertices`, then the color taken from the /// [Paint.shader] or [Paint.color] in the `paint` is blended with the colors /// specified in the `vertices` using the `blendMode` parameter. For the /// purposes of this blending, the colors from the `paint` parameter are /// considered the source, and the colors from the `vertices` are considered /// the destination. [BlendMode.dst] ignores the `paint` and uses only the /// colors of the `vertices`; [BlendMode.src] ignores the colors of the /// `vertices` and uses only the colors in the `paint`. /// /// All parameters must not be null. /// /// See also: /// * [Vertices.new], which creates a set of vertices to draw on the canvas. /// * [Vertices.raw], which creates the vertices using typed data lists /// rather than unencoded lists. /// * [paint], Image shaders can be used to draw images on a triangular mesh.  ! + 21 allSprites; /// /// @override /// void paint(Canvas canvas, Size size) { /// Paint paint = Paint(); /// canvas.drawAtlas(spriteAtlas, [ /// for (final Sprite sprite in allSprites) /// RSTransform.fromComponents( /// rotation: 0.0, /// scale: 1.0, /// // Center of the sprite relative to its rect /// anchorX: 5.0, /// anchorY: 5.0, /// // Location at which to draw the center of the sprite /// translateX: sprite.center.dx, /// translateY: sprite.center.dy, /// ), /// ], [ /// for (final Sprite sprite in allSprites) /// Rect.fromLTWH(sprite.index * 10.0, 0.0, 10.0, 10.0), /// ], null, null, null, paint); /// } /// /// // ... /// } /// ``` /// /// Another example usage which renders sprites with an optional opacity and rotation: /// /// ```dart /// class Sprite { /// Sprite(this.index, this.center, this.alpha, this.rotation); /// int index; /// Offset center; /// int alpha; /// double rotation; /// } /// /// class MyPainter extends CustomPainter { /// MyPainter(this.spriteAtlas, this.allSprites); /// /// // assume spriteAtlas contains N 10x10 sprites side by side in a (N*10)x10 image /// ui.Image spriteAtlas; /// List allSprites; /// /// @override /// void paint(Canvas canvas, Size size) { /// Paint paint = Paint(); /// canvas.drawAtlas(spriteAtlas, [ /// for (final Sprite sprite in allSprites) /// RSTransform.fromComponents( /// rotation: sprite.rotation, /// scale: 1.0, /// // Center of the sprite relative to its rect /// anchorX: 5.0, /// anchorY: 5.0, /// // Location at which to draw the center of the sprite /// translateX: sprite.center.dx, /// translateY: sprite.center.dy, /// ), /// ], [ /// for (final Sprite sprite in allSprites) /// Rect.fromLTWH(sprite.index * 10.0, 0.0, 10.0, 10.0), /// ], [ /// for (final Sprite sprite in allSprites) /// Colors.white.withAlpha(sprite.alpha), /// ], BlendMode.srcIn, null, paint); /// } /// /// // ... /// } /// ``` /// /// The length of the [transforms] and [rects] lists must be equal and /// if the [colors] argument is not null then it must either be empty or /// have the same length as the other two lists. /// /// See also: /// /// * [drawRawAtlas], which takes its arguments as typed data lists rather /// than objects. *)4BAMYXgnm{ ΂΁ΐ蠘/// Draws many parts of an image - the [atlas] - onto the canvas. /// /// This method allows for optimization when you want to draw many parts of an /// image onto the canvas, such as when using sprites or zooming. It is more efficient /// than using multiple calls to [drawImageRect] and provides more functionality /// to individually transform each image part by a separate rotation or scale and /// blend or modulate those parts with a solid color. It is also more efficient /// than [drawAtlas] as the data in the arguments is already packed in a format /// that can be directly used by the rendering code. /// /// A full description of how this method uses its arguments to draw onto the /// canvas can be found in the description of the [drawAtlas] method. /// /// The [rstTransforms] argument is interpreted as a list of four-tuples, with /// each tuple being ([RSTransform.scos], [RSTransform.ssin], /// [RSTransform.tx], [RSTransform.ty]). /// /// The [rects] argument is interpreted as a list of four-tuples, with each /// tuple being ([Rect.left], [Rect.top], [Rect.right], [Rect.bottom]). /// /// The [colors] argument, which can be null, is interpreted as a list of /// 32-bit colors, with the same packing as [Color.value]. If the [colors] /// argument is not null then the [blendMode] argument must also not be null. /// /// An example usage to render many sprites from a single sprite atlas with no rotations /// or scales: /// /// ```dart /// class Sprite { /// Sprite(this.index, this.center); /// int index; /// Offset center; /// } /// /// class MyPainter extends CustomPainter { /// MyPainter(this.spriteAtlas, this.allSprites); /// /// // assume spriteAtlas contains N 10x10 sprites side by side in a (N*10)x10 image /// ui.Image spriteAtlas; /// List allSprites; /// /// @override /// void paint(Canvas canvas, Size size) { /// // For best advantage, these lists should be cached and only specific /// // entries updated when the sprite information changes. This code is /// // illustrative of how to set up the data and not a recommendation for /// // optimal usage. /// Float32List rectList = Float32List(allSprites.length * 4); /// Float32List transformList = Float32List(allSprites.length * 4); /// for (int i = 0; i < allSprites.length; i++) { /// Sprite sprite = allSprites[i]; /// final double rectX = sprite.index * 10.0; /// rectList[i * 4 + 0] = rectX; /// rectList[i * 4 + 1] = 0.0; /// rectList[i * 4 + 2] = rectX + 10.0; /// rectList[i * 4 + 3] = 10.0; /// /// // This example sets the RSTransform values directly for a common case of no /// // rotations or scales and just a translation to position the atlas entry. For /// // more complicated transforms one could use the RSTransform class to compute /// // the necessary values or do the same math directly. /// transformList[i * 4 + 0] = 1.0; /// transformList[i * 4 + 1] = 0.0; /// transformList[i * 4 + 2] = sprite.center.dx - 5.0; /// transformList[i * 4 + 3] = sprite.center.dy - 5.0; /// } /// Paint paint = Paint(); /// canvas.drawRawAtlas(spriteAtlas, transformList, rectList, null, null, null, paint); /// } /// /// // ... /// } /// ``` /// /// Another example usage which renders sprites with an optional opacity and rotation: /// /// ```dart /// class Sprite { /// Sprite(this.index, this.center, this.alpha, this.rotation); /// int index; /// Offset center; /// int alpha; /// double rotation; /// } /// /// class MyPainter extends CustomPainter { /// MyPainter(this.spriteAtlas, this.allSprites); /// /// // assume spriteAtlas contains N 10x10 sprites side by side in a (N*10)x10 image /// ui.Image spriteAtlas; /// List allSprites; /// /// @override /// void paint(Canvas canvas, Size size) { /// // For best advantage, these lists should be cached and only specific /// // entries updated when the sprite information changes. This code is /// // illustrative of how to set up the data and not a recommendation for /// // optimal usage. /// Float32List rectList = Float32List(allSprites.length * 4); /// Float32List transformList = Float32List(allSprites.length * 4); /// Int32List colorList = Int32List(allSprites.length); /// for (int i = 0; i < allSprites.length; i++) { /// Sprite sprite = allSprites[i]; /// final double rectX = sprite.index * 10.0; /// rectList[i * 4 + 0] = rectX; /// rectList[i * 4 + 1] = 0.0; /// rectList[i * 4 + 2] = rectX + 10.0; /// rectList[i * 4 + 3] = 10.0; /// /// // This example uses an RSTransform object to compute the necessary values for /// // the transform using a factory helper method because the sprites contain /// // rotation values which are not trivial to work with. But if the math for the /// // values falls out from other calculations on the sprites then the values could /// // possibly be generated directly from the sprite update code. /// final RSTransform transform = RSTransform.fromComponents( /// rotation: sprite.rotation, /// scale: 1.0, /// // Center of the sprite relative to its rect /// anchorX: 5.0, /// anchorY: 5.0, /// // Location at which to draw the center of the sprite /// translateX: sprite.center.dx, /// translateY: sprite.center.dy, /// ); /// transformList[i * 4 + 0] = transform.scos; /// transformList[i * 4 + 1] = transform.ssin; /// transformList[i * 4 + 2] = transform.tx; /// transformList[i * 4 + 3] = transform.ty; /// /// // This example computes the color value directly, but one could also compute /// // an actual Color object and use its Color.value getter for the same result. /// // Since we are using BlendMode.srcIn, only the alpha component matters for /// // these colors which makes this a simple shift operation. /// colorList[i] = sprite.alpha << 24; /// } /// Paint paint = Paint(); /// canvas.drawRawAtlas(spriteAtlas, transformList, rectList, colorList, BlendMode.srcIn, null, paint); /// } /// /// // ... /// } /// ``` /// /// See also: /// /// * [drawAtlas], which takes its arguments as objects rather than typed /// data lists. *10> EDS8<FNV^fnzt|8u89DEKhQLYgZafbipjr󱀓**9 >= HHITU[yb\jxkrwsz{ˀHHR ZY] ed   6 0*2lH}}  lm%%, 437 ?> FFGRSY~_Zg}hotpwӀKKP XW[ cb 93-5j{{jk {{{ !'L-(5K6=B>EMiTNV0017\=8E[FMRNU]|d^f  ))8 @?I QPY a`k sr~   HHIOzUP]y^ejfmu{|݀$#1!!4"JIX^]nv no耕OOYfekqp!   "=)#+FFGMrSN[q\chdkszt|ր+87CpTT^ edkvuCD''2 76= BA Paaj rqu }| PQ    %r+&3q4;@<CKS[cksy1ZBBL SR12  $#2CCL RQW ^]23G           ' 7 6 H R QGHNTO\]dielt| d u u        d e  q q |            B    A  # ( $ + 3 ; C _ J D L Ā               ) ) : G F Q ^ ] h x w                                    {  ",+>NM_ih { |                     {  {|* 21; CBK SR] edp   Y .-?IHYZ`fanov{w~[Ellt zy [\      ,+=GFYU!/;IZta[cYxjjs yx~ YZՀFFP]\brq 4 "   D*  )(:DCRWVDEKSL[\chdkrwszr2  rs>    )10?GFS [Zfnm{  .<JXftD  #)(- 43 2J!Q!Q !e !m!l!w!!~!!!!!!!!!!!!! !!!""""""'"7"6"H"R"Q"`"e"d  2 3 9! F ? N! V ] b ^ k r w s          ! !!<!#!!%""""""""##l#l#y#### ##;####:##%#*#&#-#4#9#5#<#Z#C#=#E#G###### ####$$$$%%%%%%& %-%,$$%%%%%%%%%% %%%%&' ' '1'A'@'R'\'['j 'o'n'}''&&&&&&&&&&&&&&&&&'&&&'''''''''' ''''(e((())) )))')7)6)H)R)Q(e(f(l((r(m(z(({((((((((((((((()d!)u)u) ))))))))))))))**** **)d)e1111 111111111112 222$2+2*28 2?2>1167 7 77)7(7:7D7C7R7W7V7n 7v7u7777777777 77777666 66-6&6566=6D6I6E6R6`6n6{66666666666667888 8!8 8& 8-8,838;8:8E8K8J7889=9=9N9[9Z9d 9i9h9s9{9z999888988898888888888899+99 99K9999:h;;ƁN/// An object representing a sequence of recorded graphical operations. /// /// To create a [Picture], use a [PictureRecorder]. /// /// A [Picture] can be placed in a [Scene] using a [SceneBuilder], via /// the [SceneBuilder.addPicture] method. A [Picture] can also be /// drawn into a [Canvas], using the [Canvas.drawPicture] method.;ҁ<>/// A callback that is invoked to report the picture disposal. /// /// It's preferred to use [MemoryAllocations] in flutter/foundation.dart /// than to use [onDispose] directly because [MemoryAllocations] /// allows multiple callbacks.CdDD/// Whether this reference to the underlying picture is [dispose]d. /// /// This only returns a valid value if asserts are enabled, and must not be /// used otherwise.D/E E /// Returns the approximate number of bytes allocated for this object. /// /// The actual size of this picture may be larger, particularly if it contains /// references to image or other large objects.>D?5?5 /// Creates an image from this picture. /// /// The returned image will be `width` pixels wide and `height` pixels high. /// The picture is rasterized within the 0 (left), 0 (top), `width` (right), /// `height` (bottom) bounds. Content outside these bounds is clipped.?= ?B?A?H ?M?L?XBB6/// Synchronously creates a handle to an image of this picture. /// /// {@template dart.ui.painting.Picture.toImageSync} /// The returned image will be `width` pixels wide and `height` pixels high. /// The picture is rasterized within the 0 (left), 0 (top), `width` (right), /// `height` (bottom) bounds. Content outside these bounds is clipped. /// /// The image object is created and returned synchronously, but is rasterized /// asynchronously. If the rasterization fails, an exception will be thrown /// when the image is drawn to a [Canvas]. /// /// If a GPU context is available, this image will be created as GPU resident /// and not copied back to the host. This means the image will be more /// efficient to draw. /// /// If no GPU context is available, the image will be rasterized on the CPU. /// {@endtemplate}B BBB BBBހCVCVn/// Release the resources used by this object. The object is no longer usable /// after this method is called.E"E-E-EtFF$F%F&F%/// This class is created by the engine, and should not be instantiated /// or extended directly. /// /// To create a [Picture], use a [PictureRecorder].LL L LL"L7L7L"L#M#MMM#M$M/M0M6MUM>M7MFMTMGMNMSMOMVMM]MWM_MM}MF-FGFGFO FTFSFZ F_F^F-F.GH]H]Hf HkHjHq HvHuH}HHGGGH,GGHH+HH HHHHH%H-HHH4H.H6H5HHH HHH HHHHIۀJIJIJV J[JZJa JfJeJmJuJtIIIJIIIJIIIIJJJJJ7JJJ!JJJJJK6KKk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).KKKKKKKKKKKKKKKKKM+MMMMMUQQ/// Records a [Picture] containing a sequence of graphical operations. /// /// To begin recording, construct a [Canvas] to record the commands. /// To end recording, use the [PictureRecorder.endRecording] method. /// /// ## Use with the Flutter framework /// /// The Flutter framework's [RendererBinding] provides a hook for creating /// [PictureRecorder] objects ([RendererBinding.createPictureRecorder]) that /// allows tests to hook into the scene creation logic. When creating a /// [PictureRecorder] and [Canvas] that will be used with a [PictureLayer] as /// part of the [Scene] in the context of the Flutter framework, consider /// calling [RendererBinding.createPictureRecorder] instead of calling the /// [PictureRecorder.new] constructor directly. /// /// This does not apply when using a canvas to generate a bitmap for other /// purposes, e.g. for generating a PNG image using [Picture.toImage].QRARARP/// Creates a new idle PictureRecorder. To associate it with a /// [Canvas] and begin recording, pass this [PictureRecorder] to the /// [Canvas] constructor.RpSSu/// Whether this object is currently recording commands. /// /// Specifically, this returns true if a [Canvas] object has been /// created to record commands and recording has not yet ended via a /// call to [endRecording], and false if either this /// [PictureRecorder] has not yet been associated with a [Canvas], /// or the [endRecording] method has already been called.T ,U*U* /// Finishes recording graphical operations. /// /// Returns a picture containing the graphical operations that have been /// recorded thus far. After calling this function, both the picture recorder /// and the canvas objects are invalid and cannot be used further.U=UHUHU2UUUXXXV:4VOVOV:V;UaV'V'UUUUUUUUUUVUUUVrVVVrVsX\XXXXXX\X]XcXXiXdXqXXrXyX~XzXXXXXXY LYYY Y Y[YYT/// A single shadow. /// /// Multiple shadows are stacked together in a [TextStyle].YP[L[L[Rp/// Construct a shadow. /// /// The default shadow is a black shadow with zero offset and zero blur. /// Default shadows should be completely covered by the casting element, /// and not be visible. /// /// Transparency should be adjusted through the [color] alpha. /// /// Shadow order matters due to compositing multiple translucent objects not /// being commutative.[Y([_[^[[[[[[[f[l[q[[r[[[[[[[\[[[[ \,\&\&\7\i&\z\z\\'\\\\\\#\\\\\\#\\]]]] &]]].],]1]7]]/// Color that the shadow will be drawn with. /// /// The shadows are shapes composited directly over the base canvas, and do not /// represent optical occlusion.]4_&_&/// The displacement of the shadow from the casting element. /// /// Positive x/y offsets will shift the shadow to the right and down, while /// negative offsets shift the shadow to the left and up. The offsets are /// relative to the position of the element that is casting it._1i__O/// The standard deviation of the Gaussian to convolve with the shadow's shape.aaan/// The [blurRadius] in sigmas instead of logical pixels. /// /// See the sigma argument to [MaskFilter.blur].oGo1o1oo_|``h/// Converts a blur radius in pixels to sigmas. /// /// See the sigma argument to [MaskFilter.blur]. ///` ``aтcc/// Create the [Paint] object that corresponds to this shadow description. /// /// The [offset] is not represented in the [Paint] object. /// To honor this as well, the shape should be translated by [offset] before /// being filled using this [Paint]. /// /// This class does not provide a way to disable shadows to avoid /// inconsistencies in shadow blur rendering, primarily as a method of /// reducing test flakiness. [toPaint] should be overridden in subclasses to /// provide this functionality.d`dd[/// Returns a new shadow with its [offset] and [blurRadius] scaled by the given /// factor.d dde@iJiJ/// Linearly interpolate between two shadows. /// /// If either shadow is null, this function linearly interpolates from /// a shadow that matches the other shadow in color but has a zero /// offset and a zero blurRadius. /// /// {@template dart.ui.shadow.lerp} /// The `t` argument represents position on the timeline, with 0.0 meaning /// that the interpolation has not started, returning `a` (or something /// equivalent to `a`), 1.0 meaning that the interpolation has finished, /// returning `b` (or something equivalent to `b`), and values in between /// meaning that the interpolation is at the relevant point on the timeline /// between `a` and `b`. The interpolation can be extrapolated beyond 0.0 and /// 1.0, so negative values and values greater than 1.0 are valid (and can /// easily be generated by curves such as [Curves.elasticInOut]). /// /// Values for `t` are usually obtained from an [Animation], such as /// an [AnimationController]. /// {@endtemplate}iO iXiWiZ icibieimilkkk/// Linearly interpolate between two lists of shadows. /// /// If the lists differ in length, excess items are lerped with null. /// /// {@macro dart.ui.shadow.lerp}kkkkl ll lln&n@n@nC nKnJn&n'p"p2p2pApPpOsLt t sstJuu/// A handle to a read-only byte buffer that is managed by the engine. /// /// The creator of this object is responsible for calling [dispose] when it is /// no longer needed.u: u:uIuJuKuJuL uRuQ~M ~Q~Q~]~b~b~s}N~8~81/// The length, in bytes, of the underlying data.~}y/// Whether [dispose] has been called. /// /// This must only be used when asserts are enabled. Otherwise, it will throw.u^guu^/// Creates a copy of the data from a [Uint8List] suitable for internal use /// in the engine.uuuvɃGwawar/// Create a buffer from the asset with key [assetKey]. /// /// Throws an [Exception] if the asset does not exist.wkwswrzzzi/// Create a buffer from the file with [path]. /// /// Throws an [Exception] if the asset does not exist.z zz||t|t|z|||||||||>|||&|=|'|/|7|?|_|F|@|H|}}}%}-},}6}F}E||||||||||||}|||}S}}}}}}}}}S}T}Z}}b}[}j}}k}s}{}}}}}/// Release the resources used by this object. The object is no longer usable /// after this method is called. /// /// The underlying memory allocated by this object will be retained beyond /// this call if it is still needed by another object that has not been /// disposed. For example, an [ImageDescriptor] that has not been disposed /// may still retain a reference to the memory from this buffer even if it /// has been disposed. Freeing that memory requires disposing all resources /// that may still hold it.?  k/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).݀/// A descriptor of data that can be turned into an [Image] via a [Codec]. /// /// Use this class to determine the height, width, and byte size of image data /// before decoding it.(),)/// Creates an image descriptor from raw image pixels. /// /// The `pixels` parameter is the pixel data. They are packed in bytes in the /// order described by `pixelFormat`, then grouped in rows, from left to right, /// then top to bottom. /// /// The `rowBytes` parameter is the number of bytes consumed by each row of /// pixels in the data buffer. If unspecified, it defaults to `width` multiplied /// by the number of bytes per pixel in the provided `format`.2CBP^]hvu  Cyd/// The width, in pixels, of the image. /// /// On the Web, this is only supported for [raw] images.{44e/// The height, in pixels, of the image. /// /// On the Web, this is only supported for [raw] images.?h/// The number of bytes per pixel in the image. /// /// On web, this is only supported for [raw] images.܁cFFH/// Creates an image descriptor from encoded data in a supported format.N_^Ȁ/// Release the resources used by this object. The object is no longer usable /// after this method is called. /// /// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).āgg/// Creates a [Codec] object which is suitable for decoding the data in the /// buffer to an [Image]. /// /// If only one of targetWidth or targetHeight are specified, the other /// dimension will be scaled according to the aspect ratio of the supplied /// dimension. /// /// If either targetWidth or targetHeight is less than or equal to zero, it /// will be treated as if it is null.y~q$DZ[^[/// Creates an image descriptor from raw image pixels. /// /// The `pixels` parameter is the pixel data. They are packed in bytes in the /// order described by `pixelFormat`, then grouped in rows, from left to right, /// then top to bottom. /// /// The `rowBytes` parameter is the number of bytes consumed by each row of /// pixels in the data buffer. If unspecified, it defaults to `width` multiplied /// by the number of bytes per pixel in the provided `format`.dut   ] bb!&&%499%&7L ˀ>>K\[cts)  '&9JIU ZYd iht yxrntnou|v99:@^GAO]PW\X_f`hpuu"?(#0>18=9@cGAI(11CJISXWdihzz{u/// An exception thrown by [Canvas.drawImage] and related methods when drawing /// an [Image] created via [Picture.toImageSync] that is in an invalid state. /// /// This exception may be thrown if the requested image dimensions exceeded the /// maximum 2D texture size allowed by the GPU, or if no GPU surface or context /// was available for rasterization at request time.B  IBB2/// A string containing details about the failure.NiO/// If available, the stack trace at the time [Picture.toImageSync] was called.BL<OWWWW/// Algorithms to use when painting on the canvas. /// /// When drawing a shape or image onto a canvas, different algorithms can be /// used to blend the pixels. The different values of [BlendMode] specify /// different such algorithms. /// /// Each algorithm has two inputs, the _source_, which is the image being drawn, /// and the _destination_, which is the image into which the source image is /// being composited. The destination is often thought of as the _background_. /// The source and destination both have four color channels, the red, green, /// blue, and alpha channels. These are typically represented as numbers in the /// range 0.0 to 1.0. The output of the algorithm also has these same four /// channels, with values computed from the source and destination. /// /// The documentation of each value below describes how the algorithm works. In /// each case, an image shows the output of blending a source image with a /// destination image. In the images below, the destination is represented by an /// image with horizontal lines and an opaque landscape photograph, and the /// source is represented by an image with vertical lines (the same lines but /// rotated) and a bird clip-art image. The [src] mode shows only the source /// image, and the [dst] mode shows only the destination image. In the /// documentation below, the transparency is illustrated by a checkerboard /// pattern. The [clear] mode drops both the source and destination, resulting /// in an output that is entirely transparent (illustrated by a solid /// checkerboard pattern). /// /// The horizontal and vertical bars in these images show the red, green, and /// blue channels with varying opacity levels, then all three color channels /// together with those same varying opacity levels, then all three color /// channels set to zero with those varying opacity levels, then two bars showing /// a red/green/blue repeating gradient, the first with full opacity and the /// second with partial opacity, and finally a bar with the three color channels /// set to zero but the opacity varying in a repeating gradient. /// /// ## Application to the [Canvas] API /// /// When using [Canvas.saveLayer] and [Canvas.restore], the blend mode of the /// [Paint] given to the [Canvas.saveLayer] will be applied when /// [Canvas.restore] is called. Each call to [Canvas.saveLayer] introduces a new /// layer onto which shapes and images are painted; when [Canvas.restore] is /// called, that layer is then composited onto the parent layer, with the source /// being the most-recently-drawn shapes and images, and the destination being /// the parent layer. (For the first [Canvas.saveLayer] call, the parent layer /// is the canvas itself.) /// /// See also: /// /// * [Paint.blendMode], which uses [BlendMode] to define the compositing /// strategy.XXX/// Drop both the source and destination images, leaving nothing. /// /// This corresponds to the "clear" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_clear.png)YHZFZF4/// Drop the destination image, only paint the source image. /// /// Conceptually, the destination is first cleared, then the source image is /// painted. /// /// This corresponds to the "Copy" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_src.png)ZNM[[9/// Drop the source image, only paint the destination image. /// /// Conceptually, the source image is discarded, leaving the destination /// untouched. /// /// This corresponds to the "Destination" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_dst.png)[]]/// Composite the source image over the destination image. /// /// This is the default value. It represents the most intuitive case, where /// shapes are painted on top of what is below, with transparent areas showing /// the destination layer. /// /// This corresponds to the "Source over Destination" Porter-Duff operator, /// also known as the Painter's Algorithm. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_srcOver.png)]_7_7/// Composite the source image under the destination image. /// /// This is the opposite of [srcOver]. /// /// This corresponds to the "Destination over Source" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_dstOver.png) /// /// This is useful when the source image should have been painted before the /// destination image, but could not be._Caa؂x/// Show the source image, but only where the two images overlap. The /// destination image is not rendered, it is treated merely as a mask. The /// color channels of the destination are ignored, only the opacity has an /// effect. /// /// To show the destination image instead, consider [dstIn]. /// /// To reverse the semantic of the mask (only showing the source where the /// destination is absent, rather than where it is present), consider /// [srcOut]. /// /// This corresponds to the "Source in Destination" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_srcIn.png)a₄dadaf/// Show the destination image, but only where the two images overlap. The /// source image is not rendered, it is treated merely as a mask. The color /// channels of the source are ignored, only the opacity has an effect. /// /// To show the source image instead, consider [srcIn]. /// /// To reverse the semantic of the mask (only showing the source where the /// destination is present, rather than where it is absent), consider [dstOut]. /// /// This corresponds to the "Destination in Source" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_dstIn.png)dkffy/// Show the source image, but only where the two images do not overlap. The /// destination image is not rendered, it is treated merely as a mask. The color /// channels of the destination are ignored, only the opacity has an effect. /// /// To show the destination image instead, consider [dstOut]. /// /// To reverse the semantic of the mask (only showing the source where the /// destination is present, rather than where it is absent), consider [srcIn]. /// /// This corresponds to the "Source out Destination" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_srcOut.png)giio/// Show the destination image, but only where the two images do not overlap. The /// source image is not rendered, it is treated merely as a mask. The color /// channels of the source are ignored, only the opacity has an effect. /// /// To show the source image instead, consider [srcOut]. /// /// To reverse the semantic of the mask (only showing the destination where the /// source is present, rather than where it is absent), consider [dstIn]. /// /// This corresponds to the "Destination out Source" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_dstOut.png)igkkE/// Composite the source image over the destination image, but only where it /// overlaps the destination. /// /// This corresponds to the "Source atop Destination" Porter-Duff operator. /// /// This is essentially the [srcOver] operator, but with the output's opacity /// channel being set to that of the destination image instead of being a /// combination of both image's opacity channels. /// /// For a variant with the destination on top instead of the source, see /// [dstATop]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_srcATop.png)l]n]n];/// Composite the destination image over the source image, but only where it /// overlaps the source. /// /// This corresponds to the "Destination atop Source" Porter-Duff operator. /// /// This is essentially the [dstOver] operator, but with the output's opacity /// channel being set to that of the source image instead of being a /// combination of both image's opacity channels. /// /// For a variant with the source on top instead of the destination, see /// [srcATop]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_dstATop.png)ni;oo+/// Apply a bitwise `xor` operator to the source and destination images. This /// leaves transparency where they would overlap. /// /// This corresponds to the "Source xor Destination" Porter-Duff operator. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_xor.png)oOrr,/// Sum the components of the source and destination images. /// /// Transparency in a pixel of one of the images reduces the contribution of /// that image to the corresponding output pixel, as if the color of that /// pixel in that image was darker. /// /// This corresponds to the "Source plus Destination" Porter-Duff operator. /// /// This is the right blend mode for cross-fading between two images. Consider /// two images A and B, and an interpolation time variable _t_ (from 0.0 to /// 1.0). To cross fade between them, A should be drawn with opacity 1.0 - _t_ /// into a new layer using [BlendMode.srcOver], and B should be drawn on top /// of it, at opacity _t_, into the same layer, using [BlendMode.plus]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_plus.png)rVvKvK'/// Multiply the color components of the source and destination images. /// /// This can only result in the same or darker colors (multiplying by white, /// 1.0, results in no change; multiplying by black, 0.0, results in black). /// /// When compositing two opaque images, this has similar effect to overlapping /// two transparencies on a projector. /// /// For a variant that also multiplies the alpha channel, consider [multiply]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_modulate.png) /// /// See also: /// /// * [screen], which does a similar computation but inverted. /// * [overlay], which combines [modulate] and [screen] to favor the /// destination image. /// * [hardLight], which combines [modulate] and [screen] to favor the /// source image.v!{{/// Multiply the inverse of the components of the source and destination /// images, and inverse the result. /// /// Inverting the components means that a fully saturated channel (opaque /// white) is treated as the value 0.0, and values normally treated as 0.0 /// (black, transparent) are treated as 1.0. /// /// This is essentially the same as [modulate] blend mode, but with the values /// of the colors inverted before the multiplication and the result being /// inverted back before rendering. /// /// This can only result in the same or lighter colors (multiplying by black, /// 1.0, results in no change; multiplying by white, 0.0, results in white). /// Similarly, in the alpha channel, it can only result in more opaque colors. /// /// This has similar effect to two projectors displaying their images on the /// same screen simultaneously. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_screen.png) /// /// See also: /// /// * [modulate], which does a similar computation but without inverting the /// values. /// * [overlay], which combines [modulate] and [screen] to favor the /// destination image. /// * [hardLight], which combines [modulate] and [screen] to favor the /// source image.{ރ/// Multiply the components of the source and destination images after /// adjusting them to favor the destination. /// /// Specifically, if the destination value is smaller, this multiplies it with /// the source value, whereas is the source value is smaller, it multiplies /// the inverse of the source value with the inverse of the destination value, /// then inverts the result. /// /// Inverting the components means that a fully saturated channel (opaque /// white) is treated as the value 0.0, and values normally treated as 0.0 /// (black, transparent) are treated as 1.0. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_overlay.png) /// /// See also: /// /// * [modulate], which always multiplies the values. /// * [screen], which always multiplies the inverses of the values. /// * [hardLight], which is similar to [overlay] but favors the source image /// instead of the destination image.7"/// Composite the source and destination image by choosing the lowest value /// from each color channel. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_darken.png):00$/// Composite the source and destination image by choosing the highest value /// from each color channel. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_lighten.png)<{b/// Divide the destination by the inverse of the source. /// /// Inverting the components means that a fully saturated channel (opaque /// white) is treated as the value 0.0, and values normally treated as 0.0 /// (black, transparent) are treated as 1.0. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_colorDodge.png)DDy/// Divide the inverse of the destination by the source, and inverse the result. /// /// Inverting the components means that a fully saturated channel (opaque /// white) is treated as the value 0.0, and values normally treated as 0.0 /// (black, transparent) are treated as 1.0. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_colorBurn.png)R++/// Multiply the components of the source and destination images after /// adjusting them to favor the source. /// /// Specifically, if the source value is smaller, this multiplies it with the /// destination value, whereas is the destination value is smaller, it /// multiplies the inverse of the destination value with the inverse of the /// source value, then inverts the result. /// /// Inverting the components means that a fully saturated channel (opaque /// white) is treated as the value 0.0, and values normally treated as 0.0 /// (black, transparent) are treated as 1.0. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_hardLight.png) /// /// See also: /// /// * [modulate], which always multiplies the values. /// * [screen], which always multiplies the inverses of the values. /// * [overlay], which is similar to [hardLight] but favors the destination /// image instead of the source image.9sU/// Use [colorDodge] for source values below 0.5 and [colorBurn] for source /// values above 0.5. /// /// This results in a similar but softer effect than [overlay]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_softLight.png) /// /// See also: /// /// * [color], which is a more subtle tinting effect.ll/// Subtract the smaller value from the bigger value for each channel. /// /// Compositing black has no effect; compositing white inverts the colors of /// the other image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. /// /// The effect is similar to [exclusion] but harsher. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_difference.png){FF/// Subtract double the product of the two images from the sum of the two /// images. /// /// Compositing black has no effect; compositing white inverts the colors of /// the other image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. /// /// The effect is similar to [difference] but softer. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_exclusion.png)T%%/// Multiply the components of the source and destination images, including /// the alpha channel. /// /// This can only result in the same or darker colors (multiplying by white, /// 1.0, results in no change; multiplying by black, 0.0, results in black). /// /// Since the alpha channel is also multiplied, a fully-transparent pixel /// (opacity 0.0) in one image results in a fully transparent pixel in the /// output. This is similar to [dstIn], but with the colors combined. /// /// For a variant that multiplies the colors but does not multiply the alpha /// channel, consider [modulate]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_multiply.png)MAA/// Take the hue of the source image, and the saturation and luminosity of the /// destination image. /// /// The effect is to tint the destination image with the source image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their hue from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_hue.png) /// /// See also: /// /// * [color], which is a similar but stronger effect as it also applies the /// saturation of the source image. /// * [HSVColor], which allows colors to be expressed using Hue rather than /// the red/green/blue channels of [Color].IkD/// Take the saturation of the source image, and the hue and luminosity of the /// destination image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their saturation from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_saturation.png) /// /// See also: /// /// * [color], which also applies the hue of the source image. /// * [luminosity], which applies the luminosity of the source image to the /// destination./// Take the hue and saturation of the source image, and the luminosity of the /// destination image. /// /// The effect is to tint the destination image with the source image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their hue and saturation from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_color.png) /// /// See also: /// /// * [hue], which is a similar but weaker effect. /// * [softLight], which is a similar tinting effect but also tints white. /// * [saturation], which only applies the saturation of the source image.$$d/// Take the luminosity of the source image, and the hue and saturation of the /// destination image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their luminosity from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_luminosity.png) /// /// See also: /// /// * [saturation], which applies the saturation of the source image to the /// destination. /// * [ImageFilter.blur], which can be used with [BackdropFilter] for a /// related effect.3{t/// Quality levels for image sampling in [ImageFilter] and [Shader] objects that sample /// images and for [Canvas] operations that render images. /// /// When scaling up typically the quality is lowest at [none], higher at [low] and [medium], /// and for very large scale factors (over 10x) the highest at [high]. /// /// When scaling down, [medium] provides the best quality especially when scaling an /// image to less than half its size or for animating the scale factor between such /// reductions. Otherwise, [low] and [high] provide similar effects for reductions of /// between 50% and 100% but the image may lose detail and have dropouts below 50%. /// /// To get high quality when scaling images up and down, or when the scale is /// unknown, [medium] is typically a good balanced choice. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/filter_quality.png) /// /// When building for the web using the `--web-renderer=html` option, filter /// quality has no effect. All images are rendered using the respective /// browser's default setting. /// /// See also: /// /// * [Paint.filterQuality], which is used to pass [FilterQuality] to the /// engine while using drawImage calls on a [Canvas]. /// * [ImageShader]. /// * [ImageFilter.matrix]. /// * [Canvas.drawImage]. /// * [Canvas.drawImageRect]. /// * [Canvas.drawImageNine]. /// * [Canvas.drawAtlas].>/// The fastest filtering method, albeit also the lowest quality. /// /// This value results in a "Nearest Neighbor" algorithm which just /// repeats or eliminates pixels as an image is scaled up or down.ˀ/// Better quality than [none], faster than [medium]. /// /// This value results in a "Bilinear" algorithm which smoothly /// interpolates between pixels in an image.ӂ[[k/// The best all around filtering method that is only worse than [high] /// at extremely large scale factors. /// /// This value improves upon the "Bilinear" algorithm specified by [low] /// by utilizing a Mipmap that pre-computes high quality lower resolutions /// of the image at half (and quarter and eighth, etc.) sizes and then /// blends between those to prevent loss of detail at small scale sizes. /// /// {@template dart.ui.filterQuality.seeAlso} /// See also: /// /// * [FilterQuality] class-level documentation that goes into detail about /// relative qualities of the constant values. /// {@endtemplate}fE&/// Best possible quality when scaling up images by scale factors larger than /// 5-10x. /// /// When images are scaled down, this can be worse than [medium] for scales /// smaller than 0.5x, or when animating the scale factor. /// /// This option is also the slowest. /// /// This value results in a standard "Bicubic" algorithm which uses a 3rd order /// equation to smooth the abrupt transitions between pixels while preserving /// some of the sense of an edge and avoiding sharp peaks in the result. /// /// {@macro dart.ui.filterQuality.seeAlso}/// Styles to use for line endings. /// /// See also: /// /// * [Paint.strokeCap] for how this value is used. /// * [StrokeJoin] for the different kinds of line segment joins.22r/// Begin and end contours with a flat edge and no extension. /// /// ![A butt cap ends line segments with a square end that stops at the end of /// the line segment.](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/butt_cap.png) /// /// Compare to the [square] cap, which has the same shape, but extends past /// the end of the line by half a stroke width.;/// Begin and end contours with a semi-circle extension. /// /// ![A round cap adds a rounded end to the line segment that protrudes /// by one half of the thickness of the line (which is the radius of the cap) /// past the end of the segment.](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/round_cap.png) /// /// The cap is colored in the diagram above to highlight it: in normal use it /// is the same color as the line. hmmI/// Begin and end contours with a half square extension. This is /// similar to extending each contour by half the stroke width (as /// given by [Paint.strokeWidth]). /// /// ![A square cap has a square end that effectively extends the line length /// by half of the stroke width.](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/square_cap.png) /// /// The cap is colored in the diagram above to highlight it: in normal use it /// is the same color as the line. /// /// Compare to the [butt] cap, which has the same shape, but doesn't extend /// past the end of the line.x""g/// Styles to use for line segment joins. /// /// This only affects line joins for polygons drawn by [Canvas.drawPath] and /// rectangles, not points drawn as lines with [Canvas.drawPoints]. /// /// See also: /// /// * [Paint.strokeJoin] and [Paint.strokeMiterLimit] for how this value is /// used. /// * [StrokeCap] for the different kinds of line endings.1Y7/// Joins between line segments form sharp corners. /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/miter_4_join.mp4} /// /// The center of the line segment is colored in the diagram above to /// highlight the join, but in normal usage the join is the same color as the /// line. /// /// See also: /// /// * [Paint.strokeJoin], used to set the line segment join style to this /// value. /// * [Paint.strokeMiterLimit], used to define when a miter is drawn instead /// of a bevel when the join is set to this value.VV/// Joins between line segments are semi-circular. /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/round_join.mp4} /// /// The center of the line segment is colored in the diagram above to /// highlight the join, but in normal usage the join is the same color as the /// line. /// /// See also: /// /// * [Paint.strokeJoin], used to set the line segment join style to this /// value.`rr/// Joins between line segments connect the corners of the butt ends of the /// line segments to give a beveled appearance. /// /// {@animation 300 300 https://flutter.github.io/assets-for-api-docs/assets/dart-ui/bevel_join.mp4} /// /// The center of the line segment is colored in the diagram above to /// highlight the join, but in normal usage the join is the same color as the /// line. /// /// See also: /// /// * [Paint.strokeJoin], used to set the line segment join style to this /// value.|T/// Strategies for painting shapes and paths on a canvas. /// /// See [Paint.style].~11/// Apply the [Paint] to the inside of the shape. For example, when /// applied to the [Canvas.drawCircle] call, this results in a disc /// of the given size being painted.:II/// Apply the [Paint] to the edge of the shape. For example, when /// applied to the [Canvas.drawCircle] call, this results is a hoop /// of the given size being painted. The line drawn on the edge will /// be the width given by the [Paint.strokeWidth] property.T 個/// Different ways to clip content. /// /// See also: /// /// * [Paint.isAntiAlias], the anti-aliasing switch for general draw operations.' /// No clip at all. /// /// This is the default option for most widgets: if the content does not /// overflow the widget boundary, don't pay any performance cost for clipping. /// /// If the content does overflow, consider the following [Clip] options: /// /// * [hardEdge], which is the fastest clipping, but with lower fidelity. /// * [antiAlias], which is a little slower than [hardEdge], but with smoothed edges. /// * [antiAliasWithSaveLayer], which is much slower than [antiAlias], and should /// rarely be used.Rdd-/// Clip, but do not apply anti-aliasing. /// /// This mode enables clipping, but curves and non-axis-aligned straight lines will be /// jagged as no effort is made to anti-alias. /// /// Faster than other clipping modes, but slower than [none]. /// /// This is a reasonable choice when clipping is needed, if the container is an axis- /// aligned rectangle or an axis-aligned rounded rectangle with very small corner radii. /// /// See also: /// /// * [antiAlias], recommended when clipping is needed and the shape is not /// an axis-aligned rectangle.q*’’/// Clip with anti-aliasing. /// /// This mode has anti-aliased clipping edges, which reduces jagged edges when /// the clip shape itself has edges that are diagonal, curved, or otherwise /// not axis-aligned. /// /// This is much faster than [antiAliasWithSaveLayer], but slower than [hardEdge]. /// /// Unlike [hardEdge] and [antiAliasWithSaveLayer], this clipping can have /// bleeding edge artifacts /// ([Skia Fiddle example](https://fiddle.skia.org/c/21cb4c2b2515996b537f36e7819288ae)). /// /// See also: /// /// * [hardEdge], which is faster, but with lower fidelity. /// * [antiAliasWithSaveLayer], which is much slower, but avoids bleeding /// edge artifacts. /// * [Paint.isAntiAlias], which is the anti-aliasing switch for general draw operations. HHy/// Clip with anti-aliasing and `saveLayer` immediately following the clip. /// /// This mode not only clips with anti-aliasing, but also allocates an offscreen /// buffer. All subsequent paints are carried out on that buffer before finally /// being clipped and composited back. /// /// This is very slow. It has no bleeding edge artifacts, unlike [antiAlias], /// but it changes the semantics as it introduces an offscreen buffer. /// For example, see this /// [Skia Fiddle without `saveLayer`](https://fiddle.skia.org/c/83ed46ceadaf90f36a4df3b98cbe1c35) /// and this /// [Skia Fiddle with `saveLayer`](https://fiddle.skia.org/c/704acfa049a7e99fbe685232c45d1582). /// /// Use this mode only if necessary. For example, if you have an /// image overlaid on a very different background color. In these /// cases, consider if you can avoid overlaying multiple colors in one /// location (e.g. by having the background color only present where the image is /// absent). If possible, prefer [antiAlias] as it is much faster. /// /// See also: /// /// * [antiAlias], which is much faster, and has similar clipping results. /// * [Canvas.saveLayer]../// The color space describes the colors that are available to an [Image]. /// /// This value can help decide which [ImageByteFormat] to use with /// [Image.toByteData]. Images that are in the [extendedSRGB] color space /// should use something like [ImageByteFormat.rawExtendedRgba128] so that /// colors outside of the sRGB gamut aren't lost. /// /// This is also the result of [Image.colorSpace]. /// /// See also: https://en.wikipedia.org/wiki/Color_spaceɀ/// The sRGB color space. /// /// You may know this as the standard color space for the web or the color /// space of non-wide-gamut Flutter apps. /// /// See also: https://en.wikipedia.org/wiki/SRGB/// A color space that is backwards compatible with sRGB but can represent /// colors outside of that gamut with values outside of [0..1]. In order to /// see the extended values an [ImageByteFormat] like /// [ImageByteFormat.rawExtendedRgba128] must be used.ÁQ  9/// The Display P3 color space. /// /// This is a wide gamut color space that has broad hardware support. It's /// supported in cases like using Impeller on iOS. When used on a platform /// that doesn't support Display P3, the colors will be clamped to sRGB. /// /// See also: https://en.wikipedia.org/wiki/DCI-P3 Y/// The format in which image bytes should be returned when using /// [Image.toByteData].%%t/// Raw RGBA format. /// /// Unencoded bytes, in RGBA row-primary form with premultiplied alpha, 8 bits per channel.1x/// Raw straight RGBA format. /// /// Unencoded bytes, in RGBA row-primary form with straight alpha, 8 bits per channel.Ārr/// Raw unmodified format. /// /// Unencoded bytes, in the image's existing format. For example, a grayscale /// image may use a single 8-bit channel for each pixel.@@/// Raw extended range RGBA format. /// /// Unencoded bytes, in RGBA row-primary form with straight alpha, 32 bit /// float (IEEE 754 binary32) per channel. /// /// Example usage: /// /// ```dart /// import 'dart:ui' as ui; /// import 'dart:typed_data'; /// /// Future> getFirstPixel(ui.Image image) async { /// final ByteData data = /// (await image.toByteData(format: ui.ImageByteFormat.rawExtendedRgba128))!; /// final Float32List floats = Float32List.view(data.buffer); /// return { /// 'r': floats[0], /// 'g': floats[1], /// 'b': floats[2], /// 'a': floats[3], /// }; /// } /// ```W""/// PNG format. /// /// A loss-less compression format for images. This format is well suited for /// images with hard edges, such as screenshots or sprites, and images with /// text. Transparency is supported. The PNG format supports images up to /// 2,147,483,647 pixels in either dimension, though in practice available /// memory provides a more immediate limitation on maximum image size. /// /// PNG images normally use the `.png` file extension and the `image/png` MIME /// type. /// /// See also: /// /// * , the Wikipedia page on PNG. /// * , the PNG standard."?"^"^>/// The format of pixel data given to [decodeImageFromPixels]."n#?#?/// Each pixel is 32 bits, with the highest 8 bits encoding red, the next 8 /// bits encoding green, the next 8 bits encoding blue, and the lowest 8 bits /// encoding alpha. Premultiplied alpha is used.#L$$/// Each pixel is 32 bits, with the highest 8 bits encoding blue, the next 8 /// bits encoding green, the next 8 bits encoding red, and the lowest 8 bits /// encoding alpha. Premultiplied alpha is used.$*,%K%K/// Each pixel is 128 bits, where each color component is a 32 bit float that /// is normalized across the sRGB gamut. The first float is the red /// component, followed by: green, blue and alpha. Premultiplied alpha isn't /// used, matching [ImageByteFormat.rawExtendedRgba128].ƃcc/// Determines the winding rule that decides how the interior of a [Path] is /// calculated. /// /// This enum is used by the [Path.fillType] property.t/// The interior is defined by a non-zero sum of signed edge crossings. /// /// For a given point, the point is considered to be on the inside of the path /// if a line drawn from the point to infinity crosses lines going clockwise /// around the point a different number of times than it crosses lines going /// counter-clockwise around that point. /// /// See: (0QQ/// The interior is defined by an odd number of edge crossings. /// /// For a given point, the point is considered to be on the inside of the path /// if a line drawn from the point to infinity crosses an odd number of lines. /// /// See: ]P/// Strategies for combining paths. /// /// See also: /// /// * [Path.combine], which uses this enum to decide how to combine two paths.#/// Subtract the second path from the first path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be a crescent portion of the /// first circle that was not overlapped by the second circle. /// /// See also: /// /// * [reverseDifference], which is the same but subtracting the first path /// from the second.ˁIIk/// Create a new path that is the intersection of the two paths, leaving the /// overlapping pieces of the path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be only the overlapping portion /// of the two circles. /// /// See also: /// * [xor], which is the inverse of this operationW$vv/// Create a new path that is the union (inclusive-or) of the two paths. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be a figure-eight like shape /// matching the outer boundaries of both circles.n/// Create a new path that is the exclusive-or of the two paths, leaving /// everything but the overlapping pieces of the path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the figure-eight like shape less the overlapping parts /// /// See also: /// * [intersect], which is the inverse of this operation}/// Subtract the first path from the second path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be a crescent portion of the /// second circle that was not overlapped by the first circle. /// /// See also: /// /// * [difference], which is the same but subtracting the second path /// from the first.8u{884/// Styles to use for blurs in [MaskFilter] objects.9299€/// Fuzzy inside and outside. This is useful for painting shadows that are /// offset from the shape that ostensibly is casting the shadow.9̀::/// Solid inside, fuzzy outside. This corresponds to drawing the shape, and /// additionally drawing the blur. This can make objects appear brighter, /// maybe even as if they were fluorescent.:;;/// Nothing inside, fuzzy outside. This is useful for painting shadows for /// partially transparent shapes, when they are painted separately but without /// an offset, so that the shadow doesn't paint below the shape.;c;;Y/// Fuzzy inside, nothing outside. This can make shapes appear to be lit from /// within.4/// Defines what happens at the edge of a gradient or the sampling of a source image /// in an [ImageFilter]. /// /// A gradient is defined along a finite inner area. In the case of a linear /// gradient, it's between the parallel lines that are orthogonal to the line /// drawn between two points. In the case of radial gradients, it's the disc /// that covers the circle centered on a particular point up to a given radius. /// /// An image filter reads source samples from a source image and performs operations /// on those samples to produce a result image. An image defines color samples only /// for pixels within the bounds of the image but some filter operations, such as a blur /// filter, read samples over a wide area to compute the output for a given pixel. Such /// a filter would need to combine samples from inside the image with hypothetical /// color values from outside the image. /// /// This enum is used to define how the gradient or image filter should treat the regions /// outside that defined inner area. /// /// See also: /// /// * [painting.Gradient], the superclass for [LinearGradient] and /// [RadialGradient], as used by [BoxDecoration] et al, which works in /// relative coordinates and can create a [Shader] representing the gradient /// for a particular [Rect] on demand. /// * [dart:ui.Gradient], the low-level class used when dealing with the /// [Paint.shader] property directly, with its [Gradient.linear] and /// [Gradient.radial] constructors. /// * [dart:ui.ImageFilter.blur], an ImageFilter that may sometimes need to /// read samples from outside an image to combine with the pixels near the /// edge of the image./// Samples beyond the edge are clamped to the nearest color in the defined inner area. /// /// A gradient will paint all the regions outside the inner area with the /// color at the end of the color stop list closest to that region. /// /// An image filter will substitute the nearest edge pixel for any samples taken from /// outside its source image. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_clamp_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_clamp_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_clamp_sweep.png)5/// Samples beyond the edge are repeated from the far end of the defined area. /// /// For a gradient, this technique is as if the stop points from 0.0 to 1.0 were then /// repeated from 1.0 to 2.0, 2.0 to 3.0, and so forth (and for linear gradients, similarly /// from -1.0 to 0.0, -2.0 to -1.0, etc). /// /// An image filter will treat its source image as if it were tiled across the enlarged /// sample space from which it reads, each tile in the same orientation as the base image. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_repeated_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_repeated_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_repeated_sweep.png)|llY/// Samples beyond the edge are mirrored back and forth across the defined area. /// /// For a gradient, this technique is as if the stop points from 0.0 to 1.0 were then /// repeated backwards from 2.0 to 1.0, then forwards from 2.0 to 3.0, then backwards /// again from 4.0 to 3.0, and so forth (and for linear gradients, similarly in the /// negative direction). /// /// An image filter will treat its source image as tiled in an alternating forwards and /// backwards or upwards and downwards direction across the sample space from which /// it is reading. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_mirror_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_mirror_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_mirror_sweep.png)w///// Samples beyond the edge are treated as transparent black. /// /// A gradient will render transparency over any region that is outside the circle of a /// radial gradient or outside the parallel lines that define the inner area of a linear /// gradient. /// /// An image filter will substitute transparent black for any sample it must read from /// outside its source image. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_decal_linear.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_decal_radial.png) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/tile_mode_decal_sweep.png) w/// Defines how a list of points is interpreted when drawing a set of triangles. /// /// Used by [Canvas.drawVertices].QE/// Draw each sequence of three points as the vertices of a triangle.,[zzK/// Draw each sliding window of three points as the vertices of a triangle.A)/// Draw the first point and each sliding window of two points as the vertices /// of a triangle. /// /// This mode is not natively supported by most backends, and is instead /// implemented by unrolling the points into the equivalent /// [VertexMode.triangles], which is generally more efficient.I%II䀍/// Defines how a list of points is interpreted when drawing a set of points. /// /// Used by [Canvas.drawPoints] and [Canvas.drawRawPoints].IKK/// Draw each point separately. /// /// If the [Paint.strokeCap] is [StrokeCap.round], then each point is drawn /// as a circle with the diameter of the [Paint.strokeWidth], filled as /// described by the [Paint] (ignoring [Paint.style]). /// /// Otherwise, each point is drawn as an axis-aligned square with sides of /// length [Paint.strokeWidth], filled as described by the [Paint] (ignoring /// [Paint.style]).KLL/// Draw each sequence of two points as a line segment. /// /// If the number of points is odd, then the last point is ignored. /// /// The lines are stroked as described by the [Paint] (ignoring /// [Paint.style]).LM0M0/// Draw the entire sequence of points as one line. /// /// The lines are stroked as described by the [Paint] (ignoring /// [Paint.style]).M<MMx/// Defines how a new clip region should be merged with the existing clip /// region. /// /// Used by [Canvas.clipRect].MBMM5/// Subtract the new region from the existing region.N BNENE6/// Intersect the new region from the existing region.o t puu" *)ۆ|  l$#& .-0<; TpT/T/T: TBTATTTT'Tjj?rBrB/// Instantiates an image [Codec]. /// /// This method is a convenience wrapper around the [ImageDescriptor] API, and /// using [ImageDescriptor] directly is preferred since it allows the caller to /// make better determinations about how and whether to use the `targetWidth` /// and `targetHeight` parameters. /// /// The `list` parameter is the binary image data (e.g a PNG or GIF binary data). /// The data can be for either static or animated images. The following image /// formats are supported: /// {@template dart.ui.imageFormats} /// JPEG, PNG, GIF, Animated GIF, WebP, Animated WebP, BMP, and WBMP. Additional /// formats may be supported by the underlying platform. Flutter will /// attempt to call platform API to decode unrecognized formats, and if the /// platform API supports decoding the image Flutter will be able to render it. /// {@endtemplate} /// /// The `targetWidth` and `targetHeight` arguments specify the size of the /// output image, in image pixels. If they are not equal to the intrinsic /// dimensions of the image, then the image will be scaled after being decoded. /// If the `allowUpscaling` parameter is not set to true, both dimensions will /// be capped at the intrinsic dimensions of the image, even if only one of /// them would have exceeded those intrinsic dimensions. If exactly one of these /// two arguments is specified, then the aspect ratio will be maintained while /// forcing the image to match the other given dimension. If neither is /// specified, then the image maintains its intrinsic size. /// /// Scaling the image to larger than its intrinsic size should usually be /// avoided, since it causes the image to use more memory than necessary. /// Instead, prefer scaling the [Canvas] transform. If the image must be scaled /// up, the `allowUpscaling` parameter must be set to true. /// /// The returned future can complete with an error if the image decoding has /// failed.r[rfrerorurtrrrrrrrs{{+/// Instantiates an image [Codec]. /// /// This method is a convenience wrapper around the [ImageDescriptor] API, and /// using [ImageDescriptor] directly is preferred since it allows the caller to /// make better determinations about how and whether to use the `targetWidth` /// and `targetHeight` parameters. /// /// The [buffer] parameter is the binary image data (e.g a PNG or GIF binary data). /// The data can be for either static or animated images. The following image /// formats are supported: {@macro dart.ui.imageFormats} /// /// The [buffer] will be disposed by this method once the codec has been created, /// so the caller must relinquish ownership of the [buffer] when they call this /// method. /// /// The [targetWidth] and [targetHeight] arguments specify the size of the /// output image, in image pixels. If they are not equal to the intrinsic /// dimensions of the image, then the image will be scaled after being decoded. /// If the `allowUpscaling` parameter is not set to true, both dimensions will /// be capped at the intrinsic dimensions of the image, even if only one of /// them would have exceeded those intrinsic dimensions. If exactly one of these /// two arguments is specified, then the aspect ratio will be maintained while /// forcing the image to match the other given dimension. If neither is /// specified, then the image maintains its intrinsic size. /// /// Scaling the image to larger than its intrinsic size should usually be /// avoided, since it causes the image to use more memory than necessary. /// Instead, prefer scaling the [Canvas] transform. If the image must be scaled /// up, the `allowUpscaling` parameter must be set to true. /// /// The returned future can complete with an error if the image decoding has /// failed. /// /// ## Compatibility note on the web /// /// When running Flutter on the web, only the CanvasKit renderer supports image /// resizing capabilities (not the HTML renderer). So if image resizing is /// critical to your use case, and you're deploying to the web, you should /// build using the CanvasKit renderer.||||$|*|)|8|>|=|M|S|R|c~Nee/// Instantiates an image [Codec]. /// /// This method is a convenience wrapper around the [ImageDescriptor] API. /// /// The [buffer] parameter is the binary image data (e.g a PNG or GIF binary /// data). The data can be for either static or animated images. The following /// image formats are supported: {@macro dart.ui.imageFormats} /// /// The [buffer] will be disposed by this method once the codec has been /// created, so the caller must relinquish ownership of the [buffer] when they /// call this method. /// /// The [getTargetSize] parameter, when specified, will be invoked and passed /// the image's intrinsic size to determine the size to decode the image to. /// The width and the height of the size it returns must be positive values /// greater than or equal to 1, or null. It is valid to return a /// [TargetImageSize] that specifies only one of `width` and `height` with the /// other remaining null, in which case the omitted dimension will be scaled to /// maintain the aspect ratio of the original dimensions. When both are null or /// omitted, the image will be decoded at its native resolution (as will be the /// case if the [getTargetSize] parameter is omitted). /// /// Scaling the image to larger than its intrinsic size should usually be /// avoided, since it causes the image to use more memory than necessary. /// Instead, prefer scaling the [Canvas] transform. /// /// The returned future can complete with an error if the image decoding has /// failed. /// /// ## Compatibility note on the web /// /// When running Flutter on the web, only the CanvasKit renderer supports image /// resizing capabilities (not the HTML renderer). So if image resizing is /// critical to your use case, and you're deploying to the web, you should /// build using the CanvasKit renderer.&s FF0/// Loads a single image frame from a byte array into an [Image] object. /// /// This is a convenience wrapper around [instantiateImageCodec]. Prefer using /// [instantiateImageCodec] which also supports multi frame images and offers /// better error handling. This function swallows asynchronous errors.Zedj-/// Convert an array of pixel values into an [Image] object. /// /// The `pixels` parameter is the pixel data. They are packed in bytes in the /// order described by `format`, then grouped in rows, from left to right, /// then top to bottom. /// /// The `rowBytes` parameter is the number of bytes consumed by each row of /// pixels in the data buffer. If unspecified, it defaults to `width` multiplied /// by the number of bytes per pixel in the provided `format`. /// /// The `targetWidth` and `targetHeight` arguments specify the size of the /// output image, in image pixels. If they are not equal to the intrinsic /// dimensions of the image, then the image will be scaled after being decoded. /// If the `allowUpscaling` parameter is not set to true, both dimensions will /// be capped at the intrinsic dimensions of the image, even if only one of /// them would have exceeded those intrinsic dimensions. If exactly one of these /// two arguments is specified, then the aspect ratio will be maintained while /// forcing the image to match the other given dimension. If neither is /// specified, then the image maintains its intrinsic size. /// /// Scaling the image to larger than its intrinsic size should usually be /// avoided, since it causes the image to use more memory than necessary. /// Instead, prefer scaling the [Canvas] transform. If the image must be scaled /// up, the `allowUpscaling` parameter must be set to true.    %$398HNM^G]qGmGmGGGGGG9EEZgfၛ  ~$ƊƊƛ ƣƢƪ ƲƱ))),<;Ӄ2  B/// A variant of `_futurize` that can communicate specific errors.3336"ON%[d%%+/// Signature for [Image] lifecycle events.% %%TmTT1/// Callback signature for [decodeImageFromList].T TTI]JJ/// Signature for a callback that determines the size to which an image should /// be decoded given its intrinsic size. /// /// See also: /// /// * [instantiateImageCodecWithSize], which used this signature for its /// `getTargetSize` argument.}9l:0:0-/// Signature for [Picture] lifecycle events.:U:^:]dSS4/// Generic callback signature, used by [_futurize].]]]psr|=/// Generic callback signature, used by [_futurizeWithError]. /// Signature for a method that receives a [_Callback]. /// /// Return value should be null on success, and a string error message on /// failure.ڀ??\/// Signature for a method that receives a [_CallbackWithError]. /// See also: [_Callbacker]TTTjj<΀-FyC4ӄb^mop 3ˇ jy{| 7vxyLj܊Ck $t DHTfnrdhvzǐ/ې8>io _Ւۓ!nٓ:ɔޔLM+;ARXfޖ#sy $=Xr͘ޘߙ%+xԙCIGH7NTyƝCIڝY.JKr/0Utu ƠǠHaߡ`"mIߤ1}Ȧ+xƧa~ԧOUƨ'([aԩK}DE}ܫݬ#gMjpЮ$9L]pï 2MdƯ̰ d6lrűCɳ+Yߴ JcWr%+c}.Nnt _}߹RMS޺.{S4ҾpG}ȿ߿@@+@3@@@W@y@@@AAKAAAAABBBBKBBBC*CuCDDODDDEE2EKEQExEEEEFF?F~FFFFGG;GlGGGHHSHHHHHHI+I1I\IIIIIIJ J3J9JeJyJJJJJJK$K(K)K5KpKqK}KL9L;L<LoLsLM M)M-M~MNNhNOOGOKOOP7PPQQeQQRER`RdRRSISST9TzT~TTTU8UUV'VvVVVVVWAWRWcWWX X XPXVXXXXXY>YDYYYYYZDZKZLZZZZZ[5[;[[[[[\/\\\\]]$]]]]]]^^P^V^^_ _5_@_A__`#`1`7`v`|`aa!a'asayaaab-b{bbcc cXcccdd_dhdide eZe`eeefDfJfffgggZgggh3h9hhhi*i0iiiijjj\jbjjk2k8kkkklllTlolullmm`mmmmmn[nfngnnno>oDooooop;pppqqqXqqrFrrrrrsEsKssst@titottu&u,u<uBuuuv2vIvUvVvvvwwwbwwwx5xxxxyLyyyzzzxz~zzzz{={Y{{{|%|T|Z||}J}i}o}~~7~=~~~~~8 ,2{Jio.9:u{CI _BOPb/|(.g)67LRbhMdjjxy(?EDQR]cDJ#K S*0@F?FGP}C!'pvDJG X=CSY "023'nrqRVHgky}4On;<RXCI*u{DYcdRX'rxbF089tz L |Kkuwx7;IM/ek"r~J/5}CT]^KQ _py{| "m{|/78| GQSTx|SHDJ x>bno3KQrx3žE×_{PVř&zƿ)F`bcǥǩ"jȀȋȌ$bhɶNjʺ .|˥˩˪)t`e͵deΆ΢.Vπϩ&KvП)TшѸ'cң!aӟUԕ'gչEFև/Kfgו.Yحخ 9ـلم٥Fڊڎڏ17W]ms۹28܀ܕܩGݖ#_f*o߳^bc)/q4:@t=x|} !ek)NW] B6R378y![a[akw}W 2WZ@-QW/5AMSci759:Uv'ny&nB>DHI;Ai489dJP`f Tk2EO_ 3=uyzUvb)/34ou1C]!BMUb$hpvz{  V       X \ ] i      ( D m      ! J o w   5 ? N t |     1YqwNflSkq8PVn48{BFy}6bh?w6 Ia{1=[g  LdG#./OU5p'-BHVtV!,4>TUgm  W   !D!P!V!f!l!"""""Y"l"# #=#I#J##$$'$($x$%%I%X%Z%[%%%%%&;&?&&&&'G''($(2(6(()))*).))**`*n*****++.+2+3+T+p++++,,Y,z,,,,-2-u-----..2.3.u...../#/)/z///01000001'1=1t111111222g2}2222223 3k3o3p33344 4R4445;5T556=667 797=7>7z7788G8M8899i999:::4:B:j:y::::;#;E;K;;;;6>>>>?B?k?q?@ @ @&@\@b@p@@@@AA@A_AAAAB<BBBBCCC CBCvCCD/DsDDDE E;EAE^ExE~EEEEEFF&F,FGFMFpFFFFFFFGAGGGGGHHnHHIII-IXI\I]IIIJBJJK+KuKKKLL2L4L5LOLLLLM;M]MyMMMMMNBN]N^NNOIOyOOOOOOPPP?PPPQ QQ4Q@QXQQRR?RFR\RlRpRqRRS#S?S@SiSjSSSST TTT)TJT~TTTTTU$U(UdU~UUVVcVVWW!WZW^WjWvWWXX\XXYY/YPYVY^YbYxY|YYYZZPZZZ[D[[[[[\\3\9\w\\\]]]T]o]p]]]]^9^N^P^Q^q^u^^^__0_G_m_____``-`.`V`\````a>anaaabb bWb|bbbbbc+cFcKcccccccdddndddddeee_eeeeff.fCfcf}fffg$g.gggvgggh+h8hChKhShlhhhhhhi?iiiiiijjgjijjjjjk0k~kkklEl`llmm\mmn nnZnnoCoop/pwppqqKqqqr(r4rYrmrrrrs s5sAs_ssssssst!tqtttu:uuuvvgvsvwvw w\wwxHxxyyyiyzz?zCzzzzz{{d{{||"|6|K|i|n||||}B}j}t}}}}~?~F~K~M~N~q~u~~`;QU<}lA EI/WKS.V{$FHI!BONf$s^ _Isy Y]ARow'+y,} U@(dhL 1Fdi_+o.~"Hd#'^rb%&hnOZ\] !U[5;KQ>DGTU?t}~V9?/5~m/84FHI!".vV"aMc=C6f} (LMcp :;~DC*+p9B=> Ty].s(vw%IOa¨ eÛ<āćcŊŐ$pvƉƞƿfǫDZ:Ȉ^ɬ+Efʁʜʷʽʾ78z˨ˮNij̲.o͵=IOλ+1ϡUVШжм 06}ѱѲ7Gefҳ^dӱ*lmԳ/5ՂGH֍$h׃דה1PV؞ؤ Ixٕٖ-.ciڹQېۖ6܈m{!4:ފ[߇nuyzL2|R%rR>0dj@BC.s(NO[A`aR~45A5GKcdpUVbIJVMNZ-.:*|_z278DWl - <Pdx0Kf*:JZkrvw7K_sMQR+Gg $tu59:$;RWXd"_`l NO[R (PQ op|-#GK   @ V e t         ^ w x       V       * ; ? @      . \ {    #$0Ep>BCOnpq#3dj ^39n$*z9%6{T04;qr+EEf~='Wjp , w   !;!!"&"t""""#3#f#g###$6$$$$$%%V%%%%&&&^&&'B'{''((n((((()2)Y)_))***N*T**+ +++[+a++,5,,,,,----O----..E.F.j.v...////{////0$0o0v0011#10111112.2/222333F3333344464H4^4p44444445F5M5q5u5v5666-62666677"7(797=7>7778 88R8r8t8u8889/909}999::e::::;;;~;;;;;;;:>>>>?>?D?j?p???@@@!@8@9@@@A*A+A7AZAAAAAAABPBRBSBtBBBBCCCdCfCgCCCCD(D?DhDDDEE EEEEKE\EEEEEEFFFvFG+GOGVGZG\G]GGHIHNH`HvHHHHHI.IIJ JJJ+JVJtJJKKSKmKKLLFLaLLM MM%M?M\MzMMNN'NBNJNlNNNOOBOeOOOOOP+PQPlPPPPPPQ!QpQR R;R?RRRS S^SSSTGTtTTTTUUU^UUUV V5V;VnVVWW:W@WWWWX/XFX]XtXXXXXXXXXY0YLYhYYYYYZAZGZUZZZZ[[([2[8[[[\\<\b\\\\\]] ]8]T]U]]]]^^^D^E^^^^___A_B_Y_x____``T````a aXaYaaaaabb+bDbrbbbbc&cJccccd)d/d3d4d@dcddddde#eEemeqere~eef f$f%f1fRfgf~fffg#gUgygggggggh h!h8hqhhhii3ieitjjjjjj[j_jjkLkbkkllHlLlMllllm'mlmmmmmnn+nInMnNnnnno o@oAooop/p`papppqTq~qqqqqqrrfrrs)sTsqssst-ttttu5u{uv vvvTvvw4w8w9w}wwxx9xTxxxxxyYy]y^yyyz4zYzzz{{7{={{|)|y|||}8}d}j}~~~#~1~^~d~~~~~~~7c ^$A$O %nv`>ef  <+7no{?kgij3OPd8Pl &*+7 5IO+-.`(_`l*VjpJGHT<PV1$0ghtGHTw>BCOYZf+,8[(,-t*.~P59:'X\]7K{b $^bc7[_`F(<\`a'9=89rE'(oO^.JXYxy,<]pz Z7=#-134A7<;?MQ/Y_lr bN iSGMSnt$9?jtuph-689p˜PsÖù%MĨ=wŠž(Gfj{}~ƻ,E^wǐǡǣǤBUYgk ?Eɔ/~ p˒˘#̆Mͳ͹Jekθ K^o~Ϙ϶@|ЏмCmѳ"&'rҒҘ8ӂ"s9ou;֟ \ע׽cأةCٍ*Obuڈڢ3Zۖ۩F܉܊Kݏݥݸ6GP]kޢ%:M`p߆ߠ߸-KQ%+zdVx~w<FioOat.U{:d2DTcjnoAEb}Dhl %*+6I^lz:M`x"0G\uz{ ckx W6|Sag!'m 'CRcuZ`t %CIMNZmOy}Rw(=AkEY45z[q=>YAW_cd=LMGAGKLh#$<>?rvC  U   % P       : ; {     0 ~   g     0Ojtz7bH)/V:KQ7;<rxf Itxy\gOSr   ^b)*xA ]:O M  !6!!"""="A""#%#G#K##$,$}$%%A%x%%&&`&&'('.'{'''(I(((()H)))***n*++\++,@,P,V,,,---d-..R.y.....///U///0T0Z0j00011l12222'2/2B2L2233p333334464K4a4j44445575=556&6q6667=77778B889)9z9:::U::;>;w;};<'>w>>>?8?H?]?z?????@@s@|@@AAAmAAAAB9BqBBC.C{CCCCCCDD[DaDeDfDDEEE)ENEeE~EEEEF F"F2FJF]FgFwF{F|FFG1GMGNGhGiGGHHH8HLH\HxHHHIIIIIcIgIIIJJJfJJJK<KKKKKKL2L8LzLLLLLMM.M9M;M<MMMMMMN N NCNPNRNSNNNOOXO\OOP>P[P_PPQ-Q1Q~QQQQR6RRS#SmSSST6TNTTTTUFUUV2VuV{VVW&W'WoWuWWWWXXCXRXSXXYDYYYYZ?ZZ[#[m[s[[[[\>\\]*]O]U]]^=^^_)_q___`` ``H`p```a'a`azaaaaabIbbbbbc9cacxccd(dBdJdTdZdde;eAeOe|eef f:fQffgg ggghghh:h@hdhjhhhiKiij6jjkkkkkkkklClellllm1mPmVmmmn(n:n;nno6o<o{ooppApcpdppq3qhqnqqqqrJrrrsrs ss#sis{ssstttituu-uPuQuuvvvWvvvw!wowwx x xYxpxvxxyyynyyyz/zCzzz{ {{g{m{{| |Q|||}*}L}R}}}~~S~~EF NTNOEV\UF9U[9EKYz.hh'-sJ/0&,|ngtzbKQ.IhieOs@fl<lOrxR{|ho+xgX) UP'-|0C#q NT=$=bc#oO?(uBHD]C&,<BEKH_eH+v\*v9:~. cUEKAjVDJ8>&.4b˜ž6<N}Þ 3Rnī-[ʼnŚů&MW]lt~ƄJ]tLJǠǨǮqȏȰȶOɃɭ1Omʳ 5iˬ*V`fu}̇̍!TZjp;0IcwΈ΍Ύ)ς){ ZѢѨ9djҸTӡRciwԌԵQWհ6ֆ&Bׇ 4jؓغq&hڔ>JkY_m܂$*Xݎݔ ,2DscL5eEH (D&]' O[| !17 &:KPQ 5;lpq'8HZmrs+p ,D` $()5c}OUYZp056BEFR8ijvCDP;ghtk)-.~9S04EUgzAEF:lklx?~?CD3Z@AMMNZu)./;[/0<f:@DE  # D \ a b n      a     + M       6 M d       & t x y   :[sxy' &7GYlRVW;SXYe%8J\m )5CQWv9QVWc6#I]n7=AB6Njop|!K_o~ -4M (6DR`n|%;Obw<^+;J[m % + / 0 ; P e z         !!!!>!a!s!!!!!!" "#"D"\"x"}"~"""####\####$&$R$v$$$$$%5%%%%%&&Y&_&&&''-'N'f'y'''''((^(b(c(((())#)D)\)a)b)n))))))**!*'*I****+*+0+}+++++,D,,,,,--=-s---.#.W..../%/+/,/O//000=0S0f0z000001 111.1|1111111122 242E2K2|2}223 3&3D33334e4n4t4444455$595F5T5~55556 6666"676L6Z6h6u666666667767N7j7|77777778 8a88899)9-9J9`9o99999999:(:g:h::::;3;u;;<<<`<<<<=.=4===> >>8>>>>?%?U?V???@$@s@@AA`AAAB,BEBKBBBBC,COCaCbCCCDD,D-DvD|DDEE!E"ErEEEFF*F+F7FhFFFFFGEGbG|GGGGGGGHJHHHHHIIJIPIQIvIIIIJ9JJJJJJJJJKK/K3K4KKKLLLL L,LGL[LkLLLLMM M!M-MMMMMMMN-N1NvNNNNO4OOPPaPPPQ+QrQQRR7RmRnRRRS:SqSST T T:T@TTU U:U<U=UUUUUVV7V8VDVoVpV|VVVVW3WOWnWWXXAXUXYXZXXXYY YYXYZY[YpYtYYYYZ*ZuZZZZ[+[D[U[[[\\\C\g\\\] ]4]5]e]k]]]]^5^;^^__._/_____```;``aaaaYa_aaabb"b_bbbcchcccdddYd]d^ddde9e=e>eneteff&f,fRffg4gghhkhhii$i9iqiiiiiiijj)j8jOjjjkkkkkkRkXkkkll9lLlRlhl~llmmDmJmmmmnn nn#n$n0nSnunnnnnoooo'oeofopp pZpuppppq q q$qqqqqqrrOrirrrsrrs,s-s|ssssssttGtItJttttu8u[u\uuvvEvwvvvvwww@w~wx xVxxyy7ysyyyyzz zzzCzIzzz{+{`{{{{{||| | |a||}}P}Q}}}~.~K~Z~[~z~{~~~.>_r| \@ (8<=cg(.~>.Ld}%h<@Akq*<=ou9?,2}/W!"[a#qB`~^v+~5Q`p"#/Z[kl67  e*0e4s01[!wxK{|;?7A^aB:I G].6C`fl~\Zp4CVH}3KL6Ogdart.uiY _rectIsValid _rrectIsValid_rsuperellipseIsValid_offsetIsValid_matrix4IsValid_radiusIsValid _scaleAlphaColor BlendMode FilterQuality StrokeCap StrokeJoin PaintingStyleClipPaint ColorSpace_colorSpaceToIndex_indexToColorSpaceImageByteFormat PixelFormatImage_Image _wrapImage FrameInfoCodec _NativeCodecinstantiateImageCodecinstantiateImageCodecFromBufferinstantiateImageCodecWithSize_getDefaultImageSizeTargetImageSizedecodeImageFromList_decodeImageFromListAsyncdecodeImageFromPixels PathFillType PathOperation EngineLayer_NativeEngineLayerPath _NativePathTangent PathMetricsPathMetricIterator PathMetric _PathMeasure BlurStyle MaskFilter_ColorTransform_IdentityColorTransform_ClampTransform_MatrixColorTransform_getColorTransform ColorFilter _ColorFilter ImageFilter_MatrixImageFilter_GaussianBlurImageFilter_DilateImageFilter_ErodeImageFilter_ComposeImageFilter_FragmentShaderImageFilter _ImageFilterShaderTileMode_encodeWideColorList_encodeColorList_encodePointList_encodeTwoPointsGradient ImageShaderFragmentProgramFragmentShader VertexModeVertices PointModeClipOpCanvas _NativeCanvasPicture_NativePicturePictureRecorder_NativePictureRecorderShadowImmutableBufferImageDescriptor_NativeImageDescriptor _futurize_futurizeWithErrorPictureRasterizationException-dart.ui.Color.componentsStoredAsFloatingPoint> [!NOTE] > Each color is stored as floating-point color components, where the final > value of each component is approximated by storing `c / 255`, where `c` is one of the four components (alpha, red, green, blue).dart.ui.filterQuality.seeAlsoSee also: * [FilterQuality] class-level documentation that goes into detail about relative qualities of the constant values.dart.ui.imageFormats"JPEG, PNG, GIF, Animated GIF, WebP, Animated WebP, BMP, and WBMP. Additional formats may be supported by the underlying platform. Flutter will attempt to call platform API to decode unrecognized formats, and if the platform API supports decoding the image Flutter will be able to render it.%dart.ui.canvas.conservativeClipBoundsThe conservative estimate of the bounds is based on intersecting the bounds of each clip method that was executed with [ClipOp.intersect] and potentially ignoring any clip method that was executed with [ClipOp.difference]. The [ClipOp] argument is only present on the [clipRect] method. To understand how the bounds estimate can be conservative, consider the following two clip method calls: ```dart void draw(Canvas canvas) { canvas.clipPath(Path() ..addRect(const Rect.fromLTRB(10, 10, 20, 20)) ..addRect(const Rect.fromLTRB(80, 80, 100, 100))); canvas.clipPath(Path() ..addRect(const Rect.fromLTRB(80, 10, 100, 20)) ..addRect(const Rect.fromLTRB(10, 80, 20, 100))); // ... } ``` After executing both of those calls there is no area left in which to draw because the two paths have no overlapping regions. But, in this case, [getLocalClipBounds] would return a rectangle from `10, 10` to `100, 100` because it only intersects the bounds of the two path objects to obtain its conservative estimate. The clip bounds are not affected by the bounds of any enclosing [saveLayer] call as the engine does not currently guarantee the strict enforcement of those bounds during rendering. Methods that can change the current clip include [clipRect], [clipRRect], and [clipPath]. The [restore] method can also modify the current clip by restoring it to the same value it had before its associated [save] or [saveLayer] call.$dart.ui.painting.Picture.toImageSyncyThe returned image will be `width` pixels wide and `height` pixels high. The picture is rasterized within the 0 (left), 0 (top), `width` (right), `height` (bottom) bounds. Content outside these bounds is clipped. The image object is created and returned synchronously, but is rasterized asynchronously. If the rasterization fails, an exception will be thrown when the image is drawn to a [Canvas]. If a GPU context is available, this image will be created as GPU resident and not copied back to the host. This means the image will be more efficient to draw. If no GPU context is available, the image will be rasterized on the CPU.dart.ui.shadow.lerpThe `t` argument represents position on the timeline, with 0.0 meaning that the interpolation has not started, returning `a` (or something equivalent to `a`), 1.0 meaning that the interpolation has finished, returning `b` (or something equivalent to `b`), and values in between meaning that the interpolation is at the relevant point on the timeline between `a` and `b`. The interpolation can be extrapolated beyond 0.0 and 1.0, so negative values and values greater than 1.0 are valid (and can easily be generated by curves such as [Curves.elasticInOut]). Values for `t` are usually obtained from an [Animation], such as an [AnimationController].۹