localizations fix

Runtime/material/app.cs

             string title = "",
             Color color = null,
             ThemeData theme = null,
+            Locale locale = null,
+            List<LocalizationsDelegate<MaterialLocalizations>> localizationsDelegates = null,
+            LocaleListResolutionCallback localeListResolutionCallback = null,
+            LocaleResolutionCallback localeResolutionCallback = null,
+            List<Locale> supportedLocales = null,
+            supportedLocales = supportedLocales ?? new List<Locale> {new Locale("en", "US")};
             this.navigatorKey = navigatorKey;
             this.home = home;
             this.routes = routes ?? new Dictionary<string, WidgetBuilder>();
             this.title = title;
             this.color = color;
             this.theme = theme;
+            this.locale = locale;
+            this.localizationsDelegates = localizationsDelegates;
+            this.localeListResolutionCallback = localeListResolutionCallback;
+            this.localeResolutionCallback = localeResolutionCallback;
+            this.supportedLocales = supportedLocales;
             this.showPerformanceOverlay = showPerformanceOverlay;
         }
 
         public readonly ThemeData theme;
 
         public readonly Color color;
+
+        public readonly Locale locale;
+
+        public readonly List<LocalizationsDelegate<MaterialLocalizations>> localizationsDelegates;
+
+        public readonly LocaleListResolutionCallback localeListResolutionCallback;
+
+        public readonly LocaleResolutionCallback localeResolutionCallback;
+
+        public readonly List<Locale> supportedLocales;
 
         public readonly bool showPerformanceOverlay;
 
             return new MaterialRectArcTween(begin: begin, end: end);
         }
 
+        List<LocalizationsDelegate> _localizationsDelegates {
+            get {
+                List<LocalizationsDelegate<MaterialLocalizations>> _delegates =
+                    new List<LocalizationsDelegate<MaterialLocalizations>>();
+                if (this.widget.localizationsDelegates != null) {
+                    _delegates.AddRange(this.widget.localizationsDelegates);
+                }
+
+                _delegates.Add(DefaultMaterialLocalizations.del);
+                return new List<LocalizationsDelegate>(_delegates);
+            }
+        }
+
         public override Widget build(BuildContext context) {
             ThemeData theme = this.widget.theme ?? ThemeData.fallback();
             Widget result = new AnimatedTheme(
                     onGenerateRoute: this.widget.onGenerateRoute,
                     onUnknownRoute: this.widget.onUnknownRoute,
                     builder: this.widget.builder,
-                    textStyle: AppUtils._errorTextStyle
+                    textStyle: AppUtils._errorTextStyle,
+                    locale: this.widget.locale,
+                    localizationsDelegates: this._localizationsDelegates,
+                    localeResolutionCallback: this.widget.localeResolutionCallback,
+                    localeListResolutionCallback: this.widget.localeListResolutionCallback,
+                    supportedLocales: this.widget.supportedLocales,
+                    showPerformanceOverlay: this.widget.showPerformanceOverlay
                 )
             );
 

Runtime/material/page_transitions_theme.cs

 using System;
-using System.Collections.Generic;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
             return matchingBuilder.buildTransitions(route, context, animation, secondaryAnimation, child);
         }
 
