dom2_events.cpp
00001 00023 #include "dom/dom2_views.h" 00024 #include "dom/dom_exception.h" 00025 #include "xml/dom2_eventsimpl.h" 00026 00027 using namespace DOM; 00028 00029 EventListener::EventListener() 00030 { 00031 } 00032 00033 EventListener::~EventListener() 00034 { 00035 } 00036 00037 void EventListener::handleEvent(Event &/*evt*/) 00038 { 00039 } 00040 00041 DOMString EventListener::eventListenerType() 00042 { 00043 return ""; 00044 } 00045 00046 // ----------------------------------------------------------------------------- 00047 00048 Event::Event() 00049 { 00050 impl = 0; 00051 } 00052 00053 00054 Event::Event(const Event &other) 00055 { 00056 impl = other.impl; 00057 if (impl) impl->ref(); 00058 } 00059 00060 Event::Event(EventImpl *i) 00061 { 00062 impl = i; 00063 if (impl) impl->ref(); 00064 } 00065 00066 Event::~Event() 00067 { 00068 if (impl) impl->deref(); 00069 } 00070 00071 Event &Event::operator = (const Event &other) 00072 { 00073 if ( impl != other.impl ) { 00074 if(impl) impl->deref(); 00075 impl = other.impl; 00076 if(impl) impl->ref(); 00077 } 00078 return *this; 00079 } 00080 00081 DOMString Event::type() const 00082 { 00083 if (!impl) 00084 throw DOMException(DOMException::INVALID_STATE_ERR); 00085 00086 return impl->type(); 00087 } 00088 00089 Node Event::target() const 00090 { 00091 if (!impl) 00092 throw DOMException(DOMException::INVALID_STATE_ERR); 00093 00094 return impl->target(); 00095 } 00096 00097 Node Event::currentTarget() const 00098 { 00099 if (!impl) 00100 throw DOMException(DOMException::INVALID_STATE_ERR); 00101 00102 return impl->currentTarget(); 00103 } 00104 00105 unsigned short Event::eventPhase() const 00106 { 00107 if (!impl) 00108 throw DOMException(DOMException::INVALID_STATE_ERR); 00109 00110 return impl->eventPhase(); 00111 } 00112 00113 bool Event::bubbles() const 00114 { 00115 if (!impl) 00116 throw DOMException(DOMException::INVALID_STATE_ERR); 00117 00118 return impl->bubbles(); 00119 } 00120 00121 bool Event::cancelable() const 00122 { 00123 if (!impl) 00124 throw DOMException(DOMException::INVALID_STATE_ERR); 00125 00126 return impl->cancelable(); 00127 } 00128 00129 DOMTimeStamp Event::timeStamp() const 00130 { 00131 if (!impl) 00132 throw DOMException(DOMException::INVALID_STATE_ERR); 00133 00134 return impl->timeStamp(); 00135 } 00136 00137 void Event::stopPropagation() 00138 { 00139 if (!impl) 00140 throw DOMException(DOMException::INVALID_STATE_ERR); 00141 00142 impl->stopPropagation(true); 00143 } 00144 00145 void Event::preventDefault() 00146 { 00147 if (!impl) 00148 throw DOMException(DOMException::INVALID_STATE_ERR); 00149 00150 impl->preventDefault(true); 00151 } 00152 00153 void Event::initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg) 00154 { 00155 if (!impl) 00156 throw DOMException(DOMException::INVALID_STATE_ERR); 00157 00158 impl->initEvent(eventTypeArg,canBubbleArg,cancelableArg); 00159 } 00160 00161 EventImpl *Event::handle() const 00162 { 00163 return impl; 00164 } 00165 00166 bool Event::isNull() const 00167 { 00168 return (impl == 0); 00169 } 00170 00171 // ----------------------------------------------------------------------------- 00172 00173 #ifndef SAVE_SPACE 00174 00175 EventException::EventException(unsigned short _code) 00176 { 00177 code = _code; 00178 } 00179 00180 EventException::EventException(const EventException &other) 00181 { 00182 code = other.code; 00183 } 00184 00185 EventException & EventException::operator = (const EventException &other) 00186 { 00187 code = other.code; 00188 return *this; 00189 } 00190 00191 #endif 00192 00193 // ----------------------------------------------------------------------------- 00194 00195 UIEvent::UIEvent() : Event() 00196 { 00197 } 00198 00199 UIEvent::UIEvent(const UIEvent &other) : Event(other) 00200 { 00201 } 00202 00203 UIEvent::UIEvent(const Event &other) : Event() 00204 { 00205 (*this)=other; 00206 } 00207 00208 UIEvent::UIEvent(UIEventImpl *impl) : Event(impl) 00209 { 00210 } 00211 00212 UIEvent &UIEvent::operator = (const UIEvent &other) 00213 { 00214 Event::operator = (other); 00215 return *this; 00216 } 00217 00218 UIEvent &UIEvent::operator = (const Event &other) 00219 { 00220 Event e; 00221 e = other; 00222 if (!e.isNull() && !e.handle()->isUIEvent()) { 00223 if ( impl ) impl->deref(); 00224 impl = 0; 00225 } else 00226 Event::operator = (other); 00227 return *this; 00228 } 00229 00230 UIEvent::~UIEvent() 00231 { 00232 } 00233 00234 AbstractView UIEvent::view() const 00235 { 00236 if (!impl) 00237 throw DOMException(DOMException::INVALID_STATE_ERR); 00238 00239 return static_cast<UIEventImpl*>(impl)->view(); 00240 } 00241 00242 long UIEvent::detail() const 00243 { 00244 if (!impl) 00245 throw DOMException(DOMException::INVALID_STATE_ERR); 00246 00247 return static_cast<UIEventImpl*>(impl)->detail(); 00248 } 00249 00250 int UIEvent::keyCode() const 00251 { 00252 if ( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR ); 00253 00254 if( impl->isTextInputEvent() || impl->isKeyboardEvent() ) 00255 return static_cast<KeyEventBaseImpl*>( impl )->keyCode(); 00256 00257 return 0; 00258 } 00259 00260 int UIEvent::charCode() const 00261 { 00262 if (!impl) 00263 throw DOMException(DOMException::INVALID_STATE_ERR); 00264 00265 if( impl->isTextInputEvent() || impl->isKeyboardEvent() ) 00266 return static_cast<KeyEventBaseImpl*>( impl )->charCode(); 00267 00268 return 0; 00269 } 00270 00271 int UIEvent::pageX() const 00272 { 00273 if (!impl) 00274 throw DOMException(DOMException::INVALID_STATE_ERR); 00275 00276 if (impl->isMouseEvent() ) 00277 return static_cast<MouseEventImpl*>( impl )->pageX(); 00278 else 00279 return 0; 00280 } 00281 00282 int UIEvent::pageY() const 00283 { 00284 if (!impl) 00285 throw DOMException(DOMException::INVALID_STATE_ERR); 00286 00287 if ( impl->isMouseEvent() ) 00288 return static_cast<MouseEventImpl*>( impl )->pageY(); 00289 else 00290 return 0; 00291 } 00292 00293 int UIEvent::layerX() const 00294 { 00295 if( !impl ) 00296 throw DOMException( DOMException::INVALID_STATE_ERR ); 00297 00298 if( impl->isMouseEvent() ) 00299 return static_cast<MouseEventImpl*>( impl )->layerX(); 00300 return 0; 00301 } 00302 00303 int UIEvent::layerY() const 00304 { 00305 if( !impl ) 00306 throw DOMException( DOMException::INVALID_STATE_ERR ); 00307 00308 if( impl->isMouseEvent() ) 00309 return static_cast<MouseEventImpl*>( impl )->layerY(); 00310 return 0; 00311 } 00312 00313 int UIEvent::which() const 00314 { 00315 if( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR ); 00316 00317 if( impl->isMouseEvent() ) 00318 return static_cast<MouseEventImpl*>( impl )->button() + 1; 00319 else if( impl->isTextInputEvent() || impl->isKeyboardEvent() ) 00320 { 00321 // return 0 unless the key has an ascii value 00322 if ( static_cast<KeyEventBaseImpl*>( impl )->keyVal() ) 00323 return static_cast<KeyEventBaseImpl*>( impl )->keyCode(); 00324 } 00325 00326 return 0; 00327 } 00328 00329 void UIEvent::initUIEvent(const DOMString &typeArg, 00330 bool canBubbleArg, 00331 bool cancelableArg, 00332 const AbstractView &viewArg, 00333 long detailArg) 00334 { 00335 if (!impl) 00336 throw DOMException(DOMException::INVALID_STATE_ERR); 00337 00338 static_cast<UIEventImpl*>(impl)->initUIEvent(typeArg,canBubbleArg,cancelableArg, 00339 viewArg,detailArg); 00340 } 00341 00342 // ----------------------------------------------------------------------------- 00343 00344 MouseEvent::MouseEvent() : UIEvent() 00345 { 00346 } 00347 00348 MouseEvent::MouseEvent(const MouseEvent &other) : UIEvent(other) 00349 { 00350 } 00351 00352 MouseEvent::MouseEvent(const Event &other) : UIEvent() 00353 { 00354 (*this)=other; 00355 } 00356 00357 MouseEvent::MouseEvent(MouseEventImpl *impl) : UIEvent(impl) 00358 { 00359 } 00360 00361 MouseEvent &MouseEvent::operator = (const MouseEvent &other) 00362 { 00363 UIEvent::operator = (other); 00364 return *this; 00365 } 00366 00367 MouseEvent &MouseEvent::operator = (const Event &other) 00368 { 00369 Event e; 00370 e = other; 00371 if (!e.isNull() && !e.handle()->isMouseEvent()) { 00372 if ( impl ) impl->deref(); 00373 impl = 0; 00374 } else 00375 UIEvent::operator = (other); 00376 return *this; 00377 } 00378 00379 MouseEvent::~MouseEvent() 00380 { 00381 } 00382 00383 long MouseEvent::screenX() const 00384 { 00385 if (!impl) 00386 throw DOMException(DOMException::INVALID_STATE_ERR); 00387 00388 return static_cast<MouseEventImpl*>(impl)->screenX(); 00389 } 00390 00391 long MouseEvent::screenY() const 00392 { 00393 if (!impl) 00394 throw DOMException(DOMException::INVALID_STATE_ERR); 00395 00396 return static_cast<MouseEventImpl*>(impl)->screenY(); 00397 } 00398 00399 long MouseEvent::clientX() const 00400 { 00401 if (!impl) 00402 throw DOMException(DOMException::INVALID_STATE_ERR); 00403 00404 return static_cast<MouseEventImpl*>(impl)->clientX(); 00405 } 00406 00407 long MouseEvent::clientY() const 00408 { 00409 if (!impl) 00410 throw DOMException(DOMException::INVALID_STATE_ERR); 00411 00412 return static_cast<MouseEventImpl*>(impl)->clientY(); 00413 } 00414 00415 bool MouseEvent::ctrlKey() const 00416 { 00417 if (!impl) 00418 throw DOMException(DOMException::INVALID_STATE_ERR); 00419 00420 return static_cast<MouseEventImpl*>(impl)->ctrlKey(); 00421 } 00422 00423 bool MouseEvent::shiftKey() const 00424 { 00425 if (!impl) 00426 throw DOMException(DOMException::INVALID_STATE_ERR); 00427 00428 return static_cast<MouseEventImpl*>(impl)->shiftKey(); 00429 } 00430 00431 bool MouseEvent::altKey() const 00432 { 00433 if (!impl) 00434 throw DOMException(DOMException::INVALID_STATE_ERR); 00435 00436 return static_cast<MouseEventImpl*>(impl)->altKey(); 00437 } 00438 00439 bool MouseEvent::metaKey() const 00440 { 00441 if (!impl) 00442 throw DOMException(DOMException::INVALID_STATE_ERR); 00443 00444 return static_cast<MouseEventImpl*>(impl)->metaKey(); 00445 } 00446 00447 unsigned short MouseEvent::button() const 00448 { 00449 if (!impl) 00450 throw DOMException(DOMException::INVALID_STATE_ERR); 00451 00452 return static_cast<MouseEventImpl*>(impl)->button(); 00453 } 00454 00455 Node MouseEvent::relatedTarget() const 00456 { 00457 if (!impl) 00458 throw DOMException(DOMException::INVALID_STATE_ERR); 00459 00460 return static_cast<MouseEventImpl*>(impl)->relatedTarget(); 00461 } 00462 00463 void MouseEvent::initMouseEvent(const DOMString &typeArg, 00464 bool canBubbleArg, 00465 bool cancelableArg, 00466 const AbstractView &viewArg, 00467 long detailArg, 00468 long screenXArg, 00469 long screenYArg, 00470 long clientXArg, 00471 long clientYArg, 00472 bool ctrlKeyArg, 00473 bool altKeyArg, 00474 bool shiftKeyArg, 00475 bool metaKeyArg, 00476 unsigned short buttonArg, 00477 const Node &relatedTargetArg) 00478 { 00479 if (!impl) 00480 throw DOMException(DOMException::INVALID_STATE_ERR); 00481 00482 static_cast<MouseEventImpl*>(impl)->initMouseEvent(typeArg,canBubbleArg, 00483 cancelableArg,viewArg,detailArg,screenXArg,screenYArg,clientXArg, 00484 clientYArg,ctrlKeyArg,altKeyArg,shiftKeyArg,metaKeyArg,buttonArg, 00485 relatedTargetArg); 00486 } 00487 00488 // ----------------------------------------------------------------------------- 00489 00490 TextEvent::TextEvent() : UIEvent() 00491 { 00492 } 00493 00494 TextEvent::TextEvent(const TextEvent &other) : UIEvent(other) 00495 { 00496 } 00497 00498 TextEvent::TextEvent(const Event &other) : UIEvent() 00499 { 00500 (*this)=other; 00501 } 00502 00503 TextEvent::TextEvent(KeyEventBaseImpl *impl) : UIEvent(impl) 00504 { 00505 } 00506 00507 TextEvent &TextEvent::operator = (const TextEvent &other) 00508 { 00509 UIEvent::operator = (other); 00510 return *this; 00511 } 00512 00513 TextEvent &TextEvent::operator = (const Event &other) 00514 { 00515 Event e; 00516 e = other; 00517 if (!e.isNull() && !(e.handle()->isTextInputEvent() || e.handle()->isKeyboardEvent())) { 00518 if ( impl ) impl->deref(); 00519 impl = 0; 00520 } else 00521 UIEvent::operator = (other); 00522 return *this; 00523 } 00524 00525 TextEvent::~TextEvent() 00526 { 00527 } 00528 00529 void TextEvent::initTextEvent(const DOMString &typeArg, 00530 bool canBubbleArg, 00531 bool cancelableArg, 00532 const AbstractView &viewArg, 00533 long /*detailArg*/, 00534 const DOMString &outputStringArg, 00535 unsigned long keyValArg, 00536 unsigned long virtKeyValArg, 00537 bool /*inputGeneratedArg*/, 00538 bool numPadArg) 00539 { 00540 if (!impl) 00541 throw DOMException(DOMException::INVALID_STATE_ERR); 00542 00543 if (impl->isTextInputEvent()) { 00544 //Initialize based on the outputStringArg or virtKeyValArg. 00545 QString text = outputStringArg.string(); 00546 if (outputStringArg.length() == 0 && virtKeyValArg) { 00547 text += QChar((unsigned short)virtKeyValArg); 00548 } 00549 00550 TextEventImpl* tImpl = static_cast<TextEventImpl*>(impl); 00551 tImpl->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, text); 00552 } else { 00553 KeyboardEventImpl* kbImpl = static_cast<KeyboardEventImpl*>(impl); 00554 kbImpl->initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 00555 keyValArg, virtKeyValArg, 0, numPadArg ? 00556 KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD : KeyboardEventImpl::DOM_KEY_LOCATION_STANDARD); 00557 } 00558 } 00559 00560 unsigned long TextEvent::keyVal() const 00561 { 00562 if (!impl) 00563 throw DOMException(DOMException::INVALID_STATE_ERR); 00564 00565 return static_cast<KeyEventBaseImpl*>(impl)->keyVal(); 00566 } 00567 00568 DOMString TextEvent::outputString() const 00569 { 00570 if (!impl) 00571 throw DOMException(DOMException::INVALID_STATE_ERR); 00572 00573 KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl); 00574 if (ke->isTextInputEvent()) 00575 return static_cast<TextEventImpl*>(ke)->data(); 00576 else { 00577 if (ke->keyVal()) 00578 return QString(QChar((ushort)ke->keyVal())); 00579 else 00580 return DOMString(); 00581 } 00582 } 00583 00584 unsigned long TextEvent::virtKeyVal() const 00585 { 00586 if (!impl) 00587 throw DOMException(DOMException::INVALID_STATE_ERR); 00588 00589 return static_cast<KeyEventBaseImpl*>(impl)->virtKeyVal(); 00590 } 00591 00592 void TextEvent::initModifier(unsigned long modifierArg, bool valueArg) 00593 { 00594 if (!impl) 00595 throw DOMException(DOMException::INVALID_STATE_ERR); 00596 00597 return static_cast<KeyEventBaseImpl*>(impl)->initModifier(modifierArg,valueArg); 00598 } 00599 00600 bool TextEvent::checkModifier(unsigned long modifierArg) 00601 { 00602 if (!impl) 00603 throw DOMException(DOMException::INVALID_STATE_ERR); 00604 00605 return static_cast<KeyEventBaseImpl*>(impl)->checkModifier(modifierArg); 00606 } 00607 00608 bool TextEvent::inputGenerated() const 00609 { 00610 if (!impl) 00611 throw DOMException(DOMException::INVALID_STATE_ERR); 00612 00613 return static_cast<KeyEventBaseImpl*>(impl)->inputGenerated(); 00614 } 00615 00616 bool TextEvent::numPad() const 00617 { 00618 if (!impl) 00619 throw DOMException(DOMException::INVALID_STATE_ERR); 00620 00621 KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl); 00622 if (ke->isKeyboardEvent()) 00623 return static_cast<KeyboardEventImpl*>(ke)->keyLocation() == 00624 KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD; 00625 else return false; 00626 } 00627 // ----------------------------------------------------------------------------- 00628 00629 MutationEvent::MutationEvent() : Event() 00630 { 00631 } 00632 00633 MutationEvent::MutationEvent(const MutationEvent &other) : Event(other) 00634 { 00635 } 00636 00637 MutationEvent::MutationEvent(const Event &other) : Event() 00638 { 00639 (*this)=other; 00640 } 00641 00642 MutationEvent::MutationEvent(MutationEventImpl *impl) : Event(impl) 00643 { 00644 } 00645 00646 MutationEvent &MutationEvent::operator = (const MutationEvent &other) 00647 { 00648 Event::operator = (other); 00649 return *this; 00650 } 00651 00652 MutationEvent &MutationEvent::operator = (const Event &other) 00653 { 00654 Event e; 00655 e = other; 00656 if (!e.isNull() && !e.handle()->isMutationEvent()) { 00657 if ( impl ) impl->deref(); 00658 impl = 0; 00659 } else 00660 Event::operator = (other); 00661 return *this; 00662 } 00663 00664 MutationEvent::~MutationEvent() 00665 { 00666 } 00667 00668 Node MutationEvent::relatedNode() const 00669 { 00670 if (!impl) 00671 throw DOMException(DOMException::INVALID_STATE_ERR); 00672 00673 return static_cast<MutationEventImpl*>(impl)->relatedNode(); 00674 } 00675 00676 DOMString MutationEvent::prevValue() const 00677 { 00678 if (!impl) 00679 throw DOMException(DOMException::INVALID_STATE_ERR); 00680 00681 return static_cast<MutationEventImpl*>(impl)->prevValue(); 00682 } 00683 00684 DOMString MutationEvent::newValue() const 00685 { 00686 if (!impl) 00687 throw DOMException(DOMException::INVALID_STATE_ERR); 00688 00689 return static_cast<MutationEventImpl*>(impl)->newValue(); 00690 } 00691 00692 DOMString MutationEvent::attrName() const 00693 { 00694 if (!impl) 00695 throw DOMException(DOMException::INVALID_STATE_ERR); 00696 00697 return static_cast<MutationEventImpl*>(impl)->attrName(); 00698 } 00699 00700 unsigned short MutationEvent::attrChange() const 00701 { 00702 if (!impl) 00703 throw DOMException(DOMException::INVALID_STATE_ERR); 00704 00705 return static_cast<MutationEventImpl*>(impl)->attrChange(); 00706 } 00707 00708 void MutationEvent::initMutationEvent(const DOMString &typeArg, 00709 bool canBubbleArg, 00710 bool cancelableArg, 00711 const Node &relatedNodeArg, 00712 const DOMString &prevValueArg, 00713 const DOMString &newValueArg, 00714 const DOMString &attrNameArg, 00715 unsigned short attrChangeArg) 00716 { 00717 if (!impl) 00718 throw DOMException(DOMException::INVALID_STATE_ERR); 00719 00720 static_cast<MutationEventImpl*>(impl)->initMutationEvent(typeArg, 00721 canBubbleArg,cancelableArg,relatedNodeArg,prevValueArg, 00722 newValueArg,attrNameArg,attrChangeArg); 00723 } 00724 00725