Example #1
0
        static async ETTask __AddWindowToStack <P1, P2, P3, P4>(this UIManagerComponent self, UIWindow target, P1 p1, P2 p2, P3 p3, P4 p4)
        {
            var  ui_name    = target.Name;
            var  layer_name = target.Layer;
            bool isFirst    = true;

            if (self.window_stack[layer_name].Contains(ui_name))
            {
                isFirst = false;
                self.window_stack[layer_name].Remove(ui_name);
            }
            self.window_stack[layer_name].AddFirst(ui_name);
            Game.EventSystem.Publish(new UIEventType.AddWindowToStack()
            {
                window = target
            });
            var view = target.GetComponent(target.ViewType);

            view.SetActive(true, p1, p2, p3, p4);
            if (isFirst && (layer_name == UILayerNames.BackgroudLayer || layer_name == UILayerNames.GameBackgroudLayer))
            {
                //如果是背景layer,则销毁所有的normal层|BackgroudLayer
                await self.CloseWindowByLayer(UILayerNames.NormalLayer);

                await self.CloseWindowByLayer(UILayerNames.GameLayer);

                await self.CloseWindowByLayer(UILayerNames.BackgroudLayer, ui_name);

                await self.CloseWindowByLayer(UILayerNames.GameBackgroudLayer, ui_name);
            }
        }
Example #2
0
        public static async ETTask CloseWindowByLayer(this UIManagerComponent self, UILayerNames layer, params string[] except_ui_names)
        {
            Dictionary <string, bool> dict_ui_names = null;

            if (except_ui_names != null && except_ui_names.Length > 0)
            {
                dict_ui_names = new Dictionary <string, bool>();
                for (int i = 0; i < except_ui_names.Length; i++)
                {
                    dict_ui_names[except_ui_names[i]] = true;
                }
            }

            using (ListComponent <ETTask> TaskScheduler = ListComponent <ETTask> .Create())
            {
                foreach (var item in self.windows)
                {
                    if (item.Value.Layer == layer && (dict_ui_names == null || !dict_ui_names.ContainsKey(item.Key)))
                    {
                        TaskScheduler.Add(self.CloseWindow(item.Key));
                    }
                }
                await ETTaskHelper.WaitAll(TaskScheduler);
            }
        }
Example #3
0
        static async ETTask <T> __InnerOpenWindow <T, P1, P2, P3, P4>(this UIManagerComponent self, UIWindow target, P1 p1, P2 p2, P3 p3, P4 p4) where T : Entity
        {
            CoroutineLock coroutineLock = null;

            try
            {
                coroutineLock = await CoroutineLockComponent.Instance.Wait(CoroutineLockType.UIManager, target.GetHashCode());

                target.Active = true;
                T   res       = target.GetComponent(target.ViewType) as T;
                var need_load = target.LoadingState == UIWindowLoadingState.NotStart;
                if (need_load)
                {
                    target.LoadingState = UIWindowLoadingState.Loading;
                    await Game.EventSystem.PublishAsync(new UIEventType.InnerOpenWindow()
                    {
                        path = target.PrefabPath, window = target
                    });
                }
                Game.EventSystem.Publish(new UIEventType.ResetWindowLayer()
                {
                    window = target
                });
                await self.__AddWindowToStack(target, p1, p2, p3, p4);

                return(res);
            }
            finally
            {
                coroutineLock?.Dispose();
            }
        }
Example #4
0
        //销毁指定窗口所有窗口
        public static async ETTask DestroyWindowExceptNames(this UIManagerComponent self, string[] type_names = null)
        {
            Dictionary <string, bool> dict_ui_names = new Dictionary <string, bool>();

            if (type_names != null)
            {
                for (int i = 0; i < type_names.Length; i++)
                {
                    dict_ui_names[type_names[i]] = true;
                }
            }
            var keys = self.windows.Keys.ToArray();

            using (ListComponent <ETTask> TaskScheduler = ListComponent <ETTask> .Create())
            {
                for (int i = self.windows.Count - 1; i >= 0; i--)
                {
                    if (!dict_ui_names.ContainsKey(keys[i]))
                    {
                        TaskScheduler.Add(self.DestroyWindow(keys[i]));
                    }
                }
                await ETTaskHelper.WaitAll(TaskScheduler);
            }
        }
Example #5
0
 static void __InnnerCloseWindow(this UIManagerComponent self, UIWindow target)
 {
     if (target.Active)
     {
         __Deactivate(target);
         target.Active = false;
     }
 }
Example #6
0
 public static UILayer GetLayer(this UIManagerComponent self, UILayerNames layer)
 {
     if (UILayersComponent.Instance.layers.TryGetValue(layer, out var res))
     {
         return(res);
     }
     return(null);
 }
Example #7
0
        public static Entity GetView(this UIManagerComponent self, string ui_name)
        {
            var res = self.GetWindow(ui_name);

            if (res != null)
            {
                return(res.GetComponent <Entity>());
            }
            return(null);
        }
