The Tor Browser / file comparison

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

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

branch
TOR_BUG_9701
changeset 9
a63d609f5ebe
equal deleted inserted replaced
-1:000000000000 0:3f89458f3457
1 /***
2 Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
3 (c) 2005 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
4 (c) 2005 Jon Tirsen (http://www.tirsen.com)
5 Contributors:
6 Richard Livsey
7 Rahul Bhargava
8 Rob Wills
9 Mochi-ized By Thomas Herve (_firstname_@nimail.org)
10
11 See scriptaculous.js for full license.
12
13 Autocompleter.Base handles all the autocompletion functionality
14 that's independent of the data source for autocompletion. This
15 includes drawing the autocompletion menu, observing keyboard
16 and mouse events, and similar.
17
18 Specific autocompleters need to provide, at the very least,
19 a getUpdatedChoices function that will be invoked every time
20 the text inside the monitored textbox changes. This method
21 should get the text for which to provide autocompletion by
22 invoking this.getToken(), NOT by directly accessing
23 this.element.value. This is to allow incremental tokenized
24 autocompletion. Specific auto-completion logic (AJAX, etc)
25 belongs in getUpdatedChoices.
26
27 Tokenized incremental autocompletion is enabled automatically
28 when an autocompleter is instantiated with the 'tokens' option
29 in the options parameter, e.g.:
30 new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
31 will incrementally autocomplete with a comma as the token.
32 Additionally, ',' in the above example can be replaced with
33 a token array, e.g. { tokens: [',', '\n'] } which
34 enables autocompletion on multiple tokens. This is most
35 useful when one of the tokens is \n (a newline), as it
36 allows smart autocompletion after linebreaks.
37
38 ***/
39
40 MochiKit.Base.update(MochiKit.Base, {
41 ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
42
43 /** @id MochiKit.Base.stripScripts */
44 stripScripts: function (str) {
45 return str.replace(new RegExp(MochiKit.Base.ScriptFragment, 'img'), '');
46 },
47
48 /** @id MochiKit.Base.stripTags */
49 stripTags: function(str) {
50 return str.replace(/<\/?[^>]+>/gi, '');
51 },
52
53 /** @id MochiKit.Base.extractScripts */
54 extractScripts: function (str) {
55 var matchAll = new RegExp(MochiKit.Base.ScriptFragment, 'img');
56 var matchOne = new RegExp(MochiKit.Base.ScriptFragment, 'im');
57 return MochiKit.Base.map(function (scriptTag) {
58 return (scriptTag.match(matchOne) || ['', ''])[1];
59 }, str.match(matchAll) || []);
60 },
61
62 /** @id MochiKit.Base.evalScripts */
63 evalScripts: function (str) {
64 return MochiKit.Base.map(function (scr) {
65 eval(scr);
66 }, MochiKit.Base.extractScripts(str));
67 }
68 });
69
70 MochiKit.Form = {
71
72 /** @id MochiKit.Form.serialize */
73 serialize: function (form) {
74 var elements = MochiKit.Form.getElements(form);
75 var queryComponents = [];
76
77 for (var i = 0; i < elements.length; i++) {
78 var queryComponent = MochiKit.Form.serializeElement(elements[i]);
79 if (queryComponent) {
80 queryComponents.push(queryComponent);
81 }
82 }
83
84 return queryComponents.join('&');
85 },
86
87 /** @id MochiKit.Form.getElements */
88 getElements: function (form) {
89 form = MochiKit.DOM.getElement(form);
90 var elements = [];
91
92 for (var tagName in MochiKit.Form.Serializers) {
93 var tagElements = form.getElementsByTagName(tagName);
94 for (var j = 0; j < tagElements.length; j++) {
95 elements.push(tagElements[j]);
96 }
97 }
98 return elements;
99 },
100
101 /** @id MochiKit.Form.serializeElement */
102 serializeElement: function (element) {
103 element = MochiKit.DOM.getElement(element);
104 var method = element.tagName.toLowerCase();
105 var parameter = MochiKit.Form.Serializers[method](element);
106
107 if (parameter) {
108 var key = encodeURIComponent(parameter[0]);
109 if (key.length === 0) {
110 return;
111 }
112
113 if (!(parameter[1] instanceof Array)) {
114 parameter[1] = [parameter[1]];
115 }
116
117 return parameter[1].map(function (value) {
118 return key + '=' + encodeURIComponent(value);
119 }).join('&');
120 }
121 }
122 };
123
124 MochiKit.Form.Serializers = {
125
126 /** @id MochiKit.Form.Serializers.input */
127 input: function (element) {
128 switch (element.type.toLowerCase()) {
129 case 'submit':
130 case 'hidden':
131 case 'password':
132 case 'text':
133 return MochiKit.Form.Serializers.textarea(element);
134 case 'checkbox':
135 case 'radio':
136 return MochiKit.Form.Serializers.inputSelector(element);
137 }
138 return false;
139 },
140
141 /** @id MochiKit.Form.Serializers.inputSelector */
142 inputSelector: function (element) {
143 if (element.checked) {
144 return [element.name, element.value];
145 }
146 },
147
148 /** @id MochiKit.Form.Serializers.textarea */
149 textarea: function (element) {
150 return [element.name, element.value];
151 },
152
153 /** @id MochiKit.Form.Serializers.select */
154 select: function (element) {
155 return MochiKit.Form.Serializers[element.type == 'select-one' ?
156 'selectOne' : 'selectMany'](element);
157 },
158
159 /** @id MochiKit.Form.Serializers.selectOne */
160 selectOne: function (element) {
161 var value = '', opt, index = element.selectedIndex;
162 if (index >= 0) {
163 opt = element.options[index];
164 value = opt.value;
165 if (!value && !('value' in opt)) {
166 value = opt.text;
167 }
168 }
169 return [element.name, value];
170 },
171
172 /** @id MochiKit.Form.Serializers.selectMany */
173 selectMany: function (element) {
174 var value = [];
175 for (var i = 0; i < element.length; i++) {
176 var opt = element.options[i];
177 if (opt.selected) {
178 var optValue = opt.value;
179 if (!optValue && !('value' in opt)) {
180 optValue = opt.text;
181 }
182 value.push(optValue);
183 }
184 }
185 return [element.name, value];
186 }
187 };
188
189 /** @id Ajax */
190 var Ajax = {
191 activeRequestCount: 0
192 };
193
194 Ajax.Responders = {
195 responders: [],
196
197 /** @id Ajax.Responders.register */
198 register: function (responderToAdd) {
199 if (MochiKit.Base.find(this.responders, responderToAdd) == -1) {
200 this.responders.push(responderToAdd);
201 }
202 },
203
204 /** @id Ajax.Responders.unregister */
205 unregister: function (responderToRemove) {
206 this.responders = this.responders.without(responderToRemove);
207 },
208
209 /** @id Ajax.Responders.dispatch */
210 dispatch: function (callback, request, transport, json) {
211 MochiKit.Iter.forEach(this.responders, function (responder) {
212 if (responder[callback] &&
213 typeof(responder[callback]) == 'function') {
214 try {
215 responder[callback].apply(responder, [request, transport, json]);
216 } catch (e) {}
217 }
218 });
219 }
220 };
221
222 Ajax.Responders.register({
223
224 /** @id Ajax.Responders.onCreate */
225 onCreate: function () {
226 Ajax.activeRequestCount++;
227 },
228
229 /** @id Ajax.Responders.onComplete */
230 onComplete: function () {
231 Ajax.activeRequestCount--;
232 }
233 });
234
235 /** @id Ajax.Base */
236 Ajax.Base = function () {};
237
238 Ajax.Base.prototype = {
239
240 /** @id Ajax.Base.prototype.setOptions */
241 setOptions: function (options) {
242 this.options = {
243 method: 'post',
244 asynchronous: true,
245 parameters: ''
246 }
247 MochiKit.Base.update(this.options, options || {});
248 },
249
250 /** @id Ajax.Base.prototype.responseIsSuccess */
251 responseIsSuccess: function () {
252 return this.transport.status == undefined
253 || this.transport.status === 0
254 || (this.transport.status >= 200 && this.transport.status < 300);
255 },
256
257 /** @id Ajax.Base.prototype.responseIsFailure */
258 responseIsFailure: function () {
259 return !this.responseIsSuccess();
260 }
261 };
262
263 /** @id Ajax.Request */
264 Ajax.Request = function (url, options) {
265 this.__init__(url, options);
266 };
267
268 /** @id Ajax.Events */
269 Ajax.Request.Events = ['Uninitialized', 'Loading', 'Loaded',
270 'Interactive', 'Complete'];
271
272 MochiKit.Base.update(Ajax.Request.prototype, Ajax.Base.prototype);
273
274 MochiKit.Base.update(Ajax.Request.prototype, {
275 __init__: function (url, options) {
276 this.transport = MochiKit.Async.getXMLHttpRequest();
277 this.setOptions(options);
278 this.request(url);
279 },
280
281 /** @id Ajax.Request.prototype.request */
282 request: function (url) {
283 var parameters = this.options.parameters || '';
284 if (parameters.length > 0){
285 parameters += '&_=';
286 }
287
288 try {
289 this.url = url;
290 if (this.options.method == 'get' && parameters.length > 0) {
291 this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;
292 }
293 Ajax.Responders.dispatch('onCreate', this, this.transport);
294
295 this.transport.open(this.options.method, this.url,
296 this.options.asynchronous);
297
298 if (this.options.asynchronous) {
299 this.transport.onreadystatechange = MochiKit.Base.bind(this.onStateChange, this);
300 setTimeout(MochiKit.Base.bind(function () {
301 this.respondToReadyState(1);
302 }, this), 10);
303 }
304
305 this.setRequestHeaders();
306
307 var body = this.options.postBody ? this.options.postBody : parameters;
308 this.transport.send(this.options.method == 'post' ? body : null);
309
310 } catch (e) {
311 this.dispatchException(e);
312 }
313 },
314
315 /** @id Ajax.Request.prototype.setRequestHeaders */
316 setRequestHeaders: function () {
317 var requestHeaders = ['X-Requested-With', 'XMLHttpRequest'];
318
319 if (this.options.method == 'post') {
320 requestHeaders.push('Content-type',
321 'application/x-www-form-urlencoded');
322
323 /* Force 'Connection: close' for Mozilla browsers to work around
324 * a bug where XMLHttpRequest sends an incorrect Content-length
325 * header. See Mozilla Bugzilla #246651.
326 */
327 if (this.transport.overrideMimeType) {
328 requestHeaders.push('Connection', 'close');
329 }
330 }
331
332 if (this.options.requestHeaders) {
333 requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
334 }
335
336 for (var i = 0; i < requestHeaders.length; i += 2) {
337 this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
338 }
339 },
340
341 /** @id Ajax.Request.prototype.onStateChange */
342 onStateChange: function () {
343 var readyState = this.transport.readyState;
344 if (readyState != 1) {
345 this.respondToReadyState(this.transport.readyState);
346 }
347 },
348
349 /** @id Ajax.Request.prototype.header */
350 header: function (name) {
351 try {
352 return this.transport.getResponseHeader(name);
353 } catch (e) {}
354 },
355
356 /** @id Ajax.Request.prototype.evalJSON */
357 evalJSON: function () {
358 try {
359 return eval(this.header('X-JSON'));
360 } catch (e) {}
361 },
362
363 /** @id Ajax.Request.prototype.evalResponse */
364 evalResponse: function () {
365 try {
366 return eval(this.transport.responseText);
367 } catch (e) {
368 this.dispatchException(e);
369 }
370 },
371
372 /** @id Ajax.Request.prototype.respondToReadyState */
373 respondToReadyState: function (readyState) {
374 var event = Ajax.Request.Events[readyState];
375 var transport = this.transport, json = this.evalJSON();
376
377 if (event == 'Complete') {
378 try {
379 (this.options['on' + this.transport.status]
380 || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
381 || MochiKit.Base.noop)(transport, json);
382 } catch (e) {
383 this.dispatchException(e);
384 }
385
386 if ((this.header('Content-type') || '').match(/^text\/javascript/i)) {
387 this.evalResponse();
388 }
389 }
390
391 try {
392 (this.options['on' + event] || MochiKit.Base.noop)(transport, json);
393 Ajax.Responders.dispatch('on' + event, this, transport, json);
394 } catch (e) {
395 this.dispatchException(e);
396 }
397
398 /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
399 if (event == 'Complete') {
400 this.transport.onreadystatechange = MochiKit.Base.noop;
401 }
402 },
403
404 /** @id Ajax.Request.prototype.dispatchException */
405 dispatchException: function (exception) {
406 (this.options.onException || MochiKit.Base.noop)(this, exception);
407 Ajax.Responders.dispatch('onException', this, exception);
408 }
409 });
410
411 /** @id Ajax.Updater */
412 Ajax.Updater = function (container, url, options) {
413 this.__init__(container, url, options);
414 };
415
416 MochiKit.Base.update(Ajax.Updater.prototype, Ajax.Request.prototype);
417
418 MochiKit.Base.update(Ajax.Updater.prototype, {
419 __init__: function (container, url, options) {
420 this.containers = {
421 success: container.success ? MochiKit.DOM.getElement(container.success) : MochiKit.DOM.getElement(container),
422 failure: container.failure ? MochiKit.DOM.getElement(container.failure) :
423 (container.success ? null : MochiKit.DOM.getElement(container))
424 }
425 this.transport = MochiKit.Async.getXMLHttpRequest();
426 this.setOptions(options);
427
428 var onComplete = this.options.onComplete || MochiKit.Base.noop;
429 this.options.onComplete = MochiKit.Base.bind(function (transport, object) {
430 this.updateContent();
431 onComplete(transport, object);
432 }, this);
433
434 this.request(url);
435 },
436
437 /** @id Ajax.Updater.prototype.updateContent */
438 updateContent: function () {
439 var receiver = this.responseIsSuccess() ?
440 this.containers.success : this.containers.failure;
441 var response = this.transport.responseText;
442
443 if (!this.options.evalScripts) {
444 response = MochiKit.Base.stripScripts(response);
445 }
446
447 if (receiver) {
448 if (this.options.insertion) {
449 new this.options.insertion(receiver, response);
450 } else {
451 MochiKit.DOM.getElement(receiver).innerHTML =
452 MochiKit.Base.stripScripts(response);
453 setTimeout(function () {
454 MochiKit.Base.evalScripts(response);
455 }, 10);
456 }
457 }
458
459 if (this.responseIsSuccess()) {
460 if (this.onComplete) {
461 setTimeout(MochiKit.Base.bind(this.onComplete, this), 10);
462 }
463 }
464 }
465 });
466
467 /** @id Field */
468 var Field = {
469
470 /** @id clear */
471 clear: function () {
472 for (var i = 0; i < arguments.length; i++) {
473 MochiKit.DOM.getElement(arguments[i]).value = '';
474 }
475 },
476
477 /** @id focus */
478 focus: function (element) {
479 MochiKit.DOM.getElement(element).focus();
480 },
481
482 /** @id present */
483 present: function () {
484 for (var i = 0; i < arguments.length; i++) {
485 if (MochiKit.DOM.getElement(arguments[i]).value == '') {
486 return false;
487 }
488 }
489 return true;
490 },
491
492 /** @id select */
493 select: function (element) {
494 MochiKit.DOM.getElement(element).select();
495 },
496
497 /** @id activate */
498 activate: function (element) {
499 element = MochiKit.DOM.getElement(element);
500 element.focus();
501 if (element.select) {
502 element.select();
503 }
504 },
505
506 /** @id scrollFreeActivate */
507 scrollFreeActivate: function (field) {
508 setTimeout(function () {
509 Field.activate(field);
510 }, 1);
511 }
512 };
513
514
515 /** @id Autocompleter */
516 var Autocompleter = {};
517
518 /** @id Autocompleter.Base */
519 Autocompleter.Base = function () {};
520
521 Autocompleter.Base.prototype = {
522
523 /** @id Autocompleter.Base.prototype.baseInitialize */
524 baseInitialize: function (element, update, options) {
525 this.element = MochiKit.DOM.getElement(element);
526 this.update = MochiKit.DOM.getElement(update);
527 this.hasFocus = false;
528 this.changed = false;
529 this.active = false;
530 this.index = 0;
531 this.entryCount = 0;
532
533 if (this.setOptions) {
534 this.setOptions(options);
535 }
536 else {
537 this.options = options || {};
538 }
539
540 this.options.paramName = this.options.paramName || this.element.name;
541 this.options.tokens = this.options.tokens || [];
542 this.options.frequency = this.options.frequency || 0.4;
543 this.options.minChars = this.options.minChars || 1;
544 this.options.onShow = this.options.onShow || function (element, update) {
545 if (!update.style.position || update.style.position == 'absolute') {
546 update.style.position = 'absolute';
547 MochiKit.Position.clone(element, update, {
548 setHeight: false,
549 offsetTop: element.offsetHeight
550 });
551 }
552 MochiKit.Visual.appear(update, {duration:0.15});
553 };
554 this.options.onHide = this.options.onHide || function (element, update) {
555 MochiKit.Visual.fade(update, {duration: 0.15});
556 };
557
558 if (typeof(this.options.tokens) == 'string') {
559 this.options.tokens = new Array(this.options.tokens);
560 }
561
562 this.observer = null;
563
564 this.element.setAttribute('autocomplete', 'off');
565
566 MochiKit.Style.hideElement(this.update);
567
568 MochiKit.Signal.connect(this.element, 'onblur', this, this.onBlur);
569 MochiKit.Signal.connect(this.element, 'onkeypress', this, this.onKeyPress, this);
570 },
571
572 /** @id Autocompleter.Base.prototype.show */
573 show: function () {
574 if (MochiKit.Style.getStyle(this.update, 'display') == 'none') {
575 this.options.onShow(this.element, this.update);
576 }
577 if (!this.iefix && /MSIE/.test(navigator.userAgent &&
578 (MochiKit.Style.getStyle(this.update, 'position') == 'absolute'))) {
579 new Insertion.After(this.update,
580 '<iframe id="' + this.update.id + '_iefix" '+
581 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
582 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
583 this.iefix = MochiKit.DOM.getElement(this.update.id + '_iefix');
584 }
585 if (this.iefix) {
586 setTimeout(MochiKit.Base.bind(this.fixIEOverlapping, this), 50);
587 }
588 },
589
590 /** @id Autocompleter.Base.prototype.fixIEOverlapping */
591 fixIEOverlapping: function () {
592 MochiKit.Position.clone(this.update, this.iefix);
593 this.iefix.style.zIndex = 1;
594 this.update.style.zIndex = 2;
595 MochiKit.Style.showElement(this.iefix);
596 },
597
598 /** @id Autocompleter.Base.prototype.hide */
599 hide: function () {
600 this.stopIndicator();
601 if (MochiKit.Style.getStyle(this.update, 'display') != 'none') {
602 this.options.onHide(this.element, this.update);
603 }
604 if (this.iefix) {
605 MochiKit.Style.hideElement(this.iefix);
606 }
607 },
608
609 /** @id Autocompleter.Base.prototype.startIndicator */
610 startIndicator: function () {
611 if (this.options.indicator) {
612 MochiKit.Style.showElement(this.options.indicator);
613 }
614 },
615
616 /** @id Autocompleter.Base.prototype.stopIndicator */
617 stopIndicator: function () {
618 if (this.options.indicator) {
619 MochiKit.Style.hideElement(this.options.indicator);
620 }
621 },
622
623 /** @id Autocompleter.Base.prototype.onKeyPress */
624 onKeyPress: function (event) {
625 if (this.active) {
626 if (event.key().string == "KEY_TAB" || event.key().string == "KEY_RETURN") {
627 this.selectEntry();
628 MochiKit.Event.stop(event);
629 } else if (event.key().string == "KEY_ESCAPE") {
630 this.hide();
631 this.active = false;
632 MochiKit.Event.stop(event);
633 return;
634 } else if (event.key().string == "KEY_LEFT" || event.key().string == "KEY_RIGHT") {
635 return;
636 } else if (event.key().string == "KEY_UP") {
637 this.markPrevious();
638 this.render();
639 if (/AppleWebKit'/.test(navigator.appVersion)) {
640 event.stop();
641 }
642 return;
643 } else if (event.key().string == "KEY_DOWN") {
644 this.markNext();
645 this.render();
646 if (/AppleWebKit'/.test(navigator.appVersion)) {
647 event.stop();
648 }
649 return;
650 }
651 } else {
652 if (event.key().string == "KEY_TAB" || event.key().string == "KEY_RETURN") {
653 return;
654 }
655 }
656
657 this.changed = true;
658 this.hasFocus = true;
659
660 if (this.observer) {
661 clearTimeout(this.observer);
662 }
663 this.observer = setTimeout(MochiKit.Base.bind(this.onObserverEvent, this),
664 this.options.frequency*1000);
665 },
666
667 /** @id Autocompleter.Base.prototype.findElement */
668 findElement: function (event, tagName) {
669 var element = event.target;
670 while (element.parentNode && (!element.tagName ||
671 (element.tagName.toUpperCase() != tagName.toUpperCase()))) {
672 element = element.parentNode;
673 }
674 return element;
675 },
676
677 /** @id Autocompleter.Base.prototype.hover */
678 onHover: function (event) {
679 var element = this.findElement(event, 'LI');
680 if (this.index != element.autocompleteIndex) {
681 this.index = element.autocompleteIndex;
682 this.render();
683 }
684 event.stop();
685 },
686
687 /** @id Autocompleter.Base.prototype.onClick */
688 onClick: function (event) {
689 var element = this.findElement(event, 'LI');
690 this.index = element.autocompleteIndex;
691 this.selectEntry();
692 this.hide();
693 },
694
695 /** @id Autocompleter.Base.prototype.onBlur */
696 onBlur: function (event) {
697 // needed to make click events working
698 setTimeout(MochiKit.Base.bind(this.hide, this), 250);
699 this.hasFocus = false;
700 this.active = false;
701 },
702
703 /** @id Autocompleter.Base.prototype.render */
704 render: function () {
705 if (this.entryCount > 0) {
706 for (var i = 0; i < this.entryCount; i++) {
707 this.index == i ?
708 MochiKit.DOM.addElementClass(this.getEntry(i), 'selected') :
709 MochiKit.DOM.removeElementClass(this.getEntry(i), 'selected');
710 }
711 if (this.hasFocus) {
712 this.show();
713 this.active = true;
714 }
715 } else {
716 this.active = false;
717 this.hide();
718 }
719 },
720
721 /** @id Autocompleter.Base.prototype.markPrevious */
722 markPrevious: function () {
723 if (this.index > 0) {
724 this.index--
725 } else {
726 this.index = this.entryCount-1;
727 }
728 },
729
730 /** @id Autocompleter.Base.prototype.markNext */
731 markNext: function () {
732 if (this.index < this.entryCount-1) {
733 this.index++
734 } else {
735 this.index = 0;
736 }
737 },
738
739 /** @id Autocompleter.Base.prototype.getEntry */
740 getEntry: function (index) {
741 return this.update.firstChild.childNodes[index];
742 },
743
744 /** @id Autocompleter.Base.prototype.getCurrentEntry */
745 getCurrentEntry: function () {
746 return this.getEntry(this.index);
747 },
748
749 /** @id Autocompleter.Base.prototype.selectEntry */
750 selectEntry: function () {
751 this.active = false;
752 this.updateElement(this.getCurrentEntry());
753 },
754
755 /** @id Autocompleter.Base.prototype.collectTextNodesIgnoreClass */
756 collectTextNodesIgnoreClass: function (element, className) {
757 return MochiKit.Base.flattenArray(MochiKit.Base.map(function (node) {
758 if (node.nodeType == 3) {
759 return node.nodeValue;
760 } else if (node.hasChildNodes() && !MochiKit.DOM.hasElementClass(node, className)) {
761 return this.collectTextNodesIgnoreClass(node, className);
762 }
763 return '';
764 }, MochiKit.DOM.getElement(element).childNodes)).join('');
765 },
766
767 /** @id Autocompleter.Base.prototype.updateElement */
768 updateElement: function (selectedElement) {
769 if (this.options.updateElement) {
770 this.options.updateElement(selectedElement);
771 return;
772 }
773 var value = '';
774 if (this.options.select) {
775 var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
776 if (nodes.length > 0) {
777 value = MochiKit.DOM.scrapeText(nodes[0]);
778 }
779 } else {
780 value = this.collectTextNodesIgnoreClass(selectedElement, 'informal');
781 }
782 var lastTokenPos = this.findLastToken();
783 if (lastTokenPos != -1) {
784 var newValue = this.element.value.substr(0, lastTokenPos + 1);
785 var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
786 if (whitespace) {
787 newValue += whitespace[0];
788 }
789 this.element.value = newValue + value;
790 } else {
791 this.element.value = value;
792 }
793 this.element.focus();
794
795 if (this.options.afterUpdateElement) {
796 this.options.afterUpdateElement(this.element, selectedElement);
797 }
798 },
799
800 /** @id Autocompleter.Base.prototype.updateChoices */
801 updateChoices: function (choices) {
802 if (!this.changed && this.hasFocus) {
803 this.update.innerHTML = choices;
804 var d = MochiKit.DOM;
805 d.removeEmptyTextNodes(this.update);
806 d.removeEmptyTextNodes(this.update.firstChild);
807
808 if (this.update.firstChild && this.update.firstChild.childNodes) {
809 this.entryCount = this.update.firstChild.childNodes.length;
810 for (var i = 0; i < this.entryCount; i++) {
811 var entry = this.getEntry(i);
812 entry.autocompleteIndex = i;
813 this.addObservers(entry);
814 }
815 } else {
816 this.entryCount = 0;
817 }
818
819 this.stopIndicator();
820
821 this.index = 0;
822 this.render();
823 }
824 },
825
826 /** @id Autocompleter.Base.prototype.addObservers */
827 addObservers: function (element) {
828 MochiKit.Signal.connect(element, 'onmouseover', this, this.onHover);
829 MochiKit.Signal.connect(element, 'onclick', this, this.onClick);
830 },
831
832 /** @id Autocompleter.Base.prototype.onObserverEvent */
833 onObserverEvent: function () {
834 this.changed = false;
835 if (this.getToken().length >= this.options.minChars) {
836 this.startIndicator();
837 this.getUpdatedChoices();
838 } else {
839 this.active = false;
840 this.hide();
841 }
842 },
843
844 /** @id Autocompleter.Base.prototype.getToken */
845 getToken: function () {
846 var tokenPos = this.findLastToken();
847 if (tokenPos != -1) {
848 var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
849 } else {
850 var ret = this.element.value;
851 }
852 return /\n/.test(ret) ? '' : ret;
853 },
854
855 /** @id Autocompleter.Base.prototype.findLastToken */
856 findLastToken: function () {
857 var lastTokenPos = -1;
858
859 for (var i = 0; i < this.options.tokens.length; i++) {
860 var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
861 if (thisTokenPos > lastTokenPos) {
862 lastTokenPos = thisTokenPos;
863 }
864 }
865 return lastTokenPos;
866 }
867 }
868
869 /** @id Ajax.Autocompleter */
870 Ajax.Autocompleter = function (element, update, url, options) {
871 this.__init__(element, update, url, options);
872 };
873
874 MochiKit.Base.update(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype);
875
876 MochiKit.Base.update(Ajax.Autocompleter.prototype, {
877 __init__: function (element, update, url, options) {
878 this.baseInitialize(element, update, options);
879 this.options.asynchronous = true;
880 this.options.onComplete = MochiKit.Base.bind(this.onComplete, this);
881 this.options.defaultParams = this.options.parameters || null;
882 this.url = url;
883 },
884
885 /** @id Ajax.Autocompleter.prototype.getUpdatedChoices */
886 getUpdatedChoices: function () {
887 var entry = encodeURIComponent(this.options.paramName) + '=' +
888 encodeURIComponent(this.getToken());
889
890 this.options.parameters = this.options.callback ?
891 this.options.callback(this.element, entry) : entry;
892
893 if (this.options.defaultParams) {
894 this.options.parameters += '&' + this.options.defaultParams;
895 }
896 new Ajax.Request(this.url, this.options);
897 },
898
899 /** @id Ajax.Autocompleter.prototype.onComplete */
900 onComplete: function (request) {
901 this.updateChoices(request.responseText);
902 }
903 });
904
905 /***
906
907 The local array autocompleter. Used when you'd prefer to
908 inject an array of autocompletion options into the page, rather
909 than sending out Ajax queries, which can be quite slow sometimes.
910
911 The constructor takes four parameters. The first two are, as usual,
912 the id of the monitored textbox, and id of the autocompletion menu.
913 The third is the array you want to autocomplete from, and the fourth
914 is the options block.
915
916 Extra local autocompletion options:
917 - choices - How many autocompletion choices to offer
918
919 - partialSearch - If false, the autocompleter will match entered
920 text only at the beginning of strings in the
921 autocomplete array. Defaults to true, which will
922 match text at the beginning of any *word* in the
923 strings in the autocomplete array. If you want to
924 search anywhere in the string, additionally set
925 the option fullSearch to true (default: off).
926
927 - fullSsearch - Search anywhere in autocomplete array strings.
928
929 - partialChars - How many characters to enter before triggering
930 a partial match (unlike minChars, which defines
931 how many characters are required to do any match
932 at all). Defaults to 2.
933
934 - ignoreCase - Whether to ignore case when autocompleting.
935 Defaults to true.
936
937 It's possible to pass in a custom function as the 'selector'
938 option, if you prefer to write your own autocompletion logic.
939 In that case, the other options above will not apply unless
940 you support them.
941
942 ***/
943
944 /** @id Autocompleter.Local */
945 Autocompleter.Local = function (element, update, array, options) {
946 this.__init__(element, update, array, options);
947 };
948
949 MochiKit.Base.update(Autocompleter.Local.prototype, Autocompleter.Base.prototype);
950
951 MochiKit.Base.update(Autocompleter.Local.prototype, {
952 __init__: function (element, update, array, options) {
953 this.baseInitialize(element, update, options);
954 this.options.array = array;
955 },
956
957 /** @id Autocompleter.Local.prototype.getUpdatedChoices */
958 getUpdatedChoices: function () {
959 this.updateChoices(this.options.selector(this));
960 },
961
962 /** @id Autocompleter.Local.prototype.setOptions */
963 setOptions: function (options) {
964 this.options = MochiKit.Base.update({
965 choices: 10,
966 partialSearch: true,
967 partialChars: 2,
968 ignoreCase: true,
969 fullSearch: false,
970 selector: function (instance) {
971 var ret = []; // Beginning matches
972 var partial = []; // Inside matches
973 var entry = instance.getToken();
974 var count = 0;
975
976 for (var i = 0; i < instance.options.array.length &&
977 ret.length < instance.options.choices ; i++) {
978
979 var elem = instance.options.array[i];
980 var foundPos = instance.options.ignoreCase ?
981 elem.toLowerCase().indexOf(entry.toLowerCase()) :
982 elem.indexOf(entry);
983
984 while (foundPos != -1) {
985 if (foundPos === 0 && elem.length != entry.length) {
986 ret.push('<li><strong>' + elem.substr(0, entry.length) + '</strong>' +
987 elem.substr(entry.length) + '</li>');
988 break;
989 } else if (entry.length >= instance.options.partialChars &&
990 instance.options.partialSearch && foundPos != -1) {
991 if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos - 1, 1))) {
992 partial.push('<li>' + elem.substr(0, foundPos) + '<strong>' +
993 elem.substr(foundPos, entry.length) + '</strong>' + elem.substr(
994 foundPos + entry.length) + '</li>');
995 break;
996 }
997 }
998
999 foundPos = instance.options.ignoreCase ?
1000 elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
1001 elem.indexOf(entry, foundPos + 1);
1002
1003 }
1004 }
1005 if (partial.length) {
1006 ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
1007 }
1008 return '<ul>' + ret.join('') + '</ul>';
1009 }
1010 }, options || {});
1011 }
1012 });
1013
1014 /***
1015
1016 AJAX in-place editor
1017
1018 see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor
1019
1020 Use this if you notice weird scrolling problems on some browsers,
1021 the DOM might be a bit confused when this gets called so do this
1022 waits 1 ms (with setTimeout) until it does the activation
1023
1024 ***/
1025
1026 /** @id Ajax.InPlaceEditor */
1027 Ajax.InPlaceEditor = function (element, url, options) {
1028 this.__init__(element, url, options);
1029 };
1030
1031 /** @id Ajax.InPlaceEditor.defaultHighlightColor */
1032 Ajax.InPlaceEditor.defaultHighlightColor = '#FFFF99';
1033
1034 Ajax.InPlaceEditor.prototype = {
1035 __init__: function (element, url, options) {
1036 this.url = url;
1037 this.element = MochiKit.DOM.getElement(element);
1038
1039 this.options = MochiKit.Base.update({
1040 okButton: true,
1041 okText: 'ok',
1042 cancelLink: true,
1043 cancelText: 'cancel',
1044 savingText: 'Saving...',
1045 clickToEditText: 'Click to edit',
1046 okText: 'ok',
1047 rows: 1,
1048 onComplete: function (transport, element) {
1049 new MochiKit.Visual.Highlight(element, {startcolor: this.options.highlightcolor});
1050 },
1051 onFailure: function (transport) {
1052 alert('Error communicating with the server: ' + MochiKit.Base.stripTags(transport.responseText));
1053 },
1054 callback: function (form) {
1055 return MochiKit.DOM.formContents(form);
1056 },
1057 handleLineBreaks: true,
1058 loadingText: 'Loading...',
1059 savingClassName: 'inplaceeditor-saving',
1060 loadingClassName: 'inplaceeditor-loading',
1061 formClassName: 'inplaceeditor-form',
1062 highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
1063 highlightendcolor: '#FFFFFF',
1064 externalControl: null,
1065 submitOnBlur: false,
1066 ajaxOptions: {}
1067 }, options || {});
1068
1069 if (!this.options.formId && this.element.id) {
1070 this.options.formId = this.element.id + '-inplaceeditor';
1071 if (MochiKit.DOM.getElement(this.options.formId)) {
1072 // there's already a form with that name, don't specify an id
1073 this.options.formId = null;
1074 }
1075 }
1076
1077 if (this.options.externalControl) {
1078 this.options.externalControl = MochiKit.DOM.getElement(this.options.externalControl);
1079 }
1080
1081 this.originalBackground = MochiKit.Style.getStyle(this.element, 'background-color');
1082 if (!this.originalBackground) {
1083 this.originalBackground = 'transparent';
1084 }
1085
1086 this.element.title = this.options.clickToEditText;
1087
1088 this.onclickListener = MochiKit.Signal.connect(this.element, 'onclick', this, this.enterEditMode);
1089 this.mouseoverListener = MochiKit.Signal.connect(this.element, 'onmouseover', this, this.enterHover);
1090 this.mouseoutListener = MochiKit.Signal.connect(this.element, 'onmouseout', this, this.leaveHover);
1091 if (this.options.externalControl) {
1092 this.onclickListenerExternal = MochiKit.Signal.connect(this.options.externalControl,
1093 'onclick', this, this.enterEditMode);
1094 this.mouseoverListenerExternal = MochiKit.Signal.connect(this.options.externalControl,
1095 'onmouseover', this, this.enterHover);
1096 this.mouseoutListenerExternal = MochiKit.Signal.connect(this.options.externalControl,
1097 'onmouseout', this, this.leaveHover);
1098 }
1099 },
1100
1101 /** @id Ajax.InPlaceEditor.prototype.enterEditMode */
1102 enterEditMode: function (evt) {
1103 if (this.saving) {
1104 return;
1105 }
1106 if (this.editing) {
1107 return;
1108 }
1109 this.editing = true;
1110 this.onEnterEditMode();
1111 if (this.options.externalControl) {
1112 MochiKit.Style.hideElement(this.options.externalControl);
1113 }
1114 MochiKit.Style.hideElement(this.element);
1115 this.createForm();
1116 this.element.parentNode.insertBefore(this.form, this.element);
1117 Field.scrollFreeActivate(this.editField);
1118 // stop the event to avoid a page refresh in Safari
1119 if (evt) {
1120 evt.stop();
1121 }
1122 return false;
1123 },
1124
1125 /** @id Ajax.InPlaceEditor.prototype.createForm */
1126 createForm: function () {
1127 this.form = document.createElement('form');
1128 this.form.id = this.options.formId;
1129 MochiKit.DOM.addElementClass(this.form, this.options.formClassName)
1130 this.form.onsubmit = MochiKit.Base.bind(this.onSubmit, this);
1131
1132 this.createEditField();
1133
1134 if (this.options.textarea) {
1135 var br = document.createElement('br');
1136 this.form.appendChild(br);
1137 }
1138
1139 if (this.options.okButton) {
1140 okButton = document.createElement('input');
1141 okButton.type = 'submit';
1142 okButton.value = this.options.okText;
1143 this.form.appendChild(okButton);
1144 }
1145
1146 if (this.options.cancelLink) {
1147 cancelLink = document.createElement('a');
1148 cancelLink.href = '#';
1149 cancelLink.appendChild(document.createTextNode(this.options.cancelText));
1150 cancelLink.onclick = MochiKit.Base.bind(this.onclickCancel, this);
1151 this.form.appendChild(cancelLink);
1152 }
1153 },
1154
1155 /** @id Ajax.InPlaceEditor.prototype.hasHTMLLineBreaks */
1156 hasHTMLLineBreaks: function (string) {
1157 if (!this.options.handleLineBreaks) {
1158 return false;
1159 }
1160 return string.match(/<br/i) || string.match(/<p>/i);
1161 },
1162
1163 /** @id Ajax.InPlaceEditor.prototype.convertHTMLLineBreaks */
1164 convertHTMLLineBreaks: function (string) {
1165 return string.replace(/<br>/gi, '\n').replace(/<br\/>/gi, '\n').replace(/<\/p>/gi, '\n').replace(/<p>/gi, '');
1166 },
1167
1168 /** @id Ajax.InPlaceEditor.prototype.createEditField */
1169 createEditField: function () {
1170 var text;
1171 if (this.options.loadTextURL) {
1172 text = this.options.loadingText;
1173 } else {
1174 text = this.getText();
1175 }
1176
1177 var obj = this;
1178
1179 if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
1180 this.options.textarea = false;
1181 var textField = document.createElement('input');
1182 textField.obj = this;
1183 textField.type = 'text';
1184 textField.name = 'value';
1185 textField.value = text;
1186 textField.style.backgroundColor = this.options.highlightcolor;
1187 var size = this.options.size || this.options.cols || 0;
1188 if (size !== 0) {
1189 textField.size = size;
1190 }
1191 if (this.options.submitOnBlur) {
1192 textField.onblur = MochiKit.Base.bind(this.onSubmit, this);
1193 }
1194 this.editField = textField;
1195 } else {
1196 this.options.textarea = true;
1197 var textArea = document.createElement('textarea');
1198 textArea.obj = this;
1199 textArea.name = 'value';
1200 textArea.value = this.convertHTMLLineBreaks(text);
1201 textArea.rows = this.options.rows;
1202 textArea.cols = this.options.cols || 40;
1203 if (this.options.submitOnBlur) {
1204 textArea.onblur = MochiKit.Base.bind(this.onSubmit, this);
1205 }
1206 this.editField = textArea;
1207 }
1208
1209 if (this.options.loadTextURL) {
1210 this.loadExternalText();
1211 }
1212 this.form.appendChild(this.editField);
1213 },
1214
1215 /** @id Ajax.InPlaceEditor.prototype.getText */
1216 getText: function () {
1217 return this.element.innerHTML;
1218 },
1219
1220 /** @id Ajax.InPlaceEditor.prototype.loadExternalText */
1221 loadExternalText: function () {
1222 MochiKit.DOM.addElementClass(this.form, this.options.loadingClassName);
1223 this.editField.disabled = true;
1224 new Ajax.Request(
1225 this.options.loadTextURL,
1226 MochiKit.Base.update({
1227 asynchronous: true,
1228 onComplete: MochiKit.Base.bind(this.onLoadedExternalText, this)
1229 }, this.options.ajaxOptions)
1230 );
1231 },
1232
1233 /** @id Ajax.InPlaceEditor.prototype.onLoadedExternalText */
1234 onLoadedExternalText: function (transport) {
1235 MochiKit.DOM.removeElementClass(this.form, this.options.loadingClassName);
1236 this.editField.disabled = false;
1237 this.editField.value = MochiKit.Base.stripTags(transport);
1238 },
1239
1240 /** @id Ajax.InPlaceEditor.prototype.onclickCancel */
1241 onclickCancel: function () {
1242 this.onComplete();
1243 this.leaveEditMode();
1244 return false;
1245 },
1246
1247 /** @id Ajax.InPlaceEditor.prototype.onFailure */
1248 onFailure: function (transport) {
1249 this.options.onFailure(transport);
1250 if (this.oldInnerHTML) {
1251 this.element.innerHTML = this.oldInnerHTML;
1252 this.oldInnerHTML = null;
1253 }
1254 return false;
1255 },
1256
1257 /** @id Ajax.InPlaceEditor.prototype.onSubmit */
1258 onSubmit: function () {
1259 // onLoading resets these so we need to save them away for the Ajax call
1260 var form = this.form;
1261 var value = this.editField.value;
1262
1263 // do this first, sometimes the ajax call returns before we get a
1264 // chance to switch on Saving which means this will actually switch on
1265 // Saving *after* we have left edit mode causing Saving to be
1266 // displayed indefinitely
1267 this.onLoading();
1268
1269 new Ajax.Updater(
1270 {
1271 success: this.element,
1272 // dont update on failure (this could be an option)
1273 failure: null
1274 },
1275 this.url,
1276 MochiKit.Base.update({
1277 parameters: this.options.callback(form, value),
1278 onComplete: MochiKit.Base.bind(this.onComplete, this),
1279 onFailure: MochiKit.Base.bind(this.onFailure, this)
1280 }, this.options.ajaxOptions)
1281 );
1282 // stop the event to avoid a page refresh in Safari
1283 if (arguments.length > 1) {
1284 arguments[0].stop();
1285 }
1286 return false;
1287 },
1288
1289 /** @id Ajax.InPlaceEditor.prototype.onLoading */
1290 onLoading: function () {
1291 this.saving = true;
1292 this.removeForm();
1293 this.leaveHover();
1294 this.showSaving();
1295 },
1296
1297 /** @id Ajax.InPlaceEditor.prototype.onSaving */
1298 showSaving: function () {
1299 this.oldInnerHTML = this.element.innerHTML;
1300 this.element.innerHTML = this.options.savingText;
1301 MochiKit.DOM.addElementClass(this.element, this.options.savingClassName);
1302 this.element.style.backgroundColor = this.originalBackground;
1303 MochiKit.Style.showElement(this.element);
1304 },
1305
1306 /** @id Ajax.InPlaceEditor.prototype.removeForm */
1307 removeForm: function () {
1308 if (this.form) {
1309 if (this.form.parentNode) {
1310 MochiKit.DOM.removeElement(this.form);
1311 }
1312 this.form = null;
1313 }
1314 },
1315
1316 /** @id Ajax.InPlaceEditor.prototype.enterHover */
1317 enterHover: function () {
1318 if (this.saving) {
1319 return;
1320 }
1321 this.element.style.backgroundColor = this.options.highlightcolor;
1322 if (this.effect) {
1323 this.effect.cancel();
1324 }
1325 MochiKit.DOM.addElementClass(this.element, this.options.hoverClassName)
1326 },
1327
1328 /** @id Ajax.InPlaceEditor.prototype.leaveHover */
1329 leaveHover: function () {
1330 if (this.options.backgroundColor) {
1331 this.element.style.backgroundColor = this.oldBackground;
1332 }
1333 MochiKit.DOM.removeElementClass(this.element, this.options.hoverClassName)
1334 if (this.saving) {
1335 return;
1336 }
1337 this.effect = new MochiKit.Visual.Highlight(this.element, {
1338 startcolor: this.options.highlightcolor,
1339 endcolor: this.options.highlightendcolor,
1340 restorecolor: this.originalBackground
1341 });
1342 },
1343
1344 /** @id Ajax.InPlaceEditor.prototype.leaveEditMode */
1345 leaveEditMode: function () {
1346 MochiKit.DOM.removeElementClass(this.element, this.options.savingClassName);
1347 this.removeForm();
1348 this.leaveHover();
1349 this.element.style.backgroundColor = this.originalBackground;
1350 MochiKit.Style.showElement(this.element);
1351 if (this.options.externalControl) {
1352 MochiKit.Style.showElement(this.options.externalControl);
1353 }
1354 this.editing = false;
1355 this.saving = false;
1356 this.oldInnerHTML = null;
1357 this.onLeaveEditMode();
1358 },
1359
1360 /** @id Ajax.InPlaceEditor.prototype.onComplete */
1361 onComplete: function (transport) {
1362 this.leaveEditMode();
1363 MochiKit.Base.bind(this.options.onComplete, this)(transport, this.element);
1364 },
1365
1366 /** @id Ajax.InPlaceEditor.prototype.onEnterEditMode */
1367 onEnterEditMode: function () {},
1368
1369 /** @id Ajax.InPlaceEditor.prototype.onLeaveEditMode */
1370 onLeaveEditMode: function () {},
1371
1372 /** @id Ajax.InPlaceEditor.prototype.dispose */
1373 dispose: function () {
1374 if (this.oldInnerHTML) {
1375 this.element.innerHTML = this.oldInnerHTML;
1376 }
1377 this.leaveEditMode();
1378 MochiKit.Signal.disconnect(this.onclickListener);
1379 MochiKit.Signal.disconnect(this.mouseoverListener);
1380 MochiKit.Signal.disconnect(this.mouseoutListener);
1381 if (this.options.externalControl) {
1382 MochiKit.Signal.disconnect(this.onclickListenerExternal);
1383 MochiKit.Signal.disconnect(this.mouseoverListenerExternal);
1384 MochiKit.Signal.disconnect(this.mouseoutListenerExternal);
1385 }
1386 }
1387 };
1388

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial