static inline void appendContextSubtargetsForNode(Node* node, SubtargetGeometryList& subtargets)
{
// This is a variant of appendBasicSubtargetsForNode that adds special subtargets for
// selected or auto-selectable parts of text nodes.
ASSERT(node->renderer());
if (!node->isTextNode())
return appendBasicSubtargetsForNode(node, subtargets);
Text* textNode = static_cast<WebCore::Text*>(node);
RenderText* textRenderer = static_cast<RenderText*>(textNode->renderer());
if (textRenderer->frame()->editor()->behavior().shouldSelectOnContextualMenuClick()) {
// Make subtargets out of every word.
String textValue = textNode->data();
TextBreakIterator* wordIterator = wordBreakIterator(textValue.characters(), textValue.length());
int lastOffset = textBreakFirst(wordIterator);
if (lastOffset == -1)
return;
int offset;
while ((offset = textBreakNext(wordIterator)) != -1) {
if (isWordTextBreak(wordIterator)) {
Vector<FloatQuad> quads;
textRenderer->absoluteQuadsForRange(quads, lastOffset, offset);
appendQuadsToSubtargetList(quads, textNode, subtargets);
}
lastOffset = offset;
}
} else {
if (textRenderer->selectionState() == RenderObject::SelectionNone)
return appendBasicSubtargetsForNode(node, subtargets);
// If selected, make subtargets out of only the selected part of the text.
int startPos, endPos;
switch (textRenderer->selectionState()) {
case RenderObject::SelectionInside:
startPos = 0;
endPos = textRenderer->textLength();
break;
case RenderObject::SelectionStart:
textRenderer->selectionStartEnd(startPos, endPos);
endPos = textRenderer->textLength();
break;
case RenderObject::SelectionEnd:
textRenderer->selectionStartEnd(startPos, endPos);
startPos = 0;
break;
case RenderObject::SelectionBoth:
textRenderer->selectionStartEnd(startPos, endPos);
break;
default:
ASSERT_NOT_REACHED();
return;
}
Vector<FloatQuad> quads;
textRenderer->absoluteQuadsForRange(quads, startPos, endPos);
appendQuadsToSubtargetList(quads, textNode, subtargets);
}
}
static float textWidth(const RenderText& text, unsigned from, unsigned length, float xPosition, const RenderStyle& style)
{
if (style.font().isFixedPitch() || (!from && length == text.textLength()))
return text.width(from, length, style.font(), xPosition, nullptr, nullptr);
// FIXME: Add templated UChar/LChar paths.
TextRun run = text.is8Bit() ? TextRun(text.characters8() + from, length) : TextRun(text.characters16() + from, length);
run.setCharactersLength(text.textLength() - from);
ASSERT(run.charactersLength() >= run.length());
run.setXPos(xPosition);
return style.font().width(run);
}
TextRun SVGInlineTextBox::constructTextRun(RenderStyle* style, const SVGTextFragment& fragment) const
{
ASSERT(style);
ASSERT(textRenderer());
RenderText* text = textRenderer();
ASSERT(text);
TextRun run(text->characters() + fragment.characterOffset
, fragment.length
, false /* allowTabs */
, 0 /* xPos, only relevant with allowTabs=true */
, 0 /* padding, only relevant for justified text, not relevant for SVG */
, TextRun::AllowTrailingExpansion
, direction()
, m_dirOverride || style->rtlOrdering() == VisualOrder /* directionalOverride */);
if (textRunNeedsRenderingContext(style->font()))
run.setRenderingContext(SVGTextRunRenderingContext::create(text));
run.disableRoundingHacks();
// We handle letter & word spacing ourselves.
run.disableSpacing();
// Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
run.setCharactersLength(text->textLength() - fragment.characterOffset);
ASSERT(run.charactersLength() >= run.length());
return run;
}
TextRun SVGInlineTextBox::constructTextRun(RenderStyle* style, const SVGTextFragment& fragment) const
{
ASSERT(style);
RenderText* text = &renderer();
// FIXME(crbug.com/264211): This should not be necessary but can occur if we
// layout during layout. Remove this when 264211 is fixed.
RELEASE_ASSERT(!text->needsLayout());
TextRun run(static_cast<const LChar*>(0) // characters, will be set below if non-zero.
, 0 // length, will be set below if non-zero.
, 0 // xPos, only relevant with allowTabs=true
, 0 // padding, only relevant for justified text, not relevant for SVG
, TextRun::AllowTrailingExpansion
, direction()
, dirOverride() || style->rtlOrdering() == VisualOrder /* directionalOverride */);
if (fragment.length) {
if (text->is8Bit())
run.setText(text->characters8() + fragment.characterOffset, fragment.length);
else
run.setText(text->characters16() + fragment.characterOffset, fragment.length);
}
// We handle letter & word spacing ourselves.
run.disableSpacing();
// Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
run.setCharactersLength(text->textLength() - fragment.characterOffset);
ASSERT(run.charactersLength() >= run.length());
return run;
}
static PangoLayout* getPangoLayoutForAtk(AtkText* textObject)
{
AccessibilityObject* coreObject = core(textObject);
HostWindow* hostWindow = coreObject->document()->view()->hostWindow();
if (!hostWindow)
return 0;
PlatformPageClient webView = hostWindow->platformPageClient();
if (!webView)
return 0;
GString* str = g_string_new(NULL);
AccessibilityRenderObject* accObject = static_cast<AccessibilityRenderObject*>(coreObject);
if (!accObject)
return 0;
RenderText* renderText = toRenderText(accObject->renderer());
if (!renderText)
return 0;
// Create a string with the layout as it appears on the screen
InlineTextBox* box = renderText->firstTextBox();
while (box) {
gchar *text = convertUniCharToUTF8(renderText->characters(), renderText->textLength(), box->start(), box->end());
g_string_append(str, text);
g_string_append(str, "\n");
box = box->nextTextBox();
}
PangoLayout* layout = gtk_widget_create_pango_layout(static_cast<GtkWidget*>(webView), g_string_free(str, FALSE));
g_object_set_data_full(G_OBJECT(textObject), "webkit-accessible-pango-layout", layout, g_object_unref);
return layout;
}
int RenderTextLineBoxes::caretMaxOffset(const RenderText& renderer) const
{
auto box = m_last;
if (!box)
return renderer.textLength();
int maxOffset = box->start() + box->len();
for (box = box->prevTextBox(); box; box = box->prevTextBox())
maxOffset = std::max<int>(maxOffset, box->start() + box->len());
return maxOffset;
}
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;
}
VisiblePosition RenderTextLineBoxes::positionForPoint(const RenderText& renderer, const LayoutPoint& point) const
{
if (!m_first || !renderer.textLength())
return renderer.createVisiblePosition(0, DOWNSTREAM);
LayoutUnit pointLineDirection = m_first->isHorizontal() ? point.x() : point.y();
LayoutUnit pointBlockDirection = m_first->isHorizontal() ? point.y() : point.x();
bool blocksAreFlipped = renderer.style().isFlippedBlocksWritingMode();
InlineTextBox* lastBox = nullptr;
for (auto box = m_first; box; box = box->nextTextBox()) {
if (box->isLineBreak() && !box->prevLeafChild() && box->nextLeafChild() && !box->nextLeafChild()->isLineBreak())
box = box->nextTextBox();
auto& rootBox = box->root();
LayoutUnit top = std::min(rootBox.selectionTop(), rootBox.lineTop());
if (pointBlockDirection > top || (!blocksAreFlipped && pointBlockDirection == top)) {
LayoutUnit bottom = rootBox.selectionBottom();
if (rootBox.nextRootBox())
bottom = std::min(bottom, rootBox.nextRootBox()->lineTop());
if (pointBlockDirection < bottom || (blocksAreFlipped && pointBlockDirection == bottom)) {
ShouldAffinityBeDownstream shouldAffinityBeDownstream;
#if PLATFORM(IOS)
if (pointLineDirection != box->logicalLeft() && point.x() < box->x() + box->logicalWidth()) {
int half = box->x() + box->logicalWidth() / 2;
EAffinity affinity = point.x() < half ? DOWNSTREAM : VP_UPSTREAM_IF_POSSIBLE;
return renderer.createVisiblePosition(box->offsetForPosition(pointLineDirection) + box->start(), affinity);
}
#endif
if (lineDirectionPointFitsInBox(pointLineDirection, *box, shouldAffinityBeDownstream))
return createVisiblePositionAfterAdjustingOffsetForBiDi(*box, box->offsetForPosition(pointLineDirection), shouldAffinityBeDownstream);
}
}
lastBox = box;
}
if (lastBox) {
ShouldAffinityBeDownstream shouldAffinityBeDownstream;
lineDirectionPointFitsInBox(pointLineDirection, *lastBox, shouldAffinityBeDownstream);
return createVisiblePositionAfterAdjustingOffsetForBiDi(*lastBox, lastBox->offsetForPosition(pointLineDirection) + lastBox->start(), shouldAffinityBeDownstream);
}
return renderer.createVisiblePosition(0, DOWNSTREAM);
}
void createTextRuns(Layout::RunVector& runs, unsigned& lineCount, RenderBlockFlow& flow, RenderText& textRenderer)
{
const Style style(flow.style());
const CharacterType* text = textRenderer.text()->characters<CharacterType>();
const unsigned textLength = textRenderer.textLength();
LayoutUnit borderAndPaddingBefore = flow.borderAndPaddingBefore();
LayoutUnit lineHeight = lineHeightFromFlow(flow);
LazyLineBreakIterator lineBreakIterator(textRenderer.text(), flow.style().locale());
unsigned lineEnd = 0;
while (lineEnd < textLength) {
if (style.collapseWhitespace)
lineEnd = skipWhitespaces(text, lineEnd, textLength, style.preserveNewline);
unsigned lineStart = lineEnd;
// LineWidth reads the current y position from the flow so keep it updated.
flow.setLogicalHeight(lineHeight * lineCount + borderAndPaddingBefore);
LineWidth lineWidth(flow, false, DoNotIndentText);
auto lineRuns = createLineRuns(lineStart, lineWidth, lineBreakIterator, style, text, textLength, textRenderer);
lineEnd = lineRuns.last().end;
if (lineStart == lineEnd)
continue;
lineRuns.last().isEndOfLine = true;
float lineLeft = computeLineLeft(style.textAlign, lineWidth);
adjustRunOffsets(lineRuns, lineLeft);
for (unsigned i = 0; i < lineRuns.size(); ++i)
runs.append(lineRuns[i]);
++lineCount;
}
}
unsigned AccessibilityObject::getLengthForTextRange() const
{
unsigned textLength = text().length();
if (textLength)
return textLength;
// Gtk ATs need this for all text objects; not just text controls.
Node* node = this->node();
RenderObject* renderer = node ? node->renderer() : 0;
if (renderer && renderer->isText()) {
RenderText* renderText = toRenderText(renderer);
textLength = renderText ? renderText->textLength() : 0;
}
// Get the text length from the elements under the
// accessibility object if the value is still zero.
if (!textLength && allowsTextRanges())
textLength = textUnderElement().length();
return textLength;
}
std::vector<TextBox> Paragraph::getRectsForRange(unsigned start, unsigned end) {
if (end <= start || start == end)
return std::vector<TextBox>();
unsigned offset = 0;
std::vector<TextBox> boxes;
for (RenderObject* object = m_renderView.get(); object; object = object->nextInPreOrder()) {
if (!object->isText())
continue;
RenderText* text = toRenderText(object);
unsigned length = text->textLength();
if (offset + length > start) {
unsigned startOffset = offset > start ? 0 : start - offset;
unsigned endOffset = end - offset;
text->appendAbsoluteTextBoxesForRange(boxes, startOffset, endOffset);
}
offset += length;
if (offset >= end)
break;
}
return boxes;
}
void RenderTextLineBoxes::setSelectionState(RenderText& renderer, RenderObject::SelectionState state)
{
if (state == RenderObject::SelectionInside || state == RenderObject::SelectionNone) {
for (auto box = m_first; box; box = box->nextTextBox())
box->root().setHasSelectedChildren(state == RenderObject::SelectionInside);
return;
}
int start, end;
renderer.selectionStartEnd(start, end);
if (state == RenderObject::SelectionStart) {
end = renderer.textLength();
// to handle selection from end of text to end of line
if (start && start == end)
start = end - 1;
} else if (state == RenderObject::SelectionEnd)
start = 0;
for (auto box = m_first; box; box = box->nextTextBox()) {
if (box->isSelected(start, end))
box->root().setHasSelectedChildren(true);
}
}
static bool canUseForText(const RenderText& textRenderer, const SimpleFontData& fontData)
{
if (textRenderer.is8Bit())
return canUseForText(textRenderer.characters8(), textRenderer.textLength(), fontData);
return canUseForText(textRenderer.characters16(), textRenderer.textLength(), fontData);
}
Vector<FloatQuad> RenderTextLineBoxes::absoluteQuads(const RenderText& renderer, bool* wasFixed, ClippingOption option) const
{
Vector<FloatQuad> quads;
for (auto box = m_first; box; box = box->nextTextBox()) {
FloatRect boundaries = box->calculateBoundaries();
// Shorten the width of this text box if it ends in an ellipsis.
// FIXME: ellipsisRectForBox should switch to return FloatRect soon with the subpixellayout branch.
IntRect ellipsisRect = (option == ClipToEllipsis) ? ellipsisRectForBox(*box, 0, renderer.textLength()) : IntRect();
if (!ellipsisRect.isEmpty()) {
if (renderer.style().isHorizontalWritingMode())
boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
else
boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
}
quads.append(renderer.localToAbsoluteQuad(boundaries, 0, wasFixed));
}
return quads;
}
static int placePositionedBoxesHorizontally(InlineFlowBox* flow, int x, int& leftPosition, int& rightPosition, int& leftAlign, int& rightAlign, bool& needsWordSpacing, int xPos, bool positioned)
{
int mn = INT_MAX;
int mx = INT_MIN;
int amn = INT_MAX;
int amx = INT_MIN;
int startx = x;
bool seenPositionedElement = false;
flow->setXPos(x);
for (InlineBox* curr = flow->firstChild(); curr; curr = curr->nextOnLine()) {
if (curr->object()->isText()) {
mn = min(mn, x);
amn = min(amn, x);
InlineTextBox* text = static_cast<InlineTextBox*>(curr);
RenderText* rt = static_cast<RenderText*>(text->object());
if (rt->textLength()) {
if (needsWordSpacing && DeprecatedChar(rt->characters()[text->start()]).isSpace())
x += rt->style(flow->isFirstLineStyle())->font().wordSpacing();
needsWordSpacing = !DeprecatedChar(rt->characters()[text->end()]).isSpace();
}
text->setXPos(x);
x += text->width();
mx = max(mx, x);
amx = max(amx, x);
} else if (curr->object()->isInlineFlow()) {
InlineFlowBox* flow = static_cast<InlineFlowBox*>(curr);
if (flow->object()->element()->hasTagName(aTag)) {
x = placePositionedBoxesHorizontally(flow, x, mn, mx, amn, amx, needsWordSpacing, xPos, false);
} else {
SVGTextPositioningElement* text = static_cast<SVGTextPositioningElement*>(flow->object()->element());
x += (int)(text->dx()->getFirst().value());
if (text->x()->numberOfItems() > 0)
x = (int)(text->x()->getFirst().value() - xPos);
if (text->x()->numberOfItems() > 0 || text->y()->numberOfItems() > 0 ||
text->dx()->numberOfItems() > 0 || text->dy()->numberOfItems() > 0) {
seenPositionedElement = true;
needsWordSpacing = false;
int ignoreX, ignoreY;
x = placePositionedBoxesHorizontally(flow, x, mn, mx, ignoreX, ignoreY, needsWordSpacing, xPos, true);
} else if (seenPositionedElement) {
int ignoreX, ignoreY;
x = placePositionedBoxesHorizontally(flow, x, mn, mx, ignoreX, ignoreY, needsWordSpacing, xPos, false);
} else
x = placePositionedBoxesHorizontally(flow, x, mn, mx, amn, amx, needsWordSpacing, xPos, false);
}
}
}
if (mn > mx)
mn = mx = startx;
if (amn > amx)
amn = amx = startx;
int width = mx - mn;
flow->setWidth(width);
int awidth = amx - amn;
int dx = 0;
if (positioned) {
switch (flow->object()->style()->svgStyle()->textAnchor()) {
case TA_MIDDLE:
translateBox(flow, dx = -awidth / 2, 0, true);
break;
case TA_END:
translateBox(flow, dx = -awidth, 0, true);
break;
case TA_START:
default:
break;
}
if (dx) {
x += dx;
mn += dx;
mx += dx;
}
}
leftPosition = min(leftPosition, mn);
rightPosition = max(rightPosition, mx);
leftAlign = min(leftAlign, amn);
rightAlign = max(rightAlign, amx);
return x;
}
static gchar* textForRenderer(RenderObject* renderer)
{
GString* resultText = g_string_new(0);
if (!renderer)
return g_string_free(resultText, FALSE);
// For RenderBlocks, piece together the text from the RenderText objects they contain.
for (RenderObject* object = renderer->firstChild(); object; object = object->nextSibling()) {
if (object->isBR()) {
g_string_append(resultText, "\n");
continue;
}
RenderText* renderText;
if (object->isText())
renderText = toRenderText(object);
else {
// List item's markers will be treated in an special way
// later on this function, so ignore them here.
if (object->isReplaced() && !renderer->isListItem())
g_string_append_unichar(resultText, objectReplacementCharacter);
// We need to check children, if any, to consider when
// current object is not a text object but some of its
// children are, in order not to miss those portions of
// text by not properly handling those situations
if (object->firstChild())
g_string_append(resultText, textForRenderer(object));
continue;
}
InlineTextBox* box = renderText ? renderText->firstTextBox() : 0;
while (box) {
// WebCore introduces line breaks in the text that do not reflect
// the layout you see on the screen, replace them with spaces.
String text = String(renderText->characters(), renderText->textLength()).replace("\n", " ");
g_string_append(resultText, text.substring(box->start(), box->end() - box->start() + 1).utf8().data());
// Newline chars in the source result in separate text boxes, so check
// before adding a newline in the layout. See bug 25415 comment #78.
// If the next sibling is a BR, we'll add the newline when we examine that child.
if (!box->nextOnLineExists() && !(object->nextSibling() && object->nextSibling()->isBR())) {
// If there was a '\n' in the last position of the
// current text box, it would have been converted to a
// space in String::replace(), so remove it first.
if (renderText->characters()[box->end()] == '\n')
g_string_erase(resultText, resultText->len - 1, -1);
g_string_append(resultText, "\n");
}
box = box->nextTextBox();
}
}
// Insert the text of the marker for list item in the right place, if present
if (renderer->isListItem()) {
String markerText = toRenderListItem(renderer)->markerTextWithSuffix();
if (renderer->style()->direction() == LTR)
g_string_prepend(resultText, markerText.utf8().data());
else
g_string_append(resultText, markerText.utf8().data());
}
return g_string_free(resultText, FALSE);
}
static AvoidanceReasonFlags canUseForText(const RenderText& textRenderer, const Font& font, FallThrough fallthrough)
{
if (textRenderer.is8Bit())
return canUseForText(textRenderer.characters8(), textRenderer.textLength(), font, fallthrough);
return canUseForText(textRenderer.characters16(), textRenderer.textLength(), font, fallthrough);
}
