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