-        List<PageTransitionsBuilder> _all(PageTransitionsBuilder builder) {
-            return new List<PageTransitionsBuilder> {this.builder};
+        PageTransitionsBuilder _all(PageTransitionsBuilder builder) {
+            return builder;
         }
 
         public bool Equals(PageTransitionsTheme other) {

Runtime/material/popup_menu.cs

 using TextStyle = Unity.UIWidgets.painting.TextStyle;
 
 namespace Unity.UIWidgets.material {
-
     public static partial class PopupMenuUtils {
         internal static readonly TimeSpan _kMenuDuration = new TimeSpan(0, 0, 0, 0, 300);
         internal const float _kBaselineOffsetFromBottom = 20.0f;
     public class PopupMenuDivider : PopupMenuEntry<object> {
         public PopupMenuDivider(Key key = null, float height = PopupMenuUtils._kMenuDividerHeight) : base(key: key) {
             this._height = height;
-
         }
 
         readonly float _height;
         protected override void handleTap() {
             if (this.widget.isChecked) {
                 this._controller.reverse();
-            } else {
+            }
+            else {
+
             base.handleTap();
         }
 
                         child: item
                     );
                 }
+
                 children.Add(new FadeTransition(
                     opacity: new CurvedAnimation(
                         parent: this.route.animation,
             float y;
             if (this.selectedItemOffset == null) {
                 y = this.position.top;
-            } else {
+            }
+            else {
                 y = this.position.top + (size.height - this.position.top - this.position.bottom) / 2.0f -
                     this.selectedItemOffset.Value;
             }
                 x = size.width - this.position.right - childSize.width;
-            } else if (this.position.left < this.position.right) {
+            }
+            else if (this.position.left < this.position.right) {
-            } else {
+            }
+            else {
-            } else if (x + childSize.width > size.width - PopupMenuUtils._kMenuScreenPadding) {
+            }
+            else if (x + childSize.width > size.width - PopupMenuUtils._kMenuScreenPadding) {
-            } else if (y + childSize.height > size.height - PopupMenuUtils._kMenuScreenPadding) {
+            }
+            else if (y + childSize.height > size.height - PopupMenuUtils._kMenuScreenPadding) {
                 y = size.height - childSize.height - PopupMenuUtils._kMenuScreenPadding;
             }
 
                         selectedItemOffset = y + entry.height / 2.0f;
                         break;
                     }
+
                     y += entry.height;
                 }
             }
             Icon icon = null,
             Offset offset = null
         ) : base(key: key) {
+            offset = offset ?? Offset.zero;
             D.assert(itemBuilder != null);
             D.assert(offset != null);
             D.assert(!(child != null && icon != null));
             this.padding = padding ?? EdgeInsets.all(8.0f);
             this.child = child;
             this.icon = icon;
-            this.offset = offset ?? Offset.zero;
+            this.offset = offset;
         }
 
 
                     if (!this.mounted) {
                         return;
                     }
+
+
+
                     if (this.widget.onSelected != null) {
                         this.widget.onSelected(newValue);
                     }
                 );
         }
     }
-}
+}

Runtime/material/scaffold.cs

                 this._snackBarController.forward();
             }
 
-            ScaffoldFeatureController<SnackBar, SnackBarClosedReason> controller =
-                new ScaffoldFeatureController<SnackBar, SnackBarClosedReason>(
-                    snackbar.withAnimation(this._snackBarController, fallbackKey: new UniqueKey()),
-                    new Promise<SnackBarClosedReason>(),
-                    () => {
-                        D.assert(this._snackBars.First() == controller);
-                        this.hideCurrentSnackBar(reason: SnackBarClosedReason.hide);
-                    },
-                    null);
+            ScaffoldFeatureController<SnackBar, SnackBarClosedReason> controller = null;
+            controller = new ScaffoldFeatureController<SnackBar, SnackBarClosedReason>(
+                snackbar.withAnimation(this._snackBarController, fallbackKey: new UniqueKey()),
+                new Promise<SnackBarClosedReason>(),
+                () => {
+                    D.assert(this._snackBars.First() == controller);
+                    this.hideCurrentSnackBar(reason: SnackBarClosedReason.hide);
+                },
+                null);
 
             this.setState(() => { this._snackBars.Enqueue(controller); });
             return controller;

Runtime/material/theme.cs

                 return inheritedTheme.theme.data;
             }
 
-            //todo:xingwei.zhu: material Localizations
-            return inheritedTheme?.theme?.data ?? _kFallbackTheme;
+            MaterialLocalizations localizations = MaterialLocalizations.of(context);
+            ScriptCategory category = ScriptCategory.englishLike;
+            ThemeData theme = inheritedTheme?.theme?.data ?? _kFallbackTheme;
+            return ThemeData.localize(theme, theme.typography.geometryThemeFor(category));
         }
 
         public override Widget build(BuildContext context) {

Runtime/material/theme_data.cs

 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.service;
 using Unity.UIWidgets.widgets;
             );
         }
 
