一、根据源码的学习

发现创建弹窗：使用了一些div来组成

zindex 和 index 是自动生成。

zindex 表示生成的层次关系

index 用来表示各个层的id

默认class名

h = ["layui-layer", ".layui-layer-title", ".layui-layer-main", ".layui-layer-dialog", "layui-layer-iframe", "layui-layer-content", "layui-layer-btn", "layui-layer-close"];

默认按钮

btn: ["确定", "取消"],

默认弹框类型

type: ["dialog", "page", "iframe", "loading", "tips"]

默认动画效果

h.anim = ["layer-anim", "layer-anim-01", "layer-anim-02", "layer-anim-03", "layer-anim-04", "layer-anim-05", "layer-anim-06"],

1、背景层主要是透明度opacity: 或filter:Alpha     class:layui-layer-shade

参数：shade：透明度

times  : id;

2、总层：   class:layui-layer；  layer-anim-编号；  layui-layer-border；layui-layer-（type 名字）

anim[shift]:表示弹出动画

type : 表示弹出层样式

skin ：表示新增样式classname

times: id

time : 时间

area: 表示高和宽

fix ： 表示相对位置

3、总层内：

1、内容   class:layui-layer-content   layui-layer-padding  layui-layer-loading+编号

icon: 表示图标：菊花加载图标或页面图标    class: layui-layer-ico; layui-layer-ico+（icon)

content：

2、底部按钮   layui-layer-btn+(编号)

btn:传入参数数组

3、顶部样式  class="layui-layer-setwin"

closeBtn   class:layui-layer-min  layui-layer-ico layui-layer-max

4、标题   class:layui-layer-title

