2013-07-19  Mario Sanchez Prada  <mario.prada@samsung.com>

        [GTK] Reimplement atk_text_get_text_*_offset for SENTENCE boundaries

        https://bugs.webkit.org/show_bug.cgi?id=114873

        Reviewed by NOBODY (OOPS!).

        Re-implement this functions without using GailTextUtil nor Pango.

        * accessibility/atk/WebKitAccessibleInterfaceText.cpp:

        (isSentenceBoundary): Helper function to know when we are either

        at the beginning or the end of a sentence.

        (isSpaceBetweenRealSentences): It returns true if we are in the

        middle of a white space between sentences. Useful for implementing

        the SENTENCE_END boundary type.

        (sentenceAtPositionForAtkBoundary): New helper function to find the

        sentence at a given position considering values of AtkTextBoundary.

        (webkitAccessibleTextGetSentenceForBoundary): New function,

        implementing atk_text_get_text_*_offset for SENTENCE.

        (webkitAccessibleTextGetTextForOffset): Replace usage of Gail for

        LINE boundaries with webkitAccessibleTextGetWordForBoundary().

#include "HTMLParserIdioms.h"

static bool isSentenceBoundary(const VisiblePosition &pos)

{

    if (pos.isNull())

        return false;

    // It's definitely a sentence boundary if there's nothing before.

    if (pos.previous().isNull())

        return true;

    // We go backwards and forward to make sure about this.

    VisiblePosition startOfPreviousSentence = startOfSentence(pos);

    return startOfPreviousSentence.isNotNull() && pos == endOfSentence(startOfPreviousSentence);

}

static bool isSpaceBetweenRealSentences(const VisiblePosition& position)

{

    if (position.isNull())

        return false;

    if (!isWhitespace(position.characterAfter()))

        return false;

    VisiblePosition startOfWhiteSpace = startOfWord(position, RightWordIfOnBoundary);

    VisiblePosition endOfWhiteSpace = endOfWord(startOfWhiteSpace, RightWordIfOnBoundary);

    if (!isSentenceBoundary(startOfWhiteSpace) && !isSentenceBoundary(endOfWhiteSpace))

        return false;

    return comparePositions(startOfWhiteSpace, position) <= 0 && comparePositions(endOfWhiteSpace, position) >= 0;

}

static VisibleSelection sentenceAtPositionForAtkBoundary(const AccessibilityObject* coreObject, const VisiblePosition& position, AtkTextBoundary boundaryType)

{

    VisiblePosition startPosition;

    VisiblePosition endPosition;

    bool isAtStartOfSentenceForEndBoundary = isSpaceBetweenRealSentences(position) || isSentenceBoundary(position);

    if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_START || !isAtStartOfSentenceForEndBoundary) {

        startPosition = isSentenceBoundary(position) ? position : startOfSentence(position);

        // startOfSentence might stop at a linebreak in the HTML source code,

        // but we don't want to stop there yet, so keep going.

        while (!isSentenceBoundary(startPosition) && isHTMLLineBreak(startPosition.characterBefore()))

            startPosition = startOfSentence(startPosition);

        endPosition = endOfSentence(startPosition);

    }

    if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_END) {

        if (isAtStartOfSentenceForEndBoundary) {

            startPosition = position;

            endPosition = endOfSentence(endOfWord(position, RightWordIfOnBoundary));

        }

        // startOfSentence returns a position after any white space previous to

        // the sentence, so we might need to adjust that offset for this boundary.

        if (isWhitespace(startPosition.characterBefore()))

            startPosition = startOfWord(startPosition, LeftWordIfOnBoundary);

        // endOfSentence returns a position after any white space after the

        // sentence, so we might need to adjust that offset for this boundary.

        if (isWhitespace(endPosition.characterBefore()))

            endPosition = startOfWord(endPosition, LeftWordIfOnBoundary);

        // Finally, do some additional adjustments that might be needed if

        // positions are at the start or the end of a line.

        if (isStartOfLine(startPosition) && !isStartOfBlock(startPosition))

            startPosition = startPosition.previous();

        if (isStartOfLine(endPosition) && !isStartOfBlock(endPosition))

            endPosition = endPosition.previous();

    }

    VisibleSelection selectedSentence(startPosition, endPosition);

    // We mark the selection as 'upstream' so we can use that information later,

    // when finding the actual offsets in getSelectionOffsetsForObject().

    if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_END)

        selectedSentence.setAffinity(UPSTREAM);

    return selectedSentence;

}