+        const int _localizedThemeDataCacheSize = 5;
+
+        static readonly _FifoCache<_IdentityThemeDataCacheKey, ThemeData> _localizedThemeDataCache =
+            new _FifoCache<_IdentityThemeDataCacheKey, ThemeData>(_localizedThemeDataCacheSize);
+
+
+        public static ThemeData localize(ThemeData baseTheme, TextTheme localTextGeometry) {
+            D.assert(baseTheme != null);
+            D.assert(localTextGeometry != null);
+
+            return _localizedThemeDataCache.putIfAbsent(
+                new _IdentityThemeDataCacheKey(baseTheme, localTextGeometry),
+                () => {
+                    return baseTheme.copyWith(
+                        primaryTextTheme: localTextGeometry.merge(baseTheme.primaryTextTheme),
+                        accentTextTheme: localTextGeometry.merge(baseTheme.accentTextTheme),
+                        textTheme: localTextGeometry.merge(baseTheme.textTheme)
+                    );
+                });
+        }
+
         public static Brightness estimateBrightnessForColor(Color color) {
             float relativeLuminance = color.computeLuminance();
             float kThreshold = 0.15f;
                 defaultValue: defaultData.dialogTheme));
             properties.add(new DiagnosticsProperty<Typography>("typography", this.typography,
                 defaultValue: defaultData.typography));
+        }
+    }
+
+
+    class _IdentityThemeDataCacheKey : IEquatable<_IdentityThemeDataCacheKey> {
+        public _IdentityThemeDataCacheKey(
+            ThemeData baseTheme,
+            TextTheme localTextGeometry) {
+            this.baseTheme = baseTheme;
+            this.localTextGeometry = localTextGeometry;
+        }
+
+        public readonly ThemeData baseTheme;
+
+        public readonly TextTheme localTextGeometry;
+
+        public bool Equals(_IdentityThemeDataCacheKey other) {
+            if (ReferenceEquals(null, other)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other)) {
+                return true;
+            }
+
+            return this.baseTheme == other.baseTheme &&
+                   this.localTextGeometry == other.localTextGeometry;
+        }
+
+        public override bool Equals(object obj) {
+            if (ReferenceEquals(null, obj)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj)) {
+                return true;
+            }
+
+            if (obj.GetType() != this.GetType()) {
+                return false;
+            }
+
+            return this.Equals((_IdentityThemeDataCacheKey) obj);
+        }
+
+        public static bool operator ==(_IdentityThemeDataCacheKey left, _IdentityThemeDataCacheKey right) {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(_IdentityThemeDataCacheKey left, _IdentityThemeDataCacheKey right) {
+            return !Equals(left, right);
+        }
+
+        public override int GetHashCode() {
+            var hashCode = this.baseTheme.GetHashCode();
+            hashCode = (hashCode * 397) ^ this.localTextGeometry.GetHashCode();
+            return hashCode;
+        }
+    }
+
+    class _FifoCache<K, V> {
+        public _FifoCache(int maximumSize) {
+            D.assert(maximumSize > 0);
+            this._maximumSize = maximumSize;
+        }
+
+        readonly Dictionary<K, V> _cache = new Dictionary<K, V>();
+
+        readonly int _maximumSize;
+
+        public V putIfAbsent(K key, Func<V> value) {
+            D.assert(key != null);
+            D.assert(value != null);
+
+            if (this._cache.ContainsKey(key)) {
+                return this._cache[key];
+            }
+
+            if (this._cache.Count == this._maximumSize) {
+                this._cache.Remove(this._cache.Keys.First());
+            }
+
+            this._cache[key] = value();
+            return this._cache[key];
         }
     }
 }

Runtime/rendering/layer.cs

 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
 using UnityEngine;
