src/dom/events.h

   1 #ifndef __EVENTS_H__
   2 #define __EVENTS_H__
   3
   4 /**
   5  * Phoebe DOM Implementation.
   6  *
   7  * This is a C++ approximation of the W3C DOM model, which follows
   8  * fairly closely the specifications in the various .idl files, copies of
   9  * which are provided for reference.  Most important is this one:
  10  *
  11  * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
  12  *
  13  * Authors:
  14  *   Bob Jamison
  15  *
  16  * Copyright (C) 2005 Bob Jamison
  17  *
  18  *  This library is free software; you can redistribute it and/or
  19  *  modify it under the terms of the GNU Lesser General Public
  20  *  License as published by the Free Software Foundation; either
  21  *  version 2.1 of the License, or (at your option) any later version.
  22  *
  23  *  This library is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26  *  Lesser General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU Lesser General Public
  29  *  License along with this library; if not, write to the Free Software
  30  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  31  */
  32
  33
  34 #include "dom.h"
  35 #include "views.h"
  36
  37
  38
  39
  40 namespace org    {
  41 namespace w3c    {
  42 namespace dom    {
  43 namespace events {
  44
  45
  46
  47
  48 //Local definitions
  49 typedef dom::DOMString DOMString;
  50 typedef dom::DOMTimeStamp DOMTimeStamp;
  51 typedef dom::NodePtr  NodePtr ;
  52
  53
  54
  55
  56 //forward declarations
  57 class Event;
  58 class EventTarget;
  59 class EventListener;
  60 class DocumentEvent;
  61 class CustomEvent;
  62 class UIEvent;
  63 class TextEvent;
  64 class MouseEvent;
  65 class KeyboardEvent;
  66 class MutationEvent;
  67 class MutationNameEvent;
  68
  69
  70
  71 /*#########################################################################
  72 ## EventException
  73 #########################################################################*/
  74
  75 /**
  76  *
  77  */
  78 class EventException
  79 {
  80 public:
  81
  82     EventException(short theCode)
  83         {
  84             code = theCode;
  85         }
  86
  87     virtual ~EventException() throw()
  88        {}
  89
  90     unsigned short code;
  91 };
  92
  93     /**
  94      * EventExceptionCode
  95      */
  96     enum
  97         {
  98         UNSPECIFIED_EVENT_TYPE_ERR = 0,
  99         DISPATCH_REQUEST_ERR       = 1
 100         };
 101
 102
 103
 104 /*#########################################################################
 105 ## Event
 106 #########################################################################*/
 107
 108 /**
 109  *
 110  */
 111 class Event
 112 {
 113 public:
 114
 115     /**
 116      * PhaseType
 117      */
 118     typedef enum
 119         {
 120         CAPTURING_PHASE = 1,
 121         AT_TARGET       = 2,
 122         BUBBLING_PHASE  = 3
 123         } PhaseType;
 124
 125     /**
 126      *
 127      */
 128     virtual DOMString getType() const
 129         { return eventType; }
 130
 131     /**
 132      *
 133      */
 134     virtual EventTarget *getTarget()
 135         { return target; }
 136
 137     /**
 138      *
 139      */
 140     virtual EventTarget *getCurrentTarget()
 141         { return currentTarget; }
 142
 143     /**
 144      *
 145      */
 146     virtual unsigned short getEventPhase()
 147         { return eventPhase; }
 148
 149     /**
 150      *
 151      */
 152     virtual bool getBubbles()
 153         { return canBubble; }
 154
 155     /**
 156      *
 157      */
 158     virtual bool getCancelable()
 159         { return cancelable; }
 160
 161     /**
 162      *
 163      */
 164     virtual DOMTimeStamp getTimeStamp()
 165         { return timeStamp; }
 166
 167     /**
 168      *
 169      */
 170     virtual void stopPropagation()
 171         {
 172         }
 173
 174     /**
 175      *
 176      */
 177     virtual void preventDefault()
 178         {
 179         }
 180
 181     /**
 182      *
 183      */
 184     virtual void initEvent(const DOMString &eventTypeArg,
 185                            bool canBubbleArg,
 186                            bool cancelableArg)
 187         {
 188         namespaceURI = "";
 189         eventType    = eventTypeArg;
 190         canBubble    = canBubbleArg;
 191         cancelable   = cancelableArg;
 192         }
 193
 194
 195     /**
 196      *
 197      */
 198     virtual DOMString getNamespaceURI() const
 199         { return namespaceURI; }
 200
 201     /**
 202      *
 203      */
 204     virtual bool isCustom()
 205         { return custom; }
 206
 207     /**
 208      *
 209      */
 210     virtual void stopImmediatePropagation()
 211         {
 212         }
 213
 214     /**
 215      *
 216      */
 217     virtual bool isDefaultPrevented()
 218         { return defaultPrevented; }
 219
 220     /**
 221      *
 222      */
 223     virtual void initEventNS(const DOMString &namespaceURIArg,
 224                              const DOMString &eventTypeArg,
 225                              bool canBubbleArg,
 226                              bool cancelableArg)
 227         {
 228         namespaceURI = namespaceURIArg;
 229         eventType    = eventTypeArg;
 230         canBubble    = canBubbleArg;
 231         cancelable   = cancelableArg;
 232         }
 233
 234     //##################
 235     //# Non-API methods
 236     //##################
 237
 238     /**
 239      *
 240      */
 241     Event()
 242         {
 243         init();
 244         }
 245
 246     /**
 247      *
 248      */
 249     Event(const DOMString &eventTypeArg)
 250         {
 251         init();
 252         eventType     = eventTypeArg;
 253         }
 254
 255
 256     /**
 257      *
 258      */
 259     Event(const Event &other)
 260         {
 261         eventType        = other.eventType;
 262         target           = other.target;
 263         currentTarget    = other.currentTarget;
 264         eventPhase       = other.eventPhase;
 265         canBubble        = other.canBubble;
 266         cancelable       = other.cancelable;
 267         timeStamp        = other.timeStamp;
 268         namespaceURI     = other.namespaceURI;
 269         custom           = other.custom;
 270         defaultPrevented = other.defaultPrevented;
 271         }
 272
 273     /**
 274      *
 275      */
 276     virtual ~Event() {}
 277
 278 protected:
 279
 280     /**
 281      *
 282      */
 283     void init()
 284         {
 285         eventType        = "";
 286         target           = NULL;
 287         currentTarget    = NULL;
 288         eventPhase       = 0;
 289         canBubble        = false;
 290         cancelable       = false;
 291         //timeStamp      = other.timeStamp;
 292         namespaceURI     = "";
 293         custom           = false;
 294         defaultPrevented = false;
 295         }
 296
 297     DOMString      eventType;
 298     EventTarget    *target;
 299     EventTarget    *currentTarget;
 300     unsigned short eventPhase;
 301     bool           canBubble;
 302     bool           cancelable;
 303     DOMTimeStamp   timeStamp;
 304     DOMString      namespaceURI;
 305     bool           custom;
 306     bool           defaultPrevented;
 307
 308 };
 309
 310
 311
 312
 313 /*#########################################################################
 314 ## EventListener
 315 #########################################################################*/
 316
 317 /**
 318  *
 319  */
 320 class EventListener
 321 {
 322 public:
 323
 324     /**
 325      *
 326      */
 327     virtual void handleEvent(const Event &/*evt*/)
 328         {}
 329
 330     //##################
 331     //# Non-API methods
 332     //##################
 333
 334     /**
 335      *
 336      */
 337     virtual ~EventListener() {}
 338 };
 339
 340
 341
 342
 343
 344
 345 /*#########################################################################
 346 ## EventTarget
 347 #########################################################################*/
 348
 349 class EventListenerEntry
 350 {
 351 public:
 352     EventListenerEntry(const DOMString &namespaceURIArg,
 353                        const DOMString &eventTypeArg,
 354                        const EventListener *listenerArg,
 355                        bool useCaptureArg)
 356         {
 357         namespaceURI = namespaceURIArg;
 358         eventType    = eventTypeArg;
 359         listener     = (EventListener *)listenerArg;
 360         useCapture   = useCaptureArg;
 361         }
 362
 363     EventListenerEntry(const EventListenerEntry &other)
 364         {
 365         namespaceURI = other.namespaceURI;
 366         eventType    = other.eventType;
 367         listener     = other.listener;
 368         useCapture   = other.useCapture;
 369         }
 370
 371     virtual ~EventListenerEntry() {}
 372
 373     DOMString namespaceURI;
 374     DOMString eventType;
 375     EventListener *listener;
 376     bool useCapture;
 377 };
 378
 379
 380 /**
 381  *
 382  */
 383 class EventTarget
 384 {
 385 public:
 386
 387     /**
 388      *
 389      */
 390     virtual void addEventListener(const DOMString &type,
 391                                   const EventListener *listener,
 392                                   bool useCapture)
 393         {
 394         EventListenerEntry entry("", type, listener, useCapture);
 395         listeners.push_back(entry);
 396         }
 397
 398     /**
 399      *
 400      */
 401     virtual void removeEventListener(const DOMString &type,
 402                                      const EventListener *listener,
 403                                      bool useCapture)
 404         {
 405         std::vector<EventListenerEntry>::iterator iter;
 406         for (iter = listeners.begin() ; iter != listeners.end() ; iter++)
 407             {
 408             EventListenerEntry entry = *iter;
 409             if (entry.eventType == type &&
 410                 entry.listener  == listener &&
 411                 useCapture && entry.useCapture)
 412                 listeners.erase(iter);
 413             }
 414         }
 415
 416     /**
 417      *
 418      */
 419     virtual bool dispatchEvent(const Event &evt) throw(EventException)
 420         {
 421
 422         for (unsigned int i=0 ; i<listeners.size() ; i++)
 423             {
 424             EventListenerEntry listener = listeners[i];
 425             if (listener.namespaceURI == evt.getNamespaceURI()  &&
 426                 listener.eventType    == evt.getType())
 427                 {
 428                 if (listener.listener)
 429                     listener.listener->handleEvent(evt);
 430                 }
 431             }
 432         return true;
 433         }
 434
 435
 436     /**
 437      *
 438      */
 439     virtual void addEventListenerNS(const DOMString &namespaceURI,
 440                                     const DOMString &type,
 441                                     const EventListener *listener,
 442                                     bool useCapture)
 443         {
 444         EventListenerEntry entry(namespaceURI, type, listener, useCapture);
 445         listeners.push_back(entry);
 446         }
 447
 448     /**
 449      *
 450      */
 451     virtual void removeEventListenerNS(const DOMString &namespaceURI,
 452                                        const DOMString &type,
 453                                        const EventListener *listener,
 454                                        bool useCapture)
 455         {
 456         std::vector<EventListenerEntry>::iterator iter;
 457         for (iter = listeners.begin() ; iter != listeners.end() ; iter++)
 458             {
 459             EventListenerEntry entry = *iter;
 460             if (entry.namespaceURI == namespaceURI &&
 461                 entry.eventType    == type &&
 462                 entry.listener     == listener &&
 463                 useCapture && entry.useCapture)
 464                 listeners.erase(iter);
 465             }
 466         }
 467
 468     /**
 469      *
 470      */
 471     virtual bool willTriggerNS(const DOMString &namespaceURI,
 472                                const DOMString &type)
 473         {
 474         std::vector<EventListenerEntry>::iterator iter;
 475         for (iter = listeners.begin() ; iter != listeners.end() ; iter++)
 476             {
 477             EventListenerEntry entry = *iter;
 478             if (entry.namespaceURI == namespaceURI &&
 479                 entry.eventType    == type)
 480                 return true;
 481             }
 482         return false;
 483         }
 484
 485     /**
 486      *
 487      */
 488     virtual bool hasEventListenerNS(const DOMString &namespaceURI,
 489                                     const DOMString &type)
 490         {
 491         std::vector<EventListenerEntry>::iterator iter;
 492         for (iter = listeners.begin() ; iter != listeners.end() ; iter++)
 493             {
 494             EventListenerEntry entry = *iter;
 495             if (entry.namespaceURI == namespaceURI &&
 496                 entry.eventType    == type)
 497                 return true;
 498             }
 499         return false;
 500         }
 501
 502
 503     //##################
 504     //# Non-API methods
 505     //##################
 506
 507     /**
 508      *
 509      */
 510     EventTarget() {}
 511
 512     /**
 513      *
 514      */
 515     EventTarget(const EventTarget &other)
 516         {
 517         listeners = other.listeners;
 518         }
 519
 520     /**
 521      *
 522      */
 523     virtual ~EventTarget() {}
 524
 525 protected:
 526
 527     std::vector<EventListenerEntry> listeners;
 528
 529 };
 530
 531
 532
 533
 534 /*#########################################################################
 535 ## DocumentEvent
 536 #########################################################################*/
 537
 538 /*
 539  *
 540  */
 541 class DocumentEvent : virtual public Event
 542 {
 543 public:
 544
 545     /**
 546      *
 547      */
 548     virtual Event createEvent(const DOMString &/*eventType*/)
 549                                throw (dom::DOMException)
 550         {
 551         Event event;
 552         return event;
 553         }
 554
 555     /**
 556      *
 557      */
 558     virtual bool canDispatch(const DOMString &/*namespaceURI*/,
 559                              const DOMString &/*type*/)
 560         {
 561         return dispatchable;
 562         }
 563
 564     //##################
 565     //# Non-API methods
 566     //##################
 567
 568     /**
 569      *
 570      */
 571     DocumentEvent() {}
 572
 573     /**
 574      *
 575      */
 576     DocumentEvent(const DocumentEvent &other) : Event(other)
 577         {
 578         dispatchable = other.dispatchable;
 579         }
 580
 581     /**
 582      *
 583      */
 584     virtual ~DocumentEvent() {}
 585
 586 protected:
 587
 588     bool dispatchable;
 589
 590
 591 };
 592
 593
 594 /*#########################################################################
 595 ## CustomEvent
 596 #########################################################################*/
 597
 598 /*
 599  *
 600  */
 601 class CustomEvent : virtual public Event
 602 {
 603 public:
 604
 605     /**
 606      *
 607      */
 608     virtual void setDispatchState(const EventTarget */*target*/,
 609                                   unsigned short /*phase*/)
 610         {
 611         }
 612
 613     /**
 614      *
 615      */
 616     virtual bool isPropagationStopped()
 617         {
 618         return propagationStopped;
 619         }
 620
 621     /**
 622      *
 623      */
 624     virtual bool isImmediatePropagationStopped()
 625         {
 626         return immediatePropagationStopped;
 627         }
 628
 629     //##################
 630     //# Non-API methods
 631     //##################
 632
 633     /**
 634      *
 635      */
 636     CustomEvent() {}
 637
 638     /**
 639      *
 640      */
 641     CustomEvent(const CustomEvent &other) : Event(other)
 642         {
 643         propagationStopped          = other.propagationStopped;
 644         immediatePropagationStopped = other.immediatePropagationStopped;
 645         }
 646
 647     /**
 648      *
 649      */
 650     virtual ~CustomEvent() {}
 651
 652 protected:
 653
 654     bool propagationStopped;
 655     bool immediatePropagationStopped;
 656
 657
 658
 659 };
 660
 661
 662
 663
 664 /*#########################################################################
 665 ## UIEvent
 666 #########################################################################*/
 667
 668 /**
 669  *
 670  */
 671 class UIEvent : virtual public Event
 672 {
 673 public:
 674
 675     /**
 676      *  Note that the return type as listed in level3 events.idl is
 677      *  AbstractView, while in level3 views.idl it is called View
 678      */
 679     virtual views::View getView()
 680         { return view; }
 681
 682     /**
 683      *
 684      */
 685     virtual long getDetail()
 686         { return detail; }
 687
 688     /**
 689      *  Note that views.idl and events.idl disagree on the name of Views
 690      */
 691     virtual void initUIEvent(const DOMString &/*typeArg*/,
 692                              bool /*canBubbleArg*/,
 693                              bool /*cancelableArg*/,
 694                              const views::View */*viewArg*/,
 695                              long /*detailArg*/)
 696         {
 697         }
 698
 699     /**
 700      *  Note that views.idl and events.idl disagree on the name of Views
 701      */
 702     virtual void initUIEventNS(const DOMString &/*namespaceURI*/,
 703                                const DOMString &/*typeArg*/,
 704                                bool /*canBubbleArg*/,
 705                                bool /*cancelableArg*/,
 706                                const views::View */*viewArg*/,
 707                                long /*detailArg*/)
 708         {
 709         }
 710
 711     //##################
 712     //# Non-API methods
 713     //##################
 714
 715     /**
 716      *
 717      */
 718     UIEvent() {}
 719
 720     /**
 721      *
 722      */
 723     UIEvent(const UIEvent &other) : Event(other)
 724         {
 725         view   = other.view;
 726         detail = other.detail;
 727         }
 728
 729     /**
 730      *
 731      */
 732     virtual ~UIEvent() {}
 733
 734 protected:
 735
 736     views::View view;
 737     long detail;
 738 };
 739
 740
 741
 742
 743 /*#########################################################################
 744 ## TextEvent
 745 #########################################################################*/
 746
 747 /**
 748  *
 749  */
 750 class TextEvent : virtual public UIEvent
 751 {
 752 public:
 753
 754     /**
 755      *
 756      */
 757     virtual DOMString getData()
 758         { return data; }
 759
 760     /**
 761      *  Note that views.idl and events.idl disagree on the name of Views
 762      */
 763     virtual void initTextEvent(const DOMString &/*typeArg*/,
 764                                bool /*canBubbleArg*/,
 765                                bool /*cancelableArg*/,
 766                                const views::View */*viewArg*/,
 767                                long /*detailArg*/)
 768         {
 769         }
 770
 771     /**
 772      *
 773      */
 774     virtual void initTextEventNS(const DOMString &/*namespaceURI*/,
 775                                  const DOMString &/*typeArg*/,
 776                                  bool /*canBubbleArg*/,
 777                                  bool /*cancelableArg*/,
 778                                  const views::View */*viewArg*/,
 779                                  long /*detailArg*/)
 780         {
 781         }
 782
 783     //##################
 784     //# Non-API methods
 785     //##################
 786
 787     /**
 788      *
 789      */
 790     TextEvent() {}
 791
 792     /**
 793      *
 794      */
 795     TextEvent(const TextEvent &other) : Event(other), UIEvent(other)
 796         {
 797         data = other.data;
 798         }
 799
 800     /**
 801      *
 802      */
 803     virtual ~TextEvent() {}
 804
 805 protected:
 806
 807     DOMString data;
 808
 809 };
 810
 811
 812
 813
 814
 815
 816
 817
 818 /*#########################################################################
 819 ## MouseEvent
 820 #########################################################################*/
 821
 822 /**
 823  *
 824  */
 825 class MouseEvent : virtual public UIEvent
 826 {
 827 public:
 828
 829     /**
 830      *
 831      */
 832     virtual long getScreenX()
 833         { return screenX; }
 834
 835     /**
 836      *
 837      */
 838     virtual long getScreenY()
 839         { return screenY; }
 840
 841     /**
 842      *
 843      */
 844     virtual long getClientX()
 845         { return clientX; }
 846
 847     /**
 848      *
 849      */
 850     virtual long getClientY()
 851         { return clientY; }
 852
 853     /**
 854      *
 855      */
 856     virtual bool getCtrlKey()
 857         { return ctrlKey; }
 858
 859     /**
 860      *
 861      */
 862     virtual bool getShiftKey()
 863         { return shiftKey; }
 864
 865     /**
 866      *
 867      */
 868     virtual bool getAltKey()
 869         { return altKey; }
 870
 871     /**
 872      *
 873      */
 874     virtual bool getMetaKey()
 875         { return metaKey; }
 876
 877     /**
 878      *
 879      */
 880     virtual unsigned short getButton()
 881         { return button; }
 882
 883     /**
 884      *
 885      */
 886     virtual EventTarget *getRelatedTarget()
 887         { return relatedTarget; }
 888
 889
 890     /**
 891      *
 892      */
 893     virtual bool getModifierState()
 894         { return modifierState; }
 895
 896     /**
 897      *
 898      */
 899     virtual void initMouseEvent(const DOMString &/*typeArg*/,
 900                                 bool /*canBubbleArg*/,
 901                                 bool /*cancelableArg*/,
 902                                 const views::View */*viewArg*/,
 903                                 long /*detailArg*/,
 904                                 long /*screenXArg*/,
 905                                 long /*screenYArg*/,
 906                                 long /*clientXArg*/,
 907                                 long /*clientYArg*/,
 908                                 bool /*ctrlKeyArg*/,
 909                                 bool /*altKeyArg*/,
 910                                 bool /*shiftKeyArg*/,
 911                                 bool /*metaKeyArg*/,
 912                                 unsigned short /*buttonArg*/,
 913                                 const EventTarget */*relatedTargetArg*/)
 914         {
 915         }
 916
 917
 918     /**
 919      *
 920      */
 921     virtual void initMouseEventNS(const DOMString &/*namespaceURI*/,
 922                                   const DOMString &/*typeArg*/,
 923                                   bool /*canBubbleArg*/,
 924                                   bool /*cancelableArg*/,
 925                                   const views::View */*viewArg*/,
 926                                   long /*detailArg*/,
 927                                   long /*screenXArg*/,
 928                                   long /*screenYArg*/,
 929                                   long /*clientXArg*/,
 930                                   long /*clientYArg*/,
 931                                   unsigned short /*buttonArg*/,
 932                                   const EventTarget */*relatedTargetArg*/,
 933                                   const DOMString &/*modifiersList*/)
 934         {
 935         }
 936
 937     //##################
 938     //# Non-API methods
 939     //##################
 940
 941     /**
 942      *
 943      */
 944     MouseEvent() {}
 945
 946     /**
 947      *
 948      */
 949     MouseEvent(const MouseEvent &other) : Event(other), UIEvent(other)
 950         {
 951         screenX       = other.screenX;
 952         screenY       = other.screenY;
 953         clientX       = other.clientX;
 954         clientY       = other.clientY;
 955         ctrlKey       = other.ctrlKey;
 956         shiftKey      = other.shiftKey;
 957         altKey        = other.altKey;
 958         metaKey       = other.metaKey;
 959         button        = other.button;
 960         relatedTarget = other.relatedTarget;
 961         modifierState = other.modifierState;
 962         }
 963
 964     /**
 965      *
 966      */
 967     virtual ~MouseEvent() {}
 968
 969 protected:
 970
 971     long screenX;
 972     long screenY;
 973     long clientX;
 974     long clientY;
 975     bool ctrlKey;
 976     bool shiftKey;
 977     bool altKey;
 978     bool metaKey;
 979     unsigned short button;
 980     EventTarget *relatedTarget;
 981     bool modifierState;
 982
 983
 984 };
 985
 986
 987
 988
 989 /*#########################################################################
 990 ## KeyboardEvent
 991 #########################################################################*/
 992
 993 /**
 994  *
 995  */
 996 class KeyboardEvent : virtual public UIEvent
 997 {
 998 public:
 999
1000     typedef enum
1001         {
1002         DOM_KEY_LOCATION_STANDARD      = 0x00,
1003         DOM_KEY_LOCATION_LEFT          = 0x01,
1004         DOM_KEY_LOCATION_RIGHT         = 0x02,
1005         DOM_KEY_LOCATION_NUMPAD        = 0x03
1006         } KeyLocationCode;
1007
1008     /**
1009      *
1010      */
1011     virtual DOMString getKeyIdentifier()
1012         { return keyIdentifier; }
1013
1014     /**
1015      *
1016      */
1017     virtual unsigned long getKeyLocation()
1018         { return keyLocation; }
1019
1020     /**
1021      *
1022      */
1023     virtual bool getCtrlKey()
1024         { return ctrlKey; }
1025
1026     /**
1027      *
1028      */
1029     virtual bool getShiftKey()
1030         { return shiftKey; }
1031
1032     /**
1033      *
1034      */
1035     virtual bool getAltKey()
1036         { return altKey; }
1037
1038     /**
1039      *
1040      */
1041     virtual bool getMetaKey()
1042         { return metaKey; }
1043
1044     /**
1045      *
1046      */
1047     virtual bool getModifierState()
1048         { return modifierState; }
1049
1050     /**
1051      *
1052      */
1053     virtual void initKeyboardEvent(const DOMString &/*typeArg*/,
1054                                    bool /*canBubbleArg*/,
1055                                    bool /*cancelableArg*/,
1056                                    const views::View */*viewArg*/,
1057                                    const DOMString &/*keyIdentifier*/,
1058                                    unsigned long /*keyLocation*/,
1059                                    const DOMString /*modifiersList*/)
1060         {
1061         }
1062
1063
1064
1065     /**
1066      *
1067      */
1068     virtual void initKeyboardEventNS(const DOMString &/*namespaceURI*/,
1069                                      const DOMString &/*typeArg*/,
1070                                      bool /*canBubbleArg*/,
1071                                      bool /*cancelableArg*/,
1072                                      const views::View */*viewArg*/,
1073                                      const DOMString &/*keyIdentifier*/,
1074                                      unsigned long /*keyLocation*/,
1075                                      const DOMString /*modifiersList*/)
1076         {
1077         }
1078
1079     //##################
1080     //# Non-API methods
1081     //##################
1082
1083     /**
1084      *
1085      */
1086     KeyboardEvent() {}
1087
1088     /**
1089      *
1090      */
1091     KeyboardEvent(const KeyboardEvent &other) : Event(other), UIEvent(other)
1092         {
1093         keyIdentifier = other.keyIdentifier;
1094         keyLocation   = other.keyLocation;
1095         ctrlKey       = other.ctrlKey;
1096         shiftKey      = other.shiftKey;
1097         altKey        = other.altKey;
1098         metaKey       = other.metaKey;
1099         modifierState = other.modifierState;
1100         }
1101
1102     /**
1103      *
1104      */
1105     virtual ~KeyboardEvent() {}
1106
1107 protected:
1108
1109     DOMString keyIdentifier;
1110     unsigned long keyLocation;
1111     bool ctrlKey;
1112     bool shiftKey;
1113     bool altKey;
1114     bool metaKey;
1115     bool modifierState;
1116 };
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126 /*#########################################################################
1127 ## MutationEvent
1128 #########################################################################*/
1129
1130 /**
1131  *
1132  */
1133 class MutationEvent : virtual public Event
1134 {
1135 public:
1136
1137     /**
1138      * attrChangeType
1139      */
1140     typedef enum
1141         {
1142         MODIFICATION = 1,
1143         ADDITION     = 2,
1144         REMOVAL      = 3
1145         } AttrChangeType;
1146
1147     /**
1148      *
1149      */
1150     virtual NodePtr getRelatedNodePtr ()
1151         { return relatedNodePtr ; }
1152
1153     /**
1154      *
1155      */
1156     virtual DOMString getPrevValue()
1157         { return prevValue; }
1158
1159     /**
1160      *
1161      */
1162     virtual DOMString getNewValue()
1163         { return newValue; }
1164
1165     /**
1166      *
1167      */
1168     virtual DOMString getAttrName()
1169         { return attrName; }
1170
1171     /**
1172      *
1173      */
1174     virtual unsigned short getAttrChange()
1175         {
1176         return attrChange;
1177         }
1178
1179     /**
1180      *
1181      */
1182     virtual void initMutationEvent(const DOMString &/*typeArg*/,
1183                                    bool /*canBubbleArg*/,
1184                                    bool /*cancelableArg*/,
1185                                    const NodePtr   /*relatedNodeArg*/,
1186                                    const DOMString &/*prevValueArg*/,
1187                                    const DOMString &/*newValueArg*/,
1188                                    const DOMString &/*attrNameArg*/,
1189                                    unsigned short /*attrChangeArg*/)
1190         {
1191         }
1192
1193     /**
1194      *
1195      */
1196     virtual void initMutationEventNS(const DOMString &/*namespaceURI*/,
1197                                      const DOMString &/*typeArg*/,
1198                                      bool /*canBubbleArg*/,
1199                                      bool /*cancelableArg*/,
1200                                      const NodePtr   /*relatedNodeArg*/,
1201                                      const DOMString &/*prevValueArg*/,
1202                                      const DOMString &/*newValueArg*/,
1203                                      const DOMString &/*attrNameArg*/,
1204                                      unsigned short /*attrChangeArg*/)
1205         {
1206         }
1207
1208
1209     //##################
1210     //# Non-API methods
1211     //##################
1212
1213     /**
1214      *
1215      */
1216     MutationEvent()
1217         {
1218         relatedNodePtr  = NULL;
1219         }
1220
1221     /**
1222      *
1223      */
1224     MutationEvent(const MutationEvent &other) : Event(other)
1225         {
1226         relatedNodePtr  = other.relatedNodePtr ;
1227         prevValue   = other.prevValue;
1228         newValue    = other.newValue;
1229         attrName    = other.attrName;
1230         attrChange  = other.attrChange;
1231         }
1232
1233     /**
1234      *
1235      */
1236     virtual ~MutationEvent() {}
1237
1238 protected:
1239
1240     NodePtr   relatedNodePtr ;
1241     DOMString prevValue;
1242     DOMString newValue;
1243     DOMString attrName;
1244     unsigned short attrChange;
1245
1246 };
1247
1248
1249
1250
1251 /*#########################################################################
1252 ## MutationNameEvent
1253 #########################################################################*/
1254
1255 /**
1256  *
1257  */
1258 class MutationNameEvent : virtual public MutationEvent
1259 {
1260 public:
1261
1262     /**
1263      *
1264      */
1265     virtual DOMString getPrevNamespaceURI()
1266         { return prevNamespaceURI; }
1267
1268     /**
1269      *
1270      */
1271     virtual DOMString getPrevNodeName()
1272         { return prevNodeName; }
1273
1274     /**
1275      *
1276      */
1277     virtual void initMutationNameEvent(const DOMString &/*typeArg*/,
1278                                        bool /*canBubbleArg*/,
1279                                        bool /*cancelableArg*/,
1280                                        const NodePtr   /*relatedNodeArg*/,
1281                                        const DOMString &/*prevNamespaceURIArg*/,
1282                                        const DOMString &/*prevNodeNameArg*/)
1283         {
1284         }
1285
1286
1287     /**
1288      *
1289      */
1290     virtual void initMutationNameEventNS(const DOMString &/*namespaceURI*/,
1291                                          const DOMString &/*typeArg*/,
1292                                          bool /*canBubbleArg*/,
1293                                          bool /*cancelableArg*/,
1294                                          const NodePtr   /*relatedNodeArg*/,
1295                                          const DOMString &/*prevNamespaceURIArg*/,
1296                                          const DOMString &/*prevNodeNameArg*/)
1297         {
1298         }
1299
1300
1301
1302     //##################
1303     //# Non-API methods
1304     //##################
1305
1306     /**
1307      *
1308      */
1309     MutationNameEvent() {}
1310
1311
1312     /**
1313      *
1314      */
1315     MutationNameEvent(const MutationNameEvent &other)
1316                           : Event(other), MutationEvent(other)
1317         {
1318         prevNamespaceURI  = other.prevNamespaceURI;
1319         prevNodeName      = other.prevNodeName;
1320         }
1321
1322
1323     /**
1324      *
1325      */
1326     virtual ~MutationNameEvent() {}
1327
1328 protected:
1329
1330     DOMString prevNamespaceURI;
1331     DOMString prevNodeName;
1332
1333
1334 };
1335
1336
1337
1338
1339
1340
1341 }  //namespace events
1342 }  //namespace dom
1343 }  //namespace w3c
1344 }  //namespace org
1345
1346 #endif   /* __EVENTS_H__ */
1347
1348 /*#########################################################################
1349 ## E N D    O F    F I L E
1350 #########################################################################*/
1351