static char* webkitAccessibleTextGetSentenceForBoundary(AtkText* text, int offset, AtkTextBoundary boundaryType, GetTextRelativePosition textPosition, int* startOffset, int* endOffset)

{

    AccessibilityObject* coreObject = core(text);

    Document* document = coreObject->document();

    if (!document)

        return emptyTextSelectionAtOffset(0, startOffset, endOffset);

    Node* node = getNodeForAccessibilityObject(coreObject);

    if (!node)

        return emptyTextSelectionAtOffset(0, startOffset, endOffset);

    int actualOffset = atkOffsetToWebCoreOffset(text, offset);

    // Besides of the usual conversion from ATK offsets to WebCore offsets,

    // we need to consider the potential embedded objects that might have been

    // inserted in the text exposed through AtkText when calculating the offset.

    actualOffset -= numberOfReplacedElementsBeforeOffset(text, actualOffset);

    VisiblePosition caretPosition = coreObject->visiblePositionForIndex(actualOffset);

    VisibleSelection currentSentence = sentenceAtPositionForAtkBoundary(coreObject, caretPosition, boundaryType);

    // Take into account other relative positions, if needed, by

    // calculating the new position that we would need to consider.

    VisiblePosition newPosition = caretPosition;

    switch (textPosition) {

    case GetTextPositionAt:

        break;

    case GetTextPositionBefore:

        // Early return if asking for the previous sentence while already at the beginning.

        if (isFirstVisiblePositionInNode(currentSentence.visibleStart(), node))

            return emptyTextSelectionAtOffset(0, startOffset, endOffset);

        newPosition = currentSentence.visibleStart().previous();

        break;

    case GetTextPositionAfter:

        // Early return if asking for the following word while already at the end.

        if (isLastVisiblePositionInNode(currentSentence.visibleEnd(), node))

            return emptyTextSelectionAtOffset(accessibilityObjectLength(coreObject), startOffset, endOffset);

        newPosition = currentSentence.visibleEnd().next();

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    // Determine the relevant sentence we are actually interested in

    // and calculate the ATK offsets for it, then return everything.

    VisibleSelection selectedSentence = newPosition != caretPosition ? sentenceAtPositionForAtkBoundary(coreObject, newPosition, boundaryType) : currentSentence;

    getSelectionOffsetsForObject(coreObject, selectedSentence, *startOffset, *endOffset);

    // We might need to adjust the start or end offset to include the list item marker,

    // if present, when printing the first or the last full sentence for a list item.

    RenderObject* renderer = coreObject->renderer();

    if (renderer->isListItem()) {

        // For Left-to-Right, the list item marker is at the beginning of the exposed text.

        if (renderer->style()->direction() == LTR && isFirstVisiblePositionInNode(selectedSentence.visibleStart(), node))

            *startOffset = 0;

        // For Right-to-Left, the list item marker is at the end of the exposed text.

        if (renderer->style()->direction() == RTL && isLastVisiblePositionInNode(selectedSentence.visibleEnd(), node))

            *endOffset = accessibilityObjectLength(coreObject);

    }

    return webkitAccessibleTextGetText(text, *startOffset, *endOffset);

}

    if (boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_START || boundaryType == ATK_TEXT_BOUNDARY_SENTENCE_END)

        return webkitAccessibleTextGetSentenceForBoundary(text, offset, boundaryType, textPosition, startOffset, endOffset);