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 &)
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->isTextEvent() )
00255 return static_cast<TextEventImpl*>( 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->isTextEvent() )
00266 return static_cast<TextEventImpl*>( 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->isTextEvent() )
00320 return static_cast<TextEventImpl*>( impl )->keyCode();
00321
00322 return 0;
00323 }
00324
00325 void UIEvent::initUIEvent(const DOMString &typeArg,
00326 bool canBubbleArg,
00327 bool cancelableArg,
00328 const AbstractView &viewArg,
00329 long detailArg)
00330 {
00331 if (!impl)
00332 throw DOMException(DOMException::INVALID_STATE_ERR);
00333
00334 static_cast<UIEventImpl*>(impl)->initUIEvent(typeArg,canBubbleArg,cancelableArg,
00335 viewArg,detailArg);
00336 }
00337
00338
00339
00340 MouseEvent::MouseEvent() : UIEvent()
00341 {
00342 }
00343
00344 MouseEvent::MouseEvent(const MouseEvent &other) : UIEvent(other)
00345 {
00346 }
00347
00348 MouseEvent::MouseEvent(const Event &other) : UIEvent()
00349 {
00350 (*this)=other;
00351 }
00352
00353 MouseEvent::MouseEvent(MouseEventImpl *impl) : UIEvent(impl)
00354 {
00355 }
00356
00357 MouseEvent &MouseEvent::operator = (const MouseEvent &other)
00358 {
00359 UIEvent::operator = (other);
00360 return *this;
00361 }
00362
00363 MouseEvent &MouseEvent::operator = (const Event &other)
00364 {
00365 Event e;
00366 e = other;
00367 if (!e.isNull() && !e.handle()->isMouseEvent()) {
00368 if ( impl ) impl->deref();
00369 impl = 0;
00370 } else
00371 UIEvent::operator = (other);
00372 return *this;
00373 }
00374
00375 MouseEvent::~MouseEvent()
00376 {
00377 }
00378
00379 long MouseEvent::screenX() const
00380 {
00381 if (!impl)
00382 throw DOMException(DOMException::INVALID_STATE_ERR);
00383
00384 return static_cast<MouseEventImpl*>(impl)->screenX();
00385 }
00386
00387 long MouseEvent::screenY() const
00388 {
00389 if (!impl)
00390 throw DOMException(DOMException::INVALID_STATE_ERR);
00391
00392 return static_cast<MouseEventImpl*>(impl)->screenY();
00393 }
00394
00395 long MouseEvent::clientX() const
00396 {
00397 if (!impl)
00398 throw DOMException(DOMException::INVALID_STATE_ERR);
00399
00400 return static_cast<MouseEventImpl*>(impl)->clientX();
00401 }
00402
00403 long MouseEvent::clientY() const
00404 {
00405 if (!impl)
00406 throw DOMException(DOMException::INVALID_STATE_ERR);
00407
00408 return static_cast<MouseEventImpl*>(impl)->clientY();
00409 }
00410
00411 bool MouseEvent::ctrlKey() const
00412 {
00413 if (!impl)
00414 throw DOMException(DOMException::INVALID_STATE_ERR);
00415
00416 return static_cast<MouseEventImpl*>(impl)->ctrlKey();
00417 }
00418
00419 bool MouseEvent::shiftKey() const
00420 {
00421 if (!impl)
00422 throw DOMException(DOMException::INVALID_STATE_ERR);
00423
00424 return static_cast<MouseEventImpl*>(impl)->shiftKey();
00425 }
00426
00427 bool MouseEvent::altKey() const
00428 {
00429 if (!impl)
00430 throw DOMException(DOMException::INVALID_STATE_ERR);
00431
00432 return static_cast<MouseEventImpl*>(impl)->altKey();
00433 }
00434
00435 bool MouseEvent::metaKey() const
00436 {
00437 if (!impl)
00438 throw DOMException(DOMException::INVALID_STATE_ERR);
00439
00440 return static_cast<MouseEventImpl*>(impl)->metaKey();
00441 }
00442
00443 unsigned short MouseEvent::button() const
00444 {
00445 if (!impl)
00446 throw DOMException(DOMException::INVALID_STATE_ERR);
00447
00448 return static_cast<MouseEventImpl*>(impl)->button();
00449 }
00450
00451 Node MouseEvent::relatedTarget() const
00452 {
00453 if (!impl)
00454 throw DOMException(DOMException::INVALID_STATE_ERR);
00455
00456 return static_cast<MouseEventImpl*>(impl)->relatedTarget();
00457 }
00458
00459 void MouseEvent::initMouseEvent(const DOMString &typeArg,
00460 bool canBubbleArg,
00461 bool cancelableArg,
00462 const AbstractView &viewArg,
00463 long detailArg,
00464 long screenXArg,
00465 long screenYArg,
00466 long clientXArg,
00467 long clientYArg,
00468 bool ctrlKeyArg,
00469 bool altKeyArg,
00470 bool shiftKeyArg,
00471 bool metaKeyArg,
00472 unsigned short buttonArg,
00473 const Node &relatedTargetArg)
00474 {
00475 if (!impl)
00476 throw DOMException(DOMException::INVALID_STATE_ERR);
00477
00478 static_cast<MouseEventImpl*>(impl)->initMouseEvent(typeArg,canBubbleArg,
00479 cancelableArg,viewArg,detailArg,screenXArg,screenYArg,clientXArg,
00480 clientYArg,ctrlKeyArg,altKeyArg,shiftKeyArg,metaKeyArg,buttonArg,
00481 relatedTargetArg);
00482 }
00483
00484
00485
00486 TextEvent::TextEvent() : UIEvent()
00487 {
00488 }
00489
00490 TextEvent::TextEvent(const TextEvent &other) : UIEvent(other)
00491 {
00492 }
00493
00494 TextEvent::TextEvent(const Event &other) : UIEvent()
00495 {
00496 (*this)=other;
00497 }
00498
00499 TextEvent::TextEvent(TextEventImpl *impl) : UIEvent(impl)
00500 {
00501 }
00502
00503 TextEvent &TextEvent::operator = (const TextEvent &other)
00504 {
00505 UIEvent::operator = (other);
00506 return *this;
00507 }
00508
00509 TextEvent &TextEvent::operator = (const Event &other)
00510 {
00511 Event e;
00512 e = other;
00513 if (!e.isNull() && !e.handle()->isTextEvent()) {
00514 if ( impl ) impl->deref();
00515 impl = 0;
00516 } else
00517 UIEvent::operator = (other);
00518 return *this;
00519 }
00520
00521 TextEvent::~TextEvent()
00522 {
00523 }
00524
00525 void TextEvent::initTextEvent(const DOMString &typeArg,
00526 bool canBubbleArg,
00527 bool cancelableArg,
00528 const AbstractView &viewArg,
00529 long detailArg,
00530 const DOMString &outputStringArg,
00531 unsigned long keyValArg,
00532 unsigned long virtKeyValArg,
00533 bool inputGeneratedArg,
00534 bool numPadArg)
00535 {
00536 if (!impl)
00537 throw DOMException(DOMException::INVALID_STATE_ERR);
00538
00539 return static_cast<TextEventImpl*>(impl)->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, outputStringArg, keyValArg, virtKeyValArg, inputGeneratedArg, numPadArg);
00540 }
00541
00542 unsigned long TextEvent::keyVal() const
00543 {
00544 if (!impl)
00545 throw DOMException(DOMException::INVALID_STATE_ERR);
00546
00547 return static_cast<TextEventImpl*>(impl)->keyVal();
00548 }
00549
00550 DOMString TextEvent::outputString() const
00551 {
00552 if (!impl)
00553 throw DOMException(DOMException::INVALID_STATE_ERR);
00554
00555 return static_cast<TextEventImpl*>(impl)->outputString();
00556 }
00557
00558 unsigned long TextEvent::virtKeyVal() const
00559 {
00560 if (!impl)
00561 throw DOMException(DOMException::INVALID_STATE_ERR);
00562
00563 return static_cast<TextEventImpl*>(impl)->virtKeyVal();
00564 }
00565
00566 void TextEvent::initModifier(unsigned long modifierArg, bool valueArg)
00567 {
00568 if (!impl)
00569 throw DOMException(DOMException::INVALID_STATE_ERR);
00570
00571 return static_cast<TextEventImpl*>(impl)->initModifier(modifierArg,valueArg);
00572 }
00573
00574 bool TextEvent::checkModifier(unsigned long modiferArg)
00575 {
00576 if (!impl)
00577 throw DOMException(DOMException::INVALID_STATE_ERR);
00578
00579 return static_cast<TextEventImpl*>(impl)->checkModifier(modiferArg);
00580 }
00581
00582 bool TextEvent::inputGenerated() const
00583 {
00584 if (!impl)
00585 throw DOMException(DOMException::INVALID_STATE_ERR);
00586
00587 return static_cast<TextEventImpl*>(impl)->inputGenerated();
00588 }
00589
00590 bool TextEvent::numPad() const
00591 {
00592 if (!impl)
00593 throw DOMException(DOMException::INVALID_STATE_ERR);
00594
00595 return static_cast<TextEventImpl*>(impl)->numPad();
00596 }
00597
00598
00599 MutationEvent::MutationEvent() : Event()
00600 {
00601 }
00602
00603 MutationEvent::MutationEvent(const MutationEvent &other) : Event(other)
00604 {
00605 }
00606
00607 MutationEvent::MutationEvent(const Event &other) : Event()
00608 {
00609 (*this)=other;
00610 }
00611
00612 MutationEvent::MutationEvent(MutationEventImpl *impl) : Event(impl)
00613 {
00614 }
00615
00616 MutationEvent &MutationEvent::operator = (const MutationEvent &other)
00617 {
00618 Event::operator = (other);
00619 return *this;
00620 }
00621
00622 MutationEvent &MutationEvent::operator = (const Event &other)
00623 {
00624 Event e;
00625 e = other;
00626 if (!e.isNull() && !e.handle()->isMutationEvent()) {
00627 if ( impl ) impl->deref();
00628 impl = 0;
00629 } else
00630 Event::operator = (other);
00631 return *this;
00632 }
00633
00634 MutationEvent::~MutationEvent()
00635 {
00636 }
00637
00638 Node MutationEvent::relatedNode() const
00639 {
00640 if (!impl)
00641 throw DOMException(DOMException::INVALID_STATE_ERR);
00642
00643 return static_cast<MutationEventImpl*>(impl)->relatedNode();
00644 }
00645
00646 DOMString MutationEvent::prevValue() const
00647 {
00648 if (!impl)
00649 throw DOMException(DOMException::INVALID_STATE_ERR);
00650
00651 return static_cast<MutationEventImpl*>(impl)->prevValue();
00652 }
00653
00654 DOMString MutationEvent::newValue() const
00655 {
00656 if (!impl)
00657 throw DOMException(DOMException::INVALID_STATE_ERR);
00658
00659 return static_cast<MutationEventImpl*>(impl)->newValue();
00660 }
00661
00662 DOMString MutationEvent::attrName() const
00663 {
00664 if (!impl)
00665 throw DOMException(DOMException::INVALID_STATE_ERR);
00666
00667 return static_cast<MutationEventImpl*>(impl)->attrName();
00668 }
00669
00670 unsigned short MutationEvent::attrChange() const
00671 {
00672 if (!impl)
00673 throw DOMException(DOMException::INVALID_STATE_ERR);
00674
00675 return static_cast<MutationEventImpl*>(impl)->attrChange();
00676 }
00677
00678 void MutationEvent::initMutationEvent(const DOMString &typeArg,
00679 bool canBubbleArg,
00680 bool cancelableArg,
00681 const Node &relatedNodeArg,
00682 const DOMString &prevValueArg,
00683 const DOMString &newValueArg,
00684 const DOMString &attrNameArg,
00685 unsigned short attrChangeArg)
00686 {
00687 if (!impl)
00688 throw DOMException(DOMException::INVALID_STATE_ERR);
00689
00690 static_cast<MutationEventImpl*>(impl)->initMutationEvent(typeArg,
00691 canBubbleArg,cancelableArg,relatedNodeArg,prevValueArg,
00692 newValueArg,attrNameArg,attrChangeArg);
00693 }
00694
00695