Annotation of kupuMPIWG/common/kupuhelpers.js, revision 1.1.1.1
1.1 dwinter 1: /*****************************************************************************
2: *
3: * Copyright (c) 2003-2005 Kupu Contributors. All rights reserved.
4: *
5: * This software is distributed under the terms of the Kupu
6: * License. See LICENSE.txt for license text. For a list of Kupu
7: * Contributors see CREDITS.txt.
8: *
9: *****************************************************************************/
10:
11: // $Id: kupuhelpers.js 12353 2005-05-16 12:29:05Z duncan $
12:
13: /*
14:
15: Some notes about the scripts:
16:
17: - Problem with bound event handlers:
18:
19: When a method on an object is used as an event handler, the method uses
20: its reference to the object it is defined on. The 'this' keyword no longer
21: points to the class, but instead refers to the element on which the event
22: is bound. To overcome this problem, you can wrap the method in a class that
23: holds a reference to the object and have a method on the wrapper that calls
24: the input method in the input object's context. This wrapped method can be
25: used as the event handler. An example:
26:
27: class Foo() {
28: this.foo = function() {
29: // the method used as an event handler
30: // using this here wouldn't work if the method
31: // was passed to addEventListener directly
32: this.baz();
33: };
34: this.baz = function() {
35: // some method on the same object
36: };
37: };
38:
39: f = new Foo();
40:
41: // create the wrapper for the function, args are func, context
42: wrapper = new ContextFixer(f.foo, f);
43:
44: // the wrapper can be passed to addEventListener, 'this' in the method
45: // will be pointing to the right context.
46: some_element.addEventListener("click", wrapper.execute, false);
47:
48: - Problem with window.setTimeout:
49:
50: The window.setTimeout function has a couple of problems in usage, all
51: caused by the fact that it expects a *string* argument that will be
52: evalled in the global namespace rather than a function reference with
53: plain variables as arguments. This makes that the methods on 'this' can
54: not be called (the 'this' variable doesn't exist in the global namespace)
55: and references to variables in the argument list aren't allowed (since
56: they don't exist in the global namespace). To overcome these problems,
57: there's now a singleton instance of a class called Timer, which has one
58: public method called registerFunction. This can be called with a function
59: reference and a variable number of extra arguments to pass on to the
60: function.
61:
62: Usage:
63:
64: timer_instance.registerFunction(this, this.myFunc, 10, 'foo', bar);
65:
66: will call this.myFunc('foo', bar); in 10 milliseconds (with 'this'
67: as its context).
68:
69: */
70:
71: //----------------------------------------------------------------------------
72: // Helper classes and functions
73: //----------------------------------------------------------------------------
74:
75: function addEventHandler(element, event, method, context) {
76: /* method to add an event handler for both IE and Mozilla */
77: var wrappedmethod = new ContextFixer(method, context);
78: var args = new Array(null, null);
79: for (var i=4; i < arguments.length; i++) {
80: args.push(arguments[i]);
81: };
82: wrappedmethod.args = args;
83: try {
84: if (_SARISSA_IS_MOZ) {
85: element.addEventListener(event, wrappedmethod.execute, false);
86: } else if (_SARISSA_IS_IE) {
87: element.attachEvent("on" + event, wrappedmethod.execute);
88: } else {
89: throw _("Unsupported browser!");
90: };
91: return wrappedmethod.execute;
92: } catch(e) {
93: alert(_('exception ${message} while registering an event handler ' +
94: 'for element ${element}, event ${event}, method ${method}',
95: {'message': e.message, 'element': element,
96: 'event': event,
97: 'method': method}));
98: };
99: };
100:
101: function removeEventHandler(element, event, method) {
102: /* method to remove an event handler for both IE and Mozilla */
103: if (_SARISSA_IS_MOZ) {
104: window.removeEventListener(event, method, false);
105: } else if (_SARISSA_IS_IE) {
106: element.detachEvent("on" + event, method);
107: } else {
108: throw _("Unsupported browser!");
109: };
110: };
111:
112: /* Replacement for window.document.getElementById()
113: * selector can be an Id (so we maintain backwards compatability)
114: * but is intended to be a subset of valid CSS selectors.
115: * For now we only support the format: "#id tag.class"
116: */
117: function getFromSelector(selector) {
118: var match = /#(\S+)\s*([^ .]+)\.(\S+)/.exec(selector);
119: if (!match) {
120: return window.document.getElementById(selector);
121: }
122: var id=match[1], tag=match[2], className=match[3];
123: var base = window.document.getElementById(id);
124: return getBaseTagClass(base, tag, className);
125: }
126:
127: function getBaseTagClass(base, tag, className) {
128: var classPat = new RegExp('\\b'+className+'\\b');
129:
130: var nodes = base.getElementsByTagName(tag);
131: for (var i = 0; i < nodes.length; i++) {
132: if (classPat.test(nodes[i].className)) {
133: return nodes[i];
134: }
135: }
136: return null;
137: }
138:
139: function openPopup(url, width, height) {
140: /* open and center a popup window */
141: var sw = screen.width;
142: var sh = screen.height;
143: var left = sw / 2 - width / 2;
144: var top = sh / 2 - height / 2;
145: var win = window.open(url, 'someWindow',
146: 'width=' + width + ',height=' + height + ',left=' + left + ',top=' + top);
147: return win;
148: };
149:
150: function selectSelectItem(select, item) {
151: /* select a certain item from a select */
152: for (var i=0; i < select.options.length; i++) {
153: var option = select.options[i];
154: if (option.value == item) {
155: select.selectedIndex = i;
156: return;
157: }
158: }
159: select.selectedIndex = 0;
160: };
161:
162: function ParentWithStyleChecker(tagnames, style, stylevalue, command) {
163: /* small wrapper that provides a generic function to check if a
164: button should look pressed in */
165: return function(selNode, button, editor, event) {
166: /* check if the button needs to look pressed in */
167: if (command) {
168: var result = editor.getInnerDocument().queryCommandState(command)
169: if (result || editor.getSelection().getContentLength() == 0) {
170: return result;
171: };
172: };
173: var currnode = selNode;
174: while (currnode && currnode.style) {
175: for (var i=0; i < tagnames.length; i++) {
176: if (currnode.nodeName.toLowerCase() == tagnames[i].toLowerCase()) {
177: return true;
178: };
179: };
180: if (style && currnode.style[style] == stylevalue) {
181: return true;
182: };
183: currnode = currnode.parentNode;
184: };
185: return false;
186: };
187: };
188:
189: function _load_dict_helper(element) {
190: /* walks through a set of XML nodes and builds a nested tree of objects */
191: var dict = {};
192: for (var i=0; i < element.childNodes.length; i++) {
193: var child = element.childNodes[i];
194: if (child.nodeType == 1) {
195: var value = '';
196: for (var j=0; j < child.childNodes.length; j++) {
197: // test if we can recurse, if so ditch the string (probably
198: // ignorable whitespace) and dive into the node
199: if (child.childNodes[j].nodeType == 1) {
200: value = _load_dict_helper(child);
201: break;
202: } else if (typeof(value) == typeof('')) {
203: value += child.childNodes[j].nodeValue;
204: };
205: };
206: if (typeof(value) == typeof('') && !isNaN(parseInt(value)) &&
207: parseInt(value).toString().length == value.length) {
208: value = parseInt(value);
209: } else if (typeof(value) != typeof('')) {
210: if (value.length == 1) {
211: value = value[0];
212: };
213: };
214: var name = child.nodeName.toLowerCase();
215: if (dict[name] != undefined) {
216: if (!dict[name].push) {
217: dict[name] = new Array(dict[name], value);
218: } else {
219: dict[name].push(value);
220: };
221: } else {
222: dict[name] = value;
223: };
224: };
225: };
226: return dict;
227: };
228:
229: function loadDictFromXML(document, islandid) {
230: /* load configuration values from an XML chunk
231:
232: this is quite generic, it just reads data from a chunk of XML into
233: an object, checking if the object is complete should be done in the
234: calling context.
235: */
236: var dict = {};
237: var confnode = getFromSelector(islandid);
238: var root = null;
239: for (var i=0; i < confnode.childNodes.length; i++) {
240: if (confnode.childNodes[i].nodeType == 1) {
241: root = confnode.childNodes[i];
242: break;
243: };
244: };
245: if (!root) {
246: throw(_('No element found in the config island!'));
247: };
248: dict = _load_dict_helper(root);
249: return dict;
250: };
251:
252: function NodeIterator(node, continueatnextsibling) {
253: /* simple node iterator
254:
255: can be used to recursively walk through all children of a node,
256: the next() method will return the next node until either the next
257: sibling of the startnode is reached (when continueatnextsibling is
258: false, the default) or when there's no node left (when
259: continueatnextsibling is true)
260:
261: returns false if no nodes are left
262: */
263: this.node = node;
264: this.current = node;
265: this.terminator = continueatnextsibling ? null : node;
266:
267: this.next = function() {
268: /* return the next node */
269: if (this.current === false) {
270: // restart
271: this.current = this.node;
272: };
273: var current = this.current;
274: if (current.firstChild) {
275: this.current = current.firstChild;
276: } else {
277: // walk up parents until we finish or find one with a nextSibling
278: while (current != this.terminator && !current.nextSibling) {
279: current = current.parentNode;
280: };
281: if (current == this.terminator) {
282: this.current = false;
283: } else {
284: this.current = current.nextSibling;
285: };
286: };
287: return this.current;
288: };
289:
290: this.reset = function() {
291: /* reset the iterator so it starts at the first node */
292: this.current = this.node;
293: };
294:
295: this.setCurrent = function(node) {
296: /* change the current node
297:
298: can be really useful for specific hacks, the user must take
299: care that the node is inside the iterator's scope or it will
300: go wild
301: */
302: this.current = node;
303: };
304: };
305:
306: /* selection classes, these are wrappers around the browser-specific
307: selection objects to provide a generic abstraction layer
308: */
309: function BaseSelection() {
310: /* superclass for the Selection objects
311:
312: this will contain higher level methods that don't contain
313: browser-specific code
314: */
315: this.splitNodeAtSelection = function(node) {
316: /* split the node at the current selection
317:
318: remove any selected text, then split the node on the location
319: of the selection, thus creating a new node, this is attached to
320: the node's parent after the node
321:
322: this will fail if the selection is not inside the node
323: */
324: if (!this.selectionInsideNode(node)) {
325: throw(_('Selection not inside the node!'));
326: };
327: // a bit sneaky: what we'll do is insert a new br node to replace
328: // the current selection, then we'll walk up to that node in both
329: // the original and the cloned node, in the original we'll remove
330: // the br node and everything that's behind it, on the cloned one
331: // we'll remove the br and everything before it
332: // anyway, we'll end up with 2 nodes, the first already in the
333: // document (the original node) and the second we can just attach
334: // to the doc after the first one
335: var doc = this.document.getDocument();
336: var br = doc.createElement('br');
337: br.setAttribute('node_splitter', 'indeed');
338: this.replaceWithNode(br);
339:
340: var clone = node.cloneNode(true);
341:
342: // now walk through the original node
343: var iterator = new NodeIterator(node);
344: var currnode = iterator.next();
345: var remove = false;
346: while (currnode) {
347: if (currnode.nodeName.toLowerCase() == 'br' && currnode.getAttribute('node_splitter') == 'indeed') {
348: // here's the point where we should start removing
349: remove = true;
350: };
351: // we should fetch the next node before we remove the current one, else the iterator
352: // will fail (since the current node is removed)
353: var lastnode = currnode;
354: currnode = iterator.next();
355: // XXX this will leave nodes that *became* empty in place, since it doesn't visit it again,
356: // perhaps we should do a second pass that removes the rest(?)
357: if (remove && (lastnode.nodeType == 3 || !lastnode.hasChildNodes())) {
358: lastnode.parentNode.removeChild(lastnode);
359: };
360: };
361:
362: // and through the clone
363: var iterator = new NodeIterator(clone);
364: var currnode = iterator.next();
365: var remove = true;
366: while (currnode) {
367: var lastnode = currnode;
368: currnode = iterator.next();
369: if (lastnode.nodeName.toLowerCase() == 'br' && lastnode.getAttribute('node_splitter') == 'indeed') {
370: // here's the point where we should stop removing
371: lastnode.parentNode.removeChild(lastnode);
372: remove = false;
373: };
374: if (remove && (lastnode.nodeType == 3 || !lastnode.hasChildNodes())) {
375: lastnode.parentNode.removeChild(lastnode);
376: };
377: };
378:
379: // next we need to attach the node to the document
380: if (node.nextSibling) {
381: node.parentNode.insertBefore(clone, node.nextSibling);
382: } else {
383: node.parentNode.appendChild(clone);
384: };
385:
386: // this will change the selection, so reselect
387: this.reset();
388:
389: // return a reference to the clone
390: return clone;
391: };
392:
393: this.selectionInsideNode = function(node) {
394: /* returns a Boolean to indicate if the selection is resided
395: inside the node
396: */
397: var currnode = this.parentElement();
398: while (currnode) {
399: if (currnode == node) {
400: return true;
401: };
402: currnode = currnode.parentNode;
403: };
404: return false;
405: };
406: };
407:
408: function MozillaSelection(document) {
409: this.document = document;
410: this.selection = document.getWindow().getSelection();
411:
412: this.selectNodeContents = function(node) {
413: /* select the contents of a node */
414: this.selection.removeAllRanges();
415: this.selection.selectAllChildren(node);
416: };
417:
418: this.collapse = function(collapseToEnd) {
419: try {
420: if (!collapseToEnd) {
421: this.selection.collapseToStart();
422: } else {
423: this.selection.collapseToEnd();
424: };
425: } catch(e) {};
426: };
427:
428: this.replaceWithNode = function(node, selectAfterPlace) {
429: // XXX this should be on a range object
430: /* replaces the current selection with a new node
431: returns a reference to the inserted node
432:
433: newnode is the node to replace the content with, selectAfterPlace
434: can either be a DOM node that should be selected after the new
435: node was placed, or some value that resolves to true to select
436: the placed node
437: */
438: // get the first range of the selection
439: // (there's almost always only one range)
440: var range = this.selection.getRangeAt(0);
441:
442: // deselect everything
443: this.selection.removeAllRanges();
444:
445: // remove content of current selection from document
446: range.deleteContents();
447:
448: // get location of current selection
449: var container = range.startContainer;
450: var pos = range.startOffset;
451:
452: // make a new range for the new selection
453: var range = this.document.getDocument().createRange();
454:
455: if (container.nodeType == 3 && node.nodeType == 3) {
456: // if we insert text in a textnode, do optimized insertion
457: container.insertData(pos, node.nodeValue);
458:
459: // put cursor after inserted text
460: range.setEnd(container, pos + node.length);
461: range.setStart(container, pos + node.length);
462: } else {
463: var afterNode;
464: if (container.nodeType == 3) {
465: // when inserting into a textnode
466: // we create 2 new textnodes
467: // and put the node in between
468:
469: var textNode = container;
470: var container = textNode.parentNode;
471: var text = textNode.nodeValue;
472:
473: // text before the split
474: var textBefore = text.substr(0,pos);
475: // text after the split
476: var textAfter = text.substr(pos);
477:
478: var beforeNode = this.document.getDocument().createTextNode(textBefore);
479: afterNode = this.document.getDocument().createTextNode(textAfter);
480:
481: // insert the 3 new nodes before the old one
482: container.insertBefore(afterNode, textNode);
483: container.insertBefore(node, afterNode);
484: container.insertBefore(beforeNode, node);
485:
486: // remove the old node
487: container.removeChild(textNode);
488: } else {
489: // else simply insert the node
490: afterNode = container.childNodes[pos];
491: if (afterNode) {
492: container.insertBefore(node, afterNode);
493: } else {
494: container.appendChild(node);
495: };
496: }
497:
498: range.setEnd(afterNode, 0);
499: range.setStart(afterNode, 0);
500: }
501:
502: if (selectAfterPlace) {
503: // a bit implicit here, but I needed this to be backward
504: // compatible and also I didn't want yet another argument,
505: // JavaScript isn't as nice as Python in that respect (kwargs)
506: // if selectAfterPlace is a DOM node, select all of that node's
507: // contents, else select the newly added node's
508: this.selection = this.document.getWindow().getSelection();
509: this.selection.addRange(range);
510: if (selectAfterPlace.nodeType == 1) {
511: this.selection.selectAllChildren(selectAfterPlace);
512: } else {
513: if (node.hasChildNodes()) {
514: this.selection.selectAllChildren(node);
515: } else {
516: var range = this.selection.getRangeAt(0).cloneRange();
517: this.selection.removeAllRanges();
518: range.selectNode(node);
519: this.selection.addRange(range);
520: };
521: };
522: this.document.getWindow().focus();
523: };
524: return node;
525: };
526:
527: this.startOffset = function() {
528: // XXX this should be on a range object
529: var startnode = this.startNode();
530: var startnodeoffset = 0;
531: if (startnode == this.selection.anchorNode) {
532: startnodeoffset = this.selection.anchorOffset;
533: } else {
534: startnodeoffset = this.selection.focusOffset;
535: };
536: var parentnode = this.parentElement();
537: if (startnode == parentnode) {
538: return startnodeoffset;
539: };
540: var currnode = parentnode.firstChild;
541: var offset = 0;
542: if (!currnode) {
543: // 'Control range', range consists of a single element, so startOffset is 0
544: if (startnodeoffset != 0) {
545: // just an assertion to see if my assumption about this case is right
546: throw(_('Start node offset detected in a node without children!'));
547: };
548: return 0;
549: };
550: while (currnode != startnode) {
551: if (currnode.nodeType == 3) {
552: offset += currnode.nodeValue.length;
553: };
554: currnode = currnode.nextSibling;
555: };
556: return offset + startnodeoffset;
557: };
558:
559: this.startNode = function() {
560: // XXX this should be on a range object
561: var anode = this.selection.anchorNode;
562: var aoffset = this.selection.anchorOffset;
563: var onode = this.selection.focusNode;
564: var ooffset = this.selection.focusOffset;
565: var arange = this.document.getDocument().createRange();
566: arange.setStart(anode, aoffset);
567: var orange = this.document.getDocument().createRange();
568: orange.setStart(onode, ooffset);
569: return arange.compareBoundaryPoints('START_TO_START', orange) <= 0 ? anode : onode;
570: };
571:
572: this.endOffset = function() {
573: // XXX this should be on a range object
574: var endnode = this.endNode();
575: var endnodeoffset = 0;
576: if (endnode = this.selection.focusNode) {
577: endnodeoffset = this.selection.focusOffset;
578: } else {
579: endnodeoffset = this.selection.anchorOffset;
580: };
581: var parentnode = this.parentElement();
582: var currnode = parentnode.firstChild;
583: var offset = 0;
584: if (parentnode == endnode) {
585: for (var i=0; i < parentnode.childNodes.length; i++) {
586: var child = parentnode.childNodes[i];
587: if (i == endnodeoffset) {
588: return offset;
589: };
590: if (child.nodeType == 3) {
591: offset += child.nodeValue.length;
592: };
593: };
594: };
595: if (!currnode) {
596: // node doesn't have any content, so offset is always 0
597: if (endnodeoffset != 0) {
598: // just an assertion to see if my assumption about this case is right
599: var msg = _('End node offset detected in a node without ' +
600: 'children!');
601: alert(msg);
602: throw(msg);
603: };
604: return 0;
605: };
606: while (currnode != endnode) {
607: if (currnode.nodeType == 3) { // should account for CDATA nodes as well
608: offset += currnode.nodeValue.length;
609: };
610: currnode = currnode.nextSibling;
611: };
612: return offset + endnodeoffset;
613: };
614:
615: this.endNode = function() {
616: // XXX this should be on a range object
617: var anode = this.selection.anchorNode;
618: var aoffset = this.selection.anchorOffset;
619: var onode = this.selection.focusNode;
620: var ooffset = this.selection.focusOffset;
621: var arange = this.document.getDocument().createRange();
622: arange.setStart(anode, aoffset);
623: var orange = this.document.getDocument().createRange();
624: orange.setStart(onode, ooffset);
625: return arange.compareBoundaryPoints('START_TO_START', orange) > 0 ? anode : onode;
626: };
627:
628: this.getContentLength = function() {
629: // XXX this should be on a range object
630: return this.selection.toString().length;
631: };
632:
633: this.cutChunk = function(startOffset, endOffset) {
634: // XXX this should be on a range object
635: var range = this.selection.getRangeAt(0);
636:
637: // set start point
638: var offsetParent = this.parentElement();
639: var currnode = offsetParent.firstChild;
640: var curroffset = 0;
641:
642: var startparent = null;
643: var startparentoffset = 0;
644:
645: while (currnode) {
646: if (currnode.nodeType == 3) { // XXX need to add CDATA support
647: var nodelength = currnode.nodeValue.length;
648: if (curroffset + nodelength < startOffset) {
649: curroffset += nodelength;
650: } else {
651: startparent = currnode;
652: startparentoffset = startOffset - curroffset;
653: break;
654: };
655: };
656: currnode = currnode.nextSibling;
657: };
658: // set end point
659: var currnode = offsetParent.firstChild;
660: var curroffset = 0;
661:
662: var endparent = null;
663: var endoffset = 0;
664:
665: while (currnode) {
666: if (currnode.nodeType == 3) { // XXX need to add CDATA support
667: var nodelength = currnode.nodeValue.length;
668: if (curroffset + nodelength < endOffset) {
669: curroffset += nodelength;
670: } else {
671: endparent = currnode;
672: endparentoffset = endOffset - curroffset;
673: break;
674: };
675: };
676: currnode = currnode.nextSibling;
677: };
678:
679: // now cut the chunk
680: if (!startparent) {
681: throw(_('Start offset out of range!'));
682: };
683: if (!endparent) {
684: throw(_('End offset out of range!'));
685: };
686:
687: var newrange = range.cloneRange();
688: newrange.setStart(startparent, startparentoffset);
689: newrange.setEnd(endparent, endparentoffset);
690: return newrange.extractContents();
691: };
692:
693: this.getElementLength = function(element) {
694: // XXX this should be a helper function
695: var length = 0;
696: var currnode = element.firstChild;
697: while (currnode) {
698: if (currnode.nodeType == 3) { // XXX should support CDATA as well
699: length += currnode.nodeValue.length;
700: };
701: currnode = currnode.nextSibling;
702: };
703: return length;
704: };
705:
706: this.parentElement = function() {
707: /* return the selected node (or the node containing the selection) */
708: // XXX this should be on a range object
709: if (this.selection.rangeCount == 0) {
710: var parent = this.document.getDocument().body;
711: while (parent.firstChild) {
712: parent = parent.firstChild;
713: };
714: } else {
715: var range = this.selection.getRangeAt(0);
716: var parent = range.commonAncestorContainer;
717:
718: // the following deals with cases where only a single child is
719: // selected, e.g. after a click on an image
720: var inv = range.compareBoundaryPoints(Range.START_TO_END, range) < 0;
721: var startNode = inv ? range.endContainer : range.startContainer;
722: var startOffset = inv ? range.endOffset : range.startOffset;
723: var endNode = inv ? range.startContainer : range.endContainer;
724: var endOffset = inv ? range.startOffset : range.endOffset;
725:
726: var selectedChild = null;
727: var child = parent.firstChild;
728: while (child) {
729: // XXX the additional conditions catch some invisible
730: // intersections, but still not all of them
731: if (range.intersectsNode(child) &&
732: !(child == startNode && startOffset == child.length) &&
733: !(child == endNode && endOffset == 0)) {
734: if (selectedChild) {
735: // current child is the second selected child found
736: selectedChild = null;
737: break;
738: } else {
739: // current child is the first selected child found
740: selectedChild = child;
741: };
742: } else if (selectedChild) {
743: // current child is after the selection
744: break;
745: };
746: child = child.nextSibling;
747: };
748: if (selectedChild) {
749: parent = selectedChild;
750: };
751: };
752: if (parent.nodeType == Node.TEXT_NODE) {
753: parent = parent.parentNode;
754: };
755: return parent;
756: };
757:
758: // deprecated alias of parentElement
759: this.getSelectedNode = this.parentElement;
760:
761: this.moveStart = function(offset) {
762: // XXX this should be on a range object
763: var offsetparent = this.parentElement();
764: // the offset within the offsetparent
765: var startoffset = this.startOffset();
766: var realoffset = offset + startoffset;
767: if (realoffset >= 0) {
768: var currnode = offsetparent.firstChild;
769: var curroffset = 0;
770: var startparent = null;
771: var startoffset = 0;
772: while (currnode) {
773: if (currnode.nodeType == 3) { // XXX need to support CDATA sections
774: var nodelength = currnode.nodeValue.length;
775: if (curroffset + nodelength >= realoffset) {
776: var range = this.selection.getRangeAt(0);
777: //range.setEnd(this.endNode(), this.endOffset());
778: range.setStart(currnode, realoffset - curroffset);
779: return;
780: //this.selection.removeAllRanges();
781: //this.selection.addRange(range);
782: };
783: };
784: currnode = currnode.nextSibling;
785: };
786: // if we still haven't found the startparent we should walk to
787: // all nodes following offsetparent as well
788: var currnode = offsetparent.nextSibling;
789: while (currnode) {
790: if (currnode.nodeType == 3) {
791: var nodelength = currnode.nodeValue.length;
792: if (curroffset + nodelength >= realoffset) {
793: var range = this.selection.getRangeAt(0);
794: // XXX does IE switch the begin and end nodes here as well?
795: var endnode = this.endNode();
796: var endoffset = this.endOffset();
797: range.setEnd(currnode, realoffset - curroffset);
798: range.setStart(endnode, endoffset);
799: return;
800: };
801: curroffset += nodelength;
802: };
803: currnode = currnode.nextSibling;
804: };
805: throw(_('Offset out of document range'));
806: } else if (realoffset < 0) {
807: var currnode = offsetparent.prevSibling;
808: var curroffset = 0;
809: while (currnode) {
810: if (currnode.nodeType == 3) { // XXX need to support CDATA sections
811: var currlength = currnode.nodeValue.length;
812: if (curroffset - currlength < realoffset) {
813: var range = this.selection.getRangeAt(0);
814: range.setStart(currnode, realoffset - curroffset);
815: };
816: curroffset -= currlength;
817: };
818: currnode = currnode.prevSibling;
819: };
820: } else {
821: var range = this.selection.getRangeAt(0);
822: range.setStart(offsetparent, 0);
823: //this.selection.removeAllRanges();
824: //this.selection.addRange(range);
825: };
826: };
827:
828: this.moveEnd = function(offset) {
829: // XXX this should be on a range object
830: };
831:
832: this.reset = function() {
833: this.selection = this.document.getWindow().getSelection();
834: };
835:
836: this.cloneContents = function() {
837: /* returns a document fragment with a copy of the contents */
838: var range = this.selection.getRangeAt(0);
839: return range.cloneContents();
840: };
841:
842: this.containsNode = function(node) {
843: return this.selection.containsNode(node, true);
844: }
845:
846: this.toString = function() {
847: return this.selection.toString();
848: };
849:
850: this.getRange = function() {
851: return this.selection.getRangeAt(0);
852: }
853: this.restoreRange = function(range) {
854: var selection = this.selection;
855: selection.removeAllRanges();
856: selection.addRange(range);
857: }
858: };
859:
860: MozillaSelection.prototype = new BaseSelection;
861:
862: function IESelection(document) {
863: this.document = document;
864: this.selection = document.getDocument().selection;
865:
866: /* If no selection in editable document, IE returns selection from
867: * main page, so force an inner selection. */
868: var doc = document.getDocument();
869:
870: var range = this.selection.createRange()
871: var parent = this.selection.type=="Text" ?
872: range.parentElement() :
873: this.selection.type=="Control" ? range.parentElement : null;
874:
875: if(parent && parent.ownerDocument != doc) {
876: var range = doc.body.createTextRange();
877: range.collapse();
878: range.select();
879: }
880:
881: this.selectNodeContents = function(node) {
882: /* select the contents of a node */
883: // a bit nasty, when moveToElementText is called it will move the selection start
884: // to just before the element instead of inside it, and since IE doesn't reserve
885: // an index for the element itself as well the way to get it inside the element is
886: // by moving the start one pos and then moving it back (yuck!)
887: var range = this.selection.createRange().duplicate();
888: range.moveToElementText(node);
889: range.moveStart('character', 1);
890: range.moveStart('character', -1);
891: range.moveEnd('character', -1);
892: range.moveEnd('character', 1);
893: range.select();
894: this.selection = this.document.getDocument().selection;
895: };
896:
897: this.collapse = function(collapseToEnd) {
898: var range = this.selection.createRange();
899: range.collapse(!collapseToEnd);
900: range.select();
901: this.selection = document.getDocument().selection;
902: };
903:
904: this.replaceWithNode = function(newnode, selectAfterPlace) {
905: /* replaces the current selection with a new node
906: returns a reference to the inserted node
907:
908: newnode is the node to replace the content with, selectAfterPlace
909: can either be a DOM node that should be selected after the new
910: node was placed, or some value that resolves to true to select
911: the placed node
912: */
913: if (this.selection.type == 'Control') {
914: var range = this.selection.createRange();
915: range.item(0).parentNode.replaceChild(newnode, range.item(0));
916: for (var i=1; i < range.length; i++) {
917: range.item(i).parentNode.removeChild(range[i]);
918: };
919: if (selectAfterPlace) {
920: var range = this.document.getDocument().body.createTextRange();
921: range.moveToElementText(newnode);
922: range.select();
923: };
924: } else {
925: var document = this.document.getDocument();
926: var range = this.selection.createRange();
927:
928: range.pasteHTML('<img id="kupu-tempnode">');
929: tempnode = document.getElementById('kupu-tempnode');
930: tempnode.replaceNode(newnode);
931:
932: if (selectAfterPlace) {
933: // see MozillaSelection.replaceWithNode() for some comments about
934: // selectAfterPlace
935: if (selectAfterPlace.nodeType == Node.ELEMENT_NODE) {
936: range.moveToElementText(selectAfterPlace);
937: } else {
938: range.moveToElementText(newnode);
939: };
940: range.select();
941: };
942: };
943: this.reset();
944: return newnode;
945: };
946:
947: this.startOffset = function() {
948: var startoffset = 0;
949: var selrange = this.selection.createRange();
950: var parent = selrange.parentElement();
951: var elrange = selrange.duplicate();
952: elrange.moveToElementText(parent);
953: var tempstart = selrange.duplicate();
954: while (elrange.compareEndPoints('StartToStart', tempstart) < 0) {
955: startoffset++;
956: tempstart.moveStart('character', -1);
957: };
958:
959: return startoffset;
960: };
961:
962: this.endOffset = function() {
963: var endoffset = 0;
964: var selrange = this.selection.createRange();
965: var parent = selrange.parentElement();
966: var elrange = selrange.duplicate();
967: elrange.moveToElementText(parent);
968: var tempend = selrange.duplicate();
969: while (elrange.compareEndPoints('EndToEnd', tempend) > 0) {
970: endoffset++;
971: tempend.moveEnd('character', 1);
972: };
973:
974: return endoffset;
975: };
976:
977: this.getContentLength = function() {
978: if (this.selection.type == 'Control') {
979: return this.selection.createRange().length;
980: };
981: var contentlength = 0;
982: var range = this.selection.createRange();
983: var endrange = range.duplicate();
984: while (range.compareEndPoints('StartToEnd', endrange) < 0) {
985: range.move('character', 1);
986: contentlength++;
987: };
988: return contentlength;
989: };
990:
991: this.cutChunk = function(startOffset, endOffset) {
992: /* cut a chunk of HTML from the selection
993:
994: this *should* return the chunk of HTML but doesn't yet
995: */
996: var range = this.selection.createRange().duplicate();
997: range.moveStart('character', startOffset);
998: range.moveEnd('character', -endOffset);
999: range.pasteHTML('');
1000: // XXX here it should return the chunk
1001: };
1002:
1003: this.getElementLength = function(element) {
1004: /* returns the length of an element *including* 1 char for each child element
1005:
1006: this is defined on the selection since it returns results that can be used
1007: to work with selection offsets
1008: */
1009: var length = 0;
1010: var range = this.selection.createRange().duplicate();
1011: range.moveToElementText(element);
1012: range.moveStart('character', 1);
1013: range.moveEnd('character', -1);
1014: var endpoint = range.duplicate();
1015: endpoint.collapse(false);
1016: range.collapse();
1017: while (!range.isEqual(endpoint)) {
1018: range.moveEnd('character', 1);
1019: range.moveStart('character', 1);
1020: length++;
1021: };
1022: return length;
1023: };
1024:
1025: this.parentElement = function() {
1026: /* return the selected node (or the node containing the selection) */
1027: // XXX this should be on a range object
1028: if (this.selection.type == 'Control') {
1029: return this.selection.createRange().item(0);
1030: } else {
1031: return this.selection.createRange().parentElement();
1032: };
1033: };
1034:
1035: // deprecated alias of parentElement
1036: this.getSelectedNode = this.parentElement;
1037:
1038: this.moveStart = function(offset) {
1039: /* move the start of the selection */
1040: var range = this.selection.createRange();
1041: range.moveStart('character', offset);
1042: range.select();
1043: };
1044:
1045: this.moveEnd = function(offset) {
1046: /* moves the end of the selection */
1047: var range = this.selection.createRange();
1048: range.moveEnd('character', offset);
1049: range.select();
1050: };
1051:
1052: this.reset = function() {
1053: this.selection = this.document.getDocument().selection;
1054: };
1055:
1056: this.cloneContents = function() {
1057: /* returns a document fragment with a copy of the contents */
1058: var contents = this.selection.createRange().htmlText;
1059: var doc = this.document.getDocument();
1060: var docfrag = doc.createElement('span');
1061: docfrag.innerHTML = contents;
1062: return docfrag;
1063: };
1064:
1065: this.containsNode = function(node) {
1066: var selected = this.selection.createRange();
1067:
1068: if (this.selection.type.toLowerCase()=='text') {
1069: var range = doc.body.createTextRange();
1070: range.moveToElementText(node);
1071:
1072: if (selected.compareEndPoints('StartToEnd', range) >= 0 ||
1073: selected.compareEndPoints('EndToStart', range) <= 0) {
1074: return false;
1075: }
1076: return true;
1077: } else {
1078: for (var i = 0; i < selected.length; i++) {
1079: if (selected.item(i).contains(node)) {
1080: return true;
1081: }
1082: }
1083: return false;
1084: }
1085: };
1086:
1087: this.getRange = function() {
1088: return this.selection.createRange();
1089: }
1090:
1091: this.restoreRange = function(range) {
1092: try {
1093: range.select();
1094: } catch(e) {
1095: };
1096: }
1097:
1098: this.toString = function() {
1099: return this.selection.createRange().text;
1100: };
1101: };
1102:
1103: IESelection.prototype = new BaseSelection;
1104:
1105: /* ContextFixer, fixes a problem with the prototype based model
1106:
1107: When a method is called in certain particular ways, for instance
1108: when it is used as an event handler, the context for the method
1109: is changed, so 'this' inside the method doesn't refer to the object
1110: on which the method is defined (or to which it is attached), but for
1111: instance to the element on which the method was bound to as an event
1112: handler. This class can be used to wrap such a method, the wrapper
1113: has one method that can be used as the event handler instead. The
1114: constructor expects at least 2 arguments, first is a reference to the
1115: method, second the context (a reference to the object) and optionally
1116: it can cope with extra arguments, they will be passed to the method
1117: as arguments when it is called (which is a nice bonus of using
1118: this wrapper).
1119: */
1120:
1121: function ContextFixer(func, context) {
1122: /* Make sure 'this' inside a method points to its class */
1123: this.func = func;
1124: this.context = context;
1125: this.args = arguments;
1126: var self = this;
1127:
1128: this.execute = function() {
1129: /* execute the method */
1130: var args = new Array();
1131: // the first arguments will be the extra ones of the class
1132: for (var i=0; i < self.args.length - 2; i++) {
1133: args.push(self.args[i + 2]);
1134: };
1135: // the last are the ones passed on to the execute method
1136: for (var i=0; i < arguments.length; i++) {
1137: args.push(arguments[i]);
1138: };
1139: return self.func.apply(self.context, args);
1140: };
1141:
1142: };
1143:
1144: /* Alternative implementation of window.setTimeout
1145:
1146: This is a singleton class, the name of the single instance of the
1147: object is 'timer_instance', which has one public method called
1148: registerFunction. This method takes at least 2 arguments: a
1149: reference to the function (or method) to be called and the timeout.
1150: Arguments to the function are optional arguments to the
1151: registerFunction method. Example:
1152:
1153: timer_instance.registerMethod(foo, 100, 'bar', 'baz');
1154:
1155: will call the function 'foo' with the arguments 'bar' and 'baz' with
1156: a timeout of 100 milliseconds.
1157:
1158: Since the method doesn't expect a string but a reference to a function
1159: and since it can handle arguments that are resolved within the current
1160: namespace rather then in the global namespace, the method can be used
1161: to call methods on objects from within the object (so this.foo calls
1162: this.foo instead of failing to find this inside the global namespace)
1163: and since the arguments aren't strings which are resolved in the global
1164: namespace the arguments work as expected even inside objects.
1165:
1166: */
1167:
1168: function Timer() {
1169: /* class that has a method to replace window.setTimeout */
1170: this.lastid = 0;
1171: this.functions = {};
1172:
1173: this.registerFunction = function(object, func, timeout) {
1174: /* register a function to be called with a timeout
1175:
1176: args:
1177: func - the function
1178: timeout - timeout in millisecs
1179:
1180: all other args will be passed 1:1 to the function when called
1181: */
1182: var args = new Array();
1183: for (var i=0; i < arguments.length - 3; i++) {
1184: args.push(arguments[i + 3]);
1185: }
1186: var id = this._createUniqueId();
1187: this.functions[id] = new Array(object, func, args);
1188: setTimeout("timer_instance._handleFunction(" + id + ")", timeout);
1189: };
1190:
1191: this._handleFunction = function(id) {
1192: /* private method that does the actual function call */
1193: var obj = this.functions[id][0];
1194: var func = this.functions[id][1];
1195: var args = this.functions[id][2];
1196: this.functions[id] = null;
1197: func.apply(obj, args);
1198: };
1199:
1200: this._createUniqueId = function() {
1201: /* create a unique id to store the function by */
1202: while (this.lastid in this.functions && this.functions[this.lastid]) {
1203: this.lastid++;
1204: if (this.lastid > 100000) {
1205: this.lastid = 0;
1206: }
1207: }
1208: return this.lastid;
1209: };
1210: };
1211:
1212: // create a timer instance in the global namespace, obviously this does some
1213: // polluting but I guess it's impossible to avoid...
1214:
1215: // OBVIOUSLY THIS VARIABLE SHOULD NEVER BE OVERWRITTEN!!!
1216: timer_instance = new Timer();
1217:
1218: // helper function on the Array object to test for containment
1219: Array.prototype.contains = function(element, objectequality) {
1220: /* see if some value is in this */
1221: for (var i=0; i < this.length; i++) {
1222: if (objectequality) {
1223: if (element === this[i]) {
1224: return true;
1225: };
1226: } else {
1227: if (element == this[i]) {
1228: return true;
1229: };
1230: };
1231: };
1232: return false;
1233: };
1234:
1235: // return a copy of an array with doubles removed
1236: Array.prototype.removeDoubles = function() {
1237: var ret = [];
1238: for (var i=0; i < this.length; i++) {
1239: if (!ret.contains(this[i])) {
1240: ret.push(this[i]);
1241: };
1242: };
1243: return ret;
1244: };
1245:
1246: Array.prototype.map = function(func) {
1247: /* apply 'func' to each element in the array */
1248: for (var i=0; i < this.length; i++) {
1249: this[i] = func(this[i]);
1250: };
1251: };
1252:
1253: Array.prototype.reversed = function() {
1254: var ret = [];
1255: for (var i = this.length; i > 0; i--) {
1256: ret.push(this[i - 1]);
1257: };
1258: return ret;
1259: };
1260:
1261: // JavaScript has a friggin' blink() function, but not for string stripping...
1262: String.prototype.strip = function() {
1263: var stripspace = /^\s*([\s\S]*?)\s*$/;
1264: return stripspace.exec(this)[1];
1265: };
1266:
1267: String.prototype.reduceWhitespace = function() {
1268: /* returns a string in which all whitespace is reduced
1269: to a single, plain space */
1270: var spacereg = /(\s+)/g;
1271: var copy = this;
1272: while (true) {
1273: var match = spacereg.exec(copy);
1274: if (!match) {
1275: return copy;
1276: };
1277: copy = copy.replace(match[0], ' ');
1278: };
1279: };
1280:
1281: String.prototype.entitize = function() {
1282: var ret = this.replace(/&/g, '&');
1283: ret = ret.replace(/"/g, '"');
1284: ret = ret.replace(/</g, '<');
1285: ret = ret.replace(/>/g, '>');
1286: return ret;
1287: };
1288:
1289: String.prototype.deentitize = function() {
1290: var ret = this.replace(/>/g, '>');
1291: ret = ret.replace(/</g, '<');
1292: ret = ret.replace(/"/g, '"');
1293: ret = ret.replace(/&/g, '&');
1294: return ret;
1295: };
1296:
1297: String.prototype.urldecode = function() {
1298: var reg = /%([a-fA-F0-9]{2})/g;
1299: var str = this;
1300: while (true) {
1301: var match = reg.exec(str);
1302: if (!match || !match.length) {
1303: break;
1304: };
1305: var repl = new RegExp(match[0], 'g');
1306: str = str.replace(repl, String.fromCharCode(parseInt(match[1], 16)));
1307: };
1308: return str;
1309: };
1310:
1311: String.prototype.centerTruncate = function(maxlength) {
1312: if (this.length <= maxlength) {
1313: return this;
1314: };
1315: var chunklength = maxlength / 2 - 3;
1316: var start = this.substr(0, chunklength);
1317: var end = this.substr(this.length - chunklength);
1318: return start + ' ... ' + end;
1319: };
1320:
1321: //----------------------------------------------------------------------------
1322: // Exceptions
1323: //----------------------------------------------------------------------------
1324:
1325: function debug(str, win) {
1326: if (!win) {
1327: win = window;
1328: };
1329: var doc = win.document;
1330: var div = doc.createElement('div');
1331: div.appendChild(doc.createTextNode(str));
1332: doc.getElementsByTagName('body')[0].appendChild(div);
1333: };
1334:
1335: // XXX don't know if this is the regular way to define exceptions in JavaScript?
1336: function Exception() {
1337: return;
1338: };
1339:
1340: // throw this as an exception inside an updateState handler to restart the
1341: // update, may be required in situations where updateState changes the structure
1342: // of the document (e.g. does a cleanup or so)
1343: UpdateStateCancelBubble = new Exception();
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to kupuhelpers.js CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / kupuMPIWG / common