khtml/editing/htmlediting.cpp

   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 #include "htmlediting.h"
  27 #include "htmlediting_impl.h"
  28
  29 #include "editor.h"
  30 #include "khtml_part.h"
  31
  32 #include "xml/dom_position.h"
  33 #include "xml/dom_docimpl.h"
  34 #include "xml/dom_nodeimpl.h"
  35 #include "xml/dom_selection.h"
  36 #include "xml/dom_textimpl.h"
  37
  38 using DOM::CSSStyleDeclarationImpl;
  39 using DOM::DocumentImpl;
  40 using DOM::ElementImpl;
  41 using DOM::Position;
  42 using DOM::Editor;
  43 using DOM::DOMString;
  44 using DOM::NodeImpl;
  45 using DOM::NodeListImpl;
  46 using DOM::Selection;
  47 using DOM::TextImpl;
  48
  49 #define IF_IMPL_NULL_RETURN_ARG(arg) do { \
  50         if (isNull()) { return arg; } \
  51     } while (0)
  52
  53 #define IF_IMPL_NULL_RETURN do { \
  54         if (isNull()) { return; } \
  55     } while (0)
  56
  57
  58 namespace khtml {
  59
  60 //------------------------------------------------------------------------------------------
  61 // EditCommand
  62
  63 EditCommand::EditCommand() : SharedPtr<SharedCommandImpl>()
  64 {
  65 }
  66
  67 EditCommand::EditCommand(EditCommandImpl *impl) : SharedPtr<SharedCommandImpl>(impl)
  68 {
  69 }
  70
  71 EditCommand::EditCommand(const EditCommand &o) : SharedPtr<SharedCommandImpl>(o.get())
  72 {
  73 }
  74
  75 EditCommand::~EditCommand()
  76 {
  77 }
  78
  79 int EditCommand::commandID() const
  80 {
  81     IF_IMPL_NULL_RETURN_ARG(0);
  82     return get()->commandID();
  83 }
  84
  85 bool EditCommand::isCompositeStep() const
  86 {
  87     IF_IMPL_NULL_RETURN_ARG(false);
  88     return get()->isCompositeStep();
  89 }
  90
  91 bool EditCommand::isNull() const
  92 {
  93     return get() == 0;
  94 }
  95
  96 bool EditCommand::notNull() const
  97 {
  98     return !isNull();
  99 }
 100
 101 void EditCommand::apply()
 102 {
 103     IF_IMPL_NULL_RETURN;
 104     get()->apply();
 105 }
 106
 107 void EditCommand::unapply()
 108 {
 109     IF_IMPL_NULL_RETURN;
 110     get()->unapply();
 111 }
 112
 113 void EditCommand::reapply()
 114 {
 115     IF_IMPL_NULL_RETURN;
 116     get()->reapply();
 117 }
 118
 119 DocumentImpl* EditCommand::document() const
 120 {
 121     IF_IMPL_NULL_RETURN_ARG(0);
 122     return get()->document();
 123 }
 124
 125 Selection EditCommand::startingSelection() const
 126 {
 127     IF_IMPL_NULL_RETURN_ARG(Selection());
 128     return get()->startingSelection();
 129 }
 130
 131 Selection EditCommand::endingSelection() const
 132 {
 133     IF_IMPL_NULL_RETURN_ARG(Selection());
 134     return get()->endingSelection();
 135 }
 136
 137 void EditCommand::setStartingSelection(const Selection &s)
 138 {
 139     IF_IMPL_NULL_RETURN;
 140     get()->setStartingSelection(s);
 141 }
 142
 143 void EditCommand::setEndingSelection(const Selection &s)
 144 {
 145     IF_IMPL_NULL_RETURN;
 146     get()->setEndingSelection(s);
 147 }
 148
 149 EditCommand EditCommand::parent() const
 150 {
 151     IF_IMPL_NULL_RETURN_ARG(0);
 152     return get()->parent();
 153 }
 154
 155 EditCommandImpl *EditCommand::handle() const
 156 {
 157     return static_cast<EditCommandImpl *>(get());
 158 }
 159
 160 EditCommand &EditCommand::emptyCommand()
 161 {
 162     static EditCommand m_emptyCommand;
 163     return m_emptyCommand;
 164 }
 165
 166 //------------------------------------------------------------------------------------------
 167 // CompositeEditCommand
 168
 169 CompositeEditCommand::CompositeEditCommand() : EditCommand()
 170 {
 171 }
 172
 173 CompositeEditCommand::CompositeEditCommand(CompositeEditCommandImpl *impl) : EditCommand(impl)
 174 {
 175 }
 176
 177 CompositeEditCommand::CompositeEditCommand(const CompositeEditCommand &o)
 178     : EditCommand(o.impl())
 179 {
 180 }
 181
 182 CompositeEditCommand::~CompositeEditCommand()
 183 {
 184 }
 185
 186 CompositeEditCommandImpl *CompositeEditCommand::impl() const
 187 {
 188     return static_cast<CompositeEditCommandImpl *>(get());
 189 }
 190
 191 //==========================================================================================
 192 // Concrete commands
 193 //------------------------------------------------------------------------------------------
 194 // AppendNodeCommand
 195
 196 AppendNodeCommand::AppendNodeCommand(DocumentImpl *document, NodeImpl *parentNode, NodeImpl *appendChild)
 197     : EditCommand(new AppendNodeCommandImpl(document, parentNode, appendChild))
 198 {
 199 }
 200
 201 AppendNodeCommand::~AppendNodeCommand()
 202 {
 203 }
 204
 205 AppendNodeCommandImpl *AppendNodeCommand::impl() const
 206 {
 207     return static_cast<AppendNodeCommandImpl *>(get());
 208 }
 209
 210 NodeImpl *AppendNodeCommand::parentNode() const
 211 {
 212     IF_IMPL_NULL_RETURN_ARG(0);
 213     return impl()->parentNode();
 214 }
 215
 216 NodeImpl *AppendNodeCommand::appendChild() const
 217 {
 218     IF_IMPL_NULL_RETURN_ARG(0);
 219     return impl()->appendChild();
 220 }
 221
 222 //------------------------------------------------------------------------------------------
 223 // ApplyStyleCommand
 224
 225 ApplyStyleCommand::ApplyStyleCommand(DocumentImpl *document, CSSStyleDeclarationImpl *style)
 226     : CompositeEditCommand(new ApplyStyleCommandImpl(document, style))
 227 {
 228 }
 229
 230 ApplyStyleCommand::~ApplyStyleCommand()
 231 {
 232 }
 233
 234 ApplyStyleCommandImpl *ApplyStyleCommand::impl() const
 235 {
 236     return static_cast<ApplyStyleCommandImpl *>(get());
 237 }
 238
 239 CSSStyleDeclarationImpl *ApplyStyleCommand::style() const
 240 {
 241     IF_IMPL_NULL_RETURN_ARG(0);
 242     return impl()->style();
 243 }
 244
 245 //------------------------------------------------------------------------------------------
 246 // DeleteCollapsibleWhitespaceCommand
 247
 248 DeleteCollapsibleWhitespaceCommand::DeleteCollapsibleWhitespaceCommand(DocumentImpl *document)
 249     : CompositeEditCommand(new DeleteCollapsibleWhitespaceCommandImpl(document))
 250 {
 251 }
 252
 253 DeleteCollapsibleWhitespaceCommand::DeleteCollapsibleWhitespaceCommand(DocumentImpl *document, const Selection &selection)
 254     : CompositeEditCommand(new DeleteCollapsibleWhitespaceCommandImpl(document, selection))
 255 {
 256 }
 257
 258 DeleteCollapsibleWhitespaceCommand::~DeleteCollapsibleWhitespaceCommand()
 259 {
 260 }
 261
 262 DeleteCollapsibleWhitespaceCommandImpl *DeleteCollapsibleWhitespaceCommand::impl() const
 263 {
 264     return static_cast<DeleteCollapsibleWhitespaceCommandImpl *>(get());
 265 }
 266
 267 //------------------------------------------------------------------------------------------
 268 // DeleteSelectionCommand
 269
 270 DeleteSelectionCommand::DeleteSelectionCommand(DocumentImpl *document)
 271     : CompositeEditCommand(new DeleteSelectionCommandImpl(document))
 272 {
 273 }
 274
 275 DeleteSelectionCommand::DeleteSelectionCommand(DocumentImpl *document, const Selection &selection)
 276     : CompositeEditCommand(new DeleteSelectionCommandImpl(document, selection))
 277 {
 278 }
 279
 280 DeleteSelectionCommand::~DeleteSelectionCommand()
 281 {
 282 }
 283
 284 DeleteSelectionCommandImpl *DeleteSelectionCommand::impl() const
 285 {
 286     return static_cast<DeleteSelectionCommandImpl *>(get());
 287 }
 288
 289 //------------------------------------------------------------------------------------------
 290 // DeleteTextCommand
 291
 292 DeleteTextCommand::DeleteTextCommand(DocumentImpl *document, TextImpl *node, long offset, long count)
 293     : EditCommand(new DeleteTextCommandImpl(document, node, offset, count))
 294 {
 295 }
 296
 297 DeleteTextCommand::DeleteTextCommand(const DeleteTextCommand &o)
 298     : EditCommand(o.impl())
 299 {
 300 }
 301
 302 DeleteTextCommand::~DeleteTextCommand()
 303 {
 304 }
 305
 306 DeleteTextCommandImpl *DeleteTextCommand::impl() const
 307 {
 308     return static_cast<DeleteTextCommandImpl *>(get());
 309 }
 310
 311 TextImpl *DeleteTextCommand::node() const
 312 {
 313     IF_IMPL_NULL_RETURN_ARG(0);
 314     return impl()->node();
 315 }
 316
 317 long DeleteTextCommand::offset() const
 318 {
 319     IF_IMPL_NULL_RETURN_ARG(0);
 320     return impl()->offset();
 321 }
 322
 323 long DeleteTextCommand::count() const
 324 {
 325     IF_IMPL_NULL_RETURN_ARG(0);
 326     return impl()->count();
 327 }
 328
 329 //------------------------------------------------------------------------------------------
 330 // InputNewlineCommand
 331
 332 InputNewlineCommand::InputNewlineCommand(DocumentImpl *document)
 333     : CompositeEditCommand(new InputNewlineCommandImpl(document))
 334 {
 335 }
 336
 337 InputNewlineCommand::~InputNewlineCommand()
 338 {
 339 }
 340
 341 InputNewlineCommandImpl *InputNewlineCommand::impl() const
 342 {
 343     return static_cast<InputNewlineCommandImpl *>(get());
 344 }
 345
 346 //------------------------------------------------------------------------------------------
 347 // InputTextCommand
 348
 349 InputTextCommand::InputTextCommand(DocumentImpl *document)
 350     : CompositeEditCommand(new InputTextCommandImpl(document))
 351 {
 352 }
 353
 354 InputTextCommand::~InputTextCommand()
 355 {
 356 }
 357
 358 InputTextCommandImpl *InputTextCommand::impl() const
 359 {
 360     return static_cast<InputTextCommandImpl *>(get());
 361 }
 362
 363 void InputTextCommand::deleteCharacter()
 364 {
 365     IF_IMPL_NULL_RETURN;
 366     impl()->deleteCharacter();
 367 }
 368
 369 void InputTextCommand::input(const DOM::DOMString &text)
 370 {
 371     IF_IMPL_NULL_RETURN;
 372     impl()->input(text);
 373 }
 374
 375 unsigned long InputTextCommand::charactersAdded() const
 376 {
 377     IF_IMPL_NULL_RETURN_ARG(0);
 378     return impl()->charactersAdded();
 379 }
 380
 381 //------------------------------------------------------------------------------------------
 382 // InsertNodeBeforeCommand
 383
 384 InsertNodeBeforeCommand::InsertNodeBeforeCommand() : EditCommand()
 385 {
 386 }
 387
 388 InsertNodeBeforeCommand::InsertNodeBeforeCommand(DocumentImpl *document, NodeImpl *insertChild, NodeImpl *refChild)
 389     : EditCommand(new InsertNodeBeforeCommandImpl(document, insertChild, refChild))
 390 {
 391 }
 392
 393 InsertNodeBeforeCommand::InsertNodeBeforeCommand(const InsertNodeBeforeCommand &o)
 394     : EditCommand(new InsertNodeBeforeCommandImpl(o.document(), o.insertChild(), o.refChild()))
 395 {
 396 }
 397
 398 InsertNodeBeforeCommand::~InsertNodeBeforeCommand()
 399 {
 400 }
 401
 402 InsertNodeBeforeCommandImpl *InsertNodeBeforeCommand::impl() const
 403 {
 404     return static_cast<InsertNodeBeforeCommandImpl *>(get());
 405 }
 406
 407 NodeImpl *InsertNodeBeforeCommand::insertChild() const
 408 {
 409     IF_IMPL_NULL_RETURN_ARG(0);
 410     return impl()->insertChild();
 411 }
 412
 413 NodeImpl *InsertNodeBeforeCommand::refChild() const
 414 {
 415     IF_IMPL_NULL_RETURN_ARG(0);
 416     return impl()->refChild();
 417 }
 418
 419 //------------------------------------------------------------------------------------------
 420 // InsertTextCommand
 421
 422 InsertTextCommand::InsertTextCommand(DocumentImpl *document, TextImpl *node, long offset, const DOMString &text)
 423     : EditCommand(new InsertTextCommandImpl(document, node, offset, text))
 424 {
 425 }
 426
 427 InsertTextCommand::~InsertTextCommand()
 428 {
 429 }
 430
 431 InsertTextCommandImpl *InsertTextCommand::impl() const
 432 {
 433     return static_cast<InsertTextCommandImpl *>(get());
 434 }
 435
 436 TextImpl *InsertTextCommand::node() const
 437 {
 438     IF_IMPL_NULL_RETURN_ARG(0);
 439     return impl()->node();
 440 }
 441
 442 long InsertTextCommand::offset() const
 443 {
 444     IF_IMPL_NULL_RETURN_ARG(0);
 445     return impl()->offset();
 446 }
 447
 448 DOMString InsertTextCommand::text() const
 449 {
 450     IF_IMPL_NULL_RETURN_ARG(DOMString());
 451     return impl()->text();
 452 }
 453
 454 //------------------------------------------------------------------------------------------
 455 // JoinTextNodesCommand
 456
 457 JoinTextNodesCommand::JoinTextNodesCommand(DocumentImpl *document, TextImpl *text1, TextImpl *text2)
 458     : EditCommand(new JoinTextNodesCommandImpl(document, text1, text2))
 459 {
 460 }
 461
 462 JoinTextNodesCommand::~JoinTextNodesCommand()
 463 {
 464 }
 465
 466 JoinTextNodesCommandImpl *JoinTextNodesCommand::impl() const
 467 {
 468     return static_cast<JoinTextNodesCommandImpl *>(get());
 469 }
 470
 471 TextImpl *JoinTextNodesCommand::firstNode() const
 472 {
 473     IF_IMPL_NULL_RETURN_ARG(0);
 474     return impl()->firstNode();
 475 }
 476
 477 TextImpl *JoinTextNodesCommand::secondNode() const
 478 {
 479     IF_IMPL_NULL_RETURN_ARG(0);
 480     return impl()->secondNode();
 481 }
 482
 483 //------------------------------------------------------------------------------------------
 484 // ReplaceSelectionCommand
 485
 486 ReplaceSelectionCommand::ReplaceSelectionCommand(DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, bool selectReplacement)
 487     : CompositeEditCommand(new ReplaceSelectionCommandImpl(document, fragment, selectReplacement))
 488 {
 489 }
 490
 491 ReplaceSelectionCommand::~ReplaceSelectionCommand()
 492 {
 493 }
 494
 495 ReplaceSelectionCommandImpl *ReplaceSelectionCommand::impl() const
 496 {
 497     return static_cast<ReplaceSelectionCommandImpl *>(get());
 498 }
 499
 500 //------------------------------------------------------------------------------------------
 501 // MoveSelectionCommand
 502
 503 MoveSelectionCommand::MoveSelectionCommand(DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, DOM::Position &position)
 504 : CompositeEditCommand(new MoveSelectionCommandImpl(document, fragment, position))
 505 {
 506 }
 507
 508 MoveSelectionCommand::~MoveSelectionCommand()
 509 {
 510 }
 511
 512 MoveSelectionCommandImpl *MoveSelectionCommand::impl() const
 513 {
 514     return static_cast<MoveSelectionCommandImpl *>(get());
 515 }
 516
 517 //------------------------------------------------------------------------------------------
 518 // RemoveCSSPropertyCommand
 519
 520 RemoveCSSPropertyCommand::RemoveCSSPropertyCommand(DocumentImpl *document, CSSStyleDeclarationImpl *decl, int property)
 521     : EditCommand(new RemoveCSSPropertyCommandImpl(document, decl, property))
 522 {
 523 }
 524
 525 RemoveCSSPropertyCommand::~RemoveCSSPropertyCommand()
 526 {
 527 }
 528
 529 RemoveCSSPropertyCommandImpl *RemoveCSSPropertyCommand::impl() const
 530 {
 531     return static_cast<RemoveCSSPropertyCommandImpl *>(get());
 532 }
 533
 534 CSSStyleDeclarationImpl *RemoveCSSPropertyCommand::styleDeclaration() const
 535 {
 536     IF_IMPL_NULL_RETURN_ARG(0);
 537     return impl()->styleDeclaration();
 538 }
 539
 540 int RemoveCSSPropertyCommand::property() const
 541 {
 542     IF_IMPL_NULL_RETURN_ARG(0);
 543     return impl()->property();
 544 }
 545
 546 //------------------------------------------------------------------------------------------
 547 // RemoveNodeAttributeCommand
 548
 549 RemoveNodeAttributeCommand::RemoveNodeAttributeCommand(DocumentImpl *document, ElementImpl *element, NodeImpl::Id attribute)
 550     : EditCommand(new RemoveNodeAttributeCommandImpl(document, element, attribute))
 551 {
 552 }
 553
 554 RemoveNodeAttributeCommand::~RemoveNodeAttributeCommand()
 555 {
 556 }
 557
 558 RemoveNodeAttributeCommandImpl *RemoveNodeAttributeCommand::impl() const
 559 {
 560     return static_cast<RemoveNodeAttributeCommandImpl *>(get());
 561 }
 562
 563 ElementImpl *RemoveNodeAttributeCommand::element() const
 564 {
 565     IF_IMPL_NULL_RETURN_ARG(0);
 566     return impl()->element();
 567 }
 568
 569 NodeImpl::Id RemoveNodeAttributeCommand::attribute() const
 570 {
 571     IF_IMPL_NULL_RETURN_ARG(0);
 572     return impl()->attribute();
 573 }
 574
 575 //------------------------------------------------------------------------------------------
 576 // RemoveNodeCommand
 577
 578 RemoveNodeCommand::RemoveNodeCommand(DocumentImpl *document, NodeImpl *node)
 579     : EditCommand(new RemoveNodeCommandImpl(document, node))
 580 {
 581 }
 582
 583 RemoveNodeCommand::~RemoveNodeCommand()
 584 {
 585 }
 586
 587 RemoveNodeCommandImpl *RemoveNodeCommand::impl() const
 588 {
 589     return static_cast<RemoveNodeCommandImpl *>(get());
 590 }
 591
 592 NodeImpl *RemoveNodeCommand::node() const
 593 {
 594     IF_IMPL_NULL_RETURN_ARG(0);
 595     return impl()->node();
 596 }
 597
 598 //------------------------------------------------------------------------------------------
 599 // RemoveNodeAndPruneCommand
 600
 601 RemoveNodeAndPruneCommand::RemoveNodeAndPruneCommand(DocumentImpl *document, NodeImpl *pruneNode, NodeImpl *stopNode)
 602     : CompositeEditCommand(new RemoveNodeAndPruneCommandImpl(document, pruneNode, stopNode))
 603 {
 604 }
 605
 606 RemoveNodeAndPruneCommand::~RemoveNodeAndPruneCommand()
 607 {
 608 }
 609
 610 RemoveNodeAndPruneCommandImpl *RemoveNodeAndPruneCommand::impl() const
 611 {
 612     return static_cast<RemoveNodeAndPruneCommandImpl *>(get());
 613 }
 614
 615 NodeImpl *RemoveNodeAndPruneCommand::pruneNode() const
 616 {
 617     IF_IMPL_NULL_RETURN_ARG(0);
 618     return impl()->pruneNode();
 619 }
 620
 621 NodeImpl *RemoveNodeAndPruneCommand::stopNode() const
 622 {
 623     IF_IMPL_NULL_RETURN_ARG(0);
 624     return impl()->stopNode();
 625 }
 626
 627 //------------------------------------------------------------------------------------------
 628 // RemoveNodePreservingChildrenCommand
 629
 630 RemoveNodePreservingChildrenCommand::RemoveNodePreservingChildrenCommand(DocumentImpl *document, NodeImpl *node)
 631     : CompositeEditCommand(new RemoveNodePreservingChildrenCommandImpl(document, node))
 632 {
 633 }
 634
 635 RemoveNodePreservingChildrenCommand::~RemoveNodePreservingChildrenCommand()
 636 {
 637 }
 638
 639 RemoveNodePreservingChildrenCommandImpl *RemoveNodePreservingChildrenCommand::impl() const
 640 {
 641     return static_cast<RemoveNodePreservingChildrenCommandImpl *>(get());
 642 }
 643
 644 NodeImpl *RemoveNodePreservingChildrenCommand::node() const
 645 {
 646     IF_IMPL_NULL_RETURN_ARG(0);
 647     return impl()->node();
 648 }
 649
 650 //------------------------------------------------------------------------------------------
 651 // SetNodeAttributeCommand
 652
 653 SetNodeAttributeCommand::SetNodeAttributeCommand(DocumentImpl *document, ElementImpl *element, NodeImpl::Id attribute, const DOM::DOMString &value)
 654     : EditCommand(new SetNodeAttributeCommandImpl(document, element, attribute, value))
 655 {
 656 }
 657
 658 SetNodeAttributeCommand::~SetNodeAttributeCommand()
 659 {
 660 }
 661
 662 SetNodeAttributeCommandImpl *SetNodeAttributeCommand::impl() const
 663 {
 664     return static_cast<SetNodeAttributeCommandImpl *>(get());
 665 }
 666
 667 ElementImpl *SetNodeAttributeCommand::element() const
 668 {
 669     IF_IMPL_NULL_RETURN_ARG(0);
 670     return impl()->element();
 671 }
 672
 673 NodeImpl::Id SetNodeAttributeCommand::attribute() const
 674 {
 675     IF_IMPL_NULL_RETURN_ARG(0);
 676     return impl()->attribute();
 677 }
 678
 679 DOMString SetNodeAttributeCommand::value() const
 680 {
 681     IF_IMPL_NULL_RETURN_ARG("");
 682     return impl()->value();
 683 }
 684
 685 //------------------------------------------------------------------------------------------
 686 // SplitTextNodeCommand
 687
 688 SplitTextNodeCommand::SplitTextNodeCommand(DocumentImpl *document, TextImpl *text, long offset)
 689     : EditCommand(new SplitTextNodeCommandImpl(document, text, offset))
 690 {
 691 }
 692
 693 SplitTextNodeCommand::~SplitTextNodeCommand()
 694 {
 695 }
 696
 697 SplitTextNodeCommandImpl *SplitTextNodeCommand::impl() const
 698 {
 699     return static_cast<SplitTextNodeCommandImpl *>(get());
 700 }
 701
 702 TextImpl *SplitTextNodeCommand::node() const
 703 {
 704     IF_IMPL_NULL_RETURN_ARG(0);
 705     return impl()->node();
 706 }
 707
 708 long SplitTextNodeCommand::offset() const
 709 {
 710     IF_IMPL_NULL_RETURN_ARG(0);
 711     return impl()->offset();
 712 }
 713
 714 //------------------------------------------------------------------------------------------
 715 // TypingCommand
 716
 717 TypingCommand::TypingCommand(DocumentImpl *document)
 718     : CompositeEditCommand(new TypingCommandImpl(document))
 719 {
 720 }
 721
 722 TypingCommand::~TypingCommand()
 723 {
 724 }
 725
 726 TypingCommandImpl *TypingCommand::impl() const
 727 {
 728     return static_cast<TypingCommandImpl *>(get());
 729 }
 730
 731 void TypingCommand::insertText(DocumentImpl *document, const DOMString &text)
 732 {
 733     assert(document);
 734
 735     Editor *ed = document->part()->editor();
 736     assert(ed);
 737
 738     EditCommand lastEditCommand = ed->lastEditCommand();
 739     if (isOpenForMoreTypingCommand(lastEditCommand)) {
 740         static_cast<TypingCommand &>(lastEditCommand).insertText(text);
 741     }
 742     else {
 743         TypingCommand typingCommand(document);
 744         typingCommand.apply();
 745         typingCommand.insertText(text);
 746     }
 747 }
 748
 749 void TypingCommand::insertNewline(DocumentImpl *document)
 750 {
 751     assert(document);
 752
 753     Editor *ed = document->part()->editor();
 754     assert(ed);
 755
 756     EditCommand lastEditCommand = ed->lastEditCommand();
 757     if (isOpenForMoreTypingCommand(lastEditCommand)) {
 758         static_cast<TypingCommand &>(lastEditCommand).insertNewline();
 759     }
 760     else {
 761         TypingCommand typingCommand(document);
 762         typingCommand.apply();
 763         typingCommand.insertNewline();
 764     }
 765 }
 766
 767 void TypingCommand::deleteKeyPressed(DocumentImpl *document)
 768 {
 769     assert(document);
 770
 771     Editor *ed = document->part()->editor();
 772     assert(ed);
 773
 774     EditCommand lastEditCommand = ed->lastEditCommand();
 775     if (isOpenForMoreTypingCommand(lastEditCommand)) {
 776         static_cast<TypingCommand &>(lastEditCommand).deleteKeyPressed();
 777     }
 778     else {
 779         TypingCommand typingCommand(document);
 780         typingCommand.apply();
 781         typingCommand.deleteKeyPressed();
 782     }
 783 }
 784
 785 bool TypingCommand::isOpenForMoreTypingCommand(const EditCommand &cmd)
 786 {
 787     return cmd.commandID() == TypingCommandID &&
 788         static_cast<const TypingCommand &>(cmd).openForMoreTyping();
 789 }
 790
 791 void TypingCommand::closeTyping(EditCommand cmd)
 792 {
 793     if (isOpenForMoreTypingCommand(cmd))
 794         static_cast<TypingCommand &>(cmd).closeTyping();
 795 }
 796
 797 void TypingCommand::closeTyping()
 798 {
 799     IF_IMPL_NULL_RETURN;
 800     return impl()->closeTyping();
 801 }
 802
 803 bool TypingCommand::openForMoreTyping() const
 804 {
 805     IF_IMPL_NULL_RETURN_ARG(false);
 806     return impl()->openForMoreTyping();
 807 }
 808
 809 void TypingCommand::insertText(const DOMString &text)
 810 {
 811     IF_IMPL_NULL_RETURN;
 812     return impl()->insertText(text);
 813 }
 814
 815 void TypingCommand::insertNewline()
 816 {
 817     IF_IMPL_NULL_RETURN;
 818     return impl()->insertNewline();
 819 }
 820
 821 void TypingCommand::deleteKeyPressed()
 822 {
 823     IF_IMPL_NULL_RETURN;
 824     return impl()->deleteKeyPressed();
 825 }
 826
 827 } // namespace khtml