View Javadoc
1   /*
2    * Copyright (c) 2002-2026 Gargoyle Software Inc.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * https://www.apache.org/licenses/LICENSE-2.0
8    *
9    * Unless required by applicable law or agreed to in writing, software
10   * distributed under the License is distributed on an "AS IS" BASIS,
11   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   * See the License for the specific language governing permissions and
13   * limitations under the License.
14   */
15  package org.htmlunit.javascript.host.svg;
16  
17  import static org.htmlunit.javascript.configuration.SupportedBrowser.CHROME;
18  import static org.htmlunit.javascript.configuration.SupportedBrowser.EDGE;
19  import static org.htmlunit.javascript.configuration.SupportedBrowser.FF;
20  import static org.htmlunit.javascript.configuration.SupportedBrowser.FF_ESR;
21  
22  import org.htmlunit.corejs.javascript.Function;
23  import org.htmlunit.javascript.JavaScriptEngine;
24  import org.htmlunit.javascript.configuration.JsxClass;
25  import org.htmlunit.javascript.configuration.JsxConstructor;
26  import org.htmlunit.javascript.configuration.JsxGetter;
27  import org.htmlunit.javascript.configuration.JsxSetter;
28  import org.htmlunit.javascript.host.Element;
29  import org.htmlunit.javascript.host.css.CSSStyleDeclaration;
30  import org.htmlunit.javascript.host.event.Event;
31  import org.htmlunit.javascript.host.event.MouseEvent;
32  import org.htmlunit.svg.SvgElement;
33  
34  /**
35   * JavaScript host object for {@code SVGElement}.
36   *
37   * @author Ahmed Ashour
38   * @author Ronald Brill
39   *
40   * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/SVGElement">MDN Documentation</a>
41   */
42  @JsxClass(domClass = SvgElement.class)
43  public class SVGElement extends Element {
44  
45      /**
46       * Creates an instance of this object.
47       */
48      @Override
49      @JsxConstructor
50      public void jsConstructor() {
51          throw JavaScriptEngine.typeErrorIllegalConstructor();
52      }
53  
54      /**
55       * Returns the bounding box, in current user space, of the geometry of all contained graphics elements.
56       *
57       * @return the bounding box
58       */
59      protected SVGRect getBBox() {
60          final SVGRect rect = new SVGRect();
61          rect.setParentScope(getParentScope());
62          rect.setPrototype(getPrototype(rect.getClass()));
63          return rect;
64      }
65  
66      /**
67       * Returns the {@code nonce} property.
68       * @return the {@code nonce} property
69       */
70      @JsxGetter
71      public String getNonce() {
72          return getDomNodeOrDie().getNonce();
73      }
74  
75      /**
76       * Sets the {@code nonce} property; the nonce attribute is not changed.
77       * @param nonce the {@code nonce} property
78       */
79      @JsxSetter
80      public void setNonce(final String nonce) {
81          getDomNodeOrDie().setNonce(nonce);
82      }
83  
84      /**
85       * {@inheritDoc}
86       */
87      @Override
88      @JsxGetter
89      public CSSStyleDeclaration getStyle() {
90          return super.getStyle();
91      }
92  
93      /**
94       * {@inheritDoc}
95       */
96      @Override
97      @JsxSetter
98      public void setStyle(final String style) {
99          super.setStyle(style);
100     }
101 
102     /**
103      * Returns the {@code onfocus} event handler.
104      *
105      * @return the {@code onfocus} event handler
106      */
107     @JsxGetter
108     public Function getOnfocus() {
109         return getEventHandler(Event.TYPE_FOCUS);
110     }
111 
112     /**
113      * Sets the {@code onfocus} event handler.
114      *
115      * @param focus the {@code onfocus} event handler
116      */
117     @JsxSetter
118     public void setOnfocus(final Object focus) {
119         setEventHandler(Event.TYPE_FOCUS, focus);
120     }
121 
122     /**
123      * Returns the {@code ondragend} event handler.
124      *
125      * @return the {@code ondragend} event handler
126      */
127     @JsxGetter
128     public Function getOndragend() {
129         return getEventHandler(Event.TYPE_DRAGEND);
130     }
131 
132     /**
133      * Sets the {@code ondragend} event handler.
134      *
135      * @param dragend the {@code ondragend} event handler
136      */
137     @JsxSetter
138     public void setOndragend(final Object dragend) {
139         setEventHandler(Event.TYPE_DRAGEND, dragend);
140     }
141 
142     /**
143      * Returns the {@code oninvalid} event handler.
144      *
145      * @return the {@code oninvalid} event handler
146      */
147     @JsxGetter
148     public Function getOninvalid() {
149         return getEventHandler(Event.TYPE_INVALID);
150     }
151 
152     /**
153      * Sets the {@code oninvalid} event handler.
154      *
155      * @param invalid the {@code oninvalid} event handler
156      */
157     @JsxSetter
158     public void setOninvalid(final Object invalid) {
159         setEventHandler(Event.TYPE_INVALID, invalid);
160     }
161 
162     /**
163      * Returns the {@code onpointercancel} event handler for this element.
164      *
165      * @return the {@code onpointercancel} event handler for this element
166      */
167     @JsxGetter({CHROME, EDGE})
168     public Function getOnpointercancel() {
169         return getEventHandler(Event.TYPE_POINTERCANCEL);
170     }
171 
172     /**
173      * Sets the {@code onpointercancel} event handler.
174      *
175      * @param pointercancel the {@code onpointercancel} event handler
176      */
177     @JsxSetter({CHROME, EDGE})
178     public void setOnpointercancel(final Object pointercancel) {
179         setEventHandler(Event.TYPE_POINTERCANCEL, pointercancel);
180     }
181 
182     /**
183      * Returns the {@code onpointerout} event handler for this element.
184      *
185      * @return the {@code onpointerout} event handler for this element
186      */
187     @JsxGetter({CHROME, EDGE})
188     public Function getOnpointerout() {
189         return getEventHandler(Event.TYPE_POINTEROUT);
190     }
191 
192     /**
193      * Sets the {@code onpointerout} event handler.
194      *
195      * @param pointerout the {@code onpointerout} event handler
196      */
197     @JsxSetter({CHROME, EDGE})
198     public void setOnpointerout(final Object pointerout) {
199         setEventHandler(Event.TYPE_POINTEROUT, pointerout);
200     }
201 
202     /**
203      * Returns the {@code onratechange} event handler.
204      *
205      * @return the {@code onratechange} event handler
206      */
207     @JsxGetter
208     public Function getOnratechange() {
209         return getEventHandler(Event.TYPE_RATECHANGE);
210     }
211 
212     /**
213      * Sets the {@code onratechange} event handler.
214      *
215      * @param ratechange the {@code onratechange} event handler
216      */
217     @JsxSetter
218     public void setOnratechange(final Object ratechange) {
219         setEventHandler(Event.TYPE_RATECHANGE, ratechange);
220     }
221 
222     /**
223      * Returns the {@code onresize} event handler.
224      *
225      * @return the {@code onresize} event handler
226      */
227     @JsxGetter
228     public Function getOnresize() {
229         return getEventHandler(Event.TYPE_RESIZE);
230     }
231 
232     /**
233      * Sets the {@code onresize} event handler.
234      *
235      * @param resize the {@code onresize} event handler
236      */
237     @JsxSetter
238     public void setOnresize(final Object resize) {
239         setEventHandler(Event.TYPE_RESIZE, resize);
240     }
241 
242     /**
243      * Returns the {@code oncanplaythrough} event handler.
244      *
245      * @return the {@code oncanplaythrough} event handler
246      */
247     @JsxGetter
248     public Function getOncanplaythrough() {
249         return getEventHandler(Event.TYPE_CANPLAYTHROUGH);
250     }
251 
252     /**
253      * Sets the {@code oncanplaythrough} event handler.
254      *
255      * @param canplaythrough the {@code oncanplaythrough} event handler
256      */
257     @JsxSetter
258     public void setOncanplaythrough(final Object canplaythrough) {
259         setEventHandler(Event.TYPE_CANPLAYTHROUGH, canplaythrough);
260     }
261 
262     /**
263      * Returns the {@code oncancel} event handler.
264      *
265      * @return the {@code oncancel} event handler
266      */
267     @JsxGetter({CHROME, EDGE})
268     public Function getOncancel() {
269         return getEventHandler(Event.TYPE_CANCEL);
270     }
271 
272     /**
273      * Sets the {@code oncancel} event handler.
274      *
275      * @param cancel the {@code oncancel} event handler
276      */
277     @JsxSetter({CHROME, EDGE})
278     public void setOncancel(final Object cancel) {
279         setEventHandler(Event.TYPE_CANCEL, cancel);
280     }
281 
282     /**
283      * Returns the {@code onpointerenter} event handler.
284      *
285      * @return the {@code onpointerenter} event handler
286      */
287     @JsxGetter({CHROME, EDGE})
288     public Function getOnpointerenter() {
289         return getEventHandler(Event.TYPE_POINTERENTER);
290     }
291 
292     /**
293      * Sets the {@code onpointerenter} event handler.
294      *
295      * @param pointerenter the {@code onpointerenter} event handler
296      */
297     @JsxSetter({CHROME, EDGE})
298     public void setOnpointerenter(final Object pointerenter) {
299         setEventHandler(Event.TYPE_POINTERENTER, pointerenter);
300     }
301 
302     /**
303      * Returns the {@code onselect} event handler.
304      *
305      * @return the {@code onselect} event handler
306      */
307     @JsxGetter
308     public Function getOnselect() {
309         return getEventHandler(Event.TYPE_SELECT);
310     }
311 
312     /**
313      * Sets the {@code onselect} event handler.
314      *
315      * @param select the {@code onselect} event handler
316      */
317     @JsxSetter
318     public void setOnselect(final Object select) {
319         setEventHandler(Event.TYPE_SELECT, select);
320     }
321 
322     /**
323      * Returns the {@code onselectstart} event handler for this element.
324      *
325      * @return the {@code onselectstart} event handler for this element
326      */
327     @JsxGetter
328     public Function getOnselectstart() {
329         return getEventHandler(Event.TYPE_SELECTSTART);
330     }
331 
332     /**
333      * Sets the {@code onselectstart} event handler for this element.
334      *
335      * @param onselectstart the {@code onselectstart} event handler for this element
336      */
337     @JsxSetter
338     public void setOnselectstart(final Object onselectstart) {
339         setEventHandler(Event.TYPE_SELECTSTART, onselectstart);
340     }
341 
342     /**
343      * Returns the {@code onselectionchange} event handler for this element.
344      *
345      * @return the {@code onselectionchange} event handler for this element
346      */
347     @JsxGetter
348     public Function getOnselectionchange() {
349         return getEventHandler(Event.TYPE_SELECTIONCHANGE);
350     }
351 
352     /**
353      * Sets the {@code onselectionchange} event handler for this element.
354      *
355      * @param onselectionchange the {@code onselectionchange} event handler for this element
356      */
357     @JsxSetter
358     public void setOnselectionchange(final Object onselectionchange) {
359         setEventHandler(Event.TYPE_SELECTIONCHANGE, onselectionchange);
360     }
361 
362     /**
363      * Returns the {@code onauxclick} event handler.
364      *
365      * @return the {@code onauxclick} event handler
366      */
367     @JsxGetter({CHROME, EDGE})
368     public Function getOnauxclick() {
369         return getEventHandler(Event.TYPE_AUXCLICK);
370     }
371 
372     /**
373      * Sets the {@code onauxclick} event handler.
374      *
375      * @param auxclick the {@code onauxclick} event handler
376      */
377     @JsxSetter({CHROME, EDGE})
378     public void setOnauxclick(final Object auxclick) {
379         setEventHandler(Event.TYPE_AUXCLICK, auxclick);
380     }
381 
382     /**
383      * Returns the {@code onpause} event handler.
384      *
385      * @return the {@code onpause} event handler
386      */
387     @JsxGetter
388     public Function getOnpause() {
389         return getEventHandler(Event.TYPE_PAUSE);
390     }
391 
392     /**
393      * Sets the {@code onpause} event handler.
394      *
395      * @param pause the {@code onpause} event handler
396      */
397     @JsxSetter
398     public void setOnpause(final Object pause) {
399         setEventHandler(Event.TYPE_PAUSE, pause);
400     }
401 
402     /**
403      * Returns the {@code onloadstart} event handler.
404      *
405      * @return the {@code onloadstart} event handler
406      */
407     @JsxGetter
408     public Function getOnloadstart() {
409         return getEventHandler(Event.TYPE_LOAD_START);
410     }
411 
412     /**
413      * Sets the {@code onloadstart} event handler.
414      *
415      * @param loadstart the {@code onloadstart} event handler
416      */
417     @JsxSetter
418     public void setOnloadstart(final Object loadstart) {
419         setEventHandler(Event.TYPE_LOAD_START, loadstart);
420     }
421 
422     /**
423      * Returns the {@code onprogress} event handler.
424      *
425      * @return the {@code onprogress} event handler
426      */
427     @JsxGetter
428     public Function getOnprogress() {
429         return getEventHandler(Event.TYPE_PROGRESS);
430     }
431 
432     /**
433      * Sets the {@code onprogress} event handler.
434      *
435      * @param progress the {@code onprogress} event handler
436      */
437     @JsxSetter
438     public void setOnprogress(final Object progress) {
439         setEventHandler(Event.TYPE_PROGRESS, progress);
440     }
441 
442     /**
443      * Returns the {@code onpointerup} event handler for this element.
444      *
445      * @return the {@code onpointerup} event handler for this element
446      */
447     @JsxGetter({CHROME, EDGE})
448     public Function getOnpointerup() {
449         return getEventHandler(Event.TYPE_POINTERUP);
450     }
451 
452     /**
453      * Sets the {@code onpointerup} event handler.
454      *
455      * @param pointerup the {@code onpointerup} event handler
456      */
457     @JsxSetter({CHROME, EDGE})
458     public void setOnpointerup(final Object pointerup) {
459         setEventHandler(Event.TYPE_POINTERUP, pointerup);
460     }
461 
462     /**
463      * Returns the {@code onscroll} event handler.
464      *
465      * @return the {@code onscroll} event handler
466      */
467     @JsxGetter
468     public Function getOnscroll() {
469         return getEventHandler(Event.TYPE_SCROLL);
470     }
471 
472     /**
473      * Sets the {@code onscroll} event handler.
474      *
475      * @param scroll the {@code onscroll} event handler
476      */
477     @JsxSetter
478     public void setOnscroll(final Object scroll) {
479         setEventHandler(Event.TYPE_SCROLL, scroll);
480     }
481 
482     /**
483      * Returns the {@code onscrollend} event handler.
484      *
485      * @return the {@code onscrollend} event handler
486      */
487     @JsxGetter
488     public Function getOnscrollend() {
489         return getEventHandler(Event.TYPE_SCROLLEND);
490     }
491 
492     /**
493      * Sets the {@code onscrollend} event handler.
494      *
495      * @param scrollend the {@code onscrollend} event handler
496      */
497     @JsxSetter
498     public void setOnscrollend(final Object scrollend) {
499         setEventHandler(Event.TYPE_SCROLLEND, scrollend);
500     }
501 
502     /**
503      * Returns the {@code onkeydown} event handler.
504      *
505      * @return the {@code onkeydown} event handler
506      */
507     @JsxGetter
508     public Function getOnkeydown() {
509         return getEventHandler(Event.TYPE_KEY_DOWN);
510     }
511 
512     /**
513      * Sets the {@code onkeydown} event handler.
514      *
515      * @param keydown the {@code onkeydown} event handler
516      */
517     @JsxSetter
518     public void setOnkeydown(final Object keydown) {
519         setEventHandler(Event.TYPE_KEY_DOWN, keydown);
520     }
521 
522     /**
523      * Returns the {@code onpointerleave} event handler.
524      *
525      * @return the {@code onpointerleave} event handler
526      */
527     @JsxGetter({CHROME, EDGE})
528     public Function getOnpointerleave() {
529         return getEventHandler(Event.TYPE_POINTERLEAVE);
530     }
531 
532     /**
533      * Sets the {@code onpointerleave} event handler.
534      *
535      * @param pointerleave the {@code onpointerleave} event handler
536      */
537     @JsxSetter({CHROME, EDGE})
538     public void setOnpointerleave(final Object pointerleave) {
539         setEventHandler(Event.TYPE_POINTERLEAVE, pointerleave);
540     }
541 
542     /**
543      * Returns the {@code onclick} event handler.
544      *
545      * @return the {@code onclick} event handler
546      */
547     @JsxGetter
548     public Function getOnclick() {
549         return getEventHandler(MouseEvent.TYPE_CLICK);
550     }
551 
552     /**
553      * Sets the {@code onclick} event handler.
554      *
555      * @param click the {@code onclick} event handler
556      */
557     @JsxSetter
558     public void setOnclick(final Object click) {
559         setEventHandler(MouseEvent.TYPE_CLICK, click);
560     }
561 
562     /**
563      * Returns the {@code onkeyup} event handler.
564      *
565      * @return the {@code onkeyup} event handler
566      */
567     @JsxGetter
568     public Function getOnkeyup() {
569         return getEventHandler(Event.TYPE_KEY_UP);
570     }
571 
572     /**
573      * Sets the {@code onkeyup} event handler.
574      *
575      * @param keyup the {@code onkeyup} event handler
576      */
577     @JsxSetter
578     public void setOnkeyup(final Object keyup) {
579         setEventHandler(Event.TYPE_KEY_UP, keyup);
580     }
581 
582     /**
583      * Returns the {@code onchange} event handler.
584      *
585      * @return the {@code onchange} event handler
586      */
587     @JsxGetter
588     public Function getOnchange() {
589         return getEventHandler(Event.TYPE_CHANGE);
590     }
591 
592     /**
593      * Sets the {@code onchange} event handler.
594      *
595      * @param change the {@code onchange} event handler
596      */
597     @JsxSetter
598     public void setOnchange(final Object change) {
599         setEventHandler(Event.TYPE_CHANGE, change);
600     }
601 
602     /**
603      * Returns the {@code onreset} event handler.
604      *
605      * @return the {@code onreset} event handler
606      */
607     @JsxGetter
608     public Function getOnreset() {
609         return getEventHandler(Event.TYPE_RESET);
610     }
611 
612     /**
613      * Sets the {@code onreset} event handler.
614      *
615      * @param reset the {@code onreset} event handler
616      */
617     @JsxSetter
618     public void setOnreset(final Object reset) {
619         setEventHandler(Event.TYPE_RESET, reset);
620     }
621 
622     /**
623      * Returns the {@code onkeypress} event handler.
624      *
625      * @return the {@code onkeypress} event handler
626      */
627     @JsxGetter
628     public Function getOnkeypress() {
629         return getEventHandler(Event.TYPE_KEY_PRESS);
630     }
631 
632     /**
633      * Sets the {@code onkeypress} event handler.
634      *
635      * @param keypress the {@code onkeypress} event handler
636      */
637     @JsxSetter
638     public void setOnkeypress(final Object keypress) {
639         setEventHandler(Event.TYPE_KEY_PRESS, keypress);
640     }
641 
642     /**
643      * Returns the {@code ontimeupdate} event handler.
644      *
645      * @return the {@code ontimeupdate} event handler
646      */
647     @JsxGetter
648     public Function getOntimeupdate() {
649         return getEventHandler(Event.TYPE_TIMEUPDATE);
650     }
651 
652     /**
653      * Sets the {@code ontimeupdate} event handler.
654      *
655      * @param timeupdate the {@code ontimeupdate} event handler
656      */
657     @JsxSetter
658     public void setOntimeupdate(final Object timeupdate) {
659         setEventHandler(Event.TYPE_TIMEUPDATE, timeupdate);
660     }
661 
662     /**
663      * Returns the {@code ondblclick} event handler.
664      *
665      * @return the {@code ondblclick} event handler
666      */
667     @JsxGetter
668     public Function getOndblclick() {
669         return getEventHandler(MouseEvent.TYPE_DBL_CLICK);
670     }
671 
672     /**
673      * Sets the {@code ondblclick} event handler.
674      *
675      * @param dblclick the {@code ondblclick} event handler
676      */
677     @JsxSetter
678     public void setOndblclick(final Object dblclick) {
679         setEventHandler(MouseEvent.TYPE_DBL_CLICK, dblclick);
680     }
681 
682     /**
683      * Returns the {@code ondrag} event handler.
684      *
685      * @return the {@code ondrag} event handler
686      */
687     @JsxGetter
688     public Function getOndrag() {
689         return getEventHandler(Event.TYPE_DRAG);
690     }
691 
692     /**
693      * Sets the {@code ondrag} event handler.
694      *
695      * @param drag the {@code ondrag} event handler
696      */
697     @JsxSetter
698     public void setOndrag(final Object drag) {
699         setEventHandler(Event.TYPE_DRAG, drag);
700     }
701 
702     /**
703      * Returns the {@code onseeked} event handler.
704      *
705      * @return the {@code onseeked} event handler
706      */
707     @JsxGetter
708     public Function getOnseeked() {
709         return getEventHandler(Event.TYPE_SEEKED);
710     }
711 
712     /**
713      * Sets the {@code onseeked} event handler.
714      *
715      * @param seeked the {@code onseeked} event handler
716      */
717     @JsxSetter
718     public void setOnseeked(final Object seeked) {
719         setEventHandler(Event.TYPE_SEEKED, seeked);
720     }
721 
722     /**
723      * Returns the {@code onabort} event handler.
724      *
725      * @return the {@code onabort} event handler
726      */
727     @JsxGetter
728     public Function getOnabort() {
729         return getEventHandler(Event.TYPE_ABORT);
730     }
731 
732     /**
733      * Sets the {@code onabort} event handler.
734      *
735      * @param abort the {@code onabort} event handler
736      */
737     @JsxSetter
738     public void setOnabort(final Object abort) {
739         setEventHandler(Event.TYPE_ABORT, abort);
740     }
741 
742     /**
743      * Returns the {@code onloadedmetadata} event handler.
744      *
745      * @return the {@code onloadedmetadata} event handler
746      */
747     @JsxGetter
748     public Function getOnloadedmetadata() {
749         return getEventHandler(Event.TYPE_LOADEDMETADATA);
750     }
751 
752     /**
753      * Sets the {@code onloadedmetadata} event handler.
754      *
755      * @param loadedmetadata the {@code onloadedmetadata} event handler
756      */
757     @JsxSetter
758     public void setOnloadedmetadata(final Object loadedmetadata) {
759         setEventHandler(Event.TYPE_LOADEDMETADATA, loadedmetadata);
760     }
761 
762     /**
763      * Returns the {@code ontoggle} event handler.
764      *
765      * @return the {@code ontoggle} event handler
766      */
767     @JsxGetter({CHROME, EDGE})
768     public Function getOntoggle() {
769         return getEventHandler(Event.TYPE_TOGGLE);
770     }
771 
772     /**
773      * Sets the {@code ontoggle} event handler.
774      *
775      * @param toggle the {@code ontoggle} event handler
776      */
777     @JsxSetter({CHROME, EDGE})
778     public void setOntoggle(final Object toggle) {
779         setEventHandler(Event.TYPE_TOGGLE, toggle);
780     }
781 
782     /**
783      * Returns the {@code onplay} event handler.
784      *
785      * @return the {@code onplay} event handler
786      */
787     @JsxGetter
788     public Function getOnplay() {
789         return getEventHandler(Event.TYPE_PLAY);
790     }
791 
792     /**
793      * Sets the {@code onplay} event handler.
794      *
795      * @param play the {@code onplay} event handler
796      */
797     @JsxSetter
798     public void setOnplay(final Object play) {
799         setEventHandler(Event.TYPE_PLAY, play);
800     }
801 
802     /**
803      * Returns the {@code oncontextmenu} event handler.
804      *
805      * @return the {@code oncontextmenu} event handler
806      */
807     @JsxGetter
808     public Function getOncontextmenu() {
809         return getEventHandler(MouseEvent.TYPE_CONTEXT_MENU);
810     }
811 
812     /**
813      * Sets the {@code oncontextmenu} event handler.
814      *
815      * @param contextmenu the {@code oncontextmenu} event handler
816      */
817     @JsxSetter
818     public void setOncontextmenu(final Object contextmenu) {
819         setEventHandler(MouseEvent.TYPE_CONTEXT_MENU, contextmenu);
820     }
821 
822     /**
823      * Returns the {@code onmousemove} event handler.
824      *
825      * @return the {@code onmousemove} event handler
826      */
827     @JsxGetter
828     public Function getOnmousemove() {
829         return getEventHandler(MouseEvent.TYPE_MOUSE_MOVE);
830     }
831 
832     /**
833      * Sets the {@code onmousemove} event handler.
834      *
835      * @param mousemove the {@code onmousemove} event handler
836      */
837     @JsxSetter
838     public void setOnmousemove(final Object mousemove) {
839         setEventHandler(MouseEvent.TYPE_MOUSE_MOVE, mousemove);
840     }
841 
842     /**
843      * Returns the {@code onerror} event handler.
844      *
845      * @return the {@code onerror} event handler
846      */
847     @JsxGetter
848     public Function getOnerror() {
849         return getEventHandler(Event.TYPE_ERROR);
850     }
851 
852     /**
853      * Sets the {@code onerror} event handler.
854      *
855      * @param error the {@code onerror} event handler
856      */
857     @JsxSetter
858     public void setOnerror(final Object error) {
859         setEventHandler(Event.TYPE_ERROR, error);
860     }
861 
862     /**
863      * Returns the {@code onmouseup} event handler.
864      *
865      * @return the {@code onmouseup} event handler
866      */
867     @JsxGetter
868     public Function getOnmouseup() {
869         return getEventHandler(MouseEvent.TYPE_MOUSE_UP);
870     }
871 
872     /**
873      * Sets the {@code onmouseup} event handler.
874      *
875      * @param mouseup the {@code onmouseup} event handler
876      */
877     @JsxSetter
878     public void setOnmouseup(final Object mouseup) {
879         setEventHandler(MouseEvent.TYPE_MOUSE_UP, mouseup);
880     }
881 
882     /**
883      * Returns the {@code ondragover} event handler.
884      *
885      * @return the {@code ondragover} event handler
886      */
887     @JsxGetter
888     public Function getOndragover() {
889         return getEventHandler(Event.TYPE_DRAGOVER);
890     }
891 
892     /**
893      * Sets the {@code ondragover} event handler.
894      *
895      * @param dragover the {@code ondragover} event handler
896      */
897     @JsxSetter
898     public void setOndragover(final Object dragover) {
899         setEventHandler(Event.TYPE_DRAGOVER, dragover);
900     }
901 
902     /**
903      * Returns the {@code onpointermove} event handler for this element.
904      *
905      * @return the {@code onpointermove} event handler for this element
906      */
907     @JsxGetter({CHROME, EDGE})
908     public Function getOnpointermove() {
909         return getEventHandler(Event.TYPE_POINTERMOVE);
910     }
911 
912     /**
913      * Sets the {@code onpointermove} event handler.
914      *
915      * @param pointermove the {@code onpointermove} event handler
916      */
917     @JsxSetter({CHROME, EDGE})
918     public void setOnpointermove(final Object pointermove) {
919         setEventHandler(Event.TYPE_POINTERMOVE, pointermove);
920     }
921 
922     /**
923      * Returns the {@code oncut} event handler.
924      *
925      * @return the {@code oncut} event handler
926      */
927     @JsxGetter
928     public Function getOncut() {
929         return getEventHandler(Event.TYPE_CUT);
930     }
931 
932     /**
933      * Sets the {@code oncut} event handler.
934      *
935      * @param cut the {@code oncut} event handler
936      */
937     @JsxSetter
938     public void setOncut(final Object cut) {
939         setEventHandler(Event.TYPE_CUT, cut);
940     }
941 
942     /**
943      * Returns the {@code onmouseover} event handler.
944      *
945      * @return the {@code onmouseover} event handler
946      */
947     @JsxGetter
948     public Function getOnmouseover() {
949         return getEventHandler(MouseEvent.TYPE_MOUSE_OVER);
950     }
951 
952     /**
953      * Sets the {@code onmouseover} event handler.
954      *
955      * @param mouseover the {@code onmouseover} event handler
956      */
957     @JsxSetter
958     public void setOnmouseover(final Object mouseover) {
959         setEventHandler(MouseEvent.TYPE_MOUSE_OVER, mouseover);
960     }
961 
962     /**
963      * Returns the {@code oninput} event handler.
964      *
965      * @return the {@code oninput} event handler
966      */
967     @JsxGetter
968     public Function getOninput() {
969         return getEventHandler(Event.TYPE_INPUT);
970     }
971 
972     /**
973      * Sets the {@code oninput} event handler.
974      *
975      * @param input the {@code oninput} event handler
976      */
977     @JsxSetter
978     public void setOninput(final Object input) {
979         setEventHandler(Event.TYPE_INPUT, input);
980     }
981 
982     /**
983      * Returns the {@code onlostpointercapture} event handler for this element.
984      *
985      * @return the {@code onlostpointercapture} event handler for this element
986      */
987     @JsxGetter({CHROME, EDGE})
988     public Function getOnlostpointercapture() {
989         return getEventHandler(Event.TYPE_LOSTPOINTERCAPTURE);
990     }
991 
992     /**
993      * Sets the {@code onlostpointercapture} event handler.
994      *
995      * @param lostpointercapture the {@code onlostpointercapture} event handler
996      */
997     @JsxSetter({CHROME, EDGE})
998     public void setOnlostpointercapture(final Object lostpointercapture) {
999         setEventHandler(Event.TYPE_LOSTPOINTERCAPTURE, lostpointercapture);
1000     }
1001 
1002     /**
1003      * Returns the {@code onstalled} event handler.
1004      *
1005      * @return the {@code onstalled} event handler
1006      */
1007     @JsxGetter
1008     public Function getOnstalled() {
1009         return getEventHandler(Event.TYPE_STALLED);
1010     }
1011 
1012     /**
1013      * Sets the {@code onstalled} event handler.
1014      *
1015      * @param stalled the {@code onstalled} event handler
1016      */
1017     @JsxSetter
1018     public void setOnstalled(final Object stalled) {
1019         setEventHandler(Event.TYPE_STALLED, stalled);
1020     }
1021 
1022     /**
1023      * Returns the {@code onpointerover} event handler for this element.
1024      *
1025      * @return the {@code onpointerover} event handler for this element
1026      */
1027     @JsxGetter({CHROME, EDGE})
1028     public Function getOnpointerover() {
1029         return getEventHandler(Event.TYPE_POINTEROVER);
1030     }
1031 
1032     /**
1033      * Sets the {@code onpointerover} event handler.
1034      *
1035      * @param pointerover the {@code onpointerover} event handler
1036      */
1037     @JsxSetter({CHROME, EDGE})
1038     public void setOnpointerover(final Object pointerover) {
1039         setEventHandler(Event.TYPE_POINTEROVER, pointerover);
1040     }
1041 
1042     /**
1043      * Returns the {@code onclose} event handler.
1044      *
1045      * @return the {@code onclose} event handler
1046      */
1047     @JsxGetter
1048     public Function getOnclose() {
1049         return getEventHandler(Event.TYPE_CLOSE);
1050     }
1051 
1052     /**
1053      * Sets the {@code onclose} event handler.
1054      *
1055      * @param close the {@code onclose} event handler
1056      */
1057     @JsxSetter
1058     public void setOnclose(final Object close) {
1059         setEventHandler(Event.TYPE_CLOSE, close);
1060     }
1061 
1062     /**
1063      * Returns the {@code ondragenter} event handler.
1064      *
1065      * @return the {@code ondragenter} event handler
1066      */
1067     @JsxGetter
1068     public Function getOndragenter() {
1069         return getEventHandler(Event.TYPE_DRAGENTER);
1070     }
1071 
1072     /**
1073      * Sets the {@code ondragenter} event handler.
1074      *
1075      * @param dragenter the {@code ondragenter} event handler
1076      */
1077     @JsxSetter
1078     public void setOndragenter(final Object dragenter) {
1079         setEventHandler(Event.TYPE_DRAGENTER, dragenter);
1080     }
1081 
1082     /**
1083      * Returns the {@code onmozfullscreenerror} event handler.
1084      *
1085      * @return the {@code onmozfullscreenerror} event handler
1086      */
1087     @JsxGetter({FF, FF_ESR})
1088     public Function getOnmozfullscreenerror() {
1089         return getEventHandler(Event.TYPE_MOZFULLSCREENERROR);
1090     }
1091 
1092     /**
1093      * Sets the {@code onmozfullscreenerror} event handler.
1094      *
1095      * @param mozfullscreenerror the {@code onmozfullscreenerror} event handler
1096      */
1097     @JsxSetter({FF, FF_ESR})
1098     public void setOnmozfullscreenerror(final Object mozfullscreenerror) {
1099         setEventHandler(Event.TYPE_MOZFULLSCREENERROR, mozfullscreenerror);
1100     }
1101 
1102     /**
1103      * Returns the {@code onsubmit} event handler.
1104      *
1105      * @return the {@code onsubmit} event handler
1106      */
1107     @JsxGetter
1108     public Function getOnsubmit() {
1109         return getEventHandler(Event.TYPE_SUBMIT);
1110     }
1111 
1112     /**
1113      * Sets the {@code onsubmit} event handler.
1114      *
1115      * @param submit the {@code onsubmit} event handler
1116      */
1117     @JsxSetter
1118     public void setOnsubmit(final Object submit) {
1119         setEventHandler(Event.TYPE_SUBMIT, submit);
1120     }
1121 
1122     /**
1123      * Returns the {@code onmouseleave} event handler.
1124      *
1125      * @return the {@code onmouseleave} event handler
1126      */
1127     @JsxGetter
1128     public Function getOnmouseleave() {
1129         return getEventHandler(Event.TYPE_MOUSELEAVE);
1130     }
1131 
1132     /**
1133      * Sets the {@code onmouseleave} event handler.
1134      *
1135      * @param mouseleave the {@code onmouseleave} event handler
1136      */
1137     @JsxSetter
1138     public void setOnmouseleave(final Object mouseleave) {
1139         setEventHandler(Event.TYPE_MOUSELEAVE, mouseleave);
1140     }
1141 
1142     /**
1143      * Returns the {@code onmouseenter} event handler.
1144      *
1145      * @return the {@code onmouseenter} event handler
1146      */
1147     @JsxGetter
1148     public Function getOnmouseenter() {
1149         return getEventHandler(Event.TYPE_MOUDEENTER);
1150     }
1151 
1152     /**
1153      * Sets the {@code onmouseenter} event handler.
1154      *
1155      * @param mouseenter the {@code onmouseenter} event handler
1156      */
1157     @JsxSetter
1158     public void setOnmouseenter(final Object mouseenter) {
1159         setEventHandler(Event.TYPE_MOUDEENTER, mouseenter);
1160     }
1161 
1162     /**
1163      * Returns the {@code ondragleave} event handler.
1164      *
1165      * @return the {@code ondragleave} event handler
1166      */
1167     @JsxGetter
1168     public Function getOndragleave() {
1169         return getEventHandler(Event.TYPE_DRAGLEAVE);
1170     }
1171 
1172     /**
1173      * Sets the {@code ondragleave} event handler.
1174      *
1175      * @param dragleave the {@code ondragleave} event handler
1176      */
1177     @JsxSetter
1178     public void setOndragleave(final Object dragleave) {
1179         setEventHandler(Event.TYPE_DRAGLEAVE, dragleave);
1180     }
1181 
1182     /**
1183      * Returns the {@code onmousewheel} event handler.
1184      *
1185      * @return the {@code onmousewheel} event handler
1186      */
1187     @JsxGetter({CHROME, EDGE})
1188     public Function getOnmousewheel() {
1189         return getEventHandler(Event.TYPE_MOUSEWHEEL);
1190     }
1191 
1192     /**
1193      * Sets the {@code onmousewheel} event handler.
1194      *
1195      * @param mousewheel the {@code onmousewheel} event handler
1196      */
1197     @JsxSetter({CHROME, EDGE})
1198     public void setOnmousewheel(final Object mousewheel) {
1199         setEventHandler(Event.TYPE_MOUSEWHEEL, mousewheel);
1200     }
1201 
1202     /**
1203      * Returns the {@code onpointerdown} event handler for this element.
1204      *
1205      * @return the {@code onpointerdown} event handler for this element
1206      */
1207     @JsxGetter({CHROME, EDGE})
1208     public Function getOnpointerdown() {
1209         return getEventHandler(Event.TYPE_POINTERDOWN);
1210     }
1211 
1212     /**
1213      * Sets the {@code onpointerdown} event handler.
1214      *
1215      * @param pointerdown the {@code onpointerdown} event handler
1216      */
1217     @JsxSetter({CHROME, EDGE})
1218     public void setOnpointerdown(final Object pointerdown) {
1219         setEventHandler(Event.TYPE_POINTERDOWN, pointerdown);
1220     }
1221 
1222     /**
1223      * Returns the {@code onseeking} event handler.
1224      *
1225      * @return the {@code onseeking} event handler
1226      */
1227     @JsxGetter
1228     public Function getOnseeking() {
1229         return getEventHandler(Event.TYPE_SEEKING);
1230     }
1231 
1232     /**
1233      * Sets the {@code onseeking} event handler.
1234      *
1235      * @param seeking the {@code onseeking} event handler
1236      */
1237     @JsxSetter
1238     public void setOnseeking(final Object seeking) {
1239         setEventHandler(Event.TYPE_SEEKING, seeking);
1240     }
1241 
1242     /**
1243      * Returns the {@code onblur} event handler.
1244      *
1245      * @return the {@code onblur} event handler
1246      */
1247     @JsxGetter
1248     public Function getOnblur() {
1249         return getEventHandler(Event.TYPE_BLUR);
1250     }
1251 
1252     /**
1253      * Sets the {@code onblur} event handler.
1254      *
1255      * @param blur the {@code onblur} event handler
1256      */
1257     @JsxSetter
1258     public void setOnblur(final Object blur) {
1259         setEventHandler(Event.TYPE_BLUR, blur);
1260     }
1261 
1262     /**
1263      * Returns the {@code oncuechange} event handler.
1264      *
1265      * @return the {@code oncuechange} event handler
1266      */
1267     @JsxGetter({CHROME, EDGE})
1268     public Function getOncuechange() {
1269         return getEventHandler(Event.TYPE_CUECHANGE);
1270     }
1271 
1272     /**
1273      * Sets the {@code oncuechange} event handler.
1274      *
1275      * @param cuechange the {@code oncuechange} event handler
1276      */
1277     @JsxSetter({CHROME, EDGE})
1278     public void setOncuechange(final Object cuechange) {
1279         setEventHandler(Event.TYPE_CUECHANGE, cuechange);
1280     }
1281 
1282     /**
1283      * Returns the {@code ondrop} event handler.
1284      *
1285      * @return the {@code ondrop} event handler
1286      */
1287     @JsxGetter
1288     public Function getOndrop() {
1289         return getEventHandler(Event.TYPE_DROP);
1290     }
1291 
1292     /**
1293      * Sets the {@code ondrop} event handler.
1294      *
1295      * @param drop the {@code ondrop} event handler
1296      */
1297     @JsxSetter
1298     public void setOndrop(final Object drop) {
1299         setEventHandler(Event.TYPE_DROP, drop);
1300     }
1301 
1302     /**
1303      * Returns the {@code ondragstart} event handler.
1304      *
1305      * @return the {@code ondragstart} event handler
1306      */
1307     @JsxGetter
1308     public Function getOndragstart() {
1309         return getEventHandler(Event.TYPE_DRAGSTART);
1310     }
1311 
1312     /**
1313      * Sets the {@code ondragstart} event handler.
1314      *
1315      * @param dragstart the {@code ondragstart} event handler
1316      */
1317     @JsxSetter
1318     public void setOndragstart(final Object dragstart) {
1319         setEventHandler(Event.TYPE_DRAGSTART, dragstart);
1320     }
1321 
1322     /**
1323      * Returns the {@code onmozfullscreenchange} event handler.
1324      *
1325      * @return the {@code onmozfullscreenchange} event handler
1326      */
1327     @JsxGetter({FF, FF_ESR})
1328     public Function getOnmozfullscreenchange() {
1329         return getEventHandler(Event.TYPE_MOZFULLSCREENCHANGE);
1330     }
1331 
1332     /**
1333      * Sets the {@code onmozfullscreenchange} event handler.
1334      *
1335      * @param mozfullscreenchange the {@code onmozfullscreenchange} event handler
1336      */
1337     @JsxSetter({FF, FF_ESR})
1338     public void setOnmozfullscreenchange(final Object mozfullscreenchange) {
1339         setEventHandler(Event.TYPE_MOZFULLSCREENCHANGE, mozfullscreenchange);
1340     }
1341 
1342     /**
1343      * Returns the {@code ondurationchange} event handler.
1344      *
1345      * @return the {@code ondurationchange} event handler
1346      */
1347     @JsxGetter
1348     public Function getOndurationchange() {
1349         return getEventHandler(Event.TYPE_DURATIONCHANGE);
1350     }
1351 
1352     /**
1353      * Sets the {@code ondurationchange} event handler.
1354      *
1355      * @param durationchange the {@code ondurationchange} event handler
1356      */
1357     @JsxSetter
1358     public void setOndurationchange(final Object durationchange) {
1359         setEventHandler(Event.TYPE_DURATIONCHANGE, durationchange);
1360     }
1361 
1362     /**
1363      * Returns the {@code onplaying} event handler.
1364      *
1365      * @return the {@code onplaying} event handler
1366      */
1367     @JsxGetter
1368     public Function getOnplaying() {
1369         return getEventHandler(Event.TYPE_PLAYING);
1370     }
1371 
1372     /**
1373      * Sets the {@code onplaying} event handler.
1374      *
1375      * @param playing the {@code onplaying} event handler
1376      */
1377     @JsxSetter
1378     public void setOnplaying(final Object playing) {
1379         setEventHandler(Event.TYPE_PLAYING, playing);
1380     }
1381 
1382     /**
1383      * Returns the {@code onload} event handler.
1384      *
1385      * @return the {@code onload} event handler
1386      */
1387     @JsxGetter
1388     public Function getOnload() {
1389         return getEventHandler(Event.TYPE_LOAD);
1390     }
1391 
1392     /**
1393      * Sets the {@code onload} event handler.
1394      *
1395      * @param load the {@code onload} event handler
1396      */
1397     @JsxSetter
1398     public void setOnload(final Object load) {
1399         setEventHandler(Event.TYPE_LOAD, load);
1400     }
1401 
1402     /**
1403      * Returns the {@code onended} event handler.
1404      *
1405      * @return the {@code onended} event handler
1406      */
1407     @JsxGetter
1408     public Function getOnended() {
1409         return getEventHandler(Event.TYPE_ENDED);
1410     }
1411 
1412     /**
1413      * Sets the {@code onended} event handler.
1414      *
1415      * @param ended the {@code onended} event handler
1416      */
1417     @JsxSetter
1418     public void setOnended(final Object ended) {
1419         setEventHandler(Event.TYPE_ENDED, ended);
1420     }
1421 
1422     /**
1423      * Returns the {@code onloadeddata} event handler.
1424      *
1425      * @return the {@code onloadeddata} event handler
1426      */
1427     @JsxGetter
1428     public Function getOnloadeddata() {
1429         return getEventHandler(Event.TYPE_LOADEDDATA);
1430     }
1431 
1432     /**
1433      * Sets the {@code onloadeddata} event handler.
1434      *
1435      * @param loadeddata the {@code onloadeddata} event handler
1436      */
1437     @JsxSetter
1438     public void setOnloadeddata(final Object loadeddata) {
1439         setEventHandler(Event.TYPE_LOADEDDATA, loadeddata);
1440     }
1441 
1442     /**
1443      * Returns the {@code oncopy} event handler.
1444      *
1445      * @return the {@code oncopy} event handler
1446      */
1447     @JsxGetter
1448     public Function getOncopy() {
1449         return getEventHandler(Event.TYPE_COPY);
1450     }
1451 
1452     /**
1453      * Sets the {@code oncopy} event handler.
1454      *
1455      * @param copy the {@code oncopy} event handler
1456      */
1457     @JsxSetter
1458     public void setOncopy(final Object copy) {
1459         setEventHandler(Event.TYPE_COPY, copy);
1460     }
1461 
1462     /**
1463      * Returns the {@code onpaste} event handler.
1464      *
1465      * @return the {@code onpaste} event handler
1466      */
1467     @JsxGetter
1468     public Function getOnpaste() {
1469         return getEventHandler(Event.TYPE_PASTE);
1470     }
1471 
1472     /**
1473      * Sets the {@code onpaste} event handler.
1474      *
1475      * @param paste the {@code onpaste} event handler
1476      */
1477     @JsxSetter
1478     public void setOnpaste(final Object paste) {
1479         setEventHandler(Event.TYPE_PASTE, paste);
1480     }
1481 
1482     /**
1483      * Returns the {@code onmouseout} event handler.
1484      *
1485      * @return the {@code onmouseout} event handler
1486      */
1487     @JsxGetter
1488     public Function getOnmouseout() {
1489         return getEventHandler(MouseEvent.TYPE_MOUSE_OUT);
1490     }
1491 
1492     /**
1493      * Sets the {@code onmouseout} event handler.
1494      *
1495      * @param mouseout the {@code onmouseout} event handler
1496      */
1497     @JsxSetter
1498     public void setOnmouseout(final Object mouseout) {
1499         setEventHandler(MouseEvent.TYPE_MOUSE_OUT, mouseout);
1500     }
1501 
1502     /**
1503      * Returns the {@code onsuspend} event handler.
1504      *
1505      * @return the {@code onsuspend} event handler
1506      */
1507     @JsxGetter
1508     public Function getOnsuspend() {
1509         return getEventHandler(Event.TYPE_SUSPEND);
1510     }
1511 
1512     /**
1513      * Sets the {@code onsuspend} event handler.
1514      *
1515      * @param suspend the {@code onsuspend} event handler
1516      */
1517     @JsxSetter
1518     public void setOnsuspend(final Object suspend) {
1519         setEventHandler(Event.TYPE_SUSPEND, suspend);
1520     }
1521 
1522     /**
1523      * Returns the {@code onvolumechange} event handler.
1524      *
1525      * @return the {@code onvolumechange} event handler
1526      */
1527     @JsxGetter
1528     public Function getOnvolumechange() {
1529         return getEventHandler(Event.TYPE_VOLUMECHANGE);
1530     }
1531 
1532     /**
1533      * Sets the {@code onvolumechange} event handler.
1534      *
1535      * @param volumechange the {@code onvolumechange} event handler
1536      */
1537     @JsxSetter
1538     public void setOnvolumechange(final Object volumechange) {
1539         setEventHandler(Event.TYPE_VOLUMECHANGE, volumechange);
1540     }
1541 
1542     /**
1543      * Returns the {@code onwaiting} event handler.
1544      *
1545      * @return the {@code onwaiting} event handler
1546      */
1547     @JsxGetter
1548     public Function getOnwaiting() {
1549         return getEventHandler(Event.TYPE_WAITING);
1550     }
1551 
1552     /**
1553      * Sets the {@code onwaiting} event handler.
1554      *
1555      * @param waiting the {@code onwaiting} event handler
1556      */
1557     @JsxSetter
1558     public void setOnwaiting(final Object waiting) {
1559         setEventHandler(Event.TYPE_WAITING, waiting);
1560     }
1561 
1562     /**
1563      * Returns the {@code oncanplay} event handler.
1564      *
1565      * @return the {@code oncanplay} event handler
1566      */
1567     @JsxGetter
1568     public Function getOncanplay() {
1569         return getEventHandler(Event.TYPE_CANPLAY);
1570     }
1571 
1572     /**
1573      * Sets the {@code oncanplay} event handler.
1574      *
1575      * @param canplay the {@code oncanplay} event handler
1576      */
1577     @JsxSetter
1578     public void setOncanplay(final Object canplay) {
1579         setEventHandler(Event.TYPE_CANPLAY, canplay);
1580     }
1581 
1582     /**
1583      * Returns the {@code onmousedown} event handler.
1584      *
1585      * @return the {@code onmousedown} event handler
1586      */
1587     @JsxGetter
1588     public Function getOnmousedown() {
1589         return getEventHandler(MouseEvent.TYPE_MOUSE_DOWN);
1590     }
1591 
1592     /**
1593      * Sets the {@code onmousedown} event handler.
1594      *
1595      * @param mousedown the {@code onmousedown} event handler
1596      */
1597     @JsxSetter
1598     public void setOnmousedown(final Object mousedown) {
1599         setEventHandler(MouseEvent.TYPE_MOUSE_DOWN, mousedown);
1600     }
1601 
1602     /**
1603      * Returns the {@code onemptied} event handler.
1604      *
1605      * @return the {@code onemptied} event handler
1606      */
1607     @JsxGetter
1608     public Function getOnemptied() {
1609         return getEventHandler(Event.TYPE_EMPTIED);
1610     }
1611 
1612     /**
1613      * Sets the {@code onemptied} event handler.
1614      *
1615      * @param emptied the {@code onemptied} event handler
1616      */
1617     @JsxSetter
1618     public void setOnemptied(final Object emptied) {
1619         setEventHandler(Event.TYPE_EMPTIED, emptied);
1620     }
1621 
1622     /**
1623      * Returns the {@code ongotpointercapture} event handler for this element.
1624      *
1625      * @return the {@code ongotpointercapture} event handler for this element
1626      */
1627     @JsxGetter({CHROME, EDGE})
1628     public Function getOngotpointercapture() {
1629         return getEventHandler(Event.TYPE_GOTPOINTERCAPTURE);
1630     }
1631 
1632     /**
1633      * Sets the {@code ongotpointercapture} event handler.
1634      *
1635      * @param gotpointercapture the {@code ongotpointercapture} event handler
1636      */
1637     @JsxSetter({CHROME, EDGE})
1638     public void setOngotpointercapture(final Object gotpointercapture) {
1639         setEventHandler(Event.TYPE_GOTPOINTERCAPTURE, gotpointercapture);
1640     }
1641 
1642     /**
1643      * Returns the {@code onwheel} event handler for this element.
1644      *
1645      * @return the {@code onwheel} event handler for this element
1646      */
1647     @JsxGetter({CHROME, EDGE})
1648     @Override
1649     public Function getOnwheel() {
1650         return getEventHandler(Event.TYPE_WHEEL);
1651     }
1652 
1653     /**
1654      * Sets the {@code onwheel} event handler for this element.
1655      *
1656      * @param onwheel the {@code onwheel} event handler for this element
1657      */
1658     @JsxSetter({CHROME, EDGE})
1659     @Override
1660     public void setOnwheel(final Object onwheel) {
1661         setEventHandler(Event.TYPE_WHEEL, onwheel);
1662     }
1663 }