• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KHTML

  • khtml
  • editing
htmlediting_impl.h
Go to the documentation of this file.
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 __htmleditingimpl_h__
27#define __htmleditingimpl_h__
28
29#include "misc/shared.h"
30
31#include "xml/dom_position.h"
32#include "xml/dom_selection.h"
33#include "dom/dom_string.h"
34
35#include "xml/dom_nodeimpl.h"
36
37#include <QList>
38
39namespace DOM {
40 class CSSProperty;
41 class CSSStyleDeclarationImpl;
42 class DocumentFragmentImpl;
43 class DocumentImpl;
44 class DOMString;
45 class ElementImpl;
46 class HTMLElementImpl;
47 class NodeImpl;
48 class NodeListImpl;
49 class Position;
50 class Range;
51 class Selection;
52 class TextImpl;
53 class TreeWalkerImpl;
54}
55
56using DOM::DocumentImpl;
57using DOM::NodeImpl;
58
59namespace khtml
60{
61
62class EditCommandImpl;
63
64class SharedCommandImpl : public Shared<SharedCommandImpl>
65{
66public:
67 SharedCommandImpl() {}
68 virtual ~SharedCommandImpl() {}
69
70 virtual bool isCompositeStep() const = 0;
71
72 virtual void apply() = 0;
73 virtual void unapply() = 0;
74 virtual void reapply() = 0;
75
76 virtual DOM::DocumentImpl* document() const = 0;
77
78 virtual DOM::Selection startingSelection() const = 0;
79 virtual DOM::Selection endingSelection() const = 0;
80
81 virtual void setStartingSelection(const DOM::Selection &s) = 0;
82 virtual void setEndingSelection(const DOM::Selection &s) = 0;
83
84 virtual EditCommandImpl* parent() const = 0;
85 virtual void setParent(EditCommandImpl *) = 0;
86};
87
88//------------------------------------------------------------------------------------------
89// EditCommandImpl
90
91class EditCommandImpl : public SharedCommandImpl
92{
93public:
94 EditCommandImpl(DOM::DocumentImpl *);
95 virtual ~EditCommandImpl();
96
97 bool isCompositeStep() const { return parent(); }
98 EditCommandImpl* parent() const;
99 void setParent(EditCommandImpl *);
100
101 enum ECommandState { NotApplied, Applied };
102
103 void apply();
104 void unapply();
105 void reapply();
106
107 virtual void doApply() = 0;
108 virtual void doUnapply() = 0;
109 virtual void doReapply(); // calls doApply()
110
111 virtual DOM::DocumentImpl* document() const { return m_document.get(); }
112
113 DOM::Selection startingSelection() const { return m_startingSelection; }
114 DOM::Selection endingSelection() const { return m_endingSelection; }
115
116 ECommandState state() const { return m_state; }
117 void setState(ECommandState state) { m_state = state; }
118
119 void setStartingSelection(const DOM::Selection &s);
120 void setEndingSelection(const DOM::Selection &s);
121
122public:
123 virtual bool isTypingCommand() const { return false; }
124 virtual bool isInputTextCommand() const { return false; }
125
126private:
127 DocPtr<DOM::DocumentImpl> m_document;
128 ECommandState m_state;
129 DOM::Selection m_startingSelection;
130 DOM::Selection m_endingSelection;
131 RefPtr<EditCommandImpl> m_parent;
132};
133
134//------------------------------------------------------------------------------------------
135// CompositeEditCommandImpl
136
137class CompositeEditCommandImpl : public EditCommandImpl
138{
139public:
140 CompositeEditCommandImpl(DOM::DocumentImpl *);
141 virtual ~CompositeEditCommandImpl();
142
143 virtual void doApply() = 0;
144 virtual void doUnapply();
145 virtual void doReapply();
146
147protected:
148 //
149 // sugary-sweet convenience functions to help create and apply edit commands in composite commands
150 //
151 void appendNode(DOM::NodeImpl *parent, DOM::NodeImpl *appendChild);
152 void applyCommandToComposite(PassRefPtr<EditCommandImpl>);
153 void deleteCollapsibleWhitespace();
154 void deleteCollapsibleWhitespace(const DOM::Selection &selection);
155 void deleteKeyPressed();
156 void deleteSelection();
157 void deleteSelection(const DOM::Selection &selection);
158 void deleteText(DOM::TextImpl *node, long offset, long count);
159 void inputText(const DOM::DOMString &text);
160 void insertNodeAfter(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
161 void insertNodeAt(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild, long offset);
162 void insertNodeBefore(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
163 void insertText(DOM::TextImpl *node, long offset, const DOM::DOMString &text);
164 void joinTextNodes(DOM::TextImpl *text1, DOM::TextImpl *text2);
165 void removeCSSProperty(DOM::CSSStyleDeclarationImpl *, int property);
166 void removeNodeAttribute(DOM::ElementImpl *, int attribute);
167 void removeNode(DOM::NodeImpl *removeChild);
168 void removeNodeAndPrune(DOM::NodeImpl *pruneNode, DOM::NodeImpl *stopNode=0);
169 void removeNodePreservingChildren(DOM::NodeImpl *node);
170 void replaceText(DOM::TextImpl *node, long offset, long count, const DOM::DOMString &replacementText);
171 void setNodeAttribute(DOM::ElementImpl *, int attribute, const DOM::DOMString &);
172 void splitTextNode(DOM::TextImpl *text, long offset);
173
174 DOM::ElementImpl *createTypingStyleElement() const;
175
176 QList<RefPtr<EditCommandImpl> > m_cmds;
177};
178
179//==========================================================================================
180// Concrete commands
181//------------------------------------------------------------------------------------------
182// AppendNodeCommandImpl
183
184class AppendNodeCommandImpl : public EditCommandImpl
185{
186public:
187 AppendNodeCommandImpl(DOM::DocumentImpl *, DOM::NodeImpl *parentNode, DOM::NodeImpl *appendChild);
188 virtual ~AppendNodeCommandImpl();
189
190 virtual void doApply();
191 virtual void doUnapply();
192
193 DOM::NodeImpl *parentNode() const { return m_parentNode; }
194 DOM::NodeImpl *appendChild() const { return m_appendChild; }
195
196private:
197 DOM::NodeImpl *m_parentNode;
198 DOM::NodeImpl *m_appendChild;
199};
200
201//------------------------------------------------------------------------------------------
202// ApplyStyleCommandImpl
203
204class ApplyStyleCommandImpl : public CompositeEditCommandImpl
205{
206public:
207 ApplyStyleCommandImpl(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *style);
208 virtual ~ApplyStyleCommandImpl();
209
210 virtual void doApply();
211
212 DOM::CSSStyleDeclarationImpl *style() const { return m_style; }
213
214 struct StyleChange {
215 StyleChange() : applyBold(false), applyItalic(false) {}
216 DOM::DOMString cssStyle;
217 bool applyBold:1;
218 bool applyItalic:1;
219 };
220
221private:
222 // style-removal helpers
223 bool isHTMLStyleNode(DOM::HTMLElementImpl *);
224 void removeHTMLStyleNode(DOM::HTMLElementImpl *);
225 void removeCSSStyle(DOM::HTMLElementImpl *);
226 void removeStyle(const DOM::Position &start, const DOM::Position &end);
227 bool nodeFullySelected(const DOM::NodeImpl *node) const;
228
229 // style-application helpers
230 bool currentlyHasStyle(const DOM::Position &, const DOM::CSSProperty *) const;
231 StyleChange computeStyleChange(const DOM::Position &, DOM::CSSStyleDeclarationImpl *);
232 bool splitTextAtStartIfNeeded(const DOM::Position &start, const DOM::Position &end);
233 DOM::NodeImpl *splitTextAtEndIfNeeded(const DOM::Position &start, const DOM::Position &end);
234 void surroundNodeRangeWithElement(DOM::NodeImpl *start, DOM::NodeImpl *end, DOM::ElementImpl *element);
235 DOM::Position positionInsertionPoint(DOM::Position);
236 void applyStyleIfNeeded(DOM::NodeImpl *start, DOM::NodeImpl *end);
237
238 DOM::CSSStyleDeclarationImpl *m_style;
239};
240
241//------------------------------------------------------------------------------------------
242// DeleteCollapsibleWhitespaceCommandImpl
243
244class DeleteCollapsibleWhitespaceCommandImpl : public CompositeEditCommandImpl
245{
246public:
247 DeleteCollapsibleWhitespaceCommandImpl(DOM::DocumentImpl *document);
248 DeleteCollapsibleWhitespaceCommandImpl(DOM::DocumentImpl *document, const DOM::Selection &selection);
249
250 virtual ~DeleteCollapsibleWhitespaceCommandImpl();
251
252 virtual void doApply();
253
254private:
255 DOM::Position deleteWhitespace(const DOM::Position &pos);
256
257 unsigned long m_charactersDeleted;
258 DOM::Selection m_selectionToCollapse;
259 bool m_hasSelectionToCollapse;
260};
261
262//------------------------------------------------------------------------------------------
263// DeleteSelectionCommandImpl
264
265class DeleteSelectionCommandImpl : public CompositeEditCommandImpl
266{
267public:
268 DeleteSelectionCommandImpl(DOM::DocumentImpl *document);
269 DeleteSelectionCommandImpl(DOM::DocumentImpl *document, const DOM::Selection &selection);
270
271 virtual ~DeleteSelectionCommandImpl();
272
273 virtual void doApply();
274
275private:
276 void deleteContentBeforeOffset(NodeImpl *node, int offset);
277 void deleteContentAfterOffset(NodeImpl *node, int offset);
278 void deleteContentInsideNode(NodeImpl *node, int startOffset, int endOffset);
279 void deleteDownstreamWS(const DOM::Position &start);
280 bool containsOnlyWhitespace(const DOM::Position &start, const DOM::Position &end);
281 void joinTextNodesWithSameStyle();
282
283 DOM::Selection m_selectionToDelete;
284 bool m_hasSelectionToDelete;
285};
286
287//------------------------------------------------------------------------------------------
288// DeleteTextCommandImpl
289
290class DeleteTextCommandImpl : public EditCommandImpl
291{
292public:
293 DeleteTextCommandImpl(DOM::DocumentImpl *document, DOM::TextImpl *node, long offset, long count);
294 virtual ~DeleteTextCommandImpl();
295
296 virtual void doApply();
297 virtual void doUnapply();
298
299 DOM::TextImpl *node() const { return m_node; }
300 long offset() const { return m_offset; }
301 long count() const { return m_count; }
302
303private:
304 DOM::TextImpl *m_node;
305 long m_offset;
306 long m_count;
307 DOM::DOMString m_text;
308};
309
310//------------------------------------------------------------------------------------------
311// InputNewlineCommandImpl
312
313class InputNewlineCommandImpl : public CompositeEditCommandImpl
314{
315public:
316 InputNewlineCommandImpl(DOM::DocumentImpl *document);
317 virtual ~InputNewlineCommandImpl();
318
319 virtual void doApply();
320
321private:
322 void insertNodeAfterPosition(DOM::NodeImpl *node, const DOM::Position &pos);
323 void insertNodeBeforePosition(DOM::NodeImpl *node, const DOM::Position &pos);
324};
325
326//------------------------------------------------------------------------------------------
327// InputTextCommandImpl
328
329class InputTextCommandImpl : public CompositeEditCommandImpl
330{
331public:
332 InputTextCommandImpl(DOM::DocumentImpl *document);
333 virtual ~InputTextCommandImpl();
334
335 virtual void doApply();
336
337 void deleteCharacter();
338 void input(const DOM::DOMString &text);
339
340 unsigned long charactersAdded() const { return m_charactersAdded; }
341
342 virtual bool isInputTextCommand() const { return true; }
343private:
344 DOM::Position prepareForTextInsertion(bool adjustDownstream);
345 void execute(const DOM::DOMString &text);
346 void insertSpace(DOM::TextImpl *textNode, unsigned long offset);
347
348 unsigned long m_charactersAdded;
349};
350
351//------------------------------------------------------------------------------------------
352// InsertNodeBeforeCommandImpl
353
354class InsertNodeBeforeCommandImpl : public EditCommandImpl
355{
356public:
357 InsertNodeBeforeCommandImpl(DOM::DocumentImpl *, DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
358 virtual ~InsertNodeBeforeCommandImpl();
359
360 virtual void doApply();
361 virtual void doUnapply();
362
363 DOM::NodeImpl *insertChild() const { return m_insertChild; }
364 DOM::NodeImpl *refChild() const { return m_refChild; }
365
366private:
367 DOM::NodeImpl *m_insertChild;
368 DOM::NodeImpl *m_refChild;
369};
370
371//------------------------------------------------------------------------------------------
372// InsertTextCommandImpl
373
374class InsertTextCommandImpl : public EditCommandImpl
375{
376public:
377 InsertTextCommandImpl(DOM::DocumentImpl *document, DOM::TextImpl *, long, const DOM::DOMString &);
378 virtual ~InsertTextCommandImpl();
379
380 virtual void doApply();
381 virtual void doUnapply();
382
383 DOM::TextImpl *node() const { return m_node; }
384 long offset() const { return m_offset; }
385 DOM::DOMString text() const { return m_text; }
386
387private:
388 DOM::TextImpl *m_node;
389 long m_offset;
390 DOM::DOMString m_text;
391};
392
393//------------------------------------------------------------------------------------------
394// JoinTextNodesCommandImpl
395
396class JoinTextNodesCommandImpl : public EditCommandImpl
397{
398public:
399 JoinTextNodesCommandImpl(DOM::DocumentImpl *, DOM::TextImpl *, DOM::TextImpl *);
400 virtual ~JoinTextNodesCommandImpl();
401
402 virtual void doApply();
403 virtual void doUnapply();
404
405 DOM::TextImpl *firstNode() const { return m_text1; }
406 DOM::TextImpl *secondNode() const { return m_text2; }
407
408private:
409 DOM::TextImpl *m_text1;
410 DOM::TextImpl *m_text2;
411 unsigned long m_offset;
412};
413
414//------------------------------------------------------------------------------------------
415// ReplaceSelectionCommandImpl
416
417class ReplaceSelectionCommandImpl : public CompositeEditCommandImpl
418{
419public:
420 ReplaceSelectionCommandImpl(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, bool selectReplacement=true);
421 virtual ~ReplaceSelectionCommandImpl();
422
423 virtual void doApply();
424
425private:
426 DOM::DocumentFragmentImpl *m_fragment;
427 bool m_selectReplacement;
428};
429
430//------------------------------------------------------------------------------------------
431// MoveSelectionCommandImpl
432
433class MoveSelectionCommandImpl : public CompositeEditCommandImpl
434{
435public:
436 MoveSelectionCommandImpl(DOM::DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, DOM::Position &position);
437 virtual ~MoveSelectionCommandImpl();
438
439 virtual void doApply();
440
441private:
442 DOM::DocumentFragmentImpl *m_fragment;
443 DOM::Position m_position;
444};
445
446//------------------------------------------------------------------------------------------
447// RemoveCSSPropertyCommand
448
449class RemoveCSSPropertyCommandImpl : public EditCommandImpl
450{
451public:
452 RemoveCSSPropertyCommandImpl(DOM::DocumentImpl *, DOM::CSSStyleDeclarationImpl *, int property);
453 virtual ~RemoveCSSPropertyCommandImpl();
454
455 virtual void doApply();
456 virtual void doUnapply();
457
458 DOM::CSSStyleDeclarationImpl *styleDeclaration() const { return m_decl; }
459 int property() const { return m_property; }
460
461private:
462 DOM::CSSStyleDeclarationImpl *m_decl;
463 int m_property;
464 DOM::DOMString m_oldValue;
465 bool m_important;
466};
467
468//------------------------------------------------------------------------------------------
469// RemoveNodeAttributeCommandImpl
470
471class RemoveNodeAttributeCommandImpl : public EditCommandImpl
472{
473public:
474 RemoveNodeAttributeCommandImpl(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute);
475 virtual ~RemoveNodeAttributeCommandImpl();
476
477 virtual void doApply();
478 virtual void doUnapply();
479
480 DOM::ElementImpl *element() const { return m_element; }
481 DOM::NodeImpl::Id attribute() const { return m_attribute; }
482
483private:
484 DOM::ElementImpl *m_element;
485 DOM::NodeImpl::Id m_attribute;
486 DOM::DOMString m_oldValue;
487};
488
489//------------------------------------------------------------------------------------------
490// RemoveNodeCommandImpl
491
492class RemoveNodeCommandImpl : public EditCommandImpl
493{
494public:
495 RemoveNodeCommandImpl(DOM::DocumentImpl *, DOM::NodeImpl *);
496 virtual ~RemoveNodeCommandImpl();
497
498 virtual void doApply();
499 virtual void doUnapply();
500
501 DOM::NodeImpl *node() const { return m_removeChild; }
502
503private:
504 DOM::NodeImpl *m_parent;
505 DOM::NodeImpl *m_removeChild;
506 DOM::NodeImpl *m_refChild;
507};
508
509//------------------------------------------------------------------------------------------
510// RemoveNodeAndPruneCommandImpl
511
512class RemoveNodeAndPruneCommandImpl : public CompositeEditCommandImpl
513{
514public:
515 RemoveNodeAndPruneCommandImpl(DOM::DocumentImpl *, DOM::NodeImpl *pruneNode, DOM::NodeImpl *stopNode=0);
516 virtual ~RemoveNodeAndPruneCommandImpl();
517
518 virtual void doApply();
519
520 DOM::NodeImpl *pruneNode() const { return m_pruneNode; }
521 DOM::NodeImpl *stopNode() const { return m_stopNode; }
522
523private:
524 DOM::NodeImpl *m_pruneNode;
525 DOM::NodeImpl *m_stopNode;
526};
527
528//------------------------------------------------------------------------------------------
529// RemoveNodePreservingChildrenCommandImpl
530
531class RemoveNodePreservingChildrenCommandImpl : public CompositeEditCommandImpl
532{
533public:
534 RemoveNodePreservingChildrenCommandImpl(DOM::DocumentImpl *, DOM::NodeImpl *);
535 virtual ~RemoveNodePreservingChildrenCommandImpl();
536
537 virtual void doApply();
538
539 DOM::NodeImpl *node() const { return m_node; }
540
541private:
542 DOM::NodeImpl *m_node;
543};
544
545//------------------------------------------------------------------------------------------
546// SetNodeAttributeCommandImpl
547
548class SetNodeAttributeCommandImpl : public EditCommandImpl
549{
550public:
551 SetNodeAttributeCommandImpl(DOM::DocumentImpl *, DOM::ElementImpl *, DOM::NodeImpl::Id attribute, const DOM::DOMString &value);
552 virtual ~SetNodeAttributeCommandImpl();
553
554 virtual void doApply();
555 virtual void doUnapply();
556
557 DOM::ElementImpl *element() const { return m_element; }
558 DOM::NodeImpl::Id attribute() const { return m_attribute; }
559 DOM::DOMString value() const { return m_value; }
560
561private:
562 DOM::ElementImpl *m_element;
563 DOM::NodeImpl::Id m_attribute;
564 DOM::DOMString m_value;
565 DOM::DOMString m_oldValue;
566};
567
568//------------------------------------------------------------------------------------------
569// SplitTextNodeCommandImpl
570
571class SplitTextNodeCommandImpl : public EditCommandImpl
572{
573public:
574 SplitTextNodeCommandImpl(DOM::DocumentImpl *, DOM::TextImpl *, long);
575 virtual ~SplitTextNodeCommandImpl();
576
577 virtual void doApply();
578 virtual void doUnapply();
579
580 DOM::TextImpl *node() const { return m_text2; }
581 long offset() const { return m_offset; }
582
583private:
584 DOM::TextImpl *m_text1;
585 DOM::TextImpl *m_text2;
586 unsigned long m_offset;
587};
588
589//------------------------------------------------------------------------------------------
590// TypingCommandImpl
591
592class TypingCommandImpl : public CompositeEditCommandImpl
593{
594public:
595 TypingCommandImpl(DOM::DocumentImpl *document);
596 virtual ~TypingCommandImpl();
597
598 virtual void doApply();
599
600 bool openForMoreTyping() const { return m_openForMoreTyping; }
601 void closeTyping() { m_openForMoreTyping = false; }
602
603 void insertText(const DOM::DOMString &text);
604 void insertNewline();
605 void deleteKeyPressed();
606
607 virtual bool isTypingCommand() const { return true; }
608
609 static void deleteKeyPressed0(DocumentImpl *document);
610 static void insertNewline0(DocumentImpl *document);
611 static void insertText0(DocumentImpl *document, const DOMString &text);
612
613private:
614 void issueCommandForDeleteKey();
615 void removeCommand(const PassRefPtr<EditCommandImpl>);
616 void typingAddedToOpenCommand();
617
618 bool m_openForMoreTyping;
619};
620
621//------------------------------------------------------------------------------------------
622// InsertListCommandImpl
623
624class InsertListCommandImpl : public CompositeEditCommandImpl
625{
626public:
627 enum Type { OrderedList, UnorderedList };
628
629 InsertListCommandImpl(DOM::DocumentImpl *document, Type type);
630 virtual ~InsertListCommandImpl();
631
632 virtual void doApply();
633
634 static void insertList(DocumentImpl *document, Type type);
635
636private:
637 Type m_listType;
638};
639
640//------------------------------------------------------------------------------------------
641
642//------------------------------------------------------------------------------------------
643// IndentOutdentCommandImpl
644
645class IndentOutdentCommandImpl : public CompositeEditCommandImpl
646{
647public:
648 enum Type { Indent, Outdent };
649
650 IndentOutdentCommandImpl(DocumentImpl *document, Type type);
651 virtual ~IndentOutdentCommandImpl();
652
653 virtual void doApply();
654
655private:
656 void indent();
657 void outdent();
658
659 Type m_commandType;
660};
661
662//------------------------------------------------------------------------------------------
663
664} // end namespace khtml
665
666#endif
667
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:44
QList
Shared
khtml::AppendNodeCommandImpl
Definition: htmlediting_impl.h:185
khtml::AppendNodeCommandImpl::appendChild
DOM::NodeImpl * appendChild() const
Definition: htmlediting_impl.h:194
khtml::AppendNodeCommandImpl::~AppendNodeCommandImpl
virtual ~AppendNodeCommandImpl()
Definition: htmlediting_impl.cpp:534
khtml::AppendNodeCommandImpl::parentNode
DOM::NodeImpl * parentNode() const
Definition: htmlediting_impl.h:193
khtml::AppendNodeCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:542
khtml::AppendNodeCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:552
khtml::ApplyStyleCommandImpl
Definition: htmlediting_impl.h:205
khtml::ApplyStyleCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:634
khtml::ApplyStyleCommandImpl::style
DOM::CSSStyleDeclarationImpl * style() const
Definition: htmlediting_impl.h:212
khtml::ApplyStyleCommandImpl::~ApplyStyleCommandImpl
virtual ~ApplyStyleCommandImpl()
Definition: htmlediting_impl.cpp:573
khtml::CompositeEditCommandImpl
Definition: htmlediting_impl.h:138
khtml::CompositeEditCommandImpl::removeCSSProperty
void removeCSSProperty(DOM::CSSStyleDeclarationImpl *, int property)
Definition: htmlediting_impl.cpp:486
khtml::CompositeEditCommandImpl::removeNodeAttribute
void removeNodeAttribute(DOM::ElementImpl *, int attribute)
Definition: htmlediting_impl.cpp:492
khtml::CompositeEditCommandImpl::joinTextNodes
void joinTextNodes(DOM::TextImpl *text1, DOM::TextImpl *text2)
Definition: htmlediting_impl.cpp:425
khtml::CompositeEditCommandImpl::removeNodeAndPrune
void removeNodeAndPrune(DOM::NodeImpl *pruneNode, DOM::NodeImpl *stopNode=0)
Definition: htmlediting_impl.cpp:407
khtml::CompositeEditCommandImpl::deleteSelection
void deleteSelection(const DOM::Selection &selection)
khtml::CompositeEditCommandImpl::m_cmds
QList< RefPtr< EditCommandImpl > > m_cmds
Definition: htmlediting_impl.h:176
khtml::CompositeEditCommandImpl::insertNodeAt
void insertNodeAt(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild, long offset)
Definition: htmlediting_impl.cpp:372
khtml::CompositeEditCommandImpl::doReapply
virtual void doReapply()
Definition: htmlediting_impl.cpp:331
khtml::CompositeEditCommandImpl::splitTextNode
void splitTextNode(DOM::TextImpl *text, long offset)
Definition: htmlediting_impl.cpp:419
khtml::CompositeEditCommandImpl::inputText
void inputText(const DOM::DOMString &text)
Definition: htmlediting_impl.cpp:431
khtml::CompositeEditCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:319
khtml::CompositeEditCommandImpl::replaceText
void replaceText(DOM::TextImpl *node, long offset, long count, const DOM::DOMString &replacementText)
Definition: htmlediting_impl.cpp:450
khtml::CompositeEditCommandImpl::removeNodePreservingChildren
void removeNodePreservingChildren(DOM::NodeImpl *node)
Definition: htmlediting_impl.cpp:413
khtml::CompositeEditCommandImpl::createTypingStyleElement
DOM::ElementImpl * createTypingStyleElement() const
Definition: htmlediting_impl.cpp:504
khtml::CompositeEditCommandImpl::applyCommandToComposite
void applyCommandToComposite(PassRefPtr< EditCommandImpl >)
Definition: htmlediting_impl.cpp:346
khtml::CompositeEditCommandImpl::removeNode
void removeNode(DOM::NodeImpl *removeChild)
Definition: htmlediting_impl.cpp:401
khtml::CompositeEditCommandImpl::insertNodeBefore
void insertNodeBefore(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild)
Definition: htmlediting_impl.cpp:355
khtml::CompositeEditCommandImpl::deleteKeyPressed
void deleteKeyPressed()
khtml::CompositeEditCommandImpl::deleteSelection
void deleteSelection()
Definition: htmlediting_impl.cpp:458
khtml::CompositeEditCommandImpl::appendNode
void appendNode(DOM::NodeImpl *parent, DOM::NodeImpl *appendChild)
Definition: htmlediting_impl.cpp:395
khtml::CompositeEditCommandImpl::deleteText
void deleteText(DOM::TextImpl *node, long offset, long count)
Definition: htmlediting_impl.cpp:444
khtml::CompositeEditCommandImpl::setNodeAttribute
void setNodeAttribute(DOM::ElementImpl *, int attribute, const DOM::DOMString &)
Definition: htmlediting_impl.cpp:498
khtml::CompositeEditCommandImpl::~CompositeEditCommandImpl
virtual ~CompositeEditCommandImpl()
Definition: htmlediting_impl.cpp:315
khtml::CompositeEditCommandImpl::deleteCollapsibleWhitespace
void deleteCollapsibleWhitespace(const DOM::Selection &selection)
khtml::CompositeEditCommandImpl::insertText
void insertText(DOM::TextImpl *node, long offset, const DOM::DOMString &text)
Definition: htmlediting_impl.cpp:438
khtml::CompositeEditCommandImpl::doApply
virtual void doApply()=0
khtml::CompositeEditCommandImpl::deleteCollapsibleWhitespace
void deleteCollapsibleWhitespace()
Definition: htmlediting_impl.cpp:474
khtml::CompositeEditCommandImpl::insertNodeAfter
void insertNodeAfter(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild)
Definition: htmlediting_impl.cpp:361
khtml::DeleteCollapsibleWhitespaceCommandImpl
Definition: htmlediting_impl.h:245
khtml::DeleteCollapsibleWhitespaceCommandImpl::~DeleteCollapsibleWhitespaceCommandImpl
virtual ~DeleteCollapsibleWhitespaceCommandImpl()
Definition: htmlediting_impl.cpp:1011
khtml::DeleteCollapsibleWhitespaceCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:1140
khtml::DeleteCollapsibleWhitespaceCommandImpl::DeleteCollapsibleWhitespaceCommandImpl
DeleteCollapsibleWhitespaceCommandImpl(DOM::DocumentImpl *document)
khtml::DeleteCollapsibleWhitespaceCommandImpl::DeleteCollapsibleWhitespaceCommandImpl
DeleteCollapsibleWhitespaceCommandImpl(DOM::DocumentImpl *document, const DOM::Selection &selection)
khtml::DeleteSelectionCommandImpl
Definition: htmlediting_impl.h:266
khtml::DeleteSelectionCommandImpl::DeleteSelectionCommandImpl
DeleteSelectionCommandImpl(DOM::DocumentImpl *document, const DOM::Selection &selection)
khtml::DeleteSelectionCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:1293
khtml::DeleteSelectionCommandImpl::DeleteSelectionCommandImpl
DeleteSelectionCommandImpl(DOM::DocumentImpl *document)
khtml::DeleteSelectionCommandImpl::~DeleteSelectionCommandImpl
virtual ~DeleteSelectionCommandImpl()
Definition: htmlediting_impl.cpp:1187
khtml::DeleteTextCommandImpl
Definition: htmlediting_impl.h:291
khtml::DeleteTextCommandImpl::count
long count() const
Definition: htmlediting_impl.h:301
khtml::DeleteTextCommandImpl::offset
long offset() const
Definition: htmlediting_impl.h:300
khtml::DeleteTextCommandImpl::~DeleteTextCommandImpl
virtual ~DeleteTextCommandImpl()
Definition: htmlediting_impl.cpp:1561
khtml::DeleteTextCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:1579
khtml::DeleteTextCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:1567
khtml::DeleteTextCommandImpl::node
DOM::TextImpl * node() const
Definition: htmlediting_impl.h:299
khtml::EditCommandImpl
Definition: htmlediting_impl.h:92
khtml::EditCommandImpl::state
ECommandState state() const
Definition: htmlediting_impl.h:116
khtml::EditCommandImpl::setEndingSelection
void setEndingSelection(const DOM::Selection &s)
Definition: htmlediting_impl.cpp:287
khtml::EditCommandImpl::isInputTextCommand
virtual bool isInputTextCommand() const
Definition: htmlediting_impl.h:124
khtml::EditCommandImpl::apply
void apply()
Definition: htmlediting_impl.cpp:230
khtml::EditCommandImpl::setStartingSelection
void setStartingSelection(const DOM::Selection &s)
Definition: htmlediting_impl.cpp:277
khtml::EditCommandImpl::document
virtual DOM::DocumentImpl * document() const
Definition: htmlediting_impl.h:111
khtml::EditCommandImpl::doReapply
virtual void doReapply()
Definition: htmlediting_impl.cpp:272
khtml::EditCommandImpl::parent
EditCommandImpl * parent() const
Definition: htmlediting_impl.cpp:297
khtml::EditCommandImpl::doApply
virtual void doApply()=0
khtml::EditCommandImpl::isCompositeStep
bool isCompositeStep() const
Definition: htmlediting_impl.h:97
khtml::EditCommandImpl::isTypingCommand
virtual bool isTypingCommand() const
Definition: htmlediting_impl.h:123
khtml::EditCommandImpl::reapply
void reapply()
Definition: htmlediting_impl.cpp:258
khtml::EditCommandImpl::setParent
void setParent(EditCommandImpl *)
Definition: htmlediting_impl.cpp:302
khtml::EditCommandImpl::~EditCommandImpl
virtual ~EditCommandImpl()
Definition: htmlediting_impl.cpp:225
khtml::EditCommandImpl::endingSelection
DOM::Selection endingSelection() const
Definition: htmlediting_impl.h:114
khtml::EditCommandImpl::startingSelection
DOM::Selection startingSelection() const
Definition: htmlediting_impl.h:113
khtml::EditCommandImpl::ECommandState
ECommandState
Definition: htmlediting_impl.h:101
khtml::EditCommandImpl::Applied
@ Applied
Definition: htmlediting_impl.h:101
khtml::EditCommandImpl::NotApplied
@ NotApplied
Definition: htmlediting_impl.h:101
khtml::EditCommandImpl::setState
void setState(ECommandState state)
Definition: htmlediting_impl.h:117
khtml::EditCommandImpl::doUnapply
virtual void doUnapply()=0
khtml::EditCommandImpl::unapply
void unapply()
Definition: htmlediting_impl.cpp:244
khtml::IndentOutdentCommandImpl
Definition: htmlediting_impl.h:646
khtml::IndentOutdentCommandImpl::Type
Type
Definition: htmlediting_impl.h:648
khtml::IndentOutdentCommandImpl::Outdent
@ Outdent
Definition: htmlediting_impl.h:648
khtml::IndentOutdentCommandImpl::Indent
@ Indent
Definition: htmlediting_impl.h:648
khtml::IndentOutdentCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2998
khtml::IndentOutdentCommandImpl::~IndentOutdentCommandImpl
virtual ~IndentOutdentCommandImpl()
Definition: htmlediting_impl.cpp:2842
khtml::InputNewlineCommandImpl
Definition: htmlediting_impl.h:314
khtml::InputNewlineCommandImpl::~InputNewlineCommandImpl
virtual ~InputNewlineCommandImpl()
Definition: htmlediting_impl.cpp:1597
khtml::InputNewlineCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:1627
khtml::InputTextCommandImpl
Definition: htmlediting_impl.h:330
khtml::InputTextCommandImpl::deleteCharacter
void deleteCharacter()
Definition: htmlediting_impl.cpp:1784
khtml::InputTextCommandImpl::input
void input(const DOM::DOMString &text)
Definition: htmlediting_impl.cpp:1779
khtml::InputTextCommandImpl::isInputTextCommand
virtual bool isInputTextCommand() const
Definition: htmlediting_impl.h:342
khtml::InputTextCommandImpl::charactersAdded
unsigned long charactersAdded() const
Definition: htmlediting_impl.h:340
khtml::InputTextCommandImpl::~InputTextCommandImpl
virtual ~InputTextCommandImpl()
Definition: htmlediting_impl.cpp:1771
khtml::InputTextCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:1775
khtml::InsertListCommandImpl
Definition: htmlediting_impl.h:625
khtml::InsertListCommandImpl::~InsertListCommandImpl
virtual ~InsertListCommandImpl()
Definition: htmlediting_impl.cpp:2736
khtml::InsertListCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2740
khtml::InsertListCommandImpl::insertList
static void insertList(DocumentImpl *document, Type type)
Definition: htmlediting_impl.cpp:2826
khtml::InsertListCommandImpl::Type
Type
Definition: htmlediting_impl.h:627
khtml::InsertListCommandImpl::OrderedList
@ OrderedList
Definition: htmlediting_impl.h:627
khtml::InsertListCommandImpl::UnorderedList
@ UnorderedList
Definition: htmlediting_impl.h:627
khtml::InsertNodeBeforeCommandImpl
Definition: htmlediting_impl.h:355
khtml::InsertNodeBeforeCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2015
khtml::InsertNodeBeforeCommandImpl::insertChild
DOM::NodeImpl * insertChild() const
Definition: htmlediting_impl.h:363
khtml::InsertNodeBeforeCommandImpl::~InsertNodeBeforeCommandImpl
virtual ~InsertNodeBeforeCommandImpl()
Definition: htmlediting_impl.cpp:2007
khtml::InsertNodeBeforeCommandImpl::refChild
DOM::NodeImpl * refChild() const
Definition: htmlediting_impl.h:364
khtml::InsertNodeBeforeCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2026
khtml::InsertTextCommandImpl
Definition: htmlediting_impl.h:375
khtml::InsertTextCommandImpl::text
DOM::DOMString text() const
Definition: htmlediting_impl.h:385
khtml::InsertTextCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2067
khtml::InsertTextCommandImpl::~InsertTextCommandImpl
virtual ~InsertTextCommandImpl()
Definition: htmlediting_impl.cpp:2051
khtml::InsertTextCommandImpl::node
DOM::TextImpl * node() const
Definition: htmlediting_impl.h:383
khtml::InsertTextCommandImpl::offset
long offset() const
Definition: htmlediting_impl.h:384
khtml::InsertTextCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2057
khtml::JoinTextNodesCommandImpl
Definition: htmlediting_impl.h:397
khtml::JoinTextNodesCommandImpl::firstNode
DOM::TextImpl * firstNode() const
Definition: htmlediting_impl.h:405
khtml::JoinTextNodesCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2117
khtml::JoinTextNodesCommandImpl::~JoinTextNodesCommandImpl
virtual ~JoinTextNodesCommandImpl()
Definition: htmlediting_impl.cpp:2093
khtml::JoinTextNodesCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2101
khtml::JoinTextNodesCommandImpl::secondNode
DOM::TextImpl * secondNode() const
Definition: htmlediting_impl.h:406
khtml::MoveSelectionCommandImpl
Definition: htmlediting_impl.h:434
khtml::MoveSelectionCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2228
khtml::MoveSelectionCommandImpl::~MoveSelectionCommandImpl
virtual ~MoveSelectionCommandImpl()
Definition: htmlediting_impl.cpp:2224
khtml::RemoveCSSPropertyCommandImpl
Definition: htmlediting_impl.h:450
khtml::RemoveCSSPropertyCommandImpl::~RemoveCSSPropertyCommandImpl
virtual ~RemoveCSSPropertyCommandImpl()
Definition: htmlediting_impl.cpp:2263
khtml::RemoveCSSPropertyCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2280
khtml::RemoveCSSPropertyCommandImpl::property
int property() const
Definition: htmlediting_impl.h:459
khtml::RemoveCSSPropertyCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2269
khtml::RemoveCSSPropertyCommandImpl::styleDeclaration
DOM::CSSStyleDeclarationImpl * styleDeclaration() const
Definition: htmlediting_impl.h:458
khtml::RemoveNodeAndPruneCommandImpl
Definition: htmlediting_impl.h:513
khtml::RemoveNodeAndPruneCommandImpl::stopNode
DOM::NodeImpl * stopNode() const
Definition: htmlediting_impl.h:521
khtml::RemoveNodeAndPruneCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2403
khtml::RemoveNodeAndPruneCommandImpl::pruneNode
DOM::NodeImpl * pruneNode() const
Definition: htmlediting_impl.h:520
khtml::RemoveNodeAndPruneCommandImpl::~RemoveNodeAndPruneCommandImpl
virtual ~RemoveNodeAndPruneCommandImpl()
Definition: htmlediting_impl.cpp:2396
khtml::RemoveNodeAttributeCommandImpl
Definition: htmlediting_impl.h:472
khtml::RemoveNodeAttributeCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2304
khtml::RemoveNodeAttributeCommandImpl::element
DOM::ElementImpl * element() const
Definition: htmlediting_impl.h:480
khtml::RemoveNodeAttributeCommandImpl::attribute
DOM::NodeImpl::Id attribute() const
Definition: htmlediting_impl.h:481
khtml::RemoveNodeAttributeCommandImpl::~RemoveNodeAttributeCommandImpl
virtual ~RemoveNodeAttributeCommandImpl()
Definition: htmlediting_impl.cpp:2298
khtml::RemoveNodeAttributeCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2316
khtml::RemoveNodeCommandImpl
Definition: htmlediting_impl.h:493
khtml::RemoveNodeCommandImpl::~RemoveNodeCommandImpl
virtual ~RemoveNodeCommandImpl()
Definition: htmlediting_impl.cpp:2351
khtml::RemoveNodeCommandImpl::node
DOM::NodeImpl * node() const
Definition: htmlediting_impl.h:501
khtml::RemoveNodeCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2371
khtml::RemoveNodeCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2361
khtml::RemoveNodePreservingChildrenCommandImpl
Definition: htmlediting_impl.h:532
khtml::RemoveNodePreservingChildrenCommandImpl::~RemoveNodePreservingChildrenCommandImpl
virtual ~RemoveNodePreservingChildrenCommandImpl()
Definition: htmlediting_impl.cpp:2428
khtml::RemoveNodePreservingChildrenCommandImpl::node
DOM::NodeImpl * node() const
Definition: htmlediting_impl.h:539
khtml::RemoveNodePreservingChildrenCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2434
khtml::ReplaceSelectionCommandImpl
Definition: htmlediting_impl.h:418
khtml::ReplaceSelectionCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2146
khtml::ReplaceSelectionCommandImpl::~ReplaceSelectionCommandImpl
virtual ~ReplaceSelectionCommandImpl()
Definition: htmlediting_impl.cpp:2142
khtml::SetNodeAttributeCommandImpl
Definition: htmlediting_impl.h:549
khtml::SetNodeAttributeCommandImpl::element
DOM::ElementImpl * element() const
Definition: htmlediting_impl.h:557
khtml::SetNodeAttributeCommandImpl::~SetNodeAttributeCommandImpl
virtual ~SetNodeAttributeCommandImpl()
Definition: htmlediting_impl.cpp:2457
khtml::SetNodeAttributeCommandImpl::value
DOM::DOMString value() const
Definition: htmlediting_impl.h:559
khtml::SetNodeAttributeCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2463
khtml::SetNodeAttributeCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2474
khtml::SetNodeAttributeCommandImpl::attribute
DOM::NodeImpl::Id attribute() const
Definition: htmlediting_impl.h:558
khtml::SharedCommandImpl
Definition: htmlediting_impl.h:65
khtml::SharedCommandImpl::endingSelection
virtual DOM::Selection endingSelection() const =0
khtml::SharedCommandImpl::unapply
virtual void unapply()=0
khtml::SharedCommandImpl::document
virtual DOM::DocumentImpl * document() const =0
khtml::SharedCommandImpl::SharedCommandImpl
SharedCommandImpl()
Definition: htmlediting_impl.h:67
khtml::SharedCommandImpl::setEndingSelection
virtual void setEndingSelection(const DOM::Selection &s)=0
khtml::SharedCommandImpl::isCompositeStep
virtual bool isCompositeStep() const =0
khtml::SharedCommandImpl::reapply
virtual void reapply()=0
khtml::SharedCommandImpl::setStartingSelection
virtual void setStartingSelection(const DOM::Selection &s)=0
khtml::SharedCommandImpl::startingSelection
virtual DOM::Selection startingSelection() const =0
khtml::SharedCommandImpl::parent
virtual EditCommandImpl * parent() const =0
khtml::SharedCommandImpl::setParent
virtual void setParent(EditCommandImpl *)=0
khtml::SharedCommandImpl::apply
virtual void apply()=0
khtml::SharedCommandImpl::~SharedCommandImpl
virtual ~SharedCommandImpl()
Definition: htmlediting_impl.h:68
khtml::SplitTextNodeCommandImpl
Definition: htmlediting_impl.h:572
khtml::SplitTextNodeCommandImpl::node
DOM::TextImpl * node() const
Definition: htmlediting_impl.h:580
khtml::SplitTextNodeCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2504
khtml::SplitTextNodeCommandImpl::~SplitTextNodeCommandImpl
virtual ~SplitTextNodeCommandImpl()
Definition: htmlediting_impl.cpp:2496
khtml::SplitTextNodeCommandImpl::doUnapply
virtual void doUnapply()
Definition: htmlediting_impl.cpp:2534
khtml::SplitTextNodeCommandImpl::offset
long offset() const
Definition: htmlediting_impl.h:581
khtml::TypingCommandImpl
Definition: htmlediting_impl.h:593
khtml::TypingCommandImpl::insertNewline
void insertNewline()
Definition: htmlediting_impl.cpp:2593
khtml::TypingCommandImpl::deleteKeyPressed
void deleteKeyPressed()
Definition: htmlediting_impl.cpp:2626
khtml::TypingCommandImpl::~TypingCommandImpl
virtual ~TypingCommandImpl()
Definition: htmlediting_impl.cpp:2559
khtml::TypingCommandImpl::doApply
virtual void doApply()
Definition: htmlediting_impl.cpp:2563
khtml::TypingCommandImpl::insertNewline0
static void insertNewline0(DocumentImpl *document)
Definition: htmlediting_impl.cpp:2694
khtml::TypingCommandImpl::isTypingCommand
virtual bool isTypingCommand() const
Definition: htmlediting_impl.h:607
khtml::TypingCommandImpl::openForMoreTyping
bool openForMoreTyping() const
Definition: htmlediting_impl.h:600
khtml::TypingCommandImpl::insertText0
static void insertText0(DocumentImpl *document, const DOMString &text)
Definition: htmlediting_impl.cpp:2709
khtml::TypingCommandImpl::deleteKeyPressed0
static void deleteKeyPressed0(DocumentImpl *document)
Definition: htmlediting_impl.cpp:2681
khtml::TypingCommandImpl::closeTyping
void closeTyping()
Definition: htmlediting_impl.h:601
khtml::TypingCommandImpl::insertText
void insertText(const DOM::DOMString &text)
Definition: htmlediting_impl.cpp:2574
dom_string.h
DOM
This library provides a full-featured HTML parser and widget.
Definition: design.h:55
Type
Type
khtml
khtml::ApplyStyleCommandImpl::StyleChange
Definition: htmlediting_impl.h:214
khtml::ApplyStyleCommandImpl::StyleChange::applyBold
bool applyBold
Definition: htmlediting_impl.h:217
khtml::ApplyStyleCommandImpl::StyleChange::applyItalic
bool applyItalic
Definition: htmlediting_impl.h:218
khtml::ApplyStyleCommandImpl::StyleChange::cssStyle
DOM::DOMString cssStyle
Definition: htmlediting_impl.h:216
khtml::ApplyStyleCommandImpl::StyleChange::StyleChange
StyleChange()
Definition: htmlediting_impl.h:215
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KHTML

Skip menu "KHTML"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal