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 _fromRGBOCfromARGBroundclamp 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_validateImageFiltershadermirrorrepeateddecaldilateerodecomposed_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 ExceptionjaIUk]#d:˕To<΀-FyC4ӄb^mop 3ˇ jy{| 7vxyLj܊Ck $t DHTfnrdhvzǐ/ې8>io _Ւۓ!nٓ:ɔޔLM+;ARXfޖ#sy $=Xr͘ޘߙ%+xԙCIGH7NTyƝCIڝY.JKr/0Utuɠ͠ΠOhǡ#g#)t WŤ?֦ &9ԧ%o§#$]cԩ <=pvǩ()`ƪǫ9gh٬GMجޭ)wϭDNcvȮϮ6\w¯5װ `Ա#$m/U 6zDzzzz{{{g{{{||O|~||}#}t}}}~2~a~g~~~~b7V\$%tXcd>ms7= lyzC Y<BRX'S`av|"(w,2Rio n{|8&ntMu.4}TZjp8ipq*z%+m2KQ9nt#q39gm}3LZ\]QEA|*r+A^y=ef;CD|Ems T:n?|QIp(Zbc>)23v5!'uaesw GYL#tY_ m~u{%5;7L2Yab3q{}~ ,2}%r 9ABntDJh]u{#AD]ºo@ĉĥ zŀPƤSpNJnjǍ8LȔȪȵȶNɌɒ0xʔ5X˦S̞;͊͏0AFΎΏΰ-XπϪ'PuР%S~ѲQҍ KӋAԿ QՑ-opֱ8Yuאב׿-X؃,2Jc٪ٮٯIpڴڸڹ!"[aہۇۗ۝\bܪܿ qMމސTߙ(SY=^djgFJK+/0SxD#'(Jl(.`|]abEKD 8267\89j W{Y_kw}Aa_cd;QP:lhnrsek^bc8>tz6~\oy8BJ]g(.F SY]^A[m Kl+Iw#N 6       8         7 R n      C K t     _ i x      %+[;x <}%bz ^b:lp `i `3@BCsH[g-134v)qMXYy _$QWlr *1KV^h~ 5  !!!n!z!!!!":"A"C"D"""#4#g#s#t#$$E$Q$R$$%8%s%%%%%%&!&%&e&i&&&'"'q'((N(\(`(()B)F)T)X)**;****++++>+X+\+]+~+++++,A,,,,- --\----...I.\.].....//M/S///00[00001%1Q1g11111112=2C2222233336333334!41474|4555e5~566g67757c7g7h7778E8q8w899G999::0:>:^:l::::::;M;o;u;;< <>`>>???l???@4@J@P@@@@@@@A+AjAAAABBfBBCCC<CDCJClCCDDYDDDDE5EeEkEEEEEFF FF-FPFVFqFwFFFFGGG G&GkGGGHHHGHHI)I2I8IWIIIIJJJlJKKUKKL%L&L2L\L^L_LyLLMMMeMMMMNNNNlNNNO&OsOOOP PP P(P,P-PiPQQQ3QFQ^QjQQQR1RiRpRRRRRS SMSiSjSSSSSTT6T8T9TSTtTTTTUUUNURUUUUV?VVWWGWKWWWWWXX9XXXY:YYYzYYYYYYYYZ:ZzZ[[[n[[[[[\A\]\c\\\\]+]1]~]]]]^^^c^x^z^{^^^___=_Z_q_____``<`W`X````a!a'ahaaab b0b6bbbbbcc cUcpcuccccccddCdDdddddde/e0eeeeef.fXfmfffffgNgXgggghhUhbhmhuh}hhhhhhiiiiiijj#j$j0jjjjjk kZkkkl!lolllm@mmn"n5n9nnoomop pYpppq+quqrrrRr^rrrrrrs5s_sksssssssstKttu uuduuuvAvvvvw6wwx!xrxy yEyIyyz-zizmzzzzz{C{{||0|L|`|u||||} }(}l}}}~~~!~i~p~u~w~x~~~~;e{fF!k:FJosY)u}XNprsKl)-y#)xHN;39%s79:$kC|QU V5j R&v6G[p<@A29:U:BHIX %ALr=MQ= DOP:@y6K_eu{Bhn $*:q~i,2'./ciCIY_*GY b9^prs1KLX9=HL>w>?gm ,`5RvwEF7den)*mTUc&'l gh7~X*R OsyG‹DJÏfīıIōŴźNƚƠƳ:@AǐdȲ?EɈ#:Uoʐʫ/Fabˤ*x̓̔X͙#gsyU[?Ѐ5Z`ѧaqҏҐ ABӈӎ)TԖԗY_լ(qrַ Nג׭׽׾[z؀23s٢ٿ0WXڍړ0{ۺ`ܲIݗݥK^d޴<߅߱1$*v \/|O/|h Z0jlm  X  Rxyk|$(^_k;_qu(:>$(stwxWXdGHT%)*/F\abn3W3EIfz9Zu.DTdt&8<au;w{|HIUq8JN _cd);Ne|LJxy"#|7Rz{59/WMqu  < @ j         . / ;                , T e i j     2 X     MNZo"GH;hlmyM]-39=>]cAGNTcO`)-~Z^eCUo!<o g  *Q   V  !!!e!""P""""##]####$$`$$$$$%:%%%&&&2&8&&''l'''(I(((() ) )\)))*%*=*C*x*~**+7+;+<+++,,_,,,,,-;-=->-y----.-.o.p...///?/C/D///00#0N00011:1M1Z111122X2Y2223;3B3p333344>4B4`4r444444445%5p5w55556+6,6W6\66677/7L7R7c7g7h777858;8|888899!9Y9Z9999:C::::;;e;;;<<<<<>>d>????h?n?????@0@1@K@b@c@@AATAUAaAAAAABBB)BzB|B}BBBBCC<CHCCCCCDDDRDiDDDE E.E5E9E;E<EuEEEEEEFF2FHFFGUGyGGGGGH'HsHxHHHHHHHIXIJJ7J?JDJUJJJK%K?K}KKKL2LpLLLM5M;MOMiMMMMN.NQNlNtNNNOO:OlOOOOPP#PUP{PPPPPPPQKQQR4ReRiRRRS7SSST#TqTTTU U#U=U>UUUUV7V_VeVVVW1WdWjWXX XXYXpXXXXXXXXYYYYZYvYYYYYYZkZqZZZ[[%[H[R[\[b[[[\@\f\\\\\]]1]J]b]~]]]^^^1^G^n^o^^___._D_k_l_____``:`~`aaa)a5aaaaab b#b-bUbnbbbbc&cPctccdddSdYd]d^djdddddeeMeoeeeeeefJfNfOf[f|ffffg)gMggggh hhhh h6hKhbhhhii9i]iij:j@jDjFjGjjjk$kvkkll1lrlvlwllmm"mQmmmmmmnAnUnsnwnxnno o oJojokopppYpppqqq~qqqqqqqrCrrssSs~sstttWtu uuu_uuv5v9v:v~vww^wbwcwwwxExcx~xxxyy!yyyyyz'z^zz{%{){*{a{g{||S|||} }b}}}~/~G~M~[~~~~~~~/a$*4:NkNy+4O=ABh134fUa9:Fi 8<=I./F]yz/Gbz,JPTUa3_sy"UWXFR$%1T @BCt.:qr~  :fz%'([NZqr~>hlmy>? UVbRVWUY@{`de>RbvC5;ObqSg-Rdh"&cdpRS z#@BC=Yu$?Wg28bh;NX\^_l  bgAfjx| Z=-=/5y6<$~Grx(~Odj2@ *0Xacd›&{Þ PxĪ   @hŢ 0SrƑƕƦƨƩ*WpljǢǻmȀȄȒȖ 5jpɿZʩK˛˽HṈx/uΐΖ6vωϚϩ #HkЧк+nѫѺUYZҥkӵUԦlբը n8>׏Cؖ(v]ڂڕڨڻ5Hfۍ FU܁*݆)?Yqނދޘަ(<N`u߈ߛ߫ h%`fPA JPw1J,Oi2u"3G_u`!&'<Nhmny,2_} (:TYZe,Das.NGOUY[\*yG7djMj,?_9HOh:;+DIJ !k<X "?R\`awx Q7? W34^6SFfg+6 K   / h     \ ` a } ~     % s   Z   !'5Qs )z @!lr(} ^z~V\OS0@DE!"[0UV1MOP_lm39MQ1}D A  !,!y!""e"""##h###$"$o$%%a%%&&&V&&'<'k'q'''(>(())6)<)))*2*[*a*++S++,8,,,,---U-[--.I.....//:/R/Y///0@00001 1@1a112E2T2`2j2r2223%3T3d3444*464H4`444444555S5556#6q6667>778#868<889#9t9::K:Q::;@;;;<>$>r>????E?????@@@!@F@a@@@AA[AaABBB%BBBBBC+CyCCCCCDDDdDDDDEE1EKEYEtEEEEEFFBFUFmF}FFFFFFGG7G|GGGGGHHRHhHHHHHHHIYI]I_I`IIIJ*J;J]JcJJK4K:KKKKKL1L7L}LLLLLMM!McMyMMMMMMNNNFNTNUNNNNNNOObOOOP@PPPPQCQxQ|QRR R2R6RRSSnSSST:TTTTUUIUUV0V}VVW W#WqWrWWWWXXXYXXXXY@YYYYZ9ZZ[ [n[[\ \\5\;\\]%]u]]]^7^^_$_t___`9`R`X`f```aa;araaaaaabFbbccccAcccdd:dsddddde<eeeeef2fkfffg6gPgXgbghgghMhhhhhhiHiij2jjkkekll"l(l8l>lllmm;m<m|mmmmn/nsnnno/ooooppjppppq7q~qqqqqrErrrs sWshsnsssstCtbtctuuOuxuuuv'vNvOvvwwwlwx x7xUxVxxxyyyaygyzz*z0zzzzz{6{U{[{{{||T||}&}'}u}}}~~F~L~~>OU9b=N>30iZygbrx ?E0H]z{qwi _aN[.4y?EHIN;67DI.dI06v a.4tWD&rx2{ n V:'(o [hnEK='s@F#)9?8>'qwEFBG+v]$u: y X^ND7gR:: GZqy­B`ÁÇÙ T~ĝĹ2xŦ.qƘƢƨƷƿ(.<QǕǨǿ']cȼBcɚ#?|ʚʸ,Zkˀ˴ Au̡̫̱!lͥ͟͵ͻ  2Ce{Δή#t tOUѥD҄үҵMSӟ<BԝԮԴ*28f՜բ:@Rց q׍Tص5]cټqڳ Jۉە۶$3;EKܤܪܸ$;Ngouݣ8Vw}ޏ޾]߮Y0Y9HWs+:qr$k5?ET\fl| )@Wq?TZ(f<[ +/Mrv;STw&OX^ost5ab /Bc{e `(EKdhiD`txy d9{.N`d8Z%&2\,01#D+O~Lbbfg,;\tyz-z{)   ( 9 I [ n        J N O     T v     > ` d         ? q    59]4r2RVq<[6DRe/=N^p  .<JXft!8Oc(Jn42DR` .Ml .DWx&;IWes"4H[p-23?(;Mav   " p v z {        ! !!'!5!C!Q!^!d!!!!!"""0"C"X"n"""""""##L#P#Q####$%$q$$$%$%(%)%5%%%%%&7&Y&&&&&'['x'''''''(9(^(((()!)%)D)[)n))))))))**-*G*[*l*r***++*+u+{++,8,A,G,H,,,,-->-c---..8.n.../!/H/p/v/w///010i0j0000001 1 1J1`1g1h11111112 2+2B2Y2s2222223%3s3y333474R444455&5<5O5c5w555555566_6e6i6j6u66666666777"7(7I7h77777888/8J8O8P8\899 9 9Z9|99999999::J:L:M:{::;;;;;?;;< <#>6>`>a>>>?/?x????@(@w@AAAeAAAB6BBBBCC.C/CCCCCDDODeDDDDE ERErEtEuEFF+F1FgF}F~FFFFG,G2GHGGGGHH)H3H:H>H?HHHHI,IDIiIIIIIJ'J+J,JJJJJK KK2KEKOKrKKKKKL;LWLXLrLsLLLLLLLMMoMsMtMMNNNN6N8N9NNNOOO8O<OOPPjPPQ/Q3Q~QQR'RnRRRRSSFSST TET]T^TTTU.UsUUUUV V!V%V&VjVVVVVVVWWIWOWWWWX(XoXXXXYY@YAY[Y\YhYYYYYZZZ,Z2Z}ZZZ[)[/[~[[[[\\e\f\\\]]6]]]]]]^^3^H^I^^^_(_j_____`"`(`[`a`aa7akaoapaaab!b"bobubcc(c.crcd d,d@dSdidddeee1eeeeeffUfyfffg<ggh!hqhiiiWiwiiiijjj5j=jJjaj|jjjk kNkYkakgkkklkkkklljllllllm8mhmmmmnn8nYn_nrnvnwnnnnnnooAoiomonozooppWpspppppq&q\q]qwqqr+r,rHrnrrrrs"s#ssst't-t.tFtJtKtWtttttu7uMuuuuvvSvvvwwwwTwZwwxx_xxyyYyyyyz'z/zXz`zdzezzz{{M{~{{{|"|*|S|[|_|`|||}V}}~~L~M~~~~~~~~Ni9\bF"A^q{Lhjk !B{#=C%b ,-x7o<B}ic.4VtuVpvX;BVl~@DeYuv67Cqr_`l0c},I:@a?ptfhi UV,-n/DG#WZ).58h]2A#%&i,p0=Q8<WYZK PQ  /*0NRT1yCa/// 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.jkušv&/// 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.bcmnɀCC6/// The green channel of this color in an 8 bit value. 7j5/// The blue channel of this color in an 8 bit value.׫KUDKiKiKUKVwU9n/// 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().clamp(0, 255)`. /// /// 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. VV(/// 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); /// ```g poz    ܀/// 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.&77/// 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.CKJ-||/// 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.Ɓ /// 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.Ӂ/// 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.ŷ++DLK`/// 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 .JLL/// 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].QYX[cbemlB4DHDH/// 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.DSDZDYDeDlDkI IIw/// Returns an alpha value representative of the provided [opacity] value. /// /// The [opacity] value may not be null.IIIIVJJJ J JIIKKKKKǍJDD/// 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.NfȬȬȱY/// Constructs an empty [Paint] object with all fields initialized to /// their defaults.ȸzʀʄʀ/// 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.ʅ ʌʋ,βL βγικ/'@@UZ$kk}ς&ϓϓϧϬ%ϽϽ&&$)%::MR!ccrw'ЈЈНТ%гг'-!'*88OU'ffzр0ёёѮѴ,( >""K8NS8dd҇wҊҏ<ҠҠҵ: <E3HM<^^ӅsӈӍ:ӞӞӲ2>;(>C:TTyh|ԁ<ԒԒԹԧԼH BK6NS<ddՋyՎՓNդդF'*/>@@iVlֳ%[3׆׆[\bsc "*/'@@UZ'kk؀؅"ؖؖئ,=33ڀUUi/// 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].Mk/// 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.蹁pp/// 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.dф+/// 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.;rNN/// 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.fW../// A mask filter (for example, a blur) to apply to a shape after it has been /// drawn but before it has been composited into the image. /// /// See [MaskFilter] for details.u/// Controls the performance vs quality trade-off to use when sampling bitmaps, /// as with an [ImageShader], or when drawing images, as with [Canvas.drawImage], /// [Canvas.drawImageRect], [Canvas.drawImageNine] or [Canvas.drawAtlas]. /// /// Defaults to [FilterQuality.none].k/// The shader to use when stroking or filling a shape. /// /// When this is null, the [color] is used instead. /// /// See also: /// /// * [Gradient], a shader that paints a color gradient. /// * [ImageShader], a shader that tiles an [Image]. /// * [colorFilter], which overrides [shader]. /// * [color], which is used if [shader] and [colorFilter] are null.v/// A color filter to apply when a shape is drawn or when a layer is /// composited. /// /// See [ColorFilter] for details. /// /// When a shape is being drawn, [colorFilter] overrides [color] and [shader].`^^/// The [ImageFilter] to use when drawing raster images. /// /// For example, to blur an image using [Canvas.drawImage], apply an /// [ImageFilter.blur]: /// /// ```dart /// void paint(Canvas canvas, Size size) { /// canvas.drawImage( /// _image, /// ui.Offset.zero, /// Paint()..imageFilter = ui.ImageFilter.blur(sigmaX: 0.5, sigmaY: 0.5), /// ); /// } /// ``` /// /// See also: /// /// * [MaskFilter], which is used for drawing geometry.n  /// Whether the colors of the image are inverted when drawn. /// /// Inverting the colors of an image applies a new color filter that will /// be composed with any user provided color filters. This is primarily /// used for implementing smart invert on iOS.ٱٵٵ  䩀266<KJ*..: BAՀ9==HTS eiiẃ  <$$0>=쁷   l   *  0 /דrסס     %r**/// Opaque handle to raw decoded image data (pixels). /// /// To obtain an [Image] object, use the [ImageDescriptor] API. /// /// To draw an [Image], use one of the methods on the [Canvas] class, such as /// [Canvas.drawImage]. /// /// A class or method that receives an image object must call [dispose] on the /// handle when it is no longer needed. To create a shareable reference to the /// underlying image, call [clone]. The method or object that receives /// the new instance will then be responsible for disposing it, and the /// underlying image itself will be disposed when all outstanding handles are /// disposed. /// /// If `dart:ui` passes an `Image` object and the recipient wishes to share /// that handle with other callers, [clone] must be called _before_ [dispose]. /// A handle that has been disposed cannot create new handles anymore. /// /// See also: /// /// * [Image](https://api.flutter.dev/flutter/widgets/Image-class.html), the class in the [widgets] library. /// * [ImageDescriptor], which allows reading information about the image and /// creating a codec to decode it. /// * [instantiateImageCodec], a utility method that wraps [ImageDescriptor].******* *** *** **+/++++++++,,/// A callback that is invoked to report an image creation. /// /// It's preferred to use [MemoryAllocations] in flutter/foundation.dart /// than to use [onCreate] directly because [MemoryAllocations] /// allows multiple callbacks.,΁--݀/// A callback that is invoked to report the image disposal. /// /// It's preferred to use [MemoryAllocations] in flutter/foundation.dart /// than to use [onDispose] directly because [MemoryAllocations] /// allows multiple callbacks.---.S.U.UA/// The number of image pixels along the image's horizontal axis.._R..?/// The number of image pixels along the image's vertical axis.....122/// Whether this reference to the underlying image is [dispose]d. /// /// This only returns a valid value if asserts are enabled, and must not be /// used otherwise.7j99с/// The color space that is used by the [Image]'s colors. /// /// This value is a consequence of how the [Image] has been created. For /// example, loading a PNG that is in the Display P3 color space will result /// in a [ColorSpace.extendedSRGB] image. /// /// On rendering backends that don't support wide gamut colors (anything but /// iOS impeller), wide gamut images will still report [ColorSpace.sRGB] if /// rendering wide gamut colors isn't supported..у&00с/// Release this handle's claim on the underlying Image. This handle is no /// longer usable after this method is called. /// /// Once all outstanding handles have been disposed, the underlying image will /// be disposed as well. /// /// In debug mode, [debugGetOpenHandleStackTraces] will return a list of /// [StackTrace] objects from all open handles' creation points. This is /// useful when trying to determine what parts of the program are keeping an /// image resident in memory.366ǁ/// Converts the [Image] object into a byte array. /// /// The [format] argument specifies the format in which the bytes will be /// returned. /// /// Using [ImageByteFormat.rawRgba] on an image in the color space /// [ColorSpace.extendedSRGB] will result in the gamut being squished to fit /// into the sRGB gamut, resulting in the loss of wide-gamut colors. /// /// Returns a future that completes with the binary image data or an error /// if encoding fails.6066666:;;ɀ/// If asserts are enabled, returns the [StackTrace]s of each open handle from /// [clone], in creation order. /// /// If asserts are disabled, this method always returns null.<GG劢/// Creates a disposable handle to this image. /// /// Holders of an [Image] must dispose of the image when they no longer need /// to access it or draw it. However, once the underlying image is disposed, /// it is no longer possible to use it. If a holder of an image needs to share /// access to that image with another object or method, [clone] creates a /// duplicate handle. The underlying image will only be disposed once all /// outstanding handles are disposed. This allows for safe sharing of image /// references while still disposing of the underlying resources when all /// consumers are finished. /// /// It is safe to pass an [Image] handle to another object or method if the /// current holder no longer needs it. /// /// To check whether two [Image] references are referring to the same /// underlying image memory, use [isCloneOf] rather than the equality operator /// or [identical]. /// /// The following example demonstrates valid usage. /// /// ```dart /// import 'dart:async'; /// import 'dart:typed_data'; /// import 'dart:ui'; /// /// Future _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.IKKR/// 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 LLL(3L;L;L(L)L_LLM'MMMMMMMMMMQQ Q Q,Sl%S}S}SSSSSMfNNMMMMMMMMMMMMMMMMMMMMNhNNNNN%NCN,N&N4NBN5N<NAN=NDNjNKNENMNdN^NfSbSSSSSSSSSSSSSSSSSSSNNNN0NNNNNP/PP9/// Returns an error message on failure, null on success.P PPP+QQ PkPlPrPPzPsPPPPPPPPPPPPPQ5dQ:Q:RS]S]k/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).S SSS1SSS"S0S#S*S/S+S2SKS9S3S;S9TTSSL_L`LfLwLgU_[[/// 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].\\\\\\\]]{/// The duration this frame should be shown. /// /// A zero duration indicates that the frame should be shown indefinitely.]^q^q/// 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].^{>_i_i/// 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]._s9__#/// Number of frames in this image._`F`F/// Number of times to repeat the animation. /// /// * 0 when the animation should be played once. /// * -1 for infinity repetitions.`Zaaa//// 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).bbbcccccccccdddcDddccdFqdddFdGdMdkdTdNd\djd]dddidedlddsdmduddddSdddde2{eee2e3e9eWe@e:eHeVeIePeUeQeXee_eYeaee{ee)eeeehހi|i|9/// Returns an error message on failure, null on success.i,iiiii!iHi)i"i1iGi2i9i>i:iAiIigiPiJiRifjjiiiiiiiiiiiiiiijiiij&jj9j9j&j'҆f /// 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]./// 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.Eك99P/// A handle for the framework to hold and retain an engine layer across frames.I&ee/// 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).sI~~}3EFGFa/// This class is created by the engine, and should not be instantiated /// or extended directly.NlNOZ[a~gbo}pw|x/// 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]. ((,Ai/// 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. #"HH/// Determines how the interior of this path is calculated. /// /// Defaults to the non-zero winding rule, [PathFillType.nonZero].T!XXaonyU2/// Starts a new sub-path at the given coordinate.rE/// Starts a new sub-path at the given offset from the current point.. 659 A@HtO/// 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.M UTX `_gq/// 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.' /.2 :9= EDH POWہ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.$ ,+/ 76: BAE MLP XW[ cbjb/// 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)    ЁYYw/// 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.i qpt |{  r̃/// 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. ///Ʒ ƿƾ #)(4CAA/// 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.Ya`s{zʔʜʛʯʵʴʃʉʊʦʿvMMY/// Adds a new sub-path that consists of four lines that outline the /// given rectangle.U [Zd. /// 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.̇ ̖̍̌FF/// 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)M SRX`_ksrЂXѮѮ/// 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.ѹ ހxx/// Adds a new sub-path that consists of the straight lines and /// curves needed to form the rounded rectangle described by the /// argument.ҁ ҈҇Ғv/// Adds a new sub-path that consists of curves needed to form the rounded /// superellipse described by the argument.#21DQ[[/// 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.c ihn vu~Ԍԋԙ///// 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.> DCI QPYgft/// 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.# +*5٩٩j/// Returns a copy of the path with all the segments of every /// sub-path translated by the given offset.ٯ ٷٶ€77k/// Returns a copy of the path with all the segments of every /// sub-path transformed by the given matrix.ANMZ0/// 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.JJ0/// 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.Ra`k qpw }|ই>>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.NTSam,xxO%/// Create a new empty [Path] object. 髀/// Avoids creating a new native backing for the path for methods that will /// create it later, such as [Path.from], [shift] and [transform].{M{|J3V jbbi on 9"8#*/+2:PA;Cpzz >'!/=07<8?iF@Hc]e덀  !'T-(5S6=B>EMUz\V^tnv쫀88G ONR ZY&aabmntzu   8 7!&")19sE?GickNN` hgk srv ~} <  2,488R ZY] edh pos {z&((0 87; CBF NMQ YX\ dcg on v$$4 <;? GFJ RQU ]\` hgk srvw z ('+ 326 >=A IHLTSz{Z  #"& .-1 98<DCZ[fgmsn{|J[[a gfltsJK,4    $#3;:JPO,-394ABINJQYaiqydPuu de>YYjrq~  G=7?  #+*=ED^fey~MSTpNLLemly : 0*2 ~  &%* 218 @?~K\\d jiKLԀ^^g ont |{   L%'B<D f  %$- 54? GFRZYiqpfgmsn{|t \\hut| . -!)/J608r uZZdqp . -$ '/H608{{|%"%&,X2-:W;BGCJQVRYz`ZbƁS    $`*%2_3:?;BINJQYayhbjII\ihn vuy    7g    JI$)%,384;CKsWQY P P n { z              >    o % %                       1o   1 2 = > D a J E R ` S Z _ [ b  i c k  z  z        "         " # ) V / * 7 U 8 ? D @ G O W ~ ^ X ` x r z         l            l m s  y t                   ( '   ) /.7DC                   PaaPQg99  J JKQWR_`glhov{w~u$#1o(opDSS/// 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._V/// 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.#$%$& ,+176SIUghijv|w$;uuh/// Used by [PathMetrics] to track iteration from one segment of a path to the /// next for measurement.(22   ˍ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.""""""" """"""""#"###*#!#,#4#5#=#Z#>#F#G#p#c#r#z#{#+$$ /// 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.,$ ,,,+,2 ,:,9,?,E,D,V,w,,,,->_-I-I-{[-{-{-------7뀯88/// The index of the current contour in the list of contours in the path. /// /// [nextContour] will increment this to the zero based index.88 -ڀ.=.=.J.W.V.\.b.a---. ---. ---.... .+....r.y.y.../F//////F/G/M/s/U/N/]/r/^/e/j/f/m/t//{/u/}////Ձ/////00 0 12)2)2429282F2N2M11111111111111121112[l2`2`2l2q2p2~ 222 2222223ˀ4R4R4d 4j4i4v4{4z4 444 444443334333433333334444@4!44#4̀444445666665555555555555555555556݀667j}777j7k7q77w7r77777777777777<_=&=&/// 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.=5@@@@@/// 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.@ @@@" @(@'@3@C@C@M@Z@Z@AAAA A1A1A=A<AAAAAWAqAqAt A|A{AWAXBZB2B2BB B}_BBB:BBB BBBBBBހBBC C!C!C8C>OCPCPCZ CaC`CgCsCrC>C?CCCC"CCCC CCCDDD .DDD& D-D,D3D?D>D D E[ /// 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, /// ]); /// ```]]] ])]"]+]B]7]D]X]P]Z]n]h]p]]]]^]W/// Construct a color filter that applies the sRGB gamma curve to the RGB /// channels. ^^ ^^)^^+^?^7^A^S^M^U^q^^^^^d/// Creates a color filter that applies the inverse of the sRGB gamma curve /// to the RGB channels. _ ___&__(_<_4_>_P_J_R_n_{_{_________````%`pppppppppppppppppppppppqqqqqq#q@q)q$q1q?q2q9q>q:qAq|qHqBqJqvqpqxqss/// 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.ssssssttatltmtqtm9/// Creates an image filter that applies a Gaussian blur.tst{tzttttttttu$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.vvvww w vwwe!xOxZx[xax[/// 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.xgxtxsx2xxxxxyzzzzz/// 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)).zzzzzz{,"-.4./// 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].5EDDE/// Whether [ImageFilter.shader] is supported on the current backend.j$ww4^::hFhhz|!@++:FGMRNL?QSS?@W@ppWXM<VVY a`<=_  #"1>>HUU_oo>=!!WSnnWX<,,@T  # +*X^^C@+78>C?I>H@aaHIJ'AAD LK'(CIIvBvv? !&+'tHtu>0@II01I ''* 21 (..]L]]pr B""1=>FKGyoFopP@iiPQ_$$t tu[( !66A@YYhtu{|50@QXrru }|XYYYZ`~fan}ow+KK)/// 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.}9/// Creates an image filter that applies a Gaussian blur.g /// 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."!3+5 ,-2-/// 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.3FEWOY/// 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.//// Converts a color filter to an image filter.v0/// Composes `_innerFilter` with `_outerFilter`.!76H@J77o/// The original Dart object that created the native wrapper, which retains /// the values used for the filter.]xx   *)  $+f719\V^66BJIRZY$f  fgmsn{|K% -J.5:6=ELnSMU%%6EDUUV\b]jkrwsz""#)U/*7T8?D@GNSOVx]W_Cz/// Base class for objects such as [Gradient] and [ImageShader] which /// correspond to shaders as used by [Paint.shader].w}~~a/// This class is created by the engine, and should not be instantiated /// or extended directly.[\bsc//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()`.Ϫ@/// 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. ///7!xπρχρ /// 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.ύ ϕϔϞ ϦϥϭϺϹ" !*0E1?D@OUhVdgerxФЉЁyЄЌЛУМЮгдеж\ڄڌڍړڍ/// 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].ڙ ڡڠڬ ڴڳڿ"-,9 BALTS amsۊtۂۉۃ۔ۣۚ۫ۛۦۮ۽۾畇3/// 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. "087Sa`&'JBFGLpvwZ  ]'\(/407?GOV^jdl)C  #10@ EDR`_)*061>?FKGNV^fnv}poo     , 10>LKpqw4}0 $5]<6>\`$#0=<HVUe jiw~\]cnivw~\=/// A shader (as used by [Paint.shader]) that tiles an image.ą/// 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].   lmst)389:;E]**=    /<;=>DLETU\a]dkplszLk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).!_  /// 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).>!Zijtju}|>?EVFckk6W``rs{72z+Ձ//// 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].aVV !  "D)#+iijpxq<<1/// Returns a fresh instance of [FragmentShader]. s s/// 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].                     c q q <       (    퇐农/// 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с/J/I5?????(/// Creates a set of vertex data for use with [Canvas.drawVertices], using the /// encoding expected by the Flutter engine. /// /// The `mode` parameter describes how the points should be interpreted: as /// independent triangles ([VertexMode.triangles]), as a sliding window of /// points forming a chain of triangles each sharing one side with the next /// ([VertexMode.triangleStrip]), or as a fan of triangles with a single /// shared point ([VertexMode.triangleFan]). /// /// The `positions` parameter provides the points in the canvas space that /// will be use to draw the triangles. Each point is represented as two /// numbers in the list, the first giving the x coordinate and the second /// giving the y coordinate. (As a result, the list must have an even number /// of entries.) /// /// The `colors` parameter, if specified, provides the color for each point in /// `positions`. Each color is represented as ARGB with 8 bit color channels /// (like [Color.value]'s internal representation), and the list, if /// specified, must therefore be half the length of `positions`. Each triangle /// is painted as a gradient that blends between the three colors at the three /// points of that triangle. (These colors are then blended with the [Paint] /// specified in the call to [Canvas.drawVertices].) /// /// The `textureCoordinates` parameter, if specified, provides the points in /// the [Paint] image to sample for the corresponding points in `positions`. /// Each point is represented as two numbers in the list, the first giving the /// x coordinate and the second giving the y coordinate. This list, if /// specified, must be the same length as `positions`. /// /// The `indices` parameter specifies the order in which the points should be /// painted. If it is omitted (or present but empty), the points are processed /// in the order they are given in `positions`, as if the `indices` was a list /// from 0 to n-2, where _n_ is the number of pairs in `positions` (i.e. half /// the length of `positions`). The `indices` parameter, if present and /// non-empty, must have at least three entries, but may be of any length /// beyond this. Indicies may refer to offsets in the positions array multiple /// times, or may skip positions entirely. /// /// If the `indices` parameter is specified, all values in the list must be /// valid index values for pairs in `positions`. For example, if there are 12 /// numbers in `positions` (representing 6 coordinates), the `indicies` must /// be numbers in the range 0..5 inclusive. /// /// The `mode` and `positions` parameters must not be null.????????????@@@GGGGGHsHs/// Whether this reference to the underlying vertex data is [dispose]d. /// /// This only returns a valid value if asserts are enabled, and must not be /// used otherwise.DE*E*E5E?E>EOETESE]EjEiExEEEEEEEEDDDDDDDDDDDDDDDEDDEEрFIFIn/// Release the resources used by this object. The object is no longer usable /// after this method is called.FɀGGk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).G9G:G@G]GFGAGNG\GOGVG[GWG^GzGeG_GgN:TT/// An interface for recording graphical operations. /// /// [Canvas] objects are used in creating [Picture] objects, which can /// themselves be used with a [SceneBuilder] to build a [Scene]. In /// normal usage, however, this is all handled by the framework. /// /// A canvas has a current transformation matrix which is applied to all /// operations. Initially, the transformation matrix is the identity transform. /// It can be modified using the [translate], [scale], [rotate], [skew], /// and [transform] methods. /// /// A canvas also has a current clip region which is applied to all operations. /// Initially, the clip region is infinite. It can be modified using the /// [clipRect], [clipRRect], and [clipPath] methods. /// /// The current transform and clip can be saved and restored using the stack /// managed by the [save], [saveLayer], and [restore] methods. /// /// ## Use with the Flutter framework /// /// The Flutter framework's [RendererBinding] provides a hook for creating /// [Canvas] objects ([RendererBinding.createCanvas]) that allows tests to hook /// into the scene creation logic. When creating a [Canvas] that will be used /// with a [PictureLayer] as part of the [Scene] in the context of the Flutter /// framework, consider calling [RendererBinding.createCanvas] instead of /// calling the [Canvas.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].TW-W-W3q/// Creates a canvas for recording graphical operations into the /// given picture recorder. /// /// Graphical operations that affect pixels entirely outside the given /// `cullRect` might be discarded by the implementation. However, the /// implementation might draw outside these bounds if, for example, a command /// draws partially inside and outside the `cullRect`. To ensure that pixels /// outside a given region are discarded, consider using a [clipRect]. The /// `cullRect` is optional; by default, all operations are kept. /// /// To end the recording, call [PictureRecorder.endRecording] on the /// given recorder.W4WEWDWOWVWU'Wt(XX /// Saves a copy of the current transform and clip on the save stack. /// /// Call [restore] to pop the save stack. /// /// See also: /// /// * [saveLayer], which does the same thing but additionally also groups the /// commands done until the matching [restore].Xmm/// Saves a copy of the current transform and clip on the save stack, and then /// creates a new group which subsequent calls will become a part of. When the /// save stack is later popped, the group will be flattened into a layer and /// have the given `paint`'s [Paint.colorFilter] and [Paint.blendMode] /// applied. /// /// This lets you create composite effects, for example making a group of /// drawing commands semi-transparent. Without using [saveLayer], each part of /// the group would be painted individually, so where they overlap would be /// darker than where they do not. By using [saveLayer] to group them /// together, they can be drawn with an opaque color at first, and then the /// entire group can be made transparent using the [saveLayer]'s paint. /// /// Call [restore] to pop the save stack and apply the paint to the group. /// /// ## Using saveLayer with clips /// /// When a rectangular clip operation (from [clipRect]) is not axis-aligned /// with the raster buffer, or when the clip operation is not rectilinear /// (e.g. because it is a rounded rectangle clip created by [clipRRect] or an /// arbitrarily complicated path clip created by [clipPath]), the edge of the /// clip needs to be anti-aliased. /// /// If two draw calls overlap at the edge of such a clipped region, without /// using [saveLayer], the first drawing will be anti-aliased with the /// background first, and then the second will be anti-aliased with the result /// of blending the first drawing and the background. On the other hand, if /// [saveLayer] is used immediately after establishing the clip, the second /// drawing will cover the first in the layer, and thus the second alone will /// be anti-aliased with the background when the layer is clipped and /// composited (when [restore] is called). /// /// For example, this [CustomPainter.paint] method paints a clean white /// rounded rectangle: /// /// ```dart /// void paint(Canvas canvas, Size size) { /// Rect rect = Offset.zero & size; /// canvas.save(); /// canvas.clipRRect(RRect.fromRectXY(rect, 100.0, 100.0)); /// canvas.saveLayer(rect, Paint()); /// canvas.drawPaint(Paint()..color = Colors.red); /// canvas.drawPaint(Paint()..color = Colors.white); /// canvas.restore(); /// canvas.restore(); /// } /// ``` /// /// On the other hand, this one renders a red outline, the result of the red /// paint being anti-aliased with the background at the clip edge, then the /// white paint being similarly anti-aliased with the background _including /// the clipped red paint_: /// /// ```dart /// void paint(Canvas canvas, Size size) { /// // (this example renders poorly, prefer the example above) /// Rect rect = Offset.zero & size; /// canvas.save(); /// canvas.clipRRect(RRect.fromRectXY(rect, 100.0, 100.0)); /// canvas.drawPaint(Paint()..color = Colors.red); /// canvas.drawPaint(Paint()..color = Colors.white); /// canvas.restore(); /// } /// ``` /// /// This point is moot if the clip only clips one draw operation. For example, /// the following paint method paints a pair of clean white rounded /// rectangles, even though the clips are not done on a separate layer: /// /// ```dart /// void paint(Canvas canvas, Size size) { /// canvas.save(); /// canvas.clipRRect(RRect.fromRectXY(Offset.zero & (size / 2.0), 50.0, 50.0)); /// canvas.drawPaint(Paint()..color = Colors.white); /// canvas.restore(); /// canvas.save(); /// canvas.clipRRect(RRect.fromRectXY(size.center(Offset.zero) & (size / 2.0), 50.0, 50.0)); /// canvas.drawPaint(Paint()..color = Colors.white); /// canvas.restore(); /// } /// ``` /// /// (Incidentally, rather than using [clipRRect] and [drawPaint] to draw /// rounded rectangles like this, prefer the [drawRRect] method. These /// examples are using [drawPaint] as a proxy for "complicated draw operations /// that will get clipped", to illustrate the point.) /// /// ## Performance considerations /// /// Generally speaking, [saveLayer] is relatively expensive. /// /// There are a several different hardware architectures for GPUs (graphics /// processing units, the hardware that handles graphics), but most of them /// involve batching commands and reordering them for performance. When layers /// are used, they cause the rendering pipeline to have to switch render /// target (from one layer to another). Render target switches can flush the /// GPU's command buffer, which typically means that optimizations that one /// could get with larger batching are lost. Render target switches also /// generate a lot of memory churn because the GPU needs to copy out the /// current frame buffer contents from the part of memory that's optimized for /// writing, and then needs to copy it back in once the previous render target /// (layer) is restored. /// /// See also: /// /// * [save], which saves the current state, but does not create a new layer /// for subsequent commands. /// * [BlendMode], which discusses the use of [Paint.blendMode] with /// [saveLayer].m m&m%m- m4m3m>Fnznz(/// Pops the current save stack, if there is anything to pop. /// Otherwise, does nothing. /// /// Use [save] and [saveLayer] to push state onto the stack. /// /// If the state was pushed with [saveLayer], then this call will also /// cause the new layer to be composited into the previous layer.n%pp/// Restores the save stack to a previous level as might be obtained from [getSaveCount]. /// If [count] is less than 1, the stack is restored to its initial state. /// If [count] is greater than the current [getSaveCount] then nothing happens. /// /// Use [save] and [saveLayer] to push state onto the stack. /// /// If any of the state stack levels restored by this call were pushed with /// [saveLayer], then this call will also cause those layers to be composited /// into their previous layers.p pppBqq"/// Returns the number of items on the save stack, including the /// initial state. This means it returns 1 for a clean canvas, and /// that each call to [save] and [saveLayer] increments it, and that /// each matching call to [restore] decrements it. /// /// This number cannot go below 1.qrr/// Add a translation to the current transform, shifting the coordinate space /// horizontally by the first argument and vertically by the second argument.r rrr rrr,ss̀/// Add an axis-aligned scale to the current transform, scaling by the first /// argument in the horizontal direction and the second in the vertical /// direction. /// /// If [sy] is unspecified, [sx] will be used for the scale in both /// directions.s sss sssqtJtJR/// Add a rotation to the current transform. The argument is in radians clockwise.tQtYtXte5uu /// Add an axis-aligned skew to the current transform, with the first argument /// being the horizontal skew in rise over run units clockwise around the /// origin, and the second argument being the vertical skew in rise over run /// units clockwise around the origin.u uuu uuuv.v./// Multiply the current transform by the specified 4⨉4 transformation matrix /// specified as a list of values in column-major order.v8vEvDvQxExE/// Returns the current transform including the combined result of all transform /// methods executed since the creation of this [Canvas] object, and respecting the /// save/restore history. /// /// Methods that can change the current transform include [translate], [scale], /// [rotate], [skew], and [transform]. The [restore] method can also modify /// the current transform by restoring it to the same value it had before its /// associated [save] or [saveLayer] call.xXzz/// Reduces the clip region to the intersection of the current clip and the /// given rectangle. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/clip_rect.png) /// /// If [doAntiAlias] is true, then the clip will be anti-aliased. /// /// If multiple draw commands intersect with the clip boundary, this can result /// in incorrect blending at the clip boundary. See [saveLayer] for a /// discussion of how to address that. /// /// Use [ClipOp.difference] to subtract the provided rectangle from the /// current clip.z zzz zzzzzzzzzz;||/// Reduces the clip region to the intersection of the current clip and the /// given rounded rectangle. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/clip_rrect.png) /// /// If [doAntiAlias] is true, then the clip will be anti-aliased. /// /// If multiple draw commands intersect with the clip boundary, this can result /// in incorrect blending at the clip boundary. See [saveLayer] for a /// discussion of how to address that and some examples of using [clipRRect].| }}} }}}})fEE/// Reduces the clip region to the intersection of the current clip and the /// given rounded superellipse. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/clip_rsuperellipse.png) /// /// If [doAntiAlias] is true, then the clip will be anti-aliased. /// /// If multiple draw commands intersect with the clip boundary, this can result /// in incorrect blending at the clip boundary. See [saveLayer] for a /// discussion of how to address that and some examples of using [clipRSuperellipse].Wfeu{zii/// Reduces the clip region to the intersection of the current clip and the /// given [Path]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/clip_path.png) /// /// If [doAntiAlias] is true, then the clip will be anti-aliased. /// /// If multiple draw commands intersect with the clip boundary, this can result /// in incorrect blending at the clip boundary. See [saveLayer] for a /// discussion of how to address that.r xw~ddZ/// Returns the conservative bounds of the combined result of all clip methods /// executed within the current save stack of this [Canvas] object, as measured /// in the local coordinate space under which rendering operations are currently /// performed. /// /// The combined clip results are rounded out to an integer pixel boundary before /// they are transformed back into the local coordinate space which accounts for /// the pixel roundoff in rendering operations, particularly when antialiasing. /// Because the [Picture] may eventually be rendered into a scene within the /// context of transforming widgets or layers, the result may thus be overly /// conservative due to premature rounding. Using the [getDestinationClipBounds] /// method combined with the external transforms and rounding in the true device /// coordinate system will produce more accurate results, but this value may /// provide a more convenient approximation to compare rendering operations to /// the established clip. /// /// {@template dart.ui.canvas.conservativeClipBounds} /// The 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. /// {@endtemplate}}b/// Returns the conservative bounds of the combined result of all clip methods /// executed within the current save stack of this [Canvas] object, as measured /// in the destination coordinate space in which the [Picture] will be rendered. /// /// Unlike [getLocalClipBounds], the bounds are not rounded out to an integer /// pixel boundary as the Destination coordinate space may not represent pixels /// if the [Picture] being constructed will be further transformed when it is /// rendered or added to a scene. In order to determine the true pixels being /// affected, those external transforms should be applied first before rounding /// out the result to integer pixel boundaries. Most typically, [Picture] objects /// are rendered in a scene with a scale transform representing the Device Pixel /// Ratio. /// /// {@macro dart.ui.canvas.conservativeClipBounds} р/// Paints the given [Color] onto the canvas, applying the given /// [BlendMode], with the given color being the source and the background /// being the destination. с/// Draws a line between the given points using the given paint. The line is /// stroked, the value of the [Paint.style] is ignored for this call. /// /// The `p1` and `p2` arguments are interpreted as offsets from the origin. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_line.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_line_dark.png#gh-dark-mode-only)   /// Fills the canvas with the given [Paint]. /// /// To fill the canvas with a solid color and blend mode, consider /// [drawColor] instead. &&`/// Draws a rectangle with the given [Paint]. Whether the rectangle is filled /// or stroked (or both) is controlled by [Paint.style]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_rect.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_rect_dark.png#gh-dark-mode-only)/ 54: A@KŁj/// Draws a rounded rectangle with the given [Paint]. Whether the rectangle is /// filled or stroked (or both) is controlled by [Paint.style]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_rrect.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_rrect_dark.png#gh-dark-mode-only)  H/// Draws a shape consisting of the difference between two rounded rectangles /// with the given [Paint]. Whether this shape is filled or stroked (or both) /// is controlled by [Paint.style]. /// /// This shape is almost but not quite entirely unlike an annulus.  "!( /.9u/// Draws a rounded superellipse with the given [Paint]. The shape is filled, /// and the value of the [Paint.style] is ignored for this call. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_rsuperellipse.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_rsuperellipse.png#gh-dark-mode-only) /// Draws an axis-aligned oval that fills the given axis-aligned rectangle /// with the given [Paint]. Whether the oval is filled or stroked (or both) is /// controlled by [Paint.style]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_oval.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_oval_dark.png#gh-dark-mode-only)  ɂ)/// Draws a circle centered at the point given by the first argument and /// that has the radius given by the second argument, with the [Paint] given in /// the third argument. Whether the circle is filled or stroked (or both) is /// controlled by [Paint.style]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_circle.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_circle_dark.png#gh-dark-mode-only)  {{c/// Draw an arc scaled to fit inside the given rectangle. /// /// It starts 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. If `useCenter` is true, the arc is /// closed back to the center, forming a circle sector. Otherwise, the arc is /// not closed, forming a circle segment. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_draw_arc.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/canvas_draw_arc_dark.png#gh-dark-mode-only) /// /// This method is optimized for drawing arcs and should be faster than [Path.arcTo].  ՁӀ/// 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]).  /// 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].   ف/// 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.  Ճ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.    *[/// Draw the given picture onto the canvas. To create a picture, see /// [PictureRecorder].Iǃ/// 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. /// 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]. 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].#0/7 >=H;AA/// 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.NXWalkv }|P''/// 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. /// /// The method takes a list of [Rect] objects that each define a piece of the /// [atlas] image to be drawn independently. Each [Rect] is associated with an /// [RSTransform] entry in the [transforms] list which defines the location, /// rotation, and (uniform) scale with which to draw that portion of the image. /// Each [Rect] can also be associated with an optional [Color] which will be /// composed with the associated image part using the [blendMode] before blending /// the result onto the canvas. The full operation can be broken down as: /// /// - Blend each rectangular portion of the image specified by an entry in the /// [rects] argument with its associated entry in the [colors] list using the /// [blendMode] argument (if a color is specified). In this part of the operation, /// the image part will be considered the source of the operation and the associated /// color will be considered the destination. /// - Blend the result from the first step onto the canvas using the translation, /// rotation, and scale properties expressed in the associated entry in the /// [transforms] list using the properties of the [Paint] object. /// /// If the first stage of the operation which blends each part of the image with /// a color is needed, then both the [colors] and [blendMode] arguments must /// not be null and there must be an entry in the [colors] list for each /// image part. If that stage is not needed, then the [colors] argument can /// be either null or an empty list and the [blendMode] argument may also be null. /// /// The optional [cullRect] argument can provide an estimate of the bounds of the /// coordinates rendered by all components of the atlas to be compared against /// the clip to quickly reject the operation if it does not intersect. /// /// 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) { /// 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.6 =<GZYiut΍ΌΘΤΣβιθ ۚ/// 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. -:9DPO[gfu|{ 鞁8ꇀ/// Draws a shadow for a [Path] representing the given material elevation. /// /// The `transparentOccluder` argument should be true if the occluding object /// is not opaque. /// /// The arguments must not be null.  Oq***78IHSZY!H쾀??Qihv ~}      -oKK  93-5Vbbj pov-  vw񧀹/?>LVUd  ! )(3 ;:FVUgqpdekqlyzuuu  32%*&-4c;5=]W_  "#)V/*7U8?D@GOW^X`{u}H  ppw ~  7 6 %!(08^?9AXRZ   *+1^72?]@GLHOW_f`h~xk{klrxsꀍ{{|  & .-HNM6<=[ځtt     +*&,b82:XRZ "!/  (99KZYion()|ll"5 4!(-)06Z=7?v 334:l@;HkIPUQX_d`gmtnv̀ !22!"\\vJ& (p rr}   5 4$ '/6`=7?ZT\   i    ! )(0 87?ON`jiijpvq~|Z |}ڀ==HXWeon +}  }~   ,  4 3 =  E D M  U T _  g f r                  Q            Q R X  ^ Y f  g n s o v ~          +  2 1 8  ? > E  L K    t t                ;    :      $ , 4 < b H B J     " ! 0  7 6   ƀIIa"wv                 7Ɓ  ہffu }|   /. (0T<6>   &%- 43)):BAHPOV ^]iyxE       %-,<DCSYXgwv &4BP^lzx    !'c-(5b6=B>ELQMT\dkem⁩    *&&6 >=HPOV^]dts2  > & .-8@?L TS_gft|{  #,384AO]ky5DFFT [Za gfntsx ~56 }J!! ! !!!!!!!!!!!"""" "("'"4 "<";"G"O"N"\"d"c"r""""""""  } ~ !f   !b            !!!!-!;!I!W!g!!n!h!p"ˀ"""""""#S######S#T#Z##`#[#h##i#p#u#q#x#########G###$ $ $ $$##%+%<%<%G%R%Q%\%j%i%q %x%w%+%,%%%%& & &&!& &( &/&.%%&'k'k'|'''''' '''''&&&';''' ':''''''%'-'4'<'Y'C'='E'''(( ( (( ((* (1(0''()5)5)H)R)Q)_ )d)c)r)))))(((((((((((((((((((()#))) ))))) )))))*** **&*%*1*=*<*K*R*Q*_ *f*e))1܄111 222222/2<2;2F2R2Q2]2i2h2w2~2}2 22116l7\7\ 7l7|7{7777777 777777778 888 8%8$838A8@6l6m6s7*66y67&666666666666667 77+7G727,748R8c8c8n 8t8s8y 888888888R8S9999999 999999999999W999#9V9$9+909,939:9?9;9B9J9R9X9~9d9^9f9K::99:<<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.<%=5=5/// A callback that is invoked to report a picture creation. /// /// It's preferred to use [MemoryAllocations] in flutter/foundation.dart /// than to use [onCreate] directly because [MemoryAllocations] /// allows multiple callbacks.=B>U>U/// 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.CDpDp/// 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.DE\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.>cD?? /// 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.? ??? ???C C 6/// 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}C CCC! C&C%C1CCn/// Release the resources used by this object. The object is no longer usable /// after this method is called.EuEEEǀFiFwFxFyFx/// This class is created by the engine, and should not be instantiated /// or extended directly. /// /// To create a [Picture], use a [PictureRecorder].LZL_L_LkLuLLLuLvMvMMMvMwMMMMMMMMMMMMMMMMMMMMFFFF FFF FFFFHAHHH HHH HHHHHHAHBHHHHPHIHXH~HYH`HeHaHhHpHxHHHHHH5III III I#I"HHJ.JJJ JJJ JJJJJJ.J/J5JjJ;J6JCJiJDJKJPJLJSJ[JcJkJJrJlJtJՀJJJJKLKLKk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).KKLLLLLLLLLLLL9L%LL'N +NNN N N9UQQԃ/// 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].QRRR/// Creates a new idle PictureRecorder. To associate it with a /// [Canvas] and begin recording, pass this [PictureRecorder] to the /// [Canvas] constructor.RÁTPTPu/// 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.UUUU2UUVYCYRYRV4VVVVV(aVzVzV(V)V/VEV5V0V=VDV>VFVhVMVGVOVŁVVVVXYYY$Y4Y3XXXXXXXXXXXXXXYXXXY^LYqYqY^Y_YZ Z T/// A single shadow. /// /// Multiple shadows are stacked together in a [TextStyle].ZP[[[p/// 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.[([[[[[[[[[[[[[[[[\ \\\/\b\)\\,\1 \h,\y\y\\&\\\\'\\] ]] ]#]"]"]0].]3]8#]I]I]W]U]Z]_&]p]p]]]]^A^A/// Color that the shadow will be drawn with. /// /// The shadows are shapes composited directly over the base canvas, and do not /// represent optical occlusion.^K4_y_y/// 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._i__O/// The standard deviation of the Gaussian to convolve with the shadow's shape.araan/// The [blurRadius] in sigmas instead of logical pixels. /// /// See the sigma argument to [MaskFilter.blur].opGooopoq_|aah/// Converts a blur radius in pixels to sigmas. /// /// See the sigma argument to [MaskFilter.blur]. ///a& a.a-b$d4d4/// 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.dee[/// Returns a new shadow with its [offset] and [blurRadius] scaled by the given /// factor.e e(e'eii/// 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}i iii iiiiiknl3l3/// Linearly interpolate between two lists of shadows. /// /// If the lists differ in length, excess items are lerped with null. /// /// {@macro dart.ui.shadow.lerp}l<lKlJlMl\l[l^lflenynnn nnnynzpuppppptMLt`t`tMtNtuXuX/// 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 uuuuuu uu~ ~~~~~~~ON~~1/// The length, in bytes, of the underlying data.~ЁYYy/// Whether [dispose] has been called. /// /// This must only be used when asserts are enabled. Otherwise, it will throw.ugv3v3^/// Creates a copy of the data from a [Uint8List] suitable for internal use /// in the engine.vAvLvKwGwwr/// Create a buffer from the asset with key [assetKey]. /// /// Throws an [Exception] if the asset does not exist.wwwzgzzi/// Create a buffer from the file with [path]. /// /// Throws an [Exception] if the asset does not exist.{ { { |b|||||||||b|c|i||q|j|y||z||||||||}i}i}x}}}}}||}}*} }}})}}}#}+}T}2},}4}~~~!~)~(~2~B~A}}}}}}}}}}}}}}}}낣/// 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). & %$ 'J.(0k00/// 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.Dl{||/// 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`.  y  d/// The width, in pixels, of the image. /// /// On the Web, this is only supported for [raw] images.{e/// 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./cH/// Creates an image descriptor from encoded data in a supported format.  /// 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)./// 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.qXXnopow/// 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`.    /.  tyyx4xy97MM9:L&& %T-&5S6>EJFMU|\V^ԁ[[izy   B"$rhh ' & %!(W/)1QKSt(( bpbcnou{vփ( < ;$ '/6=rICK̀Zց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. B01213 98B HGSI2/// A string containing details about the failure.iO/// If available, the stack trace at the time [Picture.toImageSync] was called.B""LfOWW/// 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.X8Y!Y!/// 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)Y+HZpZp4/// 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)ZxM[[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)]_a_a/// 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._mbbx/// 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)b ddf/// 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)dg'g'y/// 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)g2iio/// 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)iłgl%l%E/// 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)l1]nn;/// 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)n;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)oӃOss,/// 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)s'Vvuvu'/// 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)':ZZ$/// 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)f{ׁ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)恑nny/// 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)|UU/// 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.cśU/// 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.ہ/// 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)pp/// 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)~OO/// 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)wkk/// 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].skԂD/// 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.˂NNd/// 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.]{ׅ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].h==/// 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.F/// 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}Eт&/// 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.ہ\\r/// 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.e++/// 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.5hI/// 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.LLg/// 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.[Y7/// 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./// 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./// 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.<> 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], /// }; /// } /// ```"<", the Wikipedia page on PNG. /// * , the PNG standard."D?"">/// The format of pixel data given to [decodeImageFromPixels]."#i#i/// 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.#v$G$G/// 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.$T,%u%u/// 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]./// Determines the winding rule that decides how the interior of a [Path] is /// calculated. /// /// This enum is used by the [Path.fillType] property.FF/// 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: R0{{/// 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.M恄/// 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.ssk/// 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 operation$/// 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 operation1Á}/// 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.8{994/// Styles to use for blurs in [MaskFilter] objects.9\99쀋/// 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._22/// 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)!|Y/// 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)ZZ/// 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)P  w/// Defines how a list of points is interpreted when drawing a set of triangles. /// /// Used by [Canvas.drawVertices].QaaE/// Draw each sequence of three points as the vertices of a triangle.o[K/// 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`%J/J//// Defines how a list of points is interpreted when drawing a set of points. /// /// Used by [Canvas.drawPoints] and [Canvas.drawRawPoints].J=KK/// 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]).L瀛M{M{/// Draw the entire sequence of points as one line. /// /// The lines are stroked as described by the [Paint] (ignoring /// [Paint.style]).MNNx/// Defines how a new clip region should be merged with the existing clip /// region. /// /// Used by [Canvas.clipRect].NBNHNH5/// Subtract the new region from the existing region.NWBNN6/// Intersect the new region from the existing region.o t puu" *)ۆ|  l$#& .-CGGZfe((; @?T9pTYTYTd TlTkT9T:T@TQTAj?rlrl/// 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.rrrrrrrrrrrrrsՊ||+/// 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.|2|C|B|N|T|S|b|h|g|w|}|||~x/// 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#('7<;:pp0/// 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.- 21/// 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.     +*8 >=ION]cbrxwGqGGGGGGGGdpp…’‘)):GF )76Ʃ$ƵƵ  hrr|||&2ssB/// A variant of `_futurize` that can communicate specific errors."%d%%+/// Signature for [Image] lifecycle events.% %%TmTT1/// Callback signature for [decodeImageFromList].U UUs]tt/// 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.:Ml::-/// Signature for [Picture] lifecycle events.:::id4/// Generic callback signature, used by [_futurize].π=/// Generic callback signature, used by [_futurizeWithError].(((;>=E NMV/// 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]o<΀-FyC4ӄb^mop 3ˇ jy{| 7vxyLj܊Ck $t DHTfnrdhvzǐ/ې8>io _Ւۓ!nٓ:ɔޔLM+;ARXfޖ#sy $=Xr͘ޘߙ%+xԙCIGH7NTyƝCIڝY.JKr/0Utuɠ͠ΠOhǡ#g#)t WŤ?֦ &9ԧ%o§#$]cԩ <=pvǩ()`ƪǫ9gh٬GMجޭ)wϭDNcvȮϮ6\w¯5װ `Ա#$m/U 6zDzzzz{{{g{{{||O|~||}#}t}}}~2~a~g~~~~b7V\$%tXcd>ms7= lyzC Y<BRX'S`av|"(w,2Rio n{|8&ntMu.4}TZjp8ipq*z%+m2KQ9nt#q39gm}3LZ\]QEA|*r+A^y=ef;CD|Ems T:n?|QIp(Zbc>)23v5!'uaesw GYL#tY_ m~u{%5;7L2Yab3q{}~ ,2}%r 9ABntDJh]u{#AD]ºo@ĉĥ zŀPƤSpNJnjǍ8LȔȪȵȶNɌɒ0xʔ5X˦S̞;͊͏0AFΎΏΰ-XπϪ'PuР%S~ѲQҍ KӋAԿ QՑ-opֱ8Yuאב׿-X؃,2Jc٪ٮٯIpڴڸڹ!"[aہۇۗ۝\bܪܿ qMމސTߙ(SY=^djgFJK+/0SxD#'(Jl(.`|]abEKD 8267\89j W{Y_kw}Aa_cd;QP:lhnrsek^bc8>tz6~\oy8BJ]g(.F SY]^A[m Kl+Iw#N 6       8         7 R n      C K t     _ i x      %+[;x <}%bz ^b:lp `i `3@BCsH[g-134v)qMXYy _$QWlr *1KV^h~ 5  !!!n!z!!!!":"A"C"D"""#4#g#s#t#$$E$Q$R$$%8%s%%%%%%&!&%&e&i&&&'"'q'((N(\(`(()B)F)T)X)**;****++++>+X+\+]+~+++++,A,,,,- --\----...I.\.].....//M/S///00[00001%1Q1g11111112=2C2222233336333334!41474|4555e5~566g67757c7g7h7778E8q8w899G999::0:>:^:l::::::;M;o;u;;< <>`>>???l???@4@J@P@@@@@@@A+AjAAAABBfBBCCC<CDCJClCCDDYDDDDE5EeEkEEEEEFF FF-FPFVFqFwFFFFGGG G&GkGGGHHHGHHI)I2I8IWIIIIJJJlJKKUKKL%L&L2L\L^L_LyLLMMMeMMMMNNNNlNNNO&OsOOOP PP P(P,P-PiPQQQ3QFQ^QjQQQR1RiRpRRRRRS SMSiSjSSSSSTT6T8T9TSTtTTTTUUUNURUUUUV?VVWWGWKWWWWWXX9XXXY:YYYzYYYYYYYYZ:ZzZ[[[n[[[[[\A\]\c\\\\]+]1]~]]]]^^^c^x^z^{^^^___=_Z_q_____``<`W`X````a!a'ahaaab b0b6bbbbbcc cUcpcuccccccddCdDdddddde/e0eeeeef.fXfmfffffgNgXgggghhUhbhmhuh}hhhhhhiiiiiijj#j$j0jjjjjk kZkkkl!lolllm@mmn"n5n9nnoomop pYpppq+quqrrrRr^rrrrrrs5s_sksssssssstKttu uuduuuvAvvvvw6wwx!xrxy yEyIyyz-zizmzzzzz{C{{||0|L|`|u||||} }(}l}}}~~~!~i~p~u~w~x~~~~;e{fF!k:FJosY)u}XNprsKl)-y#)xHN;39%s79:$kC|QU V5j R&v6G[p<@A29:U:BHIX %ALr=MQ= DOP:@y6K_eu{Bhn $*:q~i,2'./ciCIY_*GY b9^prs1KLX9=HL>w>?gm ,`5RvwEF7den)*mTUc&'l gh7~X*R OsyG‹DJÏfīıIōŴźNƚƠƳ:@AǐdȲ?EɈ#:Uoʐʫ/Fabˤ*x̓̔X͙#gsyU[?Ѐ5Z`ѧaqҏҐ ABӈӎ)TԖԗY_լ(qrַ Nג׭׽׾[z؀23s٢ٿ0WXڍړ0{ۺ`ܲIݗݥK^d޴<߅߱1$*v \/|O/|h Z0jlm  X  Rxyk|$(^_k;_qu(:>$(stwxWXdGHT%)*/F\abn3W3EIfz9Zu.DTdt&8<au;w{|HIUq8JN _cd);Ne|LJxy"#|7Rz{59/WMqu  < @ j         . / ;                , T e i j     2 X     MNZo"GH;hlmyM]-39=>]cAGNTcO`)-~Z^eCUo!<o g  *Q   V  !!!e!""P""""##]####$$`$$$$$%:%%%&&&2&8&&''l'''(I(((() ) )\)))*%*=*C*x*~**+7+;+<+++,,_,,,,,-;-=->-y----.-.o.p...///?/C/D///00#0N00011:1M1Z111122X2Y2223;3B3p333344>4B4`4r444444445%5p5w55556+6,6W6\66677/7L7R7c7g7h777858;8|888899!9Y9Z9999:C::::;;e;;;<<<<<>>d>????h?n?????@0@1@K@b@c@@AATAUAaAAAAABBB)BzB|B}BBBBCC<CHCCCCCDDDRDiDDDE E.E5E9E;E<EuEEEEEEFF2FHFFGUGyGGGGGH'HsHxHHHHHHHIXIJJ7J?JDJUJJJK%K?K}KKKL2LpLLLM5M;MOMiMMMMN.NQNlNtNNNOO:OlOOOOPP#PUP{PPPPPPPQKQQR4ReRiRRRS7SSST#TqTTTU U#U=U>UUUUV7V_VeVVVW1WdWjWXX XXYXpXXXXXXXXYYYYZYvYYYYYYZkZqZZZ[[%[H[R[\[b[[[\@\f\\\\\]]1]J]b]~]]]^^^1^G^n^o^^___._D_k_l_____``:`~`aaa)a5aaaaab b#b-bUbnbbbbc&cPctccdddSdYd]d^djdddddeeMeoeeeeeefJfNfOf[f|ffffg)gMggggh hhhh h6hKhbhhhii9i]iij:j@jDjFjGjjjk$kvkkll1lrlvlwllmm"mQmmmmmmnAnUnsnwnxnno o oJojokopppYpppqqq~qqqqqqqrCrrssSs~sstttWtu uuu_uuv5v9v:v~vww^wbwcwwwxExcx~xxxyy!yyyyyz'z^zz{%{){*{a{g{||S|||} }b}}}~/~G~M~[~~~~~~~/a$*4:NkNy+4O=ABh134fUa9:Fi 8<=I./F]yz/Gbz,JPTUa3_sy"UWXFR$%1T @BCt.:qr~  :fz%'([NZqr~>hlmy>? UVbRVWUY@{`de>RbvC5;ObqSg-Rdh"&cdpRS z#@BC=Yu$?Wg28bh;NX\^_l  bgAfjx| Z=-=/5y6<$~Grx(~Odj2@ *0Xacd›&{Þ PxĪ   @hŢ 0SrƑƕƦƨƩ*WpljǢǻmȀȄȒȖ 5jpɿZʩK˛˽HṈx/uΐΖ6vωϚϩ #HkЧк+nѫѺUYZҥkӵUԦlբը n8>׏Cؖ(v]ڂڕڨڻ5Hfۍ FU܁*݆)?Yqނދޘަ(<N`u߈ߛ߫ h%`fPA JPw1J,Oi2u"3G_u`!&'<Nhmny,2_} (:TYZe,Das.NGOUY[\*yG7djMj,?_9HOh:;+DIJ !k<X "?R\`awx Q7? W34^6SFfg+6 K   / h     \ ` a } ~     % s   Z   !'5Qs )z @!lr(} ^z~V\OS0@DE!"[0UV1MOP_lm39MQ1}D A  !,!y!""e"""##h###$"$o$%%a%%&&&V&&'<'k'q'''(>(())6)<)))*2*[*a*++S++,8,,,,---U-[--.I.....//:/R/Y///0@00001 1@1a112E2T2`2j2r2223%3T3d3444*464H4`444444555S5556#6q6667>778#868<889#9t9::K:Q::;@;;;<>$>r>????E?????@@@!@F@a@@@AA[AaABBB%BBBBBC+CyCCCCCDDDdDDDDEE1EKEYEtEEEEEFFBFUFmF}FFFFFFGG7G|GGGGGHHRHhHHHHHHHIYI]I_I`IIIJ*J;J]JcJJK4K:KKKKKL1L7L}LLLLLMM!McMyMMMMMMNNNFNTNUNNNNNNOObOOOP@PPPPQCQxQ|QRR R2R6RRSSnSSST:TTTTUUIUUV0V}VVW W#WqWrWWWWXXXYXXXXY@YYYYZ9ZZ[ [n[[\ \\5\;\\]%]u]]]^7^^_$_t___`9`R`X`f```aa;araaaaaabFbbccccAcccdd:dsddddde<eeeeef2fkfffg6gPgXgbghgghMhhhhhhiHiij2jjkkekll"l(l8l>lllmm;m<m|mmmmn/nsnnno/ooooppjppppq7q~qqqqqrErrrs sWshsnsssstCtbtctuuOuxuuuv'vNvOvvwwwlwx x7xUxVxxxyyyaygyzz*z0zzzzz{6{U{[{{{||T||}&}'}u}}}~~F~L~~>OU9b=N>30iZygbrx ?E0H]z{qwi _aN[.4y?EHIN;67DI.dI06v a.4tWD&rx2{ n V:'(o [hnEK='s@F#)9?8>'qwEFBG+v]$u: y X^ND7gR:: GZqy­B`ÁÇÙ T~ĝĹ2xŦ.qƘƢƨƷƿ(.<QǕǨǿ']cȼBcɚ#?|ʚʸ,Zkˀ˴ Au̡̫̱!lͥ͟͵ͻ  2Ce{Δή#t tOUѥD҄үҵMSӟ<BԝԮԴ*28f՜բ:@Rց q׍Tص5]cټqڳ Jۉە۶$3;EKܤܪܸ$;Ngouݣ8Vw}ޏ޾]߮Y0Y9HWs+:qr$k5?ET\fl| )@Wq?TZ(f<[ +/Mrv;STw&OX^ost5ab /Bc{e `(EKdhiD`txy d9{.N`d8Z%&2\,01#D+O~Lbbfg,;\tyz-z{)   ( 9 I [ n        J N O     T v     > ` d         ? q    59]4r2RVq<[6DRe/=N^p  .<JXft!8Oc(Jn42DR` .Ml .DWx&;IWes"4H[p-23?(;Mav   " p v z {        ! !!'!5!C!Q!^!d!!!!!"""0"C"X"n"""""""##L#P#Q####$%$q$$$%$%(%)%5%%%%%&7&Y&&&&&'['x'''''''(9(^(((()!)%)D)[)n))))))))**-*G*[*l*r***++*+u+{++,8,A,G,H,,,,-->-c---..8.n.../!/H/p/v/w///010i0j0000001 1 1J1`1g1h11111112 2+2B2Y2s2222223%3s3y333474R444455&5<5O5c5w555555566_6e6i6j6u66666666777"7(7I7h77777888/8J8O8P8\899 9 9Z9|99999999::J:L:M:{::;;;;;?;;< <#>6>`>a>>>?/?x????@(@w@AAAeAAAB6BBBBCC.C/CCCCCDDODeDDDDE ERErEtEuEFF+F1FgF}F~FFFFG,G2GHGGGGHH)H3H:H>H?HHHHI,IDIiIIIIIJ'J+J,JJJJJK KK2KEKOKrKKKKKL;LWLXLrLsLLLLLLLMMoMsMtMMNNNN6N8N9NNNOOO8O<OOPPjPPQ/Q3Q~QQR'RnRRRRSSFSST TET]T^TTTU.UsUUUUV V!V%V&VjVVVVVVVWWIWOWWWWX(XoXXXXYY@YAY[Y\YhYYYYYZZZ,Z2Z}ZZZ[)[/[~[[[[\\e\f\\\]]6]]]]]]^^3^H^I^^^_(_j_____`"`(`[`a`aa7akaoapaaab!b"bobubcc(c.crcd d,d@dSdidddeee1eeeeeffUfyfffg<ggh!hqhiiiWiwiiiijjj5j=jJjaj|jjjk kNkYkakgkkklkkkklljllllllm8mhmmmmnn8nYn_nrnvnwnnnnnnooAoiomonozooppWpspppppq&q\q]qwqqr+r,rHrnrrrrs"s#ssst't-t.tFtJtKtWtttttu7uMuuuuvvSvvvwwwwTwZwwxx_xxyyYyyyyz'z/zXz`zdzezzz{{M{~{{{|"|*|S|[|_|`|||}V}}~~L~M~~~~~~~~Ni9\bF"A^q{Lhjk !B{#=C%b ,-x7o<B}ic.4VtuVpvX;BVl~@DeYuv67Cqr_`l0c},I:@a?ptfhi UV,-n/DG#WZ).58h]2A#%&i,p0=Q8<WYZK PQ  /*0NRTdart.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].V