+using Color = Unity.UIWidgets.ui.Color;
 using Rect = Unity.UIWidgets.ui.Rect;
 
 namespace Unity.UIWidgets.rendering {

Runtime/widgets/app.cs

 using TextStyle = Unity.UIWidgets.painting.TextStyle;
 
 namespace Unity.UIWidgets.widgets {
+    public delegate Locale LocaleListResolutionCallback(List<Locale> locales, List<Locale> supportedLocales);
+
+    public delegate Locale LocaleResolutionCallback(Locale locale, List<Locale> supportedLocales);
+
     public delegate PageRoute PageRouteFactory(RouteSettings settings, WidgetBuilder builder);
 
     public class WidgetsApp : StatefulWidget {
         public readonly TextStyle textStyle;
         public readonly Window window;
         public readonly bool showPerformanceoverlay;
+        public readonly Locale locale;
+        public readonly List<LocalizationsDelegate> localizationsDelegates;
+        public readonly LocaleListResolutionCallback localeListResolutionCallback;
+        public readonly LocaleResolutionCallback localeResolutionCallback;
+        public readonly List<Locale> supportedLocales;
 
         public WidgetsApp(
             Key key = null,
             TransitionBuilder builder = null,
             TextStyle textStyle = null,
             Widget home = null,
+            Locale locale = null,
+            List<LocalizationsDelegate> localizationsDelegates = null,
+            LocaleListResolutionCallback localeListResolutionCallback = null,
+            LocaleResolutionCallback localeResolutionCallback = null,
+            List<Locale> supportedLocales = null,
+            supportedLocales = supportedLocales ?? new List<Locale> {new Locale("en", "US")};
             this.window = Window.instance;
             this.home = home;
             this.navigatorKey = navigatorKey;
             this.initialRoute = initialRoute;
             this.builder = builder;
             this.textStyle = textStyle;
+            this.locale = locale;
+            this.localizationsDelegates = localizationsDelegates;
+            this.localeListResolutionCallback = localeListResolutionCallback;
+            this.localeResolutionCallback = localeResolutionCallback;
+            this.supportedLocales = supportedLocales;
             this.showPerformanceoverlay = showPerformanceOverlay;
 
             D.assert(
         }
 
         public void didChangeLocales(List<Locale> locale) {
-            // TODO: support locales.
+            Locale newLocale = this._resolveLocales(locale, this.widget.supportedLocales);
+            if (newLocale != this._locale) {
+                this.setState(() => { this._locale = newLocale; });
+            }
+        }
+
+        List<LocalizationsDelegate> _localizationsDelegates {
+            get {
+                List<LocalizationsDelegate> _delegates = new List<LocalizationsDelegate>();
+                if (this.widget.localizationsDelegates != null) {
+                    _delegates.AddRange(this.widget.localizationsDelegates);
+                }
+
+                _delegates.Add(DefaultWidgetsLocalizations.del);
+                return _delegates;
+            }
+            this._locale =
+                this._resolveLocales(new List<Locale> {new Locale("en", "US")}, this.widget.supportedLocales);
+
             D.assert(() => {
                 WidgetInspectorService.instance.inspectorShowCallback += this.inspectorShowChanged;
                 return true;
             return result;
         }
 
+        Locale _locale;
+
+        Locale _resolveLocales(List<Locale> preferredLocales, List<Locale> supportedLocales) {
+            if (this.widget.localeListResolutionCallback != null) {
+                Locale locale =
+                    this.widget.localeListResolutionCallback(preferredLocales, this.widget.supportedLocales);
+                if (locale != null) {
+                    return locale;
+                }
+            }
+
+            if (this.widget.localeResolutionCallback != null) {
+                Locale locale = this.widget.localeResolutionCallback(
+                    preferredLocales != null && preferredLocales.isNotEmpty() ? preferredLocales.first() : null,
+                    this.widget.supportedLocales
+                );
+                if (locale != null) {
+                    return locale;
+                }
+            }
+
+            return basicLocaleListResolution(preferredLocales, supportedLocales);
+        }
+
+
+        static Locale basicLocaleListResolution(List<Locale> preferredLocales, List<Locale> supportedLocales) {
+            if (preferredLocales == null || preferredLocales.isEmpty()) {
+                return supportedLocales.first();
+            }
+
+            Dictionary<string, Locale> allSupportedLocales = new Dictionary<string, Locale>();
+            Dictionary<string, Locale> languageLocales = new Dictionary<string, Locale>();
+            Dictionary<string, Locale> countryLocales = new Dictionary<string, Locale>();
+            foreach (Locale locale in supportedLocales) {
+                allSupportedLocales.putIfAbsent(locale.languageCode + "_" + locale.countryCode, () => locale);
+                languageLocales.putIfAbsent(locale.languageCode, () => locale);
+                countryLocales.putIfAbsent(locale.countryCode, () => locale);
+            }
+
+            Locale matchesLanguageCode = null;
+            Locale matchesCountryCode = null;
+
+            for (int localeIndex = 0; localeIndex < preferredLocales.Count; localeIndex++) {
+                Locale userLocale = preferredLocales[localeIndex];
+                if (allSupportedLocales.ContainsKey(userLocale.languageCode + "_" + userLocale.countryCode)) {
+                    return userLocale;
+                }
+
+                if (matchesLanguageCode != null) {
+                    return matchesLanguageCode;
+                }
+
+                if (languageLocales.ContainsKey(userLocale.languageCode)) {
+                    matchesLanguageCode = languageLocales[userLocale.languageCode];
+
+                    if (localeIndex == 0 &&
+                        !(localeIndex + 1 < preferredLocales.Count && preferredLocales[localeIndex + 1].languageCode ==
+                          userLocale.languageCode)) {
+                        return matchesLanguageCode;
+                    }
+                }
+
+
+                if (matchesCountryCode == null && userLocale.countryCode != null) {
+                    if (countryLocales.ContainsKey(userLocale.countryCode)) {
+                        matchesCountryCode = countryLocales[userLocale.countryCode];
+                    }
+                }
+            }
+
+            Locale resolvedLocale = matchesLanguageCode ?? matchesCountryCode ?? supportedLocales.first();
+            return resolvedLocale;
+        }
+
+
         void inspectorShowChanged() {
             this.setState();
         }
                 child: result
             );
 
+            Locale appLocale = this.widget.locale != null
+                ? this._resolveLocales(new List<Locale> {this.widget.locale}, this.widget.supportedLocales)
+                : this._locale;
+
-                child: result
+                child: new Localizations(
+                    locale: appLocale,
+                    delegates: this._localizationsDelegates,
+                    child: result)
             );
 
             return result;

Runtime/widgets/localizations.cs

                     Type type = del.type;
                     D.assert(!output.ContainsKey(type));
                     output[type] = completedValue;
-                } else {
+                }
+                else {
                     pendingList = pendingList ?? new List<_Pending>();
                     pendingList.Add(new _Pending(del, futureValue));
                 }
                         D.assert(!output.ContainsKey(type));
                         output[type] = list[i];
                     }
+
                     return output;
                 });
         }
             D.assert(locale != null);
             D.assert(delegates != null);
             D.assert(delegates.Any(del => del is LocalizationsDelegate<WidgetsLocalizations>));
