490e13fe495d37aefff0d5bae41b92d5cb431da3
[WebKit-https.git] / Source / 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 "NodeRenderingContext.h"
27 #include "RenderCombineText.h"
28 #include "RenderText.h"
29
30 #if ENABLE(SVG)
31 #include "RenderSVGInlineText.h"
32 #include "SVGNames.h"
33 #endif
34
35 #include <wtf/text/CString.h>
36
37 using namespace std;
38
39 namespace WebCore {
40
41 PassRefPtr<Text> Text::create(Document* document, const String& data)
42 {
43     return adoptRef(new Text(document, data));
44 }
45
46 PassRefPtr<Text> Text::splitText(unsigned offset, ExceptionCode& ec)
47 {
48     ec = 0;
49
50     // INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than
51     // the number of 16-bit units in data.
52     if (offset > length()) {
53         ec = INDEX_SIZE_ERR;
54         return 0;
55     }
56
57     RefPtr<StringImpl> oldStr = dataImpl();
58     RefPtr<Text> newText = virtualCreate(oldStr->substring(offset));
59     setDataImpl(oldStr->substring(0, offset));
60
61     dispatchModifiedEvent(oldStr.get());
62
63     if (parentNode())
64         parentNode()->insertBefore(newText.get(), nextSibling(), ec);
65     if (ec)
66         return 0;
67
68     if (parentNode())
69         document()->textNodeSplit(this);
70
71     if (renderer())
72         toRenderText(renderer())->setTextWithOffset(dataImpl(), 0, oldStr->length());
73
74     return newText.release();
75 }
76
77 static const Text* earliestLogicallyAdjacentTextNode(const Text* t)
78 {
79     const Node* n = t;
80     while ((n = n->previousSibling())) {
81         Node::NodeType type = n->nodeType();
82         if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
83             t = static_cast<const Text*>(n);
84             continue;
85         }
86
87         // We would need to visit EntityReference child text nodes if they existed
88         ASSERT(type != Node::ENTITY_REFERENCE_NODE || !n->hasChildNodes());
89         break;
90     }
91     return t;
92 }
93
94 static const Text* latestLogicallyAdjacentTextNode(const Text* t)
95 {
96     const Node* n = t;
97     while ((n = n->nextSibling())) {
98         Node::NodeType type = n->nodeType();
99         if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
100             t = static_cast<const Text*>(n);
101             continue;
102         }
103
104         // We would need to visit EntityReference child text nodes if they existed
105         ASSERT(type != Node::ENTITY_REFERENCE_NODE || !n->hasChildNodes());
106         break;
107     }
108     return t;
109 }
110
111 String Text::wholeText() const
112 {
113     const Text* startText = earliestLogicallyAdjacentTextNode(this);
114     const Text* endText = latestLogicallyAdjacentTextNode(this);
115
116     Node* onePastEndText = endText->nextSibling();
117     unsigned resultLength = 0;
118     for (const Node* n = startText; n != onePastEndText; n = n->nextSibling()) {
119         if (!n->isTextNode())
120             continue;
121         const Text* t = static_cast<const Text*>(n);
122         const String& data = t->data();
123         if (std::numeric_limits<unsigned>::max() - data.length() < resultLength)
124             CRASH();
125         resultLength += data.length();
126     }
127     UChar* resultData;
128     String result = String::createUninitialized(resultLength, resultData);
129     UChar* p = resultData;
130     for (const Node* n = startText; n != onePastEndText; n = n->nextSibling()) {
131         if (!n->isTextNode())
132             continue;
133         const Text* t = static_cast<const Text*>(n);
134         const String& data = t->data();
135         unsigned dataLength = data.length();
136         memcpy(p, data.characters(), dataLength * sizeof(UChar));
137         p += dataLength;
138     }
139     ASSERT(p == resultData + resultLength);
140
141     return result;
142 }
143
144 PassRefPtr<Text> Text::replaceWholeText(const String& newText, ExceptionCode&)
145 {
146     // Remove all adjacent text nodes, and replace the contents of this one.
147
148     // Protect startText and endText against mutation event handlers removing the last ref
149     RefPtr<Text> startText = const_cast<Text*>(earliestLogicallyAdjacentTextNode(this));
150     RefPtr<Text> endText = const_cast<Text*>(latestLogicallyAdjacentTextNode(this));
151
152     RefPtr<Text> protectedThis(this); // Mutation event handlers could cause our last ref to go away
153     ContainerNode* parent = parentNode(); // Protect against mutation handlers moving this node during traversal
154     ExceptionCode ignored = 0;
155     for (RefPtr<Node> n = startText; n && n != this && n->isTextNode() && n->parentNode() == parent;) {
156         RefPtr<Node> nodeToRemove(n.release());
157         n = nodeToRemove->nextSibling();
158         parent->removeChild(nodeToRemove.get(), ignored);
159     }
160
161     if (this != endText) {
162         Node* onePastEndText = endText->nextSibling();
163         for (RefPtr<Node> n = nextSibling(); n && n != onePastEndText && n->isTextNode() && n->parentNode() == parent;) {
164             RefPtr<Node> nodeToRemove(n.release());
165             n = nodeToRemove->nextSibling();
166             parent->removeChild(nodeToRemove.get(), ignored);
167         }
168     }
169
170     if (newText.isEmpty()) {
171         if (parent && parentNode() == parent)
172             parent->removeChild(this, ignored);
173         return 0;
174     }
175
176     setData(newText, ignored);
177     return protectedThis.release();
178 }
179
180 String Text::nodeName() const
181 {
182     return textAtom.string();
183 }
184
185 Node::NodeType Text::nodeType() const
186 {
187     return TEXT_NODE;
188 }
189
190 PassRefPtr<Node> Text::cloneNode(bool /*deep*/)
191 {
192     return create(document(), data());
193 }
194
195 bool Text::rendererIsNeeded(const NodeRenderingContext& context)
196 {
197     if (!CharacterData::rendererIsNeeded(context))
198         return false;
199
200     bool onlyWS = containsOnlyWhitespace();
201     if (!onlyWS)
202         return true;
203
204     RenderObject* par = context.parentRenderer();
205     if (par->isTable() || par->isTableRow() || par->isTableSection() || par->isTableCol() || par->isFrameSet())
206         return false;
207     
208     if (context.style()->preserveNewline()) // pre/pre-wrap/pre-line always make renderers.
209         return true;
210     
211     RenderObject* prev = context.previousRenderer();
212     if (prev && prev->isBR()) // <span><br/> <br/></span>
213         return false;
214         
215     if (par->isRenderInline()) {
216         // <span><div/> <div/></span>
217         if (prev && !prev->isInline())
218             return false;
219     } else {
220         if (par->isRenderBlock() && !par->childrenInline() && (!prev || !prev->isInline()))
221             return false;
222         
223         RenderObject* first = par->firstChild();
224         while (first && first->isFloatingOrPositioned())
225             first = first->nextSibling();
226         RenderObject* next = context.nextRenderer();
227         if (!first || next == first)
228             // Whitespace at the start of a block just goes away.  Don't even
229             // make a render object for this text.
230             return false;
231     }
232     
233     return true;
234 }
235
236 RenderObject* Text::createRenderer(RenderArena* arena, RenderStyle* style)
237 {
238 #if ENABLE(SVG)
239     Node* parentOrHost = parentOrHostNode();
240     if (parentOrHost->isSVGElement()
241 #if ENABLE(SVG_FOREIGN_OBJECT)
242         && !parentOrHost->hasTagName(SVGNames::foreignObjectTag)
243 #endif
244     )
245         return new (arena) RenderSVGInlineText(this, dataImpl());
246 #endif
247
248     if (style->hasTextCombine())
249         return new (arena) RenderCombineText(this, dataImpl());
250
251     return new (arena) RenderText(this, dataImpl());
252 }
253
254 void Text::attach()
255 {
256     createRendererIfNeeded();
257     CharacterData::attach();
258 }
259
260 void Text::recalcStyle(StyleChange change)
261 {
262     if (change != NoChange && parentNode() && parentNode()->renderer()) {
263         if (renderer())
264             renderer()->setStyle(parentNode()->renderer()->style());
265     }
266     if (needsStyleRecalc()) {
267         if (renderer()) {
268             if (renderer()->isText())
269                 toRenderText(renderer())->setText(dataImpl());
270         } else
271             reattach();
272     }
273     clearNeedsStyleRecalc();
274 }
275
276 bool Text::childTypeAllowed(NodeType) const
277 {
278     return false;
279 }
280
281 PassRefPtr<Text> Text::virtualCreate(const String& data)
282 {
283     return create(document(), data);
284 }
285
286 PassRefPtr<Text> Text::createWithLengthLimit(Document* document, const String& data, unsigned start, unsigned maxChars)
287 {
288     unsigned dataLength = data.length();
289
290     if (!start && dataLength <= maxChars)
291         return create(document, data);
292
293     RefPtr<Text> result = Text::create(document, String());
294     result->parserAppendData(data.characters() + start, dataLength - start, maxChars);
295
296     return result;
297 }
298
299 #ifndef NDEBUG
300 void Text::formatForDebugger(char *buffer, unsigned length) const
301 {
302     String result;
303     String s;
304     
305     s = nodeName();
306     if (s.length() > 0) {
307         result += s;
308     }
309           
310     s = data();
311     if (s.length() > 0) {
312         if (result.length() > 0)
313             result += "; ";
314         result += "value=";
315         result += s;
316     }
317           
318     strncpy(buffer, result.utf8().data(), length - 1);
319 }
320 #endif
321
322 } // namespace WebCore