The Tor Browser / file comparison

comparison: dom/tests/mochitest/ajax/mochikit/MochiKit/Signal.js

dom/tests/mochitest/ajax/mochikit/MochiKit/Signal.js

branch
TOR_BUG_9701
changeset 9
a63d609f5ebe
equal deleted inserted replaced
-1:000000000000 0:38d735f37b41
1 /***
2
3 MochiKit.Signal 1.4
4
5 See <http://mochikit.com/> for documentation, downloads, license, etc.
6
7 (c) 2006 Jonathan Gardner, Beau Hartshorne, Bob Ippolito. All rights Reserved.
8
9 ***/
10
11 if (typeof(dojo) != 'undefined') {
12 dojo.provide('MochiKit.Signal');
13 dojo.require('MochiKit.Base');
14 dojo.require('MochiKit.DOM');
15 dojo.require('MochiKit.Style');
16 }
17 if (typeof(JSAN) != 'undefined') {
18 JSAN.use('MochiKit.Base', []);
19 JSAN.use('MochiKit.DOM', []);
20 JSAN.use('MochiKit.Style', []);
21 }
22
23 try {
24 if (typeof(MochiKit.Base) == 'undefined') {
25 throw '';
26 }
27 } catch (e) {
28 throw 'MochiKit.Signal depends on MochiKit.Base!';
29 }
30
31 try {
32 if (typeof(MochiKit.DOM) == 'undefined') {
33 throw '';
34 }
35 } catch (e) {
36 throw 'MochiKit.Signal depends on MochiKit.DOM!';
37 }
38
39 try {
40 if (typeof(MochiKit.Style) == 'undefined') {
41 throw '';
42 }
43 } catch (e) {
44 throw 'MochiKit.Signal depends on MochiKit.Style!';
45 }
46
47 if (typeof(MochiKit.Signal) == 'undefined') {
48 MochiKit.Signal = {};
49 }
50
51 MochiKit.Signal.NAME = 'MochiKit.Signal';
52 MochiKit.Signal.VERSION = '1.4';
53
54 MochiKit.Signal._observers = [];
55
56 /** @id MochiKit.Signal.Event */
57 MochiKit.Signal.Event = function (src, e) {
58 this._event = e || window.event;
59 this._src = src;
60 };
61
62 MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
63
64 __repr__: function () {
65 var repr = MochiKit.Base.repr;
66 var str = '{event(): ' + repr(this.event()) +
67 ', src(): ' + repr(this.src()) +
68 ', type(): ' + repr(this.type()) +
69 ', target(): ' + repr(this.target());
70
71 if (this.type() &&
72 this.type().indexOf('key') === 0 ||
73 this.type().indexOf('mouse') === 0 ||
74 this.type().indexOf('click') != -1 ||
75 this.type() == 'contextmenu') {
76 str += ', modifier(): ' + '{alt: ' + repr(this.modifier().alt) +
77 ', ctrl: ' + repr(this.modifier().ctrl) +
78 ', meta: ' + repr(this.modifier().meta) +
79 ', shift: ' + repr(this.modifier().shift) +
80 ', any: ' + repr(this.modifier().any) + '}';
81 }
82
83 if (this.type() && this.type().indexOf('key') === 0) {
84 str += ', key(): {code: ' + repr(this.key().code) +
85 ', string: ' + repr(this.key().string) + '}';
86 }
87
88 if (this.type() && (
89 this.type().indexOf('mouse') === 0 ||
90 this.type().indexOf('click') != -1 ||
91 this.type() == 'contextmenu')) {
92
93 str += ', mouse(): {page: ' + repr(this.mouse().page) +
94 ', client: ' + repr(this.mouse().client);
95
96 if (this.type() != 'mousemove') {
97 str += ', button: {left: ' + repr(this.mouse().button.left) +
98 ', middle: ' + repr(this.mouse().button.middle) +
99 ', right: ' + repr(this.mouse().button.right) + '}}';
100 } else {
101 str += '}';
102 }
103 }
104 if (this.type() == 'mouseover' || this.type() == 'mouseout') {
105 str += ', relatedTarget(): ' + repr(this.relatedTarget());
106 }
107 str += '}';
108 return str;
109 },
110
111 /** @id MochiKit.Signal.Event.prototype.toString */
112 toString: function () {
113 return this.__repr__();
114 },
115
116 /** @id MochiKit.Signal.Event.prototype.src */
117 src: function () {
118 return this._src;
119 },
120
121 /** @id MochiKit.Signal.Event.prototype.event */
122 event: function () {
123 return this._event;
124 },
125
126 /** @id MochiKit.Signal.Event.prototype.type */
127 type: function () {
128 return this._event.type || undefined;
129 },
130
131 /** @id MochiKit.Signal.Event.prototype.target */
132 target: function () {
133 return this._event.target || this._event.srcElement;
134 },
135
136 _relatedTarget: null,
137 /** @id MochiKit.Signal.Event.prototype.relatedTarget */
138 relatedTarget: function () {
139 if (this._relatedTarget !== null) {
140 return this._relatedTarget;
141 }
142
143 var elem = null;
144 if (this.type() == 'mouseover') {
145 elem = (this._event.relatedTarget ||
146 this._event.fromElement);
147 } else if (this.type() == 'mouseout') {
148 elem = (this._event.relatedTarget ||
149 this._event.toElement);
150 }
151 if (elem !== null) {
152 this._relatedTarget = elem;
153 return elem;
154 }
155
156 return undefined;
157 },
158
159 _modifier: null,
160 /** @id MochiKit.Signal.Event.prototype.modifier */
161 modifier: function () {
162 if (this._modifier !== null) {
163 return this._modifier;
164 }
165 var m = {};
166 m.alt = this._event.altKey;
167 m.ctrl = this._event.ctrlKey;
168 m.meta = this._event.metaKey || false; // IE and Opera punt here
169 m.shift = this._event.shiftKey;
170 m.any = m.alt || m.ctrl || m.shift || m.meta;
171 this._modifier = m;
172 return m;
173 },
174
175 _key: null,
176 /** @id MochiKit.Signal.Event.prototype.key */
177 key: function () {
178 if (this._key !== null) {
179 return this._key;
180 }
181 var k = {};
182 if (this.type() && this.type().indexOf('key') === 0) {
183
184 /*
185
186 If you're looking for a special key, look for it in keydown or
187 keyup, but never keypress. If you're looking for a Unicode
188 chracter, look for it with keypress, but never keyup or
189 keydown.
190
191 Notes:
192
193 FF key event behavior:
194 key event charCode keyCode
195 DOWN ku,kd 0 40
196 DOWN kp 0 40
197 ESC ku,kd 0 27
198 ESC kp 0 27
199 a ku,kd 0 65
200 a kp 97 0
201 shift+a ku,kd 0 65
202 shift+a kp 65 0
203 1 ku,kd 0 49
204 1 kp 49 0
205 shift+1 ku,kd 0 0
206 shift+1 kp 33 0
207
208 IE key event behavior:
209 (IE doesn't fire keypress events for special keys.)
210 key event keyCode
211 DOWN ku,kd 40
212 DOWN kp undefined
213 ESC ku,kd 27
214 ESC kp 27
215 a ku,kd 65
216 a kp 97
217 shift+a ku,kd 65
218 shift+a kp 65
219 1 ku,kd 49
220 1 kp 49
221 shift+1 ku,kd 49
222 shift+1 kp 33
223
224 Safari key event behavior:
225 (Safari sets charCode and keyCode to something crazy for
226 special keys.)
227 key event charCode keyCode
228 DOWN ku,kd 63233 40
229 DOWN kp 63233 63233
230 ESC ku,kd 27 27
231 ESC kp 27 27
232 a ku,kd 97 65
233 a kp 97 97
234 shift+a ku,kd 65 65
235 shift+a kp 65 65
236 1 ku,kd 49 49
237 1 kp 49 49
238 shift+1 ku,kd 33 49
239 shift+1 kp 33 33
240
241 */
242
243 /* look for special keys here */
244 if (this.type() == 'keydown' || this.type() == 'keyup') {
245 k.code = this._event.keyCode;
246 k.string = (MochiKit.Signal._specialKeys[k.code] ||
247 'KEY_UNKNOWN');
248 this._key = k;
249 return k;
250
251 /* look for characters here */
252 } else if (this.type() == 'keypress') {
253
254 /*
255
256 Special key behavior:
257
258 IE: does not fire keypress events for special keys
259 FF: sets charCode to 0, and sets the correct keyCode
260 Safari: sets keyCode and charCode to something stupid
261
262 */
263
264 k.code = 0;
265 k.string = '';
266
267 if (typeof(this._event.charCode) != 'undefined' &&
268 this._event.charCode !== 0 &&
269 !MochiKit.Signal._specialMacKeys[this._event.charCode]) {
270 k.code = this._event.charCode;
271 k.string = String.fromCharCode(k.code);
272 } else if (this._event.keyCode &&
273 typeof(this._event.charCode) == 'undefined') { // IE
274 k.code = this._event.keyCode;
275 k.string = String.fromCharCode(k.code);
276 }
277
278 this._key = k;
279 return k;
280 }
281 }
282 return undefined;
283 },
284
285 _mouse: null,
286 /** @id MochiKit.Signal.Event.prototype.mouse */
287 mouse: function () {
288 if (this._mouse !== null) {
289 return this._mouse;
290 }
291
292 var m = {};
293 var e = this._event;
294
295 if (this.type() && (
296 this.type().indexOf('mouse') === 0 ||
297 this.type().indexOf('click') != -1 ||
298 this.type() == 'contextmenu')) {
299
300 m.client = new MochiKit.Style.Coordinates(0, 0);
301 if (e.clientX || e.clientY) {
302 m.client.x = (!e.clientX || e.clientX < 0) ? 0 : e.clientX;
303 m.client.y = (!e.clientY || e.clientY < 0) ? 0 : e.clientY;
304 }
305
306 m.page = new MochiKit.Style.Coordinates(0, 0);
307 if (e.pageX || e.pageY) {
308 m.page.x = (!e.pageX || e.pageX < 0) ? 0 : e.pageX;
309 m.page.y = (!e.pageY || e.pageY < 0) ? 0 : e.pageY;
310 } else {
311 /*
312
313 The IE shortcut can be off by two. We fix it. See:
314 http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
315
316 This is similar to the method used in
317 MochiKit.Style.getElementPosition().
318
319 */
320 var de = MochiKit.DOM._document.documentElement;
321 var b = MochiKit.DOM._document.body;
322
323 m.page.x = e.clientX +
324 (de.scrollLeft || b.scrollLeft) -
325 (de.clientLeft || 0);
326
327 m.page.y = e.clientY +
328 (de.scrollTop || b.scrollTop) -
329 (de.clientTop || 0);
330
331 }
332 if (this.type() != 'mousemove') {
333 m.button = {};
334 m.button.left = false;
335 m.button.right = false;
336 m.button.middle = false;
337
338 /* we could check e.button, but which is more consistent */
339 if (e.which) {
340 m.button.left = (e.which == 1);
341 m.button.middle = (e.which == 2);
342 m.button.right = (e.which == 3);
343
344 /*
345
346 Mac browsers and right click:
347
348 - Safari doesn't fire any click events on a right
349 click:
350 http://bugs.webkit.org/show_bug.cgi?id=6595
351
352 - Firefox fires the event, and sets ctrlKey = true
353
354 - Opera fires the event, and sets metaKey = true
355
356 oncontextmenu is fired on right clicks between
357 browsers and across platforms.
358
359 */
360
361 } else {
362 m.button.left = !!(e.button & 1);
363 m.button.right = !!(e.button & 2);
364 m.button.middle = !!(e.button & 4);
365 }
366 }
367 this._mouse = m;
368 return m;
369 }
370 return undefined;
371 },
372
373 /** @id MochiKit.Signal.Event.prototype.stop */
374 stop: function () {
375 this.stopPropagation();
376 this.preventDefault();
377 },
378
379 /** @id MochiKit.Signal.Event.prototype.stopPropagation */
380 stopPropagation: function () {
381 if (this._event.stopPropagation) {
382 this._event.stopPropagation();
383 } else {
384 this._event.cancelBubble = true;
385 }
386 },
387
388 /** @id MochiKit.Signal.Event.prototype.preventDefault */
389 preventDefault: function () {
390 if (this._event.preventDefault) {
391 this._event.preventDefault();
392 } else if (this._confirmUnload === null) {
393 this._event.returnValue = false;
394 }
395 },
396
397 _confirmUnload: null,
398
399 /** @id MochiKit.Signal.Event.prototype.confirmUnload */
400 confirmUnload: function (msg) {
401 if (this.type() == 'beforeunload') {
402 this._confirmUnload = msg;
403 this._event.returnValue = msg;
404 }
405 }
406 });
407
408 /* Safari sets keyCode to these special values onkeypress. */
409 MochiKit.Signal._specialMacKeys = {
410 3: 'KEY_ENTER',
411 63289: 'KEY_NUM_PAD_CLEAR',
412 63276: 'KEY_PAGE_UP',
413 63277: 'KEY_PAGE_DOWN',
414 63275: 'KEY_END',
415 63273: 'KEY_HOME',
416 63234: 'KEY_ARROW_LEFT',
417 63232: 'KEY_ARROW_UP',
418 63235: 'KEY_ARROW_RIGHT',
419 63233: 'KEY_ARROW_DOWN',
420 63302: 'KEY_INSERT',
421 63272: 'KEY_DELETE'
422 };
423
424 /* for KEY_F1 - KEY_F12 */
425 (function () {
426 var _specialMacKeys = MochiKit.Signal._specialMacKeys;
427 for (i = 63236; i <= 63242; i++) {
428 // no F0
429 _specialMacKeys[i] = 'KEY_F' + (i - 63236 + 1);
430 }
431 })();
432
433 /* Standard keyboard key codes. */
434 MochiKit.Signal._specialKeys = {
435 8: 'KEY_BACKSPACE',
436 9: 'KEY_TAB',
437 12: 'KEY_NUM_PAD_CLEAR', // weird, for Safari and Mac FF only
438 13: 'KEY_ENTER',
439 16: 'KEY_SHIFT',
440 17: 'KEY_CTRL',
441 18: 'KEY_ALT',
442 19: 'KEY_PAUSE',
443 20: 'KEY_CAPS_LOCK',
444 27: 'KEY_ESCAPE',
445 32: 'KEY_SPACEBAR',
446 33: 'KEY_PAGE_UP',
447 34: 'KEY_PAGE_DOWN',
448 35: 'KEY_END',
449 36: 'KEY_HOME',
450 37: 'KEY_ARROW_LEFT',
451 38: 'KEY_ARROW_UP',
452 39: 'KEY_ARROW_RIGHT',
453 40: 'KEY_ARROW_DOWN',
454 44: 'KEY_PRINT_SCREEN',
455 45: 'KEY_INSERT',
456 46: 'KEY_DELETE',
457 59: 'KEY_SEMICOLON', // weird, for Safari and IE only
458 91: 'KEY_WINDOWS_LEFT',
459 92: 'KEY_WINDOWS_RIGHT',
460 93: 'KEY_SELECT',
461 106: 'KEY_NUM_PAD_ASTERISK',
462 107: 'KEY_NUM_PAD_PLUS_SIGN',
463 109: 'KEY_NUM_PAD_HYPHEN-MINUS',
464 110: 'KEY_NUM_PAD_FULL_STOP',
465 111: 'KEY_NUM_PAD_SOLIDUS',
466 144: 'KEY_NUM_LOCK',
467 145: 'KEY_SCROLL_LOCK',
468 186: 'KEY_SEMICOLON',
469 187: 'KEY_EQUALS_SIGN',
470 188: 'KEY_COMMA',
471 189: 'KEY_HYPHEN-MINUS',
472 190: 'KEY_FULL_STOP',
473 191: 'KEY_SOLIDUS',
474 192: 'KEY_GRAVE_ACCENT',
475 219: 'KEY_LEFT_SQUARE_BRACKET',
476 220: 'KEY_REVERSE_SOLIDUS',
477 221: 'KEY_RIGHT_SQUARE_BRACKET',
478 222: 'KEY_APOSTROPHE'
479 // undefined: 'KEY_UNKNOWN'
480 };
481
482 (function () {
483 /* for KEY_0 - KEY_9 */
484 var _specialKeys = MochiKit.Signal._specialKeys;
485 for (var i = 48; i <= 57; i++) {
486 _specialKeys[i] = 'KEY_' + (i - 48);
487 }
488
489 /* for KEY_A - KEY_Z */
490 for (i = 65; i <= 90; i++) {
491 _specialKeys[i] = 'KEY_' + String.fromCharCode(i);
492 }
493
494 /* for KEY_NUM_PAD_0 - KEY_NUM_PAD_9 */
495 for (i = 96; i <= 105; i++) {
496 _specialKeys[i] = 'KEY_NUM_PAD_' + (i - 96);
497 }
498
499 /* for KEY_F1 - KEY_F12 */
500 for (i = 112; i <= 123; i++) {
501 // no F0
502 _specialKeys[i] = 'KEY_F' + (i - 112 + 1);
503 }
504 })();
505
506 /* Internal object to keep track of created signals. */
507 MochiKit.Signal.Ident = function (ident) {
508 this.source = ident.source;
509 this.signal = ident.signal;
510 this.listener = ident.listener;
511 this.isDOM = ident.isDOM;
512 this.objOrFunc = ident.objOrFunc;
513 this.funcOrStr = ident.funcOrStr;
514 this.connected = ident.connected;
515 };
516
517 MochiKit.Signal.Ident.prototype = {};
518
519 MochiKit.Base.update(MochiKit.Signal, {
520
521 __repr__: function () {
522 return '[' + this.NAME + ' ' + this.VERSION + ']';
523 },
524
525 toString: function () {
526 return this.__repr__();
527 },
528
529 _unloadCache: function () {
530 var self = MochiKit.Signal;
531 var observers = self._observers;
532
533 for (var i = 0; i < observers.length; i++) {
534 if (observers[i].signal !== 'onload' && observers[i].signal !== 'onunload') {
535 self._disconnect(observers[i]);
536 }
537 }
538 },
539
540 _listener: function (src, sig, func, obj, isDOM) {
541 var self = MochiKit.Signal;
542 var E = self.Event;
543 if (!isDOM) {
544 return MochiKit.Base.bind(func, obj);
545 }
546 obj = obj || src;
547 if (typeof(func) == "string") {
548 if (sig === 'onload' || sig === 'onunload') {
549 return function (nativeEvent) {
550 obj[func].apply(obj, [new E(src, nativeEvent)]);
551
552 var ident = new MochiKit.Signal.Ident({
553 source: src, signal: sig, objOrFunc: obj, funcOrStr: func});
554
555 MochiKit.Signal._disconnect(ident);
556 };
557 } else {
558 return function (nativeEvent) {
559 obj[func].apply(obj, [new E(src, nativeEvent)]);
560 };
561 }
562 } else {
563 if (sig === 'onload' || sig === 'onunload') {
564 return function (nativeEvent) {
565 func.apply(obj, [new E(src, nativeEvent)]);
566 MochiKit.Signal.disconnect(src, sig, func);
567
568 var ident = new MochiKit.Signal.Ident({
569 source: src, signal: sig, objOrFunc: func});
570
571 MochiKit.Signal._disconnect(ident);
572 };
573 } else {
574 return function (nativeEvent) {
575 func.apply(obj, [new E(src, nativeEvent)]);
576 };
577 }
578 }
579 },
580
581 _browserAlreadyHasMouseEnterAndLeave: function () {
582 return /MSIE/.test(navigator.userAgent);
583 },
584
585 _mouseEnterListener: function (src, sig, func, obj) {
586 var E = MochiKit.Signal.Event;
587 return function (nativeEvent) {
588 var e = new E(src, nativeEvent);
589 try {
590 e.relatedTarget().nodeName;
591 } catch (err) {
592 /* probably hit a permission denied error; possibly one of
593 * firefox's screwy anonymous DIVs inside an input element.
594 * Allow this event to propogate up.
595 */
596 return;
597 }
598 e.stop();
599 if (MochiKit.DOM.isChildNode(e.relatedTarget(), src)) {
600 /* We've moved between our node and a child. Ignore. */
601 return;
602 }
603 e.type = function () { return sig; };
604 if (typeof(func) == "string") {
605 return obj[func].apply(obj, [e]);
606 } else {
607 return func.apply(obj, [e]);
608 }
609 };
610 },
611
612 _getDestPair: function (objOrFunc, funcOrStr) {
613 var obj = null;
614 var func = null;
615 if (typeof(funcOrStr) != 'undefined') {
616 obj = objOrFunc;
617 func = funcOrStr;
618 if (typeof(funcOrStr) == 'string') {
619 if (typeof(objOrFunc[funcOrStr]) != "function") {
620 throw new Error("'funcOrStr' must be a function on 'objOrFunc'");
621 }
622 } else if (typeof(funcOrStr) != 'function') {
623 throw new Error("'funcOrStr' must be a function or string");
624 }
625 } else if (typeof(objOrFunc) != "function") {
626 throw new Error("'objOrFunc' must be a function if 'funcOrStr' is not given");
627 } else {
628 func = objOrFunc;
629 }
630 return [obj, func];
631 },
632
633 /** @id MochiKit.Signal.connect */
634 connect: function (src, sig, objOrFunc/* optional */, funcOrStr) {
635 src = MochiKit.DOM.getElement(src);
636 var self = MochiKit.Signal;
637
638 if (typeof(sig) != 'string') {
639 throw new Error("'sig' must be a string");
640 }
641
642 var destPair = self._getDestPair(objOrFunc, funcOrStr);
643 var obj = destPair[0];
644 var func = destPair[1];
645 if (typeof(obj) == 'undefined' || obj === null) {
646 obj = src;
647 }
648
649 var isDOM = !!(src.addEventListener || src.attachEvent);
650 if (isDOM && (sig === "onmouseenter" || sig === "onmouseleave")
651 && !self._browserAlreadyHasMouseEnterAndLeave()) {
652 var listener = self._mouseEnterListener(src, sig.substr(2), func, obj);
653 if (sig === "onmouseenter") {
654 sig = "onmouseover";
655 } else {
656 sig = "onmouseout";
657 }
658 } else {
659 var listener = self._listener(src, sig, func, obj, isDOM);
660 }
661
662 if (src.addEventListener) {
663 src.addEventListener(sig.substr(2), listener, false);
664 } else if (src.attachEvent) {
665 src.attachEvent(sig, listener); // useCapture unsupported
666 }
667
668 var ident = new MochiKit.Signal.Ident({
669 source: src,
670 signal: sig,
671 listener: listener,
672 isDOM: isDOM,
673 objOrFunc: objOrFunc,
674 funcOrStr: funcOrStr,
675 connected: true
676 });
677 self._observers.push(ident);
678
679 if (!isDOM && typeof(src.__connect__) == 'function') {
680 var args = MochiKit.Base.extend([ident], arguments, 1);
681 src.__connect__.apply(src, args);
682 }
683
684 return ident;
685 },
686
687 _disconnect: function (ident) {
688 // already disconnected
689 if (!ident.connected) {
690 return;
691 }
692 ident.connected = false;
693 // check isDOM
694 if (!ident.isDOM) {
695 return;
696 }
697 var src = ident.source;
698 var sig = ident.signal;
699 var listener = ident.listener;
700
701 if (src.removeEventListener) {
702 src.removeEventListener(sig.substr(2), listener, false);
703 } else if (src.detachEvent) {
704 src.detachEvent(sig, listener); // useCapture unsupported
705 } else {
706 throw new Error("'src' must be a DOM element");
707 }
708 },
709
710 /** @id MochiKit.Signal.disconnect */
711 disconnect: function (ident) {
712 var self = MochiKit.Signal;
713 var observers = self._observers;
714 var m = MochiKit.Base;
715 if (arguments.length > 1) {
716 // compatibility API
717 var src = MochiKit.DOM.getElement(arguments[0]);
718 var sig = arguments[1];
719 var obj = arguments[2];
720 var func = arguments[3];
721 for (var i = observers.length - 1; i >= 0; i--) {
722 var o = observers[i];
723 if (o.source === src && o.signal === sig && o.objOrFunc === obj && o.funcOrStr === func) {
724 self._disconnect(o);
725 if (!self._lock) {
726 observers.splice(i, 1);
727 } else {
728 self._dirty = true;
729 }
730 return true;
731 }
732 }
733 } else {
734 var idx = m.findIdentical(observers, ident);
735 if (idx >= 0) {
736 self._disconnect(ident);
737 if (!self._lock) {
738 observers.splice(idx, 1);
739 } else {
740 self._dirty = true;
741 }
742 return true;
743 }
744 }
745 return false;
746 },
747
748 /** @id MochiKit.Signal.disconnectAllTo */
749 disconnectAllTo: function (objOrFunc, /* optional */funcOrStr) {
750 var self = MochiKit.Signal;
751 var observers = self._observers;
752 var disconnect = self._disconnect;
753 var locked = self._lock;
754 var dirty = self._dirty;
755 if (typeof(funcOrStr) === 'undefined') {
756 funcOrStr = null;
757 }
758 for (var i = observers.length - 1; i >= 0; i--) {
759 var ident = observers[i];
760 if (ident.objOrFunc === objOrFunc &&
761 (funcOrStr === null || ident.funcOrStr === funcOrStr)) {
762 disconnect(ident);
763 if (locked) {
764 dirty = true;
765 } else {
766 observers.splice(i, 1);
767 }
768 }
769 }
770 self._dirty = dirty;
771 },
772
773 /** @id MochiKit.Signal.disconnectAll */
774 disconnectAll: function (src/* optional */, sig) {
775 src = MochiKit.DOM.getElement(src);
776 var m = MochiKit.Base;
777 var signals = m.flattenArguments(m.extend(null, arguments, 1));
778 var self = MochiKit.Signal;
779 var disconnect = self._disconnect;
780 var observers = self._observers;
781 var i, ident;
782 var locked = self._lock;
783 var dirty = self._dirty;
784 if (signals.length === 0) {
785 // disconnect all
786 for (i = observers.length - 1; i >= 0; i--) {
787 ident = observers[i];
788 if (ident.source === src) {
789 disconnect(ident);
790 if (!locked) {
791 observers.splice(i, 1);
792 } else {
793 dirty = true;
794 }
795 }
796 }
797 } else {
798 var sigs = {};
799 for (i = 0; i < signals.length; i++) {
800 sigs[signals[i]] = true;
801 }
802 for (i = observers.length - 1; i >= 0; i--) {
803 ident = observers[i];
804 if (ident.source === src && ident.signal in sigs) {
805 disconnect(ident);
806 if (!locked) {
807 observers.splice(i, 1);
808 } else {
809 dirty = true;
810 }
811 }
812 }
813 }
814 self._dirty = dirty;
815 },
816
817 /** @id MochiKit.Signal.signal */
818 signal: function (src, sig) {
819 var self = MochiKit.Signal;
820 var observers = self._observers;
821 src = MochiKit.DOM.getElement(src);
822 var args = MochiKit.Base.extend(null, arguments, 2);
823 var errors = [];
824 self._lock = true;
825 for (var i = 0; i < observers.length; i++) {
826 var ident = observers[i];
827 if (ident.source === src && ident.signal === sig &&
828 ident.connected) {
829 try {
830 ident.listener.apply(src, args);
831 } catch (e) {
832 errors.push(e);
833 }
834 }
835 }
836 self._lock = false;
837 if (self._dirty) {
838 self._dirty = false;
839 for (var i = observers.length - 1; i >= 0; i--) {
840 if (!observers[i].connected) {
841 observers.splice(i, 1);
842 }
843 }
844 }
845 if (errors.length == 1) {
846 throw errors[0];
847 } else if (errors.length > 1) {
848 var e = new Error("Multiple errors thrown in handling 'sig', see errors property");
849 e.errors = errors;
850 throw e;
851 }
852 }
853
854 });
855
856 MochiKit.Signal.EXPORT_OK = [];
857
858 MochiKit.Signal.EXPORT = [
859 'connect',
860 'disconnect',
861 'signal',
862 'disconnectAll',
863 'disconnectAllTo'
864 ];
865
866 MochiKit.Signal.__new__ = function (win) {
867 var m = MochiKit.Base;
868 this._document = document;
869 this._window = win;
870 this._lock = false;
871 this._dirty = false;
872
873 try {
874 this.connect(window, 'onunload', this._unloadCache);
875 } catch (e) {
876 // pass: might not be a browser
877 }
878
879 this.EXPORT_TAGS = {
880 ':common': this.EXPORT,
881 ':all': m.concat(this.EXPORT, this.EXPORT_OK)
882 };
883
884 m.nameFunctions(this);
885 };
886
887 MochiKit.Signal.__new__(this);
888
889 //
890 // XXX: Internet Explorer blows
891 //
892 if (MochiKit.__export__) {
893 connect = MochiKit.Signal.connect;
894 disconnect = MochiKit.Signal.disconnect;
895 disconnectAll = MochiKit.Signal.disconnectAll;
896 signal = MochiKit.Signal.signal;
897 }
898
899 MochiKit.Base._exportSymbols(this, MochiKit.Signal);

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial