this将代表浏览器的window对象。
* @param {Array} newArgs (optional) 重写构造函数中传入的参数列表
*/
me.delay = function(delay, newFn, newScope, newArgs){
me.cancel();
fn = newFn || fn;
scope = newScope || scope;
args = newArgs || args;
id = setInterval(call, delay);
};
/**
* 取消执行
*/
me.cancel = function(){
if(id){
clearInterval(id);
id = null;
}
};
};
/**
* @class task.Observable
*/
task.Observable = function(){
var me = this, e = me.events;
if(me.listeners){
me.on(me.listeners);
delete me.listeners;
}
me.events = e || {};
};
task.Observable.prototype = {
filterOptRe : /^(?:scope|delay|buffer|single)$/,
/**
* 用传入的参数调用指定的事件(除了事件名)。
* @param {String} eventName 触发的事件名。
* @param {Object...} args 触发事件时传入的参数列表。
* @return {Boolean} returns 如果有人和监听器返回false则返回false，否则返回true。
*/
fireEvent : function(){
var a = Array.prototype.slice.call(arguments, 0),
ename = a[0].toLowerCase(),
me = this, ret = true,
ce = me.events[ename],
cc, q, c;
if (me.eventsSuspended === true) {
if (q = me.eventQueue) {
q.push(a);
}
}
else if(typeof ce == 'object') {
if (ce.bubble){
if(ce.fire.apply(ce, a.slice(1)) === false) {
return false;
}
c = me.getBubbleTarget && me.getBubbleTarget();
if(c && c.enableBubble) {
cc = c.events[ename];
if(!cc || typeof cc != 'object' || !cc.bubble) {
c.enableBubble(ename);
}
return c.fireEvent.apply(c, a);
}
}
else {
a.shift();
ret = ce.fire.apply(ce, a);
}
}
return ret;
},
/**
* 添加触发器到指定事件中.
* @param {String} eventName 事件名.
* @param {Function} fn 事件被触发时的执行函数.
* @param {Object} scope (optional) 函数执行时的域对象(this所指的对象).
* @param {Object} o (optional) 触发器的属性列表.
* 触发器的属性列表如下:
*
* 结合属性
* 使用触发器属性列表参数能够结合多种特性的触发器:
*
* 一个延时且只执行一次的触发器.
*
myDataView.on('click', this.onClick, this, {
single: true,
delay: 100
});
*
* 一次绑定多个触发器
* 这个方法能够通过只传入一个对象参数一次绑定多个触发器。
*
*
myGridPanel.on({
'click' : {
fn: this.onClick,
scope: this,
delay: 100
},
'mouseover' : {
fn: this.onMouseOver,
scope: this
},
'mouseout' : {
fn: this.onMouseOut,
scope: this
}
});
*
* 简写的方式:
*
myGridPanel.on({
'click' : this.onClick,
'mouseover' : this.onMouseOver,
'mouseout' : this.onMouseOut,
scope: this
});
*/
addListener : function(eventName, fn, scope, o){
var me = this,
e,
oe,
isF,
ce;
if (typeof eventName == 'object') {
o = eventName;
for (e in o){
oe = o[e];
if (!me.filterOptRe.test(e)) {
me.addListener(e, oe.fn || oe, oe.scope || o.scope, oe.fn ? oe : o);
}
}
} else {
eventName = eventName.toLowerCase();
ce = me.events[eventName] || true;
if (typeof ce == 'boolean') {
me.events[eventName] = ce = new task.Event(me, eventName);
}
ce.addListener(fn, scope, typeof o == 'object' ? o : {});
}
},
/**
* 从对象指定事件的监听器列表中删除某指定项。
* @param {String} eventName 事件名。
* @param {Function} fn 监听器的执行函数。
* @param {Object} scope 监听器执行函数的域对象。
* @return {Boolean} 返回是否删除成功的布尔值。
*/
removeListener : function(eventName, fn, scope){
var ce = this.events[eventName.toLowerCase()];
if (typeof ce == 'object') {
ce.removeListener(fn, scope);
}
},
/**
* 清除该对象上所有事件已绑定的监听器。
*/
purgeListeners : function(){
var events = this.events, evt, key;
for(key in events){
evt = events[key];
if(typeof evt == 'object'){
evt.clearListeners();
}
}
},
/**
* 添加指定的事件到该Observable对象的可调用事件列表。
* @param {Object|String} o 该参数可以是一个对象，该对象的每个属性为事件名，值为true。
* 或者是多个字符串参数的第一个，这些字符串参数是事件名。
* @param {string} Optional. 传入的多个事件名字符串参数。
* 示例:
this.addEvents('storeloaded', 'storecleared');
*/
addEvents : function(o){
var me = this;
me.events = me.events || {};
if (typeof o == 'string') {
var a = arguments,
i = a.length;
while(i--) {
me.events[a[i]] = me.events[a[i]] || true;
}
} else {
Util.applyIf(me.events, o);
}
},
/**
* 检查该对象是否在某一事件上具有监听器。
* @param {String} eventName 待检查的事件名。
* @return {Boolean} 返回是否存在监听器的布尔值。
*/
hasListener : function(eventName){
var e = this.events[eventName.toLowerCase()];
return typeof e == 'object' && e.listeners.length > 0;
},
/**
* 阻断对象的事件触发执行。
* @param {Boolean} queueSuspended 是否将阻断期间每次的触发压入事件队列。
*/
suspendEvents : function(queueSuspended){
this.eventsSuspended = true;
if(queueSuspended && !this.eventQueue){
this.eventQueue = [];
}
},
/**
* 恢复对象事件的触发执行，执行事件队列中的所有任务。
*/
resumeEvents : function(){
var me = this, queued = me.eventQueue || [];
me.eventsSuspended = false;
delete me.eventQueue;
Util.each(queued, function(e) {
me.fireEvent.apply(me, e);
});
}
};
window.Observable = task.Observable;
/**
* 给对象指定事件添加触发器({@link #addListener}的简写。)
* @param {String} eventName 事件名。
* @param {Function} handler 事件监听器的触发函数。
* @param {Object} scope (optional) 触发器函数的域对象(this指的对象)。
* @param {Object} options (optional) 触发器的参数列表。
* @method
*/
task.Observable.prototype.on = task.Observable.prototype.addListener;
/**
* 删除对象指定事件的触发器({@link #removeListener}的简写。)
* @param {String} eventName 事件名。
* @param {Function} handler 要删除触发器的触发函数这必须是{@link #addListener}调用时传入的参数。
* @param {Object} scope (optional) 触发器触发函数的域对象。
* @method
*/
task.Observable.prototype.un = task.Observable.prototype.removeListener;
task.Observable.releaseCapture = function(o){
o.fireEvent = task.Observable.fireEvent;
};
/**
* @class task.Event
* 自定义事件类型。
*/
task.Event = function(obj, name){
this.name = name;
this.obj = obj;
this.listeners = [];
};
task.Event.prototype = {
/**
* 在对象的监听器列表中添加新的监听器。
* @param {Function} fn 监听器的执行函数。
* @param {Object} scope (optional) 监听器执行函数的域对象。
* @param {Object} options (optional) 监听器的属性列表。
*/
addListener : function(fn, scope, options){
var me = this,
l;
scope = scope || me.obj;
if(!me.isListening(fn, scope)){
l = me.createListener(fn, scope, options);
if (me.firing) {//如果该事件处于执行状态，不要影响该执行过程
me.listeners = me.listeners.slice(0);
}
me.listeners.push(l);
}
},
/**
* 根据执行函数、域对象、属性列表创建监听器。
* @param {Function} fn 监听器的执行函数。
* @param {Object} scope (optional) 监听器执行函数的域对象。
* @param {Object} options (optional) 监听器的属性列表。
*/
createListener: function(fn, scope, o){
o = o || {}, scope = scope || this.obj;
var l = {
fn: fn,
scope: scope,
options: o
}, h = fn;
if(o.target){
h = createTargeted(h, o, scope);
}
if(o.delay){
h = createDelayed(h, o, l, scope);
}
if(o.single){
h = createSingle(h, this, fn, scope);
}
if(o.buffer){
h = createBuffered(h, o, l, scope);
}
l.fireFn = h;
return l;
},
/**
* 在事件对象的监听器列表中查找某监听器。
* @param {Function} fn 监听器的执行函数。
* @param {Object} scope (optional) 监听器执行函数的域对象。
* @return {Number} 返回该监听器的索引值，不存在则返回-1。
*/
findListener : function(fn, scope){
var list = this.listeners, i = list.length, l;
scope = scope || this.obj;
while(i--){
l = list[i];
if(l){
if(l.fn == fn && l.scope == scope){
return i;
}
}
}
return -1;
},
/**
* 检查事件对象是否已经包含该监听器。
* @param {Function} fn 监听器的执行函数。
* @param {Object} scope 监听器执行函数的域对象。
* @return {Boolean} 返回是否存在该监听器的布尔值。
*/
isListening : function(fn, scope){
return this.findListener(fn, scope) != -1;
},
/**
* 从事件对象监听器列表中删除某指定项。
* @param {Function} fn 监听器的执行函数。
* @param {Object} scope 监听器执行函数的域对象。
* @return {Boolean} 返回是否删除成功的布尔值。
*/
removeListener : function(fn, scope){
var index, l, k, me = this, ret = false;
if((index = me.findListener(fn, scope)) != -1){
if (me.firing) {
me.listeners = me.listeners.slice(0);
}
l = me.listeners[index];
if(l.task) {
l.task.cancel();
delete l.task;
}
k = l.tasks && l.tasks.length;
if(k) {
while(k--) {
l.tasks[k].cancel();
}
delete l.tasks;
}
me.listeners.splice(index, 1);
ret = true;
}
return ret;
},
/**
* 清除事件对象的所有监听器。
*/
clearListeners : function(){
var me = this,
l = me.listeners,
i = l.length;
while(i--) {
me.removeListener(l[i].fn, l[i].scope);
}
},
/**
* 执行该事件上监听器列表中的所有函数。
* @return {Boolean} 返回该事件监听器列表是否正确执行的布尔值。
*/
fire : function(){
var me = this, listeners = me.listeners, len = listeners.length, i = 0, l;
if(len > 0){
me.firing = true;
var args = Array.prototype.slice.call(arguments, 0);
for (; i < len; i++) {
l = listeners[i];
if(l && l.fireFn.apply(l.scope || me.obj || window, args) === false) {
return (me.firing = false);
}
}
}
me.firing = false;
return true;
}
};
window.Event = task.Event;
//结束创建Observable，在Store.js中需要用到Observable。
})();
//base64加密
var Base64 = {
_keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
encode: function(input) {
var output = "";
var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
var i = 0;
input = Base64._utf8_encode(input);
while (i < input.length) {
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2)) {
enc3 = enc4 = 64;
} else if (isNaN(chr3)) {
enc4 = 64;
}
output = output + this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) + this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
}
return output;
},
// public method for decoding
decode: function(input) {
var output = "";
var chr1, chr2, chr3;
var enc1, enc2, enc3, enc4;
var i = 0;
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
while (i < input.length) {
enc1 = this._keyStr.indexOf(input.charAt(i++));
enc2 = this._keyStr.indexOf(input.charAt(i++));
enc3 = this._keyStr.indexOf(input.charAt(i++));
enc4 = this._keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;
output = output + String.fromCharCode(chr1);
if (enc3 != 64) {
output = output + String.fromCharCode(chr2);
}
if (enc4 != 64) {
output = output + String.fromCharCode(chr3);
}
}
output = Base64._utf8_decode(output);
return output;
},
// private method for UTF-8 encoding
_utf8_encode: function(string) {
string = string.replace(/\r\n/g, "\n");
var utftext = "";
for (var n = 0; n < string.length; n++) {
var c = string.charCodeAt(n);
if (c < 128) {
utftext += String.fromCharCode(c);
}else if ((c > 127) && (c < 2048)) {
utftext += String.fromCharCode((c >> 6) | 192);
utftext += String.fromCharCode((c & 63) | 128);
}else {
utftext += String.fromCharCode((c >> 12) | 224);
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
utftext += String.fromCharCode((c & 63) | 128);
}
}
return utftext;
},
_utf8_decode: function(utftext) {
var string = "";
var i = 0;
var c = c1 = c2 = 0;
while (i < utftext.length) {
c = utftext.charCodeAt(i);
if (c < 128) {
string += String.fromCharCode(c);
i++;
}else if ((c > 191) && (c < 224)) {
c2 = utftext.charCodeAt(i + 1);
string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
i += 2;
}else {
c2 = utftext.charCodeAt(i + 1);
c3 = utftext.charCodeAt(i + 2);
string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
i += 3;
}
}
return string;
}
}
function make_auth(user, password) {
var tok = user + ':' + password;
var hash = Base64.encode(tok);
return hash;
}
function login(u, p) {
window.auth = make_auth(u, p);
window.user = u;
if (u == "") {
auth = null;
}
var parm="";
parm+="&username="+u;
parm+="&password="+p;
$.cookie("auth", auth);
$.cookie("userManage", user);
$.cookie("passManage", Base64.encode(p));
$.cookie('loginstatus',null);
//var res = Util.request("exec", "show version");
var res=Util.cgi_request("login_rj.cgi",0,parm);
if (res ==0) {
auth = "";
user = "";
$.cookie("auth", null);
$.cookie("userManage", user);
$.cookie("passManage", Base64.encode(p));
return "fail";
} else if (typeof res === 'undefined') {
return "nolink";
}
return "success";
}
function toBase64(str) {
return Base64.decode(str);
}