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