KHtml

dom2_events.cpp
1 
23 #include "dom/dom2_views.h"
24 #include "dom/dom_exception.h"
25 #include "xml/dom2_eventsimpl.h"
26 #include "xml/dom_nodeimpl.h"
27 
28 using namespace DOM;
29 
30 EventListener::EventListener()
31 {
32 }
33 
34 EventListener::~EventListener()
35 {
36 }
37 
39 {
40 }
41 
43 {
44  return "";
45 }
46 
47 // -----------------------------------------------------------------------------
48 
49 Event::Event()
50 {
51  impl = nullptr;
52 }
53 
54 Event::Event(const Event &other)
55 {
56  impl = other.impl;
57  if (impl) {
58  impl->ref();
59  }
60 }
61 
62 Event::Event(EventImpl *i)
63 {
64  impl = i;
65  if (impl) {
66  impl->ref();
67  }
68 }
69 
70 Event::~Event()
71 {
72  if (impl) {
73  impl->deref();
74  }
75 }
76 
77 Event &Event::operator = (const Event &other)
78 {
79  if (impl != other.impl) {
80  if (impl) {
81  impl->deref();
82  }
83  impl = other.impl;
84  if (impl) {
85  impl->ref();
86  }
87  }
88  return *this;
89 }
90 
92 {
93  if (!impl) {
94  throw DOMException(DOMException::INVALID_STATE_ERR);
95  }
96 
97  return impl->type();
98 }
99 
101 {
102  if (!impl) {
103  throw DOMException(DOMException::INVALID_STATE_ERR);
104  }
105 
106  if (impl->target()->eventTargetType() == EventTargetImpl::DOM_NODE) {
107  return static_cast<DOM::NodeImpl *>(impl->target());
108  }
109  return nullptr;
110 }
111 
113 {
114  if (!impl) {
115  throw DOMException(DOMException::INVALID_STATE_ERR);
116  }
117 
118  if (impl->currentTarget()->eventTargetType() == EventTargetImpl::DOM_NODE) {
119  return static_cast<DOM::NodeImpl *>(impl->currentTarget());
120  }
121  return nullptr;
122 }
123 
124 unsigned short Event::eventPhase() const
125 {
126  if (!impl) {
127  throw DOMException(DOMException::INVALID_STATE_ERR);
128  }
129 
130  return impl->eventPhase();
131 }
132 
133 bool Event::bubbles() const
134 {
135  if (!impl) {
136  throw DOMException(DOMException::INVALID_STATE_ERR);
137  }
138 
139  return impl->bubbles();
140 }
141 
142 bool Event::cancelable() const
143 {
144  if (!impl) {
145  throw DOMException(DOMException::INVALID_STATE_ERR);
146  }
147 
148  return impl->cancelable();
149 }
150 
152 {
153  if (!impl) {
154  throw DOMException(DOMException::INVALID_STATE_ERR);
155  }
156 
157  return impl->timeStamp();
158 }
159 
161 {
162  if (!impl) {
163  throw DOMException(DOMException::INVALID_STATE_ERR);
164  }
165 
166  impl->stopPropagation(true);
167 }
168 
170 {
171  if (!impl) {
172  throw DOMException(DOMException::INVALID_STATE_ERR);
173  }
174 
175  impl->preventDefault(true);
176 }
177 
178 void Event::initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
179 {
180  if (!impl) {
181  throw DOMException(DOMException::INVALID_STATE_ERR);
182  }
183 
184  impl->initEvent(eventTypeArg, canBubbleArg, cancelableArg);
185 }
186 
187 EventImpl *Event::handle() const
188 {
189  return impl;
190 }
191 
192 bool Event::isNull() const
193 {
194  return (impl == nullptr);
195 }
196 
197 // -----------------------------------------------------------------------------
198 
199 #ifndef SAVE_SPACE
200 
201 EventException::EventException(unsigned short _code)
202 {
203  code = _code;
204 }
205 
206 EventException::EventException(const EventException &other)
207 {
208  code = other.code;
209 }
210 
211 EventException &EventException::operator = (const EventException &other)
212 {
213  code = other.code;
214  return *this;
215 }
216 
217 #endif
218 
220 {
221  return codeAsString(code);
222 }
223 
225 {
226  return exceptioncode >= _EXCEPTION_OFFSET && exceptioncode < _EXCEPTION_MAX;
227 }
228 
230 {
231  switch (code) {
232  case UNSPECIFIED_EVENT_TYPE_ERR:
233  return DOMString("UNSPECIFIED_EVENT_TYPE_ERR");
234  default:
235  return DOMString("(unknown exception code)");
236  }
237 }
238 
239 // -----------------------------------------------------------------------------
240 
241 UIEvent::UIEvent() : Event()
242 {
243 }
244 
245 UIEvent::UIEvent(const UIEvent &other) : Event(other)
246 {
247 }
248 
249 UIEvent::UIEvent(const Event &other) : Event()
250 {
251  (*this) = other;
252 }
253 
254 UIEvent::UIEvent(UIEventImpl *impl) : Event(impl)
255 {
256 }
257 
258 UIEvent &UIEvent::operator = (const UIEvent &other)
259 {
260  Event::operator = (other);
261  return *this;
262 }
263 
264 UIEvent &UIEvent::operator = (const Event &other)
265 {
266  Event e;
267  e = other;
268  if (!e.isNull() && !e.handle()->isUIEvent()) {
269  if (impl) {
270  impl->deref();
271  }
272  impl = nullptr;
273  } else {
274  Event::operator = (other);
275  }
276  return *this;
277 }
278 
279 UIEvent::~UIEvent()
280 {
281 }
282 
284 {
285  if (!impl) {
286  throw DOMException(DOMException::INVALID_STATE_ERR);
287  }
288 
289  return static_cast<UIEventImpl *>(impl)->view();
290 }
291 
292 long UIEvent::detail() const
293 {
294  if (!impl) {
295  throw DOMException(DOMException::INVALID_STATE_ERR);
296  }
297 
298  return static_cast<UIEventImpl *>(impl)->detail();
299 }
300 
301 int UIEvent::keyCode() const
302 {
303  if (!impl) {
304  throw DOMException(DOMException::INVALID_STATE_ERR);
305  }
306 
307  return static_cast<UIEventImpl *>(impl)->keyCode();
308 }
309 
310 int UIEvent::charCode() const
311 {
312  if (!impl) {
313  throw DOMException(DOMException::INVALID_STATE_ERR);
314  }
315 
316  return static_cast<UIEventImpl *>(impl)->charCode();
317 }
318 
319 int UIEvent::pageX() const
320 {
321  if (!impl) {
322  throw DOMException(DOMException::INVALID_STATE_ERR);
323  }
324 
325  return static_cast<UIEventImpl *>(impl)->pageX();
326 }
327 
328 int UIEvent::pageY() const
329 {
330  if (!impl) {
331  throw DOMException(DOMException::INVALID_STATE_ERR);
332  }
333 
334  return static_cast<UIEventImpl *>(impl)->pageY();
335 }
336 
337 int UIEvent::layerX() const
338 {
339  if (!impl) {
340  throw DOMException(DOMException::INVALID_STATE_ERR);
341  }
342 
343  return static_cast<UIEventImpl *>(impl)->layerX();
344 }
345 
346 int UIEvent::layerY() const
347 {
348  if (!impl) {
349  throw DOMException(DOMException::INVALID_STATE_ERR);
350  }
351 
352  return static_cast<UIEventImpl *>(impl)->layerY();
353 }
354 
355 int UIEvent::which() const
356 {
357  if (!impl) {
358  throw DOMException(DOMException::INVALID_STATE_ERR);
359  }
360  return static_cast<UIEventImpl *>(impl)->which();
361 }
362 
363 void UIEvent::initUIEvent(const DOMString &typeArg,
364  bool canBubbleArg,
365  bool cancelableArg,
366  const AbstractView &viewArg,
367  long detailArg)
368 {
369  if (!impl) {
370  throw DOMException(DOMException::INVALID_STATE_ERR);
371  }
372 
373  static_cast<UIEventImpl *>(impl)->initUIEvent(typeArg, canBubbleArg, cancelableArg,
374  viewArg.handle(), detailArg);
375 }
376 
377 // -----------------------------------------------------------------------------
378 
379 MouseEvent::MouseEvent() : UIEvent()
380 {
381 }
382 
383 MouseEvent::MouseEvent(const MouseEvent &other) : UIEvent(other)
384 {
385 }
386 
387 MouseEvent::MouseEvent(const Event &other) : UIEvent()
388 {
389  (*this) = other;
390 }
391 
392 MouseEvent::MouseEvent(MouseEventImpl *impl) : UIEvent(impl)
393 {
394 }
395 
396 MouseEvent &MouseEvent::operator = (const MouseEvent &other)
397 {
398  UIEvent::operator = (other);
399  return *this;
400 }
401 
402 MouseEvent &MouseEvent::operator = (const Event &other)
403 {
404  Event e;
405  e = other;
406  if (!e.isNull() && !e.handle()->isMouseEvent()) {
407  if (impl) {
408  impl->deref();
409  }
410  impl = nullptr;
411  } else {
412  UIEvent::operator = (other);
413  }
414  return *this;
415 }
416 
417 MouseEvent::~MouseEvent()
418 {
419 }
420 
422 {
423  if (!impl) {
424  throw DOMException(DOMException::INVALID_STATE_ERR);
425  }
426 
427  return static_cast<MouseEventImpl *>(impl)->screenX();
428 }
429 
431 {
432  if (!impl) {
433  throw DOMException(DOMException::INVALID_STATE_ERR);
434  }
435 
436  return static_cast<MouseEventImpl *>(impl)->screenY();
437 }
438 
440 {
441  if (!impl) {
442  throw DOMException(DOMException::INVALID_STATE_ERR);
443  }
444 
445  return static_cast<MouseEventImpl *>(impl)->clientX();
446 }
447 
449 {
450  if (!impl) {
451  throw DOMException(DOMException::INVALID_STATE_ERR);
452  }
453 
454  return static_cast<MouseEventImpl *>(impl)->clientY();
455 }
456 
458 {
459  if (!impl) {
460  throw DOMException(DOMException::INVALID_STATE_ERR);
461  }
462 
463  return static_cast<MouseEventImpl *>(impl)->ctrlKey();
464 }
465 
467 {
468  if (!impl) {
469  throw DOMException(DOMException::INVALID_STATE_ERR);
470  }
471 
472  return static_cast<MouseEventImpl *>(impl)->shiftKey();
473 }
474 
475 bool MouseEvent::altKey() const
476 {
477  if (!impl) {
478  throw DOMException(DOMException::INVALID_STATE_ERR);
479  }
480 
481  return static_cast<MouseEventImpl *>(impl)->altKey();
482 }
483 
485 {
486  if (!impl) {
487  throw DOMException(DOMException::INVALID_STATE_ERR);
488  }
489 
490  return static_cast<MouseEventImpl *>(impl)->metaKey();
491 }
492 
493 unsigned short MouseEvent::button() const
494 {
495  if (!impl) {
496  throw DOMException(DOMException::INVALID_STATE_ERR);
497  }
498 
499  return static_cast<MouseEventImpl *>(impl)->button();
500 }
501 
503 {
504  if (!impl) {
505  throw DOMException(DOMException::INVALID_STATE_ERR);
506  }
507 
508  return static_cast<MouseEventImpl *>(impl)->relatedTarget();
509 }
510 
512  bool canBubbleArg,
513  bool cancelableArg,
514  const AbstractView &viewArg,
515  long detailArg,
516  long screenXArg,
517  long screenYArg,
518  long clientXArg,
519  long clientYArg,
520  bool ctrlKeyArg,
521  bool altKeyArg,
522  bool shiftKeyArg,
523  bool metaKeyArg,
524  unsigned short buttonArg,
525  const Node &relatedTargetArg)
526 {
527  if (!impl) {
528  throw DOMException(DOMException::INVALID_STATE_ERR);
529  }
530 
531  static_cast<MouseEventImpl *>(impl)->initMouseEvent(typeArg, canBubbleArg,
532  cancelableArg, viewArg.handle(), detailArg, screenXArg, screenYArg, clientXArg,
533  clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg,
534  relatedTargetArg);
535 }
536 
537 // -----------------------------------------------------------------------------
538 
539 TextEvent::TextEvent() : UIEvent()
540 {
541 }
542 
543 TextEvent::TextEvent(const TextEvent &other) : UIEvent(other)
544 {
545 }
546 
547 TextEvent::TextEvent(const Event &other) : UIEvent()
548 {
549  (*this) = other;
550 }
551 
552 TextEvent &TextEvent::operator = (const TextEvent &other)
553 {
554  UIEvent::operator = (other);
555  return *this;
556 }
557 
558 TextEvent &TextEvent::operator = (const Event &other)
559 {
560  Event e;
561  e = other;
562  if (!e.isNull() && !e.handle()->isTextInputEvent()) {
563  if (impl) {
564  impl->deref();
565  }
566  impl = nullptr;
567  } else {
568  UIEvent::operator = (other);
569  }
570  return *this;
571 }
572 
573 TextEvent::~TextEvent()
574 {
575 }
576 
578  bool canBubbleArg,
579  bool cancelableArg,
580  const AbstractView &viewArg,
581  const DOMString &dataArg)
582 {
583  static_cast<TextEventImpl *>(impl)->initTextEvent(
584  typeArg, canBubbleArg, cancelableArg, viewArg.handle(), dataArg);
585 }
586 // -----------------------------------------------------------------------------
587 
588 KeyboardEvent::KeyboardEvent() : UIEvent()
589 {
590 }
591 
592 KeyboardEvent::KeyboardEvent(const KeyboardEvent &other) : UIEvent(other)
593 {
594 }
595 
596 KeyboardEvent::KeyboardEvent(const Event &other) : UIEvent()
597 {
598  (*this) = other;
599 }
600 
601 KeyboardEvent &KeyboardEvent::operator = (const KeyboardEvent &other)
602 {
603  UIEvent::operator = (other);
604  return *this;
605 }
606 
607 KeyboardEvent &KeyboardEvent::operator = (const Event &other)
608 {
609  Event e;
610  e = other;
611  if (!e.isNull() && !e.handle()->isKeyboardEvent()) {
612  if (impl) {
613  impl->deref();
614  }
615  impl = nullptr;
616  } else {
617  UIEvent::operator = (other);
618  }
619  return *this;
620 }
621 
622 KeyboardEvent::~KeyboardEvent()
623 {
624 }
625 
627 {
628  return static_cast<const KeyboardEventImpl *>(impl)->keyIdentifier();
629 }
630 
631 unsigned long KeyboardEvent::keyLocation() const
632 {
633  return static_cast<const KeyboardEventImpl *>(impl)->keyLocation();
634 }
635 
637 {
638  return static_cast<const KeyboardEventImpl *>(impl)->ctrlKey();
639 }
640 
642 {
643  return static_cast<const KeyboardEventImpl *>(impl)->shiftKey();
644 }
645 
647 {
648  return static_cast<const KeyboardEventImpl *>(impl)->altKey();
649 }
650 
652 {
653  return static_cast<const KeyboardEventImpl *>(impl)->metaKey();
654 }
655 
656 bool KeyboardEvent::getModifierState(DOMString keyIdentifierArg) const
657 {
658  return static_cast<const KeyboardEventImpl *>(impl)->getModifierState(keyIdentifierArg);
659 }
660 
662  bool canBubbleArg,
663  bool cancelableArg,
664  AbstractView viewArg,
665  DOMString keyIdentifierArg,
666  unsigned long keyLocationArg,
667  DOMString modifiersList)
668 {
669  static_cast<KeyboardEventImpl *>(impl)->initKeyboardEvent(typeArg,
670  canBubbleArg, cancelableArg, viewArg.handle(), keyIdentifierArg, keyLocationArg, modifiersList);
671 }
672 
673 // -----------------------------------------------------------------------------
674 
675 MutationEvent::MutationEvent() : Event()
676 {
677 }
678 
679 MutationEvent::MutationEvent(const MutationEvent &other) : Event(other)
680 {
681 }
682 
683 MutationEvent::MutationEvent(const Event &other) : Event()
684 {
685  (*this) = other;
686 }
687 
688 MutationEvent::MutationEvent(MutationEventImpl *impl) : Event(impl)
689 {
690 }
691 
692 MutationEvent &MutationEvent::operator = (const MutationEvent &other)
693 {
694  Event::operator = (other);
695  return *this;
696 }
697 
698 MutationEvent &MutationEvent::operator = (const Event &other)
699 {
700  Event e;
701  e = other;
702  if (!e.isNull() && !e.handle()->isMutationEvent()) {
703  if (impl) {
704  impl->deref();
705  }
706  impl = nullptr;
707  } else {
708  Event::operator = (other);
709  }
710  return *this;
711 }
712 
713 MutationEvent::~MutationEvent()
714 {
715 }
716 
718 {
719  if (!impl) {
720  throw DOMException(DOMException::INVALID_STATE_ERR);
721  }
722 
723  return static_cast<MutationEventImpl *>(impl)->relatedNode();
724 }
725 
727 {
728  if (!impl) {
729  throw DOMException(DOMException::INVALID_STATE_ERR);
730  }
731 
732  return static_cast<MutationEventImpl *>(impl)->prevValue();
733 }
734 
736 {
737  if (!impl) {
738  throw DOMException(DOMException::INVALID_STATE_ERR);
739  }
740 
741  return static_cast<MutationEventImpl *>(impl)->newValue();
742 }
743 
745 {
746  if (!impl) {
747  throw DOMException(DOMException::INVALID_STATE_ERR);
748  }
749 
750  return static_cast<MutationEventImpl *>(impl)->attrName();
751 }
752 
753 unsigned short MutationEvent::attrChange() const
754 {
755  if (!impl) {
756  throw DOMException(DOMException::INVALID_STATE_ERR);
757  }
758 
759  return static_cast<MutationEventImpl *>(impl)->attrChange();
760 }
761 
763  bool canBubbleArg,
764  bool cancelableArg,
765  const Node &relatedNodeArg,
766  const DOMString &prevValueArg,
767  const DOMString &newValueArg,
768  const DOMString &attrNameArg,
769  unsigned short attrChangeArg)
770 {
771  if (!impl) {
772  throw DOMException(DOMException::INVALID_STATE_ERR);
773  }
774 
775  static_cast<MutationEventImpl *>(impl)->initMutationEvent(typeArg,
776  canBubbleArg, cancelableArg, relatedNodeArg, prevValueArg,
777  newValueArg, attrNameArg, attrChangeArg);
778 }
779 
virtual void handleEvent(Event &evt)
This method is called whenever an event occurs of the type for which the EventListener interface was ...
Definition: dom2_events.cpp:38
int layerX() const
Non-standard extensions to support Netscape-style layerX and layerY event properties.
DOMString type() const
The name of the event (case-insensitive).
Definition: dom2_events.cpp:91
The Node interface is the primary datatype for the entire Document Object Model.
Definition: dom_node.h:278
long detail() const
Specifies some detail information about the Event, depending on the type of event.
Node target() const
Used to indicate the EventTarget to which the event was originally dispatched.
void initKeyboardEvent(DOMString typeArg, bool canBubbleArg, bool cancelableArg, AbstractView viewArg, DOMString keyIdentifierArg, unsigned long keyLocationArg, DOMString modifiersList)
initKeyboardEvent
long clientY() const
The vertical coordinate at which the event occurred relative to the DOM implementation&#39;s client area...
bool bubbles() const
Used to indicate whether or not an event is a bubbling event.
Introduced in DOM Level 2.
Definition: dom2_views.h:42
Introduced in DOM Level 2.
Definition: dom2_events.h:310
DOMString keyIdentifier() const
keyIdentifier of type DOMString, readonly
Node relatedNode() const
relatedNode is used to identify a secondary node related to a mutation event.
Introduced in DOM Level 2.
Definition: dom2_events.h:413
AbstractView view() const
The view attribute identifies the AbstractView from which the event was generated.
bool shiftKey() const
shiftKey of type boolean, readonly
int charCode() const
Non-standard extension to support IE-style charCode event property.
bool metaKey() const
metaKey of type boolean, readonly
DOMTimeStamp timeStamp() const
Used to specify the time (in milliseconds relative to the epoch) at which the event was created...
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:58
bool ctrlKey() const
Used to indicate whether the &#39;ctrl&#39; key was depressed during the firing of the event.
bool cancelable() const
Used to indicate whether or not an event can have its default action prevented.
Introduced in DOM Level 2:
Definition: dom2_events.h:267
Node relatedTarget() const
Used to identify a secondary EventTarget related to a UI event.
bool shiftKey() const
Used to indicate whether the &#39;shift&#39; key was depressed during the firing of the event.
EventImpl * handle() const
Introduced in DOM Level 3.
Definition: dom2_events.h:627
void preventDefault()
If an event is cancelable, the preventDefault method is used to signify that the event is to be cance...
void initUIEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const AbstractView &viewArg, long detailArg)
The initUIEvent method is used to initialize the value of a UIEvent created through the DocumentEvent...
int keyCode() const
Non-standard extension to support IE-style keyCode event property.
Introduced in DOM Level 3.
Definition: dom2_events.h:565
unsigned short eventPhase() const
Used to indicate which phase of event flow is currently being evaluated.
bool getModifierState(DOMString keyIdentifierArg) const
getModifierState
bool altKey() const
Used to indicate whether the &#39;alt&#39; key was depressed during the firing of the event.
This class implements the basic string we use in the DOM.
Definition: dom_string.h:44
void initMutationEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const Node &relatedNodeArg, const DOMString &prevValueArg, const DOMString &newValueArg, const DOMString &attrNameArg, unsigned short attrChangeArg)
The initMutationEvent method is used to initialize the value of a MutationEvent created through the D...
Introduced in DOM Level 2.
Definition: dom2_events.h:774
bool ctrlKey() const
ctrlKey of type boolean, readonly
virtual DOMString eventListenerType()
Definition: dom2_events.cpp:42
unsigned short button() const
During mouse events caused by the depression or release of a mouse button, button is used to indicate...
unsigned short attrChange() const
attrChange indicates the type of change which triggered the DOMAttrModified event.
void initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
The initEvent method is used to initialize the value of an Event created through the DocumentEvent in...
DOMString codeAsString() const
Returns the name of this error.
DOMString prevValue() const
prevValue indicates the previous value of the Attr node in DOMAttrModified events, and of the CharacterData node in DOMCharDataModified events.
static bool isEventExceptionCode(int exceptioncode)
This library provides a full-featured HTML parser and widget.
bool metaKey() const
Used to indicate whether the &#39;meta&#39; key was depressed during the firing of the event.
DOMString newValue() const
newValue indicates the new value of the Attr node in DOMAttrModified events, and of the CharacterData...
Introduced in DOM Level 2.
Definition: dom2_events.h:116
long screenX() const
The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate...
int which() const
Non-standard extension to support Netscape-style "which" event property.
unsigned long keyLocation() const
keyLocation of type unsigned long, readonly
void initTextEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const AbstractView &viewArg, const DOMString &dataArg)
initTextEvent The initTextEvent method is used to initialize the value of a TextEvent object and has ...
DOMString attrName() const
attrName indicates the name of the changed Attr node in a DOMAttrModified event.
void initMouseEvent(const DOMString &typeArg, bool canBubbleArg, bool cancelableArg, const AbstractView &viewArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, unsigned short buttonArg, const Node &relatedTargetArg)
The initMouseEvent method is used to initialize the value of a MouseEvent created through the Documen...
AbstractViewImpl * handle() const
Definition: dom2_views.cpp:91
unsigned long long DOMTimeStamp
Node currentTarget() const
Used to indicate the EventTarget whose EventListeners are currently being processed.
long clientX() const
The horizontal coordinate at which the event occurred relative to the DOM implementation&#39;s client are...
long screenY() const
The vertical coordinate at which the event occurred relative to the origin of the screen coordinate s...
int pageX() const
Non-standard extensions to support Netscape-style pageX and pageY event properties.
EventListenerImpl * impl
Definition: dom2_events.h:101
bool altKey() const
altKey of type boolean, readonly
void stopPropagation()
The stopPropagation method is used prevent further propagation of an event during event flow...
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Fri Aug 14 2020 22:45:45 by doxygen 1.8.11 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.