insults 0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (19) hide show
  1. data/README.rdoc +11 -0
  2. data/Rakefile +54 -0
  3. data/bin/example +13 -0
  4. data/bin/example.bat +12 -0
  5. data/doc/classes/Insults.html +57 -0
  6. data/doc/classes/Try.html +87 -0
  7. data/doc/created.rid +1 -0
  8. data/doc/files/LICENSE_txt.html +76 -0
  9. data/doc/files/README_rdoc.html +59 -0
  10. data/doc/files/lib/insults_rb.html +84 -0
  11. data/doc/files/lib/try_rb.html +49 -0
  12. data/doc/fr_class_index.html +17 -0
  13. data/doc/fr_file_index.html +23 -0
  14. data/doc/fr_method_index.html +4401 -0
  15. data/doc/index.html +15 -0
  16. data/doc/rdoc-style.css +319 -0
  17. data/lib/insults.rb +70 -0
  18. data/lib/try.rb +16 -0
  19. metadata +73 -0
data/doc/fr_method_index.html ADDED
@@ -0,0 +1,4401 @@
1
+ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
2
+ <html lang='en'>
3
+ <head>
4
+ <title>Methods [Insults will insult you when it feels you deserve it.]</title>
5
+ <meta content='text/html; charset=utf-8' http-equiv='Content-Type'>
6
+ <link href='rdoc-style.css' media='screen' rel='stylesheet' type='text/css'>
7
+ <base target='docwin'>
8
+ </head>
9
+ <body class='list'>
10
+ <div id='index'>
11
+ <h1>Methods</h1>
12
+ <script type='text/javascript'>
13
+ /* Prototype JavaScript framework, version 1.6.0.3
14
+ * (c) 2005-2008 Sam Stephenson
15
+ *
16
+ * Prototype is freely distributable under the terms of an MIT-style license.
17
+ * For details, see the Prototype web site: http://www.prototypejs.org/
18
+ *
19
+ *--------------------------------------------------------------------------*/
20
+
21
+ var Prototype = {
22
+ Version: '1.6.0.3',
23
+
24
+ Browser: {
25
+ IE: !!(window.attachEvent &&
26
+ navigator.userAgent.indexOf('Opera') === -1),
27
+ Opera: navigator.userAgent.indexOf('Opera') > -1,
28
+ WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
29
+ Gecko: navigator.userAgent.indexOf('Gecko') > -1 &&
30
+ navigator.userAgent.indexOf('KHTML') === -1,
31
+ MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
32
+ },
33
+
34
+ BrowserFeatures: {
35
+ XPath: !!document.evaluate,
36
+ SelectorsAPI: !!document.querySelector,
37
+ ElementExtensions: !!window.HTMLElement,
38
+ SpecificElementExtensions:
39
+ document.createElement('div')['__proto__'] &&
40
+ document.createElement('div')['__proto__'] !==
41
+ document.createElement('form')['__proto__']
42
+ },
43
+
44
+ ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
45
+ JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
46
+
47
+ emptyFunction: function() { },
48
+ K: function(x) { return x }
49
+ };
50
+
51
+ if (Prototype.Browser.MobileSafari)
52
+ Prototype.BrowserFeatures.SpecificElementExtensions = false;
53
+
54
+
55
+ /* Based on Alex Arnell's inheritance implementation. */
56
+ var Class = {
57
+ create: function() {
58
+ var parent = null, properties = $A(arguments);
59
+ if (Object.isFunction(properties[0]))
60
+ parent = properties.shift();
61
+
62
+ function klass() {
63
+ this.initialize.apply(this, arguments);
64
+ }
65
+
66
+ Object.extend(klass, Class.Methods);
67
+ klass.superclass = parent;
68
+ klass.subclasses = [];
69
+
70
+ if (parent) {
71
+ var subclass = function() { };
72
+ subclass.prototype = parent.prototype;
73
+ klass.prototype = new subclass;
74
+ parent.subclasses.push(klass);
75
+ }
76
+
77
+ for (var i = 0; i < properties.length; i++)
78
+ klass.addMethods(properties[i]);
79
+
80
+ if (!klass.prototype.initialize)
81
+ klass.prototype.initialize = Prototype.emptyFunction;
82
+
83
+ klass.prototype.constructor = klass;
84
+
85
+ return klass;
86
+ }
87
+ };
88
+
89
+ Class.Methods = {
90
+ addMethods: function(source) {
91
+ var ancestor = this.superclass && this.superclass.prototype;
92
+ var properties = Object.keys(source);
93
+
94
+ if (!Object.keys({ toString: true }).length)
95
+ properties.push("toString", "valueOf");
96
+
97
+ for (var i = 0, length = properties.length; i < length; i++) {
98
+ var property = properties[i], value = source[property];
99
+ if (ancestor && Object.isFunction(value) &&
100
+ value.argumentNames().first() == "$super") {
101
+ var method = value;
102
+ value = (function(m) {
103
+ return function() { return ancestor[m].apply(this, arguments) };
104
+ })(property).wrap(method);
105
+
106
+ value.valueOf = method.valueOf.bind(method);
107
+ value.toString = method.toString.bind(method);
108
+ }
109
+ this.prototype[property] = value;
110
+ }
111
+
112
+ return this;
113
+ }
114
+ };
115
+
116
+ var Abstract = { };
117
+
118
+ Object.extend = function(destination, source) {
119
+ for (var property in source)
120
+ destination[property] = source[property];
121
+ return destination;
122
+ };
123
+
124
+ Object.extend(Object, {
125
+ inspect: function(object) {
126
+ try {
127
+ if (Object.isUndefined(object)) return 'undefined';
128
+ if (object === null) return 'null';
129
+ return object.inspect ? object.inspect() : String(object);
130
+ } catch (e) {
131
+ if (e instanceof RangeError) return '...';
132
+ throw e;
133
+ }
134
+ },
135
+
136
+ toJSON: function(object) {
137
+ var type = typeof object;
138
+ switch (type) {
139
+ case 'undefined':
140
+ case 'function':
141
+ case 'unknown': return;
142
+ case 'boolean': return object.toString();
143
+ }
144
+
145
+ if (object === null) return 'null';
146
+ if (object.toJSON) return object.toJSON();
147
+ if (Object.isElement(object)) return;
148
+
149
+ var results = [];
150
+ for (var property in object) {
151
+ var value = Object.toJSON(object[property]);
152
+ if (!Object.isUndefined(value))
153
+ results.push(property.toJSON() + ': ' + value);
154
+ }
155
+
156
+ return '{' + results.join(', ') + '}';
157
+ },
158
+
159
+ toQueryString: function(object) {
160
+ return $H(object).toQueryString();
161
+ },
162
+
163
+ toHTML: function(object) {
164
+ return object && object.toHTML ? object.toHTML() : String.interpret(object);
165
+ },
166
+
167
+ keys: function(object) {
168
+ var keys = [];
169
+ for (var property in object)
170
+ keys.push(property);
171
+ return keys;
172
+ },
173
+
174
+ values: function(object) {
175
+ var values = [];
176
+ for (var property in object)
177
+ values.push(object[property]);
178
+ return values;
179
+ },
180
+
181
+ clone: function(object) {
182
+ return Object.extend({ }, object);
183
+ },
184
+
185
+ isElement: function(object) {
186
+ return !!(object && object.nodeType == 1);
187
+ },
188
+
189
+ isArray: function(object) {
190
+ return object != null && typeof object == "object" &&
191
+ 'splice' in object && 'join' in object;
192
+ },
193
+
194
+ isHash: function(object) {
195
+ return object instanceof Hash;
196
+ },
197
+
198
+ isFunction: function(object) {
199
+ return typeof object == "function";
200
+ },
201
+
202
+ isString: function(object) {
203
+ return typeof object == "string";
204
+ },
205
+
206
+ isNumber: function(object) {
207
+ return typeof object == "number";
208
+ },
209
+
210
+ isUndefined: function(object) {
211
+ return typeof object == "undefined";
212
+ }
213
+ });
214
+
215
+ Object.extend(Function.prototype, {
216
+ argumentNames: function() {
217
+ var names = this.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1]
218
+ .replace(/\s+/g, '').split(',');
219
+ return names.length == 1 && !names[0] ? [] : names;
220
+ },
221
+
222
+ bind: function() {
223
+ if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
224
+ var __method = this, args = $A(arguments), object = args.shift();
225
+ return function() {
226
+ return __method.apply(object, args.concat($A(arguments)));
227
+ }
228
+ },
229
+
230
+ bindAsEventListener: function() {
231
+ var __method = this, args = $A(arguments), object = args.shift();
232
+ return function(event) {
233
+ return __method.apply(object, [event || window.event].concat(args));
234
+ }
235
+ },
236
+
237
+ curry: function() {
238
+ if (!arguments.length) return this;
239
+ var __method = this, args = $A(arguments);
240
+ return function() {
241
+ return __method.apply(this, args.concat($A(arguments)));
242
+ }
243
+ },
244
+
245
+ delay: function() {
246
+ var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
247
+ return window.setTimeout(function() {
248
+ return __method.apply(__method, args);
249
+ }, timeout);
250
+ },
251
+
252
+ defer: function() {
253
+ var args = [0.01].concat($A(arguments));
254
+ return this.delay.apply(this, args);
255
+ },
256
+
257
+ wrap: function(wrapper) {
258
+ var __method = this;
259
+ return function() {
260
+ return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
261
+ }
262
+ },
263
+
264
+ methodize: function() {
265
+ if (this._methodized) return this._methodized;
266
+ var __method = this;
267
+ return this._methodized = function() {
268
+ return __method.apply(null, [this].concat($A(arguments)));
269
+ };
270
+ }
271
+ });
272
+
273
+ Date.prototype.toJSON = function() {
274
+ return '"' + this.getUTCFullYear() + '-' +
275
+ (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
276
+ this.getUTCDate().toPaddedString(2) + 'T' +
277
+ this.getUTCHours().toPaddedString(2) + ':' +
278
+ this.getUTCMinutes().toPaddedString(2) + ':' +
279
+ this.getUTCSeconds().toPaddedString(2) + 'Z"';
280
+ };
281
+
282
+ var Try = {
283
+ these: function() {
284
+ var returnValue;
285
+
286
+ for (var i = 0, length = arguments.length; i < length; i++) {
287
+ var lambda = arguments[i];
288
+ try {
289
+ returnValue = lambda();
290
+ break;
291
+ } catch (e) { }
292
+ }
293
+
294
+ return returnValue;
295
+ }
296
+ };
297
+
298
+ RegExp.prototype.match = RegExp.prototype.test;
299
+
300
+ RegExp.escape = function(str) {
301
+ return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
302
+ };
303
+
304
+ /*--------------------------------------------------------------------------*/
305
+
306
+ var PeriodicalExecuter = Class.create({
307
+ initialize: function(callback, frequency) {
308
+ this.callback = callback;
309
+ this.frequency = frequency;
310
+ this.currentlyExecuting = false;
311
+
312
+ this.registerCallback();
313
+ },
314
+
315
+ registerCallback: function() {
316
+ this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
317
+ },
318
+
319
+ execute: function() {
320
+ this.callback(this);
321
+ },
322
+
323
+ stop: function() {
324
+ if (!this.timer) return;
325
+ clearInterval(this.timer);
326
+ this.timer = null;
327
+ },
328
+
329
+ onTimerEvent: function() {
330
+ if (!this.currentlyExecuting) {
331
+ try {
332
+ this.currentlyExecuting = true;
333
+ this.execute();
334
+ } finally {
335
+ this.currentlyExecuting = false;
336
+ }
337
+ }
338
+ }
339
+ });
340
+ Object.extend(String, {
341
+ interpret: function(value) {
342
+ return value == null ? '' : String(value);
343
+ },
344
+ specialChar: {
345
+ '\b': '\\b',
346
+ '\t': '\\t',
347
+ '\n': '\\n',
348
+ '\f': '\\f',
349
+ '\r': '\\r',
350
+ '\\': '\\\\'
351
+ }
352
+ });
353
+
354
+ Object.extend(String.prototype, {
355
+ gsub: function(pattern, replacement) {
356
+ var result = '', source = this, match;
357
+ replacement = arguments.callee.prepareReplacement(replacement);
358
+
359
+ while (source.length > 0) {
360
+ if (match = source.match(pattern)) {
361
+ result += source.slice(0, match.index);
362
+ result += String.interpret(replacement(match));
363
+ source = source.slice(match.index + match[0].length);
364
+ } else {
365
+ result += source, source = '';
366
+ }
367
+ }
368
+ return result;
369
+ },
370
+
371
+ sub: function(pattern, replacement, count) {
372
+ replacement = this.gsub.prepareReplacement(replacement);
373
+ count = Object.isUndefined(count) ? 1 : count;
374
+
375
+ return this.gsub(pattern, function(match) {
376
+ if (--count < 0) return match[0];
377
+ return replacement(match);
378
+ });
379
+ },
380
+
381
+ scan: function(pattern, iterator) {
382
+ this.gsub(pattern, iterator);
383
+ return String(this);
384
+ },
385
+
386
+ truncate: function(length, truncation) {
387
+ length = length || 30;
388
+ truncation = Object.isUndefined(truncation) ? '...' : truncation;
389
+ return this.length > length ?
390
+ this.slice(0, length - truncation.length) + truncation : String(this);
391
+ },
392
+
393
+ strip: function() {
394
+ return this.replace(/^\s+/, '').replace(/\s+$/, '');
395
+ },
396
+
397
+ stripTags: function() {
398
+ return this.replace(/<\/?[^>]+>/gi, '');
399
+ },
400
+
401
+ stripScripts: function() {
402
+ return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
403
+ },
404
+
405
+ extractScripts: function() {
406
+ var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
407
+ var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
408
+ return (this.match(matchAll) || []).map(function(scriptTag) {
409
+ return (scriptTag.match(matchOne) || ['', ''])[1];
410
+ });
411
+ },
412
+
413
+ evalScripts: function() {
414
+ return this.extractScripts().map(function(script) { return eval(script) });
415
+ },
416
+
417
+ escapeHTML: function() {
418
+ var self = arguments.callee;
419
+ self.text.data = this;
420
+ return self.div.innerHTML;
421
+ },
422
+
423
+ unescapeHTML: function() {
424
+ var div = new Element('div');
425
+ div.innerHTML = this.stripTags();
426
+ return div.childNodes[0] ? (div.childNodes.length > 1 ?
427
+ $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
428
+ div.childNodes[0].nodeValue) : '';
429
+ },
430
+
431
+ toQueryParams: function(separator) {
432
+ var match = this.strip().match(/([^?#]*)(#.*)?$/);
433
+ if (!match) return { };
434
+
435
+ return match[1].split(separator || '&').inject({ }, function(hash, pair) {
436
+ if ((pair = pair.split('='))[0]) {
437
+ var key = decodeURIComponent(pair.shift());
438
+ var value = pair.length > 1 ? pair.join('=') : pair[0];
439
+ if (value != undefined) value = decodeURIComponent(value);
440
+
441
+ if (key in hash) {
442
+ if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
443
+ hash[key].push(value);
444
+ }
445
+ else hash[key] = value;
446
+ }
447
+ return hash;
448
+ });
449
+ },
450
+
451
+ toArray: function() {
452
+ return this.split('');
453
+ },
454
+
455
+ succ: function() {
456
+ return this.slice(0, this.length - 1) +
457
+ String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
458
+ },
459
+
460
+ times: function(count) {
461
+ return count < 1 ? '' : new Array(count + 1).join(this);
462
+ },
463
+
464
+ camelize: function() {
465
+ var parts = this.split('-'), len = parts.length;
466
+ if (len == 1) return parts[0];
467
+
468
+ var camelized = this.charAt(0) == '-'
469
+ ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
470
+ : parts[0];
471
+
472
+ for (var i = 1; i < len; i++)
473
+ camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
474
+
475
+ return camelized;
476
+ },
477
+
478
+ capitalize: function() {
479
+ return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
480
+ },
481
+
482
+ underscore: function() {
483
+ return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
484
+ },
485
+
486
+ dasherize: function() {
487
+ return this.gsub(/_/,'-');
488
+ },
489
+
490
+ inspect: function(useDoubleQuotes) {
491
+ var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
492
+ var character = String.specialChar[match[0]];
493
+ return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
494
+ });
495
+ if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
496
+ return "'" + escapedString.replace(/'/g, '\\\'') + "'";
497
+ },
498
+
499
+ toJSON: function() {
500
+ return this.inspect(true);
501
+ },
502
+
503
+ unfilterJSON: function(filter) {
504
+ return this.sub(filter || Prototype.JSONFilter, '#{1}');
505
+ },
506
+
507
+ isJSON: function() {
508
+ var str = this;
509
+ if (str.blank()) return false;
510
+ str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
511
+ return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
512
+ },
513
+
514
+ evalJSON: function(sanitize) {
515
+ var json = this.unfilterJSON();
516
+ try {
517
+ if (!sanitize || json.isJSON()) return eval('(' + json + ')');
518
+ } catch (e) { }
519
+ throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
520
+ },
521
+
522
+ include: function(pattern) {
523
+ return this.indexOf(pattern) > -1;
524
+ },
525
+
526
+ startsWith: function(pattern) {
527
+ return this.indexOf(pattern) === 0;
528
+ },
529
+
530
+ endsWith: function(pattern) {
531
+ var d = this.length - pattern.length;
532
+ return d >= 0 && this.lastIndexOf(pattern) === d;
533
+ },
534
+
535
+ empty: function() {
536
+ return this == '';
537
+ },
538
+
539
+ blank: function() {
540
+ return /^\s*$/.test(this);
541
+ },
542
+
543
+ interpolate: function(object, pattern) {
544
+ return new Template(this, pattern).evaluate(object);
545
+ }
546
+ });
547
+
548
+ if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
549
+ escapeHTML: function() {
550
+ return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
551
+ },
552
+ unescapeHTML: function() {
553
+ return this.stripTags().replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
554
+ }
555
+ });
556
+
557
+ String.prototype.gsub.prepareReplacement = function(replacement) {
558
+ if (Object.isFunction(replacement)) return replacement;
559
+ var template = new Template(replacement);
560
+ return function(match) { return template.evaluate(match) };
561
+ };
562
+
563
+ String.prototype.parseQuery = String.prototype.toQueryParams;
564
+
565
+ Object.extend(String.prototype.escapeHTML, {
566
+ div: document.createElement('div'),
567
+ text: document.createTextNode('')
568
+ });
569
+
570
+ String.prototype.escapeHTML.div.appendChild(String.prototype.escapeHTML.text);
571
+
572
+ var Template = Class.create({
573
+ initialize: function(template, pattern) {
574
+ this.template = template.toString();
575
+ this.pattern = pattern || Template.Pattern;
576
+ },
577
+
578
+ evaluate: function(object) {
579
+ if (Object.isFunction(object.toTemplateReplacements))
580
+ object = object.toTemplateReplacements();
581
+
582
+ return this.template.gsub(this.pattern, function(match) {
583
+ if (object == null) return '';
584
+
585
+ var before = match[1] || '';
586
+ if (before == '\\') return match[2];
587
+
588
+ var ctx = object, expr = match[3];
589
+ var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
590
+ match = pattern.exec(expr);
591
+ if (match == null) return before;
592
+
593
+ while (match != null) {
594
+ var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];
595
+ ctx = ctx[comp];
596
+ if (null == ctx || '' == match[3]) break;
597
+ expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
598
+ match = pattern.exec(expr);
599
+ }
600
+
601
+ return before + String.interpret(ctx);
602
+ });
603
+ }
604
+ });
605
+ Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
606
+
607
+ var $break = { };
608
+
609
+ var Enumerable = {
610
+ each: function(iterator, context) {
611
+ var index = 0;
612
+ try {
613
+ this._each(function(value) {
614
+ iterator.call(context, value, index++);
615
+ });
616
+ } catch (e) {
617
+ if (e != $break) throw e;
618
+ }
619
+ return this;
620
+ },
621
+
622
+ eachSlice: function(number, iterator, context) {
623
+ var index = -number, slices = [], array = this.toArray();
624
+ if (number < 1) return array;
625
+ while ((index += number) < array.length)
626
+ slices.push(array.slice(index, index+number));
627
+ return slices.collect(iterator, context);
628
+ },
629
+
630
+ all: function(iterator, context) {
631
+ iterator = iterator || Prototype.K;
632
+ var result = true;
633
+ this.each(function(value, index) {
634
+ result = result && !!iterator.call(context, value, index);
635
+ if (!result) throw $break;
636
+ });
637
+ return result;
638
+ },
639
+
640
+ any: function(iterator, context) {
641
+ iterator = iterator || Prototype.K;
642
+ var result = false;
643
+ this.each(function(value, index) {
644
+ if (result = !!iterator.call(context, value, index))
645
+ throw $break;
646
+ });
647
+ return result;
648
+ },
649
+
650
+ collect: function(iterator, context) {
651
+ iterator = iterator || Prototype.K;
652
+ var results = [];
653
+ this.each(function(value, index) {
654
+ results.push(iterator.call(context, value, index));
655
+ });
656
+ return results;
657
+ },
658
+
659
+ detect: function(iterator, context) {
660
+ var result;
661
+ this.each(function(value, index) {
662
+ if (iterator.call(context, value, index)) {
663
+ result = value;
664
+ throw $break;
665
+ }
666
+ });
667
+ return result;
668
+ },
669
+
670
+ findAll: function(iterator, context) {
671
+ var results = [];
672
+ this.each(function(value, index) {
673
+ if (iterator.call(context, value, index))
674
+ results.push(value);
675
+ });
676
+ return results;
677
+ },
678
+
679
+ grep: function(filter, iterator, context) {
680
+ iterator = iterator || Prototype.K;
681
+ var results = [];
682
+
683
+ if (Object.isString(filter))
684
+ filter = new RegExp(filter);
685
+
686
+ this.each(function(value, index) {
687
+ if (filter.match(value))
688
+ results.push(iterator.call(context, value, index));
689
+ });
690
+ return results;
691
+ },
692
+
693
+ include: function(object) {
694
+ if (Object.isFunction(this.indexOf))
695
+ if (this.indexOf(object) != -1) return true;
696
+
697
+ var found = false;
698
+ this.each(function(value) {
699
+ if (value == object) {
700
+ found = true;
701
+ throw $break;
702
+ }
703
+ });
704
+ return found;
705
+ },
706
+
707
+ inGroupsOf: function(number, fillWith) {
708
+ fillWith = Object.isUndefined(fillWith) ? null : fillWith;
709
+ return this.eachSlice(number, function(slice) {
710
+ while(slice.length < number) slice.push(fillWith);
711
+ return slice;
712
+ });
713
+ },
714
+
715
+ inject: function(memo, iterator, context) {
716
+ this.each(function(value, index) {
717
+ memo = iterator.call(context, memo, value, index);
718
+ });
719
+ return memo;
720
+ },
721
+
722
+ invoke: function(method) {
723
+ var args = $A(arguments).slice(1);
724
+ return this.map(function(value) {
725
+ return value[method].apply(value, args);
726
+ });
727
+ },
728
+
729
+ max: function(iterator, context) {
730
+ iterator = iterator || Prototype.K;
731
+ var result;
732
+ this.each(function(value, index) {
733
+ value = iterator.call(context, value, index);
734
+ if (result == null || value >= result)
735
+ result = value;
736
+ });
737
+ return result;
738
+ },
739
+
740
+ min: function(iterator, context) {
741
+ iterator = iterator || Prototype.K;
742
+ var result;
743
+ this.each(function(value, index) {
744
+ value = iterator.call(context, value, index);
745
+ if (result == null || value < result)
746
+ result = value;
747
+ });
748
+ return result;
749
+ },
750
+
751
+ partition: function(iterator, context) {
752
+ iterator = iterator || Prototype.K;
753
+ var trues = [], falses = [];
754
+ this.each(function(value, index) {
755
+ (iterator.call(context, value, index) ?
756
+ trues : falses).push(value);
757
+ });
758
+ return [trues, falses];
759
+ },
760
+
761
+ pluck: function(property) {
762
+ var results = [];
763
+ this.each(function(value) {
764
+ results.push(value[property]);
765
+ });
766
+ return results;
767
+ },
768
+
769
+ reject: function(iterator, context) {
770
+ var results = [];
771
+ this.each(function(value, index) {
772
+ if (!iterator.call(context, value, index))
773
+ results.push(value);
774
+ });
775
+ return results;
776
+ },
777
+
778
+ sortBy: function(iterator, context) {
779
+ return this.map(function(value, index) {
780
+ return {
781
+ value: value,
782
+ criteria: iterator.call(context, value, index)
783
+ };
784
+ }).sort(function(left, right) {
785
+ var a = left.criteria, b = right.criteria;
786
+ return a < b ? -1 : a > b ? 1 : 0;
787
+ }).pluck('value');
788
+ },
789
+
790
+ toArray: function() {
791
+ return this.map();
792
+ },
793
+
794
+ zip: function() {
795
+ var iterator = Prototype.K, args = $A(arguments);
796
+ if (Object.isFunction(args.last()))
797
+ iterator = args.pop();
798
+
799
+ var collections = [this].concat(args).map($A);
800
+ return this.map(function(value, index) {
801
+ return iterator(collections.pluck(index));
802
+ });
803
+ },
804
+
805
+ size: function() {
806
+ return this.toArray().length;
807
+ },
808
+
809
+ inspect: function() {
810
+ return '#<Enumerable:' + this.toArray().inspect() + '>';
811
+ }
812
+ };
813
+
814
+ Object.extend(Enumerable, {
815
+ map: Enumerable.collect,
816
+ find: Enumerable.detect,
817
+ select: Enumerable.findAll,
818
+ filter: Enumerable.findAll,
819
+ member: Enumerable.include,
820
+ entries: Enumerable.toArray,
821
+ every: Enumerable.all,
822
+ some: Enumerable.any
823
+ });
824
+ function $A(iterable) {
825
+ if (!iterable) return [];
826
+ if (iterable.toArray) return iterable.toArray();
827
+ var length = iterable.length || 0, results = new Array(length);
828
+ while (length--) results[length] = iterable[length];
829
+ return results;
830
+ }
831
+
832
+ if (Prototype.Browser.WebKit) {
833
+ $A = function(iterable) {
834
+ if (!iterable) return [];
835
+ // In Safari, only use the `toArray` method if it's not a NodeList.
836
+ // A NodeList is a function, has an function `item` property, and a numeric
837
+ // `length` property. Adapted from Google Doctype.
838
+ if (!(typeof iterable === 'function' && typeof iterable.length ===
839
+ 'number' && typeof iterable.item === 'function') && iterable.toArray)
840
+ return iterable.toArray();
841
+ var length = iterable.length || 0, results = new Array(length);
842
+ while (length--) results[length] = iterable[length];
843
+ return results;
844
+ };
845
+ }
846
+
847
+ Array.from = $A;
848
+
849
+ Object.extend(Array.prototype, Enumerable);
850
+
851
+ if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;
852
+
853
+ Object.extend(Array.prototype, {
854
+ _each: function(iterator) {
855
+ for (var i = 0, length = this.length; i < length; i++)
856
+ iterator(this[i]);
857
+ },
858
+
859
+ clear: function() {
860
+ this.length = 0;
861
+ return this;
862
+ },
863
+
864
+ first: function() {
865
+ return this[0];
866
+ },
867
+
868
+ last: function() {
869
+ return this[this.length - 1];
870
+ },
871
+
872
+ compact: function() {
873
+ return this.select(function(value) {
874
+ return value != null;
875
+ });
876
+ },
877
+
878
+ flatten: function() {
879
+ return this.inject([], function(array, value) {
880
+ return array.concat(Object.isArray(value) ?
881
+ value.flatten() : [value]);
882
+ });
883
+ },
884
+
885
+ without: function() {
886
+ var values = $A(arguments);
887
+ return this.select(function(value) {
888
+ return !values.include(value);
889
+ });
890
+ },
891
+
892
+ reverse: function(inline) {
893
+ return (inline !== false ? this : this.toArray())._reverse();
894
+ },
895
+
896
+ reduce: function() {
897
+ return this.length > 1 ? this : this[0];
898
+ },
899
+
900
+ uniq: function(sorted) {
901
+ return this.inject([], function(array, value, index) {
902
+ if (0 == index || (sorted ? array.last() != value : !array.include(value)))
903
+ array.push(value);
904
+ return array;
905
+ });
906
+ },
907
+
908
+ intersect: function(array) {
909
+ return this.uniq().findAll(function(item) {
910
+ return array.detect(function(value) { return item === value });
911
+ });
912
+ },
913
+
914
+ clone: function() {
915
+ return [].concat(this);
916
+ },
917
+
918
+ size: function() {
919
+ return this.length;
920
+ },
921
+
922
+ inspect: function() {
923
+ return '[' + this.map(Object.inspect).join(', ') + ']';
924
+ },
925
+
926
+ toJSON: function() {
927
+ var results = [];
928
+ this.each(function(object) {
929
+ var value = Object.toJSON(object);
930
+ if (!Object.isUndefined(value)) results.push(value);
931
+ });
932
+ return '[' + results.join(', ') + ']';
933
+ }
934
+ });
935
+
936
+ // use native browser JS 1.6 implementation if available
937
+ if (Object.isFunction(Array.prototype.forEach))
938
+ Array.prototype._each = Array.prototype.forEach;
939
+
940
+ if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
941
+ i || (i = 0);
942
+ var length = this.length;
943
+ if (i < 0) i = length + i;
944
+ for (; i < length; i++)
945
+ if (this[i] === item) return i;
946
+ return -1;
947
+ };
948
+
949
+ if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
950
+ i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
951
+ var n = this.slice(0, i).reverse().indexOf(item);
952
+ return (n < 0) ? n : i - n - 1;
953
+ };
954
+
955
+ Array.prototype.toArray = Array.prototype.clone;
956
+
957
+ function $w(string) {
958
+ if (!Object.isString(string)) return [];
959
+ string = string.strip();
960
+ return string ? string.split(/\s+/) : [];
961
+ }
962
+
963
+ if (Prototype.Browser.Opera){
964
+ Array.prototype.concat = function() {
965
+ var array = [];
966
+ for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
967
+ for (var i = 0, length = arguments.length; i < length; i++) {
968
+ if (Object.isArray(arguments[i])) {
969
+ for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
970
+ array.push(arguments[i][j]);
971
+ } else {
972
+ array.push(arguments[i]);
973
+ }
974
+ }
975
+ return array;
976
+ };
977
+ }
978
+ Object.extend(Number.prototype, {
979
+ toColorPart: function() {
980
+ return this.toPaddedString(2, 16);
981
+ },
982
+
983
+ succ: function() {
984
+ return this + 1;
985
+ },
986
+
987
+ times: function(iterator, context) {
988
+ $R(0, this, true).each(iterator, context);
989
+ return this;
990
+ },
991
+
992
+ toPaddedString: function(length, radix) {
993
+ var string = this.toString(radix || 10);
994
+ return '0'.times(length - string.length) + string;
995
+ },
996
+
997
+ toJSON: function() {
998
+ return isFinite(this) ? this.toString() : 'null';
999
+ }
1000
+ });
1001
+
1002
+ $w('abs round ceil floor').each(function(method){
1003
+ Number.prototype[method] = Math[method].methodize();
1004
+ });
1005
+ function $H(object) {
1006
+ return new Hash(object);
1007
+ };
1008
+
1009
+ var Hash = Class.create(Enumerable, (function() {
1010
+
1011
+ function toQueryPair(key, value) {
1012
+ if (Object.isUndefined(value)) return key;
1013
+ return key + '=' + encodeURIComponent(String.interpret(value));
1014
+ }
1015
+
1016
+ return {
1017
+ initialize: function(object) {
1018
+ this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
1019
+ },
1020
+
1021
+ _each: function(iterator) {
1022
+ for (var key in this._object) {
1023
+ var value = this._object[key], pair = [key, value];
1024
+ pair.key = key;
1025
+ pair.value = value;
1026
+ iterator(pair);
1027
+ }
1028
+ },
1029
+
1030
+ set: function(key, value) {
1031
+ return this._object[key] = value;
1032
+ },
1033
+
1034
+ get: function(key) {
1035
+ // simulating poorly supported hasOwnProperty
1036
+ if (this._object[key] !== Object.prototype[key])
1037
+ return this._object[key];
1038
+ },
1039
+
1040
+ unset: function(key) {
1041
+ var value = this._object[key];
1042
+ delete this._object[key];
1043
+ return value;
1044
+ },
1045
+
1046
+ toObject: function() {
1047
+ return Object.clone(this._object);
1048
+ },
1049
+
1050
+ keys: function() {
1051
+ return this.pluck('key');
1052
+ },
1053
+
1054
+ values: function() {
1055
+ return this.pluck('value');
1056
+ },
1057
+
1058
+ index: function(value) {
1059
+ var match = this.detect(function(pair) {
1060
+ return pair.value === value;
1061
+ });
1062
+ return match && match.key;
1063
+ },
1064
+
1065
+ merge: function(object) {
1066
+ return this.clone().update(object);
1067
+ },
1068
+
1069
+ update: function(object) {
1070
+ return new Hash(object).inject(this, function(result, pair) {
1071
+ result.set(pair.key, pair.value);
1072
+ return result;
1073
+ });
1074
+ },
1075
+
1076
+ toQueryString: function() {
1077
+ return this.inject([], function(results, pair) {
1078
+ var key = encodeURIComponent(pair.key), values = pair.value;
1079
+
1080
+ if (values && typeof values == 'object') {
1081
+ if (Object.isArray(values))
1082
+ return results.concat(values.map(toQueryPair.curry(key)));
1083
+ } else results.push(toQueryPair(key, values));
1084
+ return results;
1085
+ }).join('&');
1086
+ },
1087
+
1088
+ inspect: function() {
1089
+ return '#<Hash:{' + this.map(function(pair) {
1090
+ return pair.map(Object.inspect).join(': ');
1091
+ }).join(', ') + '}>';
1092
+ },
1093
+
1094
+ toJSON: function() {
1095
+ return Object.toJSON(this.toObject());
1096
+ },
1097
+
1098
+ clone: function() {
1099
+ return new Hash(this);
1100
+ }
1101
+ }
1102
+ })());
1103
+
1104
+ Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;
1105
+ Hash.from = $H;
1106
+ var ObjectRange = Class.create(Enumerable, {
1107
+ initialize: function(start, end, exclusive) {
1108
+ this.start = start;
1109
+ this.end = end;
1110
+ this.exclusive = exclusive;
1111
+ },
1112
+
1113
+ _each: function(iterator) {
1114
+ var value = this.start;
1115
+ while (this.include(value)) {
1116
+ iterator(value);
1117
+ value = value.succ();
1118
+ }
1119
+ },
1120
+
1121
+ include: function(value) {
1122
+ if (value < this.start)
1123
+ return false;
1124
+ if (this.exclusive)
1125
+ return value < this.end;
1126
+ return value <= this.end;
1127
+ }
1128
+ });
1129
+
1130
+ var $R = function(start, end, exclusive) {
1131
+ return new ObjectRange(start, end, exclusive);
1132
+ };
1133
+
1134
+ var Ajax = {
1135
+ getTransport: function() {
1136
+ return Try.these(
1137
+ function() {return new XMLHttpRequest()},
1138
+ function() {return new ActiveXObject('Msxml2.XMLHTTP')},
1139
+ function() {return new ActiveXObject('Microsoft.XMLHTTP')}
1140
+ ) || false;
1141
+ },
1142
+
1143
+ activeRequestCount: 0
1144
+ };
1145
+
1146
+ Ajax.Responders = {
1147
+ responders: [],
1148
+
1149
+ _each: function(iterator) {
1150
+ this.responders._each(iterator);
1151
+ },
1152
+
1153
+ register: function(responder) {
1154
+ if (!this.include(responder))
1155
+ this.responders.push(responder);
1156
+ },
1157
+
1158
+ unregister: function(responder) {
1159
+ this.responders = this.responders.without(responder);
1160
+ },
1161
+
1162
+ dispatch: function(callback, request, transport, json) {
1163
+ this.each(function(responder) {
1164
+ if (Object.isFunction(responder[callback])) {
1165
+ try {
1166
+ responder[callback].apply(responder, [request, transport, json]);
1167
+ } catch (e) { }
1168
+ }
1169
+ });
1170
+ }
1171
+ };
1172
+
1173
+ Object.extend(Ajax.Responders, Enumerable);
1174
+
1175
+ Ajax.Responders.register({
1176
+ onCreate: function() { Ajax.activeRequestCount++ },
1177
+ onComplete: function() { Ajax.activeRequestCount-- }
1178
+ });
1179
+
1180
+ Ajax.Base = Class.create({
1181
+ initialize: function(options) {
1182
+ this.options = {
1183
+ method: 'post',
1184
+ asynchronous: true,
1185
+ contentType: 'application/x-www-form-urlencoded',
1186
+ encoding: 'UTF-8',
1187
+ parameters: '',
1188
+ evalJSON: true,
1189
+ evalJS: true
1190
+ };
1191
+ Object.extend(this.options, options || { });
1192
+
1193
+ this.options.method = this.options.method.toLowerCase();
1194
+
1195
+ if (Object.isString(this.options.parameters))
1196
+ this.options.parameters = this.options.parameters.toQueryParams();
1197
+ else if (Object.isHash(this.options.parameters))
1198
+ this.options.parameters = this.options.parameters.toObject();
1199
+ }
1200
+ });
1201
+
1202
+ Ajax.Request = Class.create(Ajax.Base, {
1203
+ _complete: false,
1204
+
1205
+ initialize: function($super, url, options) {
1206
+ $super(options);
1207
+ this.transport = Ajax.getTransport();
1208
+ this.request(url);
1209
+ },
1210
+
1211
+ request: function(url) {
1212
+ this.url = url;
1213
+ this.method = this.options.method;
1214
+ var params = Object.clone(this.options.parameters);
1215
+
1216
+ if (!['get', 'post'].include(this.method)) {
1217
+ // simulate other verbs over post
1218
+ params['_method'] = this.method;
1219
+ this.method = 'post';
1220
+ }
1221
+
1222
+ this.parameters = params;
1223
+
1224
+ if (params = Object.toQueryString(params)) {
1225
+ // when GET, append parameters to URL
1226
+ if (this.method == 'get')
1227
+ this.url += (this.url.include('?') ? '&' : '?') + params;
1228
+ else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
1229
+ params += '&_=';
1230
+ }
1231
+
1232
+ try {
1233
+ var response = new Ajax.Response(this);
1234
+ if (this.options.onCreate) this.options.onCreate(response);
1235
+ Ajax.Responders.dispatch('onCreate', this, response);
1236
+
1237
+ this.transport.open(this.method.toUpperCase(), this.url,
1238
+ this.options.asynchronous);
1239
+
1240
+ if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);
1241
+
1242
+ this.transport.onreadystatechange = this.onStateChange.bind(this);
1243
+ this.setRequestHeaders();
1244
+
1245
+ this.body = this.method == 'post' ? (this.options.postBody || params) : null;
1246
+ this.transport.send(this.body);
1247
+
1248
+ /* Force Firefox to handle ready state 4 for synchronous requests */
1249
+ if (!this.options.asynchronous && this.transport.overrideMimeType)
1250
+ this.onStateChange();
1251
+
1252
+ }
1253
+ catch (e) {
1254
+ this.dispatchException(e);
1255
+ }
1256
+ },
1257
+
1258
+ onStateChange: function() {
1259
+ var readyState = this.transport.readyState;
1260
+ if (readyState > 1 && !((readyState == 4) && this._complete))
1261
+ this.respondToReadyState(this.transport.readyState);
1262
+ },
1263
+
1264
+ setRequestHeaders: function() {
1265
+ var headers = {
1266
+ 'X-Requested-With': 'XMLHttpRequest',
1267
+ 'X-Prototype-Version': Prototype.Version,
1268
+ 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
1269
+ };
1270
+
1271
+ if (this.method == 'post') {
1272
+ headers['Content-type'] = this.options.contentType +
1273
+ (this.options.encoding ? '; charset=' + this.options.encoding : '');
1274
+
1275
+ /* Force "Connection: close" for older Mozilla browsers to work
1276
+ * around a bug where XMLHttpRequest sends an incorrect
1277
+ * Content-length header. See Mozilla Bugzilla #246651.
1278
+ */
1279
+ if (this.transport.overrideMimeType &&
1280
+ (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
1281
+ headers['Connection'] = 'close';
1282
+ }
1283
+
1284
+ // user-defined headers
1285
+ if (typeof this.options.requestHeaders == 'object') {
1286
+ var extras = this.options.requestHeaders;
1287
+
1288
+ if (Object.isFunction(extras.push))
1289
+ for (var i = 0, length = extras.length; i < length; i += 2)
1290
+ headers[extras[i]] = extras[i+1];
1291
+ else
1292
+ $H(extras).each(function(pair) { headers[pair.key] = pair.value });
1293
+ }
1294
+
1295
+ for (var name in headers)
1296
+ this.transport.setRequestHeader(name, headers[name]);
1297
+ },
1298
+
1299
+ success: function() {
1300
+ var status = this.getStatus();
1301
+ return !status || (status >= 200 && status < 300);
1302
+ },
1303
+
1304
+ getStatus: function() {
1305
+ try {
1306
+ return this.transport.status || 0;
1307
+ } catch (e) { return 0 }
1308
+ },
1309
+
1310
+ respondToReadyState: function(readyState) {
1311
+ var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);
1312
+
1313
+ if (state == 'Complete') {
1314
+ try {
1315
+ this._complete = true;
1316
+ (this.options['on' + response.status]
1317
+ || this.options['on' + (this.success() ? 'Success' : 'Failure')]
1318
+ || Prototype.emptyFunction)(response, response.headerJSON);
1319
+ } catch (e) {
1320
+ this.dispatchException(e);
1321
+ }
1322
+
1323
+ var contentType = response.getHeader('Content-type');
1324
+ if (this.options.evalJS == 'force'
1325
+ || (this.options.evalJS && this.isSameOrigin() && contentType
1326
+ && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
1327
+ this.evalResponse();
1328
+ }
1329
+
1330
+ try {
1331
+ (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
1332
+ Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
1333
+ } catch (e) {
1334
+ this.dispatchException(e);
1335
+ }
1336
+
1337
+ if (state == 'Complete') {
1338
+ // avoid memory leak in MSIE: clean up
1339
+ this.transport.onreadystatechange = Prototype.emptyFunction;
1340
+ }
1341
+ },
1342
+
1343
+ isSameOrigin: function() {
1344
+ var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
1345
+ return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
1346
+ protocol: location.protocol,
1347
+ domain: document.domain,
1348
+ port: location.port ? ':' + location.port : ''
1349
+ }));
1350
+ },
1351
+
1352
+ getHeader: function(name) {
1353
+ try {
1354
+ return this.transport.getResponseHeader(name) || null;
1355
+ } catch (e) { return null }
1356
+ },
1357
+
1358
+ evalResponse: function() {
1359
+ try {
1360
+ return eval((this.transport.responseText || '').unfilterJSON());
1361
+ } catch (e) {
1362
+ this.dispatchException(e);
1363
+ }
1364
+ },
1365
+
1366
+ dispatchException: function(exception) {
1367
+ (this.options.onException || Prototype.emptyFunction)(this, exception);
1368
+ Ajax.Responders.dispatch('onException', this, exception);
1369
+ }
1370
+ });
1371
+
1372
+ Ajax.Request.Events =
1373
+ ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
1374
+
1375
+ Ajax.Response = Class.create({
1376
+ initialize: function(request){
1377
+ this.request = request;
1378
+ var transport = this.transport = request.transport,
1379
+ readyState = this.readyState = transport.readyState;
1380
+
1381
+ if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
1382
+ this.status = this.getStatus();
1383
+ this.statusText = this.getStatusText();
1384
+ this.responseText = String.interpret(transport.responseText);
1385
+ this.headerJSON = this._getHeaderJSON();
1386
+ }
1387
+
1388
+ if(readyState == 4) {
1389
+ var xml = transport.responseXML;
1390
+ this.responseXML = Object.isUndefined(xml) ? null : xml;
1391
+ this.responseJSON = this._getResponseJSON();
1392
+ }
1393
+ },
1394
+
1395
+ status: 0,
1396
+ statusText: '',
1397
+
1398
+ getStatus: Ajax.Request.prototype.getStatus,
1399
+
1400
+ getStatusText: function() {
1401
+ try {
1402
+ return this.transport.statusText || '';
1403
+ } catch (e) { return '' }
1404
+ },
1405
+
1406
+ getHeader: Ajax.Request.prototype.getHeader,
1407
+
1408
+ getAllHeaders: function() {
1409
+ try {
1410
+ return this.getAllResponseHeaders();
1411
+ } catch (e) { return null }
1412
+ },
1413
+
1414
+ getResponseHeader: function(name) {
1415
+ return this.transport.getResponseHeader(name);
1416
+ },
1417
+
1418
+ getAllResponseHeaders: function() {
1419
+ return this.transport.getAllResponseHeaders();
1420
+ },
1421
+
1422
+ _getHeaderJSON: function() {
1423
+ var json = this.getHeader('X-JSON');
1424
+ if (!json) return null;
1425
+ json = decodeURIComponent(escape(json));
1426
+ try {
1427
+ return json.evalJSON(this.request.options.sanitizeJSON ||
1428
+ !this.request.isSameOrigin());
1429
+ } catch (e) {
1430
+ this.request.dispatchException(e);
1431
+ }
1432
+ },
1433
+
1434
+ _getResponseJSON: function() {
1435
+ var options = this.request.options;
1436
+ if (!options.evalJSON || (options.evalJSON != 'force' &&
1437
+ !(this.getHeader('Content-type') || '').include('application/json')) ||
1438
+ this.responseText.blank())
1439
+ return null;
1440
+ try {
1441
+ return this.responseText.evalJSON(options.sanitizeJSON ||
1442
+ !this.request.isSameOrigin());
1443
+ } catch (e) {
1444
+ this.request.dispatchException(e);
1445
+ }
1446
+ }
1447
+ });
1448
+
1449
+ Ajax.Updater = Class.create(Ajax.Request, {
1450
+ initialize: function($super, container, url, options) {
1451
+ this.container = {
1452
+ success: (container.success || container),
1453
+ failure: (container.failure || (container.success ? null : container))
1454
+ };
1455
+
1456
+ options = Object.clone(options);
1457
+ var onComplete = options.onComplete;
1458
+ options.onComplete = (function(response, json) {
1459
+ this.updateContent(response.responseText);
1460
+ if (Object.isFunction(onComplete)) onComplete(response, json);
1461
+ }).bind(this);
1462
+
1463
+ $super(url, options);
1464
+ },
1465
+
1466
+ updateContent: function(responseText) {
1467
+ var receiver = this.container[this.success() ? 'success' : 'failure'],
1468
+ options = this.options;
1469
+
1470
+ if (!options.evalScripts) responseText = responseText.stripScripts();
1471
+
1472
+ if (receiver = $(receiver)) {
1473
+ if (options.insertion) {
1474
+ if (Object.isString(options.insertion)) {
1475
+ var insertion = { }; insertion[options.insertion] = responseText;
1476
+ receiver.insert(insertion);
1477
+ }
1478
+ else options.insertion(receiver, responseText);
1479
+ }
1480
+ else receiver.update(responseText);
1481
+ }
1482
+ }
1483
+ });
1484
+
1485
+ Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1486
+ initialize: function($super, container, url, options) {
1487
+ $super(options);
1488
+ this.onComplete = this.options.onComplete;
1489
+
1490
+ this.frequency = (this.options.frequency || 2);
1491
+ this.decay = (this.options.decay || 1);
1492
+
1493
+ this.updater = { };
1494
+ this.container = container;
1495
+ this.url = url;
1496
+
1497
+ this.start();
1498
+ },
1499
+
1500
+ start: function() {
1501
+ this.options.onComplete = this.updateComplete.bind(this);
1502
+ this.onTimerEvent();
1503
+ },
1504
+
1505
+ stop: function() {
1506
+ this.updater.options.onComplete = undefined;
1507
+ clearTimeout(this.timer);
1508
+ (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
1509
+ },
1510
+
1511
+ updateComplete: function(response) {
1512
+ if (this.options.decay) {
1513
+ this.decay = (response.responseText == this.lastText ?
1514
+ this.decay * this.options.decay : 1);
1515
+
1516
+ this.lastText = response.responseText;
1517
+ }
1518
+ this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
1519
+ },
1520
+
1521
+ onTimerEvent: function() {
1522
+ this.updater = new Ajax.Updater(this.container, this.url, this.options);
1523
+ }
1524
+ });
1525
+ function $(element) {
1526
+ if (arguments.length > 1) {
1527
+ for (var i = 0, elements = [], length = arguments.length; i < length; i++)
1528
+ elements.push($(arguments[i]));
1529
+ return elements;
1530
+ }
1531
+ if (Object.isString(element))
1532
+ element = document.getElementById(element);
1533
+ return Element.extend(element);
1534
+ }
1535
+
1536
+ if (Prototype.BrowserFeatures.XPath) {
1537
+ document._getElementsByXPath = function(expression, parentElement) {
1538
+ var results = [];
1539
+ var query = document.evaluate(expression, $(parentElement) || document,
1540
+ null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
1541
+ for (var i = 0, length = query.snapshotLength; i < length; i++)
1542
+ results.push(Element.extend(query.snapshotItem(i)));
1543
+ return results;
1544
+ };
1545
+ }
1546
+
1547
+ /*--------------------------------------------------------------------------*/
1548
+
1549
+ if (!window.Node) var Node = { };
1550
+
1551
+ if (!Node.ELEMENT_NODE) {
1552
+ // DOM level 2 ECMAScript Language Binding
1553
+ Object.extend(Node, {
1554
+ ELEMENT_NODE: 1,
1555
+ ATTRIBUTE_NODE: 2,
1556
+ TEXT_NODE: 3,
1557
+ CDATA_SECTION_NODE: 4,
1558
+ ENTITY_REFERENCE_NODE: 5,
1559
+ ENTITY_NODE: 6,
1560
+ PROCESSING_INSTRUCTION_NODE: 7,
1561
+ COMMENT_NODE: 8,
1562
+ DOCUMENT_NODE: 9,
1563
+ DOCUMENT_TYPE_NODE: 10,
1564
+ DOCUMENT_FRAGMENT_NODE: 11,
1565
+ NOTATION_NODE: 12
1566
+ });
1567
+ }
1568
+
1569
+ (function() {
1570
+ var element = this.Element;
1571
+ this.Element = function(tagName, attributes) {
1572
+ attributes = attributes || { };
1573
+ tagName = tagName.toLowerCase();
1574
+ var cache = Element.cache;
1575
+ if (Prototype.Browser.IE && attributes.name) {
1576
+ tagName = '<' + tagName + ' name="' + attributes.name + '">';
1577
+ delete attributes.name;
1578
+ return Element.writeAttribute(document.createElement(tagName), attributes);
1579
+ }
1580
+ if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
1581
+ return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
1582
+ };
1583
+ Object.extend(this.Element, element || { });
1584
+ if (element) this.Element.prototype = element.prototype;
1585
+ }).call(window);
1586
+
1587
+ Element.cache = { };
1588
+
1589
+ Element.Methods = {
1590
+ visible: function(element) {
1591
+ return $(element).style.display != 'none';
1592
+ },
1593
+
1594
+ toggle: function(element) {
1595
+ element = $(element);
1596
+ Element[Element.visible(element) ? 'hide' : 'show'](element);
1597
+ return element;
1598
+ },
1599
+
1600
+ hide: function(element) {
1601
+ element = $(element);
1602
+ element.style.display = 'none';
1603
+ return element;
1604
+ },
1605
+
1606
+ show: function(element) {
1607
+ element = $(element);
1608
+ element.style.display = '';
1609
+ return element;
1610
+ },
1611
+
1612
+ remove: function(element) {
1613
+ element = $(element);
1614
+ element.parentNode.removeChild(element);
1615
+ return element;
1616
+ },
1617
+
1618
+ update: function(element, content) {
1619
+ element = $(element);
1620
+ if (content && content.toElement) content = content.toElement();
1621
+ if (Object.isElement(content)) return element.update().insert(content);
1622
+ content = Object.toHTML(content);
1623
+ element.innerHTML = content.stripScripts();
1624
+ content.evalScripts.bind(content).defer();
1625
+ return element;
1626
+ },
1627
+
1628
+ replace: function(element, content) {
1629
+ element = $(element);
1630
+ if (content && content.toElement) content = content.toElement();
1631
+ else if (!Object.isElement(content)) {
1632
+ content = Object.toHTML(content);
1633
+ var range = element.ownerDocument.createRange();
1634
+ range.selectNode(element);
1635
+ content.evalScripts.bind(content).defer();
1636
+ content = range.createContextualFragment(content.stripScripts());
1637
+ }
1638
+ element.parentNode.replaceChild(content, element);
1639
+ return element;
1640
+ },
1641
+
1642
+ insert: function(element, insertions) {
1643
+ element = $(element);
1644
+
1645
+ if (Object.isString(insertions) || Object.isNumber(insertions) ||
1646
+ Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
1647
+ insertions = {bottom:insertions};
1648
+
1649
+ var content, insert, tagName, childNodes;
1650
+
1651
+ for (var position in insertions) {
1652
+ content = insertions[position];
1653
+ position = position.toLowerCase();
1654
+ insert = Element._insertionTranslations[position];
1655
+
1656
+ if (content && content.toElement) content = content.toElement();
1657
+ if (Object.isElement(content)) {
1658
+ insert(element, content);
1659
+ continue;
1660
+ }
1661
+
1662
+ content = Object.toHTML(content);
1663
+
1664
+ tagName = ((position == 'before' || position == 'after')
1665
+ ? element.parentNode : element).tagName.toUpperCase();
1666
+
1667
+ childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
1668
+
1669
+ if (position == 'top' || position == 'after') childNodes.reverse();
1670
+ childNodes.each(insert.curry(element));
1671
+
1672
+ content.evalScripts.bind(content).defer();
1673
+ }
1674
+
1675
+ return element;
1676
+ },
1677
+
1678
+ wrap: function(element, wrapper, attributes) {
1679
+ element = $(element);
1680
+ if (Object.isElement(wrapper))
1681
+ $(wrapper).writeAttribute(attributes || { });
1682
+ else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
1683
+ else wrapper = new Element('div', wrapper);
1684
+ if (element.parentNode)
1685
+ element.parentNode.replaceChild(wrapper, element);
1686
+ wrapper.appendChild(element);
1687
+ return wrapper;
1688
+ },
1689
+
1690
+ inspect: function(element) {
1691
+ element = $(element);
1692
+ var result = '<' + element.tagName.toLowerCase();
1693
+ $H({'id': 'id', 'className': 'class'}).each(function(pair) {
1694
+ var property = pair.first(), attribute = pair.last();
1695
+ var value = (element[property] || '').toString();
1696
+ if (value) result += ' ' + attribute + '=' + value.inspect(true);
1697
+ });
1698
+ return result + '>';
1699
+ },
1700
+
1701
+ recursivelyCollect: function(element, property) {
1702
+ element = $(element);
1703
+ var elements = [];
1704
+ while (element = element[property])
1705
+ if (element.nodeType == 1)
1706
+ elements.push(Element.extend(element));
1707
+ return elements;
1708
+ },
1709
+
1710
+ ancestors: function(element) {
1711
+ return $(element).recursivelyCollect('parentNode');
1712
+ },
1713
+
1714
+ descendants: function(element) {
1715
+ return $(element).select("*");
1716
+ },
1717
+
1718
+ firstDescendant: function(element) {
1719
+ element = $(element).firstChild;
1720
+ while (element && element.nodeType != 1) element = element.nextSibling;
1721
+ return $(element);
1722
+ },
1723
+
1724
+ immediateDescendants: function(element) {
1725
+ if (!(element = $(element).firstChild)) return [];
1726
+ while (element && element.nodeType != 1) element = element.nextSibling;
1727
+ if (element) return [element].concat($(element).nextSiblings());
1728
+ return [];
1729
+ },
1730
+
1731
+ previousSiblings: function(element) {
1732
+ return $(element).recursivelyCollect('previousSibling');
1733
+ },
1734
+
1735
+ nextSiblings: function(element) {
1736
+ return $(element).recursivelyCollect('nextSibling');
1737
+ },
1738
+
1739
+ siblings: function(element) {
1740
+ element = $(element);
1741
+ return element.previousSiblings().reverse().concat(element.nextSiblings());
1742
+ },
1743
+
1744
+ match: function(element, selector) {
1745
+ if (Object.isString(selector))
1746
+ selector = new Selector(selector);
1747
+ return selector.match($(element));
1748
+ },
1749
+
1750
+ up: function(element, expression, index) {
1751
+ element = $(element);
1752
+ if (arguments.length == 1) return $(element.parentNode);
1753
+ var ancestors = element.ancestors();
1754
+ return Object.isNumber(expression) ? ancestors[expression] :
1755
+ Selector.findElement(ancestors, expression, index);
1756
+ },
1757
+
1758
+ down: function(element, expression, index) {
1759
+ element = $(element);
1760
+ if (arguments.length == 1) return element.firstDescendant();
1761
+ return Object.isNumber(expression) ? element.descendants()[expression] :
1762
+ Element.select(element, expression)[index || 0];
1763
+ },
1764
+
1765
+ previous: function(element, expression, index) {
1766
+ element = $(element);
1767
+ if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
1768
+ var previousSiblings = element.previousSiblings();
1769
+ return Object.isNumber(expression) ? previousSiblings[expression] :
1770
+ Selector.findElement(previousSiblings, expression, index);
1771
+ },
1772
+
1773
+ next: function(element, expression, index) {
1774
+ element = $(element);
1775
+ if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
1776
+ var nextSiblings = element.nextSiblings();
1777
+ return Object.isNumber(expression) ? nextSiblings[expression] :
1778
+ Selector.findElement(nextSiblings, expression, index);
1779
+ },
1780
+
1781
+ select: function() {
1782
+ var args = $A(arguments), element = $(args.shift());
1783
+ return Selector.findChildElements(element, args);
1784
+ },
1785
+
1786
+ adjacent: function() {
1787
+ var args = $A(arguments), element = $(args.shift());
1788
+ return Selector.findChildElements(element.parentNode, args).without(element);
1789
+ },
1790
+
1791
+ identify: function(element) {
1792
+ element = $(element);
1793
+ var id = element.readAttribute('id'), self = arguments.callee;
1794
+ if (id) return id;
1795
+ do { id = 'anonymous_element_' + self.counter++ } while ($(id));
1796
+ element.writeAttribute('id', id);
1797
+ return id;
1798
+ },
1799
+
1800
+ readAttribute: function(element, name) {
1801
+ element = $(element);
1802
+ if (Prototype.Browser.IE) {
1803
+ var t = Element._attributeTranslations.read;
1804
+ if (t.values[name]) return t.values[name](element, name);
1805
+ if (t.names[name]) name = t.names[name];
1806
+ if (name.include(':')) {
1807
+ return (!element.attributes || !element.attributes[name]) ? null :
1808
+ element.attributes[name].value;
1809
+ }
1810
+ }
1811
+ return element.getAttribute(name);
1812
+ },
1813
+
1814
+ writeAttribute: function(element, name, value) {
1815
+ element = $(element);
1816
+ var attributes = { }, t = Element._attributeTranslations.write;
1817
+
1818
+ if (typeof name == 'object') attributes = name;
1819
+ else attributes[name] = Object.isUndefined(value) ? true : value;
1820
+
1821
+ for (var attr in attributes) {
1822
+ name = t.names[attr] || attr;
1823
+ value = attributes[attr];
1824
+ if (t.values[attr]) name = t.values[attr](element, value);
1825
+ if (value === false || value === null)
1826
+ element.removeAttribute(name);
1827
+ else if (value === true)
1828
+ element.setAttribute(name, name);
1829
+ else element.setAttribute(name, value);
1830
+ }
1831
+ return element;
1832
+ },
1833
+
1834
+ getHeight: function(element) {
1835
+ return $(element).getDimensions().height;
1836
+ },
1837
+
1838
+ getWidth: function(element) {
1839
+ return $(element).getDimensions().width;
1840
+ },
1841
+
1842
+ classNames: function(element) {
1843
+ return new Element.ClassNames(element);
1844
+ },
1845
+
1846
+ hasClassName: function(element, className) {
1847
+ if (!(element = $(element))) return;
1848
+ var elementClassName = element.className;
1849
+ return (elementClassName.length > 0 && (elementClassName == className ||
1850
+ new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1851
+ },
1852
+
1853
+ addClassName: function(element, className) {
1854
+ if (!(element = $(element))) return;
1855
+ if (!element.hasClassName(className))
1856
+ element.className += (element.className ? ' ' : '') + className;
1857
+ return element;
1858
+ },
1859
+
1860
+ removeClassName: function(element, className) {
1861
+ if (!(element = $(element))) return;
1862
+ element.className = element.className.replace(
1863
+ new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1864
+ return element;
1865
+ },
1866
+
1867
+ toggleClassName: function(element, className) {
1868
+ if (!(element = $(element))) return;
1869
+ return element[element.hasClassName(className) ?
1870
+ 'removeClassName' : 'addClassName'](className);
1871
+ },
1872
+
1873
+ // removes whitespace-only text node children
1874
+ cleanWhitespace: function(element) {
1875
+ element = $(element);
1876
+ var node = element.firstChild;
1877
+ while (node) {
1878
+ var nextNode = node.nextSibling;
1879
+ if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
1880
+ element.removeChild(node);
1881
+ node = nextNode;
1882
+ }
1883
+ return element;
1884
+ },
1885
+
1886
+ empty: function(element) {
1887
+ return $(element).innerHTML.blank();
1888
+ },
1889
+
1890
+ descendantOf: function(element, ancestor) {
1891
+ element = $(element), ancestor = $(ancestor);
1892
+
1893
+ if (element.compareDocumentPosition)
1894
+ return (element.compareDocumentPosition(ancestor) & 8) === 8;
1895
+
1896
+ if (ancestor.contains)
1897
+ return ancestor.contains(element) && ancestor !== element;
1898
+
1899
+ while (element = element.parentNode)
1900
+ if (element == ancestor) return true;
1901
+
1902
+ return false;
1903
+ },
1904
+
1905
+ scrollTo: function(element) {
1906
+ element = $(element);
1907
+ var pos = element.cumulativeOffset();
1908
+ window.scrollTo(pos[0], pos[1]);
1909
+ return element;
1910
+ },
1911
+
1912
+ getStyle: function(element, style) {
1913
+ element = $(element);
1914
+ style = style == 'float' ? 'cssFloat' : style.camelize();
1915
+ var value = element.style[style];
1916
+ if (!value || value == 'auto') {
1917
+ var css = document.defaultView.getComputedStyle(element, null);
1918
+ value = css ? css[style] : null;
1919
+ }
1920
+ if (style == 'opacity') return value ? parseFloat(value) : 1.0;
1921
+ return value == 'auto' ? null : value;
1922
+ },
1923
+
1924
+ getOpacity: function(element) {
1925
+ return $(element).getStyle('opacity');
1926
+ },
1927
+
1928
+ setStyle: function(element, styles) {
1929
+ element = $(element);
1930
+ var elementStyle = element.style, match;
1931
+ if (Object.isString(styles)) {
1932
+ element.style.cssText += ';' + styles;
1933
+ return styles.include('opacity') ?
1934
+ element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
1935
+ }
1936
+ for (var property in styles)
1937
+ if (property == 'opacity') element.setOpacity(styles[property]);
1938
+ else
1939
+ elementStyle[(property == 'float' || property == 'cssFloat') ?
1940
+ (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
1941
+ property] = styles[property];
1942
+
1943
+ return element;
1944
+ },
1945
+
1946
+ setOpacity: function(element, value) {
1947
+ element = $(element);
1948
+ element.style.opacity = (value == 1 || value === '') ? '' :
1949
+ (value < 0.00001) ? 0 : value;
1950
+ return element;
1951
+ },
1952
+
1953
+ getDimensions: function(element) {
1954
+ element = $(element);
1955
+ var display = element.getStyle('display');
1956
+ if (display != 'none' && display != null) // Safari bug
1957
+ return {width: element.offsetWidth, height: element.offsetHeight};
1958
+
1959
+ // All *Width and *Height properties give 0 on elements with display none,
1960
+ // so enable the element temporarily
1961
+ var els = element.style;
1962
+ var originalVisibility = els.visibility;
1963
+ var originalPosition = els.position;
1964
+ var originalDisplay = els.display;
1965
+ els.visibility = 'hidden';
1966
+ els.position = 'absolute';
1967
+ els.display = 'block';
1968
+ var originalWidth = element.clientWidth;
1969
+ var originalHeight = element.clientHeight;
1970
+ els.display = originalDisplay;
1971
+ els.position = originalPosition;
1972
+ els.visibility = originalVisibility;
1973
+ return {width: originalWidth, height: originalHeight};
1974
+ },
1975
+
1976
+ makePositioned: function(element) {
1977
+ element = $(element);
1978
+ var pos = Element.getStyle(element, 'position');
1979
+ if (pos == 'static' || !pos) {
1980
+ element._madePositioned = true;
1981
+ element.style.position = 'relative';
1982
+ // Opera returns the offset relative to the positioning context, when an
1983
+ // element is position relative but top and left have not been defined
1984
+ if (Prototype.Browser.Opera) {
1985
+ element.style.top = 0;
1986
+ element.style.left = 0;
1987
+ }
1988
+ }
1989
+ return element;
1990
+ },
1991
+
1992
+ undoPositioned: function(element) {
1993
+ element = $(element);
1994
+ if (element._madePositioned) {
1995
+ element._madePositioned = undefined;
1996
+ element.style.position =
1997
+ element.style.top =
1998
+ element.style.left =
1999
+ element.style.bottom =
2000
+ element.style.right = '';
2001
+ }
2002
+ return element;
2003
+ },
2004
+
2005
+ makeClipping: function(element) {
2006
+ element = $(element);
2007
+ if (element._overflow) return element;
2008
+ element._overflow = Element.getStyle(element, 'overflow') || 'auto';
2009
+ if (element._overflow !== 'hidden')
2010
+ element.style.overflow = 'hidden';
2011
+ return element;
2012
+ },
2013
+
2014
+ undoClipping: function(element) {
2015
+ element = $(element);
2016
+ if (!element._overflow) return element;
2017
+ element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
2018
+ element._overflow = null;
2019
+ return element;
2020
+ },
2021
+
2022
+ cumulativeOffset: function(element) {
2023
+ var valueT = 0, valueL = 0;
2024
+ do {
2025
+ valueT += element.offsetTop || 0;
2026
+ valueL += element.offsetLeft || 0;
2027
+ element = element.offsetParent;
2028
+ } while (element);
2029
+ return Element._returnOffset(valueL, valueT);
2030
+ },
2031
+
2032
+ positionedOffset: function(element) {
2033
+ var valueT = 0, valueL = 0;
2034
+ do {
2035
+ valueT += element.offsetTop || 0;
2036
+ valueL += element.offsetLeft || 0;
2037
+ element = element.offsetParent;
2038
+ if (element) {
2039
+ if (element.tagName.toUpperCase() == 'BODY') break;
2040
+ var p = Element.getStyle(element, 'position');
2041
+ if (p !== 'static') break;
2042
+ }
2043
+ } while (element);
2044
+ return Element._returnOffset(valueL, valueT);
2045
+ },
2046
+
2047
+ absolutize: function(element) {
2048
+ element = $(element);
2049
+ if (element.getStyle('position') == 'absolute') return element;
2050
+ // Position.prepare(); // To be done manually by Scripty when it needs it.
2051
+
2052
+ var offsets = element.positionedOffset();
2053
+ var top = offsets[1];
2054
+ var left = offsets[0];
2055
+ var width = element.clientWidth;
2056
+ var height = element.clientHeight;
2057
+
2058
+ element._originalLeft = left - parseFloat(element.style.left || 0);
2059
+ element._originalTop = top - parseFloat(element.style.top || 0);
2060
+ element._originalWidth = element.style.width;
2061
+ element._originalHeight = element.style.height;
2062
+
2063
+ element.style.position = 'absolute';
2064
+ element.style.top = top + 'px';
2065
+ element.style.left = left + 'px';
2066
+ element.style.width = width + 'px';
2067
+ element.style.height = height + 'px';
2068
+ return element;
2069
+ },
2070
+
2071
+ relativize: function(element) {
2072
+ element = $(element);
2073
+ if (element.getStyle('position') == 'relative') return element;
2074
+ // Position.prepare(); // To be done manually by Scripty when it needs it.
2075
+
2076
+ element.style.position = 'relative';
2077
+ var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
2078
+ var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
2079
+
2080
+ element.style.top = top + 'px';
2081
+ element.style.left = left + 'px';
2082
+ element.style.height = element._originalHeight;
2083
+ element.style.width = element._originalWidth;
2084
+ return element;
2085
+ },
2086
+
2087
+ cumulativeScrollOffset: function(element) {
2088
+ var valueT = 0, valueL = 0;
2089
+ do {
2090
+ valueT += element.scrollTop || 0;
2091
+ valueL += element.scrollLeft || 0;
2092
+ element = element.parentNode;
2093
+ } while (element);
2094
+ return Element._returnOffset(valueL, valueT);
2095
+ },
2096
+
2097
+ getOffsetParent: function(element) {
2098
+ if (element.offsetParent) return $(element.offsetParent);
2099
+ if (element == document.body) return $(element);
2100
+
2101
+ while ((element = element.parentNode) && element != document.body)
2102
+ if (Element.getStyle(element, 'position') != 'static')
2103
+ return $(element);
2104
+
2105
+ return $(document.body);
2106
+ },
2107
+
2108
+ viewportOffset: function(forElement) {
2109
+ var valueT = 0, valueL = 0;
2110
+
2111
+ var element = forElement;
2112
+ do {
2113
+ valueT += element.offsetTop || 0;
2114
+ valueL += element.offsetLeft || 0;
2115
+
2116
+ // Safari fix
2117
+ if (element.offsetParent == document.body &&
2118
+ Element.getStyle(element, 'position') == 'absolute') break;
2119
+
2120
+ } while (element = element.offsetParent);
2121
+
2122
+ element = forElement;
2123
+ do {
2124
+ if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
2125
+ valueT -= element.scrollTop || 0;
2126
+ valueL -= element.scrollLeft || 0;
2127
+ }
2128
+ } while (element = element.parentNode);
2129
+
2130
+ return Element._returnOffset(valueL, valueT);
2131
+ },
2132
+
2133
+ clonePosition: function(element, source) {
2134
+ var options = Object.extend({
2135
+ setLeft: true,
2136
+ setTop: true,
2137
+ setWidth: true,
2138
+ setHeight: true,
2139
+ offsetTop: 0,
2140
+ offsetLeft: 0
2141
+ }, arguments[2] || { });
2142
+
2143
+ // find page position of source
2144
+ source = $(source);
2145
+ var p = source.viewportOffset();
2146
+
2147
+ // find coordinate system to use
2148
+ element = $(element);
2149
+ var delta = [0, 0];
2150
+ var parent = null;
2151
+ // delta [0,0] will do fine with position: fixed elements,
2152
+ // position:absolute needs offsetParent deltas
2153
+ if (Element.getStyle(element, 'position') == 'absolute') {
2154
+ parent = element.getOffsetParent();
2155
+ delta = parent.viewportOffset();
2156
+ }
2157
+
2158
+ // correct by body offsets (fixes Safari)
2159
+ if (parent == document.body) {
2160
+ delta[0] -= document.body.offsetLeft;
2161
+ delta[1] -= document.body.offsetTop;
2162
+ }
2163
+
2164
+ // set position
2165
+ if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
2166
+ if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
2167
+ if (options.setWidth) element.style.width = source.offsetWidth + 'px';
2168
+ if (options.setHeight) element.style.height = source.offsetHeight + 'px';
2169
+ return element;
2170
+ }
2171
+ };
2172
+
2173
+ Element.Methods.identify.counter = 1;
2174
+
2175
+ Object.extend(Element.Methods, {
2176
+ getElementsBySelector: Element.Methods.select,
2177
+ childElements: Element.Methods.immediateDescendants
2178
+ });
2179
+
2180
+ Element._attributeTranslations = {
2181
+ write: {
2182
+ names: {
2183
+ className: 'class',
2184
+ htmlFor: 'for'
2185
+ },
2186
+ values: { }
2187
+ }
2188
+ };
2189
+
2190
+ if (Prototype.Browser.Opera) {
2191
+ Element.Methods.getStyle = Element.Methods.getStyle.wrap(
2192
+ function(proceed, element, style) {
2193
+ switch (style) {
2194
+ case 'left': case 'top': case 'right': case 'bottom':
2195
+ if (proceed(element, 'position') === 'static') return null;
2196
+ case 'height': case 'width':
2197
+ // returns '0px' for hidden elements; we want it to return null
2198
+ if (!Element.visible(element)) return null;
2199
+
2200
+ // returns the border-box dimensions rather than the content-box
2201
+ // dimensions, so we subtract padding and borders from the value
2202
+ var dim = parseInt(proceed(element, style), 10);
2203
+
2204
+ if (dim !== element['offset' + style.capitalize()])
2205
+ return dim + 'px';
2206
+
2207
+ var properties;
2208
+ if (style === 'height') {
2209
+ properties = ['border-top-width', 'padding-top',
2210
+ 'padding-bottom', 'border-bottom-width'];
2211
+ }
2212
+ else {
2213
+ properties = ['border-left-width', 'padding-left',
2214
+ 'padding-right', 'border-right-width'];
2215
+ }
2216
+ return properties.inject(dim, function(memo, property) {
2217
+ var val = proceed(element, property);
2218
+ return val === null ? memo : memo - parseInt(val, 10);
2219
+ }) + 'px';
2220
+ default: return proceed(element, style);
2221
+ }
2222
+ }
2223
+ );
2224
+
2225
+ Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
2226
+ function(proceed, element, attribute) {
2227
+ if (attribute === 'title') return element.title;
2228
+ return proceed(element, attribute);
2229
+ }
2230
+ );
2231
+ }
2232
+
2233
+ else if (Prototype.Browser.IE) {
2234
+ // IE doesn't report offsets correctly for static elements, so we change them
2235
+ // to "relative" to get the values, then change them back.
2236
+ Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
2237
+ function(proceed, element) {
2238
+ element = $(element);
2239
+ // IE throws an error if element is not in document
2240
+ try { element.offsetParent }
2241
+ catch(e) { return $(document.body) }
2242
+ var position = element.getStyle('position');
2243
+ if (position !== 'static') return proceed(element);
2244
+ element.setStyle({ position: 'relative' });
2245
+ var value = proceed(element);
2246
+ element.setStyle({ position: position });
2247
+ return value;
2248
+ }
2249
+ );
2250
+
2251
+ $w('positionedOffset viewportOffset').each(function(method) {
2252
+ Element.Methods[method] = Element.Methods[method].wrap(
2253
+ function(proceed, element) {
2254
+ element = $(element);
2255
+ try { element.offsetParent }
2256
+ catch(e) { return Element._returnOffset(0,0) }
2257
+ var position = element.getStyle('position');
2258
+ if (position !== 'static') return proceed(element);
2259
+ // Trigger hasLayout on the offset parent so that IE6 reports
2260
+ // accurate offsetTop and offsetLeft values for position: fixed.
2261
+ var offsetParent = element.getOffsetParent();
2262
+ if (offsetParent && offsetParent.getStyle('position') === 'fixed')
2263
+ offsetParent.setStyle({ zoom: 1 });
2264
+ element.setStyle({ position: 'relative' });
2265
+ var value = proceed(element);
2266
+ element.setStyle({ position: position });
2267
+ return value;
2268
+ }
2269
+ );
2270
+ });
2271
+
2272
+ Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
2273
+ function(proceed, element) {
2274
+ try { element.offsetParent }
2275
+ catch(e) { return Element._returnOffset(0,0) }
2276
+ return proceed(element);
2277
+ }
2278
+ );
2279
+
2280
+ Element.Methods.getStyle = function(element, style) {
2281
+ element = $(element);
2282
+ style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
2283
+ var value = element.style[style];
2284
+ if (!value && element.currentStyle) value = element.currentStyle[style];
2285
+
2286
+ if (style == 'opacity') {
2287
+ if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
2288
+ if (value[1]) return parseFloat(value[1]) / 100;
2289
+ return 1.0;
2290
+ }
2291
+
2292
+ if (value == 'auto') {
2293
+ if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
2294
+ return element['offset' + style.capitalize()] + 'px';
2295
+ return null;
2296
+ }
2297
+ return value;
2298
+ };
2299
+
2300
+ Element.Methods.setOpacity = function(element, value) {
2301
+ function stripAlpha(filter){
2302
+ return filter.replace(/alpha\([^\)]*\)/gi,'');
2303
+ }
2304
+ element = $(element);
2305
+ var currentStyle = element.currentStyle;
2306
+ if ((currentStyle && !currentStyle.hasLayout) ||
2307
+ (!currentStyle && element.style.zoom == 'normal'))
2308
+ element.style.zoom = 1;
2309
+
2310
+ var filter = element.getStyle('filter'), style = element.style;
2311
+ if (value == 1 || value === '') {
2312
+ (filter = stripAlpha(filter)) ?
2313
+ style.filter = filter : style.removeAttribute('filter');
2314
+ return element;
2315
+ } else if (value < 0.00001) value = 0;
2316
+ style.filter = stripAlpha(filter) +
2317
+ 'alpha(opacity=' + (value * 100) + ')';
2318
+ return element;
2319
+ };
2320
+
2321
+ Element._attributeTranslations = {
2322
+ read: {
2323
+ names: {
2324
+ 'class': 'className',
2325
+ 'for': 'htmlFor'
2326
+ },
2327
+ values: {
2328
+ _getAttr: function(element, attribute) {
2329
+ return element.getAttribute(attribute, 2);
2330
+ },
2331
+ _getAttrNode: function(element, attribute) {
2332
+ var node = element.getAttributeNode(attribute);
2333
+ return node ? node.value : "";
2334
+ },
2335
+ _getEv: function(element, attribute) {
2336
+ attribute = element.getAttribute(attribute);
2337
+ return attribute ? attribute.toString().slice(23, -2) : null;
2338
+ },
2339
+ _flag: function(element, attribute) {
2340
+ return $(element).hasAttribute(attribute) ? attribute : null;
2341
+ },
2342
+ style: function(element) {
2343
+ return element.style.cssText.toLowerCase();
2344
+ },
2345
+ title: function(element) {
2346
+ return element.title;
2347
+ }
2348
+ }
2349
+ }
2350
+ };
2351
+
2352
+ Element._attributeTranslations.write = {
2353
+ names: Object.extend({
2354
+ cellpadding: 'cellPadding',
2355
+ cellspacing: 'cellSpacing'
2356
+ }, Element._attributeTranslations.read.names),
2357
+ values: {
2358
+ checked: function(element, value) {
2359
+ element.checked = !!value;
2360
+ },
2361
+
2362
+ style: function(element, value) {
2363
+ element.style.cssText = value ? value : '';
2364
+ }
2365
+ }
2366
+ };
2367
+
2368
+ Element._attributeTranslations.has = {};
2369
+
2370
+ $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
2371
+ 'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
2372
+ Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
2373
+ Element._attributeTranslations.has[attr.toLowerCase()] = attr;
2374
+ });
2375
+
2376
+ (function(v) {
2377
+ Object.extend(v, {
2378
+ href: v._getAttr,
2379
+ src: v._getAttr,
2380
+ type: v._getAttr,
2381
+ action: v._getAttrNode,
2382
+ disabled: v._flag,
2383
+ checked: v._flag,
2384
+ readonly: v._flag,
2385
+ multiple: v._flag,
2386
+ onload: v._getEv,
2387
+ onunload: v._getEv,
2388
+ onclick: v._getEv,
2389
+ ondblclick: v._getEv,
2390
+ onmousedown: v._getEv,
2391
+ onmouseup: v._getEv,
2392
+ onmouseover: v._getEv,
2393
+ onmousemove: v._getEv,
2394
+ onmouseout: v._getEv,
2395
+ onfocus: v._getEv,
2396
+ onblur: v._getEv,
2397
+ onkeypress: v._getEv,
2398
+ onkeydown: v._getEv,
2399
+ onkeyup: v._getEv,
2400
+ onsubmit: v._getEv,
2401
+ onreset: v._getEv,
2402
+ onselect: v._getEv,
2403
+ onchange: v._getEv
2404
+ });
2405
+ })(Element._attributeTranslations.read.values);
2406
+ }
2407
+
2408
+ else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
2409
+ Element.Methods.setOpacity = function(element, value) {
2410
+ element = $(element);
2411
+ element.style.opacity = (value == 1) ? 0.999999 :
2412
+ (value === '') ? '' : (value < 0.00001) ? 0 : value;
2413
+ return element;
2414
+ };
2415
+ }
2416
+
2417
+ else if (Prototype.Browser.WebKit) {
2418
+ Element.Methods.setOpacity = function(element, value) {
2419
+ element = $(element);
2420
+ element.style.opacity = (value == 1 || value === '') ? '' :
2421
+ (value < 0.00001) ? 0 : value;
2422
+
2423
+ if (value == 1)
2424
+ if(element.tagName.toUpperCase() == 'IMG' && element.width) {
2425
+ element.width++; element.width--;
2426
+ } else try {
2427
+ var n = document.createTextNode(' ');
2428
+ element.appendChild(n);
2429
+ element.removeChild(n);
2430
+ } catch (e) { }
2431
+
2432
+ return element;
2433
+ };
2434
+
2435
+ // Safari returns margins on body which is incorrect if the child is absolutely
2436
+ // positioned. For performance reasons, redefine Element#cumulativeOffset for
2437
+ // KHTML/WebKit only.
2438
+ Element.Methods.cumulativeOffset = function(element) {
2439
+ var valueT = 0, valueL = 0;
2440
+ do {
2441
+ valueT += element.offsetTop || 0;
2442
+ valueL += element.offsetLeft || 0;
2443
+ if (element.offsetParent == document.body)
2444
+ if (Element.getStyle(element, 'position') == 'absolute') break;
2445
+
2446
+ element = element.offsetParent;
2447
+ } while (element);
2448
+
2449
+ return Element._returnOffset(valueL, valueT);
2450
+ };
2451
+ }
2452
+
2453
+ if (Prototype.Browser.IE || Prototype.Browser.Opera) {
2454
+ // IE and Opera are missing .innerHTML support for TABLE-related and SELECT elements
2455
+ Element.Methods.update = function(element, content) {
2456
+ element = $(element);
2457
+
2458
+ if (content && content.toElement) content = content.toElement();
2459
+ if (Object.isElement(content)) return element.update().insert(content);
2460
+
2461
+ content = Object.toHTML(content);
2462
+ var tagName = element.tagName.toUpperCase();
2463
+
2464
+ if (tagName in Element._insertionTranslations.tags) {
2465
+ $A(element.childNodes).each(function(node) { element.removeChild(node) });
2466
+ Element._getContentFromAnonymousElement(tagName, content.stripScripts())
2467
+ .each(function(node) { element.appendChild(node) });
2468
+ }
2469
+ else element.innerHTML = content.stripScripts();
2470
+
2471
+ content.evalScripts.bind(content).defer();
2472
+ return element;
2473
+ };
2474
+ }
2475
+
2476
+ if ('outerHTML' in document.createElement('div')) {
2477
+ Element.Methods.replace = function(element, content) {
2478
+ element = $(element);
2479
+
2480
+ if (content && content.toElement) content = content.toElement();
2481
+ if (Object.isElement(content)) {
2482
+ element.parentNode.replaceChild(content, element);
2483
+ return element;
2484
+ }
2485
+
2486
+ content = Object.toHTML(content);
2487
+ var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
2488
+
2489
+ if (Element._insertionTranslations.tags[tagName]) {
2490
+ var nextSibling = element.next();
2491
+ var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
2492
+ parent.removeChild(element);
2493
+ if (nextSibling)
2494
+ fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
2495
+ else
2496
+ fragments.each(function(node) { parent.appendChild(node) });
2497
+ }
2498
+ else element.outerHTML = content.stripScripts();
2499
+
2500
+ content.evalScripts.bind(content).defer();
2501
+ return element;
2502
+ };
2503
+ }
2504
+
2505
+ Element._returnOffset = function(l, t) {
2506
+ var result = [l, t];
2507
+ result.left = l;
2508
+ result.top = t;
2509
+ return result;
2510
+ };
2511
+
2512
+ Element._getContentFromAnonymousElement = function(tagName, html) {
2513
+ var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
2514
+ if (t) {
2515
+ div.innerHTML = t[0] + html + t[1];
2516
+ t[2].times(function() { div = div.firstChild });
2517
+ } else div.innerHTML = html;
2518
+ return $A(div.childNodes);
2519
+ };
2520
+
2521
+ Element._insertionTranslations = {
2522
+ before: function(element, node) {
2523
+ element.parentNode.insertBefore(node, element);
2524
+ },
2525
+ top: function(element, node) {
2526
+ element.insertBefore(node, element.firstChild);
2527
+ },
2528
+ bottom: function(element, node) {
2529
+ element.appendChild(node);
2530
+ },
2531
+ after: function(element, node) {
2532
+ element.parentNode.insertBefore(node, element.nextSibling);
2533
+ },
2534
+ tags: {
2535
+ TABLE: ['<table>', '</table>', 1],
2536
+ TBODY: ['<table><tbody>', '</tbody></table>', 2],
2537
+ TR: ['<table><tbody><tr>', '</tr></tbody></table>', 3],
2538
+ TD: ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
2539
+ SELECT: ['<select>', '</select>', 1]
2540
+ }
2541
+ };
2542
+
2543
+ (function() {
2544
+ Object.extend(this.tags, {
2545
+ THEAD: this.tags.TBODY,
2546
+ TFOOT: this.tags.TBODY,
2547
+ TH: this.tags.TD
2548
+ });
2549
+ }).call(Element._insertionTranslations);
2550
+
2551
+ Element.Methods.Simulated = {
2552
+ hasAttribute: function(element, attribute) {
2553
+ attribute = Element._attributeTranslations.has[attribute] || attribute;
2554
+ var node = $(element).getAttributeNode(attribute);
2555
+ return !!(node && node.specified);
2556
+ }
2557
+ };
2558
+
2559
+ Element.Methods.ByTag = { };
2560
+
2561
+ Object.extend(Element, Element.Methods);
2562
+
2563
+ if (!Prototype.BrowserFeatures.ElementExtensions &&
2564
+ document.createElement('div')['__proto__']) {
2565
+ window.HTMLElement = { };
2566
+ window.HTMLElement.prototype = document.createElement('div')['__proto__'];
2567
+ Prototype.BrowserFeatures.ElementExtensions = true;
2568
+ }
2569
+
2570
+ Element.extend = (function() {
2571
+ if (Prototype.BrowserFeatures.SpecificElementExtensions)
2572
+ return Prototype.K;
2573
+
2574
+ var Methods = { }, ByTag = Element.Methods.ByTag;
2575
+
2576
+ var extend = Object.extend(function(element) {
2577
+ if (!element || element._extendedByPrototype ||
2578
+ element.nodeType != 1 || element == window) return element;
2579
+
2580
+ var methods = Object.clone(Methods),
2581
+ tagName = element.tagName.toUpperCase(), property, value;
2582
+
2583
+ // extend methods for specific tags
2584
+ if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);
2585
+
2586
+ for (property in methods) {
2587
+ value = methods[property];
2588
+ if (Object.isFunction(value) && !(property in element))
2589
+ element[property] = value.methodize();
2590
+ }
2591
+
2592
+ element._extendedByPrototype = Prototype.emptyFunction;
2593
+ return element;
2594
+
2595
+ }, {
2596
+ refresh: function() {
2597
+ // extend methods for all tags (Safari doesn't need this)
2598
+ if (!Prototype.BrowserFeatures.ElementExtensions) {
2599
+ Object.extend(Methods, Element.Methods);
2600
+ Object.extend(Methods, Element.Methods.Simulated);
2601
+ }
2602
+ }
2603
+ });
2604
+
2605
+ extend.refresh();
2606
+ return extend;
2607
+ })();
2608
+
2609
+ Element.hasAttribute = function(element, attribute) {
2610
+ if (element.hasAttribute) return element.hasAttribute(attribute);
2611
+ return Element.Methods.Simulated.hasAttribute(element, attribute);
2612
+ };
2613
+
2614
+ Element.addMethods = function(methods) {
2615
+ var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
2616
+
2617
+ if (!methods) {
2618
+ Object.extend(Form, Form.Methods);
2619
+ Object.extend(Form.Element, Form.Element.Methods);
2620
+ Object.extend(Element.Methods.ByTag, {
2621
+ "FORM": Object.clone(Form.Methods),
2622
+ "INPUT": Object.clone(Form.Element.Methods),
2623
+ "SELECT": Object.clone(Form.Element.Methods),
2624
+ "TEXTAREA": Object.clone(Form.Element.Methods)
2625
+ });
2626
+ }
2627
+
2628
+ if (arguments.length == 2) {
2629
+ var tagName = methods;
2630
+ methods = arguments[1];
2631
+ }
2632
+
2633
+ if (!tagName) Object.extend(Element.Methods, methods || { });
2634
+ else {
2635
+ if (Object.isArray(tagName)) tagName.each(extend);
2636
+ else extend(tagName);
2637
+ }
2638
+
2639
+ function extend(tagName) {
2640
+ tagName = tagName.toUpperCase();
2641
+ if (!Element.Methods.ByTag[tagName])
2642
+ Element.Methods.ByTag[tagName] = { };
2643
+ Object.extend(Element.Methods.ByTag[tagName], methods);
2644
+ }
2645
+
2646
+ function copy(methods, destination, onlyIfAbsent) {
2647
+ onlyIfAbsent = onlyIfAbsent || false;
2648
+ for (var property in methods) {
2649
+ var value = methods[property];
2650
+ if (!Object.isFunction(value)) continue;
2651
+ if (!onlyIfAbsent || !(property in destination))
2652
+ destination[property] = value.methodize();
2653
+ }
2654
+ }
2655
+
2656
+ function findDOMClass(tagName) {
2657
+ var klass;
2658
+ var trans = {
2659
+ "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
2660
+ "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
2661
+ "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
2662
+ "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
2663
+ "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
2664
+ "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
2665
+ "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
2666
+ "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
2667
+ "FrameSet", "IFRAME": "IFrame"
2668
+ };
2669
+ if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
2670
+ if (window[klass]) return window[klass];
2671
+ klass = 'HTML' + tagName + 'Element';
2672
+ if (window[klass]) return window[klass];
2673
+ klass = 'HTML' + tagName.capitalize() + 'Element';
2674
+ if (window[klass]) return window[klass];
2675
+
2676
+ window[klass] = { };
2677
+ window[klass].prototype = document.createElement(tagName)['__proto__'];
2678
+ return window[klass];
2679
+ }
2680
+
2681
+ if (F.ElementExtensions) {
2682
+ copy(Element.Methods, HTMLElement.prototype);
2683
+ copy(Element.Methods.Simulated, HTMLElement.prototype, true);
2684
+ }
2685
+
2686
+ if (F.SpecificElementExtensions) {
2687
+ for (var tag in Element.Methods.ByTag) {
2688
+ var klass = findDOMClass(tag);
2689
+ if (Object.isUndefined(klass)) continue;
2690
+ copy(T[tag], klass.prototype);
2691
+ }
2692
+ }
2693
+
2694
+ Object.extend(Element, Element.Methods);
2695
+ delete Element.ByTag;
2696
+
2697
+ if (Element.extend.refresh) Element.extend.refresh();
2698
+ Element.cache = { };
2699
+ };
2700
+
2701
+ document.viewport = {
2702
+ getDimensions: function() {
2703
+ var dimensions = { }, B = Prototype.Browser;
2704
+ $w('width height').each(function(d) {
2705
+ var D = d.capitalize();
2706
+ if (B.WebKit && !document.evaluate) {
2707
+ // Safari <3.0 needs self.innerWidth/Height
2708
+ dimensions[d] = self['inner' + D];
2709
+ } else if (B.Opera && parseFloat(window.opera.version()) < 9.5) {
2710
+ // Opera <9.5 needs document.body.clientWidth/Height
2711
+ dimensions[d] = document.body['client' + D]
2712
+ } else {
2713
+ dimensions[d] = document.documentElement['client' + D];
2714
+ }
2715
+ });
2716
+ return dimensions;
2717
+ },
2718
+
2719
+ getWidth: function() {
2720
+ return this.getDimensions().width;
2721
+ },
2722
+
2723
+ getHeight: function() {
2724
+ return this.getDimensions().height;
2725
+ },
2726
+
2727
+ getScrollOffsets: function() {
2728
+ return Element._returnOffset(
2729
+ window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
2730
+ window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
2731
+ }
2732
+ };
2733
+ /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2734
+ * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
2735
+ * license. Please see http://www.yui-ext.com/ for more information. */
2736
+
2737
+ var Selector = Class.create({
2738
+ initialize: function(expression) {
2739
+ this.expression = expression.strip();
2740
+
2741
+ if (this.shouldUseSelectorsAPI()) {
2742
+ this.mode = 'selectorsAPI';
2743
+ } else if (this.shouldUseXPath()) {
2744
+ this.mode = 'xpath';
2745
+ this.compileXPathMatcher();
2746
+ } else {
2747
+ this.mode = "normal";
2748
+ this.compileMatcher();
2749
+ }
2750
+
2751
+ },
2752
+
2753
+ shouldUseXPath: function() {
2754
+ if (!Prototype.BrowserFeatures.XPath) return false;
2755
+
2756
+ var e = this.expression;
2757
+
2758
+ // Safari 3 chokes on :*-of-type and :empty
2759
+ if (Prototype.Browser.WebKit &&
2760
+ (e.include("-of-type") || e.include(":empty")))
2761
+ return false;
2762
+
2763
+ // XPath can't do namespaced attributes, nor can it read
2764
+ // the "checked" property from DOM nodes
2765
+ if ((/(\[[\w-]*?:|:checked)/).test(e))
2766
+ return false;
2767
+
2768
+ return true;
2769
+ },
2770
+
2771
+ shouldUseSelectorsAPI: function() {
2772
+ if (!Prototype.BrowserFeatures.SelectorsAPI) return false;
2773
+
2774
+ if (!Selector._div) Selector._div = new Element('div');
2775
+
2776
+ // Make sure the browser treats the selector as valid. Test on an
2777
+ // isolated element to minimize cost of this check.
2778
+ try {
2779
+ Selector._div.querySelector(this.expression);
2780
+ } catch(e) {
2781
+ return false;
2782
+ }
2783
+
2784
+ return true;
2785
+ },
2786
+
2787
+ compileMatcher: function() {
2788
+ var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
2789
+ c = Selector.criteria, le, p, m;
2790
+
2791
+ if (Selector._cache[e]) {
2792
+ this.matcher = Selector._cache[e];
2793
+ return;
2794
+ }
2795
+
2796
+ this.matcher = ["this.matcher = function(root) {",
2797
+ "var r = root, h = Selector.handlers, c = false, n;"];
2798
+
2799
+ while (e && le != e && (/\S/).test(e)) {
2800
+ le = e;
2801
+ for (var i in ps) {
2802
+ p = ps[i];
2803
+ if (m = e.match(p)) {
2804
+ this.matcher.push(Object.isFunction(c[i]) ? c[i](m) :
2805
+ new Template(c[i]).evaluate(m));
2806
+ e = e.replace(m[0], '');
2807
+ break;
2808
+ }
2809
+ }
2810
+ }
2811
+
2812
+ this.matcher.push("return h.unique(n);\n}");
2813
+ eval(this.matcher.join('\n'));
2814
+ Selector._cache[this.expression] = this.matcher;
2815
+ },
2816
+
2817
+ compileXPathMatcher: function() {
2818
+ var e = this.expression, ps = Selector.patterns,
2819
+ x = Selector.xpath, le, m;
2820
+
2821
+ if (Selector._cache[e]) {
2822
+ this.xpath = Selector._cache[e]; return;
2823
+ }
2824
+
2825
+ this.matcher = ['.//*'];
2826
+ while (e && le != e && (/\S/).test(e)) {
2827
+ le = e;
2828
+ for (var i in ps) {
2829
+ if (m = e.match(ps[i])) {
2830
+ this.matcher.push(Object.isFunction(x[i]) ? x[i](m) :
2831
+ new Template(x[i]).evaluate(m));
2832
+ e = e.replace(m[0], '');
2833
+ break;
2834
+ }
2835
+ }
2836
+ }
2837
+
2838
+ this.xpath = this.matcher.join('');
2839
+ Selector._cache[this.expression] = this.xpath;
2840
+ },
2841
+
2842
+ findElements: function(root) {
2843
+ root = root || document;
2844
+ var e = this.expression, results;
2845
+
2846
+ switch (this.mode) {
2847
+ case 'selectorsAPI':
2848
+ // querySelectorAll queries document-wide, then filters to descendants
2849
+ // of the context element. That's not what we want.
2850
+ // Add an explicit context to the selector if necessary.
2851
+ if (root !== document) {
2852
+ var oldId = root.id, id = $(root).identify();
2853
+ e = "#" + id + " " + e;
2854
+ }
2855
+
2856
+ results = $A(root.querySelectorAll(e)).map(Element.extend);
2857
+ root.id = oldId;
2858
+
2859
+ return results;
2860
+ case 'xpath':
2861
+ return document._getElementsByXPath(this.xpath, root);
2862
+ default:
2863
+ return this.matcher(root);
2864
+ }
2865
+ },
2866
+
2867
+ match: function(element) {
2868
+ this.tokens = [];
2869
+
2870
+ var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
2871
+ var le, p, m;
2872
+
2873
+ while (e && le !== e && (/\S/).test(e)) {
2874
+ le = e;
2875
+ for (var i in ps) {
2876
+ p = ps[i];
2877
+ if (m = e.match(p)) {
2878
+ // use the Selector.assertions methods unless the selector
2879
+ // is too complex.
2880
+ if (as[i]) {
2881
+ this.tokens.push([i, Object.clone(m)]);
2882
+ e = e.replace(m[0], '');
2883
+ } else {
2884
+ // reluctantly do a document-wide search
2885
+ // and look for a match in the array
2886
+ return this.findElements(document).include(element);
2887
+ }
2888
+ }
2889
+ }
2890
+ }
2891
+
2892
+ var match = true, name, matches;
2893
+ for (var i = 0, token; token = this.tokens[i]; i++) {
2894
+ name = token[0], matches = token[1];
2895
+ if (!Selector.assertions[name](element, matches)) {
2896
+ match = false; break;
2897
+ }
2898
+ }
2899
+
2900
+ return match;
2901
+ },
2902
+
2903
+ toString: function() {
2904
+ return this.expression;
2905
+ },
2906
+
2907
+ inspect: function() {
2908
+ return "#<Selector:" + this.expression.inspect() + ">";
2909
+ }
2910
+ });
2911
+
2912
+ Object.extend(Selector, {
2913
+ _cache: { },
2914
+
2915
+ xpath: {
2916
+ descendant: "//*",
2917
+ child: "/*",
2918
+ adjacent: "/following-sibling::*[1]",
2919
+ laterSibling: '/following-sibling::*',
2920
+ tagName: function(m) {
2921
+ if (m[1] == '*') return '';
2922
+ return "[local-name()='" + m[1].toLowerCase() +
2923
+ "' or local-name()='" + m[1].toUpperCase() + "']";
2924
+ },
2925
+ className: "[contains(concat(' ', @class, ' '), ' #{1} ')]",
2926
+ id: "[@id='#{1}']",
2927
+ attrPresence: function(m) {
2928
+ m[1] = m[1].toLowerCase();
2929
+ return new Template("[@#{1}]").evaluate(m);
2930
+ },
2931
+ attr: function(m) {
2932
+ m[1] = m[1].toLowerCase();
2933
+ m[3] = m[5] || m[6];
2934
+ return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
2935
+ },
2936
+ pseudo: function(m) {
2937
+ var h = Selector.xpath.pseudos[m[1]];
2938
+ if (!h) return '';
2939
+ if (Object.isFunction(h)) return h(m);
2940
+ return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
2941
+ },
2942
+ operators: {
2943
+ '=': "[@#{1}='#{3}']",
2944
+ '!=': "[@#{1}!='#{3}']",
2945
+ '^=': "[starts-with(@#{1}, '#{3}')]",
2946
+ '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
2947
+ '*=': "[contains(@#{1}, '#{3}')]",
2948
+ '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
2949
+ '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
2950
+ },
2951
+ pseudos: {
2952
+ 'first-child': '[not(preceding-sibling::*)]',
2953
+ 'last-child': '[not(following-sibling::*)]',
2954
+ 'only-child': '[not(preceding-sibling::* or following-sibling::*)]',
2955
+ 'empty': "[count(*) = 0 and (count(text()) = 0)]",
2956
+ 'checked': "[@checked]",
2957
+ 'disabled': "[(@disabled) and (@type!='hidden')]",
2958
+ 'enabled': "[not(@disabled) and (@type!='hidden')]",
2959
+ 'not': function(m) {
2960
+ var e = m[6], p = Selector.patterns,
2961
+ x = Selector.xpath, le, v;
2962
+
2963
+ var exclusion = [];
2964
+ while (e && le != e && (/\S/).test(e)) {
2965
+ le = e;
2966
+ for (var i in p) {
2967
+ if (m = e.match(p[i])) {
2968
+ v = Object.isFunction(x[i]) ? x[i](m) : new Template(x[i]).evaluate(m);
2969
+ exclusion.push("(" + v.substring(1, v.length - 1) + ")");
2970
+ e = e.replace(m[0], '');
2971
+ break;
2972
+ }
2973
+ }
2974
+ }
2975
+ return "[not(" + exclusion.join(" and ") + ")]";
2976
+ },
2977
+ 'nth-child': function(m) {
2978
+ return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
2979
+ },
2980
+ 'nth-last-child': function(m) {
2981
+ return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
2982
+ },
2983
+ 'nth-of-type': function(m) {
2984
+ return Selector.xpath.pseudos.nth("position() ", m);
2985
+ },
2986
+ 'nth-last-of-type': function(m) {
2987
+ return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
2988
+ },
2989
+ 'first-of-type': function(m) {
2990
+ m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
2991
+ },
2992
+ 'last-of-type': function(m) {
2993
+ m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
2994
+ },
2995
+ 'only-of-type': function(m) {
2996
+ var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
2997
+ },
2998
+ nth: function(fragment, m) {
2999
+ var mm, formula = m[6], predicate;
3000
+ if (formula == 'even') formula = '2n+0';
3001
+ if (formula == 'odd') formula = '2n+1';
3002
+ if (mm = formula.match(/^(\d+)$/)) // digit only
3003
+ return '[' + fragment + "= " + mm[1] + ']';
3004
+ if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
3005
+ if (mm[1] == "-") mm[1] = -1;
3006
+ var a = mm[1] ? Number(mm[1]) : 1;
3007
+ var b = mm[2] ? Number(mm[2]) : 0;
3008
+ predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
3009
+ "((#{fragment} - #{b}) div #{a} >= 0)]";
3010
+ return new Template(predicate).evaluate({
3011
+ fragment: fragment, a: a, b: b });
3012
+ }
3013
+ }
3014
+ }
3015
+ },
3016
+
3017
+ criteria: {
3018
+ tagName: 'n = h.tagName(n, r, "#{1}", c); c = false;',
3019
+ className: 'n = h.className(n, r, "#{1}", c); c = false;',
3020
+ id: 'n = h.id(n, r, "#{1}", c); c = false;',
3021
+ attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
3022
+ attr: function(m) {
3023
+ m[3] = (m[5] || m[6]);
3024
+ return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
3025
+ },
3026
+ pseudo: function(m) {
3027
+ if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
3028
+ return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
3029
+ },
3030
+ descendant: 'c = "descendant";',
3031
+ child: 'c = "child";',
3032
+ adjacent: 'c = "adjacent";',
3033
+ laterSibling: 'c = "laterSibling";'
3034
+ },
3035
+
3036
+ patterns: {
3037
+ // combinators must be listed first
3038
+ // (and descendant needs to be last combinator)
3039
+ laterSibling: /^\s*~\s*/,
3040
+ child: /^\s*>\s*/,
3041
+ adjacent: /^\s*\+\s*/,
3042
+ descendant: /^\s/,
3043
+
3044
+ // selectors follow
3045
+ tagName: /^\s*(\*|[\w\-]+)(\b|$)?/,
3046
+ id: /^#([\w\-\*]+)(\b|$)/,
3047
+ className: /^\.([\w\-\*]+)(\b|$)/,
3048
+ pseudo:
3049
+ /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/,
3050
+ attrPresence: /^\[((?:[\w]+:)?[\w]+)\]/,
3051
+ attr: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/
3052
+ },
3053
+
3054
+ // for Selector.match and Element#match
3055
+ assertions: {
3056
+ tagName: function(element, matches) {
3057
+ return matches[1].toUpperCase() == element.tagName.toUpperCase();
3058
+ },
3059
+
3060
+ className: function(element, matches) {
3061
+ return Element.hasClassName(element, matches[1]);
3062
+ },
3063
+
3064
+ id: function(element, matches) {
3065
+ return element.id === matches[1];
3066
+ },
3067
+
3068
+ attrPresence: function(element, matches) {
3069
+ return Element.hasAttribute(element, matches[1]);
3070
+ },
3071
+
3072
+ attr: function(element, matches) {
3073
+ var nodeValue = Element.readAttribute(element, matches[1]);
3074
+ return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
3075
+ }
3076
+ },
3077
+
3078
+ handlers: {
3079
+ // UTILITY FUNCTIONS
3080
+ // joins two collections
3081
+ concat: function(a, b) {
3082
+ for (var i = 0, node; node = b[i]; i++)
3083
+ a.push(node);
3084
+ return a;
3085
+ },
3086
+
3087
+ // marks an array of nodes for counting
3088
+ mark: function(nodes) {
3089
+ var _true = Prototype.emptyFunction;
3090
+ for (var i = 0, node; node = nodes[i]; i++)
3091
+ node._countedByPrototype = _true;
3092
+ return nodes;
3093
+ },
3094
+
3095
+ unmark: function(nodes) {
3096
+ for (var i = 0, node; node = nodes[i]; i++)
3097
+ node._countedByPrototype = undefined;
3098
+ return nodes;
3099
+ },
3100
+
3101
+ // mark each child node with its position (for nth calls)
3102
+ // "ofType" flag indicates whether we're indexing for nth-of-type
3103
+ // rather than nth-child
3104
+ index: function(parentNode, reverse, ofType) {
3105
+ parentNode._countedByPrototype = Prototype.emptyFunction;
3106
+ if (reverse) {
3107
+ for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
3108
+ var node = nodes[i];
3109
+ if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
3110
+ }
3111
+ } else {
3112
+ for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
3113
+ if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
3114
+ }
3115
+ },
3116
+
3117
+ // filters out duplicates and extends all nodes
3118
+ unique: function(nodes) {
3119
+ if (nodes.length == 0) return nodes;
3120
+ var results = [], n;
3121
+ for (var i = 0, l = nodes.length; i < l; i++)
3122
+ if (!(n = nodes[i])._countedByPrototype) {
3123
+ n._countedByPrototype = Prototype.emptyFunction;
3124
+ results.push(Element.extend(n));
3125
+ }
3126
+ return Selector.handlers.unmark(results);
3127
+ },
3128
+
3129
+ // COMBINATOR FUNCTIONS
3130
+ descendant: function(nodes) {
3131
+ var h = Selector.handlers;
3132
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3133
+ h.concat(results, node.getElementsByTagName('*'));
3134
+ return results;
3135
+ },
3136
+
3137
+ child: function(nodes) {
3138
+ var h = Selector.handlers;
3139
+ for (var i = 0, results = [], node; node = nodes[i]; i++) {
3140
+ for (var j = 0, child; child = node.childNodes[j]; j++)
3141
+ if (child.nodeType == 1 && child.tagName != '!') results.push(child);
3142
+ }
3143
+ return results;
3144
+ },
3145
+
3146
+ adjacent: function(nodes) {
3147
+ for (var i = 0, results = [], node; node = nodes[i]; i++) {
3148
+ var next = this.nextElementSibling(node);
3149
+ if (next) results.push(next);
3150
+ }
3151
+ return results;
3152
+ },
3153
+
3154
+ laterSibling: function(nodes) {
3155
+ var h = Selector.handlers;
3156
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3157
+ h.concat(results, Element.nextSiblings(node));
3158
+ return results;
3159
+ },
3160
+
3161
+ nextElementSibling: function(node) {
3162
+ while (node = node.nextSibling)
3163
+ if (node.nodeType == 1) return node;
3164
+ return null;
3165
+ },
3166
+
3167
+ previousElementSibling: function(node) {
3168
+ while (node = node.previousSibling)
3169
+ if (node.nodeType == 1) return node;
3170
+ return null;
3171
+ },
3172
+
3173
+ // TOKEN FUNCTIONS
3174
+ tagName: function(nodes, root, tagName, combinator) {
3175
+ var uTagName = tagName.toUpperCase();
3176
+ var results = [], h = Selector.handlers;
3177
+ if (nodes) {
3178
+ if (combinator) {
3179
+ // fastlane for ordinary descendant combinators
3180
+ if (combinator == "descendant") {
3181
+ for (var i = 0, node; node = nodes[i]; i++)
3182
+ h.concat(results, node.getElementsByTagName(tagName));
3183
+ return results;
3184
+ } else nodes = this[combinator](nodes);
3185
+ if (tagName == "*") return nodes;
3186
+ }
3187
+ for (var i = 0, node; node = nodes[i]; i++)
3188
+ if (node.tagName.toUpperCase() === uTagName) results.push(node);
3189
+ return results;
3190
+ } else return root.getElementsByTagName(tagName);
3191
+ },
3192
+
3193
+ id: function(nodes, root, id, combinator) {
3194
+ var targetNode = $(id), h = Selector.handlers;
3195
+ if (!targetNode) return [];
3196
+ if (!nodes && root == document) return [targetNode];
3197
+ if (nodes) {
3198
+ if (combinator) {
3199
+ if (combinator == 'child') {
3200
+ for (var i = 0, node; node = nodes[i]; i++)
3201
+ if (targetNode.parentNode == node) return [targetNode];
3202
+ } else if (combinator == 'descendant') {
3203
+ for (var i = 0, node; node = nodes[i]; i++)
3204
+ if (Element.descendantOf(targetNode, node)) return [targetNode];
3205
+ } else if (combinator == 'adjacent') {
3206
+ for (var i = 0, node; node = nodes[i]; i++)
3207
+ if (Selector.handlers.previousElementSibling(targetNode) == node)
3208
+ return [targetNode];
3209
+ } else nodes = h[combinator](nodes);
3210
+ }
3211
+ for (var i = 0, node; node = nodes[i]; i++)
3212
+ if (node == targetNode) return [targetNode];
3213
+ return [];
3214
+ }
3215
+ return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
3216
+ },
3217
+
3218
+ className: function(nodes, root, className, combinator) {
3219
+ if (nodes && combinator) nodes = this[combinator](nodes);
3220
+ return Selector.handlers.byClassName(nodes, root, className);
3221
+ },
3222
+
3223
+ byClassName: function(nodes, root, className) {
3224
+ if (!nodes) nodes = Selector.handlers.descendant([root]);
3225
+ var needle = ' ' + className + ' ';
3226
+ for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3227
+ nodeClassName = node.className;
3228
+ if (nodeClassName.length == 0) continue;
3229
+ if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3230
+ results.push(node);
3231
+ }
3232
+ return results;
3233
+ },
3234
+
3235
+ attrPresence: function(nodes, root, attr, combinator) {
3236
+ if (!nodes) nodes = root.getElementsByTagName("*");
3237
+ if (nodes && combinator) nodes = this[combinator](nodes);
3238
+ var results = [];
3239
+ for (var i = 0, node; node = nodes[i]; i++)
3240
+ if (Element.hasAttribute(node, attr)) results.push(node);
3241
+ return results;
3242
+ },
3243
+
3244
+ attr: function(nodes, root, attr, value, operator, combinator) {
3245
+ if (!nodes) nodes = root.getElementsByTagName("*");
3246
+ if (nodes && combinator) nodes = this[combinator](nodes);
3247
+ var handler = Selector.operators[operator], results = [];
3248
+ for (var i = 0, node; node = nodes[i]; i++) {
3249
+ var nodeValue = Element.readAttribute(node, attr);
3250
+ if (nodeValue === null) continue;
3251
+ if (handler(nodeValue, value)) results.push(node);
3252
+ }
3253
+ return results;
3254
+ },
3255
+
3256
+ pseudo: function(nodes, name, value, root, combinator) {
3257
+ if (nodes && combinator) nodes = this[combinator](nodes);
3258
+ if (!nodes) nodes = root.getElementsByTagName("*");
3259
+ return Selector.pseudos[name](nodes, value, root);
3260
+ }
3261
+ },
3262
+
3263
+ pseudos: {
3264
+ 'first-child': function(nodes, value, root) {
3265
+ for (var i = 0, results = [], node; node = nodes[i]; i++) {
3266
+ if (Selector.handlers.previousElementSibling(node)) continue;
3267
+ results.push(node);
3268
+ }
3269
+ return results;
3270
+ },
3271
+ 'last-child': function(nodes, value, root) {
3272
+ for (var i = 0, results = [], node; node = nodes[i]; i++) {
3273
+ if (Selector.handlers.nextElementSibling(node)) continue;
3274
+ results.push(node);
3275
+ }
3276
+ return results;
3277
+ },
3278
+ 'only-child': function(nodes, value, root) {
3279
+ var h = Selector.handlers;
3280
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3281
+ if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
3282
+ results.push(node);
3283
+ return results;
3284
+ },
3285
+ 'nth-child': function(nodes, formula, root) {
3286
+ return Selector.pseudos.nth(nodes, formula, root);
3287
+ },
3288
+ 'nth-last-child': function(nodes, formula, root) {
3289
+ return Selector.pseudos.nth(nodes, formula, root, true);
3290
+ },
3291
+ 'nth-of-type': function(nodes, formula, root) {
3292
+ return Selector.pseudos.nth(nodes, formula, root, false, true);
3293
+ },
3294
+ 'nth-last-of-type': function(nodes, formula, root) {
3295
+ return Selector.pseudos.nth(nodes, formula, root, true, true);
3296
+ },
3297
+ 'first-of-type': function(nodes, formula, root) {
3298
+ return Selector.pseudos.nth(nodes, "1", root, false, true);
3299
+ },
3300
+ 'last-of-type': function(nodes, formula, root) {
3301
+ return Selector.pseudos.nth(nodes, "1", root, true, true);
3302
+ },
3303
+ 'only-of-type': function(nodes, formula, root) {
3304
+ var p = Selector.pseudos;
3305
+ return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
3306
+ },
3307
+
3308
+ // handles the an+b logic
3309
+ getIndices: function(a, b, total) {
3310
+ if (a == 0) return b > 0 ? [b] : [];
3311
+ return $R(1, total).inject([], function(memo, i) {
3312
+ if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
3313
+ return memo;
3314
+ });
3315
+ },
3316
+
3317
+ // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
3318
+ nth: function(nodes, formula, root, reverse, ofType) {
3319
+ if (nodes.length == 0) return [];
3320
+ if (formula == 'even') formula = '2n+0';
3321
+ if (formula == 'odd') formula = '2n+1';
3322
+ var h = Selector.handlers, results = [], indexed = [], m;
3323
+ h.mark(nodes);
3324
+ for (var i = 0, node; node = nodes[i]; i++) {
3325
+ if (!node.parentNode._countedByPrototype) {
3326
+ h.index(node.parentNode, reverse, ofType);
3327
+ indexed.push(node.parentNode);
3328
+ }
3329
+ }
3330
+ if (formula.match(/^\d+$/)) { // just a number
3331
+ formula = Number(formula);
3332
+ for (var i = 0, node; node = nodes[i]; i++)
3333
+ if (node.nodeIndex == formula) results.push(node);
3334
+ } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
3335
+ if (m[1] == "-") m[1] = -1;
3336
+ var a = m[1] ? Number(m[1]) : 1;
3337
+ var b = m[2] ? Number(m[2]) : 0;
3338
+ var indices = Selector.pseudos.getIndices(a, b, nodes.length);
3339
+ for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
3340
+ for (var j = 0; j < l; j++)
3341
+ if (node.nodeIndex == indices[j]) results.push(node);
3342
+ }
3343
+ }
3344
+ h.unmark(nodes);
3345
+ h.unmark(indexed);
3346
+ return results;
3347
+ },
3348
+
3349
+ 'empty': function(nodes, value, root) {
3350
+ for (var i = 0, results = [], node; node = nodes[i]; i++) {
3351
+ // IE treats comments as element nodes
3352
+ if (node.tagName == '!' || node.firstChild) continue;
3353
+ results.push(node);
3354
+ }
3355
+ return results;
3356
+ },
3357
+
3358
+ 'not': function(nodes, selector, root) {
3359
+ var h = Selector.handlers, selectorType, m;
3360
+ var exclusions = new Selector(selector).findElements(root);
3361
+ h.mark(exclusions);
3362
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3363
+ if (!node._countedByPrototype) results.push(node);
3364
+ h.unmark(exclusions);
3365
+ return results;
3366
+ },
3367
+
3368
+ 'enabled': function(nodes, value, root) {
3369
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3370
+ if (!node.disabled && (!node.type || node.type !== 'hidden'))
3371
+ results.push(node);
3372
+ return results;
3373
+ },
3374
+
3375
+ 'disabled': function(nodes, value, root) {
3376
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3377
+ if (node.disabled) results.push(node);
3378
+ return results;
3379
+ },
3380
+
3381
+ 'checked': function(nodes, value, root) {
3382
+ for (var i = 0, results = [], node; node = nodes[i]; i++)
3383
+ if (node.checked) results.push(node);
3384
+ return results;
3385
+ }
3386
+ },
3387
+
3388
+ operators: {
3389
+ '=': function(nv, v) { return nv == v; },
3390
+ '!=': function(nv, v) { return nv != v; },
3391
+ '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
3392
+ '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
3393
+ '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
3394
+ '$=': function(nv, v) { return nv.endsWith(v); },
3395
+ '*=': function(nv, v) { return nv.include(v); },
3396
+ '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
3397
+ '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
3398
+ '-').include('-' + (v || "").toUpperCase() + '-'); }
3399
+ },
3400
+
3401
+ split: function(expression) {
3402
+ var expressions = [];
3403
+ expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
3404
+ expressions.push(m[1].strip());
3405
+ });
3406
+ return expressions;
3407
+ },
3408
+
3409
+ matchElements: function(elements, expression) {
3410
+ var matches = $$(expression), h = Selector.handlers;
3411
+ h.mark(matches);
3412
+ for (var i = 0, results = [], element; element = elements[i]; i++)
3413
+ if (element._countedByPrototype) results.push(element);
3414
+ h.unmark(matches);
3415
+ return results;
3416
+ },
3417
+
3418
+ findElement: function(elements, expression, index) {
3419
+ if (Object.isNumber(expression)) {
3420
+ index = expression; expression = false;
3421
+ }
3422
+ return Selector.matchElements(elements, expression || '*')[index || 0];
3423
+ },
3424
+
3425
+ findChildElements: function(element, expressions) {
3426
+ expressions = Selector.split(expressions.join(','));
3427
+ var results = [], h = Selector.handlers;
3428
+ for (var i = 0, l = expressions.length, selector; i < l; i++) {
3429
+ selector = new Selector(expressions[i].strip());
3430
+ h.concat(results, selector.findElements(element));
3431
+ }
3432
+ return (l > 1) ? h.unique(results) : results;
3433
+ }
3434
+ });
3435
+
3436
+ if (Prototype.Browser.IE) {
3437
+ Object.extend(Selector.handlers, {
3438
+ // IE returns comment nodes on getElementsByTagName("*").
3439
+ // Filter them out.
3440
+ concat: function(a, b) {
3441
+ for (var i = 0, node; node = b[i]; i++)
3442
+ if (node.tagName !== "!") a.push(node);
3443
+ return a;
3444
+ },
3445
+
3446
+ // IE improperly serializes _countedByPrototype in (inner|outer)HTML.
3447
+ unmark: function(nodes) {
3448
+ for (var i = 0, node; node = nodes[i]; i++)
3449
+ node.removeAttribute('_countedByPrototype');
3450
+ return nodes;
3451
+ }
3452
+ });
3453
+ }
3454
+
3455
+ function $$() {
3456
+ return Selector.findChildElements(document, $A(arguments));
3457
+ }
3458
+ var Form = {
3459
+ reset: function(form) {
3460
+ $(form).reset();
3461
+ return form;
3462
+ },
3463
+
3464
+ serializeElements: function(elements, options) {
3465
+ if (typeof options != 'object') options = { hash: !!options };
3466
+ else if (Object.isUndefined(options.hash)) options.hash = true;
3467
+ var key, value, submitted = false, submit = options.submit;
3468
+
3469
+ var data = elements.inject({ }, function(result, element) {
3470
+ if (!element.disabled && element.name) {
3471
+ key = element.name; value = $(element).getValue();
3472
+ if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
3473
+ submit !== false && (!submit || key == submit) && (submitted = true)))) {
3474
+ if (key in result) {
3475
+ // a key is already present; construct an array of values
3476
+ if (!Object.isArray(result[key])) result[key] = [result[key]];
3477
+ result[key].push(value);
3478
+ }
3479
+ else result[key] = value;
3480
+ }
3481
+ }
3482
+ return result;
3483
+ });
3484
+
3485
+ return options.hash ? data : Object.toQueryString(data);
3486
+ }
3487
+ };
3488
+
3489
+ Form.Methods = {
3490
+ serialize: function(form, options) {
3491
+ return Form.serializeElements(Form.getElements(form), options);
3492
+ },
3493
+
3494
+ getElements: function(form) {
3495
+ return $A($(form).getElementsByTagName('*')).inject([],
3496
+ function(elements, child) {
3497
+ if (Form.Element.Serializers[child.tagName.toLowerCase()])
3498
+ elements.push(Element.extend(child));
3499
+ return elements;
3500
+ }
3501
+ );
3502
+ },
3503
+
3504
+ getInputs: function(form, typeName, name) {
3505
+ form = $(form);
3506
+ var inputs = form.getElementsByTagName('input');
3507
+
3508
+ if (!typeName && !name) return $A(inputs).map(Element.extend);
3509
+
3510
+ for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
3511
+ var input = inputs[i];
3512
+ if ((typeName && input.type != typeName) || (name && input.name != name))
3513
+ continue;
3514
+ matchingInputs.push(Element.extend(input));
3515
+ }
3516
+
3517
+ return matchingInputs;
3518
+ },
3519
+
3520
+ disable: function(form) {
3521
+ form = $(form);
3522
+ Form.getElements(form).invoke('disable');
3523
+ return form;
3524
+ },
3525
+
3526
+ enable: function(form) {
3527
+ form = $(form);
3528
+ Form.getElements(form).invoke('enable');
3529
+ return form;
3530
+ },
3531
+
3532
+ findFirstElement: function(form) {
3533
+ var elements = $(form).getElements().findAll(function(element) {
3534
+ return 'hidden' != element.type && !element.disabled;
3535
+ });
3536
+ var firstByIndex = elements.findAll(function(element) {
3537
+ return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
3538
+ }).sortBy(function(element) { return element.tabIndex }).first();
3539
+
3540
+ return firstByIndex ? firstByIndex : elements.find(function(element) {
3541
+ return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
3542
+ });
3543
+ },
3544
+
3545
+ focusFirstElement: function(form) {
3546
+ form = $(form);
3547
+ form.findFirstElement().activate();
3548
+ return form;
3549
+ },
3550
+
3551
+ request: function(form, options) {
3552
+ form = $(form), options = Object.clone(options || { });
3553
+
3554
+ var params = options.parameters, action = form.readAttribute('action') || '';
3555
+ if (action.blank()) action = window.location.href;
3556
+ options.parameters = form.serialize(true);
3557
+
3558
+ if (params) {
3559
+ if (Object.isString(params)) params = params.toQueryParams();
3560
+ Object.extend(options.parameters, params);
3561
+ }
3562
+
3563
+ if (form.hasAttribute('method') && !options.method)
3564
+ options.method = form.method;
3565
+
3566
+ return new Ajax.Request(action, options);
3567
+ }
3568
+ };
3569
+
3570
+ /*--------------------------------------------------------------------------*/
3571
+
3572
+ Form.Element = {
3573
+ focus: function(element) {
3574
+ $(element).focus();
3575
+ return element;
3576
+ },
3577
+
3578
+ select: function(element) {
3579
+ $(element).select();
3580
+ return element;
3581
+ }
3582
+ };
3583
+
3584
+ Form.Element.Methods = {
3585
+ serialize: function(element) {
3586
+ element = $(element);
3587
+ if (!element.disabled && element.name) {
3588
+ var value = element.getValue();
3589
+ if (value != undefined) {
3590
+ var pair = { };
3591
+ pair[element.name] = value;
3592
+ return Object.toQueryString(pair);
3593
+ }
3594
+ }
3595
+ return '';
3596
+ },
3597
+
3598
+ getValue: function(element) {
3599
+ element = $(element);
3600
+ var method = element.tagName.toLowerCase();
3601
+ return Form.Element.Serializers[method](element);
3602
+ },
3603
+
3604
+ setValue: function(element, value) {
3605
+ element = $(element);
3606
+ var method = element.tagName.toLowerCase();
3607
+ Form.Element.Serializers[method](element, value);
3608
+ return element;
3609
+ },
3610
+
3611
+ clear: function(element) {
3612
+ $(element).value = '';
3613
+ return element;
3614
+ },
3615
+
3616
+ present: function(element) {
3617
+ return $(element).value != '';
3618
+ },
3619
+
3620
+ activate: function(element) {
3621
+ element = $(element);
3622
+ try {
3623
+ element.focus();
3624
+ if (element.select && (element.tagName.toLowerCase() != 'input' ||
3625
+ !['button', 'reset', 'submit'].include(element.type)))
3626
+ element.select();
3627
+ } catch (e) { }
3628
+ return element;
3629
+ },
3630
+
3631
+ disable: function(element) {
3632
+ element = $(element);
3633
+ element.disabled = true;
3634
+ return element;
3635
+ },
3636
+
3637
+ enable: function(element) {
3638
+ element = $(element);
3639
+ element.disabled = false;
3640
+ return element;
3641
+ }
3642
+ };
3643
+
3644
+ /*--------------------------------------------------------------------------*/
3645
+
3646
+ var Field = Form.Element;
3647
+ var $F = Form.Element.Methods.getValue;
3648
+
3649
+ /*--------------------------------------------------------------------------*/
3650
+
3651
+ Form.Element.Serializers = {
3652
+ input: function(element, value) {
3653
+ switch (element.type.toLowerCase()) {
3654
+ case 'checkbox':
3655
+ case 'radio':
3656
+ return Form.Element.Serializers.inputSelector(element, value);
3657
+ default:
3658
+ return Form.Element.Serializers.textarea(element, value);
3659
+ }
3660
+ },
3661
+
3662
+ inputSelector: function(element, value) {
3663
+ if (Object.isUndefined(value)) return element.checked ? element.value : null;
3664
+ else element.checked = !!value;
3665
+ },
3666
+
3667
+ textarea: function(element, value) {
3668
+ if (Object.isUndefined(value)) return element.value;
3669
+ else element.value = value;
3670
+ },
3671
+
3672
+ select: function(element, value) {
3673
+ if (Object.isUndefined(value))
3674
+ return this[element.type == 'select-one' ?
3675
+ 'selectOne' : 'selectMany'](element);
3676
+ else {
3677
+ var opt, currentValue, single = !Object.isArray(value);
3678
+ for (var i = 0, length = element.length; i < length; i++) {
3679
+ opt = element.options[i];
3680
+ currentValue = this.optionValue(opt);
3681
+ if (single) {
3682
+ if (currentValue == value) {
3683
+ opt.selected = true;
3684
+ return;
3685
+ }
3686
+ }
3687
+ else opt.selected = value.include(currentValue);
3688
+ }
3689
+ }
3690
+ },
3691
+
3692
+ selectOne: function(element) {
3693
+ var index = element.selectedIndex;
3694
+ return index >= 0 ? this.optionValue(element.options[index]) : null;
3695
+ },
3696
+
3697
+ selectMany: function(element) {
3698
+ var values, length = element.length;
3699
+ if (!length) return null;
3700
+
3701
+ for (var i = 0, values = []; i < length; i++) {
3702
+ var opt = element.options[i];
3703
+ if (opt.selected) values.push(this.optionValue(opt));
3704
+ }
3705
+ return values;
3706
+ },
3707
+
3708
+ optionValue: function(opt) {
3709
+ // extend element because hasAttribute may not be native
3710
+ return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
3711
+ }
3712
+ };
3713
+
3714
+ /*--------------------------------------------------------------------------*/
3715
+
3716
+ Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3717
+ initialize: function($super, element, frequency, callback) {
3718
+ $super(callback, frequency);
3719
+ this.element = $(element);
3720
+ this.lastValue = this.getValue();
3721
+ },
3722
+
3723
+ execute: function() {
3724
+ var value = this.getValue();
3725
+ if (Object.isString(this.lastValue) && Object.isString(value) ?
3726
+ this.lastValue != value : String(this.lastValue) != String(value)) {
3727
+ this.callback(this.element, value);
3728
+ this.lastValue = value;
3729
+ }
3730
+ }
3731
+ });
3732
+
3733
+ Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3734
+ getValue: function() {
3735
+ return Form.Element.getValue(this.element);
3736
+ }
3737
+ });
3738
+
3739
+ Form.Observer = Class.create(Abstract.TimedObserver, {
3740
+ getValue: function() {
3741
+ return Form.serialize(this.element);
3742
+ }
3743
+ });
3744
+
3745
+ /*--------------------------------------------------------------------------*/
3746
+
3747
+ Abstract.EventObserver = Class.create({
3748
+ initialize: function(element, callback) {
3749
+ this.element = $(element);
3750
+ this.callback = callback;
3751
+
3752
+ this.lastValue = this.getValue();
3753
+ if (this.element.tagName.toLowerCase() == 'form')
3754
+ this.registerFormCallbacks();
3755
+ else
3756
+ this.registerCallback(this.element);
3757
+ },
3758
+
3759
+ onElementEvent: function() {
3760
+ var value = this.getValue();
3761
+ if (this.lastValue != value) {
3762
+ this.callback(this.element, value);
3763
+ this.lastValue = value;
3764
+ }
3765
+ },
3766
+
3767
+ registerFormCallbacks: function() {
3768
+ Form.getElements(this.element).each(this.registerCallback, this);
3769
+ },
3770
+
3771
+ registerCallback: function(element) {
3772
+ if (element.type) {
3773
+ switch (element.type.toLowerCase()) {
3774
+ case 'checkbox':
3775
+ case 'radio':
3776
+ Event.observe(element, 'click', this.onElementEvent.bind(this));
3777
+ break;
3778
+ default:
3779
+ Event.observe(element, 'change', this.onElementEvent.bind(this));
3780
+ break;
3781
+ }
3782
+ }
3783
+ }
3784
+ });
3785
+
3786
+ Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3787
+ getValue: function() {
3788
+ return Form.Element.getValue(this.element);
3789
+ }
3790
+ });
3791
+
3792
+ Form.EventObserver = Class.create(Abstract.EventObserver, {
3793
+ getValue: function() {
3794
+ return Form.serialize(this.element);
3795
+ }
3796
+ });
3797
+ if (!window.Event) var Event = { };
3798
+
3799
+ Object.extend(Event, {
3800
+ KEY_BACKSPACE: 8,
3801
+ KEY_TAB: 9,
3802
+ KEY_RETURN: 13,
3803
+ KEY_ESC: 27,
3804
+ KEY_LEFT: 37,
3805
+ KEY_UP: 38,
3806
+ KEY_RIGHT: 39,
3807
+ KEY_DOWN: 40,
3808
+ KEY_DELETE: 46,
3809
+ KEY_HOME: 36,
3810
+ KEY_END: 35,
3811
+ KEY_PAGEUP: 33,
3812
+ KEY_PAGEDOWN: 34,
3813
+ KEY_INSERT: 45,
3814
+
3815
+ cache: { },
3816
+
3817
+ relatedTarget: function(event) {
3818
+ var element;
3819
+ switch(event.type) {
3820
+ case 'mouseover': element = event.fromElement; break;
3821
+ case 'mouseout': element = event.toElement; break;
3822
+ default: return null;
3823
+ }
3824
+ return Element.extend(element);
3825
+ }
3826
+ });
3827
+
3828
+ Event.Methods = (function() {
3829
+ var isButton;
3830
+
3831
+ if (Prototype.Browser.IE) {
3832
+ var buttonMap = { 0: 1, 1: 4, 2: 2 };
3833
+ isButton = function(event, code) {
3834
+ return event.button == buttonMap[code];
3835
+ };
3836
+
3837
+ } else if (Prototype.Browser.WebKit) {
3838
+ isButton = function(event, code) {
3839
+ switch (code) {
3840
+ case 0: return event.which == 1 && !event.metaKey;
3841
+ case 1: return event.which == 1 && event.metaKey;
3842
+ default: return false;
3843
+ }
3844
+ };
3845
+
3846
+ } else {
3847
+ isButton = function(event, code) {
3848
+ return event.which ? (event.which === code + 1) : (event.button === code);
3849
+ };
3850
+ }
3851
+
3852
+ return {
3853
+ isLeftClick: function(event) { return isButton(event, 0) },
3854
+ isMiddleClick: function(event) { return isButton(event, 1) },
3855
+ isRightClick: function(event) { return isButton(event, 2) },
3856
+
3857
+ element: function(event) {
3858
+ event = Event.extend(event);
3859
+
3860
+ var node = event.target,
3861
+ type = event.type,
3862
+ currentTarget = event.currentTarget;
3863
+
3864
+ if (currentTarget && currentTarget.tagName) {
3865
+ // Firefox screws up the "click" event when moving between radio buttons
3866
+ // via arrow keys. It also screws up the "load" and "error" events on images,
3867
+ // reporting the document as the target instead of the original image.
3868
+ if (type === 'load' || type === 'error' ||
3869
+ (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
3870
+ && currentTarget.type === 'radio'))
3871
+ node = currentTarget;
3872
+ }
3873
+ if (node.nodeType == Node.TEXT_NODE) node = node.parentNode;
3874
+ return Element.extend(node);
3875
+ },
3876
+
3877
+ findElement: function(event, expression) {
3878
+ var element = Event.element(event);
3879
+ if (!expression) return element;
3880
+ var elements = [element].concat(element.ancestors());
3881
+ return Selector.findElement(elements, expression, 0);
3882
+ },
3883
+
3884
+ pointer: function(event) {
3885
+ var docElement = document.documentElement,
3886
+ body = document.body || { scrollLeft: 0, scrollTop: 0 };
3887
+ return {
3888
+ x: event.pageX || (event.clientX +
3889
+ (docElement.scrollLeft || body.scrollLeft) -
3890
+ (docElement.clientLeft || 0)),
3891
+ y: event.pageY || (event.clientY +
3892
+ (docElement.scrollTop || body.scrollTop) -
3893
+ (docElement.clientTop || 0))
3894
+ };
3895
+ },
3896
+
3897
+ pointerX: function(event) { return Event.pointer(event).x },
3898
+ pointerY: function(event) { return Event.pointer(event).y },
3899
+
3900
+ stop: function(event) {
3901
+ Event.extend(event);
3902
+ event.preventDefault();
3903
+ event.stopPropagation();
3904
+ event.stopped = true;
3905
+ }
3906
+ };
3907
+ })();
3908
+
3909
+ Event.extend = (function() {
3910
+ var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
3911
+ m[name] = Event.Methods[name].methodize();
3912
+ return m;
3913
+ });
3914
+
3915
+ if (Prototype.Browser.IE) {
3916
+ Object.extend(methods, {
3917
+ stopPropagation: function() { this.cancelBubble = true },
3918
+ preventDefault: function() { this.returnValue = false },
3919
+ inspect: function() { return "[object Event]" }
3920
+ });
3921
+
3922
+ return function(event) {
3923
+ if (!event) return false;
3924
+ if (event._extendedByPrototype) return event;
3925
+
3926
+ event._extendedByPrototype = Prototype.emptyFunction;
3927
+ var pointer = Event.pointer(event);
3928
+ Object.extend(event, {
3929
+ target: event.srcElement,
3930
+ relatedTarget: Event.relatedTarget(event),
3931
+ pageX: pointer.x,
3932
+ pageY: pointer.y
3933
+ });
3934
+ return Object.extend(event, methods);
3935
+ };
3936
+
3937
+ } else {
3938
+ Event.prototype = Event.prototype || document.createEvent("HTMLEvents")['__proto__'];
3939
+ Object.extend(Event.prototype, methods);
3940
+ return Prototype.K;
3941
+ }
3942
+ })();
3943
+
3944
+ Object.extend(Event, (function() {
3945
+ var cache = Event.cache;
3946
+
3947
+ function getEventID(element) {
3948
+ if (element._prototypeEventID) return element._prototypeEventID[0];
3949
+ arguments.callee.id = arguments.callee.id || 1;
3950
+ return element._prototypeEventID = [++arguments.callee.id];
3951
+ }
3952
+
3953
+ function getDOMEventName(eventName) {
3954
+ if (eventName && eventName.include(':')) return "dataavailable";
3955
+ return eventName;
3956
+ }
3957
+
3958
+ function getCacheForID(id) {
3959
+ return cache[id] = cache[id] || { };
3960
+ }
3961
+
3962
+ function getWrappersForEventName(id, eventName) {
3963
+ var c = getCacheForID(id);
3964
+ return c[eventName] = c[eventName] || [];
3965
+ }
3966
+
3967
+ function createWrapper(element, eventName, handler) {
3968
+ var id = getEventID(element);
3969
+ var c = getWrappersForEventName(id, eventName);
3970
+ if (c.pluck("handler").include(handler)) return false;
3971
+
3972
+ var wrapper = function(event) {
3973
+ if (!Event || !Event.extend ||
3974
+ (event.eventName && event.eventName != eventName))
3975
+ return false;
3976
+
3977
+ Event.extend(event);
3978
+ handler.call(element, event);
3979
+ };
3980
+
3981
+ wrapper.handler = handler;
3982
+ c.push(wrapper);
3983
+ return wrapper;
3984
+ }
3985
+
3986
+ function findWrapper(id, eventName, handler) {
3987
+ var c = getWrappersForEventName(id, eventName);
3988
+ return c.find(function(wrapper) { return wrapper.handler == handler });
3989
+ }
3990
+
3991
+ function destroyWrapper(id, eventName, handler) {
3992
+ var c = getCacheForID(id);
3993
+ if (!c[eventName]) return false;
3994
+ c[eventName] = c[eventName].without(findWrapper(id, eventName, handler));
3995
+ }
3996
+
3997
+ function destroyCache() {
3998
+ for (var id in cache)
3999
+ for (var eventName in cache[id])
4000
+ cache[id][eventName] = null;
4001
+ }
4002
+
4003
+
4004
+ // Internet Explorer needs to remove event handlers on page unload
4005
+ // in order to avoid memory leaks.
4006
+ if (window.attachEvent) {
4007
+ window.attachEvent("onunload", destroyCache);
4008
+ }
4009
+
4010
+ // Safari has a dummy event handler on page unload so that it won't
4011
+ // use its bfcache. Safari <= 3.1 has an issue with restoring the "document"
4012
+ // object when page is returned to via the back button using its bfcache.
4013
+ if (Prototype.Browser.WebKit) {
4014
+ window.addEventListener('unload', Prototype.emptyFunction, false);
4015
+ }
4016
+
4017
+ return {
4018
+ observe: function(element, eventName, handler) {
4019
+ element = $(element);
4020
+ var name = getDOMEventName(eventName);
4021
+
4022
+ var wrapper = createWrapper(element, eventName, handler);
4023
+ if (!wrapper) return element;
4024
+
4025
+ if (element.addEventListener) {
4026
+ element.addEventListener(name, wrapper, false);
4027
+ } else {
4028
+ element.attachEvent("on" + name, wrapper);
4029
+ }
4030
+
4031
+ return element;
4032
+ },
4033
+
4034
+ stopObserving: function(element, eventName, handler) {
4035
+ element = $(element);
4036
+ var id = getEventID(element), name = getDOMEventName(eventName);
4037
+
4038
+ if (!handler && eventName) {
4039
+ getWrappersForEventName(id, eventName).each(function(wrapper) {
4040
+ element.stopObserving(eventName, wrapper.handler);
4041
+ });
4042
+ return element;
4043
+
4044
+ } else if (!eventName) {
4045
+ Object.keys(getCacheForID(id)).each(function(eventName) {
4046
+ element.stopObserving(eventName);
4047
+ });
4048
+ return element;
4049
+ }
4050
+
4051
+ var wrapper = findWrapper(id, eventName, handler);
4052
+ if (!wrapper) return element;
4053
+
4054
+ if (element.removeEventListener) {
4055
+ element.removeEventListener(name, wrapper, false);
4056
+ } else {
4057
+ element.detachEvent("on" + name, wrapper);
4058
+ }
4059
+
4060
+ destroyWrapper(id, eventName, handler);
4061
+
4062
+ return element;
4063
+ },
4064
+
4065
+ fire: function(element, eventName, memo) {
4066
+ element = $(element);
4067
+ if (element == document && document.createEvent && !element.dispatchEvent)
4068
+ element = document.documentElement;
4069
+
4070
+ var event;
4071
+ if (document.createEvent) {
4072
+ event = document.createEvent("HTMLEvents");
4073
+ event.initEvent("dataavailable", true, true);
4074
+ } else {
4075
+ event = document.createEventObject();
4076
+ event.eventType = "ondataavailable";
4077
+ }
4078
+
4079
+ event.eventName = eventName;
4080
+ event.memo = memo || { };
4081
+
4082
+ if (document.createEvent) {
4083
+ element.dispatchEvent(event);
4084
+ } else {
4085
+ element.fireEvent(event.eventType, event);
4086
+ }
4087
+
4088
+ return Event.extend(event);
4089
+ }
4090
+ };
4091
+ })());
4092
+
4093
+ Object.extend(Event, Event.Methods);
4094
+
4095
+ Element.addMethods({
4096
+ fire: Event.fire,
4097
+ observe: Event.observe,
4098
+ stopObserving: Event.stopObserving
4099
+ });
4100
+
4101
+ Object.extend(document, {
4102
+ fire: Element.Methods.fire.methodize(),
4103
+ observe: Element.Methods.observe.methodize(),
4104
+ stopObserving: Element.Methods.stopObserving.methodize(),
4105
+ loaded: false
4106
+ });
4107
+
4108
+ (function() {
4109
+ /* Support for the DOMContentLoaded event is based on work by Dan Webb,
4110
+ Matthias Miller, Dean Edwards and John Resig. */
4111
+
4112
+ var timer;
4113
+
4114
+ function fireContentLoadedEvent() {
4115
+ if (document.loaded) return;
4116
+ if (timer) window.clearInterval(timer);
4117
+ document.fire("dom:loaded");
4118
+ document.loaded = true;
4119
+ }
4120
+
4121
+ if (document.addEventListener) {
4122
+ if (Prototype.Browser.WebKit) {
4123
+ timer = window.setInterval(function() {
4124
+ if (/loaded|complete/.test(document.readyState))
4125
+ fireContentLoadedEvent();
4126
+ }, 0);
4127
+
4128
+ Event.observe(window, "load", fireContentLoadedEvent);
4129
+
4130
+ } else {
4131
+ document.addEventListener("DOMContentLoaded",
4132
+ fireContentLoadedEvent, false);
4133
+ }
4134
+
4135
+ } else {
4136
+ document.write("<script id=__onDOMContentLoaded defer src=//:><\/script>");
4137
+ $("__onDOMContentLoaded").onreadystatechange = function() {
4138
+ if (this.readyState == "complete") {
4139
+ this.onreadystatechange = null;
4140
+ fireContentLoadedEvent();
4141
+ }
4142
+ };
4143
+ }
4144
+ })();
4145
+ /*------------------------------- DEPRECATED -------------------------------*/
4146
+
4147
+ Hash.toQueryString = Object.toQueryString;
4148
+
4149
+ var Toggle = { display: Element.toggle };
4150
+
4151
+ Element.Methods.childOf = Element.Methods.descendantOf;
4152
+
4153
+ var Insertion = {
4154
+ Before: function(element, content) {
4155
+ return Element.insert(element, {before:content});
4156
+ },
4157
+
4158
+ Top: function(element, content) {
4159
+ return Element.insert(element, {top:content});
4160
+ },
4161
+
4162
+ Bottom: function(element, content) {
4163
+ return Element.insert(element, {bottom:content});
4164
+ },
4165
+
4166
+ After: function(element, content) {
4167
+ return Element.insert(element, {after:content});
4168
+ }
4169
+ };
4170
+
4171
+ var $continue = new Error('"throw $continue" is deprecated, use "return" instead');
4172
+
4173
+ // This should be moved to script.aculo.us; notice the deprecated methods
4174
+ // further below, that map to the newer Element methods.
4175
+ var Position = {
4176
+ // set to true if needed, warning: firefox performance problems
4177
+ // NOT neeeded for page scrolling, only if draggable contained in
4178
+ // scrollable elements
4179
+ includeScrollOffsets: false,
4180
+
4181
+ // must be called before calling withinIncludingScrolloffset, every time the
4182
+ // page is scrolled
4183
+ prepare: function() {
4184
+ this.deltaX = window.pageXOffset
4185
+ || document.documentElement.scrollLeft
4186
+ || document.body.scrollLeft
4187
+ || 0;
4188
+ this.deltaY = window.pageYOffset
4189
+ || document.documentElement.scrollTop
4190
+ || document.body.scrollTop
4191
+ || 0;
4192
+ },
4193
+
4194
+ // caches x/y coordinate pair to use with overlap
4195
+ within: function(element, x, y) {
4196
+ if (this.includeScrollOffsets)
4197
+ return this.withinIncludingScrolloffsets(element, x, y);
4198
+ this.xcomp = x;
4199
+ this.ycomp = y;
4200
+ this.offset = Element.cumulativeOffset(element);
4201
+
4202
+ return (y >= this.offset[1] &&
4203
+ y < this.offset[1] + element.offsetHeight &&
4204
+ x >= this.offset[0] &&
4205
+ x < this.offset[0] + element.offsetWidth);
4206
+ },
4207
+
4208
+ withinIncludingScrolloffsets: function(element, x, y) {
4209
+ var offsetcache = Element.cumulativeScrollOffset(element);
4210
+
4211
+ this.xcomp = x + offsetcache[0] - this.deltaX;
4212
+ this.ycomp = y + offsetcache[1] - this.deltaY;
4213
+ this.offset = Element.cumulativeOffset(element);
4214
+
4215
+ return (this.ycomp >= this.offset[1] &&
4216
+ this.ycomp < this.offset[1] + element.offsetHeight &&
4217
+ this.xcomp >= this.offset[0] &&
4218
+ this.xcomp < this.offset[0] + element.offsetWidth);
4219
+ },
4220
+
4221
+ // within must be called directly before
4222
+ overlap: function(mode, element) {
4223
+ if (!mode) return 0;
4224
+ if (mode == 'vertical')
4225
+ return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
4226
+ element.offsetHeight;
4227
+ if (mode == 'horizontal')
4228
+ return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
4229
+ element.offsetWidth;
4230
+ },
4231
+
4232
+ // Deprecation layer -- use newer Element methods now (1.5.2).
4233
+
4234
+ cumulativeOffset: Element.Methods.cumulativeOffset,
4235
+
4236
+ positionedOffset: Element.Methods.positionedOffset,
4237
+
4238
+ absolutize: function(element) {
4239
+ Position.prepare();
4240
+ return Element.absolutize(element);
4241
+ },
4242
+
4243
+ relativize: function(element) {
4244
+ Position.prepare();
4245
+ return Element.relativize(element);
4246
+ },
4247
+
4248
+ realOffset: Element.Methods.cumulativeScrollOffset,
4249
+
4250
+ offsetParent: Element.Methods.getOffsetParent,
4251
+
4252
+ page: Element.Methods.viewportOffset,
4253
+
4254
+ clone: function(source, target, options) {
4255
+ options = options || { };
4256
+ return Element.clonePosition(target, source, options);
4257
+ }
4258
+ };
4259
+
4260
+ /*--------------------------------------------------------------------------*/
4261
+
4262
+ if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4263
+ function iter(name) {
4264
+ return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4265
+ }
4266
+
4267
+ instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
4268
+ function(element, className) {
4269
+ className = className.toString().strip();
4270
+ var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4271
+ return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
4272
+ } : function(element, className) {
4273
+ className = className.toString().strip();
4274
+ var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4275
+ if (!classNames && !className) return elements;
4276
+
4277
+ var nodes = $(element).getElementsByTagName('*');
4278
+ className = ' ' + className + ' ';
4279
+
4280
+ for (var i = 0, child, cn; child = nodes[i]; i++) {
4281
+ if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4282
+ (classNames && classNames.all(function(name) {
4283
+ return !name.toString().blank() && cn.include(' ' + name + ' ');
4284
+ }))))
4285
+ elements.push(Element.extend(child));
4286
+ }
4287
+ return elements;
4288
+ };
4289
+
4290
+ return function(className, parentElement) {
4291
+ return $(parentElement || document.body).getElementsByClassName(className);
4292
+ };
4293
+ }(Element.Methods);
4294
+
4295
+ /*--------------------------------------------------------------------------*/
4296
+
4297
+ Element.ClassNames = Class.create();
4298
+ Element.ClassNames.prototype = {
4299
+ initialize: function(element) {
4300
+ this.element = $(element);
4301
+ },
4302
+
4303
+ _each: function(iterator) {
4304
+ this.element.className.split(/\s+/).select(function(name) {
4305
+ return name.length > 0;
4306
+ })._each(iterator);
4307
+ },
4308
+
4309
+ set: function(className) {
4310
+ this.element.className = className;
4311
+ },
4312
+
4313
+ add: function(classNameToAdd) {
4314
+ if (this.include(classNameToAdd)) return;
4315
+ this.set($A(this).concat(classNameToAdd).join(' '));
4316
+ },
4317
+
4318
+ remove: function(classNameToRemove) {
4319
+ if (!this.include(classNameToRemove)) return;
4320
+ this.set($A(this).without(classNameToRemove).join(' '));
4321
+ },
4322
+
4323
+ toString: function() {
4324
+ return $A(this).join(' ');
4325
+ }
4326
+ };
4327
+
4328
+ Object.extend(Element.ClassNames.prototype, Enumerable);
4329
+
4330
+ /*--------------------------------------------------------------------------*/
4331
+
4332
+ Element.addMethods();
4333
+ var search_index = [
4334
+ { method: 'broken', module: 'try', html: '<a href="classes/Try.html#M000001"><span class="method_name">broken</span> <span class="module_name">(Try)</span></a>' },
4335
+ ]
4336
+ $(document).observe('dom:loaded', function() {
4337
+ // Setup search-during-typing.
4338
+ new Form.Element.Observer('search', 0.3, function(element, value) {
4339
+ performSearch();
4340
+ });
4341
+
4342
+ // Remove the default search box value when the user puts the focus on
4343
+ // the search box for the first time.
4344
+ var search_box = $('search');
4345
+ if ($F('search') == 'Enter search terms...') {
4346
+ search_box.observe('focus', function() {
4347
+ if (search_box.hasClassName('untouched')) {
4348
+ search_box.removeClassName('untouched');
4349
+ search_box.value = '';
4350
+ }
4351
+ });
4352
+ } else {
4353
+ search_box.removeClassName('untouched');
4354
+ }
4355
+ });
4356
+
4357
+ function searchInIndex(query) {
4358
+ var i;
4359
+ var results = [];
4360
+ query = query.toLowerCase();
4361
+ for (i = 0; i < search_index.length; i++) {
4362
+ if (search_index[i].method.indexOf(query) != -1) {
4363
+ results.push(search_index[i]);
4364
+ }
4365
+ }
4366
+ return results;
4367
+ }
4368
+
4369
+ function buildHtmlForResults(results) {
4370
+ var html = "";
4371
+ var i;
4372
+ for (i = 0; i < results.length; i++) {
4373
+ html += '<li>' + results[i].html + '</li>';
4374
+ }
4375
+ return html;
4376
+ }
4377
+
4378
+ function performSearch() {
4379
+ var query = $F('search');
4380
+ if (query == '') {
4381
+ $('index-entries').show();
4382
+ $('search-results').hide();
4383
+ } else {
4384
+ var results = searchInIndex(query);
4385
+ $('search-results').update(buildHtmlForResults(results));
4386
+ $('index-entries').hide();
4387
+ $('search-results').show();
4388
+ }
4389
+ return false;
4390
+ }
4391
+ </script>
4392
+ <form onsubmit='return performSearch()'>
4393
+ <input class='untouched' id='search' type='text' value='Enter search terms...'>
4394
+ </form>
4395
+ <ol class='methods' id='search-results' style='display: none'></ol>
4396
+ <ol class='methods' id='index-entries'>
4397
+ <li><a href="classes/Try.html#M000001"><span class="method_name">broken</span> <span class="module_name">(Try)</span></a></li>
4398
+ </ol>
4399
+ </div>
4400
+ </body>
4401
+ </html>