Reviewed by Darin.
[WebKit-https.git] / WebCore / khtml / xml / dom2_eventsimpl.cpp
1 /**
2  * This file is part of the DOM implementation for KDE.
3  *
4  * (C) 2001 Peter Kelly (pmk@post.com)
5  * (C) 2001 Tobias Anton (anton@stud.fbi.fh-darmstadt.de)
6  * Copyright (C) 2003 Apple Computer, Inc.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 #include "dom/dom2_views.h"
25
26 #include "xml/dom2_eventsimpl.h"
27 #include "xml/dom_stringimpl.h"
28 #include "xml/dom_nodeimpl.h"
29 #include "xml/dom_docimpl.h"
30 #include "rendering/render_object.h"
31 #include "rendering/render_layer.h"
32
33 #include <kdebug.h>
34
35 using namespace DOM;
36
37 EventImpl::EventImpl()
38 {
39     m_type = 0;
40     m_canBubble = false;
41     m_cancelable = false;
42
43     m_propagationStopped = false;
44     m_defaultPrevented = false;
45     m_cancelBubble = false;
46     m_id = UNKNOWN_EVENT;
47     m_currentTarget = 0;
48     m_eventPhase = 0;
49     m_target = 0;
50     m_createTime = QDateTime::currentDateTime();
51     m_defaultHandled = false;
52 }
53
54 EventImpl::EventImpl(EventId _id, bool canBubbleArg, bool cancelableArg)
55 {
56     DOMString t = EventImpl::idToType(_id);
57     m_type = t.implementation();
58     if (m_type)
59         m_type->ref();
60     m_canBubble = canBubbleArg;
61     m_cancelable = cancelableArg;
62
63     m_propagationStopped = false;
64     m_defaultPrevented = false;
65     m_cancelBubble = false;
66     m_id = _id;
67     m_currentTarget = 0;
68     m_eventPhase = 0;
69     m_target = 0;
70     m_createTime = QDateTime::currentDateTime();
71     m_defaultHandled = false;
72 }
73
74 EventImpl::~EventImpl()
75 {
76     if (m_type)
77         m_type->deref();
78     if (m_target)
79         m_target->deref();
80 }
81
82 DOMString EventImpl::type() const
83 {
84     return m_type;
85 }
86
87 NodeImpl *EventImpl::target() const
88 {
89     return m_target;
90 }
91
92 void EventImpl::setTarget(NodeImpl *_target)
93 {
94     if (m_target)
95         m_target->deref();
96     m_target = _target;
97     if (m_target)
98         m_target->ref();
99 }
100
101 NodeImpl *EventImpl::currentTarget() const
102 {
103     return m_currentTarget;
104 }
105
106 void EventImpl::setCurrentTarget(NodeImpl *_currentTarget)
107 {
108     m_currentTarget = _currentTarget;
109 }
110
111 unsigned short EventImpl::eventPhase() const
112 {
113     return m_eventPhase;
114 }
115
116 void EventImpl::setEventPhase(unsigned short _eventPhase)
117 {
118     m_eventPhase = _eventPhase;
119 }
120
121 bool EventImpl::bubbles() const
122 {
123     return m_canBubble;
124 }
125
126 bool EventImpl::cancelable() const
127 {
128     return m_cancelable;
129 }
130
131 DOMTimeStamp EventImpl::timeStamp()
132 {
133     QDateTime epoch(QDate(1970,1,1),QTime(0,0));
134     // ### kjs does not yet support long long (?) so the value wraps around
135     return epoch.secsTo(m_createTime)*1000+m_createTime.time().msec();
136 }
137
138 void EventImpl::stopPropagation()
139 {
140     m_propagationStopped = true;
141 }
142
143 void EventImpl::preventDefault()
144 {
145     if (m_cancelable)
146         m_defaultPrevented = true;
147 }
148
149 void EventImpl::initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
150 {
151     // ### ensure this is not called after we have been dispatched (also for subclasses)
152
153     if (m_type)
154         m_type->deref();
155
156     m_type = eventTypeArg.implementation();
157     if (m_type)
158         m_type->ref();
159
160     m_id = typeToId(eventTypeArg);
161
162     m_canBubble = canBubbleArg;
163     m_cancelable = cancelableArg;
164 }
165
166 EventImpl::EventId EventImpl::typeToId(DOMString type)
167 {
168     if (type == "DOMFocusIn")
169         return DOMFOCUSIN_EVENT;
170     else if (type == "DOMFocusOut")
171         return DOMFOCUSOUT_EVENT;
172     else if (type == "DOMActivate")
173         return DOMACTIVATE_EVENT;
174     else if (type == "click")
175         return CLICK_EVENT;
176     else if (type == "mousedown")
177         return MOUSEDOWN_EVENT;
178     else if (type == "mouseup")
179         return MOUSEUP_EVENT;
180     else if (type == "mouseover")
181         return MOUSEOVER_EVENT;
182     else if (type == "mousemove")
183         return MOUSEMOVE_EVENT;
184     else if (type == "mouseout")
185         return MOUSEOUT_EVENT;
186     else if (type == "onbeforecut")
187         return BEFORECUT_EVENT;
188     else if (type == "oncut")
189         return CUT_EVENT;
190     else if (type == "onbeforecopy")
191         return BEFORECOPY_EVENT;
192     else if (type == "oncopy")
193         return COPY_EVENT;
194     else if (type == "onbeforepaste")
195         return BEFOREPASTE_EVENT;
196     else if (type == "onpaste")
197         return PASTE_EVENT;
198     else if (type == "dragenter")
199         return DRAGENTER_EVENT;
200     else if (type == "dragover")
201         return DRAGOVER_EVENT;
202     else if (type == "dragleave")
203         return DRAGLEAVE_EVENT;
204     else if (type == "drop")
205         return DROP_EVENT;
206     else if (type == "dragstart")
207         return DRAGSTART_EVENT;
208     else if (type == "drag")
209         return DRAG_EVENT;
210     else if (type == "dragend")
211         return DRAGEND_EVENT;
212     else if (type == "selectstart")
213         return SELECTSTART_EVENT;
214     else if (type == "DOMSubtreeModified")
215         return DOMSUBTREEMODIFIED_EVENT;
216     else if (type == "DOMNodeInserted")
217         return DOMNODEINSERTED_EVENT;
218     else if (type == "DOMNodeRemoved")
219         return DOMNODEREMOVED_EVENT;
220     else if (type == "DOMNodeRemovedFromDocument")
221         return DOMNODEREMOVEDFROMDOCUMENT_EVENT;
222     else if (type == "DOMNodeInsertedIntoDocument")
223         return DOMNODEINSERTEDINTODOCUMENT_EVENT;
224     else if (type == "DOMAttrModified")
225         return DOMATTRMODIFIED_EVENT;
226     else if (type == "DOMCharacterDataModified")
227         return DOMCHARACTERDATAMODIFIED_EVENT;
228     else if (type == "load")
229         return LOAD_EVENT;
230     else if (type == "unload")
231         return UNLOAD_EVENT;
232     else if (type == "abort")
233         return ABORT_EVENT;
234     else if (type == "error")
235         return ERROR_EVENT;
236     else if (type == "select")
237         return SELECT_EVENT;
238     else if (type == "change")
239         return CHANGE_EVENT;
240     else if (type == "submit")
241         return SUBMIT_EVENT;
242     else if (type == "reset")
243         return RESET_EVENT;
244     else if (type == "focus")
245         return FOCUS_EVENT;
246     else if (type == "blur")
247         return BLUR_EVENT;
248     else if (type == "resize")
249         return RESIZE_EVENT;
250     else if (type == "scroll")
251         return SCROLL_EVENT;
252     else if (type == "contextmenu")
253         return CONTEXTMENU_EVENT;
254     else if (type == "keydown")
255         return KEYDOWN_EVENT;
256     else if (type == "keyup")
257         return KEYUP_EVENT;
258 #if APPLE_CHANGES
259     else if (type == "search")
260         return SEARCH_EVENT;
261 #endif
262     else if (type == "input")
263         return INPUT_EVENT;
264     else if (type == "textInput")
265         return TEXTINPUT_EVENT;
266     else if (type == "readystatechange")
267         return KHTML_READYSTATECHANGE_EVENT;
268     // ignore: KHTML_DBLCLICK_EVENT
269     // ignore: KHTML_CLICK_EVENT
270     return UNKNOWN_EVENT;
271 }
272
273 DOMString EventImpl::idToType(EventImpl::EventId id)
274 {
275     switch (id) {
276         case DOMFOCUSIN_EVENT:
277             return "DOMFocusIn";
278         case DOMFOCUSOUT_EVENT:
279             return "DOMFocusOut";
280         case DOMACTIVATE_EVENT:
281             return "DOMActivate";
282         case CLICK_EVENT:
283             return "click";
284         case MOUSEDOWN_EVENT:
285             return "mousedown";
286         case MOUSEUP_EVENT:
287             return "mouseup";
288         case MOUSEOVER_EVENT:
289             return "mouseover";
290         case MOUSEMOVE_EVENT:
291             return "mousemove";
292         case MOUSEOUT_EVENT:
293             return "mouseout";
294         case BEFORECUT_EVENT:
295             return "onbeforecut";
296         case CUT_EVENT:
297             return "oncut";
298         case BEFORECOPY_EVENT:
299             return "onbeforecopy";
300         case COPY_EVENT:
301             return "oncopy";
302         case BEFOREPASTE_EVENT:
303             return "onbeforepaste";
304         case PASTE_EVENT:
305             return "onpaste";
306         case DRAGENTER_EVENT:
307             return "dragenter";
308         case DRAGOVER_EVENT:
309             return "dragover";
310         case DRAGLEAVE_EVENT:
311             return "dragleave";
312         case DROP_EVENT:
313             return "drop";
314         case DRAGSTART_EVENT:
315             return "dragstart";
316         case DRAG_EVENT:
317             return "drag";
318         case DRAGEND_EVENT:
319             return "dragend";
320         case SELECTSTART_EVENT:
321             return "selectstart";
322         case DOMSUBTREEMODIFIED_EVENT:
323             return "DOMSubtreeModified";
324         case DOMNODEINSERTED_EVENT:
325             return "DOMNodeInserted";
326         case DOMNODEREMOVED_EVENT:
327             return "DOMNodeRemoved";
328         case DOMNODEREMOVEDFROMDOCUMENT_EVENT:
329             return "DOMNodeRemovedFromDocument";
330         case DOMNODEINSERTEDINTODOCUMENT_EVENT:
331             return "DOMNodeInsertedIntoDocument";
332         case DOMATTRMODIFIED_EVENT:
333             return "DOMAttrModified";
334         case DOMCHARACTERDATAMODIFIED_EVENT:
335             return "DOMCharacterDataModified";
336         case LOAD_EVENT:
337             return "load";
338         case UNLOAD_EVENT:
339             return "unload";
340         case ABORT_EVENT:
341             return "abort";
342         case ERROR_EVENT:
343             return "error";
344         case SELECT_EVENT:
345             return "select";
346         case CHANGE_EVENT:
347             return "change";
348         case SUBMIT_EVENT:
349             return "submit";
350         case RESET_EVENT:
351             return "reset";
352         case FOCUS_EVENT:
353             return "focus";
354         case BLUR_EVENT:
355             return "blur";
356         case RESIZE_EVENT:
357             return "resize";
358         case SCROLL_EVENT:
359             return "scroll";
360         case CONTEXTMENU_EVENT:
361             return "contextmenu";
362         case KEYDOWN_EVENT:
363             return "keydown";
364         case KEYUP_EVENT:
365             return "keyup";
366         case KEYPRESS_EVENT:
367             return "keypress";
368         case TEXTINPUT_EVENT:
369             return "textInput";
370 #if APPLE_CHANGES
371         case SEARCH_EVENT:
372             return "search";
373 #endif
374         case INPUT_EVENT:
375             return "input";
376         // khtml extensions
377         case KHTML_DBLCLICK_EVENT:
378             return "dblclick";
379         case KHTML_CLICK_EVENT:
380             return "click";
381         case KHTML_DRAGDROP_EVENT:
382             return "khtml_dragdrop";
383         case KHTML_ERROR_EVENT:
384             return "khtml_error";
385         case KHTML_MOVE_EVENT:
386             return "khtml_move";
387         case KHTML_ORIGCLICK_MOUSEUP_EVENT:
388             return "khtml_origclick_mouseup_event";
389         case KHTML_READYSTATECHANGE_EVENT:
390             return "readystatechange";
391         default:
392             return DOMString();
393             break;
394     }
395 }
396
397 bool EventImpl::isUIEvent() const
398 {
399     return false;
400 }
401
402 bool EventImpl::isMouseEvent() const
403 {
404     return false;
405 }
406
407 bool EventImpl::isMutationEvent() const
408 {
409     return false;
410 }
411
412 bool EventImpl::isKeyboardEvent() const
413 {
414     return false;
415 }
416
417 bool EventImpl::isDragEvent() const
418 {
419     return false;
420 }
421
422 bool EventImpl::isClipboardEvent() const
423 {
424     return false;
425 }
426
427 // -----------------------------------------------------------------------------
428
429 UIEventImpl::UIEventImpl()
430 {
431     m_view = 0;
432     m_detail = 0;
433 }
434
435 UIEventImpl::UIEventImpl(EventId _id, bool canBubbleArg, bool cancelableArg,
436                 AbstractViewImpl *viewArg, long detailArg)
437                 : EventImpl(_id,canBubbleArg,cancelableArg)
438 {
439     m_view = viewArg;
440     if (m_view)
441         m_view->ref();
442     m_detail = detailArg;
443 }
444
445 UIEventImpl::~UIEventImpl()
446 {
447     if (m_view)
448         m_view->deref();
449 }
450
451 void UIEventImpl::initUIEvent(const DOMString &typeArg,
452                               bool canBubbleArg,
453                               bool cancelableArg,
454                               const AbstractView &viewArg,
455                               long detailArg)
456 {
457     EventImpl::initEvent(typeArg,canBubbleArg,cancelableArg);
458
459     if (m_view)
460         m_view->deref();
461
462     m_view = viewArg.handle();
463     if (m_view)
464         m_view->ref();
465     m_detail = detailArg;
466 }
467
468 bool UIEventImpl::isUIEvent() const
469 {
470     return true;
471 }
472
473 // -----------------------------------------------------------------------------
474
475 MouseEventImpl::MouseEventImpl()
476 {
477     m_screenX = 0;
478     m_screenY = 0;
479     m_clientX = 0;
480     m_clientY = 0;
481     m_ctrlKey = false;
482     m_altKey = false;
483     m_shiftKey = false;
484     m_metaKey = false;
485     m_button = 0;
486     m_relatedTarget = 0;
487     m_clipboard = 0;
488 }
489
490 MouseEventImpl::MouseEventImpl(EventId _id,
491                                bool canBubbleArg,
492                                bool cancelableArg,
493                                AbstractViewImpl *viewArg,
494                                long detailArg,
495                                long screenXArg,
496                                long screenYArg,
497                                long clientXArg,
498                                long clientYArg,
499                                bool ctrlKeyArg,
500                                bool altKeyArg,
501                                bool shiftKeyArg,
502                                bool metaKeyArg,
503                                unsigned short buttonArg,
504                                NodeImpl *relatedTargetArg,
505                                ClipboardImpl *clipboardArg)
506                    : UIEventImpl(_id,canBubbleArg,cancelableArg,viewArg,detailArg)
507 {
508     m_screenX = screenXArg;
509     m_screenY = screenYArg;
510     m_clientX = clientXArg;
511     m_clientY = clientYArg;
512     m_ctrlKey = ctrlKeyArg;
513     m_altKey = altKeyArg;
514     m_shiftKey = shiftKeyArg;
515     m_metaKey = metaKeyArg;
516     m_button = buttonArg;
517     m_relatedTarget = relatedTargetArg;
518     if (m_relatedTarget)
519         m_relatedTarget->ref();
520     m_clipboard = clipboardArg;
521     if (m_clipboard)
522         m_clipboard->ref();
523     computeLayerPos();
524 }
525
526 void MouseEventImpl::computeLayerPos()
527 {
528     m_layerX = m_clientX;
529     m_layerY = m_clientY;
530
531     DocumentImpl *doc = view()->document();
532
533     if (!doc) {
534         return;
535     }
536
537     khtml::RenderObject::NodeInfo renderInfo(true, false);
538     doc->renderer()->layer()->nodeAtPoint(renderInfo, m_clientX, m_clientY);
539
540     NodeImpl *node = renderInfo.innerNonSharedNode();
541     while (node && !node->renderer()) {
542         node = node->parent();
543     }
544
545     if (!node) {
546         return;
547     }
548
549     node->renderer()->enclosingLayer()->updateLayerPosition();
550     
551     for (khtml::RenderLayer *layer = node->renderer()->enclosingLayer(); layer != NULL; layer = layer->parent()) {
552         m_layerX -= layer->xPos();
553         m_layerY -= layer->yPos();
554     }
555 }
556
557 MouseEventImpl::~MouseEventImpl()
558 {
559     if (m_relatedTarget)
560         m_relatedTarget->deref();
561     if (m_clipboard)
562         m_clipboard->deref();
563 }
564
565 void MouseEventImpl::initMouseEvent(const DOMString &typeArg,
566                                     bool canBubbleArg,
567                                     bool cancelableArg,
568                                     const AbstractView &viewArg,
569                                     long detailArg,
570                                     long screenXArg,
571                                     long screenYArg,
572                                     long clientXArg,
573                                     long clientYArg,
574                                     bool ctrlKeyArg,
575                                     bool altKeyArg,
576                                     bool shiftKeyArg,
577                                     bool metaKeyArg,
578                                     unsigned short buttonArg,
579                                     const Node &relatedTargetArg)
580 {
581     UIEventImpl::initUIEvent(typeArg,canBubbleArg,cancelableArg,viewArg,detailArg);
582
583     if (m_relatedTarget)
584         m_relatedTarget->deref();
585
586     m_screenX = screenXArg;
587     m_screenY = screenYArg;
588     m_clientX = clientXArg;
589     m_clientY = clientYArg;
590     m_ctrlKey = ctrlKeyArg;
591     m_altKey = altKeyArg;
592     m_shiftKey = shiftKeyArg;
593     m_metaKey = metaKeyArg;
594     m_button = buttonArg;
595     m_relatedTarget = relatedTargetArg.handle();
596     if (m_relatedTarget)
597         m_relatedTarget->ref();
598     computeLayerPos();
599 }
600
601 bool MouseEventImpl::isMouseEvent() const
602 {
603     return true;
604 }
605
606 bool MouseEventImpl::isDragEvent() const
607 {
608     return (m_id == EventImpl::DRAGENTER_EVENT || m_id == EventImpl::DRAGOVER_EVENT
609             || m_id == EventImpl::DRAGLEAVE_EVENT || m_id == EventImpl::DROP_EVENT 
610             || m_id == EventImpl::DRAGSTART_EVENT || m_id == EventImpl::DRAG_EVENT
611             || m_id == EventImpl::DRAGEND_EVENT);
612 }
613
614 //---------------------------------------------------------------------------------------------
615
616 KeyboardEventImpl::KeyboardEventImpl()
617 {
618   m_keyEvent = 0;
619   m_keyIdentifier = 0;
620   m_keyLocation = KeyboardEvent::DOM_KEY_LOCATION_STANDARD;
621   m_ctrlKey = false;
622   m_shiftKey = false;
623   m_altKey = false;
624   m_metaKey = false;
625   m_altGraphKey = false;
626 }
627
628 KeyboardEventImpl::KeyboardEventImpl(QKeyEvent *key, AbstractViewImpl *view)
629   : UIEventImpl(key->type() == QEvent::KeyRelease ? KEYUP_EVENT : key->isAutoRepeat() ? KEYPRESS_EVENT : KEYDOWN_EVENT,
630                 true,true,view,0)
631 {
632 #if APPLE_CHANGES
633     m_keyEvent = new QKeyEvent(*key);
634 #else
635     m_keyEvent = new QKeyEvent(key->type(), key->key(), key->ascii(), key->state(), key->text(), key->isAutoRepeat(), key->count());
636 #endif
637
638 #if APPLE_CHANGES
639     DOMString identifier(key->keyIdentifier());
640     m_keyIdentifier = identifier.implementation();
641     m_keyIdentifier->ref();
642 #else
643     m_keyIdentifier = 0;
644     // need the equivalent of the above for KDE
645 #endif
646
647     int keyState = key->state();
648
649     m_ctrlKey = keyState & Qt::ControlButton;
650     m_shiftKey = keyState & Qt::ShiftButton;
651     m_altKey = keyState & Qt::AltButton;
652     m_metaKey = keyState & Qt::MetaButton;
653     m_altGraphKey = false; // altGraphKey is not supported by Qt.
654     
655     // Note: we only support testing for num pad
656     m_keyLocation = (keyState & Qt::Keypad) ? KeyboardEvent::DOM_KEY_LOCATION_NUMPAD : KeyboardEvent::DOM_KEY_LOCATION_STANDARD;
657 }
658
659 KeyboardEventImpl::KeyboardEventImpl(EventId _id,
660                                         bool canBubbleArg,
661                                         bool cancelableArg,
662                                         AbstractViewImpl *viewArg, 
663                                         const DOMString &keyIdentifierArg, 
664                                         unsigned long keyLocationArg, 
665                                         bool ctrlKeyArg, 
666                                         bool shiftKeyArg, 
667                                         bool altKeyArg, 
668                                         bool metaKeyArg, 
669                                         bool altGraphKeyArg)
670   : UIEventImpl(_id,canBubbleArg,cancelableArg,viewArg,0)
671 {
672     m_keyEvent = 0;
673     m_keyIdentifier = keyIdentifierArg.implementation();
674     if (m_keyIdentifier)
675         m_keyIdentifier->ref();
676     m_keyLocation = keyLocationArg;
677     m_ctrlKey = ctrlKeyArg;
678     m_shiftKey = shiftKeyArg;
679     m_altKey = altKeyArg;
680     m_metaKey = metaKeyArg;
681     m_altGraphKey = altGraphKeyArg;
682 }
683
684 KeyboardEventImpl::~KeyboardEventImpl()
685 {
686     delete m_keyEvent;
687     if (m_keyIdentifier)
688         m_keyIdentifier->deref();
689 }
690
691 void KeyboardEventImpl::initKeyboardEvent(const DOMString &typeArg,
692                         bool canBubbleArg,
693                         bool cancelableArg,
694                         const AbstractView &viewArg, 
695                         const DOMString &keyIdentifierArg, 
696                         unsigned long keyLocationArg, 
697                         bool ctrlKeyArg, 
698                         bool shiftKeyArg, 
699                         bool altKeyArg, 
700                         bool metaKeyArg, 
701                         bool altGraphKeyArg)
702 {
703     if (m_keyIdentifier)
704         m_keyIdentifier->deref();
705
706     UIEventImpl::initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 0);
707     m_keyIdentifier = keyIdentifierArg.implementation();
708     if (m_keyIdentifier)
709         m_keyIdentifier->ref();
710     m_keyLocation = keyLocationArg;
711     m_ctrlKey = ctrlKeyArg;
712     m_shiftKey = shiftKeyArg;
713     m_altKey = altKeyArg;
714     m_metaKey = metaKeyArg;
715     m_altGraphKey = altGraphKeyArg;
716 }
717
718 int KeyboardEventImpl::keyCode() const
719 {
720     if (!m_keyEvent) {
721         return 0;
722     }
723     switch (m_id) {
724         case KEYDOWN_EVENT:
725         case KEYUP_EVENT:
726 #if APPLE_CHANGES
727             return m_keyEvent->WindowsKeyCode();
728 #else
729             // need the equivalent of the above for KDE
730 #endif
731         default:
732             return charCode();
733     }
734 }
735
736 int KeyboardEventImpl::charCode() const
737 {
738     if (!m_keyEvent) {
739         return 0;
740     }
741     QString text = m_keyEvent->text();
742     if (text.length() != 1) {
743         return 0;
744     }
745     return text[0].unicode();
746 }
747
748 bool KeyboardEventImpl::isKeyboardEvent() const
749 {
750     return true;
751 }
752
753 // -----------------------------------------------------------------------------
754
755 MutationEventImpl::MutationEventImpl()
756 {
757     m_relatedNode = 0;
758     m_prevValue = 0;
759     m_newValue = 0;
760     m_attrName = 0;
761     m_attrChange = 0;
762 }
763
764 MutationEventImpl::MutationEventImpl(EventId _id,
765                                      bool canBubbleArg,
766                                      bool cancelableArg,
767                                      const Node &relatedNodeArg,
768                                      const DOMString &prevValueArg,
769                                      const DOMString &newValueArg,
770                                      const DOMString &attrNameArg,
771                                      unsigned short attrChangeArg)
772                       : EventImpl(_id,canBubbleArg,cancelableArg)
773 {
774     m_relatedNode = relatedNodeArg.handle();
775     if (m_relatedNode)
776         m_relatedNode->ref();
777     m_prevValue = prevValueArg.implementation();
778     if (m_prevValue)
779         m_prevValue->ref();
780     m_newValue = newValueArg.implementation();
781     if (m_newValue)
782         m_newValue->ref();
783     m_attrName = attrNameArg.implementation();
784     if (m_newValue)
785         m_newValue->ref();
786     m_attrChange = attrChangeArg;
787 }
788
789 MutationEventImpl::~MutationEventImpl()
790 {
791     if (m_relatedNode)
792         m_relatedNode->deref();
793     if (m_prevValue)
794         m_prevValue->deref();
795     if (m_newValue)
796         m_newValue->deref();
797     if (m_attrName)
798         m_attrName->deref();
799 }
800
801 void MutationEventImpl::initMutationEvent(const DOMString &typeArg,
802                                           bool canBubbleArg,
803                                           bool cancelableArg,
804                                           const Node &relatedNodeArg,
805                                           const DOMString &prevValueArg,
806                                           const DOMString &newValueArg,
807                                           const DOMString &attrNameArg,
808                                           unsigned short attrChangeArg)
809 {
810     EventImpl::initEvent(typeArg,canBubbleArg,cancelableArg);
811
812     if (m_relatedNode)
813         m_relatedNode->deref();
814     if (m_prevValue)
815         m_prevValue->deref();
816     if (m_newValue)
817         m_newValue->deref();
818     if (m_attrName)
819         m_attrName->deref();
820
821     m_relatedNode = relatedNodeArg.handle();
822     if (m_relatedNode)
823         m_relatedNode->ref();
824     m_prevValue = prevValueArg.implementation();
825     if (m_prevValue)
826         m_prevValue->ref();
827     m_newValue = newValueArg.implementation();
828     if (m_newValue)
829         m_newValue->ref();
830     m_attrName = attrNameArg.implementation();
831     if (m_newValue)
832         m_newValue->ref();
833     m_attrChange = attrChangeArg;
834 }
835
836 bool MutationEventImpl::isMutationEvent() const
837 {
838     return true;
839 }
840
841 // -----------------------------------------------------------------------------
842
843 ClipboardEventImpl::ClipboardEventImpl()
844 {
845     m_clipboard = 0;
846 }
847
848 ClipboardEventImpl::ClipboardEventImpl(EventId _id, bool canBubbleArg, bool cancelableArg, ClipboardImpl *clipboardArg)
849   : EventImpl(_id, canBubbleArg, cancelableArg), m_clipboard(clipboardArg)
850 {
851       if (m_clipboard)
852           m_clipboard->ref();
853 }
854
855 ClipboardEventImpl::~ClipboardEventImpl()
856 {
857     if (m_clipboard)
858         m_clipboard->deref();
859 }
860
861 bool ClipboardEventImpl::isClipboardEvent() const
862 {
863     return true;
864 }
865
866 // -----------------------------------------------------------------------------
867
868 RegisteredEventListener::RegisteredEventListener(EventImpl::EventId _id, EventListener *_listener, bool _useCapture)
869 {
870     id = _id;
871     listener = _listener;
872     useCapture = _useCapture;
873     listener->ref();
874 }
875
876 RegisteredEventListener::~RegisteredEventListener() {
877     listener->deref();
878 }
879
880 bool RegisteredEventListener::operator==(const RegisteredEventListener &other)
881 {
882     return (id == other.id &&
883             listener == other.listener &&
884             useCapture == other.useCapture);
885 }
886
887 // -----------------------------------------------------------------------------
888
889 ClipboardImpl::ClipboardImpl()
890 {
891 }
892
893 ClipboardImpl::~ClipboardImpl()
894 {
895 }