CompositeEditCommand.cpp [plain text]
#include "config.h"
#include "CompositeEditCommand.h"
#include "AppendNodeCommand.h"
#include "ApplyStyleCommand.h"
#include "CSSComputedStyleDeclaration.h"
#include "CSSMutableStyleDeclaration.h"
#include "CharacterNames.h"
#include "DeleteFromTextNodeCommand.h"
#include "DeleteSelectionCommand.h"
#include "Document.h"
#include "DocumentFragment.h"
#include "EditorInsertAction.h"
#include "Element.h"
#include "HTMLNames.h"
#include "InlineTextBox.h"
#include "InsertIntoTextNodeCommand.h"
#include "InsertLineBreakCommand.h"
#include "InsertNodeBeforeCommand.h"
#include "InsertParagraphSeparatorCommand.h"
#include "InsertTextCommand.h"
#include "JoinTextNodesCommand.h"
#include "MergeIdenticalElementsCommand.h"
#include "Range.h"
#include "RemoveCSSPropertyCommand.h"
#include "RemoveNodeCommand.h"
#include "RemoveNodePreservingChildrenCommand.h"
#include "ReplaceSelectionCommand.h"
#include "RenderBlock.h"
#include "RenderText.h"
#include "SetNodeAttributeCommand.h"
#include "SplitElementCommand.h"
#include "SplitTextNodeCommand.h"
#include "SplitTextNodeContainingElementCommand.h"
#include "Text.h"
#include "TextIterator.h"
#include "WrapContentsInDummySpanCommand.h"
#include "htmlediting.h"
#include "markup.h"
#include "visible_units.h"
using namespace std;
namespace WebCore {
using namespace HTMLNames;
CompositeEditCommand::CompositeEditCommand(Document *document)
: EditCommand(document)
{
}
void CompositeEditCommand::doUnapply()
{
size_t size = m_commands.size();
for (size_t i = size; i != 0; --i)
m_commands[i - 1]->unapply();
}
void CompositeEditCommand::doReapply()
{
size_t size = m_commands.size();
for (size_t i = 0; i != size; ++i)
m_commands[i]->reapply();
}
void CompositeEditCommand::applyCommandToComposite(PassRefPtr<EditCommand> cmd)
{
cmd->setParent(this);
cmd->apply();
m_commands.append(cmd);
}
void CompositeEditCommand::applyStyle(CSSStyleDeclaration* style, EditAction editingAction)
{
applyCommandToComposite(ApplyStyleCommand::create(document(), style, editingAction));
}
void CompositeEditCommand::applyStyle(CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction editingAction)
{
applyCommandToComposite(ApplyStyleCommand::create(document(), style, start, end, editingAction));
}
void CompositeEditCommand::applyStyledElement(PassRefPtr<Element> element)
{
applyCommandToComposite(ApplyStyleCommand::create(element, false));
}
void CompositeEditCommand::removeStyledElement(PassRefPtr<Element> element)
{
applyCommandToComposite(ApplyStyleCommand::create(element, true));
}
void CompositeEditCommand::insertParagraphSeparator(bool useDefaultParagraphElement)
{
applyCommandToComposite(InsertParagraphSeparatorCommand::create(document(), useDefaultParagraphElement));
}
void CompositeEditCommand::insertLineBreak()
{
applyCommandToComposite(InsertLineBreakCommand::create(document()));
}
void CompositeEditCommand::insertNodeBefore(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
{
ASSERT(!refChild->hasTagName(bodyTag));
applyCommandToComposite(InsertNodeBeforeCommand::create(insertChild, refChild));
}
void CompositeEditCommand::insertNodeAfter(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
{
ASSERT(insertChild);
ASSERT(refChild);
ASSERT(!refChild->hasTagName(bodyTag));
Element* parent = refChild->parentElement();
ASSERT(parent);
if (parent->lastChild() == refChild)
appendNode(insertChild, parent);
else {
ASSERT(refChild->nextSibling());
insertNodeBefore(insertChild, refChild->nextSibling());
}
}
void CompositeEditCommand::insertNodeAt(PassRefPtr<Node> insertChild, const Position& editingPosition)
{
ASSERT(isEditablePosition(editingPosition));
Position p = rangeCompliantEquivalent(editingPosition);
Node* refChild = p.node();
int offset = p.offset();
if (canHaveChildrenForEditing(refChild)) {
Node* child = refChild->firstChild();
for (int i = 0; child && i < offset; i++)
child = child->nextSibling();
if (child)
insertNodeBefore(insertChild, child);
else
appendNode(insertChild, static_cast<Element*>(refChild));
} else if (caretMinOffset(refChild) >= offset)
insertNodeBefore(insertChild, refChild);
else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
splitTextNode(static_cast<Text *>(refChild), offset);
insertNodeBefore(insertChild, refChild);
} else
insertNodeAfter(insertChild, refChild);
}
void CompositeEditCommand::appendNode(PassRefPtr<Node> node, PassRefPtr<Element> parent)
{
ASSERT(canHaveChildrenForEditing(parent.get()));
applyCommandToComposite(AppendNodeCommand::create(parent, node));
}
void CompositeEditCommand::removeChildrenInRange(PassRefPtr<Node> node, unsigned from, unsigned to)
{
Vector<RefPtr<Node> > children;
Node* child = node->childNode(from);
for (unsigned i = from; child && i < to; i++, child = child->nextSibling())
children.append(child);
size_t size = children.size();
for (size_t i = 0; i < size; ++i)
removeNode(children[i].release());
}
void CompositeEditCommand::removeNode(PassRefPtr<Node> node)
{
applyCommandToComposite(RemoveNodeCommand::create(node));
}
void CompositeEditCommand::removeNodePreservingChildren(PassRefPtr<Node> node)
{
applyCommandToComposite(RemoveNodePreservingChildrenCommand::create(node));
}
void CompositeEditCommand::removeNodeAndPruneAncestors(PassRefPtr<Node> node)
{
RefPtr<Node> parent = node->parentNode();
removeNode(node);
prune(parent.release());
}
static bool hasARenderedDescendant(Node* node)
{
Node* n = node->firstChild();
while (n) {
if (n->renderer())
return true;
n = n->traverseNextNode(node);
}
return false;
}
void CompositeEditCommand::prune(PassRefPtr<Node> node)
{
while (node) {
RenderObject* renderer = node->renderer();
if (renderer && (!renderer->canHaveChildren() || hasARenderedDescendant(node.get()) || node->rootEditableElement() == node))
return;
RefPtr<Node> next = node->parentNode();
removeNode(node);
node = next;
}
}
void CompositeEditCommand::splitTextNode(PassRefPtr<Text> node, unsigned offset)
{
applyCommandToComposite(SplitTextNodeCommand::create(node, offset));
}
void CompositeEditCommand::splitElement(PassRefPtr<Element> element, PassRefPtr<Node> atChild)
{
applyCommandToComposite(SplitElementCommand::create(element, atChild));
}
void CompositeEditCommand::mergeIdenticalElements(PassRefPtr<Element> prpFirst, PassRefPtr<Element> prpSecond)
{
RefPtr<Element> first = prpFirst;
RefPtr<Element> second = prpSecond;
ASSERT(!first->isDescendantOf(second.get()) && second != first);
if (first->nextSibling() != second) {
removeNode(second);
insertNodeAfter(second, first);
}
applyCommandToComposite(MergeIdenticalElementsCommand::create(first, second));
}
void CompositeEditCommand::wrapContentsInDummySpan(PassRefPtr<Element> element)
{
applyCommandToComposite(WrapContentsInDummySpanCommand::create(element));
}
void CompositeEditCommand::splitTextNodeContainingElement(PassRefPtr<Text> text, unsigned offset)
{
applyCommandToComposite(SplitTextNodeContainingElementCommand::create(text, offset));
}
void CompositeEditCommand::joinTextNodes(PassRefPtr<Text> text1, PassRefPtr<Text> text2)
{
applyCommandToComposite(JoinTextNodesCommand::create(text1, text2));
}
void CompositeEditCommand::inputText(const String& text, bool selectInsertedText)
{
int offset = 0;
int length = text.length();
RefPtr<Range> startRange = Range::create(document(), Position(document()->documentElement(), 0), endingSelection().start());
int startIndex = TextIterator::rangeLength(startRange.get());
int newline;
do {
newline = text.find('\n', offset);
if (newline != offset) {
RefPtr<InsertTextCommand> command = InsertTextCommand::create(document());
applyCommandToComposite(command);
int substringLength = newline == -1 ? length - offset : newline - offset;
command->input(text.substring(offset, substringLength), false);
}
if (newline != -1)
insertLineBreak();
offset = newline + 1;
} while (newline != -1 && offset != length);
if (selectInsertedText) {
RefPtr<Range> selectedRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, length);
setEndingSelection(Selection(selectedRange.get()));
}
}
void CompositeEditCommand::insertTextIntoNode(PassRefPtr<Text> node, unsigned offset, const String& text)
{
applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, text));
}
void CompositeEditCommand::deleteTextFromNode(PassRefPtr<Text> node, unsigned offset, unsigned count)
{
applyCommandToComposite(DeleteFromTextNodeCommand::create(node, offset, count));
}
void CompositeEditCommand::replaceTextInNode(PassRefPtr<Text> node, unsigned offset, unsigned count, const String& replacementText)
{
applyCommandToComposite(DeleteFromTextNodeCommand::create(node.get(), offset, count));
applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, replacementText));
}
Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
{
if (!isTabSpanTextNode(pos.node()))
return pos;
Node* tabSpan = tabSpanNode(pos.node());
if (pos.offset() <= caretMinOffset(pos.node()))
return positionBeforeNode(tabSpan);
if (pos.offset() >= caretMaxOffset(pos.node()))
return positionAfterNode(tabSpan);
splitTextNodeContainingElement(static_cast<Text *>(pos.node()), pos.offset());
return positionBeforeNode(tabSpan);
}
void CompositeEditCommand::insertNodeAtTabSpanPosition(PassRefPtr<Node> node, const Position& pos)
{
insertNodeAt(node, positionOutsideTabSpan(pos));
}
void CompositeEditCommand::deleteSelection(bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
{
if (endingSelection().isRange())
applyCommandToComposite(DeleteSelectionCommand::create(document(), smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements));
}
void CompositeEditCommand::deleteSelection(const Selection &selection, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
{
if (selection.isRange())
applyCommandToComposite(DeleteSelectionCommand::create(selection, smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements));
}
void CompositeEditCommand::removeCSSProperty(PassRefPtr<CSSMutableStyleDeclaration> style, CSSPropertyID property)
{
applyCommandToComposite(RemoveCSSPropertyCommand::create(document(), style, property));
}
void CompositeEditCommand::removeNodeAttribute(PassRefPtr<Element> element, const QualifiedName& attribute)
{
setNodeAttribute(element, attribute, AtomicString());
}
void CompositeEditCommand::setNodeAttribute(PassRefPtr<Element> element, const QualifiedName& attribute, const AtomicString& value)
{
applyCommandToComposite(SetNodeAttributeCommand::create(element, attribute, value));
}
static inline bool isWhitespace(UChar c)
{
return c == noBreakSpace || c == ' ' || c == '\n' || c == '\t';
}
void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
{
Node* node = position.node();
if (!node || !node->isTextNode())
return;
Text* textNode = static_cast<Text*>(node);
if (textNode->length() == 0)
return;
RenderObject* renderer = textNode->renderer();
if (renderer && !renderer->style()->collapseWhiteSpace())
return;
String text = textNode->data();
ASSERT(!text.isEmpty());
int offset = position.offset();
if (!isWhitespace(text[offset])) {
offset--;
if (offset < 0 || !isWhitespace(text[offset]))
return;
}
int upstream = offset;
while (upstream > 0 && isWhitespace(text[upstream - 1]))
upstream--;
int downstream = offset;
while ((unsigned)downstream + 1 < text.length() && isWhitespace(text[downstream + 1]))
downstream++;
int length = downstream - upstream + 1;
ASSERT(length > 0);
VisiblePosition visibleUpstreamPos(Position(position.node(), upstream));
VisiblePosition visibleDownstreamPos(Position(position.node(), downstream + 1));
String string = text.substring(upstream, length);
String rebalancedString = stringWithRebalancedWhitespace(string,
isStartOfParagraph(visibleUpstreamPos) || upstream == 0,
isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length() - 1);
if (string != rebalancedString)
replaceTextInNode(textNode, upstream, length, rebalancedString);
}
void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
{
Node* node = position.node();
if (!node || !node->isTextNode())
return;
Text* textNode = static_cast<Text*>(node);
if (textNode->length() == 0)
return;
RenderObject* renderer = textNode->renderer();
if (renderer && !renderer->style()->collapseWhiteSpace())
return;
Position upstreamPos = position.upstream();
deleteInsignificantText(position.upstream(), position.downstream());
position = upstreamPos.downstream();
VisiblePosition visiblePos(position);
VisiblePosition previousVisiblePos(visiblePos.previous());
Position previous(previousVisiblePos.deepEquivalent());
if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.node()->isTextNode() && !previous.node()->hasTagName(brTag))
replaceTextInNode(static_cast<Text*>(previous.node()), previous.offset(), 1, nonBreakingSpaceString());
if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.node()->isTextNode() && !position.node()->hasTagName(brTag))
replaceTextInNode(static_cast<Text*>(position.node()), position.offset(), 1, nonBreakingSpaceString());
}
void CompositeEditCommand::rebalanceWhitespace()
{
Selection selection = endingSelection();
if (selection.isNone())
return;
rebalanceWhitespaceAt(selection.start());
if (selection.isRange())
rebalanceWhitespaceAt(selection.end());
}
void CompositeEditCommand::deleteInsignificantText(PassRefPtr<Text> textNode, unsigned start, unsigned end)
{
if (!textNode || start >= end)
return;
RenderText* textRenderer = toRenderText(textNode->renderer());
if (!textRenderer)
return;
InlineTextBox* box = textRenderer->firstTextBox();
if (!box) {
removeNode(textNode);
return;
}
unsigned length = textNode->length();
if (start >= length || end > length)
return;
unsigned removed = 0;
InlineTextBox* prevBox = 0;
String str;
while (prevBox || box) {
unsigned gapStart = prevBox ? prevBox->start() + prevBox->len() : 0;
if (end < gapStart)
break;
unsigned gapEnd = box ? box->start() : length;
bool indicesIntersect = start <= gapEnd && end >= gapStart;
int gapLen = gapEnd - gapStart;
if (indicesIntersect && gapLen > 0) {
gapStart = max(gapStart, start);
gapEnd = min(gapEnd, end);
if (str.isNull())
str = textNode->string()->substring(start, end - start);
str.remove(gapStart - start - removed, gapLen);
removed += gapLen;
}
prevBox = box;
if (box)
box = box->nextTextBox();
}
if (!str.isNull()) {
if (!str.isEmpty())
replaceTextInNode(textNode, start, end - start, str);
else {
ASSERT(start > 0 || end - start < textNode->length());
deleteTextFromNode(textNode, start, end - start);
}
}
}
void CompositeEditCommand::deleteInsignificantText(const Position& start, const Position& end)
{
if (start.isNull() || end.isNull())
return;
if (Range::compareBoundaryPoints(start, end) >= 0)
return;
Node* next;
for (Node* node = start.node(); node; node = next) {
next = node->traverseNextNode();
if (node->isTextNode()) {
Text* textNode = static_cast<Text*>(node);
int startOffset = node == start.node() ? start.offset() : 0;
int endOffset = node == end.node() ? end.offset() : textNode->length();
deleteInsignificantText(textNode, startOffset, endOffset);
}
if (node == end.node())
break;
}
}
void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
{
Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
deleteInsignificantText(pos, end);
}
PassRefPtr<Node> CompositeEditCommand::appendBlockPlaceholder(PassRefPtr<Element> container)
{
if (!container)
return 0;
ASSERT(container->renderer());
RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
appendNode(placeholder, container);
return placeholder.release();
}
PassRefPtr<Node> CompositeEditCommand::insertBlockPlaceholder(const Position& pos)
{
if (pos.isNull())
return 0;
ASSERT(pos.node()->renderer());
RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
insertNodeAt(placeholder, pos);
return placeholder.release();
}
PassRefPtr<Node> CompositeEditCommand::addBlockPlaceholderIfNeeded(Element* container)
{
if (!container)
return 0;
updateLayout();
RenderObject* renderer = container->renderer();
if (!renderer || !renderer->isBlockFlow())
return 0;
RenderBlock* block = static_cast<RenderBlock*>(renderer);
if (block->height() == 0 || (block->isListItem() && block->isEmpty()))
return appendBlockPlaceholder(container);
return 0;
}
void CompositeEditCommand::removePlaceholderAt(const Position& p)
{
ASSERT(lineBreakExistsAtPosition(p));
if (p.node()->hasTagName(brTag)) {
removeNode(p.node());
return;
}
deleteTextFromNode(static_cast<Text*>(p.node()), p.offset(), 1);
}
PassRefPtr<Node> CompositeEditCommand::insertNewDefaultParagraphElementAt(const Position& position)
{
RefPtr<Element> paragraphElement = createDefaultParagraphElement(document());
ExceptionCode ec;
paragraphElement->appendChild(createBreakElement(document()), ec);
insertNodeAt(paragraphElement, position);
return paragraphElement.release();
}
PassRefPtr<Node> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos)
{
if (pos.isNull())
return 0;
updateLayout();
VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
VisiblePosition visibleParagraphStart(startOfParagraph(visiblePos));
VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
VisiblePosition next = visibleParagraphEnd.next();
VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
Position upstreamStart = visibleParagraphStart.deepEquivalent().upstream();
Position upstreamEnd = visibleEnd.deepEquivalent().upstream();
if (Range::compareBoundaryPoints(pos, upstreamStart) < 0)
return 0;
if (isBlock(upstreamStart.node())) {
if (upstreamStart.node()->hasTagName(bodyTag)) {
if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(upstreamStart.node()->renderer()))
return insertNewDefaultParagraphElementAt(upstreamStart);
} else if (isBlock(upstreamEnd.node())) {
if (!upstreamEnd.node()->isDescendantOf(upstreamStart.node())) {
return 0;
}
}
else if (enclosingBlock(upstreamEnd.node()) != upstreamStart.node()) {
ASSERT(upstreamStart.node()->isDescendantOf(enclosingBlock(upstreamEnd.node())));
return 0;
}
else if (isEndOfDocument(visibleEnd)) {
return 0;
}
}
RefPtr<Node> newBlock = insertNewDefaultParagraphElementAt(upstreamStart);
moveParagraphs(visibleParagraphStart, visibleParagraphEnd, VisiblePosition(Position(newBlock.get(), 0)));
return newBlock.release();
}
void CompositeEditCommand::pushAnchorElementDown(Node* anchorNode)
{
if (!anchorNode)
return;
ASSERT(anchorNode->isLink());
setEndingSelection(Selection::selectionFromContentsOfNode(anchorNode));
applyStyledElement(static_cast<Element*>(anchorNode));
if (anchorNode->inDocument())
removeNodePreservingChildren(anchorNode);
}
void CompositeEditCommand::pushPartiallySelectedAnchorElementsDown()
{
Selection originalSelection = endingSelection();
VisiblePosition visibleStart(originalSelection.start());
VisiblePosition visibleEnd(originalSelection.end());
Node* startAnchor = enclosingAnchorElement(originalSelection.start());
VisiblePosition startOfStartAnchor(Position(startAnchor, 0));
if (startAnchor && startOfStartAnchor != visibleStart)
pushAnchorElementDown(startAnchor);
Node* endAnchor = enclosingAnchorElement(originalSelection.end());
VisiblePosition endOfEndAnchor(Position(endAnchor, 0));
if (endAnchor && endOfEndAnchor != visibleEnd)
pushAnchorElementDown(endAnchor);
ASSERT(originalSelection.start().node()->inDocument() && originalSelection.end().node()->inDocument());
setEndingSelection(originalSelection);
}
void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle)
{
ASSERT(isStartOfParagraph(startOfParagraphToMove));
ASSERT(isEndOfParagraph(endOfParagraphToMove));
moveParagraphs(startOfParagraphToMove, endOfParagraphToMove, destination, preserveSelection, preserveStyle);
}
void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle)
{
if (startOfParagraphToMove == destination)
return;
int startIndex = -1;
int endIndex = -1;
int destinationIndex = -1;
if (preserveSelection && !endingSelection().isNone()) {
VisiblePosition visibleStart = endingSelection().visibleStart();
VisiblePosition visibleEnd = endingSelection().visibleEnd();
bool startAfterParagraph = Range::compareBoundaryPoints(visibleStart.deepEquivalent(), endOfParagraphToMove.deepEquivalent()) > 0;
bool endBeforeParagraph = Range::compareBoundaryPoints(visibleEnd.deepEquivalent(), startOfParagraphToMove.deepEquivalent()) < 0;
if (!startAfterParagraph && !endBeforeParagraph) {
bool startInParagraph = Range::compareBoundaryPoints(visibleStart.deepEquivalent(), startOfParagraphToMove.deepEquivalent()) >= 0;
bool endInParagraph = Range::compareBoundaryPoints(visibleEnd.deepEquivalent(), endOfParagraphToMove.deepEquivalent()) <= 0;
startIndex = 0;
if (startInParagraph) {
RefPtr<Range> startRange = Range::create(document(), rangeCompliantEquivalent(startOfParagraphToMove.deepEquivalent()), rangeCompliantEquivalent(visibleStart.deepEquivalent()));
startIndex = TextIterator::rangeLength(startRange.get(), true);
}
endIndex = 0;
if (endInParagraph) {
RefPtr<Range> endRange = Range::create(document(), rangeCompliantEquivalent(startOfParagraphToMove.deepEquivalent()), rangeCompliantEquivalent(visibleEnd.deepEquivalent()));
endIndex = TextIterator::rangeLength(endRange.get(), true);
}
}
}
VisiblePosition beforeParagraph = startOfParagraphToMove.previous();
VisiblePosition afterParagraph(endOfParagraphToMove.next());
Position start = startOfParagraphToMove.deepEquivalent().downstream();
Position end = endOfParagraphToMove.deepEquivalent().upstream();
Position startRangeCompliant = rangeCompliantEquivalent(start);
Position endRangeCompliant = rangeCompliantEquivalent(end);
RefPtr<Range> range = Range::create(document(), startRangeCompliant.node(), startRangeCompliant.offset(), endRangeCompliant.node(), endRangeCompliant.offset());
RefPtr<DocumentFragment> fragment = startOfParagraphToMove != endOfParagraphToMove ? createFragmentFromMarkup(document(), createMarkup(range.get(), 0, DoNotAnnotateForInterchange, true), "") : 0;
RefPtr<CSSMutableStyleDeclaration> styleInEmptyParagraph;
if (startOfParagraphToMove == endOfParagraphToMove && preserveStyle && isRichlyEditablePosition(destination.deepEquivalent())) {
styleInEmptyParagraph = styleAtPosition(startOfParagraphToMove.deepEquivalent());
styleInEmptyParagraph->removeBlockProperties();
}
setEndingSelection(Selection(start, end, DOWNSTREAM));
deleteSelection(false, false, false, false);
ASSERT(destination.deepEquivalent().node()->inDocument());
VisiblePosition caretAfterDelete = endingSelection().visibleStart();
if (isStartOfParagraph(caretAfterDelete) && isEndOfParagraph(caretAfterDelete)) {
Position position = caretAfterDelete.deepEquivalent().downstream();
Node* node = position.node();
if (node->hasTagName(brTag))
removeNodeAndPruneAncestors(node);
else if (isBlock(node))
removeNodeAndPruneAncestors(node);
else if (lineBreakExistsAtVisiblePosition(caretAfterDelete)) {
Text* textNode = static_cast<Text*>(node);
if (textNode->length() == 1)
removeNodeAndPruneAncestors(node);
else
deleteTextFromNode(textNode, position.offset(), 1);
}
}
beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph == afterParagraph)) {
insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
updateLayout();
}
RefPtr<Range> startToDestinationRange(Range::create(document(), Position(document(), 0), rangeCompliantEquivalent(destination.deepEquivalent())));
destinationIndex = TextIterator::rangeLength(startToDestinationRange.get(), true);
setEndingSelection(destination);
applyCommandToComposite(ReplaceSelectionCommand::create(document(), fragment, true, false, !preserveStyle, false, true));
if (styleInEmptyParagraph)
applyStyle(styleInEmptyParagraph.get());
if (preserveSelection && startIndex != -1) {
RefPtr<Range> start = TextIterator::rangeFromLocationAndLength(document()->documentElement(), destinationIndex + startIndex, 0, true);
RefPtr<Range> end = TextIterator::rangeFromLocationAndLength(document()->documentElement(), destinationIndex + endIndex, 0, true);
if (start && end)
setEndingSelection(Selection(start->startPosition(), end->startPosition(), DOWNSTREAM));
}
}
bool CompositeEditCommand::breakOutOfEmptyListItem()
{
Node* emptyListItem = enclosingEmptyListItem(endingSelection().visibleStart());
if (!emptyListItem)
return false;
RefPtr<CSSMutableStyleDeclaration> style = styleAtPosition(endingSelection().start());
Node* listNode = emptyListItem->parentNode();
if (!listNode->isContentEditable())
return false;
RefPtr<Element> newBlock = isListElement(listNode->parentNode()) ? createListItemElement(document()) : createDefaultParagraphElement(document());
if (emptyListItem->renderer()->nextSibling()) {
if (emptyListItem->renderer()->previousSibling())
splitElement(static_cast<Element*>(listNode), emptyListItem);
insertNodeBefore(newBlock, listNode);
removeNode(emptyListItem);
} else {
insertNodeAfter(newBlock, listNode);
removeNode(emptyListItem->renderer()->previousSibling() ? emptyListItem : listNode);
}
appendBlockPlaceholder(newBlock);
setEndingSelection(Selection(Position(newBlock.get(), 0), DOWNSTREAM));
computedStyle(endingSelection().start().node())->diff(style.get());
if (style->length() > 0)
applyStyle(style.get());
return true;
}
bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph()
{
if (!endingSelection().isCaret())
return false;
VisiblePosition caret(endingSelection().visibleStart());
Node* highestBlockquote = highestEnclosingNodeOfType(caret.deepEquivalent(), &isMailBlockquote);
if (!highestBlockquote)
return false;
if (!isStartOfParagraph(caret) || !isEndOfParagraph(caret))
return false;
VisiblePosition previous(caret.previous(true));
if (enclosingNodeOfType(previous.deepEquivalent(), &isMailBlockquote))
return false;
RefPtr<Node> br = createBreakElement(document());
insertNodeBefore(br, highestBlockquote);
VisiblePosition atBR(Position(br.get(), 0));
if (!isStartOfParagraph(atBR))
insertNodeBefore(createBreakElement(document()), br);
setEndingSelection(Selection(atBR));
if (!lineBreakExistsAtVisiblePosition(caret))
return false;
Position caretPos(caret.deepEquivalent());
ASSERT(caretPos.node()->hasTagName(brTag) || caretPos.node()->isTextNode() && caretPos.node()->renderer()->style()->preserveNewline());
if (caretPos.node()->hasTagName(brTag)) {
Position beforeBR(positionBeforeNode(caretPos.node()));
removeNode(caretPos.node());
prune(beforeBR.node());
} else {
ASSERT(caretPos.offset() == 0);
Text* textNode = static_cast<Text*>(caretPos.node());
Node* parentNode = textNode->parentNode();
deleteTextFromNode(textNode, 0, 1);
prune(parentNode);
}
return true;
}
Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Position& original)
{
if (original.isNull())
return original;
VisiblePosition visiblePos(original);
Node* enclosingAnchor = enclosingAnchorElement(original);
Position result = original;
if (enclosingAnchor && !isBlock(enclosingAnchor)) {
VisiblePosition firstInAnchor(Position(enclosingAnchor, 0));
VisiblePosition lastInAnchor(Position(enclosingAnchor, maxDeepOffset(enclosingAnchor)));
if (visiblePos == lastInAnchor) {
if (original.node() != enclosingAnchor && original.node()->parentNode() != enclosingAnchor) {
pushAnchorElementDown(enclosingAnchor);
enclosingAnchor = enclosingAnchorElement(original);
if (!enclosingAnchor)
return original;
}
Position downstream(visiblePos.deepEquivalent().downstream());
if (lineBreakExistsAtVisiblePosition(visiblePos) && downstream.node()->isDescendantOf(enclosingAnchor))
return original;
result = positionAfterNode(enclosingAnchor);
}
if (visiblePos == firstInAnchor) {
if (original.node() != enclosingAnchor && original.node()->parentNode() != enclosingAnchor) {
pushAnchorElementDown(enclosingAnchor);
enclosingAnchor = enclosingAnchorElement(original);
}
result = positionBeforeNode(enclosingAnchor);
}
}
if (result.isNull() || !editableRootForPosition(result))
result = original;
return result;
}
PassRefPtr<Node> CompositeEditCommand::splitTreeToNode(Node* start, Node* end, bool splitAncestor)
{
RefPtr<Node> node;
for (node = start; node && node->parent() != end; node = node->parent()) {
VisiblePosition positionInParent(Position(node->parent(), 0), DOWNSTREAM);
VisiblePosition positionInNode(Position(node, 0), DOWNSTREAM);
if (positionInParent != positionInNode)
applyCommandToComposite(SplitElementCommand::create(static_cast<Element*>(node->parent()), node));
}
if (splitAncestor)
return splitTreeToNode(end, end->parent());
return node.release();
}
PassRefPtr<Element> createBlockPlaceholderElement(Document* document)
{
ExceptionCode ec = 0;
RefPtr<Element> breakNode = document->createElementNS(xhtmlNamespaceURI, "br", ec);
ASSERT(ec == 0);
return breakNode.release();
}
}