精华内容
下载资源
问答
  • 这里我要自我检讨一下,我根据自己的认知对vue-router的路径进行保存,花费时间和精力,这里 我贴出一段错误代码 我的理解是这样的 // 首先获取当前路由对象 let route = this.$route.matched.pop();...

    这里我要自我检讨一下,我根据自己的认知对vue-router的路径进行保存,花费时间和精力,这里 我贴出一段我自己的代码
    我的理解是这样的

    	// 首先获取当前路由对象
    	let route = this.$route.matched.pop();
    	getRouterBran (route ) { 
    		// 检测当前路由是否为一级路由,一级路由我不会写name属性,
          	if (!router.name) return // 检测到 router.name === 'undefined' 截断函数
    		//不是 则进行下一步
          	let obj = {name:router.name,path:router.path}
          	// 把this.navPath内的所有值转换成字符,以便检测当前数组中是否已有路由对象
          	let matech = this.navPath.map(val => {
            	return JSON.stringify(val)
         	})
         	// 检测是否已有对象
          	if (!matech.includes(JSON.stringify(obj))) {
          		// 没有,加入数组
           		this.navPath.push(obj)
           		//判断当前路由是否有父级
            	if (router.parent) {
            		// 有,则有两种情况,父级为一级路由,父级不为一级路由
            		// 为一级路由,则截断函数
              		if(!router.parent.name) return
              		// 不为一级,则递归继续往上查找,并添加路径
              		this.getBreadcrumb(router.parent)
            	}
          	}
          	//将获取到的路径倒转,得到正常路径
          	this.navPath = this.navPath.reverse()
        }
        //然后将这个方法放在
        created () {
        	this.getRouterBran(this.$route.matched.pop())
        },
        watch:{
    		$router () {
        		this.getRouterBran(this.$route.matched.pop())
    		}
    	}
    

    这个方法,得到了我想要的面包屑,但是,我发现,我的二级路由视图根本没有效果,router-view标签没有效果

    而且Vue还不报错,路由也不报错,当我满心欢喜的去点面包屑,发现,面包屑是有效果的,但是路由调到二级页面,二级路由压根就不知道你点了你说的是啥,但是路由的URL又是跳了的

    在这里,我表示很方,查找了一个下午,我终是没有查到原因

    解决并作出面包屑的效果

    这里UI方面我使用了elementUI的面包屑UI组件
    如下:

    
     <el-breadcrumb separator-class="el-icon-arrow-right">
       <el-breadcrumb-item v-for ='(item, index) in navPath':to="item.path" :key='index'>{{item.name}}</el-breadcrumb-item>
     </el-breadcrumb>
     
    

    然后js代码

    	getRouterBran () {
    		//$route.matched属性 包含当前路由的所有 嵌套路径片段 的路由记录
    		// 当 URL 为 /foo/bar,$route.matched 将会是一个包含从上到下的所有嵌套路由对象 (副本),比如上面路由为二级路由,
    		
    		// 那么$route.matched的值为[{foo路由对象},{bar路由对象}]
    		//当url地址为/foo
    		// 那么$route.matched的值为[{foo路由对象}]
    		
    		//当url地址为/home
    		// 那么$route.matched的值为[{home路由对象}]
    		
    		let matche = this.$route.matched()
    		//所以 我这里以 /foo/bar为列
    		// 得到嵌套的路由对象记录,筛选排除一些路由,条件自定
    		// 我这里是筛选排除不带name 的路由,自己决定
    		matche = matche.filter(item => item.name)
    		this.navPath = matche
    	}
    

    实际代码就是这么多,三行 脑力的教训啊,使用轮子,还是多看别人的文档,

    我写的方法,是可以做出来面包屑的,但是二级路由就是不能渲染出来,就好像router-view没有检测到二级路由的变化一样

    展开全文
  • 2.直接利用键盘输入你的层级内容,输完一行后直接利用回车键换行,括号内容会自动对齐将第一层级输入完毕后,将光标移到需要输入第二层级的后面。   利用键盘将同一个层级的内容输入完毕   3.用相同的...

            MathType数学公式编辑器编辑公式的能力很强大,利用MathType可以编辑出任何想要的数学公式。但是利用MathType不仅仅可以编辑公式,还可以制作层级关系。那么MathType层级关系怎么做呢?
            具体步骤如下:
            1.打开MathType编辑窗口,选择括号模板中的左边大括号模板(或者右边、两边,具体哪个模板根据你要画的类型来选择)。
     

    103129_5K9U_2459792.jpg

    在MathType窗口中根据需要选择大括号模板

            2.直接利用键盘输入你的层级内容,输完一行后直接利用回车键换行,括号内容会自动对齐将第一层级输入完毕后,将光标移到需要输入第二层级的后面。
     

    103152_P0L5_2459792.jpg

    利用键盘将同一个层级的内容输入完毕

            3.用相同的方法进行第三层级的输入,对于没有第二层级的部分不用输入,MathType会自动将内容对齐。
     

    103210_IttA_2459792.jpg

    用相同的方法输入同一个层级的内容

            注意:1.在用括号输入层级时选择大括号后就不要再使用矩阵模板了,否则会出现同一个层级的内容无法左对齐的情况,这是因为MathType将内容默认为了矩阵元素会自动将之居中对齐。
     

    103229_CdUO_2459792.jpg

    使用大括号模板后不再使用矩阵模板

            2.对层级内容进行输入后一定要先将同一层级的内容输入完成后再进行下一层级的输入,否则也会出现内容无法在括号内居中对齐的情况。
     

    103256_R6J4_2459792.jpg

    先将同一层级的内容输入完成后再进行下一层级的输入

            以上内容向大家介绍了MathType层级关系的制作过程,最主要是对MathType大括号模板的应用以及在输入时的顺序问题,否则就会出现无法对齐的情况,调整起来比较麻烦。

    转载于:https://my.oschina.net/mathtype/blog/540085

    展开全文
  • link环境下制作的《网盘软件》,按照不同层级返点怎么实现?
  • 使用v-for循环生成一个多级嵌套菜单栏,只要你学会了这个方法,几乎所有的菜单栏都可以实现了。 实例1:不能伸缩的多级...实例2:使用element-ui的组件制作一个无限层级树形伸缩菜单栏  请猛戳这里 (完)

            使用v-for循环生成一个多级嵌套菜单栏,只要你学会了这个方法,几乎所有的菜单栏都可以实现了。

    实例1:不能伸缩的多级菜单栏

    现在以一个三级菜单栏为例:

    <div class="level-one" v-if="obj.level == 1" v-for="obj in bar1"><a>{{obj.title}}</a>
      <div class="level-two" v-if="obj1.parentId == obj.id " v-for="obj1 in bar1"><a>{{obj1.title}}</a>
        <div class="level-three" v-if="obj2.parentId == obj1.id" v-for="obj2 in bar1"><a>{{obj2.title}}</a></div>
      </div>
    </div>
    .level-one{
      text-indent: 1em;
    }
    .level-two{
      text-indent: 2em;
    }
    .level-three{
      text-indent: 3em;
    }
    bar1:[
      /*所有第一级菜单*/
      {
        title:'一级菜单(1)',
        id:1,             //选项的唯一ID
        parentId:0,       //父级的ID
        level:1           //所处的层级
      },
      {
        title:'一级菜单(2)',
        id:2,
        parentId:0,
        level:1
      },
      {
        title:'一级菜单(3)',
        id:3,
        parentId:0,
        level:1,
      },
    
      /*所有二级菜单*/
      {
        title:'二级菜单(1.1)',
        id:4,
        parentId:1,
        level:2
      },
      {
        title:'二级菜单(1.2)',
        id:5,
        parentId:1,
        level:2
      },
      {
        title:'二级菜单(2.1)',
        id:6,
        parentId:2,
        level:2
      },
      {
        title:'二级菜单(2.2)',
        id:7,
        parentId:2,
        level:2
      },
    
      /*所有三级菜单*/
      {
        title:'三级菜单(1.1.1)',
        id:8,
        parentId:4,
        level:3
      },
      {
        title:'三级菜单(1.1.2)',
        id:9,
        parentId:4,
        level:3
      }
    ]

    解释:

    1)菜单栏嵌套了多少层,就需要进行多少次v-for循环;

    2)通过v-if来选择level=1的选项作为最外层;

    3)通过判断选项的parentId等于上一层的id,来确定它是哪个选项的子级菜单;

    4)同理,多级菜单,依次进行循环。

    实例2:使用element-ui的组件制作一个无限层级树形伸缩菜单栏 

    请猛戳这里

    (完)

    展开全文
  • javascript层级菜单

    2009-06-12 20:01:41
    通过使用javascript制作层级菜单
  • UI框架中UI窗体的“层级管理”,最核心的问题是如何进行窗体的显示管理。窗体(预设)的显示我们前面定义了三种类型: 普通、隐藏其他、反向切换。 “普通显示”模式允许多个窗体同时显示,这种类型应用最多。 ...

    UI框架中UI窗体的“层级管理”,最核心的问题是如何进行窗体的显示管理。窗体(预设)的显示我们前面定义了三种类型: 普通、隐藏其他、反向切换。

    “普通显示”模式允许多个窗体同时显示,这种类型应用最多。

    “隐藏其他界面” 模式一般应用于全局性的窗体。我们在开发此类窗体时,为了减少UI渲染压力、提高Unity渲染效率,则设置被覆盖的窗体为“不可见”状态。(即: this.gameObject.SetActive(false))。例如一般的登录窗体、选择英雄窗体等。

    “反向切换”模式类型,一般都大量引用于“弹出窗体”中。此类窗体的特点是:显示弹出窗体时不完全覆盖底层窗体,一般在屏幕的四周会露出底层窗体。之所以命名“反向切换”是因为: 程序员要维护一种“后进先出”的“栈”的数据结构特点,即我们一般要求玩家必须先关闭弹出的顶层窗体,再依次关闭下一级窗体。

    一般我们都要求玩家先处理弹出窗体中的信息,然后关闭此窗体。一般不允许在没有关闭子窗体的情况下,直接点击父窗体。以上说了这么多了,对于“层级管理”的核心代码实现,基本都体现在“UI管理器脚本” (UIManager.cs )中。

    public class UiManager : MonoBehaviour
    {
        private static UiManager _instance;
        /// <summary>
        /// 得到实例
        /// </summary>
        public static UiManager Instance()
        {
            if (_instance == null)
            {
                _instance = new GameObject("UiManager").AddComponent<UiManager>();
            }
            return _instance;
        }
        private UiManager() { }
    
        //UI窗体预设路径(参数1:窗体预设名称,2:表示窗体预设路径)
        private Dictionary<UiWind, string> _dicFormsPaths;
        //缓存所有UI窗体
        private Dictionary<string, BaseUiFrame> _dicAllUiForms;
        //当前显示的UI窗体
        private Dictionary<string, BaseUiFrame> _dicCurrentShowUiForms;
        //定义“栈”集合,存储显示当前所有[反向切换]的窗体类型
        private Stack<BaseUiFrame> _staCurrentUiForms;
    
        //UI根节点
        private Transform CanvasTrans;
        //全屏幕显示的节点
        private Transform _normalTrans;
        //固定显示的节点
        private Transform _fixedTrans;
        //弹出节点
        private Transform _popUpTrans;
    
        //UI管理脚本的节点
        private Transform _uiScriptsTrans;
    
        //初始化核心数据,加载“UI窗体路径”到集合中。
        public void Awake()
        {
            _dicAllUiForms = new Dictionary<string, BaseUiFrame>();
            _dicCurrentShowUiForms = new Dictionary<string, BaseUiFrame>();
            _dicFormsPaths = new Dictionary<UiWind, string>();
            _staCurrentUiForms = new Stack<BaseUiFrame>();
            //初始化加载(根UI窗体)Canvas预设
            InitRootCanvasLoading();
            //得到UI根节点、全屏节点、固定节点、弹出节点
            CanvasTrans = GameObject.FindGameObjectWithTag("Canvas").transform;
            _normalTrans = CanvasTrans.transform.Find("Normal");
            _fixedTrans = CanvasTrans.transform.Find("Fixed");
            _popUpTrans = CanvasTrans.transform.Find("PopUp");
            _uiScriptsTrans = CanvasTrans.transform.Find("Scripts");
    
            //把本脚本作为“根UI窗体”的子节点。
            gameObject.transform.SetParent(_uiScriptsTrans, false);
    
            DontDestroyOnLoad(CanvasTrans);//"根UI窗体"在场景转换的时候,不允许销毁
            //初始化“UI窗体预设”路径数据
            InitUiFormsPathData();
        }
        /// <summary>
        /// 初始化“UI窗体预设”路径数据
        /// </summary>
        private void InitUiFormsPathData()
        {
            TextAsset textAsset = Resources.Load<TextAsset>("ResCfgs/UiWind");
            if (!textAsset)
            {
                Debug.Log("Xml file:" + "ResCfgs / UiWind" + "not exist");
            }
            else
            {
                XmlDocument xmlDocument = new XmlDocument();
                xmlDocument.LoadXml(textAsset.text);
                XmlNodeList xmlNodeList = xmlDocument.SelectSingleNode("root")?.ChildNodes;
                if (xmlNodeList != null)
                    for (int i = 0; i < xmlNodeList.Count; i++)
                    {
                        XmlElement xmlElement = (XmlElement)xmlNodeList[i];
                        if (xmlElement != null && xmlElement.GetAttributeNode("ID") == null)
                        {
                            continue;
                        }
                        int id = Convert.ToInt32(xmlElement?.GetAttributeNode("ID")?.InnerText);
                        UiWindCfg uiWindCfgData = new UiWindCfg
                        {
                            Id = id,
                        };
                        foreach (XmlElement element in xmlNodeList[i].ChildNodes)
                        {
                            switch (element.Name)
                            {
                                case "key":
                                    uiWindCfgData.Key = (UiWind)Enum.Parse(typeof(UiWind), element.InnerText);
                                    break;
                                case "path":
                                    uiWindCfgData.Value = element.InnerText;
                                    break;
                            }
                        }
                        _dicFormsPaths.Add(uiWindCfgData.Key, uiWindCfgData.Value);
                    }
            }
        }
        //初始化加载(根UI窗体)Canvas预设
        private void InitRootCanvasLoading()
        {
            ResourcesMgr.Instance().LoadAsset("ResUi/Canvas", false);
        }
    
        /// <summary>
        /// 显示(打开)UI窗体
        /// 功能:
        /// 1: 根据UI窗体的名称,加载到“所有UI窗体”缓存集合中
        /// 2: 根据不同的UI窗体的“显示模式”,分别作不同的加载处理
        /// </summary>
        /// <param name="uiFormName">UI窗体预设的名称</param>
        public void ShowUiForms(string uiFormName)
        {
            //参数的检查
            if (uiFormName == null) return;
            //根据UI窗体的名称,加载到“所有UI窗体”缓存集合中
            var baseUiForms = LoadFormsToAllUiFormsCatch(uiFormName);
    
            if (baseUiForms == null) return;
            //根据不同的UI窗体的显示模式,分别作不同的加载处理
            switch (baseUiForms.CurrentUiType.UiShowMode)
            {
                case UiShowMode.Normal:                 //“普通显示”窗口模式
                    //把当前窗体加载到“当前窗体”集合中。
                    LoadUiToCurrentCache(uiFormName);
                    break;
                case UiShowMode.ReverseChange:          //需要“反向切换”窗口模式
                    PushUiFormToStack(uiFormName);
                    break;
                case UiShowMode.HideOther:              //“隐藏其他”窗口模式
                    EnterUiFormsAndHideOther(uiFormName);
                    break;
            }
        }
    
        /// <summary>
        /// 关闭(返回上一个)窗体
        /// </summary>
        /// <param name="uiFormName"></param>
        public void CloseUiForms(string uiFormName)
        {
            //参数检查
            //“所有UI窗体”集合中,如果没有记录,则直接返回
            if (uiFormName == null)
            {
                return;
            }
            _dicAllUiForms.TryGetValue(uiFormName, out var baseUiForm);
            if (baseUiForm != null)
            {
                switch (baseUiForm.CurrentUiType.UiShowMode)
                {
                    case UiShowMode.Normal:
                        //普通窗体的关闭
                        ExitUiForms(uiFormName);
                        break;
                    case UiShowMode.ReverseChange:
                        //反向切换窗体的关闭
                        PopUiForms();
                        break;
                    case UiShowMode.HideOther:
                        //隐藏其他窗体关闭
                        ExitUiFormsAndDisplayOther(uiFormName);
                        break;
                }
            }
            if (baseUiForm == null)
            {
                return;
            }
            //根据窗体不同的显示类型,分别作不同的关闭处理
    
        }
        /// <summary>
        /// 根据UI窗体的名称,加载到“所有UI窗体”缓存集合中
        /// 功能: 检查“所有UI窗体”集合中,是否已经加载过,否则才加载。
        /// </summary>
        /// <param name="uiFormsName">UI窗体(预设)的名称</param>
        private BaseUiFrame LoadFormsToAllUiFormsCatch(string uiFormsName)
        {
            _dicAllUiForms.TryGetValue(uiFormsName, out BaseUiFrame baseUiResult);
            if (baseUiResult == null)
            {
                //加载指定名称的“UI窗体”
                baseUiResult = LoadUiForm(uiFormsName);
            }
    
            return baseUiResult;
        }
        /// <summary>
        /// 加载指定名称的“UI窗体”
        /// 功能:
        ///    1:根据“UI窗体名称”,加载预设克隆体。
        ///    2:根据不同预设克隆体中带的脚本中不同的“位置信息”,加载到“根窗体”下不同的节点。
        ///    3:隐藏刚创建的UI克隆体。
        ///    4:把克隆体,加入到“所有UI窗体”(缓存)集合中。
        /// </summary>
        /// <param name="uiFormName">UI窗体名称</param>
        private BaseUiFrame LoadUiForm(string uiFormName)
        {
            GameObject cloneUiPrefabs = null;             //创建的UI克隆体预设
            UiWind uiWind = (UiWind)Enum.Parse(typeof(UiWind), uiFormName);
            //根据UI窗体名称,得到对应的加载路径
            _dicFormsPaths.TryGetValue(uiWind, out string strUiFormPaths);
            //根据“UI窗体名称”,加载“预设克隆体”
            if (strUiFormPaths != null)
            {
                cloneUiPrefabs = ResourcesMgr.Instance().LoadAsset(strUiFormPaths, false);
            }
            //设置“UI克隆体”的父节点(根据克隆体中带的脚本中不同的“位置信息”)
            if (CanvasTrans != null && cloneUiPrefabs != null)
            {
                BaseUiFrame baseUiForm = cloneUiPrefabs.GetComponent<BaseUiFrame>();   //窗体基类
                if (baseUiForm == null)
                {
                    Debug.Log("baseUiForm==null! ,请先确认窗体预设对象上是否加载了baseUIForm的子类脚本! 参数 uiFormName=" + uiFormName);
                    return null;
                }
                switch (baseUiForm.CurrentUiType.UiWindType)
                {
                    case UiWindType.Normal:                 //普通窗体节点
                        cloneUiPrefabs.transform.SetParent(_normalTrans, false);
                        break;
                    case UiWindType.Fixed:                  //固定窗体节点
                        cloneUiPrefabs.transform.SetParent(_fixedTrans, false);
                        break;
                    case UiWindType.PopUp:                  //弹出窗体节点
                        cloneUiPrefabs.transform.SetParent(_popUpTrans, false);
                        break;
                }
                //设置隐藏
                cloneUiPrefabs.SetActive(false);
                //把克隆体,加入到“所有UI窗体”(缓存)集合中。
                _dicAllUiForms.Add(uiFormName, baseUiForm);
                return baseUiForm;
            }
            else
            {
                Debug.Log("_TraCanvasTransfrom==null Or goCloneUIPrefabs==null!! ,Plese Check!, 参数uiFormName=" + uiFormName);
            }
    
            Debug.Log("出现不可以预估的错误,请检查,参数 uiFormName=" + uiFormName);
            return null;
        }
        /// <summary>
        /// 把当前窗体加载到“当前窗体”集合中
        /// </summary>
        /// <param name="uiFormName">窗体预设的名称</param>
        private void LoadUiToCurrentCache(string uiFormName)
        {
            //如果“正在显示”的集合中,存在整个UI窗体,则直接返回
            _dicCurrentShowUiForms.TryGetValue(uiFormName, out BaseUiFrame baseWind);
            if (baseWind != null) return;
            //把当前窗体,加载到“正在显示”集合中
            _dicAllUiForms.TryGetValue(uiFormName, out var baseUiWindAllCache);
            if (baseUiWindAllCache != null)
            {
                _dicCurrentShowUiForms.Add(uiFormName, baseUiWindAllCache);
                baseUiWindAllCache.Display();           //显示当前窗体
            }
        }
    
        /// <summary>
        /// UI窗体入栈
        /// </summary>
        /// <param name="uiFormName">窗体的名称</param>
        private void PushUiFormToStack(string uiFormName)
        {
            //判断“栈”集合中,是否有其他的窗体,有则“冻结”处理。
            if (_staCurrentUiForms.Count > 0)
            {
                BaseUiFrame topUiForm = _staCurrentUiForms.Peek();
                //栈顶元素作冻结处理
                topUiForm.Freeze();
            }
            //判断“UI所有窗体”集合是否有指定的UI窗体,有则处理。
            _dicAllUiForms.TryGetValue(uiFormName, out BaseUiFrame baseWind);
            if (baseWind != null)
            {
                baseWind.Display();//当前窗口显示状态
                //把指定的UI窗体,入栈操作。
                _staCurrentUiForms.Push(baseWind);
            }
            else
            {
                Debug.Log("baseUIForm==null,Please Check, 参数 uiFormName=" + uiFormName);
            }
        }
        /// <summary>
        /// 退出指定UI窗体
        /// </summary>
        /// <param name="strUiFormName"></param>
        private void ExitUiForms(string strUiFormName)
        {
            //"正在显示集合"中如果没有记录,则直接返回。
            _dicCurrentShowUiForms.TryGetValue(strUiFormName, out BaseUiFrame baseUiForm);
            if (baseUiForm == null) return;
            //指定窗体,标记为“隐藏状态”,且从"正在显示集合"中移除。
            baseUiForm.Hiding();
            _dicCurrentShowUiForms.Remove(strUiFormName);
        }
    
        //(“反向切换”属性)窗体的出栈逻辑
        private void PopUiForms()
        {
            if (_staCurrentUiForms.Count >= 2)
            {
                //出栈处理
                BaseUiFrame topUiForms = _staCurrentUiForms.Pop();
                //做隐藏处理
                topUiForms.Hiding();
                //出栈后,下一个窗体做“重新显示”处理。
                BaseUiFrame nextUiForms = _staCurrentUiForms.Peek();
                nextUiForms.Redisplay();
            }
            else if (_staCurrentUiForms.Count == 1)
            {
                //出栈处理
                BaseUiFrame topUiForms = _staCurrentUiForms.Pop();
                //做隐藏处理
                topUiForms.Hiding();
            }
        }
        /// <summary>
        /// (“隐藏其他”属性)打开窗体,且隐藏其他窗体
        /// </summary>
        /// <param name="strUiName">打开的指定窗体名称</param>
        private void EnterUiFormsAndHideOther(string strUiName)
        {
            //参数检查
            if (strUiName == null) return;
    
            _dicCurrentShowUiForms.TryGetValue(strUiName, out BaseUiFrame baseWind);
            if (baseWind != null) return;
    
            //把“正在显示集合”与“栈集合”中所有窗体都隐藏。
            foreach (BaseUiFrame baseUi in _dicCurrentShowUiForms.Values)
            {
                baseUi.Hiding();
            }
            foreach (BaseUiFrame staUi in _staCurrentUiForms)
            {
                staUi.Hiding();
            }
    
            //把当前窗体加入到“正在显示窗体”集合中,且做显示处理。
            _dicAllUiForms.TryGetValue(strUiName, out BaseUiFrame baseUiWindAllCache);
            if (baseUiWindAllCache != null)
            {
                _dicCurrentShowUiForms.Add(strUiName, baseUiWindAllCache);
                //窗体显示
                baseUiWindAllCache.Display();
            }
        }
    
        /// <summary>
        /// (“隐藏其他”属性)关闭窗体,且显示其他窗体
        /// </summary>
        /// <param name="strUiName">打开的指定窗体名称</param>
        private void ExitUiFormsAndDisplayOther(string strUiName)
        {
            //参数检查
            if (strUiName == null) return;
    
            _dicCurrentShowUiForms.TryGetValue(strUiName, out var baseUiForm);
            if (baseUiForm == null) return;
    
            //当前窗体隐藏状态,且“正在显示”集合中,移除本窗体
            baseUiForm.Hiding();
            _dicCurrentShowUiForms.Remove(strUiName);
    
            //把“正在显示集合”与“栈集合”中所有窗体都定义重新显示状态。
            foreach (BaseUiFrame baseUi in _dicCurrentShowUiForms.Values)
            {
                baseUi.Redisplay();
            }
            foreach (BaseUiFrame staUi in _staCurrentUiForms)
            {
                staUi.Redisplay();
            }
        }
    }

    以上代码解释:

    一:上述代码中重要字段的解释如下:
        1:  “_DicFormsPaths” 表示“UI窗体预设路径”集合,负责缓存所有UI窗体预设的名称与对应资源路径的关系。
      2: “ _DicALLUIForms” 表示“所有UI窗体”集合,负责缓存已经加载过的所有UI窗体名称以及与之对应的UI窗体。
      3: “_DicCurrentShowUIForms”表示“当前正在显示”集合,负责控制正在显示UI窗体的内部逻辑。
      4: UI管理器脚本中的“_TraCanvasTransfrom”、“_TraNormal”、“_TraFixed”、“_TraPopUp”、“_TraUIScripts”,分别表示Unity层级视图中的根结点、普通节点、固定节点、弹出节点、管理脚本节点,这些节点是加载UI窗体的不同类型的父节点,用于各种UI窗体的管理工作。

    二:上述代码中重要方法的解释如下:

      1: ShowUIForms()  是外部程序调用本框架的对外公共方法,负责加载、缓存、打开与显示制定窗体名称的UI窗体预设。
      2: LoadFormsToAllUIFormsCatch() 是根据UI窗体的名称,加载到“所有UI窗体”缓存集合中。
      3: LoadUIToCurrentCache() 是把当前窗体加载到“当前窗体”集合中。

        1: UIManager.cs  中定义的新的字段 ,“_StaCurrentUIForms” 就是一个“栈”数据类型,用于维护一种后进先出的数据结构。常见的方法如下:

          C#语言中提供 Stack<T> 泛型集合,来直接实现这种结构。 
    常用属性与方法:

    •  Count 属性  查询栈内元素数量
    •  Push()      压栈
    •  Pop()       出栈
    •  Peek()      查询栈顶元素
    •  GetEnumerator() 遍历栈中所有元素

    UIManager.cs 中的“ShowUIForms()”方法中,就是专门处理“反向切换”与“隐藏其他”窗体特性的实现方法。

    项目源码工程下载地址:https://github.com/AnderTroy/UIFrameWork

    展开全文
  • 2.1定义层级 说明:这个层级上的定义主要是为了防止图片的叠加,造成视觉上的不好效果。 Sorting Layer能定义层级,我们点击进去设置层级, 我们的打飞机游戏主要分为这几层,Bg为背景层,Lead为主角层,UI为UI层,...
  • 这是一张漏斗层级关系PPT图表,第一PPT模板网提供幻灯片免费下载。 本图表用灰色,紫色构成的漏斗作为主要元素,适用于各个行业和机构层级关系的幻灯片制作。 扩展阅读:14张通用实用PPT图表打包下载 关键词:层级...
  • 这是一张圆形层级关系PPT图表,第一PPT模板网提供幻灯片模板免费下载。 PPT图表用红色、浅红、黄色构成了一个包含关系维恩图,右边用直线引出了文字内容,图表清晰直观,适合用来制作PowerPoint的层级关系。 ...
  • 层级菜单在Unity中用到的并不多,主要是做分类的时候用的比较多,今天就给大家分享几个层级代码,扩充一下,写成插件也是不错的。
  • 这是一张漏斗层级关系PPT图表,第一PPT模板网提供幻灯片免费下载。 本图表用灰色,紫色构成的漏斗作为主要元素,适用于各个行业和机构层级关系的幻灯片制作。 扩展阅读:14张通用实用PPT图表打包下载 关键词:...
  • 这是一张米尺构成的层级关系幻灯片图表,第一PPT模板网提供幻灯片图表免费下载。 PPT图表使用不同长度设计了三条横着展开的米尺,让人更直观的看到层级的差别和具体的数值,右面圆形上面标注了文字,本张幻灯片图表...
  • BAT的职位层级

    千次阅读 2019-05-07 19:04:53
    【阿里的职位层级】 分为技术岗(P5-P11)和管理岗(M1-M10),一般研究生毕业从P5开始,前几年也有从P4开始的,M2是经理,M3是资深经理,M4总监,M5资深总监,M6是副总裁,几十个人,M7和M8是资深副总裁,类似于张宇、...
  • NGUI的渲染层级顺序是由UIPanel来确定的,看源码我们得知UIPanel下的所有UIWidget的RenderQueue是递增的。 而Unity的物体,如果是Transparent渲染的话,会和NGUI一样,这就有可能处于同一层级导致随机前后的情况。 ...
  • 这是一张彩色圆环包含层级关系幻灯片图表,第一PPT模板网提供幻灯片图表免费下载。 ppt图表包含四个不同颜色的圆弧,右侧标注了数值百分比,本幻灯片图表适合制作PowerPoint层级关系。 关键词:层级关系PPT图表,...
  • 这是一份采用扁平化设计的,层级关系PPT图表。 本图表适合用于制作企业工作汇报PPT,公司业务内容说明幻灯片等。 关键词:扁平化幻灯片图表素材,层级关系PPT图表,PowerPoint关系图,.PPTX格式;
  • Linux文件层级标准

    2017-04-27 23:57:17
    文件系统标准文件系统标准定义了Unix类操作系统的文件层级标准。由Linux基金会维护。最新的版本是3.0,在2015年一月3日发布。当前值用于Linux系列。 1. 目的架构 2. 遵循文件层级标准 3. 历史 1. 相关历史 ...
  • RecyclerView用多层级TreeView
  • UINavigationBar的视图层级关系

    千次阅读 2016-04-08 11:01:48
    用它来探究一下UINavigationBar的视图层级关系。触发我去看这个的原因是我在学习《动态修改UINavigationBar的背景颜色》中遇到了疑问。下面集合小例子来说明探究结果。从view hierarchy可以看到,当为navigationBar...
  • 这是三张立体水晶锥形图层级关系幻灯片图表,第一PPT模板网提供幻灯片图表免费下载。 PowerPoint图表用四个颜色构成的锥形图作为PPT背景图片,有并列的水晶金字塔,有递进的金字塔,PPT图表适合用来制作PowerPoint...
  • 【巨人的肩膀上制造世界】——2——Unity3D实用插件之QHierarchy,更方便的管理你的层级面板,全中文教程! 目录 1、博客介绍 2、QHierarchy介绍 3、QHierarchy操作详解 4、推送 5、结语 1、博客介绍 这是...
  • 【Unity3D】UGUI实现层级菜单

    千次阅读 2019-08-30 18:43:42
    层级菜单在Unity中用到的并不多,主要是做分类的时候用的比较多,今天就给大家分享几个层级代码,扩充一下,写成插件也是不错的。 首先看一下效果吧: 1. 2. 3. 4. 5. 二、资源下载 源文件: ...
  • 文章目录一、前言 一、前言 点关注不迷路,持续输出Unity干货...这真是太糟糕了,我们希望粒子可以被ScrollView裁切,可以通过Mask组件通过Image蒙版来显示,可以按照UGUI的层级关系处理UI对象与粒子的渲染顺序。 ...
  • 递进层级关系PowerPoint图表素材免费下载,关键词:递进关系、层级关系PPT图表模板,.PPTX格式;
  • 在cg制作过程中,为了统一制作规范,提高效率我们Pipeline都会制作一个比对层级的工具下面介绍的是maya利用batch文件进行模型与绑定和材质文件进行比对层级。 直接上代码: #!usr/bin/env python # -*- encoding: ...
  • Power BI(三十)power pivot之使用父子层级 原始数据如下:我们加入用数据透视表生成汽车费报销金额非常不友好,所以我们考虑用父子层级关系 非使用父子层级关系利用数据透视表得到下图,非常不好: 我们...
  • 使用Axure做的 2、3层级菜单展开折叠Demo rp 源文件。 点击一级菜单展开二级菜单,点击二级菜单展开三级菜单。 用户可直接下载使用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,314
精华内容 14,125
关键字:

层级制