【JavaScript 封装库】BETA 4.0 测试版发布！

   1 /*
   2     源码作者: 石不易(Louis Shi)
   3     联系方式: http://www.shibuyi.net
   4     ===================================================================================================
   5     程序名称: JavaScript 封装库 BETA 4.0 版
   6     迭代版本: BETA 3.0
   7     插件总数: 12 个
   8     库方法数: 26 个
   9     功能总数: 67 个
  10     新增总数: 22 个
  11     删除总数: 3 个
  12     追加功能: 
  13         1. 进一步完善“获取元素节点”的功能, 包括: 前后位兄弟节点、子节点、父节点
  14         2. 新增“获取元素节点尺寸”, 可直接输出元素的宽高和坐标
  15         3. 库方法: 新增对 CSS 样式原生风格的解析, 支持 JavaScript 与 CSS 的两种; 例如: fontSize 也可写作 font-size
  16         4. 插件: 新增“元素动画”特效, 支持常规的宽高运动、坐标运动和透明度渐变; 另外也可自定义, 但必须要有对应像素单位的样式, 否则无效
  17         5. 插件: 新增“事件切换器”特效, 支持任意方法数, 点击元素后迭代切换事件
  18         ...
  19     优化功能: 
  20         1. 优化了 CSS 解析功能, 支持原生和 JavaScript 两种写法, 可任意混合搭配
  21         2. 优化了“移除样式规则”, 从原先的索引下标移除转变为直接输入对应选择器名称即可删除, 但 W3C 与 IE 6/7/8 在选择器多重叠加上的解释并不一致, 需谨慎使用
  22         2. 优化了“自动加载插件”, 载入插件时直接将插件方法名变量传入即可, 但不支持匿名函数赋值给变量后在传入的写法
  23         4. 插件: 优化了“元素居中”特效, 现已支持 3 种居中方式: 水平居中、垂直居中、水平+垂直居中
  24         ...
  25     删除功能: 
  26         1. 库方法: 删除了“初始化滚动条”方法, 今后直接通过“滚动条”方法设置即可
  27         2. 库方法: 删除了“CSS 处理”方法, 与“添加元素节点属性”结合, 无需再分离调用
  28         3. 库方法: 删除了“class 处理”方法, 与“添加元素节点属性”结合, 无需再分离调用
  29 */
  30 
  31 // 实例化基础库
  32 var $ = function () {
  33     var nodes = [];
  34     for (var i = 0; i < arguments.length; i ++) {
  35         nodes.push(arguments[i]);
  36     }
  37     return new Base(nodes);
  38 };
  39 
  40 // 基础库构造方法
  41 var Base = function (nodes) {
  42     this.info = ‘无节点‘;
  43     this.elements = [];
  44     if (nodes instanceof Array) {
  45         var node = null, patternSpace = /[\s\t　]+/, elements = [], elementsList = [];
  46         for (var i = 0; i < nodes.length; i ++) {
  47             node = nodes[i];
  48             if (typeof node == ‘string‘) { // 节点选择器
  49                 if ((node = Base.trim(node)) == ‘‘) continue;
  50                 if (patternSpace.test(node)) { // 多层
  51                     elements = node.split(patternSpace);
  52                 } else { // 单层
  53                     elements.push(node);
  54                 }
  55                 for (var j = 0; j < elements.length; j ++) {
  56                     if (this.selector(elements[j]).getNodes() == this.info) break;
  57                 }
  58                 for (var k = 0; k < this.elements.length; k ++) {
  59                     elementsList.push(this.elements[k]);
  60                 }
  61                 this.elements = [], elements = [];
  62             } else if (Base.checkNode(node) || node === window) {
  63                 elementsList.push(node);
  64             } else if (typeof node == ‘function‘) { // HTML DOM
  65                 this.loaded(node);
  66             }
  67         }
  68         this.elements = elementsList;
  69     }
  70 };
  71 
  72 // 元素节点选择器
  73 Base.prototype.selector = function (selector) {
  74     if (typeof selector != ‘string‘) {
  75         this.elements = [];
  76         return this;
  77     }
  78     selector = Base.trim(selector);
  79     var nodes = null, elements = [];
  80     if (this.elements.length == 0) this.elements.push(document);
  81     switch (selector.charAt(0)) {
  82         case ‘#‘ : // id
  83             selector = selector.substring(1);
  84             for (var i = 0; i < this.elements.length; i ++) {
  85                 if ((nodes = $().getId(selector, this.elements[i]).getNodes()) != this.info) elements.push(nodes);
  86             }
  87             break;
  88         case ‘.‘ : // class
  89             selector = selector.substring(1);
  90             for (var i = 0; i < this.elements.length; i ++) {
  91                 if ((nodes = $().getClass(selector, this.elements[i]).getNodes()) != this.info) {
  92                     if (nodes instanceof Array) { // 集群
  93                         for (var j = 0; j < nodes.length; j ++) {
  94                             elements.push(nodes[j]);
  95                         }
  96                     } else { // 单一
  97                         elements.push(nodes);
  98                     }
  99                 }
 100             }
 101             break;
 102         default : // tagName
 103             var patternId = /^(\w+)#([\-\w]+)$/i, patternClass = /^(\w+)\.([\-\w]+)$/i;
 104             if (patternId.test(selector)) { // tagName + id
 105                 var tagName = patternId.exec(selector)[1];
 106                 var id = patternId.exec(selector)[2];
 107                 for (var i = 0; i < this.elements.length; i ++) {
 108                     if ((nodes = $().getTagName(tagName, this.elements[i]).getNodes()) != this.info) {
 109                         if (nodes instanceof Array) { // 集群
 110                             for (var j = 0; j < nodes.length; j ++) {
 111                                 if (nodes[j].id == id) elements.push(nodes[j]);
 112                             }
 113                         } else { // 单一
 114                             if (nodes.id == id) elements.push(nodes);
 115                         }
 116                     }
 117                 }
 118             } else if (patternClass.test(selector)) { // tagName + class
 119                 var tagName = patternClass.exec(selector)[1];
 120                 var className = patternClass.exec(selector)[2];
 121                 for (var i = 0; i < this.elements.length; i ++) {
 122                     if ((nodes = $().getTagName(tagName, this.elements[i]).getNodes()) != this.info) {
 123                         if (nodes instanceof Array) { // 集群
 124                             for (var j = 0; j < nodes.length; j ++) {
 125                                 if (Base.hasClass(className, nodes[j])) elements.push(nodes[j]);
 126                             }
 127                         } else { // 单一
 128                             if (Base.hasClass(className, nodes)) elements.push(nodes);
 129                         }
 130                     }
 131                 }
 132             } else { // tagName
 133                 for (var i = 0; i < this.elements.length; i ++) {
 134                      if ((nodes = $().getTagName(selector, this.elements[i]).getNodes()) != this.info) {
 135                         if (nodes instanceof Array) { // 集群
 136                             for (var j = 0; j < nodes.length; j ++) {
 137                                 elements.push(nodes[j]);
 138                             }
 139                         } else { // 单一
 140                             elements.push(nodes);
 141                         }
 142                      }
 143                 }
 144             }
 145     }
 146     this.elements = elements;
 147     return this;
 148 };
 149 
 150 // 获取 id 元素节点
 151 Base.prototype.getId = function (ids, positioner) {
 152     if (ids instanceof Array) { // 集群
 153         for (var i = 0; i < ids.length; i ++) {
 154             this.getId(ids[i], positioner);
 155         }
 156     } else { // 单一
 157         for (var k = 0; k < this.elements.length; k ++) {
 158             if (this.elements[k].id == ids) return this;
 159         }
 160         var selector = null, node = null;
 161         selector = Base.targetNode(positioner);
 162         if (selector === false) return this;
 163         if (selector instanceof Array) { // 集群
 164             for (var i = 0; i < selector.length; i ++) {
 165                 node = selector[i].getElementsByTagName(‘*‘);
 166                 for (var j = 0; j < node.length; j ++) {
 167                     if (node[j].id == ids) {
 168                         this.elements.push(node[j]);
 169                     }
 170                 }
 171             }
 172         } else { // 单一
 173             node = selector.getElementsByTagName(‘*‘);
 174             for (var i = 0; i < node.length; i ++) {
 175                 if (node[i].id == ids) this.elements.push(node[i]);
 176             }
 177         }
 178     }
 179     return this;
 180 };
 181 
 182 // 获取 tagName 元素节点
 183 Base.prototype.getTagName = function (tagName, positioner) {
 184     var selector  = null, node = null;
 185     selector = Base.targetNode(positioner);
 186     if (selector === false) return this;
 187     if (selector instanceof Array) { // 集群
 188         for (var i = 0; i < selector.length; i ++) {
 189             node = selector[i].getElementsByTagName(tagName);
 190             for (var j = 0; j < node.length; j ++) {
 191                 this.elements.push(node[j]);
 192             }
 193         }
 194     } else { // 单一
 195         node = selector.getElementsByTagName(tagName);
 196         for (var i = 0; i < node.length; i ++) {
 197             this.elements.push(node[i]);
 198         }
 199     }
 200     return this;
 201 };
 202 
 203 // 获取 class 元素节点
 204 Base.prototype.getClass = function (className, positioner) {
 205     var selector = null, node = null;
 206     selector = Base.targetNode(positioner);
 207     if (selector === false) return this;
 208     if (selector instanceof Array) { // 集群
 209         for (var i = 0; i < selector.length; i ++) {
 210             node = selector[i].getElementsByTagName(‘*‘);
 211             for (var j = 0; j < node.length; j ++) {
 212                 if (Base.hasClass(className, node[j])) this.elements.push(node[j]);
 213             }
 214         }
 215     } else { // 单一
 216         node = selector.getElementsByTagName(‘*‘);
 217         for (var i = 0; i < node.length; i ++) {
 218             if (Base.hasClass(className, node[i])) this.elements.push(node[i]);
 219         }
 220     }
 221     return this;
 222 };
 223 
 224 // 获取 name 元素节点
 225 Base.prototype.getName = function (name, positioner) {
 226     var selector = null, node= null;
 227     selector = Base.targetNode(positioner);
 228     if (selector === false) return this;
 229     if (selector instanceof Array) { // 集群
 230         for (var i = 0; i < selector.length; i ++) {
 231             node = selector[i].getElementsByTagName(‘*‘);
 232             for (var j = 0; j < node.length; j ++) {
 233                 if (node[j].name == name) this.elements.push(node[j]);
 234             }
 235         }
 236     } else { // 单一
 237         node = selector.getElementsByTagName(‘*‘);
 238         for (var i = 0; i < node.length; i ++) {
 239             if (node[i].name == name) this.elements.push(node[i]);
 240         }
 241     }
 242     return this;
 243 };
 244 
 245 // 返回元素节点
 246 Base.prototype.getNodes = function () {
 247     if (this.elements.length == 0) return this.info;
 248     if (this.elements.length == 1) return this.elements[0];
 249     return this.elements;
 250 };
 251 
 252 // 返回第一个元素节点
 253 Base.prototype.firstNode = function () {
 254     if (this.elements.length == 0) return this.info;
 255     return this.elements[0];
 256 };
 257 
 258 // 返回最后一个元素节点
 259 Base.prototype.lastNode = function () {
 260     if (this.elements.length == 0) return this.info;
 261     return this.elements[this.elements.length - 1];
 262 };
 263 
 264 // 获取第一个子元素节点
 265 Base.prototype.firstChild = function () {
 266     var childs = [];
 267     var length = this.elements.length - 1;
 268     for (var i = length; i >= 0; i --) {
 269         Base.space(Base.comment(this.elements[i]));
 270         if (!(childs = Base.getChilds(this.elements[i]))) {
 271             this.elements.splice(i, 1);
 272             continue;
 273         }
 274         this.elements[i] = childs[0];
 275     }
 276     return this;
 277 };
 278 
 279 // 获取最后一个子元素节点
 280 Base.prototype.lastChild = function () {
 281     var childs = [];
 282     var length = this.elements.length - 1;
 283     for (var i = length; i >= 0; i --) {
 284         Base.space(Base.comment(this.elements[i]));
 285         if (!(childs = Base.getChilds(this.elements[i]))) {
 286             this.elements.splice(i, 1);
 287             continue;
 288         }
 289         this.elements[i] = childs[childs.length - 1];
 290     }
 291     return this;
 292 };
 293 
 294 // 获取子元素节点
 295 Base.prototype.childNodes = function () {
 296     var childs = [];
 297     var length = this.elements.length - 1;
 298     for (var i = length; i >= 0; i --) {
 299         Base.space(Base.comment(this.elements[i]));
 300         childs = Base.getChilds(this.elements[i])
 301         this.elements.splice(i, 1);
 302         if (!childs) continue;
 303         for (var j = 0; j < childs.length; j ++) {
 304             this.elements.splice(i + j, 0, childs[j]);
 305         }
 306     }
 307     return this;
 308 };
 309 
 310 // 获取上一位兄弟节点
 311 Base.prototype.previousNode = function () {
 312     var length = this.elements.length - 1;
 313     for (var i = length; i >= 0; i --) {
 314         Base.space(Base.comment(this.elements[i].parentNode));
 315         if (!(this.elements[i] = Base.siblingNode(this.elements[i], false))) this.elements.splice(i, 1);
 316     }
 317     return this;
 318 };
 319 
 320 // 获取下一位兄弟节点
 321 Base.prototype.nextNode = function () {
 322     var length = this.elements.length - 1;
 323     for (var i = length; i >= 0; i --) {
 324         Base.space(Base.comment(this.elements[i].parentNode));
 325         if (!(this.elements[i] = Base.siblingNode(this.elements[i], true))) this.elements.splice(i, 1);
 326     }
 327     return this;
 328 };
 329 
 330 // 获取之前所有兄弟节点
 331 Base.prototype.previousAllNode = function () {
 332     var length = this.elements.length - 1;
 333     var siblings = [];
 334     for (var i = length; i >= 0; i --) {
 335         Base.space(Base.comment(this.elements[i].parentNode));
 336         if (!(this.elements[i] = Base.siblingNode(this.elements[i], false))) {
 337             this.elements.splice(i, 1);
 338             for (var j = 0; j < siblings.length; j ++) {
 339                 this.elements.splice(i + j, 0, siblings[j]);
 340             }
 341             siblings = [];
 342         } else {
 343             siblings.push(this.elements[i]);
 344             i ++;
 345         }
 346     }
 347     return this;
 348 };
 349 
 350 // 获取之后所有兄弟节点
 351 Base.prototype.nextAllNode = function () {
 352     var length = this.elements.length - 1;
 353     var siblings = [];
 354     for (var i = length; i >= 0; i --) {
 355         Base.space((Base.comment(this.elements[i].parentNode)));
 356         if (!(this.elements[i] = Base.siblingNode(this.elements[i]))) {
 357             this.elements.splice(i, 1);
 358             for (var j = 0; j < siblings.length; j ++) {
 359                 this.elements.splice(i + j, 0, siblings[j]);
 360             }
 361             siblings = [];
 362         } else {
 363             siblings.push(this.elements[i]);
 364             i ++;
 365         }
 366     }
 367     return this;
 368 };
 369 
 370 // 获取父级元素节点
 371 Base.prototype.parentNode = function () {
 372     var length = this.elements.length - 1;
 373     for (var i = length; i >= 0; i --) {
 374         if (!Base.checkNode(this.elements[i]) || this.elements[i].parentNode === null) {
 375             this.elements.splice(i, 1);
 376             continue;
 377         }
 378         this.elements[i] = this.elements[i].parentNode;
 379     }
 380     return this;
 381 };
 382 
 383 // 设置与获取元素内容
 384 Base.prototype.html = function (text) {
 385     var html = [];
 386     for (var i = 0; i < this.elements.length; i ++) {
 387         if (typeof text != ‘undefined‘) { // 设置
 388             this.elements[i].innerHTML = text;
 389         } else { // 获取
 390             html.push(this.elements[i].innerHTML);
 391         }
 392     }
 393     switch (html.length) {
 394         case 0 :
 395             return this;
 396             break;
 397         case 1 :
 398             return html[0];
 399             break;
 400         default : 
 401             return html;
 402     }
 403 };
 404 
 405 // 设置与获取表单内容
 406 Base.prototype.value = function (text) {
 407     var value = [];
 408     for (var i = 0; i < this.elements.length; i ++) {
 409         if (typeof this.elements[i].value == ‘undefined‘) continue;
 410         if (typeof text != ‘undefined‘) { // 设置
 411             this.elements[i].value = text;
 412         } else { // 获取
 413             value.push(this.elements[i].value);
 414         }
 415     }
 416     switch (value.length) {
 417         case 0 :
 418             return this;
 419             break;
 420         case 1 :
 421             return value[0];
 422             break;
 423         default : 
 424             return value;
 425     }
 426 };
 427 
 428 // 设置与获取元素样式
 429 Base.prototype.css = function (cssKey, cssValue) {
 430     var css = [], isList = false;
 431     var patternCss = /^([a-z\-\s]+)([\s\t　]*)(=|:)\2([\s\w\-\.\\\/\‘\"#%\(\)=]+);?$/i;
 432     var key = ‘‘, value = ‘‘;
 433     cssValue = Base.trim(cssValue);
 434     if (!(isList = cssKey instanceof Array)) cssKey = Base.trim(cssKey); 
 435     for (var i = 0; i < this.elements.length; i ++) {
 436         if (typeof cssValue != ‘undefined‘ || isList) { // 设置
 437             if (isList) { // 集群
 438                 for (var j = 0; j < cssKey.length; j ++) {
 439                     cssKey[j] = Base.trim(cssKey[j]);
 440                     if (patternCss.test(cssKey[j])) {
 441                         key = Base.toStyle(Base.trim(patternCss.exec(cssKey[j])[1]));
 442                         value = Base.trim(patternCss.exec(cssKey[j])[4]);
 443                         this.elements[i].style[key] = value;
 444                     }
 445                 }
 446             } else { // 单一
 447                 cssKey = Base.toStyle(Base.trim(cssKey));
 448                 this.elements[i].style[cssKey] = cssValue;
 449             }
 450         } else { // 获取
 451             css.push(Tool.getStyle(cssKey, this.elements[i]));
 452         }
 453     }
 454     switch (css.length) {
 455         case 0 :
 456             return this;
 457             break;
 458         case 1 : 
 459             return css[0];
 460             break;
 461         default : 
 462             return css;
 463     }
 464 };
 465 
 466 // 添加 class 选择器
 467 Base.prototype.addClass = function (className) {
 468     if (typeof className == ‘undefined‘) return this;
 469     className = Base.trim(className);
 470     if (arguments.length == 1) { // 单一
 471         var space = ‘‘;
 472         for (var i = 0; i < this.elements.length; i ++) {
 473             if (this.elements[i].className != ‘‘) space = ‘ ‘;
 474             if (!Base.hasClass(className, this.elements[i])) this.elements[i].className += space + className;
 475             space = ‘‘;
 476         }
 477     } else { // 集群
 478         for (var i = 0; i < arguments.length; i ++) {
 479             this.addClass(arguments[i]);
 480         }
 481     }
 482     return this;
 483 };
 484 
 485 // 移除 class 选择器
 486 Base.prototype.removeClass = function (className) {
 487     if (typeof className == ‘undefined‘) return this;
 488     className = Base.trim(className);
 489     if (arguments.length == 1) { // 单一
 490         for (var i = 0; i < this.elements.length; i ++) {
 491             if (Base.hasClass(className, this.elements[i])) {
 492                 this.elements[i].className = this.elements[i].className.replace(new RegExp(‘(^|\\s+)‘ + className + ‘(\\s+|$)‘), ‘ ‘);
 493                 this.elements[i].className = Base.trim(this.elements[i].className);
 494             }
 495         }
 496     } else { // 集群
 497         for (var i = 0; i < arguments.length; i ++) {
 498             this.removeClass(arguments[i]);
 499         }
 500     }
 501     return this;
 502 };
 503 
 504 // 添加样式规则
 505 Base.prototype.addRule = function (ruleName, ruleText, positioner, sheetIndex) {
 506     var rule = null;
 507     if (!(rule = Base.checkRule(positioner, sheetIndex))) return this;
 508     if (ruleName instanceof Array) { // 集群
 509         var patternRule = /^([\w\-#\.:,\s]+)[\s\t　]*\{([\s\w\-\.\\\/\‘\"#%\(\)=:;]+)\}$/i;
 510         var _rule = null;
 511         for (var i = 0; i < ruleName.length; i ++) {
 512             _rule = Base.trim(ruleName[i]);
 513             if (patternRule.test(_rule)) {
 514                 this.addRule(patternRule.exec(_rule)[1], patternRule.exec(_rule)[2], positioner, sheetIndex);
 515             }
 516         }
 517     } else { // 单一
 518         ruleText = Base.trim(ruleText);
 519         if (ruleName.indexOf(‘,‘) != -1) {
 520             ruleName = ruleName.split(‘,‘);
 521             for (var i = 0 ; i < ruleName.length; i ++) {
 522                 ruleName[i] = Base.trim(ruleName[i]);
 523                 if (ruleName[i] == ‘‘) continue;
 524                 Tool.addRule(rule.sheet, ruleName[i], ruleText, rule.positioner);
 525             }
 526         } else {
 527             ruleName = Base.trim(ruleName);
 528             if (ruleName == ‘‘) return this;
 529             Tool.addRule(rule.sheet, ruleName, ruleText, rule.positioner);
 530         }
 531     }
 532     return this;
 533 };
 534 
 535 // 移除样式规则
 536 Base.prototype.removeRule = function (ruleName, sheetIndex) {
 537     var rule = null;
 538     if (!(rule = Base.checkRule(null, sheetIndex))) return this;
 539     if (ruleName instanceof Array) { // 集群
 540         for (var i = 0; i < ruleName.length; i ++) {
 541             this.removeRule(ruleName[i], sheetIndex);
 542         }
 543     } else { // 单一
 544         var nameList = Tool.ruleName(rule.sheet);
 545         ruleName = Base.trim(ruleName.toLowerCase());
 546         var patternName = ‘‘;
 547         switch (ruleName.charAt(0)) {
 548             case ‘#‘ : // id
 549                 patternName = ‘(^|\\s+|[a-z]+)‘ + ruleName + ‘(:[a-z]+)*($|,)‘;
 550                 break;
 551             case ‘.‘ : // class
 552                 patternName = ‘(^|\\s+|[a-z]+)‘ + ruleName + ‘(:[a-z]+)*($|,)‘;
 553                 break;
 554             default : // tagName
 555                 patternName = ‘(^|\\s+)‘ + ruleName + ‘(:[a-z]+)*($|,)‘;
 556                 break;
 557         }
 558         for (var i = nameList.length - 1; i >= 0; i --) {
 559             nameList[i] = Base.trim(nameList[i].toLowerCase());
 560             if ((new RegExp(patternName, ‘i‘)).test(nameList[i])) Tool.removeRule(rule.sheet, i);
 561         }
 562     }
 563     return this;
 564 };
 565 
 566 // 获取元素尺寸信息
 567 Base.prototype.getSize = function () {
 568     var elementNode = null, innerRectangle = null, outerRectangle = null, size = [];
 569     for (var i = 0; i < this.elements.length; i ++)    {
 570         elementNode = this.elements[i];
 571         innerRectangle = Base.getInnerRectangle(elementNode);
 572         outerRectangle = Base.getOuterRectangle(elementNode);
 573         size.push({
 574             width : innerRectangle.width,
 575             height : innerRectangle.height,
 576             x : outerRectangle.left,
 577             y : outerRectangle.top
 578         });
 579     }
 580     switch (size.length) {
 581         case 0 : 
 582             return this;
 583             break;
 584         case 1 :
 585             return size[0];
 586             break;
 587         default : 
 588             return size;
 589     }
 590 };
 591 
 592 // 元素事件绑定
 593 Base.prototype.nodeEvent = function (eventName, method, mode) {
 594     if (typeof eventName != ‘string‘ || typeof method != ‘function‘) return this;
 595     eventName = eventName.toLowerCase();
 596     if (eventName.indexOf(‘on‘) == 0) eventName = eventName.substring(2);
 597     if (typeof mode == ‘undefined‘) mode = true;
 598     for (var i = 0; i < this.elements.length; i ++) {
 599         switch (eventName) {
 600             case ‘scroll‘ : // 滚动条事件
 601                 Tool.scroll(this.elements[i], method, !!mode);
 602                 break;
 603             case ‘mousewheel‘ : // 鼠标滚轮事件
 604                 Tool.mousewheel(this.elements[i], method, !!mode);
 605                 break;
 606             case ‘mouseover‘ : // 鼠标移入
 607                 Tool.mouseover(this.elements[i], method, !!mode);
 608                 break;
 609             case ‘mouseout‘ : // 鼠标移出
 610                 Tool.mouseout(this.elements[i], method, !!mode);
 611                 break;
 612             default : // 其他事件
 613                 !!mode ? Tool.loginEvent(this.elements[i], eventName, method) : Tool.logoutEvent(this.elements[i], eventName, method);
 614         }
 615     }
 616     return this;
 617 };
 618 
 619 // HTML DOM 加载
 620 Base.prototype.loaded = function (method) {
 621     if (typeof method != ‘function‘) return this;
 622     Tool.loaded(method);
 623     return this;
 624 };
 625 
 626 // 自动加载插件
 627 Base.prototype.plugins = function () {
 628     var plugins = arguments;
 629     if (plugins.length != 0) {
 630         var pluginName = ‘‘;
 631         for (var i = 0; i < plugins.length; i ++) {
 632             if (!(pluginName = Base.getMethodName(plugins[i]))) continue;
 633             Base.prototype[pluginName] = plugins[i];
 634         }
 635     }
 636     return this;
 637 };
 638 
 639 /*
 640     库方法集合
 641 */
 642 // 库方法: 检测元素内容是否为空
 643 Base.empty = function (elementNode) {
 644     elementNode = this.comment(elementNode);
 645     var text = this.trim($(elementNode).html());
 646     return text == ‘‘;
 647 };
 648 
 649 // 库方法: 获取方法名称
 650 Base.getMethodName = function (method) {
 651     var patternMethodName  = /^function\s([\$\w]+)\(/i;
 652     if (typeof method != ‘function‘ || !patternMethodName.test(method.toString())) return false;
 653     return patternMethodName.exec(method.toString())[1];
 654 };
 655 
 656 // 库方法: 禁止页面滚动(浏览器 BUG 修正)
 657 Base.fixed = function (elementNode) {
 658     // 兼容 IE
 659     $(elementNode).nodeEvent(‘mousedown‘, function () {
 660         var scroll = Base.scroll();
 661         $(document.documentElement).nodeEvent(‘mouseup‘, function () {
 662             Base.scroll(scroll.x, scroll.y);
 663             $(this).nodeEvent(‘mouseup‘, arguments.callee, false);
 664         });
 665     });
 666     // 兼容 Chrome
 667     $(elementNode).nodeEvent(‘mousewheel‘, function () {});
 668 };
 669 
 670 // 库方法: 动画参数容错处理
 671 Base.checkAnimation = function (animation, elementNode) {
 672     // 动画参数对象容错处理
 673     if (typeof animation != ‘object‘) return false;
 674     
 675     // 动画缓冲开关容错处理
 676     if (typeof animation.isBuffer != ‘undefined‘) {
 677         animation.isBuffer = !!animation.isBuffer;
 678     } else {
 679         animation.isBuffer = false;
 680     }
 681     
 682     // 动画缓冲速率容错处理
 683     animation.speed = Math.abs(this.number(animation.speed, 20));
 684     
 685     // 动画迭代毫秒数容错处理
 686     animation.time = Math.abs(this.number(animation.time, 30));
 687     
 688     // 动画列队容错处理
 689     if (typeof animation.method != ‘function‘) {
 690         animation.method = function () {};
 691     }
 692     
 693     // 动画增减量容错处理
 694     animation.value = this.number(animation.value, false);
 695     
 696     // 动画步长值容错处理
 697     animation.step = Math.abs(this.number(animation.step, 10));
 698     
 699     // 同步动画容错处理
 700     if (typeof animation.multiple != ‘object‘) animation.multiple = {};
 701     
 702     function checkAction(action) {
 703         if (typeof action != ‘string‘) return false;
 704         action = Base.trim(action.toLowerCase());
 705         switch (action) {
 706             case ‘x‘ : 
 707             case ‘l‘ :
 708                 action = ‘left‘;
 709                 break;
 710             case ‘y‘ :
 711             case ‘t‘ :
 712                 action = ‘top‘;
 713                 break;
 714             case ‘w‘ :
 715                 action = ‘width‘;
 716                 break;
 717             case ‘h‘ :
 718                 action = ‘height‘;
 719                 break;
 720             case ‘o‘ :
 721                 action = ‘opacity‘;
 722                 break;
 723             default :
 724                 action = Base.toStyle(action);
 725         }
 726         return action;
 727     }
 728     
 729     function checkStart(start, action) {
 730         start = Base.trim(start);
 731         return Base.number(start, function () {
 732             if (/^(left)|(top)$/.test(action))     Base.absolute(elementNode);
 733             if (action == ‘opacity‘) {
 734                 if (browserDetect.ie && browserDetect.browser.version < 9) {
 735                     var opacity = Base.trim($(elementNode).css(‘filter‘));
 736                     var patternOpacity = /alpha\(opacity([\s\t　]*)=\1(\d+)\)/i;
 737                     if (patternOpacity.test(opacity)) {
 738                         return patternOpacity.exec(opacity)[2];
 739                     } else {
 740                         return 100;
 741                     }
 742                 } else {
 743                     return $(elementNode).css(‘opacity‘) * 100;
 744                 }
 745             } else {
 746                 return parseInt(Base.replace($(elementNode).css(action), ‘px‘));
 747             }
 748         });
 749     }
 750     
 751     function checkTarget(target) {
 752         target = Base.trim(target);
 753         return Base.number(target, function () {
 754             return animation.value === false ? animation.value : animation.start + animation.value;
 755         });
 756     }
 757     
 758     function checkOpacity(value) {
 759         if (value < 0) value = 0;
 760         if (value > 100) value = 100;
 761         return value;
 762     }
 763     
 764     for (var key in animation.multiple) {}
 765     
 766     // 检测是否同步动画
 767     if (typeof key == ‘undefined‘) { // 单一动画
 768         
 769         // 动画运动方式容错处理
 770         animation.action = checkAction(animation.action);
 771         
 772         if (animation.action === false) return false;
 773         
 774         // 动画初始值容错处理
 775         animation.start = checkStart(animation.start, animation.action);
 776         
 777         // 动画目标量容错处理
 778         animation.target = checkTarget(animation.target);
 779         
 780         if (animation.action == ‘opacity‘) {
 781             animation.start = checkOpacity(animation.start);
 782             animation.target = checkOpacity(animation.target);
 783         }
 784         if (animation.target === false || animation.start == animation.target) return false;
 785         
 786         if (animation.start > animation.target) animation.step = -animation.step;
 787         
 788         // 容错机制
 789         if (animation.start == 0) animation.start = 1;
 790         
 791         animation.action = [animation.action];
 792         animation.start = [animation.start];
 793         animation.target = [animation.target];
 794         animation.step = [animation.step];
 795     } else { // 同步动画
 796         // 遍历同步动画
 797         animation.action = [];
 798         animation.start = [];
 799         animation.target = [];
 800         var id = 0, value = ‘‘, patternValue = /^([\d\.]+)([\s\t　]*)=>\2([\d\.]+)$/;
 801         var action = ‘‘, start = 0, target = 0, step = animation.step;
 802         animation.step = [];
 803         for (var i in animation.multiple) {
 804             value = Base.trim(animation.multiple[i]);
 805             action = checkAction(i);
 806             if (patternValue.test(value)) { // 初始值 + 目标量
 807                 start = checkStart(patternValue.exec(value)[1], action);
 808                 target = checkTarget(patternValue.exec(value)[3]);
 809             } else { // 目标量
 810                 start = checkStart(null, action);
 811                 target = checkTarget(value);
 812             }
 813             if (action == ‘opacity‘) {
 814                 start = checkOpacity(start);
 815                 target = checkOpacity(target);
 816             }
 817             if (target === false || target == start) continue;
 818             
 819             // 容错机制
 820             if (start == 0) start = 1;
 821         
 822             animation.action[id] = action;
 823             animation.start[id] = start;
 824             animation.target[id] = target;
 825             animation.step[id] = start > target ? -step : step;
 826             id ++;
 827         }
 828     }
 829     return animation;
 830 };
 831 
 832 // 库方法: 数字转换
 833 Base.number = function (number, replace) {
 834     if (typeof number != ‘undefined‘ && !isNaN(parseInt(number))) {
 835         return parseInt(number);
 836     } else {
 837         switch (typeof replace) {
 838             case ‘undefined‘ :
 839                 return 0;
 840                 break;
 841             case ‘function‘ : 
 842                 return replace();
 843                 break;
 844             default : 
 845                 return replace;
 846         }
 847     }
 848 };
 849 
 850 // 库方法: 添加元素节点属性
 851 Base.attribute = function (attributes, elementNode) {
 852     if (attributes instanceof Array) { // 集群
 853         for (var i = 0; i < attributes.length; i ++) {
 854             this.attribute(attributes[i], elementNode);
 855         }
 856     } else { // 单一
 857         attributes = this.trim(attributes);
 858         var patternAttribute = /^([a-z]+)([\s\t　]*)=\2([=\w\‘\":;\.\\\/\-%#\(\)\s]+)$/i, key = ‘‘, value = ‘‘;
 859         if (patternAttribute.test(attributes)) {
 860             key = patternAttribute.exec(attributes)[1];
 861             value = patternAttribute.exec(attributes)[3];
 862             if (/^class(Name)?$/i.test(key)) { // class
 863                 var patternSpace = /[\s\t　]+/;
 864                 if (patternSpace.test(value)) { // 集群
 865                     var valueList = value.split(patternSpace);
 866                     for (var i = 0; i < valueList.length; i ++) {
 867                         if (valueList[i] == ‘‘) continue;
 868                         $(elementNode).addClass(valueList[i]);
 869                     }
 870                 } else { // 单一
 871                     $(elementNode).addClass(value);
 872                 }
 873             } else if (key == ‘style‘) { // css
 874                 var patternSpace = /;[\s\t　]*/;
 875                 if (patternSpace.test(value)) { // 集群
 876                     var valueList = value.split(patternSpace);
 877                     $(elementNode).css(valueList);
 878                 } else { // 单一
 879                     $(elementNode).css([value]);
 880                 }
 881             } else {
 882                 elementNode.setAttribute(key, value);
 883             }
 884         }
 885     }
 886     return elementNode;
 887 };
 888 
 889 // 库方法: 获取元素兄弟节点
 890 Base.siblingNode = function (elementNode, siblingMode) {
 891     if (!this.checkNode(elementNode) && elementNode.nodeType != 3) return false;
 892     if (typeof siblingMode == ‘undefined‘) siblingMode = true;
 893     siblingNode = !!siblingMode ? elementNode.nextSibling : elementNode.previousSibling;
 894     if (siblingNode === null) {
 895         return false;
 896     } else if (siblingNode.nodeType != 1) {
 897         return this.siblingNode(siblingNode, siblingMode);
 898     } else {
 899         return siblingNode;
 900     }
 901 };
 902 
 903 // 库方法: 添加节点对象
 904 Base.addElement = function (elementName, attributes, htmlText, elementTarget) {
 905     if (typeof elementName != ‘string‘) return false;
 906     var elementNode = document.createElement(elementName);
 907     if (typeof attributes == ‘string‘ || attributes instanceof Array) this.attribute(attributes, elementNode);
 908     if (typeof htmlText != ‘undefined‘ && htmlText !== null) $(elementNode).html(htmlText);
 909     if (typeof elementTarget == ‘undefined‘ || !(elementTarget = this.targetNode(elementTarget))) elementTarget = document.body;
 910     var nodes = [];
 911     if (elementTarget instanceof Array) { // 集群
 912         for (var i = 0; i < elementTarget.length; i ++) {
 913             nodes.push(elementTarget[i].appendChild(elementNode.cloneNode(true)));
 914         }
 915     } else { // 单一
 916         nodes.push(elementTarget.appendChild(elementNode));
 917     }
 918     return nodes.length == 1 ? nodes[0] : nodes;
 919 };
 920 
 921 // 库方法: 移除节点对象
 922 Base.removeElement = function (elementNode, elementTarget) {
 923     if (typeof elementNode == ‘undefined‘ || (!(elementNode instanceof Array) && !(elementNode = this.targetNode(elementNode)))) return false;
 924     if (typeof elementTarget == ‘undefined‘ || (!(elementTarget instanceof Array) && !(elementTarget = this.targetNode(elementTarget)))) elementTarget = false;
 925     if (elementTarget instanceof Array) {
 926         for (var i = 0; i < elementTarget.length; i ++) {
 927             this.removeElement(elementNode, elementTarget[i]);
 928         }
 929     } else {
 930         if (elementNode instanceof Array) {
 931             for (var i = 0; i < elementNode.length; i ++) {
 932                 this.removeElement(elementNode[i], elementTarget);
 933             }
 934         } else {
 935             if (elementTarget === false) elementTarget = elementNode.parentNode;
 936             if (this.contains(elementNode, elementTarget)) elementTarget.removeChild(elementNode);
 937         }
 938     }
 939 };
 940 
 941 // 库方法: 元素直接从属关系
 942 Base.contains = function (elementNode, elementTarget) {
 943     if (!this.checkNode(elementNode) || !this.checkNode(elementTarget)) return false;
 944     var children = elementTarget.childNodes;
 945     for (var i = 0; i < children.length; i ++) {
 946         if (children[i] == elementNode) return true;
 947     }
 948     return false;
 949 };
 950 
 951 // 库方法: 获取浏览器可视区域大小
 952 Base.getWindowRectangle = function () {
 953     return {
 954         width : Tool.getWindowWidth(),
 955         height : Tool.getWindowHeight()
 956     }
 957 };
 958 
 959 // 库方法: 获取元素内部区域大小
 960 Base.getInnerRectangle = function (elementNode) {
 961     var _this = $(elementNode);
 962     var display = _this.css(‘display‘);
 963     var width = 0, height = 0;
 964     if (display != ‘none‘) {
 965         width = elementNode.offsetWidth;
 966         height = elementNode.offsetHeight;
 967     } else {
 968         width = this.number(this.replace(_this.css(‘width‘), ‘px‘));
 969         height = this.number(this.replace(_this.css(‘height‘), ‘px‘));
 970     }
 971     return {
 972         width : width,
 973         height : height
 974     }
 975 };
 976 
 977 // 库方法: 获取元素外部区域大小
 978 Base.getOuterRectangle = function (elementNode) {
 979     var _this = $(elementNode);
 980     var display = _this.css(‘display‘);
 981     var left = 0, top = 0;
 982     if (display != ‘none‘) {
 983         left = elementNode.offsetLeft;
 984         top = elementNode.offsetTop;
 985     } else {
 986         this.absolute(elementNode);
 987         left = this.number(this.replace(_this.css(‘left‘), ‘px‘));
 988         top = this.number(this.replace(_this.css(‘top‘), ‘px‘));
 989     }
 990     return {
 991         left : left,
 992         top : top
 993     }
 994 };
 995 
 996 // 库方法: 设置元素绝对定位
 997 Base.absolute = function (elementNode) {
 998     var _this = $(elementNode);
 999     if (_this.css(‘position‘) == ‘static‘) _this.css(‘position‘, ‘absolute‘);
1000 };
1001 
1002 // 库方法: 样式风格转换
1003 Base.toStyle = function (cssKey) {
1004     if (typeof cssKey != ‘string‘) return cssKey;
1005     if (cssKey.indexOf(‘-‘) != -1) {
1006         var keyList = cssKey.split(‘-‘);
1007         for (var i = 0; i < keyList.length; i ++) {
1008             if ((keyList[i] = Base.trim(keyList[i])) == ‘‘) continue;
1009             if (i == 0) {
1010                 cssKey = keyList[i];
1011             } else {
1012                 cssKey += keyList[i].charAt(0).toUpperCase() + keyList[i].substring(1);
1013             }
1014         }
1015     }
1016     return cssKey;
1017 };
1018 
1019 // 库方法: 获取目标节点
1020 Base.targetNode = function (positioner) {
1021     var selector = null;
1022     if (typeof positioner != ‘undefined‘) { // 局部
1023         if (this.checkNode(positioner)) {
1024             selector = positioner;
1025         } else {
1026             if (!(selector = this.positioner(positioner))) return false;
1027         }
1028     } else { // 全局
1029         selector = document;
1030     }
1031     return selector;
1032 };
1033 
1034 // 库方法: 获取与设置浏览器滚动条
1035 Base.scroll = function (x, y) {
1036     if (typeof x == ‘number‘) {
1037         Tool.scrollX(Math.abs(parseInt(x)));
1038     }
1039     if (typeof y == ‘number‘) {
1040         Tool.scrollY(Math.abs(parseInt(y)));
1041     }
1042     return {
1043         x : Tool.scrollX(),
1044         y : Tool.scrollY()
1045     }
1046 };
1047 
1048 // 库方法: 检测样式规则参数
1049 Base.checkRule = function (positioner, sheetIndex) {
1050     var sheets = document.styleSheets;
1051     if (typeof positioner == ‘undefiend‘ || isNaN(positioner)) positioner = 0;
1052     if (typeof sheetIndex == ‘undefined‘ || isNaN(sheetIndex)) sheetIndex = 0;
1053     if (sheetIndex >= sheets.length) sheetIndex = sheets.length - 1;
1054     sheetIndex = Math.abs(parseInt(sheetIndex));
1055     positioner = Math.abs(parseInt(positioner));
1056     if (typeof sheets[sheetIndex] == ‘undefined‘ || typeof sheets[sheetIndex] == ‘unknown‘) return false;
1057     var sheet = sheets[sheetIndex];
1058     var positionerMax = Tool.ruleTotal(sheet) - 1;
1059     if (positioner > positionerMax) positioner = positionerMax;
1060     return {
1061         positioner : positioner,
1062         sheet : sheet
1063     }
1064 };
1065 
1066 // 库方法: 检测 class
1067 Base.hasClass = function (className, elementNode) {
1068     return (new RegExp(‘(^|\\s+)‘ + className + ‘(\\s+|$)‘, ‘i‘)).test(elementNode.className);
1069 };
1070 
1071 // 库方法: 元素节点定位器
1072 Base.positioner = function (selector) {
1073     if (typeof selector != ‘string‘) return false;
1074     selector = this.trim(selector);
1075     var patternId = /^(id([\s\t　]*)=\2)?(\w+)$/i, 
1076         patternTag = /^tag(Name)?([\s\t　]*)=\2(\w+)$/i, 
1077         patternClass = /^class(Name)?([\s\t　]*)=\2(\w+)$/i;
1078     if (patternId.test(selector)) { // id node
1079         selector = patternId.exec(selector)[3];
1080         selector = $().getId(selector).getNodes();
1081     } else if (patternTag.test(selector)) { // tagName node
1082         selector = patternTag.exec(selector)[3];
1083         selector = $().getTagName(selector).getNodes();
1084     } else if (patternClass.test(selector)) { // class node
1085         selector = patternClass.exec(selector)[3];
1086         selector = $().getClass(selector).getNodes();
1087     }
1088     if (selector == $().info) return false;
1089     return selector;
1090 };
1091 
1092 // 库方法: 移除两边空格
1093 Base.trim = function (string) {
1094     if (typeof string != ‘string‘) return string;
1095     var spaceLeft = /^[\s\t　]+/, spaceRight = /[\s\t　]+$/;
1096     if (spaceLeft.test(string)) string = string.replace(spaceLeft, ‘‘);
1097     if (spaceRight.test(string)) string = string.replace(spaceRight, ‘‘);
1098     return string;
1099 };
1100 
1101 // 库方法: 移除指定字符串
1102 Base.replace = function (string, index) {
1103     if (typeof string != ‘string‘ || typeof index == ‘undefined‘) return string;
1104     if (string.toLowerCase().indexOf(index.toLowerCase()) != -1) string = string.replace(new RegExp(index, ‘gi‘), ‘‘);
1105     return string;
1106 };
1107 
1108 // 库方法: 检测是否元素节点
1109 Base.checkNode = function (elementNode) {
1110     if (elementNode === null 
1111     || 
1112         typeof elementNode != ‘object‘ 
1113     || 
1114         typeof elementNode.nodeType != ‘number‘ 
1115     || 
1116         (elementNode.nodeType != 1 && elementNode.nodeType != 9)) return false;
1117     return true;
1118 };
1119 
1120 // 库方法: 移除空白节点
1121 Base.space = function (elementNode) {
1122     if (!this.checkNode(elementNode)) return elementNode;
1123     var childs = elementNode.childNodes;
1124     var maxIndex = childs.length - 1;
1125     for (var i = maxIndex; i >= 0; i --) {
1126         if (childs[i].nodeType == 3 && /^[\s\t　]+$/.test(childs[i].nodeValue)) elementNode.removeChild(childs[i]);
1127     }
1128     return elementNode;
1129 };
1130 
1131 // 库方法: 移除注释节点
1132 Base.comment = function (elementNode) {
1133     if (!this.checkNode(elementNode)) return elementNode;
1134     var childs = elementNode.childNodes;
1135     var maxIndex = childs.length - 1;
1136     for (var i = maxIndex; i >= 0; i --) {
1137         if (childs[i].nodeType == 8) elementNode.removeChild(childs[i]);
1138     }
1139     return elementNode;
1140 };
1141 
1142 // 库方法: 获取子元素节点
1143 Base.getChilds = function (elementNode) {
1144     if (!this.checkNode(elementNode)) return false;
1145     var childs = elementNode.childNodes;
1146     var childList = [];
1147     for (var i = 0; i < childs.length; i ++) {
1148         if (childs[i].nodeType == 1) childList.push(childs[i]);
1149     }
1150     return childList.length != 0 ? childList : false;
1151 };

  1 /*
  2     源码作者: 石不易(Louis Shi)
  3     联系方式: http://www.shibuyi.net
  4     ===================================================================================================
  5     程序名称: JavaScript 工具库(跨浏览器兼容) BETA 4.0 版
  6     迭代版本: BETA 3.0
  7     功能总数: 21 个
  8     新增总数: 3 个
  9     删除总数: 0 个
 10     追加功能: 
 11         1. 新增“跨浏览器鼠标移入事件”, 解决元素对子元素的移入误判, 导致事件反复执行的BUG
 12         2. 新增“跨浏览器鼠标移出事件”, 解决元素对子元素的移出误判, 导致事件反复执行的BUG
 13         3. 新增“跨浏览器滚动条事件”, 解决 IE 6/7/8 无法识别 document 节点的滚动条事件
 14     优化功能: 
 15         1. 删除了“跨浏览器现代事件绑定: 注册事件”使用的唯一标识符, 直接用数组 push 方法添加
 16         2. 对“IE 6/7/8 专属: 匹配 W3C 事件 Event 对象”方法新增了 mouseover 与 mouseout 事件中获取周围元素的方法
 17     删除功能: 
 18         无
 19 */
 20 
 21 var Tool = {
 22     // 数组排序
 23     sort : {
 24         minToMax : function (min, max) {
 25             if (min < max) {
 26                 return -1;
 27             } else if (min > max) {
 28                 return 1;
 29             } else {
 30                 return 0;
 31             }
 32         },
 33         maxToMin : function (min, max) {
 34             if (min < max) {
 35                 return 1;
 36             } else if (min > max) {
 37                 return -1;
 38             } else {
 39                 return 0;
 40             }
 41         }
 42     },
 43     
 44     // 跨浏览器获取计算后的样式
 45     getStyle : function (cssKey, elementNode) {
 46         if (typeof window.getComputedStyle != ‘undefined‘) { // W3C
 47             return window.getComputedStyle(elementNode, null)[cssKey];
 48         } else if (typeof elementNode.currentStyle) { // IE 6/7/8
 49             return elementNode.currentStyle[cssKey];
 50         }
 51     },
 52     
 53     // 跨浏览器获取样式规则总数
 54     ruleTotal : function (sheet) {
 55         if (typeof sheet.cssRules != ‘undefined‘) { // W3C
 56             return sheet.cssRules.length;
 57         } else if (typeof sheet.rules != ‘undefined‘) { // IE 6/7/8
 58             return sheet.rules.length;
 59         }
 60     },
 61     
 62     // 跨浏览器获取样式规则名称
 63     ruleName : function (sheet) {
 64         var nameList = [], rules = null;
 65         if (typeof sheet.cssRules != ‘undefined‘) { // W3C
 66              rules = sheet.cssRules;
 67         } else if (typeof sheet.rules != ‘undefined‘) { // IE 6/7/8
 68             rules = sheet.rules;
 69         }
 70         for (var i = 0; i < rules.length; i ++) {
 71             nameList.push(rules[i].selectorText);
 72         }
 73         return nameList;
 74     },
 75     
 76     // 跨浏览器添加样式规则
 77     addRule : function (sheet, ruleName, ruleText, positioner) {
 78         if (typeof sheet.insertRule != ‘undefined‘) { // W3C
 79             sheet.insertRule(ruleName + ‘ {‘ + ruleText + ‘}‘, positioner);
 80         } else if (typeof sheet.addRule != ‘undefined‘) { // IE 6/7/8
 81             sheet.addRule(ruleName, ruleText, positioner);
 82         }
 83     },
 84     
 85     // 跨浏览器删除样式规则
 86     removeRule : function (sheet, positioner) {
 87         if (typeof sheet.deleteRule != ‘undefined‘) { // W3C
 88             sheet.deleteRule(positioner);
 89         } else if (typeof sheet.removeRule != ‘undefined‘) { // IE 6/7/8
 90             sheet.removeRule(positioner);
 91         }
 92     },
 93     
 94     // 跨浏览器现代事件绑定: 注册事件
 95     loginEvent : function (elementNode, eventName, method) {
 96         if (typeof elementNode.addEventListener != ‘undefined‘) { // W3C
 97             elementNode.addEventListener(eventName, method, false);
 98         } else if (typeof elementNode.attachEvent != ‘undefined‘) { // IE 6/7/8
 99             // 创建哈希表
100             if (typeof elementNode.hashTable != ‘object‘) elementNode.hashTable = {};
101             // 创建事件数组
102             if (!(elementNode.hashTable[eventName] instanceof Array)) elementNode.hashTable[eventName] = [];
103             var events = elementNode.hashTable[eventName];
104             // 检测方法是否重复
105             for (var i = 0; i < events.length; i ++) {
106                 if (events[i] == method) return false;
107             }
108             // 存储事件方法
109             events.push(method);
110             var _this = this;
111             // 执行事件
112             elementNode[‘on‘ + eventName] = function () {
113                 var event = _this.eventIE(window.event);
114                 for (var i = 0; i < events.length; i ++) {
115                     events[i].call(this, event);
116                 }
117             };
118         }
119     },
120     
121     // 跨浏览器现代事件绑定: 注销事件
122     logoutEvent : function (elementNode, eventName, method) {
123         if (typeof elementNode.removeEventListener != ‘undefined‘) { // W3C
124             elementNode.removeEventListener(eventName, method, false);
125         } else if (typeof elementNode.detachEvent != ‘undefined‘) { // IE 6/7/8
126             if (typeof elementNode.hashTable != ‘object‘ || !(elementNode.hashTable[eventName] instanceof Array)) return false;
127             var events = elementNode.hashTable[eventName];
128             for (var i = 0; i < events.length; i ++) {
129                 if (events[i] == method) events.splice(i, 1);
130             }
131         }
132     },
133     
134     // IE 6/7/8 专属: 匹配 W3C 事件 Event 对象
135     eventIE : function (event) {
136         event.target = event.srcElement;
137         event.preventDefault = function () {
138             event.returnValue = false;
139         };
140         event.stopPropagation = function () {
141             event.cancelBubble = true;
142         };
143         event.relatedTarget = function () {
144             switch (event.type) {
145                 case ‘mouseover‘ :
146                     return event.fromElement;
147                     break;
148                 case ‘mouseout‘ : 
149                     return event.toElement;
150                     break;
151                 default :
152                     return null;
153             }
154         }();
155         return event;
156     },
157     
158     // 跨浏览器鼠标滚轮(鼠标中键)事件
159     mousewheel : function (elementNode, method, mode) {
160         if (elementNode == window) elementNode = document; // IE 6/7/8
161         if (typeof elementNode.onmousewheel != ‘undefined‘) { // Not Firefox
162             mode ? this.loginEvent(elementNode, ‘mousewheel‘, method) : this.logoutEvent(elementNode, ‘mousewheel‘, method);
163         } else { // Firefox
164             mode ? this.loginEvent(elementNode, ‘DOMMouseScroll‘, method) : this.logoutEvent(elementNode, ‘DOMMouseScroll‘, method);
165         }
166     },
167     
168     // 跨浏览器鼠标移入事件
169     mouseover : function (elementNode, method, mode) {
170         mode ? this.loginEvent(elementNode, ‘mouseover‘, function (event) {
171             if (event.relatedTarget !== null && (event.relatedTarget == this || Tool.contains(event.relatedTarget, this))) return false;
172             method.call(this, event);
173         }) : this.logoutEvent(elementNode, ‘mouseover‘, method);
174     },
175     
176     // 跨浏览器鼠标移出事件
177     mouseout : function (elementNode, method, mode) {
178         mode ? this.loginEvent(elementNode, ‘mouseout‘, function (event) {
179             if (event.relatedTarget !== null && (event.relatedTarget == this || Tool.contains(event.relatedTarget, this))) return false;
180             method.call(this, event);
181         }) : this.logoutEvent(elementNode, ‘mouseout‘, method);
182     },
183     
184     // 跨浏览器滚动条事件
185     scroll : function (elementNode, method, mode) {
186         if (elementNode == document) this.scroll(document.documentElement, method, mode); // IE 6/7/8
187         mode ? this.loginEvent(elementNode, ‘scroll‘, method) : this.logoutEvent(elementNode, ‘scroll‘, method);
188     },
189     
190     // 跨浏览器设置与获取 X 轴滚动条
191     scrollX : function (x) {
192         var html = document.documentElement;
193         var body = document.body;
194         if (typeof x != ‘undefined‘) { // 设置
195             html.scrollLeft = x;
196             body.scrollTop = x;
197         } else { // 获取
198             return html.scrollLeft == 0 ? body.scrollLeft : html.scrollLeft;
199         }
200     },
201     
202     // 跨浏览器设置与获取 Y 轴滚动条
203     scrollY : function (y) {
204         var html = document.documentElement;
205         var body = document.body;
206         if (typeof y != ‘undefined‘) { // 设置
207             html.scrollTop = y;
208             body.scrollTop = y;
209         } else { // 获取
210             return html.scrollTop == 0 ? body.scrollTop : html.scrollTop;
211         }
212     },
213     
214     // 跨浏览器 HTML DOM 记载
215     loaded : function (method) {
216         if ((browserDetect.opera && browserDetect.browser.version < 9) 
217         || 
218             (/WebKit/i.test(browserDetect.engine.name) && browserDetect.engine.version < 525) 
219         || 
220             (browserDetect.firefox && browserDetect.browser.version < 3)) { // 低版本 W3C
221             var timer = setTimeout(function () {
222                 clearTimeout(timer);
223                 if (!/^(loading)|(interactive)|(loaded)|(complete)$/i.test(document.readyState)) {
224                     timer = setTimeout(arguments.callee, 1); // 递归
225                 }
226                 method();
227             }, 1);
228             
229         } else if (!/Trident/i.test(browserDetect.engine.name) || browserDetect.engine.version >= 5) { // 主流 W3C
230             var _this = this;
231             _this.loginEvent(document, ‘DOMContentLoaded‘, function () {
232                 _this.logoutEvent(document, ‘DOMContentLoaded‘, arguments.callee);
233                 method();
234             });
235         } else if (/Trident/i.test(browserDetect.engine.name) && browserDetect.engine.version < 5) { // IE 6/7/8
236             var timer = setTimeout(function () {
237                 clearTimeout(timer);
238                 try {
239                     document.documentElement.doScroll(‘top‘);
240                     method();
241                 } catch(error) {
242                     timer = clearTimeout(arguments.callee, 1);
243                 }
244             }, 1);
245         }
246     },
247     
248     // 跨浏览器检测元素从属关系(间接从属+直接从属)
249     contains : function (elementNode, elementTarget) {
250         if (typeof elementTarget.compareDocumentPosition != ‘undefined‘) { // W3C
251             return elementTarget.compareDocumentPosition(elementNode) == 20;
252         } else if (typeof elementTarget.contains != ‘undefined‘) { // IE 6/7/8
253             return elementTarget.contains(elementNode);
254         }
255     },
256     
257     // 跨浏览器获取浏览器可视区域 X 轴大小
258     getWindowWidth : function () {
259         if (typeof window.innerWidth != ‘undefined‘) { // W3C
260             return window.innerWidth;
261         } else if (typeof document.documentElement.clientWidth != ‘undefined‘) { // IE 6/7/8
262             return document.documentElement.clientWidth;
263         }
264     },
265     
266     // 跨浏览器获取浏览器可视区域 Y 轴大小
267     getWindowHeight : function () {
268         if (typeof window.innerHeight != ‘undefined‘) { // W3C
269             return window.innerHeight;
270         } else if (typeof document.documentElement.clientHeight != ‘undefined‘) { // IE 6/7/8
271             return document.documentElement.clientHeight;
272         }
273     },
274     
275     // IE 专属: 浏览器外捕获鼠标按下
276     setCaptureIE : function (elementNode) {
277         if (typeof elementNode.setCapture != ‘undefined‘) {
278             elementNode.setCapture();
279         }
280     },
281     
282     // IE 专属: 浏览器外捕获鼠标松开
283     releaseCaptureIE : function (elementNode) {
284         if (typeof elementNode.releaseCapture != ‘undefined‘) {
285             elementNode.releaseCapture();
286         }
287     }
288 };

  1 /*
  2     源码作者: 石不易(Louis Shi)
  3     联系方式: http://www.shibuyi.net
  4     ===================================================================================================
  5     程序名称: 浏览器嗅探器 BETA 4.0
  6     版本迭代: BETA 3.0
  7     功能总数: 4 个
  8     新增总数: 0 个
  9     删除总数: 0 个
 10     追加功能: 
 11         无
 12     优化功能: 
 13         1. 优化了 IE 浏览器版本的嗅探
 14     删除功能: 
 15         无
 16 */
 17 
 18 // 浏览器嗅探器
 19 (function () {
 20 
 21     window.browserDetect = {
 22         ie : false,
 23         firefox : false,
 24         chrome : false,
 25         safari : false,
 26         opera : false,
 27         other : false,
 28         
 29         browser : {
 30             name : ‘‘,
 31             version : 0
 32         },
 33         
 34         engine : {
 35             name : ‘‘,
 36             version : 0
 37         },
 38         
 39         system : {
 40             name : ‘‘,
 41             version : 0
 42         }
 43         
 44     };
 45     
 46     // 获取用户代理字符串
 47     var userAgent = navigator.userAgent;
 48     var platform = navigator.platform;
 49     
 50     var patternIELow = /MSIE\s([\.\d]+)/i;
 51     var patternIEHigh = /Trident(.+)rv:([\.\d]+)/i;
 52     var patternFirefox = /Firefox\/([\.\d]+)/i;
 53     var patternChrome = /Chrome\/([\.\d]+)/i;
 54     var patternSafari = /Safari\/([\.\d]+)/i;
 55     var patternOpera = /Opera\/([\.\d]+)/i;
 56     
 57     var patternTrident = /Trident\/([\.\d]+)/i;
 58     var patternVersion = /Version\/([\.\d]+)/i;
 59     
 60     // 嗅探浏览器型号
 61     if (patternIELow.test(userAgent) || patternIEHigh.test(userAgent)) { // IE
 62         browserDetect.ie = true;
 63         browserDetect.browser.name = ‘Internet Explorer‘;
 64         // 浏览器版本
 65         if (patternIELow.test(userAgent)) { // IE 6~10
 66             browserDetect.browser.version = parseFloat(patternIELow.exec(userAgent)[1]);
 67         } else { // IE 11+
 68             browserDetect.browser.version = parseFloat(patternIEHigh.exec(userAgent)[2]);
 69         }
 70         browserDetect.engine.name = ‘Trident‘;
 71         switch (browserDetect.browser.version) {
 72             case 6 :
 73                 browserDetect.engine.version = 2;
 74                 break;
 75             case 7 :
 76                 browserDetect.engine.version = 3;
 77                 break;
 78             default :
 79                 browserDetect.engine.version = ‘unknown‘;
 80         }
 81     } else if (patternFirefox.test(userAgent)) { // Firefox
 82         browserDetect.firefox = true;
 83         browserDetect.browser.name = ‘Firefox‘;
 84         browserDetect.browser.version = parseFloat(patternFirefox.exec(userAgent)[1]);
 85     } else if (patternChrome.test(userAgent)) { // Chrome
 86         browserDetect.chrome = true;
 87         browserDetect.browser.name = ‘Chrome‘;
 88         browserDetect.browser.version = parseFloat(patternChrome.exec(userAgent)[1]);
 89     } else if (patternSafari.test(userAgent)) { // Safari
 90         browserDetect.safari = true;
 91         browserDetect.browser.name = ‘Safari‘;
 92         if (patternVersion.test(userAgent)) { // 高版本
 93             browserDetect.browser.version = parseFloat(patternVersion.exec(userAgent)[1]);
 94         } else { // 低版本
 95             browserDetect.browser.version = parseFloat(patternSafari.exec(userAgent)[1]);
 96         }
 97     } else if (patternOpera.test(userAgent)) { // Opera
 98         browserDetect.opera = true;
 99         browserDetect.browser.name = ‘Opera‘;
100         if (patternVersion.test(userAgent)) { // 高版本
101             browserDetect.browser.version = parseFloat(patternVersion.exec(userAgent)[1]);
102         } else { // 低版本
103             browserDetect.browser.version = parseFloat(patternOpera.exec(userAgent)[1]);
104         }
105     } else { // Other
106         browserDetect.other = true;
107         browserDetect.browser.name = ‘unknown‘;
108         browserDetect.browser.version = ‘unknown‘;
109     }
110     
111     var patternGecko = /Gecko\/([\.\d]+)/i;
112     var patternWebKit = /WebKit\/([\.\d]+)/i;
113     var patternPresto = /Presto\/([\.\d]+)/i;
114     
115     // 嗅探浏览器内核(引擎)
116     if (patternTrident.test(userAgent)) { // Trident
117         browserDetect.engine.name = ‘Trident‘;
118         browserDetect.engine.version = parseFloat(patternTrident.exec(userAgent)[1]);
119     } else if (patternGecko.test(userAgent)) { // Gecko
120         browserDetect.engine.name = ‘Gecko‘;
121         patternVersion = /rv:([\.\d]+)/i;
122         if (patternVersion.test(userAgent)) { // 高版本
123             browserDetect.engine.version = parseFloat(patternVersion.exec(userAgent)[1]);
124         } else { // 低版本
125             browserDetect.engine.version = parseFloat(patternGecko.exec(userAgent)[1]);
126         }
127     } else if (patternWebKit.test(userAgent)) { // WebKit
128         browserDetect.engine.name = ‘WebKit‘;
129         browserDetect.engine.version = parseFloat(patternWebKit.exec(userAgent)[1]);
130     } else if (patternPresto.test(userAgent)) { // Presto
131         browserDetect.engine.name = ‘Presto‘;
132         browserDetect.engine.version = parseFloat(patternPresto.exec(userAgent)[1]);
133     } else if (!browserDetect.ie) { // Other
134         browserDetect.engine.name = ‘unknown‘;
135         browserDetect.engine.version = ‘unknown‘;
136     }
137     
138     var patternWindows = /Windows\sNT\s([\.\d]+)/i;
139     var patternWin = /Win/i;
140     var patternLinux = /Linux/i;
141     var patternUnix = /X11/i;
142     var patternMac = /Mac/i;
143     
144     // 嗅探系统平台
145     if (patternWindows.test(userAgent)) { // Windows (高版本浏览器)
146         browserDetect.system.version = parseFloat(patternWindows.exec(userAgent)[1]);
147         switch (browserDetect.system.version) {
148             case 5.0 : 
149                 browserDetect.system.name = ‘Windows 2000‘;
150                 break;
151             case 5.1 : 
152                 browserDetect.system.name = ‘Windows XP‘;
153                 break;
154             case 5.2 : 
155                 browserDetect.system.name = ‘Windows Server 2003 / Windows Server 2003 R2‘;
156                 break;
157             case 6.0 : 
158                 browserDetect.system.name = ‘Windows Vista / Windows Server 2008‘;
159                 break;
160             case 6.1 : 
161                 browserDetect.system.name = ‘Windows 7 / Windows Server 2008 R2‘;
162                 break;
163             case 6.2 : 
164                 browserDetect.system.name = ‘Windows 8 / Windows Server 2012 / Windows Phone 8‘;
165                 break;
166             case 6.3 : 
167                 browserDetect.system.name = ‘Windows 8.1 / Windows Server 2012 R2‘;
168                 break;
169             default : 
170                 browserDetect.system.name = ‘Windows‘;
171         }
172     } else if (patternWin.test(platform)) { // Windows (低版本浏览器)
173         browserDetect.system.name = ‘Windows‘;
174         browserDetect.system.version = ‘unknown‘;
175     } else if (patternLinux.test(platform)) { // Linux
176         browserDetect.system.name = ‘Linux‘;
177         browserDetect.system.version = ‘unknown‘;
178     } else if (patternUnix.test(platform)) { // Unix
179         browserDetect.system.name = ‘Unix‘;
180         browserDetect.system.version = ‘unknown‘;
181     } else if (patternMac.test(platform)) { // Mac
182         browserDetect.system.name = ‘Macintosh‘;
183         browserDetect.system.version = ‘unknown‘;
184     } else { // Other
185         browserDetect.system.name = ‘unknown‘;
186         browserDetect.system.version = ‘unknown‘;
187     }
188 })();

 1 /*
 2     源码作者: 石不易(Louis Shi)
 3     联系方式: http://www.shibuyi.net
 4     ===================================================================================================
 5     插件:
 6     1. 元素隐藏
 7     2. 元素显示
 8     3. 鼠标移入移出
 9 */
10 
11 $().plugins(hide, show, hover);
12 
13 // 元素隐藏
14 function hide() {
15     this.css(‘display‘, ‘none‘);
16     return this;
17 }
18 
19 // 元素显示
20 function show() {
21     this.css(‘display‘, ‘block‘);
22     return this;
23 }
24 
25 // 鼠标移入移出
26 function hover(overMethod, outMethod) {
27     this.nodeEvent(‘mouseover‘, overMethod);
28     this.nodeEvent(‘mouseout‘, outMethod);
29     return this;
30 }

 1 /*
 2     源码作者: 石不易(Louis Shi)
 3     联系方式: http://www.shibuyi.net
 4     ===================================================================================================
 5     插件:
 6     1. 元素垂直居中
 7     2. 元素水平居中
 8     3. 元素垂直水平居中
 9 */
10 
11 $().plugins(yCenter, xCenter, center);
12 
13 // 元素垂直居中
14 function yCenter(animationMode) {
15     if (typeof animationMode == ‘undefined‘) animationMode = false;
16     var windowHeight = Base.getWindowRectangle().height;
17     var innerHeight = 0, y = 0, elementNode = null;
18     for (var i = 0; i < this.elements.length; i ++) {
19         elementNode = this.elements[i];
20         Base.absolute(elementNode);
21         innerHeight = Base.getInnerRectangle(elementNode).height;
22          y = (windowHeight - innerHeight) / 2;
23         if (y < 0) y = 0;
24         y += Base.scroll().y;
25         if (!!animationMode) { // 动画模式
26             $(elementNode).animation({
27                 action : ‘y‘,
28                 target : y,
29                 isBuffer : true,
30                 speed : 10
31             });
32         } else {
33             $(elementNode).css(‘top‘, y + ‘px‘);
34         }
35     }
36     return this;
37 }
38 
39 // 元素水平居中
40 function xCenter(animationMode) {
41     if (typeof animationMode == ‘undefined‘) animationMode = false;
42     var windowWidth = Base.getWindowRectangle().width;
43     var innerWidth = 0, x = 0, elementNode = null;
44     for (var i = 0; i < this.elements.length; i ++) {
45         elementNode = this.elements[i];
46         Base.absolute(elementNode);
47         innerWidth = Base.getInnerRectangle(elementNode).width;
48         x = (windowWidth - innerWidth) / 2;
49         if (x < 0) x = 0;
50         x += Base.scroll().x;
51         if (!!animationMode) {
52             $(elementNode).animation({
53                 action : ‘x‘,
54                 target : x,
55                 isBuffer : true,
56                 speed : 10
57             });
58         } else {
59             $(elementNode).css(‘left‘, x + ‘px‘);
60         }
61     }
62     return this;
63 }
64 
65 // 元素垂直水平居中
66 function center(animationMode) {
67     if (typeof animationMode == ‘undefined‘) animationMode = false;
68     var windowRectangle = Base.getWindowRectangle();
69     var scroll = Base.scroll();
70     var innerRectangle = 0, x = 0, y = 0, elementNode = null;
71     for (var i = 0; i < this.elements.length; i ++) {
72         elementNode = this.elements[i];
73         Base.absolute(elementNode);
74         innerRectangle = Base.getInnerRectangle(elementNode);
75         x = (windowRectangle.width - innerRectangle.width) / 2;
76         y = (windowRectangle.height - innerRectangle.height) / 2;
77         if (x < 0) x = 0;
78         if (y < 0) y = 0;
79         x += scroll.x;
80         y += scroll.y;
81         if (!!animationMode) {
82             $(elementNode).animation({
83                 multiple : {
84                     x : x,
85                     y : y
86                 },
87                 isBuffer : true,
88                 speed : 10
89             });
90         } else {
91             $(elementNode).css([‘left : ‘  + x + ‘px‘, ‘top : ‘ + y + ‘px‘]);
92         }
93     }
94     return this;
95 }

 1 /*
 2     源码作者: 石不易(Louis Shi)
 3     联系方式: http://www.shibuyi.net
 4     ===================================================================================================
 5     插件:
 6     1. 遮罩锁屏
 7     2. 清除锁屏
 8 */
 9 
10 $().plugins(lock, unlock);
11 
12 // 遮罩锁屏
13 function lock(animationMode) {
14     if (typeof animationMode == ‘undefined‘) animationMode = false;
15     var screen = null;
16     if ((screen = $(‘#screen_lock‘).getNodes()) != this.info) {
17         if (!Base.empty(screen)) {
18             Base.removeElement(‘id = screen_lock‘);
19             screen = Base.addElement(‘div‘, ‘id = screen_lock‘, null, document.body);
20         };
21     } else {
22         screen = Base.addElement(‘div‘, ‘id = screen_lock‘, null, document.body);
23     }
24     Base.absolute(screen);
25     var scroll = Base.scroll();
26     $(document.documentElement).css(‘overflow‘, ‘hidden‘);
27     var windowRectangle = Base.getWindowRectangle();
28     Base.scroll(scroll.x, scroll.y);
29     $(screen).css([
30                                 ‘color : green‘,
31                                 ‘zIndex : 9998‘,
32                                 ‘top : ‘ + scroll.y + ‘px‘,
33                                 ‘left : ‘ + scroll.x + ‘px‘,
34                                 ‘width : ‘ + windowRectangle.width + ‘px‘, 
35                                 ‘height : ‘ + windowRectangle.height + ‘px‘, 
36                                 ‘background-color : black‘
37                         ]).show();
38     if (!!animationMode) {
39         $(screen).animation({
40             action : ‘o‘,
41             start : 0,
42             target : 40,
43             isBuffer : true,
44             speed : 10
45         });
46     } else {
47         $(screen).css([‘opacity : 0.4‘, ‘filter : alpha(opacity = 40)‘]);
48     }
49     Base.fixed(screen);
50     return this;
51 }
52 
53 // 清除锁屏
54 function unlock(animationMode) {
55     if (typeof animationMode == ‘undefined‘) animationMode = false;
56     var screen = null;
57     if (!(screen = $(‘#screen_lock‘).getNodes()) != this.info && Base.empty(screen)) {
58         if (!!animationMode) {
59             $(screen).animation({
60                 action : ‘o‘,
61                 target : 0,
62                 isBuffer : true,
63                 speed : 10,
64                 method : close
65             });
66         } else {
67             close();
68         }
69     }
70     function close() {
71         $(screen).hide();
72         var scroll = Base.scroll();
73         $(document.documentElement).css(‘overflow‘, ‘auto‘);
74         Base.scroll(scroll.x, scroll.y);
75     }
76     return this;
77 }

 1 /*
 2     源码作者: 石不易(Louis Shi)
 3     联系方式: http://www.shibuyi.net
 4     ===================================================================================================
 5     插件: 元素拖拽
 6 */
 7 
 8 $().plugins(drag);
 9 
10 // 元素拖拽
11 function drag(selector) {
12     var elementNode = null, targetNode = null;
13     for (var i = 0; i < this.elements.length; i ++) {
14         elementNode = this.elements[i];
15         if (typeof selector == ‘string‘) { // 拖拽子节点
16             if ((targetNode = $(elementNode).selector(selector).getNodes()) == this.info) continue;
17         } else { // 拖拽自身
18             targetNode = elementNode;
19         }
20         if (targetNode instanceof Array) { // 集群
21             for (var j = 0; j < targetNode.length; j ++) {
22                 $(targetNode[j]).css(‘cursor‘, ‘move‘).nodeEvent(‘mousedown‘, down);
23             }
24         } else { // 单一
25             $(targetNode).css(‘cursor‘, ‘move‘).nodeEvent(‘mousedown‘, down);
26         }
27         Base.fixed(elementNode);
28     }
29     function down(event) {
30         Base.absolute(elementNode);
31         if (Base.empty(elementNode)) event.preventDefault(); // Firefox Bug
32         Tool.setCaptureIE(elementNode);
33         var outerRectangle = Base.getOuterRectangle(elementNode);
34         var windowRectangle = Base.getWindowRectangle();
35         var innerRectangle = Base.getInnerRectangle(elementNode);
36         var scroll = Base.scroll();
37         var fixedX = event.clientX - outerRectangle.left;
38         var fixedY = event.clientY - outerRectangle.top;
39         var minX = scroll.x;
40         var minY = scroll.y;
41         var maxX = (windowRectangle.width - innerRectangle.width) + scroll.x;
42         var maxY = (windowRectangle.height - innerRectangle.height) + scroll.y;
43         $(document).nodeEvent(‘mousemove‘, move);
44         $(document).nodeEvent(‘mouseup‘, up);
45         function move(event) {
46             var x = event.clientX - fixedX;
47             var y = event.clientY - fixedY;
48             if (x < minX) x = minX;
49             if (x > maxX) x = maxX;
50             if (y < minY) y = minY;
51             if (y > maxY) y = maxY;
52             $(elementNode).css([‘left : ‘ + x + ‘px‘, ‘top : ‘ + y + ‘px‘]);
53         }
54         function up() {
55             Tool.releaseCaptureIE(elementNode);
56             $(this).nodeEvent(‘mousemove‘, move, false);
57             $(this).nodeEvent(‘mouseup‘, up, false);
58         }
59     }
60     return this;
61 }

 1 /*
 2     源码作者: 石不易(Louis Shi)
 3     联系方式: http://www.shibuyi.net
 4     ===================================================================================================
 5     插件: 禁止元素溢出可视区
 6 */
 7 
 8 $().plugins(overflow);
 9 
10 // 禁止元素溢出
11 function overflow() {
12     var scroll = Base.scroll();
13     var windowRectangle = Base.getWindowRectangle();
14     var outerRectangle = null, innerRectangle = null, elementNode = null;
15     var minX = scroll.x, minY = scroll.y, maxX = 0, maxY = 0, x = 0, y = 0;
16     for (var i = 0; i < this.elements.length; i ++) {
17         elementNode = this.elements[i];
18         Base.absolute(elementNode);
19         outerRectangle = Base.getOuterRectangle(elementNode);
20         innerRectangle = Base.getInnerRectangle(elementNode);
21         x = outerRectangle.left;
22         y = outerRectangle.top;
23         maxX = (scroll.x + windowRectangle.width) - innerRectangle.width;
24         maxY = (scroll.y + windowRectangle.height) - innerRectangle.height;
25         if (x < minX) x = minX;
26         if (x > maxX) x = maxX;
27         if (y < minY) y = minY;
28         if (y > maxY) y = maxY;
29         $(elementNode).css([‘left : ‘ + x + ‘px‘, ‘top : ‘ + y + ‘px‘]);
30     }
31     return this;
32 }

  1 /*
  2     源码作者: 石不易(Louis Shi)
  3     联系方式: http://www.shibuyi.net
  4     ===================================================================================================
  5     插件: 元素动画
  6 */
  7 
  8 $().plugins(animation);
  9 
 10 // 元素动画
 11 function animation(animation) {
 12     var elementNode = null, animationList = [];
 13     for (var i = 0; i < this.elements.length; i ++) {
 14         elementNode = this.elements[i];
 15         if (i == 0 && !(animation = Base.checkAnimation(animation, elementNode))) {
 16             return this;
 17         }
 18         var unique = ‘‘;
 19         for (var j = 0; j < animation.action.length; j ++) {
 20             // 组合唯一标识符(用于定时器)
 21             unique += animation.action[j];
 22             if (animation.action[j] == ‘opacity‘) {
 23                 $(elementNode).css(‘opacity‘, animation.start[j] / 100);
 24                 $(elementNode).css(‘filter‘, ‘alpha(opacity=‘ + animation.start[j] + ‘)‘);
 25             } else {
 26                 // 设置初始值
 27                 $(elementNode).css(animation.action[j], animation.start[j] + ‘px‘);
 28             }
 29         }
 30         // 清除动画唯一标识
 31         if (typeof elementNode[unique] == ‘number‘) clearTimeout(elementNode[unique]);
 32         
 33         (function (elementNode) { // 警告: IE 6/7/8 出现多定时器, 多重触发动画时, 会严重卡顿
 34                 // 定时器
 35                 elementNode[unique] = setTimeout(function () {
 36                     clearTimeout(elementNode[unique]);
 37                     var value = 0, target = 0, step = 0, action = ‘‘, flags = [];
 38                     for (var i = 0; i < animation.action.length; i ++) {
 39                         // 动画动作
 40                         action = animation.action[i];
 41                         // 目标量
 42                         target = animation.target[i];
 43                         // 步长量
 44                         step = animation.step[i];
 45                         
 46                         if (action == ‘opacity‘) {
 47                             if (browserDetect.ie && browserDetect.browser.version < 9) {
 48                                 var opacity = Base.trim($(elementNode).css(‘filter‘));
 49                                 value = Base.number(/alpha\(opacity([\s\t　]*)=\1(\d+)\)/i.exec(opacity)[2]);
 50                             } else {
 51                                 value = $(elementNode).css(‘opacity‘) * 100;
 52                             }
 53                         } else {
 54                             // 获取当前值
 55                             value = parseInt(Base.replace($(elementNode).css(action), ‘px‘));
 56                         }
 57                         
 58                         // 缓冲处理
 59                         if (animation.isBuffer) {
 60                             var speed = (target - value) / animation.speed;
 61                             step = step > 0 ? Math.ceil(speed) : Math.floor(speed);
 62                         }
 63                         
 64                         if (target == value || step == 0) continue;
 65                         
 66                         // 检测动画当前值
 67                         if (step > 0 && Math.abs(target - value) <= step) { // 结束(递增)
 68                             setAnimation(target);
 69                             flags[i] = false;
 70                         } else if (step < 0 && Math.abs(value - target) <= Math.abs(step)) { // 结束(递减)
 71                             setAnimation(target);
 72                             flags[i] = false;
 73                         } else { // 继续执行动画
 74                             setAnimation(value + step);
 75                             flags[i] = true;
 76                         }
 77                     }
 78                     
 79                     // 执行动画
 80                     function setAnimation(value) {
 81                         if (action == ‘opacity‘) {
 82                             $(elementNode).css(‘opacity‘, Base.number(value) / 100);
 83                             $(elementNode).css(‘filter‘, ‘alpha(opacity=‘ + Base.number(value) + ‘)‘);
 84                         } else {
 85                             $(elementNode).css(action, Base.number(value) + ‘px‘);
 86                         }
 87                     }
 88                     
 89                     // 遍历动画开关
 90                     for (var k = 0; k < flags.length; k ++) {
 91                         if (flags[k]) {
 92                             flags = true;
 93                             break;
 94                         }
 95                     }
 96                     
 97                     if (flags === true) { // 继续执行
 98                         elementNode[unique] = setTimeout(arguments.callee, animation.time);
 99                     } else { // 执行列队
100                         animation.method();
101                     }
102                 }, animation.time);
103             })(elementNode);
104     }
105     return this;
106 }

 1 /*
 2     源码作者: 石不易(Louis Shi)
 3     联系方式: http://www.shibuyi.net
 4     ===================================================================================================
 5     插件: 事件切换器
 6 */
 7 
 8 $().plugins(toggle);
 9 
10 // 事件切换器
11 function toggle() {
12     var methodList = arguments;
13     if (methodList.length != 0) {
14         var elementNode = null;
15         for (var i = 0; i < this.elements.length; i ++) {
16             elementNode = this.elements[i];
17             // 闭包实现计数器唯一性
18             (function () {
19                 var counter = 0;
20                 $(elementNode).nodeEvent(‘click‘, function () {
21                     methodList[counter ++].call(this);
22                     if (counter >= methodList.length) counter = 0;
23                 });
24             })();
25         }
26     }
27     return this;
28 }