f9a4f04bc3675eedf6de1ec4b09e33b24d8bb877
[WebKit-https.git] / WebCore / dom / Text.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23 #include "Text.h"
24
25 #include "ExceptionCode.h"
26 #include "RenderText.h"
27 #include "TextBreakIterator.h"
28 #include <wtf/text/CString.h>
29
30 #if ENABLE(SVG)
31 #include "RenderSVGInlineText.h"
32 #include "SVGNames.h"
33 #endif
34
35 #if ENABLE(WML)
36 #include "WMLDocument.h"
37 #include "WMLVariables.h"
38 #endif
39
40 using namespace std;
41
42 namespace WebCore {
43
44 PassRefPtr<Text> Text::create(Document* document, const String& data)
45 {
46     return adoptRef(new Text(document, data));
47 }
48
49 PassRefPtr<Text> Text::splitText(unsigned offset, ExceptionCode& ec)
50 {
51     ec = 0;
52
53     // INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than
54     // the number of 16-bit units in data.
55     if (offset > length()) {
56         ec = INDEX_SIZE_ERR;
57         return 0;
58     }
59
60     RefPtr<StringImpl> oldStr = dataImpl();
61     RefPtr<Text> newText = virtualCreate(oldStr->substring(offset));
62     setDataImpl(oldStr->substring(0, offset));
63
64     dispatchModifiedEvent(oldStr.get());
65
66     if (parentNode())
67         parentNode()->insertBefore(newText.get(), nextSibling(), ec);
68     if (ec)
69         return 0;
70
71     if (parentNode())
72         document()->textNodeSplit(this);
73
74     if (renderer())
75         toRenderText(renderer())->setTextWithOffset(dataImpl(), 0, oldStr->length());
76
77     return newText.release();
78 }
79
80 static const Text* earliestLogicallyAdjacentTextNode(const Text* t)
81 {
82     const Node* n = t;
83     while ((n = n->previousSibling())) {
84         Node::NodeType type = n->nodeType();
85         if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
86             t = static_cast<const Text*>(n);
87             continue;
88         }
89
90         // We would need to visit EntityReference child text nodes if they existed
91         ASSERT(type != Node::ENTITY_REFERENCE_NODE || !n->hasChildNodes());
92         break;
93     }
94     return t;
95 }
96
97 static const Text* latestLogicallyAdjacentTextNode(const Text* t)
98 {
99     const Node* n = t;
100     while ((n = n->nextSibling())) {
101         Node::NodeType type = n->nodeType();
102         if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
103             t = static_cast<const Text*>(n);
104             continue;
105         }
106
107         // We would need to visit EntityReference child text nodes if they existed
108         ASSERT(type != Node::ENTITY_REFERENCE_NODE || !n->hasChildNodes());
109         break;
110     }
111     return t;
112 }
113
114 String Text::wholeText() const
115 {
116     const Text* startText = earliestLogicallyAdjacentTextNode(this);
117     const Text* endText = latestLogicallyAdjacentTextNode(this);
118
119     Node* onePastEndText = endText->nextSibling();
120     unsigned resultLength = 0;
121     for (const Node* n = startText; n != onePastEndText; n = n->nextSibling()) {
122         if (!n->isTextNode())
123             continue;
124         const Text* t = static_cast<const Text*>(n);
125         const String& data = t->data();
126         if (std::numeric_limits<unsigned>::max() - data.length() < resultLength)
127             CRASH();
128         resultLength += data.length();
129     }
130     UChar* resultData;
131     String result = String::createUninitialized(resultLength, resultData);
132     UChar* p = resultData;
133     for (const Node* n = startText; n != onePastEndText; n = n->nextSibling()) {
134         if (!n->isTextNode())
135             continue;
136         const Text* t = static_cast<const Text*>(n);
137         const String& data = t->data();
138         unsigned dataLength = data.length();
139         memcpy(p, data.characters(), dataLength * sizeof(UChar));
140         p += dataLength;
141     }
142     ASSERT(p == resultData + resultLength);
143
144     return result;
145 }
146
147 PassRefPtr<Text> Text::replaceWholeText(const String& newText, ExceptionCode&)
148 {
149     // Remove all adjacent text nodes, and replace the contents of this one.
150
151     // Protect startText and endText against mutation event handlers removing the last ref
152     RefPtr<Text> startText = const_cast<Text*>(earliestLogicallyAdjacentTextNode(this));
153     RefPtr<Text> endText = const_cast<Text*>(latestLogicallyAdjacentTextNode(this));
154
155     RefPtr<Text> protectedThis(this); // Mutation event handlers could cause our last ref to go away
156     ContainerNode* parent = parentNode(); // Protect against mutation handlers moving this node during traversal
157     ExceptionCode ignored = 0;
158     for (RefPtr<Node> n = startText; n && n != this && n->isTextNode() && n->parentNode() == parent;) {
159         RefPtr<Node> nodeToRemove(n.release());
160         n = nodeToRemove->nextSibling();
161         parent->removeChild(nodeToRemove.get(), ignored);
162     }
163
164     if (this != endText) {
165         Node* onePastEndText = endText->nextSibling();
166         for (RefPtr<Node> n = nextSibling(); n && n != onePastEndText && n->isTextNode() && n->parentNode() == parent;) {
167             RefPtr<Node> nodeToRemove(n.release());
168             n = nodeToRemove->nextSibling();
169             parent->removeChild(nodeToRemove.get(), ignored);
170         }
171     }
172
173     if (newText.isEmpty()) {
174         if (parent && parentNode() == parent)
175             parent->removeChild(this, ignored);
176         return 0;
177     }
178
179     setData(newText, ignored);
180     return protectedThis.release();
181 }
182
183 String Text::nodeName() const
184 {
185     return textAtom.string();
186 }
187
188 Node::NodeType Text::nodeType() const
189 {
190     return TEXT_NODE;
191 }
192
193 PassRefPtr<Node> Text::cloneNode(bool /*deep*/)
194 {
195     return create(document(), data());
196 }
197
198 bool Text::rendererIsNeeded(RenderStyle *style)
199 {
200     if (!CharacterData::rendererIsNeeded(style))
201         return false;
202
203     bool onlyWS = containsOnlyWhitespace();
204     if (!onlyWS)
205         return true;
206
207     RenderObject *par = parentNode()->renderer();
208     
209     if (par->isTable() || par->isTableRow() || par->isTableSection() || par->isTableCol() || par->isFrameSet())
210         return false;
211     
212     if (style->preserveNewline()) // pre/pre-wrap/pre-line always make renderers.
213         return true;
214     
215     RenderObject *prev = previousRenderer();
216     if (prev && prev->isBR()) // <span><br/> <br/></span>
217         return false;
218         
219     if (par->isRenderInline()) {
220         // <span><div/> <div/></span>
221         if (prev && !prev->isInline())
222             return false;
223     } else {
224         if (par->isRenderBlock() && !par->childrenInline() && (!prev || !prev->isInline()))
225             return false;
226         
227         RenderObject *first = par->firstChild();
228         while (first && first->isFloatingOrPositioned())
229             first = first->nextSibling();
230         RenderObject *next = nextRenderer();
231         if (!first || next == first)
232             // Whitespace at the start of a block just goes away.  Don't even
233             // make a render object for this text.
234             return false;
235     }
236     
237     return true;
238 }
239
240 RenderObject* Text::createRenderer(RenderArena* arena, RenderStyle*)
241 {
242     Node* parentOrHost = parentOrHostNode();
243 #if ENABLE(SVG)
244     if (parentOrHost->isSVGElement()
245 #if ENABLE(SVG_FOREIGN_OBJECT)
246         && !parentOrHost->hasTagName(SVGNames::foreignObjectTag)
247 #endif
248     )
249         return new (arena) RenderSVGInlineText(this, dataImpl());
250 #endif
251     
252     return new (arena) RenderText(this, dataImpl());
253 }
254
255 void Text::attach()
256 {
257 #if ENABLE(WML)
258     if (document()->isWMLDocument() && !containsOnlyWhitespace()) {
259         String text = data();
260         ASSERT(!text.isEmpty());
261
262         text = substituteVariableReferences(text, document());
263
264         ExceptionCode code = 0;
265         setData(text, code);
266         ASSERT(!code);
267     }
268 #endif
269
270     createRendererIfNeeded();
271     CharacterData::attach();
272 }
273
274 void Text::recalcStyle(StyleChange change)
275 {
276     if (change != NoChange && parentNode()) {
277         if (renderer())
278             renderer()->setStyle(parentNode()->renderer()->style());
279     }
280     if (needsStyleRecalc()) {
281         if (renderer()) {
282             if (renderer()->isText())
283                 toRenderText(renderer())->setText(dataImpl());
284         } else {
285             if (attached())
286                 detach();
287             attach();
288         }
289     }
290     clearNeedsStyleRecalc();
291 }
292
293 bool Text::childTypeAllowed(NodeType)
294 {
295     return false;
296 }
297
298 PassRefPtr<Text> Text::virtualCreate(const String& data)
299 {
300     return create(document(), data);
301 }
302
303 PassRefPtr<Text> Text::createWithLengthLimit(Document* document, const String& data, unsigned& charsLeft, unsigned maxChars)
304 {
305     unsigned dataLength = data.length();
306
307     if (charsLeft == dataLength && charsLeft <= maxChars) {
308         charsLeft = 0;
309         return create(document, data);
310     }
311
312     unsigned start = dataLength - charsLeft;
313     unsigned end = start + min(charsLeft, maxChars);
314     
315     // Check we are not on an unbreakable boundary.
316     // Some text break iterator implementations work best if the passed buffer is as small as possible, 
317     // see <https://bugs.webkit.org/show_bug.cgi?id=29092>. 
318     // We need at least two characters look-ahead to account for UTF-16 surrogates.
319     if (end < dataLength) {
320         TextBreakIterator* it = characterBreakIterator(data.characters() + start, (end + 2 > dataLength) ? dataLength - start : end - start + 2);
321         if (!isTextBreak(it, end - start))
322             end = textBreakPreceding(it, end - start) + start;
323     }
324     
325     // If we have maxChars of unbreakable characters the above could lead to
326     // an infinite loop.
327     // FIXME: It would be better to just have the old value of end before calling
328     // textBreakPreceding rather than this, because this exceeds the length limit.
329     if (end <= start)
330         end = dataLength;
331     
332     charsLeft = dataLength - end;
333     return create(document, data.substring(start, end - start));
334 }
335
336 #ifndef NDEBUG
337 void Text::formatForDebugger(char *buffer, unsigned length) const
338 {
339     String result;
340     String s;
341     
342     s = nodeName();
343     if (s.length() > 0) {
344         result += s;
345     }
346           
347     s = data();
348     if (s.length() > 0) {
349         if (result.length() > 0)
350             result += "; ";
351         result += "value=";
352         result += s;
353     }
354           
355     strncpy(buffer, result.utf8().data(), length - 1);
356 }
357 #endif
358
359 } // namespace WebCore