Reviewed by Harrison
[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     void performDelete();
283     void fixupWhitespace();
284     void moveNodesAfterNode(DOM::NodeImpl *startNode, DOM::NodeImpl *dstNode);
285     void calculateEndingPosition();
286     void calculateTypingStyleAfterDelete();
287     void clearTransientState();
288
289     bool m_hasSelectionToDelete;
290     bool m_smartDelete;
291     bool m_mergeBlocksAfterDelete;
292     bool m_trailingWhitespaceValid;
293
294     // This data is transient and should be cleared at the end of the doApply function.
295     khtml::Selection m_selectionToDelete;
296     DOM::Position m_upstreamStart;
297     DOM::Position m_downstreamStart;
298     DOM::Position m_upstreamEnd;
299     DOM::Position m_downstreamEnd;
300     DOM::Position m_endingPosition;
301     DOM::Position m_leadingWhitespace;
302     DOM::Position m_trailingWhitespace;
303     DOM::NodeImpl *m_startBlock;
304     DOM::NodeImpl *m_endBlock;
305     DOM::NodeImpl *m_startNode;
306     DOM::CSSStyleDeclarationImpl *m_typingStyle;
307 };
308
309 //------------------------------------------------------------------------------------------
310 // DeleteTextCommand
311
312 class DeleteTextCommand : public EditCommand
313 {
314 public:
315     DeleteTextCommand(DOM::DocumentImpl *document, DOM::TextImpl *node, long offset, long count);
316     virtual ~DeleteTextCommand();
317         
318     virtual void doApply();
319     virtual void doUnapply();
320
321     DOM::TextImpl *node() const { return m_node; }
322     long offset() const { return m_offset; }
323     long count() const { return m_count; }
324
325 private:
326     DOM::TextImpl *m_node;
327     long m_offset;
328     long m_count;
329     DOM::DOMString m_text;
330 };
331
332 //------------------------------------------------------------------------------------------
333 // InputNewlineCommand
334
335 class InputNewlineCommand : public CompositeEditCommand
336 {
337 public:
338     InputNewlineCommand(DOM::DocumentImpl *document);
339
340     virtual void doApply();
341
342 private:
343     void insertNodeAfterPosition(DOM::NodeImpl *node, const DOM::Position &pos);
344     void insertNodeBeforePosition(DOM::NodeImpl *node, const DOM::Position &pos);
345 };
346
347 //------------------------------------------------------------------------------------------
348 // InputNewlineInQuotedContentCommand
349
350 class InputNewlineInQuotedContentCommand : public CompositeEditCommand
351 {
352 public:
353     InputNewlineInQuotedContentCommand(DOM::DocumentImpl *);
354     virtual ~InputNewlineInQuotedContentCommand();
355         
356     virtual void doApply();
357     
358 private:
359     bool isMailBlockquote(const DOM::NodeImpl *) const;
360     bool isLastVisiblePositionInBlockquote(const VisiblePosition &pos, const DOM::NodeImpl *) const;
361
362     QPtrList<DOM::NodeImpl> ancestors;
363     QPtrList<DOM::NodeImpl> clonedNodes;
364     DOM::ElementImpl *m_breakNode;
365 };
366
367 //------------------------------------------------------------------------------------------
368 // InputTextCommand
369
370 class InputTextCommand : public CompositeEditCommand
371 {
372 public:
373     InputTextCommand(DOM::DocumentImpl *document);
374
375     virtual void doApply();
376
377     void deleteCharacter();
378     void input(const DOM::DOMString &text, bool selectInsertedText = false);
379     
380     unsigned long charactersAdded() const { return m_charactersAdded; }
381     
382 private:
383     virtual bool isInputTextCommand() const;
384
385     DOM::Position prepareForTextInsertion(bool adjustDownstream);
386     void insertSpace(DOM::TextImpl *textNode, unsigned long offset);
387
388     unsigned long m_charactersAdded;
389 };
390
391 //------------------------------------------------------------------------------------------
392 // InsertNodeBeforeCommand
393
394 class InsertNodeBeforeCommand : public EditCommand
395 {
396 public:
397     InsertNodeBeforeCommand(DOM::DocumentImpl *, DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
398     virtual ~InsertNodeBeforeCommand();
399
400     virtual void doApply();
401     virtual void doUnapply();
402
403     DOM::NodeImpl *insertChild() const { return m_insertChild; }
404     DOM::NodeImpl *refChild() const { return m_refChild; }
405
406 private:
407     DOM::NodeImpl *m_insertChild;
408     DOM::NodeImpl *m_refChild; 
409 };
410
411 //------------------------------------------------------------------------------------------
412 // InsertTextCommand
413
414 class InsertTextCommand : public EditCommand
415 {
416 public:
417     InsertTextCommand(DOM::DocumentImpl *document, DOM::TextImpl *, long, const DOM::DOMString &);
418     virtual ~InsertTextCommand();
419         
420     virtual void doApply();
421     virtual void doUnapply();
422
423     DOM::TextImpl *node() const { return m_node; }
424     long offset() const { return m_offset; }
425     DOM::DOMString text() const { return m_text; }
426
427 private:
428     DOM::TextImpl *m_node;
429     long m_offset;
430     DOM::DOMString m_text;
431 };
432
433 //------------------------------------------------------------------------------------------
434 // JoinTextNodesCommand
435
436 class JoinTextNodesCommand : public EditCommand
437 {
438 public:
439     JoinTextNodesCommand(DOM::DocumentImpl *, DOM::TextImpl *, DOM::TextImpl *);
440     virtual ~JoinTextNodesCommand();
441         
442     virtual void doApply();
443     virtual void doUnapply();
444
445     DOM::TextImpl *firstNode() const { return m_text1; }
446     DOM::TextImpl *secondNode() const { return m_text2; }
447
448 private:
449     DOM::TextImpl *m_text1;
450     DOM::TextImpl *m_text2;
451     unsigned long m_offset;
452 };
453
454 //------------------------------------------------------------------------------------------
455 // ReplaceSelectionCommand
456
457 class ReplaceSelectionCommand : public CompositeEditCommand
458 {
459 public:
460     ReplaceSelectionCommand(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, bool selectReplacement=true, bool smartReplace=false);
461     virtual ~ReplaceSelectionCommand();
462     
463     virtual void doApply();
464
465 private:
466     DOM::DocumentFragmentImpl *m_fragment;
467     bool m_selectReplacement;
468     bool m_smartReplace;
469 };
470
471 //------------------------------------------------------------------------------------------
472 // MoveSelectionCommand
473
474 class MoveSelectionCommand : public CompositeEditCommand
475 {
476 public:
477     MoveSelectionCommand(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, DOM::Position &position, bool smartMove=false);
478     virtual ~MoveSelectionCommand();
479     
480     virtual void doApply();
481     
482 private:
483     DOM::DocumentFragmentImpl *m_fragment;
484     DOM::Position m_position;
485     bool m_smartMove;
486 };
487
488 //------------------------------------------------------------------------------------------
489 // RemoveCSSPropertyCommand
490
491 class RemoveCSSPropertyCommand : public EditCommand
492 {
493 public:
494     RemoveCSSPropertyCommand(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *, int property);
495     virtual ~RemoveCSSPropertyCommand();
496
497     virtual void doApply();
498     virtual void doUnapply();
499
500     DOM::CSSStyleDeclarationImpl *styleDeclaration() const { return m_decl; }
501     int property() const { return m_property; }
502     
503 private:
504     DOM::CSSStyleDeclarationImpl *m_decl;
505     int m_property;
506     DOM::DOMString m_oldValue;
507     bool m_important;
508 };
509
510 //------------------------------------------------------------------------------------------
511 // RemoveNodeAttributeCommand
512
513 class RemoveNodeAttributeCommand : public EditCommand
514 {
515 public:
516     RemoveNodeAttributeCommand(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute);
517     virtual ~RemoveNodeAttributeCommand();
518
519     virtual void doApply();
520     virtual void doUnapply();
521
522     DOM::ElementImpl *element() const { return m_element; }
523     DOM::NodeImpl::Id attribute() const { return m_attribute; }
524     
525 private:
526     DOM::ElementImpl *m_element;
527     DOM::NodeImpl::Id m_attribute;
528     DOM::DOMString m_oldValue;
529 };
530
531 //------------------------------------------------------------------------------------------
532 // RemoveNodeCommand
533
534 class RemoveNodeCommand : public EditCommand
535 {
536 public:
537     RemoveNodeCommand(DOM::DocumentImpl *, DOM::NodeImpl *);
538     virtual ~RemoveNodeCommand();
539         
540     virtual void doApply();
541     virtual void doUnapply();
542
543     DOM::NodeImpl *node() const { return m_removeChild; }
544
545 private:
546     DOM::NodeImpl *m_parent;    
547     DOM::NodeImpl *m_removeChild;
548     DOM::NodeImpl *m_refChild;    
549 };
550
551 //------------------------------------------------------------------------------------------
552 // RemoveNodePreservingChildrenCommand
553
554 class RemoveNodePreservingChildrenCommand : public CompositeEditCommand
555 {
556 public:
557     RemoveNodePreservingChildrenCommand(DOM::DocumentImpl *, DOM::NodeImpl *);
558     virtual ~RemoveNodePreservingChildrenCommand();
559         
560     virtual void doApply();
561
562     DOM::NodeImpl *node() const { return m_node; }
563
564 private:
565     DOM::NodeImpl *m_node;
566 };
567
568 //------------------------------------------------------------------------------------------
569 // SetNodeAttributeCommand
570
571 class SetNodeAttributeCommand : public EditCommand
572 {
573 public:
574     SetNodeAttributeCommand(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute, const DOM::DOMString &value);
575     virtual ~SetNodeAttributeCommand();
576
577     virtual void doApply();
578     virtual void doUnapply();
579
580     DOM::ElementImpl *element() const { return m_element; }
581     DOM::NodeImpl::Id attribute() const { return m_attribute; }
582     DOM::DOMString value() const { return m_value; }
583     
584 private:
585     DOM::ElementImpl *m_element;
586     DOM::NodeImpl::Id m_attribute;
587     DOM::DOMString m_value;
588     DOM::DOMString m_oldValue;
589 };
590
591 //------------------------------------------------------------------------------------------
592 // SplitTextNodeCommand
593
594 class SplitTextNodeCommand : public EditCommand
595 {
596 public:
597     SplitTextNodeCommand(DOM::DocumentImpl *, DOM::TextImpl *, long);
598     virtual ~SplitTextNodeCommand();
599         
600     virtual void doApply();
601     virtual void doUnapply();
602
603     DOM::TextImpl *node() const { return m_text2; }
604     long offset() const { return m_offset; }
605
606 private:
607     DOM::TextImpl *m_text1;
608     DOM::TextImpl *m_text2;
609     unsigned long m_offset;
610 };
611
612 //------------------------------------------------------------------------------------------
613 // TypingCommand
614
615 class TypingCommand : public CompositeEditCommand
616 {
617 public:
618     enum ETypingCommand { DeleteKey, InsertText, InsertNewline, InsertNewlineInQuotedContent };
619
620     TypingCommand(DOM::DocumentImpl *document, ETypingCommand, const DOM::DOMString &text = "", bool selectInsertedText = false);
621
622     static void deleteKeyPressed(DOM::DocumentImpl *document);
623     static void insertText(DOM::DocumentImpl *document, const DOM::DOMString &text, bool selectInsertedText = false);
624     static void insertNewline(DOM::DocumentImpl *document);
625     static void insertNewlineInQuotedContent(DOM::DocumentImpl *document);
626     static bool isOpenForMoreTypingCommand(const EditCommandPtr &);
627     static void closeTyping(const EditCommandPtr &);
628     
629     virtual void doApply();
630
631     bool openForMoreTyping() const { return m_openForMoreTyping; }
632     void closeTyping() { m_openForMoreTyping = false; }
633
634     void insertText(const DOM::DOMString &text, bool selectInsertedText);
635     void insertNewline();
636     void insertNewlineInQuotedContent();
637     void deleteKeyPressed();
638
639 private:
640     virtual bool isTypingCommand() const;
641     virtual bool preservesTypingStyle() const;
642
643     void issueCommandForDeleteKey();
644     void removeCommand(const EditCommandPtr &);
645     void markMisspellingsAfterTyping();
646     void typingAddedToOpenCommand();
647     
648     ETypingCommand m_commandType;
649     DOM::DOMString m_textToInsert;
650     bool m_openForMoreTyping;
651     bool m_applyEditing;
652     bool m_selectInsertedText;
653 };
654
655 //------------------------------------------------------------------------------------------
656
657 } // end namespace khtml
658
659 #endif