argb colorSpace _floatToInt8valuealphaopacityredgreenblue 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 addPolygonaddRRectaddPathextendWithPathcloseresetcontainsshift transform getBoundscombinecomputeMetrics _constructor_clone _getFillType _setFillType_arcTo _arcToPoint_relativeArcToPoint_addRect_addOval_addArc _addPolygon _addRRect_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_initSrgbToLinearGammadata nativeFiltersigmaXsigmaYtileMode _modeStringradiusXradiusY innerFilter outerFilter _initBlur _initDilate _initErode_initColorFilter _initComposed_debugDisposedclamprepeatedmirrordecal _initLinear _initRadial _initConical _initSweep_validateColorStops_initWithImage _debugName fromAsset_shaderRegistry_reinitializeShader_uniformFloatCount _samplerCount_initFromAssetfragmentShader_kEmptyFloat32List_floatssetFloatsetImageSampler_setImageSampler_validateSamplers triangles triangleStrip triangleFan_initpointslinespolygonsave saveLayerrestorerestoreToCount getSaveCount translatescalerotateskew getTransformclipRect clipRRectclipPathgetLocalClipBoundsgetDestinationClipBounds drawColordrawLine drawPaintdrawRect drawRRect drawDRRectdrawOval drawCircledrawArcdrawPath drawImage drawImageRect drawImageNine drawPicture drawParagraph drawPoints drawRawPoints drawVertices drawAtlas drawRawAtlas drawShadow _recorder_sorted_saveLayerWithoutBounds _saveLayer_scale _getTransform _clipRect _clipRRect _clipPath_getLocalClipBounds_getDestinationClipBounds _drawColor _drawLine _drawPaint _drawRect _drawRRect _drawDRRect _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_instantiateCodecmessagestack_ _rectIsValid _rrectIsValid_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 _ImageFilterShaderTileMode_encodeWideColorList_encodeColorList_encodePointList_encodeTwoPointsGradient ImageShaderFragmentProgramFragmentShader VertexModeVertices PointModeClipOpCanvas _NativeCanvasPictureEventCallbackPicture_NativePicturePictureRecorder_NativePictureRecorderShadowImmutableBufferImageDescriptor_NativeImageDescriptor _Callback_CallbackWithError _Callbacker_CallbackerWithError _futurize_futurizeWithErrorPictureRasterizationExceptiondartuiboolRecthasNaNRRectOffsetdxisNaNdy Float64ListlengtheverydoublevalueisFiniteRadiusxy withValuesalpha clampDoubleaint _fromARGBCsRGBfromRGBO _fromRGBOCfromARGBround Deprecatedfromredgreenblue colorSpace transformmathpow extendedSRGBHSVColormaterialColors transparentCurves elasticInOutAnimationController _lerpDoublergboverrideObject identical runtimeTypehashStringtoStringAsFixedsrcdstclear saveLayerrestore blendModesrcOverdstInsrcOutsrcIndstOutdstATopdstOversrcATopplusmultiplyscreenoverlaymodulate hardLight colorDodge colorBurncolor exclusion difference luminosityhue softLight saturationblurBackdropFilternonelowmediumhigh filterQualitymatrix drawImage drawImageRect drawImageNine drawAtlas strokeCapAsquare strokeWidthbuttdrawPath drawPoints strokeJoinstrokeMiterLimitstyle drawCirclehardEdge antiAliasantiAliasWithSaveLayer isAntiAliasbuffer 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 _getValue32matrix4fromLTRB forceClosedgetTangentForOffsetcossinatan2computeMetricslineTomoveTo IterableBaseIterator RangeError _nextContourcurrentContourIndexisClosedcloseaddRectstartWithMoveTo nextContour maskFilter drawShadow colorFilterfromColorFiltermodelinearToSrgbGammasrgbToLinearGamma_type _listEquals_matrix_color _blendModehashAll _kTypeMode _kTypeMatrixfromList_kTypeLinearToSrgbGamma_kTypeSrgbToLinearGamma ImageFilteredpushBackdropFilterpushImageFilterclampsigmaXsigmaYtileModeradiusXradiusYMatrix4 diagonal3data innerFilterinner outerFilteroutermirrorrepeateddecaldilateerodecomposed_shortDescriptionshaderpaintingGradientLinearGradientRadialGradient BoxDecorationlinearradiali Int32ListNoSuchMethodError colorStopsfocal focalRadiuspi startAngleendAngle isNotEmptyUripath encodeFull microtask _fromAssetMap_initFromAsset debugNamefragmentShader_uniformFloatCount _samplerCount drawVertices triangles triangleStrip triangleFannew 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 Exceptionķ7(Zv}tT<΀-FzE6Մd`oqr/pΆ݆߆]lnoڇ܇݈e,0`dpՊ EMQAmq}ʌn !%37Ў+|̎Ҏ+QxAou-F_3Ւ )Sfw6FkR_ȕɕ)BΖ7]ڗ#)q9NlЙ֚'I[\͚Κ,KLr̛қ(NuҜ'Fdhi2ab'MN˟̠LMˠ̡+1ҡ:Ƣߢ?E0=ekop-Hx|}ƦLܧ bͧfڨ%)*{156tѪ8<=Dbխ9kЭ֮ag=ְ kU &uʳ6Kbwóڳ 9Tε ImxζfGҸLsȸθNgy3^gݺ,wļ;DJNOͽ;?@Loֽ %=Um@1@{@@@A<AAB)BtBBC CWCCDBDDE!EpEEEF#FpFG GYGGGHHHhHHIGIIJ6JQJUJcJgJJJK#K6K|K}KKLL LfLoLpLLMMMMTMZMMMMNNMN^NdNNOOOOLOROOPPPbPPPPQQ>QDQmQsQQR&R,R{RRRRSGSSSSST:TTTTTUGUPUQUUV6V<VvV|VWW!WmWsWWWX)X|XXYYYdYYZZZlZvZwZ[[c[i[[[\H\N\\\] ] ]Y]y]]]^#^o^^^__ _j_u_v___`4`:``aa aVagamaaab(b\bbbbccccWc]ccdd$drdxdeehefffcfkflffg gZg`gggh1h7hhhhhi=iYiiiijjj[jjjk kOkUkklllnlmmmcmmmmmnnUnfnnoo+oNoOooopplpppq.q{qqrrr%r+rdrrs&s1s2sssssttctmtntttu+u<uBuuuuuv:vvvww,w-wwwxxNxTxxxy y6y<yyz#zPzVzz{{${{{{{|!|p||||}}}X}^}}}}~~!~"~k~q~~~&7=u{8FLPV,2"o 06*0y>D 4 &,uZ`pv+,}4"28n e~JP3~;?<:>$(u=v2A>EF V 06)6<L"$%IM[_$dj%s9Ot}~+1GlrhUIO ]n7=BNTdj!SY^jp+/F7}7~ k$q8@AmsCItou6<m$*}PAG55OQRYoz{QW=YkcOT STuEo˜:eÎùCwħRŒPƎDDŽVȨ45vɸɹ:UVʄH˜˝(os̓ 4x|}͵%EK[aΧ &nσϗ5ЄНXoхїѭEҊfӁӅӆӾLRԔ6W]ժc֗`כן>BC؇؍ص#'Jo٭ٱٲ;x~ڻ@bۭۨ۬$VrRVWݘݞ:@zހޞޤ z߀9-v'+Pu,-x^KouMS_kq5URVW.rDB,^ Z`de W]PT)/ek{'o%\exAKSfp 17"&N[aefIcuSt2P~*U=> =Xt&IQzeo~+1a"A~ B +hdh@rvf n   d    7 D F G w          ! L ^ j       0 4 6 7 y   , t    P[\| b'TZou-4NYak8 q}=DFG7jvwHTU;v$(hl%tQ_cEIW[>"A[_`D   _    !!!L!_!`!!!!""O"U"""##]####$'$S$i$$$$$$$%?%E%%%%%&&&!&&&&&''+'1'v'( ((_(x())a)**/*]*a*b***+?+k+q+,,A,,,- -*-8-X-f------.G.i.o..///g/z//////0"0q011Z11222f2223.3D3J33333334%4d444455`556 6666>6D6f6677S77778/8_8e88888899 9'9J9P9k9q9999:::: :e::::;;A;;<"<+<1N>>???+?U?W?X?r??@ @@^@@@@@AAAeAAABBlBBBCCCC!C%C&CbCDDD,D?DWDcD{DDE*EbEiEEEEEFFFFbFcFFFFFFG/G1G2GLGmGGGGHHHGHKHHHHI8IIJJ@JDJ}JJJJKK2KKKL3LRLsLyLLLLLLLM3MsMMNNgNNNNNO:OVO\OOOOP$P*PwPPPPQ QQ\QqQsQtQQQQQR6RSRjRRRRRSS5SPSQSySSSTT TaTTTUU)U/UzUUUUVVVNViVnVVVVVVWW<W=WWWWWWX(X)XXXXXY'YYYZ.Z8ZqZZZ[&[2[:[B[[[y[[[[[\.\~\\\\\\]V]X]Y]|]]^^m^^^_4_O__``K````aIaab2b~bccfcccd:dddee#eHe\epeeeef$f0fNfnffffffgg`gggh)hwhhiiVibifiijKjjk7kkl llXllm.m2mmmmmnnSnnnoo%o:oXo]oooop1pYpcppppq.q5q:q<q=q`qdqqrrOrrrs*s@sDsst+tltu u[uuuv0vzvvvw ww4w8wwxxFxsxxxxy:yByyzzEzjzzzzzzz{{5{7{8{{{{{||1|m||||||||}E}}}}}~D~\~~~~m X YCms  SW;L59x|aM $nD`t %Bvz ^nBlv*Nt~"Hd#'^rb%&hnOZ\] !U[5;KQ=CFS=r{S5;+1zi+|4 0BDE*r R]I_9?2by}~$HI~_l 67z@?&'l5>9: Pu{Y*o$rs!EK]a8}_ lr ]1 U"<]x./qE`a%f4@F"(˜ LMßíó'-tĨĩ.>\]ţũDoƱƲ7tzCȌȍ#$iɭ)vʕʛ.MNˎ˽Krs̨̮K͖,{dϲfyWѠ06ҭұҲ28ӄjԴ=Պ ]֪=׊&vhٜ٢>xz{`ۥ۸۹Z܀܁܍sݒݓ&ބްޱ޽#YZfcno{'Z[gABN89E  MmT +Fa|%)*=>Je!EDi-MMNZvFW[\OP\WXdFGSKX@A j%2tz~/0h!Dnrs-QPQ]  a+/0uFGS04B :;D Mfg=YpqFbhT134|cg L j n   ) i      $ V X Y    ( ) D g h t     ^ .7=W[\h|\`AeiR/mh8>"AXY!oK#=>]^*wHc#$yVx|}  P  L h {        !X!!!""{"""###r##$${$$$%%/%0%[%`%%%&#&3&P&V&g&k&l&&&'9'?'''''((%(](^(((()G))))**i***+++++ +m+++,$,7,,,,---h-....l.r....///+/</A/B/\/s/t/00/0e0f0r0000001 1=1>1J11111112:2]2i22223 3)353s33344+4P4T4V4W4444444565M5e555566*6L6c66667 7777b77888+8@8V8i8q889B99999: :):r::;;";s;y;;<><>Z>>>??J?R?q???@@@B@t@|@@@@A#AqAAAB;BHBsBCCUC[CCD'DbDzDDDDEE`EuE{EEEF)F\FFFFGJGGGGHHH/HFHPHZH`HrHxHHHHII#I?I[IeIoIuIJJJMJpJJJJJJK|KKKKLLCLiLsL}LLLLMMMdMtMMMMNNN^NyNNNNOOO,OKOjO}O~OOP'PpPPPPQ+Q,QUQjQQQQQRRERcRzRRRSSRSvSSSTTTTT6TbTvT|TTTUU@UDUEUQUfUUUUVV%V:VQVVVVW(WLW~WWWWWWWWX XDX]XXXYY8YGYYYYYZ.Z2ZZ[[5[p[[[\\#\$\H\\\\]]G][]y]}]~]]^^$^(^)^w^^^^_____` `;`<```a/aYa[a\aaaaabAbbcc/cLcccddwddde"eheeeefCffg%g)g*gngtgh h>hhhhiSiWiXiiij.jSjjjjkMkkkl lClclelfllllm#m$mEmmmmmnnn)nmnnnznnnno o:olopoqo}oooppdpep|ppppqqqHqIqdq|qqrr0r6r:r;rGrrrrrrssEsYs_sssssstt;t=t>tptttttu.u:uquru~uuuv v vv<vhv|vvvvvvww8w:w;wlwwwwwx(x4xkxlxxxxxyyyy4y`ytyzyyyyyyz/z1z2zezzzzz{{Z{f{{{|||!|w|x|||||}}A}n}r}s}}}}}~~R~~$`  X-12v$TXY;l;?@r<@At+ ?|}!"|!^_"#q2gAG.23C!4D(AE-}*.W[4~BLf ]!'OXYfOU!D mB TZ%~j7q5Tsw@aevxy8VySu(9;<y},}g*0KQP0Nv'TCW"(waSu{h/2MS39k2Px%8ev, " '-xV§@Ñ2TZĪSŵ}ƃ"EKǘ+=PjȈȰ 1Wɓɦ~ʒ  Iij^_'<Vu͉ͦͧGezΏΩμ 4QR  :YmІНйк1QѩѱѾJRX\^_ҝ-|Jԙԧԭ:gmճPm։"2Rאזת6TZ^_k~ؓأاب مAfڮ,0Z۪4H|ܙܸܾ  #$ioݸJ`ޞ,vߣ-H}0FNRS,zABw<|6<@A]|}u134gk8JE#$@A6m6Upz=hN/5\@QW!=ABx~l=AB%`l0?@134CPQh15a(v%t]IdhLnrSEh: OU"p o  ? E   7    g w }    9 ?   - y     6=|${$E)8DNVis 6Dx OU> U ZAm V6!m? P`u   t    !@!x!!"5"""""""# #b#h#l#m#$$)$]$$$$%O%r%%%%%%%%%&B&g&&&&'-'3''''''(((((((())Y)j)))***c*i*+++%+&+`+f+++, ,,,J,P,,,,,-- --/-=-u------...M...//o///0)0r000171;1a1e122N22333i334 4)4/4x455_5556<6R666677#737977778 8q89 999j9: :Q:::;<;B;f;l;<>U>>?? ?j?????@@C@l@@@AAA"A(AwABB1B7BEBrBBBC4CkCCCCCD'DmDDDDEEcEEEF.FgFFFFFG-G~GGGGH%H+HyHIIcIJJKJJK8KSKYKiKoKKL)L?LlLmLLLMMM`MMMNN`NNNNOKOOOOP#PhPPPQQ%Q&QvQQQR>RRRRRSSStSSST1TTTTUUXUUUV)VEVKVVW;WhWWWWWXHXNXXXY2Y[YaYYZZZiZZZZ[/[5[[\\Y\Z\\\]]]b]h]^^+^b^c^__Y_j_p_``i`aaZaabMbibobbcMcccd2dYd_dmddde#eBe|eeeeef0f|fg+g;gAgghhh^hhii&iCiDiij:j@jjk2kkl(l{lllllm*mvmmmnn_nenno$ooooopBp]p|p}pqqqyqrrrcrrssssttTtztttuuMuuuv2vvvwwhwwwxMxxxy4y:yzyzzez{{2{8{|| |x||} }}[}}}}~H~~~*v|6$r Z>+,s_lr IOA+wDJ'-=C<B+u{IJFK/za(y>$}$\bRH;kV>> "K^u}Fd$X6|2u,2@U+agFg'C0^oEy%p $Bq!"flia6<L5  I\s{Dbie'N~`(T]gm|Zm"(WXCy!'4"KeHt&[am´~ÈÎÝåïõ-N}Ĥ;<ʼnŏ wyz )džnjZ^_>?ɛ<abnʼ,U~˧/I̶̅̒!%&͈X9TUaOno{[\ѻNvw҃ BbӠӦӿBCOnԟԻ$XYeH֖045״#$0k؍ؿXYeٝ,klxږ,01ۇ G܍ܑܒ-.:oݝݡݢ:;G|ޜ޼ }"OST-Mg  <^bcoFJK%&2\|06:;12>xL)ISm&ABNx!  [}%W%YB[e !8Ps#Ed=uC|^dhi=Qj4NmnzLBf%~IOqr~9=>+Ix )K,25tu .dH|  &      : @ D E Q r     = `     5 ; Y    r x   ,v}~3LezPTU&'3uwx.2fj5N Ajk@a ZS:@ a-YZ&,zK}:V\#W]s  J T ^ e i j !!!*!W!o!!!!!""R"V"W"""# ##5#E#]#p#z#####$"$f$$$$$$$$%%%"%%%%&&*&+&7&Y&[&\&&&'1'5'['_''(?(()")R)V))* *J****++%+i++,,,h,,,,--Q----..B.C.......//"/f/l////0E000001#1]1^1x1y1111112 2/2I2O22233F3L333344-444455,5S5z55556-6P6e6f6667E77778 8 8?8E8x8~899T99999::>:?:::;;E;K;;<'F>>>>?(?r?@ @W@@A8A>AAAABB&B;BJBkBsBBBBBC CBCCCCCCCCD)D/DRDDDDDEE3EnEEEF F1F7FnFFFFFFFFGGG2GRGtGGGGGGH;HHHHIIII\IIIIJ,JaJbJJJKKGKHKKKKL6L\LbLcL{LLLLLLMMMlMMMMN2NGNNNO,OJONOOOOOPPKPPQ QSQQQRR0R\RdRRRRRRS SGSSSTTTWT_TTTTTU-U.UUUV5VVVVVVWWW,W2WWWWWWXXXXXnXXXY.Y{YZZ4ZGZWZvZZZZZZ[[5[[[[[[\>\V\w\\]]X]r]x]^^Z^^^^___>_a_b__`:`l``````a4aEaFaqawaaaaab4bMbNbbbcc7cIcJcccddRdcdidde(e*e+eeeeef9ffffgLggghhh7hJhphwhhhhiLiPiQijjjpjjkkkhkkkkkkkl(lElFlRlllllmmm+mnmom{mmmmn?nrnnnnnno o;oXooppIpOppppppq qqqzqqqrfrhrirrrs sUsVsssst,t-tntttu/uDuGuuuvvvvv#vWvZvvvvvw)w.w5w8wwxxxhxxyy]yyyyzz2zAzzzzzzzz{{{#{%{&{i{{|,|p|||}}0}=}Q}}}}}}~~~8~<~W~Y~Z~~~K PQ  /*0NRT0ݷΎ/// An immutable 32 bit color value in ARGB format. /// /// Consider the light teal of the Flutter logo. It is fully opaque, with a red /// channel value of 0x42 (66), a green channel value of 0xA5 (165), and a blue /// channel value of 0xF5 (245). In the common "hash syntax" for color values, /// it would be described as `#42A5F5`. /// /// Here are some ways it could be constructed: /// /// ```dart /// Color c1 = const Color(0xFF42A5F5); /// Color c2 = const Color.fromARGB(0xFF, 0x42, 0xA5, 0xF5); /// Color c3 = const Color.fromARGB(255, 66, 165, 245); /// Color c4 = const Color.fromRGBO(66, 165, 245, 1.0); /// ``` /// /// If you are having a problem with `Color` 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 /// Color c1 = const Color(0xFFFFFF); // fully transparent white (invisible) /// Color c2 = const Color(0xFFFFFFFF); // fully opaque white (visible) /// ``` /// /// [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 `package:test`'s /// `isSameColorAs`. /// /// See also: /// /// * [Colors](https://api.flutter.dev/flutter/material/Colors-class.html), /// which defines the colors found in the Material Design specification. /// * [`isSameColorAs`](https://api.flutter.dev/flutter/flutter_test/isSameColorAs.html), /// a Matcher to handle floating-point deltas when checking [Color] equality.5:/// Construct an 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 `const 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).; @NRS]qkt~x/// Construct a color with normalized color components. /// /// Normalized color components allows arbitrary bit depths for color /// components to be be supported. The values will be normalized relative to /// the [ColorSpace] argument.$/!5AKL][_pnr(lmu/// 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.v{} ŕˀ֕ו   156@NSZo`mgaiqvb~/// 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. ĘŘȘ˘Θט쀻  (.CAEXVeZc][_gvtx{y}X/// The alpha channel of this color. /// /// A value of 0.0 means this color is fully transparent. A value of 1.0 means /// this color is fully opaque.^3"/// The red channel of this color.5$/// The green channel of this color.4#/// The blue channel of this color. @?"/// The color space of this color.ǜ܀/// A 32 bit value representing this color. /// /// The bits are assigned 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.Мk.沥/// 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]./// 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.Qw/// Returns an alpha value representative of the provided [opacity] value. /// /// The [opacity] value may not be null.BV\_ gBCžRJ /// 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.fqvY/// Constructs an empty [Paint] object with all fields initialized to /// their defaults.}DEI/// 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.J Q,wL wx~'$0BG&Xlq%‚•š&«¿&%!(7<'Mbg%xËÐ'áõû-*'+?E0Vsy,Ċģĩ(ĺ>8)L<OT<eŌzŏŔ:ťŹ< <#J8MR:cƈwƋƐ2ơƾƱ>:>-AF<W~lǁdžHǗDzB<)P>SXNiȢȇȥȪFȻ>.1x%ɉɛ 3K !'8("''0EJ"[kͷ,=3 '˟i/// Whether to apply anti-aliasing to lines and images drawn on the /// canvas. /// /// Defaults to true.uy̅ ̋Ϗ/// 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].סץׯ׺Ek/// Whether to paint inside shapes, the edges of shapes, or both. /// /// Defaults to [PaintingStyle.fill].)-3Bٴ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. $0 8ۯf/// 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.ʀYƄ+/// 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.-1<H/rB/// 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.褀 YW!/// 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.볂g/// 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].VZhw}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].(<,8Fhf/// 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.l#0 6Xrfh/// 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!XA/// The number of image pixels along the image's horizontal axis.!bR!?/// The number of image pixels along the image's vertical axis.!!!$%/// 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.*d,ˁ/// 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.!Ӄ&#Ӂ/// 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.&)/// 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.)0))))-.À/// 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./:ߊ/// 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.<>R/// Returns true if `other` is a [clone] of this and thus shares the same /// underlying image memory, even if this or `other` is [dispose]d. /// /// This method may return false for two images that were decoded from the /// same underlying asset, if they are not sharing the same memory. For /// example, if the same file is decoded using [instantiateImageCodec] twice, /// or the same bytes are decoded using [decodeImageFromPixels] twice, there /// will be two distinct [Image]s that render the same but do not share /// underlying memory, and so will not be treated as clones of each other.> >?!3?4?!?"?X?}@'@@@@@@@@DDD%Fe%FvFFFFF@fA @@@@@@@@@@@@@@@@@@@@AhAxAAAA<A%AA-A;A.A5A:A6A=AcADA>AFA]AWA_FbFFFFFFFFFFFFFFFFFFAAA0AAAAC(C9/// Returns an error message on failure, null on success.C CC+DCdCeCkCCsClC{CC|CCCCCCCCCCD.dD3EFVk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).FFF F*FFFF)FF#F(F$F+FDF2F,F4F9GFF?X?Y?_?p?`H_N/// 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(); /// } /// ```NOOOÀ/// 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].OOOOOP{/// The duration this frame should be shown. /// /// A zero duration indicates that the frame should be shown indefinitely.PQj/// 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].Qt>Rb/// 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].Rl9R#/// Number of frames in this image.RS?/// Number of times to repeat the animation. /// /// * 0 when the animation should be played once. /// * -1 for infinity repetitions.SSaT//// 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.TU/// 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).UUVVVVVVWWVDW VVW?qWW?W@WFWdWMWGWUWcWVW]WbW^WeWWlWfWnWWWWSWWWX+{XX+X,X2XPX9X3XAXOXBXIXNXJXQXXXXRXZXzXtX|XXXX[\A9/// Returns an error message on failure, null on success.\O,\t[[[\ [[[\ [[\[\\\,\\\\f\\\\\\\\\\\\\\\\\\\\\j\\\|j} /// 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].}Ł#~d~s/// 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.~u ~{~ ~~~~~~~~~~~~~~~~~~~~~~́/// 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 P/// A handle for the framework to hold and retain an engine layer across frames.&7/// 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).EIP}a/// This class is created by the engine, and should not be instantiated /// or extended directly. l !,-3P94AOBINJQpXRZX/// A complex, one-dimensional subset of a plane. /// /// A path consists of a number of sub-paths, and a _current point_. /// /// Sub-paths consist of segments of various types, such as lines, /// arcs, or beziers. Sub-paths can be open or closed, and can /// self-intersect. /// /// Closed sub-paths enclose a (possibly discontiguous) region of the /// plane based on the current [fillType]. /// /// The _current point_ is initially at the origin. After each /// operation adding a segment to a sub-path, the current point is /// updated to the end of that segment. /// /// Paths can be drawn on canvases using [Canvas.drawPath], and can /// used to create clip regions using [Canvas.clipPath].i/// Creates a copy of another [Path]. /// /// This copy is fast and does not require additional memory unless either /// the `source` path or the path returned by this constructor are modified. /// Determines how the interior of this path is calculated. /// /// Defaults to the non-zero winding rule, [PathFillType.nonZero].&!*3AKU2/// Starts a new sub-path at the given coordinate.rE/// Starts a new sub-path at the given offset from the current point.  tsO/// Adds a straight line segment from the current point to the given /// point.zt/// Adds a straight line segment from the current point to the point /// at the given offset from the current point. '* 29q/// Adds a quadratic bezier segment that curves from the current /// point to the given point (x2,y2), using the control point /// (x1,y1). /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_quadratic_to.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_quadratic_to_dark.png#gh-dark-mode-only)    '߀/// Adds a quadratic bezier segment that curves from the current /// point to the point at the offset (x2,y2) from the current point, /// using the control point at the offset (x1,y1) from the current /// point.     ")r/// Adds a cubic bezier segment that curves from the current point /// to the given point (x3,y3), using the control points (x1,y1) and /// (x2,y2). /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_cubic_to.png#gh-light-mode-only) /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/path_cubic_to_dark.png#gh-dark-mode-only)      =/// Adds a cubic bezier segment that curves from the current point /// to the point at the offset (x3,y3) from the current point, using /// the control points at the offsets (x1,y1) and (x2,y2) from the /// current point.     " *- 5 FPj/// Returns a copy of the path with all the segments of every /// sub-path translated by the given offset. ݀Rk/// Returns a copy of the path with all the segments of every /// sub-path transformed by the given matrix.\iu 0/// Computes the bounding rectangle for this path. /// /// A path containing only axis-aligned points on the same straight line will /// have no area, and therefore `Rect.isEmpty` will return true for such a /// path. Consider checking `rect.width + rect.height > 0.0` instead, or /// using the [computeMetrics] API to check the path length. /// /// For many more elaborate paths, the bounds may be inaccurate. For example, /// when a path contains a circle, the points used to compute the bounds are /// the circle's implied control points, which form a square around the circle; /// if the circle has a transformation applied using [transform] then that /// square is rotated, and the (axis-aligned, non-rotated) bounding box /// therefore ends up grossly overestimating the actual area covered by the /// circle.e0/// 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.m|ц ьђ јҴLM/// 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.\bo{qچI%/// 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ܠ܃܄J1ۻVۻۼjjq wA"*@+273:BXICK!p݂!"(F/)7E8?D@GqNHPkemݕ ݕݖݜݢݝݪݿݫݲݷݳݺޔޛޣޥޭ()/\50=[>EJFMU]ނd^f|v~޳3B JM U޳޴޿!\\]hioߜup}ߛ~߅ߊ߆ߍߕߝߤߞߦ߼߶߾s  3 2!$,4a;5=[U]/A IL TW _b jq - 58 @C KN Vqr}~]    '* 25 =]^ijpvq~D    ! ), 4DEPQW]Xefmrnu};    ;<GHNTO\]dielt|    !f'"/e07<8?GOW_gnhp &.9?Ӂdk sx   -, (.R5/7LFN݁K /7JPek$%AZv,  #,2,-394ABINJQYaiqy@tQiq@A븁KTow  B<6> &퐀  # +/ 7= EPai oPQـV_ gl tx  D%'>8@ ^    !(0;C^_ekfst{|Rtcn| RSʀ*6CJ PZrkt {Z[u(2?ISZb hm u}IJ$) 14 <C   CDJPKXY`eahotpwg'6 <A IQ_  # +2  239}?:G|HOTPW^c_fnv~ox$A*%2@3:?;BfICK`Zboz uuv|} $$+ 19 AD LSdn{STq| D%C&-2.5=E_LFN2g239XA:IWJQVRYs`Zb #06 ;IuaqwIJ(D/// 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. #, 2=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.#+4 <\/// Position of the tangent. /// /// When used with [PathMetric.getTangentForOffset], this represents the precise /// position that the given offset along the path corresponds to.ih/// 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]).s+/// 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.4# //// 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. k v w x y                   $  ; ?   Y h/// Used by [PathMetrics] to track iteration from one segment of a path to the /// next for measurement. (      + 7 F Y j  j k^o^_k/// 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. &<5>FGMjNVW|s~+ /// 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.AN!/// 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.@S`,!/// 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.5=j/// 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.v ~ q([&'/// The index of the current contour in the list of contours in the path. /// /// [nextContour] will increment this to the zero based index.'' &&'-X3.;W<DKPLSYw`Zb+0=E !o!z!!! !!!4!!!!3!!!#!!&!-!5!V!<!6!>!_!!!! !! !!!!### #### ## ###### #M## ##L##!#&#"#)#1#8#@#H#N#p#U#O#W#〿###$%%%!$$$$$$$$$$$$$$%$$$$$$%ဉ%&n}&&n&o&u&&{&v&&&&&&&&&&&&&&+ |,*/// 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.,9////// 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./ /$// /5/D/T/^/k000$010B0N1<1110h00 00h0i1@Z1S1@1A1_11:11 111122< 2B2Y2_O2q2{ 2222_2`222"222 33 3"3+(3=3G 3N3T3`3+3,4W4]4:44/// Row-major.4 4444 55 555#44@kBN/// A description of a color filter to apply when drawing a shape or compositing /// a layer with a particular [Paint]. A color filter is a function that takes /// two colors, and outputs one color. When applied during compositing, it is /// independently applied to each pixel of the layer being drawn before the /// entire layer is merged with the destination. /// /// Instances of this class are used with [Paint.colorFilter] on [Paint] /// objects.BuXD:D;D?/// Creates a color filter that applies the blend mode given as the second /// argument. The source color is the one given as the first argument, and the /// destination color is the one from the layer being composited. /// /// The output of this filter is then composited into the background according /// to the [Paint.blendMode], using the output of this filter as the source /// and the background as the destination.D@ DGDMDX DqDjDsDDDDDDDDDDшELLL7/// Construct a color filter from a 4x5 row-major matrix. The matrix is /// interpreted as a 5x5 matrix, where the fifth row is the identity /// configuration. /// /// Every pixel's color value, represented as an `[R, G, B, A]`, is matrix /// multiplied to create a new color: /// /// | R' | | a00 a01 a02 a03 a04 | | R | /// | G' | | a10 a11 a12 a13 a14 | | G | /// | B' | = | a20 a21 a22 a23 a24 | * | B | /// | A' | | a30 a31 a32 a33 a34 | | A | /// | 1 | | 0 0 0 0 1 | | 1 | /// /// The matrix is in row-major order and the translation column is specified /// in unnormalized, 0...255, space. For example, the identity matrix is: /// /// ```dart /// const ColorFilter identity = ColorFilter.matrix([ /// 1, 0, 0, 0, 0, /// 0, 1, 0, 0, 0, /// 0, 0, 1, 0, 0, /// 0, 0, 0, 1, 0, /// ]); /// ``` /// /// ## Examples /// /// An inversion color matrix: /// /// ```dart /// const ColorFilter invert = ColorFilter.matrix([ /// -1, 0, 0, 0, 255, /// 0, -1, 0, 0, 255, /// 0, 0, -1, 0, 255, /// 0, 0, 0, 1, 0, /// ]); /// ``` /// /// A sepia-toned color matrix (values based on the [Filter Effects Spec](https://www.w3.org/TR/filter-effects-1/#sepiaEquivalent)): /// /// ```dart /// const ColorFilter sepia = ColorFilter.matrix([ /// 0.393, 0.769, 0.189, 0, 0, /// 0.349, 0.686, 0.168, 0, 0, /// 0.272, 0.534, 0.131, 0, 0, /// 0, 0, 0, 1, 0, /// ]); /// ``` /// /// A greyscale color filter (values based on the [Filter Effects Spec](https://www.w3.org/TR/filter-effects-1/#grayscaleEquivalent)): /// /// ```dart /// const ColorFilter greyscale = ColorFilter.matrix([ /// 0.2126, 0.7152, 0.0722, 0, 0, /// 0.2126, 0.7152, 0.0722, 0, 0, /// 0.2126, 0.7152, 0.0722, 0, 0, /// 0, 0, 0, 1, 0, /// ]); /// ```LL LLLLLLLLLMMM MMMMW/// Construct a color filter that applies the sRGB gamma curve to the RGB /// channels. MMMMMMMMMMMMNNNNd/// Creates a color filter that applies the inverse of the sRGB gamma curve /// to the RGB channels. NNNNNNNNNNNNOO$O.O?OMOaOlOvOOOO!OPP),P:PTPr,PPUGU[UGUHUVUUPVPPPQ.Q<T :T#T& T.T T W-WWWYj[@D/// A [ColorFilter] that is backed by a native DlColorFilter. /// /// This is a private class, rather than being the implementation of the public /// ColorFilter, because we want ColorFilter to be const constructible and /// efficiently comparable, so that widgets can check for ColorFilter equality to /// avoid repainting.[r[~[[[ [ [[[[[[[[[[\&\2\3\9\: \@ \N\T\~\c\U\\\]\f\q\r\Հ\\\\ \ ]]]C]]]]] ]+],]]]]] ] ]]]]]]]]]]^+^o/// The original Dart object that created the native wrapper, which retains /// the values used for the filter.^]_ ^^^^^^^^^^^^^^___ __ ____%_P_+_&_3_O_4_;_@_<_C_J_Q__X_R_Z_y_s_{_``&`3______________`___`>``>`?`E`b`K`F`S`a`T`[```\`c``j`d`l````̀a?`````````````a-```a'a!a)a\c>/// 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.ccccc΁ddd"9/// Creates an image filter that applies a Gaussian blur.d%d-d:dBdO"dYd5dJdcdkdldׁ&e}e~e/// 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.eeeeeef'fff/// 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.ffffffg,*h!h"h(/// 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.h)h6hU2hdhshhiZjhjijp/// 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)).jsjjjlElPk$klf`lllHllllllllm!mmG@m_mnmzm{mmmmLmmmosQoosotm@mmmnMn2nn npnn nnpnqoȄtopapppp,p3pBpIpXpgptp~pppp>pppppqpqKqVr=SrTr=r>s<tssq@q qqrTrrrrss srrt>tDtrEtrtttttttttt@uuuu u&u+u'utIuutuuv>w vvu0@uIu0u1uJuuuvv)v, v4vvw;wAwnDwnwwwwwwwwww?wxxxx x%x!xnHxxnxoy>zyyx*@xCx*x+xIxxxyy!y$ y,yyz2z8zgNzgzzz}zzzzzzz{B{.{={I{J{R{W{S{s{{{}uF}}u}v{\@{u{\{]|_|*|||z|| ||z|{}~)/// 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.&nos9/// Creates an image filter that applies a Gaussian blur.t #/// 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.4#܀/// 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.[IJP/// 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.Qezr|B//// Converts a color filter to an image filter.Cz0/// Composes `_innerFilter` with `_outerFilter`.%o/// The original Dart object that created the native wrapper, which retains /// the values used for the filter.]"   "#)]/*7\8?D@GOW^e_g؀O[cks   =719$$%+W1,9V:AFBIQXz_YaĀ1BQaabhnivw~=z/// Base class for objects such as [Gradient] and [ImageShader] which /// correspond to shaders as used by [Paint.shader].ia/// This class is created by the engine, and should not be instantiated /// or extended directly.y/// Whether [dispose] has been called. /// /// This must only be used when asserts are enabled. Otherwise, it will throw.5(/// 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()`.TJ?L^dɐumepxɇɏɈɚɟɠɡɢZY+#*$,G3-5l  .9 >GUlms˷ytˁ˶˂ˉˎˊˑ˙ˡ˩˰˸˿˹aD - 5BO\j{ ̀͏͝abh̼niv̻w~̵̖̞̦̮̃̆̎̽̾ͩW k s΀ ΈΕΝί η & +:HͩͪͰͶͱ;ͿE$&Td&3@N_ ds{ЌДУбTU[Ϸa\i϶jqvryρωϑϙϠϨϰϸϿϹм_lҨ=/// A shader (as used by [Paint.shader]) that tiles an image.Dž֋֖/// 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].֗ ֤֞ ֲ֮ ּopvևw   &+,-.aErabت]تثرطزؿ ٘٧ ٯٵٺپ  ]"\#*/+29>:AHOV^كe_gھk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).hioڌup}ڋ~څڊچڍڬڔڎږ͌e۵/// 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).! !)] =>$<%-C7hCDJ[K2&+ށ//// 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].ދޓDPdla"I*#2H3:?;BJsQKS櫀1/// Returns a fresh instance of [FragmentShader].4%/// 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].GUVWXis|&4C<\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`.  D\D\Q\\^2/// 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.^; ^A^G^M^Z^ei-Z/// 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}iFlʃ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}lm/// Paints the given [Color] onto the canvas, applying the given /// [BlendMode], with the given color being the source and the background /// being the destination.m mmmmʁo/// 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)o oo oo ooʀpd/// Fills the canvas with the given [Paint]. /// /// To fill the canvas with a solid color and blend mode, consider /// [drawColor] instead.pn pupq`/// 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)q qr r rsj/// 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)s ss ssHt́/// 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.t tt tt tuv/// 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)v vv vv͂)xŁ/// 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)xxx xx xx|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].'4; BL;E/// 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.R\epz +/// 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.5 <Sf $4/// 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.A HbođĞĸ - 4>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.2 8= DJR\bzKƅʁ>!VDa   (. 6abhȭnivȬwȆȋȇȎȖȞȦȮȵȯȷdodepqwʔ}xʅʓʆʍʒʎʕʺʜʖʞʴʮʶׁ -  '(͘Ͱ()/\50=[>EJFMU]͆d^fhs {΀ ΈΌ ΔΚ ΢Ωι98 "*2:VA;CuI  71+3W WXcdjώpkxύyπυρψϏϾϖϐϘϸϲϺ^ M'!)GAIq   qr}~ЄбЊЅВаГКПЛТЪвйглH#) 15 >^  ^_eђkfsёt{р|уыѓѹњєќѳѭѵ쀉^em$ #%L,&.F@Hy   yz҅҆ҌҹҒҍҚҸқҢҧңҪҲҺһ!+8{!,9E]EFր4BO"  [lu {Ղ Պդժ[\Ւ՘ՙշ7      78>׈D?LׇMTYU\dlt|׃׉ײא׊ג׬צ׮&7A HOU&'bƀ'2?EK[vlu {فه[\ٔՀ<FSX^  *nno3ۗ۫۸34:_@;H^IPUQX`ۅgaiÀܔ%ܔܕܛܡܜܩܿܪܱܹܶܲ0pAK RXc01ݤ $* /ݤݥݫݱݬݹݺ=NW _b jm t=> ߍߗ ߟߢ ߪ߭ ߵ߸   _ ^!(-)08@HPX`{gaiZ  VVW]c^klsxt{   %    b#a$+0,3;CKS[c~jdl '- 4㧀*0@MWev   efMMNTZUbcjokrz(9B HM T()=    &=>DJERSZ_[bjrz4EPXZ bi p45\hprz| ,+ %-J4.6   !́tc s {    ,665 !'/7Q>8@DxU^ di pDE1;HM]jt  킁~     ` _#($+273:BJRZa}hbj + 28>BHL S  x    '/>FVfy BA $,4<CcJDL   k- C KW_px ':DTY klrzsppq\iy+ *$)%,J3-5G Ѐ  ,9CM R\it tu@  @AGMHUV]b^elqmt{!"2< CZm !!" G X e  l         - 4 Q  X G H   %9FR^k pe d !)07<8?GOW^fmgo  W  WX^d_lmtyu|)K<)*抸DN/// 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.P`/// 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.m/// 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./// 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./// Returns the approximate number of bytes allocated for this object. /// /// The actual size of this picture may be larger, particularly if it contains /// references to image or other large objects.D /// 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.  փ56/// 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}A FL Q\n/// Release the resources used by this object. The object is no longer usable /// after this method is called./// This class is created by the engine, and should not be instantiated /// or extended directly. /// /// To create a [Picture], use a [PictureRecorder].$$$$$$$%&%%%%%%%%%%%%%%%%%%%%%%   l      ! l m s  { t              ! 5!2!> !C!I !N! !!"Y"" "" """"Y"Z"`""f"a"n""o"v"{"w"~"""""""#####$vk/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).$$$%$+$H$1$,$9$G$:$A$F$B$I$d$P$J$R&-+&@&-&.&\U)/// 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].* **ƀ/// Creates a new idle PictureRecorder. To associate it with a /// [Canvas] and begin recording, pass this [PictureRecorder] to the /// [Canvas] constructor.*恙,su/// 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.,,- /// 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.--.,..+1`1o.4....Ea..E.F.L.b.R.M.Z.a.[.c..j.d.l....0̀131A1Q000000000000001!1011{L11{1|1˛2&T/// A single shadow. /// /// Multiple shadows are stacked together in a [TextStyle].21P33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.3(333443333344 4 4(444:4L44F4;4I4N 4,444&445'55&5$5)5.#5?5M5K5P5U#5f5t5r5w5|&555556^/// Color that the shadow will be drawn with. /// /// The shadows are shapes composited directly over the base canvas, and do not /// represent optical occlusion.6h47/// 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.7i8O/// The standard deviation of the Gaussian to convolve with the shadow's shape.9:n/// The [blurRadius] in sigmas instead of logical pixels. /// /// See the sigma argument to [MaskFilter.blur].GGGGG8|9.h/// Converts a blur radius in pixels to sigmas. /// /// See the sigma argument to [MaskFilter.blur]. ///9C 9K:A], such as /// an [AnimationController]. /// {@endtemplate}A AA AAACDi/// Linearly interpolate between two lists of shadows. /// /// If the lists differ in length, excess items are lerped with null. /// /// {@macro dart.ui.shadow.lerp}DrDDDDDFFF FFFHHHHLLLLLLҎM/// 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.M MMMM MV VVVVVNV1/// The length, in bytes, of the underlying data.WWy/// Whether [dispose] has been called. /// /// This must only be used when asserts are enabled. Otherwise, it will throw.MgNh^/// Creates a copy of the data from a [Uint8List] suitable for internal use /// in the engine.NvNOQGOr/// Create a buffer from the asset with key [assetKey]. /// /// Throws an [Exception] if the asset does not exist.OORS+i/// Create a buffer from the file with [path]. /// /// Throws an [Exception] if the asset does not exist.S8 S@TTUU UU#TTTTTTTTTTTTTTTTU0UUUUUU0U1U7U_U?U8UGU^UHUPUXU`UUgUaUiUۀVHVVV^VgVwUUUV UUUV UUVV V3VV VX Z;/// 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.Zǀ[k/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).[7[8[>[[[D[?[L[Z[M[T[Y[U[\[[c[][e[\e/// 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.\y^^^/// 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`.^^^^^^_ __ _2`ya>d/// The width, in pixels, of the image. /// /// On the Web, this is only supported for [raw] images.aH{ae/// The height, in pixels, of the image. /// /// On the Web, this is only supported for [raw] images.aǀb>h/// The number of bytes per pixel in the image. /// /// On web, this is only supported for [raw] images._dc_H/// Creates an image descriptor from encoded data in a supported format.__bPc>/// 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).cLd/// 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.eeeee+<e6eeeeeggg/// 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`.ggh hh"h0h; hAhN hdk kk kllk4kkklH7l\lHlIm!Lm5m!m" iSiiiiiiSiTiZiibi[ijiikisizii{iiiiiij jjjjjj jj jj jjjj j jjJjjjjIjj'j/j6j=jDjKjnjRjLjTkrkwkkkk6kkk'k5k(k/k4k0k7kfk>k8k@k`kZkbktl7kkkkkkkkkkkkkl&kkkl ll"lm llllllllllllllllllllmqpmmqmrm}m~mmmmmmmmmmmmmmmm(mnnn#n)mmqqqqqqqqqqqqKqqq&qJq'q.q3q/q6q>qEqLqxqSqMqUqӀqqq~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. B0123 9B HSI2/// A string containing details about the failure.iO/// If available, the stack trace at the time [Picture.toImageSync] was called.B"OJȋ/// 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.KLh/// 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)LrHM4/// 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)MMO 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)OP/// 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)QR/// 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.RUIx/// 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)USW҂f/// 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)W܂Zny/// 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)Zy]o/// 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)] g_lE/// 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)_x]a΂;/// 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)aځ;c+/// 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)cOfe,/// 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)fnVi'/// 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.j!o-/// 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.oQs(/// 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.s47te"/// 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)tp:u$/// 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)u{w 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)w/xy/// 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)xŃ|/// 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.|s~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)/// 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)ǂ/// 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)‚/// 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].kD/// Take the saturation of the source image, and the hue and luminosity of the /// destination image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their saturation from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_saturation.png) /// /// See also: /// /// * [color], which also applies the hue of the source image. /// * [luminosity], which applies the luminosity of the source image to the /// destination.. /// Take the hue and saturation of the source image, and the luminosity of the /// destination image. /// /// The effect is to tint the destination image with the source image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their hue and saturation from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_color.png) /// /// See also: /// /// * [hue], which is a similar but weaker effect. /// * [softLight], which is a similar tinting effect but also tints white. /// * [saturation], which only applies the saturation of the source image.d/// Take the luminosity of the source image, and the hue and saturation of the /// destination image. /// /// The opacity of the output image is computed in the same way as for /// [srcOver]. Regions that are entirely transparent in the source image take /// their luminosity from the destination. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/blend_mode_luminosity.png) /// /// See also: /// /// * [saturation], which applies the saturation of the source image to the /// destination. /// * [ImageFilter.blur], which can be used with [BackdropFilter] for a /// related effect.{"t/// Quality levels for image sampling in [ImageFilter] and [Shader] objects that sample /// images and for [Canvas] operations that render images. /// /// When scaling up typically the quality is lowest at [none], higher at [low] and [medium], /// and for very large scale factors (over 10x) the highest at [high]. /// /// When scaling down, [medium] provides the best quality especially when scaling an /// image to less than half its size or for animating the scale factor between such /// reductions. Otherwise, [low] and [high] provide similar effects for reductions of /// between 50% and 100% but the image may lose detail and have dropouts below 50%. /// /// To get high quality when scaling images up and down, or when the scale is /// unknown, [medium] is typically a good balanced choice. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/filter_quality.png) /// /// When building for the web using the `--web-renderer=html` option, filter /// quality has no effect. All images are rendered using the respective /// browser's default setting. /// /// See also: /// /// * [Paint.filterQuality], which is used to pass [FilterQuality] to the /// engine while using drawImage calls on a [Canvas]. /// * [ImageShader]. /// * [ImageFilter.matrix]. /// * [Canvas.drawImage]. /// * [Canvas.drawImageRect]. /// * [Canvas.drawImageNine]. /// * [Canvas.drawAtlas]./// The fastest filtering method, albeit also the lowest quality. /// /// This value results in a "Nearest Neighbor" algorithm which just /// repeats or eliminates pixels as an image is scaled up or down.@/// Better quality than [none], faster than [medium]. /// /// This value results in a "Bilinear" algorithm which smoothly /// interpolates between pixels in an image.HЂ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.v/// 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.hI/// 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.g/// Styles to use for line segment joins. /// /// This only affects line joins for polygons drawn by [Canvas.drawPath] and /// rectangles, not points drawn as lines with [Canvas.drawPoints]. /// /// See also: /// /// * [Paint.strokeJoin] and [Paint.strokeMiterLimit] for how this value is /// used. /// * [StrokeCap] for the different kinds of line endings.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.T/// Strategies for painting shapes and paths on a canvas. /// /// See [Paint.style]./// Apply the [Paint] to the inside of the shape. For example, when /// applied to the [Canvas.drawCircle] call, this results in a disc /// of the given size being painted./// Apply the [Paint] to the edge of the shape. For example, when /// applied to the [Canvas.drawCircle] call, this results is a hoop /// of the given size being painted. The line drawn on the edge will /// be the width given by the [Paint.strokeWidth] property.Ɍ./// Different ways to clip a widget's content.8:/// No clip at all. /// /// This is the default option for most widgets: if the content does not /// overflow the widget boundary, don't pay any performance cost for clipping. /// /// If the content does overflow, please explicitly specify the following /// [Clip] options: /// * [hardEdge], which is the fastest clipping, but with lower fidelity. /// * [antiAlias], which is a little slower than [hardEdge], but with smoothed edges. /// * [antiAliasWithSaveLayer], which is much slower than [antiAlias], and should /// rarely be used.C_:/// Clip, but do not apply anti-aliasing. /// /// This mode enables clipping, but curves and non-axis-aligned straight lines will be /// jagged as no effort is made to anti-alias. /// /// Faster than other clipping modes, but slower than [none]. /// /// This is a reasonable choice when clipping is needed, if the container is an axis- /// aligned rectangle or an axis-aligned rounded rectangle with very small corner radii. /// /// See also: /// /// * [antiAlias], which is more reasonable when clipping is needed and the shape is not /// an axis-aligned rectangle..̃/// Clip with anti-aliasing. /// /// This mode has anti-aliased clipping edges to achieve a smoother look. /// /// It' s much faster than [antiAliasWithSaveLayer], but slower than [hardEdge]. /// /// This will be the common case when dealing with circles and arcs. /// /// Different from [hardEdge] and [antiAliasWithSaveLayer], this clipping may have /// bleeding edge artifacts. /// (See https://fiddle.skia.org/c/21cb4c2b2515996b537f36e7819288ae for an example.) /// /// See also: /// /// * [hardEdge], which is a little faster, but with lower fidelity. /// * [antiAliasWithSaveLayer], which is much slower, but can avoid the /// bleeding edges if there's no other way. /// * [Paint.isAntiAlias], which is the anti-aliasing switch for general draw operations.ڄs74/// Clip with anti-aliasing and saveLayer immediately following the clip. /// /// This mode not only clips with anti-aliasing, but also allocates an offscreen /// buffer. All subsequent paints are carried out on that buffer before finally /// being clipped and composited back. /// /// This is very slow. It has no bleeding edge artifacts (that [antiAlias] has) /// but it changes the semantics as an offscreen buffer is now introduced. /// (See https://github.com/flutter/flutter/issues/18057#issuecomment-394197336 /// for a difference between paint without saveLayer and paint with saveLayer.) /// /// This will be only rarely needed. One case where you might need this is if /// you have an image overlaid on a very different background color. In these /// cases, consider whether you can avoid overlaying multiple colors in one /// spot (e.g. by having the background color only present where the image is /// absent). If you can, [antiAlias] would be fine and much faster. /// /// See also: /// /// * [antiAlias], which is much faster, and has similar clipping results.,/// The color space describes the colors that are available to an [Image]. /// /// This value can help decide which [ImageByteFormat] to use with /// [Image.toByteData]. Images that are in the [extendedSRGB] color space /// should use something like [ImageByteFormat.rawExtendedRgba128] so that /// colors outside of the sRGB gamut aren't lost. /// /// This is also the result of [Image.colorSpace]. /// /// See also: https://en.wikipedia.org/wiki/Color_spacè/// The sRGB color space. /// /// You may know this as the standard color space for the web or the color /// space of non-wide-gamut Flutter apps. /// /// See also: https://en.wikipedia.org/wiki/SRGBՁ/// A color space that is backwards compatible with sRGB but can represent /// colors outside of that gamut with values outside of [0..1]. In order to /// see the extended values an [ImageByteFormat] like /// [ImageByteFormat.rawExtendedRgba128] must be used.Q 99/// The Display P3 color space. /// /// This is a wide gamut color space that has broad hardware support. It's /// supported in cases like using Impeller on iOS. When used on a platform /// that doesn't support Display P3, the colors will be clamped to sRGB. /// /// See also: https://en.wikipedia.org/wiki/DCI-P3 7 Y/// The format in which image bytes should be returned when using /// [Image.toByteData]. ׀Rt/// Raw RGBA format. /// /// Unencoded bytes, in RGBA row-primary form with premultiplied alpha, 8 bits per channel.^x/// Raw straight RGBA format. /// /// Unencoded bytes, in RGBA row-primary form with straight alpha, 8 bits per channel./// Raw unmodified format. /// /// Unencoded bytes, in the image's existing format. For example, a grayscale /// image may use a single 8-bit channel for each pixel.m/// Raw extended range RGBA format. /// /// Unencoded bytes, in RGBA row-primary form with straight alpha, 32 bit /// float (IEEE 754 binary32) per channel. /// /// Example usage: /// /// ```dart /// import 'dart:ui' as ui; /// import 'dart:typed_data'; /// /// Future> getFirstPixel(ui.Image image) async { /// final ByteData data = /// (await image.toByteData(format: ui.ImageByteFormat.rawExtendedRgba128))!; /// final Float32List floats = Float32List.view(data.buffer); /// return { /// 'r': floats[0], /// 'g': floats[1], /// 'b': floats[2], /// 'a': floats[3], /// }; /// } /// ```?/// PNG format. /// /// A loss-less compression format for images. This format is well suited for /// images with hard edges, such as screenshots or sprites, and images with /// text. Transparency is supported. The PNG format supports images up to /// 2,147,483,647 pixels in either dimension, though in practice available /// memory provides a more immediate limitation on maximum image size. /// /// PNG images normally use the `.png` file extension and the `image/png` MIME /// type. /// /// See also: /// /// * , the Wikipedia page on PNG. /// * , the PNG standard.G?>/// The format of pixel data given to [decodeImageFromPixels].l/// 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.yJ/// 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.W,x/// 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].ƃc/// Determines the winding rule that decides how the interior of a [Path] is /// calculated. /// /// This enum is used by the [Path.fillType] property.t/// The interior is defined by a non-zero sum of signed edge crossings. /// /// For a given point, the point is considered to be on the inside of the path /// if a line drawn from the point to infinity crosses lines going clockwise /// around the point a different number of times than it crosses lines going /// counter-clockwise around that point. /// /// See: (0Q/// 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: ]L/// Strategies for combining paths. /// /// See also: /// /// * [Path.combine], which uses this enum to decide how to combine two paths.#/// Subtract the second path from the first path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be a crescent portion of the /// first circle that was not overlapped by the second circle. /// /// See also: /// /// * [reverseDifference], which is the same but subtracting the first path /// from the second.ʁHk/// 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 operationU$t/// Create a new path that is the union (inclusive-or) of the two paths. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be a figure-eight like shape /// matching the outer boundaries of both circles.}n/// Create a new path that is the exclusive-or of the two paths, leaving /// everything but the overlapping pieces of the path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the figure-eight like shape less the overlapping parts /// /// See also: /// * [intersect], which is the inverse of this operation}/// Subtract the first path from the second path. /// /// For example, if the two paths are overlapping circles of equal diameter /// but differing centers, the result would be a crescent portion of the /// second circle that was not overlapped by the first circle. /// /// See also: /// /// * [difference], which is the same but subtracting the second path /// from the first.'{(4/// Styles to use for blurs in [MaskFilter] objects.(`(/// Fuzzy inside and outside. This is useful for painting shadows that are /// offset from the shape that ostensibly is casting the shadow.()À/// 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.ӓ/// 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.Q/// 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)΂/// 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)4w/// Defines how a list of points is interpreted when drawing a set of triangles. /// /// Used by [Canvas.drawVertices].QEE/// Draw each sequence of three points as the vertices of a triangle.S[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.(-)^/// Defines how a list of points is interpreted when drawing a set of points. /// /// Used by [Canvas.drawPoints] and [Canvas.drawRawPoints].)l+/// 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]).+(, /// 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]).,,/// Draw the entire sequence of points as one line. /// /// The lines are stroked as described by the [Paint] (ignoring /// [Paint.style]).,-4x/// Defines how a new clip region should be merged with the existing clip /// region. /// /// Used by [Canvas.clipRect].-?B-w5/// Subtract the new region from the existing region.-B-6/// Intersect the new region from the existing region.o t rw ۆ% olu  G K ^ j ! , ?  DG2pGRG] GeG2G3G9GJG:]Y?e1/// 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.eJeUe^ederexeeefnԈ+/// 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.noooo'o-o<oBoRq=xT/// 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.xuxx&xzszzzz{ @0/// 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.T_dzI/// 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. bmv {   7o7"757A7H7T؁y$"3 ;B Jxhxrx|x|xx{&2{sB/// A variant of `_futurize` that can communicate specific errors.{{{"{d+/// Signature for [Image] lifecycle events. GmG1/// Callback signature for [decodeImageFromList].H H {8d|9/// 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.|o|t||xl-/// Signature for [Picture] lifecycle events.ridr4/// Generic callback signature, used by [_futurize].rrrrrπs=/// Generic callback signature, used by [_futurizeWithError].s(s(s;s>sE sNsVs/// Signature for a method that receives a [_Callback]. /// /// Return value should be null on success, and a string error message on /// failure.sstt"t-t\/// Signature for a method that receives a [_CallbackWithError]. /// See also: [_Callbacker]tttt<΀-FzE6Մd`oqr/pΆ݆߆]lnoڇ܇݈e,0`dpՊ EMQAmq}ʌn !%37Ў+|̎Ҏ+QxAou-F_3Ւ )Sfw6FkR_ȕɕ)BΖ7]ڗ#)q9NlЙ֚'I[\͚Κ,KLr̛қ(NuҜ'Fdhi2ab'MN˟̠LMˠ̡+1ҡ:Ƣߢ?E0=ekop-Hx|}ƦLܧ bͧfڨ%)*{156tѪ8<=Dbխ9kЭ֮ag=ְ kU &uʳ6Kbwóڳ 9Tε ImxζfGҸLsȸθNgy3^gݺ,wļ;DJNOͽ;?@Loֽ %=Um@1@{@@@A<AAB)BtBBC CWCCDBDDE!EpEEEF#FpFG GYGGGHHHhHHIGIIJ6JQJUJcJgJJJK#K6K|K}KKLL LfLoLpLLMMMMTMZMMMMNNMN^NdNNOOOOLOROOPPPbPPPPQQ>QDQmQsQQR&R,R{RRRRSGSSSSST:TTTTTUGUPUQUUV6V<VvV|VWW!WmWsWWWX)X|XXYYYdYYZZZlZvZwZ[[c[i[[[\H\N\\\] ] ]Y]y]]]^#^o^^^__ _j_u_v___`4`:``aa aVagamaaab(b\bbbbccccWc]ccdd$drdxdeehefffcfkflffg gZg`gggh1h7hhhhhi=iYiiiijjj[jjjk kOkUkklllnlmmmcmmmmmnnUnfnnoo+oNoOooopplpppq.q{qqrrr%r+rdrrs&s1s2sssssttctmtntttu+u<uBuuuuuv:vvvww,w-wwwxxNxTxxxy y6y<yyz#zPzVzz{{${{{{{|!|p||||}}}X}^}}}}~~!~"~k~q~~~&7=u{8FLPV,2"o 06*0y>D 4 &,uZ`pv+,}4"28n e~JP3~;?<:>$(u=v2A>EF V 06)6<L"$%IM[_$dj%s9Ot}~+1GlrhUIO ]n7=BNTdj!SY^jp+/F7}7~ k$q8@AmsCItou6<m$*}PAG55OQRYoz{QW=YkcOT STuEo˜:eÎùCwħRŒPƎDDŽVȨ45vɸɹ:UVʄH˜˝(os̓ 4x|}͵%EK[aΧ &nσϗ5ЄНXoхїѭEҊfӁӅӆӾLRԔ6W]ժc֗`כן>BC؇؍ص#'Jo٭ٱٲ;x~ڻ@bۭۨ۬$VrRVWݘݞ:@zހޞޤ z߀9-v'+Pu,-x^KouMS_kq5URVW.rDB,^ Z`de W]PT)/ek{'o%\exAKSfp 17"&N[aefIcuSt2P~*U=> =Xt&IQzeo~+1a"A~ B +hdh@rvf n   d    7 D F G w          ! L ^ j       0 4 6 7 y   , t    P[\| b'TZou-4NYak8 q}=DFG7jvwHTU;v$(hl%tQ_cEIW[>"A[_`D   _    !!!L!_!`!!!!""O"U"""##]####$'$S$i$$$$$$$%?%E%%%%%&&&!&&&&&''+'1'v'( ((_(x())a)**/*]*a*b***+?+k+q+,,A,,,- -*-8-X-f------.G.i.o..///g/z//////0"0q011Z11222f2223.3D3J33333334%4d444455`556 6666>6D6f6677S77778/8_8e88888899 9'9J9P9k9q9999:::: :e::::;;A;;<"<+<1N>>???+?U?W?X?r??@ @@^@@@@@AAAeAAABBlBBBCCCC!C%C&CbCDDD,D?DWDcD{DDE*EbEiEEEEEFFFFbFcFFFFFFG/G1G2GLGmGGGGHHHGHKHHHHI8IIJJ@JDJ}JJJJKK2KKKL3LRLsLyLLLLLLLM3MsMMNNgNNNNNO:OVO\OOOOP$P*PwPPPPQ QQ\QqQsQtQQQQQR6RSRjRRRRRSS5SPSQSySSSTT TaTTTUU)U/UzUUUUVVVNViVnVVVVVVWW<W=WWWWWWX(X)XXXXXY'YYYZ.Z8ZqZZZ[&[2[:[B[[[y[[[[[\.\~\\\\\\]V]X]Y]|]]^^m^^^_4_O__``K````aIaab2b~bccfcccd:dddee#eHe\epeeeef$f0fNfnffffffgg`gggh)hwhhiiVibifiijKjjk7kkl llXllm.m2mmmmmnnSnnnoo%o:oXo]oooop1pYpcppppq.q5q:q<q=q`qdqqrrOrrrs*s@sDsst+tltu u[uuuv0vzvvvw ww4w8wwxxFxsxxxxy:yByyzzEzjzzzzzzz{{5{7{8{{{{{||1|m||||||||}E}}}}}~D~\~~~~m X YCms  SW;L59x|aM $nD`t %Bvz ^nBlv*Nt~"Hd#'^rb%&hnOZ\] !U[5;KQ=CFS=r{S5;+1zi+|4 0BDE*r R]I_9?2by}~$HI~_l 67z@?&'l5>9: Pu{Y*o$rs!EK]a8}_ lr ]1 U"<]x./qE`a%f4@F"(˜ LMßíó'-tĨĩ.>\]ţũDoƱƲ7tzCȌȍ#$iɭ)vʕʛ.MNˎ˽Krs̨̮K͖,{dϲfyWѠ06ҭұҲ28ӄjԴ=Պ ]֪=׊&vhٜ٢>xz{`ۥ۸۹Z܀܁܍sݒݓ&ބްޱ޽#YZfcno{'Z[gABN89E  MmT +Fa|%)*=>Je!EDi-MMNZvFW[\OP\WXdFGSKX@A j%2tz~/0h!Dnrs-QPQ]  a+/0uFGS04B :;D Mfg=YpqFbhT134|cg L j n   ) i      $ V X Y    ( ) D g h t     ^ .7=W[\h|\`AeiR/mh8>"AXY!oK#=>]^*wHc#$yVx|}  P  L h {        !X!!!""{"""###r##$${$$$%%/%0%[%`%%%&#&3&P&V&g&k&l&&&'9'?'''''((%(](^(((()G))))**i***+++++ +m+++,$,7,,,,---h-....l.r....///+/</A/B/\/s/t/00/0e0f0r0000001 1=1>1J11111112:2]2i22223 3)353s33344+4P4T4V4W4444444565M5e555566*6L6c66667 7777b77888+8@8V8i8q889B99999: :):r::;;";s;y;;<><>Z>>>??J?R?q???@@@B@t@|@@@@A#AqAAAB;BHBsBCCUC[CCD'DbDzDDDDEE`EuE{EEEF)F\FFFFGJGGGGHHH/HFHPHZH`HrHxHHHHII#I?I[IeIoIuIJJJMJpJJJJJJK|KKKKLLCLiLsL}LLLLMMMdMtMMMMNNN^NyNNNNOOO,OKOjO}O~OOP'PpPPPPQ+Q,QUQjQQQQQRRERcRzRRRSSRSvSSSTTTTT6TbTvT|TTTUU@UDUEUQUfUUUUVV%V:VQVVVVW(WLW~WWWWWWWWX XDX]XXXYY8YGYYYYYZ.Z2ZZ[[5[p[[[\\#\$\H\\\\]]G][]y]}]~]]^^$^(^)^w^^^^_____` `;`<```a/aYa[a\aaaaabAbbcc/cLcccddwddde"eheeeefCffg%g)g*gngtgh h>hhhhiSiWiXiiij.jSjjjjkMkkkl lClclelfllllm#m$mEmmmmmnnn)nmnnnznnnno o:olopoqo}oooppdpep|ppppqqqHqIqdq|qqrr0r6r:r;rGrrrrrrssEsYs_sssssstt;t=t>tptttttu.u:uquru~uuuv v vv<vhv|vvvvvvww8w:w;wlwwwwwx(x4xkxlxxxxxyyyy4y`ytyzyyyyyyz/z1z2zezzzzz{{Z{f{{{|||!|w|x|||||}}A}n}r}s}}}}}~~R~~$`  X-12v$TXY;l;?@r<@At+ ?|}!"|!^_"#q2gAG.23C!4D(AE-}*.W[4~BLf ]!'OXYfOU!D mB TZ%~j7q5Tsw@aevxy8VySu(9;<y},}g*0KQP0Nv'TCW"(waSu{h/2MS39k2Px%8ev, " '-xV§@Ñ2TZĪSŵ}ƃ"EKǘ+=PjȈȰ 1Wɓɦ~ʒ  Iij^_'<Vu͉ͦͧGezΏΩμ 4QR  :YmІНйк1QѩѱѾJRX\^_ҝ-|Jԙԧԭ:gmճPm։"2Rאזת6TZ^_k~ؓأاب مAfڮ,0Z۪4H|ܙܸܾ  #$ioݸJ`ޞ,vߣ-H}0FNRS,zABw<|6<@A]|}u134gk8JE#$@A6m6Upz=hN/5\@QW!=ABx~l=AB%`l0?@134CPQh15a(v%t]IdhLnrSEh: OU"p o  ? E   7    g w }    9 ?   - y     6=|${$E)8DNVis 6Dx OU> U ZAm V6!m? P`u   t    !@!x!!"5"""""""# #b#h#l#m#$$)$]$$$$%O%r%%%%%%%%%&B&g&&&&'-'3''''''(((((((())Y)j)))***c*i*+++%+&+`+f+++, ,,,J,P,,,,,-- --/-=-u------...M...//o///0)0r000171;1a1e122N22333i334 4)4/4x455_5556<6R666677#737977778 8q89 999j9: :Q:::;<;B;f;l;<>U>>?? ?j?????@@C@l@@@AAA"A(AwABB1B7BEBrBBBC4CkCCCCCD'DmDDDDEEcEEEF.FgFFFFFG-G~GGGGH%H+HyHIIcIJJKJJK8KSKYKiKoKKL)L?LlLmLLLMMM`MMMNN`NNNNOKOOOOP#PhPPPQQ%Q&QvQQQR>RRRRRSSStSSST1TTTTUUXUUUV)VEVKVVW;WhWWWWWXHXNXXXY2Y[YaYYZZZiZZZZ[/[5[[\\Y\Z\\\]]]b]h]^^+^b^c^__Y_j_p_``i`aaZaabMbibobbcMcccd2dYd_dmddde#eBe|eeeeef0f|fg+g;gAgghhh^hhii&iCiDiij:j@jjk2kkl(l{lllllm*mvmmmnn_nenno$ooooopBp]p|p}pqqqyqrrrcrrssssttTtztttuuMuuuv2vvvwwhwwwxMxxxy4y:yzyzzez{{2{8{|| |x||} }}[}}}}~H~~~*v|6$r Z>+,s_lr IOA+wDJ'-=C<B+u{IJFK/za(y>$}$\bRH;kV>> "K^u}Fd$X6|2u,2@U+agFg'C0^oEy%p $Bq!"flia6<L5  I\s{Dbie'N~`(T]gm|Zm"(WXCy!'4"KeHt&[am´~ÈÎÝåïõ-N}Ĥ;<ʼnŏ wyz )džnjZ^_>?ɛ<abnʼ,U~˧/I̶̅̒!%&͈X9TUaOno{[\ѻNvw҃ BbӠӦӿBCOnԟԻ$XYeH֖045״#$0k؍ؿXYeٝ,klxږ,01ۇ G܍ܑܒ-.:oݝݡݢ:;G|ޜ޼ }"OST-Mg  <^bcoFJK%&2\|06:;12>xL)ISm&ABNx!  [}%W%YB[e !8Ps#Ed=uC|^dhi=Qj4NmnzLBf%~IOqr~9=>+Ix )K,25tu .dH|  &      : @ D E Q r     = `     5 ; Y    r x   ,v}~3LezPTU&'3uwx.2fj5N Ajk@a ZS:@ a-YZ&,zK}:V\#W]s  J T ^ e i j !!!*!W!o!!!!!""R"V"W"""# ##5#E#]#p#z#####$"$f$$$$$$$$%%%"%%%%&&*&+&7&Y&[&\&&&'1'5'['_''(?(()")R)V))* *J****++%+i++,,,h,,,,--Q----..B.C.......//"/f/l////0E000001#1]1^1x1y1111112 2/2I2O22233F3L333344-444455,5S5z55556-6P6e6f6667E77778 8 8?8E8x8~899T99999::>:?:::;;E;K;;<'F>>>>?(?r?@ @W@@A8A>AAAABB&B;BJBkBsBBBBBC CBCCCCCCCCD)D/DRDDDDDEE3EnEEEF F1F7FnFFFFFFFFGGG2GRGtGGGGGGH;HHHHIIII\IIIIJ,JaJbJJJKKGKHKKKKL6L\LbLcL{LLLLLLMMMlMMMMN2NGNNNO,OJONOOOOOPPKPPQ QSQQQRR0R\RdRRRRRRS SGSSSTTTWT_TTTTTU-U.UUUV5VVVVVVWWW,W2WWWWWWXXXXXnXXXY.Y{YZZ4ZGZWZvZZZZZZ[[5[[[[[[\>\V\w\\]]X]r]x]^^Z^^^^___>_a_b__`:`l``````a4aEaFaqawaaaaab4bMbNbbbcc7cIcJcccddRdcdidde(e*e+eeeeef9ffffgLggghhh7hJhphwhhhhiLiPiQijjjpjjkkkhkkkkkkkl(lElFlRlllllmmm+mnmom{mmmmn?nrnnnnnno o;oXooppIpOppppppq qqqzqqqrfrhrirrrs sUsVsssst,t-tntttu/uDuGuuuvvvvv#vWvZvvvvvw)w.w5w8wwxxxhxxyy]yyyyzz2zAzzzzzzzz{{{#{%{&{i{{|,|p|||}}0}=}Q}}}}}}~~~8~<~W~Y~Z~~~K PQ  /*0NRTdart.uiW _rectIsValid _rrectIsValid_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 _ImageFilterShaderTileMode_encodeWideColorList_encodeColorList_encodePointList_encodeTwoPointsGradient ImageShaderFragmentProgramFragmentShader VertexModeVertices PointModeClipOpCanvas _NativeCanvasPicture_NativePicturePictureRecorder_NativePictureRecorderShadowImmutableBufferImageDescriptor_NativeImageDescriptor _futurize_futurizeWithErrorPictureRasterizationException