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