+            this.locale = locale;
+            this.delegates = delegates;
+            this.child = child;
         }
 
         public static Localizations overrides(
             if (delegates != null) {
                 mergedDelegates.InsertRange(0, delegates);
             }
+
-                locale: locale ?? Localizations.localeOf(context),
+                locale: locale ?? localeOf(context),
                 delegates: mergedDelegates,
                 child: child
             );
             if (nullOk && scope == null) {
                 return null;
             }
+
             D.assert((bool) (scope != null), "a Localizations ancestor was not found");
             return scope.localizationsState.locale;
         }
                     return true;
                 }
             }
+
             return false;
         }
 
             if (typeToResources != null) {
                 this._typeToResources = typeToResources;
                 this._locale = locale;
-            } else {
+            }
+            else {
                 // WidgetsBinding.instance.deferFirstFrameReport();
                 typeToResourcesFuture.Then(value => {
                     // WidgetsBinding.instance.allowFirstFrameReport();
+
                     this.setState(() => {
                         this._typeToResources = value;
                         this._locale = locale;
             if (this._locale == null) {
                 return new Container();
             }
+
             return new _LocalizationsScope(
                 key: this._localizedResourcesScopeKey,
                 locale: this._locale,
             );
         }
     }
-}
+}

Samples/UIWidgetSample/MaterialSample.cs

 
         protected override Widget createWidget() {
             return new MaterialApp(
+                showPerformanceOverlay: true,
-        
+
         protected override void OnEnable() {
             base.OnEnable();
             FontManager.instance.addFont(Resources.Load<Font>(path: "MaterialIcons-Regular"));
     class MaterialAppBarWidget : StatefulWidget {
         public MaterialAppBarWidget(Key key = null) : base(key) {
-            
+
         public override State createState() {
             return new MaterialAppBarWidgetState();
         }
 
         public override Widget build(BuildContext context) {
             return new Scaffold(
-                    appBar: new AppBar(
-                        title: new Text("Basic AppBar"),
-                        actions: new List<Widget> {
-                            new IconButton(
-                                icon: new Icon(Choice.choices[0].icon),
-                                //color: Colors.blue,
-                                onPressed: () => {
-                                    this._select((Choice.choices[0]));
-                                }
-                                ),
-                            new IconButton(
-                                icon: new Icon(Choice.choices[1].icon),
-                                //color: Colors.blue,
-                                onPressed: () => {
-                                    this._select((Choice.choices[1]));
+                appBar: new AppBar(
+                    title: new Text("Basic AppBar"),
+                    actions: new List<Widget> {
+                        new IconButton(
+                            icon: new Icon(Choice.choices[0].icon),
+                            //color: Colors.blue,
+                            onPressed: () => { this._select((Choice.choices[0])); }
+                        ),
+                        new IconButton(
+                            icon: new Icon(Choice.choices[1].icon),
+                            //color: Colors.blue,
+                            onPressed: () => { this._select((Choice.choices[1])); }
+                        ),
+
+                        new PopupMenuButton<Choice>(
+                            onSelected: this._select,
+                            itemBuilder: (BuildContext subContext) => {
+                                List<PopupMenuEntry<Choice>> popupItems = new List<PopupMenuEntry<Choice>>();
+                                for (int i = 2; i < Choice.choices.Count; i++) {
+                                    popupItems.Add(new PopupMenuItem<Choice>(
+                                        value: Choice.choices[i],
+                                        child: new Text(Choice.choices[i].title)));
-                            ),
-                            
-                            /*new PopupMenuButton<Choice>(
-                                onSelected: this._select,
-                                itemBuilder: (BuildContext subContext) => {
-                                    List<PopupMenuEntry<Choice>> popupItems = new List<PopupMenuEntry<Choice>>();
-                                    for (int i = 2; i < Choice.choices.Count; i++) {
-                                        popupItems.Add(new PopupMenuItem<Choice>(
-                                            value: Choice.choices[i],
-                                            child: new Text(Choice.choices[i].title)));
-                                    }
-                                    return popupItems;
-                                }
-                            )*/
-                        }
-                        ),
-                    body: new Padding(
-                        padding: EdgeInsets.all(16.0f),
-                        child: new ChoiceCard(choice: this._selectedChoice)
+                                return popupItems;
+                            }
-                );
+                    }
+                ),
+                body: new Padding(
+                    padding: EdgeInsets.all(16.0f),
+                    child: new ChoiceCard(choice: this._selectedChoice)
+                )
+            );
         }
     }
 
         public override Widget build(BuildContext context) {
             TextStyle textStyle = Theme.of(context).textTheme.display1;
             return new Card(
-                    color: Colors.white,
-                    child: new Center(
-                        child: new Column(
-                                   mainAxisSize: MainAxisSize.min,
-                                   crossAxisAlignment: CrossAxisAlignment.center,
-                                   children: new List<Widget>{
-                        new Icon(this.choice.icon, size: 128.0f, color: textStyle.color),
-                        new Text(this.choice.title, style: textStyle)
+                color: Colors.white,
+                child: new Center(
+                    child: new Column(
+                        mainAxisSize: MainAxisSize.min,
+                        crossAxisAlignment: CrossAxisAlignment.center,
+                        children: new List<Widget> {
+                            new Icon(this.choice.icon, size: 128.0f, color: textStyle.color),
+                            new Text(this.choice.title, style: textStyle)
                         }
                     )
                 )

Samples/UIWidgetSample/UIWidgetSample.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.37311947, g: 0.38074, b: 0.35872698, a: 1}
+  m_IndirectSpecularColor: {r: 0.37311953, g: 0.38074, b: 0.35872698, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!114 &304189371
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1148735784}
   m_CullTransparentMesh: 0
+--- !u!1 &1155767695
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1155767701}
+  - component: {fileID: 1155767700}
+  - component: {fileID: 1155767699}
+  - component: {fileID: 1155767698}
+  - component: {fileID: 1155767697}
+  - component: {fileID: 1155767696}
+  m_Layer: 5
+  m_Name: Canvas2
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1155767696
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1155767695}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d7c3be43dd8b94a349f26e3e7173c3f6, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_Texture: {fileID: 0}
+  m_UVRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  devicePixelRatioOverride: 0
+--- !u!222 &1155767697
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1155767695}
+  m_CullTransparentMesh: 0
+--- !u!114 &1155767698
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1155767695}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1301386320, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &1155767699
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1155767695}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1980459831, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 0
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &1155767700
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1155767695}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &1155767701
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1155767695}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
 --- !u!1 &1199742531
 GameObject:
   m_ObjectHideFlags: 0