1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
|
/*
* Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "ReplaceSelectionCommand.h"
#include "ApplyStyleCommand.h"
#include "BeforeTextInsertedEvent.h"
#include "BreakBlockquoteCommand.h"
#include "CSSComputedStyleDeclaration.h"
#include "CSSMutableStyleDeclaration.h"
#include "CSSPropertyNames.h"
#include "CSSValueKeywords.h"
#include "Document.h"
#include "DocumentFragment.h"
#include "EditingText.h"
#include "Element.h"
#include "EventNames.h"
#include "Frame.h"
#include "HTMLElement.h"
#include "HTMLInputElement.h"
#include "HTMLInterchange.h"
#include "HTMLNames.h"
#include "SelectionController.h"
#include "SmartReplace.h"
#include "TextIterator.h"
#include "htmlediting.h"
#include "markup.h"
#include "visible_units.h"
#include <wtf/StdLibExtras.h>
#include <wtf/Vector.h>
namespace WebCore {
typedef Vector<RefPtr<Node> > NodeVector;
using namespace HTMLNames;
enum EFragmentType { EmptyFragment, SingleTextNodeFragment, TreeFragment };
// --- ReplacementFragment helper class
class ReplacementFragment {
WTF_MAKE_NONCOPYABLE(ReplacementFragment);
public:
ReplacementFragment(Document*, DocumentFragment*, bool matchStyle, const VisibleSelection&);
Node* firstChild() const;
Node* lastChild() const;
bool isEmpty() const;
bool hasInterchangeNewlineAtStart() const { return m_hasInterchangeNewlineAtStart; }
bool hasInterchangeNewlineAtEnd() const { return m_hasInterchangeNewlineAtEnd; }
void removeNode(PassRefPtr<Node>);
void removeNodePreservingChildren(Node*);
private:
PassRefPtr<StyledElement> insertFragmentForTestRendering(Node* context);
void removeUnrenderedNodes(Node*);
void restoreTestRenderingNodesToFragment(StyledElement*);
void removeInterchangeNodes(Node*);
void insertNodeBefore(PassRefPtr<Node> node, Node* refNode);
RefPtr<Document> m_document;
RefPtr<DocumentFragment> m_fragment;
bool m_matchStyle;
bool m_hasInterchangeNewlineAtStart;
bool m_hasInterchangeNewlineAtEnd;
};
static bool isInterchangeNewlineNode(const Node *node)
{
DEFINE_STATIC_LOCAL(String, interchangeNewlineClassString, (AppleInterchangeNewline));
return node && node->hasTagName(brTag) &&
static_cast<const Element *>(node)->getAttribute(classAttr) == interchangeNewlineClassString;
}
static bool isInterchangeConvertedSpaceSpan(const Node *node)
{
DEFINE_STATIC_LOCAL(String, convertedSpaceSpanClassString, (AppleConvertedSpace));
return node->isHTMLElement() &&
static_cast<const HTMLElement *>(node)->getAttribute(classAttr) == convertedSpaceSpanClassString;
}
static Position positionAvoidingPrecedingNodes(Position pos)
{
// If we're already on a break, it's probably a placeholder and we shouldn't change our position.
if (pos.deprecatedNode()->hasTagName(brTag))
return pos;
// We also stop when changing block flow elements because even though the visual position is the
// same. E.g.,
// <div>foo^</div>^
// The two positions above are the same visual position, but we want to stay in the same block.
Node* stopNode = pos.deprecatedNode()->enclosingBlockFlowElement();
while (stopNode != pos.deprecatedNode() && VisiblePosition(pos) == VisiblePosition(pos.next()))
pos = pos.next();
return pos;
}
ReplacementFragment::ReplacementFragment(Document* document, DocumentFragment* fragment, bool matchStyle, const VisibleSelection& selection)
: m_document(document),
m_fragment(fragment),
m_matchStyle(matchStyle),
m_hasInterchangeNewlineAtStart(false),
m_hasInterchangeNewlineAtEnd(false)
{
if (!m_document)
return;
if (!m_fragment)
return;
if (!m_fragment->firstChild())
return;
Element* editableRoot = selection.rootEditableElement();
ASSERT(editableRoot);
if (!editableRoot)
return;
Node* shadowAncestorNode = editableRoot->shadowAncestorNode();
if (!editableRoot->getAttributeEventListener(eventNames().webkitBeforeTextInsertedEvent) &&
// FIXME: Remove these checks once textareas and textfields actually register an event handler.
!(shadowAncestorNode && shadowAncestorNode->renderer() && shadowAncestorNode->renderer()->isTextControl()) &&
editableRoot->isContentRichlyEditable()) {
removeInterchangeNodes(m_fragment.get());
return;
}
Node* styleNode = selection.base().deprecatedNode();
RefPtr<StyledElement> holder = insertFragmentForTestRendering(styleNode);
RefPtr<Range> range = VisibleSelection::selectionFromContentsOfNode(holder.get()).toNormalizedRange();
String text = plainText(range.get());
// Give the root a chance to change the text.
RefPtr<BeforeTextInsertedEvent> evt = BeforeTextInsertedEvent::create(text);
ExceptionCode ec = 0;
editableRoot->dispatchEvent(evt, ec);
ASSERT(ec == 0);
if (text != evt->text() || !editableRoot->isContentRichlyEditable()) {
restoreTestRenderingNodesToFragment(holder.get());
removeNode(holder);
m_fragment = createFragmentFromText(selection.toNormalizedRange().get(), evt->text());
if (!m_fragment->firstChild())
return;
holder = insertFragmentForTestRendering(styleNode);
}
removeInterchangeNodes(holder.get());
removeUnrenderedNodes(holder.get());
restoreTestRenderingNodesToFragment(holder.get());
removeNode(holder);
}
bool ReplacementFragment::isEmpty() const
{
return (!m_fragment || !m_fragment->firstChild()) && !m_hasInterchangeNewlineAtStart && !m_hasInterchangeNewlineAtEnd;
}
Node *ReplacementFragment::firstChild() const
{
return m_fragment ? m_fragment->firstChild() : 0;
}
Node *ReplacementFragment::lastChild() const
{
return m_fragment ? m_fragment->lastChild() : 0;
}
void ReplacementFragment::removeNodePreservingChildren(Node *node)
{
if (!node)
return;
while (RefPtr<Node> n = node->firstChild()) {
removeNode(n);
insertNodeBefore(n.release(), node);
}
removeNode(node);
}
void ReplacementFragment::removeNode(PassRefPtr<Node> node)
{
if (!node)
return;
ContainerNode* parent = node->parentNode();
if (!parent)
return;
ExceptionCode ec = 0;
parent->removeChild(node.get(), ec);
ASSERT(ec == 0);
}
void ReplacementFragment::insertNodeBefore(PassRefPtr<Node> node, Node* refNode)
{
if (!node || !refNode)
return;
ContainerNode* parent = refNode->parentNode();
if (!parent)
return;
ExceptionCode ec = 0;
parent->insertBefore(node, refNode, ec);
ASSERT(ec == 0);
}
PassRefPtr<StyledElement> ReplacementFragment::insertFragmentForTestRendering(Node* context)
{
HTMLElement* body = m_document->body();
if (!body)
return 0;
RefPtr<StyledElement> holder = createDefaultParagraphElement(m_document.get());
ExceptionCode ec = 0;
// Copy the whitespace and user-select style from the context onto this element.
// FIXME: We should examine other style properties to see if they would be appropriate to consider during the test rendering.
Node* n = context;
while (n && !n->isElementNode())
n = n->parentNode();
if (n) {
RefPtr<CSSComputedStyleDeclaration> conFontStyle = computedStyle(n);
CSSStyleDeclaration* style = holder->style();
style->setProperty(CSSPropertyWhiteSpace, conFontStyle->getPropertyValue(CSSPropertyWhiteSpace), false, ec);
ASSERT(ec == 0);
style->setProperty(CSSPropertyWebkitUserSelect, conFontStyle->getPropertyValue(CSSPropertyWebkitUserSelect), false, ec);
ASSERT(ec == 0);
}
holder->appendChild(m_fragment, ec);
ASSERT(ec == 0);
body->appendChild(holder.get(), ec);
ASSERT(ec == 0);
m_document->updateLayoutIgnorePendingStylesheets();
return holder.release();
}
void ReplacementFragment::restoreTestRenderingNodesToFragment(StyledElement* holder)
{
if (!holder)
return;
ExceptionCode ec = 0;
while (RefPtr<Node> node = holder->firstChild()) {
holder->removeChild(node.get(), ec);
ASSERT(ec == 0);
m_fragment->appendChild(node.get(), ec);
ASSERT(ec == 0);
}
}
void ReplacementFragment::removeUnrenderedNodes(Node* holder)
{
Vector<Node*> unrendered;
for (Node* node = holder->firstChild(); node; node = node->traverseNextNode(holder))
if (!isNodeRendered(node) && !isTableStructureNode(node))
unrendered.append(node);
size_t n = unrendered.size();
for (size_t i = 0; i < n; ++i)
removeNode(unrendered[i]);
}
void ReplacementFragment::removeInterchangeNodes(Node* container)
{
// Interchange newlines at the "start" of the incoming fragment must be
// either the first node in the fragment or the first leaf in the fragment.
Node* node = container->firstChild();
while (node) {
if (isInterchangeNewlineNode(node)) {
m_hasInterchangeNewlineAtStart = true;
removeNode(node);
break;
}
node = node->firstChild();
}
if (!container->hasChildNodes())
return;
// Interchange newlines at the "end" of the incoming fragment must be
// either the last node in the fragment or the last leaf in the fragment.
node = container->lastChild();
while (node) {
if (isInterchangeNewlineNode(node)) {
m_hasInterchangeNewlineAtEnd = true;
removeNode(node);
break;
}
node = node->lastChild();
}
node = container->firstChild();
while (node) {
Node *next = node->traverseNextNode();
if (isInterchangeConvertedSpaceSpan(node)) {
RefPtr<Node> n = 0;
while ((n = node->firstChild())) {
removeNode(n);
insertNodeBefore(n, node);
}
removeNode(node);
if (n)
next = n->traverseNextNode();
}
node = next;
}
}
ReplaceSelectionCommand::ReplaceSelectionCommand(Document* document, PassRefPtr<DocumentFragment> fragment, CommandOptions options, EditAction editAction)
: CompositeEditCommand(document)
, m_selectReplacement(options & SelectReplacement)
, m_smartReplace(options & SmartReplace)
, m_matchStyle(options & MatchStyle)
, m_documentFragment(fragment)
, m_preventNesting(options & PreventNesting)
, m_movingParagraph(options & MovingParagraph)
, m_editAction(editAction)
, m_shouldMergeEnd(false)
{
}
static bool hasMatchingQuoteLevel(VisiblePosition endOfExistingContent, VisiblePosition endOfInsertedContent)
{
Position existing = endOfExistingContent.deepEquivalent();
Position inserted = endOfInsertedContent.deepEquivalent();
bool isInsideMailBlockquote = nearestMailBlockquote(inserted.deprecatedNode());
return isInsideMailBlockquote && (numEnclosingMailBlockquotes(existing) == numEnclosingMailBlockquotes(inserted));
}
bool ReplaceSelectionCommand::shouldMergeStart(bool selectionStartWasStartOfParagraph, bool fragmentHasInterchangeNewlineAtStart, bool selectionStartWasInsideMailBlockquote)
{
if (m_movingParagraph)
return false;
VisiblePosition startOfInsertedContent(positionAtStartOfInsertedContent());
VisiblePosition prev = startOfInsertedContent.previous(true);
if (prev.isNull())
return false;
// When we have matching quote levels, its ok to merge more frequently.
// For a successful merge, we still need to make sure that the inserted content starts with the beginning of a paragraph.
// And we should only merge here if the selection start was inside a mail blockquote. This prevents against removing a
// blockquote from newly pasted quoted content that was pasted into an unquoted position. If that unquoted position happens
// to be right after another blockquote, we don't want to merge and risk stripping a valid block (and newline) from the pasted content.
if (isStartOfParagraph(startOfInsertedContent) && selectionStartWasInsideMailBlockquote && hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))
return true;
return !selectionStartWasStartOfParagraph
&& !fragmentHasInterchangeNewlineAtStart
&& isStartOfParagraph(startOfInsertedContent)
&& !startOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
&& shouldMerge(startOfInsertedContent, prev);
}
bool ReplaceSelectionCommand::shouldMergeEnd(bool selectionEndWasEndOfParagraph)
{
VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());
VisiblePosition next = endOfInsertedContent.next(true);
if (next.isNull())
return false;
return !selectionEndWasEndOfParagraph
&& isEndOfParagraph(endOfInsertedContent)
&& !endOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
&& shouldMerge(endOfInsertedContent, next);
}
static bool isMailPasteAsQuotationNode(const Node* node)
{
return node && node->hasTagName(blockquoteTag) && node->isElementNode() && static_cast<const Element*>(node)->getAttribute(classAttr) == ApplePasteAsQuotation;
}
// Wrap CompositeEditCommand::removeNodePreservingChildren() so we can update the nodes we track
void ReplaceSelectionCommand::removeNodePreservingChildren(Node* node)
{
if (m_firstNodeInserted == node)
m_firstNodeInserted = node->traverseNextNode();
if (m_lastLeafInserted == node)
m_lastLeafInserted = node->lastChild() ? node->lastChild() : node->traverseNextSibling();
CompositeEditCommand::removeNodePreservingChildren(node);
}
// Wrap CompositeEditCommand::removeNodeAndPruneAncestors() so we can update the nodes we track
void ReplaceSelectionCommand::removeNodeAndPruneAncestors(Node* node)
{
// prepare in case m_firstNodeInserted and/or m_lastLeafInserted get removed
// FIXME: shouldn't m_lastLeafInserted be adjusted using traversePreviousNode()?
Node* afterFirst = m_firstNodeInserted ? m_firstNodeInserted->traverseNextSibling() : 0;
Node* afterLast = m_lastLeafInserted ? m_lastLeafInserted->traverseNextSibling() : 0;
CompositeEditCommand::removeNodeAndPruneAncestors(node);
// adjust m_firstNodeInserted and m_lastLeafInserted since either or both may have been removed
if (m_lastLeafInserted && !m_lastLeafInserted->inDocument())
m_lastLeafInserted = afterLast;
if (m_firstNodeInserted && !m_firstNodeInserted->inDocument())
m_firstNodeInserted = m_lastLeafInserted && m_lastLeafInserted->inDocument() ? afterFirst : 0;
}
static bool isHeaderElement(Node* a)
{
if (!a)
return false;
return a->hasTagName(h1Tag) ||
a->hasTagName(h2Tag) ||
a->hasTagName(h3Tag) ||
a->hasTagName(h4Tag) ||
a->hasTagName(h5Tag);
}
static bool haveSameTagName(Node* a, Node* b)
{
return a && b && a->isElementNode() && b->isElementNode() && static_cast<Element*>(a)->tagName() == static_cast<Element*>(b)->tagName();
}
bool ReplaceSelectionCommand::shouldMerge(const VisiblePosition& source, const VisiblePosition& destination)
{
if (source.isNull() || destination.isNull())
return false;
Node* sourceNode = source.deepEquivalent().deprecatedNode();
Node* destinationNode = destination.deepEquivalent().deprecatedNode();
Node* sourceBlock = enclosingBlock(sourceNode);
Node* destinationBlock = enclosingBlock(destinationNode);
return !enclosingNodeOfType(source.deepEquivalent(), &isMailPasteAsQuotationNode) &&
sourceBlock && (!sourceBlock->hasTagName(blockquoteTag) || isMailBlockquote(sourceBlock)) &&
enclosingListChild(sourceBlock) == enclosingListChild(destinationNode) &&
enclosingTableCell(source.deepEquivalent()) == enclosingTableCell(destination.deepEquivalent()) &&
(!isHeaderElement(sourceBlock) || haveSameTagName(sourceBlock, destinationBlock)) &&
// Don't merge to or from a position before or after a block because it would
// be a no-op and cause infinite recursion.
!isBlock(sourceNode) && !isBlock(destinationNode);
}
// Style rules that match just inserted elements could change their appearance, like
// a div inserted into a document with div { display:inline; }.
void ReplaceSelectionCommand::negateStyleRulesThatAffectAppearance()
{
for (RefPtr<Node> node = m_firstNodeInserted.get(); node; node = node->traverseNextNode()) {
// FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
if (isStyleSpan(node.get())) {
HTMLElement* e = toHTMLElement(node.get());
// There are other styles that style rules can give to style spans,
// but these are the two important ones because they'll prevent
// inserted content from appearing in the right paragraph.
// FIXME: Hyatt is concerned that selectively using display:inline will give inconsistent
// results. We already know one issue because td elements ignore their display property
// in quirks mode (which Mail.app is always in). We should look for an alternative.
if (isBlock(e))
e->getInlineStyleDecl()->setProperty(CSSPropertyDisplay, CSSValueInline);
if (e->renderer() && e->renderer()->style()->floating() != FNONE)
e->getInlineStyleDecl()->setProperty(CSSPropertyFloat, CSSValueNone);
}
if (node == m_lastLeafInserted)
break;
}
}
void ReplaceSelectionCommand::removeUnrenderedTextNodesAtEnds()
{
document()->updateLayoutIgnorePendingStylesheets();
if (!m_lastLeafInserted->renderer()
&& m_lastLeafInserted->isTextNode()
&& !enclosingNodeWithTag(firstPositionInOrBeforeNode(m_lastLeafInserted.get()), selectTag)
&& !enclosingNodeWithTag(firstPositionInOrBeforeNode(m_lastLeafInserted.get()), scriptTag)) {
if (m_firstNodeInserted == m_lastLeafInserted) {
removeNode(m_lastLeafInserted.get());
m_lastLeafInserted = 0;
m_firstNodeInserted = 0;
return;
}
RefPtr<Node> previous = m_lastLeafInserted->traversePreviousNode();
removeNode(m_lastLeafInserted.get());
m_lastLeafInserted = previous;
}
// We don't have to make sure that m_firstNodeInserted isn't inside a select or script element, because
// it is a top level node in the fragment and the user can't insert into those elements.
if (!m_firstNodeInserted->renderer() &&
m_firstNodeInserted->isTextNode()) {
if (m_firstNodeInserted == m_lastLeafInserted) {
removeNode(m_firstNodeInserted.get());
m_firstNodeInserted = 0;
m_lastLeafInserted = 0;
return;
}
RefPtr<Node> next = m_firstNodeInserted->traverseNextSibling();
removeNode(m_firstNodeInserted.get());
m_firstNodeInserted = next;
}
}
void ReplaceSelectionCommand::handlePasteAsQuotationNode()
{
Node* node = m_firstNodeInserted.get();
if (isMailPasteAsQuotationNode(node))
removeNodeAttribute(static_cast<Element*>(node), classAttr);
}
VisiblePosition ReplaceSelectionCommand::positionAtEndOfInsertedContent()
{
Node* lastNode = m_lastLeafInserted.get();
// FIXME: Why is this hack here? What's special about <select> tags?
Node* enclosingSelect = enclosingNodeWithTag(firstDeepEditingPositionForNode(lastNode), selectTag);
if (enclosingSelect)
lastNode = enclosingSelect;
return lastDeepEditingPositionForNode(lastNode);
}
VisiblePosition ReplaceSelectionCommand::positionAtStartOfInsertedContent()
{
// Return the inserted content's first VisiblePosition.
return VisiblePosition(nextCandidate(positionInParentBeforeNode(m_firstNodeInserted.get())));
}
// Remove style spans before insertion if they are unnecessary. It's faster because we'll
// avoid doing a layout.
static bool handleStyleSpansBeforeInsertion(ReplacementFragment& fragment, const Position& insertionPos)
{
Node* topNode = fragment.firstChild();
// Handling the case where we are doing Paste as Quotation or pasting into quoted content is more complicated (see handleStyleSpans)
// and doesn't receive the optimization.
if (isMailPasteAsQuotationNode(topNode) || nearestMailBlockquote(topNode))
return false;
// Either there are no style spans in the fragment or a WebKit client has added content to the fragment
// before inserting it. Look for and handle style spans after insertion.
if (!isStyleSpan(topNode))
return false;
Node* sourceDocumentStyleSpan = topNode;
RefPtr<Node> copiedRangeStyleSpan = sourceDocumentStyleSpan->firstChild();
RefPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());
String styleText = styleAtInsertionPos->style()->cssText();
// FIXME: This string comparison is a naive way of comparing two styles.
// We should be taking the diff and check that the diff is empty.
if (styleText == static_cast<Element*>(sourceDocumentStyleSpan)->getAttribute(styleAttr)) {
fragment.removeNodePreservingChildren(sourceDocumentStyleSpan);
if (!isStyleSpan(copiedRangeStyleSpan.get()))
return true;
}
if (isStyleSpan(copiedRangeStyleSpan.get()) && styleText == static_cast<Element*>(copiedRangeStyleSpan.get())->getAttribute(styleAttr)) {
fragment.removeNodePreservingChildren(copiedRangeStyleSpan.get());
return true;
}
return false;
}
// At copy time, WebKit wraps copied content in a span that contains the source document's
// default styles. If the copied Range inherits any other styles from its ancestors, we put
// those styles on a second span.
// This function removes redundant styles from those spans, and removes the spans if all their
// styles are redundant.
// We should remove the Apple-style-span class when we're done, see <rdar://problem/5685600>.
// We should remove styles from spans that are overridden by all of their children, either here
// or at copy time.
void ReplaceSelectionCommand::handleStyleSpans()
{
Node* sourceDocumentStyleSpan = 0;
Node* copiedRangeStyleSpan = 0;
// The style span that contains the source document's default style should be at
// the top of the fragment, but Mail sometimes adds a wrapper (for Paste As Quotation),
// so search for the top level style span instead of assuming it's at the top.
for (Node* node = m_firstNodeInserted.get(); node; node = node->traverseNextNode()) {
if (isStyleSpan(node)) {
sourceDocumentStyleSpan = node;
// If the copied Range's common ancestor had user applied inheritable styles
// on it, they'll be on a second style span, just below the one that holds the
// document defaults.
if (isStyleSpan(node->firstChild()))
copiedRangeStyleSpan = node->firstChild();
break;
}
}
// There might not be any style spans if we're pasting from another application or if
// we are here because of a document.execCommand("InsertHTML", ...) call.
if (!sourceDocumentStyleSpan)
return;
RefPtr<EditingStyle> sourceDocumentStyle = EditingStyle::create(toHTMLElement(sourceDocumentStyleSpan)->getInlineStyleDecl());
ContainerNode* context = sourceDocumentStyleSpan->parentNode();
// If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,
// styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.
Node* blockquoteNode = isMailPasteAsQuotationNode(context) ? context : nearestMailBlockquote(context);
if (blockquoteNode) {
sourceDocumentStyle->removeStyleConflictingWithStyleOfNode(blockquoteNode);
context = blockquoteNode->parentNode();
}
// This operation requires that only editing styles to be removed from sourceDocumentStyle.
sourceDocumentStyle->prepareToApplyAt(firstPositionInNode(context));
// Remove block properties in the span's style. This prevents properties that probably have no effect
// currently from affecting blocks later if the style is cloned for a new block element during a future
// editing operation.
// FIXME: They *can* have an effect currently if blocks beneath the style span aren't individually marked
// with block styles by the editing engine used to style them. WebKit doesn't do this, but others might.
sourceDocumentStyle->removeBlockProperties();
// The styles on sourceDocumentStyleSpan are all redundant, and there is no copiedRangeStyleSpan
// to consider. We're finished.
if (sourceDocumentStyle->isEmpty() && !copiedRangeStyleSpan) {
removeNodePreservingChildren(sourceDocumentStyleSpan);
return;
}
// There are non-redundant styles on sourceDocumentStyleSpan, but there is no
// copiedRangeStyleSpan. Remove the span, because it could be surrounding block elements,
// and apply the styles to its children.
if (!sourceDocumentStyle->isEmpty() && !copiedRangeStyleSpan) {
copyStyleToChildren(sourceDocumentStyleSpan, sourceDocumentStyle->style());
removeNodePreservingChildren(sourceDocumentStyleSpan);
return;
}
RefPtr<EditingStyle> copiedRangeStyle = EditingStyle::create(toHTMLElement(copiedRangeStyleSpan)->getInlineStyleDecl());
// We're going to put sourceDocumentStyleSpan's non-redundant styles onto copiedRangeStyleSpan,
// as long as they aren't overridden by ones on copiedRangeStyleSpan.
copiedRangeStyle->style()->merge(sourceDocumentStyle->style(), false);
removeNodePreservingChildren(sourceDocumentStyleSpan);
// Remove redundant styles.
context = copiedRangeStyleSpan->parentNode();
copiedRangeStyle->prepareToApplyAt(firstPositionInNode(context));
copiedRangeStyle->removeBlockProperties();
if (copiedRangeStyle->isEmpty()) {
removeNodePreservingChildren(copiedRangeStyleSpan);
return;
}
// Clear the redundant styles from the span's style attribute.
// FIXME: If font-family:-webkit-monospace is non-redundant, then the font-size should stay, even if it
// appears redundant.
setNodeAttribute(static_cast<Element*>(copiedRangeStyleSpan), styleAttr, copiedRangeStyle->style()->cssText());
}
// Take the style attribute of a span and apply it to it's children instead. This allows us to
// convert invalid HTML where a span contains block elements into valid HTML while preserving
// styles.
void ReplaceSelectionCommand::copyStyleToChildren(Node* parentNode, const CSSMutableStyleDeclaration* parentStyle)
{
ASSERT(parentNode->hasTagName(spanTag));
NodeVector childNodes;
for (RefPtr<Node> childNode = parentNode->firstChild(); childNode; childNode = childNode->nextSibling())
childNodes.append(childNode);
for (NodeVector::const_iterator it = childNodes.begin(); it != childNodes.end(); it++) {
Node* childNode = it->get();
if (childNode->isTextNode() || !isBlock(childNode) || childNode->hasTagName(preTag)) {
// In this case, put a span tag around the child node.
RefPtr<Node> newNode = parentNode->cloneNode(false);
ASSERT(newNode->hasTagName(spanTag));
HTMLElement* newSpan = toHTMLElement(newNode.get());
setNodeAttribute(newSpan, styleAttr, parentStyle->cssText());
insertNodeAfter(newSpan, childNode);
ExceptionCode ec = 0;
newSpan->appendChild(childNode, ec);
ASSERT(!ec);
childNode = newSpan;
} else if (childNode->isHTMLElement()) {
// Copy the style attribute and merge them into the child node. We don't want to override
// existing styles, so don't clobber on merge.
RefPtr<CSSMutableStyleDeclaration> newStyle = parentStyle->copy();
HTMLElement* childElement = toHTMLElement(childNode);
RefPtr<CSSMutableStyleDeclaration> existingStyles = childElement->getInlineStyleDecl()->copy();
existingStyles->merge(newStyle.get(), false);
setNodeAttribute(childElement, styleAttr, existingStyles->cssText());
}
}
}
void ReplaceSelectionCommand::mergeEndIfNeeded()
{
if (!m_shouldMergeEnd)
return;
VisiblePosition startOfInsertedContent(positionAtStartOfInsertedContent());
VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());
// Bail to avoid infinite recursion.
if (m_movingParagraph) {
ASSERT_NOT_REACHED();
return;
}
// Merging two paragraphs will destroy the moved one's block styles. Always move the end of inserted forward
// to preserve the block style of the paragraph already in the document, unless the paragraph to move would
// include the what was the start of the selection that was pasted into, so that we preserve that paragraph's
// block styles.
bool mergeForward = !(inSameParagraph(startOfInsertedContent, endOfInsertedContent) && !isStartOfParagraph(startOfInsertedContent));
VisiblePosition destination = mergeForward ? endOfInsertedContent.next() : endOfInsertedContent;
VisiblePosition startOfParagraphToMove = mergeForward ? startOfParagraph(endOfInsertedContent) : endOfInsertedContent.next();
// Merging forward could result in deleting the destination anchor node.
// To avoid this, we add a placeholder node before the start of the paragraph.
if (endOfParagraph(startOfParagraphToMove) == destination) {
RefPtr<Node> placeholder = createBreakElement(document());
insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().deprecatedNode());
destination = VisiblePosition(positionBeforeNode(placeholder.get()));
}
moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
// Merging forward will remove m_lastLeafInserted from the document.
// FIXME: Maintain positions for the start and end of inserted content instead of keeping nodes. The nodes are
// only ever used to create positions where inserted content starts/ends. Also, we sometimes insert content
// directly into text nodes already in the document, in which case tracking inserted nodes is inadequate.
if (mergeForward) {
m_lastLeafInserted = destination.previous().deepEquivalent().deprecatedNode();
if (!m_firstNodeInserted->inDocument())
m_firstNodeInserted = endingSelection().visibleStart().deepEquivalent().deprecatedNode();
// If we merged text nodes, m_lastLeafInserted could be null. If this is the case,
// we use m_firstNodeInserted.
if (!m_lastLeafInserted)
m_lastLeafInserted = m_firstNodeInserted;
}
}
static Node* enclosingInline(Node* node)
{
while (ContainerNode* parent = node->parentNode()) {
if (parent->isBlockFlow() || parent->hasTagName(bodyTag))
return node;
// Stop if any previous sibling is a block.
for (Node* sibling = node->previousSibling(); sibling; sibling = sibling->previousSibling()) {
if (sibling->isBlockFlow())
return node;
}
node = parent;
}
return node;
}
void ReplaceSelectionCommand::doApply()
{
VisibleSelection selection = endingSelection();
ASSERT(selection.isCaretOrRange());
ASSERT(selection.start().deprecatedNode());
if (!selection.isNonOrphanedCaretOrRange() || !selection.start().deprecatedNode())
return;
bool selectionIsPlainText = !selection.isContentRichlyEditable();
Element* currentRoot = selection.rootEditableElement();
ReplacementFragment fragment(document(), m_documentFragment.get(), m_matchStyle, selection);
if (performTrivialReplace(fragment))
return;
// We can skip matching the style if the selection is plain text.
if ((selection.start().deprecatedNode()->renderer() && selection.start().deprecatedNode()->renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY)
&& (selection.end().deprecatedNode()->renderer() && selection.end().deprecatedNode()->renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY))
m_matchStyle = false;
if (m_matchStyle) {
m_insertionStyle = EditingStyle::create(selection.start());
m_insertionStyle->mergeTypingStyle(document());
}
VisiblePosition visibleStart = selection.visibleStart();
VisiblePosition visibleEnd = selection.visibleEnd();
bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);
Node* startBlock = enclosingBlock(visibleStart.deepEquivalent().deprecatedNode());
Position insertionPos = selection.start();
bool startIsInsideMailBlockquote = nearestMailBlockquote(insertionPos.deprecatedNode());
if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !startIsInsideMailBlockquote) ||
startBlock == currentRoot || isListItem(startBlock) || selectionIsPlainText)
m_preventNesting = false;
if (selection.isRange()) {
// When the end of the selection being pasted into is at the end of a paragraph, and that selection
// spans multiple blocks, not merging may leave an empty line.
// When the start of the selection being pasted into is at the start of a block, not merging
// will leave hanging block(s).
// Merge blocks if the start of the selection was in a Mail blockquote, since we handle
// that case specially to prevent nesting.
bool mergeBlocksAfterDelete = startIsInsideMailBlockquote || isEndOfParagraph(visibleEnd) || isStartOfBlock(visibleStart);
// FIXME: We should only expand to include fully selected special elements if we are copying a
// selection and pasting it on top of itself.
deleteSelection(false, mergeBlocksAfterDelete, true, false);
visibleStart = endingSelection().visibleStart();
if (fragment.hasInterchangeNewlineAtStart()) {
if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {
if (!isEndOfDocument(visibleStart))
setEndingSelection(visibleStart.next());
} else
insertParagraphSeparator();
}
insertionPos = endingSelection().start();
} else {
ASSERT(selection.isCaret());
if (fragment.hasInterchangeNewlineAtStart()) {
VisiblePosition next = visibleStart.next(true);
if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) && next.isNotNull())
setEndingSelection(next);
else
insertParagraphSeparator();
}
// We split the current paragraph in two to avoid nesting the blocks from the fragment inside the current block.
// For example paste <div>foo</div><div>bar</div><div>baz</div> into <div>x^x</div>, where ^ is the caret.
// As long as the div styles are the same, visually you'd expect: <div>xbar</div><div>bar</div><div>bazx</div>,
// not <div>xbar<div>bar</div><div>bazx</div></div>.
// Don't do this if the selection started in a Mail blockquote.
if (m_preventNesting && !startIsInsideMailBlockquote && !isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {
insertParagraphSeparator();
setEndingSelection(endingSelection().visibleStart().previous());
}
insertionPos = endingSelection().start();
}
// We don't want any of the pasted content to end up nested in a Mail blockquote, so first break
// out of any surrounding Mail blockquotes. Unless we're inserting in a table, in which case
// breaking the blockquote will prevent the content from actually being inserted in the table.
if (startIsInsideMailBlockquote && m_preventNesting && !(enclosingNodeOfType(insertionPos, &isTableStructureNode))) {
applyCommandToComposite(BreakBlockquoteCommand::create(document()));
// This will leave a br between the split.
Node* br = endingSelection().start().deprecatedNode();
ASSERT(br->hasTagName(brTag));
// Insert content between the two blockquotes, but remove the br (since it was just a placeholder).
insertionPos = positionInParentBeforeNode(br);
removeNode(br);
}
// Inserting content could cause whitespace to collapse, e.g. inserting <div>foo</div> into hello^ world.
prepareWhitespaceAtPositionForSplit(insertionPos);
// If the downstream node has been removed there's no point in continuing.
if (!insertionPos.downstream().deprecatedNode())
return;
// NOTE: This would be an incorrect usage of downstream() if downstream() were changed to mean the last position after
// p that maps to the same visible position as p (since in the case where a br is at the end of a block and collapsed
// away, there are positions after the br which map to the same visible position as [br, 0]).
Node* endBR = insertionPos.downstream().deprecatedNode()->hasTagName(brTag) ? insertionPos.downstream().deprecatedNode() : 0;
VisiblePosition originalVisPosBeforeEndBR;
if (endBR)
originalVisPosBeforeEndBR = VisiblePosition(positionBeforeNode(endBR), DOWNSTREAM).previous();
startBlock = enclosingBlock(insertionPos.deprecatedNode());
// Adjust insertionPos to prevent nesting.
// If the start was in a Mail blockquote, we will have already handled adjusting insertionPos above.
if (m_preventNesting && startBlock && !startIsInsideMailBlockquote) {
ASSERT(startBlock != currentRoot);
VisiblePosition visibleInsertionPos(insertionPos);
if (isEndOfBlock(visibleInsertionPos) && !(isStartOfBlock(visibleInsertionPos) && fragment.hasInterchangeNewlineAtEnd()))
insertionPos = positionInParentAfterNode(startBlock);
else if (isStartOfBlock(visibleInsertionPos))
insertionPos = positionInParentBeforeNode(startBlock);
}
// Paste into run of tabs splits the tab span.
insertionPos = positionOutsideTabSpan(insertionPos);
// Paste at start or end of link goes outside of link.
insertionPos = positionAvoidingSpecialElementBoundary(insertionPos);
// FIXME: Can this wait until after the operation has been performed? There doesn't seem to be
// any work performed after this that queries or uses the typing style.
if (Frame* frame = document()->frame())
frame->selection()->clearTypingStyle();
bool handledStyleSpans = handleStyleSpansBeforeInsertion(fragment, insertionPos);
// We don't want the destination to end up inside nodes that weren't selected. To avoid that, we move the
// position forward without changing the visible position so we're still at the same visible location, but
// outside of preceding tags.
insertionPos = positionAvoidingPrecedingNodes(insertionPos);
// FIXME: When pasting rich content we're often prevented from heading down the fast path by style spans. Try
// again here if they've been removed.
// We're finished if there is nothing to add.
if (fragment.isEmpty() || !fragment.firstChild())
return;
// 1) Insert the content.
// 2) Remove redundant styles and style tags, this inner <b> for example: <b>foo <b>bar</b> baz</b>.
// 3) Merge the start of the added content with the content before the position being pasted into.
// 4) Do one of the following: a) expand the last br if the fragment ends with one and it collapsed,
// b) merge the last paragraph of the incoming fragment with the paragraph that contained the
// end of the selection that was pasted into, or c) handle an interchange newline at the end of the
// incoming fragment.
// 5) Add spaces for smart replace.
// 6) Select the replacement if requested, and match style if requested.
VisiblePosition startOfInsertedContent, endOfInsertedContent;
RefPtr<Node> refNode = fragment.firstChild();
RefPtr<Node> node = refNode->nextSibling();
fragment.removeNode(refNode);
Node* blockStart = enclosingBlock(insertionPos.deprecatedNode());
if ((isListElement(refNode.get()) || (isStyleSpan(refNode.get()) && isListElement(refNode->firstChild())))
&& blockStart->renderer()->isListItem())
refNode = insertAsListItems(refNode, blockStart, insertionPos);
else
insertNodeAtAndUpdateNodesInserted(refNode, insertionPos);
// Mutation events (bug 22634) may have already removed the inserted content
if (!refNode->inDocument())
return;
bool plainTextFragment = isPlainTextMarkup(refNode.get());
while (node) {
RefPtr<Node> next = node->nextSibling();
fragment.removeNode(node.get());
insertNodeAfterAndUpdateNodesInserted(node, refNode.get());
// Mutation events (bug 22634) may have already removed the inserted content
if (!node->inDocument())
return;
refNode = node;
if (node && plainTextFragment)
plainTextFragment = isPlainTextMarkup(node.get());
node = next;
}
removeUnrenderedTextNodesAtEnds();
negateStyleRulesThatAffectAppearance();
if (!handledStyleSpans)
handleStyleSpans();
// Mutation events (bug 20161) may have already removed the inserted content
if (!m_firstNodeInserted || !m_firstNodeInserted->inDocument())
return;
endOfInsertedContent = positionAtEndOfInsertedContent();
startOfInsertedContent = positionAtStartOfInsertedContent();
// We inserted before the startBlock to prevent nesting, and the content before the startBlock wasn't in its own block and
// didn't have a br after it, so the inserted content ended up in the same paragraph.
if (startBlock && insertionPos.deprecatedNode() == startBlock->parentNode() && (unsigned)insertionPos.deprecatedEditingOffset() < startBlock->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
insertNodeAt(createBreakElement(document()).get(), startOfInsertedContent.deepEquivalent());
Position lastPositionToSelect;
bool interchangeNewlineAtEnd = fragment.hasInterchangeNewlineAtEnd();
if (endBR && (plainTextFragment || shouldRemoveEndBR(endBR, originalVisPosBeforeEndBR)))
removeNodeAndPruneAncestors(endBR);
// Determine whether or not we should merge the end of inserted content with what's after it before we do
// the start merge so that the start merge doesn't effect our decision.
m_shouldMergeEnd = shouldMergeEnd(selectionEndWasEndOfParagraph);
if (shouldMergeStart(selectionStartWasStartOfParagraph, fragment.hasInterchangeNewlineAtStart(), startIsInsideMailBlockquote)) {
VisiblePosition destination = startOfInsertedContent.previous();
VisiblePosition startOfParagraphToMove = startOfInsertedContent;
// We need to handle the case where we need to merge the end
// but our destination node is inside an inline that is the last in the block.
// We insert a placeholder before the newly inserted content to avoid being merged into the inline.
Node* destinationNode = destination.deepEquivalent().deprecatedNode();
if (m_shouldMergeEnd && destinationNode != enclosingInline(destinationNode) && enclosingInline(destinationNode)->nextSibling())
insertNodeBefore(createBreakElement(document()), refNode.get());
// Merging the the first paragraph of inserted content with the content that came
// before the selection that was pasted into would also move content after
// the selection that was pasted into if: only one paragraph was being pasted,
// and it was not wrapped in a block, the selection that was pasted into ended
// at the end of a block and the next paragraph didn't start at the start of a block.
// Insert a line break just after the inserted content to separate it from what
// comes after and prevent that from happening.
VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
if (startOfParagraph(endOfInsertedContent) == startOfParagraphToMove) {
insertNodeAt(createBreakElement(document()).get(), endOfInsertedContent.deepEquivalent());
// Mutation events (bug 22634) triggered by inserting the <br> might have removed the content we're about to move
if (!startOfParagraphToMove.deepEquivalent().anchorNode()->inDocument())
return;
}
// FIXME: Maintain positions for the start and end of inserted content instead of keeping nodes. The nodes are
// only ever used to create positions where inserted content starts/ends.
moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
m_firstNodeInserted = endingSelection().visibleStart().deepEquivalent().downstream().deprecatedNode();
if (!m_lastLeafInserted->inDocument())
m_lastLeafInserted = endingSelection().visibleEnd().deepEquivalent().upstream().deprecatedNode();
}
endOfInsertedContent = positionAtEndOfInsertedContent();
startOfInsertedContent = positionAtStartOfInsertedContent();
if (interchangeNewlineAtEnd) {
VisiblePosition next = endOfInsertedContent.next(true);
if (selectionEndWasEndOfParagraph || !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
if (!isStartOfParagraph(endOfInsertedContent)) {
setEndingSelection(endOfInsertedContent);
Node* enclosingNode = enclosingBlock(endOfInsertedContent.deepEquivalent().deprecatedNode());
if (isListItem(enclosingNode)) {
RefPtr<Node> newListItem = createListItemElement(document());
insertNodeAfter(newListItem, enclosingNode);
setEndingSelection(VisiblePosition(firstPositionInNode(newListItem.get())));
} else
// Use a default paragraph element (a plain div) for the empty paragraph, using the last paragraph
// block's style seems to annoy users.
insertParagraphSeparator(true);
// Select up to the paragraph separator that was added.
lastPositionToSelect = endingSelection().visibleStart().deepEquivalent();
updateNodesInserted(lastPositionToSelect.deprecatedNode());
}
} else {
// Select up to the beginning of the next paragraph.
lastPositionToSelect = next.deepEquivalent().downstream();
}
} else
mergeEndIfNeeded();
handlePasteAsQuotationNode();
endOfInsertedContent = positionAtEndOfInsertedContent();
startOfInsertedContent = positionAtStartOfInsertedContent();
// Add spaces for smart replace.
if (m_smartReplace && currentRoot) {
// Disable smart replace for password fields.
Node* start = currentRoot->shadowAncestorNode();
if (start->hasTagName(inputTag) && static_cast<HTMLInputElement*>(start)->isPasswordField())
m_smartReplace = false;
}
if (m_smartReplace) {
bool needsTrailingSpace = !isEndOfParagraph(endOfInsertedContent) &&
!isCharacterSmartReplaceExempt(endOfInsertedContent.characterAfter(), false);
if (needsTrailingSpace) {
RenderObject* renderer = m_lastLeafInserted->renderer();
bool collapseWhiteSpace = !renderer || renderer->style()->collapseWhiteSpace();
Node* endNode = positionAtEndOfInsertedContent().deepEquivalent().upstream().deprecatedNode();
if (endNode->isTextNode()) {
Text* text = static_cast<Text*>(endNode);
insertTextIntoNode(text, text->length(), collapseWhiteSpace ? nonBreakingSpaceString() : " ");
} else {
RefPtr<Node> node = document()->createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
insertNodeAfterAndUpdateNodesInserted(node, endNode);
}
}
bool needsLeadingSpace = !isStartOfParagraph(startOfInsertedContent) &&
!isCharacterSmartReplaceExempt(startOfInsertedContent.previous().characterAfter(), true);
if (needsLeadingSpace) {
RenderObject* renderer = m_lastLeafInserted->renderer();
bool collapseWhiteSpace = !renderer || renderer->style()->collapseWhiteSpace();
Node* startNode = positionAtStartOfInsertedContent().deepEquivalent().downstream().deprecatedNode();
if (startNode->isTextNode()) {
Text* text = static_cast<Text*>(startNode);
insertTextIntoNode(text, 0, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
} else {
RefPtr<Node> node = document()->createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
// Don't updateNodesInserted. Doing so would set m_lastLeafInserted to be the node containing the
// leading space, but m_lastLeafInserted is supposed to mark the end of pasted content.
insertNodeBefore(node, startNode);
// FIXME: Use positions to track the start/end of inserted content.
m_firstNodeInserted = node;
}
}
}
// If we are dealing with a fragment created from plain text
// no style matching is necessary.
if (plainTextFragment)
m_matchStyle = false;
completeHTMLReplacement(lastPositionToSelect);
}
bool ReplaceSelectionCommand::shouldRemoveEndBR(Node* endBR, const VisiblePosition& originalVisPosBeforeEndBR)
{
if (!endBR || !endBR->inDocument())
return false;
VisiblePosition visiblePos(positionBeforeNode(endBR));
// Don't remove the br if nothing was inserted.
if (visiblePos.previous() == originalVisPosBeforeEndBR)
return false;
// Remove the br if it is collapsed away and so is unnecessary.
if (!document()->inNoQuirksMode() && isEndOfBlock(visiblePos) && !isStartOfParagraph(visiblePos))
return true;
// A br that was originally holding a line open should be displaced by inserted content or turned into a line break.
// A br that was originally acting as a line break should still be acting as a line break, not as a placeholder.
return isStartOfParagraph(visiblePos) && isEndOfParagraph(visiblePos);
}
void ReplaceSelectionCommand::completeHTMLReplacement(const Position &lastPositionToSelect)
{
Position start;
Position end;
// FIXME: This should never not be the case.
if (m_firstNodeInserted && m_firstNodeInserted->inDocument() && m_lastLeafInserted && m_lastLeafInserted->inDocument()) {
start = positionAtStartOfInsertedContent().deepEquivalent();
end = positionAtEndOfInsertedContent().deepEquivalent();
// FIXME (11475): Remove this and require that the creator of the fragment to use nbsps.
rebalanceWhitespaceAt(start);
rebalanceWhitespaceAt(end);
if (m_matchStyle) {
ASSERT(m_insertionStyle);
applyStyle(m_insertionStyle.get(), start, end);
}
if (lastPositionToSelect.isNotNull())
end = lastPositionToSelect;
} else if (lastPositionToSelect.isNotNull())
start = end = lastPositionToSelect;
else
return;
if (m_selectReplacement)
setEndingSelection(VisibleSelection(start, end, SEL_DEFAULT_AFFINITY));
else
setEndingSelection(VisibleSelection(end, SEL_DEFAULT_AFFINITY));
}
EditAction ReplaceSelectionCommand::editingAction() const
{
return m_editAction;
}
void ReplaceSelectionCommand::insertNodeAfterAndUpdateNodesInserted(PassRefPtr<Node> insertChild, Node* refChild)
{
Node* nodeToUpdate = insertChild.get(); // insertChild will be cleared when passed
insertNodeAfter(insertChild, refChild);
updateNodesInserted(nodeToUpdate);
}
void ReplaceSelectionCommand::insertNodeAtAndUpdateNodesInserted(PassRefPtr<Node> insertChild, const Position& p)
{
Node* nodeToUpdate = insertChild.get(); // insertChild will be cleared when passed
insertNodeAt(insertChild, p);
updateNodesInserted(nodeToUpdate);
}
void ReplaceSelectionCommand::insertNodeBeforeAndUpdateNodesInserted(PassRefPtr<Node> insertChild, Node* refChild)
{
Node* nodeToUpdate = insertChild.get(); // insertChild will be cleared when passed
insertNodeBefore(insertChild, refChild);
updateNodesInserted(nodeToUpdate);
}
// If the user is inserting a list into an existing list, instead of nesting the list,
// we put the list items into the existing list.
Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<Node> listElement, Node* insertionBlock, const Position& insertPos)
{
while (listElement->hasChildNodes() && isListElement(listElement->firstChild()) && listElement->childNodeCount() == 1)
listElement = listElement->firstChild();
bool isStart = isStartOfParagraph(insertPos);
bool isEnd = isEndOfParagraph(insertPos);
bool isMiddle = !isStart && !isEnd;
Node* lastNode = insertionBlock;
// If we're in the middle of a list item, we should split it into two separate
// list items and insert these nodes between them.
if (isMiddle) {
int textNodeOffset = insertPos.offsetInContainerNode();
if (insertPos.deprecatedNode()->isTextNode() && textNodeOffset > 0)
splitTextNode(static_cast<Text*>(insertPos.deprecatedNode()), textNodeOffset);
splitTreeToNode(insertPos.deprecatedNode(), lastNode, true);
}
while (RefPtr<Node> listItem = listElement->firstChild()) {
ExceptionCode ec = 0;
toContainerNode(listElement.get())->removeChild(listItem.get(), ec);
ASSERT(!ec);
if (isStart || isMiddle)
insertNodeBefore(listItem, lastNode);
else if (isEnd) {
insertNodeAfter(listItem, lastNode);
lastNode = listItem.get();
} else
ASSERT_NOT_REACHED();
}
if (isStart || isMiddle)
lastNode = lastNode->previousSibling();
if (isMiddle)
insertNodeAfter(createListItemElement(document()), lastNode);
updateNodesInserted(lastNode);
return lastNode;
}
void ReplaceSelectionCommand::updateNodesInserted(Node *node)
{
if (!node)
return;
if (!m_firstNodeInserted)
m_firstNodeInserted = node;
if (node == m_lastLeafInserted)
return;
m_lastLeafInserted = node->lastDescendant();
}
// During simple pastes, where we're just pasting a text node into a run of text, we insert the text node
// directly into the text node that holds the selection. This is much faster than the generalized code in
// ReplaceSelectionCommand, and works around <https://bugs.webkit.org/show_bug.cgi?id=6148> since we don't
// split text nodes.
bool ReplaceSelectionCommand::performTrivialReplace(const ReplacementFragment& fragment)
{
if (!fragment.firstChild() || fragment.firstChild() != fragment.lastChild() || !fragment.firstChild()->isTextNode())
return false;
// FIXME: Would be nice to handle smart replace in the fast path.
if (m_smartReplace || fragment.hasInterchangeNewlineAtStart() || fragment.hasInterchangeNewlineAtEnd())
return false;
Text* textNode = static_cast<Text*>(fragment.firstChild());
// Our fragment creation code handles tabs, spaces, and newlines, so we don't have to worry about those here.
String text(textNode->data());
Position start = endingSelection().start().parentAnchoredEquivalent();
Position end = endingSelection().end().parentAnchoredEquivalent();
ASSERT(start.anchorType() == Position::PositionIsOffsetInAnchor);
ASSERT(end.anchorType() == Position::PositionIsOffsetInAnchor);
if (start.containerNode() != end.containerNode() || !start.containerNode()->isTextNode())
return false;
replaceTextInNode(static_cast<Text*>(start.containerNode()), start.offsetInContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode(), text);
end = Position(start.containerNode(), start.offsetInContainerNode() + text.length(), Position::PositionIsOffsetInAnchor);
VisibleSelection selectionAfterReplace(m_selectReplacement ? start : end, end);
setEndingSelection(selectionAfterReplace);
return true;
}
} // namespace WebCore
|