示例#1
0
 //点击返回按钮
 public void ClickReturn()
 {
     //说明没有反向切换的信息
     if (_stackReturnInfor.Count == 0)
     {
         if (_currentUI.beforeUiId != EUiId.NullUI)
         {
             HideTheUI(_currentUI.uiId, delegate { ShowUI(_currentUI.beforeUiId); });
         }
     }
     //说明有反向切换信息
     else
     {
         UIReturnInfor uiReturnInfor = _stackReturnInfor.Peek();
         if (uiReturnInfor != null)
         {
             //获得当前窗体的ui
             EUiId theId = uiReturnInfor._willBeShowUI.uiId;
             if (_dicShownUI.ContainsKey(theId))
             {
                 HideTheUI(theId, delegate
                 {
                     BaseView baseUI          = _dicAllUI.FirstOrDefault(t => t.Key == uiReturnInfor._listReturn[0]).Value;
                     _dicShownUI[baseUI.uiId] = baseUI;
                     baseUI.gameObject.SetActive(true);
                     _currentUI = baseUI;
                     //pop是把栈顶元素删除
                     _stackReturnInfor.Pop();
                 });
             }
         }
     }
 }
示例#2
0
 //检测栈的顺序是否被打乱。如果被打乱了就清空栈
 public void CheckStack(BaseView baseUi)
 {
     if (_stackReturnInfor.Count > 0)
     {
         //peek是取出栈顶的栈顶元素
         UIReturnInfor uiReturnInfor = _stackReturnInfor.Peek();
         if (uiReturnInfor._willBeShowUI != baseUi)//说明栈被打乱
         {
             _stackReturnInfor.Clear();
         }
     }
 }
示例#3
0
    //把窗体添加进栈stackReturnInfor
    public void UpDateStack(BaseView baseUI)
    {
        if (baseUI.isReturnInfo)
        {
            baseUI.currentDepth = _currentUI.currentDepth + 1;
            baseUI.beforeUiId   = _currentUI.uiId;
            //将要移除的窗体的id列表
            List <EUiId> removeKey = new List <EUiId>();;
            //存放需要添加进栈的窗体列表
            List <BaseView> maxToMinUi = new List <BaseView>();
            //存放depth值从大到小排序后的窗体id
            List <EUiId> newList = new List <EUiId>();
            //新建栈体信息
            UIReturnInfor uiReturnInfor = new UIReturnInfor();
            if (_dicShownUI.Count > 0)
            {
                foreach (KeyValuePair <EUiId, BaseView> item in _dicShownUI)
                {
                    if (!item.Value.isReturnInfo)
                    {
                        removeKey.Add(item.Key);
                    }
                    else
                    {
                        maxToMinUi.Add(item.Value);
                    }
                }
                if (removeKey != null)
                {
                    for (int i = 0; i < removeKey.Count; i++)
                    {
                        HideTheUI(removeKey[i]);
                    }
                }
                //把进栈的窗体按照depth值从大到小排序
                if (maxToMinUi.Count > 0)
                {
                    maxToMinUi.Sort(delegate(BaseView a, BaseView b) { return(a.currentDepth.CompareTo(b.currentDepth)); });
                    for (int i = 0; i < maxToMinUi.Count; i++)
                    {
                        newList.Add(maxToMinUi[i].uiId);
                    }

                    uiReturnInfor._willBeShowUI = baseUI;
                    uiReturnInfor._listReturn   = newList;
                    _stackReturnInfor.Push(uiReturnInfor);
                }
            }
        }
        CheckStack(baseUI);
    }
示例#4
0
 //检测栈的顺序是否被打乱。如果被打乱了就清空栈
 public void CheckStack(BaseView baseUi)
 {
     if (baseUi.isNeedUpdateStack)
     {
         if (stackReturnInfor.Count > 0)
         {
             //peek是取出栈顶的栈顶元素
             UIReturnInfor uiReturnInfor = stackReturnInfor.Peek();
             if (uiReturnInfor.willBeShowUI != baseUi)//说明栈被打乱
             {
                 stackReturnInfor.Clear();
             }
         }
     }
 }
示例#5
0
    //点击返回按钮
    public void ClickReturn()
    {
        if (stackReturnInfor.Count == 0)//说明没有反向切换的信息
        {
            if (currentUI == null)
            {
                return;
            }
            EUiId beforeUiId = currentUI.beforeUiId;
            if (beforeUiId != EUiId.NullUI)
            {
                HideUI(currentUI.uiId, delegate { ShowUI(beforeUiId); });
            }
        }
        else //说明有反向切换信息
        {
            UIReturnInfor uiReturnInfor = stackReturnInfor.Peek();
            if (uiReturnInfor != null)
            {
                //获得当前窗体的ui
                EUiId theId = uiReturnInfor.willBeShowUI.uiId;
                if (dicShownUI.ContainsKey(theId))
                {
                    HideUI(theId, delegate
                    {
                        //如果是第一个窗体(depth值最大的窗体),并且没有显示出来
                        if (!dicShownUI.ContainsKey(uiReturnInfor.listReturn[0]))
                        {
                            BaseView baseUI = GetBaseUI(uiReturnInfor.listReturn[0]);
                            baseUI.ShowUI();
                            dicShownUI[baseUI.uiId] = baseUI;

                            //this.beforeUI = currentUI;
                            currentUI = baseUI;
                            //pop是把栈顶元素删除
                            stackReturnInfor.Pop();
                        }
                    });
                }
            }
        }
    }
示例#6
0
    //把窗体添加进栈stackReturnInfor
    public void UpDateStack(BaseView baseUI)
    {
        if (baseUI.isNeedUpdateStack)
        {
            //将要移除的窗体的id列表
            List <EUiId> removeKey = null;

            //存放需要添加进栈的窗体列表
            List <BaseView> maxToMinUi = new List <BaseView>();

            //存放depth值从大到小排序后的窗体id
            List <EUiId> newList = new List <EUiId>();

            UIReturnInfor uiReturnInfor = new UIReturnInfor();

            if (dicShownUI.Count > 0)
            {
                foreach (KeyValuePair <EUiId, BaseView> item in dicShownUI)
                {
                    if (item.Value.rootType != EUIRootType.KeepAbove)
                    {
                        item.Value.HideUI();
                        if (removeKey == null)
                        {
                            removeKey = new List <EUiId>();
                        }
                        removeKey.Add(item.Key);
                    }
                    if (item.Value.isNeedUpdateStack)
                    {
                        maxToMinUi.Add(item.Value);
                    }
                }
                if (removeKey != null)
                {
                    for (int i = 0; i < removeKey.Count; i++)
                    {
                        dicShownUI.Remove(removeKey[i]);
                    }
                }
                //把进栈的窗体按照depth值从大到小排序
                if (maxToMinUi.Count > 0)
                {
                    maxToMinUi.Sort(delegate(BaseView a, BaseView b) { return(a.CurrentDepth.CompareTo(b.CurrentDepth)); });

                    for (int i = 0; i < maxToMinUi.Count; i++)
                    {
                        newList.Add(maxToMinUi[i].uiId);
                    }

                    uiReturnInfor.willBeShowUI = baseUI;
                    uiReturnInfor.listReturn   = newList;
                    stackReturnInfor.Push(uiReturnInfor);
                }
            }
        }
        else
        {
            if (baseUI.showMode == EShowUIMode.NoReturn)
            {
                HideAllUI(true);
            }
        }
        CheckStack(baseUI);
    }