To get this branch, use:
bzr branch
http://darksoft.org/webbzr/adei/ui
« back to all changes in this revision
Viewing changes to includes/prototype.js.1.5.1
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Suren A. Chilingaryan
- Date: 2008-04-02 10:23:22 UTC
- Revision ID: csa@dside.dyndns.org-20080402102322-okib92sicg2dx3o3
Initial import
- files added:
- apps
- apps/csv2root
- apps/mod_root2
- apps/mod_root2/conf
- classes
- classes/cache
- classes/handlers
- classes/readers
- classes/stream
- classes/time
- docs
- docs/databases
- docs/templates
- docs/templates/32bit
- docs/templates/64bit
- images
- includes
- includes/cropper
- includes/cropper.1.2
- includes/dhtmlx
- includes/dhtmlx/imgs
- includes/ext
- includes/ext/adapter
- includes/ext/adapter/ext
- includes/ext/adapter/jquery
- includes/ext/adapter/prototype
- includes/ext/adapter/yui
- includes/scriptaculous
- includes/scriptaculous.1.7.0
- includes/scriptaculous/extra
- js
- modules
- services
- setups
- setups/katrin
- setups/toska
- storage
- system
- tmp
added
removed
includes/prototype.js.1.5.1
1
/* Prototype JavaScript framework, version 1.5.1
2
* (c) 2005-2007 Sam Stephenson
3
*
4
* Prototype is freely distributable under the terms of an MIT-style license.
5
* For details, see the Prototype web site: http://www.prototypejs.org/
6
*
7
/*--------------------------------------------------------------------------*/
8
9
var Prototype = {
10
Version: '1.5.1',
11
12
Browser: {
13
IE: !!(window.attachEvent && !window.opera),
14
Opera: !!window.opera,
15
WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
16
Gecko: navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1
17
},
18
19
BrowserFeatures: {
20
XPath: !!document.evaluate,
21
ElementExtensions: !!window.HTMLElement,
22
SpecificElementExtensions:
23
(document.createElement('div').__proto__ !==
24
document.createElement('form').__proto__)
25
},
26
27
ScriptFragment: '<script[^>]*>([\u0001-\uFFFF]*?)</script>',
28
JSONFilter: /^\/\*-secure-\s*(.*)\s*\*\/\s*$/,
29
30
emptyFunction: function() { },
31
K: function(x) { return x }
32
}
33
34
var Class = {
35
create: function() {
36
return function() {
37
this.initialize.apply(this, arguments);
38
}
39
}
40
}
41
42
var Abstract = new Object();
43
44
Object.extend = function(destination, source) {
45
for (var property in source) {
46
destination[property] = source[property];
47
}
48
return destination;
49
}
50
51
Object.extend(Object, {
52
inspect: function(object) {
53
try {
54
if (object === undefined) return 'undefined';
55
if (object === null) return 'null';
56
return object.inspect ? object.inspect() : object.toString();
57
} catch (e) {
58
if (e instanceof RangeError) return '...';
59
throw e;
60
}
61
},
62
63
toJSON: function(object) {
64
var type = typeof object;
65
switch(type) {
66
case 'undefined':
67
case 'function':
68
case 'unknown': return;
69
case 'boolean': return object.toString();
70
}
71
if (object === null) return 'null';
72
if (object.toJSON) return object.toJSON();
73
if (object.ownerDocument === document) return;
74
var results = [];
75
for (var property in object) {
76
var value = Object.toJSON(object[property]);
77
if (value !== undefined)
78
results.push(property.toJSON() + ': ' + value);
79
}
80
return '{' + results.join(', ') + '}';
81
},
82
83
keys: function(object) {
84
var keys = [];
85
for (var property in object)
86
keys.push(property);
87
return keys;
88
},
89
90
values: function(object) {
91
var values = [];
92
for (var property in object)
93
values.push(object[property]);
94
return values;
95
},
96
97
clone: function(object) {
98
return Object.extend({}, object);
99
}
100
});
101
102
Function.prototype.bind = function() {
103
var __method = this, args = $A(arguments), object = args.shift();
104
return function() {
105
return __method.apply(object, args.concat($A(arguments)));
106
}
107
}
108
109
Function.prototype.bindAsEventListener = function(object) {
110
var __method = this, args = $A(arguments), object = args.shift();
111
return function(event) {
112
return __method.apply(object, [event || window.event].concat(args));
113
}
114
}
115
116
Object.extend(Number.prototype, {
117
toColorPart: function() {
118
return this.toPaddedString(2, 16);
119
},
120
121
succ: function() {
122
return this + 1;
123
},
124
125
times: function(iterator) {
126
$R(0, this, true).each(iterator);
127
return this;
128
},
129
130
toPaddedString: function(length, radix) {
131
var string = this.toString(radix || 10);
132
return '0'.times(length - string.length) + string;
133
},
134
135
toJSON: function() {
136
return isFinite(this) ? this.toString() : 'null';
137
}
138
});
139
140
Date.prototype.toJSON = function() {
141
return '"' + this.getFullYear() + '-' +
142
(this.getMonth() + 1).toPaddedString(2) + '-' +
143
this.getDate().toPaddedString(2) + 'T' +
144
this.getHours().toPaddedString(2) + ':' +
145
this.getMinutes().toPaddedString(2) + ':' +
146
this.getSeconds().toPaddedString(2) + '"';
147
};
148
149
var Try = {
150
these: function() {
151
var returnValue;
152
153
for (var i = 0, length = arguments.length; i < length; i++) {
154
var lambda = arguments[i];
155
try {
156
returnValue = lambda();
157
break;
158
} catch (e) {}
159
}
160
161
return returnValue;
162
}
163
}
164
165
/*--------------------------------------------------------------------------*/
166
167
var PeriodicalExecuter = Class.create();
168
PeriodicalExecuter.prototype = {
169
initialize: function(callback, frequency) {
170
this.callback = callback;
171
this.frequency = frequency;
172
this.currentlyExecuting = false;
173
174
this.registerCallback();
175
},
176
177
registerCallback: function() {
178
this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
179
},
180
181
stop: function() {
182
if (!this.timer) return;
183
clearInterval(this.timer);
184
this.timer = null;
185
},
186
187
onTimerEvent: function() {
188
if (!this.currentlyExecuting) {
189
try {
190
this.currentlyExecuting = true;
191
this.callback(this);
192
} finally {
193
this.currentlyExecuting = false;
194
}
195
}
196
}
197
}
198
Object.extend(String, {
199
interpret: function(value) {
200
return value == null ? '' : String(value);
201
},
202
specialChar: {
203
'\b': '\\b',
204
'\t': '\\t',
205
'\n': '\\n',
206
'\f': '\\f',
207
'\r': '\\r',
208
'\\': '\\\\'
209
}
210
});
211
212
Object.extend(String.prototype, {
213
gsub: function(pattern, replacement) {
214
var result = '', source = this, match;
215
replacement = arguments.callee.prepareReplacement(replacement);
216
217
while (source.length > 0) {
218
if (match = source.match(pattern)) {
219
result += source.slice(0, match.index);
220
result += String.interpret(replacement(match));
221
source = source.slice(match.index + match[0].length);
222
} else {
223
result += source, source = '';
224
}
225
}
226
return result;
227
},
228
229
sub: function(pattern, replacement, count) {
230
replacement = this.gsub.prepareReplacement(replacement);
231
count = count === undefined ? 1 : count;
232
233
return this.gsub(pattern, function(match) {
234
if (--count < 0) return match[0];
235
return replacement(match);
236
});
237
},
238
239
scan: function(pattern, iterator) {
240
this.gsub(pattern, iterator);
241
return this;
242
},
243
244
truncate: function(length, truncation) {
245
length = length || 30;
246
truncation = truncation === undefined ? '...' : truncation;
247
return this.length > length ?
248
this.slice(0, length - truncation.length) + truncation : this;
249
},
250
251
strip: function() {
252
return this.replace(/^\s+/, '').replace(/\s+$/, '');
253
},
254
255
stripTags: function() {
256
return this.replace(/<\/?[^>]+>/gi, '');
257
},
258
259
stripScripts: function() {
260
return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
261
},
262
263
extractScripts: function() {
264
var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
265
var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
266
return (this.match(matchAll) || []).map(function(scriptTag) {
267
return (scriptTag.match(matchOne) || ['', ''])[1];
268
});
269
},
270
271
evalScripts: function() {
272
return this.extractScripts().map(function(script) { return eval(script) });
273
},
274
275
escapeHTML: function() {
276
var self = arguments.callee;
277
self.text.data = this;
278
return self.div.innerHTML;
279
},
280
281
unescapeHTML: function() {
282
var div = document.createElement('div');
283
div.innerHTML = this.stripTags();
284
return div.childNodes[0] ? (div.childNodes.length > 1 ?
285
$A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
286
div.childNodes[0].nodeValue) : '';
287
},
288
289
toQueryParams: function(separator) {
290
var match = this.strip().match(/([^?#]*)(#.*)?$/);
291
if (!match) return {};
292
293
return match[1].split(separator || '&').inject({}, function(hash, pair) {
294
if ((pair = pair.split('='))[0]) {
295
var key = decodeURIComponent(pair.shift());
296
var value = pair.length > 1 ? pair.join('=') : pair[0];
297
if (value != undefined) value = decodeURIComponent(value);
298
299
if (key in hash) {
300
if (hash[key].constructor != Array) hash[key] = [hash[key]];
301
hash[key].push(value);
302
}
303
else hash[key] = value;
304
}
305
return hash;
306
});
307
},
308
309
toArray: function() {
310
return this.split('');
311
},
312
313
succ: function() {
314
return this.slice(0, this.length - 1) +
315
String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
316
},
317
318
times: function(count) {
319
var result = '';
320
for (var i = 0; i < count; i++) result += this;
321
return result;
322
},
323
324
camelize: function() {
325
var parts = this.split('-'), len = parts.length;
326
if (len == 1) return parts[0];
327
328
var camelized = this.charAt(0) == '-'
329
? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
330
: parts[0];
331
332
for (var i = 1; i < len; i++)
333
camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
334
335
return camelized;
336
},
337
338
capitalize: function() {
339
return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
340
},
341
342
underscore: function() {
343
return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
344
},
345
346
dasherize: function() {
347
return this.gsub(/_/,'-');
348
},
349
350
inspect: function(useDoubleQuotes) {
351
var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
352
var character = String.specialChar[match[0]];
353
return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
354
});
355
if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
356
return "'" + escapedString.replace(/'/g, '\\\'') + "'";
357
},
358
359
toJSON: function() {
360
return this.inspect(true);
361
},
362
363
unfilterJSON: function(filter) {
364
return this.sub(filter || Prototype.JSONFilter, '#{1}');
365
},
366
367
evalJSON: function(sanitize) {
368
var json = this.unfilterJSON();
369
try {
370
if (!sanitize || (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.test(json)))
371
return eval('(' + json + ')');
372
} catch (e) { }
373
throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
374
},
375
376
include: function(pattern) {
377
return this.indexOf(pattern) > -1;
378
},
379
380
startsWith: function(pattern) {
381
return this.indexOf(pattern) === 0;
382
},
383
384
endsWith: function(pattern) {
385
var d = this.length - pattern.length;
386
return d >= 0 && this.lastIndexOf(pattern) === d;
387
},
388
389
empty: function() {
390
return this == '';
391
},
392
393
blank: function() {
394
return /^\s*$/.test(this);
395
}
396
});
397
398
if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
399
escapeHTML: function() {
400
return this.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
401
},
402
unescapeHTML: function() {
403
return this.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
404
}
405
});
406
407
String.prototype.gsub.prepareReplacement = function(replacement) {
408
if (typeof replacement == 'function') return replacement;
409
var template = new Template(replacement);
410
return function(match) { return template.evaluate(match) };
411
}
412
413
String.prototype.parseQuery = String.prototype.toQueryParams;
414
415
Object.extend(String.prototype.escapeHTML, {
416
div: document.createElement('div'),
417
text: document.createTextNode('')
418
});
419
420
with (String.prototype.escapeHTML) div.appendChild(text);
421
422
var Template = Class.create();
423
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
424
Template.prototype = {
425
initialize: function(template, pattern) {
426
this.template = template.toString();
427
this.pattern = pattern || Template.Pattern;
428
},
429
430
evaluate: function(object) {
431
return this.template.gsub(this.pattern, function(match) {
432
var before = match[1];
433
if (before == '\\') return match[2];
434
return before + String.interpret(object[match[3]]);
435
});
436
}
437
}
438
439
var $break = {}, $continue = new Error('"throw $continue" is deprecated, use "return" instead');
440
441
var Enumerable = {
442
each: function(iterator) {
443
var index = 0;
444
try {
445
this._each(function(value) {
446
iterator(value, index++);
447
});
448
} catch (e) {
449
if (e != $break) throw e;
450
}
451
return this;
452
},
453
454
eachSlice: function(number, iterator) {
455
var index = -number, slices = [], array = this.toArray();
456
while ((index += number) < array.length)
457
slices.push(array.slice(index, index+number));
458
return slices.map(iterator);
459
},
460
461
all: function(iterator) {
462
var result = true;
463
this.each(function(value, index) {
464
result = result && !!(iterator || Prototype.K)(value, index);
465
if (!result) throw $break;
466
});
467
return result;
468
},
469
470
any: function(iterator) {
471
var result = false;
472
this.each(function(value, index) {
473
if (result = !!(iterator || Prototype.K)(value, index))
474
throw $break;
475
});
476
return result;
477
},
478
479
collect: function(iterator) {
480
var results = [];
481
this.each(function(value, index) {
482
results.push((iterator || Prototype.K)(value, index));
483
});
484
return results;
485
},
486
487
detect: function(iterator) {
488
var result;
489
this.each(function(value, index) {
490
if (iterator(value, index)) {
491
result = value;
492
throw $break;
493
}
494
});
495
return result;
496
},
497
498
findAll: function(iterator) {
499
var results = [];
500
this.each(function(value, index) {
501
if (iterator(value, index))
502
results.push(value);
503
});
504
return results;
505
},
506
507
grep: function(pattern, iterator) {
508
var results = [];
509
this.each(function(value, index) {
510
var stringValue = value.toString();
511
if (stringValue.match(pattern))
512
results.push((iterator || Prototype.K)(value, index));
513
})
514
return results;
515
},
516
517
include: function(object) {
518
var found = false;
519
this.each(function(value) {
520
if (value == object) {
521
found = true;
522
throw $break;
523
}
524
});
525
return found;
526
},
527
528
inGroupsOf: function(number, fillWith) {
529
fillWith = fillWith === undefined ? null : fillWith;
530
return this.eachSlice(number, function(slice) {
531
while(slice.length < number) slice.push(fillWith);
532
return slice;
533
});
534
},
535
536
inject: function(memo, iterator) {
537
this.each(function(value, index) {
538
memo = iterator(memo, value, index);
539
});
540
return memo;
541
},
542
543
invoke: function(method) {
544
var args = $A(arguments).slice(1);
545
return this.map(function(value) {
546
return value[method].apply(value, args);
547
});
548
},
549
550
max: function(iterator) {
551
var result;
552
this.each(function(value, index) {
553
value = (iterator || Prototype.K)(value, index);
554
if (result == undefined || value >= result)
555
result = value;
556
});
557
return result;
558
},
559
560
min: function(iterator) {
561
var result;
562
this.each(function(value, index) {
563
value = (iterator || Prototype.K)(value, index);
564
if (result == undefined || value < result)
565
result = value;
566
});
567
return result;
568
},
569
570
partition: function(iterator) {
571
var trues = [], falses = [];
572
this.each(function(value, index) {
573
((iterator || Prototype.K)(value, index) ?
574
trues : falses).push(value);
575
});
576
return [trues, falses];
577
},
578
579
pluck: function(property) {
580
var results = [];
581
this.each(function(value, index) {
582
results.push(value[property]);
583
});
584
return results;
585
},
586
587
reject: function(iterator) {
588
var results = [];
589
this.each(function(value, index) {
590
if (!iterator(value, index))
591
results.push(value);
592
});
593
return results;
594
},
595
596
sortBy: function(iterator) {
597
return this.map(function(value, index) {
598
return {value: value, criteria: iterator(value, index)};
599
}).sort(function(left, right) {
600
var a = left.criteria, b = right.criteria;
601
return a < b ? -1 : a > b ? 1 : 0;
602
}).pluck('value');
603
},
604
605
toArray: function() {
606
return this.map();
607
},
608
609
zip: function() {
610
var iterator = Prototype.K, args = $A(arguments);
611
if (typeof args.last() == 'function')
612
iterator = args.pop();
613
614
var collections = [this].concat(args).map($A);
615
return this.map(function(value, index) {
616
return iterator(collections.pluck(index));
617
});
618
},
619
620
size: function() {
621
return this.toArray().length;
622
},
623
624
inspect: function() {
625
return '#<Enumerable:' + this.toArray().inspect() + '>';
626
}
627
}
628
629
Object.extend(Enumerable, {
630
map: Enumerable.collect,
631
find: Enumerable.detect,
632
select: Enumerable.findAll,
633
member: Enumerable.include,
634
entries: Enumerable.toArray
635
});
636
var $A = Array.from = function(iterable) {
637
if (!iterable) return [];
638
if (iterable.toArray) {
639
return iterable.toArray();
640
} else {
641
var results = [];
642
for (var i = 0, length = iterable.length; i < length; i++)
643
results.push(iterable[i]);
644
return results;
645
}
646
}
647
648
if (Prototype.Browser.WebKit) {
649
$A = Array.from = function(iterable) {
650
if (!iterable) return [];
651
if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
652
iterable.toArray) {
653
return iterable.toArray();
654
} else {
655
var results = [];
656
for (var i = 0, length = iterable.length; i < length; i++)
657
results.push(iterable[i]);
658
return results;
659
}
660
}
661
}
662
663
Object.extend(Array.prototype, Enumerable);
664
665
if (!Array.prototype._reverse)
666
Array.prototype._reverse = Array.prototype.reverse;
667
668
Object.extend(Array.prototype, {
669
_each: function(iterator) {
670
for (var i = 0, length = this.length; i < length; i++)
671
iterator(this[i]);
672
},
673
674
clear: function() {
675
this.length = 0;
676
return this;
677
},
678
679
first: function() {
680
return this[0];
681
},
682
683
last: function() {
684
return this[this.length - 1];
685
},
686
687
compact: function() {
688
return this.select(function(value) {
689
return value != null;
690
});
691
},
692
693
flatten: function() {
694
return this.inject([], function(array, value) {
695
return array.concat(value && value.constructor == Array ?
696
value.flatten() : [value]);
697
});
698
},
699
700
without: function() {
701
var values = $A(arguments);
702
return this.select(function(value) {
703
return !values.include(value);
704
});
705
},
706
707
indexOf: function(object) {
708
for (var i = 0, length = this.length; i < length; i++)
709
if (this[i] == object) return i;
710
return -1;
711
},
712
713
reverse: function(inline) {
714
return (inline !== false ? this : this.toArray())._reverse();
715
},
716
717
reduce: function() {
718
return this.length > 1 ? this : this[0];
719
},
720
721
uniq: function(sorted) {
722
return this.inject([], function(array, value, index) {
723
if (0 == index || (sorted ? array.last() != value : !array.include(value)))
724
array.push(value);
725
return array;
726
});
727
},
728
729
clone: function() {
730
return [].concat(this);
731
},
732
733
size: function() {
734
return this.length;
735
},
736
737
inspect: function() {
738
return '[' + this.map(Object.inspect).join(', ') + ']';
739
},
740
741
toJSON: function() {
742
var results = [];
743
this.each(function(object) {
744
var value = Object.toJSON(object);
745
if (value !== undefined) results.push(value);
746
});
747
return '[' + results.join(', ') + ']';
748
}
749
});
750
751
Array.prototype.toArray = Array.prototype.clone;
752
753
function $w(string) {
754
string = string.strip();
755
return string ? string.split(/\s+/) : [];
756
}
757
758
if (Prototype.Browser.Opera){
759
Array.prototype.concat = function() {
760
var array = [];
761
for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
762
for (var i = 0, length = arguments.length; i < length; i++) {
763
if (arguments[i].constructor == Array) {
764
for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
765
array.push(arguments[i][j]);
766
} else {
767
array.push(arguments[i]);
768
}
769
}
770
return array;
771
}
772
}
773
var Hash = function(object) {
774
if (object instanceof Hash) this.merge(object);
775
else Object.extend(this, object || {});
776
};
777
778
Object.extend(Hash, {
779
toQueryString: function(obj) {
780
var parts = [];
781
parts.add = arguments.callee.addPair;
782
783
this.prototype._each.call(obj, function(pair) {
784
if (!pair.key) return;
785
var value = pair.value;
786
787
if (value && typeof value == 'object') {
788
if (value.constructor == Array) value.each(function(value) {
789
parts.add(pair.key, value);
790
});
791
return;
792
}
793
parts.add(pair.key, value);
794
});
795
796
return parts.join('&');
797
},
798
799
toJSON: function(object) {
800
var results = [];
801
this.prototype._each.call(object, function(pair) {
802
var value = Object.toJSON(pair.value);
803
if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);
804
});
805
return '{' + results.join(', ') + '}';
806
}
807
});
808
809
Hash.toQueryString.addPair = function(key, value, prefix) {
810
key = encodeURIComponent(key);
811
if (value === undefined) this.push(key);
812
else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));
813
}
814
815
Object.extend(Hash.prototype, Enumerable);
816
Object.extend(Hash.prototype, {
817
_each: function(iterator) {
818
for (var key in this) {
819
var value = this[key];
820
if (value && value == Hash.prototype[key]) continue;
821
822
var pair = [key, value];
823
pair.key = key;
824
pair.value = value;
825
iterator(pair);
826
}
827
},
828
829
keys: function() {
830
return this.pluck('key');
831
},
832
833
values: function() {
834
return this.pluck('value');
835
},
836
837
merge: function(hash) {
838
return $H(hash).inject(this, function(mergedHash, pair) {
839
mergedHash[pair.key] = pair.value;
840
return mergedHash;
841
});
842
},
843
844
remove: function() {
845
var result;
846
for(var i = 0, length = arguments.length; i < length; i++) {
847
var value = this[arguments[i]];
848
if (value !== undefined){
849
if (result === undefined) result = value;
850
else {
851
if (result.constructor != Array) result = [result];
852
result.push(value)
853
}
854
}
855
delete this[arguments[i]];
856
}
857
return result;
858
},
859
860
toQueryString: function() {
861
return Hash.toQueryString(this);
862
},
863
864
inspect: function() {
865
return '#<Hash:{' + this.map(function(pair) {
866
return pair.map(Object.inspect).join(': ');
867
}).join(', ') + '}>';
868
},
869
870
toJSON: function() {
871
return Hash.toJSON(this);
872
}
873
});
874
875
function $H(object) {
876
if (object instanceof Hash) return object;
877
return new Hash(object);
878
};
879
880
// Safari iterates over shadowed properties
881
if (function() {
882
var i = 0, Test = function(value) { this.key = value };
883
Test.prototype.key = 'foo';
884
for (var property in new Test('bar')) i++;
885
return i > 1;
886
}()) Hash.prototype._each = function(iterator) {
887
var cache = [];
888
for (var key in this) {
889
var value = this[key];
890
if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;
891
cache.push(key);
892
var pair = [key, value];
893
pair.key = key;
894
pair.value = value;
895
iterator(pair);
896
}
897
};
898
ObjectRange = Class.create();
899
Object.extend(ObjectRange.prototype, Enumerable);
900
Object.extend(ObjectRange.prototype, {
901
initialize: function(start, end, exclusive) {
902
this.start = start;
903
this.end = end;
904
this.exclusive = exclusive;
905
},
906
907
_each: function(iterator) {
908
var value = this.start;
909
while (this.include(value)) {
910
iterator(value);
911
value = value.succ();
912
}
913
},
914
915
include: function(value) {
916
if (value < this.start)
917
return false;
918
if (this.exclusive)
919
return value < this.end;
920
return value <= this.end;
921
}
922
});
923
924
var $R = function(start, end, exclusive) {
925
return new ObjectRange(start, end, exclusive);
926
}
927
928
var Ajax = {
929
getTransport: function() {
930
return Try.these(
931
function() {return new XMLHttpRequest()},
932
function() {return new ActiveXObject('Msxml2.XMLHTTP')},
933
function() {return new ActiveXObject('Microsoft.XMLHTTP')}
934
) || false;
935
},
936
937
activeRequestCount: 0
938
}
939
940
Ajax.Responders = {
941
responders: [],
942
943
_each: function(iterator) {
944
this.responders._each(iterator);
945
},
946
947
register: function(responder) {
948
if (!this.include(responder))
949
this.responders.push(responder);
950
},
951
952
unregister: function(responder) {
953
this.responders = this.responders.without(responder);
954
},
955
956
dispatch: function(callback, request, transport, json) {
957
this.each(function(responder) {
958
if (typeof responder[callback] == 'function') {
959
try {
960
responder[callback].apply(responder, [request, transport, json]);
961
} catch (e) {}
962
}
963
});
964
}
965
};
966
967
Object.extend(Ajax.Responders, Enumerable);
968
969
Ajax.Responders.register({
970
onCreate: function() {
971
Ajax.activeRequestCount++;
972
},
973
onComplete: function() {
974
Ajax.activeRequestCount--;
975
}
976
});
977
978
Ajax.Base = function() {};
979
Ajax.Base.prototype = {
980
setOptions: function(options) {
981
this.options = {
982
method: 'post',
983
asynchronous: true,
984
contentType: 'application/x-www-form-urlencoded',
985
encoding: 'UTF-8',
986
parameters: ''
987
}
988
Object.extend(this.options, options || {});
989
990
this.options.method = this.options.method.toLowerCase();
991
if (typeof this.options.parameters == 'string')
992
this.options.parameters = this.options.parameters.toQueryParams();
993
}
994
}
995
996
Ajax.Request = Class.create();
997
Ajax.Request.Events =
998
['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
999
1000
Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
1001
_complete: false,
1002
1003
initialize: function(url, options) {
1004
this.transport = Ajax.getTransport();
1005
this.setOptions(options);
1006
this.request(url);
1007
},
1008
1009
request: function(url) {
1010
this.url = url;
1011
this.method = this.options.method;
1012
var params = Object.clone(this.options.parameters);
1013
1014
if (!['get', 'post'].include(this.method)) {
1015
// simulate other verbs over post
1016
params['_method'] = this.method;
1017
this.method = 'post';
1018
}
1019
1020
this.parameters = params;
1021
1022
if (params = Hash.toQueryString(params)) {
1023
// when GET, append parameters to URL
1024
if (this.method == 'get')
1025
this.url += (this.url.include('?') ? '&' : '?') + params;
1026
else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
1027
params += '&_=';
1028
}
1029
1030
try {
1031
if (this.options.onCreate) this.options.onCreate(this.transport);
1032
Ajax.Responders.dispatch('onCreate', this, this.transport);
1033
1034
this.transport.open(this.method.toUpperCase(), this.url,
1035
this.options.asynchronous);
1036
1037
if (this.options.asynchronous)
1038
setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);
1039
1040
this.transport.onreadystatechange = this.onStateChange.bind(this);
1041
this.setRequestHeaders();
1042
1043
this.body = this.method == 'post' ? (this.options.postBody || params) : null;
1044
this.transport.send(this.body);
1045
1046
/* Force Firefox to handle ready state 4 for synchronous requests */
1047
if (!this.options.asynchronous && this.transport.overrideMimeType)
1048
this.onStateChange();
1049
1050
}
1051
catch (e) {
1052
this.dispatchException(e);
1053
}
1054
},
1055
1056
onStateChange: function() {
1057
var readyState = this.transport.readyState;
1058
if (readyState > 1 && !((readyState == 4) && this._complete))
1059
this.respondToReadyState(this.transport.readyState);
1060
},
1061
1062
setRequestHeaders: function() {
1063
var headers = {
1064
'X-Requested-With': 'XMLHttpRequest',
1065
'X-Prototype-Version': Prototype.Version,
1066
'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
1067
};
1068
1069
if (this.method == 'post') {
1070
headers['Content-type'] = this.options.contentType +
1071
(this.options.encoding ? '; charset=' + this.options.encoding : '');
1072
1073
/* Force "Connection: close" for older Mozilla browsers to work
1074
* around a bug where XMLHttpRequest sends an incorrect
1075
* Content-length header. See Mozilla Bugzilla #246651.
1076
*/
1077
if (this.transport.overrideMimeType &&
1078
(navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
1079
headers['Connection'] = 'close';
1080
}
1081
1082
// user-defined headers
1083
if (typeof this.options.requestHeaders == 'object') {
1084
var extras = this.options.requestHeaders;
1085
1086
if (typeof extras.push == 'function')
1087
for (var i = 0, length = extras.length; i < length; i += 2)
1088
headers[extras[i]] = extras[i+1];
1089
else
1090
$H(extras).each(function(pair) { headers[pair.key] = pair.value });
1091
}
1092
1093
for (var name in headers)
1094
this.transport.setRequestHeader(name, headers[name]);
1095
},
1096
1097
success: function() {
1098
return !this.transport.status
1099
|| (this.transport.status >= 200 && this.transport.status < 300);
1100
},
1101
1102
respondToReadyState: function(readyState) {
1103
var state = Ajax.Request.Events[readyState];
1104
var transport = this.transport, json = this.evalJSON();
1105
1106
if (state == 'Complete') {
1107
try {
1108
this._complete = true;
1109
(this.options['on' + this.transport.status]
1110
|| this.options['on' + (this.success() ? 'Success' : 'Failure')]
1111
|| Prototype.emptyFunction)(transport, json);
1112
} catch (e) {
1113
this.dispatchException(e);
1114
}
1115
1116
var contentType = this.getHeader('Content-type');
1117
if (contentType && contentType.strip().
1118
match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
1119
this.evalResponse();
1120
}
1121
1122
try {
1123
(this.options['on' + state] || Prototype.emptyFunction)(transport, json);
1124
Ajax.Responders.dispatch('on' + state, this, transport, json);
1125
} catch (e) {
1126
this.dispatchException(e);
1127
}
1128
1129
if (state == 'Complete') {
1130
// avoid memory leak in MSIE: clean up
1131
this.transport.onreadystatechange = Prototype.emptyFunction;
1132
}
1133
},
1134
1135
getHeader: function(name) {
1136
try {
1137
return this.transport.getResponseHeader(name);
1138
} catch (e) { return null }
1139
},
1140
1141
evalJSON: function() {
1142
try {
1143
var json = this.getHeader('X-JSON');
1144
return json ? json.evalJSON() : null;
1145
} catch (e) { return null }
1146
},
1147
1148
evalResponse: function() {
1149
try {
1150
return eval((this.transport.responseText || '').unfilterJSON());
1151
} catch (e) {
1152
this.dispatchException(e);
1153
}
1154
},
1155
1156
dispatchException: function(exception) {
1157
(this.options.onException || Prototype.emptyFunction)(this, exception);
1158
Ajax.Responders.dispatch('onException', this, exception);
1159
}
1160
});
1161
1162
Ajax.Updater = Class.create();
1163
1164
Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
1165
initialize: function(container, url, options) {
1166
this.container = {
1167
success: (container.success || container),
1168
failure: (container.failure || (container.success ? null : container))
1169
}
1170
1171
this.transport = Ajax.getTransport();
1172
this.setOptions(options);
1173
1174
var onComplete = this.options.onComplete || Prototype.emptyFunction;
1175
this.options.onComplete = (function(transport, param) {
1176
this.updateContent();
1177
onComplete(transport, param);
1178
}).bind(this);
1179
1180
this.request(url);
1181
},
1182
1183
updateContent: function() {
1184
var receiver = this.container[this.success() ? 'success' : 'failure'];
1185
var response = this.transport.responseText;
1186
1187
if (!this.options.evalScripts) response = response.stripScripts();
1188
1189
if (receiver = $(receiver)) {
1190
if (this.options.insertion)
1191
new this.options.insertion(receiver, response);
1192
else
1193
receiver.update(response);
1194
}
1195
1196
if (this.success()) {
1197
if (this.onComplete)
1198
setTimeout(this.onComplete.bind(this), 10);
1199
}
1200
}
1201
});
1202
1203
Ajax.PeriodicalUpdater = Class.create();
1204
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
1205
initialize: function(container, url, options) {
1206
this.setOptions(options);
1207
this.onComplete = this.options.onComplete;
1208
1209
this.frequency = (this.options.frequency || 2);
1210
this.decay = (this.options.decay || 1);
1211
1212
this.updater = {};
1213
this.container = container;
1214
this.url = url;
1215
1216
this.start();
1217
},
1218
1219
start: function() {
1220
this.options.onComplete = this.updateComplete.bind(this);
1221
this.onTimerEvent();
1222
},
1223
1224
stop: function() {
1225
this.updater.options.onComplete = undefined;
1226
clearTimeout(this.timer);
1227
(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
1228
},
1229
1230
updateComplete: function(request) {
1231
if (this.options.decay) {
1232
this.decay = (request.responseText == this.lastText ?
1233
this.decay * this.options.decay : 1);
1234
1235
this.lastText = request.responseText;
1236
}
1237
this.timer = setTimeout(this.onTimerEvent.bind(this),
1238
this.decay * this.frequency * 1000);
1239
},
1240
1241
onTimerEvent: function() {
1242
this.updater = new Ajax.Updater(this.container, this.url, this.options);
1243
}
1244
});
1245
function $(element) {
1246
if (arguments.length > 1) {
1247
for (var i = 0, elements = [], length = arguments.length; i < length; i++)
1248
elements.push($(arguments[i]));
1249
return elements;
1250
}
1251
if (typeof element == 'string')
1252
element = document.getElementById(element);
1253
return Element.extend(element);
1254
}
1255
1256
if (Prototype.BrowserFeatures.XPath) {
1257
document._getElementsByXPath = function(expression, parentElement) {
1258
var results = [];
1259
var query = document.evaluate(expression, $(parentElement) || document,
1260
null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
1261
for (var i = 0, length = query.snapshotLength; i < length; i++)
1262
results.push(query.snapshotItem(i));
1263
return results;
1264
};
1265
1266
document.getElementsByClassName = function(className, parentElement) {
1267
var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1268
return document._getElementsByXPath(q, parentElement);
1269
}
1270
1271
} else document.getElementsByClassName = function(className, parentElement) {
1272
var children = ($(parentElement) || document.body).getElementsByTagName('*');
1273
var elements = [], child;
1274
for (var i = 0, length = children.length; i < length; i++) {
1275
child = children[i];
1276
if (Element.hasClassName(child, className))
1277
elements.push(Element.extend(child));
1278
}
1279
return elements;
1280
};
1281
1282
/*--------------------------------------------------------------------------*/
1283
1284
if (!window.Element) var Element = {};
1285
1286
Element.extend = function(element) {
1287
var F = Prototype.BrowserFeatures;
1288
if (!element || !element.tagName || element.nodeType == 3 ||
1289
element._extended || F.SpecificElementExtensions || element == window)
1290
return element;
1291
1292
var methods = {}, tagName = element.tagName, cache = Element.extend.cache,
1293
T = Element.Methods.ByTag;
1294
1295
// extend methods for all tags (Safari doesn't need this)
1296
if (!F.ElementExtensions) {
1297
Object.extend(methods, Element.Methods),
1298
Object.extend(methods, Element.Methods.Simulated);
1299
}
1300
1301
// extend methods for specific tags
1302
if (T[tagName]) Object.extend(methods, T[tagName]);
1303
1304
for (var property in methods) {
1305
var value = methods[property];
1306
if (typeof value == 'function' && !(property in element))
1307
element[property] = cache.findOrStore(value);
1308
}
1309
1310
element._extended = Prototype.emptyFunction;
1311
return element;
1312
};
1313
1314
Element.extend.cache = {
1315
findOrStore: function(value) {
1316
return this[value] = this[value] || function() {
1317
return value.apply(null, [this].concat($A(arguments)));
1318
}
1319
}
1320
};
1321
1322
Element.Methods = {
1323
visible: function(element) {
1324
return $(element).style.display != 'none';
1325
},
1326
1327
toggle: function(element) {
1328
element = $(element);
1329
Element[Element.visible(element) ? 'hide' : 'show'](element);
1330
return element;
1331
},
1332
1333
hide: function(element) {
1334
$(element).style.display = 'none';
1335
return element;
1336
},
1337
1338
show: function(element) {
1339
$(element).style.display = '';
1340
return element;
1341
},
1342
1343
remove: function(element) {
1344
element = $(element);
1345
element.parentNode.removeChild(element);
1346
return element;
1347
},
1348
1349
update: function(element, html) {
1350
html = typeof html == 'undefined' ? '' : html.toString();
1351
$(element).innerHTML = html.stripScripts();
1352
setTimeout(function() {html.evalScripts()}, 10);
1353
return element;
1354
},
1355
1356
replace: function(element, html) {
1357
element = $(element);
1358
html = typeof html == 'undefined' ? '' : html.toString();
1359
if (element.outerHTML) {
1360
element.outerHTML = html.stripScripts();
1361
} else {
1362
var range = element.ownerDocument.createRange();
1363
range.selectNodeContents(element);
1364
element.parentNode.replaceChild(
1365
range.createContextualFragment(html.stripScripts()), element);
1366
}
1367
setTimeout(function() {html.evalScripts()}, 10);
1368
return element;
1369
},
1370
1371
inspect: function(element) {
1372
element = $(element);
1373
var result = '<' + element.tagName.toLowerCase();
1374
$H({'id': 'id', 'className': 'class'}).each(function(pair) {
1375
var property = pair.first(), attribute = pair.last();
1376
var value = (element[property] || '').toString();
1377
if (value) result += ' ' + attribute + '=' + value.inspect(true);
1378
});
1379
return result + '>';
1380
},
1381
1382
recursivelyCollect: function(element, property) {
1383
element = $(element);
1384
var elements = [];
1385
while (element = element[property])
1386
if (element.nodeType == 1)
1387
elements.push(Element.extend(element));
1388
return elements;
1389
},
1390
1391
ancestors: function(element) {
1392
return $(element).recursivelyCollect('parentNode');
1393
},
1394
1395
descendants: function(element) {
1396
return $A($(element).getElementsByTagName('*')).each(Element.extend);
1397
},
1398
1399
firstDescendant: function(element) {
1400
element = $(element).firstChild;
1401
while (element && element.nodeType != 1) element = element.nextSibling;
1402
return $(element);
1403
},
1404
1405
immediateDescendants: function(element) {
1406
if (!(element = $(element).firstChild)) return [];
1407
while (element && element.nodeType != 1) element = element.nextSibling;
1408
if (element) return [element].concat($(element).nextSiblings());
1409
return [];
1410
},
1411
1412
previousSiblings: function(element) {
1413
return $(element).recursivelyCollect('previousSibling');
1414
},
1415
1416
nextSiblings: function(element) {
1417
return $(element).recursivelyCollect('nextSibling');
1418
},
1419
1420
siblings: function(element) {
1421
element = $(element);
1422
return element.previousSiblings().reverse().concat(element.nextSiblings());
1423
},
1424
1425
match: function(element, selector) {
1426
if (typeof selector == 'string')
1427
selector = new Selector(selector);
1428
return selector.match($(element));
1429
},
1430
1431
up: function(element, expression, index) {
1432
element = $(element);
1433
if (arguments.length == 1) return $(element.parentNode);
1434
var ancestors = element.ancestors();
1435
return expression ? Selector.findElement(ancestors, expression, index) :
1436
ancestors[index || 0];
1437
},
1438
1439
down: function(element, expression, index) {
1440
element = $(element);
1441
if (arguments.length == 1) return element.firstDescendant();
1442
var descendants = element.descendants();
1443
return expression ? Selector.findElement(descendants, expression, index) :
1444
descendants[index || 0];
1445
},
1446
1447
previous: function(element, expression, index) {
1448
element = $(element);
1449
if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
1450
var previousSiblings = element.previousSiblings();
1451
return expression ? Selector.findElement(previousSiblings, expression, index) :
1452
previousSiblings[index || 0];
1453
},
1454
1455
next: function(element, expression, index) {
1456
element = $(element);
1457
if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
1458
var nextSiblings = element.nextSiblings();
1459
return expression ? Selector.findElement(nextSiblings, expression, index) :
1460
nextSiblings[index || 0];
1461
},
1462
1463
getElementsBySelector: function() {
1464
var args = $A(arguments), element = $(args.shift());
1465
return Selector.findChildElements(element, args);
1466
},
1467
1468
getElementsByClassName: function(element, className) {
1469
return document.getElementsByClassName(className, element);
1470
},
1471
1472
readAttribute: function(element, name) {
1473
element = $(element);
1474
if (Prototype.Browser.IE) {
1475
if (!element.attributes) return null;
1476
var t = Element._attributeTranslations;
1477
if (t.values[name]) return t.values[name](element, name);
1478
if (t.names[name]) name = t.names[name];
1479
var attribute = element.attributes[name];
1480
return attribute ? attribute.nodeValue : null;
1481
}
1482
return element.getAttribute(name);
1483
},
1484
1485
getHeight: function(element) {
1486
return $(element).getDimensions().height;
1487
},
1488
1489
getWidth: function(element) {
1490
return $(element).getDimensions().width;
1491
},
1492
1493
classNames: function(element) {
1494
return new Element.ClassNames(element);
1495
},
1496
1497
hasClassName: function(element, className) {
1498
if (!(element = $(element))) return;
1499
var elementClassName = element.className;
1500
if (elementClassName.length == 0) return false;
1501
if (elementClassName == className ||
1502
elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
1503
return true;
1504
return false;
1505
},
1506
1507
addClassName: function(element, className) {
1508
if (!(element = $(element))) return;
1509
Element.classNames(element).add(className);
1510
return element;
1511
},
1512
1513
removeClassName: function(element, className) {
1514
if (!(element = $(element))) return;
1515
Element.classNames(element).remove(className);
1516
return element;
1517
},
1518
1519
toggleClassName: function(element, className) {
1520
if (!(element = $(element))) return;
1521
Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
1522
return element;
1523
},
1524
1525
observe: function() {
1526
Event.observe.apply(Event, arguments);
1527
return $A(arguments).first();
1528
},
1529
1530
stopObserving: function() {
1531
Event.stopObserving.apply(Event, arguments);
1532
return $A(arguments).first();
1533
},
1534
1535
// removes whitespace-only text node children
1536
cleanWhitespace: function(element) {
1537
element = $(element);
1538
var node = element.firstChild;
1539
while (node) {
1540
var nextNode = node.nextSibling;
1541
if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
1542
element.removeChild(node);
1543
node = nextNode;
1544
}
1545
return element;
1546
},
1547
1548
empty: function(element) {
1549
return $(element).innerHTML.blank();
1550
},
1551
1552
descendantOf: function(element, ancestor) {
1553
element = $(element), ancestor = $(ancestor);
1554
while (element = element.parentNode)
1555
if (element == ancestor) return true;
1556
return false;
1557
},
1558
1559
scrollTo: function(element) {
1560
element = $(element);
1561
var pos = Position.cumulativeOffset(element);
1562
window.scrollTo(pos[0], pos[1]);
1563
return element;
1564
},
1565
1566
getStyle: function(element, style) {
1567
element = $(element);
1568
style = style == 'float' ? 'cssFloat' : style.camelize();
1569
var value = element.style[style];
1570
if (!value) {
1571
var css = document.defaultView.getComputedStyle(element, null);
1572
value = css ? css[style] : null;
1573
}
1574
if (style == 'opacity') return value ? parseFloat(value) : 1.0;
1575
return value == 'auto' ? null : value;
1576
},
1577
1578
getOpacity: function(element) {
1579
return $(element).getStyle('opacity');
1580
},
1581
1582
setStyle: function(element, styles, camelized) {
1583
element = $(element);
1584
var elementStyle = element.style;
1585
1586
for (var property in styles)
1587
if (property == 'opacity') element.setOpacity(styles[property])
1588
else
1589
elementStyle[(property == 'float' || property == 'cssFloat') ?
1590
(elementStyle.styleFloat === undefined ? 'cssFloat' : 'styleFloat') :
1591
(camelized ? property : property.camelize())] = styles[property];
1592
1593
return element;
1594
},
1595
1596
setOpacity: function(element, value) {
1597
element = $(element);
1598
element.style.opacity = (value == 1 || value === '') ? '' :
1599
(value < 0.00001) ? 0 : value;
1600
return element;
1601
},
1602
1603
getDimensions: function(element) {
1604
element = $(element);
1605
var display = $(element).getStyle('display');
1606
if (display != 'none' && display != null) // Safari bug
1607
return {width: element.offsetWidth, height: element.offsetHeight};
1608
1609
// All *Width and *Height properties give 0 on elements with display none,
1610
// so enable the element temporarily
1611
var els = element.style;
1612
var originalVisibility = els.visibility;
1613
var originalPosition = els.position;
1614
var originalDisplay = els.display;
1615
els.visibility = 'hidden';
1616
els.position = 'absolute';
1617
els.display = 'block';
1618
var originalWidth = element.clientWidth;
1619
var originalHeight = element.clientHeight;
1620
els.display = originalDisplay;
1621
els.position = originalPosition;
1622
els.visibility = originalVisibility;
1623
return {width: originalWidth, height: originalHeight};
1624
},
1625
1626
makePositioned: function(element) {
1627
element = $(element);
1628
var pos = Element.getStyle(element, 'position');
1629
if (pos == 'static' || !pos) {
1630
element._madePositioned = true;
1631
element.style.position = 'relative';
1632
// Opera returns the offset relative to the positioning context, when an
1633
// element is position relative but top and left have not been defined
1634
if (window.opera) {
1635
element.style.top = 0;
1636
element.style.left = 0;
1637
}
1638
}
1639
return element;
1640
},
1641
1642
undoPositioned: function(element) {
1643
element = $(element);
1644
if (element._madePositioned) {
1645
element._madePositioned = undefined;
1646
element.style.position =
1647
element.style.top =
1648
element.style.left =
1649
element.style.bottom =
1650
element.style.right = '';
1651
}
1652
return element;
1653
},
1654
1655
makeClipping: function(element) {
1656
element = $(element);
1657
if (element._overflow) return element;
1658
element._overflow = element.style.overflow || 'auto';
1659
if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
1660
element.style.overflow = 'hidden';
1661
return element;
1662
},
1663
1664
undoClipping: function(element) {
1665
element = $(element);
1666
if (!element._overflow) return element;
1667
element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
1668
element._overflow = null;
1669
return element;
1670
}
1671
};
1672
1673
Object.extend(Element.Methods, {
1674
childOf: Element.Methods.descendantOf,
1675
childElements: Element.Methods.immediateDescendants
1676
});
1677
1678
if (Prototype.Browser.Opera) {
1679
Element.Methods._getStyle = Element.Methods.getStyle;
1680
Element.Methods.getStyle = function(element, style) {
1681
switch(style) {
1682
case 'left':
1683
case 'top':
1684
case 'right':
1685
case 'bottom':
1686
if (Element._getStyle(element, 'position') == 'static') return null;
1687
default: return Element._getStyle(element, style);
1688
}
1689
};
1690
}
1691
else if (Prototype.Browser.IE) {
1692
Element.Methods.getStyle = function(element, style) {
1693
element = $(element);
1694
style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
1695
var value = element.style[style];
1696
if (!value && element.currentStyle) value = element.currentStyle[style];
1697
1698
if (style == 'opacity') {
1699
if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
1700
if (value[1]) return parseFloat(value[1]) / 100;
1701
return 1.0;
1702
}
1703
1704
if (value == 'auto') {
1705
if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
1706
return element['offset'+style.capitalize()] + 'px';
1707
return null;
1708
}
1709
return value;
1710
};
1711
1712
Element.Methods.setOpacity = function(element, value) {
1713
element = $(element);
1714
var filter = element.getStyle('filter'), style = element.style;
1715
if (value == 1 || value === '') {
1716
style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');
1717
return element;
1718
} else if (value < 0.00001) value = 0;
1719
style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +
1720
'alpha(opacity=' + (value * 100) + ')';
1721
return element;
1722
};
1723
1724
// IE is missing .innerHTML support for TABLE-related elements
1725
Element.Methods.update = function(element, html) {
1726
element = $(element);
1727
html = typeof html == 'undefined' ? '' : html.toString();
1728
var tagName = element.tagName.toUpperCase();
1729
if (['THEAD','TBODY','TR','TD'].include(tagName)) {
1730
var div = document.createElement('div');
1731
switch (tagName) {
1732
case 'THEAD':
1733
case 'TBODY':
1734
div.innerHTML = '<table><tbody>' + html.stripScripts() + '</tbody></table>';
1735
depth = 2;
1736
break;
1737
case 'TR':
1738
div.innerHTML = '<table><tbody><tr>' + html.stripScripts() + '</tr></tbody></table>';
1739
depth = 3;
1740
break;
1741
case 'TD':
1742
div.innerHTML = '<table><tbody><tr><td>' + html.stripScripts() + '</td></tr></tbody></table>';
1743
depth = 4;
1744
}
1745
$A(element.childNodes).each(function(node) { element.removeChild(node) });
1746
depth.times(function() { div = div.firstChild });
1747
$A(div.childNodes).each(function(node) { element.appendChild(node) });
1748
} else {
1749
element.innerHTML = html.stripScripts();
1750
}
1751
setTimeout(function() { html.evalScripts() }, 10);
1752
return element;
1753
}
1754
}
1755
else if (Prototype.Browser.Gecko) {
1756
Element.Methods.setOpacity = function(element, value) {
1757
element = $(element);
1758
element.style.opacity = (value == 1) ? 0.999999 :
1759
(value === '') ? '' : (value < 0.00001) ? 0 : value;
1760
return element;
1761
};
1762
}
1763
1764
Element._attributeTranslations = {
1765
names: {
1766
colspan: "colSpan",
1767
rowspan: "rowSpan",
1768
valign: "vAlign",
1769
datetime: "dateTime",
1770
accesskey: "accessKey",
1771
tabindex: "tabIndex",
1772
enctype: "encType",
1773
maxlength: "maxLength",
1774
readonly: "readOnly",
1775
longdesc: "longDesc"
1776
},
1777
values: {
1778
_getAttr: function(element, attribute) {
1779
return element.getAttribute(attribute, 2);
1780
},
1781
_flag: function(element, attribute) {
1782
return $(element).hasAttribute(attribute) ? attribute : null;
1783
},
1784
style: function(element) {
1785
return element.style.cssText.toLowerCase();
1786
},
1787
title: function(element) {
1788
var node = element.getAttributeNode('title');
1789
return node.specified ? node.nodeValue : null;
1790
}
1791
}
1792
};
1793
1794
(function() {
1795
Object.extend(this, {
1796
href: this._getAttr,
1797
src: this._getAttr,
1798
type: this._getAttr,
1799
disabled: this._flag,
1800
checked: this._flag,
1801
readonly: this._flag,
1802
multiple: this._flag
1803
});
1804
}).call(Element._attributeTranslations.values);
1805
1806
Element.Methods.Simulated = {
1807
hasAttribute: function(element, attribute) {
1808
var t = Element._attributeTranslations, node;
1809
attribute = t.names[attribute] || attribute;
1810
node = $(element).getAttributeNode(attribute);
1811
return node && node.specified;
1812
}
1813
};
1814
1815
Element.Methods.ByTag = {};
1816
1817
Object.extend(Element, Element.Methods);
1818
1819
if (!Prototype.BrowserFeatures.ElementExtensions &&
1820
document.createElement('div').__proto__) {
1821
window.HTMLElement = {};
1822
window.HTMLElement.prototype = document.createElement('div').__proto__;
1823
Prototype.BrowserFeatures.ElementExtensions = true;
1824
}
1825
1826
Element.hasAttribute = function(element, attribute) {
1827
if (element.hasAttribute) return element.hasAttribute(attribute);
1828
return Element.Methods.Simulated.hasAttribute(element, attribute);
1829
};
1830
1831
Element.addMethods = function(methods) {
1832
var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
1833
1834
if (!methods) {
1835
Object.extend(Form, Form.Methods);
1836
Object.extend(Form.Element, Form.Element.Methods);
1837
Object.extend(Element.Methods.ByTag, {
1838
"FORM": Object.clone(Form.Methods),
1839
"INPUT": Object.clone(Form.Element.Methods),
1840
"SELECT": Object.clone(Form.Element.Methods),
1841
"TEXTAREA": Object.clone(Form.Element.Methods)
1842
});
1843
}
1844
1845
if (arguments.length == 2) {
1846
var tagName = methods;
1847
methods = arguments[1];
1848
}
1849
1850
if (!tagName) Object.extend(Element.Methods, methods || {});
1851
else {
1852
if (tagName.constructor == Array) tagName.each(extend);
1853
else extend(tagName);
1854
}
1855
1856
function extend(tagName) {
1857
tagName = tagName.toUpperCase();
1858
if (!Element.Methods.ByTag[tagName])
1859
Element.Methods.ByTag[tagName] = {};
1860
Object.extend(Element.Methods.ByTag[tagName], methods);
1861
}
1862
1863
function copy(methods, destination, onlyIfAbsent) {
1864
onlyIfAbsent = onlyIfAbsent || false;
1865
var cache = Element.extend.cache;
1866
for (var property in methods) {
1867
var value = methods[property];
1868
if (!onlyIfAbsent || !(property in destination))
1869
destination[property] = cache.findOrStore(value);
1870
}
1871
}
1872
1873
function findDOMClass(tagName) {
1874
var klass;
1875
var trans = {
1876
"OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
1877
"FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
1878
"DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
1879
"H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
1880
"INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
1881
"TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
1882
"TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
1883
"TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
1884
"FrameSet", "IFRAME": "IFrame"
1885
};
1886
if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
1887
if (window[klass]) return window[klass];
1888
klass = 'HTML' + tagName + 'Element';
1889
if (window[klass]) return window[klass];
1890
klass = 'HTML' + tagName.capitalize() + 'Element';
1891
if (window[klass]) return window[klass];
1892
1893
window[klass] = {};
1894
window[klass].prototype = document.createElement(tagName).__proto__;
1895
return window[klass];
1896
}
1897
1898
if (F.ElementExtensions) {
1899
copy(Element.Methods, HTMLElement.prototype);
1900
copy(Element.Methods.Simulated, HTMLElement.prototype, true);
1901
}
1902
1903
if (F.SpecificElementExtensions) {
1904
for (var tag in Element.Methods.ByTag) {
1905
var klass = findDOMClass(tag);
1906
if (typeof klass == "undefined") continue;
1907
copy(T[tag], klass.prototype);
1908
}
1909
}
1910
1911
Object.extend(Element, Element.Methods);
1912
delete Element.ByTag;
1913
};
1914
1915
var Toggle = { display: Element.toggle };
1916
1917
/*--------------------------------------------------------------------------*/
1918
1919
Abstract.Insertion = function(adjacency) {
1920
this.adjacency = adjacency;
1921
}
1922
1923
Abstract.Insertion.prototype = {
1924
initialize: function(element, content) {
1925
this.element = $(element);
1926
this.content = content.stripScripts();
1927
1928
if (this.adjacency && this.element.insertAdjacentHTML) {
1929
try {
1930
this.element.insertAdjacentHTML(this.adjacency, this.content);
1931
} catch (e) {
1932
var tagName = this.element.tagName.toUpperCase();
1933
if (['TBODY', 'TR'].include(tagName)) {
1934
this.insertContent(this.contentFromAnonymousTable());
1935
} else {
1936
throw e;
1937
}
1938
}
1939
} else {
1940
this.range = this.element.ownerDocument.createRange();
1941
if (this.initializeRange) this.initializeRange();
1942
this.insertContent([this.range.createContextualFragment(this.content)]);
1943
}
1944
1945
setTimeout(function() {content.evalScripts()}, 10);
1946
},
1947
1948
contentFromAnonymousTable: function() {
1949
var div = document.createElement('div');
1950
div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
1951
return $A(div.childNodes[0].childNodes[0].childNodes);
1952
}
1953
}
1954
1955
var Insertion = new Object();
1956
1957
Insertion.Before = Class.create();
1958
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
1959
initializeRange: function() {
1960
this.range.setStartBefore(this.element);
1961
},
1962
1963
insertContent: function(fragments) {
1964
fragments.each((function(fragment) {
1965
this.element.parentNode.insertBefore(fragment, this.element);
1966
}).bind(this));
1967
}
1968
});
1969
1970
Insertion.Top = Class.create();
1971
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
1972
initializeRange: function() {
1973
this.range.selectNodeContents(this.element);
1974
this.range.collapse(true);
1975
},
1976
1977
insertContent: function(fragments) {
1978
fragments.reverse(false).each((function(fragment) {
1979
this.element.insertBefore(fragment, this.element.firstChild);
1980
}).bind(this));
1981
}
1982
});
1983
1984
Insertion.Bottom = Class.create();
1985
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
1986
initializeRange: function() {
1987
this.range.selectNodeContents(this.element);
1988
this.range.collapse(this.element);
1989
},
1990
1991
insertContent: function(fragments) {
1992
fragments.each((function(fragment) {
1993
this.element.appendChild(fragment);
1994
}).bind(this));
1995
}
1996
});
1997
1998
Insertion.After = Class.create();
1999
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
2000
initializeRange: function() {
2001
this.range.setStartAfter(this.element);
2002
},
2003
2004
insertContent: function(fragments) {
2005
fragments.each((function(fragment) {
2006
this.element.parentNode.insertBefore(fragment,
2007
this.element.nextSibling);
2008
}).bind(this));
2009
}
2010
});
2011
2012
/*--------------------------------------------------------------------------*/
2013
2014
Element.ClassNames = Class.create();
2015
Element.ClassNames.prototype = {
2016
initialize: function(element) {
2017
this.element = $(element);
2018
},
2019
2020
_each: function(iterator) {
2021
this.element.className.split(/\s+/).select(function(name) {
2022
return name.length > 0;
2023
})._each(iterator);
2024
},
2025
2026
set: function(className) {
2027
this.element.className = className;
2028
},
2029
2030
add: function(classNameToAdd) {
2031
if (this.include(classNameToAdd)) return;
2032
this.set($A(this).concat(classNameToAdd).join(' '));
2033
},
2034
2035
remove: function(classNameToRemove) {
2036
if (!this.include(classNameToRemove)) return;
2037
this.set($A(this).without(classNameToRemove).join(' '));
2038
},
2039
2040
toString: function() {
2041
return $A(this).join(' ');
2042
}
2043
};
2044
2045
Object.extend(Element.ClassNames.prototype, Enumerable);
2046
/* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2047
* part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
2048
* license. Please see http://www.yui-ext.com/ for more information. */
2049
2050
var Selector = Class.create();
2051
2052
Selector.prototype = {
2053
initialize: function(expression) {
2054
this.expression = expression.strip();
2055
this.compileMatcher();
2056
},
2057
2058
compileMatcher: function() {
2059
// Selectors with namespaced attributes can't use the XPath version
2060
if (Prototype.BrowserFeatures.XPath && !(/\[[\w-]*?:/).test(this.expression))
2061
return this.compileXPathMatcher();
2062
2063
var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
2064
c = Selector.criteria, le, p, m;
2065
2066
if (Selector._cache[e]) {
2067
this.matcher = Selector._cache[e]; return;
2068
}
2069
this.matcher = ["this.matcher = function(root) {",
2070
"var r = root, h = Selector.handlers, c = false, n;"];
2071
2072
while (e && le != e && (/\S/).test(e)) {
2073
le = e;
2074
for (var i in ps) {
2075
p = ps[i];
2076
if (m = e.match(p)) {
2077
this.matcher.push(typeof c[i] == 'function' ? c[i](m) :
2078
new Template(c[i]).evaluate(m));
2079
e = e.replace(m[0], '');
2080
break;
2081
}
2082
}
2083
}
2084
2085
this.matcher.push("return h.unique(n);\n}");
2086
eval(this.matcher.join('\n'));
2087
Selector._cache[this.expression] = this.matcher;
2088
},
2089
2090
compileXPathMatcher: function() {
2091
var e = this.expression, ps = Selector.patterns,
2092
x = Selector.xpath, le, m;
2093
2094
if (Selector._cache[e]) {
2095
this.xpath = Selector._cache[e]; return;
2096
}
2097
2098
this.matcher = ['.//*'];
2099
while (e && le != e && (/\S/).test(e)) {
2100
le = e;
2101
for (var i in ps) {
2102
if (m = e.match(ps[i])) {
2103
this.matcher.push(typeof x[i] == 'function' ? x[i](m) :
2104
new Template(x[i]).evaluate(m));
2105
e = e.replace(m[0], '');
2106
break;
2107
}
2108
}
2109
}
2110
2111
this.xpath = this.matcher.join('');
2112
Selector._cache[this.expression] = this.xpath;
2113
},
2114
2115
findElements: function(root) {
2116
root = root || document;
2117
if (this.xpath) return document._getElementsByXPath(this.xpath, root);
2118
return this.matcher(root);
2119
},
2120
2121
match: function(element) {
2122
return this.findElements(document).include(element);
2123
},
2124
2125
toString: function() {
2126
return this.expression;
2127
},
2128
2129
inspect: function() {
2130
return "#<Selector:" + this.expression.inspect() + ">";
2131
}
2132
};
2133
2134
Object.extend(Selector, {
2135
_cache: {},
2136
2137
xpath: {
2138
descendant: "//*",
2139
child: "/*",
2140
adjacent: "/following-sibling::*[1]",
2141
laterSibling: '/following-sibling::*',
2142
tagName: function(m) {
2143
if (m[1] == '*') return '';
2144
return "[local-name()='" + m[1].toLowerCase() +
2145
"' or local-name()='" + m[1].toUpperCase() + "']";
2146
},
2147
className: "[contains(concat(' ', @class, ' '), ' #{1} ')]",
2148
id: "[@id='#{1}']",
2149
attrPresence: "[@#{1}]",
2150
attr: function(m) {
2151
m[3] = m[5] || m[6];
2152
return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
2153
},
2154
pseudo: function(m) {
2155
var h = Selector.xpath.pseudos[m[1]];
2156
if (!h) return '';
2157
if (typeof h === 'function') return h(m);
2158
return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
2159
},
2160
operators: {
2161
'=': "[@#{1}='#{3}']",
2162
'!=': "[@#{1}!='#{3}']",
2163
'^=': "[starts-with(@#{1}, '#{3}')]",
2164
'$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
2165
'*=': "[contains(@#{1}, '#{3}')]",
2166
'~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
2167
'|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
2168
},
2169
pseudos: {
2170
'first-child': '[not(preceding-sibling::*)]',
2171
'last-child': '[not(following-sibling::*)]',
2172
'only-child': '[not(preceding-sibling::* or following-sibling::*)]',
2173
'empty': "[count(*) = 0 and (count(text()) = 0 or translate(text(), ' \t\r\n', '') = '')]",
2174
'checked': "[@checked]",
2175
'disabled': "[@disabled]",
2176
'enabled': "[not(@disabled)]",
2177
'not': function(m) {
2178
var e = m[6], p = Selector.patterns,
2179
x = Selector.xpath, le, m, v;
2180
2181
var exclusion = [];
2182
while (e && le != e && (/\S/).test(e)) {
2183
le = e;
2184
for (var i in p) {
2185
if (m = e.match(p[i])) {
2186
v = typeof x[i] == 'function' ? x[i](m) : new Template(x[i]).evaluate(m);
2187
exclusion.push("(" + v.substring(1, v.length - 1) + ")");
2188
e = e.replace(m[0], '');
2189
break;
2190
}
2191
}
2192
}
2193
return "[not(" + exclusion.join(" and ") + ")]";
2194
},
2195
'nth-child': function(m) {
2196
return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
2197
},
2198
'nth-last-child': function(m) {
2199
return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
2200
},
2201
'nth-of-type': function(m) {
2202
return Selector.xpath.pseudos.nth("position() ", m);
2203
},
2204
'nth-last-of-type': function(m) {
2205
return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
2206
},
2207
'first-of-type': function(m) {
2208
m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
2209
},
2210
'last-of-type': function(m) {
2211
m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
2212
},
2213
'only-of-type': function(m) {
2214
var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
2215
},
2216
nth: function(fragment, m) {
2217
var mm, formula = m[6], predicate;
2218
if (formula == 'even') formula = '2n+0';
2219
if (formula == 'odd') formula = '2n+1';
2220
if (mm = formula.match(/^(\d+)$/)) // digit only
2221
return '[' + fragment + "= " + mm[1] + ']';
2222
if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
2223
if (mm[1] == "-") mm[1] = -1;
2224
var a = mm[1] ? Number(mm[1]) : 1;
2225
var b = mm[2] ? Number(mm[2]) : 0;
2226
predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
2227
"((#{fragment} - #{b}) div #{a} >= 0)]";
2228
return new Template(predicate).evaluate({
2229
fragment: fragment, a: a, b: b });
2230
}
2231
}
2232
}
2233
},
2234
2235
criteria: {
2236
tagName: 'n = h.tagName(n, r, "#{1}", c); c = false;',
2237
className: 'n = h.className(n, r, "#{1}", c); c = false;',
2238
id: 'n = h.id(n, r, "#{1}", c); c = false;',
2239
attrPresence: 'n = h.attrPresence(n, r, "#{1}"); c = false;',
2240
attr: function(m) {
2241
m[3] = (m[5] || m[6]);
2242
return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}"); c = false;').evaluate(m);
2243
},
2244
pseudo: function(m) {
2245
if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
2246
return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
2247
},
2248
descendant: 'c = "descendant";',
2249
child: 'c = "child";',
2250
adjacent: 'c = "adjacent";',
2251
laterSibling: 'c = "laterSibling";'
2252
},
2253
2254
patterns: {
2255
// combinators must be listed first
2256
// (and descendant needs to be last combinator)
2257
laterSibling: /^\s*~\s*/,
2258
child: /^\s*>\s*/,
2259
adjacent: /^\s*\+\s*/,
2260
descendant: /^\s/,
2261
2262
// selectors follow
2263
tagName: /^\s*(\*|[\w\-]+)(\b|$)?/,
2264
id: /^#([\w\-\*]+)(\b|$)/,
2265
className: /^\.([\w\-\*]+)(\b|$)/,
2266
pseudo: /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|\s|(?=:))/,
2267
attrPresence: /^\[([\w]+)\]/,
2268
attr: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\]]*?)\4|([^'"][^\]]*?)))?\]/
2269
},
2270
2271
handlers: {
2272
// UTILITY FUNCTIONS
2273
// joins two collections
2274
concat: function(a, b) {
2275
for (var i = 0, node; node = b[i]; i++)
2276
a.push(node);
2277
return a;
2278
},
2279
2280
// marks an array of nodes for counting
2281
mark: function(nodes) {
2282
for (var i = 0, node; node = nodes[i]; i++)
2283
node._counted = true;
2284
return nodes;
2285
},
2286
2287
unmark: function(nodes) {
2288
for (var i = 0, node; node = nodes[i]; i++)
2289
node._counted = undefined;
2290
return nodes;
2291
},
2292
2293
// mark each child node with its position (for nth calls)
2294
// "ofType" flag indicates whether we're indexing for nth-of-type
2295
// rather than nth-child
2296
index: function(parentNode, reverse, ofType) {
2297
parentNode._counted = true;
2298
if (reverse) {
2299
for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
2300
node = nodes[i];
2301
if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
2302
}
2303
} else {
2304
for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
2305
if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
2306
}
2307
},
2308
2309
// filters out duplicates and extends all nodes
2310
unique: function(nodes) {
2311
if (nodes.length == 0) return nodes;
2312
var results = [], n;
2313
for (var i = 0, l = nodes.length; i < l; i++)
2314
if (!(n = nodes[i])._counted) {
2315
n._counted = true;
2316
results.push(Element.extend(n));
2317
}
2318
return Selector.handlers.unmark(results);
2319
},
2320
2321
// COMBINATOR FUNCTIONS
2322
descendant: function(nodes) {
2323
var h = Selector.handlers;
2324
for (var i = 0, results = [], node; node = nodes[i]; i++)
2325
h.concat(results, node.getElementsByTagName('*'));
2326
return results;
2327
},
2328
2329
child: function(nodes) {
2330
var h = Selector.handlers;
2331
for (var i = 0, results = [], node; node = nodes[i]; i++) {
2332
for (var j = 0, children = [], child; child = node.childNodes[j]; j++)
2333
if (child.nodeType == 1 && child.tagName != '!') results.push(child);
2334
}
2335
return results;
2336
},
2337
2338
adjacent: function(nodes) {
2339
for (var i = 0, results = [], node; node = nodes[i]; i++) {
2340
var next = this.nextElementSibling(node);
2341
if (next) results.push(next);
2342
}
2343
return results;
2344
},
2345
2346
laterSibling: function(nodes) {
2347
var h = Selector.handlers;
2348
for (var i = 0, results = [], node; node = nodes[i]; i++)
2349
h.concat(results, Element.nextSiblings(node));
2350
return results;
2351
},
2352
2353
nextElementSibling: function(node) {
2354
while (node = node.nextSibling)
2355
if (node.nodeType == 1) return node;
2356
return null;
2357
},
2358
2359
previousElementSibling: function(node) {
2360
while (node = node.previousSibling)
2361
if (node.nodeType == 1) return node;
2362
return null;
2363
},
2364
2365
// TOKEN FUNCTIONS
2366
tagName: function(nodes, root, tagName, combinator) {
2367
tagName = tagName.toUpperCase();
2368
var results = [], h = Selector.handlers;
2369
if (nodes) {
2370
if (combinator) {
2371
// fastlane for ordinary descendant combinators
2372
if (combinator == "descendant") {
2373
for (var i = 0, node; node = nodes[i]; i++)
2374
h.concat(results, node.getElementsByTagName(tagName));
2375
return results;
2376
} else nodes = this[combinator](nodes);
2377
if (tagName == "*") return nodes;
2378
}
2379
for (var i = 0, node; node = nodes[i]; i++)
2380
if (node.tagName.toUpperCase() == tagName) results.push(node);
2381
return results;
2382
} else return root.getElementsByTagName(tagName);
2383
},
2384
2385
id: function(nodes, root, id, combinator) {
2386
var targetNode = $(id), h = Selector.handlers;
2387
if (!nodes && root == document) return targetNode ? [targetNode] : [];
2388
if (nodes) {
2389
if (combinator) {
2390
if (combinator == 'child') {
2391
for (var i = 0, node; node = nodes[i]; i++)
2392
if (targetNode.parentNode == node) return [targetNode];
2393
} else if (combinator == 'descendant') {
2394
for (var i = 0, node; node = nodes[i]; i++)
2395
if (Element.descendantOf(targetNode, node)) return [targetNode];
2396
} else if (combinator == 'adjacent') {
2397
for (var i = 0, node; node = nodes[i]; i++)
2398
if (Selector.handlers.previousElementSibling(targetNode) == node)
2399
return [targetNode];
2400
} else nodes = h[combinator](nodes);
2401
}
2402
for (var i = 0, node; node = nodes[i]; i++)
2403
if (node == targetNode) return [targetNode];
2404
return [];
2405
}
2406
return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
2407
},
2408
2409
className: function(nodes, root, className, combinator) {
2410
if (nodes && combinator) nodes = this[combinator](nodes);
2411
return Selector.handlers.byClassName(nodes, root, className);
2412
},
2413
2414
byClassName: function(nodes, root, className) {
2415
if (!nodes) nodes = Selector.handlers.descendant([root]);
2416
var needle = ' ' + className + ' ';
2417
for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
2418
nodeClassName = node.className;
2419
if (nodeClassName.length == 0) continue;
2420
if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
2421
results.push(node);
2422
}
2423
return results;
2424
},
2425
2426
attrPresence: function(nodes, root, attr) {
2427
var results = [];
2428
for (var i = 0, node; node = nodes[i]; i++)
2429
if (Element.hasAttribute(node, attr)) results.push(node);
2430
return results;
2431
},
2432
2433
attr: function(nodes, root, attr, value, operator) {
2434
if (!nodes) nodes = root.getElementsByTagName("*");
2435
var handler = Selector.operators[operator], results = [];
2436
for (var i = 0, node; node = nodes[i]; i++) {
2437
var nodeValue = Element.readAttribute(node, attr);
2438
if (nodeValue === null) continue;
2439
if (handler(nodeValue, value)) results.push(node);
2440
}
2441
return results;
2442
},
2443
2444
pseudo: function(nodes, name, value, root, combinator) {
2445
if (nodes && combinator) nodes = this[combinator](nodes);
2446
if (!nodes) nodes = root.getElementsByTagName("*");
2447
return Selector.pseudos[name](nodes, value, root);
2448
}
2449
},
2450
2451
pseudos: {
2452
'first-child': function(nodes, value, root) {
2453
for (var i = 0, results = [], node; node = nodes[i]; i++) {
2454
if (Selector.handlers.previousElementSibling(node)) continue;
2455
results.push(node);
2456
}
2457
return results;
2458
},
2459
'last-child': function(nodes, value, root) {
2460
for (var i = 0, results = [], node; node = nodes[i]; i++) {
2461
if (Selector.handlers.nextElementSibling(node)) continue;
2462
results.push(node);
2463
}
2464
return results;
2465
},
2466
'only-child': function(nodes, value, root) {
2467
var h = Selector.handlers;
2468
for (var i = 0, results = [], node; node = nodes[i]; i++)
2469
if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
2470
results.push(node);
2471
return results;
2472
},
2473
'nth-child': function(nodes, formula, root) {
2474
return Selector.pseudos.nth(nodes, formula, root);
2475
},
2476
'nth-last-child': function(nodes, formula, root) {
2477
return Selector.pseudos.nth(nodes, formula, root, true);
2478
},
2479
'nth-of-type': function(nodes, formula, root) {
2480
return Selector.pseudos.nth(nodes, formula, root, false, true);
2481
},
2482
'nth-last-of-type': function(nodes, formula, root) {
2483
return Selector.pseudos.nth(nodes, formula, root, true, true);
2484
},
2485
'first-of-type': function(nodes, formula, root) {
2486
return Selector.pseudos.nth(nodes, "1", root, false, true);
2487
},
2488
'last-of-type': function(nodes, formula, root) {
2489
return Selector.pseudos.nth(nodes, "1", root, true, true);
2490
},
2491
'only-of-type': function(nodes, formula, root) {
2492
var p = Selector.pseudos;
2493
return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
2494
},
2495
2496
// handles the an+b logic
2497
getIndices: function(a, b, total) {
2498
if (a == 0) return b > 0 ? [b] : [];
2499
return $R(1, total).inject([], function(memo, i) {
2500
if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
2501
return memo;
2502
});
2503
},
2504
2505
// handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
2506
nth: function(nodes, formula, root, reverse, ofType) {
2507
if (nodes.length == 0) return [];
2508
if (formula == 'even') formula = '2n+0';
2509
if (formula == 'odd') formula = '2n+1';
2510
var h = Selector.handlers, results = [], indexed = [], m;
2511
h.mark(nodes);
2512
for (var i = 0, node; node = nodes[i]; i++) {
2513
if (!node.parentNode._counted) {
2514
h.index(node.parentNode, reverse, ofType);
2515
indexed.push(node.parentNode);
2516
}
2517
}
2518
if (formula.match(/^\d+$/)) { // just a number
2519
formula = Number(formula);
2520
for (var i = 0, node; node = nodes[i]; i++)
2521
if (node.nodeIndex == formula) results.push(node);
2522
} else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
2523
if (m[1] == "-") m[1] = -1;
2524
var a = m[1] ? Number(m[1]) : 1;
2525
var b = m[2] ? Number(m[2]) : 0;
2526
var indices = Selector.pseudos.getIndices(a, b, nodes.length);
2527
for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
2528
for (var j = 0; j < l; j++)
2529
if (node.nodeIndex == indices[j]) results.push(node);
2530
}
2531
}
2532
h.unmark(nodes);
2533
h.unmark(indexed);
2534
return results;
2535
},
2536
2537
'empty': function(nodes, value, root) {
2538
for (var i = 0, results = [], node; node = nodes[i]; i++) {
2539
// IE treats comments as element nodes
2540
if (node.tagName == '!' || (node.firstChild && !node.innerHTML.match(/^\s*$/))) continue;
2541
results.push(node);
2542
}
2543
return results;
2544
},
2545
2546
'not': function(nodes, selector, root) {
2547
var h = Selector.handlers, selectorType, m;
2548
var exclusions = new Selector(selector).findElements(root);
2549
h.mark(exclusions);
2550
for (var i = 0, results = [], node; node = nodes[i]; i++)
2551
if (!node._counted) results.push(node);
2552
h.unmark(exclusions);
2553
return results;
2554
},
2555
2556
'enabled': function(nodes, value, root) {
2557
for (var i = 0, results = [], node; node = nodes[i]; i++)
2558
if (!node.disabled) results.push(node);
2559
return results;
2560
},
2561
2562
'disabled': function(nodes, value, root) {
2563
for (var i = 0, results = [], node; node = nodes[i]; i++)
2564
if (node.disabled) results.push(node);
2565
return results;
2566
},
2567
2568
'checked': function(nodes, value, root) {
2569
for (var i = 0, results = [], node; node = nodes[i]; i++)
2570
if (node.checked) results.push(node);
2571
return results;
2572
}
2573
},
2574
2575
operators: {
2576
'=': function(nv, v) { return nv == v; },
2577
'!=': function(nv, v) { return nv != v; },
2578
'^=': function(nv, v) { return nv.startsWith(v); },
2579
'$=': function(nv, v) { return nv.endsWith(v); },
2580
'*=': function(nv, v) { return nv.include(v); },
2581
'~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
2582
'|=': function(nv, v) { return ('-' + nv.toUpperCase() + '-').include('-' + v.toUpperCase() + '-'); }
2583
},
2584
2585
matchElements: function(elements, expression) {
2586
var matches = new Selector(expression).findElements(), h = Selector.handlers;
2587
h.mark(matches);
2588
for (var i = 0, results = [], element; element = elements[i]; i++)
2589
if (element._counted) results.push(element);
2590
h.unmark(matches);
2591
return results;
2592
},
2593
2594
findElement: function(elements, expression, index) {
2595
if (typeof expression == 'number') {
2596
index = expression; expression = false;
2597
}
2598
return Selector.matchElements(elements, expression || '*')[index || 0];
2599
},
2600
2601
findChildElements: function(element, expressions) {
2602
var exprs = expressions.join(','), expressions = [];
2603
exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
2604
expressions.push(m[1].strip());
2605
});
2606
var results = [], h = Selector.handlers;
2607
for (var i = 0, l = expressions.length, selector; i < l; i++) {
2608
selector = new Selector(expressions[i].strip());
2609
h.concat(results, selector.findElements(element));
2610
}
2611
return (l > 1) ? h.unique(results) : results;
2612
}
2613
});
2614
2615
function $$() {
2616
return Selector.findChildElements(document, $A(arguments));
2617
}
2618
var Form = {
2619
reset: function(form) {
2620
$(form).reset();
2621
return form;
2622
},
2623
2624
serializeElements: function(elements, getHash) {
2625
var data = elements.inject({}, function(result, element) {
2626
if (!element.disabled && element.name) {
2627
var key = element.name, value = $(element).getValue();
2628
if (value != null) {
2629
if (key in result) {
2630
if (result[key].constructor != Array) result[key] = [result[key]];
2631
result[key].push(value);
2632
}
2633
else result[key] = value;
2634
}
2635
}
2636
return result;
2637
});
2638
2639
return getHash ? data : Hash.toQueryString(data);
2640
}
2641
};
2642
2643
Form.Methods = {
2644
serialize: function(form, getHash) {
2645
return Form.serializeElements(Form.getElements(form), getHash);
2646
},
2647
2648
getElements: function(form) {
2649
return $A($(form).getElementsByTagName('*')).inject([],
2650
function(elements, child) {
2651
if (Form.Element.Serializers[child.tagName.toLowerCase()])
2652
elements.push(Element.extend(child));
2653
return elements;
2654
}
2655
);
2656
},
2657
2658
getInputs: function(form, typeName, name) {
2659
form = $(form);
2660
var inputs = form.getElementsByTagName('input');
2661
2662
if (!typeName && !name) return $A(inputs).map(Element.extend);
2663
2664
for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
2665
var input = inputs[i];
2666
if ((typeName && input.type != typeName) || (name && input.name != name))
2667
continue;
2668
matchingInputs.push(Element.extend(input));
2669
}
2670
2671
return matchingInputs;
2672
},
2673
2674
disable: function(form) {
2675
form = $(form);
2676
Form.getElements(form).invoke('disable');
2677
return form;
2678
},
2679
2680
enable: function(form) {
2681
form = $(form);
2682
Form.getElements(form).invoke('enable');
2683
return form;
2684
},
2685
2686
findFirstElement: function(form) {
2687
return $(form).getElements().find(function(element) {
2688
return element.type != 'hidden' && !element.disabled &&
2689
['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
2690
});
2691
},
2692
2693
focusFirstElement: function(form) {
2694
form = $(form);
2695
form.findFirstElement().activate();
2696
return form;
2697
},
2698
2699
request: function(form, options) {
2700
form = $(form), options = Object.clone(options || {});
2701
2702
var params = options.parameters;
2703
options.parameters = form.serialize(true);
2704
2705
if (params) {
2706
if (typeof params == 'string') params = params.toQueryParams();
2707
Object.extend(options.parameters, params);
2708
}
2709
2710
if (form.hasAttribute('method') && !options.method)
2711
options.method = form.method;
2712
2713
return new Ajax.Request(form.readAttribute('action'), options);
2714
}
2715
}
2716
2717
/*--------------------------------------------------------------------------*/
2718
2719
Form.Element = {
2720
focus: function(element) {
2721
$(element).focus();
2722
return element;
2723
},
2724
2725
select: function(element) {
2726
$(element).select();
2727
return element;
2728
}
2729
}
2730
2731
Form.Element.Methods = {
2732
serialize: function(element) {
2733
element = $(element);
2734
if (!element.disabled && element.name) {
2735
var value = element.getValue();
2736
if (value != undefined) {
2737
var pair = {};
2738
pair[element.name] = value;
2739
return Hash.toQueryString(pair);
2740
}
2741
}
2742
return '';
2743
},
2744
2745
getValue: function(element) {
2746
element = $(element);
2747
var method = element.tagName.toLowerCase();
2748
return Form.Element.Serializers[method](element);
2749
},
2750
2751
clear: function(element) {
2752
$(element).value = '';
2753
return element;
2754
},
2755
2756
present: function(element) {
2757
return $(element).value != '';
2758
},
2759
2760
activate: function(element) {
2761
element = $(element);
2762
try {
2763
element.focus();
2764
if (element.select && (element.tagName.toLowerCase() != 'input' ||
2765
!['button', 'reset', 'submit'].include(element.type)))
2766
element.select();
2767
} catch (e) {}
2768
return element;
2769
},
2770
2771
disable: function(element) {
2772
element = $(element);
2773
element.blur();
2774
element.disabled = true;
2775
return element;
2776
},
2777
2778
enable: function(element) {
2779
element = $(element);
2780
element.disabled = false;
2781
return element;
2782
}
2783
}
2784
2785
/*--------------------------------------------------------------------------*/
2786
2787
var Field = Form.Element;
2788
var $F = Form.Element.Methods.getValue;
2789
2790
/*--------------------------------------------------------------------------*/
2791
2792
Form.Element.Serializers = {
2793
input: function(element) {
2794
switch (element.type.toLowerCase()) {
2795
case 'checkbox':
2796
case 'radio':
2797
return Form.Element.Serializers.inputSelector(element);
2798
default:
2799
return Form.Element.Serializers.textarea(element);
2800
}
2801
},
2802
2803
inputSelector: function(element) {
2804
return element.checked ? element.value : null;
2805
},
2806
2807
textarea: function(element) {
2808
return element.value;
2809
},
2810
2811
select: function(element) {
2812
return this[element.type == 'select-one' ?
2813
'selectOne' : 'selectMany'](element);
2814
},
2815
2816
selectOne: function(element) {
2817
var index = element.selectedIndex;
2818
return index >= 0 ? this.optionValue(element.options[index]) : null;
2819
},
2820
2821
selectMany: function(element) {
2822
var values, length = element.length;
2823
if (!length) return null;
2824
2825
for (var i = 0, values = []; i < length; i++) {
2826
var opt = element.options[i];
2827
if (opt.selected) values.push(this.optionValue(opt));
2828
}
2829
return values;
2830
},
2831
2832
optionValue: function(opt) {
2833
// extend element because hasAttribute may not be native
2834
return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
2835
}
2836
}
2837
2838
/*--------------------------------------------------------------------------*/
2839
2840
Abstract.TimedObserver = function() {}
2841
Abstract.TimedObserver.prototype = {
2842
initialize: function(element, frequency, callback) {
2843
this.frequency = frequency;
2844
this.element = $(element);
2845
this.callback = callback;
2846
2847
this.lastValue = this.getValue();
2848
this.registerCallback();
2849
},
2850
2851
registerCallback: function() {
2852
setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
2853
},
2854
2855
onTimerEvent: function() {
2856
var value = this.getValue();
2857
var changed = ('string' == typeof this.lastValue && 'string' == typeof value
2858
? this.lastValue != value : String(this.lastValue) != String(value));
2859
if (changed) {
2860
this.callback(this.element, value);
2861
this.lastValue = value;
2862
}
2863
}
2864
}
2865
2866
Form.Element.Observer = Class.create();
2867
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
2868
getValue: function() {
2869
return Form.Element.getValue(this.element);
2870
}
2871
});
2872
2873
Form.Observer = Class.create();
2874
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
2875
getValue: function() {
2876
return Form.serialize(this.element);
2877
}
2878
});
2879
2880
/*--------------------------------------------------------------------------*/
2881
2882
Abstract.EventObserver = function() {}
2883
Abstract.EventObserver.prototype = {
2884
initialize: function(element, callback) {
2885
this.element = $(element);
2886
this.callback = callback;
2887
2888
this.lastValue = this.getValue();
2889
if (this.element.tagName.toLowerCase() == 'form')
2890
this.registerFormCallbacks();
2891
else
2892
this.registerCallback(this.element);
2893
},
2894
2895
onElementEvent: function() {
2896
var value = this.getValue();
2897
if (this.lastValue != value) {
2898
this.callback(this.element, value);
2899
this.lastValue = value;
2900
}
2901
},
2902
2903
registerFormCallbacks: function() {
2904
Form.getElements(this.element).each(this.registerCallback.bind(this));
2905
},
2906
2907
registerCallback: function(element) {
2908
if (element.type) {
2909
switch (element.type.toLowerCase()) {
2910
case 'checkbox':
2911
case 'radio':
2912
Event.observe(element, 'click', this.onElementEvent.bind(this));
2913
break;
2914
default:
2915
Event.observe(element, 'change', this.onElementEvent.bind(this));
2916
break;
2917
}
2918
}
2919
}
2920
}
2921
2922
Form.Element.EventObserver = Class.create();
2923
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
2924
getValue: function() {
2925
return Form.Element.getValue(this.element);
2926
}
2927
});
2928
2929
Form.EventObserver = Class.create();
2930
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
2931
getValue: function() {
2932
return Form.serialize(this.element);
2933
}
2934
});
2935
if (!window.Event) {
2936
var Event = new Object();
2937
}
2938
2939
Object.extend(Event, {
2940
KEY_BACKSPACE: 8,
2941
KEY_TAB: 9,
2942
KEY_RETURN: 13,
2943
KEY_ESC: 27,
2944
KEY_LEFT: 37,
2945
KEY_UP: 38,
2946
KEY_RIGHT: 39,
2947
KEY_DOWN: 40,
2948
KEY_DELETE: 46,
2949
KEY_HOME: 36,
2950
KEY_END: 35,
2951
KEY_PAGEUP: 33,
2952
KEY_PAGEDOWN: 34,
2953
2954
element: function(event) {
2955
return $(event.target || event.srcElement);
2956
},
2957
2958
isLeftClick: function(event) {
2959
return (((event.which) && (event.which == 1)) ||
2960
((event.button) && (event.button == 1)));
2961
},
2962
2963
pointerX: function(event) {
2964
return event.pageX || (event.clientX +
2965
(document.documentElement.scrollLeft || document.body.scrollLeft));
2966
},
2967
2968
pointerY: function(event) {
2969
return event.pageY || (event.clientY +
2970
(document.documentElement.scrollTop || document.body.scrollTop));
2971
},
2972
2973
stop: function(event) {
2974
if (event.preventDefault) {
2975
event.preventDefault();
2976
event.stopPropagation();
2977
} else {
2978
event.returnValue = false;
2979
event.cancelBubble = true;
2980
}
2981
},
2982
2983
// find the first node with the given tagName, starting from the
2984
// node the event was triggered on; traverses the DOM upwards
2985
findElement: function(event, tagName) {
2986
var element = Event.element(event);
2987
while (element.parentNode && (!element.tagName ||
2988
(element.tagName.toUpperCase() != tagName.toUpperCase())))
2989
element = element.parentNode;
2990
return element;
2991
},
2992
2993
observers: false,
2994
2995
_observeAndCache: function(element, name, observer, useCapture) {
2996
if (!this.observers) this.observers = [];
2997
if (element.addEventListener) {
2998
this.observers.push([element, name, observer, useCapture]);
2999
element.addEventListener(name, observer, useCapture);
3000
} else if (element.attachEvent) {
3001
this.observers.push([element, name, observer, useCapture]);
3002
element.attachEvent('on' + name, observer);
3003
}
3004
},
3005
3006
unloadCache: function() {
3007
if (!Event.observers) return;
3008
for (var i = 0, length = Event.observers.length; i < length; i++) {
3009
Event.stopObserving.apply(this, Event.observers[i]);
3010
Event.observers[i][0] = null;
3011
}
3012
Event.observers = false;
3013
},
3014
3015
observe: function(element, name, observer, useCapture) {
3016
element = $(element);
3017
useCapture = useCapture || false;
3018
3019
if (name == 'keypress' &&
3020
(Prototype.Browser.WebKit || element.attachEvent))
3021
name = 'keydown';
3022
3023
Event._observeAndCache(element, name, observer, useCapture);
3024
},
3025
3026
stopObserving: function(element, name, observer, useCapture) {
3027
element = $(element);
3028
useCapture = useCapture || false;
3029
3030
if (name == 'keypress' &&
3031
(Prototype.Browser.WebKit || element.attachEvent))
3032
name = 'keydown';
3033
3034
if (element.removeEventListener) {
3035
element.removeEventListener(name, observer, useCapture);
3036
} else if (element.detachEvent) {
3037
try {
3038
element.detachEvent('on' + name, observer);
3039
} catch (e) {}
3040
}
3041
}
3042
});
3043
3044
/* prevent memory leaks in IE */
3045
if (Prototype.Browser.IE)
3046
Event.observe(window, 'unload', Event.unloadCache, false);
3047
var Position = {
3048
// set to true if needed, warning: firefox performance problems
3049
// NOT neeeded for page scrolling, only if draggable contained in
3050
// scrollable elements
3051
includeScrollOffsets: false,
3052
3053
// must be called before calling withinIncludingScrolloffset, every time the
3054
// page is scrolled
3055
prepare: function() {
3056
this.deltaX = window.pageXOffset
3057
|| document.documentElement.scrollLeft
3058
|| document.body.scrollLeft
3059
|| 0;
3060
this.deltaY = window.pageYOffset
3061
|| document.documentElement.scrollTop
3062
|| document.body.scrollTop
3063
|| 0;
3064
},
3065
3066
realOffset: function(element) {
3067
var valueT = 0, valueL = 0;
3068
do {
3069
valueT += element.scrollTop || 0;
3070
valueL += element.scrollLeft || 0;
3071
element = element.parentNode;
3072
} while (element);
3073
return [valueL, valueT];
3074
},
3075
3076
cumulativeOffset: function(element) {
3077
var valueT = 0, valueL = 0;
3078
do {
3079
valueT += element.offsetTop || 0;
3080
valueL += element.offsetLeft || 0;
3081
element = element.offsetParent;
3082
} while (element);
3083
return [valueL, valueT];
3084
},
3085
3086
positionedOffset: function(element) {
3087
var valueT = 0, valueL = 0;
3088
do {
3089
valueT += element.offsetTop || 0;
3090
valueL += element.offsetLeft || 0;
3091
element = element.offsetParent;
3092
if (element) {
3093
if(element.tagName=='BODY') break;
3094
var p = Element.getStyle(element, 'position');
3095
if (p == 'relative' || p == 'absolute') break;
3096
}
3097
} while (element);
3098
return [valueL, valueT];
3099
},
3100
3101
offsetParent: function(element) {
3102
if (element.offsetParent) return element.offsetParent;
3103
if (element == document.body) return element;
3104
3105
while ((element = element.parentNode) && element != document.body)
3106
if (Element.getStyle(element, 'position') != 'static')
3107
return element;
3108
3109
return document.body;
3110
},
3111
3112
// caches x/y coordinate pair to use with overlap
3113
within: function(element, x, y) {
3114
if (this.includeScrollOffsets)
3115
return this.withinIncludingScrolloffsets(element, x, y);
3116
this.xcomp = x;
3117
this.ycomp = y;
3118
this.offset = this.cumulativeOffset(element);
3119
3120
return (y >= this.offset[1] &&
3121
y < this.offset[1] + element.offsetHeight &&
3122
x >= this.offset[0] &&
3123
x < this.offset[0] + element.offsetWidth);
3124
},
3125
3126
withinIncludingScrolloffsets: function(element, x, y) {
3127
var offsetcache = this.realOffset(element);
3128
3129
this.xcomp = x + offsetcache[0] - this.deltaX;
3130
this.ycomp = y + offsetcache[1] - this.deltaY;
3131
this.offset = this.cumulativeOffset(element);
3132
3133
return (this.ycomp >= this.offset[1] &&
3134
this.ycomp < this.offset[1] + element.offsetHeight &&
3135
this.xcomp >= this.offset[0] &&
3136
this.xcomp < this.offset[0] + element.offsetWidth);
3137
},
3138
3139
// within must be called directly before
3140
overlap: function(mode, element) {
3141
if (!mode) return 0;
3142
if (mode == 'vertical')
3143
return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
3144
element.offsetHeight;
3145
if (mode == 'horizontal')
3146
return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
3147
element.offsetWidth;
3148
},
3149
3150
page: function(forElement) {
3151
var valueT = 0, valueL = 0;
3152
3153
var element = forElement;
3154
do {
3155
valueT += element.offsetTop || 0;
3156
valueL += element.offsetLeft || 0;
3157
3158
// Safari fix
3159
if (element.offsetParent == document.body)
3160
if (Element.getStyle(element,'position')=='absolute') break;
3161
3162
} while (element = element.offsetParent);
3163
3164
element = forElement;
3165
do {
3166
if (!window.opera || element.tagName=='BODY') {
3167
valueT -= element.scrollTop || 0;
3168
valueL -= element.scrollLeft || 0;
3169
}
3170
} while (element = element.parentNode);
3171
3172
return [valueL, valueT];
3173
},
3174
3175
clone: function(source, target) {
3176
var options = Object.extend({
3177
setLeft: true,
3178
setTop: true,
3179
setWidth: true,
3180
setHeight: true,
3181
offsetTop: 0,
3182
offsetLeft: 0
3183
}, arguments[2] || {})
3184
3185
// find page position of source
3186
source = $(source);
3187
var p = Position.page(source);
3188
3189
// find coordinate system to use
3190
target = $(target);
3191
var delta = [0, 0];
3192
var parent = null;
3193
// delta [0,0] will do fine with position: fixed elements,
3194
// position:absolute needs offsetParent deltas
3195
if (Element.getStyle(target,'position') == 'absolute') {
3196
parent = Position.offsetParent(target);
3197
delta = Position.page(parent);
3198
}
3199
3200
// correct by body offsets (fixes Safari)
3201
if (parent == document.body) {
3202
delta[0] -= document.body.offsetLeft;
3203
delta[1] -= document.body.offsetTop;
3204
}
3205
3206
// set position
3207
if(options.setLeft) target.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
3208
if(options.setTop) target.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
3209
if(options.setWidth) target.style.width = source.offsetWidth + 'px';
3210
if(options.setHeight) target.style.height = source.offsetHeight + 'px';
3211
},
3212
3213
absolutize: function(element) {
3214
element = $(element);
3215
if (element.style.position == 'absolute') return;
3216
Position.prepare();
3217
3218
var offsets = Position.positionedOffset(element);
3219
var top = offsets[1];
3220
var left = offsets[0];
3221
var width = element.clientWidth;
3222
var height = element.clientHeight;
3223
3224
element._originalLeft = left - parseFloat(element.style.left || 0);
3225
element._originalTop = top - parseFloat(element.style.top || 0);
3226
element._originalWidth = element.style.width;
3227
element._originalHeight = element.style.height;
3228
3229
element.style.position = 'absolute';
3230
element.style.top = top + 'px';
3231
element.style.left = left + 'px';
3232
element.style.width = width + 'px';
3233
element.style.height = height + 'px';
3234
},
3235
3236
relativize: function(element) {
3237
element = $(element);
3238
if (element.style.position == 'relative') return;
3239
Position.prepare();
3240
3241
element.style.position = 'relative';
3242
var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
3243
var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
3244
3245
element.style.top = top + 'px';
3246
element.style.left = left + 'px';
3247
element.style.height = element._originalHeight;
3248
element.style.width = element._originalWidth;
3249
}
3250
}
3251
3252
// Safari returns margins on body which is incorrect if the child is absolutely
3253
// positioned. For performance reasons, redefine Position.cumulativeOffset for
3254
// KHTML/WebKit only.
3255
if (Prototype.Browser.WebKit) {
3256
Position.cumulativeOffset = function(element) {
3257
var valueT = 0, valueL = 0;
3258
do {
3259
valueT += element.offsetTop || 0;
3260
valueL += element.offsetLeft || 0;
3261
if (element.offsetParent == document.body)
3262
if (Element.getStyle(element, 'position') == 'absolute') break;
3263
3264
element = element.offsetParent;
3265
} while (element);
3266
3267
return [valueL, valueT];
3268
}
3269
}
3270
3271
Element.addMethods();
b'\\ No newline at end of file'
Loggerhead is a web-based interface for Breezy
Version: 1.20.0