Commit f5a954c0573b925cc0e7961b8d38f7fa329386c7

Authored by Braulio Bhavamitra
1 parent d43bc1c4

Remove scriptalous/prototype javascripts

public/javascripts/controls.js
... ... @@ -1,963 +0,0 @@
1   -// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
2   -// (c) 2005-2007 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
3   -// (c) 2005-2007 Jon Tirsen (http://www.tirsen.com)
4   -// Contributors:
5   -// Richard Livsey
6   -// Rahul Bhargava
7   -// Rob Wills
8   -//
9   -// script.aculo.us is freely distributable under the terms of an MIT-style license.
10   -// For details, see the script.aculo.us web site: http://script.aculo.us/
11   -
12   -// Autocompleter.Base handles all the autocompletion functionality
13   -// that's independent of the data source for autocompletion. This
14   -// includes drawing the autocompletion menu, observing keyboard
15   -// and mouse events, and similar.
16   -//
17   -// Specific autocompleters need to provide, at the very least,
18   -// a getUpdatedChoices function that will be invoked every time
19   -// the text inside the monitored textbox changes. This method
20   -// should get the text for which to provide autocompletion by
21   -// invoking this.getToken(), NOT by directly accessing
22   -// this.element.value. This is to allow incremental tokenized
23   -// autocompletion. Specific auto-completion logic (AJAX, etc)
24   -// belongs in getUpdatedChoices.
25   -//
26   -// Tokenized incremental autocompletion is enabled automatically
27   -// when an autocompleter is instantiated with the 'tokens' option
28   -// in the options parameter, e.g.:
29   -// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
30   -// will incrementally autocomplete with a comma as the token.
31   -// Additionally, ',' in the above example can be replaced with
32   -// a token array, e.g. { tokens: [',', '\n'] } which
33   -// enables autocompletion on multiple tokens. This is most
34   -// useful when one of the tokens is \n (a newline), as it
35   -// allows smart autocompletion after linebreaks.
36   -
37   -if(typeof Effect == 'undefined')
38   - throw("controls.js requires including script.aculo.us' effects.js library");
39   -
40   -var Autocompleter = { }
41   -Autocompleter.Base = Class.create({
42   - baseInitialize: function(element, update, options) {
43   - element = $(element)
44   - this.element = element;
45   - this.update = $(update);
46   - this.hasFocus = false;
47   - this.changed = false;
48   - this.active = false;
49   - this.index = 0;
50   - this.entryCount = 0;
51   - this.oldElementValue = this.element.value;
52   -
53   - if(this.setOptions)
54   - this.setOptions(options);
55   - else
56   - this.options = options || { };
57   -
58   - this.options.paramName = this.options.paramName || this.element.name;
59   - this.options.tokens = this.options.tokens || [];
60   - this.options.frequency = this.options.frequency || 0.4;
61   - this.options.minChars = this.options.minChars || 1;
62   - this.options.onShow = this.options.onShow ||
63   - function(element, update){
64   - if(!update.style.position || update.style.position=='absolute') {
65   - update.style.position = 'absolute';
66   - Position.clone(element, update, {
67   - setHeight: false,
68   - offsetTop: element.offsetHeight
69   - });
70   - }
71   - Effect.Appear(update,{duration:0.15});
72   - };
73   - this.options.onHide = this.options.onHide ||
74   - function(element, update){ new Effect.Fade(update,{duration:0.15}) };
75   -
76   - if(typeof(this.options.tokens) == 'string')
77   - this.options.tokens = new Array(this.options.tokens);
78   - // Force carriage returns as token delimiters anyway
79   - if (!this.options.tokens.include('\n'))
80   - this.options.tokens.push('\n');
81   -
82   - this.observer = null;
83   -
84   - this.element.setAttribute('autocomplete','off');
85   -
86   - Element.hide(this.update);
87   -
88   - Event.observe(this.element, 'blur', this.onBlur.bindAsEventListener(this));
89   - Event.observe(this.element, 'keydown', this.onKeyPress.bindAsEventListener(this));
90   - },
91   -
92   - show: function() {
93   - if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
94   - if(!this.iefix &&
95   - (Prototype.Browser.IE) &&
96   - (Element.getStyle(this.update, 'position')=='absolute')) {
97   - new Insertion.After(this.update,
98   - '<iframe id="' + this.update.id + '_iefix" '+
99   - 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
100   - 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
101   - this.iefix = $(this.update.id+'_iefix');
102   - }
103   - if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
104   - },
105   -
106   - fixIEOverlapping: function() {
107   - Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
108   - this.iefix.style.zIndex = 1;
109   - this.update.style.zIndex = 2;
110   - Element.show(this.iefix);
111   - },
112   -
113   - hide: function() {
114   - this.stopIndicator();
115   - if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
116   - if(this.iefix) Element.hide(this.iefix);
117   - },
118   -
119   - startIndicator: function() {
120   - if(this.options.indicator) Element.show(this.options.indicator);
121   - },
122   -
123   - stopIndicator: function() {
124   - if(this.options.indicator) Element.hide(this.options.indicator);
125   - },
126   -
127   - onKeyPress: function(event) {
128   - if(this.active)
129   - switch(event.keyCode) {
130   - case Event.KEY_TAB:
131   - case Event.KEY_RETURN:
132   - this.selectEntry();
133   - Event.stop(event);
134   - case Event.KEY_ESC:
135   - this.hide();
136   - this.active = false;
137   - Event.stop(event);
138   - return;
139   - case Event.KEY_LEFT:
140   - case Event.KEY_RIGHT:
141   - return;
142   - case Event.KEY_UP:
143   - this.markPrevious();
144   - this.render();
145   - Event.stop(event);
146   - return;
147   - case Event.KEY_DOWN:
148   - this.markNext();
149   - this.render();
150   - Event.stop(event);
151   - return;
152   - }
153   - else
154   - if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN ||
155   - (Prototype.Browser.WebKit > 0 && event.keyCode == 0)) return;
156   -
157   - this.changed = true;
158   - this.hasFocus = true;
159   -
160   - if(this.observer) clearTimeout(this.observer);
161   - this.observer =
162   - setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
163   - },
164   -
165   - activate: function() {
166   - this.changed = false;
167   - this.hasFocus = true;
168   - this.getUpdatedChoices();
169   - },
170   -
171   - onHover: function(event) {
172   - var element = Event.findElement(event, 'LI');
173   - if(this.index != element.autocompleteIndex)
174   - {
175   - this.index = element.autocompleteIndex;
176   - this.render();
177   - }
178   - Event.stop(event);
179   - },
180   -
181   - onClick: function(event) {
182   - var element = Event.findElement(event, 'LI');
183   - this.index = element.autocompleteIndex;
184   - this.selectEntry();
185   - this.hide();
186   - },
187   -
188   - onBlur: function(event) {
189   - // needed to make click events working
190   - setTimeout(this.hide.bind(this), 250);
191   - this.hasFocus = false;
192   - this.active = false;
193   - },
194   -
195   - render: function() {
196   - if(this.entryCount > 0) {
197   - for (var i = 0; i < this.entryCount; i++)
198   - this.index==i ?
199   - Element.addClassName(this.getEntry(i),"selected") :
200   - Element.removeClassName(this.getEntry(i),"selected");
201   - if(this.hasFocus) {
202   - this.show();
203   - this.active = true;
204   - }
205   - } else {
206   - this.active = false;
207   - this.hide();
208   - }
209   - },
210   -
211   - markPrevious: function() {
212   - if(this.index > 0) this.index--
213   - else this.index = this.entryCount-1;
214   - this.getEntry(this.index).scrollIntoView(true);
215   - },
216   -
217   - markNext: function() {
218   - if(this.index < this.entryCount-1) this.index++
219   - else this.index = 0;
220   - this.getEntry(this.index).scrollIntoView(false);
221   - },
222   -
223   - getEntry: function(index) {
224   - return this.update.firstChild.childNodes[index];
225   - },
226   -
227   - getCurrentEntry: function() {
228   - return this.getEntry(this.index);
229   - },
230   -
231   - selectEntry: function() {
232   - this.active = false;
233   - this.updateElement(this.getCurrentEntry());
234   - },
235   -
236   - updateElement: function(selectedElement) {
237   - if (this.options.updateElement) {
238   - this.options.updateElement(selectedElement);
239   - return;
240   - }
241   - var value = '';
242   - if (this.options.select) {
243   - var nodes = $(selectedElement).select('.' + this.options.select) || [];
244   - if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
245   - } else
246   - value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
247   -
248   - var bounds = this.getTokenBounds();
249   - if (bounds[0] != -1) {
250   - var newValue = this.element.value.substr(0, bounds[0]);
251   - var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);
252   - if (whitespace)
253   - newValue += whitespace[0];
254   - this.element.value = newValue + value + this.element.value.substr(bounds[1]);
255   - } else {
256   - this.element.value = value;
257   - }
258   - this.oldElementValue = this.element.value;
259   - this.element.focus();
260   -
261   - if (this.options.afterUpdateElement)
262   - this.options.afterUpdateElement(this.element, selectedElement);
263   - },
264   -
265   - updateChoices: function(choices) {
266   - if(!this.changed && this.hasFocus) {
267   - this.update.innerHTML = choices;
268   - Element.cleanWhitespace(this.update);
269   - Element.cleanWhitespace(this.update.down());
270   -
271   - if(this.update.firstChild && this.update.down().childNodes) {
272   - this.entryCount =
273   - this.update.down().childNodes.length;
274   - for (var i = 0; i < this.entryCount; i++) {
275   - var entry = this.getEntry(i);
276   - entry.autocompleteIndex = i;
277   - this.addObservers(entry);
278   - }
279   - } else {
280   - this.entryCount = 0;
281   - }
282   -
283   - this.stopIndicator();
284   - this.index = 0;
285   -
286   - if(this.entryCount==1 && this.options.autoSelect) {
287   - this.selectEntry();
288   - this.hide();
289   - } else {
290   - this.render();
291   - }
292   - }
293   - },
294   -
295   - addObservers: function(element) {
296   - Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
297   - Event.observe(element, "click", this.onClick.bindAsEventListener(this));
298   - },
299   -
300   - onObserverEvent: function() {
301   - this.changed = false;
302   - this.tokenBounds = null;
303   - if(this.getToken().length>=this.options.minChars) {
304   - this.getUpdatedChoices();
305   - } else {
306   - this.active = false;
307   - this.hide();
308   - }
309   - this.oldElementValue = this.element.value;
310   - },
311   -
312   - getToken: function() {
313   - var bounds = this.getTokenBounds();
314   - return this.element.value.substring(bounds[0], bounds[1]).strip();
315   - },
316   -
317   - getTokenBounds: function() {
318   - if (null != this.tokenBounds) return this.tokenBounds;
319   - var value = this.element.value;
320   - if (value.strip().empty()) return [-1, 0];
321   - var diff = arguments.callee.getFirstDifferencePos(value, this.oldElementValue);
322   - var offset = (diff == this.oldElementValue.length ? 1 : 0);
323   - var prevTokenPos = -1, nextTokenPos = value.length;
324   - var tp;
325   - for (var index = 0, l = this.options.tokens.length; index < l; ++index) {
326   - tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);
327   - if (tp > prevTokenPos) prevTokenPos = tp;
328   - tp = value.indexOf(this.options.tokens[index], diff + offset);
329   - if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;
330   - }
331   - return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);
332   - }
333   -});
334   -
335   -Autocompleter.Base.prototype.getTokenBounds.getFirstDifferencePos = function(newS, oldS) {
336   - var boundary = Math.min(newS.length, oldS.length);
337   - for (var index = 0; index < boundary; ++index)
338   - if (newS[index] != oldS[index])
339   - return index;
340   - return boundary;
341   -};
342   -
343   -Ajax.Autocompleter = Class.create(Autocompleter.Base, {
344   - initialize: function(element, update, url, options) {
345   - this.baseInitialize(element, update, options);
346   - this.options.asynchronous = true;
347   - this.options.onComplete = this.onComplete.bind(this);
348   - this.options.defaultParams = this.options.parameters || null;
349   - this.url = url;
350   - },
351   -
352   - getUpdatedChoices: function() {
353   - this.startIndicator();
354   -
355   - var entry = encodeURIComponent(this.options.paramName) + '=' +
356   - encodeURIComponent(this.getToken());
357   -
358   - this.options.parameters = this.options.callback ?
359   - this.options.callback(this.element, entry) : entry;
360   -
361   - if(this.options.defaultParams)
362   - this.options.parameters += '&' + this.options.defaultParams;
363   -
364   - new Ajax.Request(this.url, this.options);
365   - },
366   -
367   - onComplete: function(request) {
368   - this.updateChoices(request.responseText);
369   - }
370   -});
371   -
372   -// The local array autocompleter. Used when you'd prefer to
373   -// inject an array of autocompletion options into the page, rather
374   -// than sending out Ajax queries, which can be quite slow sometimes.
375   -//
376   -// The constructor takes four parameters. The first two are, as usual,
377   -// the id of the monitored textbox, and id of the autocompletion menu.
378   -// The third is the array you want to autocomplete from, and the fourth
379   -// is the options block.
380   -//
381   -// Extra local autocompletion options:
382   -// - choices - How many autocompletion choices to offer
383   -//
384   -// - partialSearch - If false, the autocompleter will match entered
385   -// text only at the beginning of strings in the
386   -// autocomplete array. Defaults to true, which will
387   -// match text at the beginning of any *word* in the
388   -// strings in the autocomplete array. If you want to
389   -// search anywhere in the string, additionally set
390   -// the option fullSearch to true (default: off).
391   -//
392   -// - fullSsearch - Search anywhere in autocomplete array strings.
393   -//
394   -// - partialChars - How many characters to enter before triggering
395   -// a partial match (unlike minChars, which defines
396   -// how many characters are required to do any match
397   -// at all). Defaults to 2.
398   -//
399   -// - ignoreCase - Whether to ignore case when autocompleting.
400   -// Defaults to true.
401   -//
402   -// It's possible to pass in a custom function as the 'selector'
403   -// option, if you prefer to write your own autocompletion logic.
404   -// In that case, the other options above will not apply unless
405   -// you support them.
406   -
407   -Autocompleter.Local = Class.create(Autocompleter.Base, {
408   - initialize: function(element, update, array, options) {
409   - this.baseInitialize(element, update, options);
410   - this.options.array = array;
411   - },
412   -
413   - getUpdatedChoices: function() {
414   - this.updateChoices(this.options.selector(this));
415   - },
416   -
417   - setOptions: function(options) {
418   - this.options = Object.extend({
419   - choices: 10,
420   - partialSearch: true,
421   - partialChars: 2,
422   - ignoreCase: true,
423   - fullSearch: false,
424   - selector: function(instance) {
425   - var ret = []; // Beginning matches
426   - var partial = []; // Inside matches
427   - var entry = instance.getToken();
428   - var count = 0;
429   -
430   - for (var i = 0; i < instance.options.array.length &&
431   - ret.length < instance.options.choices ; i++) {
432   -
433   - var elem = instance.options.array[i];
434   - var foundPos = instance.options.ignoreCase ?
435   - elem.toLowerCase().indexOf(entry.toLowerCase()) :
436   - elem.indexOf(entry);
437   -
438   - while (foundPos != -1) {
439   - if (foundPos == 0 && elem.length != entry.length) {
440   - ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" +
441   - elem.substr(entry.length) + "</li>");
442   - break;
443   - } else if (entry.length >= instance.options.partialChars &&
444   - instance.options.partialSearch && foundPos != -1) {
445   - if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
446   - partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
447   - elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
448   - foundPos + entry.length) + "</li>");
449   - break;
450   - }
451   - }
452   -
453   - foundPos = instance.options.ignoreCase ?
454   - elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
455   - elem.indexOf(entry, foundPos + 1);
456   -
457   - }
458   - }
459   - if (partial.length)
460   - ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
461   - return "<ul>" + ret.join('') + "</ul>";
462   - }
463   - }, options || { });
464   - }
465   -});
466   -
467   -// AJAX in-place editor and collection editor
468   -// Full rewrite by Christophe Porteneuve <tdd@tddsworld.com> (April 2007).
469   -
470   -// Use this if you notice weird scrolling problems on some browsers,
471   -// the DOM might be a bit confused when this gets called so do this
472   -// waits 1 ms (with setTimeout) until it does the activation
473   -Field.scrollFreeActivate = function(field) {
474   - setTimeout(function() {
475   - Field.activate(field);
476   - }, 1);
477   -}
478   -
479   -Ajax.InPlaceEditor = Class.create({
480   - initialize: function(element, url, options) {
481   - this.url = url;
482   - this.element = element = $(element);
483   - this.prepareOptions();
484   - this._controls = { };
485   - arguments.callee.dealWithDeprecatedOptions(options); // DEPRECATION LAYER!!!
486   - Object.extend(this.options, options || { });
487   - if (!this.options.formId && this.element.id) {
488   - this.options.formId = this.element.id + '-inplaceeditor';
489   - if ($(this.options.formId))
490   - this.options.formId = '';
491   - }
492   - if (this.options.externalControl)
493   - this.options.externalControl = $(this.options.externalControl);
494   - if (!this.options.externalControl)
495   - this.options.externalControlOnly = false;
496   - this._originalBackground = this.element.getStyle('background-color') || 'transparent';
497   - this.element.title = this.options.clickToEditText;
498   - this._boundCancelHandler = this.handleFormCancellation.bind(this);
499   - this._boundComplete = (this.options.onComplete || Prototype.emptyFunction).bind(this);
500   - this._boundFailureHandler = this.handleAJAXFailure.bind(this);
501   - this._boundSubmitHandler = this.handleFormSubmission.bind(this);
502   - this._boundWrapperHandler = this.wrapUp.bind(this);
503   - this.registerListeners();
504   - },
505   - checkForEscapeOrReturn: function(e) {
506   - if (!this._editing || e.ctrlKey || e.altKey || e.shiftKey) return;
507   - if (Event.KEY_ESC == e.keyCode)
508   - this.handleFormCancellation(e);
509   - else if (Event.KEY_RETURN == e.keyCode)
510   - this.handleFormSubmission(e);
511   - },
512   - createControl: function(mode, handler, extraClasses) {
513   - var control = this.options[mode + 'Control'];
514   - var text = this.options[mode + 'Text'];
515   - if ('button' == control) {
516   - var btn = document.createElement('input');
517   - btn.type = 'submit';
518   - btn.value = text;
519   - btn.className = 'editor_' + mode + '_button';
520   - if ('cancel' == mode)
521   - btn.onclick = this._boundCancelHandler;
522   - this._form.appendChild(btn);
523   - this._controls[mode] = btn;
524   - } else if ('link' == control) {
525   - var link = document.createElement('a');
526   - link.href = '#';
527   - link.appendChild(document.createTextNode(text));
528   - link.onclick = 'cancel' == mode ? this._boundCancelHandler : this._boundSubmitHandler;
529   - link.className = 'editor_' + mode + '_link';
530   - if (extraClasses)
531   - link.className += ' ' + extraClasses;
532   - this._form.appendChild(link);
533   - this._controls[mode] = link;
534   - }
535   - },
536   - createEditField: function() {
537   - var text = (this.options.loadTextURL ? this.options.loadingText : this.getText());
538   - var fld;
539   - if (1 >= this.options.rows && !/\r|\n/.test(this.getText())) {
540   - fld = document.createElement('input');
541   - fld.type = 'text';
542   - var size = this.options.size || this.options.cols || 0;
543   - if (0 < size) fld.size = size;
544   - } else {
545   - fld = document.createElement('textarea');
546   - fld.rows = (1 >= this.options.rows ? this.options.autoRows : this.options.rows);
547   - fld.cols = this.options.cols || 40;
548   - }
549   - fld.name = this.options.paramName;
550   - fld.value = text; // No HTML breaks conversion anymore
551   - fld.className = 'editor_field';
552   - if (this.options.submitOnBlur)
553   - fld.onblur = this._boundSubmitHandler;
554   - this._controls.editor = fld;
555   - if (this.options.loadTextURL)
556   - this.loadExternalText();
557   - this._form.appendChild(this._controls.editor);
558   - },
559   - createForm: function() {
560   - var ipe = this;
561   - function addText(mode, condition) {
562   - var text = ipe.options['text' + mode + 'Controls'];
563   - if (!text || condition === false) return;
564   - ipe._form.appendChild(document.createTextNode(text));
565   - };
566   - this._form = $(document.createElement('form'));
567   - this._form.id = this.options.formId;
568   - this._form.addClassName(this.options.formClassName);
569   - this._form.onsubmit = this._boundSubmitHandler;
570   - this.createEditField();
571   - if ('textarea' == this._controls.editor.tagName.toLowerCase())
572   - this._form.appendChild(document.createElement('br'));
573   - if (this.options.onFormCustomization)
574   - this.options.onFormCustomization(this, this._form);
575   - addText('Before', this.options.okControl || this.options.cancelControl);
576   - this.createControl('ok', this._boundSubmitHandler);
577   - addText('Between', this.options.okControl && this.options.cancelControl);
578   - this.createControl('cancel', this._boundCancelHandler, 'editor_cancel');
579   - addText('After', this.options.okControl || this.options.cancelControl);
580   - },
581   - destroy: function() {
582   - if (this._oldInnerHTML)
583   - this.element.innerHTML = this._oldInnerHTML;
584   - this.leaveEditMode();
585   - this.unregisterListeners();
586   - },
587   - enterEditMode: function(e) {
588   - if (this._saving || this._editing) return;
589   - this._editing = true;
590   - this.triggerCallback('onEnterEditMode');
591   - if (this.options.externalControl)
592   - this.options.externalControl.hide();
593   - this.element.hide();
594   - this.createForm();
595   - this.element.parentNode.insertBefore(this._form, this.element);
596   - if (!this.options.loadTextURL)
597   - this.postProcessEditField();
598   - if (e) Event.stop(e);
599   - },
600   - enterHover: function(e) {
601   - if (this.options.hoverClassName)
602   - this.element.addClassName(this.options.hoverClassName);
603   - if (this._saving) return;
604   - this.triggerCallback('onEnterHover');
605   - },
606   - getText: function() {
607   - return this.element.innerHTML;
608   - },
609   - handleAJAXFailure: function(transport) {
610   - this.triggerCallback('onFailure', transport);
611   - if (this._oldInnerHTML) {
612   - this.element.innerHTML = this._oldInnerHTML;
613   - this._oldInnerHTML = null;
614   - }
615   - },
616   - handleFormCancellation: function(e) {
617   - this.wrapUp();
618   - if (e) Event.stop(e);
619   - },
620   - handleFormSubmission: function(e) {
621   - var form = this._form;
622   - var value = $F(this._controls.editor);
623   - this.prepareSubmission();
624   - var params = this.options.callback(form, value) || '';
625   - if (Object.isString(params))
626   - params = params.toQueryParams();
627   - params.editorId = this.element.id;
628   - if (this.options.htmlResponse) {
629   - var options = Object.extend({ evalScripts: true }, this.options.ajaxOptions);
630   - Object.extend(options, {
631   - parameters: params,
632   - onComplete: this._boundWrapperHandler,
633   - onFailure: this._boundFailureHandler
634   - });
635   - new Ajax.Updater({ success: this.element }, this.url, options);
636   - } else {
637   - var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
638   - Object.extend(options, {
639   - parameters: params,
640   - onComplete: this._boundWrapperHandler,
641   - onFailure: this._boundFailureHandler
642   - });
643   - new Ajax.Request(this.url, options);
644   - }
645   - if (e) Event.stop(e);
646   - },
647   - leaveEditMode: function() {
648   - this.element.removeClassName(this.options.savingClassName);
649   - this.removeForm();
650   - this.leaveHover();
651   - this.element.style.backgroundColor = this._originalBackground;
652   - this.element.show();
653   - if (this.options.externalControl)
654   - this.options.externalControl.show();
655   - this._saving = false;
656   - this._editing = false;
657   - this._oldInnerHTML = null;
658   - this.triggerCallback('onLeaveEditMode');
659   - },
660   - leaveHover: function(e) {
661   - if (this.options.hoverClassName)
662   - this.element.removeClassName(this.options.hoverClassName);
663   - if (this._saving) return;
664   - this.triggerCallback('onLeaveHover');
665   - },
666   - loadExternalText: function() {
667   - this._form.addClassName(this.options.loadingClassName);
668   - this._controls.editor.disabled = true;
669   - var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
670   - Object.extend(options, {
671   - parameters: 'editorId=' + encodeURIComponent(this.element.id),
672   - onComplete: Prototype.emptyFunction,
673   - onSuccess: function(transport) {
674   - this._form.removeClassName(this.options.loadingClassName);
675   - var text = transport.responseText;
676   - if (this.options.stripLoadedTextTags)
677   - text = text.stripTags();
678   - this._controls.editor.value = text;
679   - this._controls.editor.disabled = false;
680   - this.postProcessEditField();
681   - }.bind(this),
682   - onFailure: this._boundFailureHandler
683   - });
684   - new Ajax.Request(this.options.loadTextURL, options);
685   - },
686   - postProcessEditField: function() {
687   - var fpc = this.options.fieldPostCreation;
688   - if (fpc)
689   - $(this._controls.editor)['focus' == fpc ? 'focus' : 'activate']();
690   - },
691   - prepareOptions: function() {
692   - this.options = Object.clone(Ajax.InPlaceEditor.DefaultOptions);
693   - Object.extend(this.options, Ajax.InPlaceEditor.DefaultCallbacks);
694   - [this._extraDefaultOptions].flatten().compact().each(function(defs) {
695   - Object.extend(this.options, defs);
696   - }.bind(this));
697   - },
698   - prepareSubmission: function() {
699   - this._saving = true;
700   - this.removeForm();
701   - this.leaveHover();
702   - this.showSaving();
703   - },
704   - registerListeners: function() {
705   - this._listeners = { };
706   - var listener;
707   - $H(Ajax.InPlaceEditor.Listeners).each(function(pair) {
708   - listener = this[pair.value].bind(this);
709   - this._listeners[pair.key] = listener;
710   - if (!this.options.externalControlOnly)
711   - this.element.observe(pair.key, listener);
712   - if (this.options.externalControl)
713   - this.options.externalControl.observe(pair.key, listener);
714   - }.bind(this));
715   - },
716   - removeForm: function() {
717   - if (!this._form) return;
718   - this._form.remove();
719   - this._form = null;
720   - this._controls = { };
721   - },
722   - showSaving: function() {
723   - this._oldInnerHTML = this.element.innerHTML;
724   - this.element.innerHTML = this.options.savingText;
725   - this.element.addClassName(this.options.savingClassName);
726   - this.element.style.backgroundColor = this._originalBackground;
727   - this.element.show();
728   - },
729   - triggerCallback: function(cbName, arg) {
730   - if ('function' == typeof this.options[cbName]) {
731   - this.options[cbName](this, arg);
732   - }
733   - },
734   - unregisterListeners: function() {
735   - $H(this._listeners).each(function(pair) {
736   - if (!this.options.externalControlOnly)
737   - this.element.stopObserving(pair.key, pair.value);
738   - if (this.options.externalControl)
739   - this.options.externalControl.stopObserving(pair.key, pair.value);
740   - }.bind(this));
741   - },
742   - wrapUp: function(transport) {
743   - this.leaveEditMode();
744   - // Can't use triggerCallback due to backward compatibility: requires
745   - // binding + direct element
746   - this._boundComplete(transport, this.element);
747   - }
748   -});
749   -
750   -Object.extend(Ajax.InPlaceEditor.prototype, {
751   - dispose: Ajax.InPlaceEditor.prototype.destroy
752   -});
753   -
754   -Ajax.InPlaceCollectionEditor = Class.create(Ajax.InPlaceEditor, {
755   - initialize: function($super, element, url, options) {
756   - this._extraDefaultOptions = Ajax.InPlaceCollectionEditor.DefaultOptions;
757   - $super(element, url, options);
758   - },
759   -
760   - createEditField: function() {
761   - var list = document.createElement('select');
762   - list.name = this.options.paramName;
763   - list.size = 1;
764   - this._controls.editor = list;
765   - this._collection = this.options.collection || [];
766   - if (this.options.loadCollectionURL)
767   - this.loadCollection();
768   - else
769   - this.checkForExternalText();
770   - this._form.appendChild(this._controls.editor);
771   - },
772   -
773   - loadCollection: function() {
774   - this._form.addClassName(this.options.loadingClassName);
775   - this.showLoadingText(this.options.loadingCollectionText);
776   - var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
777   - Object.extend(options, {
778   - parameters: 'editorId=' + encodeURIComponent(this.element.id),
779   - onComplete: Prototype.emptyFunction,
780   - onSuccess: function(transport) {
781   - var js = transport.responseText.strip();
782   - if (!/^\[.*\]$/.test(js)) // TODO: improve sanity check
783   - throw 'Server returned an invalid collection representation.';
784   - this._collection = eval(js);
785   - this.checkForExternalText();
786   - }.bind(this),
787   - onFailure: this.onFailure
788   - });
789   - new Ajax.Request(this.options.loadCollectionURL, options);
790   - },
791   -
792   - showLoadingText: function(text) {
793   - this._controls.editor.disabled = true;
794   - var tempOption = this._controls.editor.firstChild;
795   - if (!tempOption) {
796   - tempOption = document.createElement('option');
797   - tempOption.value = '';
798   - this._controls.editor.appendChild(tempOption);
799   - tempOption.selected = true;
800   - }
801   - tempOption.update((text || '').stripScripts().stripTags());
802   - },
803   -
804   - checkForExternalText: function() {
805   - this._text = this.getText();
806   - if (this.options.loadTextURL)
807   - this.loadExternalText();
808   - else
809   - this.buildOptionList();
810   - },
811   -
812   - loadExternalText: function() {
813   - this.showLoadingText(this.options.loadingText);
814   - var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
815   - Object.extend(options, {
816   - parameters: 'editorId=' + encodeURIComponent(this.element.id),
817   - onComplete: Prototype.emptyFunction,
818   - onSuccess: function(transport) {
819   - this._text = transport.responseText.strip();
820   - this.buildOptionList();
821   - }.bind(this),
822   - onFailure: this.onFailure
823   - });
824   - new Ajax.Request(this.options.loadTextURL, options);
825   - },
826   -
827   - buildOptionList: function() {
828   - this._form.removeClassName(this.options.loadingClassName);
829   - this._collection = this._collection.map(function(entry) {
830   - return 2 === entry.length ? entry : [entry, entry].flatten();
831   - });
832   - var marker = ('value' in this.options) ? this.options.value : this._text;
833   - var textFound = this._collection.any(function(entry) {
834   - return entry[0] == marker;
835   - }.bind(this));
836   - this._controls.editor.update('');
837   - var option;
838   - this._collection.each(function(entry, index) {
839   - option = document.createElement('option');
840   - option.value = entry[0];
841   - option.selected = textFound ? entry[0] == marker : 0 == index;
842   - option.appendChild(document.createTextNode(entry[1]));
843   - this._controls.editor.appendChild(option);
844   - }.bind(this));
845   - this._controls.editor.disabled = false;
846   - Field.scrollFreeActivate(this._controls.editor);
847   - }
848   -});
849   -
850   -//**** DEPRECATION LAYER FOR InPlace[Collection]Editor! ****
851   -//**** This only exists for a while, in order to let ****
852   -//**** users adapt to the new API. Read up on the new ****
853   -//**** API and convert your code to it ASAP! ****
854   -
855   -Ajax.InPlaceEditor.prototype.initialize.dealWithDeprecatedOptions = function(options) {
856   - if (!options) return;
857   - function fallback(name, expr) {
858   - if (name in options || expr === undefined) return;
859   - options[name] = expr;
860   - };
861   - fallback('cancelControl', (options.cancelLink ? 'link' : (options.cancelButton ? 'button' :
862   - options.cancelLink == options.cancelButton == false ? false : undefined)));
863   - fallback('okControl', (options.okLink ? 'link' : (options.okButton ? 'button' :
864   - options.okLink == options.okButton == false ? false : undefined)));
865   - fallback('highlightColor', options.highlightcolor);
866   - fallback('highlightEndColor', options.highlightendcolor);
867   -};
868   -
869   -Object.extend(Ajax.InPlaceEditor, {
870   - DefaultOptions: {
871   - ajaxOptions: { },
872   - autoRows: 3, // Use when multi-line w/ rows == 1
873   - cancelControl: 'link', // 'link'|'button'|false
874   - cancelText: 'cancel',
875   - clickToEditText: 'Click to edit',
876   - externalControl: null, // id|elt
877   - externalControlOnly: false,
878   - fieldPostCreation: 'activate', // 'activate'|'focus'|false
879   - formClassName: 'inplaceeditor-form',
880   - formId: null, // id|elt
881   - highlightColor: '#ffff99',
882   - highlightEndColor: '#ffffff',
883   - hoverClassName: '',
884   - htmlResponse: true,
885   - loadingClassName: 'inplaceeditor-loading',
886   - loadingText: 'Loading...',
887   - okControl: 'button', // 'link'|'button'|false
888   - okText: 'ok',
889   - paramName: 'value',
890   - rows: 1, // If 1 and multi-line, uses autoRows
891   - savingClassName: 'inplaceeditor-saving',
892   - savingText: 'Saving...',
893   - size: 0,
894   - stripLoadedTextTags: false,
895   - submitOnBlur: false,
896   - textAfterControls: '',
897   - textBeforeControls: '',
898   - textBetweenControls: ''
899   - },
900   - DefaultCallbacks: {
901   - callback: function(form) {
902   - return Form.serialize(form);
903   - },
904   - onComplete: function(transport, element) {
905   - // For backward compatibility, this one is bound to the IPE, and passes
906   - // the element directly. It was too often customized, so we don't break it.
907   - new Effect.Highlight(element, {
908   - startcolor: this.options.highlightColor, keepBackgroundImage: true });
909   - },
910   - onEnterEditMode: null,
911   - onEnterHover: function(ipe) {
912   - ipe.element.style.backgroundColor = ipe.options.highlightColor;
913   - if (ipe._effect)
914   - ipe._effect.cancel();
915   - },
916   - onFailure: function(transport, ipe) {
917   - alert('Error communication with the server: ' + transport.responseText.stripTags());
918   - },
919   - onFormCustomization: null, // Takes the IPE and its generated form, after editor, before controls.
920   - onLeaveEditMode: null,
921   - onLeaveHover: function(ipe) {
922   - ipe._effect = new Effect.Highlight(ipe.element, {
923   - startcolor: ipe.options.highlightColor, endcolor: ipe.options.highlightEndColor,
924   - restorecolor: ipe._originalBackground, keepBackgroundImage: true
925   - });
926   - }
927   - },
928   - Listeners: {
929   - click: 'enterEditMode',
930   - keydown: 'checkForEscapeOrReturn',
931   - mouseover: 'enterHover',
932   - mouseout: 'leaveHover'
933   - }
934   -});
935   -
936   -Ajax.InPlaceCollectionEditor.DefaultOptions = {
937   - loadingCollectionText: 'Loading options...'
938   -};
939   -
940   -// Delayed observer, like Form.Element.Observer,
941   -// but waits for delay after last key input
942   -// Ideal for live-search fields
943   -
944   -Form.Element.DelayedObserver = Class.create({
945   - initialize: function(element, delay, callback) {
946   - this.delay = delay || 0.5;
947   - this.element = $(element);
948   - this.callback = callback;
949   - this.timer = null;
950   - this.lastValue = $F(this.element);
951   - Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
952   - },
953   - delayedListener: function(event) {
954   - if(this.lastValue == $F(this.element)) return;
955   - if(this.timer) clearTimeout(this.timer);
956   - this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
957   - this.lastValue = $F(this.element);
958   - },
959   - onTimerEvent: function() {
960   - this.timer = null;
961   - this.callback(this.element, $F(this.element));
962   - }
963   -});
public/javascripts/dragdrop.js
... ... @@ -1,972 +0,0 @@
1   -// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
2   -// (c) 2005-2007 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
3   -//
4   -// script.aculo.us is freely distributable under the terms of an MIT-style license.
5   -// For details, see the script.aculo.us web site: http://script.aculo.us/
6   -
7   -if(Object.isUndefined(Effect))
8   - throw("dragdrop.js requires including script.aculo.us' effects.js library");
9   -
10   -var Droppables = {
11   - drops: [],
12   -
13   - remove: function(element) {
14   - this.drops = this.drops.reject(function(d) { return d.element==$(element) });
15   - },
16   -
17   - add: function(element) {
18   - element = $(element);
19   - var options = Object.extend({
20   - greedy: true,
21   - hoverclass: null,
22   - tree: false
23   - }, arguments[1] || { });
24   -
25   - // cache containers
26   - if(options.containment) {
27   - options._containers = [];
28   - var containment = options.containment;
29   - if(Object.isArray(containment)) {
30   - containment.each( function(c) { options._containers.push($(c)) });
31   - } else {
32   - options._containers.push($(containment));
33   - }
34   - }
35   -
36   - if(options.accept) options.accept = [options.accept].flatten();
37   -
38   - Element.makePositioned(element); // fix IE
39   - options.element = element;
40   -
41   - this.drops.push(options);
42   - },
43   -
44   - findDeepestChild: function(drops) {
45   - deepest = drops[0];
46   -
47   - for (i = 1; i < drops.length; ++i)
48   - if (Element.isParent(drops[i].element, deepest.element))
49   - deepest = drops[i];
50   -
51   - return deepest;
52   - },
53   -
54   - isContained: function(element, drop) {
55   - var containmentNode;
56   - if(drop.tree) {
57   - containmentNode = element.treeNode;
58   - } else {
59   - containmentNode = element.parentNode;
60   - }
61   - return drop._containers.detect(function(c) { return containmentNode == c });
62   - },
63   -
64   - isAffected: function(point, element, drop) {
65   - return (
66   - (drop.element!=element) &&
67   - ((!drop._containers) ||
68   - this.isContained(element, drop)) &&
69   - ((!drop.accept) ||
70   - (Element.classNames(element).detect(
71   - function(v) { return drop.accept.include(v) } ) )) &&
72   - Position.within(drop.element, point[0], point[1]) );
73   - },
74   -
75   - deactivate: function(drop) {
76   - if(drop.hoverclass)
77   - Element.removeClassName(drop.element, drop.hoverclass);
78   - this.last_active = null;
79   - },
80   -
81   - activate: function(drop) {
82   - if(drop.hoverclass)
83   - Element.addClassName(drop.element, drop.hoverclass);
84   - this.last_active = drop;
85   - },
86   -
87   - show: function(point, element) {
88   - if(!this.drops.length) return;
89   - var drop, affected = [];
90   -
91   - this.drops.each( function(drop) {
92   - if(Droppables.isAffected(point, element, drop))
93   - affected.push(drop);
94   - });
95   -
96   - if(affected.length>0)
97   - drop = Droppables.findDeepestChild(affected);
98   -
99   - if(this.last_active && this.last_active != drop) this.deactivate(this.last_active);
100   - if (drop) {
101   - Position.within(drop.element, point[0], point[1]);
102   - if(drop.onHover)
103   - drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
104   -
105   - if (drop != this.last_active) Droppables.activate(drop);
106   - }
107   - },
108   -
109   - fire: function(event, element) {
110   - if(!this.last_active) return;
111   - Position.prepare();
112   -
113   - if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
114   - if (this.last_active.onDrop) {
115   - this.last_active.onDrop(element, this.last_active.element, event);
116   - return true;
117   - }
118   - },
119   -
120   - reset: function() {
121   - if(this.last_active)
122   - this.deactivate(this.last_active);
123   - }
124   -}
125   -
126   -var Draggables = {
127   - drags: [],
128   - observers: [],
129   -
130   - register: function(draggable) {
131   - if(this.drags.length == 0) {
132   - this.eventMouseUp = this.endDrag.bindAsEventListener(this);
133   - this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
134   - this.eventKeypress = this.keyPress.bindAsEventListener(this);
135   -
136   - Event.observe(document, "mouseup", this.eventMouseUp);
137   - Event.observe(document, "mousemove", this.eventMouseMove);
138   - Event.observe(document, "keypress", this.eventKeypress);
139   - }
140   - this.drags.push(draggable);
141   - },
142   -
143   - unregister: function(draggable) {
144   - this.drags = this.drags.reject(function(d) { return d==draggable });
145   - if(this.drags.length == 0) {
146   - Event.stopObserving(document, "mouseup", this.eventMouseUp);
147   - Event.stopObserving(document, "mousemove", this.eventMouseMove);
148   - Event.stopObserving(document, "keypress", this.eventKeypress);
149   - }
150   - },
151   -
152   - activate: function(draggable) {
153   - if(draggable.options.delay) {
154   - this._timeout = setTimeout(function() {
155   - Draggables._timeout = null;
156   - window.focus();
157   - Draggables.activeDraggable = draggable;
158   - }.bind(this), draggable.options.delay);
159   - } else {
160   - window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
161   - this.activeDraggable = draggable;
162   - }
163   - },
164   -
165   - deactivate: function() {
166   - this.activeDraggable = null;
167   - },
168   -
169   - updateDrag: function(event) {
170   - if(!this.activeDraggable) return;
171   - var pointer = [Event.pointerX(event), Event.pointerY(event)];
172   - // Mozilla-based browsers fire successive mousemove events with
173   - // the same coordinates, prevent needless redrawing (moz bug?)
174   - if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
175   - this._lastPointer = pointer;
176   -
177   - this.activeDraggable.updateDrag(event, pointer);
178   - },
179   -
180   - endDrag: function(event) {
181   - if(this._timeout) {
182   - clearTimeout(this._timeout);
183   - this._timeout = null;
184   - }
185   - if(!this.activeDraggable) return;
186   - this._lastPointer = null;
187   - this.activeDraggable.endDrag(event);
188   - this.activeDraggable = null;
189   - },
190   -
191   - keyPress: function(event) {
192   - if(this.activeDraggable)
193   - this.activeDraggable.keyPress(event);
194   - },
195   -
196   - addObserver: function(observer) {
197   - this.observers.push(observer);
198   - this._cacheObserverCallbacks();
199   - },
200   -
201   - removeObserver: function(element) { // element instead of observer fixes mem leaks
202   - this.observers = this.observers.reject( function(o) { return o.element==element });
203   - this._cacheObserverCallbacks();
204   - },
205   -
206   - notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
207   - if(this[eventName+'Count'] > 0)
208   - this.observers.each( function(o) {
209   - if(o[eventName]) o[eventName](eventName, draggable, event);
210   - });
211   - if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
212   - },
213   -
214   - _cacheObserverCallbacks: function() {
215   - ['onStart','onEnd','onDrag'].each( function(eventName) {
216   - Draggables[eventName+'Count'] = Draggables.observers.select(
217   - function(o) { return o[eventName]; }
218   - ).length;
219   - });
220   - }
221   -}
222   -
223   -/*--------------------------------------------------------------------------*/
224   -
225   -var Draggable = Class.create({
226   - initialize: function(element) {
227   - var defaults = {
228   - handle: false,
229   - reverteffect: function(element, top_offset, left_offset) {
230   - var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
231   - new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
232   - queue: {scope:'_draggable', position:'end'}
233   - });
234   - },
235   - endeffect: function(element) {
236   - var toOpacity = Object.isNumber(element._opacity) ? element._opacity : 1.0;
237   - new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
238   - queue: {scope:'_draggable', position:'end'},
239   - afterFinish: function(){
240   - Draggable._dragging[element] = false
241   - }
242   - });
243   - },
244   - zindex: 1000,
245   - revert: false,
246   - quiet: false,
247   - scroll: false,
248   - scrollSensitivity: 20,
249   - scrollSpeed: 15,
250   - snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
251   - delay: 0
252   - };
253   -
254   - if(!arguments[1] || Object.isUndefined(arguments[1].endeffect))
255   - Object.extend(defaults, {
256   - starteffect: function(element) {
257   - element._opacity = Element.getOpacity(element);
258   - Draggable._dragging[element] = true;
259   - new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
260   - }
261   - });
262   -
263   - var options = Object.extend(defaults, arguments[1] || { });
264   -
265   - this.element = $(element);
266   -
267   - if(options.handle && Object.isString(options.handle))
268   - this.handle = this.element.down('.'+options.handle, 0);
269   -
270   - if(!this.handle) this.handle = $(options.handle);
271   - if(!this.handle) this.handle = this.element;
272   -
273   - if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
274   - options.scroll = $(options.scroll);
275   - this._isScrollChild = Element.childOf(this.element, options.scroll);
276   - }
277   -
278   - Element.makePositioned(this.element); // fix IE
279   -
280   - this.options = options;
281   - this.dragging = false;
282   -
283   - this.eventMouseDown = this.initDrag.bindAsEventListener(this);
284   - Event.observe(this.handle, "mousedown", this.eventMouseDown);
285   -
286   - Draggables.register(this);
287   - },
288   -
289   - destroy: function() {
290   - Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
291   - Draggables.unregister(this);
292   - },
293   -
294   - currentDelta: function() {
295   - return([
296   - parseInt(Element.getStyle(this.element,'left') || '0'),
297   - parseInt(Element.getStyle(this.element,'top') || '0')]);
298   - },
299   -
300   - initDrag: function(event) {
301   - if(!Object.isUndefined(Draggable._dragging[this.element]) &&
302   - Draggable._dragging[this.element]) return;
303   - if(Event.isLeftClick(event)) {
304   - // abort on form elements, fixes a Firefox issue
305   - var src = Event.element(event);
306   - if((tag_name = src.tagName.toUpperCase()) && (
307   - tag_name=='INPUT' ||
308   - tag_name=='SELECT' ||
309   - tag_name=='OPTION' ||
310   - tag_name=='BUTTON' ||
311   - tag_name=='TEXTAREA')) return;
312   -
313   - var pointer = [Event.pointerX(event), Event.pointerY(event)];
314   - var pos = Position.cumulativeOffset(this.element);
315   - this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
316   -
317   - Draggables.activate(this);
318   - Event.stop(event);
319   - }
320   - },
321   -
322   - startDrag: function(event) {
323   - this.dragging = true;
324   - if(!this.delta)
325   - this.delta = this.currentDelta();
326   -
327   - if(this.options.zindex) {
328   - this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
329   - this.element.style.zIndex = this.options.zindex;
330   - }
331   -
332   - if(this.options.ghosting) {
333   - this._clone = this.element.cloneNode(true);
334   - this.element._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
335   - if (!this.element._originallyAbsolute)
336   - Position.absolutize(this.element);
337   - this.element.parentNode.insertBefore(this._clone, this.element);
338   - }
339   -
340   - if(this.options.scroll) {
341   - if (this.options.scroll == window) {
342   - var where = this._getWindowScroll(this.options.scroll);
343   - this.originalScrollLeft = where.left;
344   - this.originalScrollTop = where.top;
345   - } else {
346   - this.originalScrollLeft = this.options.scroll.scrollLeft;
347   - this.originalScrollTop = this.options.scroll.scrollTop;
348   - }
349   - }
350   -
351   - Draggables.notify('onStart', this, event);
352   -
353   - if(this.options.starteffect) this.options.starteffect(this.element);
354   - },
355   -
356   - updateDrag: function(event, pointer) {
357   - if(!this.dragging) this.startDrag(event);
358   -
359   - if(!this.options.quiet){
360   - Position.prepare();
361   - Droppables.show(pointer, this.element);
362   - }
363   -
364   - Draggables.notify('onDrag', this, event);
365   -
366   - this.draw(pointer);
367   - if(this.options.change) this.options.change(this);
368   -
369   - if(this.options.scroll) {
370   - this.stopScrolling();
371   -
372   - var p;
373   - if (this.options.scroll == window) {
374   - with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
375   - } else {
376   - p = Position.page(this.options.scroll);
377   - p[0] += this.options.scroll.scrollLeft + Position.deltaX;
378   - p[1] += this.options.scroll.scrollTop + Position.deltaY;
379   - p.push(p[0]+this.options.scroll.offsetWidth);
380   - p.push(p[1]+this.options.scroll.offsetHeight);
381   - }
382   - var speed = [0,0];
383   - if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
384   - if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
385   - if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
386   - if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
387   - this.startScrolling(speed);
388   - }
389   -
390   - // fix AppleWebKit rendering
391   - if(Prototype.Browser.WebKit) window.scrollBy(0,0);
392   -
393   - Event.stop(event);
394   - },
395   -
396   - finishDrag: function(event, success) {
397   - this.dragging = false;
398   -
399   - if(this.options.quiet){
400   - Position.prepare();
401   - var pointer = [Event.pointerX(event), Event.pointerY(event)];
402   - Droppables.show(pointer, this.element);
403   - }
404   -
405   - if(this.options.ghosting) {
406   - if (!this.element._originallyAbsolute)
407   - Position.relativize(this.element);
408   - delete this.element._originallyAbsolute;
409   - Element.remove(this._clone);
410   - this._clone = null;
411   - }
412   -
413   - var dropped = false;
414   - if(success) {
415   - dropped = Droppables.fire(event, this.element);
416   - if (!dropped) dropped = false;
417   - }
418   - if(dropped && this.options.onDropped) this.options.onDropped(this.element);
419   - Draggables.notify('onEnd', this, event);
420   -
421   - var revert = this.options.revert;
422   - if(revert && Object.isFunction(revert)) revert = revert(this.element);
423   -
424   - var d = this.currentDelta();
425   - if(revert && this.options.reverteffect) {
426   - if (dropped == 0 || revert != 'failure')
427   - this.options.reverteffect(this.element,
428   - d[1]-this.delta[1], d[0]-this.delta[0]);
429   - } else {
430   - this.delta = d;
431   - }
432   -
433   - if(this.options.zindex)
434   - this.element.style.zIndex = this.originalZ;
435   -
436   - if(this.options.endeffect)
437   - this.options.endeffect(this.element);
438   -
439   - Draggables.deactivate(this);
440   - Droppables.reset();
441   - },
442   -
443   - keyPress: function(event) {
444   - if(event.keyCode!=Event.KEY_ESC) return;
445   - this.finishDrag(event, false);
446   - Event.stop(event);
447   - },
448   -
449   - endDrag: function(event) {
450   - if(!this.dragging) return;
451   - this.stopScrolling();
452   - this.finishDrag(event, true);
453   - Event.stop(event);
454   - },
455   -
456   - draw: function(point) {
457   - var pos = Position.cumulativeOffset(this.element);
458   - if(this.options.ghosting) {
459   - var r = Position.realOffset(this.element);
460   - pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
461   - }
462   -
463   - var d = this.currentDelta();
464   - pos[0] -= d[0]; pos[1] -= d[1];
465   -
466   - if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
467   - pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
468   - pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
469   - }
470   -
471   - var p = [0,1].map(function(i){
472   - return (point[i]-pos[i]-this.offset[i])
473   - }.bind(this));
474   -
475   - if(this.options.snap) {
476   - if(Object.isFunction(this.options.snap)) {
477   - p = this.options.snap(p[0],p[1],this);
478   - } else {
479   - if(Object.isArray(this.options.snap)) {
480   - p = p.map( function(v, i) {
481   - return (v/this.options.snap[i]).round()*this.options.snap[i] }.bind(this))
482   - } else {
483   - p = p.map( function(v) {
484   - return (v/this.options.snap).round()*this.options.snap }.bind(this))
485   - }
486   - }}
487   -
488   - var style = this.element.style;
489   - if((!this.options.constraint) || (this.options.constraint=='horizontal'))
490   - style.left = p[0] + "px";
491   - if((!this.options.constraint) || (this.options.constraint=='vertical'))
492   - style.top = p[1] + "px";
493   -
494   - if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
495   - },
496   -
497   - stopScrolling: function() {
498   - if(this.scrollInterval) {
499   - clearInterval(this.scrollInterval);
500   - this.scrollInterval = null;
501   - Draggables._lastScrollPointer = null;
502   - }
503   - },
504   -
505   - startScrolling: function(speed) {
506   - if(!(speed[0] || speed[1])) return;
507   - this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
508   - this.lastScrolled = new Date();
509   - this.scrollInterval = setInterval(this.scroll.bind(this), 10);
510   - },
511   -
512   - scroll: function() {
513   - var current = new Date();
514   - var delta = current - this.lastScrolled;
515   - this.lastScrolled = current;
516   - if(this.options.scroll == window) {
517   - with (this._getWindowScroll(this.options.scroll)) {
518   - if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
519   - var d = delta / 1000;
520   - this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
521   - }
522   - }
523   - } else {
524   - this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
525   - this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
526   - }
527   -
528   - Position.prepare();
529   - Droppables.show(Draggables._lastPointer, this.element);
530   - Draggables.notify('onDrag', this);
531   - if (this._isScrollChild) {
532   - Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
533   - Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
534   - Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
535   - if (Draggables._lastScrollPointer[0] < 0)
536   - Draggables._lastScrollPointer[0] = 0;
537   - if (Draggables._lastScrollPointer[1] < 0)
538   - Draggables._lastScrollPointer[1] = 0;
539   - this.draw(Draggables._lastScrollPointer);
540   - }
541   -
542   - if(this.options.change) this.options.change(this);
543   - },
544   -
545   - _getWindowScroll: function(w) {
546   - var T, L, W, H;
547   - with (w.document) {
548   - if (w.document.documentElement && documentElement.scrollTop) {
549   - T = documentElement.scrollTop;
550   - L = documentElement.scrollLeft;
551   - } else if (w.document.body) {
552   - T = body.scrollTop;
553   - L = body.scrollLeft;
554   - }
555   - if (w.innerWidth) {
556   - W = w.innerWidth;
557   - H = w.innerHeight;
558   - } else if (w.document.documentElement && documentElement.clientWidth) {
559   - W = documentElement.clientWidth;
560   - H = documentElement.clientHeight;
561   - } else {
562   - W = body.offsetWidth;
563   - H = body.offsetHeight
564   - }
565   - }
566   - return { top: T, left: L, width: W, height: H };
567   - }
568   -});
569   -
570   -Draggable._dragging = { };
571   -
572   -/*--------------------------------------------------------------------------*/
573   -
574   -var SortableObserver = Class.create({
575   - initialize: function(element, observer) {
576   - this.element = $(element);
577   - this.observer = observer;
578   - this.lastValue = Sortable.serialize(this.element);
579   - },
580   -
581   - onStart: function() {
582   - this.lastValue = Sortable.serialize(this.element);
583   - },
584   -
585   - onEnd: function() {
586   - Sortable.unmark();
587   - if(this.lastValue != Sortable.serialize(this.element))
588   - this.observer(this.element)
589   - }
590   -});
591   -
592   -var Sortable = {
593   - SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
594   -
595   - sortables: { },
596   -
597   - _findRootElement: function(element) {
598   - while (element.tagName.toUpperCase() != "BODY") {
599   - if(element.id && Sortable.sortables[element.id]) return element;
600   - element = element.parentNode;
601   - }
602   - },
603   -
604   - options: function(element) {
605   - element = Sortable._findRootElement($(element));
606   - if(!element) return;
607   - return Sortable.sortables[element.id];
608   - },
609   -
610   - destroy: function(element){
611   - var s = Sortable.options(element);
612   -
613   - if(s) {
614   - Draggables.removeObserver(s.element);
615   - s.droppables.each(function(d){ Droppables.remove(d) });
616   - s.draggables.invoke('destroy');
617   -
618   - delete Sortable.sortables[s.element.id];
619   - }
620   - },
621   -
622   - create: function(element) {
623   - element = $(element);
624   - var options = Object.extend({
625   - element: element,
626   - tag: 'li', // assumes li children, override with tag: 'tagname'
627   - dropOnEmpty: false,
628   - tree: false,
629   - treeTag: 'ul',
630   - overlap: 'vertical', // one of 'vertical', 'horizontal'
631   - constraint: 'vertical', // one of 'vertical', 'horizontal', false
632   - containment: element, // also takes array of elements (or id's); or false
633   - handle: false, // or a CSS class
634   - only: false,
635   - delay: 0,
636   - hoverclass: null,
637   - ghosting: false,
638   - quiet: false,
639   - scroll: false,
640   - scrollSensitivity: 20,
641   - scrollSpeed: 15,
642   - format: this.SERIALIZE_RULE,
643   -
644   - // these take arrays of elements or ids and can be
645   - // used for better initialization performance
646   - elements: false,
647   - handles: false,
648   -
649   - onChange: Prototype.emptyFunction,
650   - onUpdate: Prototype.emptyFunction
651   - }, arguments[1] || { });
652   -
653   - // clear any old sortable with same element
654   - this.destroy(element);
655   -
656   - // build options for the draggables
657   - var options_for_draggable = {
658   - revert: true,
659   - quiet: options.quiet,
660   - scroll: options.scroll,
661   - scrollSpeed: options.scrollSpeed,
662   - scrollSensitivity: options.scrollSensitivity,
663   - delay: options.delay,
664   - ghosting: options.ghosting,
665   - constraint: options.constraint,
666   - handle: options.handle };
667   -
668   - if(options.starteffect)
669   - options_for_draggable.starteffect = options.starteffect;
670   -
671   - if(options.reverteffect)
672   - options_for_draggable.reverteffect = options.reverteffect;
673   - else
674   - if(options.ghosting) options_for_draggable.reverteffect = function(element) {
675   - element.style.top = 0;
676   - element.style.left = 0;
677   - };
678   -
679   - if(options.endeffect)
680   - options_for_draggable.endeffect = options.endeffect;
681   -
682   - if(options.zindex)
683   - options_for_draggable.zindex = options.zindex;
684   -
685   - // build options for the droppables
686   - var options_for_droppable = {
687   - overlap: options.overlap,
688   - containment: options.containment,
689   - tree: options.tree,
690   - hoverclass: options.hoverclass,
691   - onHover: Sortable.onHover
692   - }
693   -
694   - var options_for_tree = {
695   - onHover: Sortable.onEmptyHover,
696   - overlap: options.overlap,
697   - containment: options.containment,
698   - hoverclass: options.hoverclass
699   - }
700   -
701   - // fix for gecko engine
702   - Element.cleanWhitespace(element);
703   -
704   - options.draggables = [];
705   - options.droppables = [];
706   -
707   - // drop on empty handling
708   - if(options.dropOnEmpty || options.tree) {
709   - Droppables.add(element, options_for_tree);
710   - options.droppables.push(element);
711   - }
712   -
713   - (options.elements || this.findElements(element, options) || []).each( function(e,i) {
714   - var handle = options.handles ? $(options.handles[i]) :
715   - (options.handle ? $(e).select('.' + options.handle)[0] : e);
716   - options.draggables.push(
717   - new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
718   - Droppables.add(e, options_for_droppable);
719   - if(options.tree) e.treeNode = element;
720   - options.droppables.push(e);
721   - });
722   -
723   - if(options.tree) {
724   - (Sortable.findTreeElements(element, options) || []).each( function(e) {
725   - Droppables.add(e, options_for_tree);
726   - e.treeNode = element;
727   - options.droppables.push(e);
728   - });
729   - }
730   -
731   - // keep reference
732   - this.sortables[element.id] = options;
733   -
734   - // for onupdate
735   - Draggables.addObserver(new SortableObserver(element, options.onUpdate));
736   -
737   - },
738   -
739   - // return all suitable-for-sortable elements in a guaranteed order
740   - findElements: function(element, options) {
741   - return Element.findChildren(
742   - element, options.only, options.tree ? true : false, options.tag);
743   - },
744   -
745   - findTreeElements: function(element, options) {
746   - return Element.findChildren(
747   - element, options.only, options.tree ? true : false, options.treeTag);
748   - },
749   -
750   - onHover: function(element, dropon, overlap) {
751   - if(Element.isParent(dropon, element)) return;
752   -
753   - if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
754   - return;
755   - } else if(overlap>0.5) {
756   - Sortable.mark(dropon, 'before');
757   - if(dropon.previousSibling != element) {
758   - var oldParentNode = element.parentNode;
759   - element.style.visibility = "hidden"; // fix gecko rendering
760   - dropon.parentNode.insertBefore(element, dropon);
761   - if(dropon.parentNode!=oldParentNode)
762   - Sortable.options(oldParentNode).onChange(element);
763   - Sortable.options(dropon.parentNode).onChange(element);
764   - }
765   - } else {
766   - Sortable.mark(dropon, 'after');
767   - var nextElement = dropon.nextSibling || null;
768   - if(nextElement != element) {
769   - var oldParentNode = element.parentNode;
770   - element.style.visibility = "hidden"; // fix gecko rendering
771   - dropon.parentNode.insertBefore(element, nextElement);
772   - if(dropon.parentNode!=oldParentNode)
773   - Sortable.options(oldParentNode).onChange(element);
774   - Sortable.options(dropon.parentNode).onChange(element);
775   - }
776   - }
777   - },
778   -
779   - onEmptyHover: function(element, dropon, overlap) {
780   - var oldParentNode = element.parentNode;
781   - var droponOptions = Sortable.options(dropon);
782   -
783   - if(!Element.isParent(dropon, element)) {
784   - var index;
785   -
786   - var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
787   - var child = null;
788   -
789   - if(children) {
790   - var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
791   -
792   - for (index = 0; index < children.length; index += 1) {
793   - if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
794   - offset -= Element.offsetSize (children[index], droponOptions.overlap);
795   - } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
796   - child = index + 1 < children.length ? children[index + 1] : null;
797   - break;
798   - } else {
799   - child = children[index];
800   - break;
801   - }
802   - }
803   - }
804   -
805   - dropon.insertBefore(element, child);
806   -
807   - Sortable.options(oldParentNode).onChange(element);
808   - droponOptions.onChange(element);
809   - }
810   - },
811   -
812   - unmark: function() {
813   - if(Sortable._marker) Sortable._marker.hide();
814   - },
815   -
816   - mark: function(dropon, position) {
817   - // mark on ghosting only
818   - var sortable = Sortable.options(dropon.parentNode);
819   - if(sortable && !sortable.ghosting) return;
820   -
821   - if(!Sortable._marker) {
822   - Sortable._marker =
823   - ($('dropmarker') || Element.extend(document.createElement('DIV'))).
824   - hide().addClassName('dropmarker').setStyle({position:'absolute'});
825   - document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
826   - }
827   - var offsets = Position.cumulativeOffset(dropon);
828   - Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
829   -
830   - if(position=='after')
831   - if(sortable.overlap == 'horizontal')
832   - Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
833   - else
834   - Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
835   -
836   - Sortable._marker.show();
837   - },
838   -
839   - _tree: function(element, options, parent) {
840   - var children = Sortable.findElements(element, options) || [];
841   -
842   - for (var i = 0; i < children.length; ++i) {
843   - var match = children[i].id.match(options.format);
844   -
845   - if (!match) continue;
846   -
847   - var child = {
848   - id: encodeURIComponent(match ? match[1] : null),
849   - element: element,
850   - parent: parent,
851   - children: [],
852   - position: parent.children.length,
853   - container: $(children[i]).down(options.treeTag)
854   - }
855   -
856   - /* Get the element containing the children and recurse over it */
857   - if (child.container)
858   - this._tree(child.container, options, child)
859   -
860   - parent.children.push (child);
861   - }
862   -
863   - return parent;
864   - },
865   -
866   - tree: function(element) {
867   - element = $(element);
868   - var sortableOptions = this.options(element);
869   - var options = Object.extend({
870   - tag: sortableOptions.tag,
871   - treeTag: sortableOptions.treeTag,
872   - only: sortableOptions.only,
873   - name: element.id,
874   - format: sortableOptions.format
875   - }, arguments[1] || { });
876   -
877   - var root = {
878   - id: null,
879   - parent: null,
880   - children: [],
881   - container: element,
882   - position: 0
883   - }
884   -
885   - return Sortable._tree(element, options, root);
886   - },
887   -
888   - /* Construct a [i] index for a particular node */
889   - _constructIndex: function(node) {
890   - var index = '';
891   - do {
892   - if (node.id) index = '[' + node.position + ']' + index;
893   - } while ((node = node.parent) != null);
894   - return index;
895   - },
896   -
897   - sequence: function(element) {
898   - element = $(element);
899   - var options = Object.extend(this.options(element), arguments[1] || { });
900   -
901   - return $(this.findElements(element, options) || []).map( function(item) {
902   - return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
903   - });
904   - },
905   -
906   - setSequence: function(element, new_sequence) {
907   - element = $(element);
908   - var options = Object.extend(this.options(element), arguments[2] || { });
909   -
910   - var nodeMap = { };
911   - this.findElements(element, options).each( function(n) {
912   - if (n.id.match(options.format))
913   - nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
914   - n.parentNode.removeChild(n);
915   - });
916   -
917   - new_sequence.each(function(ident) {
918   - var n = nodeMap[ident];
919   - if (n) {
920   - n[1].appendChild(n[0]);
921   - delete nodeMap[ident];
922   - }
923   - });
924   - },
925   -
926   - serialize: function(element) {
927   - element = $(element);
928   - var options = Object.extend(Sortable.options(element), arguments[1] || { });
929   - var name = encodeURIComponent(
930   - (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
931   -
932   - if (options.tree) {
933   - return Sortable.tree(element, arguments[1]).children.map( function (item) {
934   - return [name + Sortable._constructIndex(item) + "[id]=" +
935   - encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
936   - }).flatten().join('&');
937   - } else {
938   - return Sortable.sequence(element, arguments[1]).map( function(item) {
939   - return name + "[]=" + encodeURIComponent(item);
940   - }).join('&');
941   - }
942   - }
943   -}
944   -
945   -// Returns true if child is contained within element
946   -Element.isParent = function(child, element) {
947   - if (!child.parentNode || child == element) return false;
948   - if (child.parentNode == element) return true;
949   - return Element.isParent(child.parentNode, element);
950   -}
951   -
952   -Element.findChildren = function(element, only, recursive, tagName) {
953   - if(!element.hasChildNodes()) return null;
954   - tagName = tagName.toUpperCase();
955   - if(only) only = [only].flatten();
956   - var elements = [];
957   - $A(element.childNodes).each( function(e) {
958   - if(e.tagName && e.tagName.toUpperCase()==tagName &&
959   - (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
960   - elements.push(e);
961   - if(recursive) {
962   - var grandchildren = Element.findChildren(e, only, recursive, tagName);
963   - if(grandchildren) elements.push(grandchildren);
964   - }
965   - });
966   -
967   - return (elements.length>0 ? elements.flatten() : []);
968   -}
969   -
970   -Element.offsetSize = function (element, type) {
971   - return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
972   -}
public/javascripts/effects.js
... ... @@ -1,1120 +0,0 @@
1   -// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
2   -// Contributors:
3   -// Justin Palmer (http://encytemedia.com/)
4   -// Mark Pilgrim (http://diveintomark.org/)
5   -// Martin Bialasinki
6   -//
7   -// script.aculo.us is freely distributable under the terms of an MIT-style license.
8   -// For details, see the script.aculo.us web site: http://script.aculo.us/
9   -
10   -// converts rgb() and #xxx to #xxxxxx format,
11   -// returns self (or first argument) if not convertable
12   -String.prototype.parseColor = function() {
13   - var color = '#';
14   - if (this.slice(0,4) == 'rgb(') {
15   - var cols = this.slice(4,this.length-1).split(',');
16   - var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
17   - } else {
18   - if (this.slice(0,1) == '#') {
19   - if (this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
20   - if (this.length==7) color = this.toLowerCase();
21   - }
22   - }
23   - return (color.length==7 ? color : (arguments[0] || this));
24   -};
25   -
26   -/*--------------------------------------------------------------------------*/
27   -
28   -Element.collectTextNodes = function(element) {
29   - return $A($(element).childNodes).collect( function(node) {
30   - return (node.nodeType==3 ? node.nodeValue :
31   - (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
32   - }).flatten().join('');
33   -};
34   -
35   -Element.collectTextNodesIgnoreClass = function(element, className) {
36   - return $A($(element).childNodes).collect( function(node) {
37   - return (node.nodeType==3 ? node.nodeValue :
38   - ((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
39   - Element.collectTextNodesIgnoreClass(node, className) : ''));
40   - }).flatten().join('');
41   -};
42   -
43   -Element.setContentZoom = function(element, percent) {
44   - element = $(element);
45   - element.setStyle({fontSize: (percent/100) + 'em'});
46   - if (Prototype.Browser.WebKit) window.scrollBy(0,0);
47   - return element;
48   -};
49   -
50   -Element.getInlineOpacity = function(element){
51   - return $(element).style.opacity || '';
52   -};
53   -
54   -Element.forceRerendering = function(element) {
55   - try {
56   - element = $(element);
57   - var n = document.createTextNode(' ');
58   - element.appendChild(n);
59   - element.removeChild(n);
60   - } catch(e) { }
61   -};
62   -
63   -/*--------------------------------------------------------------------------*/
64   -
65   -var Effect = {
66   - _elementDoesNotExistError: {
67   - name: 'ElementDoesNotExistError',
68   - message: 'The specified DOM element does not exist, but is required for this effect to operate'
69   - },
70   - Transitions: {
71   - linear: Prototype.K,
72   - sinoidal: function(pos) {
73   - return (-Math.cos(pos*Math.PI)/2) + 0.5;
74   - },
75   - reverse: function(pos) {
76   - return 1-pos;
77   - },
78   - flicker: function(pos) {
79   - var pos = ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
80   - return pos > 1 ? 1 : pos;
81   - },
82   - wobble: function(pos) {
83   - return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
84   - },
85   - pulse: function(pos, pulses) {
86   - pulses = pulses || 5;
87   - return (
88   - ((pos % (1/pulses)) * pulses).round() == 0 ?
89   - ((pos * pulses * 2) - (pos * pulses * 2).floor()) :
90   - 1 - ((pos * pulses * 2) - (pos * pulses * 2).floor())
91   - );
92   - },
93   - spring: function(pos) {
94   - return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
95   - },
96   - none: function(pos) {
97   - return 0;
98   - },
99   - full: function(pos) {
100   - return 1;
101   - }
102   - },
103   - DefaultOptions: {
104   - duration: 1.0, // seconds
105   - fps: 100, // 100= assume 66fps max.
106   - sync: false, // true for combining
107   - from: 0.0,
108   - to: 1.0,
109   - delay: 0.0,
110   - queue: 'parallel'
111   - },
112   - tagifyText: function(element) {
113   - var tagifyStyle = 'position:relative';
114   - if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';
115   -
116   - element = $(element);
117   - $A(element.childNodes).each( function(child) {
118   - if (child.nodeType==3) {
119   - child.nodeValue.toArray().each( function(character) {
120   - element.insertBefore(
121   - new Element('span', {style: tagifyStyle}).update(
122   - character == ' ' ? String.fromCharCode(160) : character),
123   - child);
124   - });
125   - Element.remove(child);
126   - }
127   - });
128   - },
129   - multiple: function(element, effect) {
130   - var elements;
131   - if (((typeof element == 'object') ||
132   - Object.isFunction(element)) &&
133   - (element.length))
134   - elements = element;
135   - else
136   - elements = $(element).childNodes;
137   -
138   - var options = Object.extend({
139   - speed: 0.1,
140   - delay: 0.0
141   - }, arguments[2] || { });
142   - var masterDelay = options.delay;
143   -
144   - $A(elements).each( function(element, index) {
145   - new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
146   - });
147   - },
148   - PAIRS: {
149   - 'slide': ['SlideDown','SlideUp'],
150   - 'blind': ['BlindDown','BlindUp'],
151   - 'appear': ['Appear','Fade']
152   - },
153   - toggle: function(element, effect) {
154   - element = $(element);
155   - effect = (effect || 'appear').toLowerCase();
156   - var options = Object.extend({
157   - queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
158   - }, arguments[2] || { });
159   - Effect[element.visible() ?
160   - Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
161   - }
162   -};
163   -
164   -Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;
165   -
166   -/* ------------- core effects ------------- */
167   -
168   -Effect.ScopedQueue = Class.create(Enumerable, {
169   - initialize: function() {
170   - this.effects = [];
171   - this.interval = null;
172   - },
173   - _each: function(iterator) {
174   - this.effects._each(iterator);
175   - },
176   - add: function(effect) {
177   - var timestamp = new Date().getTime();
178   -
179   - var position = Object.isString(effect.options.queue) ?
180   - effect.options.queue : effect.options.queue.position;
181   -
182   - switch(position) {
183   - case 'front':
184   - // move unstarted effects after this effect
185   - this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
186   - e.startOn += effect.finishOn;
187   - e.finishOn += effect.finishOn;
188   - });
189   - break;
190   - case 'with-last':
191   - timestamp = this.effects.pluck('startOn').max() || timestamp;
192   - break;
193   - case 'end':
194   - // start effect after last queued effect has finished
195   - timestamp = this.effects.pluck('finishOn').max() || timestamp;
196   - break;
197   - }
198   -
199   - effect.startOn += timestamp;
200   - effect.finishOn += timestamp;
201   -
202   - if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
203   - this.effects.push(effect);
204   -
205   - if (!this.interval)
206   - this.interval = setInterval(this.loop.bind(this), 15);
207   - },
208   - remove: function(effect) {
209   - this.effects = this.effects.reject(function(e) { return e==effect });
210   - if (this.effects.length == 0) {
211   - clearInterval(this.interval);
212   - this.interval = null;
213   - }
214   - },
215   - loop: function() {
216   - var timePos = new Date().getTime();
217   - for(var i=0, len=this.effects.length;i<len;i++)
218   - this.effects[i] && this.effects[i].loop(timePos);
219   - }
220   -});
221   -
222   -Effect.Queues = {
223   - instances: $H(),
224   - get: function(queueName) {
225   - if (!Object.isString(queueName)) return queueName;
226   -
227   - return this.instances.get(queueName) ||
228   - this.instances.set(queueName, new Effect.ScopedQueue());
229   - }
230   -};
231   -Effect.Queue = Effect.Queues.get('global');
232   -
233   -Effect.Base = Class.create({
234   - position: null,
235   - start: function(options) {
236   - function codeForEvent(options,eventName){
237   - return (
238   - (options[eventName+'Internal'] ? 'this.options.'+eventName+'Internal(this);' : '') +
239   - (options[eventName] ? 'this.options.'+eventName+'(this);' : '')
240   - );
241   - }
242   - if (options && options.transition === false) options.transition = Effect.Transitions.linear;
243   - this.options = Object.extend(Object.extend({ },Effect.DefaultOptions), options || { });
244   - this.currentFrame = 0;
245   - this.state = 'idle';
246   - this.startOn = this.options.delay*1000;
247   - this.finishOn = this.startOn+(this.options.duration*1000);
248   - this.fromToDelta = this.options.to-this.options.from;
249   - this.totalTime = this.finishOn-this.startOn;
250   - this.totalFrames = this.options.fps*this.options.duration;
251   -
252   - eval('this.render = function(pos){ '+
253   - 'if (this.state=="idle"){this.state="running";'+
254   - codeForEvent(this.options,'beforeSetup')+
255   - (this.setup ? 'this.setup();':'')+
256   - codeForEvent(this.options,'afterSetup')+
257   - '};if (this.state=="running"){'+
258   - 'pos=this.options.transition(pos)*'+this.fromToDelta+'+'+this.options.from+';'+
259   - 'this.position=pos;'+
260   - codeForEvent(this.options,'beforeUpdate')+
261   - (this.update ? 'this.update(pos);':'')+
262   - codeForEvent(this.options,'afterUpdate')+
263   - '}}');
264   -
265   - this.event('beforeStart');
266   - if (!this.options.sync)
267   - Effect.Queues.get(Object.isString(this.options.queue) ?
268   - 'global' : this.options.queue.scope).add(this);
269   - },
270   - loop: function(timePos) {
271   - if (timePos >= this.startOn) {
272   - if (timePos >= this.finishOn) {
273   - this.render(1.0);
274   - this.cancel();
275   - this.event('beforeFinish');
276   - if (this.finish) this.finish();
277   - this.event('afterFinish');
278   - return;
279   - }
280   - var pos = (timePos - this.startOn) / this.totalTime,
281   - frame = (pos * this.totalFrames).round();
282   - if (frame > this.currentFrame) {
283   - this.render(pos);
284   - this.currentFrame = frame;
285   - }
286   - }
287   - },
288   - cancel: function() {
289   - if (!this.options.sync)
290   - Effect.Queues.get(Object.isString(this.options.queue) ?
291   - 'global' : this.options.queue.scope).remove(this);
292   - this.state = 'finished';
293   - },
294   - event: function(eventName) {
295   - if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
296   - if (this.options[eventName]) this.options[eventName](this);
297   - },
298   - inspect: function() {
299   - var data = $H();
300   - for(property in this)
301   - if (!Object.isFunction(this[property])) data.set(property, this[property]);
302   - return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
303   - }
304   -});
305   -
306   -Effect.Parallel = Class.create(Effect.Base, {
307   - initialize: function(effects) {
308   - this.effects = effects || [];
309   - this.start(arguments[1]);
310   - },
311   - update: function(position) {
312   - this.effects.invoke('render', position);
313   - },
314   - finish: function(position) {
315   - this.effects.each( function(effect) {
316   - effect.render(1.0);
317   - effect.cancel();
318   - effect.event('beforeFinish');
319   - if (effect.finish) effect.finish(position);
320   - effect.event('afterFinish');
321   - });
322   - }
323   -});
324   -
325   -Effect.Tween = Class.create(Effect.Base, {
326   - initialize: function(object, from, to) {
327   - object = Object.isString(object) ? $(object) : object;
328   - var args = $A(arguments), method = args.last(),
329   - options = args.length == 5 ? args[3] : null;
330   - this.method = Object.isFunction(method) ? method.bind(object) :
331   - Object.isFunction(object[method]) ? object[method].bind(object) :
332   - function(value) { object[method] = value };
333   - this.start(Object.extend({ from: from, to: to }, options || { }));
334   - },
335   - update: function(position) {
336   - this.method(position);
337   - }
338   -});
339   -
340   -Effect.Event = Class.create(Effect.Base, {
341   - initialize: function() {
342   - this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
343   - },
344   - update: Prototype.emptyFunction
345   -});
346   -
347   -Effect.Opacity = Class.create(Effect.Base, {
348   - initialize: function(element) {
349   - this.element = $(element);
350   - if (!this.element) throw(Effect._elementDoesNotExistError);
351   - // make this work on IE on elements without 'layout'
352   - if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
353   - this.element.setStyle({zoom: 1});
354   - var options = Object.extend({
355   - from: this.element.getOpacity() || 0.0,
356   - to: 1.0
357   - }, arguments[1] || { });
358   - this.start(options);
359   - },
360   - update: function(position) {
361   - this.element.setOpacity(position);
362   - }
363   -});
364   -
365   -Effect.Move = Class.create(Effect.Base, {
366   - initialize: function(element) {
367   - this.element = $(element);
368   - if (!this.element) throw(Effect._elementDoesNotExistError);
369   - var options = Object.extend({
370   - x: 0,
371   - y: 0,
372   - mode: 'relative'
373   - }, arguments[1] || { });
374   - this.start(options);
375   - },
376   - setup: function() {
377   - this.element.makePositioned();
378   - this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
379   - this.originalTop = parseFloat(this.element.getStyle('top') || '0');
380   - if (this.options.mode == 'absolute') {
381   - this.options.x = this.options.x - this.originalLeft;
382   - this.options.y = this.options.y - this.originalTop;
383   - }
384   - },
385   - update: function(position) {
386   - this.element.setStyle({
387   - left: (this.options.x * position + this.originalLeft).round() + 'px',
388   - top: (this.options.y * position + this.originalTop).round() + 'px'
389   - });
390   - }
391   -});
392   -
393   -// for backwards compatibility
394   -Effect.MoveBy = function(element, toTop, toLeft) {
395   - return new Effect.Move(element,
396   - Object.extend({ x: toLeft, y: toTop }, arguments[3] || { }));
397   -};
398   -
399   -Effect.Scale = Class.create(Effect.Base, {
400   - initialize: function(element, percent) {
401   - this.element = $(element);
402   - if (!this.element) throw(Effect._elementDoesNotExistError);
403   - var options = Object.extend({
404   - scaleX: true,
405   - scaleY: true,
406   - scaleContent: true,
407   - scaleFromCenter: false,
408   - scaleMode: 'box', // 'box' or 'contents' or { } with provided values
409   - scaleFrom: 100.0,
410   - scaleTo: percent
411   - }, arguments[2] || { });
412   - this.start(options);
413   - },
414   - setup: function() {
415   - this.restoreAfterFinish = this.options.restoreAfterFinish || false;
416   - this.elementPositioning = this.element.getStyle('position');
417   -
418   - this.originalStyle = { };
419   - ['top','left','width','height','fontSize'].each( function(k) {
420   - this.originalStyle[k] = this.element.style[k];
421   - }.bind(this));
422   -
423   - this.originalTop = this.element.offsetTop;
424   - this.originalLeft = this.element.offsetLeft;
425   -
426   - var fontSize = this.element.getStyle('font-size') || '100%';
427   - ['em','px','%','pt'].each( function(fontSizeType) {
428   - if (fontSize.indexOf(fontSizeType)>0) {
429   - this.fontSize = parseFloat(fontSize);
430   - this.fontSizeType = fontSizeType;
431   - }
432   - }.bind(this));
433   -
434   - this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
435   -
436   - this.dims = null;
437   - if (this.options.scaleMode=='box')
438   - this.dims = [this.element.offsetHeight, this.element.offsetWidth];
439   - if (/^content/.test(this.options.scaleMode))
440   - this.dims = [this.element.scrollHeight, this.element.scrollWidth];
441   - if (!this.dims)
442   - this.dims = [this.options.scaleMode.originalHeight,
443   - this.options.scaleMode.originalWidth];
444   - },
445   - update: function(position) {
446   - var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
447   - if (this.options.scaleContent && this.fontSize)
448   - this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
449   - this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
450   - },
451   - finish: function(position) {
452   - if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
453   - },
454   - setDimensions: function(height, width) {
455   - var d = { };
456   - if (this.options.scaleX) d.width = width.round() + 'px';
457   - if (this.options.scaleY) d.height = height.round() + 'px';
458   - if (this.options.scaleFromCenter) {
459   - var topd = (height - this.dims[0])/2;
460   - var leftd = (width - this.dims[1])/2;
461   - if (this.elementPositioning == 'absolute') {
462   - if (this.options.scaleY) d.top = this.originalTop-topd + 'px';
463   - if (this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
464   - } else {
465   - if (this.options.scaleY) d.top = -topd + 'px';
466   - if (this.options.scaleX) d.left = -leftd + 'px';
467   - }
468   - }
469   - this.element.setStyle(d);
470   - }
471   -});
472   -
473   -Effect.Highlight = Class.create(Effect.Base, {
474   - initialize: function(element) {
475   - this.element = $(element);
476   - if (!this.element) throw(Effect._elementDoesNotExistError);
477   - var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
478   - this.start(options);
479   - },
480   - setup: function() {
481   - // Prevent executing on elements not in the layout flow
482   - if (this.element.getStyle('display')=='none') { this.cancel(); return; }
483   - // Disable background image during the effect
484   - this.oldStyle = { };
485   - if (!this.options.keepBackgroundImage) {
486   - this.oldStyle.backgroundImage = this.element.getStyle('background-image');
487   - this.element.setStyle({backgroundImage: 'none'});
488   - }
489   - if (!this.options.endcolor)
490   - this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
491   - if (!this.options.restorecolor)
492   - this.options.restorecolor = this.element.getStyle('background-color');
493   - // init color calculations
494   - this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
495   - this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
496   - },
497   - update: function(position) {
498   - this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
499   - return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
500   - },
501   - finish: function() {
502   - this.element.setStyle(Object.extend(this.oldStyle, {
503   - backgroundColor: this.options.restorecolor
504   - }));
505   - }
506   -});
507   -
508   -Effect.ScrollTo = function(element) {
509   - var options = arguments[1] || { },
510   - scrollOffsets = document.viewport.getScrollOffsets(),
511   - elementOffsets = $(element).cumulativeOffset(),
512   - max = (window.height || document.body.scrollHeight) - document.viewport.getHeight();
513   -
514   - if (options.offset) elementOffsets[1] += options.offset;
515   -
516   - return new Effect.Tween(null,
517   - scrollOffsets.top,
518   - elementOffsets[1] > max ? max : elementOffsets[1],
519   - options,
520   - function(p){ scrollTo(scrollOffsets.left, p.round()) }
521   - );
522   -};
523   -
524   -/* ------------- combination effects ------------- */
525   -
526   -Effect.Fade = function(element) {
527   - element = $(element);
528   - var oldOpacity = element.getInlineOpacity();
529   - var options = Object.extend({
530   - from: element.getOpacity() || 1.0,
531   - to: 0.0,
532   - afterFinishInternal: function(effect) {
533   - if (effect.options.to!=0) return;
534   - effect.element.hide().setStyle({opacity: oldOpacity});
535   - }
536   - }, arguments[1] || { });
537   - return new Effect.Opacity(element,options);
538   -};
539   -
540   -Effect.Appear = function(element) {
541   - element = $(element);
542   - var options = Object.extend({
543   - from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
544   - to: 1.0,
545   - // force Safari to render floated elements properly
546   - afterFinishInternal: function(effect) {
547   - effect.element.forceRerendering();
548   - },
549   - beforeSetup: function(effect) {
550   - effect.element.setOpacity(effect.options.from).show();
551   - }}, arguments[1] || { });
552   - return new Effect.Opacity(element,options);
553   -};
554   -
555   -Effect.Puff = function(element) {
556   - element = $(element);
557   - var oldStyle = {
558   - opacity: element.getInlineOpacity(),
559   - position: element.getStyle('position'),
560   - top: element.style.top,
561   - left: element.style.left,
562   - width: element.style.width,
563   - height: element.style.height
564   - };
565   - return new Effect.Parallel(
566   - [ new Effect.Scale(element, 200,
567   - { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
568   - new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
569   - Object.extend({ duration: 1.0,
570   - beforeSetupInternal: function(effect) {
571   - Position.absolutize(effect.effects[0].element)
572   - },
573   - afterFinishInternal: function(effect) {
574   - effect.effects[0].element.hide().setStyle(oldStyle); }
575   - }, arguments[1] || { })
576   - );
577   -};
578   -
579   -Effect.BlindUp = function(element) {
580   - element = $(element);
581   - element.makeClipping();
582   - return new Effect.Scale(element, 0,
583   - Object.extend({ scaleContent: false,
584   - scaleX: false,
585   - restoreAfterFinish: true,
586   - afterFinishInternal: function(effect) {
587   - effect.element.hide().undoClipping();
588   - }
589   - }, arguments[1] || { })
590   - );
591   -};
592   -
593   -Effect.BlindDown = function(element) {
594   - element = $(element);
595   - var elementDimensions = element.getDimensions();
596   - return new Effect.Scale(element, 100, Object.extend({
597   - scaleContent: false,
598   - scaleX: false,
599   - scaleFrom: 0,
600   - scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
601   - restoreAfterFinish: true,
602   - afterSetup: function(effect) {
603   - effect.element.makeClipping().setStyle({height: '0px'}).show();
604   - },
605   - afterFinishInternal: function(effect) {
606   - effect.element.undoClipping();
607   - }
608   - }, arguments[1] || { }));
609   -};
610   -
611   -Effect.SwitchOff = function(element) {
612   - element = $(element);
613   - var oldOpacity = element.getInlineOpacity();
614   - return new Effect.Appear(element, Object.extend({
615   - duration: 0.4,
616   - from: 0,
617   - transition: Effect.Transitions.flicker,
618   - afterFinishInternal: function(effect) {
619   - new Effect.Scale(effect.element, 1, {
620   - duration: 0.3, scaleFromCenter: true,
621   - scaleX: false, scaleContent: false, restoreAfterFinish: true,
622   - beforeSetup: function(effect) {
623   - effect.element.makePositioned().makeClipping();
624   - },
625   - afterFinishInternal: function(effect) {
626   - effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
627   - }
628   - })
629   - }
630   - }, arguments[1] || { }));
631   -};
632   -
633   -Effect.DropOut = function(element) {
634   - element = $(element);
635   - var oldStyle = {
636   - top: element.getStyle('top'),
637   - left: element.getStyle('left'),
638   - opacity: element.getInlineOpacity() };
639   - return new Effect.Parallel(
640   - [ new Effect.Move(element, {x: 0, y: 100, sync: true }),
641   - new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
642   - Object.extend(
643   - { duration: 0.5,
644   - beforeSetup: function(effect) {
645   - effect.effects[0].element.makePositioned();
646   - },
647   - afterFinishInternal: function(effect) {
648   - effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
649   - }
650   - }, arguments[1] || { }));
651   -};
652   -
653   -Effect.Shake = function(element) {
654   - element = $(element);
655   - var options = Object.extend({
656   - distance: 20,
657   - duration: 0.5
658   - }, arguments[1] || {});
659   - var distance = parseFloat(options.distance);
660   - var split = parseFloat(options.duration) / 10.0;
661   - var oldStyle = {
662   - top: element.getStyle('top'),
663   - left: element.getStyle('left') };
664   - return new Effect.Move(element,
665   - { x: distance, y: 0, duration: split, afterFinishInternal: function(effect) {
666   - new Effect.Move(effect.element,
667   - { x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
668   - new Effect.Move(effect.element,
669   - { x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
670   - new Effect.Move(effect.element,
671   - { x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
672   - new Effect.Move(effect.element,
673   - { x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
674   - new Effect.Move(effect.element,
675   - { x: -distance, y: 0, duration: split, afterFinishInternal: function(effect) {
676   - effect.element.undoPositioned().setStyle(oldStyle);
677   - }}) }}) }}) }}) }}) }});
678   -};
679   -
680   -Effect.SlideDown = function(element) {
681   - element = $(element).cleanWhitespace();
682   - // SlideDown need to have the content of the element wrapped in a container element with fixed height!
683   - var oldInnerBottom = element.down().getStyle('bottom');
684   - var elementDimensions = element.getDimensions();
685   - return new Effect.Scale(element, 100, Object.extend({
686   - scaleContent: false,
687   - scaleX: false,
688   - scaleFrom: window.opera ? 0 : 1,
689   - scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
690   - restoreAfterFinish: true,
691   - afterSetup: function(effect) {
692   - effect.element.makePositioned();
693   - effect.element.down().makePositioned();
694   - if (window.opera) effect.element.setStyle({top: ''});
695   - effect.element.makeClipping().setStyle({height: '0px'}).show();
696   - },
697   - afterUpdateInternal: function(effect) {
698   - effect.element.down().setStyle({bottom:
699   - (effect.dims[0] - effect.element.clientHeight) + 'px' });
700   - },
701   - afterFinishInternal: function(effect) {
702   - effect.element.undoClipping().undoPositioned();
703   - effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
704   - }, arguments[1] || { })
705   - );
706   -};
707   -
708   -Effect.SlideUp = function(element) {
709   - element = $(element).cleanWhitespace();
710   - var oldInnerBottom = element.down().getStyle('bottom');
711   - var elementDimensions = element.getDimensions();
712   - return new Effect.Scale(element, window.opera ? 0 : 1,
713   - Object.extend({ scaleContent: false,
714   - scaleX: false,
715   - scaleMode: 'box',
716   - scaleFrom: 100,
717   - scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
718   - restoreAfterFinish: true,
719   - afterSetup: function(effect) {
720   - effect.element.makePositioned();
721   - effect.element.down().makePositioned();
722   - if (window.opera) effect.element.setStyle({top: ''});
723   - effect.element.makeClipping().show();
724   - },
725   - afterUpdateInternal: function(effect) {
726   - effect.element.down().setStyle({bottom:
727   - (effect.dims[0] - effect.element.clientHeight) + 'px' });
728   - },
729   - afterFinishInternal: function(effect) {
730   - effect.element.hide().undoClipping().undoPositioned();
731   - effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
732   - }
733   - }, arguments[1] || { })
734   - );
735   -};
736   -
737   -// Bug in opera makes the TD containing this element expand for a instance after finish
738   -Effect.Squish = function(element) {
739   - return new Effect.Scale(element, window.opera ? 1 : 0, {
740   - restoreAfterFinish: true,
741   - beforeSetup: function(effect) {
742   - effect.element.makeClipping();
743   - },
744   - afterFinishInternal: function(effect) {
745   - effect.element.hide().undoClipping();
746   - }
747   - });
748   -};
749   -
750   -Effect.Grow = function(element) {
751   - element = $(element);
752   - var options = Object.extend({
753   - direction: 'center',
754   - moveTransition: Effect.Transitions.sinoidal,
755   - scaleTransition: Effect.Transitions.sinoidal,
756   - opacityTransition: Effect.Transitions.full
757   - }, arguments[1] || { });
758   - var oldStyle = {
759   - top: element.style.top,
760   - left: element.style.left,
761   - height: element.style.height,
762   - width: element.style.width,
763   - opacity: element.getInlineOpacity() };
764   -
765   - var dims = element.getDimensions();
766   - var initialMoveX, initialMoveY;
767   - var moveX, moveY;
768   -
769   - switch (options.direction) {
770   - case 'top-left':
771   - initialMoveX = initialMoveY = moveX = moveY = 0;
772   - break;
773   - case 'top-right':
774   - initialMoveX = dims.width;
775   - initialMoveY = moveY = 0;
776   - moveX = -dims.width;
777   - break;
778   - case 'bottom-left':
779   - initialMoveX = moveX = 0;
780   - initialMoveY = dims.height;
781   - moveY = -dims.height;
782   - break;
783   - case 'bottom-right':
784   - initialMoveX = dims.width;
785   - initialMoveY = dims.height;
786   - moveX = -dims.width;
787   - moveY = -dims.height;
788   - break;
789   - case 'center':
790   - initialMoveX = dims.width / 2;
791   - initialMoveY = dims.height / 2;
792   - moveX = -dims.width / 2;
793   - moveY = -dims.height / 2;
794   - break;
795   - }
796   -
797   - return new Effect.Move(element, {
798   - x: initialMoveX,
799   - y: initialMoveY,
800   - duration: 0.01,
801   - beforeSetup: function(effect) {
802   - effect.element.hide().makeClipping().makePositioned();
803   - },
804   - afterFinishInternal: function(effect) {
805   - new Effect.Parallel(
806   - [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
807   - new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
808   - new Effect.Scale(effect.element, 100, {
809   - scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
810   - sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
811   - ], Object.extend({
812   - beforeSetup: function(effect) {
813   - effect.effects[0].element.setStyle({height: '0px'}).show();
814   - },
815   - afterFinishInternal: function(effect) {
816   - effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
817   - }
818   - }, options)
819   - )
820   - }
821   - });
822   -};
823   -
824   -Effect.Shrink = function(element) {
825   - element = $(element);
826   - var options = Object.extend({
827   - direction: 'center',
828   - moveTransition: Effect.Transitions.sinoidal,
829   - scaleTransition: Effect.Transitions.sinoidal,
830   - opacityTransition: Effect.Transitions.none
831   - }, arguments[1] || { });
832   - var oldStyle = {
833   - top: element.style.top,
834   - left: element.style.left,
835   - height: element.style.height,
836   - width: element.style.width,
837   - opacity: element.getInlineOpacity() };
838   -
839   - var dims = element.getDimensions();
840   - var moveX, moveY;
841   -
842   - switch (options.direction) {
843   - case 'top-left':
844   - moveX = moveY = 0;
845   - break;
846   - case 'top-right':
847   - moveX = dims.width;
848   - moveY = 0;
849   - break;
850   - case 'bottom-left':
851   - moveX = 0;
852   - moveY = dims.height;
853   - break;
854   - case 'bottom-right':
855   - moveX = dims.width;
856   - moveY = dims.height;
857   - break;
858   - case 'center':
859   - moveX = dims.width / 2;
860   - moveY = dims.height / 2;
861   - break;
862   - }
863   -
864   - return new Effect.Parallel(
865   - [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
866   - new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
867   - new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
868   - ], Object.extend({
869   - beforeStartInternal: function(effect) {
870   - effect.effects[0].element.makePositioned().makeClipping();
871   - },
872   - afterFinishInternal: function(effect) {
873   - effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
874   - }, options)
875   - );
876   -};
877   -
878   -Effect.Pulsate = function(element) {
879   - element = $(element);
880   - var options = arguments[1] || { };
881   - var oldOpacity = element.getInlineOpacity();
882   - var transition = options.transition || Effect.Transitions.sinoidal;
883   - var reverser = function(pos){ return transition(1-Effect.Transitions.pulse(pos, options.pulses)) };
884   - reverser.bind(transition);
885   - return new Effect.Opacity(element,
886   - Object.extend(Object.extend({ duration: 2.0, from: 0,
887   - afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
888   - }, options), {transition: reverser}));
889   -};
890   -
891   -Effect.Fold = function(element) {
892   - element = $(element);
893   - var oldStyle = {
894   - top: element.style.top,
895   - left: element.style.left,
896   - width: element.style.width,
897   - height: element.style.height };
898   - element.makeClipping();
899   - return new Effect.Scale(element, 5, Object.extend({
900   - scaleContent: false,
901   - scaleX: false,
902   - afterFinishInternal: function(effect) {
903   - new Effect.Scale(element, 1, {
904   - scaleContent: false,
905   - scaleY: false,
906   - afterFinishInternal: function(effect) {
907   - effect.element.hide().undoClipping().setStyle(oldStyle);
908   - } });
909   - }}, arguments[1] || { }));
910   -};
911   -
912   -Effect.Morph = Class.create(Effect.Base, {
913   - initialize: function(element) {
914   - this.element = $(element);
915   - if (!this.element) throw(Effect._elementDoesNotExistError);
916   - var options = Object.extend({
917   - style: { }
918   - }, arguments[1] || { });
919   -
920   - if (!Object.isString(options.style)) this.style = $H(options.style);
921   - else {
922   - if (options.style.include(':'))
923   - this.style = options.style.parseStyle();
924   - else {
925   - this.element.addClassName(options.style);
926   - this.style = $H(this.element.getStyles());
927   - this.element.removeClassName(options.style);
928   - var css = this.element.getStyles();
929   - this.style = this.style.reject(function(style) {
930   - return style.value == css[style.key];
931   - });
932   - options.afterFinishInternal = function(effect) {
933   - effect.element.addClassName(effect.options.style);
934   - effect.transforms.each(function(transform) {
935   - effect.element.style[transform.style] = '';
936   - });
937   - }
938   - }
939   - }
940   - this.start(options);
941   - },
942   -
943   - setup: function(){
944   - function parseColor(color){
945   - if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
946   - color = color.parseColor();
947   - return $R(0,2).map(function(i){
948   - return parseInt( color.slice(i*2+1,i*2+3), 16 )
949   - });
950   - }
951   - this.transforms = this.style.map(function(pair){
952   - var property = pair[0], value = pair[1], unit = null;
953   -
954   - if (value.parseColor('#zzzzzz') != '#zzzzzz') {
955   - value = value.parseColor();
956   - unit = 'color';
957   - } else if (property == 'opacity') {
958   - value = parseFloat(value);
959   - if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
960   - this.element.setStyle({zoom: 1});
961   - } else if (Element.CSS_LENGTH.test(value)) {
962   - var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
963   - value = parseFloat(components[1]);
964   - unit = (components.length == 3) ? components[2] : null;
965   - }
966   -
967   - var originalValue = this.element.getStyle(property);
968   - return {
969   - style: property.camelize(),
970   - originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0),
971   - targetValue: unit=='color' ? parseColor(value) : value,
972   - unit: unit
973   - };
974   - }.bind(this)).reject(function(transform){
975   - return (
976   - (transform.originalValue == transform.targetValue) ||
977   - (
978   - transform.unit != 'color' &&
979   - (isNaN(transform.originalValue) || isNaN(transform.targetValue))
980   - )
981   - )
982   - });
983   - },
984   - update: function(position) {
985   - var style = { }, transform, i = this.transforms.length;
986   - while(i--)
987   - style[(transform = this.transforms[i]).style] =
988   - transform.unit=='color' ? '#'+
989   - (Math.round(transform.originalValue[0]+
990   - (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
991   - (Math.round(transform.originalValue[1]+
992   - (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
993   - (Math.round(transform.originalValue[2]+
994   - (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
995   - (transform.originalValue +
996   - (transform.targetValue - transform.originalValue) * position).toFixed(3) +
997   - (transform.unit === null ? '' : transform.unit);
998   - this.element.setStyle(style, true);
999   - }
1000   -});
1001   -
1002   -Effect.Transform = Class.create({
1003   - initialize: function(tracks){
1004   - this.tracks = [];
1005   - this.options = arguments[1] || { };
1006   - this.addTracks(tracks);
1007   - },
1008   - addTracks: function(tracks){
1009   - tracks.each(function(track){
1010   - track = $H(track);
1011   - var data = track.values().first();
1012   - this.tracks.push($H({
1013   - ids: track.keys().first(),
1014   - effect: Effect.Morph,
1015   - options: { style: data }
1016   - }));
1017   - }.bind(this));
1018   - return this;
1019   - },
1020   - play: function(){
1021   - return new Effect.Parallel(
1022   - this.tracks.map(function(track){
1023   - var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
1024   - var elements = [$(ids) || $$(ids)].flatten();
1025   - return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
1026   - }).flatten(),
1027   - this.options
1028   - );
1029   - }
1030   -});
1031   -
1032   -Element.CSS_PROPERTIES = $w(
1033   - 'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' +
1034   - 'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
1035   - 'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
1036   - 'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
1037   - 'fontSize fontWeight height left letterSpacing lineHeight ' +
1038   - 'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
1039   - 'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
1040   - 'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
1041   - 'right textIndent top width wordSpacing zIndex');
1042   -
1043   -Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;
1044   -
1045   -String.__parseStyleElement = document.createElement('div');
1046   -String.prototype.parseStyle = function(){
1047   - var style, styleRules = $H();
1048   - if (Prototype.Browser.WebKit)
1049   - style = new Element('div',{style:this}).style;
1050   - else {
1051   - String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
1052   - style = String.__parseStyleElement.childNodes[0].style;
1053   - }
1054   -
1055   - Element.CSS_PROPERTIES.each(function(property){
1056   - if (style[property]) styleRules.set(property, style[property]);
1057   - });
1058   -
1059   - if (Prototype.Browser.IE && this.include('opacity'))
1060   - styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);
1061   -
1062   - return styleRules;
1063   -};
1064   -
1065   -if (document.defaultView && document.defaultView.getComputedStyle) {
1066   - Element.getStyles = function(element) {
1067   - var css = document.defaultView.getComputedStyle($(element), null);
1068   - return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
1069   - styles[property] = css[property];
1070   - return styles;
1071   - });
1072   - };
1073   -} else {
1074   - Element.getStyles = function(element) {
1075   - element = $(element);
1076   - var css = element.currentStyle, styles;
1077   - styles = Element.CSS_PROPERTIES.inject({ }, function(hash, property) {
1078   - hash.set(property, css[property]);
1079   - return hash;
1080   - });
1081   - if (!styles.opacity) styles.set('opacity', element.getOpacity());
1082   - return styles;
1083   - };
1084   -};
1085   -
1086   -Effect.Methods = {
1087   - morph: function(element, style) {
1088   - element = $(element);
1089   - new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
1090   - return element;
1091   - },
1092   - visualEffect: function(element, effect, options) {
1093   - element = $(element)
1094   - var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
1095   - new Effect[klass](element, options);
1096   - return element;
1097   - },
1098   - highlight: function(element, options) {
1099   - element = $(element);
1100   - new Effect.Highlight(element, options);
1101   - return element;
1102   - }
1103   -};
1104   -
1105   -$w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
1106   - 'pulsate shake puff squish switchOff dropOut').each(
1107   - function(effect) {
1108   - Effect.Methods[effect] = function(element, options){
1109   - element = $(element);
1110   - Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
1111   - return element;
1112   - }
1113   - }
1114   -);
1115   -
1116   -$w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each(
1117   - function(f) { Effect.Methods[f] = Element[f]; }
1118   -);
1119   -
1120   -Element.addMethods(Effect.Methods);
public/javascripts/lowpro.js
... ... @@ -1,338 +0,0 @@
1   -LowPro = {};
2   -LowPro.Version = '0.5';
3   -LowPro.CompatibleWithPrototype = '1.6';
4   -
5   -if (Prototype.Version.indexOf(LowPro.CompatibleWithPrototype) != 0 && window.console && window.console.warn)
6   - console.warn("This version of Low Pro is tested with Prototype " + LowPro.CompatibleWithPrototype +
7   - " it may not work as expected with this version (" + Prototype.Version + ")");
8   -
9   -if (!Element.addMethods)
10   - Element.addMethods = function(o) { Object.extend(Element.Methods, o) };
11   -
12   -// Simple utility methods for working with the DOM
13   -DOM = {};
14   -
15   -// DOMBuilder for prototype
16   -DOM.Builder = {
17   - tagFunc : function(tag) {
18   - return function() {
19   - var attrs, children;
20   - if (arguments.length>0) {
21   - if (arguments[0].constructor == Object) {
22   - attrs = arguments[0];
23   - children = Array.prototype.slice.call(arguments, 1);
24   - } else {
25   - children = arguments;
26   - };
27   - children = $A(children).flatten()
28   - }
29   - return DOM.Builder.create(tag, attrs, children);
30   - };
31   - },
32   - create : function(tag, attrs, children) {
33   - attrs = attrs || {}; children = children || []; tag = tag.toLowerCase();
34   - var el = new Element(tag, attrs);
35   -
36   - for (var i=0; i<children.length; i++) {
37   - if (typeof children[i] == 'string')
38   - children[i] = document.createTextNode(children[i]);
39   - el.appendChild(children[i]);
40   - }
41   - return $(el);
42   - }
43   -};
44   -
45   -// Automatically create node builders as $tagName.
46   -(function() {
47   - var els = ("p|div|span|strong|em|img|table|tr|td|th|thead|tbody|tfoot|pre|code|" +
48   - "h1|h2|h3|h4|h5|h6|ul|ol|li|form|input|textarea|legend|fieldset|" +
49   - "select|option|blockquote|cite|br|hr|dd|dl|dt|address|a|button|abbr|acronym|" +
50   - "script|link|style|bdo|ins|del|object|param|col|colgroup|optgroup|caption|" +
51   - "label|dfn|kbd|samp|var").split("|");
52   - var el, i=0;
53   - while (el = els[i++])
54   - window['$' + el] = DOM.Builder.tagFunc(el);
55   -})();
56   -
57   -DOM.Builder.fromHTML = function(html) {
58   - var root;
59   - if (!(root = arguments.callee._root))
60   - root = arguments.callee._root = document.createElement('div');
61   - root.innerHTML = html;
62   - return root.childNodes[0];
63   -};
64   -
65   -
66   -
67   -// Wraps the 1.6 contentloaded event for backwards compatibility
68   -//
69   -// Usage:
70   -//
71   -// Event.onReady(callbackFunction);
72   -Object.extend(Event, {
73   - onReady : function(f) {
74   - if (document.body) f();
75   - else document.observe('dom:loaded', f);
76   - }
77   -});
78   -
79   -// Based on event:Selectors by Justin Palmer
80   -// http://encytemedia.com/event-selectors/
81   -//
82   -// Usage:
83   -//
84   -// Event.addBehavior({
85   -// "selector:event" : function(event) { /* event handler. this refers to the element. */ },
86   -// "selector" : function() { /* runs function on dom ready. this refers to the element. */ }
87   -// ...
88   -// });
89   -//
90   -// Multiple calls will add to exisiting rules. Event.addBehavior.reassignAfterAjax and
91   -// Event.addBehavior.autoTrigger can be adjusted to needs.
92   -Event.addBehavior = function(rules) {
93   - var ab = this.addBehavior;
94   - Object.extend(ab.rules, rules);
95   -
96   - if (!ab.responderApplied) {
97   - Ajax.Responders.register({
98   - onComplete : function() {
99   - if (Event.addBehavior.reassignAfterAjax)
100   - setTimeout(function() { ab.reload() }, 10);
101   - }
102   - });
103   - ab.responderApplied = true;
104   - }
105   -
106   - if (ab.autoTrigger) {
107   - this.onReady(ab.load.bind(ab, rules));
108   - }
109   -
110   -};
111   -
112   -Event.delegate = function(rules) {
113   - return function(e) {
114   - var element = $(e.element());
115   - for (var selector in rules)
116   - if (element.match(selector)) return rules[selector].apply(this, $A(arguments));
117   - }
118   -}
119   -
120   -Object.extend(Event.addBehavior, {
121   - rules : {}, cache : [],
122   - reassignAfterAjax : false,
123   - autoTrigger : true,
124   -
125   - load : function(rules) {
126   - for (var selector in rules) {
127   - var observer = rules[selector];
128   - var sels = selector.split(',');
129   - sels.each(function(sel) {
130   - var parts = sel.split(/:(?=[a-z]+$)/), css = parts[0], event = parts[1];
131   - $$(css).each(function(element) {
132   - if (event) {
133   - observer = Event.addBehavior._wrapObserver(observer);
134   - $(element).observe(event, observer);
135   - Event.addBehavior.cache.push([element, event, observer]);
136   - } else {
137   - if (!element.$$assigned || !element.$$assigned.include(observer)) {
138   - if (observer.attach) observer.attach(element);
139   -
140   - else observer.call($(element));
141   - element.$$assigned = element.$$assigned || [];
142   - element.$$assigned.push(observer);
143   - }
144   - }
145   - });
146   - });
147   - }
148   - },
149   -
150   - unload : function() {
151   - this.cache.each(function(c) {
152   - Event.stopObserving.apply(Event, c);
153   - });
154   - this.cache = [];
155   - },
156   -
157   - reload: function() {
158   - var ab = Event.addBehavior;
159   - ab.unload();
160   - ab.load(ab.rules);
161   - },
162   -
163   - _wrapObserver: function(observer) {
164   - return function(event) {
165   - if (observer.call(this, event) === false) event.stop();
166   - }
167   - }
168   -
169   -});
170   -
171   -Event.observe(window, 'unload', Event.addBehavior.unload.bind(Event.addBehavior));
172   -
173   -// A silly Prototype style shortcut for the reckless
174   -$$$ = Event.addBehavior.bind(Event);
175   -
176   -// Behaviors can be bound to elements to provide an object orientated way of controlling elements
177   -// and their behavior. Use Behavior.create() to make a new behavior class then use attach() to
178   -// glue it to an element. Each element then gets it's own instance of the behavior and any
179   -// methods called onxxx are bound to the relevent event.
180   -//
181   -// Usage:
182   -//
183   -// var MyBehavior = Behavior.create({
184   -// onmouseover : function() { this.element.addClassName('bong') }
185   -// });
186   -//
187   -// Event.addBehavior({ 'a.rollover' : MyBehavior });
188   -//
189   -// If you need to pass additional values to initialize use:
190   -//
191   -// Event.addBehavior({ 'a.rollover' : MyBehavior(10, { thing : 15 }) })
192   -//
193   -// You can also use the attach() method. If you specify extra arguments to attach they get passed to initialize.
194   -//
195   -// MyBehavior.attach(el, values, to, init);
196   -//
197   -// Finally, the rawest method is using the new constructor normally:
198   -// var draggable = new Draggable(element, init, vals);
199   -//
200   -// Each behaviour has a collection of all its instances in Behavior.instances
201   -//
202   -var Behavior = {
203   - create: function() {
204   - var parent = null, properties = $A(arguments);
205   - if (Object.isFunction(properties[0]))
206   - parent = properties.shift();
207   -
208   - var behavior = function() {
209   - var behavior = arguments.callee;
210   - if (!this.initialize) {
211   - var args = $A(arguments);
212   -
213   - return function() {
214   - var initArgs = [this].concat(args);
215   - behavior.attach.apply(behavior, initArgs);
216   - };
217   - } else {
218   - var args = (arguments.length == 2 && arguments[1] instanceof Array) ?
219   - arguments[1] : Array.prototype.slice.call(arguments, 1);
220   -
221   - this.element = $(arguments[0]);
222   - this.initialize.apply(this, args);
223   - behavior._bindEvents(this);
224   - behavior.instances.push(this);
225   - }
226   - };
227   -
228   - Object.extend(behavior, Class.Methods);
229   - Object.extend(behavior, Behavior.Methods);
230   - behavior.superclass = parent;
231   - behavior.subclasses = [];
232   - behavior.instances = [];
233   -
234   - if (parent) {
235   - var subclass = function() { };
236   - subclass.prototype = parent.prototype;
237   - behavior.prototype = new subclass;
238   - parent.subclasses.push(behavior);
239   - }
240   -
241   - for (var i = 0; i < properties.length; i++)
242   - behavior.addMethods(properties[i]);
243   -
244   - if (!behavior.prototype.initialize)
245   - behavior.prototype.initialize = Prototype.emptyFunction;
246   -
247   - behavior.prototype.constructor = behavior;
248   -
249   - return behavior;
250   - },
251   - Methods : {
252   - attach : function(element) {
253   - return new this(element, Array.prototype.slice.call(arguments, 1));
254   - },
255   - _bindEvents : function(bound) {
256   - for (var member in bound)
257   - if (member.match(/^on(.+)/) && typeof bound[member] == 'function')
258   - bound.element.observe(RegExp.$1, Event.addBehavior._wrapObserver(bound[member].bindAsEventListener(bound)));
259   - }
260   - }
261   -};
262   -
263   -
264   -
265   -Remote = Behavior.create({
266   - initialize: function(options) {
267   - if (this.element.nodeName == 'FORM') new Remote.Form(this.element, options);
268   - else new Remote.Link(this.element, options);
269   - }
270   -});
271   -
272   -Remote.Base = {
273   - initialize : function(options) {
274   - this.options = Object.extend({
275   - evaluateScripts : true
276   - }, options || {});
277   -
278   - this._bindCallbacks();
279   - },
280   - _makeRequest : function(options) {
281   - if (options.update) new Ajax.Updater(options.update, options.url, options);
282   - else new Ajax.Request(options.url, options);
283   - return false;
284   - },
285   - _bindCallbacks: function() {
286   - $w('onCreate onComplete onException onFailure onInteractive onLoading onLoaded onSuccess').each(function(cb) {
287   - if (Object.isFunction(this.options[cb]))
288   - this.options[cb] = this.options[cb].bind(this);
289   - }.bind(this));
290   - }
291   -}
292   -
293   -Remote.Link = Behavior.create(Remote.Base, {
294   - onclick : function() {
295   - var options = Object.extend({ url : this.element.href, method : 'get' }, this.options);
296   - return this._makeRequest(options);
297   - }
298   -});
299   -
300   -
301   -Remote.Form = Behavior.create(Remote.Base, {
302   - onclick : function(e) {
303   - var sourceElement = e.element();
304   -
305   - if (['input', 'button'].include(sourceElement.nodeName.toLowerCase()) &&
306   - sourceElement.type == 'submit')
307   - this._submitButton = sourceElement;
308   - },
309   - onsubmit : function() {
310   - var options = Object.extend({
311   - url : this.element.action,
312   - method : this.element.method || 'get',
313   - parameters : this.element.serialize({ submit: this._submitButton.name })
314   - }, this.options);
315   - this._submitButton = null;
316   - return this._makeRequest(options);
317   - }
318   -});
319   -
320   -Observed = Behavior.create({
321   - initialize : function(callback, options) {
322   - this.callback = callback.bind(this);
323   - this.options = options || {};
324   - this.observer = (this.element.nodeName == 'FORM') ? this._observeForm() : this._observeField();
325   - },
326   - stop: function() {
327   - this.observer.stop();
328   - },
329   - _observeForm: function() {
330   - return (this.options.frequency) ? new Form.Observer(this.element, this.options.frequency, this.callback) :
331   - new Form.EventObserver(this.element, this.callback);
332   - },
333   - _observeField: function() {
334   - return (this.options.frequency) ? new Form.Element.Observer(this.element, this.options.frequency, this.callback) :
335   - new Form.Element.EventObserver(this.element, this.callback);
336   - }
337   -});
338   -