Rename Node::childNodeCount() to countChildNodes() and avoid inefficient uses
[WebKit-https.git] / Source / WebCore / page / DOMSelection.cpp
1 /*
2  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2012 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30
31 #include "config.h"
32 #include "DOMSelection.h"
33
34 #include "Document.h"
35 #include "ExceptionCode.h"
36 #include "Frame.h"
37 #include "FrameSelection.h"
38 #include "Node.h"
39 #include "Range.h"
40 #include "TextIterator.h"
41 #include "TreeScope.h"
42 #include "htmlediting.h"
43 #include <wtf/text/WTFString.h>
44
45 namespace WebCore {
46
47 static Node* selectionShadowAncestor(Frame* frame)
48 {
49     Node* node = frame->selection().selection().base().anchorNode();
50     if (!node)
51         return 0;
52
53     if (!node->isInShadowTree())
54         return 0;
55
56     return frame->document()->ancestorInThisScope(node);
57 }
58
59 DOMSelection::DOMSelection(const TreeScope* treeScope)
60     : DOMWindowProperty(treeScope->rootNode().document().frame())
61     , m_treeScope(treeScope)
62 {
63 }
64
65 void DOMSelection::clearTreeScope()
66 {
67     m_treeScope = 0;
68 }
69
70 const VisibleSelection& DOMSelection::visibleSelection() const
71 {
72     ASSERT(m_frame);
73     return m_frame->selection().selection();
74 }
75
76 static Position anchorPosition(const VisibleSelection& selection)
77 {
78     Position anchor = selection.isBaseFirst() ? selection.start() : selection.end();
79     return anchor.parentAnchoredEquivalent();
80 }
81
82 static Position focusPosition(const VisibleSelection& selection)
83 {
84     Position focus = selection.isBaseFirst() ? selection.end() : selection.start();
85     return focus.parentAnchoredEquivalent();
86 }
87
88 static Position basePosition(const VisibleSelection& selection)
89 {
90     return selection.base().parentAnchoredEquivalent();
91 }
92
93 static Position extentPosition(const VisibleSelection& selection)
94 {
95     return selection.extent().parentAnchoredEquivalent();
96 }
97
98 Node* DOMSelection::anchorNode() const
99 {
100     if (!m_frame)
101         return 0;
102
103     return shadowAdjustedNode(anchorPosition(visibleSelection()));
104 }
105
106 int DOMSelection::anchorOffset() const
107 {
108     if (!m_frame)
109         return 0;
110
111     return shadowAdjustedOffset(anchorPosition(visibleSelection()));
112 }
113
114 Node* DOMSelection::focusNode() const
115 {
116     if (!m_frame)
117         return 0;
118
119     return shadowAdjustedNode(focusPosition(visibleSelection()));
120 }
121
122 int DOMSelection::focusOffset() const
123 {
124     if (!m_frame)
125         return 0;
126
127     return shadowAdjustedOffset(focusPosition(visibleSelection()));
128 }
129
130 Node* DOMSelection::baseNode() const
131 {
132     if (!m_frame)
133         return 0;
134
135     return shadowAdjustedNode(basePosition(visibleSelection()));
136 }
137
138 int DOMSelection::baseOffset() const
139 {
140     if (!m_frame)
141         return 0;
142
143     return shadowAdjustedOffset(basePosition(visibleSelection()));
144 }
145
146 Node* DOMSelection::extentNode() const
147 {
148     if (!m_frame)
149         return 0;
150
151     return shadowAdjustedNode(extentPosition(visibleSelection()));
152 }
153
154 int DOMSelection::extentOffset() const
155 {
156     if (!m_frame)
157         return 0;
158
159     return shadowAdjustedOffset(extentPosition(visibleSelection()));
160 }
161
162 bool DOMSelection::isCollapsed() const
163 {
164     if (!m_frame || selectionShadowAncestor(m_frame))
165         return true;
166     return !m_frame->selection().isRange();
167 }
168
169 String DOMSelection::type() const
170 {
171     if (!m_frame)
172         return String();
173
174     FrameSelection& selection = m_frame->selection();
175
176     // This is a WebKit DOM extension, incompatible with an IE extension
177     // IE has this same attribute, but returns "none", "text" and "control"
178     // http://msdn.microsoft.com/en-us/library/ms534692(VS.85).aspx
179     if (selection.isNone())
180         return "None";
181     if (selection.isCaret())
182         return "Caret";
183     return "Range";
184 }
185
186 int DOMSelection::rangeCount() const
187 {
188     if (!m_frame)
189         return 0;
190     return m_frame->selection().isNone() ? 0 : 1;
191 }
192
193 void DOMSelection::collapse(Node* node, int offset, ExceptionCode& ec)
194 {
195     if (!m_frame)
196         return;
197
198     if (offset < 0) {
199         ec = INDEX_SIZE_ERR;
200         return;
201     }
202
203     if (!isValidForPosition(node))
204         return;
205
206     // FIXME: Eliminate legacy editing positions
207     m_frame->selection().moveTo(createLegacyEditingPosition(node, offset), DOWNSTREAM);
208 }
209
210 void DOMSelection::collapseToEnd(ExceptionCode& ec)
211 {
212     if (!m_frame)
213         return;
214
215     const VisibleSelection& selection = m_frame->selection().selection();
216
217     if (selection.isNone()) {
218         ec = INVALID_STATE_ERR;
219         return;
220     }
221
222     m_frame->selection().moveTo(selection.end(), DOWNSTREAM);
223 }
224
225 void DOMSelection::collapseToStart(ExceptionCode& ec)
226 {
227     if (!m_frame)
228         return;
229
230     const VisibleSelection& selection = m_frame->selection().selection();
231
232     if (selection.isNone()) {
233         ec = INVALID_STATE_ERR;
234         return;
235     }
236
237     m_frame->selection().moveTo(selection.start(), DOWNSTREAM);
238 }
239
240 void DOMSelection::empty()
241 {
242     if (!m_frame)
243         return;
244     m_frame->selection().clear();
245 }
246
247 void DOMSelection::setBaseAndExtent(Node* baseNode, int baseOffset, Node* extentNode, int extentOffset, ExceptionCode& ec)
248 {
249     if (!m_frame)
250         return;
251
252     if (baseOffset < 0 || extentOffset < 0) {
253         ec = INDEX_SIZE_ERR;
254         return;
255     }
256
257     if (!isValidForPosition(baseNode) || !isValidForPosition(extentNode))
258         return;
259
260     // FIXME: Eliminate legacy editing positions
261     m_frame->selection().moveTo(createLegacyEditingPosition(baseNode, baseOffset), createLegacyEditingPosition(extentNode, extentOffset), DOWNSTREAM);
262 }
263
264 void DOMSelection::setPosition(Node* node, int offset, ExceptionCode& ec)
265 {
266     if (!m_frame)
267         return;
268     if (offset < 0) {
269         ec = INDEX_SIZE_ERR;
270         return;
271     }
272
273     if (!isValidForPosition(node))
274         return;
275
276     // FIXME: Eliminate legacy editing positions
277     m_frame->selection().moveTo(createLegacyEditingPosition(node, offset), DOWNSTREAM);
278 }
279
280 void DOMSelection::modify(const String& alterString, const String& directionString, const String& granularityString)
281 {
282     if (!m_frame)
283         return;
284
285     FrameSelection::EAlteration alter;
286     if (equalIgnoringCase(alterString, "extend"))
287         alter = FrameSelection::AlterationExtend;
288     else if (equalIgnoringCase(alterString, "move"))
289         alter = FrameSelection::AlterationMove;
290     else
291         return;
292
293     SelectionDirection direction;
294     if (equalIgnoringCase(directionString, "forward"))
295         direction = DirectionForward;
296     else if (equalIgnoringCase(directionString, "backward"))
297         direction = DirectionBackward;
298     else if (equalIgnoringCase(directionString, "left"))
299         direction = DirectionLeft;
300     else if (equalIgnoringCase(directionString, "right"))
301         direction = DirectionRight;
302     else
303         return;
304
305     TextGranularity granularity;
306     if (equalIgnoringCase(granularityString, "character"))
307         granularity = CharacterGranularity;
308     else if (equalIgnoringCase(granularityString, "word"))
309         granularity = WordGranularity;
310     else if (equalIgnoringCase(granularityString, "sentence"))
311         granularity = SentenceGranularity;
312     else if (equalIgnoringCase(granularityString, "line"))
313         granularity = LineGranularity;
314     else if (equalIgnoringCase(granularityString, "paragraph"))
315         granularity = ParagraphGranularity;
316     else if (equalIgnoringCase(granularityString, "lineboundary"))
317         granularity = LineBoundary;
318     else if (equalIgnoringCase(granularityString, "sentenceboundary"))
319         granularity = SentenceBoundary;
320     else if (equalIgnoringCase(granularityString, "paragraphboundary"))
321         granularity = ParagraphBoundary;
322     else if (equalIgnoringCase(granularityString, "documentboundary"))
323         granularity = DocumentBoundary;
324     else
325         return;
326
327     m_frame->selection().modify(alter, direction, granularity);
328 }
329
330 void DOMSelection::extend(Node* node, int offset, ExceptionCode& ec)
331 {
332     if (!m_frame)
333         return;
334
335     if (!node) {
336         ec = TYPE_MISMATCH_ERR;
337         return;
338     }
339
340     if (offset < 0 || offset > (node->offsetInCharacters() ? caretMaxOffset(node) : static_cast<int>(node->countChildNodes()))) {
341         ec = INDEX_SIZE_ERR;
342         return;
343     }
344
345     if (!isValidForPosition(node))
346         return;
347
348     // FIXME: Eliminate legacy editing positions
349     m_frame->selection().setExtent(createLegacyEditingPosition(node, offset), DOWNSTREAM);
350 }
351
352 PassRefPtr<Range> DOMSelection::getRangeAt(int index, ExceptionCode& ec)
353 {
354     if (!m_frame)
355         return 0;
356
357     if (index < 0 || index >= rangeCount()) {
358         ec = INDEX_SIZE_ERR;
359         return 0;
360     }
361
362     // If you're hitting this, you've added broken multi-range selection support
363     ASSERT(rangeCount() == 1);
364
365     if (Node* shadowAncestor = selectionShadowAncestor(m_frame)) {
366         ContainerNode* container = shadowAncestor->parentNodeGuaranteedHostFree();
367         int offset = shadowAncestor->nodeIndex();
368         return Range::create(shadowAncestor->document(), container, offset, container, offset);
369     }
370
371     return m_frame->selection().selection().firstRange();
372 }
373
374 void DOMSelection::removeAllRanges()
375 {
376     if (!m_frame)
377         return;
378     m_frame->selection().clear();
379 }
380
381 void DOMSelection::addRange(Range* r)
382 {
383     if (!m_frame)
384         return;
385     if (!r)
386         return;
387
388     FrameSelection& selection = m_frame->selection();
389
390     if (selection.isNone()) {
391         selection.moveTo(r);
392         return;
393     }
394
395     RefPtr<Range> range = selection.selection().toNormalizedRange();
396     if (r->compareBoundaryPoints(Range::START_TO_START, range.get(), IGNORE_EXCEPTION) == -1) {
397         // We don't support discontiguous selection. We don't do anything if r and range don't intersect.
398         if (r->compareBoundaryPoints(Range::START_TO_END, range.get(), IGNORE_EXCEPTION) > -1) {
399             if (r->compareBoundaryPoints(Range::END_TO_END, range.get(), IGNORE_EXCEPTION) == -1) {
400                 // The original range and r intersect.
401                 selection.moveTo(r->startPosition(), range->endPosition(), DOWNSTREAM);
402             } else {
403                 // r contains the original range.
404                 selection.moveTo(r);
405             }
406         }
407     } else {
408         // We don't support discontiguous selection. We don't do anything if r and range don't intersect.
409         ExceptionCode ec = 0;
410         if (r->compareBoundaryPoints(Range::END_TO_START, range.get(), ec) < 1 && !ec) {
411             if (r->compareBoundaryPoints(Range::END_TO_END, range.get(), IGNORE_EXCEPTION) == -1) {
412                 // The original range contains r.
413                 selection.moveTo(range.get());
414             } else {
415                 // The original range and r intersect.
416                 selection.moveTo(range->startPosition(), r->endPosition(), DOWNSTREAM);
417             }
418         }
419     }
420 }
421
422 void DOMSelection::deleteFromDocument()
423 {
424     if (!m_frame)
425         return;
426
427     FrameSelection& selection = m_frame->selection();
428
429     if (selection.isNone())
430         return;
431
432     if (isCollapsed())
433         selection.modify(FrameSelection::AlterationExtend, DirectionBackward, CharacterGranularity);
434
435     RefPtr<Range> selectedRange = selection.selection().toNormalizedRange();
436     if (!selectedRange)
437         return;
438
439     selectedRange->deleteContents(ASSERT_NO_EXCEPTION);
440
441     setBaseAndExtent(selectedRange->startContainer(ASSERT_NO_EXCEPTION), selectedRange->startOffset(), selectedRange->startContainer(), selectedRange->startOffset(), ASSERT_NO_EXCEPTION);
442 }
443
444 bool DOMSelection::containsNode(Node* n, bool allowPartial) const
445 {
446     if (!m_frame)
447         return false;
448
449     FrameSelection& selection = m_frame->selection();
450
451     if (!n || m_frame->document() != &n->document() || selection.isNone())
452         return false;
453
454     RefPtr<Node> node = n;
455     RefPtr<Range> selectedRange = selection.selection().toNormalizedRange();
456
457     ContainerNode* parentNode = node->parentNode();
458     if (!parentNode || !parentNode->inDocument())
459         return false;
460     unsigned nodeIndex = node->nodeIndex();
461
462     ExceptionCode ec = 0;
463     bool nodeFullySelected = Range::compareBoundaryPoints(parentNode, nodeIndex, selectedRange->startContainer(), selectedRange->startOffset(), ec) >= 0 && !ec
464         && Range::compareBoundaryPoints(parentNode, nodeIndex + 1, selectedRange->endContainer(), selectedRange->endOffset(), ec) <= 0 && !ec;
465     ASSERT(!ec);
466     if (nodeFullySelected)
467         return true;
468
469     bool nodeFullyUnselected = (Range::compareBoundaryPoints(parentNode, nodeIndex, selectedRange->endContainer(), selectedRange->endOffset(), ec) > 0 && !ec)
470         || (Range::compareBoundaryPoints(parentNode, nodeIndex + 1, selectedRange->startContainer(), selectedRange->startOffset(), ec) < 0 && !ec);
471     ASSERT(!ec);
472     if (nodeFullyUnselected)
473         return false;
474
475     return allowPartial || node->isTextNode();
476 }
477
478 void DOMSelection::selectAllChildren(Node* n, ExceptionCode& ec)
479 {
480     if (!n)
481         return;
482
483     // This doesn't (and shouldn't) select text node characters.
484     setBaseAndExtent(n, 0, n, n->countChildNodes(), ec);
485 }
486
487 String DOMSelection::toString()
488 {
489     if (!m_frame)
490         return String();
491
492     return plainText(m_frame->selection().selection().toNormalizedRange().get());
493 }
494
495 Node* DOMSelection::shadowAdjustedNode(const Position& position) const
496 {
497     if (position.isNull())
498         return 0;
499
500     Node* containerNode = position.containerNode();
501     Node* adjustedNode = m_treeScope->ancestorInThisScope(containerNode);
502
503     if (!adjustedNode)
504         return 0;
505
506     if (containerNode == adjustedNode)
507         return containerNode;
508
509     return adjustedNode->parentNodeGuaranteedHostFree();
510 }
511
512 int DOMSelection::shadowAdjustedOffset(const Position& position) const
513 {
514     if (position.isNull())
515         return 0;
516
517     Node* containerNode = position.containerNode();
518     Node* adjustedNode = m_treeScope->ancestorInThisScope(containerNode);
519
520     if (!adjustedNode)
521         return 0;
522
523     if (containerNode == adjustedNode)
524         return position.computeOffsetInContainerNode();
525
526     return adjustedNode->nodeIndex();
527 }
528
529 bool DOMSelection::isValidForPosition(Node* node) const
530 {
531     ASSERT(m_frame);
532     if (!node)
533         return true;
534     return &node->document() == m_frame->document();
535 }
536
537 } // namespace WebCore