Example #8
0
        //判断窗口是否打开
        public static bool IsActiveWindow <T>(this UIManagerComponent self) where T : Entity
        {
            string ui_name = typeof(T).Name;
            var    target  = self.GetWindow(ui_name);

            if (target == null)
            {
                return(false);
            }
            return(target.Active);
        }
Example #9
0
 /// <summary>
 /// 获取UI窗口
 /// </summary>
 /// <param name="ui_name"></param>
 /// <param name="active">1打开,-1关闭,0不做限制</param>
 /// <returns></returns>
 public static UIWindow GetWindow(this UIManagerComponent self, string ui_name, int active = 0)
 {
     if (self.windows.TryGetValue(ui_name, out var target))
     {
         if (active == 0 || active == (target.Active ? 1 : -1))
         {
             return(target);
         }
         return(null);
     }
     return(null);
 }
Example #10
0
        public static async ETTask DestroyAllWindow(this UIManagerComponent self)
        {
            var keys = self.windows.Keys.ToArray();

            using (ListComponent <ETTask> TaskScheduler = ListComponent <ETTask> .Create())
            {
                for (int i = self.windows.Count - 1; i >= 0; i--)
                {
                    TaskScheduler.Add(self.DestroyWindow(self.windows[keys[i]].Name));
                }
                await ETTaskHelper.WaitAll(TaskScheduler);
            }
        }
Example #11
0
 /// <summary>
 /// 销毁隐藏状态的窗口
 /// </summary>
 /// <param name="self"></param>
 public static async ETTask DestroyUnShowWindow(this UIManagerComponent self)
 {
     using (ListComponent <ETTask> TaskScheduler = ListComponent <ETTask> .Create())
     {
         foreach (var key in self.windows.Keys.ToList())
         {
             if (!self.windows[key].Active)
             {
                 TaskScheduler.Add(self.DestroyWindow(key));
             }
         }
         await ETTaskHelper.WaitAll(TaskScheduler);
     }
 }
Example #12
0
        /// <summary>
        /// 初始化window
        /// </summary>
        static UIWindow __InitWindow <T>(this UIManagerComponent self, string path, UILayerNames layer_name) where T : Entity, IAwake, new()
        {
            UIWindow window = self.AddChild <UIWindow>();
            var      type   = typeof(T);

            window.Name         = type.Name;
            window.Active       = false;
            window.ViewType     = type;
            window.Layer        = layer_name;
            window.LoadingState = UIWindowLoadingState.NotStart;
            window.PrefabPath   = path;
            window.AddComponent <T>();
            return(window);
        }
Example #13
0
        /// <summary>
        /// 获取UI窗口
        /// </summary>
        /// <param name="active">1打开,-1关闭,0不做限制</param>
        /// <returns></returns>
        public static T GetWindow <T>(this UIManagerComponent self, int active = 0) where T : Entity
        {
            string ui_name = typeof(T).Name;

            if (self != null && self.windows != null && self.windows.TryGetValue(ui_name, out var target))
            {
                if (active == 0 || active == (target.Active ? 1 : -1))
                {
                    return(target.GetComponent <T>());
                }
                return(null);
            }
            return(null);
        }
Example #14
0
        /// <summary>
        /// 移除
        /// </summary>
        /// <param name="self"></param>
        /// <param name="target"></param>
        static void __RemoveFromStack(this UIManagerComponent self, UIWindow target)
        {
            var ui_name    = target.Name;
            var layer_name = target.Layer;

            if (self.window_stack.ContainsKey(layer_name))
            {
                self.window_stack[layer_name].Remove(ui_name);
            }
            else
            {
                Log.Error("not layer, name :" + layer_name);
            }
        }
Example #15
0
        public static async ETTask CloseWindow(this UIManagerComponent self, string ui_name)
        {
            var target = self.GetWindow(ui_name, 1);

            if (target == null)
            {
                return;
            }
            while (target.LoadingState != UIWindowLoadingState.LoadOver)
            {
                await TimerComponent.Instance.WaitAsync(1);
            }
            self.__RemoveFromStack(target);
            self.__InnnerCloseWindow(target);
        }
Example #16
0
        //打开窗口
        public static async ETTask <T> OpenWindow <T, P1, P2, P3, P4>(this UIManagerComponent self, string path, P1 p1, P2 p2, P3 p3, P4 p4,
                                                                      UILayerNames layer_name = UILayerNames.NormalLayer, bool banKey = true) where T : Entity, IAwake, IOnCreate, IOnEnable <P1, P2, P3, P4>, new()
        {
            string ui_name = typeof(T).Name;
            var    target  = self.GetWindow(ui_name);

            if (target == null)
            {
                target = self.__InitWindow <T>(path, layer_name);
                self.windows[ui_name] = target;
            }
            target.Layer  = layer_name;
            target.BanKey = banKey;
            return(await self.__InnerOpenWindow <T, P1, P2, P3, P4>(target, p1, p2, p3, p4));
        }
