自学教程：C++ toRenderText函数代码示例

void RenderContainer::addChild(RenderObject* newChild, RenderObject* beforeChild){    bool needsTable = false;    if (newChild->isListItem())        updateListMarkerNumbers(beforeChild ? beforeChild : children()->lastChild());    else if (newChild->isTableCol() && newChild->style()->display() == TABLE_COLUMN_GROUP)        needsTable = !isTable();    else if (newChild->isRenderBlock() && newChild->style()->display() == TABLE_CAPTION)        needsTable = !isTable();    else if (newChild->isTableSection())        needsTable = !isTable();    else if (newChild->isTableRow())        needsTable = !isTableSection();    else if (newChild->isTableCell()) {        needsTable = !isTableRow();        // I'm not 100% sure this is the best way to fix this, but without this        // change we recurse infinitely when trying to render the CSS2 test page:        // http://www.bath.ac.uk/%7Epy8ieh/internet/eviltests/htmlbodyheadrendering2.html.        // See Radar 2925291.        if (needsTable && isTableCell() && !children()->firstChild() && !newChild->isTableCell())            needsTable = false;    }    if (needsTable) {        RenderTable* table;        RenderObject* afterChild = beforeChild ? beforeChild->previousSibling() : children()->lastChild();        if (afterChild && afterChild->isAnonymous() && afterChild->isTable())            table = static_cast<RenderTable*>(afterChild);        else {            table = new (renderArena()) RenderTable(document() /* is anonymous */);            RefPtr<RenderStyle> newStyle = RenderStyle::create();            newStyle->inheritFrom(style());            newStyle->setDisplay(TABLE);            table->setStyle(newStyle.release());            addChild(table, beforeChild);        }        table->addChild(newChild);    } else {        // just add it...        children()->insertChildNode(this, newChild, beforeChild);    }        if (newChild->isText() && newChild->style()->textTransform() == CAPITALIZE) {        RefPtr<StringImpl> textToTransform = toRenderText(newChild)->originalText();        if (textToTransform)            toRenderText(newChild)->setText(textToTransform.release(), true);    }}

void CharacterData::updateRenderer(unsigned offsetOfReplacedData, unsigned lengthOfReplacedData){    if ((!renderer() || !rendererIsNeeded(NodeRenderingContext(this, renderer()->style()))) && attached())        reattach();    else if (renderer())        toRenderText(renderer())->setTextWithOffset(m_data.impl(), offsetOfReplacedData, lengthOfReplacedData);}

void TextAutoSizingValue::addNode(Node* node, float size){    ASSERT(node);    RenderText* renderText = toRenderText(node->renderer());    renderText->setCandidateComputedTextSize(size);    m_autoSizedNodes.add(node);}

void CharacterData::replaceData(unsigned offset, unsigned count, const String& arg, ExceptionCode& ec){    checkCharDataOperation(offset, ec);    if (ec)        return;    unsigned realCount;    if (offset + count > length())        realCount = length() - offset;    else        realCount = count;    String newStr = m_data;    newStr.remove(offset, realCount);    newStr.insert(arg, offset);    RefPtr<StringImpl> oldStr = m_data;    m_data = newStr.impl();    if ((!renderer() || !rendererIsNeeded(renderer()->style())) && attached()) {        detach();        attach();    } else if (renderer())        toRenderText(renderer())->setTextWithOffset(m_data, offset, count);        dispatchModifiedEvent(oldStr.get());        // update the markers for spell checking and grammar checking    document()->textRemoved(this, offset, realCount);    document()->textInserted(this, offset, arg.length());}

PassRefPtr<Text> Text::splitText(unsigned offset, ExceptionState& exceptionState){    // IndexSizeError: Raised if the specified offset is negative or greater than    // the number of 16-bit units in data.    if (offset > length()) {        exceptionState.throwDOMException(IndexSizeError, "The offset " + String::number(offset) + " is larger than the Text node's length.");        return 0;    }    EventQueueScope scope;    String oldStr = data();    RefPtr<Text> newText = cloneWithData(oldStr.substring(offset));    setDataWithoutUpdate(oldStr.substring(0, offset));    didModifyData(oldStr);    if (parentNode())        parentNode()->insertBefore(newText.get(), nextSibling(), exceptionState);    if (exceptionState.hadException())        return 0;    if (renderer())        toRenderText(renderer())->setTextWithOffset(dataImpl(), 0, oldStr.length());    if (parentNode())        document().didSplitTextNode(this);    return newText.release();}

bool hitTestFlow(const RenderBlockFlow& flow, const Layout& layout, const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction){    if (hitTestAction != HitTestForeground)        return false;    if (!layout.runCount())        return false;    RenderStyle& style = flow.style();    if (style.visibility() != VISIBLE || style.pointerEvents() == PE_NONE)        return false;    RenderText& textRenderer = toRenderText(*flow.firstChild());    LayoutRect rangeRect = locationInContainer.boundingBox();    rangeRect.moveBy(-accumulatedOffset);    auto resolver = lineResolver(flow, layout);    auto range = resolver.rangeForRect(rangeRect);    for (auto it = range.begin(), end = range.end(); it != end; ++it) {        auto lineRect = *it;        lineRect.moveBy(accumulatedOffset);        if (!locationInContainer.intersects(lineRect))            continue;        textRenderer.updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));        if (!result.addNodeToRectBasedTestResult(textRenderer.textNode(), request, locationInContainer, lineRect))            return true;    }    return false;}

PassRefPtr<Text> Text::splitText(unsigned offset, ExceptionCode& ec){    ec = 0;    // INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than    // the number of 16-bit units in data.    if (offset > m_data->length()) {        ec = INDEX_SIZE_ERR;        return 0;    }    RefPtr<StringImpl> oldStr = m_data;    RefPtr<Text> newText = createNew(oldStr->substring(offset));    m_data = oldStr->substring(0, offset);    dispatchModifiedEvent(oldStr.get());    if (parentNode())        parentNode()->insertBefore(newText.get(), nextSibling(), ec);    if (ec)        return 0;    if (parentNode())        document()->textNodeSplit(this);    if (renderer())        toRenderText(renderer())->setText(m_data);    return newText.release();}

void CharacterData::updateRenderer(unsigned offsetOfReplacedData, unsigned lengthOfReplacedData){    if ((!renderer() || !rendererIsNeeded(renderer()->style())) && attached()) {        detach();        attach();    } else if (renderer())        toRenderText(renderer())->setTextWithOffset(m_data, offsetOfReplacedData, lengthOfReplacedData);}

RenderSelectionInfo::RenderSelectionInfo(RenderObject& renderer, bool clipToVisibleContent)    : RenderSelectionInfoBase(renderer){    if (renderer.canUpdateSelectionOnRootLineBoxes()) {        if (renderer.isText())            m_rect = toRenderText(renderer).collectSelectionRectsForLineBoxes(m_repaintContainer, clipToVisibleContent, m_collectedSelectionRects);        else            m_rect = renderer.selectionRectForRepaint(m_repaintContainer, clipToVisibleContent);    }}

void RenderRubyRun::getOverhang(bool firstLine, RenderObject* startRenderer, RenderObject* endRenderer, int& startOverhang, int& endOverhang) const{    ASSERT(!needsLayout());    startOverhang = 0;    endOverhang = 0;    RenderRubyBase* rubyBase = this->rubyBase();    RenderRubyText* rubyText = this->rubyText();    if (!rubyBase || !rubyText)        return;    if (!rubyBase->firstRootBox())        return;    int logicalWidth = this->logicalWidth();    int logicalLeftOverhang = numeric_limits<int>::max();    int logicalRightOverhang = numeric_limits<int>::max();    for (RootInlineBox* rootInlineBox = rubyBase->firstRootBox(); rootInlineBox; rootInlineBox = rootInlineBox->nextRootBox()) {        logicalLeftOverhang = min<int>(logicalLeftOverhang, rootInlineBox->logicalLeft());        logicalRightOverhang = min<int>(logicalRightOverhang, logicalWidth - rootInlineBox->logicalRight());    }    startOverhang = style()->isLeftToRightDirection() ? logicalLeftOverhang : logicalRightOverhang;    endOverhang = style()->isLeftToRightDirection() ? logicalRightOverhang : logicalLeftOverhang;    if (!startRenderer || !startRenderer->isText() || startRenderer->style(firstLine)->fontSize() > rubyBase->style(firstLine)->fontSize())        startOverhang = 0;    if (!endRenderer || !endRenderer->isText() || endRenderer->style(firstLine)->fontSize() > rubyBase->style(firstLine)->fontSize())        endOverhang = 0;    // We overhang a ruby only if the neighboring render object is a text.    // We can overhang the ruby by no more than half the width of the neighboring text    // and no more than half the font size.    int halfWidthOfFontSize = rubyText->style(firstLine)->fontSize() / 2;    if (startOverhang)        startOverhang = min<int>(startOverhang, min<int>(toRenderText(startRenderer)->minLogicalWidth(), halfWidthOfFontSize));    if (endOverhang)        endOverhang = min<int>(endOverhang, min<int>(toRenderText(endRenderer)->minLogicalWidth(), halfWidthOfFontSize));}

void Text::updateTextRenderer(unsigned offsetOfReplacedData, unsigned lengthOfReplacedData){    if (!attached())        return;    RenderText* textRenderer = toRenderText(renderer());    if (!textRenderer || !textRendererIsNeeded(NodeRenderingContext(this, textRenderer->style()))) {        reattach();        return;    }    textRenderer->setTextWithOffset(dataImpl(), offsetOfReplacedData, lengthOfReplacedData);}

BidiRun::BidiRun(int start, int stop, RenderObject& renderer, BidiContext* context, UCharDirection dir)    : BidiCharacterRun(start, stop, context, dir)    , m_renderer(renderer)    , m_box(nullptr){#ifndef NDEBUG    bidiRunCounter.increment();#endif    ASSERT(!m_renderer.isText() || static_cast<unsigned>(stop) <= toRenderText(m_renderer).textLength());    // Stored in base class to save space.    m_hasHyphen = false;}

static void writeCounterValuesFromChildren(TextStream& stream, RenderObject* parent, bool& isFirstCounter){    for (RenderObject* child = parent->firstChild(); child; child = child->nextSibling()) {        if (child->isCounter()) {            if (!isFirstCounter)                stream << " ";            isFirstCounter = false;            String str(toRenderText(child)->text());            stream << str;        }    }}

void Text::recalcTextStyle(StyleRecalcChange change, Text* nextTextSibling){    if (RenderText* renderer = toRenderText(this->renderer())) {        if (change != NoChange || needsStyleRecalc())            renderer->setStyle(document().ensureStyleResolver().styleForText(this));        if (needsStyleRecalc())            renderer->setText(dataImpl());        clearNeedsStyleRecalc();    } else if (needsStyleRecalc() || needsWhitespaceRenderer()) {        reattach();        reattachWhitespaceSiblings(nextTextSibling);    }}

bool Text::recalcTextStyle(StyleChange change){    if (RenderText* renderer = toRenderText(this->renderer())) {        if (change != NoChange || needsStyleRecalc())            renderer->setStyle(document()->styleResolver()->styleForText(this));        if (needsStyleRecalc())            renderer->setText(dataImpl());        clearNeedsStyleRecalc();    } else if (needsStyleRecalc() || needsWhitespaceRenderer()) {        reattach();        return true;    }    return false;}

int Paragraph::absoluteOffsetForPosition(const PositionWithAffinity& position) {  DCHECK(position.renderer());  unsigned offset = 0;  for (RenderObject* object = m_renderView.get(); object; object = object->nextInPreOrder()) {    if (object == position.renderer())      return offset + position.offset();    if (object->isText()) {      RenderText* text = toRenderText(object);      offset += text->textLength();    }  }  DCHECK(false);  return 0;}

void Text::updateTextRenderer(unsigned offsetOfReplacedData, unsigned lengthOfReplacedData, RecalcStyleBehavior recalcStyleBehavior){    if (!inActiveDocument())        return;    RenderText* textRenderer = toRenderText(renderer());    if (!textRenderer || !textRendererIsNeeded(*textRenderer->style(), *textRenderer->parent())) {        lazyReattachIfAttached();        // FIXME: Editing should be updated so this is not neccesary.        if (recalcStyleBehavior == DeprecatedRecalcStyleImmediatlelyForEditing)            document().updateStyleIfNeeded();        return;    }    textRenderer->setTextWithOffset(dataImpl(), offsetOfReplacedData, lengthOfReplacedData);}

void Text::recalcTextStyle(StyleChange change){    RenderText* renderer = toRenderText(this->renderer());    if (change != NoChange && renderer)        renderer->setStyle(document()->ensureStyleResolver()->styleForText(this));    if (needsStyleRecalc()) {        if (renderer)            renderer->setText(dataImpl());        else            reattach();    }    clearNeedsStyleRecalc();}

void Text::recalcStyle(StyleChange change){    if (change != NoChange && parentNode()) {        if (renderer())            renderer()->setStyle(parentNode()->renderer()->style());    }    if (needsStyleRecalc()) {        if (renderer()) {            if (renderer()->isText())                toRenderText(renderer())->setText(dataImpl());        } else            reattach();    }    clearNeedsStyleRecalc();}

void CharacterData::appendData(const String& arg, ExceptionCode&){    String newStr = m_data;    newStr.append(arg);    RefPtr<StringImpl> oldStr = m_data;    m_data = newStr.impl();    if ((!renderer() || !rendererIsNeeded(renderer()->style())) && attached()) {        detach();        attach();    } else if (renderer())        toRenderText(renderer())->setTextWithOffset(m_data, oldStr->length(), 0);        dispatchModifiedEvent(oldStr.get());}

std::unique_ptr<Layout> create(RenderBlockFlow& flow){    Layout::RunVector runs;    unsigned lineCount = 0;    RenderText& textRenderer = toRenderText(*flow.firstChild());    ASSERT(!textRenderer.firstTextBox());    if (textRenderer.is8Bit())        createTextRuns<LChar>(runs, lineCount, flow, textRenderer);    else        createTextRuns<UChar>(runs, lineCount, flow, textRenderer);    textRenderer.clearNeedsLayout();    return Layout::create(runs, lineCount);}

void InsertIntoTextNodeCommand::doApply(){    if (!m_node->rendererIsEditable())        return;    if (document()->settings() && document()->settings()->passwordEchoEnabled()) {        RenderText* renderText = toRenderText(m_node->renderer());        if (renderText && renderText->isSecure())            renderText->momentarilyRevealLastTypedCharacter(m_offset + m_text.length() - 1);    }    ExceptionCode ec;    m_node->insertData(m_offset, m_text, ec);    if (AXObjectCache::accessibilityEnabled())        document()->axObjectCache()->nodeTextChangeNotification(m_node->renderer(), AXObjectCache::AXTextInserted, m_offset, m_text.length());}

void InsertIntoTextNodeCommand::doApply(){    bool passwordEchoEnabled = document().settings() && document().settings()->passwordEchoEnabled();    if (passwordEchoEnabled)        document().updateLayoutIgnorePendingStylesheets();    if (!m_node->rendererIsEditable())        return;    if (passwordEchoEnabled) {        RenderText* renderText = toRenderText(m_node->renderer());        if (renderText && renderText->isSecure())            renderText->momentarilyRevealLastTypedCharacter(m_offset + m_text.length() - 1);    }    m_node->insertData(m_offset, m_text, IGNORE_EXCEPTION, CharacterData::DeprecatedRecalcStyleImmediatlelyForEditing);}