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