5740b6ca99a75218b272a6998f139d7d9ff1e65c
[clinton/lisp-on-lines.git] / wwwroot / prototype-1.3.1.js
1 /* Prototype JavaScript framework, version 1.3.1
2 * (c) 2005 Sam Stephenson <sam@conio.net>
3 *
4 * THIS FILE IS AUTOMATICALLY GENERATED. When sending patches, please diff
5 * against the source tree, available from the Prototype darcs repository.
6 *
7 * Prototype is freely distributable under the terms of an MIT-style license.
8 *
9 * For details, see the Prototype web site: http://prototype.conio.net/
10 *
11 /*--------------------------------------------------------------------------*/
12
13 var Prototype = {
14 Version: '1.3.1',
15 emptyFunction: function() {}
16 }
17
18 var Class = {
19 create: function() {
20 return function() {
21 this.initialize.apply(this, arguments);
22 }
23 }
24 }
25
26 var Abstract = new Object();
27
28 Object.extend = function(destination, source) {
29 for (property in source) {
30 destination[property] = source[property];
31 }
32 return destination;
33 }
34
35 Object.prototype.extend = function(object) {
36 return Object.extend.apply(this, [this, object]);
37 }
38
39 Function.prototype.bind = function(object) {
40 var __method = this;
41 return function() {
42 __method.apply(object, arguments);
43 }
44 }
45
46 Function.prototype.bindAsEventListener = function(object) {
47 var __method = this;
48 return function(event) {
49 __method.call(object, event || window.event);
50 }
51 }
52
53 Number.prototype.toColorPart = function() {
54 var digits = this.toString(16);
55 if (this < 16) return '0' + digits;
56 return digits;
57 }
58
59 var Try = {
60 these: function() {
61 var returnValue;
62
63 for (var i = 0; i < arguments.length; i++) {
64 var lambda = arguments[i];
65 try {
66 returnValue = lambda();
67 break;
68 } catch (e) {}
69 }
70
71 return returnValue;
72 }
73 }
74
75 /*--------------------------------------------------------------------------*/
76
77 var PeriodicalExecuter = Class.create();
78 PeriodicalExecuter.prototype = {
79 initialize: function(callback, frequency) {
80 this.callback = callback;
81 this.frequency = frequency;
82 this.currentlyExecuting = false;
83
84 this.registerCallback();
85 },
86
87 registerCallback: function() {
88 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
89 },
90
91 onTimerEvent: function() {
92 if (!this.currentlyExecuting) {
93 try {
94 this.currentlyExecuting = true;
95 this.callback();
96 } finally {
97 this.currentlyExecuting = false;
98 }
99 }
100 }
101 }
102
103 /*--------------------------------------------------------------------------*/
104
105 function $() {
106 var elements = new Array();
107
108 for (var i = 0; i < arguments.length; i++) {
109 var element = arguments[i];
110 if (typeof element == 'string')
111 element = document.getElementById(element);
112
113 if (arguments.length == 1)
114 return element;
115
116 elements.push(element);
117 }
118
119 return elements;
120 }
121
122 if (!Array.prototype.push) {
123 Array.prototype.push = function() {
124 var startLength = this.length;
125 for (var i = 0; i < arguments.length; i++)
126 this[startLength + i] = arguments[i];
127 return this.length;
128 }
129 }
130
131 if (!Function.prototype.apply) {
132 // Based on code from http://www.youngpup.net/
133 Function.prototype.apply = function(object, parameters) {
134 var parameterStrings = new Array();
135 if (!object) object = window;
136 if (!parameters) parameters = new Array();
137
138 for (var i = 0; i < parameters.length; i++)
139 parameterStrings[i] = 'parameters[' + i + ']';
140
141 object.__apply__ = this;
142 var result = eval('object.__apply__(' +
143 parameterStrings.join(', ') + ')');
144 object.__apply__ = null;
145
146 return result;
147 }
148 }
149
150 String.prototype.extend({
151 stripTags: function() {
152 return this.replace(/<\/?[^>]+>/gi, '');
153 },
154
155 escapeHTML: function() {
156 var div = document.createElement('div');
157 var text = document.createTextNode(this);
158 div.appendChild(text);
159 return div.innerHTML;
160 },
161
162 unescapeHTML: function() {
163 var div = document.createElement('div');
164 div.innerHTML = this.stripTags();
165 return div.childNodes[0].nodeValue;
166 }
167 });
168
169 var Ajax = {
170 getTransport: function() {
171 return Try.these(
172 function() {return new ActiveXObject('Msxml2.XMLHTTP')},
173 function() {return new ActiveXObject('Microsoft.XMLHTTP')},
174 function() {return new XMLHttpRequest()}
175 ) || false;
176 }
177 }
178
179 Ajax.Base = function() {};
180 Ajax.Base.prototype = {
181 setOptions: function(options) {
182 this.options = {
183 method: 'post',
184 asynchronous: true,
185 parameters: ''
186 }.extend(options || {});
187 },
188
189 responseIsSuccess: function() {
190 return this.transport.status == undefined
191 || this.transport.status == 0
192 || (this.transport.status >= 200 && this.transport.status < 300);
193 },
194
195 responseIsFailure: function() {
196 return !this.responseIsSuccess();
197 }
198 }
199
200 Ajax.Request = Class.create();
201 Ajax.Request.Events =
202 ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
203
204 Ajax.Request.prototype = (new Ajax.Base()).extend({
205 initialize: function(url, options) {
206 this.transport = Ajax.getTransport();
207 this.setOptions(options);
208 this.request(url);
209 },
210
211 request: function(url) {
212 var parameters = this.options.parameters || '';
213 if (parameters.length > 0) parameters += '&_=';
214
215 try {
216 if (this.options.method == 'get')
217 url += '?' + parameters;
218
219 this.transport.open(this.options.method, url,
220 this.options.asynchronous);
221
222 if (this.options.asynchronous) {
223 this.transport.onreadystatechange = this.onStateChange.bind(this);
224 setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
225 }
226
227 this.setRequestHeaders();
228
229 var body = this.options.postBody ? this.options.postBody : parameters;
230 this.transport.send(this.options.method == 'post' ? body : null);
231
232 } catch (e) {
233 }
234 },
235
236 setRequestHeaders: function() {
237 var requestHeaders =
238 ['X-Requested-With', 'XMLHttpRequest',
239 'X-Prototype-Version', Prototype.Version];
240
241 if (this.options.method == 'post') {
242 requestHeaders.push('Content-type',
243 'application/x-www-form-urlencoded');
244
245 /* Force "Connection: close" for Mozilla browsers to work around
246 * a bug where XMLHttpReqeuest sends an incorrect Content-length
247 * header. See Mozilla Bugzilla #246651.
248 */
249 if (this.transport.overrideMimeType)
250 requestHeaders.push('Connection', 'close');
251 }
252
253 if (this.options.requestHeaders)
254 requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
255
256 for (var i = 0; i < requestHeaders.length; i += 2)
257 this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
258 },
259
260 onStateChange: function() {
261 var readyState = this.transport.readyState;
262 if (readyState != 1)
263 this.respondToReadyState(this.transport.readyState);
264 },
265
266 respondToReadyState: function(readyState) {
267 var event = Ajax.Request.Events[readyState];
268
269 if (event == 'Complete')
270 (this.options['on' + this.transport.status]
271 || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
272 || Prototype.emptyFunction)(this.transport);
273
274 (this.options['on' + event] || Prototype.emptyFunction)(this.transport);
275
276 /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
277 if (event == 'Complete')
278 this.transport.onreadystatechange = Prototype.emptyFunction;
279 }
280 });
281
282 Ajax.Updater = Class.create();
283 Ajax.Updater.ScriptFragment = '(?:<script.*?>)((\n|.)*?)(?:<\/script>)';
284
285 Ajax.Updater.prototype.extend(Ajax.Request.prototype).extend({
286 initialize: function(container, url, options) {
287 this.containers = {
288 success: container.success ? $(container.success) : $(container),
289 failure: container.failure ? $(container.failure) :
290 (container.success ? null : $(container))
291 }
292
293 this.transport = Ajax.getTransport();
294 this.setOptions(options);
295
296 var onComplete = this.options.onComplete || Prototype.emptyFunction;
297 this.options.onComplete = (function() {
298 this.updateContent();
299 onComplete(this.transport);
300 }).bind(this);
301
302 this.request(url);
303 },
304
305 updateContent: function() {
306 var receiver = this.responseIsSuccess() ?
307 this.containers.success : this.containers.failure;
308
309 var match = new RegExp(Ajax.Updater.ScriptFragment, 'img');
310 var response = this.transport.responseText.replace(match, '');
311 var scripts = this.transport.responseText.match(match);
312
313 if (receiver) {
314 if (this.options.insertion) {
315 new this.options.insertion(receiver, response);
316 } else {
317 receiver.innerHTML = response;
318 }
319 }
320
321 if (this.responseIsSuccess()) {
322 if (this.onComplete)
323 setTimeout((function() {this.onComplete(
324 this.transport)}).bind(this), 10);
325 }
326
327 if (this.options.evalScripts && scripts) {
328 match = new RegExp(Ajax.Updater.ScriptFragment, 'im');
329 setTimeout((function() {
330 for (var i = 0; i < scripts.length; i++)
331 eval(scripts[i].match(match)[1]);
332 }).bind(this), 10);
333 }
334 }
335 });
336
337 Ajax.PeriodicalUpdater = Class.create();
338 Ajax.PeriodicalUpdater.prototype = (new Ajax.Base()).extend({
339 initialize: function(container, url, options) {
340 this.setOptions(options);
341 this.onComplete = this.options.onComplete;
342
343 this.frequency = (this.options.frequency || 2);
344 this.decay = 1;
345
346 this.updater = {};
347 this.container = container;
348 this.url = url;
349
350 this.start();
351 },
352
353 start: function() {
354 this.options.onComplete = this.updateComplete.bind(this);
355 this.onTimerEvent();
356 },
357
358 stop: function() {
359 this.updater.onComplete = undefined;
360 clearTimeout(this.timer);
361 (this.onComplete || Ajax.emptyFunction).apply(this, arguments);
362 },
363
364 updateComplete: function(request) {
365 if (this.options.decay) {
366 this.decay = (request.responseText == this.lastText ?
367 this.decay * this.options.decay : 1);
368
369 this.lastText = request.responseText;
370 }
371 this.timer = setTimeout(this.onTimerEvent.bind(this),
372 this.decay * this.frequency * 1000);
373 },
374
375 onTimerEvent: function() {
376 this.updater = new Ajax.Updater(this.container, this.url, this.options);
377 }
378 });
379
380 document.getElementsByClassName = function(className) {
381 var children = document.getElementsByTagName('*') || document.all;
382 var elements = new Array();
383
384 for (var i = 0; i < children.length; i++) {
385 var child = children[i];
386 var classNames = child.className.split(' ');
387 for (var j = 0; j < classNames.length; j++) {
388 if (classNames[j] == className) {
389 elements.push(child);
390 break;
391 }
392 }
393 }
394
395 return elements;
396 }
397
398 /*--------------------------------------------------------------------------*/
399
400 if (!window.Element) {
401 var Element = new Object();
402 }
403
404 Object.extend(Element, {
405 toggle: function() {
406 for (var i = 0; i < arguments.length; i++) {
407 var element = $(arguments[i]);
408 element.style.display =
409 (element.style.display == 'none' ? '' : 'none');
410 }
411 },
412
413 hide: function() {
414 for (var i = 0; i < arguments.length; i++) {
415 var element = $(arguments[i]);
416 element.style.display = 'none';
417 }
418 },
419
420 show: function() {
421 for (var i = 0; i < arguments.length; i++) {
422 var element = $(arguments[i]);
423 element.style.display = '';
424 }
425 },
426
427 remove: function(element) {
428 element = $(element);
429 element.parentNode.removeChild(element);
430 },
431
432 getHeight: function(element) {
433 element = $(element);
434 return element.offsetHeight;
435 },
436
437 hasClassName: function(element, className) {
438 element = $(element);
439 if (!element)
440 return;
441 var a = element.className.split(' ');
442 for (var i = 0; i < a.length; i++) {
443 if (a[i] == className)
444 return true;
445 }
446 return false;
447 },
448
449 addClassName: function(element, className) {
450 element = $(element);
451 Element.removeClassName(element, className);
452 element.className += ' ' + className;
453 },
454
455 removeClassName: function(element, className) {
456 element = $(element);
457 if (!element)
458 return;
459 var newClassName = '';
460 var a = element.className.split(' ');
461 for (var i = 0; i < a.length; i++) {
462 if (a[i] != className) {
463 if (i > 0)
464 newClassName += ' ';
465 newClassName += a[i];
466 }
467 }
468 element.className = newClassName;
469 },
470
471 // removes whitespace-only text node children
472 cleanWhitespace: function(element) {
473 var element = $(element);
474 for (var i = 0; i < element.childNodes.length; i++) {
475 var node = element.childNodes[i];
476 if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
477 Element.remove(node);
478 }
479 }
480 });
481
482 var Toggle = new Object();
483 Toggle.display = Element.toggle;
484
485 /*--------------------------------------------------------------------------*/
486
487 Abstract.Insertion = function(adjacency) {
488 this.adjacency = adjacency;
489 }
490
491 Abstract.Insertion.prototype = {
492 initialize: function(element, content) {
493 this.element = $(element);
494 this.content = content;
495
496 if (this.adjacency && this.element.insertAdjacentHTML) {
497 this.element.insertAdjacentHTML(this.adjacency, this.content);
498 } else {
499 this.range = this.element.ownerDocument.createRange();
500 if (this.initializeRange) this.initializeRange();
501 this.fragment = this.range.createContextualFragment(this.content);
502 this.insertContent();
503 }
504 }
505 }
506
507 var Insertion = new Object();
508
509 Insertion.Before = Class.create();
510 Insertion.Before.prototype = (new Abstract.Insertion('beforeBegin')).extend({
511 initializeRange: function() {
512 this.range.setStartBefore(this.element);
513 },
514
515 insertContent: function() {
516 this.element.parentNode.insertBefore(this.fragment, this.element);
517 }
518 });
519
520 Insertion.Top = Class.create();
521 Insertion.Top.prototype = (new Abstract.Insertion('afterBegin')).extend({
522 initializeRange: function() {
523 this.range.selectNodeContents(this.element);
524 this.range.collapse(true);
525 },
526
527 insertContent: function() {
528 this.element.insertBefore(this.fragment, this.element.firstChild);
529 }
530 });
531
532 Insertion.Bottom = Class.create();
533 Insertion.Bottom.prototype = (new Abstract.Insertion('beforeEnd')).extend({
534 initializeRange: function() {
535 this.range.selectNodeContents(this.element);
536 this.range.collapse(this.element);
537 },
538
539 insertContent: function() {
540 this.element.appendChild(this.fragment);
541 }
542 });
543
544 Insertion.After = Class.create();
545 Insertion.After.prototype = (new Abstract.Insertion('afterEnd')).extend({
546 initializeRange: function() {
547 this.range.setStartAfter(this.element);
548 },
549
550 insertContent: function() {
551 this.element.parentNode.insertBefore(this.fragment,
552 this.element.nextSibling);
553 }
554 });
555
556 var Field = {
557 clear: function() {
558 for (var i = 0; i < arguments.length; i++)
559 $(arguments[i]).value = '';
560 },
561
562 focus: function(element) {
563 $(element).focus();
564 },
565
566 present: function() {
567 for (var i = 0; i < arguments.length; i++)
568 if ($(arguments[i]).value == '') return false;
569 return true;
570 },
571
572 select: function(element) {
573 $(element).select();
574 },
575
576 activate: function(element) {
577 $(element).focus();
578 $(element).select();
579 }
580 }
581
582 /*--------------------------------------------------------------------------*/
583
584 var Form = {
585 serialize: function(form) {
586 var elements = Form.getElements($(form));
587 var queryComponents = new Array();
588
589 for (var i = 0; i < elements.length; i++) {
590 var queryComponent = Form.Element.serialize(elements[i]);
591 if (queryComponent)
592 queryComponents.push(queryComponent);
593 }
594
595 return queryComponents.join('&');
596 },
597
598 getElements: function(form) {
599 var form = $(form);
600 var elements = new Array();
601
602 for (tagName in Form.Element.Serializers) {
603 var tagElements = form.getElementsByTagName(tagName);
604 for (var j = 0; j < tagElements.length; j++)
605 elements.push(tagElements[j]);
606 }
607 return elements;
608 },
609
610 getInputs: function(form, typeName, name) {
611 var form = $(form);
612 var inputs = form.getElementsByTagName('input');
613
614 if (!typeName && !name)
615 return inputs;
616
617 var matchingInputs = new Array();
618 for (var i = 0; i < inputs.length; i++) {
619 var input = inputs[i];
620 if ((typeName && input.type != typeName) ||
621 (name && input.name != name))
622 continue;
623 matchingInputs.push(input);
624 }
625
626 return matchingInputs;
627 },
628
629 disable: function(form) {
630 var elements = Form.getElements(form);
631 for (var i = 0; i < elements.length; i++) {
632 var element = elements[i];
633 element.blur();
634 element.disabled = 'true';
635 }
636 },
637
638 enable: function(form) {
639 var elements = Form.getElements(form);
640 for (var i = 0; i < elements.length; i++) {
641 var element = elements[i];
642 element.disabled = '';
643 }
644 },
645
646 focusFirstElement: function(form) {
647 var form = $(form);
648 var elements = Form.getElements(form);
649 for (var i = 0; i < elements.length; i++) {
650 var element = elements[i];
651 if (element.type != 'hidden' && !element.disabled) {
652 Field.activate(element);
653 break;
654 }
655 }
656 },
657
658 reset: function(form) {
659 $(form).reset();
660 }
661 }
662
663 Form.Element = {
664 serialize: function(element) {
665 var element = $(element);
666 var method = element.tagName.toLowerCase();
667 var parameter = Form.Element.Serializers[method](element);
668
669 if (parameter)
670 return encodeURIComponent(parameter[0]) + '=' +
671 encodeURIComponent(parameter[1]);
672 },
673
674 getValue: function(element) {
675 var element = $(element);
676 var method = element.tagName.toLowerCase();
677 var parameter = Form.Element.Serializers[method](element);
678
679 if (parameter)
680 return parameter[1];
681 }
682 }
683
684 Form.Element.Serializers = {
685 input: function(element) {
686 switch (element.type.toLowerCase()) {
687 case 'submit':
688 case 'hidden':
689 case 'password':
690 case 'text':
691 return Form.Element.Serializers.textarea(element);
692 case 'checkbox':
693 case 'radio':
694 return Form.Element.Serializers.inputSelector(element);
695 }
696 return false;
697 },
698
699 inputSelector: function(element) {
700 if (element.checked)
701 return [element.name, element.value];
702 },
703
704 textarea: function(element) {
705 return [element.name, element.value];
706 },
707
708 select: function(element) {
709 var value = '';
710 if (element.type == 'select-one') {
711 var index = element.selectedIndex;
712 if (index >= 0)
713 value = element.options[index].value || element.options[index].text;
714 } else {
715 value = new Array();
716 for (var i = 0; i < element.length; i++) {
717 var opt = element.options[i];
718 if (opt.selected)
719 value.push(opt.value || opt.text);
720 }
721 }
722 return [element.name, value];
723 }
724 }
725
726 /*--------------------------------------------------------------------------*/
727
728 var $F = Form.Element.getValue;
729
730 /*--------------------------------------------------------------------------*/
731
732 Abstract.TimedObserver = function() {}
733 Abstract.TimedObserver.prototype = {
734 initialize: function(element, frequency, callback) {
735 this.frequency = frequency;
736 this.element = $(element);
737 this.callback = callback;
738
739 this.lastValue = this.getValue();
740 this.registerCallback();
741 },
742
743 registerCallback: function() {
744 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
745 },
746
747 onTimerEvent: function() {
748 var value = this.getValue();
749 if (this.lastValue != value) {
750 this.callback(this.element, value);
751 this.lastValue = value;
752 }
753 }
754 }
755
756 Form.Element.Observer = Class.create();
757 Form.Element.Observer.prototype = (new Abstract.TimedObserver()).extend({
758 getValue: function() {
759 return Form.Element.getValue(this.element);
760 }
761 });
762
763 Form.Observer = Class.create();
764 Form.Observer.prototype = (new Abstract.TimedObserver()).extend({
765 getValue: function() {
766 return Form.serialize(this.element);
767 }
768 });
769
770 /*--------------------------------------------------------------------------*/
771
772 Abstract.EventObserver = function() {}
773 Abstract.EventObserver.prototype = {
774 initialize: function(element, callback) {
775 this.element = $(element);
776 this.callback = callback;
777
778 this.lastValue = this.getValue();
779 if (this.element.tagName.toLowerCase() == 'form')
780 this.registerFormCallbacks();
781 else
782 this.registerCallback(this.element);
783 },
784
785 onElementEvent: function() {
786 var value = this.getValue();
787 if (this.lastValue != value) {
788 this.callback(this.element, value);
789 this.lastValue = value;
790 }
791 },
792
793 registerFormCallbacks: function() {
794 var elements = Form.getElements(this.element);
795 for (var i = 0; i < elements.length; i++)
796 this.registerCallback(elements[i]);
797 },
798
799 registerCallback: function(element) {
800 if (element.type) {
801 switch (element.type.toLowerCase()) {
802 case 'checkbox':
803 case 'radio':
804 element.target = this;
805 element.prev_onclick = element.onclick || Prototype.emptyFunction;
806 element.onclick = function() {
807 this.prev_onclick();
808 this.target.onElementEvent();
809 }
810 break;
811 case 'password':
812 case 'text':
813 case 'textarea':
814 case 'select-one':
815 case 'select-multiple':
816 element.target = this;
817 element.prev_onchange = element.onchange || Prototype.emptyFunction;
818 element.onchange = function() {
819 this.prev_onchange();
820 this.target.onElementEvent();
821 }
822 break;
823 }
824 }
825 }
826 }
827
828 Form.Element.EventObserver = Class.create();
829 Form.Element.EventObserver.prototype = (new Abstract.EventObserver()).extend({
830 getValue: function() {
831 return Form.Element.getValue(this.element);
832 }
833 });
834
835 Form.EventObserver = Class.create();
836 Form.EventObserver.prototype = (new Abstract.EventObserver()).extend({
837 getValue: function() {
838 return Form.serialize(this.element);
839 }
840 });
841
842
843 if (!window.Event) {
844 var Event = new Object();
845 }
846
847 Object.extend(Event, {
848 KEY_BACKSPACE: 8,
849 KEY_TAB: 9,
850 KEY_RETURN: 13,
851 KEY_ESC: 27,
852 KEY_LEFT: 37,
853 KEY_UP: 38,
854 KEY_RIGHT: 39,
855 KEY_DOWN: 40,
856 KEY_DELETE: 46,
857
858 element: function(event) {
859 return event.target || event.srcElement;
860 },
861
862 isLeftClick: function(event) {
863 return (((event.which) && (event.which == 1)) ||
864 ((event.button) && (event.button == 1)));
865 },
866
867 pointerX: function(event) {
868 return event.pageX || (event.clientX +
869 (document.documentElement.scrollLeft || document.body.scrollLeft));
870 },
871
872 pointerY: function(event) {
873 return event.pageY || (event.clientY +
874 (document.documentElement.scrollTop || document.body.scrollTop));
875 },
876
877 stop: function(event) {
878 if (event.preventDefault) {
879 event.preventDefault();
880 event.stopPropagation();
881 } else {
882 event.returnValue = false;
883 }
884 },
885
886 // find the first node with the given tagName, starting from the
887 // node the event was triggered on; traverses the DOM upwards
888 findElement: function(event, tagName) {
889 var element = Event.element(event);
890 while (element.parentNode && (!element.tagName ||
891 (element.tagName.toUpperCase() != tagName.toUpperCase())))
892 element = element.parentNode;
893 return element;
894 },
895
896 observers: false,
897
898 _observeAndCache: function(element, name, observer, useCapture) {
899 if (!this.observers) this.observers = [];
900 if (element.addEventListener) {
901 this.observers.push([element, name, observer, useCapture]);
902 element.addEventListener(name, observer, useCapture);
903 } else if (element.attachEvent) {
904 this.observers.push([element, name, observer, useCapture]);
905 element.attachEvent('on' + name, observer);
906 }
907 },
908
909 unloadCache: function() {
910 if (!Event.observers) return;
911 for (var i = 0; i < Event.observers.length; i++) {
912 Event.stopObserving.apply(this, Event.observers[i]);
913 Event.observers[i][0] = null;
914 }
915 Event.observers = false;
916 },
917
918 observe: function(element, name, observer, useCapture) {
919 var element = $(element);
920 useCapture = useCapture || false;
921
922 if (name == 'keypress' &&
923 ((navigator.appVersion.indexOf('AppleWebKit') > 0)
924 || element.attachEvent))
925 name = 'keydown';
926
927 this._observeAndCache(element, name, observer, useCapture);
928 },
929
930 stopObserving: function(element, name, observer, useCapture) {
931 var element = $(element);
932 useCapture = useCapture || false;
933
934 if (name == 'keypress' &&
935 ((navigator.appVersion.indexOf('AppleWebKit') > 0)
936 || element.detachEvent))
937 name = 'keydown';
938
939 if (element.removeEventListener) {
940 element.removeEventListener(name, observer, useCapture);
941 } else if (element.detachEvent) {
942 element.detachEvent('on' + name, observer);
943 }
944 }
945 });
946
947 /* prevent memory leaks in IE */
948 Event.observe(window, 'unload', Event.unloadCache, false);
949
950 var Position = {
951
952 // set to true if needed, warning: firefox performance problems
953 // NOT neeeded for page scrolling, only if draggable contained in
954 // scrollable elements
955 includeScrollOffsets: false,
956
957 // must be called before calling withinIncludingScrolloffset, every time the
958 // page is scrolled
959 prepare: function() {
960 this.deltaX = window.pageXOffset
961 || document.documentElement.scrollLeft
962 || document.body.scrollLeft
963 || 0;
964 this.deltaY = window.pageYOffset
965 || document.documentElement.scrollTop
966 || document.body.scrollTop
967 || 0;
968 },
969
970 realOffset: function(element) {
971 var valueT = 0, valueL = 0;
972 do {
973 valueT += element.scrollTop || 0;
974 valueL += element.scrollLeft || 0;
975 element = element.parentNode;
976 } while (element);
977 return [valueL, valueT];
978 },
979
980 cumulativeOffset: function(element) {
981 var valueT = 0, valueL = 0;
982 do {
983 valueT += element.offsetTop || 0;
984 valueL += element.offsetLeft || 0;
985 element = element.offsetParent;
986 } while (element);
987 return [valueL, valueT];
988 },
989
990 // caches x/y coordinate pair to use with overlap
991 within: function(element, x, y) {
992 if (this.includeScrollOffsets)
993 return this.withinIncludingScrolloffsets(element, x, y);
994 this.xcomp = x;
995 this.ycomp = y;
996 this.offset = this.cumulativeOffset(element);
997
998 return (y >= this.offset[1] &&
999 y < this.offset[1] + element.offsetHeight &&
1000 x >= this.offset[0] &&
1001 x < this.offset[0] + element.offsetWidth);
1002 },
1003
1004 withinIncludingScrolloffsets: function(element, x, y) {
1005 var offsetcache = this.realOffset(element);
1006
1007 this.xcomp = x + offsetcache[0] - this.deltaX;
1008 this.ycomp = y + offsetcache[1] - this.deltaY;
1009 this.offset = this.cumulativeOffset(element);
1010
1011 return (this.ycomp >= this.offset[1] &&
1012 this.ycomp < this.offset[1] + element.offsetHeight &&
1013 this.xcomp >= this.offset[0] &&
1014 this.xcomp < this.offset[0] + element.offsetWidth);
1015 },
1016
1017 // within must be called directly before
1018 overlap: function(mode, element) {
1019 if (!mode) return 0;
1020 if (mode == 'vertical')
1021 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
1022 element.offsetHeight;
1023 if (mode == 'horizontal')
1024 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
1025 element.offsetWidth;
1026 },
1027
1028 clone: function(source, target) {
1029 source = $(source);
1030 target = $(target);
1031 target.style.position = 'absolute';
1032 var offsets = this.cumulativeOffset(source);
1033 target.style.top = offsets[1] + 'px';
1034 target.style.left = offsets[0] + 'px';
1035 target.style.width = source.offsetWidth + 'px';
1036 target.style.height = source.offsetHeight + 'px';
1037 }
1038 }