title:

  1. /*! layer-v2.3 弹层组件 License LGPL  http://layer.layui.com/ By 贤心 */
  2. ; !
  3. /**
  4.  * 其中 c 表示继承了juery的对象
  5.  *      e 表示初始化完成后的对象
  6.  *      h 表示此版本的实例化对象
  7.  */
  8.     function(a, b) {
  9.         "use strict";
  10.         var c, d, e = {
  11.                 //获取加载文件地址上级路径
  12.                 getPath: function() {
  13.                     var a = document.scripts,
  14.                         b = a[a.length - 1],
  15.                         c = b.src;
  16.                     if (!b.getAttribute("merge")) return c.substring(0, c.lastIndexOf("/") + 1)
  17.                 } (),
  18.                 //判断键盘输入数字拒绝enter键
  19.                 enter: function(a) {
  20.                     13 === a.keyCode && a.preventDefault()
  21.                 },
  22.                 //全局参数
  23.                 config: {},
  24.                 end: {},
  25.                 btn: ["确定", "取消"],
  26.                 type: ["dialog", "page", "iframe", "loading", "tips"]
  27.             },
  28.         //f作为内部实例化对象
  29.             f = {
  30.                 v: "2.3",
  31.                 //ie版本
  32.                 ie6: !!a.ActiveXObject && !a.XMLHttpRequest,
  33.                 index: 0,
  34.                 //文件路径：绝对路径
  35.                 path: e.getPath,
  36.                 //自定义全局参数
  37.                 //a是全局对象 b是回调函数
  38.                 config: function(a, b) {
  39.                     var d = 0;
  40.                     return a = a || {},
  41.                         //将 参数对象放入 e中和f的缓存中避免污染全局
  42.                         f.cache = e.config = c.extend(e.config, a),
  43.                         //f.path:修改为传入参数路径，如果没有就是默认加载文件路径
  44.                         f.path = e.config.path || f.path,
  45.                         //是用来扩展的css样式。。查看是否存在，并是否为多个。并将其转换成数组形式。
  46.                     "string" == typeof a.extend && (a.extend = [a.extend]),
  47.                         //执行替换默认css
  48.                         f.use("skin/layer.css",
  49.                             //指定样式，没有的话就传入第二个参数
  50.                             a.extend && a.extend.length > 0 ?
  51.  
  52.                                 //先加载 指定样式避免默认样式被覆盖掉？这样写是有问题的，
  53.                                 function g() {
  54.                                     var c = a.extend;
  55.                                     f.use(
  56.                                         //按顺序加载指定js或css
  57.                                         c[c[d] ? d: d - 1]
  58.                                         ,
  59.                                         //判断指定样式是否全部加载
  60.                                         d < c.length ?
  61.                                             function() {
  62.                                                 return++d,
  63.                                                     //此函数自身 用于回调。
  64.                                                     g
  65.                                             } () : b)
  66.                                 } () :
  67.                                 b),
  68.                         //最终返回这个对象。
  69.                         this
  70.                 },
  71.                 //将引入js或css加入页面中
  72.                 use: function(a, b, d) {
  73.                     //c是juery
  74.                     var e = c("head")[0],
  75.                     //去掉所有的空格
  76.                         a = a.replace(/\s/g, ""),
  77.                     //是否是css文件
  78.                         g = /\.css$/.test(a),
  79.                     //判断是js还是css
  80.                         h = document.createElement(g ? "link": "script"),
  81.                     //定义这个元素id
  82.                         i = "layui_layer_" + a.replace(/\.|\//g, "");
  83.                     //f.path:默认路径和指定路径
  84.                     return f.path ?
  85.                         //f.path存在返回this
  86.                         (   //将h.rel设置为stylesheet
  87.                             g && (h.rel = "stylesheet"),
  88.                                 //f.path 为文件传过来的路径或者默认文件路径（判断a 路径是否是相对或绝对路径）
  89.                                 h[g ? "href": "src"] = /^http:\/\//.test(a) ? a: f.path + a,
  90.                                 //设置这个元素id，e表示<head>元素
  91.                                 h.id = i,
  92.                                 //页面是否存在这个标签：并将这个标签放在<head>中
  93.                             c("#" + i)[0] || e.appendChild(h),
  94.  
  95.                                 function j() {
  96.                                     //判断新生成的这个元素是否是最后一个元素，也就是默认的样式或js
  97.                                     //这个应该是个bug
  98.                                     (g ?
  99.                                     1989=== parseInt(c("#" + i).css("width"))
  100.                                     : f[d || i])
  101.                                     ?
  102.                                         function() {
  103.                                             b && b();
  104.                                             try {
  105.                                                 g || e.removeChild(h)
  106.                                             } catch(a) {}
  107.                                         } () :
  108.                                         setTimeout(j, 100)
  109.                                 } (),
  110.                                 this)
  111.                         //不存在返回0
  112.                         : void 0
  113.                 },
  114.                 //预先加载事件a表示加载文件的根路径  b表示一个回调函数
  115.                 ready: function(a, b) {
  116.                     //判断第一个参数是不是函数
  117.                     var d = "function" == typeof a;
  118.                     return
  119.                     //如果第一个是函数，那么传入参数格式错了就不用执行第二个参数了
  120.                     d && (b = a),
  121.                         //将信息复制过去：这个主要是为了修改路径
  122.                         f.config(c.extend(e.config,
  123.                             function() {
  124.                                 //第一个参数不是函数格式的话就跳过，是函数就执行，a表示的是根路径
  125.                                 return d ? {}: {
  126.                                     path: a
  127.                                 }
  128.                             } ()), b),
  129.                         this
  130.                 },
  131.                 //第一个表示输出内容，第二个表示配置参数（加入一些指定样式），第三个表示回调函数。
  132.                 alert: function(a, b, d) {
  133.                     //第三个是函数；第一个是必填的，
  134.                     var e = "function" == typeof b;
  135.                     return
  136.                     //明确传入的参数。
  137.                     e && (d = b),
  138.                         //调用open方法；这个在后面看
  139.                         f.open(c.extend({
  140.                                 content: a,
  141.                                 yes: d
  142.                             },
  143.                             //如果有指定格式的话，将此格式作为第二个参数加入open方法中
  144.                             e ? {}: b))
  145.                 },
  146.                 //与上面相同
  147.                 //第一个参数 内容，必输
  148.                 //第二个参数 指定格式  非必输
  149.                 //第三个参数 回调函数 必输
  150.                 //第四个参数 设置按钮的 非必输
  151.                 confirm: function(a, b, d, g) {
  152.                     var h = "function" == typeof b;
  153.                     return
  154.                     //根据第二个来判断输入参数格式
  155.                     h && (g = d, d = b),
  156.                         f.open(c.extend({
  157.                                 content: a,
  158.                                 btn: e.btn,
  159.                                 yes: d,
  160.                                 btn2: g
  161.                             },
  162.                             h ? {}: b))
  163.                 },
  164.                 //第一个参数：内容 必输
  165.                 //第二个参数：指定样式 非必输
  166.                 //第三个参数：回调函数；关闭后执行操作
  167.                 msg: function(a, d, g) {
  168.                     var i = "function" == typeof d,
  169.                     //默认图标样式或在初始化中指定的样式
  170.                         j = e.config.skin,
  171.                     //判断指定的样式是否存在，不存在就选择默认的样式，存在的话就加载两个样式 一个j 一个后面-msg的，
  172.                     //用来避免输入了layui-layer的简化class名
  173.                         k = (j ? j + " " + j + "-msg": "") || "layui-layer-msg",
  174.                     //动画类型的样式名称
  175.                         l = h.anim.length - 1;
  176.                     return i && (g = d),
  177.                         f.open(c.extend({
  178.                                 //内容
  179.                                 content: a,
  180.                                 //执行时间自动关闭时间  3e3 表示很长时间
  181.                                 time: 3e3,
  182.                                 //遮罩效果
  183.                                 shade: !1,
  184.                                 //自定义样式 class名称
  185.                                 skin: k,
  186.                                 //名字
  187.                                 title: !1,
  188.                                 //是否有关闭框
  189.                                 closeBtn: !1,
  190.                                 //是否有按钮
  191.                                 btn: !1,//!1为1取反 为fasle 0
  192.                                 //关闭后执行操作
  193.                                 end: g
  194.                             },
  195.                             //三个参数时
  196.                             i &&
  197.                                 //当不传入第二个参数时
  198.                             !e.config.skin ? {
  199.                                 skin: k + " layui-layer-hui",
  200.                                 shift: l
  201.                             }:
  202.                                 //当没有默认样式时
  203.                                 function() {
  204.                                     //好像是想创建一个保存class的空的对象，但是明显写的有些矛盾。
  205.                                     return d = d || {},
  206.                                         //很奇怪 写法好像错了：!e.config.skin为true时就不会执行这个了
  207.                                     ( - 1 === d.icon || d.icon === b && !e.config.skin) && (d.skin = k + " " + (d.skin || "layui-layer-hui")),
  208.                                         //指定样式
  209.                                         d
  210.                                 } ()))
  211.                 },
  212.  
  213.                 //菊花加载的效果，第一个参数表示选择的菊花样式
  214.                 //第二个参数是一个封装样式的对象
  215.                 load: function(a, b) {
  216.                     return f.open(c.extend({
  217.                             type: 3,
  218.                             icon: a || 0,
  219.                             shade: .01
  220.                         },
  221.                         b))
  222.                 },
  223.                 //a表示内容
  224.                 //b表示选择器  “#id”
  225.                 //d表示指定样式 {} 非必输
  226.                 tips: function(a, b, d) {
  227.                     return f.open(c.extend({
  228.                             type: 4,
  229.                             content: [a, b],
  230.                             closeBtn: !1,
  231.                             time: 3e3,
  232.                             shade: !1,
  233.                             maxWidth: 210
  234.                         },
  235.                         d))
  236.                 }
  237.             },
  238.         //难道g才是这个layer的对外对象？表明一个实例化对象？
  239.             g = function(a) {
  240.                 var b = this;
  241.                 //index 表示这个新建元素的标示
  242.                 b.index = ++f.index,
  243.                     b.config = c.extend({},
  244.                         b.config, e.config, a),
  245.                     b.creat()
  246.             };
  247.         //设置prototype的别名和使用到的变量名称；使用内部变量这样不能从外部修改。
  248.         g.pt = g.prototype;
  249.         var h = ["layui-layer", ".layui-layer-title", ".layui-layer-main", ".layui-layer-dialog", "layui-layer-iframe", "layui-layer-content", "layui-layer-btn", "layui-layer-close"];
  250.         h.anim = ["layer-anim", "layer-anim-01", "layer-anim-02", "layer-anim-03", "layer-anim-04", "layer-anim-05", "layer-anim-06"],
  251.             //设置默认属性
  252.             g.pt.config = {
  253.                 type: 0,
  254.                 //透明度和颜色
  255.                 shade: .3,
  256.                 fix: !0,
  257.                 move: h[1],
  258.                 title: "信息",
  259.                 offset: "auto",
  260.                 area: "auto",
  261.                 closeBtn: 1,
  262.                 time: 0,
  263.                 zIndex: 19891014,
  264.                 maxWidth: 360,
  265.                 //表示支持的动画效果
  266.                 shift: 0,
  267.                 icon: -1,
  268.                 scrollbar: !0,
  269.                 tips: 2
  270.             },
  271.             //a表示内容的类型 对象还是字符串
  272.             g.pt.vessel = function(a, b) {
  273.                 var c = this,
  274.                     //d作为
  275.                     d = c.index,
  276.                     //作为配置参数
  277.                     f = c.config,
  278.                     //g标示显示层等级
  279.                     g = f.zIndex + d,
  280.                     //标题是否是个对象对象中第二个参数是css样式
  281.                     i = "object" == typeof f.title,
  282.                 //表示最大最小化只有在 type = 1,2时才有用
  283.                     j = f.maxmin && (1 === f.type || 2 === f.type),
  284.                     //判断标题存在不存在
  285.                     k = f.title ? '<div class="layui-layer-title" style="' + (i ? f.title[1] : "") + '">' + (i ? f.title[0] : f.title) + "</div>": "";
  286.  
  287.                 return
  288.                 //更改其中的层级
  289.                 f.zIndex = g,
  290.                     //定义背景层 没有就不写
  291.                     b([f.shade ? '<div class="layui-layer-shade" id="layui-layer-shade' + d + '" times="' + d + '" style="' + ("z-index:" + (g - 1) + "; background-color:" + (f.shade[1] || "#000") + "; opacity:" + (f.shade[0] || f.shade) + "; filter:alpha(opacity=" + (100 * f.shade[0] || 100 * f.shade) + ");") + '"></div>': "",
  292.                        //定义动画效果 anim表示支持的类型设置内容类型？动画 - 弹框 - 透明度 -边框 - 新增样式 ； id = layui-layer+index;
  293.                         '<div class="' + h[0] + " " + (h.anim[f.shift] || "") + (" layui-layer-" + e.type[f.type]) + (0 != f.type && 2 != f.type || f.shade ? "": " layui-layer-border") + " " + (f.skin || "") + '' +
  294.  
  295.                         '" id="' + h[0] + d + '" type="' + e.type[f.type] + '" times="' + d + '" showtime="' + f.time + '" conType="' + (a ? "object": "string") + '' +
  296.                             //样式： area: 长 高； fix:定位；
  297.                         '" style="z-index: ' + g + "; width:" + f.area[0] + ";height:" + f.area[1] + (f.fix ? "": ";position:absolute;") + '">'
  298.                             //加入标题，根据第一个参数和弹框类型来看是否需要 标题
  299.                         + (a && 2 != f.type ? "": k)
  300.                             //根据id 表示是第几个内容 估计可以删减 只有3 的区分？加载时采取一个样式 有菊花加载？
  301.                         + '<div id="' + (f.id || "") + '" class="layui-layer-content' + (0 == f.type && -1 !== f.icon ? " layui-layer-padding": "") + (3 == f.type ? " layui-layer-loading" + f.icon: "") + '">'
  302.                            //好像是图标+内容
  303.                         + (0 == f.type && -1 !== f.icon ? '<i class="layui-layer-ico layui-layer-ico' + f.icon + '"></i>': "") +
  304.                         // 下面方法中调用这个时已经进行处理 当2,4时f.content本身就是可填入内容，当1时content是对象就填入空值，这个在外侧处理了。
  305.                         (1 == f.type && a ? "": f.content || "") + '</div>' +
  306.                           //制作上面关闭显示按钮
  307.                         '<span class="layui-layer-setwin">' +
  308.                     function() {
  309.                         var a = j ? '<a class="layui-layer-min" href="javascript:;"><cite></cite></a><a class="layui-layer-ico layui-layer-max" href="javascript:;"></a>': "";
  310.                         //判断按钮样式 并返回a数据
  311.                         return f.closeBtn && (a += '<a class="layui-layer-ico ' + h[7] + " " + h[7] + (f.title ? f.closeBtn: 4 == f.type ? "1": "2") + '" href="javascript:;"></a>'),
  312.                             a
  313.                     } () + "</span>"
  314.                         //表示下面的按钮 确定，取消等等
  315.                         + (f.btn ?
  316.                         function() {
  317.                             var a = "";
  318.                             //如果是String  转换成数组
  319.                             "string" == typeof f.btn && (f.btn = [f.btn]);
  320.                             for (var b = 0,
  321.                                      c = f.btn.length; c > b; b++) a += '<a class="' + h[6] + b + '">' + f.btn[b] + "</a>";
  322.                             return '<div class="' + h[6] + '">' + a + "</div>"
  323.                         } () : "") + "</div>"], k),
  324.                     c
  325.             },
  326.             //创建
  327.             g.pt.creat = function() {
  328.                 var a = this,
  329.                     //表示配置信息
  330.                     b = a.config,
  331.                     //表示id
  332.                     g = a.index,
  333.                     //表示内容
  334.                     i = b.content,
  335.  
  336.                     j = "object" == typeof i;
  337.                 //判断这个元素是否存在
  338.                 if (!c("#" + b.id)[0]) {
  339.                     //执行大小是否自适应，并根据type来判断
  340.                     //对内容和已有框进行处理  2,4 将内容取了出来，
  341.                     switch ("string" == typeof b.area && (b.area = "auto" === b.area ? ["", ""] : [b.area, ""]), b.type) {
  342.                         //dialog
  343.                         case 0:
  344.                             b.btn = "btn" in b ? b.btn: e.btn[0],
  345.                                 f.closeAll("dialog");
  346.                             break;
  347.                         //iframe
  348.                         case 2:
  349.                             //根据内容格式 将其转换成数组 --第一个地址是加载地址，第二个参数是overflow
  350.                             var i = b.content = j ? b.content: [b.content || "http://layer.layui.com", "auto"];
  351.                             b.content = '<iframe scrolling="' + (b.content[1] || "auto") + '" allowtransparency="true" id="' + h[4] + g + '" name="' + h[4] + g +
  352.                                 //加入链接地址
  353.                             '" onload="this.className=\'\';" class="layui-layer-load" frameborder="0" src="' + b.content[0] + '"></iframe>';
  354.                             break;
  355.                         //loading
  356.                         case 3:
  357.                             //没有名字
  358.                             b.title = !1,
  359.                                 //没有关闭按钮
  360.                                 b.closeBtn = !1,
  361.                                 //判断图标是否存在 并没有什么意义吧
  362.                             -1 === b.icon && 0 === b.icon,
  363.                                 //关闭所有的加载框
  364.                                 f.closeAll("loading");
  365.                             break;
  366.                         //tips
  367.                         case 4:
  368.                             //内容变成数组
  369.                             j || (b.content = [b.content, "body"]),
  370.                                 //follow是啥 第二个参数是传入的id值 tips() 第二个参数
  371.                                 b.follow = b.content[1],
  372.                                 //内容后面加个样式
  373.                                 b.content = b.content[0] + '<i class="layui-layer-TipsG"></i>',
  374.                                 //没有标题
  375.                                 b.title = !1
  376.                                 //没有定位,
  377.                                 b.fix = !1,
  378.                                 //将tips转换成数组
  379.                                 b.tips = "object" == typeof b.tips ? b.tips: [b.tips, !0],
  380.                                 //关闭所有的tips
  381.                             b.tipsMore || f.closeAll("tips")
  382.                     }
  383.                     //j表示内容是否是对象 d是数组 0--背景 1- 内容就两个参数
  384.                     a.vessel(j,
  385.                         function(d, e) {
  386.                             //加载在body内内容
  387.                             c("body").append(d[0]),
  388.                                 //如果j是一个对象的话
  389.                                 j ?
  390.                                     function() {
  391.                                         //如果是ifram或tips 直接按默认方式加入 只有2和4 是数组
  392.                                        2 == b.type || 4 == b.type ?
  393.                                             function() {
  394.                                                 //加入引入的地址
  395.                                                 c("body").append(d[1])
  396.                                             } ()
  397.                                            //其他情况时
  398.                                            : function() {
  399.                                            //判断加入内容有没有对应layui-layer元素，如果没有那么就将这个元素内容套在里面，并在内容前加入e e是标题部分  不放在内容区域里
  400.                                             i.parents("." + h[0])[0] || (i.show().addClass("layui-layer-wrap").wrap(d[1]), c("#" + h[0] + g).find("." + h[5]).before(e))
  401.                                         } ()
  402.                                     } ()
  403.                                     //内容不是对象的话，直接加入
  404.                                     : c("body").append(d[1]),
  405.                                 //a表示j 应该就是layer对象将这个生成的div框不包含背景
  406.                                 a.layero = c("#" + h[0] + g),
  407.                                 //默认值
  408.                             b.scrollbar || h.html.css("overflow", "hidden").attr("layer-full", g)
  409.                         }).auto(g),
  410.                         //对于ie6的处理
  411.                2 == b.type && f.ie6 && a.layero.find("iframe").attr("src", i[0]),
  412.  
  413.                         c(document).off("keydown", e.enter).on("keydown", e.enter),
  414.                         a.layero.on("keydown",
  415.                             function(a) {
  416.                                 c(document).off("keydown", e.enter)
  417.                             }),
  418.  
  419.                4 == b.type ? a.tips() : a.offset(),
  420.                         //判断fix是否存在
  421.                     b.fix && d.on("resize",
  422.                         function() {
  423.                             a.offset(),
  424.                             (/^\d+%$/.test(b.area[0]) || /^\d+%$/.test(b.area[1])) && a.auto(g),
  425.                            4 == b.type && a.tips()
  426.                         }),
  427.                         //过多长时间关闭
  428.                     b.time <= 0 || setTimeout(function() {
  429.                             f.close(a.index)
  430.                         },
  431.                         b.time),
  432.                         //移动。。。。
  433.                         a.move().callback()
  434.                 }
  435.             },
  436.             //这段主要是定义内容区域的高度。。。
  437.             g.pt.auto = function(a) {
  438.                 function b(a) {
  439.                     //g是一个juery对象？
  440.                     a = g.find(a),
  441.                         //内容区域的高度
  442.                         a.height(i[1] - j - k - 2 * (0 | parseFloat(a.css("padding"))))
  443.                 }
  444.                 var e = this,
  445.                     f = e.config,
  446.                     //表示所指的juery页面元素对象
  447.                     g = c("#" + h[0] + a);
  448.                 //总层的宽
  449.                 "" === f.area[0] && f.maxWidth > 0 && (/MSIE 7/.test(navigator.userAgent) && f.btn && g.width(g.innerWidth()),
  450.                 //.....
  451.                 g.outerWidth() > f.maxWidth && g.width(f.maxWidth));
  452.                 //宽和高指的是内边距的宽和高
  453.                 var i = [g.innerWidth(), g.innerHeight()],
  454.                     //标题的高度
  455.                     j = g.find(h[1]).outerHeight() || 0,
  456.                     //按钮的高度？
  457.                     k = g.find("." + h[6]).outerHeight() || 0;
  458.                 switch (f.type) {
  459.                     case 2:
  460.                         b("iframe");
  461.                         break;
  462.                     default:
  463.                         "" === f.area[1] ? f.fix && i[1] >= d.height() && (i[1] = d.height(), b("." + h[5])) : b("." + h[5])
  464.                 }
  465.                 return e
  466.             },
  467.             //设置距离上面的高度和宽度
  468.             g.pt.offset = function() {
  469.                 var a = this,
  470.                     b = a.config,
  471.                     //总层元素
  472.                     c = a.layero,
  473.                     //自身完全区域
  474.                     e = [c.outerWidth(), c.outerHeight()],
  475.                     //判断offset是否自定义了值
  476.                     f = "object" == typeof b.offset;
  477.                 //d应该是offsetheight等作为参考的元素吧 距离上端距离
  478.                 a.offsetTop = (d.height() - e[1]) / 2,
  479.                     //距离左边距离
  480.                     a.offsetLeft = (d.width() - e[0]) / 2,
  481.                     //采取自定义的？？那前面的判断呢？？？可能是bug
  482.                     f ? (a.offsetTop = b.offset[0],
  483.                         //当这个异常时不赋值。。。。
  484.                         a.offsetLeft = b.offset[1] || a.offsetLeft)
  485.                         //当没有自定义的高和宽时；并且不等于auto时 是一个字符串 也就是指定了一个参数 作为高度；这个参数是rb的时候就默认居中；这个RB是啥？
  486.                         : "auto" !== b.offset && (a.offsetTop = b.offset, "rb" === b.offset && (a.offsetTop = d.height() - e[1], a.offsetLeft = d.width() - e[0])),
  487.                     //fix为true时执行下面的语句。。。
  488.                 b.fix ||
  489.                 //上面是为offsetTop和offsetleft赋值，这边是判断值的形式来计算具体的px单位的值
  490.                 (a.offsetTop = /%$/.test(a.offsetTop) ? d.height() * parseFloat(a.offsetTop) / 100 : parseFloat(a.offsetTop), a.offsetLeft = /%$/.test(a.offsetLeft) ? d.width() * parseFloat(a.offsetLeft) / 100 : parseFloat(a.offsetLeft),
  491.                     //使其最终居中。。。
  492.                     a.offsetTop += d.scrollTop(), a.offsetLeft += d.scrollLeft()),
  493.                     c.css({
  494.                         top: a.offsetTop,
  495.                         left: a.offsetLeft
  496.                     })
  497.             },
  498.  
  499.             g.pt.tips = function() {
  500.                 var a = this,
  501.  
  502.                     b = a.config,
  503.                     //总层
  504.                     e = a.layero,
  505.                     f = [e.outerWidth(), e.outerHeight()],
  506.                     //找到id的元素
  507.                     g = c(b.follow);
  508.                 //没有就默认body
  509.                 g[0] || (g = c("body"));
  510.                 //id元素的位置信息
  511.                 var i = {
  512.                         width: g.outerWidth(),
  513.                         height: g.outerHeight(),
  514.                         top: g.offset().top,
  515.                         left: g.offset().left
  516.                     },
  517.                     //内容后面的图标
  518.                     j = e.find(".layui-layer-TipsG"),
  519.                     //表示现对于参考元素的位置
  520.                     k = b.tips[0];
  521.                 //如果为true 移走图标；第二个参数作为样式传入的
  522.                 b.tips[1] || j.remove(),
  523.                     //给i设定方法
  524.                     //自适应左侧：1、可以容纳的话放在右边，不能容纳的话放在左侧 ---依i最右边线为准
  525.                     i.autoLeft = function() {
  526.  
  527.                         i.left + f[0] - d.width() > 0 ? (i.tipLeft = i.left + i.width - f[0], j.css({
  528.                             right: 12,
  529.                             left: "auto"
  530.                         })) : i.tipLeft = i.left
  531.                     },
  532.                     //位置
  533.                     i.where = [function() {
  534.                         //自动指定left后
  535.                         i.autoLeft(),
  536.                             //放在i的上面
  537.                             i.tipTop = i.top - f[1] - 10,
  538.                             j.removeClass("layui-layer-TipsB").addClass("layui-layer-TipsT").css("border-right-color", b.tips[1])
  539.                     },
  540.                         function() {
  541.                             //放在右边
  542.                             i.tipLeft = i.left + i.width + 10,
  543.                                 i.tipTop = i.top,
  544.                                 j.removeClass("layui-layer-TipsL").addClass("layui-layer-TipsR").css("border-bottom-color", b.tips[1])
  545.                         },
  546.                         function() {
  547.                             i.autoLeft(),
  548.                                 //放在下面
  549.                                 i.tipTop = i.top + i.height + 10,
  550.                                 j.removeClass("layui-layer-TipsT").addClass("layui-layer-TipsB").css("border-right-color", b.tips[1])
  551.                         },
  552.                         function() {
  553.                             //放在左边
  554.                             i.tipLeft = i.left - f[0] - 10,
  555.                                 i.tipTop = i.top,
  556.                                 j.removeClass("layui-layer-TipsR").addClass("layui-layer-TipsL").css("border-bottom-color", b.tips[1])
  557.                         }],
  558.                     //根据第一个参数决定放置位置{tipTop,tipLeft}
  559.                     i.where[k - 1](),
  560.                1 === k ?
  561.                    //放在上面的时候如果容纳不下就放在右边
  562.                i.top - (d.scrollTop() + f[1] + 16) < 0 && i.where[2]() :
  563.                    //放在右边容纳不下的话就放在下面
  564.                    2 === k ? d.width() - (i.left + i.width + f[0] + 16) > 0 || i.where[3]() :
  565.                        //放在下面容纳不下的时候放在左边
  566.                        3 === k ? i.top - d.scrollTop() + i.height + f[1] + 16 - d.height() > 0 && i.where[0]() :
  567.                        //左边容纳不下的时候放在上边。。。
  568.                        4 === k && f[0] + 16 - i.left > 0 && i.where[1](),
  569.                    //标示符的颜色
  570.                     e.find("." + h[5]).css({
  571.                         "background-color": b.tips[1],
  572.                         "padding-right": b.closeBtn ? "30px": ""
  573.                     }),
  574.                     //表示
  575.                     e.css({
  576.                         left: i.tipLeft,
  577.                         top: i.tipTop
  578.                     })
  579.             },
  580.             g.pt.move = function() {
  581.                 var a = this,
  582.                     b = a.config,
  583.                     e = {
  584.                         setY: 0,
  585.                         moveLayer: function() {
  586.                             var a = e.layero,
  587.                                 b = parseInt(a.css("margin-left")),
  588.                                 c = parseInt(e.move.css("left"));
  589.                             === b || (c -= b),
  590.                             "fixed" !== a.css("position") && (c -= a.parent().offset().left, e.setY = 0),
  591.                                 a.css({
  592.                                     left: c,
  593.                                     top: parseInt(e.move.css("top")) - e.setY
  594.                                 })
  595.                         }
  596.                     },
  597.                     f = a.layero.find(b.move);
  598.                 return b.move && f.attr("move", "ok"),
  599.                     f.css({
  600.                         cursor: b.move ? "move": "auto"
  601.                     }),
  602.                     c(b.move).on("mousedown",
  603.                         function(a) {
  604.                             if (a.preventDefault(), "ok" === c(this).attr("move")) {
  605.                                 e.ismove = !0,
  606.                                     e.layero = c(this).parents("." + h[0]);
  607.                                 var f = e.layero.offset().left,
  608.                                     g = e.layero.offset().top,
  609.                                     i = e.layero.outerWidth() - 6,
  610.                                     j = e.layero.outerHeight() - 6;
  611.                                 c("#layui-layer-moves")[0] || c("body").append('<div id="layui-layer-moves" class="layui-layer-moves" style="left:' + f + "px; top:" + g + "px; width:" + i + "px; height:" + j + 'px; z-index:2147483584"></div>'),
  612.                                     e.move = c("#layui-layer-moves"),
  613.                                 b.moveType && e.move.css({
  614.                                     visibility: "hidden"
  615.                                 }),
  616.                                     e.moveX = a.pageX - e.move.position().left,
  617.                                     e.moveY = a.pageY - e.move.position().top,
  618.                                 "fixed" !== e.layero.css("position") || (e.setY = d.scrollTop())
  619.                             }
  620.                         }),
  621.                     c(document).mousemove(function(a) {
  622.                         if (e.ismove) {
  623.                             var c = a.pageX - e.moveX,
  624.                                 f = a.pageY - e.moveY;
  625.                             if (a.preventDefault(), !b.moveOut) {
  626.                                 e.setY = d.scrollTop();
  627.                                 var g = d.width() - e.move.outerWidth(),
  628.                                     h = e.setY;
  629.                             > c && (c = 0),
  630.                                 c > g && (c = g),
  631.                                 h > f && (f = h),
  632.                                 f > d.height() - e.move.outerHeight() + e.setY && (f = d.height() - e.move.outerHeight() + e.setY)
  633.                             }
  634.                             e.move.css({
  635.                                 left: c,
  636.                                 top: f
  637.                             }),
  638.                             b.moveType && e.moveLayer(),
  639.                                 c = f = g = h = null
  640.                         }
  641.                     }).mouseup(function() {
  642.                         try {
  643.                             e.ismove && (e.moveLayer(), e.move.remove(), b.moveEnd && b.moveEnd()),
  644.                                 e.ismove = !1
  645.                         } catch(a) {
  646.                             e.ismove = !1
  647.                         }
  648.                     }),
  649.                     a
  650.             },
  651.             g.pt.callback = function() {
  652.                 function a() {
  653.                     var a = g.cancel && g.cancel(b.index, d);
  654.                     a === !1 || f.close(b.index)
  655.                 }
  656.                 var b = this,
  657.                     d = b.layero,
  658.                     g = b.config;
  659.                 b.openLayer(),
  660.                 g.success && (2 == g.type ? d.find("iframe").on("load",
  661.                     function() {
  662.                         g.success(d, b.index)
  663.                     }) : g.success(d, b.index)),
  664.                 f.ie6 && b.IE6(d),
  665.                     d.find("." + h[6]).children("a").on("click",
  666.                         function() {
  667.                             var a = c(this).index();
  668.                             if (0 === a) g.yes ? g.yes(b.index, d) : g.btn1 ? g.btn1(b.index, d) : f.close(b.index);
  669.                             else {
  670.                                 var e = g["btn" + (a + 1)] && g["btn" + (a + 1)](b.index, d);
  671.                                 e === !1 || f.close(b.index)
  672.                             }
  673.                         }),
  674.                     d.find("." + h[7]).on("click", a),
  675.                 g.shadeClose && c("#layui-layer-shade" + b.index).on("click",
  676.                     function() {
  677.                         f.close(b.index)
  678.                     }),
  679.                     d.find(".layui-layer-min").on("click",
  680.                         function() {
  681.                             f.min(b.index, g),
  682.                             g.min && g.min(d)
  683.                         }),
  684.                     d.find(".layui-layer-max").on("click",
  685.                         function() {
  686.                             c(this).hasClass("layui-layer-maxmin") ? (f.restore(b.index), g.restore && g.restore(d)) : (f.full(b.index, g), g.full && g.full(d))
  687.                         }),
  688.                 g.end && (e.end[b.index] = g.end)
  689.             },
  690.             e.reselect = function() {
  691.                 c.each(c("select"),
  692.                     function(a, b) {
  693.                         var d = c(this);
  694.                         d.parents("." + h[0])[0] || 1 == d.attr("layer") && c("." + h[0]).length < 1 && d.removeAttr("layer").show(),
  695.                             d = null
  696.                     })
  697.             },
  698.             g.pt.IE6 = function(a) {
  699.                 function b() {
  700.                     a.css({
  701.                         top: f + (e.config.fix ? d.scrollTop() : 0)
  702.                     })
  703.                 }
  704.                 var e = this,
  705.                     f = a.offset().top;
  706.                 b(),
  707.                     d.scroll(b),
  708.                     c("select").each(function(a, b) {
  709.                         var d = c(this);
  710.                         d.parents("." + h[0])[0] || "none" === d.css("display") || d.attr({
  711.                             layer: "1"
  712.                         }).hide(),
  713.                             d = null
  714.                     })
  715.             },
  716.             g.pt.openLayer = function() {
  717.                 var a = this;
  718.                 f.zIndex = a.config.zIndex,
  719.                     f.setTop = function(a) {
  720.                         var b = function() {
  721.                             f.zIndex++,
  722.                                 a.css("z-index", f.zIndex + 1)
  723.                         };
  724.                         return f.zIndex = parseInt(a[0].style.zIndex),
  725.                             a.on("mousedown", b),
  726.                             f.zIndex
  727.                     }
  728.             },
  729.             e.record = function(a) {
  730.                 var b = [a.outerWidth(), a.outerHeight(), a.position().top, a.position().left + parseFloat(a.css("margin-left"))];
  731.                 a.find(".layui-layer-max").addClass("layui-layer-maxmin"),
  732.                     a.attr({
  733.                         area: b
  734.                     })
  735.             },
  736.             e.rescollbar = function(a) {
  737.                 h.html.attr("layer-full") == a && (h.html[0].style.removeProperty ? h.html[0].style.removeProperty("overflow") : h.html[0].style.removeAttribute("overflow"), h.html.removeAttr("layer-full"))
  738.             },
  739.             a.layer = f,
  740.             f.getChildFrame = function(a, b) {
  741.                 return b = b || c("." + h[4]).attr("times"),
  742.                     c("#" + h[0] + b).find("iframe").contents().find(a)
  743.             },
  744.             f.getFrameIndex = function(a) {
  745.                 return c("#" + a).parents("." + h[4]).attr("times")
  746.             },
  747.             f.iframeAuto = function(a) {
  748.                 if (a) {
  749.                     var b = f.getChildFrame("html", a).outerHeight(),
  750.                         d = c("#" + h[0] + a),
  751.                         e = d.find(h[1]).outerHeight() || 0,
  752.                         g = d.find("." + h[6]).outerHeight() || 0;
  753.                     d.css({
  754.                         height: b + e + g
  755.                     }),
  756.                         d.find("iframe").css({
  757.                             height: b
  758.                         })
  759.                 }
  760.             },
  761.             f.iframeSrc = function(a, b) {
  762.                 c("#" + h[0] + a).find("iframe").attr("src", b)
  763.             },
  764.             f.style = function(a, b) {
  765.                 var d = c("#" + h[0] + a),
  766.                     f = d.attr("type"),
  767.                     g = d.find(h[1]).outerHeight() || 0,
  768.                     i = d.find("." + h[6]).outerHeight() || 0; (f === e.type[1] || f === e.type[2]) && (d.css(b), f === e.type[2] && d.find("iframe").css({
  769.                     height: parseFloat(b.height) - g - i
  770.                 }))
  771.             },
  772.             f.min = function(a, b) {
  773.                 var d = c("#" + h[0] + a),
  774.                     g = d.find(h[1]).outerHeight() || 0;
  775.                 e.record(d),
  776.                     f.style(a, {
  777.                         width: 180,
  778.                         height: g,
  779.                         overflow: "hidden"
  780.                     }),
  781.                     d.find(".layui-layer-min").hide(),
  782.                 "page" === d.attr("type") && d.find(h[4]).hide(),
  783.                     e.rescollbar(a)
  784.             },
  785.             f.restore = function(a) {
  786.                 var b = c("#" + h[0] + a),
  787.                     d = b.attr("area").split(",");
  788.                 b.attr("type");
  789.                 f.style(a, {
  790.                     width: parseFloat(d[0]),
  791.                     height: parseFloat(d[1]),
  792.                     top: parseFloat(d[2]),
  793.                     left: parseFloat(d[3]),
  794.                     overflow: "visible"
  795.                 }),
  796.                     b.find(".layui-layer-max").removeClass("layui-layer-maxmin"),
  797.                     b.find(".layui-layer-min").show(),
  798.                 "page" === b.attr("type") && b.find(h[4]).show(),
  799.                     e.rescollbar(a)
  800.             },
  801.             f.full = function(a) {
  802.                 var b, g = c("#" + h[0] + a);
  803.                 e.record(g),
  804.                 h.html.attr("layer-full") || h.html.css("overflow", "hidden").attr("layer-full", a),
  805.                     clearTimeout(b),
  806.                     b = setTimeout(function() {
  807.                             var b = "fixed" === g.css("position");
  808.                             f.style(a, {
  809.                                 top: b ? 0 : d.scrollTop(),
  810.                                 left: b ? 0 : d.scrollLeft(),
  811.                                 width: d.width(),
  812.                                 height: d.height()
  813.                             }),
  814.                                 g.find(".layui-layer-min").hide()
  815.                         },
  816.                         100)
  817.             },
  818.             //b作为选择的id a作为传入的内容
  819.             f.title = function(a, b) {
  820.                 var d = c("#" + h[0] + (b || f.index)).find(h[1]);
  821.                 d.html(a)
  822.             },
  823.             //关闭事件：
  824.             f.close = function(a) {
  825.                 //找到出符合id的总框
  826.                 var b = c("#" + h[0] + a),
  827.                     //判断框的类型
  828.                     d = b.attr("type");
  829.                 //表示第一个
  830.                 if (b[0]) {
  831.                     //是page框时 判断内容类型
  832.                     if (d === e.type[1] && "object" === b.attr("conType")) {
  833.                         //表示移除除了内容的其他框
  834.                         b.children(":not(." + h[5] + ")").remove();
  835.                         //删除套的样式
  836.                         for (var g = 0; 2 > g; g++) b.find(".layui-layer-wrap").unwrap().hide()
  837.                     } else {
  838.                         //如果是iframe层的时候
  839.                         if (d === e.type[2]) try {
  840.                             var i = c("#" + h[4] + a)[0];
  841.                             //关闭iframe
  842.                             i.contentWindow.document.write(""),
  843.                                 i.contentWindow.close(),
  844.                                 //移除内容下面的编号为。。。
  845.                                 b.find("." + h[5])[0].removeChild(i)
  846.                         } catch(j) {}
  847.                         //将b情空并移除，，感觉与上面的重复，
  848.                         b[0].innerHTML = "",
  849.                             b.remove()
  850.                     }
  851.                     //清掉这些元素
  852.                     c("#layui-layer-moves, #layui-layer-shade" + a).remove(),
  853.                     f.ie6 && e.reselect(),
  854.                         e.rescollbar(a),
  855.                         c(document).off("keydown", e.enter),
  856.                     "function" == typeof e.end[a] && e.end[a](),
  857.                         delete e.end[a]
  858.                 }
  859.             },
  860.             //选择每一个创建的弹窗
  861.             f.closeAll = function(a) {
  862.                 c.each(c("." + h[0]),
  863.                     function() {
  864.                         var b = c(this),
  865.                             //判断传入参数是否为弹出框类型
  866.                             d = a ? b.attr("type") === a: 1;
  867.                         //如果是的话就关闭
  868.                         d && f.close(b.attr("times")),
  869.                             d = null
  870.                     })
  871.             };
  872.         var i = f.cache || {},
  873.             j = function(a) {
  874.                 return i.skin ? " " + i.skin + " " + i.skin + "-" + a: ""
  875.             };
  876.         f.prompt = function(a, b) {
  877.             a = a || {},
  878.             "function" == typeof a && (b = a);
  879.             var d, e = 2 == a.formType ? '<textarea class="layui-layer-input">' + (a.value || "") + "</textarea>": function() {
  880.                 return '<input type="' + (1 == a.formType ? "password": "text") + '" class="layui-layer-input" value="' + (a.value || "") + '">'
  881.             } ();
  882.             return f.open(c.extend({
  883.                     btn: ["确定", "取消"],
  884.                     content: e,
  885.                     skin: "layui-layer-prompt" + j("prompt"),
  886.                     success: function(a) {
  887.                         d = a.find(".layui-layer-input"),
  888.                             d.focus()
  889.                     },
  890.                     yes: function(c) {
  891.                         var e = d.val();
  892.                         "" === e ? d.focus() : e.length > (a.maxlength || 500) ? f.tips("最多输入" + (a.maxlength || 500) + "个字数", d, {
  893.                             tips: 1
  894.                         }) : b && b(e, c, d)
  895.                     }
  896.                 },
  897.                 a))
  898.         },
  899.             f.tab = function(a) {
  900.                 a = a || {};
  901.                 var b = a.tab || {};
  902.                 return f.open(c.extend({
  903.                         type: 1,
  904.                         skin: "layui-layer-tab" + j("tab"),
  905.                         title: function() {
  906.                             var a = b.length,
  907.                                 c = 1,
  908.                                 d = "";
  909.                             if (a > 0) for (d = '<span class="layui-layer-tabnow">' + b[0].title + "</span>"; a > c; c++) d += "<span>" + b[c].title + "</span>";
  910.                             return d
  911.                         } (),
  912.                         content: '<ul class="layui-layer-tabmain">' +
  913.                         function() {
  914.                             var a = b.length,
  915.                                 c = 1,
  916.                                 d = "";
  917.                             if (a > 0) for (d = '<li class="layui-layer-tabli xubox_tab_layer">' + (b[0].content || "no content") + "</li>"; a > c; c++) d += '<li class="layui-layer-tabli">' + (b[c].content || "no  content") + "</li>";
  918.                             return d
  919.                         } () + "</ul>",
  920.                         success: function(b) {
  921.                             var d = b.find(".layui-layer-title").children(),
  922.                                 e = b.find(".layui-layer-tabmain").children();
  923.                             d.on("mousedown",
  924.                                 function(b) {
  925.                                     b.stopPropagation ? b.stopPropagation() : b.cancelBubble = !0;
  926.                                     var d = c(this),
  927.                                         f = d.index();
  928.                                     d.addClass("layui-layer-tabnow").siblings().removeClass("layui-layer-tabnow"),
  929.                                         e.eq(f).show().siblings().hide(),
  930.                                     "function" == typeof a.change && a.change(f)
  931.                                 })
  932.                         }
  933.                     },
  934.                     a))
  935.             },
  936.             f.photos = function(b, d, e) {
  937.                 function g(a, b, c) {
  938.                     var d = new Image;
  939.                     return d.src = a,
  940.                         d.complete ? b(d) : (d.onload = function() {
  941.                             d.onload = null,
  942.                                 b(d)
  943.                         },
  944.                             void(d.onerror = function(a) {
  945.                                 d.onerror = null,
  946.                                     c(a)
  947.                             }))
  948.                 }
  949.                 var h = {};
  950.                 if (b = b || {},
  951.                         b.photos) {
  952.                     var i = b.photos.constructor === Object,
  953.                         k = i ? b.photos: {},
  954.                         l = k.data || [],
  955.                         m = k.start || 0;
  956.                     if (h.imgIndex = (0 | m) + 1, b.img = b.img || "img", i) {
  957.                         if (0 === l.length) return f.msg("没有图片")
  958.                     } else {
  959.                         var n = c(b.photos),
  960.                             o = function() {
  961.                                 l = [],
  962.                                     n.find(b.img).each(function(a) {
  963.                                         var b = c(this);
  964.                                         b.attr("layer-index", a),
  965.                                             l.push({
  966.                                                 alt: b.attr("alt"),
  967.                                                 pid: b.attr("layer-pid"),
  968.                                                 src: b.attr("layer-src") || b.attr("src"),
  969.                                                 thumb: b.attr("src")
  970.                                             })
  971.                                     })
  972.                             };
  973.                         if (o(), 0 === l.length) return;
  974.                         if (d || n.on("click", b.img,
  975.                                 function() {
  976.                                     var a = c(this),
  977.                                         d = a.attr("layer-index");
  978.                                     f.photos(c.extend(b, {
  979.                                         photos: {
  980.                                             start: d,
  981.                                             data: l,
  982.                                             tab: b.tab
  983.                                         },
  984.                                         full: b.full
  985.                                     }), !0),
  986.                                         o()
  987.                                 }), !d) return
  988.                     }
  989.                     h.imgprev = function(a) {
  990.                         h.imgIndex--,
  991.                         h.imgIndex < 1 && (h.imgIndex = l.length),
  992.                             h.tabimg(a)
  993.                     },
  994.                         h.imgnext = function(a, b) {
  995.                             h.imgIndex++,
  996.                             h.imgIndex > l.length && (h.imgIndex = 1, b) || h.tabimg(a)
  997.                         },
  998.                         h.keyup = function(a) {
  999.                             if (!h.end) {
  1000.                                 var b = a.keyCode;
  1001.                                 a.preventDefault(),
  1002.                             === b ? h.imgprev(!0) : 39 === b ? h.imgnext(!0) : 27 === b && f.close(h.index)
  1003.                             }
  1004.                         },
  1005.                         h.tabimg = function(a) {
  1006.                             l.length <= 1 || (k.start = h.imgIndex - 1, f.close(h.index), f.photos(b, !0, a))
  1007.                         },
  1008.                         h.event = function() {
  1009.                             h.bigimg.hover(function() {
  1010.                                     h.imgsee.show()
  1011.                                 },
  1012.                                 function() {
  1013.                                     h.imgsee.hide()
  1014.                                 }),
  1015.                                 h.bigimg.find(".layui-layer-imgprev").on("click",
  1016.                                     function(a) {
  1017.                                         a.preventDefault(),
  1018.                                             h.imgprev()
  1019.                                     }),
  1020.                                 h.bigimg.find(".layui-layer-imgnext").on("click",
  1021.                                     function(a) {
  1022.                                         a.preventDefault(),
  1023.                                             h.imgnext()
  1024.                                     }),
  1025.                                 c(document).on("keyup", h.keyup)
  1026.                         },
  1027.                         h.loadi = f.load(1, {
  1028.                             shade: "shade" in b ? !1 : .9,
  1029.                             scrollbar: !1
  1030.                         }),
  1031.                         g(l[m].src,
  1032.                             function(d) {
  1033.                                 f.close(h.loadi),
  1034.                                     h.index = f.open(c.extend({
  1035.                                             type: 1,
  1036.                                             area: function() {
  1037.                                                 var e = [d.width, d.height],
  1038.                                                     f = [c(a).width() - 50, c(a).height() - 50];
  1039.                                                 return ! b.full && e[0] > f[0] && (e[0] = f[0], e[1] = e[0] * d.height / d.width),
  1040.                                                     [e[0] + "px", e[1] + "px"]
  1041.                                             } (),
  1042.                                             title: !1,
  1043.                                             shade: .9,
  1044.                                             shadeClose: !0,
  1045.                                             closeBtn: !1,
  1046.                                             move: ".layui-layer-phimg img",
  1047.                                             moveType: 1,
  1048.                                             scrollbar: !1,
  1049.                                             moveOut: !0,
  1050.                                             shift: 5 * Math.random() | 0,
  1051.                                             skin: "layui-layer-photos" + j("photos"),
  1052.                                             content: '<div class="layui-layer-phimg"><img src="' + l[m].src + '" alt="' + (l[m].alt || "") + '" layer-pid="' + l[m].pid + '"><div class="layui-layer-imgsee">' + (l.length > 1 ? '<span class="layui-layer-imguide"><a href="javascript:;" class="layui-layer-iconext layui-layer-imgprev"></a><a href="javascript:;" class="layui-layer-iconext layui-layer-imgnext"></a></span>': "") + '<div class="layui-layer-imgbar" style="display:' + (e ? "block": "") + '"><span class="layui-layer-imgtit"><a href="javascript:;">' + (l[m].alt || "") + "</a><em>" + h.imgIndex + "/" + l.length + "</em></span></div></div></div>",
  1053.                                             success: function(a, c) {
  1054.                                                 h.bigimg = a.find(".layui-layer-phimg"),
  1055.                                                     h.imgsee = a.find(".layui-layer-imguide,.layui-layer-imgbar"),
  1056.                                                     h.event(a),
  1057.                                                 b.tab && b.tab(l[m], a)
  1058.                                             },
  1059.                                             end: function() {
  1060.                                                 h.end = !0,
  1061.                                                     c(document).off("keyup", h.keyup)
  1062.                                             }
  1063.                                         },
  1064.                                         b))
  1065.                             },
  1066.                             function() {
  1067.                                 f.close(h.loadi),
  1068.                                     f.msg("当前图片地址异常<br>是否继续查看下一张？", {
  1069.                                         time: 3e4,
  1070.                                         btn: ["下一张", "不看了"],
  1071.                                         yes: function() {
  1072.                                             l.length > 1 && h.imgnext(!0, !0)
  1073.                                         }
  1074.                                     })
  1075.                             })
  1076.                 }
  1077.             },
  1078.             e.run = function() {
  1079.                 c = jQuery,
  1080.                     d = c(a),
  1081.                     h.html = c("html"),
  1082.                     f.open = function(a) {
  1083.                         var b = new g(a);
  1084.                         return b.index
  1085.                     }
  1086.             },
  1087.             "function" == typeof define ? define(function() {
  1088.                 return e.run(),
  1089.                     f
  1090.             }) : function() {
  1091.                 e.run(),
  1092.                     f.use("skin/layer.css")
  1093.             } ()
  1094.     } (window);

layer——源码学习的更多相关文章

  1. caffe源码学习之Proto数据格式【１】

    前言: 由于业务需要,接触caffe已经有接近半年,一直忙着阅读各种论文,重现大大小小的模型. 期间也总结过一些caffe源码学习笔记,断断续续,这次打算系统的记录一下caffe源码学习笔记,巩固一下 ...

  2. mongo源码学习（四）服务入口点ServiceEntryPoint

    在上一篇博客mongo源码学习(三)请求接收传输层中,稍微分析了一下TransportLayer的作用,这篇来看下ServiceEntryPoint是怎么做的. 首先ServiceEntryPoint ...

  3. 移动端触摸、点击事件优化（fastclick源码学习）

    移动端触摸.点击事件优化(fastclick源码学习) 最近在做一些微信移动端的页面,在此记录关于移动端触摸和点击事件的学习优化过程,主要内容围绕fastclick展开.fastclick githu ...

  4. [阿里DIN]从论文源码学习 之 embedding_lookup

    [阿里DIN]从论文源码学习 之 embedding_lookup 目录 [阿里DIN]从论文源码学习 之 embedding_lookup 0x00 摘要 0x01 DIN代码 1.1 Embedd ...

  5. [阿里DIN] 从论文源码学习 之 embedding层如何自动更新

    [阿里DIN] 从论文源码学习 之 embedding层如何自动更新 目录 [阿里DIN] 从论文源码学习 之 embedding层如何自动更新 0x00 摘要 0x01 DIN源码 1.1 问题 1 ...

  6. Spring5.0源码学习系列之Spring AOP简述

    前言介绍 附录:Spring源码学习专栏 在前面章节的学习中,我们对Spring框架的IOC实现源码有了一定的了解,接着本文继续学习Springframework一个核心的技术点AOP技术. 在学习S ...

  7. Java集合专题总结（1）：HashMap 和 HashTable 源码学习和面试总结

    2017年的秋招彻底结束了,感觉Java上面的最常见的集合相关的问题就是hash--系列和一些常用并发集合和队列,堆等结合算法一起考察,不完全统计,本人经历:先后百度.唯品会.58同城.新浪微博.趣分 ...

  8. jQuery源码学习感想

    还记得去年(2015)九月份的时候,作为一个大四的学生去参加美团霸面,结果被美团技术总监教育了一番,那次问了我很多jQuery源码的知识点,以前虽然喜欢研究框架,但水平还不足够来研究jQuery源码, ...

  9. MVC系列——MVC源码学习：打造自己的MVC框架（四：了解神奇的视图引擎）

    前言:通过之前的三篇介绍,我们基本上完成了从请求发出到路由匹配.再到控制器的激活,再到Action的执行这些个过程.今天还是趁热打铁,将我们的View也来完善下,也让整个系列相对完整,博主不希望烂尾. ...

随机推荐

  1. (总结)Oracle 11g常用管理命令(用户、表空间、权限)

    1.启动oracle数据库: 从root切换到oracle用户进入:su - oracle 进入sqlplus环境,nolog参数表示不登录:sqlplus /nolog 以管理员模式登录:sqlpl ...

  2. 微信调用照相拍照等 js 接口的权限配置 和 照片上传和下载实现

    直接上代码: 1. 前端调试代码: <html> <head> <meta http-equiv="Content-Type" content=&qu ...

  3. Eclipse注释模板设置详解

    设置注释模板的入口:Window->Preference->Java->Code Style->Code Template 然后展开Comments节点就是所有需设置注释的元素 ...

  4. Selenium-java-testng插件安装eclipse

    1 进入Help----Install 2  点击 ADD 输入: TestNG http://beust.com/eclipse 点击OK 3 等一会会加载出如下图,勾选,点击Next  下一步 4 ...

  5. 语义网 （Semantic Web）和 web 3.0

    语义网=有意义的网络. "如果说 HTML 和 WEB 将整个在线文档变成了一本巨大的书,那么 RDF, schema, 和 inference languages 将会使世界上所有的数据变 ...

  6. 让Visual Studio 2013为你自动生成XML反序列化的类

    Visual Sutdio 2013增加了许多新功能,其中很多都直接提高了对代码编辑的便利性.如: 1. 在代码编辑界面的右侧滚动条上显示不同颜色的标签,让开发人员可以对所编辑文档的修改.查找.定位情 ...

  7. 【URAL 1519】Formula 1

    http://acm.timus.ru/problem.aspx?space=1&num=1519 调了好久啊.参考(抄)的iwtwiioi的题解. 如果想要题解,题解在<基于连通性状态 ...

  8. oracle db link的查看创建与删除

    1.查看dblink select owner,object_name from dba_objects where object_type='DATABASE LINK'; 或者 select * ...

  9. poj3581

    Sequence Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 6893   Accepted: 1534 Case Tim ...

  10. Java集合框架List，Map，Set等全面介绍

    Java集合框架的基本接口/类层次结构: java.util.Collection [I]+--java.util.List [I]   +--java.util.ArrayList [C]   +- ...