ss001/g.hnyhua.cn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c2cda58c65deacaec84f620f1e9860376b8071c9
g.hnyhua.cn/Mtxfw.VipSite/Scripts/module.base.js

5334 lines
218 KiB
JavaScript
Raw Normal View History

代码修改后的版本，全部提交
2026-02-07 15:48:27 +08:00
/// <reference path="/global/script/lib/jquery-1.9.0.js" />
/**
*
* module.base.js
*
* 基础模块文件
*
* version 1.0.3.2(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年7月14日14:46:19
*
* last update 2014年9月30日09:57:28
*
*/
//JSON2
if (!this.JSON) { this.JSON = {}; } (function () { function f(n) { return n < 10 ? '0' + n : n; } if (typeof Date.prototype.toJSON !== 'function') { Date.prototype.toJSON = function (key) { return isFinite(this.valueOf()) ? this.getUTCFullYear() + '-' + f(this.getUTCMonth() + 1) + '-' + f(this.getUTCDate()) + 'T' + f(this.getUTCHours()) + ':' + f(this.getUTCMinutes()) + ':' + f(this.getUTCSeconds()) + 'Z' : null; }; String.prototype.toJSON = Number.prototype.toJSON = Boolean.prototype.toJSON = function (key) { return this.valueOf(); }; } var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = { '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"': '\\"', '\\': '\\\\' }, rep; function quote(string) { escapable.lastIndex = 0; return escapable.test(string) ? '"' + string.replace(escapable, function (a) { var c = meta[a]; return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); }) + '"' : '"' + string + '"'; } function str(key, holder) { var i, k, v, length, mind = gap, partial, value = holder[key]; if (value && typeof value === 'object' && typeof value.toJSON === 'function') { value = value.toJSON(key); } if (typeof rep === 'function') { value = rep.call(holder, key, value); } switch (typeof value) { case 'string': return quote(value); case 'number': return isFinite(value) ? String(value) : 'null'; case 'boolean': case 'null': return String(value); case 'object': if (!value) { return 'null'; } gap += indent; partial = []; if (Object.prototype.toString.apply(value) === '[object Array]') { length = value.length; for (i = 0; i < length; i += 1) { partial[i] = str(i, value) || 'null'; } v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '[' + partial.join(',') + ']'; gap = mind; return v; } if (rep && typeof rep === 'object') { length = rep.length; for (i = 0; i < length; i += 1) { k = rep[i]; if (typeof k === 'string') { v = str(k, value); if (v) { partial.push(quote(k) + (gap ? ':' : ':') + v); } } } } else { for (k in value) { if (Object.hasOwnProperty.call(value, k)) { v = str(k, value); if (v) { partial.push(quote(k) + (gap ? ':' : ':') + v); } } } } v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{' + partial.join(',') + '}'; gap = mind; return v; } } if (typeof JSON.stringify !== 'function') { JSON.stringify = function (value, replacer, space) { var i; gap = ''; indent = ''; if (typeof space === 'number') { for (i = 0; i < space; i += 1) { indent += ' '; } } else if (typeof space === 'string') { indent = space; } rep = replacer; if (replacer && typeof replacer !== 'function' && (typeof replacer !== 'object' || typeof replacer.length !== 'number')) { throw new Error('JSON.stringify'); } return str('', { '': value }); }; } if (typeof JSON.parse !== 'function') { JSON.parse = function (text, reviver) { var j; function walk(holder, key) { var k, v, value = holder[key]; if (value && typeof value === 'object') { for (k in value) { if (Object.hasOwnProperty.call(value, k)) { v = walk(value, k); if (v !== undefined) { value[k] = v; } else { delete value[k]; } } } } return reviver.call(holder, key, value); } text = String(text); cx.lastIndex = 0; if (cx.test(text)) { text = text.replace(cx, function (a) { return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); }); } if (/^[\],:{}\s]*$/.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { j = eval('(' + text + ')'); return typeof reviver === 'function' ? walk({ '': j }, '') : j; } throw new SyntaxError('JSON.parse'); }; } } ());
//创建函数原型方法
Function.prototype.Method = function (name, handle) {
/// <summary>
/// 创建函数原型方法
/// </summary>
/// <param name="name" type="String">函数名称</param>
/// <param name="handle" type="Function/JSON Object">操作对象</param>
/// <returns type="Object" />当前对象
this.prototype[name] = handle;
return this;
};
//函数继承
Function.prototype.extend = function (extendFn) {
/// <summary>
/// 函数继承
/// </summary>
/// <param name="extendFn" type="Function">被继承函数</param>
/// <returns type="Object" />当前对象
if (extendFn) {
this.prototype = extendFn.prototype;
}
return this;
};
//添加创建全局(公共)对象(或函数)
window.Global = window.Global || new Object();
//创建添加全局对象(对象将被添加到window对象下，以作为任何地方都可访问的全局对象)
Global.Add = function (name, handle) {
/// <summary>
/// 创建添加公共方法的函数(函数将被添加到window对象下，以作为任何地方都可访问的公共函数)
/// </summary>
/// <param name="name" type="String">名称</param>
/// <param name="handle" type="Function/Object">操作对象，可以是函数，也可以是JSON对象</param>
/// <returns type="Object" />当前对象
window[name] = handle;
return this;
};
; (function () {
//去掉字符串中间的空格(包括开始和结束)
String.Method('trim', function (str) {
/// <summary>去掉字符串中间的空格(包括开始和结束)</summary>
/// <param name="str" type="String">自定义需要将空格替换成什么字符(选填，默认为为空字符[""]，即是去掉空格)</param>
/// <returns type="String" />替换后的字符串
return this.toString().replace(/[ ]/g, str || '');
});
//去掉字符串开始的空格
String.Method('lTrim', function (str) {
/// <summary>去掉字符串开始的空格</summary>
/// <param name="str" type="String">自定义需要将空格替换成什么字符(选填，默认为为空字符[""]，即是去掉空格)</param>
/// <returns type="String" />替换后的字符串
return this.toString().replace(/(^\s*)/g, str || '');
});
//去掉字符串结束的空格
String.Method('rTrim', function (str) {
/// <summary>去掉字符串结束的空格</summary>
/// <param name="str" type="String">自定义需要将空格替换成什么字符(选填，默认为为空字符[""]，即是去掉空格)</param>
/// <returns type="String" />替换后的字符串
return this.toString().replace(/(\s*$)/g, str || '');
});
//替换所有
String.Method('replaceAll', function (beRep, rep) {
/// <summary>替换所有</summary>
/// <param name="beRep" type="String">被替换字符串</param>
/// <param name="rep" type="String">替换字符串</param>
/// <returns type="String" />替换后的字符串
return this.replace(new RegExp(beRep, "gm"), rep);
});
//截取字符串，超过指定长度以"..."代替(默认，可自定义)
String.Method('subString', function (subLength, strReplace) {
/// <summary>截取字符串，超过指定长度以"..."代替(默认，可自定义)</summary>
/// <params name="subLength" type="Int">需要截取字符串的长度</params>
/// <params name="strReplace" type="String">截取字符串，超过指定长度以"..."代替(默认，可自定义)，该参数就是用户自定义的字符或字符串</params>
/// <returns type="String" />截取后的字符串
var that = this.toString();
return (that.length > subLength && subLength) ? (that.substring(0, subLength) + (strReplace ? strReplace : "...")) : (that);
});
//获取字符串中的'{=}'字符
String.Method('regMatch', function (reg) {
/// <summary>获取字符串中的'{=}'字符</summary>
/// <params name="reg" type="String">自定义正则</params>
/// <returns type="Array" />获取到的字符集合
reg = reg || /\{=[^\}]+\}/g;
return this.toString().match(reg);
});
//判断是否为数组
Global.Add('isArray', function (ary) {
/// <summary>判断是否为数组</summary>
/// <param name="ary" type="Array">数组对象</param>
/// <returns type="Boolean" />是否为数组(true.数组 false.非数组)
try {
return Object.prototype.toString.call(ary) === "[object Array]";
} catch (e) {
return false;
}
});
//判断是否为JSON
Global.Add('isJSON', function (json) {
/// <summary>判断是否为JSON</summary>
/// <param name="json" type="Object">JSON对象</param>
/// <returns type="Boolean" />是否为JSON(true.JSON false.非JSON)
try {
return (typeof (json) == "object" && Object.prototype.toString.call(json).toLowerCase() == "[object object]" && !json.length);
} catch (e) {
return false;
}
});
//判断是否为函数
Global.Add('isFunction', function (fun) {
/// <summary>判断是否为函数</summary>
/// <param name="fun" type="Function">函数对象</param>
/// <returns type="Boolean" />是否为函数(true.函数 false.非函数)
return typeof (fun) === 'function';
});
//判断是否为字符串
Global.Add('isString', function (str) {
/// <summary>判断是否为字符串</summary>
/// <param name="str" type="String">字符串</param>
/// <returns type="Boolean" />是否为字符串(true.字符串 false.非字符串)
return typeof (str) === 'string';
});
//判断是否为数字
Global.Add('isNumber', function (num) {
/// <summary>判断是否为数字</summary>
/// <param name="num" type="Int">数字</param>
/// <returns type="Boolean" />是否为数字(true.数字 false.非数字)
return !isNaN(num);
});
//判断是否为Boolean类型
Global.Add('isBoolean', function (bool) {
/// <summary>判断是否为Boolean类型</summary>
/// <param name="bool" type="Boolean">boolean</param>
/// <returns type="Boolean" />是否为Boolean类型(true.boolean类型 false.非boolean类型)
try {
return (typeof (eval(bool)) == 'boolean');
} catch (e) { }
return false;
});
//判断是否为Url
Global.Add('isUrl', function (url) {
/// <summary>判断是否为Url</summary>
/// <param name="url" type="String">需要判断的字符串</param>
/// <returns type="Boolean" />是否为Url(true.Url false.非Url)
var reg = /^[a-zA-z]+:\/\/([a-zA-Z0-9\-\.]+)([-\w .\/?%&=:]*)$/;
return new RegExp(reg).test(url);
});
//判断浏览器类型是否为360
Global.Add('is360', function () {
/// <summary>判断浏览器类型是否为360</summary>
/// <returns type="Boolean" />是否为360
var result = false;
if (window.navigator.userAgent.toLowerCase().indexOf("360se") >= 1) { result = true; }
if (window.external && window.external.twGetRunPath) {
var runPath = external.twGetRunPath();
if (runPath && runPath.toLowerCase().indexOf("360se") > -1) { result = true }
}
return result;
});
//判断是否为'false'，不论是字符串还是布尔类型
Global.Add('isFalse', function (value) {
/// <summary>判断是否为'false'，不论是字符串还是布尔类型</summary>
/// <param name="value" type="String/Boolean">需要判断的值</param>
/// <returns type="Boolean" />不论是字符串还是布尔类型，不区分大小写，只要为false则返回true，否则返回false
return value != null && value != undefined ? value.toString().toLocaleLowerCase() === 'false' ? true : false : false;
});
//判断是否为'true'，不论是字符串还是布尔类型
Global.Add('isTrue', function (value) {
/// <summary>判断是否为'true'，不论是字符串还是布尔类型</summary>
/// <param name="value" type="String/Boolean">需要判断的值</param>
/// <returns type="Boolean" />不论是字符串还是布尔类型，不区分大小写，只要为true则返回true，否则返回false
return value ? value.toString().toLocaleLowerCase() === 'true' ? true : false : false;
});
//判断元素对象(默认为浏览器对象)是否出现滚动条
Global.Add('isScroll', function (target) {
/// <summary>判断一个元素对象（默认为浏览器对象）是否出现滚动条</summary>
/// <param name="target" type="Element">元素对象(默认为body)</param>
/// <returns type="JSON">{x: 下(true:有 false:无), y: 右(true:有 false:无)}
//初始化变量值
target = target ? (target.length ? target : [target]) : [document.documentElement, document.body];
var xStatus = false, yStatus = false;
var i = 0, length = target.length, element, scrollLeft, scrollTop;
for (; i < length; i++) {
element = target[i];
//获取scrollLeft
scrollLeft = element.scrollLeft;
element.scrollLeft += scrollLeft > 0 ? -1 : 1;
element.scrollLeft !== scrollLeft && (xStatus = xStatus || true);
element.scrollLeft = scrollLeft;
//获取scrollTop
scrollTop = element.scrollTop;
element.scrollTop += scrollTop > 0 ? -1 : 1;
element.scrollTop !== scrollTop && (yStatus = yStatus || true);
element.scrollTop = scrollTop;
}
return { x: xStatus, y: yStatus };
});
//获取元素对象(默认为浏览器对象)滚动条距顶部的距离和距左边的距离
Global.Add('getScroll', function (target) {
/// <summary>获取滚动条距顶部的距离和距左边的距离</summary>
/// <param name="target" type="Element">元素对象(默认为body)</param>
/// <returns type="JSON">{left: 横向滚动条距左边的距离, top: 纵向滚动条距上边的距离}
var x, y;
if (target) {
target = target.length ? target[0] : target;
x = target.scrollLeft;
y = target.scrollTop;
}
else {
if (window.pageYOffset) {
x = window.pageXOffset;
y = window.pageYOffset;
}
else if (document.compatMode && document.compatMode != 'BackCompat') {
x = document.documentElement.scrollLeft || document.body.scrollLeft;
y = document.documentElement.scrollTop || document.body.scrollTop;
}
else if (document.body) {
x = document.body.scrollLeft;
y = document.body.scrollTop;
}
}
return { left: x, top: y };
});
//获取元素对象(默认为浏览器对象)的宽和高(可操作区域，包括滚动条内所有内容)
Global.Add('scrollSize', function (target) {
/// <summary>获取元素对象(默认为浏览器对象)的宽和高(可操作区域，包括滚动条内所有内容)</summary>
/// <param name="target" type="Element">元素对象(默认为body)</param>
/// <returns type="JSON">{width: 宽, height: 高}
var height, width;
if (target) {
target = target.length ? target[0] : target;
var offsetHeight = target.offsetHeight,
scrollHeight = target.scrollHeight;
height = scrollHeight > offsetHeight ? scrollHeight : offsetHeight;
var offsetWidth = target.offsetWidth,
scrollWidth = target.scrollWidth;
width = scrollWidth > offsetWidth ? scrollWidth : offsetWidth;
}
else {
var clientHeight = document.documentElement.clientHeight;
var offsetHeight = document.body.offsetHeight;
var docHeight = document.documentElement.offsetHeight;
var scrollHeight = document.body.scrollHeight;
height = offsetHeight >= clientHeight ? offsetHeight : clientHeight;
height = height < docHeight ? docHeight : height;
height = height < scrollHeight ? scrollHeight : height;
clientWidth = document.documentElement.clientWidth;
offsetHeight = document.body.offsetWidth;
docHeight = document.documentElement.offsetWidth;
scrollHeight = document.body.scrollWidth;
width = offsetHeight >= clientWidth ? offsetHeight : clientWidth;
width = width < docHeight ? docHeight : width;
width = width < scrollHeight ? scrollHeight : width;
}
return { width: width, height: height };
});
//获取元素对象(默认为浏览器对象)的宽和高(可见区域，不包括滚动条内所有内容)
Global.Add('clientSize', function (target) {
/// <summary>获取元素对象(默认为浏览器对象)的宽和高(可见区域，不包括滚动条内所有内容)</summary>
/// <param name="target" type="Element">元素对象(默认为body)</param>
/// <returns type="JSON">{width: 宽, height: 高}
var width = 0, height = 0;
if (target) {
target = target.length ? target[0] : target;
width = target.offsetWidth, height = target.offsetHeight;
}
else {
if (self.innerHeight && self.innerWidth) {
width = self.innerWidth, height = self.innerHeight;
}
else {
var documentElement = document.documentElement;
width = documentElement.clientWidth, height = documentElement.clientHeight;
}
}
return { width: width, height: height };
});
//时间线程模拟循环(提高遍历数据执行效率)
Global.Add('listEach', function (list, each, callBack) {
/// <summary>时间线程模拟循环(提高遍历数据执行效率)</summary>
/// <param name="list" type="Array List">遍历的数据集合</param>
/// <param name="each" type="Function">遍历时回调函数</param>
/// <param name="callBack" type="Function">遍历完成时回调函数</param>
var i = 0, length = list.length, item;
if (length) {
var listThread = window.setInterval(function () {
item = list[i];
if (isFunction(each)) {
each.call(item, i);
}
i++;
if (i >= length) {
window.clearInterval(listThread);
listThread = null;
if (isFunction(callBack)) {
callBack.call(list, length);
}
}
}, 1);
}
});
//判断浏览器类型
Global.Add('browser', function () {
/// <summary>获取浏览器类型及版本</summary>
/// <returns type="Object" />浏览器类型信息
var typeInfo = {}, userAgent = navigator.userAgent.toLowerCase(), info;
(info = userAgent.match(/msie ([\d.]+)/)) ? typeInfo.ie = info[1] :
(info = userAgent.match(/firefox\/([\d.]+)/)) ? typeInfo.firefox = info[1] :
(info = userAgent.match(/chrome\/([\d.]+)/)) ? typeInfo.chrome = info[1] :
(info = userAgent.match(/opera.([\d.]+)/)) ? typeInfo.opera = info[1] :
(info = userAgent.match(/version\/([\d.]+).*safari/)) ? typeInfo.safari = info[1] : 0;
return typeInfo;
});
//密码强度验证(类型：数字、大写字母、小写字母、特殊字符)
Global.Add('evaluate', function (word, lens) {
/// <summary>密码强度验证(类型：数字、大写字母、小写字母、特殊字符)</summary>
/// <param name="word" type="String">密码字符串</param>
/// <param name="lens" type="Int">密码长度</param>
/// <returns type="Int" />返回密码强度级别
if (lens != undefined) {
lens = lens || 6;
}
else {
lens = 1;
}
//CharMode函数
//测试某个字符是属于哪一类.
var CharMode = function (iN) {
if (iN >= 48 && iN <= 57) //数字
return 1;
if (iN >= 65 && iN <= 90) //大写字母
return 2;
if (iN >= 97 && iN <= 122) //小写
return 4;
else
return 8; //特殊字符
};
//bitTotal函数
//计算出当前密码当中一共有多少种模式
var bitTotal = function (num) {
modes = 0;
for (i = 0; i < 4; i++) {
if (num & 1) modes++;
num >>>= 1;
}
return modes;
};
//checkStrong函数
//返回密码的强度级别
var checkStrong = function (sPW) {
if (sPW.length < lens)
return 0; //密码太短
Modes = 0;
for (i = 0; i < sPW.length; i++) {
//测试每一个字符的类别并统计一共有多少种模式.
Modes |= CharMode(sPW.charCodeAt(i));
}
return bitTotal(Modes);
};
return checkStrong(word);
});
//获取事件的目标元素
Global.Add('eventTarget', function (e) {
/// <summary>获取事件的目标元素</summary>
/// <param name="e" type="Event">Event对象</param>
/// <returns type="Element" />目标元素
e = e || window.event;
return e.target || e.srcElement || arguments.callee.caller.arguments[0];
});
//获取事件坐标
Global.Add('eventCoordinates', function (e) {
/// <summary>获取事件坐标</summary>
/// <param name="e" type="Event">Event对象</param>
/// <returns type="JSON Object" />坐标对象
var coor = { x: 0, y: 0 };
e = e || window.event;
coor.x = e.clientX, coor.y = e.clientY;
return coor;
});
//阻止浏览器的默认行为
Global.Add('stopDefault', function (e) {
e = e || window.event;
//如果提供了事件对象，则这是一个非IE浏览器
if (e && e.preventDefault) {
//阻止默认浏览器动作(W3C)
e.preventDefault();
} else {
//IE中阻止函数器默认动作的方式
try {
if (e.returnValue) {
e.returnValue = false;
}
} catch (e) {
}
}
return false;
});
//停止事件冒泡
Global.Add('stopBubble', function (e) {
e = e || window.event;
//如果提供了事件对象，则这是一个非IE浏览器
if (e && e.stopPropagation) {
//因此它支持W3C的stopPropagation()方法
e.stopPropagation();
} else {
//否则，我们需要使用IE的方式来取消事件冒泡
e.cancelBubble = true;
}
return false;
});
//设置元素透明度
Global.Add('opacity', function (target, opacity) {
/// <summary>设置元素透明度</summary>
/// <param name="target" type="Element">目标元素</param>
/// <param name="opacity" type="Number">透明度(取值为：0~1之间)</param>
target = $(target);
target.css('filter', 'alpha(opacity=' + (opacity * 100) + ')')
.css('-moz-opacity', opacity)
.css('-khtml-opacity', opacity)
.css('opacity', opacity);
});
//等比例缩放
Global.Add('suchAsScaling', function (opts) {
opts = opts || {};
var options = {
//原始宽度
width: opts.width || 10,
//原始高度
height: opts.height || 10,
//最大宽度
maxWidth: opts.maxWidth || 100,
//最大高度
maxHeight: opts.maxHeight || 100
};
var width = options.width, height = options.height,
maxWidth = options.maxWidth, maxHeight = options.maxHeight,
resultWidth = width, resultHeight = height,
rate = 0;
if (height > maxHeight && width < maxWidth) {
resultHeight = maxHeight;
rate = width > height ? height / width : width / height;
resultWidth = (((height - maxHeight) / height) * width) * rate;
}
else if (width > maxWidth && height < maxHeight) {
resultWidth = maxWidth;
rate = width > height ? height / width : width / height;
resultHeight = (((width - maxWidth) / width) * height) * rate;
}
else if (width > maxHeight && height > maxHeight) {
if (width > height) {
resultWidth = maxWidth;
resultHeight = ((maxWidth / width) * height) * (height / width);
}
else {
resultHeight = maxHeight;
resultWidth = ((maxHeight / h) * w) * (width / h);
}
}
var marginLeft = 0, marginTop = 0;
if (resultWidth < maxWidth) {
marginLeft = (maxWidth - resultWidth) / 2;
}
if (resultHeight < maxHeight) {
marginTop = (maxHeight - resultHeight) / 2;
}
return { width: resultWidth, height: resultHeight, marginTop: marginTop, marginLeft: marginLeft };
});
})();
; (function () {
/// <summary>
/// 创建模块对象
/// </summary>
var TheModule = function () {
/// <summary>
/// 模块对象
/// </summary>
var that = this;
//identity
that.identity = 0;
//版本
that.version = '1.0.3.2';
//作者
that.author = 'pye-mail@163.com';
//更新历史
that.history = [
{ date: '2015年3月10日14:18:25', handle: '创建', remark: '创建O2O WebApp base' }
];
//模块加载完成
that.loadComplete = true;
//基础地址
that.basePath = '/global/script/module/';
var ModelGroup = new Object();
//GUID.全局唯一标识符
TheModule.Method('Guid', function (prefix) {
/// <summary>
/// GUID.全局唯一标识符
/// </summary>
/// <param name="prefix" type="String">前缀</param>
/// <returns type="String" />前缀(prefix) + GUID
var result = prefix ? (prefix + that.identity) : that.identity;
that.identity += 1;
return result;
});
//创建模块
TheModule.Method('Create', function (name, handle) {
/// <summary>
/// 创建模块
/// </summary>
/// <param name="name" type="String">模块名称</param>
/// <param name="handle" type="Function/JSON Object">操作函数/对象</param>
ModelGroup[name] = handle;
});
//引用模块
TheModule.Method('Use', function (name, arguments, callBack) {
/// <summary>
/// 创建模块
/// </summary>
/// <param name="name" type="String">模块名称</param>
/// <param name="callBack" type="Function">回调函数</param>
var ModelHandle = ModelGroup[name],
ModelResult;
if (ModelHandle) {
if (typeof (arguments) == 'function') {
callBack = arguments;
arguments = null;
}
ModelResult = new ModelHandle(arguments);
if (callBack) {
//callBack.call(ModelHandle, ModelResult);
callBack(ModelHandle, ModelResult);
}
}
else {
var msg = "Cannot find module '" + name + "'";
alert(msg);
Module.Error(msg);
}
return ModelResult;
});
//加载(模块文件[JS文件])
TheModule.Method('Require', function (path, callBack) {
/// <summary>
/// 加载(模块文件[JS文件])
/// </summary>
/// <param name="path" type="String/Array">模块名或集合</param>
/// <param name="callBack" type="Function">回调函数</param>
if (path) {
var pathArray = [];
if (isString(path)) {
pathArray.push(path);
}
else if (isArray(path)) {
pathArray = path;
}
else {
return false;
}
var flag = false;
if (callBack) {
if (isBoolean(callBack)) {
flag = callBack;
callBack = null;
}
}
var isBrowser = !!(typeof window !== 'undefined' && navigator && document);
var isWebWorker = !isBrowser && typeof importScripts !== 'undefined';
var isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]';
var readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ? /^complete$/ : /^(complete|loaded)$/
var head = document.getElementsByTagName('head')[0], scriptTarget, scriptID;
var i = 0, length = pathArray.length, pathItem, src, count = 0;
var scriptLoad = function (event) {
if (event.type === 'load' || (readyRegExp.test((event.currentTarget || event.srcElement).readyState))) {
count++;
if (count == length) {
if (callBack) {
callBack.call(this);
}
}
}
};
for (; i < length; i++) {
pathItem = pathArray[i];
scriptID = 'J-require-#MODULE#'.replace('#MODULE#', pathItem);
scriptTarget = document.getElementById(scriptID);
if (scriptTarget) {
count++;
if (count == length) {
if (callBack) {
callBack.call(this);
}
}
}
else {
if (flag) {
src = pathItem;
}
else {
src = that.basePath + pathItem + '.js';
}
scriptTarget = document.createElement('script');
scriptTarget.type = 'text/javascript';
scriptTarget.charset = 'utf-8';
scriptTarget.async = true;
scriptTarget.setAttribute('data-module', pathItem);
scriptTarget.setAttribute('id', scriptID);
if (isBrowser) {
if (scriptTarget.attachEvent && !(scriptTarget.attachEvent.toString && scriptTarget.attachEvent.toString().indexOf('[native code') < 0) && !isOpera) {
scriptTarget.attachEvent('onreadystatechange', scriptLoad);
} else {
scriptTarget.addEventListener('load', scriptLoad, false);
}
scriptTarget.src = src;
head.appendChild(scriptTarget);
}
else if (isWebWorker) {
importScripts(src);
scriptLoad();
}
}
}
}
});
//保存RequireCallBack事件
TheModule.Method('onRequireCallBack', function (callBack) {
if (callBack) {
that.customCallBack = that.customCallBack || {};
that.customCallBack['onRequireCallBack'] = callBack;
}
});
//响应RequireCallBack事件，主要用于组合模块调用
TheModule.Method('getCustomCallBackEvent', function () {
var requireCallBack = that.customCallBack['onRequireCallBack'];
if (requireCallBack) {
requireCallBack();
}
that.customCallBack['onRequireCallBack'] = null;
});
//执行代码
TheModule.Method('Run', function (fun) {
if (fun) {
$(function () {
var pageHandle = {
//刷新本页面
refresh: function () {
/// <summary>
/// 刷新本页面
/// </summary>
var url = window.location.href;
window.location.href = url;
return pageHandle;
},
//在本页打开另一页面
jump: function (url, data) {
/// <summary>
/// 在本页打开另一页面
/// </summary>
/// <param name="url" type="String">跳转路径</param>
/// <param name="data" type="JSON Object">新页面所需数据</param>
if (url) {
if (data && isJSON(data)) {
var hasParam = url.indexOf('?'), firstSplit = '?', i = 0;
if (hasParam) {
firstSplit = '&';
}
for (var key in data) {
if (i == 0) {
url += firstSplit + key + '=' + data[key];
}
else {
url += '&' + key + '=' + data[key];
}
}
}
window.location.href = url;
}
return pageHandle;
},
//返回历史记录中上一次访问的页面
history: function (back) {
/// <summary>
/// 返回历史记录中上一次访问的页面
/// </summary>
/// <param name="back" type="Int">返回第几步，默认为-1，上一步</param>
return pageHandle;
}
};
fun.call(pageHandle);
});
}
});
//异步请求完成后执行
TheModule.Method('AsyncRun', function (fun) {
if (fun) {
//异步执行操作
Module.asyncRunHandle = function () {
var tabID = GlobalTabID;
var pageHandle = {
//刷新本页面
refresh: function () {
/// <summary>
/// 刷新本页面
/// </summary>
return pageHandle;
},
//在本页打开另一页面
jump: function (path, data) {
/// <summary>
/// 在本页打开另一页面
/// </summary>
/// <param name="path" type="String">跳转路径</param>
/// <param name="title" type="String">跳转页面后标签标题</param>
/// <param name="data" type="JSON Object">新页面所需数据</param>
if (isJson(title)) {
data = title;
title = null;
}
return pageHandle;
},
//返回历史记录中上一次访问的页面
history: function (back) {
/// <summary>
/// 返回历史记录中上一次访问的页面
/// </summary>
/// <param name="back" type="Int">返回第几步，默认为-1，上一步</param>
return pageHandle;
}
};
fun.call(pageHandle);
Module.asyncRunHandle = null;
};
}
});
//保存异步请求历史记录
TheModule.Method('AsyncHistory', function (options) {
var path = options.path;
var thisOptions = {};
thisOptions.tabID = tabID;
thisOptions.path = path;
thisOptions.title = options.title;
thisOptions.data = options.data;
NavTabsModelInstance.history = NavTabsModelInstance.history || {};
NavTabsModelInstance.history[tabID] = NavTabsModelInstance.history[tabID] || {
//所有历史记录页面地址
path: [],
//当前页位置
pageIdx: 0
};
var historyList = NavTabsModelInstance.history[tabID];
var pathList = historyList.path;
var i = 0, length = pathList.length, pathItem, flag = true;
for (; i < length; i++) {
pathItem = pathList[i];
if (pathItem.path == path) {
flag = false;
break;
}
}
if (flag) {
pathList.push(thisOptions);
historyList.pageIdx++;
}
});
//抛出错误消息
TheModule.Method('Error', function (msg) {
/// <summary>
/// 抛出错误消息
/// </summary>
/// <param name="msg" type="String">消息内容</param>
throw msg instanceof Error ? msg : new Error(msg);
});
//MediaQuery
TheModule.Method('onMediaQuery', function (width, callBack) {
var browserInfo = browser();
var mediaHandle = function () {
if (browserInfo.ie) {
var ieVersion = parseInt(browserInfo.ie);
if (ieVersion < 8) {
if (callBack && isFunction(callBack)) {
$(window).resize(function () {
var clientInfo = clientSize();
var clientWidth = clientInfo.width;
if (width) {
if (clientWidth < width) {
callBack.call(browserInfo, clientWidth);
}
}
else {
callBack.call(browserInfo, clientWidth);
}
});
}
}
}
};
if (isNumber(width)) {
mediaHandle();
}
else if (isFunction(width)) {
callBack = width;
width = null;
mediaHandle();
}
});
};
Global.Add('Module', new TheModule);
})();
/**
*
* 模拟线程
*
* version 1.0.2.0(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年7月14日14:12:44
*
* update log 2014年7月15日09:58:46
*
*/
Module.Create('Thread', function () {
/// <summary>
/// 模拟线程类
/// </summary>
/// <param name='fun' type='Function'>线程执行函数</param>
/// <param name='timer' type='Int'>线程执行间隔时间(单位：毫秒[1000毫秒 = 1秒])</param>
var that = this;
that.Thread = function (fun, timer) {
var that = this;
var startThread, timingStartThread, timingStopThread, suspendThread;
var ThreadModel = function (fun, timer) {
var that = this;
that.fun = fun;
that.timer = timer;
};
var clearAllThread = function () {
//清空启动中定时启动的线程
window.clearTimeout(timingStartThread),
timingStartThread = null;
//清空start线程
window.clearInterval(startThread),
startThread = null;
//清空暂停中的线程
window.clearTimeout(suspendThread),
suspendThread = null;
//清空定时停止线程
window.clearTimeout(timingStopThread),
timingStopThread = null;
};
var ThreadModelInstance = new ThreadModel(fun, timer);
//启动线程
that.start = function (timer) {
/// <summary>
/// 启动线程
/// </summary>
/// <param name='timer' type='Int'>启动线程的时间，即多少毫秒后启动，默认(不填时)为立即启动(单位：毫秒[1000毫秒 = 1秒])</param>
var that = this;
timer = timer || 0;
timingStartThread = window.setTimeout(function () {
clearAllThread();
//启动模拟线程
startThread = window.setInterval(ThreadModelInstance.fun, ThreadModelInstance.timer);
}, timer);
};
//停止线程
that.stop = function (timer) {
/// <summary>
/// 停止线程
/// </summary>
/// <param name='timer' type='Int'>停止线程的时间，即多少毫秒后停止，默认(不填时)为立即停止(单位：毫秒[1000毫秒 = 1秒])</param>
var that = this;
timer = timer || 0;
timingStopThread = window.setTimeout(function () {
clearAllThread();
}, timer);
};
//暂停线程
that.suspend = function (timer) {
/// <summary>
/// 暂停线程
/// </summary>
/// <param name='timer' type='Int'>暂停线程的时间，即多少毫秒后继续执行，默认(不填时)为1000(单位：毫秒[1000毫秒 = 1秒])</param>
var that = this;
timer = timer || 1000;
var againStart = that.start;
clearAllThread();
suspendThread = window.setTimeout(againStart, timer);
};
};
});
/**
*
* Touch 移动端Web触摸滑动事件模块
*
* version 1.0.2.2(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年8月30日15:01:55
*
* update log 2014年8月30日16:03:25
* 2014年9月9日14:37:30(兼容pc端(IE6,7,8,9)、windows phone(IE10，11)和android、ios的触摸事件，只需要和android,ios一样使用函数就可以了)
* 2014年10月14日09:36:41(修复低版本IE出错的Bug)
*
*/
Module.Create('Touch', function () {
/// <summary>
/// 移动端Web触摸滑动事件模块
/// </summary>
var that = this;
//函数封装(或包装)
var EncapsulationFunction = function (handle) {
/// <summary>
/// 函数封装(或包装)，将传入的函数包装为我们需要的函数对象
/// </summary>
/// <param name="handle" type="JSON Object">函数对象</param>
var that = this;
//触摸开始函数
that.start = handle.start || null;
//触摸滑动函数
that.move = handle.move || null;
//触摸结束函数
that.end = handle.end || null;
};
//封装一个我们需要的触摸事件参数集合对象
var EncapsulationTouch = function (touch, event) {
/// <summary>
/// 封装一个我们需要的触摸事件参数集合对象
/// </summary>
/// <param name="touch" type="Object">Touch对象</param>
/// <param name="event" type="Event Object">触摸事件对象</param>
var that = this;
var count = 0;
if (touch) {
var i = 0, length = touch.length, touchItem;
for (; i < length; i++) {
//获取第i个手指的触摸事件相关参数
touchItem = touch[i];
if (touchItem) {
that['touch' + (i + 1)] = { x: touchItem.clientX, y: touchItem.clientY, event: event };
count++;
}
}
//保存当前触发触摸事件的手指个数
that['length'] = count;
}
else {
that['touch1'] = { x: event.clientX, y: event.clientY, event: event };
count = 1;
}
//保存当前触发触摸事件的手指个数
that['length'] = count;
};
//触摸滑动事件封装
that.TouchSlide = function (options) {
/// <summary>
/// 触摸基本事件
/// </summary>
/// <param name="options" type="JSON Object">参数对象</param>
/// <param name="handle" type="Function/JSON Object">操作函数(move)对象或集合</param>
var that = this;
var TouchSlideModel = function (model) {
var that = this;
that.target = $(model.target || document.body);
that.handle = model.handle;
that.preventDefault = isFalse(model.preventDefault) ? false : true;
};
var TouchSlideModelInstance = new TouchSlideModel(options || {});
var TouchEventType = function () {
var that = this;
that.MSPointerType = {
start: 'MSPointerOver',
move: 'MSPointerMove',
end: 'MSPointerOut'
};
that.pointerType = {
start: 'pointerover',
move: 'pointermove',
end: 'pointerout'
};
that.touchType = {
start: 'touchstart',
move: 'touchmove',
end: 'touchend'
};
that.mouseType = {
start: 'mousedown',
move: 'mousemove',
end: 'mouseup',
out: 'mouseout'
};
};
var EventType = new TouchEventType();
var isTouch = function () {
return typeof window.ontouchstart !== 'undefined';
};
var isMSPointer = function () {
return window.navigator.msPointerEnabled;
};
var isPointer = function () {
return window.navigator.pointerEnabled;
};
var bindEvent = function (target, eventName, handle) {
if (target) {
if (isString(eventName)) {
target['on' + eventName] = handle;
}
else if (isArray(eventName)) {
var i = 0, length = eventName.length;
for (; i < length; i++) {
target['on' + eventName[i]] = handle[i];
}
}
}
};
var install = function () {
var handle = TouchSlideModelInstance.handle,
target = TouchSlideModelInstance.target,
preventDefault = TouchSlideModelInstance.preventDefault;
//封装基础操作函数
var baseHandle = new EncapsulationFunction(handle || {});
if (target) {
var touchStart, touchMove, touchEnd, touchFlag = false, moveTouchFlag = false;
//触摸开始事件
var startHandle = function (event) {
/// <summary>
/// 触摸开始事件
/// </summary>
/// <param name="e">Window Event</param>
event = event || window.event;
if (!touchFlag) {
//获取手指触摸移动对象
touchStart = new EncapsulationTouch(event.targetTouches, event);
if (baseHandle.start) {
//响应事件
baseHandle.start.call(this, touchStart);
}
var customEvent = that.customEvent;
if (customEvent) {
var touchStartEvent = customEvent.onTouchStart;
if (touchStartEvent && typeof (touchStartEvent) == 'function') {
touchStartEvent.call(this, touchStart);
}
}
//激活Touch状态
touchFlag = true;
this.onclick = function () {
moveTouchFlag = true;
$(this).mouseup();
};
//阻止内容(如图片、文字、链接等)被拖动
return false;
}
};
//触摸移动事件
var moveHandle = function (event) {
/// <summary>
/// 触摸移动事件
/// </summary>
/// <param name="event">Window Event</param>
event = event || window.event;
if (touchFlag) {
if (event.preventDefault) {
//touchmove事件加上preventDefault从而阻止触摸时浏览器的缩放、滚动条滚动等
event.preventDefault();
}
//获取手指触摸移动对象
touchMove = new EncapsulationTouch(event.touches, event);
var xDistance = touchStart.touch1.x - touchMove.touch1.x,
yDistance = touchStart.touch1.y - touchMove.touch1.y;
if (baseHandle.move) {
//响应事件
baseHandle.move.call(this, touchStart, touchMove, [xDistance, yDistance]);
}
var customEvent = that.customEvent;
if (customEvent) {
var touchMoveEvent = customEvent.onTouchMove;
if (touchMoveEvent && typeof (touchMoveEvent) == 'function') {
touchMoveEvent.call(this, touchStart, touchMove, [xDistance, yDistance]);
}
}
if (yDistance > 0) {
//向上滑动事件
if (customEvent) {
var slideUpEvent = customEvent.onSlideUp;
if (slideUpEvent && typeof (slideUpEvent) == 'function') {
slideUpEvent.call(this, touchStart, touchMove, yDistance);
}
}
}
else {
//向下滑动事件
if (customEvent) {
var slideDownEvent = customEvent.onSlideDown;
if (slideDownEvent && typeof (slideDownEvent) == 'function') {
slideDownEvent.call(this, touchStart, touchMove, yDistance);
}
}
}
if (xDistance > 0) {
//向左滑动事件
if (customEvent) {
var slideLeftEvent = customEvent.onSlideLeft;
if (slideLeftEvent && typeof (slideLeftEvent) == 'function') {
slideLeftEvent.call(this, touchStart, touchMove, xDistance);
}
}
}
else {
//向右滑动事件
if (customEvent) {
var slideRightEvent = customEvent.onSlideRight;
if (slideRightEvent && typeof (slideRightEvent) == 'function') {
slideRightEvent.call(this, touchStart, touchMove, xDistance);
}
}
}
moveTouchFlag = true;
}
};
//触摸结束事件
var endHandle = function (event) {
/// <summary>
/// 触摸结束事件
/// </summary>
/// <param name="event">Window Event</param>
event = event || window.event;
if (touchFlag && moveTouchFlag) {
//获取结束触摸事件对象
touchEnd = new EncapsulationTouch(event.changedTouches, event);
var xDistance = touchStart.touch1.x - touchEnd.touch1.x,
yDistance = touchStart.touch1.y - touchEnd.touch1.y;
if (baseHandle.end) {
//响应事件
setTimeout(function () {
baseHandle.end.call(this, touchStart, touchEnd, [xDistance, yDistance]);
}, 1);
}
var customEvent = that.customEvent;
if (customEvent) {
var touchEndEvent = customEvent.onTouchEnd;
if (touchEndEvent && typeof (touchEndEvent) == 'function') {
setTimeout(function () {
touchEndEvent.call(this, touchStart, touchEnd, [xDistance, yDistance]);
}, 1);
}
var slideEndEvent = customEvent.onSlideEnd;
if (slideEndEvent && typeof (slideEndEvent) == 'function') {
setTimeout(function () {
slideEndEvent.call(this, touchStart, touchEnd, [xDistance, yDistance]);
}, 1);
}
}
//还原Touch状态
touchFlag = false;
moveTouchFlag = false;
this.onclick = function () {
this.onclick = null;
return false;
};
}
};
var type = null;
if (isTouch()) {
type = EventType.touchType;
}
else if (isMSPointer()) {
type = EventType.MSPointerType;
}
else if (isPointer()) {
type = EventType.pointerType;
}
else {
type = EventType.mouseType;
}
if (type) {
bindEvent(target[0], type.start, startHandle);
bindEvent(target[0], type.move, moveHandle);
bindEvent(target[0], type.end, endHandle);
}
}
};
install();
//触摸开始
that.onTouchStart = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onTouchStart'] = fun;
}
return that;
};
//触摸滑动
that.onTouchMove = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onTouchMove'] = fun;
}
return that;
};
//触摸结束
that.onTouchEnd = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onTouchEnd'] = fun;
}
return that;
};
//向上滑动(返回参数：touchStart, touchMove, yDistance)
that.onSlideUp = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onSlideUp'] = fun;
}
return that;
};
//向下滑动(返回参数：touchStart, touchMove, yDistance)
that.onSlideDown = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onSlideDown'] = fun;
}
return that;
};
//向左滑动(返回参数：touchStart, touchMove, xDistance)
that.onSlideLeft = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onSlideLeft'] = fun;
}
return that;
};
//向右滑动(返回参数：touchStart, touchMove, xDistance)
that.onSlideRight = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onSlideRight'] = fun;
}
return that;
};
//滑动结束
that.onSlideEnd = function (fun) {
if (fun) {
that.customEvent = that.customEvent || {};
that.customEvent['onSlideEnd'] = fun;
}
return that;
};
};
});
/**
*
* Sliders 滑块切换效果
*
* version 1.0.0.0(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年7月25日09:33:24
*
* update log 2014年7月30日17:48:57
*
* remark 依赖于Thread和Touch模块
*
*/
Module.Create('Sliders', function () {
/// <summary>
/// 实现滚动效果函数对象(依赖于Thread和Touch模块)
/// </summary>
var that = this;
//移动端触摸滑动效果(依赖于Touch、Thread模块)
that.TouchSlider = function (options) {
/// <summary>
/// 移动端触摸滑动效果(依赖于Touch、Thread模块)
/// </summary>
/// <param name="options" type="JSON Object">函数对象所需参数对象集合</param>
var that = this;
//创建实体对象
var SliderModel = function (model) {
/// <summary>
/// 滑动效果实体对象
/// </summary>
/// <param name="model" type="JSON Object">实体对象</param>
var that = this;
//容器对象
that.container = $(model.container || document.body);
//滚动项每一项的宽度
that.itemWidth = model.itemWidth;
//一次滚动多少个项
that.switchCount = model.switchCount || 1;
//是否自动播放
that.isAutoPlay = model.isAutoPlay != undefined && model.isAutoPlay != null ? model.isAutoPlay : true;
//滚动时间间隔
that.timeout = model.timeout || 5000;
//是否无缝隙滚动
that.isSeamlessSwitch = model.isSeamlessSwitch != undefined && model.isSeamlessSwitch != null ? model.isSeamlessSwitch : true;
//滚动目标元素
that.switchTarget = model.switchTarget || '.J-target-slider';
//滚动目标元素Item
that.switchTargetItem = model.switchTargetItem || '.J-slider-item';
//滚动指示器
that.indicators = model.indicators || '.J-slider-indicators';
//指示器Item
that.indicatorsItem = model.indicatorsItem || '.ui-slider-indicator';
//当前项
that.currentIndicators = model.currentIndicators || 'ui-slider-indicator-current';
//自定义事件
that.customEvent = model.customEvent || new Object();
};
//实例化实体对象
var SliderModelInstance = new SliderModel(options || {});
//初始化操作
var install = function () {
var container = SliderModelInstance.container;
var switchTarget = container.find(SliderModelInstance.switchTarget),
switchTargetItem = container.find(SliderModelInstance.switchTargetItem),
indicators = container.find(SliderModelInstance.indicators),
indicatorsItem = container.find(SliderModelInstance.indicatorsItem);
var indicatorsWidth = indicatorsItem.length * 20;
indicators.css('width', indicatorsWidth + 'px').css('margin-left', -(indicatorsWidth / 2) + 'px');
//Item长度
var itemLength = switchTargetItem.length;
//Item宽度
var itemWidth = SliderModelInstance.itemWidth || switchTargetItem[0].offsetWidth;
//内容总宽度
var contentWidth = itemLength * itemWidth;
//设置内容宽度
switchTarget.css('position', 'absolute').css('width', (contentWidth) + 'px').css('float', 'left');
switchTargetItem.css('width', (itemWidth) + 'px').css('float', 'left');
if ($('#strQty').length) {
setTimeout(function () {
container.css('height', container.find('.ui-slider-repeater').eq(0).height() + 'px');
}, 500);
}
//复制一个滚动元素作为无缝切换效果
var cloneSwitchTarget = switchTarget.clone().css('margin-left', -contentWidth + 'px').attr('data-left', -contentWidth);
switchTarget.before(cloneSwitchTarget);
//自定义事件
var customEvent = SliderModelInstance.customEvent;
//点击事件
container.click(function (e) {
e = e || window.event;
var target = e.target || e.srcElement;
var $target = $(target);
//响应自定义事件-点击事件
if (customEvent) {
var clickEvent = customEvent.onClick;
if (clickEvent && typeof (clickEvent) == 'function') {
//返回当前点击目标元素对象
clickEvent.call(this, $target);
}
}
});
//滑动事件
var TouchModule = Module.Use('Touch');
var startLeft, cloneStartLeft;
TouchModule.TouchSlide({
target: container,
handle: {
start: function (startTouch) {
startLeft = parseInt(switchTarget.attr('data-left') || 0);
cloneStartLeft = parseInt(cloneSwitchTarget.attr('data-left') || 0);
switchTarget.removeClass('transition');
cloneSwitchTarget.removeClass('transition');
SliderModelInstance.Thread.stop();
},
move: function (startTouch, moveTouch) {
var x = moveTouch.touch1.x - startTouch.touch1.x;
//设置
switchTarget.css('margin-left', (startLeft + x) + 'px');
cloneSwitchTarget.css('margin-left', (cloneStartLeft + x) + 'px');
},
end: function (startTouch, endTouch) {
switchTarget.addClass('transition');
cloneSwitchTarget.addClass('transition');
var x = endTouch.touch1.x - startTouch.touch1.x;
if (Math.abs(x) >= itemWidth / 3) {
//如果滑动距离大于屏幕宽的三分之一，就移动到下一屏内容
if (x < 0) {
//向左
roll('left');
}
else {
//向右
roll('right');
}
}
else {
//还原
switchTarget.css('margin-left', (startLeft) + 'px');
cloneSwitchTarget.css('margin-left', (cloneStartLeft) + 'px');
}
SliderModelInstance.Thread.start();
}
}
});
//滚动
var item = 0;
var roll = function (direction) {
//滚动方向
var sliderDirection = direction || (container.attr('data-sliderDirection') || 'left');
//目标元素当前Left值
var marginLeft = parseInt(switchTarget.attr('data-left') || 0),
//克隆元素Left值
cloneMarginLeft = parseInt(cloneSwitchTarget.attr('data-left') || 0);
//滚动距离
var scrollLeft = itemWidth * SliderModelInstance.switchCount;
if (sliderDirection == 'left') {
//向左滚动
var mLeft = marginLeft - scrollLeft,
cloneMLeft = cloneMarginLeft - scrollLeft;
//switchTarget.css('margin-left', (mLeft) + 'px').attr('data-left', mLeft);
//cloneSwitchTarget.css('margin-left', (cloneMLeft) + 'px').attr('data-left', cloneMLeft);
item++;
if (item >= itemLength) {
item = 0;
}
indicators.find('.' + SliderModelInstance.currentIndicators).removeClass(SliderModelInstance.currentIndicators);
indicatorsItem.eq(item).addClass(SliderModelInstance.currentIndicators);
//console.log(mLeft + '<--->' + itemWidth + '<--->' + (mLeft - itemWidth) + '<--->' + (-contentWidth));
if (mLeft - itemWidth == -contentWidth) {
cloneSwitchTarget.css('margin-left', (itemWidth) + 'px').attr('data-left', itemWidth);
}
else {
cloneSwitchTarget.css('margin-left', (cloneMLeft) + 'px').attr('data-left', cloneMLeft);
}
if (cloneMLeft - itemWidth == -contentWidth) {
switchTarget.css('margin-left', (itemWidth) + 'px').attr('data-left', itemWidth);
}
else {
switchTarget.css('margin-left', (mLeft) + 'px').attr('data-left', mLeft);
}
container.attr('data-sliderDirection', 'left');
//响应自定义事件-向左滚动事件
if (customEvent) {
var sliderLeftEvent = customEvent.onSliderLeft;
if (sliderLeftEvent && typeof (sliderLeftEvent) == 'function') {
//返回当前滚动元素对象
sliderLeftEvent.call(this, switchTarget);
}
}
}
else if (sliderDirection == 'right') {
//向右滚动
var mLeft = marginLeft + scrollLeft,
cloneMLeft = cloneMarginLeft + scrollLeft;
switchTarget.css('margin-left', (mLeft) + 'px').attr('data-left', mLeft);
cloneSwitchTarget.css('margin-left', (cloneMLeft) + 'px').attr('data-left', cloneMLeft);
item--;
if (item < 0) {
item = itemLength - 1;
}
indicators.find('.' + SliderModelInstance.currentIndicators).removeClass(SliderModelInstance.currentIndicators);
indicatorsItem.eq(item).addClass(SliderModelInstance.currentIndicators);
if (mLeft == 0) {
cloneSwitchTarget.css('margin-left', (-contentWidth) + 'px').attr('data-left', -contentWidth);
}
if (cloneMLeft == 0) {
switchTarget.css('margin-left', (-contentWidth) + 'px').attr('data-left', -contentWidth);
}
container.attr('data-sliderDirection', 'right');
//响应自定义事件-向右滚动事件
if (customEvent) {
var sliderRightEvent = customEvent.onSliderRight;
if (sliderRightEvent && typeof (sliderRightEvent) == 'function') {
//返回当前滚动元素对象
sliderRightEvent.call(this, switchTarget);
}
}
}
//响应自定义事件-滚动事件
if (customEvent) {
var sliderEvent = customEvent.onSlider;
if (sliderEvent && typeof (sliderEvent) == 'function') {
//返回当前滚动元素对象
sliderEvent.call(this, switchTarget);
}
}
};
//是否自动切换
if (SliderModelInstance.isAutoPlay) {
//引入时间线程对象
var sliderThread = Module.Use('Thread');
//自动切换
SliderModelInstance.Thread = new sliderThread.Thread(roll, SliderModelInstance.timeout);
if (indicatorsItem.length > 1) {
SliderModelInstance.Thread.start();
}
}
};
install();
that.onClick = function (fun) {
if (fun) {
SliderModelInstance.customEvent = SliderModelInstance.customEvent || {};
SliderModelInstance.customEvent['onClick'] = fun;
}
return that;
};
that.onSlider = function (fun) {
if (fun) {
SliderModelInstance.customEvent = SliderModelInstance.customEvent || {};
SliderModelInstance.customEvent['onSlider'] = fun;
}
return that;
};
that.onSliderLeft = function (fun) {
if (fun) {
SliderModelInstance.customEvent = SliderModelInstance.customEvent || {};
SliderModelInstance.customEvent['onSliderLeft'] = fun;
}
return that;
};
that.onSliderRight = function (fun) {
if (fun) {
SliderModelInstance.customEvent = SliderModelInstance.customEvent || {};
SliderModelInstance.customEvent['onSliderRight'] = fun;
}
return that;
};
};
});
/**
*
* 简单的表单验证
*
* version 1.2.5.2(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年8月10日15:55:27
*
* update log 2014年11月29日10:12:27
*
*/
Module.Create('Validation', function () {
/// <summary>
/// 选项卡切换
/// </summary>
var that = this;
that.FormValidation = function (options) {
var that = this;
//表单验证实体类
var FormValidationModel = function (model) {
var that = this;
//表单
that.form = $(model.form || '.J-form-validation');
//自定义验证类型
that.verify = model.verify;
//是否响应事件
that.isInteraction = isFalse(model.isInteraction) ? false : true;
//测试验证时执行一次自定义事件
that.executeOnceCustomEvent = model.executeOnceCustomEvent || false;
//各中状态下的className
that.status = model.status || {
//验证失败
failure: 'ui-form-item-failure',
//验证错误
error: 'ui-form-item-error',
//成功
success: 'ui-form-item-success',
//警告
warning: 'ui-form-item-warning',
//获取焦点
focus: 'ui-form-item-focus'
};
//元素自定义键
that.keys = model.keys || {
//为空提示
dataRequiredTip: 'data-required-tip',
//警告提示
dataWarningTip: 'data-required-tip',
//错误消息
dataErrorTip: 'data-error-tip',
//成功消息
dataSuccessTip: 'data-success-tip',
//关联元素
dataToggle: 'data-toggle'
};
};
var FormValidationModelInstance = new FormValidationModel(options || {});
//基本配置实体类
var ConfigModel = function () {
var that = this;
//被验证目标元素
that.verifyTarget = 'J-verify';
//必填、必选项
that.required = 'J-required';
//一般的验证在验证通过后就不再执行验证表达式，在被验证元素上设置该属性为true时，不管该元素的验证是否通过都会继续执行验证表达式
that.continuousKey = 'data-continuous';
//异步验证键
that.asyncKey = 'data-async';
//test中的异步验证回调操作键
that.asyncCallBackKey = 'data-asyncCallBack';
//(异步)验证状态键
that.asyncStatusKey = 'data-asyncStatus';
//(异步)验证状态[状态： 1.基础验证未通过、2.基础验证通过、3.异步验证未通过、4异步验证中、5.异步验证通过]
that.asyncStatus = { baseNotPass: 1, basePass: 2, asyncNotPass: 3, asyncVerifying: 4, asyncPass: 5 };
};
var ConfigModelInstance = new ConfigModel();
//验证类型实体类
var VerifyTypeModel = function () {
var that = this;
that['J-v000'] = { regular: /^[0-9a-zA-Z_.\-]{1,}$/, remark: '只能为数字,字母,下划线,中划线,点' };
that['J-v001'] = { regular: /^[\u4E00-\u9FA5\uF900-\uFA2D0-9a-zA-Z\-\_\(\)\（\）]{1,}$/, remark: '只能为中文,括号,数字或字母,中划线,下划线' }
that['J-v002'] = { regular: /^[\u4E00-\u9FA5\uF900-\uFA2Da-zA-Z\-\_]{1,}$/, remark: '只能为中文,字母,中划线,下划线' };
that['J-v003'] = { regular: /^[\u4E00-\uFA29]*$/, remark: '只能为中文' };
that['J-v004'] = { regular: /^[\uFF00-\uFFFF\u4E00-\u9FA5\uF900-\uFA2D\u20140-9a-zA-Z.@\-_]{1,}$/, remark: '只能为中文,数字或字母,中划线,下划线,点,@' };
that['J-float2'] = { regular: /^(-?\d+)(\.\d{1,2})?$/, remark: '请输入浮点数(两位有效数字)' };
that['J-alphaNumeric'] = { regular: /^[A-Za-z0-9]+$/, remark: '只能为字母和数字' };
that['J-letters'] = { regular: /^[A-Za-z]+$/, remark: '只能为字母' };
that['J-int'] = { regular: /^[1-9]*[1-9][0-9]*$/, remark: '请输入正整数' };
that['J-num'] = { regular: /^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d+)?$/, remark: '请输入数字' };
that['J-email'] = { regular: /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/, remark: '请输入正确的邮件(如:xxx@163.com)' };
that['J-tel'] = { regular: /^(\d{3}-|\d{4}-)?(\d{8}|\d{7})?$/, remark: '请输入正确的座机号码(如:68888888)' };
that['J-phone'] = { regular: /^1[3-9]{1}[0-9]{9}$/, remark: '请输入正确的手机号码(如:13888888888)' };
that['J-url'] = { regular: /^[a-zA-z]+:\/\/([a-zA-Z0-9\-\.]+)([-\w .\/?%&=:]*)$/, remark: '请输入正确的地址' };
that['J-postCode'] = { regular: /^[1-9][0-9]{5}$/, remark: '请输入正确的邮编(如:400000)' };
that['J-longitude'] = { regular: /^-?(?:(?:180(?:\.0{1,5})?)|(?:(?:(?:1[0-7]\d)|(?:[1-9]?\d))(?:\.\d{1,5})?))$/, remark: '经度(-180.00000~180.00000)' };
that['J-latitude'] = { regular: /^-?(?:90(?:\.0{1,5})?|(?:[1-8]?\d(?:\.\d{1,5})?))$/, remark: '纬度(-90.00000~90.00000)' };
that['J-idCard'] = { regular: /^(\d{11}|\d{14})\d{3}?(\d|X|x)$/, remark: '请输入正确的身份证号码' };
that['J-qq'] = { regular: /^[1-9]*[1-9][0-9]*$/, remark: '请输入正确的QQ' };
that['J-notNullByFloat1'] = { regular: /^[0-9]+(\.[0-9]{1})?$/, remark: '非空且保留一位小数' };
that['J-notNullByFloat2'] = { regular: /^\\d{1,8}\\.{0,1}(\\d{1,2})?$/, remark: '非空且保留两位小数' };
that['J-pure-digital'] = function (value) {
var result = { status: true, message: 'OK', type: 'success' };
if (isNumber(value)) {
result = { status: false, message: '不能是纯数字', type: 'failure', level: 1 };
}
return result;
};
that['J-phone-email'] = function (value) {
var result = { status: false, message: null, type: 'failure' };
if (isNumber(value)) {
var status = new RegExp(/^1[3-9]{1}[0-9]{9}$/).test(value);
if (status) {
result = { status: true, message: '成功！', type: 'success', flag: 'phone' };
}
else {
result = { status: false, message: '手机号码格式不正确', type: 'failure' };
}
}
else {
var status = new RegExp(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/).test(value);
if (status) {
result = { status: true, message: '成功！', type: 'success', flag: 'email' };
}
else {
result = { status: false, message: '邮箱格式不正确', type: 'failure' };
}
}
return result;
};
var verifyType = FormValidationModelInstance.verify;
if (verifyType) {
for (var key in verifyType) {
that[key] = verifyType[key];
}
}
};
var VerifyTypeModelInstance = new VerifyTypeModel();
//语言包实体类
var LangModel = function () {
var that = this;
//必选提示
that.L001 = '必选';
//必填提示
that.L002 = '必填';
};
var LangModelInstance = new LangModel();
//获取表单中的数据(以元素的Name作为键，如果没有Name属性，则以标签名称递增方式作为键)
var getFormData = function (form) {
/// <summary>
/// 获取表单中的数据(以元素的Name作为键，如果没有Name属性，则以标签名称递增方式作为键)
/// </summary>
/// <param name="form" type="Element">需要获取数据的Form表单元素(非必填，默认为当前被验证表单)</param>
/// <returns type="Object" />当前获取到的数据集合
var i, elementLength, inputs, selects, textareas, element, value, result, group, key, type, check;
form = form || FormValidationModelInstance.form;
//获取表单下所有input
inputs = form.find('input');
//获取表单下所有select
selects = form.find('select');
//获取表单下所有textarea
textareas = form.find('textarea');
if (inputs.length > 0 || selects.length > 0 || textareas.length > 0) {
//result.当前表单下的数据JSON对象, group.用于判断同一个分组的radio或checkbox
result = {}, group = "";
//遍历inputs
elementLength = inputs.length;
for (i = 0; i < elementLength; i++) {
element = inputs[i];
//获取value，并去除首尾的空格
value = encodeURIComponent(element.value.replace(/(^\s*)/g, '').replace(/(\s*$)/g, ''));
//获取当前元素id，用作key
key = element.getAttribute("name");
//如果没有id，就为该标签名加i
key = key ? key : element.nodeName + i;
//获取标签的type，用于判断标签类型
type = element.getAttribute("type");
if (type == "radio" || type == "checkbox") {
//获取name，该key用name代替
key = element.getAttribute("name");
group = key != group ? key : group;
if (key == group) {
check = element.checked;
if (check) { result[key] = result[key] ? result[key] + ',' + value : value; }
}
}
else if (type == "text" || type == "password" || type == "hidden") { result[key] = value; }
}
//遍历selects
elementLength = selects.length;
for (i = 0; i < elementLength; i++) {
element = selects[i];
key = element.getAttribute('name');
key = key ? key : element.nodeName + i;
value = element.value.replace(/(^\s*)/g, '').replace(/(\s*$)/g, '');
result[key] = value;
}
//遍历textareas
elementLength = textareas.length;
for (i = 0; i < elementLength; i++) {
element = textareas[i];
key = element.getAttribute('name');
key = key ? key : element.nodeName + i;
value = element.value.replace(/(^\s*)/g, '').replace(/(\s*$)/g, '');
result[key] = value;
}
}
return result;
};
//异步验证
var asyncVerify = function (options) {
var asyncVerifyModel = function (model) {
var that = this;
//被验证元素
that.target = model.target;
//请求路径
that.url = model.url;
//提交数据
that.data = model.data;
//请求开始
that.requestBegin = model.requestBegin;
//请求失败
that.requestError = model.requestError;
//请求成功
that.callBack = model.callBack;
};
var asyncVerifyModelInstance = new asyncVerifyModel(options || {});
if (typeof (asyncVerifyModelInstance.target) == 'string') {
asyncVerifyModelInstance.target = FormValidationModelInstance.form.find(asyncVerifyModelInstance.target);
}
//获取异步验证方法的键
var asyncKey = asyncVerifyModelInstance.target.attr(ConfigModelInstance.asyncKey);
if (!asyncKey) {
asyncKey = Module.Guid(ConfigModelInstance.asyncKey.replace('-', '').toLocaleUpperCase());
asyncVerifyModelInstance.target.attr(ConfigModelInstance.asyncKey, asyncKey);
}
FormValidationModelInstance.asyncHandle = FormValidationModelInstance.asyncHandle || {};
FormValidationModelInstance.asyncHandle[asyncKey] = asyncVerifyModelInstance;
};
//单个元素验证
var regularVerify = function (target) {
/// <summary>
/// 对单个元素验证
/// </summary>
/// <param name="target" type="Element">被验证的DOM元素对象</param>
/// <returns type="Boolean" />验证是否通过
/// <remarks/>执行步骤(第一、二、三、四步)最好不要调换
var result = { status: true, message: 'OK！', type: 'success' };
var form = FormValidationModelInstance.form,
keys = FormValidationModelInstance.keys, tempTarget;
if (target) {
//获取自定义消息内容
var requiredMessage = $(target).attr(keys.dataRequiredTip),
//错误消息
errorMessage = $(target).attr(keys.dataErrorTip),
//警告消息
warningMessage = $(target).attr(keys.dataWarningTip),
//成功消息
successMessage = $(target).attr(keys.dataSuccessTip);
var value = target.value,
name = target.name,
type = target.type,
checkBox;
if (type == 'radio' || type == 'checkbox') {
//获取同一组的元素
checkBox = form.find('input[name=' + name + ']');
target = checkBox[0];
}
//第一步，非空验证(必填或必选)
var required = $(target).hasClass(ConfigModelInstance.required);
if (required) {
if (type == 'radio' || type == 'checkbox') {
if (name) {
var i = 0, length = checkBox.length, flag = 0;
//循环获取有多少个被选中
for (; i < length; i++) {
if (checkBox[i].checked) {
flag++;
}
}
if (flag <= 0) {
result.status = false;
result.message = $(target).attr(keys.dataRequiredTip) || LangModelInstance.L001;
result.type = 'warning';
//##错误提示操作##//
return result;
}
else {
//如果有选中的项，再验证选中项个数限制
var minLength = target.getAttribute('minlength'),
maxLength = target.getAttribute('maxlength');
//长度判断
if (minLength) {
minLength = parseInt(minLength);
if (flag < minLength) {
result.status = false;
result.message = '至少需要选择#MIN#项'.replace('#MIN#', minLength);
result.type = 'warning';
return result;
}
}
if (maxLength) {
maxLength = parseInt(maxLength);
if (flag > maxLength) {
result.status = false;
result.message = '最多只能选择#MAX#项'.replace('#MAX#', maxLength);
result.type = 'warning';
return result;
}
}
}
}
}
else if (!value) {
var nodeName = target.nodeName.toLocaleLowerCase();
result.status = false;
result.message = nodeName === 'input' || nodeName === 'textarea' ? $(target).attr(keys.dataRequiredTip) || LangModelInstance.L002 : $(target).attr(keys.dataRequiredTip) || LangModelInstance.L001;
result.type = 'warning';
return result;
}
}
if (value) {
//第三步，验证长度
var valueLength = value.length;
//获取关联
var equalTo = target[keys.dataToggle];
equalTo = equalTo ? equalTo : target.getAttribute(keys.dataToggle);
//是否存在异步验证
var asyncKeys = $(target).attr(ConfigModelInstance.asyncKey);
//最小长度
var minLength = target.minlength;
minLength = parseInt(minLength ? minLength : target.getAttribute('minlength'));
var minByte = $(target).attr('minByte');
if (minLength) {
if (valueLength < minLength) {
result.status = false;
if (equalTo || asyncKeys) {
//如果有关联(消息应该是为关联的错误消息)
result.message = '至少需要#MINLENGTH#个字符'.replace('#MINLENGTH#', minLength);
}
else {
result.message = errorMessage || '至少需要#MINLENGTH#个字符'.replace('#MINLENGTH#', minLength);
}
result.type = 'failure';
return result;
}
}
//字节判断
if (minByte) {
minByte = parseInt(minByte);
var charByte = value.getCharByte();
if (charByte < minByte) {
result.status = false;
if (equalTo || asyncKeys) {
//如果有关联(消息应该是为关联的错误消息)
result.message = '至少需要#MINLENGTH#个字节'.replace('#MINLENGTH#', minByte);
}
else {
result.message = errorMessage || '至少需要#MINLENGTH#个字节'.replace('#MINLENGTH#', minByte);
}
result.type = 'failure';
return result;
}
}
//最大长度
var maxLength = target.maxlength;
maxLength = parseInt(maxLength ? maxLength : target.getAttribute('maxlength'));
var maxByte = $(target).attr('maxByte');
if (maxLength) {
if (valueLength > maxLength) {
result.status = false;
if (equalTo) {
//如果有关联(消息应该是为关联的错误消息)
result.message = '最多只需#MINLENGTH#个字符'.replace('#MINLENGTH#', maxLength);
}
else {
result.message = errorMessage || '最多只需#MINLENGTH#个字符'.replace('#MINLENGTH#', maxLength);
}
result.type = 'failure';
return result;
}
}
//字节判断
if (maxByte) {
maxByte = parseInt(maxByte);
var charByte = value.getCharByte();
if (charByte > maxByte) {
result.status = false;
if (equalTo || asyncKeys) {
//如果有关联(消息应该是为关联的错误消息)
result.message = '最多只需#MINLENGTH#个字节'.replace('#MINLENGTH#', maxByte);
}
else {
result.message = errorMessage || '最多只需#MINLENGTH#个字节'.replace('#MINLENGTH#', maxByte);
}
result.type = 'failure';
return result;
}
}
//第二步，格式验证
var verifyType = VerifyTypeModelInstance;
for (var key in verifyType) {
if ($(target).hasClass(key)) {
result = matchVerifyType(value, key);
if (!result.status) {
var dataErrorTip = $(target).attr(keys.dataErrorTip);
if (dataErrorTip && !result.level) {
result.message = dataErrorTip;
}
return result;
}
}
}
//第四步(最后一步)，关联验证
if (equalTo) {
//找到其关联的元素
var equalElement = form.find(equalTo)[0];
if (equalElement) {
//获取关联元素的value
var equalValue = equalElement.value;
equalValue = equalValue ? equalValue : equalElement.innerHTML;
//获取key，该key值为：'>'、'<'、'=='、'>='等用于验证两者间关系，默认为'=='
var key = target.getAttribute('key');
key = key ? key : '==';
var compare;
switch (key) {
case '>': compare = '大于'; break;
case '<': compare = '小于'; break;
case '>=': compare = '大于等于'; break;
case '<=': compare = '小于等于'; break;
default: compare = '等于'; break;
}
if (key == '==') {
if (value != equalValue) {
result.status = false;
result.message = errorMessage || '与关联值不一致';
result.type = 'failure';
return result;
}
}
else {
var flag = false;
eval('if(parseInt(value) ' + key + ' parseInt(equalValue)){ flag = true; }');
if (!flag) {
result.status = false;
result.message = errorMessage || "值必须#KEY##EQVAL#".replace('#KEY#', compare).replace('#EQVAL#', equalValue);
result.type = 'failure';
return result;
}
}
}
}
}
}
return result;
};
//匹配验证类型
var matchVerifyType = function (regValue, regType) {
/// <summary>
/// 正则验证
/// </summary>
/// <param name="regValue" type="String">需要验证的内容</param>
/// <param name="regType" type="String">验证的类型</param>
/// <returns type="JSON Object" />返回验证结果{status: 状态, message: 消息内容, type: 消息类型}
regType = regType ? regType : 'J-alphaNumeric';
var verifyType = VerifyTypeModelInstance[regType];
var result = { status: true, message: 'OK！', type: 'success' };
if (typeof (verifyType) == 'function') {
result = verifyType(regValue);
}
else {
if (regType == 'J-telPhone') {
result = matchVerifyType(regValue, 'J-tel');
if (!result.status) {
result = matchVerifyType(regValue, 'J-phone');
}
}
else if (regType == 'J-alphaNumerics') {
regValue = regValue.substring(0, 1);
if (!isNaN(regValue)) {
result.status = false;
result.type = 'failure';
result.message = verifyType['remark'];
}
}
else {
result.status = new RegExp(verifyType['regular']).test(regValue);
result.type = result.status ? 'success' : 'failure';
result.message = verifyType['remark'];
}
}
return result;
};
//验证
var verify = function (target, callBack) {
target = $(target);
//响应验证(前)事件
var customEvent = FormValidationModelInstance.customEvent;
var isInteraction = FormValidationModelInstance.isInteraction;
if (customEvent && isInteraction) {
var verifyEvent = customEvent.onVerify;
if (verifyEvent) {
verifyEvent.call(target);
}
}
var asyncStatus = ConfigModelInstance.asyncStatus,
asyncStatusKey = ConfigModelInstance.asyncStatusKey;
var result = regularVerify(target[0]);
if (result.status) {
target.attr(asyncStatusKey, asyncStatus.basePass);
//做异步验证处理
var asyncKey = target.attr(ConfigModelInstance.asyncKey), asyncFlag = true;
if (asyncKey) {
var asyncHandle = FormValidationModelInstance.asyncHandle[asyncKey];
if (asyncHandle) {
var postData = asyncHandle.data || {};
var targetName = target.attr('name') || asyncKey;
postData[targetName] = target.val();
target.attr(asyncStatusKey, asyncStatus.asyncVerifying);
$.ajax({
url: asyncHandle.url,
data: postData,
type: "POST",
beforeSend: function () {
if (asyncHandle.requestBegin) {
asyncHandle.requestBegin(target);
}
var customEvent = FormValidationModelInstance.customEvent;
if (customEvent) {
var asyncVerifyBeginEvent = customEvent.onAsyncVerifyBegin;
if (asyncVerifyBeginEvent) {
asyncVerifyBeginEvent.call(target);
}
}
},
error: function (responseText, response) {
target.attr(asyncStatusKey, asyncStatus.asyncNotPass);
result.status = false;
result.type = 'error';
result.message = target.attr(FormValidationModelInstance.keys.dataErrorTip) || 'Error';
if (asyncHandle.requestError) {
asyncHandle.requestError(responseText, response, target, result);
}
if (callBack) {
callBack.call(target, result);
}
//获取异步验证CallBack键
var asyncCallBackKey = target.attr(ConfigModelInstance.asyncCallBackKey);
if (asyncCallBackKey) {
var asyncCallBackHandle = FormValidationModelInstance.asyncCallBack[asyncCallBackKey];
if (asyncCallBackHandle) {
asyncCallBackHandle.call(target, result);
}
}
//验证失败
if (customEvent && isInteraction) {
//响应验证失败事件
var verifyFailureEvent = customEvent.onVerifyFailure;
if (verifyFailureEvent) {
verifyFailureEvent.call(target, result);
}
//结束当前验证
//响应验证结束事件
var verifyEndEvent = customEvent.onVerifyEnd;
if (verifyEndEvent) {
verifyEndEvent.call(target, result);
}
}
},
success: function (responseText, response) {
if (isTrue(responseText) || isFalse(responseText)) {
if (isTrue(responseText)) {
//异步验证通过状态设置
target.attr(asyncStatusKey, asyncStatus.asyncPass);
result.status = true;
result.type = 'success';
result.message = target.attr(FormValidationModelInstance.keys.dataSuccessTip) || 'Ok';
if (customEvent && isInteraction) {
var verifySuccessEvent = customEvent.onVerifySuccess;
if (verifySuccessEvent) {
verifySuccessEvent.call(target, result);
}
}
}
else {
//异步验证未通过状态设置
target.attr(asyncStatusKey, asyncStatus.asyncNotPass);
result.status = false;
result.type = 'failure';
result.message = 'Failure';
if (customEvent && isInteraction) {
var verifyFailureEvent = customEvent.onVerifyFailure;
if (verifyFailureEvent) {
verifyFailureEvent.call(target, result);
}
}
}
}
else {
if (value != responseText) {
//异步验证通过状态设置
target.attr(asyncStatusKey, asyncStatus.asyncPass);
result.status = true;
result.type = 'success';
result.message = 'ok';
if (customEvent && isInteraction) {
var verifySuccessEvent = customEvent.onVerifySuccess;
if (verifySuccessEvent) {
verifySuccessEvent.call(target, result);
}
}
}
else {
//异步验证未通过状态设置
target.attr(asyncStatusKey, asyncStatus.asyncNotPass);
result.status = false;
result.type = 'failure';
result.message = 'Failure';
if (customEvent && isInteraction) {
var verifyFailureEvent = customEvent.onVerifyFailure;
if (verifyFailureEvent) {
verifyFailureEvent.call(target, result);
}
}
}
}
if (asyncHandle.callBack) {
asyncHandle.callBack(responseText, response, target, result);
}
if (callBack) {
callBack.call(target, result);
}
//获取异步验证CallBack键
var asyncCallBackKey = target.attr(ConfigModelInstance.asyncCallBackKey);
if (asyncCallBackKey) {
var asyncCallBackHandle = FormValidationModelInstance.asyncCallBack[asyncCallBackKey];
if (asyncCallBackHandle) {
asyncCallBackHandle.call(target, result);
}
}
//结束当前验证
if (customEvent && isInteraction) {
//响应验证结束事件
var verifyEndEvent = customEvent.onVerifyEnd;
if (verifyEndEvent) {
verifyEndEvent.call(target, result);
}
}
}
});
}
else {
asyncFlag = false;
}
}
else {
asyncFlag = false;
}
if (!asyncFlag) {
target.attr(asyncStatusKey, asyncStatus.basePass);
if (callBack) {
callBack.call(target, result);
}
if (customEvent && isInteraction) {
//响应验证成功事件
var verifySuccessEvent = customEvent.onVerifySuccess;
if (verifySuccessEvent) {
verifySuccessEvent.call(target, result);
}
//结束当前验证
//响应验证结束事件
var verifyEndEvent = customEvent.onVerifyEnd;
if (verifyEndEvent) {
verifyEndEvent.call(target, result);
}
}
}
}
else {
target.attr(asyncStatusKey, asyncStatus.baseNotPass);
//验证失败
if (callBack) {
callBack.call(target, result);
}
if (customEvent && isInteraction) {
//响应验证失败事件
var verifyFailureEvent = customEvent.onVerifyFailure;
if (verifyFailureEvent) {
verifyFailureEvent.call(target, result);
}
//结束当前验证
//响应验证结束事件
var verifyEndEvent = customEvent.onVerifyEnd;
if (verifyEndEvent) {
verifyEndEvent.call(target, result);
}
}
}
};
//验证测试
var test = function (callBack) {
var verifyTargets = FormValidationModelInstance.form.find('.' + ConfigModelInstance.verifyTarget);
var i = 0, length = verifyTargets.length, target, targetAsyncStatus, targetContinuousFlag, count = 0, tempResult = [],
asyncStatusKey = ConfigModelInstance.asyncStatusKey,
asyncStatus = ConfigModelInstance.asyncStatus,
continuousFlag = ConfigModelInstance.continuousKey,
executeOnceCustomEvent = FormValidationModelInstance.executeOnceCustomEvent,
isInteraction = FormValidationModelInstance.isInteraction,
executeCount = 0;
//执行一次自定义事件
//FormValidationModelInstance.executeOnceCustomEvent = true;
var callBackHandle = function (result) {
if (result.status) {
count++;
if (count == length) {
if (callBack) {
callBack.call(this, getFormData());
}
//恢复
//FormValidationModelInstance.executeOnceCustomEvent = false;
}
}
else {
//遇到错误，就清空线程停止下面的验证
window.clearInterval(IntervalThread);
IntervalThread = null;
if (i == length) {
if (executeOnceCustomEvent) {
//还原
FormValidationModelInstance.isInteraction = isInteraction;
}
if (count < length) {
//响应测试失败事件
var customEvent = FormValidationModelInstance.customEvent;
if (customEvent) {
var testFailure = customEvent.onTestFailure;
if (testFailure) {
testFailure.call(this);
}
}
}
}
}
};
var IntervalThread = window.setInterval(function () {
if (!length) {
if (callBack) {
callBack.call(this, getFormData());
}
window.clearInterval(IntervalThread);
IntervalThread = null;
}
target = verifyTargets.eq(i);
i++;
targetAsyncStatus = target.attr(asyncStatusKey);
targetContinuousFlag = target.attr(continuousFlag);
if (targetAsyncStatus && targetContinuousFlag != 'true') {
if (targetAsyncStatus == asyncStatus.basePass || targetAsyncStatus == asyncStatus.asyncPass) {
var toggle = FormValidationModelInstance.keys.dataToggle;
var dataToggle = target.attr(toggle);
if (dataToggle) {
verify(target, callBackHandle);
}
else {
//验证为通过状态，count++
callBackHandle({ status: true });
}
}
else if (targetAsyncStatus == asyncStatus.asyncVerifying) {
//正在验证中状态
//获取异步验证CallBack键
var asyncCallBackKey = target.attr(ConfigModelInstance.asyncCallBackKey);
if (!asyncCallBackKey) {
asyncCallBackKey = Module.Guid(ConfigModelInstance.asyncCallBackKey.replace('-', '').toLocaleUpperCase());
target.attr(ConfigModelInstance.asyncCallBackKey, asyncCallBackKey);
}
FormValidationModelInstance.asyncCallBack = FormValidationModelInstance.asyncCallBack || {};
FormValidationModelInstance.asyncCallBack[asyncCallBackKey] = callBackHandle;
}
else {
if (executeOnceCustomEvent) {
if (executeCount > 0) {
FormValidationModelInstance.isInteraction = false;
}
verify(target, callBackHandle);
executeCount++;
}
else {
verify(target, callBackHandle);
}
}
}
else {
if (executeOnceCustomEvent && executeCount > 0) {
FormValidationModelInstance.isInteraction = false;
}
verify(target, callBackHandle);
executeCount++;
}
if (i == length) {
window.clearInterval(IntervalThread);
IntervalThread = null;
}
}, 10);
};
that.addVerifyType = function (types) {
/// <summary>
/// 自定义验证类型
/// </summary>
/// <param name="type" type="Object">验证类型集合</param>
if (types) {
for (var key in types) {
VerifyTypeModelInstance[key] = types[key];
}
}
return that;
};
that.customVerify = function (target, type) {
/// <summary>
/// 自定义元素验证
/// </summary>
/// <param name="target" type="Element">被验证元素</param>
/// <param name="type" type="String">验证类型</param>
var result = null;
var value = $(target).val();
var verifyType = VerifyTypeModelInstance[type];
if (verifyType) {
if (isFunction(verifyType)) {
result = verifyType(value);
}
else {
var message = null;
if (isJSON(verifyType)) {
message = verifyType.remark;
verifyType = verifyType.regular;
}
result = { status: false, message: null, type: 'failure' };
var status = new RegExp(verifyType).test(value);
if (status) {
result = { status: true, message: '成功！', type: 'success' };
}
else {
result = { status: false, message: message || $(target).attr(FormValidationModelInstance.keys.dataErrorTip), type: 'failure' };
}
}
}
return that;
};
//验证被触发前事件
that.onVerifyTriggerBefore = function (fun) {
/// <summary>
/// 验证被触发前事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onVerifyTriggerBefore'] = fun;
}
return that;
};
//验证事件
that.onVerify = function (fun) {
/// <summary>
/// 验证事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onVerify'] = fun;
}
return that;
};
//验证结束事件
that.onVerifyEnd = function (fun) {
/// <summary>
/// 验证结束事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onVerifyEnd'] = fun;
}
return that;
};
//异步验证开始事件
that.onAsyncVerifyBegin = function (fun) {
/// <summary>
/// 异步验证开始事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onAsyncVerifyBegin'] = fun;
}
return that;
};
//验证成功事件
that.onVerifySuccess = function (fun) {
/// <summary>
/// 验证成功事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onVerifySuccess'] = fun;
}
return that;
};
//验证失败事件
that.onVerifyFailure = function (fun) {
/// <summary>
/// 验证失败事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onVerifyFailure'] = fun;
}
return that;
};
//表单验证测试失败事件
that.onTestFailure = function (fun) {
/// <summary>
/// 验证测试失败事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
if (fun) {
FormValidationModelInstance.customEvent = FormValidationModelInstance.customEvent || {};
FormValidationModelInstance.customEvent['onTestFailure'] = fun;
}
return that;
};
//表单所有验证元素测试事件(成功)
that.onFormTest = function (fun) {
/// <summary>
/// 表单所有验证元素测试事件
/// </summary>
/// <param name="fun" type="Function">事件函数</param>
test(fun);
return that;
};
//获取表单中的数据(以元素的Name作为键，如果没有Name属性，则以标签名称递增方式作为键)
that.getFormData = getFormData;
//给元素添加异步验证
that.asyncVerify = asyncVerify;
//设置自定义事件是否响应
that.interaction = function (flag) {
/// <summary>
/// 设置自定义事件是否响应
/// </summary>
/// <param name="flag" type="Boolean">true.响应(默认) false.不响应</param>
if (isFalse(flag)) {
flag = false;
}
else {
flag = true;
}
FormValidationModelInstance.isInteraction = flag;
return that;
};
var install = function () {
var form = FormValidationModelInstance.form;
form.click(function (e) {
e = e || window.event;
var target = e.target || e.srcElement;
var $target = $(target);
var nodeName = target.nodeName.toLocaleLowerCase();
if (nodeName == 'input' || nodeName == 'select' || nodeName == 'textarea') {
if ($target.hasClass(ConfigModelInstance.verifyTarget)) {
//target.focus();
//执行验证
//verify(target);
//响应验证事件
var customEvent = FormValidationModelInstance.customEvent;
if (customEvent && FormValidationModelInstance.isInteraction) {
var verifyTriggerBeforeEvent = customEvent.onVerifyTriggerBefore;
if (verifyTriggerBeforeEvent) {
verifyTriggerBeforeEvent.call(target);
}
}
//绑定blur事件
target.onblur = function () {
//执行验证
verify(this);
};
}
}
});
};
install();
};
});
/**
*
* 表单提交模块
*
* version 1.0.2.2(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年9月22日15:17:10
*
* update log 2014年11月14日16:31:45
*
* remark 依赖于Validation模块
*
*/
Module.Create('FormSubmit', function () {
/// <summary>
/// Grid模块
/// </summary>
/** 引用需要使用的控件模块 **/
//引用Validation验证模块
var Validation = Module.Use('Validation'),
Tips = Module.Use('Tips');
var ToolTips = new Tips.RenderTips({ clickMaskHide: true });
var that = this;
that.RenderFromSubmit = function (options) {
that = this;
var FormModel = function (model) {
var that = this;
//操作表单
that.form = $(model.form || 'form').eq(0);
//依赖验证模块的自定义验证类型
that.verify = model.verify;
//提交按钮
that.submitButton = model.submitButton || 'J-form-btn-submit';
};
var FormModelInstance = new FormModel(options || {});
var install = function () {
var FormValidation = new Validation.FormValidation({
form: FormModelInstance.form,
verify: FormModelInstance.verify
});
//验证成功事件
FormValidation.onVerifySuccess(function (result) {
var target = $(this);
var message = result.message;
var customEvent = FormModelInstance.customEvent;
if (customEvent) {
var successEvent = customEvent['onVerifySuccess'];
if (successEvent) {
successEvent.call(target, result);
return false;
}
}
});
FormValidation.onAsyncVerifyBegin(function () {
var target = $(this);
});
//验证失败事件
FormValidation.onVerifyFailure(function (result) {
var target = $(this);
var message = result.message;
ToolTips.error({ message: message, timeout: 3000 });
var customEvent = FormModelInstance.customEvent;
if (customEvent) {
var failureEvent = customEvent['onVerifyFailure'];
if (failureEvent) {
failureEvent.call(target, result);
return false;
}
}
});
var formTarget = FormModelInstance.form;
that.submit = function (url) {
var customEvent = FormModelInstance.customEvent;
FormValidation.onFormTest(function (data) {
var path = url || formTarget.attr('action'),
method = (formTarget.attr('method') || 'POST').toUpperCase();
try {
var dataLoading = formTarget.attr('data-loading') || '正在提交数据，请稍等...';
RenderTip.loading(dataLoading);
} catch (e) { }
var dataAsync = formTarget.attr('data-async') || false;
if (isTrue(dataAsync)) {
$.ajax({
//请求路径
url: path,
//请求方式(POST/GET)
type: method,
//提交数据
data: data,
//返回值类型
dataType: 'text',
//请求失败
error: function (responseText, response) {
if (customEvent) {
//响应请求失败事件
var errorEvent = customEvent.onError;
if (errorEvent) {
errorEvent.call(formTarget, responseText, response);
}
}
try {
var dataError = formTarget.attr('data-error') || '操作失败！';
RenderTip.error({ message: dataError, timeout: 2000 });
} catch (e) { }
},
//请求成功
success: function (responseText, response) {
if (customEvent) {
//响应请求完成事件
var successEvent = customEvent.onSuccess;
if (successEvent) {
successEvent.call(formTarget, responseText, response);
}
}
//var dataSuccess = formTarget.attr('data-success') || '操作成功！';
//RenderTip.success({
// message: dataSuccess, timeout: 2000, callBack: function () {
// if (customEvent) {
// //响应操作完成事件
// var submitCompleteEvent = customEvent.onSubmitComplete;
// if (submitCompleteEvent) {
// var contentPanel = formTarget.parents('.J-tab-panel-content').parent();
// var tabID = contentPanel.attr('id');
// submitCompleteEvent.call(formTarget, responseText, response);
// }
// }
// }
//});
}
});
}
else {
var nodeName = formTarget[0].nodeName.toLocaleLowerCase();
var submitForm = formTarget;
if (nodeName != 'form') {
var form = target.parents('form').eq(0);
if (form.length) {
formTarget = form;
}
}
formTarget.submit();
}
});
};
formTarget.click(function (e) {
e = e || window.event;
var target = $(e.target || e.srcElement);
var customEvent = FormModelInstance.customEvent;
if (customEvent) {
var clickEvent = customEvent['onClick'];
if (clickEvent) {
clickEvent.call(target, e);
}
}
if (target.hasClass(FormModelInstance.submitButton)) {
that.submit();
}
});
that.addVerifyType = FormValidation.addVerifyType;
that.customVerify = FormValidation.customVerify;
that.asyncVerify = FormValidation.asyncVerify;
};
that.onClick = function (fun) {
if (fun) {
FormModelInstance.customEvent = FormModelInstance.customEvent || {};
FormModelInstance.customEvent['onClick'] = fun;
}
return that;
};
that.onError = function (fun) {
if (fun) {
FormModelInstance.customEvent = FormModelInstance.customEvent || {};
FormModelInstance.customEvent['onError'] = fun;
}
return that;
};
that.onSuccess = function (fun) {
if (fun) {
FormModelInstance.customEvent = FormModelInstance.customEvent || {};
FormModelInstance.customEvent['onSuccess'] = fun;
}
return that;
};
that.onSubmitComplete = function (fun) {
if (fun) {
FormModelInstance.customEvent = FormModelInstance.customEvent || {};
FormModelInstance.customEvent['onSubmitComplete'] = fun;
}
return that;
};
that.onVerifySuccess = function (fun) {
if (fun) {
FormModelInstance.customEvent = FormModelInstance.customEvent || {};
FormModelInstance.customEvent['onVerifySuccess'] = fun;
}
return that;
};
that.onVerifyFailure = function (fun) {
if (fun) {
FormModelInstance.customEvent = FormModelInstance.customEvent || {};
FormModelInstance.customEvent['onVerifyFailure'] = fun;
}
return that;
};
install();
};
});
/**
*
* 消息提示框模块
*
* version 1.0.0.0(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年9月17日09:40:07
*
* update log 2014年9月20日17:40:54
*
*/
Module.Create('Tips', function () {
/// <summary>
/// 提示框模块
/// </summary>
var that = this;
that.RenderTips = function (options) {
/// <summary>
/// 提示框渲染类
/// </summary>
var that = this;
var TipsModel = function (model) {
var that = this;
//自定义提示框
that.tips = model.tips || null;
//自定义背景遮罩层
that.mask = model.mask || null;
//类型
that.type = model.type;
//定时器(默认为0，不计时)
that.timeout = model.timeout || 0;
//消息内容
that.message = model.message || 'Tips Say...';
//回调函数(关闭时回调)
that.callBack = model.callBack || null;
//点击背景遮罩关闭弹出框
that.clickMaskHide = isTrue(model.clickMaskHide) ? true : false;
//是否自动居中定位
that.isPosition = isFalse(model.isPosition) ? false : true;
that.tips = that.tips ? $(that.tips) : null;
that.mask = that.mask ? $(that.mask) : null;
};
var TipsModelInstance = new TipsModel(options || {});
var createTips = function () {
var tips = [];
tips.push('<div class="ui-xbox-o2o">');
tips.push(' <div class="xbox-o2o-cont">');
tips.push(' <div class="ui-msg ui-msg-success-s" id="J-tips-icon">');
tips.push(' <i class="icon"></i>');
tips.push(' <div class="ui-msg-cont J-tip-cont"></div>');
tips.push(' </div>');
tips.push(' </div>');
tips.push('</div>');
tips = $(tips.join('\r\n'));
$(document.body).append(tips);
TipsModelInstance.tips = tips;
};
var createMask = function () {
//var mask = $('<div class="ui-mask" style="display:none;"><iframe class="ui-mask-iframe"></iframe></div>');
var mask = $('<div class="ui-mask"></div>');
$(document.body).append(mask);
TipsModelInstance.mask = mask;
TipsModelInstance.mask.click(function () {
if (TipsModelInstance.clickMaskHide) {
that.close();
}
});
};
var install = function () {
if (!TipsModelInstance.mask) {
createMask();
}
if (!TipsModelInstance.tips) {
createTips();
}
};
install();
//打开提示框
that.tip = function (options) {
/// <summary>
/// 打开loading提示
/// </summary>
/// <param name="options">参数对象[type, timeout, message, callBack]</param>
options = options || {};
var type = options.type || TipsModelInstance.tips,
timeout = options.timeout || TipsModelInstance.timeout,
message = options.message || TipsModelInstance.message,
callBack = options.callBack || TipsModelInstance.callBack,
isShowMask = options.isShowMask == undefined ? true : options.isShowMask,
isPosition = TipsModelInstance.isPosition;
if (TipsModelInstance.Thread) {
window.clearTimeout(TipsModelInstance.Thread);
TipsModelInstance.Thread = null;
}
var getScrollSize = scrollSize();
var width = getScrollSize.width,
height = getScrollSize.height,
bodyHeight = document.body.offsetHeight;
var mask = TipsModelInstance.mask,
tips = TipsModelInstance.tips;
if (isShowMask) {
mask.css('width', '100%').css('height', (height > bodyHeight ? height : bodyHeight) + 'px').show();
}
if (isPosition) {
tips.css('top', '50%').css('left', '50%');
}
tips.find('.J-tip-cont').html(message);
tips.find('#J-tips-icon').attr('class', 'ui-msg ui-msg-' + type + '-s');
tips.show();
var tipsWidth = tips[0].offsetWidth,
tipsHeight = tips[0].offsetHeight;
if (browser().ie == 6) {
var clientScroll = getScroll(),
getClientSize = clientSize();
var top = clientScroll.top + (getClientSize.height / 2) - (tipsHeight / 2),
left = clientScroll.left + (getClientSize.width / 2);
tips.css('position', 'absolute').css('top', top + 'px').css('left', left + 'px');
tipsWidth = tips[0].offsetWidth,
tipsHeight = tips[0].offsetHeight;
top = clientScroll.top + (getClientSize.height / 2) - (tipsHeight / 2),
left = clientScroll.left + (getClientSize.width / 2) - (tipsWidth / 2);
tips.css('top', top + 'px').css('left', left + 'px');
}
else if (isPosition) {
tips.css('margin-left', -(tipsWidth / 2) + 'px').css('margin-top', -(tipsHeight / 2) + 'px');
}
if (timeout) {
TipsModelInstance.Thread = window.setTimeout(function () {
that.close();
if (callBack) {
callBack.call(tips);
}
}, timeout);
}
return that;
};
//关闭提示框
that.close = function () {
/// <summary>
/// 关闭提示框
/// </summary>
if (TipsModelInstance.Thread) {
window.clearTimeout(TipsModelInstance.Thread);
TipsModelInstance.Thread = null;
}
if (TipsModelInstance.tips) {
TipsModelInstance.tips.hide();
}
if (TipsModelInstance.mask) {
TipsModelInstance.mask.hide();
}
return that;
};
//打开loading提示
that.loading = function (options) {
/// <summary>
/// 打开loading提示
/// </summary>
/// <param name="options">参数对象[timeout, message, callBack]</param>
options = options || {};
if (isString(options)) {
var message = options;
options = { message: message };
}
var loadingOptions = {
type: 'loading', timeout: options.timeout, message: options.message, callBack: options.callBack
};
that.tip(loadingOptions);
return that;
};
//打开error提示
that.error = function (options) {
/// <summary>
/// 打开error提示
/// </summary>
/// <param name="options">参数对象[timeout, message, callBack]</param>
options = options || {};
if (isString(options)) {
var message = options;
options = { message: message };
}
var errorOptions = {
type: 'error', timeout: options.timeout, message: options.message, callBack: options.callBack
};
that.tip(errorOptions);
return that;
};
//打开warning提示
that.warning = function (options) {
/// <summary>
/// 打开warning提示
/// </summary>
/// <param name="options">参数对象[timeout, message, callBack]</param>
options = options || {};
if (isString(options)) {
var message = options;
options = { message: message };
}
var warningOptions = {
type: 'warning', timeout: options.timeout, message: options.message, callBack: options.callBack
};
that.tip(warningOptions);
return that;
};
//打开success提示
that.success = function (options) {
/// <summary>
/// 打开success提示
/// </summary>
/// <param name="options">参数对象[timeout, message, callBack]</param>
options = options || {};
if (isString(options)) {
var message = options;
options = { message: message };
}
var successOptions = {
type: 'success', timeout: options.timeout, message: options.message, callBack: options.callBack
};
that.tip(successOptions);
return that;
};
//显示事件
that.onShow = function (fun) {
if (fun) {
TipsModelInstance.customEvent = TipsModelInstance.customEvent || {};
TipsModelInstance.customEvent['onShow'] = fun;
}
return that;
};
//关闭事件
that.onClose = function (fun) {
if (fun) {
TipsModelInstance.customEvent = TipsModelInstance.customEvent || {};
TipsModelInstance.customEvent['onClose'] = fun;
}
return that;
};
};
});
/**
*
* 弹出框模块
*
* version 1.2.2.1(主版本号.子版本号.编译版本号.修正版本号)
*
* @author pye-mail@163.com
*
* create log 2014年10月31日17:26:00
*
* update log 2014年11月11日14:55:04
*
*/
Module.Create('XBox', function () {
var that = this;
var BoxConfig = function () {
var that = this;
//是否已创建背景遮罩
that.isCreateMask = false;
//是否已显示背景遮罩
that.isShowMask = false;
//层级zIndex
that.zIndex = 1000;
//遮罩ZIndex
that.maskZIndex = that.zIndex + 1;
//弹出框个数
that.xBox = 0;
//弹出框显示个数
that.showXBox = 0;
//弹出框ZIndex
that.xBoxZIndex = that.zIndex + 2;
//当前弹出框对象
that.currentXBox = null;
//当前所有最大化状态的弹出框(用于window的resize事件，问题来源：当使用load加载页面嵌入iframe时给window绑定事件无效，因为存在多个window[iframe中也存在不可访问(如果是跨域)的window])
that.maxXBox = {};
//所有弹出框对象
that.allXBox = {};
//背景遮罩对象
that.mask = null;
//需要特殊组合操作的键
that.handleKey = ['min', 'max', 'button'];
//ie6
that.ie6XBoxTop = null;
//提示框模板
that.template = {
//背景遮罩模板
mask: '<div class="ui-mask" style="display:none;"></div>',
//系统按钮
sysButton: '<a href="javascript:;" class="J-btn-sys ui-xbox-#KEY# #DISABLED#" data-key="#KEY#"></a>',
//自定义按钮
cusButton: '<input type="button" value="#TEXT#" class="J-btn-cus ui-btn J-btn-#KEY# #DEFAULT# #DISABLED#" data-key="#KEY#"/>',
//弹出框模板
xbox: (function () {
var html = [];
html.push('<div class="ui-xbox ui-xbox-blue" style="display:none;z-index:-1;">');
html.push('<table class="ui-xbox-w1">');
html.push(' <thead class="ui-xbox-thd">');
html.push(' <tr>');
html.push(' <td>');
html.push(' <div class="ui-xbox-hd J-xbox-drag">');
html.push(' <div class="ui-xbox-hd-w1">');
html.push(' <div class="ui-xbox-hd-w2">');
html.push(' <div class="ui-xbox-handle J-xbox-toolsBar"></div>');
html.push(' <span class="ui-xbox-title J-xbox-title">#-TITLE-#</span>');
html.push(' </div>');
html.push(' </div>');
html.push(' </div>');
html.push(' </td>');
html.push(' </tr>');
html.push(' </thead>');
html.push(' <tbody class="ui-xbox-tbd">');
html.push(' <tr><td><div class="ui-xbox-cont J-xbox-cont">#-CONTENT-#</div></td></tr>');
html.push(' </tbody>');
html.push(' <tfoot class="ui-xbox-tft">');
html.push(' <tr><td><div class="ui-xbox-ft"><div class="ui-xbox-btns J-xbox-btns"></div></div></td></tr>');
html.push(' </tfoot>');
html.push('</table>');
html.push('</div>');
return html.join('\r\n');
})(),
//消息提示模板
msgTip: (function () {
var html = [];
html.push('<div class="ui-msg ui-msg-#-TYPE-#">');
html.push(' <div class="ui-msg-cont">#-MESSAGE-#</div>');
html.push(' <div class="ui-msg-remark">#-REMARK-#</div>');
html.push('</div>');
return html.join('\r\n');
})()
};
//各种状态集合
that.status = {
//基础(未整理)
base: {},
//皮肤(未整理)
skin: {},
//默认
defaults: { min: null, max: null, close: null, yes: 'ui-btn-blue', no: 'ui-btn-gray', cancel: 'ui-btn-gray' },
//鼠标靠近
hover: { min: 'ui-xbox-min-focus', max: 'ui-xbox-max-focus', close: 'ui-xbox-close-focus', yes: 'ui-btn-blue-hover', no: 'ui-btn-gray-hover', cancel: 'ui-btn-gray-hover' },
//鼠标按下
down: { min: null, max: null, close: null, yes: null, no: null, cancel: null },
//禁用
disabled: { min: null, max: null, close: null, yes: 'ui-btn-disable', no: 'ui-btn-disable', cancel: 'ui-btn-disable' }
};
//各种自定义属性
that.dataAttr = {
//XBox唯一标识
dataIdentity: 'data-identity',
//XBox是否绑定事件
dataEventIsBind: 'data-event-isBind'
};
};
var BoxConfigInstance = new BoxConfig();
var BoxLang = function () {
var that = this;
//加载中提示语
that.loading = '正在加载，请稍后...';
that.titleLoading = '正在连接...';
//操作失败提示语
that.error = '抱歉，操作失败！';
that.titleError = '连接失败';
};
var BoxLangInstance = new BoxLang();
that.RenderBox = function (options) {
var that = this;
var BoxModel = function (model) {
var that = this;
//静态弹出框模板
that.xbox = model.xbox || null;
//静态背景遮罩
that.mask = model.mask || null;
//宽度
that.width = model.width || 200;
//高度
that.height = model.height || 50;
//初始化属性
that.initAttribute = isTrue(model.initAttribute) ? true : false;
//目标路径
that.url = model.url || null;
//加载类型(ajax|iframe)
that.loadType = model.loadType || 'ajax';
//是否加载完成
that.isCompleteLoad = false;
//加载一次
that.loadOnce = isFalse(model.loadOnce) ? false : true;
//请求附带数据集合对象
that.data = model.data || null;
//内容
that.content = model.data || '[空白面板]';
//标题
that.title = model.title || '[无标题]';
//是否可拖动
that.isDrag = isFalse(model.isDrag) ? false : true;
//每次关闭xbox时，是否作为隐藏处理(true.隐藏 false.直接删除)
that.isHidden = isFalse(model.isHidden) ? false : true;
//是否为模态窗口
that.isModal = isFalse(model.isModal) ? false : true;
//是否需要背景遮罩
that.isMask = isFalse(model.isMask) ? false : true;
//是否允许改变大小
that.isResize = isTrue(model.isResize) ? true : false;
//最小宽度和高度
that.min = { width: 240, height: 60 };
//最大宽度和高度
that.max = { width: 'auto', height: 'auto' };
//将弹出框添加到
that.appendTo = model.appendTo || null;
//按钮集合
that.buttons = {
//最小化窗体
min: { type: 'system', isShow: false, isDisabled: false, text: null, callBack: null },
//最大化窗体
max: { type: 'system', isShow: false, isDisabled: false, text: null, callBack: null },
//关闭窗体
close: { type: 'system', isShow: true, isDisabled: false, text: null, callBack: null },
//肯定
yes: { type: 'custom', isShow: true, isDisabled: false, text: '确定', callBack: null },
//否定
no: { type: 'custom', isShow: true, isDisabled: false, text: '取消', callBack: null },
//还原或不改变现状
cancel: { type: 'custom', isShow: false, isDisabled: false, text: '返回', callBack: null }
};
//元素对象(表示当前实例控件的对象)
that.element = { mask: null, xbox: null, content: null, title: null, buttons: null, toolsBar: null };
//操作元素类名
that.handleClassName = { drag: 'J-xbox-drag', content: 'J-xbox-cont', title: 'J-xbox-title', buttons: 'J-xbox-btns', toolsBar: 'J-xbox-toolsBar', close: 'J-xbox-btn-close', max: 'J-xbox-btn-max', min: 'J-xbox-btn-min', restore: 'J-xbox-btn-restore', yes: 'J-xbox-btn-yes', no: 'J-xbox-btn-no', cancel: 'J-xbox-btn-cancel' };
//浏览器信息
that.browser = model.browser || browser();
//是否重写XBox中的内容(包括标题、内容和按钮，主要应用在使用静态自定义弹出框时)
that.isOverRide = isFalse(model.isOverRide) ? false : true;
//当前弹出框状态类型(默认:'default' 最小化:'min' 最大化:'max')
that.statusType = model.statusType || 'default';
//是否响应自定义事件
that.isInteraction = isFalse(model.isInteraction) ? false : true;
//弹出框显示状态
that.boxStatus = 'hide';
var buttons = model.buttons;
if (buttons) {
var buttonItem;
for (var key in buttons) {
buttonItem = buttons[key];
for (var itemKey in buttonItem) {
that.buttons[key][itemKey] = buttonItem[itemKey];
}
}
}
};
var BoxModelInstance = new BoxModel(options || {});
var createMask = function () {
if (!BoxConfigInstance.isCreateMask) {
var mask = $(BoxModelInstance.mask || BoxConfigInstance.template.mask);
$(document.body).append(mask);
//已创建背景遮罩
BoxConfigInstance.isCreateMask = true;
//未显示遮罩
BoxConfigInstance.isShowMask = false;
//保存背景遮罩对象
BoxConfigInstance.mask = mask;
BoxModelInstance.element.mask = mask;
}
else {
BoxModelInstance.element.mask = BoxConfigInstance.mask;
}
};
var createXBox = function () {
var xbox = $(BoxModelInstance.xbox || BoxConfigInstance.template.xbox),
appendTo = $(BoxModelInstance.appendTo || document.body);
var handleClassName = BoxModelInstance.handleClassName;
xbox.appendTo(appendTo);
//弹出框个数+1
BoxConfigInstance.xBox++;
//保存当前弹出框对象
BoxConfigInstance.currentXBox = xbox;
//弹出框对象
BoxModelInstance.element.xbox = xbox;
//弹出框内容区域对象
BoxModelInstance.element.content = xbox.find('.' + handleClassName.content);
//标题区域对象
BoxModelInstance.element.title = xbox.find('.' + handleClassName.title);
//按钮区域对象
BoxModelInstance.element.buttons = xbox.find('.' + handleClassName.buttons);
//工具栏区域对象
BoxModelInstance.element.toolsBar = xbox.find('.' + handleClassName.toolsBar);
var identity = Module.Guid('XBOX-IDENTITY-');
xbox.attr(BoxConfigInstance.dataAttr.dataIdentity, identity);
//保存所有弹出框
BoxConfigInstance.allXBox[identity] = xbox;
};
var bindEvent = function () {
var xbox = BoxConfigInstance.currentXBox,
dataEventIsBind = BoxConfigInstance.dataAttr.dataEventIsBind,
handleClassName = BoxModelInstance.handleClassName;
var isBind = xbox.attr(dataEventIsBind);
if (isBind != true) {
//点击事件
xbox.click(function (e) {
var target = $(eventTarget(e));
var key = target.attr('data-key');
var isDisabled = BoxConfigInstance.status.disabled[key];
var buttons = BoxModelInstance.buttons,
customEvent = BoxModelInstance.customEvent;
if (!target.hasClass(isDisabled)) {
if (target.hasClass(handleClassName.close)) {
//关闭
var closeButton = buttons[key];
if (!closeButton.isDisabled) {
close(closeButton.callBack);
}
}
else if (target.hasClass(handleClassName.yes)) {
//确定按钮
var yesButton = buttons[key];
if (!yesButton.isDisabled) {
var yesEvent = null;
if (customEvent) {
yesEvent = customEvent['onYes'];
}
var yesCallBack = function () {
var callBackResult = true, eventResult = true, result = true;
if (yesButton.callBack) {
callBackResult = yesButton.callBack.call(BoxModelInstance.element.xbox);
if (isFalse(callBackResult)) {
result = false;
}
}
if (yesEvent) {
eventResult = yesEvent.call(BoxModelInstance.element.xbox);
if (isFalse(eventResult)) {
result = false;
}
}
return result;
};
close(yesCallBack);
}
}
else if (target.hasClass(handleClassName.no)) {
//否定按钮
var noButton = buttons[key];
if (!noButton.isDisabled) {
var noEvent = null;
if (customEvent) {
noEvent = customEvent['onNo'];
}
var noCallBack = function () {
var callBackResult = true, eventResult = true, result = true;
if (noButton.callBack) {
callBackResult = noButton.callBack.call(BoxModelInstance.element.xbox);
if (isFalse(callBackResult)) {
result = false;
}
}
if (noEvent) {
eventResult = noEvent.call(BoxModelInstance.element.xbox);
if (isFalse(eventResult)) {
result = false;
}
}
return result;
};
close(noCallBack);
}
}
else if (target.hasClass(handleClassName.cancel)) {
//取消按钮
var cancelButton = buttons[key];
if (!cancelButton.isDisabled) {
var cancelEvent = null;
if (customEvent) {
cancelEvent = customEvent['onCancel'];
}
var cancelCallBack = function () {
var callBackResult = true, eventResult = true, result = true;
if (cancelButton.callBack) {
callBackResult = cancelButton.callBack.call(BoxModelInstance.element.xbox);
if (isFalse(callBackResult)) {
result = false;
}
}
if (cancelEvent) {
eventResult = cancelEvent.call(BoxModelInstance.element.xbox);
if (isFalse(eventResult)) {
result = false;
}
}
return result;
};
close(cancelCallBack);
}
}
}
var customEvent = BoxModelInstance.customEvent;
if (customEvent) {
var clickEvent = customEvent.onClick;
if (clickEvent) {
clickEvent.call(target, e);
}
}
});
//mouseover事件
xbox.mouseover(function (e) {
var target = $(eventTarget(e));
});
//mousedown事件
xbox.mousedown(function (e) {
var target = $(eventTarget(e));
});
xbox.attr(dataEventIsBind, true);
}
};
var drag = function (opts) {
var dragOptions = {
//拖动触发元素
drag: null,
//拖动移动元素，如果为null，默认为drag对象
move: null,
//拖动范围限制区域
region: document.body
}, browserInfo = BoxModelInstance.browser;
//遍历自定义参数
if (opts) {
for (var key in opts) { dragOptions[key.toLocaleLowerCase()] = opts[key]; }
//如果移动对象为空
if (!dragOptions.move) { dragOptions.move = dragOptions.drag; }
}
var dragEvent = function (event) {
event = event || window.event;
//获取移动元素的相对坐标
var movePosition = getPosition(dragOptions.move);
//响应拖动事件
var customEvent = BoxModelInstance.customEvent;
if (customEvent) {
var dragEvent = customEvent.onDrag;
if (dragEvent && BoxModelInstance.isInteraction) {
var eventResult = dragEvent.call(BoxModelInstance.element.xbox, event, movePosition.top, movePosition.left);
if (eventResult == false || eventResult == 'false' || eventResult == 'False') {
return false;
}
}
}
//判断移动元素是否为浮动元素
dragOptions.drag.style.cursor = 'move';
//获取拖动限制区域相对坐标
var regionPosition = getPosition(dragOptions.region);
var regionTop = regionPosition.top, regionLeft = regionPosition.left;
var moveStyle = dragOptions.move.style;
if (browserInfo.ie !== '6.0') {
moveStyle.position = 'absolute';
moveStyle.top = movePosition.top + 'px';
moveStyle.left = movePosition.left + 'px';
moveStyle.margin = '0px';
}
//获取移动元素的宽和高
var moveWidth = dragOptions.move.offsetWidth, moveHeight = dragOptions.move.offsetHeight;
//移动元素在限制区域的最小坐标
var minTop = 0, minLeft = 0;
//移动元素在限制区域的最大坐标
var scrolls = getScroll();
var clients = clientSize();
var maxTop = clients.height + scrolls.top - moveHeight,
maxLeft = clients.width + scrolls.left - moveWidth;
//初始化鼠标坐标
var dragClientX = event.clientX, dragClientY = event.clientY;
//定义元素移动距离
var top, left;
//鼠标移动事件
document.onmousemove = function (e) {
e = e || window.event;
//获取鼠标当前坐标位置
var moveClientX = e.clientX, moveClientY = e.clientY;
top = movePosition.top + moveClientY - dragClientY, left = movePosition.left + moveClientX - dragClientX;
if (top <= minTop) { top = minTop; }
if (top >= maxTop) { top = maxTop; }
if (left <= minLeft) { left = minLeft; }
if (left >= maxLeft) { left = maxLeft; }
moveStyle.top = top + 'px';
moveStyle.left = left + 'px';
//响应控件移动事件
if (customEvent) {
var moveEvent = customEvent.onDragMove;
if (moveEvent) {
moveEvent.call(BoxModelInstance.element.xbox, e, top, left);
}
}
};
document.onmouseup = function (e) {
document.onmousemove = null;
document.onmouseup = null;
dragOptions.drag.style.cursor = 'default';
BoxModelInstance.ie6XBoxTop = parseInt(moveStyle.top) - getScroll().top;
if (browserInfo.ie !== '6.0') {
moveStyle.top = BoxModelInstance.ie6XBoxTop + 'px';
moveStyle.position = 'fixed';
}
movePosition = getPosition(dragOptions.move);
if (customEvent) {
var dragEndEvent = customEvent.onDragEnd;
//响应控件拖拽结束事件
if (dragEndEvent) {
dragEndEvent.call(BoxModelInstance.element.xbox, e, movePosition.top, movePosition.left);
}
}
};
};
//绑定事件
if (dragOptions.drag) { dragOptions.drag.onmousedown = dragEvent; }
};
var show = function (callBack) {
var xbox = BoxModelInstance.element.xbox,
mask = BoxModelInstance.element.mask;
if (!xbox) {
var buttons = options.buttons;
if (buttons) {
var buttonItem;
for (var key in buttons) {
buttonItem = buttons[key];
for (var itemKey in buttonItem) {
BoxModelInstance.buttons[key][itemKey] = buttonItem[itemKey];
}
}
}
install();
xbox = BoxModelInstance.element.xbox;
}
//弹出框zindex+2
BoxConfigInstance.xBoxZIndex += 2;
xbox.css('z-index', BoxConfigInstance.xBoxZIndex).show();
//弹出框显示个数+1
BoxConfigInstance.showXBox++;
if (BoxModelInstance.isMask) {
BoxConfigInstance.maskZIndex += 2;
mask.css('z-index', BoxConfigInstance.maskZIndex).show();
BoxConfigInstance.isShowMask = true;
}
BoxModelInstance.boxStatus = 'show';
renderBoxPosition();
if (callBack && isFunction(callBack)) {
callBack();
}
//响应显示事件
var customEvent = BoxModelInstance.customEvent;
if (customEvent) {
var showEvent = customEvent.onShow;
if (showEvent && BoxModelInstance.isInteraction) {
var eventResult = showEvent.call(BoxModelInstance.element.xbox);
if (eventResult == false || eventResult == 'false' || eventResult == 'False') {
return that;
}
}
}
return that;
};
var close = function (callBack) {
if (BoxModelInstance.boxStatus === 'show') {
if (callBack && isFunction(callBack)) {
//执行自定义操作
var eventResult = callBack.call(BoxModelInstance.element.xbox);
if (eventResult == false || eventResult == 'false' || eventResult == 'False') {
return that;
}
}
//响应关闭事件
var customEvent = BoxModelInstance.customEvent;
if (customEvent) {
var closeEvent = customEvent.onClose;
if (closeEvent && BoxModelInstance.isInteraction) {
var eventResult = closeEvent.call(BoxModelInstance.element.xbox);
if (eventResult == false || eventResult == 'false' || eventResult == 'False') {
return that;
}
}
}
//ZIndex递减
BoxConfigInstance.xBoxZIndex -= 2, BoxConfigInstance.maskZIndex -= 2;
if (BoxModelInstance.isHidden) {
//隐藏弹出框
BoxModelInstance.element.xbox.hide();
//设置xbox状态
BoxModelInstance.boxStatus = 'hide';
//弹出框显示个数减一
BoxConfigInstance.showXBox--;
//如果是链接加载页面，关闭时终止页面的加载
if (BoxModelInstance.url && !BoxModelInstance.isCompleteLoad) {
that.stopLoad();
}
}
else {
//删除弹出框，并设置状态
BoxModelInstance.element.xbox.remove();
BoxModelInstance.element.xbox = null;
BoxModelInstance.boxStatus = 'remove';
//弹出框个数减一、显示个数减一
BoxConfigInstance.showXBox--;
BoxConfigInstance.xBox--;
//
if (BoxModelInstance.next) {
BoxModelInstance.next.idx = 0;
}
}
if (BoxConfigInstance.showXBox > 0) {
BoxModelInstance.element.mask.css('z-index', BoxConfigInstance.maskZIndex);
//如果存在非模态窗口
}
else {
//隐藏背景遮罩
BoxModelInstance.element.mask.hide();
BoxConfigInstance.isShowMask = false;
}
}
return that;
};
var renderButton = function (buttons, overRide) {
if (isBoolean(buttons)) {
overRide = buttons;
buttons = null;
}
if (overRide || overRide == undefined || overRide == null) {
if (buttons) {
var boxButtons = null, btns = null;
for (var key in buttons) {
boxButtons = BoxModelInstance.buttons[key];
btns = buttons[key];
for (var btnKey in btns) {
boxButtons[btnKey] = btns[btnKey];
}
}
}
buttons = BoxModelInstance.buttons;
var sysButton = BoxConfigInstance.template.sysButton,
cusButton = BoxConfigInstance.template.cusButton,
disabled = BoxConfigInstance.status.disabled,
defaults = BoxConfigInstance.status.defaults,
handleClassName = BoxModelInstance.handleClassName,
item, handleLink, btnButton;
var toolsBar = BoxModelInstance.element.toolsBar.html(''),
xboxButton = BoxModelInstance.element.buttons.html('');
var showCount = 0;
for (var key in buttons) {
item = buttons[key];
if (item.isShow) {
if (item.type == 'system') {
handleLink = $(sysButton.replaceAll('#KEY#', key)
.replace('#DISABLED#', (item.isDisabled ? (disabled[key] ? disabled[key] : '') : '')));
handleLink.addClass(handleClassName[key]);
toolsBar.append(handleLink);
}
else if (item.type == 'custom') {
btnButton = $(cusButton.replaceAll('#KEY#', key)
.replace('#TEXT#', item.text || '')
.replace('#DEFAULT#', defaults[key] || '')
.replace('#DISABLED#', (item.isDisabled ? (disabled[key] || '') : '')));
btnButton.addClass(handleClassName[key]);
xboxButton.append(btnButton);
}
showCount++;
}
}
if (!showCount) {
xboxButton.parents('tfoot').hide();
}
}
};
var renderButtonKey = function () {
var toolsBar = BoxModelInstance.element.toolsBar,
xboxButton = BoxModelInstance.element.buttons,
handleClassName = BoxModelInstance.handleClassName;
toolsBar.find('.' + handleClassName.close).addClass('J-btn-sys').attr('data-key', 'close');
toolsBar.find('.' + handleClassName.min).addClass('J-btn-sys').attr('data-key', 'min');
toolsBar.find('.' + handleClassName.max).addClass('J-btn-sys').attr('data-key', 'max');
toolsBar.find('.' + handleClassName.restore).addClass('J-btn-sys').attr('data-key', 'restore');
xboxButton.find('.' + handleClassName.yes).addClass('J-btn-cus').attr('data-key', 'yes');
xboxButton.find('.' + handleClassName.no).addClass('J-btn-cus').attr('data-key', 'no');
xboxButton.find('.' + handleClassName.cancel).addClass('J-btn-cus').attr('data-key', 'cancel');
};
var renderBoxPosition = function () {
var mask = BoxModelInstance.element.mask,
xbox = BoxModelInstance.element.xbox;
//获取浏览器内容区域的宽和高
var scroller = scrollSize();
mask.css('width', (scroller.width) + 'px').css('height', (scroller.height) + 'px');
var contentTarget = BoxModelInstance.element.content;
contentTarget.css('width', 'auto').css('height', 'auto');
if (BoxModelInstance.url === null || BoxModelInstance.isCompleteLoad || BoxModelInstance.initAttribute) {
//设置最小宽度和高度
var contentWidth = contentTarget[0].offsetWidth, contentHeight = contentTarget[0].offsetHeight;
var min = BoxModelInstance.min, max = BoxModelInstance.max;
var minWidth = min.width, minHeight = min.height,
maxWidth = max.width, maxHeight = max.height;
var width = BoxModelInstance.width,
height = BoxModelInstance.height;
if (minWidth != 'auto') {
if (contentWidth <= minWidth) {
if (minWidth < width) {
contentTarget.css('width', width + 'px').css('overflow', 'auto');
}
else {
contentTarget.css('width', minWidth + 'px').css('overflow', 'auto');
}
}
else if (width > contentWidth) {
contentTarget.css('width', width + 'px').css('overflow', 'auto');
}
}
if (minHeight != 'auto') {
if (contentHeight <= minHeight) {
if (minHeight < height) {
contentTarget.css('height', height + 'px').css('overflow', 'auto');
}
else {
contentTarget.css('height', minHeight + 'px').css('overflow', 'auto');
}
}
else if (height > contentHeight) {
contentTarget.css('height', height + 'px').css('overflow', 'auto');
}
}
if (maxWidth != 'auto') {
if (contentWidth >= maxWidth) {
contentTarget.css('width', maxWidth + 'px').css('overflow', 'auto');
}
else if (width > maxWidth) {
contentTarget.css('width', maxWidth + 'px').css('overflow', 'auto');
}
}
if (maxHeight != 'auto') {
if (contentHeight <= maxHeight) { contentTarget.css('height', maxHeight + 'px').css('overflow', 'auto'); }
}
}
var width = xbox[0].offsetWidth, height = xbox[0].offsetHeight;
if (BoxModelInstance.browser.ie !== '6.0') {
xbox.css('left', '50%');
xbox.css('top', '50%');
xbox.css('margin', '-' + (height / 2) + 'px ' + '-' + (width / 2) + 'px');
}
else {
//获取浏览器可见区域的宽和高
var clients = clientSize();
//获取滚动条距离
var scrollBar = getScroll();
xbox.css('left', ((clients.width / 2) - (width / 2) + scrollBar.left) + 'px');
xbox.css('top', ((clients.height / 2) - (height / 2) + scrollBar.top) + 'px');
}
};
var renderTitle = function (title, overRide) {
if (isBoolean(title)) {
overRide = title;
title = null;
}
if (overRide || overRide == undefined || overRide == null) {
title = title || BoxModelInstance.title;
var xbox = BoxModelInstance.element.xbox;
if (xbox) {
if (title) {
BoxModelInstance.element.title.html(title);
}
else {
BoxModelInstance.element.title.parents('thead').hide();
}
}
}
else {
BoxModelInstance.title = BoxModelInstance.element.title.html();
}
};
var renderContent = function (content, overRide) {
if (isBoolean(content)) {
overRide = content;
content = BoxModelInstance.content;
}
if (overRide || overRide == undefined || overRide == null) {
content = content || BoxModelInstance.content;
var xbox = BoxModelInstance.element.xbox;
if (xbox) {
if (isString(content)) {
BoxModelInstance.element.content.html(content);
}
else {
BoxModelInstance.element.content.append(content);
}
renderBoxPosition();
}
}
else {
BoxModelInstance.content = BoxModelInstance.element.content.html();
}
};
var saveHistory = function (options) {
var boxLoadHistory = {
//URL
url: options.url,
//标题
title: options.title,
//数据
data: options.data,
//请求方式
loadType: options.loadType,
//宽
width: options.width,
//高
height: options.height,
//按钮
buttons: options.buttons,
//其他属性(非BoxModelInstance中的属性)
other: options.other
};
if (!BoxModelInstance.loadHistory) {
BoxModelInstance.loadHistory = {
//历史记录信息集合
history: [boxLoadHistory],
//当前记录位置下标，从0开始
index: 0
};
}
else {
//判断是否已经存在
var history = BoxModelInstance.loadHistory.history;
var i = 0, length = history.length, historyItem, status = true;
for (; i < length; i++) {
historyItem = history[i];
if (historyItem['url'] == boxLoadHistory['url']) {
status = false;
break;
}
}
if (status) {
BoxModelInstance.loadHistory.history.push(boxLoadHistory);
}
}
};
var clearHistory = function (url) {
if (url) {
var history = BoxModelInstance.loadHistory.history,
index = BoxModelInstance.loadHistory.index;
var i = 0, length = history.length, historyItem, tempHistory = [];
for (; i < length; i++) {
historyItem = history[i];
if (historyItem['url'] != url) {
//重新组合记录
tempHistory.push(historyItem);
}
else {
//重新设置记录当前位置下标
if (index > i) {
BoxModelInstance.loadHistory.index -= 1;
}
}
}
//重新设置历史记录
BoxModelInstance.loadHistory.history = tempHistory;
}
else {
BoxModelInstance.loadHistory = {
//历史记录信息集合
history: [],
//当前记录位置下标，从0开始
index: 0
};
}
};
var loadPage = function (options) {
options = options || {};
if (options.data) {
//重置请求提交数据
BoxModelInstance.data = options.data;
}
if (options.url) {
//重置请求路径
BoxModelInstance.url = options.url;
}
if (options.loadType) {
//重置加载类型
BoxModelInstance.loadType = options.loadType;
}
if (options.title) {
//重置标题
BoxModelInstance.title = options.title;
}
BoxModelInstance.next = null;
//失败
var error = options.error,
//完成
complete = options.complete,
//成功
success = options.success,
//是否缓存数据
isCache = options.isCache;
if (isCache != false) {
//保存历史记录
saveHistory({
url: BoxModelInstance.url,
data: BoxModelInstance.data,
title: BoxModelInstance.title,
loadType: BoxModelInstance.loadType,
width: BoxModelInstance.width,
height: BoxModelInstance.height,
buttons: BoxModelInstance.buttons,
other: {
error: error,
complete: complete,
success: success
}
});
}
//自定义事件
var customEvent = BoxModelInstance.customEvent;
if (BoxModelInstance.boxStatus == 'hide') {
show();
}
if (BoxModelInstance.loadOnce) {
if (BoxModelInstance.isCompleteLoad) {
return that;
}
}
//设置加载状态
BoxModelInstance.isCompleteLoad = false;
//设置加载模板
var loading = BoxConfigInstance.template.msgTip.replace('#-TYPE-#', 'loading').replace('#-MESSAGE-#', BoxLangInstance.loading).replace('#-REMARK-#', '');
renderContent(loading, true);
renderTitle(BoxLangInstance.titleLoading);
//保持最大化
if (BoxModelInstance.statusType === 'max') {
var thisInteraction = BoxModelInstance.isInteraction;
BoxModelInstance.isInteraction = false;
that.reMax();
BoxModelInstance.isInteraction = thisInteraction;
}
var loadType = BoxModelInstance.loadType.toLocaleLowerCase();
if (loadType == 'iframe') {
//嵌入iframe方式
var iframes = document.createElement('iframe');
$(iframes).attr('frameBorder', 'none')
.css('display', 'none')
.css('border', 'none')
.css('width', '100%')
.css('height', '98%');
BoxModelInstance.content = $(iframes);
BoxModelInstance.element.content.append($(iframes));
iframes.onload = function () {
renderTitle(BoxModelInstance.title);
$(iframes).show();
BoxModelInstance.element.content.find('.ui-msg').remove();
//设置加载完成
BoxModelInstance.isCompleteLoad = true;
renderBoxPosition();
//保持最大化
if (BoxModelInstance.statusType === 'max') {
var thisInteraction = BoxModelInstance.isInteraction;
BoxModelInstance.isInteraction = false;
that.reMax();
BoxModelInstance.isInteraction = thisInteraction;
}
if (success) {
success.call(that);
}
if (customEvent) {
var loadEvent = customEvent.onLoad;
//响应加载完成事件
if (loadEvent && BoxModelInstance.isInteraction) {
loadEvent.call(BoxModelInstance.element.xbox);
}
}
};
var data = BoxModelInstance.data,
url = BoxModelInstance.url;
if (data) {
var dataString = '';
for (var key in data) {
if (dataString == '') {
dataString = '?' + key + '=' + data[key];
}
else {
dataString += '&' + key + '=' + data[key];
}
}
url = url + dataString;
}
iframes.src = url;
}
else if (loadType == 'ajax') {
var method = BoxModelInstance.url.substring(BoxModelInstance.url.length - 5, BoxModelInstance.url.length) == '.html' ? 'GET' : 'POST';
//加载内容
BoxModelInstance.ajaxRequired = $.ajax({
//请求路径
url: BoxModelInstance.url,
//请求方式(POST/GET)
method: method,
//同步(false)/异步(true)
async: true,
//提交数据
data: BoxModelInstance.data,
//请求出错
error: function (responseText, response) {
renderTitle(BoxLangInstance.titleError);
var errors = BoxConfigInstance.template.msgTip.replace('#-TYPE-#', 'error').replace('#-MESSAGE-#', BoxLangInstance.error).replace('#-REMARK-#', '');
BoxModelInstance.element.content.html(error);
renderBoxPosition();
//保持最大化
if (BoxModelInstance.statusType == 'max') {
var thisInteraction = BoxModelInstance.isInteraction;
BoxModelInstance.isInteraction = false;
that.reMax();
BoxModelInstance.isInteraction = thisInteraction;
}
if (error) {
error.call(BoxModelInstance.element.xbox, responseText, response);
}
},
//请求完成
complete: function (responseText, response) {
if (complete) {
complete.call(BoxModelInstance.element.xbox);
}
},
//请求成功
success: function (responseText, response) {
renderTitle(BoxModelInstance.title);
BoxModelInstance.content = responseText
BoxModelInstance.element.content.html(responseText);
//保持最大化
if (BoxModelInstance.statusType === 'max') {
var thisInteraction = BoxModelInstance.isInteraction;
BoxModelInstance.isInteraction = false;
that.reMax();
BoxModelInstance.isInteraction = thisInteraction;
}
//设置加载完成
BoxModelInstance.loadComplete = true;
renderBoxPosition();
if (Module.asyncRunHandle) {
Module.asyncRunHandle();
}
if (success) {
success.call(BoxModelInstance.element.xbox, responseText, response);
}
if (customEvent) {
var loadEvent = customEvent.onLoad;
//响应加载完成事件
if (loadEvent && BoxModelInstance.isInteraction) {
loadEvent.call(BoxModelInstance.element.xbox, responseText, response);
}
}
}
});
}
return that;
};
var renderLoad = function (options) {
var loadType = options.loadType,
url = options.url,
data = options.data,
callBack = options.callBack;
};
var createNextPanel = function (option, callBack) {
var optionID = option.id;
BoxModelInstance.next = BoxModelInstance.next || {
list: {},
keys: [],
idx: 0
};
var tempPanel = '<div class="J-xbox-next-panel J-xbox-next-panel-#OPTIONID#" style="width:100%;height:97%;"></div>';
var xboxContent = BoxModelInstance.element.content;
if (BoxModelInstance.next.keys.length == 0) {
//var defaultContent = BoxModelInstance.content;
var tempContent = $(tempPanel.replace('#OPTIONID#', 'default')).append(xboxContent.children()).hide();
xboxContent.html('').append(tempContent);
var defaultOptions = {
id: 'default',
title: BoxModelInstance.title,
content: BoxModelInstance.content,
buttons: {}
};
var defaultButtons = BoxModelInstance.buttons, defaultItem;
for (var key in defaultButtons) {
defaultItem = defaultButtons[key];
defaultOptions.buttons[key] = {};
for (var defaultKey in defaultItem) {
defaultOptions.buttons[key][defaultKey] = defaultItem[defaultKey];
}
}
BoxModelInstance.next.list['default'] = defaultOptions;
BoxModelInstance.next.keys.push('default');
//BoxModelInstance.next.idx++;
}
if (!BoxModelInstance.next.list[optionID]) {
BoxModelInstance.next.list[optionID] = option;
BoxModelInstance.next.keys.push(optionID);
BoxModelInstance.next.idx++;
}
var nextPanel = xboxContent.find('.J-xbox-next-panel-' + optionID);
if (!nextPanel.length) {
nextPanel = $(tempPanel.replace('#OPTIONID#', optionID));
nextPanel.html('');
}
xboxContent.find('.J-xbox-next-panel').hide();
xboxContent.append(nextPanel);
var content = option.content,
target = option.target,
url = option.url;
if (content) {
//静态内容
nextPanel.html(content);
if (callBack && isFunction(callBack)) {
callBack.call(that);
}
if (option.callBack && isFunction(option.callBack)) {
option.callBack.call(that);
}
}
else if (target && target.length) {
//目标元素
nextPanel.append(target);
if (callBack && isFunction(callBack)) {
callBack.call(that);
}
if (option.callBack && isFunction(option.callBack)) {
option.callBack.call(that);
}
}
else if (url) {
//地址请求
var data = option.data,
loadType = option.loadType;
//设置加载模板
var loading = BoxConfigInstance.template.msgTip.replace('#-TYPE-#', 'loading').replace('#-MESSAGE-#', BoxLangInstance.loading).replace('#-REMARK-#', '');
nextPanel.append(loading);
if (loadType == 'iframe') {
//嵌入iframe方式
var iframes = document.createElement('iframe');
$(iframes).attr('frameBorder', 'none')
.css('display', 'none')
.css('border', 'none')
.css('width', '100%')
.css('height', '100%');
if (data) {
var dataString = '';
for (var key in data) {
if (dataString == '') {
dataString = '?' + key + '=' + data[key];
}
else {
dataString += '&' + key + '=' + data[key];
}
}
url = url + dataString;
}
iframes.onload = function () {
nextPanel.find('.ui-msg').remove();
$(iframes).show();
if (callBack && isFunction(callBack)) {
callBack.call(that);
}
if (option.callBack && isFunction(option.callBack)) {
option.callBack.call(that);
}
};
iframes.src = url;
nextPanel.append(iframes);
}
else if (loadType == 'ajax') {
var method = url.substring(url.length - 5, url.length) == '.html' ? 'GET' : 'POST';
//加载内容
BoxModelInstance.ajaxRequired = $.ajax({
//请求路径
url: url,
//请求方式(POST/GET)
method: method,
//同步(false)/异步(true)
async: true,
//提交数据
data: data,
//请求出错
error: function (responseText, response) {
var errors = BoxConfigInstance.template.msgTip.replace('#-TYPE-#', 'error').replace('#-MESSAGE-#', BoxLangInstance.error).replace('#-REMARK-#', '');
nextPanel.html(errors);
},
//请求完成
complete: function (responseText, response) { },
//请求成功
success: function (responseText, response) {
nextPanel.html(responseText);
if (Module.asyncRunHandle) {
Module.asyncRunHandle();
}
if (callBack && isFunction(callBack)) {
callBack.call(that);
}
if (option.callBack && isFunction(option.callBack)) {
option.callBack.call(that);
}
}
});
}
}
};
var install = function () {
//创建背景遮罩
createMask();
//创建XBox
createXBox();
//创建按钮
renderButton(BoxModelInstance.isOverRide);
//设置标题
renderTitle(BoxModelInstance.isOverRide);
//设置内容
renderContent(BoxModelInstance.isOverRide);
renderButtonKey();
//绑定事件
bindEvent();
var xbox = BoxModelInstance.element.xbox;
//拖动事件
if (BoxModelInstance.isDrag) {
var dragTarget = xbox.find('.J-xbox-drag');
drag({ drag: dragTarget[0], move: xbox[0] });
}
//IE6滚动
if (BoxModelInstance.browser.ie === '6.0') {
var clientHeight = clientSize().height;
var xBoxTop = (clientHeight - xbox.offsetHeight) / 2;
var scrollTop;
xbox.css('position', 'absolute').css('margin', '0px').css('top', xBoxTop + 'px');
var scroll = function () {
var osHeight = xbox.offsetHeight;
xBoxTop = BoxModelInstance.ie6XBoxTop || (clientSize().height - osHeight) / 2;
scrollTop = getScroll().top;
xbox.css('top', (scrollTop + xBoxTop) + 'px');
};
window.onscroll = scroll;
scroll();
}
};
that.open = show;
that.close = close;
that.load = loadPage;
that.reLoad = function () {
if (BoxModelInstance.url) {
//动态加载
var loadHistory = BoxModelInstance.loadHistory;
var history = loadHistory.history;
var historyData = history[loadHistory.index];
//重新加载历史记录
loadPage({ other: historyData['other'], isCache: false });
}
else {
//静态内容
renderContent();
show();
}
return that;
};
that.stopLoad = function (callBack) {
var ajaxRequired = BoxModelInstance.ajaxRequired,
loadType = BoxModelInstance.loadType.toLocaleLowerCase();
if (loadType == 'iframe') {
//终止iframe嵌入(移除元素)
BoxModelInstance.element.content.html('');
}
else if (loadType == 'ajax') {
if (ajaxRequired) {
ajaxRequired.abort();
}
}
if (callBack) {
callBack();
}
return that;
};
that.history = function (back) {
if (back == undefined || back == null || back == 'null' || back == 'undefined') {
back = -1;
}
var loadHistory = BoxModelInstance.loadHistory;
if (loadHistory) {
var history = loadHistory.history;
var historyLength = history.length;
loadHistory.index += back;
if (loadHistory.index < 0) {
loadHistory.index = 0;
}
else if (loadHistory.index > historyLength) {
loadHistory.index = historyLength;
}
//获取历史记录数据
var historyData = history[loadHistory.index];
//重置Box相关属性
for (var key in historyData) {
if (key != 'other') {
BoxModelInstance[key] = historyData[key];
}
}
//重新加载历史记录
loadPage({ other: historyData['other'], isCache: false });
}
return that;
};
that.title = function (title, callBack) {
renderTitle(title);
if (callBack && isFunction(callBack)) {
callBack();
}
return that;
};
that.button = function (buttons, callBack) {
renderButton(buttons);
if (callBack && isFunction(callBack)) {
callBack();
}
return that;
};
that.content = function (content, callBack) {
renderContent(content);
if (callBack && isFunction(callBack)) {
callBack();
}
return that;
};
that.contentGroup = function (options) {
BoxModelInstance.next = BoxModelInstance.next || {
list: {},
keys: [],
idx: -1
};
if (options) {
var i = 0, length = options.length, item, id;
for (; i < length; i++) {
item = options[i];
id = item.id;
if (!BoxModelInstance.next[id]) {
BoxModelInstance.next[id] = item;
BoxModelInstance.next.keys.push(id);
}
}
}
return that;
};
that.goToNext = function (flag) {
flag = flag == undefined || flag == null ? 1 : flag;
var toNext = BoxModelInstance.next;
if (toNext) {
var keys = toNext.keys,
list = toNext.list,
idx = toNext.idx;
var keyIdx = idx + flag;
var renderNextBox = function () {
renderTitle(nextkey.title);
var buttons = nextItem.buttons, btnItem;
if (buttons) {
for (var key in buttons) {
btnItem = buttons[key];
for (var btnKey in btnItem) {
BoxModelInstance.buttons[key][btnKey] = btnItem[btnKey];
}
}
renderButton();
var customEvent = BoxModelInstance.customEvent;
if (customEvent) {
var prevEvent = customEvent.onPrev;
if (prevEvent) {
prevEvent.call(that);
}
}
}
};
var xboxContent = BoxModelInstance.element.content;
if (keyIdx >= 0) {
var nextkey = keys[keyIdx];
if (nextkey) {
var nextItem = list[nextkey];
if (nextItem) {
var optionID = nextItem.id;
xboxContent.find('.J-xbox-next-panel').hide();
//当前项的元素(数据来源有可能来自contentGroup中添加的，可能所有数据并没有创建元素)
var nextPanel = xboxContent.find('.J-xbox-next-panel-' + optionID);
if (nextPanel.length) {
xboxContent.find('.J-xbox-next-panel-' + optionID).show();
toNext.idx = keyIdx;
renderNextBox();
}
else {
createNextPanel(nextItem, renderNextBox);
}
}
}
}
}
return that;
};
that.next = function (options) {
if (options) {
var optionID = options.id;
if (!optionID) {
//ID为必填
Module.Error('未指定ID[弹出框内容切换]');
return that;
}
var baseOptions = {};
//唯一ID
baseOptions.id = optionID;
//静态内容(显示级别：1)
baseOptions.content = options.content;
//目标元素(显示级别：2)
baseOptions.target = $(options.target);
//请求地址(显示级别：3)
baseOptions.url = options.url;
//提交数据
baseOptions.data = options.data;
//如果是url，加载类型(ajax||iframe)
baseOptions.loadType = options.loadType || 'ajax';
//请求一次，下次再打开这个地址时，则不再请求
baseOptions.isLoadOnce = isFalse(options.isLoadOnce) ? false : true;
//回调函数
baseOptions.callBack = options.callBack;
//ajax加载状态(0.初始||1.加载中||2.加载完成)
//baseOptions.loadStatus = 0;
//标题
baseOptions.title = options.title;
//按钮
baseOptions.buttons = options.buttons;
//form表单
baseOptions.form = null;
if (options.form) {
baseOptions.form = {
//提交地址
path: options.form.path,
//提交方式(POST||GET)
method: options.form.method || 'POST',
//提交类型(submit||ajax)
submitType: options.form.submitType || 'submit',
//提交前事件
submitBefore: options.form.submitBefore,
//提交失败(只针对ajax提交)
submitError: options.form.submitError,
//提交成功(只针对ajax提交)
submitSuccess: options.form.submitSuccess
};
}
var xboxContent = BoxModelInstance.element.content;
var boxNext = BoxModelInstance.next;
var renderCallBack = function () {
renderTitle(baseOptions.title);
var buttons = baseOptions.buttons, btnItem;
if (buttons) {
for (var key in buttons) {
btnItem = buttons[key];
for (var btnKey in btnItem) {
BoxModelInstance.buttons[key][btnKey] = btnItem[btnKey];
}
}
renderButton();
var customEvent = BoxModelInstance.customEvent;
if (customEvent) {
var nextEvent = customEvent.onNext;
if (nextEvent) {
nextEvent.call(that);
}
}
}
};
if (boxNext) {
var historyBoxNext = boxNext.list[optionID];
if (historyBoxNext) {
renderCallBack();
//如果已创建内容，直接显示
xboxContent.find('.J-xbox-next-panel').hide();
xboxContent.find('.J-xbox-next-panel-' + optionID).show();
BoxModelInstance.next.idx++;
if (options.callBack && isFunction(options.callBack)) {
options.callBack.call(that);
}
return that;
}
}
createNextPanel(baseOptions, renderCallBack);
}
else {
goToNext();
}
return that;
};
that.prev = function () {
that.goToNext(-1);
return that;
};
that.max = function () { };
that.reMax = function () { };
that.moveTo = function () { };
that.resizeBy = function () { };
that.alert = function (options, sure) {
var thisOptions = { message: '[空]', type: 'default', title: '提示消息', remark: '', sure: null };
if (isString(options)) {
thisOptions.message = options;
if (sure && isFunction(sure)) {
thisOptions.sure = sure;
}
}
else if (isJSON(options)) {
for (var key in options) {
thisOptions[key] = options[key];
}
}
var message = BoxConfigInstance.template.msgTip;
if (thisOptions.type == 'warn') {
thisOptions.type = 'warning';
}
message = message.replace('#-TYPE-#', thisOptions.type).replace('#-MESSAGE-#', thisOptions.message).replace('#-REMARK-#', thisOptions.remark);
BoxModelInstance.width = 360;
BoxModelInstance.height = 90;
BoxModelInstance.title = thisOptions.title;
BoxModelInstance.content = message;
BoxModelInstance.buttons.yes.callBack = thisOptions.sure;
//创建按钮
renderButton();
//设置标题
renderTitle();
//设置内容
renderContent();
renderButtonKey();
show();
};
that.success = function (options, sure) {
var thisOptions = { message: '[空]', type: 'success', title: '提示消息', remark: '', sure: null };
if (isString(options)) {
thisOptions.message = options;
if (sure && isFunction(sure)) {
thisOptions.sure = sure;
}
}
else if (isJSON(options)) {
for (var key in options) {
if (key != 'type') {
thisOptions[key] = options[key];
}
}
}
var message = BoxConfigInstance.template.msgTip;
message = message.replace('#-TYPE-#', thisOptions.type).replace('#-MESSAGE-#', thisOptions.message).replace('#-REMARK-#', thisOptions.remark);
BoxModelInstance.width = 360;
BoxModelInstance.height = 90;
BoxModelInstance.title = thisOptions.title;
BoxModelInstance.content = message;
BoxModelInstance.buttons.yes.callBack = thisOptions.sure;
//创建按钮
renderButton();
//设置标题
renderTitle();
//设置内容
renderContent();
renderButtonKey();
show();
};
that.warn = function (options, sure) {
var thisOptions = { message: '[空]', type: 'warning', title: '提示消息', remark: '', sure: null };
if (isString(options)) {
thisOptions.message = options;
if (sure && isFunction(sure)) {
thisOptions.sure = sure;
}
}
else if (isJSON(options)) {
for (var key in options) {
if (key != 'type') {
thisOptions[key] = options[key];
}
}
}
var message = BoxConfigInstance.template.msgTip;
message = message.replace('#-TYPE-#', thisOptions.type).replace('#-MESSAGE-#', thisOptions.message).replace('#-REMARK-#', thisOptions.remark);
BoxModelInstance.width = 360;
BoxModelInstance.height = 90;
BoxModelInstance.title = thisOptions.title;
BoxModelInstance.content = message;
BoxModelInstance.buttons.yes.callBack = thisOptions.sure;
//创建按钮
renderButton();
//设置标题
renderTitle();
//设置内容
renderContent();
renderButtonKey();
show();
};
that.help = function (options, sure) {
var thisOptions = { message: '[空]', type: 'help', title: '提示消息', remark: '', sure: null };
if (isString(options)) {
thisOptions.message = options;
if (sure && isFunction(sure)) {
thisOptions.sure = sure;
}
}
else if (isJSON(options)) {
for (var key in options) {
if (key != 'type') {
thisOptions[key] = options[key];
}
}
}
var message = BoxConfigInstance.template.msgTip;
message = message.replace('#-TYPE-#', thisOptions.type).replace('#-MESSAGE-#', thisOptions.message).replace('#-REMARK-#', thisOptions.remark);
BoxModelInstance.width = 360;
BoxModelInstance.height = 90;
BoxModelInstance.title = thisOptions.title;
BoxModelInstance.content = message;
BoxModelInstance.buttons.yes.callBack = thisOptions.sure;
//创建按钮
renderButton();
//设置标题
renderTitle();
//设置内容
renderContent();
renderButtonKey();
show();
};
that.prompt = function () { };
that.loading = function (options) {
var thisOptions = { message: '正在处理，请稍等...', type: 'loading', title: '', remark: '', timeout: 0, callBack: null };
if (isString(options)) {
thisOptions.message = options;
}
else if (isJSON(options)) {
for (var key in options) {
if (key != 'type') {
thisOptions[key] = options[key];
}
}
}
var message = BoxConfigInstance.template.msgTip;
message = message.replace('#-TYPE-#', thisOptions.type).replace('#-MESSAGE-#', thisOptions.message).replace('#-REMARK-#', thisOptions.remark);
BoxModelInstance.width = 200;
BoxModelInstance.height = 90;
BoxModelInstance.title = thisOptions.title;
BoxModelInstance.content = message;
BoxModelInstance.buttons.max.isShow = false;
BoxModelInstance.buttons.min.isShow = false;
BoxModelInstance.buttons.close.isShow = false;
BoxModelInstance.buttons.yes.isShow = false;
BoxModelInstance.buttons.no.isShow = false;
BoxModelInstance.buttons.cancel.isShow = false;
//创建按钮
renderButton();
//设置标题
renderTitle();
//设置内容
renderContent();
renderButtonKey();
show();
if (BoxModelInstance.loadingThread) {
window.clearTimeout(BoxModelInstance.loadingThread);
BoxModelInstance.loadingThread = null;
}
if (thisOptions.timeout) {
BoxModelInstance.loadingThread = window.setTimeout(function () {
if (thisOptions.callBack) {
thisOptions.callBack.call(that);
}
close();
}, thisOptions.timeout);
}
};
that.confirm = function (options, sure, cancel) {
var thisOptions = { message: '[空]', type: 'help', title: '确认消息', remark: '', sure: null, cancel: null };
if (isString(options)) {
thisOptions.message = options;
if (sure && isFunction(sure)) {
thisOptions.sure = sure;
}
if (cancel && isFunction(cancel)) {
thisOptions.cancel = cancel;
}
}
else if (isJSON(options)) {
for (var key in options) {
if (key != 'type') {
thisOptions[key] = options[key];
}
}
}
var message = BoxConfigInstance.template.msgTip;
message = message.replace('#-TYPE-#', thisOptions.type).replace('#-MESSAGE-#', thisOptions.message).replace('#-REMARK-#', thisOptions.remark);
BoxModelInstance.width = 360;
BoxModelInstance.height = 90;
BoxModelInstance.title = thisOptions.title;
BoxModelInstance.content = message;
BoxModelInstance.buttons.yes.callBack = thisOptions.sure;
BoxModelInstance.buttons.cancel.callBack = thisOptions.cancel;
//创建按钮
renderButton();
//设置标题
renderTitle();
//设置内容
renderContent();
renderButtonKey();
show();
};
that.onYes = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onYes'] = fun;
}
return that;
};
that.onNo = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onNo'] = fun;
}
return that;
};
that.onCancel = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onCancel'] = fun;
}
return that;
};
that.onClose = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onClose'] = fun;
}
return that;
};
that.onShow = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onShow'] = fun;
}
return that;
};
that.onNext = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onNext'] = fun;
}
return that;
};
that.onPrev = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onPrev'] = fun;
}
return that;
};
that.onLoad = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onLoad'] = fun;
}
return that;
};
that.onDrag = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onDrag'] = fun;
}
return that;
};
that.onDragMove = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onDragMove'] = fun;
}
return that;
};
that.onDragEnd = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onDragEnd'] = fun;
}
return that;
};
that.onClick = function (fun) {
if (fun) {
BoxModelInstance.customEvent = BoxModelInstance.customEvent || {};
BoxModelInstance.customEvent['onClick'] = fun;
}
return that;
};
install();
};
});
var scripts = $('script');
var i = 0, length = scripts.length, scriptTarget, dataPath, src;
for (; i < length; i++) {
targetScript = scripts.eq(i);
dataPath = targetScript.attr('data-path');
dataParent = targetScript.attr('data-parent') || 'pages';
if (dataPath) {
src = '/global/script/' + dataParent + '/' + dataPath + '.js';
Module.Require(src, true);
}
}
Reference in New Issue Copy Permalink