Example #17
0
        //销毁指定层级外层级所有窗口
        public static async ETTask DestroyWindowExceptLayer(this UIManagerComponent self, UILayerNames layer)
        {
            var keys = self.windows.Keys.ToArray();

            using (ListComponent <ETTask> TaskScheduler = ListComponent <ETTask> .Create())
            {
                for (int i = self.windows.Count - 1; i >= 0; i--)
                {
                    if (self.windows[keys[i]].Layer != layer)
                    {
                        TaskScheduler.Add(self.DestroyWindow(keys[i]));
                    }
                }
                await ETTaskHelper.WaitAll(TaskScheduler);
            }
        }
Example #18
0
        public static async ETTask DestroyWindow(this UIManagerComponent self, string ui_name)
        {
            var target = self.GetWindow(ui_name);

            if (target != null)
            {
                await self.CloseWindow(ui_name);

                Game.EventSystem.Publish(new UIEventType.InnerDestroyWindow()
                {
                    target = target
                });
                self.windows.Remove(target.Name);
                target.Dispose();
            }
        }
Example #19
0
 /// <summary>
 /// 获取最上层window
 /// </summary>
 /// <param name="self"></param>
 /// <returns></returns>
 public static UIWindow GetTopWindow(this UIManagerComponent self)
 {
     for (int i = (byte)UILayerNames.TopLayer; i >= 0; i--)
     {
         var wins = self.window_stack[(UILayerNames)i];
         if (wins.Count <= 0)
         {
             continue;
         }
         var name = wins.First.Value;
         var win  = self.GetWindow(name, 1);
         if (win != null)
         {
             return(win);
         }
     }
     return(null);
 }
Example #20
0
        /// <summary>
        /// 将窗口移到当前层级最上方
        /// </summary>
        /// <param name="self"></param>
        /// <typeparam name="T"></typeparam>
        public static void MoveWindowToTop <T>(this UIManagerComponent self) where T : Entity
        {
            string ui_name = typeof(T).Name;
            var    target  = self.GetWindow(ui_name, 1);

            if (target == null)
            {
                return;
            }
            var layer_name = target.Layer;

            if (self.window_stack[layer_name].Contains(ui_name))
            {
                self.window_stack[layer_name].Remove(ui_name);
            }
            self.window_stack[layer_name].AddFirst(ui_name);
            Game.EventSystem.Publish(new UIEventType.AddWindowToStack()
            {
                window = target
            });
        }
Example #21
0
 public static void SetWidthPadding(this UIManagerComponent self, float value)
 {
     self.WidthPadding = value;
     foreach (var layer in self.window_stack.Values)
     {
         if (layer != null)
         {
             for (LinkedListNode <string> node = layer.First; null != node; node = node.Next)
             {
                 var target = self.GetWindow(node.Value);
                 var win    = target.GetComponent(target.ViewType) as IOnWidthPaddingChange;
                 if (win != null)
                 {
                     EventSystem.Instance.Publish(new UIEventType.OnWidthPaddingChange
                     {
                         entity = win as Entity
                     });
                 }
             }
         }
     }
 }
Example #22
0
 public static void SetNeedTurn(this UIManagerComponent self, bool flag)
 {
     UILayersComponent.Instance.need_turn = flag;
 }
Example #23
0
 public static bool GetNeedTurn(this UIManagerComponent self)
 {
     return(UILayersComponent.Instance.need_turn);
 }
Example #24
0
 public static async ETTask CloseWindow(this UIManagerComponent self, Entity window)
 {
     string ui_name = window.GetType().Name;
     await self.CloseWindow(ui_name);
 }
Example #25
0
 public static async ETTask CloseWindow <T>(this UIManagerComponent self)
 {
     string ui_name = typeof(T).Name;
     await self.CloseWindow(ui_name);
 }
Example #26
0
 public static async ETTask DestroyWindow <T>(this UIManagerComponent self) where T : Entity
 {
     string ui_name = typeof(T).Name;
     await self.DestroyWindow(ui_name);
 }
Example #27
0
 public static Vector2 GetResolution(this UIManagerComponent self)
 {
     return(UILayersComponent.Instance.Resolution);
 }
Example #28
0
 //打开窗口
 public static async ETTask OpenWindowTask <T, P1, P2, P3, P4>(this UIManagerComponent self, string path, P1 p1, P2 p2, P3 p3, P4 p4, UILayerNames layer_name = UILayerNames.NormalLayer) where T : Entity, IAwake, IOnCreate, IOnEnable <P1, P2, P3, P4>, new()
 {
     await self.OpenWindow <T, P1, P2, P3, P4>(path, p1, p2, p3, p4, layer_name);
 }
Example #29
0
 //打开窗口
 public static async ETTask OpenWindowTask <T>(this UIManagerComponent self, string path, UILayerNames layer_name = UILayerNames.NormalLayer) where T : Entity, IAwake, IOnCreate, IOnEnable, new()
 {
     await self.OpenWindow <T>(path, layer_name);
 }
Example #30
0
 public static GameObject GetUICameraGo(this UIManagerComponent self)
 {
     return(UILayersComponent.Instance.UICamera.gameObject);
 }