916d0b306bf855ea64487671027fa5dbce32ad39
[WebKit-https.git] / 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 CSSProperty;
37     class DocumentFragmentImpl;
38     class HTMLElementImpl;
39     class TextImpl;
40 }
41
42 namespace khtml {
43
44 class EditCommand;
45 class Selection;
46 class VisiblePosition;
47
48 //------------------------------------------------------------------------------------------
49 // EditCommandPtr
50
51 class EditCommandPtr : public SharedPtr<EditCommand>
52 {
53 public:
54     EditCommandPtr();
55     EditCommandPtr(EditCommand *);
56     EditCommandPtr(const EditCommandPtr &);
57     ~EditCommandPtr();
58
59     EditCommandPtr &operator=(const EditCommandPtr &);
60
61     bool isCompositeStep() const;
62
63     void apply() const;
64     void unapply() const;
65     void reapply() const;
66
67     DOM::DocumentImpl * const document() const;
68
69     khtml::Selection startingSelection() const;
70     khtml::Selection endingSelection() const;
71
72     void setStartingSelection(const khtml::Selection &s) const;
73     void setEndingSelection(const khtml::Selection &s) const;
74
75     DOM::CSSStyleDeclarationImpl *typingStyle() const;
76     void setTypingStyle(DOM::CSSStyleDeclarationImpl *) const;
77
78     EditCommandPtr parent() const;
79     void setParent(const EditCommandPtr &) const;
80
81     bool isInputTextCommand() const;
82     bool isInputNewlineCommand() const;
83     bool isTypingCommand() const;
84
85     static EditCommandPtr &emptyCommand();
86 };
87
88 //------------------------------------------------------------------------------------------
89 // StyleChange
90
91 class StyleChange {
92 public:
93     StyleChange() : m_applyBold(false), m_applyItalic(false) { }
94     explicit StyleChange(DOM::CSSStyleDeclarationImpl *);
95     StyleChange(DOM::CSSStyleDeclarationImpl *, const DOM::Position &);
96
97     DOM::DOMString cssStyle() const { return m_cssStyle; }
98     bool applyBold() const { return m_applyBold; }
99     bool applyItalic() const { return m_applyItalic; }
100
101 private:
102     void init(DOM::CSSStyleDeclarationImpl *, const DOM::Position &);
103     static bool currentlyHasStyle(const DOM::Position &, const DOM::CSSProperty *);
104     
105     DOM::DOMString m_cssStyle;
106     bool m_applyBold;
107     bool m_applyItalic;
108 };
109
110 //------------------------------------------------------------------------------------------
111 // EditCommand
112
113 class EditCommand : public Shared<EditCommand>
114 {
115 public:
116     EditCommand(DOM::DocumentImpl *);
117     virtual ~EditCommand();
118
119     bool isCompositeStep() const { return m_parent.notNull(); }
120     EditCommand *parent() const { return m_parent.get(); }
121     void setParent(EditCommand *parent) { m_parent = parent; }
122
123     enum ECommandState { NotApplied, Applied };
124     
125     void apply();       
126     void unapply();
127     void reapply();
128
129     virtual void doApply() = 0;
130     virtual void doUnapply() = 0;
131     virtual void doReapply();  // calls doApply()
132
133     virtual DOM::DocumentImpl * const document() const { return m_document; }
134
135     khtml::Selection startingSelection() const { return m_startingSelection; }
136     khtml::Selection endingSelection() const { return m_endingSelection; }
137         
138     ECommandState state() const { return m_state; }
139     void setState(ECommandState state) { m_state = state; }
140
141     void setStartingSelection(const khtml::Selection &s);
142     void setEndingSelection(const khtml::Selection &s);
143
144     DOM::CSSStyleDeclarationImpl *typingStyle() const { return m_typingStyle; };
145     void setTypingStyle(DOM::CSSStyleDeclarationImpl *);
146     
147     virtual bool isInputTextCommand() const;
148     virtual bool isTypingCommand() const;
149
150 private:
151     void assignTypingStyle(DOM::CSSStyleDeclarationImpl *);
152
153     virtual bool preservesTypingStyle() const;
154
155     DOM::DocumentImpl *m_document;
156     ECommandState m_state;
157     khtml::Selection m_startingSelection;
158     khtml::Selection m_endingSelection;
159     DOM::CSSStyleDeclarationImpl *m_typingStyle;
160     EditCommandPtr m_parent;
161 };
162
163 //------------------------------------------------------------------------------------------
164 // CompositeEditCommand
165
166 class CompositeEditCommand : public EditCommand
167 {
168 public:
169     CompositeEditCommand(DOM::DocumentImpl *);
170         
171     virtual void doUnapply();
172     virtual void doReapply();
173
174 protected:
175     //
176     // sugary-sweet convenience functions to help create and apply edit commands in composite commands
177     //
178     void appendNode(DOM::NodeImpl *appendChild, DOM::NodeImpl *parentNode);
179     void applyCommandToComposite(EditCommandPtr &);
180     void deleteKeyPressed();
181     void deleteSelection(bool smartDelete=false, bool mergeBlocksAfterDelete=true);
182     void deleteSelection(const khtml::Selection &selection, bool smartDelete=false, bool mergeBlocksAfterDelete=true);
183     void deleteText(DOM::TextImpl *node, long offset, long count);
184     void inputText(const DOM::DOMString &text, bool selectInsertedText = false);
185     void insertNodeAfter(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
186     void insertNodeAt(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild, long offset);
187     void insertNodeBefore(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
188     void insertText(DOM::TextImpl *node, long offset, const DOM::DOMString &text);
189     void joinTextNodes(DOM::TextImpl *text1, DOM::TextImpl *text2);
190     void removeCSSProperty(DOM::CSSStyleDeclarationImpl *, int property);
191     void removeFullySelectedNode(DOM::NodeImpl *);
192     void removeNodeAttribute(DOM::ElementImpl *, int attribute);
193     void removeNode(DOM::NodeImpl *removeChild);
194     void removeNodePreservingChildren(DOM::NodeImpl *node);
195     void replaceText(DOM::TextImpl *node, long offset, long count, const DOM::DOMString &replacementText);
196     void setNodeAttribute(DOM::ElementImpl *, int attribute, const DOM::DOMString &);
197     void splitTextNode(DOM::TextImpl *text, long offset);
198
199     DOM::NodeImpl *applyTypingStyle(DOM::NodeImpl *) const;
200
201     void deleteInsignificantText(DOM::TextImpl *, int start, int end);
202     void deleteInsignificantText(const DOM::Position &start, const DOM::Position &end);
203     void deleteInsignificantTextDownstream(const DOM::Position &);
204
205     void insertBlockPlaceholderIfNeeded(DOM::NodeImpl *);
206     bool removeBlockPlaceholderIfNeeded(DOM::NodeImpl *);
207
208     QValueList<EditCommandPtr> m_cmds;
209 };
210
211 //==========================================================================================
212 // Concrete commands
213 //------------------------------------------------------------------------------------------
214 // AppendNodeCommand
215
216 class AppendNodeCommand : public EditCommand
217 {
218 public:
219     AppendNodeCommand(DOM::DocumentImpl *, DOM::NodeImpl *appendChild, DOM::NodeImpl *parentNode);
220     virtual ~AppendNodeCommand();
221
222     virtual void doApply();
223     virtual void doUnapply();
224
225     DOM::NodeImpl *appendChild() const { return m_appendChild; }
226     DOM::NodeImpl *parentNode() const { return m_parentNode; }
227
228 private:
229     DOM::NodeImpl *m_appendChild;
230     DOM::NodeImpl *m_parentNode;    
231 };
232
233 //------------------------------------------------------------------------------------------
234 // ApplyStyleCommand
235
236 class ApplyStyleCommand : public CompositeEditCommand
237 {
238 public:
239     ApplyStyleCommand(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *style);
240     virtual ~ApplyStyleCommand();
241         
242     virtual void doApply();
243
244     DOM::CSSStyleDeclarationImpl *style() const { return m_style; }
245
246 private:
247     // style-removal helpers
248     bool isHTMLStyleNode(DOM::HTMLElementImpl *);
249     void removeHTMLStyleNode(DOM::HTMLElementImpl *);
250     void removeCSSStyle(DOM::HTMLElementImpl *);
251     void removeStyle(const DOM::Position &start, const DOM::Position &end);
252     bool nodeFullySelected(DOM::NodeImpl *, const DOM::Position &start, const DOM::Position &end) const;
253
254     // style-application helpers
255     bool splitTextAtStartIfNeeded(const DOM::Position &start, const DOM::Position &end);
256     DOM::NodeImpl *splitTextAtEndIfNeeded(const DOM::Position &start, const DOM::Position &end);
257     void surroundNodeRangeWithElement(DOM::NodeImpl *start, DOM::NodeImpl *end, DOM::ElementImpl *element);
258     DOM::Position positionInsertionPoint(DOM::Position);
259     void applyStyleIfNeeded(DOM::NodeImpl *start, DOM::NodeImpl *end);
260     
261     DOM::CSSStyleDeclarationImpl *m_style;
262 };
263
264 //------------------------------------------------------------------------------------------
265 // DeleteSelectionCommand
266
267 class DeleteSelectionCommand : public CompositeEditCommand
268
269 public:
270     DeleteSelectionCommand(DOM::DocumentImpl *document, bool smartDelete=false, bool mergeBlocksAfterDelete=true);
271     DeleteSelectionCommand(DOM::DocumentImpl *document, const khtml::Selection &selection, bool smartDelete=false, bool mergeBlocksAfterDelete=true);
272         
273     virtual void doApply();
274     
275 private:
276     virtual bool preservesTypingStyle() const;
277
278     void initializePositionData();
279     DOM::Position startPositionForDelete() const;
280     DOM::Position endPositionForDelete() const;
281     void saveTypingStyleState();
282     bool canPerformSpecialCaseBRDelete();
283     void performGeneralDelete();
284     void fixupWhitespace();
285     void moveNodesAfterNode();
286     void calculateEndingPosition();
287     void calculateTypingStyleAfterDelete();
288     void clearTransientState();
289
290     bool m_hasSelectionToDelete;
291     bool m_smartDelete;
292     bool m_mergeBlocksAfterDelete;
293     bool m_trailingWhitespaceValid;
294
295     // This data is transient and should be cleared at the end of the doApply function.
296     khtml::Selection m_selectionToDelete;
297     DOM::Position m_upstreamStart;
298     DOM::Position m_downstreamStart;
299     DOM::Position m_upstreamEnd;
300     DOM::Position m_downstreamEnd;
301     DOM::Position m_endingPosition;
302     DOM::Position m_leadingWhitespace;
303     DOM::Position m_trailingWhitespace;
304     DOM::NodeImpl *m_startBlock;
305     DOM::NodeImpl *m_endBlock;
306     DOM::NodeImpl *m_startNode;
307     DOM::CSSStyleDeclarationImpl *m_typingStyle;
308 };
309
310 //------------------------------------------------------------------------------------------
311 // DeleteTextCommand
312
313 class DeleteTextCommand : public EditCommand
314 {
315 public:
316     DeleteTextCommand(DOM::DocumentImpl *document, DOM::TextImpl *node, long offset, long count);
317     virtual ~DeleteTextCommand();
318         
319     virtual void doApply();
320     virtual void doUnapply();
321
322     DOM::TextImpl *node() const { return m_node; }
323     long offset() const { return m_offset; }
324     long count() const { return m_count; }
325
326 private:
327     DOM::TextImpl *m_node;
328     long m_offset;
329     long m_count;
330     DOM::DOMString m_text;
331 };
332
333 //------------------------------------------------------------------------------------------
334 // InputNewlineCommand
335
336 class InputNewlineCommand : public CompositeEditCommand
337 {
338 public:
339     InputNewlineCommand(DOM::DocumentImpl *document);
340
341     virtual void doApply();
342
343 private:
344     void insertNodeAfterPosition(DOM::NodeImpl *node, const DOM::Position &pos);
345     void insertNodeBeforePosition(DOM::NodeImpl *node, const DOM::Position &pos);
346 };
347
348 //------------------------------------------------------------------------------------------
349 // InputNewlineInQuotedContentCommand
350
351 class InputNewlineInQuotedContentCommand : public CompositeEditCommand
352 {
353 public:
354     InputNewlineInQuotedContentCommand(DOM::DocumentImpl *);
355     virtual ~InputNewlineInQuotedContentCommand();
356         
357     virtual void doApply();
358     
359 private:
360     bool isMailBlockquote(const DOM::NodeImpl *) const;
361     bool isLastVisiblePositionInBlockquote(const VisiblePosition &pos, const DOM::NodeImpl *) const;
362
363     QPtrList<DOM::NodeImpl> ancestors;
364     QPtrList<DOM::NodeImpl> clonedNodes;
365     DOM::ElementImpl *m_breakNode;
366 };
367
368 //------------------------------------------------------------------------------------------
369 // InputTextCommand
370
371 class InputTextCommand : public CompositeEditCommand
372 {
373 public:
374     InputTextCommand(DOM::DocumentImpl *document);
375
376     virtual void doApply();
377
378     void deleteCharacter();
379     void input(const DOM::DOMString &text, bool selectInsertedText = false);
380     
381     unsigned long charactersAdded() const { return m_charactersAdded; }
382     
383 private:
384     virtual bool isInputTextCommand() const;
385
386     DOM::Position prepareForTextInsertion(bool adjustDownstream);
387     void insertSpace(DOM::TextImpl *textNode, unsigned long offset);
388
389     unsigned long m_charactersAdded;
390 };
391
392 //------------------------------------------------------------------------------------------
393 // InsertNodeBeforeCommand
394
395 class InsertNodeBeforeCommand : public EditCommand
396 {
397 public:
398     InsertNodeBeforeCommand(DOM::DocumentImpl *, DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
399     virtual ~InsertNodeBeforeCommand();
400
401     virtual void doApply();
402     virtual void doUnapply();
403
404     DOM::NodeImpl *insertChild() const { return m_insertChild; }
405     DOM::NodeImpl *refChild() const { return m_refChild; }
406
407 private:
408     DOM::NodeImpl *m_insertChild;
409     DOM::NodeImpl *m_refChild; 
410 };
411
412 //------------------------------------------------------------------------------------------
413 // InsertTextCommand
414
415 class InsertTextCommand : public EditCommand
416 {
417 public:
418     InsertTextCommand(DOM::DocumentImpl *document, DOM::TextImpl *, long, const DOM::DOMString &);
419     virtual ~InsertTextCommand();
420         
421     virtual void doApply();
422     virtual void doUnapply();
423
424     DOM::TextImpl *node() const { return m_node; }
425     long offset() const { return m_offset; }
426     DOM::DOMString text() const { return m_text; }
427
428 private:
429     DOM::TextImpl *m_node;
430     long m_offset;
431     DOM::DOMString m_text;
432 };
433
434 //------------------------------------------------------------------------------------------
435 // JoinTextNodesCommand
436
437 class JoinTextNodesCommand : public EditCommand
438 {
439 public:
440     JoinTextNodesCommand(DOM::DocumentImpl *, DOM::TextImpl *, DOM::TextImpl *);
441     virtual ~JoinTextNodesCommand();
442         
443     virtual void doApply();
444     virtual void doUnapply();
445
446     DOM::TextImpl *firstNode() const { return m_text1; }
447     DOM::TextImpl *secondNode() const { return m_text2; }
448
449 private:
450     DOM::TextImpl *m_text1;
451     DOM::TextImpl *m_text2;
452     unsigned long m_offset;
453 };
454
455 //------------------------------------------------------------------------------------------
456 // ReplaceSelectionCommand
457
458 class ReplaceSelectionCommand : public CompositeEditCommand
459 {
460 public:
461     ReplaceSelectionCommand(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, bool selectReplacement=true, bool smartReplace=false);
462     virtual ~ReplaceSelectionCommand();
463     
464     virtual void doApply();
465
466 private:
467     DOM::DocumentFragmentImpl *m_fragment;
468     bool m_selectReplacement;
469     bool m_smartReplace;
470 };
471
472 //------------------------------------------------------------------------------------------
473 // MoveSelectionCommand
474
475 class MoveSelectionCommand : public CompositeEditCommand
476 {
477 public:
478     MoveSelectionCommand(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, DOM::Position &position, bool smartMove=false);
479     virtual ~MoveSelectionCommand();
480     
481     virtual void doApply();
482     
483 private:
484     DOM::DocumentFragmentImpl *m_fragment;
485     DOM::Position m_position;
486     bool m_smartMove;
487 };
488
489 //------------------------------------------------------------------------------------------
490 // RemoveCSSPropertyCommand
491
492 class RemoveCSSPropertyCommand : public EditCommand
493 {
494 public:
495     RemoveCSSPropertyCommand(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *, int property);
496     virtual ~RemoveCSSPropertyCommand();
497
498     virtual void doApply();
499     virtual void doUnapply();
500
501     DOM::CSSStyleDeclarationImpl *styleDeclaration() const { return m_decl; }
502     int property() const { return m_property; }
503     
504 private:
505     DOM::CSSStyleDeclarationImpl *m_decl;
506     int m_property;
507     DOM::DOMString m_oldValue;
508     bool m_important;
509 };
510
511 //------------------------------------------------------------------------------------------
512 // RemoveNodeAttributeCommand
513
514 class RemoveNodeAttributeCommand : public EditCommand
515 {
516 public:
517     RemoveNodeAttributeCommand(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute);
518     virtual ~RemoveNodeAttributeCommand();
519
520     virtual void doApply();
521     virtual void doUnapply();
522
523     DOM::ElementImpl *element() const { return m_element; }
524     DOM::NodeImpl::Id attribute() const { return m_attribute; }
525     
526 private:
527     DOM::ElementImpl *m_element;
528     DOM::NodeImpl::Id m_attribute;
529     DOM::DOMString m_oldValue;
530 };
531
532 //------------------------------------------------------------------------------------------
533 // RemoveNodeCommand
534
535 class RemoveNodeCommand : public EditCommand
536 {
537 public:
538     RemoveNodeCommand(DOM::DocumentImpl *, DOM::NodeImpl *);
539     virtual ~RemoveNodeCommand();
540         
541     virtual void doApply();
542     virtual void doUnapply();
543
544     DOM::NodeImpl *node() const { return m_removeChild; }
545
546 private:
547     DOM::NodeImpl *m_parent;    
548     DOM::NodeImpl *m_removeChild;
549     DOM::NodeImpl *m_refChild;    
550 };
551
552 //------------------------------------------------------------------------------------------
553 // RemoveNodePreservingChildrenCommand
554
555 class RemoveNodePreservingChildrenCommand : public CompositeEditCommand
556 {
557 public:
558     RemoveNodePreservingChildrenCommand(DOM::DocumentImpl *, DOM::NodeImpl *);
559     virtual ~RemoveNodePreservingChildrenCommand();
560         
561     virtual void doApply();
562
563     DOM::NodeImpl *node() const { return m_node; }
564
565 private:
566     DOM::NodeImpl *m_node;
567 };
568
569 //------------------------------------------------------------------------------------------
570 // SetNodeAttributeCommand
571
572 class SetNodeAttributeCommand : public EditCommand
573 {
574 public:
575     SetNodeAttributeCommand(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute, const DOM::DOMString &value);
576     virtual ~SetNodeAttributeCommand();
577
578     virtual void doApply();
579     virtual void doUnapply();
580
581     DOM::ElementImpl *element() const { return m_element; }
582     DOM::NodeImpl::Id attribute() const { return m_attribute; }
583     DOM::DOMString value() const { return m_value; }
584     
585 private:
586     DOM::ElementImpl *m_element;
587     DOM::NodeImpl::Id m_attribute;
588     DOM::DOMString m_value;
589     DOM::DOMString m_oldValue;
590 };
591
592 //------------------------------------------------------------------------------------------
593 // SplitTextNodeCommand
594
595 class SplitTextNodeCommand : public EditCommand
596 {
597 public:
598     SplitTextNodeCommand(DOM::DocumentImpl *, DOM::TextImpl *, long);
599     virtual ~SplitTextNodeCommand();
600         
601     virtual void doApply();
602     virtual void doUnapply();
603
604     DOM::TextImpl *node() const { return m_text2; }
605     long offset() const { return m_offset; }
606
607 private:
608     DOM::TextImpl *m_text1;
609     DOM::TextImpl *m_text2;
610     unsigned long m_offset;
611 };
612
613 //------------------------------------------------------------------------------------------
614 // TypingCommand
615
616 class TypingCommand : public CompositeEditCommand
617 {
618 public:
619     enum ETypingCommand { DeleteKey, InsertText, InsertNewline, InsertNewlineInQuotedContent };
620
621     TypingCommand(DOM::DocumentImpl *document, ETypingCommand, const DOM::DOMString &text = "", bool selectInsertedText = false);
622
623     static void deleteKeyPressed(DOM::DocumentImpl *document);
624     static void insertText(DOM::DocumentImpl *document, const DOM::DOMString &text, bool selectInsertedText = false);
625     static void insertNewline(DOM::DocumentImpl *document);
626     static void insertNewlineInQuotedContent(DOM::DocumentImpl *document);
627     static bool isOpenForMoreTypingCommand(const EditCommandPtr &);
628     static void closeTyping(const EditCommandPtr &);
629     
630     virtual void doApply();
631
632     bool openForMoreTyping() const { return m_openForMoreTyping; }
633     void closeTyping() { m_openForMoreTyping = false; }
634
635     void insertText(const DOM::DOMString &text, bool selectInsertedText);
636     void insertNewline();
637     void insertNewlineInQuotedContent();
638     void deleteKeyPressed();
639
640 private:
641     virtual bool isTypingCommand() const;
642     virtual bool preservesTypingStyle() const;
643
644     void issueCommandForDeleteKey();
645     void removeCommand(const EditCommandPtr &);
646     void markMisspellingsAfterTyping();
647     void typingAddedToOpenCommand();
648     
649     ETypingCommand m_commandType;
650     DOM::DOMString m_textToInsert;
651     bool m_openForMoreTyping;
652     bool m_applyEditing;
653     bool m_selectInsertedText;
654 };
655
656 //------------------------------------------------------------------------------------------
657
658 } // end namespace khtml
659
660 #endif