Fix
[redakcja.git] / redakcja / static / js / lib / codemirror-0.8 / select.js
1 /* Functionality for finding, storing, and restoring selections
2  *
3  * This does not provide a generic API, just the minimal functionality
4  * required by the CodeMirror system.
5  */
6
7 // Namespace object.
8 var select = {};
9
10 (function() {
11   select.ie_selection = document.selection && document.selection.createRangeCollection;
12
13   // Find the 'top-level' (defined as 'a direct child of the node
14   // passed as the top argument') node that the given node is
15   // contained in. Return null if the given node is not inside the top
16   // node.
17   function topLevelNodeAt(node, top) {
18     while (node && node.parentNode != top)
19       node = node.parentNode;
20     return node;
21   }
22
23   // Find the top-level node that contains the node before this one.
24   function topLevelNodeBefore(node, top) {
25     while (!node.previousSibling && node.parentNode != top)
26       node = node.parentNode;
27     return topLevelNodeAt(node.previousSibling, top);
28   }
29
30   var fourSpaces = "\u00a0\u00a0\u00a0\u00a0";
31
32   select.scrollToNode = function(node, cursor) {
33     if (!node) return;
34     var element = node,
35         doc = element.ownerDocument, body = doc.body,
36         win = (doc.defaultView || doc.parentWindow),
37         html = doc.documentElement,
38         atEnd = !element.nextSibling || !element.nextSibling.nextSibling
39                 || !element.nextSibling.nextSibling.nextSibling;
40     // In Opera (and recent Webkit versions), BR elements *always*
41     // have a offsetTop property of zero.
42     var compensateHack = 0;
43     while (element && !element.offsetTop) {
44       compensateHack++;
45       element = element.previousSibling;
46     }
47     // atEnd is another kludge for these browsers -- if the cursor is
48     // at the end of the document, and the node doesn't have an
49     // offset, just scroll to the end.
50     if (compensateHack == 0) atEnd = false;
51
52     // WebKit has a bad habit of (sometimes) happily returning bogus
53     // offsets when the document has just been changed. This seems to
54     // always be 5/5, so we don't use those.
55     if (webkit && element && element.offsetTop == 5 && element.offsetLeft == 5)
56       return;
57
58     var y = compensateHack * (element ? element.offsetHeight : 0), x = 0,
59         width = (node ? node.offsetWidth : 0), pos = element;
60     while (pos && pos.offsetParent) {
61       y += pos.offsetTop;
62       // Don't count X offset for <br> nodes
63       if (!isBR(pos))
64         x += pos.offsetLeft;
65       pos = pos.offsetParent;
66     }
67
68     var scroll_x = body.scrollLeft || html.scrollLeft || 0,
69         scroll_y = body.scrollTop || html.scrollTop || 0,
70         scroll = false, screen_width = win.innerWidth || html.clientWidth || 0;
71
72     if (cursor || width < screen_width) {
73       if (cursor) {
74         var off = select.offsetInNode(win, node), size = nodeText(node).length;
75         if (size) x += width * (off / size);
76       }
77       var screen_x = x - scroll_x;
78       if (screen_x < 0 || screen_x > screen_width) {
79         scroll_x = x;
80         scroll = true;
81       }
82     }
83     var screen_y = y - scroll_y;
84     if (screen_y < 0 || atEnd || screen_y > (win.innerHeight || html.clientHeight || 0) - 50) {
85       scroll_y = atEnd ? 1e6 : y;
86       scroll = true;
87     }
88     if (scroll) win.scrollTo(scroll_x, scroll_y);
89   };
90
91   select.scrollToCursor = function(container) {
92     select.scrollToNode(select.selectionTopNode(container, true) || container.firstChild, true);
93   };
94
95   // Used to prevent restoring a selection when we do not need to.
96   var currentSelection = null;
97
98   select.snapshotChanged = function() {
99     if (currentSelection) currentSelection.changed = true;
100   };
101
102   // This is called by the code in editor.js whenever it is replacing
103   // a text node. The function sees whether the given oldNode is part
104   // of the current selection, and updates this selection if it is.
105   // Because nodes are often only partially replaced, the length of
106   // the part that gets replaced has to be taken into account -- the
107   // selection might stay in the oldNode if the newNode is smaller
108   // than the selection's offset. The offset argument is needed in
109   // case the selection does move to the new object, and the given
110   // length is not the whole length of the new node (part of it might
111   // have been used to replace another node).
112   select.snapshotReplaceNode = function(from, to, length, offset) {
113     if (!currentSelection) return;
114
115     function replace(point) {
116       if (from == point.node) {
117         currentSelection.changed = true;
118         if (length && point.offset > length) {
119           point.offset -= length;
120         }
121         else {
122           point.node = to;
123           point.offset += (offset || 0);
124         }
125       }
126     }
127     replace(currentSelection.start);
128     replace(currentSelection.end);
129   };
130
131   select.snapshotMove = function(from, to, distance, relative, ifAtStart) {
132     if (!currentSelection) return;
133
134     function move(point) {
135       if (from == point.node && (!ifAtStart || point.offset == 0)) {
136         currentSelection.changed = true;
137         point.node = to;
138         if (relative) point.offset = Math.max(0, point.offset + distance);
139         else point.offset = distance;
140       }
141     }
142     move(currentSelection.start);
143     move(currentSelection.end);
144   };
145
146   // Most functions are defined in two ways, one for the IE selection
147   // model, one for the W3C one.
148   if (select.ie_selection) {
149     function selectionNode(win, start) {
150       var range = win.document.selection.createRange();
151       range.collapse(start);
152
153       function nodeAfter(node) {
154         var found = null;
155         while (!found && node) {
156           found = node.nextSibling;
157           node = node.parentNode;
158         }
159         return nodeAtStartOf(found);
160       }
161
162       function nodeAtStartOf(node) {
163         while (node && node.firstChild) node = node.firstChild;
164         return {node: node, offset: 0};
165       }
166
167       var containing = range.parentElement();
168       if (!isAncestor(win.document.body, containing)) return null;
169       if (!containing.firstChild) return nodeAtStartOf(containing);
170
171       var working = range.duplicate();
172       working.moveToElementText(containing);
173       working.collapse(true);
174       for (var cur = containing.firstChild; cur; cur = cur.nextSibling) {
175         if (cur.nodeType == 3) {
176           var size = cur.nodeValue.length;
177           working.move("character", size);
178         }
179         else {
180           working.moveToElementText(cur);
181           working.collapse(false);
182         }
183
184         var dir = range.compareEndPoints("StartToStart", working);
185         if (dir == 0) return nodeAfter(cur);
186         if (dir == 1) continue;
187         if (cur.nodeType != 3) return nodeAtStartOf(cur);
188
189         working.setEndPoint("StartToEnd", range);
190         return {node: cur, offset: size - working.text.length};
191       }
192       return nodeAfter(containing);
193     }
194
195     select.markSelection = function(win) {
196       currentSelection = null;
197       var sel = win.document.selection;
198       if (!sel) return;
199       var start = selectionNode(win, true),
200           end = selectionNode(win, false);
201       if (!start || !end) return;
202       currentSelection = {start: start, end: end, window: win, changed: false};
203     };
204
205     select.selectMarked = function() {
206       if (!currentSelection || !currentSelection.changed) return;
207       var win = currentSelection.window, doc = win.document;
208
209       function makeRange(point) {
210         var range = doc.body.createTextRange(),
211             node = point.node;
212         if (!node) {
213           range.moveToElementText(currentSelection.window.document.body);
214           range.collapse(false);
215         }
216         else if (node.nodeType == 3) {
217           range.moveToElementText(node.parentNode);
218           var offset = point.offset;
219           while (node.previousSibling) {
220             node = node.previousSibling;
221             offset += (node.innerText || "").length;
222           }
223           range.move("character", offset);
224         }
225         else {
226           range.moveToElementText(node);
227           range.collapse(true);
228         }
229         return range;
230       }
231
232       var start = makeRange(currentSelection.start), end = makeRange(currentSelection.end);
233       start.setEndPoint("StartToEnd", end);
234       start.select();
235     };
236
237     select.offsetInNode = function(win, node) {
238       var sel = win.document.selection;
239       if (!sel) return 0;
240       var range = sel.createRange(), range2 = range.duplicate();
241       try {range2.moveToElementText(node);} catch(e){return 0;}
242       range.setEndPoint("StartToStart", range2);
243       return range.text.length;
244     };
245
246     // Get the top-level node that one end of the cursor is inside or
247     // after. Note that this returns false for 'no cursor', and null
248     // for 'start of document'.
249     select.selectionTopNode = function(container, start) {
250       var selection = container.ownerDocument.selection;
251       if (!selection) return false;
252
253       var range = selection.createRange(), range2 = range.duplicate();
254       range.collapse(start);
255       var around = range.parentElement();
256       if (around && isAncestor(container, around)) {
257         // Only use this node if the selection is not at its start.
258         range2.moveToElementText(around);
259         if (range.compareEndPoints("StartToStart", range2) == 1)
260           return topLevelNodeAt(around, container);
261       }
262
263       // Move the start of a range to the start of a node,
264       // compensating for the fact that you can't call
265       // moveToElementText with text nodes.
266       function moveToNodeStart(range, node) {
267         if (node.nodeType == 3) {
268           var count = 0, cur = node.previousSibling;
269           while (cur && cur.nodeType == 3) {
270             count += cur.nodeValue.length;
271             cur = cur.previousSibling;
272           }
273           if (cur) {
274             try{range.moveToElementText(cur);}
275             catch(e){return false;}
276             range.collapse(false);
277           }
278           else range.moveToElementText(node.parentNode);
279           if (count) range.move("character", count);
280         }
281         else {
282           try{range.moveToElementText(node);}
283           catch(e){return false;}
284         }
285         return true;
286       }
287
288       // Do a binary search through the container object, comparing
289       // the start of each node to the selection
290       var start = 0, end = container.childNodes.length - 1;
291       while (start < end) {
292         var middle = Math.ceil((end + start) / 2), node = container.childNodes[middle];
293         if (!node) return false; // Don't ask. IE6 manages this sometimes.
294         if (!moveToNodeStart(range2, node)) return false;
295         if (range.compareEndPoints("StartToStart", range2) == 1)
296           start = middle;
297         else
298           end = middle - 1;
299       }
300       return container.childNodes[start] || null;
301     };
302
303     // Place the cursor after this.start. This is only useful when
304     // manually moving the cursor instead of restoring it to its old
305     // position.
306     select.focusAfterNode = function(node, container) {
307       var range = container.ownerDocument.body.createTextRange();
308       range.moveToElementText(node || container);
309       range.collapse(!node);
310       range.select();
311     };
312
313     select.somethingSelected = function(win) {
314       var sel = win.document.selection;
315       return sel && (sel.createRange().text != "");
316     };
317
318     function insertAtCursor(window, html) {
319       var selection = window.document.selection;
320       if (selection) {
321         var range = selection.createRange();
322         range.pasteHTML(html);
323         range.collapse(false);
324         range.select();
325       }
326     }
327
328     // Used to normalize the effect of the enter key, since browsers
329     // do widely different things when pressing enter in designMode.
330     select.insertNewlineAtCursor = function(window) {
331       insertAtCursor(window, "<br>");
332     };
333
334     select.insertTabAtCursor = function(window) {
335       insertAtCursor(window, fourSpaces);
336     };
337
338     // Get the BR node at the start of the line on which the cursor
339     // currently is, and the offset into the line. Returns null as
340     // node if cursor is on first line.
341     select.cursorPos = function(container, start) {
342       var selection = container.ownerDocument.selection;
343       if (!selection) return null;
344
345       var topNode = select.selectionTopNode(container, start);
346       while (topNode && !isBR(topNode))
347         topNode = topNode.previousSibling;
348
349       var range = selection.createRange(), range2 = range.duplicate();
350       range.collapse(start);
351       if (topNode) {
352         range2.moveToElementText(topNode);
353         range2.collapse(false);
354       }
355       else {
356         // When nothing is selected, we can get all kinds of funky errors here.
357         try { range2.moveToElementText(container); }
358         catch (e) { return null; }
359         range2.collapse(true);
360       }
361       range.setEndPoint("StartToStart", range2);
362
363       return {node: topNode, offset: range.text.length};
364     };
365
366     select.setCursorPos = function(container, from, to) {
367       function rangeAt(pos) {
368         var range = container.ownerDocument.body.createTextRange();
369         if (!pos.node) {
370           range.moveToElementText(container);
371           range.collapse(true);
372         }
373         else {
374           range.moveToElementText(pos.node);
375           range.collapse(false);
376         }
377         range.move("character", pos.offset);
378         return range;
379       }
380
381       var range = rangeAt(from);
382       if (to && to != from)
383         range.setEndPoint("EndToEnd", rangeAt(to));
384       range.select();
385     }
386
387     // Some hacks for storing and re-storing the selection when the editor loses and regains focus.
388     select.getBookmark = function (container) {
389       var from = select.cursorPos(container, true), to = select.cursorPos(container, false);
390       if (from && to) return {from: from, to: to};
391     };
392
393     // Restore a stored selection.
394     select.setBookmark = function(container, mark) {
395       if (!mark) return;
396       select.setCursorPos(container, mark.from, mark.to);
397     };
398   }
399   // W3C model
400   else {
401     // Find the node right at the cursor, not one of its
402     // ancestors with a suitable offset. This goes down the DOM tree
403     // until a 'leaf' is reached (or is it *up* the DOM tree?).
404     function innerNode(node, offset) {
405       while (node.nodeType != 3 && !isBR(node)) {
406         var newNode = node.childNodes[offset] || node.nextSibling;
407         offset = 0;
408         while (!newNode && node.parentNode) {
409           node = node.parentNode;
410           newNode = node.nextSibling;
411         }
412         node = newNode;
413         if (!newNode) break;
414       }
415       return {node: node, offset: offset};
416     }
417
418     // Store start and end nodes, and offsets within these, and refer
419     // back to the selection object from those nodes, so that this
420     // object can be updated when the nodes are replaced before the
421     // selection is restored.
422     select.markSelection = function (win) {
423       var selection = win.getSelection();
424       if (!selection || selection.rangeCount == 0)
425         return (currentSelection = null);
426       var range = selection.getRangeAt(0);
427
428       currentSelection = {
429         start: innerNode(range.startContainer, range.startOffset),
430         end: innerNode(range.endContainer, range.endOffset),
431         window: win,
432         changed: false
433       };
434     };
435
436     select.selectMarked = function () {
437       var cs = currentSelection;
438       // on webkit-based browsers, it is apparently possible that the
439       // selection gets reset even when a node that is not one of the
440       // endpoints get messed with. the most common situation where
441       // this occurs is when a selection is deleted or overwitten. we
442       // check for that here.
443       function focusIssue() {
444         if (cs.start.node == cs.end.node && cs.start.offset == cs.end.offset) {
445           var selection = cs.window.getSelection();
446           if (!selection || selection.rangeCount == 0) return true;
447           var range = selection.getRangeAt(0), point = innerNode(range.startContainer, range.startOffset);
448           return cs.start.node != point.node || cs.start.offset != point.offset;
449         }
450       }
451       if (!cs || !(cs.changed || (webkit && focusIssue()))) return;
452       var win = cs.window, range = win.document.createRange();
453
454       function setPoint(point, which) {
455         if (point.node) {
456           // Some magic to generalize the setting of the start and end
457           // of a range.
458           if (point.offset == 0)
459             range["set" + which + "Before"](point.node);
460           else
461             range["set" + which](point.node, point.offset);
462         }
463         else {
464           range.setStartAfter(win.document.body.lastChild || win.document.body);
465         }
466       }
467
468       setPoint(cs.end, "End");
469       setPoint(cs.start, "Start");
470       selectRange(range, win);
471     };
472
473     // Helper for selecting a range object.
474     function selectRange(range, window) {
475       var selection = window.getSelection();
476       if (!selection) return;
477       selection.removeAllRanges();
478       selection.addRange(range);
479     }
480     function selectionRange(window) {
481       var selection = window.getSelection();
482       if (!selection || selection.rangeCount == 0)
483         return false;
484       else
485         return selection.getRangeAt(0);
486     }
487
488     // Finding the top-level node at the cursor in the W3C is, as you
489     // can see, quite an involved process.
490     select.selectionTopNode = function(container, start) {
491       var range = selectionRange(container.ownerDocument.defaultView);
492       if (!range) return false;
493
494       var node = start ? range.startContainer : range.endContainer;
495       var offset = start ? range.startOffset : range.endOffset;
496       // Work around (yet another) bug in Opera's selection model.
497       if (window.opera && !start && range.endContainer == container && range.endOffset == range.startOffset + 1 &&
498           container.childNodes[range.startOffset] && isBR(container.childNodes[range.startOffset]))
499         offset--;
500
501       // For text nodes, we look at the node itself if the cursor is
502       // inside, or at the node before it if the cursor is at the
503       // start.
504       if (node.nodeType == 3){
505         if (offset > 0)
506           return topLevelNodeAt(node, container);
507         else
508           return topLevelNodeBefore(node, container);
509       }
510       // Occasionally, browsers will return the HTML node as
511       // selection. If the offset is 0, we take the start of the frame
512       // ('after null'), otherwise, we take the last node.
513       else if (node.nodeName.toUpperCase() == "HTML") {
514         return (offset == 1 ? null : container.lastChild);
515       }
516       // If the given node is our 'container', we just look up the
517       // correct node by using the offset.
518       else if (node == container) {
519         return (offset == 0) ? null : node.childNodes[offset - 1];
520       }
521       // In any other case, we have a regular node. If the cursor is
522       // at the end of the node, we use the node itself, if it is at
523       // the start, we use the node before it, and in any other
524       // case, we look up the child before the cursor and use that.
525       else {
526         if (offset == node.childNodes.length)
527           return topLevelNodeAt(node, container);
528         else if (offset == 0)
529           return topLevelNodeBefore(node, container);
530         else
531           return topLevelNodeAt(node.childNodes[offset - 1], container);
532       }
533     };
534
535     select.focusAfterNode = function(node, container) {
536       var win = container.ownerDocument.defaultView,
537           range = win.document.createRange();
538       range.setStartBefore(container.firstChild || container);
539       // In Opera, setting the end of a range at the end of a line
540       // (before a BR) will cause the cursor to appear on the next
541       // line, so we set the end inside of the start node when
542       // possible.
543       if (node && !node.firstChild)
544         range.setEndAfter(node);
545       else if (node)
546         range.setEnd(node, node.childNodes.length);
547       else
548         range.setEndBefore(container.firstChild || container);
549       range.collapse(false);
550       selectRange(range, win);
551     };
552
553     select.somethingSelected = function(win) {
554       var range = selectionRange(win);
555       return range && !range.collapsed;
556     };
557
558     select.offsetInNode = function(win, node) {
559       var range = selectionRange(win);
560       if (!range) return 0;
561       range = range.cloneRange();
562       range.setStartBefore(node);
563       return range.toString().length;
564     };
565
566     function insertNodeAtCursor(window, node) {
567       var range = selectionRange(window);
568       if (!range) return;
569
570       range.deleteContents();
571       range.insertNode(node);
572
573       // work around weirdness where Opera will magically insert a new
574       // BR node when a BR node inside a span is moved around. makes
575       // sure the BR ends up outside of spans.
576       if (window.opera && isBR(node) && isSpan(node.parentNode)) {
577         var next = node.nextSibling, p = node.parentNode, outer = p.parentNode;
578         outer.insertBefore(node, p.nextSibling);
579         var textAfter = "";
580         for (; next && next.nodeType == 3; next = next.nextSibling) {
581           textAfter += next.nodeValue;
582           removeElement(next);
583         }
584         outer.insertBefore(makePartSpan(textAfter, window.document), node.nextSibling);
585       }
586       range = window.document.createRange();
587       range.selectNode(node);
588       range.collapse(false);
589       selectRange(range, window);
590     }
591
592     select.insertNewlineAtCursor = function(window) {
593       if (webkit)
594         document.execCommand('insertLineBreak');
595       else
596         insertNodeAtCursor(window, window.document.createElement("BR"));
597     };
598
599     select.insertTabAtCursor = function(window) {
600       insertNodeAtCursor(window, window.document.createTextNode(fourSpaces));
601     };
602
603     select.cursorPos = function(container, start) {
604       var range = selectionRange(window);
605       if (!range) return;
606
607       var topNode = select.selectionTopNode(container, start);
608       while (topNode && !isBR(topNode))
609         topNode = topNode.previousSibling;
610
611       range = range.cloneRange();
612       range.collapse(start);
613       if (topNode)
614         range.setStartAfter(topNode);
615       else
616         range.setStartBefore(container);
617
618       return {node: topNode, offset: range.toString().length};
619     };
620
621     select.setCursorPos = function(container, from, to) {
622       var win = container.ownerDocument.defaultView,
623           range = win.document.createRange();
624
625       function setPoint(node, offset, side) {
626         if (offset == 0 && node && !node.nextSibling) {
627           range["set" + side + "After"](node);
628           return true;
629         }
630
631         if (!node)
632           node = container.firstChild;
633         else
634           node = node.nextSibling;
635
636         if (!node) return;
637
638         if (offset == 0) {
639           range["set" + side + "Before"](node);
640           return true;
641         }
642
643         var backlog = []
644         function decompose(node) {
645           if (node.nodeType == 3)
646             backlog.push(node);
647           else
648             forEach(node.childNodes, decompose);
649         }
650         while (true) {
651           while (node && !backlog.length) {
652             decompose(node);
653             node = node.nextSibling;
654           }
655           var cur = backlog.shift();
656           if (!cur) return false;
657
658           var length = cur.nodeValue.length;
659           if (length >= offset) {
660             range["set" + side](cur, offset);
661             return true;
662           }
663           offset -= length;
664         }
665       }
666
667       to = to || from;
668       if (setPoint(to.node, to.offset, "End") && setPoint(from.node, from.offset, "Start"))
669         selectRange(range, win);
670     };
671   }
672 })();