WebCore/khtml/editing/htmlediting.h

   1 /*
   2  * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef __htmlediting_h__
  27 #define __htmlediting_h__
  28
  29 #include "dom_nodeimpl.h"
  30 #include "qptrlist.h"
  31 #include "qvaluelist.h"
  32 #include "selection.h"
  33 #include "shared.h"
  34
  35 namespace DOM {
  36     class CSSMutableStyleDeclarationImpl;
  37     class CSSProperty;
  38     class DocumentFragmentImpl;
  39     class HTMLElementImpl;
  40     class TextImpl;
  41 }
  42
  43 namespace khtml {
  44
  45 class EditCommand;
  46 class Selection;
  47 class VisiblePosition;
  48
  49 //------------------------------------------------------------------------------------------
  50 // EditCommandPtr
  51
  52 class EditCommandPtr : public SharedPtr<EditCommand>
  53 {
  54 public:
  55     EditCommandPtr();
  56     EditCommandPtr(EditCommand *);
  57     EditCommandPtr(const EditCommandPtr &);
  58     ~EditCommandPtr();
  59
  60     EditCommandPtr &operator=(const EditCommandPtr &);
  61
  62     bool isCompositeStep() const;
  63
  64     void apply() const;
  65     void unapply() const;
  66     void reapply() const;
  67
  68     DOM::DocumentImpl * const document() const;
  69
  70     khtml::Selection startingSelection() const;
  71     khtml::Selection endingSelection() const;
  72
  73     void setStartingSelection(const khtml::Selection &s) const;
  74     void setEndingSelection(const khtml::Selection &s) const;
  75
  76     DOM::CSSMutableStyleDeclarationImpl *typingStyle() const;
  77     void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *) const;
  78
  79     EditCommandPtr parent() const;
  80     void setParent(const EditCommandPtr &) const;
  81
  82     bool isInsertTextCommand() const;
  83     bool isInsertLineBreakCommand() const;
  84     bool isTypingCommand() const;
  85
  86     static EditCommandPtr &emptyCommand();
  87 };
  88
  89 //------------------------------------------------------------------------------------------
  90 // StyleChange
  91
  92 class StyleChange {
  93 public:
  94     enum ELegacyHTMLStyles { DoNotUseLegacyHTMLStyles, UseLegacyHTMLStyles };
  95
  96     explicit StyleChange(DOM::CSSStyleDeclarationImpl *, ELegacyHTMLStyles usesLegacyStyles=UseLegacyHTMLStyles);
  97     StyleChange(DOM::CSSStyleDeclarationImpl *, const DOM::Position &, ELegacyHTMLStyles usesLegacyStyles=UseLegacyHTMLStyles);
  98
  99     DOM::DOMString cssStyle() const { return m_cssStyle; }
 100     bool applyBold() const { return m_applyBold; }
 101     bool applyItalic() const { return m_applyItalic; }
 102     bool usesLegacyStyles() const { return m_usesLegacyStyles; }
 103
 104 private:
 105     void init(DOM::CSSStyleDeclarationImpl *, const DOM::Position &);
 106     bool checkForLegacyHTMLStyleChange(const DOM::CSSProperty *);
 107     static bool currentlyHasStyle(const DOM::Position &, const DOM::CSSProperty *);
 108
 109     DOM::DOMString m_cssStyle;
 110     bool m_applyBold;
 111     bool m_applyItalic;
 112     bool m_usesLegacyStyles;
 113 };
 114
 115 //------------------------------------------------------------------------------------------
 116 // EditCommand
 117
 118 class EditCommand : public Shared<EditCommand>
 119 {
 120 public:
 121     EditCommand(DOM::DocumentImpl *);
 122     virtual ~EditCommand();
 123
 124     bool isCompositeStep() const { return m_parent != 0; }
 125     EditCommand *parent() const { return m_parent; }
 126     void setParent(EditCommand *parent) { m_parent = parent; }
 127
 128     enum ECommandState { NotApplied, Applied };
 129
 130     void apply();
 131     void unapply();
 132     void reapply();
 133
 134     virtual void doApply() = 0;
 135     virtual void doUnapply() = 0;
 136     virtual void doReapply();  // calls doApply()
 137
 138     virtual DOM::DocumentImpl * const document() const { return m_document; }
 139
 140     khtml::Selection startingSelection() const { return m_startingSelection; }
 141     khtml::Selection endingSelection() const { return m_endingSelection; }
 142
 143     void setEndingSelectionNeedsLayout(bool flag=true) { m_endingSelection.setNeedsLayout(flag); }
 144
 145     ECommandState state() const { return m_state; }
 146     void setState(ECommandState state) { m_state = state; }
 147
 148     void setStartingSelection(const khtml::Selection &s);
 149     void setEndingSelection(const khtml::Selection &s);
 150
 151     DOM::CSSMutableStyleDeclarationImpl *typingStyle() const { return m_typingStyle; };
 152     void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 153
 154     virtual bool isInsertTextCommand() const;
 155     virtual bool isTypingCommand() const;
 156
 157 private:
 158     void assignTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 159
 160     virtual bool preservesTypingStyle() const;
 161
 162     DOM::DocumentImpl *m_document;
 163     ECommandState m_state;
 164     khtml::Selection m_startingSelection;
 165     khtml::Selection m_endingSelection;
 166     DOM::CSSMutableStyleDeclarationImpl *m_typingStyle;
 167     EditCommand *m_parent;
 168 };
 169
 170 //------------------------------------------------------------------------------------------
 171 // CompositeEditCommand
 172
 173 class CompositeEditCommand : public EditCommand
 174 {
 175 public:
 176     CompositeEditCommand(DOM::DocumentImpl *);
 177
 178     virtual void doUnapply();
 179     virtual void doReapply();
 180
 181 protected:
 182     //
 183     // sugary-sweet convenience functions to help create and apply edit commands in composite commands
 184     //
 185     void appendNode(DOM::NodeImpl *appendChild, DOM::NodeImpl *parentNode);
 186     void applyCommandToComposite(EditCommandPtr &);
 187     void deleteKeyPressed();
 188     void deleteSelection(bool smartDelete=false, bool mergeBlocksAfterDelete=true);
 189     void deleteSelection(const khtml::Selection &selection, bool smartDelete=false, bool mergeBlocksAfterDelete=true);
 190     void deleteTextFromNode(DOM::TextImpl *node, long offset, long count);
 191     void inputText(const DOM::DOMString &text, bool selectInsertedText = false);
 192     void insertNodeAfter(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
 193     void insertNodeAt(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild, long offset);
 194     void insertNodeBefore(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
 195     void insertParagraphSeparator();
 196     void insertTextIntoNode(DOM::TextImpl *node, long offset, const DOM::DOMString &text);
 197     void joinTextNodes(DOM::TextImpl *text1, DOM::TextImpl *text2);
 198     void rebalanceWhitespace();
 199     void removeCSSProperty(DOM::CSSStyleDeclarationImpl *, int property);
 200     void removeFullySelectedNode(DOM::NodeImpl *);
 201     void removeNodeAttribute(DOM::ElementImpl *, int attribute);
 202     void removeNode(DOM::NodeImpl *removeChild);
 203     void removeNodePreservingChildren(DOM::NodeImpl *node);
 204     void replaceTextInNode(DOM::TextImpl *node, long offset, long count, const DOM::DOMString &replacementText);
 205     void setNodeAttribute(DOM::ElementImpl *, int attribute, const DOM::DOMString &);
 206     void splitTextNode(DOM::TextImpl *text, long offset);
 207
 208     DOM::NodeImpl *applyTypingStyle(DOM::NodeImpl *) const;
 209
 210     void deleteInsignificantText(DOM::TextImpl *, int start, int end);
 211     void deleteInsignificantText(const DOM::Position &start, const DOM::Position &end);
 212     void deleteInsignificantTextDownstream(const DOM::Position &);
 213
 214     void insertBlockPlaceholderIfNeeded(DOM::NodeImpl *);
 215     bool removeBlockPlaceholderIfNeeded(DOM::NodeImpl *);
 216
 217     QValueList<EditCommandPtr> m_cmds;
 218 };
 219
 220 //==========================================================================================
 221 // Concrete commands
 222 //------------------------------------------------------------------------------------------
 223 // AppendNodeCommand
 224
 225 class AppendNodeCommand : public EditCommand
 226 {
 227 public:
 228     AppendNodeCommand(DOM::DocumentImpl *, DOM::NodeImpl *appendChild, DOM::NodeImpl *parentNode);
 229     virtual ~AppendNodeCommand();
 230
 231     virtual void doApply();
 232     virtual void doUnapply();
 233
 234     DOM::NodeImpl *appendChild() const { return m_appendChild; }
 235     DOM::NodeImpl *parentNode() const { return m_parentNode; }
 236
 237 private:
 238     DOM::NodeImpl *m_appendChild;
 239     DOM::NodeImpl *m_parentNode;
 240 };
 241
 242 //------------------------------------------------------------------------------------------
 243 // ApplyStyleCommand
 244
 245 class ApplyStyleCommand : public CompositeEditCommand
 246 {
 247 public:
 248     ApplyStyleCommand(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *style);
 249     virtual ~ApplyStyleCommand();
 250
 251     virtual void doApply();
 252
 253     DOM::CSSMutableStyleDeclarationImpl *style() const { return m_style; }
 254
 255 private:
 256     // style-removal helpers
 257     bool isHTMLStyleNode(DOM::CSSMutableStyleDeclarationImpl *, DOM::HTMLElementImpl *);
 258     void removeHTMLStyleNode(DOM::HTMLElementImpl *);
 259     void removeCSSStyle(DOM::CSSMutableStyleDeclarationImpl *, DOM::HTMLElementImpl *);
 260     void removeBlockStyle(DOM::CSSMutableStyleDeclarationImpl *, const DOM::Position &start, const DOM::Position &end);
 261     void removeInlineStyle(DOM::CSSMutableStyleDeclarationImpl *, const DOM::Position &start, const DOM::Position &end);
 262     bool nodeFullySelected(DOM::NodeImpl *, const DOM::Position &start, const DOM::Position &end) const;
 263
 264     // style-application helpers
 265     void applyBlockStyle(DOM::CSSMutableStyleDeclarationImpl *);
 266     void applyInlineStyle(DOM::CSSMutableStyleDeclarationImpl *);
 267     void addBlockStyleIfNeeded(DOM::CSSMutableStyleDeclarationImpl *, DOM::HTMLElementImpl *);
 268     void addInlineStyleIfNeeded(DOM::CSSMutableStyleDeclarationImpl *, DOM::NodeImpl *start, DOM::NodeImpl *end);
 269     bool splitTextAtStartIfNeeded(const DOM::Position &start, const DOM::Position &end);
 270     DOM::NodeImpl *splitTextAtEndIfNeeded(const DOM::Position &start, const DOM::Position &end);
 271     void surroundNodeRangeWithElement(DOM::NodeImpl *start, DOM::NodeImpl *end, DOM::ElementImpl *element);
 272     DOM::Position positionInsertionPoint(DOM::Position);
 273
 274     DOM::CSSMutableStyleDeclarationImpl *m_style;
 275 };
 276
 277 //------------------------------------------------------------------------------------------
 278 // DeleteFromTextNodeCommand
 279
 280 class DeleteFromTextNodeCommand : public EditCommand
 281 {
 282 public:
 283     DeleteFromTextNodeCommand(DOM::DocumentImpl *document, DOM::TextImpl *node, long offset, long count);
 284     virtual ~DeleteFromTextNodeCommand();
 285
 286     virtual void doApply();
 287     virtual void doUnapply();
 288
 289     DOM::TextImpl *node() const { return m_node; }
 290     long offset() const { return m_offset; }
 291     long count() const { return m_count; }
 292
 293 private:
 294     DOM::TextImpl *m_node;
 295     long m_offset;
 296     long m_count;
 297     DOM::DOMString m_text;
 298 };
 299
 300 //------------------------------------------------------------------------------------------
 301 // DeleteSelectionCommand
 302
 303 class DeleteSelectionCommand : public CompositeEditCommand
 304 {
 305 public:
 306     DeleteSelectionCommand(DOM::DocumentImpl *document, bool smartDelete=false, bool mergeBlocksAfterDelete=true);
 307     DeleteSelectionCommand(DOM::DocumentImpl *document, const khtml::Selection &selection, bool smartDelete=false, bool mergeBlocksAfterDelete=true);
 308
 309     virtual void doApply();
 310
 311 private:
 312     virtual bool preservesTypingStyle() const;
 313
 314     void initializePositionData();
 315     void saveTypingStyleState();
 316     bool handleSpecialCaseAllContentDelete();
 317     bool handleSpecialCaseBRDelete();
 318     void handleGeneralDelete();
 319     void fixupWhitespace();
 320     void moveNodesAfterNode();
 321     void calculateEndingPosition();
 322     void calculateTypingStyleAfterDelete();
 323     void clearTransientState();
 324
 325     bool m_hasSelectionToDelete;
 326     bool m_smartDelete;
 327     bool m_mergeBlocksAfterDelete;
 328     bool m_trailingWhitespaceValid;
 329
 330     // This data is transient and should be cleared at the end of the doApply function.
 331     khtml::Selection m_selectionToDelete;
 332     DOM::Position m_upstreamStart;
 333     DOM::Position m_downstreamStart;
 334     DOM::Position m_upstreamEnd;
 335     DOM::Position m_downstreamEnd;
 336     DOM::Position m_endingPosition;
 337     DOM::Position m_leadingWhitespace;
 338     DOM::Position m_trailingWhitespace;
 339     DOM::NodeImpl *m_startBlock;
 340     DOM::NodeImpl *m_endBlock;
 341     DOM::NodeImpl *m_startNode;
 342     DOM::CSSMutableStyleDeclarationImpl *m_typingStyle;
 343 };
 344
 345 //------------------------------------------------------------------------------------------
 346 // InsertIntoTextNode
 347
 348 class InsertIntoTextNode : public EditCommand
 349 {
 350 public:
 351     InsertIntoTextNode(DOM::DocumentImpl *document, DOM::TextImpl *, long, const DOM::DOMString &);
 352     virtual ~InsertIntoTextNode();
 353
 354     virtual void doApply();
 355     virtual void doUnapply();
 356
 357     DOM::TextImpl *node() const { return m_node; }
 358     long offset() const { return m_offset; }
 359     DOM::DOMString text() const { return m_text; }
 360
 361 private:
 362     DOM::TextImpl *m_node;
 363     long m_offset;
 364     DOM::DOMString m_text;
 365 };
 366
 367 //------------------------------------------------------------------------------------------
 368 // InsertNodeBeforeCommand
 369
 370 class InsertNodeBeforeCommand : public EditCommand
 371 {
 372 public:
 373     InsertNodeBeforeCommand(DOM::DocumentImpl *, DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
 374     virtual ~InsertNodeBeforeCommand();
 375
 376     virtual void doApply();
 377     virtual void doUnapply();
 378
 379     DOM::NodeImpl *insertChild() const { return m_insertChild; }
 380     DOM::NodeImpl *refChild() const { return m_refChild; }
 381
 382 private:
 383     DOM::NodeImpl *m_insertChild;
 384     DOM::NodeImpl *m_refChild;
 385 };
 386
 387 //------------------------------------------------------------------------------------------
 388 // InsertLineBreakCommand
 389
 390 class InsertLineBreakCommand : public CompositeEditCommand
 391 {
 392 public:
 393     InsertLineBreakCommand(DOM::DocumentImpl *document);
 394
 395     virtual void doApply();
 396
 397 private:
 398     void insertNodeAfterPosition(DOM::NodeImpl *node, const DOM::Position &pos);
 399     void insertNodeBeforePosition(DOM::NodeImpl *node, const DOM::Position &pos);
 400 };
 401
 402 //------------------------------------------------------------------------------------------
 403 // InsertParagraphSeparatorCommand
 404
 405 class InsertParagraphSeparatorCommand : public CompositeEditCommand
 406 {
 407 public:
 408     InsertParagraphSeparatorCommand(DOM::DocumentImpl *document);
 409     virtual ~InsertParagraphSeparatorCommand();
 410
 411     virtual void doApply();
 412
 413 private:
 414     QPtrList<DOM::NodeImpl> ancestors;
 415     QPtrList<DOM::NodeImpl> clonedNodes;
 416 };
 417
 418 //------------------------------------------------------------------------------------------
 419 // InsertParagraphSeparatorInQuotedContentCommand
 420
 421 class InsertParagraphSeparatorInQuotedContentCommand : public CompositeEditCommand
 422 {
 423 public:
 424     InsertParagraphSeparatorInQuotedContentCommand(DOM::DocumentImpl *);
 425     virtual ~InsertParagraphSeparatorInQuotedContentCommand();
 426
 427     virtual void doApply();
 428
 429 private:
 430     bool isMailBlockquote(const DOM::NodeImpl *) const;
 431
 432     QPtrList<DOM::NodeImpl> ancestors;
 433     QPtrList<DOM::NodeImpl> clonedNodes;
 434     DOM::ElementImpl *m_breakNode;
 435 };
 436
 437 //------------------------------------------------------------------------------------------
 438 // InsertTextCommand
 439
 440 class InsertTextCommand : public CompositeEditCommand
 441 {
 442 public:
 443     InsertTextCommand(DOM::DocumentImpl *document);
 444
 445     virtual void doApply();
 446
 447     void deleteCharacter();
 448     void input(const DOM::DOMString &text, bool selectInsertedText = false);
 449
 450     unsigned long charactersAdded() const { return m_charactersAdded; }
 451
 452 private:
 453     virtual bool isInsertTextCommand() const;
 454
 455     DOM::Position prepareForTextInsertion(bool adjustDownstream);
 456     void insertSpace(DOM::TextImpl *textNode, unsigned long offset);
 457
 458     unsigned long m_charactersAdded;
 459 };
 460
 461 //------------------------------------------------------------------------------------------
 462 // JoinTextNodesCommand
 463
 464 class JoinTextNodesCommand : public EditCommand
 465 {
 466 public:
 467     JoinTextNodesCommand(DOM::DocumentImpl *, DOM::TextImpl *, DOM::TextImpl *);
 468     virtual ~JoinTextNodesCommand();
 469
 470     virtual void doApply();
 471     virtual void doUnapply();
 472
 473     DOM::TextImpl *firstNode() const { return m_text1; }
 474     DOM::TextImpl *secondNode() const { return m_text2; }
 475
 476 private:
 477     DOM::TextImpl *m_text1;
 478     DOM::TextImpl *m_text2;
 479     unsigned long m_offset;
 480 };
 481
 482 //------------------------------------------------------------------------------------------
 483 // MoveSelectionCommand
 484
 485 class MoveSelectionCommand : public CompositeEditCommand
 486 {
 487 public:
 488     MoveSelectionCommand(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, DOM::Position &position, bool smartMove=false);
 489     virtual ~MoveSelectionCommand();
 490
 491     virtual void doApply();
 492
 493 private:
 494     DOM::DocumentFragmentImpl *m_fragment;
 495     DOM::Position m_position;
 496     bool m_smartMove;
 497 };
 498
 499 //------------------------------------------------------------------------------------------
 500 // RebalanceWhitespaceCommand
 501
 502 class RebalanceWhitespaceCommand : public EditCommand
 503 {
 504 public:
 505     RebalanceWhitespaceCommand(DOM::DocumentImpl *, const DOM::Position &);
 506     virtual ~RebalanceWhitespaceCommand();
 507
 508     virtual void doApply();
 509     virtual void doUnapply();
 510
 511 private:
 512     enum { InvalidOffset = -1 };
 513
 514     virtual bool preservesTypingStyle() const;
 515
 516     DOM::DOMString m_beforeString;
 517     DOM::DOMString m_afterString;
 518     DOM::Position m_position;
 519     long m_upstreamOffset;
 520     long m_downstreamOffset;
 521 };
 522
 523 //------------------------------------------------------------------------------------------
 524 // RemoveCSSPropertyCommand
 525
 526 class RemoveCSSPropertyCommand : public EditCommand
 527 {
 528 public:
 529     RemoveCSSPropertyCommand(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *, int property);
 530     virtual ~RemoveCSSPropertyCommand();
 531
 532     virtual void doApply();
 533     virtual void doUnapply();
 534
 535     DOM::CSSMutableStyleDeclarationImpl *styleDeclaration() const { return m_decl; }
 536     int property() const { return m_property; }
 537
 538 private:
 539     DOM::CSSMutableStyleDeclarationImpl *m_decl;
 540     int m_property;
 541     DOM::DOMString m_oldValue;
 542     bool m_important;
 543 };
 544
 545 //------------------------------------------------------------------------------------------
 546 // RemoveNodeAttributeCommand
 547
 548 class RemoveNodeAttributeCommand : public EditCommand
 549 {
 550 public:
 551     RemoveNodeAttributeCommand(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute);
 552     virtual ~RemoveNodeAttributeCommand();
 553
 554     virtual void doApply();
 555     virtual void doUnapply();
 556
 557     DOM::ElementImpl *element() const { return m_element; }
 558     DOM::NodeImpl::Id attribute() const { return m_attribute; }
 559
 560 private:
 561     DOM::ElementImpl *m_element;
 562     DOM::NodeImpl::Id m_attribute;
 563     DOM::DOMString m_oldValue;
 564 };
 565
 566 //------------------------------------------------------------------------------------------
 567 // RemoveNodeCommand
 568
 569 class RemoveNodeCommand : public EditCommand
 570 {
 571 public:
 572     RemoveNodeCommand(DOM::DocumentImpl *, DOM::NodeImpl *);
 573     virtual ~RemoveNodeCommand();
 574
 575     virtual void doApply();
 576     virtual void doUnapply();
 577
 578     DOM::NodeImpl *node() const { return m_removeChild; }
 579
 580 private:
 581     DOM::NodeImpl *m_parent;
 582     DOM::NodeImpl *m_removeChild;
 583     DOM::NodeImpl *m_refChild;
 584 };
 585
 586 //------------------------------------------------------------------------------------------
 587 // RemoveNodePreservingChildrenCommand
 588
 589 class RemoveNodePreservingChildrenCommand : public CompositeEditCommand
 590 {
 591 public:
 592     RemoveNodePreservingChildrenCommand(DOM::DocumentImpl *, DOM::NodeImpl *);
 593     virtual ~RemoveNodePreservingChildrenCommand();
 594
 595     virtual void doApply();
 596
 597     DOM::NodeImpl *node() const { return m_node; }
 598
 599 private:
 600     DOM::NodeImpl *m_node;
 601 };
 602
 603 //------------------------------------------------------------------------------------------
 604 // ReplaceSelectionCommand
 605
 606 // --- ReplacementFragment helper class
 607
 608 class ReplacementFragment
 609 {
 610 public:
 611     ReplacementFragment(DOM::DocumentFragmentImpl *fragment);
 612     ~ReplacementFragment();
 613
 614     enum EFragmentType { EmptyFragment, SingleTextNodeFragment, TreeFragment };
 615
 616     DOM::DocumentFragmentImpl *root() const { return m_fragment; }
 617     DOM::NodeImpl *firstChild() const;
 618     DOM::NodeImpl *lastChild() const;
 619
 620     DOM::NodeImpl *mergeStartNode() const;
 621     DOM::NodeImpl *mergeEndNode() const;
 622
 623     void pruneEmptyNodes();
 624
 625     EFragmentType type() const { return m_type; }
 626     bool isEmpty() const { return m_type == EmptyFragment; }
 627     bool isSingleTextNode() const { return m_type == SingleTextNodeFragment; }
 628     bool isTreeFragment() const { return m_type == TreeFragment; }
 629
 630     bool hasMoreThanOneBlock() const { return m_hasMoreThanOneBlock; }
 631     bool hasInterchangeNewlineComment() const { return m_hasInterchangeNewlineComment; }
 632
 633 private:
 634     // no copy construction or assignment
 635     ReplacementFragment(const ReplacementFragment &);
 636     ReplacementFragment &operator=(const ReplacementFragment &);
 637
 638     static bool isInterchangeNewlineComment(const DOM::NodeImpl *);
 639     static bool isInterchangeConvertedSpaceSpan(const DOM::NodeImpl *);
 640
 641     // A couple simple DOM helpers
 642     void removeNode(DOM::NodeImpl *);
 643     void insertNodeBefore(DOM::NodeImpl *node, DOM::NodeImpl *refNode);
 644
 645     EFragmentType m_type;
 646     DOM::DocumentFragmentImpl *m_fragment;
 647     bool m_hasInterchangeNewlineComment;
 648     bool m_hasMoreThanOneBlock;
 649 };
 650
 651 // free-floating helper functions
 652 bool isProbablyBlock(const DOM::NodeImpl *);
 653 bool isComment(const DOM::NodeImpl *);
 654
 655 class ReplaceSelectionCommand : public CompositeEditCommand
 656 {
 657 public:
 658     ReplaceSelectionCommand(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, bool selectReplacement=true, bool smartReplace=false);
 659     virtual ~ReplaceSelectionCommand();
 660
 661     virtual void doApply();
 662
 663 private:
 664     void completeHTMLReplacement(const DOM::Position &, const DOM::Position &);
 665     void completeHTMLReplacement(DOM::NodeImpl *, DOM::NodeImpl *);
 666
 667     ReplacementFragment m_fragment;
 668     bool m_selectReplacement;
 669     bool m_smartReplace;
 670 };
 671
 672 //------------------------------------------------------------------------------------------
 673 // SetNodeAttributeCommand
 674
 675 class SetNodeAttributeCommand : public EditCommand
 676 {
 677 public:
 678     SetNodeAttributeCommand(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute, const DOM::DOMString &value);
 679     virtual ~SetNodeAttributeCommand();
 680
 681     virtual void doApply();
 682     virtual void doUnapply();
 683
 684     DOM::ElementImpl *element() const { return m_element; }
 685     DOM::NodeImpl::Id attribute() const { return m_attribute; }
 686     DOM::DOMString value() const { return m_value; }
 687
 688 private:
 689     DOM::ElementImpl *m_element;
 690     DOM::NodeImpl::Id m_attribute;
 691     DOM::DOMString m_value;
 692     DOM::DOMString m_oldValue;
 693 };
 694
 695 //------------------------------------------------------------------------------------------
 696 // SplitTextNodeCommand
 697
 698 class SplitTextNodeCommand : public EditCommand
 699 {
 700 public:
 701     SplitTextNodeCommand(DOM::DocumentImpl *, DOM::TextImpl *, long);
 702     virtual ~SplitTextNodeCommand();
 703
 704     virtual void doApply();
 705     virtual void doUnapply();
 706
 707     DOM::TextImpl *node() const { return m_text2; }
 708     long offset() const { return m_offset; }
 709
 710 private:
 711     DOM::TextImpl *m_text1;
 712     DOM::TextImpl *m_text2;
 713     unsigned long m_offset;
 714 };
 715
 716 //------------------------------------------------------------------------------------------
 717 // TypingCommand
 718
 719 class TypingCommand : public CompositeEditCommand
 720 {
 721 public:
 722     enum ETypingCommand {
 723         DeleteKey,
 724         InsertText,
 725         InsertLineBreak,
 726         InsertParagraphSeparator,
 727         InsertParagraphSeparatorInQuotedContent,
 728     };
 729
 730     TypingCommand(DOM::DocumentImpl *document, ETypingCommand, const DOM::DOMString &text = "", bool selectInsertedText = false);
 731
 732     static void deleteKeyPressed(DOM::DocumentImpl *);
 733     static void insertText(DOM::DocumentImpl *, const DOM::DOMString &, bool selectInsertedText = false);
 734     static void insertLineBreak(DOM::DocumentImpl *);
 735     static void insertParagraphSeparator(DOM::DocumentImpl *);
 736     static void insertParagraphSeparatorInQuotedContent(DOM::DocumentImpl *);
 737     static bool isOpenForMoreTypingCommand(const EditCommandPtr &);
 738     static void closeTyping(const EditCommandPtr &);
 739
 740     virtual void doApply();
 741
 742     bool openForMoreTyping() const { return m_openForMoreTyping; }
 743     void closeTyping() { m_openForMoreTyping = false; }
 744
 745     void insertText(const DOM::DOMString &text, bool selectInsertedText);
 746     void insertLineBreak();
 747     void insertParagraphSeparatorInQuotedContent();
 748     void insertParagraphSeparator();
 749     void deleteKeyPressed();
 750
 751 private:
 752     virtual bool isTypingCommand() const;
 753     virtual bool preservesTypingStyle() const;
 754
 755     void issueCommandForDeleteKey();
 756     void removeCommand(const EditCommandPtr &);
 757     void markMisspellingsAfterTyping();
 758     void typingAddedToOpenCommand();
 759
 760     ETypingCommand m_commandType;
 761     DOM::DOMString m_textToInsert;
 762     bool m_openForMoreTyping;
 763     bool m_applyEditing;
 764     bool m_selectInsertedText;
 765 };
 766
 767 //------------------------------------------------------------------------------------------
 768
 769 } // end namespace khtml
 770
 771 #endif