Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
3584 sourcerer 1
// HTML WebIDL
2
// retrived from http://www.whatwg.org/specs/web-apps/current-work/
3
// 23rd October 2012
4
 
5
 
6
interface HTMLAllCollection : HTMLCollection {
7
  // inherits length and item()
8
  legacycaller getter object? namedItem(DOMString name); // overrides inherited namedItem()
9
  HTMLAllCollection tags(DOMString tagName);
10
};
11
 
12
interface HTMLFormControlsCollection : HTMLCollection {
13
  // inherits length and item()
14
  legacycaller getter object? namedItem(DOMString name); // overrides inherited namedItem()
15
};
16
 
17
interface RadioNodeList : NodeList {
18
          attribute DOMString value;
19
};
20
 
21
interface HTMLOptionsCollection : HTMLCollection {
22
  // inherits item()
23
           attribute unsigned long length; // overrides inherited length
24
  legacycaller getter object? namedItem(DOMString name); // overrides inherited namedItem()
25
  setter creator void (unsigned long index, HTMLOptionElement? option);
26
  void add((HTMLOptionElement or HTMLOptGroupElement) element, optional (HTMLElement or long)? before = null);
27
  void remove(long index);
28
           attribute long selectedIndex;
29
};
30
 
31
interface HTMLPropertiesCollection : HTMLCollection {
32
  // inherits length and item()
33
  getter PropertyNodeList? namedItem(DOMString name); // overrides inherited namedItem()
34
  readonly attribute DOMString[] names;
35
};
36
 
37
typedef sequence PropertyValueArray;
38
 
39
interface PropertyNodeList : NodeList {
40
  PropertyValueArray getValues();
41
};
42
 
43
interface DOMStringMap {
44
  getter DOMString (DOMString name);
45
  setter void (DOMString name, DOMString value);
46
  creator void (DOMString name, DOMString value);
47
  deleter void (DOMString name);
48
};
49
 
50
interface DOMElementMap {
51
  getter Element (DOMString name);
52
  setter void (DOMString name, Element value);
53
  creator void (DOMString name, Element value);
54
  deleter void (DOMString name);
55
};
56
 
57
[NoInterfaceObject]
58
interface Transferable { };
59
 
60
[OverrideBuiltins]
61
partial interface Document {
62
  // resource metadata management
63
  [PutForwards=href] readonly attribute Location? location;
64
           attribute DOMString domain;
65
  readonly attribute DOMString referrer;
66
           attribute DOMString cookie;
67
  readonly attribute DOMString lastModified;
68
  readonly attribute DOMString readyState;
69
 
70
  // DOM tree accessors
71
  getter object (DOMString name);
72
           attribute DOMString title;
73
           attribute DOMString dir;
74
           attribute HTMLElement? body;
75
  readonly attribute HTMLHeadElement? head;
76
  readonly attribute HTMLCollection images;
77
  readonly attribute HTMLCollection embeds;
78
  readonly attribute HTMLCollection plugins;
79
  readonly attribute HTMLCollection links;
80
  readonly attribute HTMLCollection forms;
81
  readonly attribute HTMLCollection scripts;
82
  NodeList getElementsByName(DOMString elementName);
83
  NodeList getItems(optional DOMString typeNames); // microdata
84
  readonly attribute DOMElementMap cssElementMap;
85
 
86
  // dynamic markup insertion
87
  Document open(optional DOMString type, optional DOMString replace);
88
  WindowProxy open(DOMString url, DOMString name, DOMString features, optional boolean replace);
89
  void close();
90
  void write(DOMString... text);
91
  void writeln(DOMString... text);
92
 
93
  // user interaction
94
  readonly attribute WindowProxy? defaultView;
95
  readonly attribute Element? activeElement;
96
  boolean hasFocus();
97
           attribute DOMString designMode;
98
  boolean execCommand(DOMString commandId);
99
  boolean execCommand(DOMString commandId, boolean showUI);
100
  boolean execCommand(DOMString commandId, boolean showUI, DOMString value);
101
  boolean queryCommandEnabled(DOMString commandId);
102
  boolean queryCommandIndeterm(DOMString commandId);
103
  boolean queryCommandState(DOMString commandId);
104
  boolean queryCommandSupported(DOMString commandId);
105
  DOMString queryCommandValue(DOMString commandId);
106
  readonly attribute HTMLCollection commands;
107
 
108
  // event handler IDL attributes
109
           attribute EventHandler onabort;
110
           attribute EventHandler onblur;
111
           attribute EventHandler oncancel;
112
           attribute EventHandler oncanplay;
113
           attribute EventHandler oncanplaythrough;
114
           attribute EventHandler onchange;
115
           attribute EventHandler onclick;
116
           attribute EventHandler onclose;
117
           attribute EventHandler oncontextmenu;
118
           attribute EventHandler oncuechange;
119
           attribute EventHandler ondblclick;
120
           attribute EventHandler ondrag;
121
           attribute EventHandler ondragend;
122
           attribute EventHandler ondragenter;
123
           attribute EventHandler ondragleave;
124
           attribute EventHandler ondragover;
125
           attribute EventHandler ondragstart;
126
           attribute EventHandler ondrop;
127
           attribute EventHandler ondurationchange;
128
           attribute EventHandler onemptied;
129
           attribute EventHandler onended;
130
           attribute OnErrorEventHandler onerror;
131
           attribute EventHandler onfocus;
132
           attribute EventHandler oninput;
133
           attribute EventHandler oninvalid;
134
           attribute EventHandler onkeydown;
135
           attribute EventHandler onkeypress;
136
           attribute EventHandler onkeyup;
137
           attribute EventHandler onload;
138
           attribute EventHandler onloadeddata;
139
           attribute EventHandler onloadedmetadata;
140
           attribute EventHandler onloadstart;
141
           attribute EventHandler onmousedown;
142
           attribute EventHandler onmousemove;
143
           attribute EventHandler onmouseout;
144
           attribute EventHandler onmouseover;
145
           attribute EventHandler onmouseup;
146
           attribute EventHandler onmousewheel;
147
           attribute EventHandler onpause;
148
           attribute EventHandler onplay;
149
           attribute EventHandler onplaying;
150
           attribute EventHandler onprogress;
151
           attribute EventHandler onratechange;
152
           attribute EventHandler onreset;
153
           attribute EventHandler onscroll;
154
           attribute EventHandler onseeked;
155
           attribute EventHandler onseeking;
156
           attribute EventHandler onselect;
157
           attribute EventHandler onshow;
158
           attribute EventHandler onstalled;
159
           attribute EventHandler onsubmit;
160
           attribute EventHandler onsuspend;
161
           attribute EventHandler ontimeupdate;
162
           attribute EventHandler onvolumechange;
163
           attribute EventHandler onwaiting;
164
 
165
  // special event handler IDL attributes that only apply to Document objects
166
  [LenientThis] attribute EventHandler onreadystatechange;
167
};
168
 
169
partial interface XMLDocument {
170
  boolean load(DOMString url);
171
};
172
 
173
interface HTMLElement : Element {
174
  // metadata attributes
175
           attribute DOMString title;
176
           attribute DOMString lang;
177
           attribute boolean translate;
178
           attribute DOMString dir;
179
  readonly attribute DOMStringMap dataset;
180
 
181
  // microdata
182
           attribute boolean itemScope;
183
  [PutForwards=value] readonly attribute DOMSettableTokenList itemType;
184
           attribute DOMString itemId;
185
  [PutForwards=value] readonly attribute DOMSettableTokenList itemRef;
186
  [PutForwards=value] readonly attribute DOMSettableTokenList itemProp;
187
  readonly attribute HTMLPropertiesCollection properties;
188
           attribute any itemValue; // acts as DOMString on setting
189
 
190
  // user interaction
191
           attribute boolean hidden;
192
  void click();
193
           attribute long tabIndex;
194
  void focus();
195
  void blur();
196
           attribute DOMString accessKey;
197
  readonly attribute DOMString accessKeyLabel;
198
           attribute boolean draggable;
199
  [PutForwards=value] readonly attribute DOMSettableTokenList dropzone;
200
           attribute DOMString contentEditable;
201
  readonly attribute boolean isContentEditable;
202
           attribute HTMLMenuElement? contextMenu;
203
           attribute boolean spellcheck;
204
  void forceSpellCheck();
205
 
206
  // command API
207
  readonly attribute DOMString? commandType;
208
  readonly attribute DOMString? commandLabel;
209
  readonly attribute DOMString? commandIcon;
210
  readonly attribute boolean? commandHidden;
211
  readonly attribute boolean? commandDisabled;
212
  readonly attribute boolean? commandChecked;
213
 
214
  // styling
215
  readonly attribute CSSStyleDeclaration style;
216
 
217
  // event handler IDL attributes
218
           attribute EventHandler onabort;
219
           attribute EventHandler onblur;
220
           attribute EventHandler oncancel;
221
           attribute EventHandler oncanplay;
222
           attribute EventHandler oncanplaythrough;
223
           attribute EventHandler onchange;
224
           attribute EventHandler onclick;
225
           attribute EventHandler onclose;
226
           attribute EventHandler oncontextmenu;
227
           attribute EventHandler oncuechange;
228
           attribute EventHandler ondblclick;
229
           attribute EventHandler ondrag;
230
           attribute EventHandler ondragend;
231
           attribute EventHandler ondragenter;
232
           attribute EventHandler ondragleave;
233
           attribute EventHandler ondragover;
234
           attribute EventHandler ondragstart;
235
           attribute EventHandler ondrop;
236
           attribute EventHandler ondurationchange;
237
           attribute EventHandler onemptied;
238
           attribute EventHandler onended;
239
           attribute OnErrorEventHandler onerror;
240
           attribute EventHandler onfocus;
241
           attribute EventHandler oninput;
242
           attribute EventHandler oninvalid;
243
           attribute EventHandler onkeydown;
244
           attribute EventHandler onkeypress;
245
           attribute EventHandler onkeyup;
246
           attribute EventHandler onload;
247
           attribute EventHandler onloadeddata;
248
           attribute EventHandler onloadedmetadata;
249
           attribute EventHandler onloadstart;
250
           attribute EventHandler onmousedown;
251
           attribute EventHandler onmousemove;
252
           attribute EventHandler onmouseout;
253
           attribute EventHandler onmouseover;
254
           attribute EventHandler onmouseup;
255
           attribute EventHandler onmousewheel;
256
           attribute EventHandler onpause;
257
           attribute EventHandler onplay;
258
           attribute EventHandler onplaying;
259
           attribute EventHandler onprogress;
260
           attribute EventHandler onratechange;
261
           attribute EventHandler onreset;
262
           attribute EventHandler onscroll;
263
           attribute EventHandler onseeked;
264
           attribute EventHandler onseeking;
265
           attribute EventHandler onselect;
266
           attribute EventHandler onshow;
267
           attribute EventHandler onstalled;
268
           attribute EventHandler onsubmit;
269
           attribute EventHandler onsuspend;
270
           attribute EventHandler ontimeupdate;
271
           attribute EventHandler onvolumechange;
272
           attribute EventHandler onwaiting;
273
};
274
 
275
interface HTMLUnknownElement : HTMLElement { };
276
 
277
interface HTMLHtmlElement : HTMLElement {};
278
 
279
interface HTMLHeadElement : HTMLElement {};
280
 
281
interface HTMLTitleElement : HTMLElement {
282
           attribute DOMString text;
283
};
284
 
285
interface HTMLBaseElement : HTMLElement {
286
           attribute DOMString href;
287
           attribute DOMString target;
288
};
289
 
290
interface HTMLLinkElement : HTMLElement {
291
           attribute boolean disabled;
292
           attribute DOMString href;
293
           attribute DOMString rel;
294
  readonly attribute DOMTokenList relList;
295
           attribute DOMString media;
296
           attribute DOMString hreflang;
297
           attribute DOMString type;
298
  [PutForwards=value] readonly attribute DOMSettableTokenList sizes;
299
};
300
HTMLLinkElement implements LinkStyle;
301
 
302
interface HTMLMetaElement : HTMLElement {
303
           attribute DOMString name;
304
           attribute DOMString httpEquiv;
305
           attribute DOMString content;
306
};
307
 
308
interface HTMLStyleElement : HTMLElement {
309
           attribute boolean disabled;
310
           attribute DOMString media;
311
           attribute DOMString type;
312
           attribute boolean scoped;
313
};
314
HTMLStyleElement implements LinkStyle;
315
 
316
interface HTMLScriptElement : HTMLElement {
317
           attribute DOMString src;
318
           attribute boolean async;
319
           attribute boolean defer;
320
           attribute DOMString type;
321
           attribute DOMString charset;
322
           attribute DOMString text;
323
};
324
 
325
interface HTMLBodyElement : HTMLElement {
326
           attribute EventHandler onafterprint;
327
           attribute EventHandler onbeforeprint;
328
           attribute EventHandler onbeforeunload;
329
           attribute EventHandler onblur;
330
           attribute OnErrorEventHandler onerror;
331
           attribute EventHandler onfocus;
332
           attribute EventHandler onhashchange;
333
           attribute EventHandler onload;
334
           attribute EventHandler onmessage;
335
           attribute EventHandler onoffline;
336
           attribute EventHandler ononline;
337
           attribute EventHandler onpopstate;
338
           attribute EventHandler onpagehide;
339
           attribute EventHandler onpageshow;
340
           attribute EventHandler onresize;
341
           attribute EventHandler onscroll;
342
           attribute EventHandler onstorage;
343
           attribute EventHandler onunload;
344
};
345
 
346
interface HTMLHeadingElement : HTMLElement {};
347
 
348
interface HTMLParagraphElement : HTMLElement {};
349
 
350
interface HTMLHRElement : HTMLElement {};
351
 
352
interface HTMLPreElement : HTMLElement {};
353
 
354
interface HTMLQuoteElement : HTMLElement {
355
           attribute DOMString cite;
356
};
357
 
358
interface HTMLOListElement : HTMLElement {
359
           attribute boolean reversed;
360
           attribute long start;
361
           attribute DOMString type;
362
};
363
 
364
interface HTMLUListElement : HTMLElement {};
365
 
366
interface HTMLLIElement : HTMLElement {
367
           attribute long value;
368
};
369
 
370
interface HTMLDListElement : HTMLElement {};
371
 
372
interface HTMLDivElement : HTMLElement {};
373
 
374
interface HTMLAnchorElement : HTMLElement {
375
  stringifier attribute DOMString href;
376
           attribute DOMString target;
377
 
378
           attribute DOMString download;
379
           attribute DOMString ping;
380
 
381
           attribute DOMString rel;
382
  readonly attribute DOMTokenList relList;
383
           attribute DOMString media;
384
           attribute DOMString hreflang;
385
           attribute DOMString type;
386
 
387
           attribute DOMString text;
388
 
389
  // URL decomposition IDL attributes
390
           attribute DOMString protocol;
391
           attribute DOMString host;
392
           attribute DOMString hostname;
393
           attribute DOMString port;
394
           attribute DOMString pathname;
395
           attribute DOMString search;
396
           attribute DOMString hash;
397
};
398
 
399
interface HTMLDataElement : HTMLElement {
400
           attribute DOMString value;
401
};
402
 
403
interface HTMLTimeElement : HTMLElement {
404
           attribute DOMString datetime;
405
};
406
 
407
interface HTMLSpanElement : HTMLElement {};
408
 
409
interface HTMLBRElement : HTMLElement {};
410
 
411
interface HTMLModElement : HTMLElement {
412
           attribute DOMString cite;
413
           attribute DOMString dateTime;
414
};
415
 
416
[NamedConstructor=Image(),
417
 NamedConstructor=Image(unsigned long width),
418
 NamedConstructor=Image(unsigned long width, unsigned long height)]
419
interface HTMLImageElement : HTMLElement {
420
           attribute DOMString alt;
421
           attribute DOMString src;
422
           attribute DOMString srcset;
423
           attribute DOMString crossOrigin;
424
           attribute DOMString useMap;
425
           attribute boolean isMap;
426
           attribute unsigned long width;
427
           attribute unsigned long height;
428
  readonly attribute unsigned long naturalWidth;
429
  readonly attribute unsigned long naturalHeight;
430
  readonly attribute boolean complete;
431
};
432
 
433
interface HTMLIFrameElement : HTMLElement {
434
           attribute DOMString src;
435
           attribute DOMString srcdoc;
436
           attribute DOMString name;
437
  [PutForwards=value] readonly attribute DOMSettableTokenList sandbox;
438
           attribute boolean seamless;
439
           attribute DOMString width;
440
           attribute DOMString height;
441
  readonly attribute Document? contentDocument;
442
  readonly attribute WindowProxy? contentWindow;
443
};
444
 
445
interface HTMLEmbedElement : HTMLElement {
446
           attribute DOMString src;
447
           attribute DOMString type;
448
           attribute DOMString width;
449
           attribute DOMString height;
450
  legacycaller any (any... arguments);
451
};
452
 
453
interface HTMLObjectElement : HTMLElement {
454
           attribute DOMString data;
455
           attribute DOMString type;
456
           attribute boolean typeMustMatch;
457
           attribute DOMString name;
458
           attribute DOMString useMap;
459
  readonly attribute HTMLFormElement? form;
460
           attribute DOMString width;
461
           attribute DOMString height;
462
  readonly attribute Document? contentDocument;
463
  readonly attribute WindowProxy? contentWindow;
464
 
465
  readonly attribute boolean willValidate;
466
  readonly attribute ValidityState validity;
467
  readonly attribute DOMString validationMessage;
468
  boolean checkValidity();
469
  void setCustomValidity(DOMString error);
470
 
471
  legacycaller any (any... arguments);
472
};
473
 
474
interface HTMLParamElement : HTMLElement {
475
           attribute DOMString name;
476
           attribute DOMString value;
477
};
478
 
479
interface HTMLVideoElement : HTMLMediaElement {
480
           attribute unsigned long width;
481
           attribute unsigned long height;
482
  readonly attribute unsigned long videoWidth;
483
  readonly attribute unsigned long videoHeight;
484
           attribute DOMString poster;
485
};
486
 
487
[NamedConstructor=Audio(),
488
 NamedConstructor=Audio(DOMString src)]
489
interface HTMLAudioElement : HTMLMediaElement {};
490
 
491
interface HTMLSourceElement : HTMLElement {
492
           attribute DOMString src;
493
           attribute DOMString type;
494
           attribute DOMString media;
495
};
496
 
497
interface HTMLTrackElement : HTMLElement {
498
           attribute DOMString kind;
499
           attribute DOMString src;
500
           attribute DOMString srclang;
501
           attribute DOMString label;
502
           attribute boolean default;
503
 
504
  const unsigned short NONE = 0;
505
  const unsigned short LOADING = 1;
506
  const unsigned short LOADED = 2;
507
  const unsigned short ERROR = 3;
508
  readonly attribute unsigned short readyState;
509
 
510
  readonly attribute TextTrack track;
511
};
512
 
513
interface HTMLMediaElement : HTMLElement {
514
 
515
  // error state
516
  readonly attribute MediaError? error;
517
 
518
  // network state
519
           attribute DOMString src;
520
  readonly attribute DOMString currentSrc;
521
           attribute DOMString crossOrigin;
522
  const unsigned short NETWORK_EMPTY = 0;
523
  const unsigned short NETWORK_IDLE = 1;
524
  const unsigned short NETWORK_LOADING = 2;
525
  const unsigned short NETWORK_NO_SOURCE = 3;
526
  readonly attribute unsigned short networkState;
527
           attribute DOMString preload;
528
  readonly attribute TimeRanges buffered;
529
  void load();
530
  DOMString canPlayType(DOMString type);
531
 
532
  // ready state
533
  const unsigned short HAVE_NOTHING = 0;
534
  const unsigned short HAVE_METADATA = 1;
535
  const unsigned short HAVE_CURRENT_DATA = 2;
536
  const unsigned short HAVE_FUTURE_DATA = 3;
537
  const unsigned short HAVE_ENOUGH_DATA = 4;
538
  readonly attribute unsigned short readyState;
539
  readonly attribute boolean seeking;
540
 
541
  // playback state
542
           attribute double currentTime;
543
  void fastSeek(double time);
544
  readonly attribute unrestricted double duration;
545
  readonly attribute Date startDate;
546
  readonly attribute boolean paused;
547
           attribute double defaultPlaybackRate;
548
           attribute double playbackRate;
549
  readonly attribute TimeRanges played;
550
  readonly attribute TimeRanges seekable;
551
  readonly attribute boolean ended;
552
           attribute boolean autoplay;
553
           attribute boolean loop;
554
  void play();
555
  void pause();
556
 
557
  // media controller
558
           attribute DOMString mediaGroup;
559
           attribute MediaController? controller;
560
 
561
  // controls
562
           attribute boolean controls;
563
           attribute double volume;
564
           attribute boolean muted;
565
           attribute boolean defaultMuted;
566
 
567
  // tracks
568
  readonly attribute AudioTrackList audioTracks;
569
  readonly attribute VideoTrackList videoTracks;
570
  readonly attribute TextTrackList textTracks;
571
  TextTrack addTextTrack(DOMString kind, optional DOMString label, optional DOMString language);
572
};
573
 
574
interface MediaError {
575
  const unsigned short MEDIA_ERR_ABORTED = 1;
576
  const unsigned short MEDIA_ERR_NETWORK = 2;
577
  const unsigned short MEDIA_ERR_DECODE = 3;
578
  const unsigned short MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
579
  readonly attribute unsigned short code;
580
};
581
 
582
interface AudioTrackList : EventTarget {
583
  readonly attribute unsigned long length;
584
  getter AudioTrack (unsigned long index);
585
  AudioTrack? getTrackById(DOMString id);
586
 
587
           attribute EventHandler onchange;
588
           attribute EventHandler onaddtrack;
589
           attribute EventHandler onremovetrack;
590
};
591
 
592
interface AudioTrack {
593
  readonly attribute DOMString id;
594
  readonly attribute DOMString kind;
595
  readonly attribute DOMString label;
596
  readonly attribute DOMString language;
597
           attribute boolean enabled;
598
};
599
 
600
interface VideoTrackList : EventTarget {
601
  readonly attribute unsigned long length;
602
  getter VideoTrack (unsigned long index);
603
  VideoTrack? getTrackById(DOMString id);
604
  readonly attribute long selectedIndex;
605
 
606
           attribute EventHandler onchange;
607
           attribute EventHandler onaddtrack;
608
           attribute EventHandler onremovetrack;
609
};
610
 
611
interface VideoTrack {
612
  readonly attribute DOMString id;
613
  readonly attribute DOMString kind;
614
  readonly attribute DOMString label;
615
  readonly attribute DOMString language;
616
           attribute boolean selected;
617
};
618
 
619
enum MediaControllerPlaybackState { "waiting", "playing", "ended" };
620
[Constructor]
621
interface MediaController : EventTarget {
622
  readonly attribute unsigned short readyState; // uses HTMLMediaElement.readyState's values
623
 
624
  readonly attribute TimeRanges buffered;
625
  readonly attribute TimeRanges seekable;
626
  readonly attribute unrestricted double duration;
627
           attribute double currentTime;
628
 
629
  readonly attribute boolean paused;
630
  readonly attribute MediaControllerPlaybackState playbackState;
631
  readonly attribute TimeRanges played;
632
  void pause();
633
  void unpause();
634
  void play(); // calls play() on all media elements as well
635
 
636
           attribute double defaultPlaybackRate;
637
           attribute double playbackRate;
638
 
639
           attribute double volume;
640
           attribute boolean muted;
641
 
642
           attribute EventHandler onemptied;
643
           attribute EventHandler onloadedmetadata;
644
           attribute EventHandler onloadeddata;
645
           attribute EventHandler oncanplay;
646
           attribute EventHandler oncanplaythrough;
647
           attribute EventHandler onplaying;
648
           attribute EventHandler onended;
649
           attribute EventHandler onwaiting;
650
 
651
           attribute EventHandler ondurationchange;
652
           attribute EventHandler ontimeupdate;
653
           attribute EventHandler onplay;
654
           attribute EventHandler onpause;
655
           attribute EventHandler onratechange;
656
           attribute EventHandler onvolumechange;
657
};
658
 
659
interface TextTrackList : EventTarget {
660
  readonly attribute unsigned long length;
661
  getter TextTrack (unsigned long index);
662
 
663
           attribute EventHandler onaddtrack;
664
           attribute EventHandler onremovetrack;
665
};
666
 
667
enum TextTrackMode { "disabled", "hidden", "showing" };
668
interface TextTrack : EventTarget {
669
  readonly attribute DOMString kind;
670
  readonly attribute DOMString label;
671
  readonly attribute DOMString language;
672
  readonly attribute DOMString inBandMetadataTrackDispatchType;
673
 
674
           attribute TextTrackMode mode;
675
 
676
  readonly attribute TextTrackCueList? cues;
677
  readonly attribute TextTrackCueList? activeCues;
678
 
679
  void addCue(TextTrackCue cue);
680
  void removeCue(TextTrackCue cue);
681
 
682
           attribute EventHandler oncuechange;
683
};
684
 
685
interface TextTrackCueList {
686
  readonly attribute unsigned long length;
687
  getter TextTrackCue (unsigned long index);
688
  TextTrackCue? getCueById(DOMString id);
689
};
690
 
691
enum AutoKeyword { "auto" };
692
[Constructor(double startTime, double endTime, DOMString text)]
693
interface TextTrackCue : EventTarget {
694
  readonly attribute TextTrack? track;
695
 
696
           attribute DOMString id;
697
           attribute double startTime;
698
           attribute double endTime;
699
           attribute boolean pauseOnExit;
700
           attribute DOMString vertical;
701
           attribute boolean snapToLines;
702
           attribute (long or AutoKeyword) line;
703
           attribute long position;
704
           attribute long size;
705
           attribute DOMString align;
706
           attribute DOMString text;
707
  DocumentFragment getCueAsHTML();
708
 
709
           attribute EventHandler onenter;
710
           attribute EventHandler onexit;
711
};
712
 
713
interface TimeRanges {
714
  readonly attribute unsigned long length;
715
  double start(unsigned long index);
716
  double end(unsigned long index);
717
};
718
 
719
[Constructor(DOMString type, optional TrackEventInit eventInitDict)]
720
interface TrackEvent : Event {
721
  readonly attribute object? track;
722
};
723
 
724
dictionary TrackEventInit : EventInit {
725
  object? track;
726
};
727
 
728
interface HTMLCanvasElement : HTMLElement {
729
           attribute unsigned long width;
730
           attribute unsigned long height;
731
 
732
  DOMString toDataURL(optional DOMString type, any... arguments);
733
  DOMString toDataURLHD(optional DOMString type, any... arguments);
734
  void toBlob(FileCallback? _callback, optional DOMString type, any... arguments);
735
  void toBlobHD(FileCallback? _callback, optional DOMString type, any... arguments);
736
 
737
  object? getContext(DOMString contextId, any... arguments);
738
  boolean supportsContext(DOMString contextId, any... arguments);
739
};
740
 
741
interface CanvasRenderingContext2D {
742
 
743
  // back-reference to the canvas
744
  readonly attribute HTMLCanvasElement canvas;
745
 
746
  // state
747
  void save(); // push state on state stack
748
  void restore(); // pop state stack and restore state
749
 
750
  // transformations (default transform is the identity matrix)
751
           attribute SVGMatrix currentTransform;
752
  void scale(unrestricted double x, unrestricted double y);
753
  void rotate(unrestricted double angle);
754
  void translate(unrestricted double x, unrestricted double y);
755
  void transform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
756
  void setTransform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
757
  void resetTransform();
758
 
759
  // compositing
760
           attribute unrestricted double globalAlpha; // (default 1.0)
761
           attribute DOMString globalCompositeOperation; // (default source-over)
762
 
763
  // image smoothing
764
           attribute boolean imageSmoothingEnabled; // (default true)
765
 
766
  // colors and styles (see also the CanvasDrawingStyles interface)
767
           attribute (DOMString or CanvasGradient or CanvasPattern) strokeStyle; // (default black)
768
           attribute (DOMString or CanvasGradient or CanvasPattern) fillStyle; // (default black)
769
  CanvasGradient createLinearGradient(double x0, double y0, double x1, double y1);
770
  CanvasGradient createRadialGradient(double x0, double y0, double r0, double x1, double y1, double r1);
771
  CanvasPattern createPattern((HTMLImageElement or HTMLCanvasElement or HTMLVideoElement) image, DOMString repetition);
772
 
773
  // shadows
774
           attribute unrestricted double shadowOffsetX; // (default 0)
775
           attribute unrestricted double shadowOffsetY; // (default 0)
776
           attribute unrestricted double shadowBlur; // (default 0)
777
           attribute DOMString shadowColor; // (default transparent black)
778
 
779
  // rects
780
  void clearRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
781
  void fillRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
782
  void strokeRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
783
 
784
  // path API (see also CanvasPathMethods)
785
  void beginPath();
786
  void fill();
787
  void fill(Path path);
788
  void stroke();
789
  void stroke(Path path);
790
  void drawSystemFocusRing(Element element);
791
  void drawSystemFocusRing(Path path, Element element);
792
  boolean drawCustomFocusRing(Element element);
793
  boolean drawCustomFocusRing(Path path, Element element);
794
  void scrollPathIntoView();
795
  void scrollPathIntoView(Path path);
796
  void clip();
797
  void clip(Path path);
798
  void resetClip();
799
  boolean isPointInPath(unrestricted double x, unrestricted double y);
800
  boolean isPointInPath(Path path, unrestricted double x, unrestricted double y);
801
 
802
  // text (see also the CanvasDrawingStyles interface)
803
  void fillText(DOMString text, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
804
  void strokeText(DOMString text, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
805
  TextMetrics measureText(DOMString text);
806
 
807
  // drawing images
808
  void drawImage((HTMLImageElement or HTMLCanvasElement or HTMLVideoElement) image, unrestricted double dx, unrestricted double dy);
809
  void drawImage((HTMLImageElement or HTMLCanvasElement or HTMLVideoElement) image, unrestricted double dx, unrestricted double dy, unrestricted double dw, unrestricted double dh);
810
  void drawImage((HTMLImageElement or HTMLCanvasElement or HTMLVideoElement) image, unrestricted double sx, unrestricted double sy, unrestricted double sw, unrestricted double sh, unrestricted double dx, unrestricted double dy, unrestricted double dw, unrestricted double dh);
811
 
812
  // hit regions
813
  void addHitRegion(HitRegionOptions options);
814
  void removeHitRegion(HitRegionOptions options);
815
 
816
  // pixel manipulation
817
  ImageData createImageData(double sw, double sh);
818
  ImageData createImageData(ImageData imagedata);
819
  ImageData createImageDataHD(double sw, double sh);
820
  ImageData getImageData(double sx, double sy, double sw, double sh);
821
  ImageData getImageDataHD(double sx, double sy, double sw, double sh);
822
  void putImageData(ImageData imagedata, double dx, double dy);
823
  void putImageData(ImageData imagedata, double dx, double dy, double dirtyX, double dirtyY, double dirtyWidth, double dirtyHeight);
824
  void putImageDataHD(ImageData imagedata, double dx, double dy);
825
  void putImageDataHD(ImageData imagedata, double dx, double dy, double dirtyX, double dirtyY, double dirtyWidth, double dirtyHeight);
826
};
827
CanvasRenderingContext2D implements CanvasDrawingStyles;
828
CanvasRenderingContext2D implements CanvasPathMethods;
829
 
830
[NoInterfaceObject]
831
interface CanvasDrawingStyles {
832
  // line caps/joins
833
           attribute unrestricted double lineWidth; // (default 1)
834
           attribute DOMString lineCap; // "butt", "round", "square" (default "butt")
835
           attribute DOMString lineJoin; // "round", "bevel", "miter" (default "miter")
836
           attribute unrestricted double miterLimit; // (default 10)
837
 
838
  // dashed lines
839
  void setLineDash(sequence segments); // default empty
840
  sequence getLineDash();
841
           attribute unrestricted double lineDashOffset;
842
 
843
  // text
844
           attribute DOMString font; // (default 10px sans-serif)
845
           attribute DOMString textAlign; // "start", "end", "left", "right", "center" (default: "start")
846
           attribute DOMString textBaseline; // "top", "hanging", "middle", "alphabetic", "ideographic", "bottom" (default: "alphabetic")
847
};
848
 
849
[NoInterfaceObject]
850
interface CanvasPathMethods {
851
  // shared path API methods
852
  void closePath();
853
  void moveTo(unrestricted double x, unrestricted double y);
854
  void lineTo(unrestricted double x, unrestricted double y);
855
  void quadraticCurveTo(unrestricted double cpx, unrestricted double cpy, unrestricted double x, unrestricted double y);
856
  void bezierCurveTo(unrestricted double cp1x, unrestricted double cp1y, unrestricted double cp2x, unrestricted double cp2y, unrestricted double x, unrestricted double y);
857
  void arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
858
  void arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation);
859
  void rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
860
  void arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
861
  void ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, boolean anticlockwise);
862
};
863
 
864
interface CanvasGradient {
865
  // opaque object
866
  void addColorStop(double offset, DOMString color);
867
};
868
 
869
interface CanvasPattern {
870
  // opaque object
871
  void setTransform(SVGMatrix transform);
872
};
873
 
874
interface TextMetrics {
875
  // x-direction
876
  readonly attribute double width; // advance width
877
  readonly attribute double actualBoundingBoxLeft;
878
  readonly attribute double actualBoundingBoxRight;
879
 
880
  // y-direction
881
  readonly attribute double fontBoundingBoxAscent;
882
  readonly attribute double fontBoundingBoxDescent;
883
  readonly attribute double actualBoundingBoxAscent;
884
  readonly attribute double actualBoundingBoxDescent;
885
  readonly attribute double emHeightAscent;
886
  readonly attribute double emHeightDescent;
887
  readonly attribute double hangingBaseline;
888
  readonly attribute double alphabeticBaseline;
889
  readonly attribute double ideographicBaseline;
890
};
891
 
892
dictionary HitRegionOptions {
893
  Path? path = null;
894
  DOMString id = "";
895
  DOMString? parentID = null;
896
  DOMString cursor = "inherit";
897
  // for control-backed regions:
898
  Element? control = null;
899
  // for unbacked regions:
900
  DOMString? label = null;
901
  DOMString? role = null;
902
};
903
 
904
interface ImageData {
905
  readonly attribute unsigned long width;
906
  readonly attribute unsigned long height;
907
  readonly attribute Uint8ClampedArray data;
908
};
909
 
910
[Constructor(optional Element scope)]
911
interface DrawingStyle { };
912
DrawingStyle implements CanvasDrawingStyles;
913
 
914
[Constructor,
915
 Constructor(Path path),
916
 Constructor(DOMString d)]
917
interface Path {
918
  void addPath(Path path, SVGMatrix? transformation);
919
  void addPathByStrokingPath(Path path, CanvasDrawingStyles styles, SVGMatrix? transformation);
920
  void addText(DOMString text, CanvasDrawingStyles styles, SVGMatrix? transformation, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
921
  void addPathByStrokingText(DOMString text, CanvasDrawingStyles styles, SVGMatrix? transformation, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
922
  void addText(DOMString text, CanvasDrawingStyles styles, SVGMatrix? transformation, Path path, optional unrestricted double maxWidth);
923
  void addPathByStrokingText(DOMString text, CanvasDrawingStyles styles, SVGMatrix? transformation, Path path, optional unrestricted double maxWidth);
924
};
925
Path implements CanvasPathMethods;
926
 
927
partial interface Screen {
928
  readonly attribute double canvasResolution;
929
};
930
 
931
partial interface MouseEvent {
932
  readonly attribute DOMString? region;
933
};
934
 
935
partial dictionary MouseEventInit {
936
  DOMString? region;
937
};
938
 
939
interface HTMLMapElement : HTMLElement {
940
           attribute DOMString name;
941
  readonly attribute HTMLCollection areas;
942
  readonly attribute HTMLCollection images;
943
};
944
 
945
interface HTMLAreaElement : HTMLElement {
946
           attribute DOMString alt;
947
           attribute DOMString coords;
948
           attribute DOMString shape;
949
  stringifier attribute DOMString href;
950
           attribute DOMString target;
951
 
952
           attribute DOMString download;
953
           attribute DOMString ping;
954
 
955
           attribute DOMString rel;
956
  readonly attribute DOMTokenList relList;
957
           attribute DOMString media;
958
           attribute DOMString hreflang;
959
           attribute DOMString type;
960
 
961
  // URL decomposition IDL attributes
962
           attribute DOMString protocol;
963
           attribute DOMString host;
964
           attribute DOMString hostname;
965
           attribute DOMString port;
966
           attribute DOMString pathname;
967
           attribute DOMString search;
968
           attribute DOMString hash;
969
};
970
 
971
interface HTMLTableElement : HTMLElement {
972
           attribute HTMLTableCaptionElement? caption;
973
  HTMLElement createCaption();
974
  void deleteCaption();
975
           attribute HTMLTableSectionElement? tHead;
976
  HTMLElement createTHead();
977
  void deleteTHead();
978
           attribute HTMLTableSectionElement? tFoot;
979
  HTMLElement createTFoot();
980
  void deleteTFoot();
981
  readonly attribute HTMLCollection tBodies;
982
  HTMLElement createTBody();
983
  readonly attribute HTMLCollection rows;
984
  HTMLElement insertRow(optional long index);
985
  void deleteRow(long index);
986
};
987
 
988
interface HTMLTableCaptionElement : HTMLElement {};
989
 
990
interface HTMLTableColElement : HTMLElement {
991
           attribute unsigned long span;
992
};
993
 
994
interface HTMLTableSectionElement : HTMLElement {
995
  readonly attribute HTMLCollection rows;
996
  HTMLElement insertRow(optional long index);
997
  void deleteRow(long index);
998
};
999
 
1000
interface HTMLTableRowElement : HTMLElement {
1001
  readonly attribute long rowIndex;
1002
  readonly attribute long sectionRowIndex;
1003
  readonly attribute HTMLCollection cells;
1004
  HTMLElement insertCell(optional long index);
1005
  void deleteCell(long index);
1006
};
1007
 
1008
interface HTMLTableDataCellElement : HTMLTableCellElement {};
1009
 
1010
interface HTMLTableHeaderCellElement : HTMLTableCellElement {
1011
           attribute DOMString scope;
1012
           attribute DOMString abbr;
1013
};
1014
 
1015
interface HTMLTableCellElement : HTMLElement {
1016
           attribute unsigned long colSpan;
1017
           attribute unsigned long rowSpan;
1018
  [PutForwards=value] readonly attribute DOMSettableTokenList headers;
1019
  readonly attribute long cellIndex;
1020
};
1021
 
1022
[OverrideBuiltins]
1023
interface HTMLFormElement : HTMLElement {
1024
           attribute DOMString acceptCharset;
1025
           attribute DOMString action;
1026
           attribute DOMString autocomplete;
1027
           attribute DOMString enctype;
1028
           attribute DOMString encoding;
1029
           attribute DOMString method;
1030
           attribute DOMString name;
1031
           attribute boolean noValidate;
1032
           attribute DOMString target;
1033
 
1034
  readonly attribute HTMLFormControlsCollection elements;
1035
  readonly attribute long length;
1036
  getter Element (unsigned long index);
1037
  getter object (DOMString name);
1038
 
1039
  void submit();
1040
  void reset();
1041
  boolean checkValidity();
1042
};
1043
 
1044
interface HTMLFieldSetElement : HTMLElement {
1045
           attribute boolean disabled;
1046
  readonly attribute HTMLFormElement? form;
1047
           attribute DOMString name;
1048
 
1049
  readonly attribute DOMString type;
1050
 
1051
  readonly attribute HTMLFormControlsCollection elements;
1052
 
1053
  readonly attribute boolean willValidate;
1054
  readonly attribute ValidityState validity;
1055
  readonly attribute DOMString validationMessage;
1056
  boolean checkValidity();
1057
  void setCustomValidity(DOMString error);
1058
};
1059
 
1060
interface HTMLLegendElement : HTMLElement {
1061
  readonly attribute HTMLFormElement? form;
1062
};
1063
 
1064
interface HTMLLabelElement : HTMLElement {
1065
  readonly attribute HTMLFormElement? form;
1066
           attribute DOMString htmlFor;
1067
  readonly attribute HTMLElement? control;
1068
};
1069
 
1070
interface HTMLInputElement : HTMLElement {
1071
           attribute DOMString accept;
1072
           attribute DOMString alt;
1073
           attribute DOMString autocomplete;
1074
           attribute boolean autofocus;
1075
           attribute boolean defaultChecked;
1076
           attribute boolean checked;
1077
           attribute DOMString dirName;
1078
           attribute boolean disabled;
1079
  readonly attribute HTMLFormElement? form;
1080
  readonly attribute FileList? files;
1081
           attribute DOMString formAction;
1082
           attribute DOMString formEnctype;
1083
           attribute DOMString formMethod;
1084
           attribute boolean formNoValidate;
1085
           attribute DOMString formTarget;
1086
           attribute unsigned long height;
1087
           attribute boolean indeterminate;
1088
           attribute DOMString inputMode;
1089
  readonly attribute HTMLElement? list;
1090
           attribute DOMString max;
1091
           attribute long maxLength;
1092
           attribute DOMString min;
1093
           attribute boolean multiple;
1094
           attribute DOMString name;
1095
           attribute DOMString pattern;
1096
           attribute DOMString placeholder;
1097
           attribute boolean readOnly;
1098
           attribute boolean required;
1099
           attribute unsigned long size;
1100
           attribute DOMString src;
1101
           attribute DOMString step;
1102
           attribute DOMString type;
1103
           attribute DOMString defaultValue;
1104
  [TreatNullAs=EmptyString] attribute DOMString value;
1105
           attribute Date? valueAsDate;
1106
           attribute unrestricted double valueAsNumber;
1107
           attribute unsigned long width;
1108
 
1109
  void stepUp(optional long n);
1110
  void stepDown(optional long n);
1111
 
1112
  readonly attribute boolean willValidate;
1113
  readonly attribute ValidityState validity;
1114
  readonly attribute DOMString validationMessage;
1115
  boolean checkValidity();
1116
  void setCustomValidity(DOMString error);
1117
 
1118
  readonly attribute NodeList labels;
1119
 
1120
  void select();
1121
           attribute unsigned long selectionStart;
1122
           attribute unsigned long selectionEnd;
1123
           attribute DOMString selectionDirection;
1124
 
1125
  void setRangeText(DOMString replacement);
1126
  void setRangeText(DOMString replacement, unsigned long start, unsigned long end, optional SelectionMode selectionMode);
1127
 
1128
  void setSelectionRange(unsigned long start, unsigned long end, optional DOMString direction);
1129
};
1130
 
1131
interface HTMLButtonElement : HTMLElement {
1132
           attribute boolean autofocus;
1133
           attribute boolean disabled;
1134
  readonly attribute HTMLFormElement? form;
1135
           attribute DOMString formAction;
1136
           attribute DOMString formEnctype;
1137
           attribute DOMString formMethod;
1138
           attribute boolean formNoValidate;
1139
           attribute DOMString formTarget;
1140
           attribute DOMString name;
1141
           attribute DOMString type;
1142
           attribute DOMString value;
1143
 
1144
  readonly attribute boolean willValidate;
1145
  readonly attribute ValidityState validity;
1146
  readonly attribute DOMString validationMessage;
1147
  boolean checkValidity();
1148
  void setCustomValidity(DOMString error);
1149
 
1150
  readonly attribute NodeList labels;
1151
};
1152
 
1153
interface HTMLSelectElement : HTMLElement {
1154
           attribute boolean autofocus;
1155
           attribute boolean disabled;
1156
  readonly attribute HTMLFormElement? form;
1157
           attribute boolean multiple;
1158
           attribute DOMString name;
1159
           attribute boolean required;
1160
           attribute unsigned long size;
1161
 
1162
  readonly attribute DOMString type;
1163
 
1164
  readonly attribute HTMLOptionsCollection options;
1165
           attribute unsigned long length;
1166
  getter Element item(unsigned long index);
1167
  object namedItem(DOMString name);
1168
  void add((HTMLOptionElement or HTMLOptGroupElement) element, optional (HTMLElement or long)? before = null);
1169
  void remove(long index);
1170
  setter creator void (unsigned long index, HTMLOptionElement? option);
1171
 
1172
  readonly attribute HTMLCollection selectedOptions;
1173
           attribute long selectedIndex;
1174
           attribute DOMString value;
1175
 
1176
  readonly attribute boolean willValidate;
1177
  readonly attribute ValidityState validity;
1178
  readonly attribute DOMString validationMessage;
1179
  boolean checkValidity();
1180
  void setCustomValidity(DOMString error);
1181
 
1182
  readonly attribute NodeList labels;
1183
};
1184
 
1185
interface HTMLDataListElement : HTMLElement {
1186
  readonly attribute HTMLCollection options;
1187
};
1188
 
1189
interface HTMLOptGroupElement : HTMLElement {
1190
           attribute boolean disabled;
1191
           attribute DOMString label;
1192
};
1193
 
1194
[NamedConstructor=Option(),
1195
 NamedConstructor=Option(DOMString text),
1196
 NamedConstructor=Option(DOMString text, DOMString value),
1197
 NamedConstructor=Option(DOMString text, DOMString value, boolean defaultSelected),
1198
 NamedConstructor=Option(DOMString text, DOMString value, boolean defaultSelected, boolean selected)]
1199
interface HTMLOptionElement : HTMLElement {
1200
           attribute boolean disabled;
1201
  readonly attribute HTMLFormElement? form;
1202
           attribute DOMString label;
1203
           attribute boolean defaultSelected;
1204
           attribute boolean selected;
1205
           attribute DOMString value;
1206
 
1207
           attribute DOMString text;
1208
  readonly attribute long index;
1209
};
1210
 
1211
interface HTMLTextAreaElement : HTMLElement {
1212
           attribute DOMString autocomplete;
1213
           attribute boolean autofocus;
1214
           attribute unsigned long cols;
1215
           attribute DOMString dirName;
1216
           attribute boolean disabled;
1217
  readonly attribute HTMLFormElement? form;
1218
           attribute DOMString inputMode;
1219
           attribute long maxLength;
1220
           attribute DOMString name;
1221
           attribute DOMString placeholder;
1222
           attribute boolean readOnly;
1223
           attribute boolean required;
1224
           attribute unsigned long rows;
1225
           attribute DOMString wrap;
1226
 
1227
  readonly attribute DOMString type;
1228
           attribute DOMString defaultValue;
1229
  [TreatNullAs=EmptyString] attribute DOMString value;
1230
  readonly attribute unsigned long textLength;
1231
 
1232
  readonly attribute boolean willValidate;
1233
  readonly attribute ValidityState validity;
1234
  readonly attribute DOMString validationMessage;
1235
  boolean checkValidity();
1236
  void setCustomValidity(DOMString error);
1237
 
1238
  readonly attribute NodeList labels;
1239
 
1240
  void select();
1241
           attribute unsigned long selectionStart;
1242
           attribute unsigned long selectionEnd;
1243
           attribute DOMString selectionDirection;
1244
 
1245
  void setRangeText(DOMString replacement);
1246
  void setRangeText(DOMString replacement, unsigned long start, unsigned long end, optional SelectionMode selectionMode);
1247
 
1248
  void setSelectionRange(unsigned long start, unsigned long end, optional DOMString direction);
1249
};
1250
 
1251
interface HTMLKeygenElement : HTMLElement {
1252
           attribute boolean autofocus;
1253
           attribute DOMString challenge;
1254
           attribute boolean disabled;
1255
  readonly attribute HTMLFormElement? form;
1256
           attribute DOMString keytype;
1257
           attribute DOMString name;
1258
 
1259
  readonly attribute DOMString type;
1260
 
1261
  readonly attribute boolean willValidate;
1262
  readonly attribute ValidityState validity;
1263
  readonly attribute DOMString validationMessage;
1264
  boolean checkValidity();
1265
  void setCustomValidity(DOMString error);
1266
 
1267
  readonly attribute NodeList labels;
1268
};
1269
 
1270
interface HTMLOutputElement : HTMLElement {
1271
  [PutForwards=value] readonly attribute DOMSettableTokenList htmlFor;
1272
  readonly attribute HTMLFormElement? form;
1273
           attribute DOMString name;
1274
 
1275
  readonly attribute DOMString type;
1276
           attribute DOMString defaultValue;
1277
           attribute DOMString value;
1278
 
1279
  readonly attribute boolean willValidate;
1280
  readonly attribute ValidityState validity;
1281
  readonly attribute DOMString validationMessage;
1282
  boolean checkValidity();
1283
  void setCustomValidity(DOMString error);
1284
 
1285
  readonly attribute NodeList labels;
1286
};
1287
 
1288
interface HTMLProgressElement : HTMLElement {
1289
           attribute double value;
1290
           attribute double max;
1291
  readonly attribute double position;
1292
  readonly attribute NodeList labels;
1293
};
1294
 
1295
interface HTMLMeterElement : HTMLElement {
1296
           attribute double value;
1297
           attribute double min;
1298
           attribute double max;
1299
           attribute double low;
1300
           attribute double high;
1301
           attribute double optimum;
1302
  readonly attribute NodeList labels;
1303
};
1304
 
1305
interface ValidityState {
1306
  readonly attribute boolean valueMissing;
1307
  readonly attribute boolean typeMismatch;
1308
  readonly attribute boolean patternMismatch;
1309
  readonly attribute boolean tooLong;
1310
  readonly attribute boolean rangeUnderflow;
1311
  readonly attribute boolean rangeOverflow;
1312
  readonly attribute boolean stepMismatch;
1313
  readonly attribute boolean customError;
1314
  readonly attribute boolean valid;
1315
};
1316
 
1317
interface HTMLDetailsElement : HTMLElement {
1318
           attribute boolean open;
1319
};
1320
 
1321
interface HTMLCommandElement : HTMLElement {
1322
           attribute DOMString type;
1323
           attribute DOMString label;
1324
           attribute DOMString icon;
1325
           attribute boolean disabled;
1326
           attribute boolean checked;
1327
           attribute DOMString radiogroup;
1328
  readonly attribute HTMLElement? command;
1329
};
1330
 
1331
interface HTMLMenuElement : HTMLElement {
1332
           attribute DOMString type;
1333
           attribute DOMString label;
1334
};
1335
 
1336
interface HTMLDialogElement : HTMLElement {
1337
           attribute boolean open;
1338
           attribute DOMString returnValue;
1339
  void show(optional (MouseEvent or Element) anchor);
1340
  void showModal(optional (MouseEvent or Element) anchor);
1341
  void close(optional DOMString returnValue);
1342
};
1343
 
1344
[NamedPropertiesObject]
1345
interface Window : EventTarget {
1346
  // the current browsing context
1347
  [Unforgeable] readonly attribute WindowProxy window;
1348
  [Replaceable] readonly attribute WindowProxy self;
1349
  [Unforgeable] readonly attribute Document document;
1350
           attribute DOMString name;
1351
  [PutForwards=href, Unforgeable] readonly attribute Location location;
1352
  readonly attribute History history;
1353
  [Replaceable] readonly attribute BarProp locationbar;
1354
  [Replaceable] readonly attribute BarProp menubar;
1355
  [Replaceable] readonly attribute BarProp personalbar;
1356
  [Replaceable] readonly attribute BarProp scrollbars;
1357
  [Replaceable] readonly attribute BarProp statusbar;
1358
  [Replaceable] readonly attribute BarProp toolbar;
1359
           attribute DOMString status;
1360
  void close();
1361
  void stop();
1362
  void focus();
1363
  void blur();
1364
 
1365
  // other browsing contexts
1366
  [Replaceable] readonly attribute WindowProxy frames;
1367
  [Replaceable] readonly attribute unsigned long length;
1368
  [Unforgeable] readonly attribute WindowProxy top;
1369
           attribute WindowProxy? opener;
1370
  readonly attribute WindowProxy parent;
1371
  readonly attribute Element? frameElement;
1372
  WindowProxy open(optional DOMString url, optional DOMString target, optional DOMString features, optional boolean replace);
1373
  getter WindowProxy (unsigned long index);
1374
  getter object (DOMString name);
1375
 
1376
  // the user agent
1377
  readonly attribute Navigator navigator;
1378
 
1379
  readonly attribute External external;
1380
  readonly attribute ApplicationCache applicationCache;
1381
 
1382
  // user prompts
1383
  void alert(DOMString message);
1384
  boolean confirm(DOMString message);
1385
  DOMString? prompt(DOMString message, optional DOMString default);
1386
  void print();
1387
  any showModalDialog(DOMString url, optional any argument);
1388
 
1389
  // cross-document messaging
1390
  void postMessage(any message, DOMString targetOrigin, optional sequence transfer);
1391
 
1392
  // event handler IDL attributes
1393
           attribute EventHandler onabort;
1394
           attribute EventHandler onafterprint;
1395
           attribute EventHandler onbeforeprint;
1396
           attribute EventHandler onbeforeunload;
1397
           attribute EventHandler onblur;
1398
           attribute EventHandler oncancel;
1399
           attribute EventHandler oncanplay;
1400
           attribute EventHandler oncanplaythrough;
1401
           attribute EventHandler onchange;
1402
           attribute EventHandler onclick;
1403
           attribute EventHandler onclose;
1404
           attribute EventHandler oncontextmenu;
1405
           attribute EventHandler oncuechange;
1406
           attribute EventHandler ondblclick;
1407
           attribute EventHandler ondrag;
1408
           attribute EventHandler ondragend;
1409
           attribute EventHandler ondragenter;
1410
           attribute EventHandler ondragleave;
1411
           attribute EventHandler ondragover;
1412
           attribute EventHandler ondragstart;
1413
           attribute EventHandler ondrop;
1414
           attribute EventHandler ondurationchange;
1415
           attribute EventHandler onemptied;
1416
           attribute EventHandler onended;
1417
           attribute OnErrorEventHandler onerror;
1418
           attribute EventHandler onfocus;
1419
           attribute EventHandler onhashchange;
1420
           attribute EventHandler oninput;
1421
           attribute EventHandler oninvalid;
1422
           attribute EventHandler onkeydown;
1423
           attribute EventHandler onkeypress;
1424
           attribute EventHandler onkeyup;
1425
           attribute EventHandler onload;
1426
           attribute EventHandler onloadeddata;
1427
           attribute EventHandler onloadedmetadata;
1428
           attribute EventHandler onloadstart;
1429
           attribute EventHandler onmessage;
1430
           attribute EventHandler onmousedown;
1431
           attribute EventHandler onmousemove;
1432
           attribute EventHandler onmouseout;
1433
           attribute EventHandler onmouseover;
1434
           attribute EventHandler onmouseup;
1435
           attribute EventHandler onmousewheel;
1436
           attribute EventHandler onoffline;
1437
           attribute EventHandler ononline;
1438
           attribute EventHandler onpause;
1439
           attribute EventHandler onplay;
1440
           attribute EventHandler onplaying;
1441
           attribute EventHandler onpagehide;
1442
           attribute EventHandler onpageshow;
1443
           attribute EventHandler onpopstate;
1444
           attribute EventHandler onprogress;
1445
           attribute EventHandler onratechange;
1446
           attribute EventHandler onreset;
1447
           attribute EventHandler onresize;
1448
           attribute EventHandler onscroll;
1449
           attribute EventHandler onseeked;
1450
           attribute EventHandler onseeking;
1451
           attribute EventHandler onselect;
1452
           attribute EventHandler onshow;
1453
           attribute EventHandler onstalled;
1454
           attribute EventHandler onstorage;
1455
           attribute EventHandler onsubmit;
1456
           attribute EventHandler onsuspend;
1457
           attribute EventHandler ontimeupdate;
1458
           attribute EventHandler onunload;
1459
           attribute EventHandler onvolumechange;
1460
           attribute EventHandler onwaiting;
1461
};
1462
 
1463
interface BarProp {
1464
           attribute boolean visible;
1465
};
1466
 
1467
interface History {
1468
  readonly attribute long length;
1469
  readonly attribute any state;
1470
  void go(optional long delta);
1471
  void back();
1472
  void forward();
1473
  void pushState(any data, DOMString title, optional DOMString url);
1474
  void replaceState(any data, DOMString title, optional DOMString url);
1475
};
1476
 
1477
interface Location {
1478
  stringifier attribute DOMString href;
1479
  void assign(DOMString url);
1480
  void replace(DOMString url);
1481
  void reload();
1482
 
1483
  // URL decomposition IDL attributes
1484
           attribute DOMString protocol;
1485
           attribute DOMString host;
1486
           attribute DOMString hostname;
1487
           attribute DOMString port;
1488
           attribute DOMString pathname;
1489
           attribute DOMString search;
1490
           attribute DOMString hash;
1491
};
1492
 
1493
[Constructor(DOMString type, optional PopStateEventInit eventInitDict)]
1494
interface PopStateEvent : Event {
1495
  readonly attribute any state;
1496
};
1497
 
1498
dictionary PopStateEventInit : EventInit {
1499
  any state;
1500
};
1501
 
1502
[Constructor(DOMString type, optional HashChangeEventInit eventInitDict)]
1503
interface HashChangeEvent : Event {
1504
  readonly attribute DOMString oldURL;
1505
  readonly attribute DOMString newURL;
1506
};
1507
 
1508
dictionary HashChangeEventInit : EventInit {
1509
  DOMString oldURL;
1510
  DOMString newURL;
1511
};
1512
 
1513
[Constructor(DOMString type, optional PageTransitionEventInit eventInitDict)]
1514
interface PageTransitionEvent : Event {
1515
  readonly attribute boolean persisted;
1516
};
1517
 
1518
dictionary PageTransitionEventInit : EventInit {
1519
  boolean persisted;
1520
};
1521
 
1522
interface BeforeUnloadEvent : Event {
1523
           attribute DOMString returnValue;
1524
};
1525
 
1526
interface ApplicationCache : EventTarget {
1527
 
1528
  // update status
1529
  const unsigned short UNCACHED = 0;
1530
  const unsigned short IDLE = 1;
1531
  const unsigned short CHECKING = 2;
1532
  const unsigned short DOWNLOADING = 3;
1533
  const unsigned short UPDATEREADY = 4;
1534
  const unsigned short OBSOLETE = 5;
1535
  readonly attribute unsigned short status;
1536
 
1537
  // updates
1538
  void update();
1539
  void abort();
1540
  void swapCache();
1541
 
1542
  // events
1543
           attribute EventHandler onchecking;
1544
           attribute EventHandler onerror;
1545
           attribute EventHandler onnoupdate;
1546
           attribute EventHandler ondownloading;
1547
           attribute EventHandler onprogress;
1548
           attribute EventHandler onupdateready;
1549
           attribute EventHandler oncached;
1550
           attribute EventHandler onobsolete;
1551
};
1552
 
1553
[NoInterfaceObject]
1554
interface NavigatorOnLine {
1555
  readonly attribute boolean onLine;
1556
};
1557
 
1558
[TreatNonCallableAsNull]
1559
callback EventHandlerNonNull = any (Event event);
1560
typedef EventHandlerNonNull? EventHandler;
1561
 
1562
[TreatNonCallableAsNull]
1563
callback OnErrorEventHandlerNonNull = any ((Event or DOMString) event, DOMString source, unsigned long lineno, unsigned long column);
1564
typedef OnErrorEventHandlerNonNull? OnErrorEventHandler;
1565
 
1566
[NoInterfaceObject]
1567
interface WindowBase64 {
1568
  DOMString btoa(DOMString btoa);
1569
  DOMString atob(DOMString atob);
1570
};
1571
Window implements WindowBase64;
1572
 
1573
[NoInterfaceObject]
1574
interface WindowTimers {
1575
  long setTimeout(Function handler, optional long timeout, any... arguments);
1576
  long setTimeout(DOMString handler, optional long timeout, any... arguments);
1577
  void clearTimeout(long handle);
1578
  long setInterval(Function handler, optional long timeout, any... arguments);
1579
  long setInterval(DOMString handler, optional long timeout, any... arguments);
1580
  void clearInterval(long handle);
1581
};
1582
Window implements WindowTimers;
1583
 
1584
[NoInterfaceObject] interface WindowModal {
1585
  readonly attribute any dialogArguments;
1586
           attribute DOMString returnValue;
1587
};
1588
 
1589
interface Navigator {
1590
  // objects implementing this interface also implement the interfaces given below
1591
};
1592
Navigator implements NavigatorID;
1593
Navigator implements NavigatorOnLine;
1594
Navigator implements NavigatorContentUtils;
1595
Navigator implements NavigatorStorageUtils;
1596
 
1597
[NoInterfaceObject]
1598
interface NavigatorID {
1599
  readonly attribute DOMString appName;
1600
  readonly attribute DOMString appVersion;
1601
  readonly attribute DOMString platform;
1602
  readonly attribute DOMString userAgent;
1603
};
1604
 
1605
[NoInterfaceObject]
1606
interface NavigatorContentUtils {
1607
  // content handler registration
1608
  void registerProtocolHandler(DOMString scheme, DOMString url, DOMString title);
1609
  void registerContentHandler(DOMString mimeType, DOMString url, DOMString title);
1610
  DOMString isProtocolHandlerRegistered(DOMString scheme, DOMString url);
1611
  DOMString isContentHandlerRegistered(DOMString mimeType, DOMString url);
1612
  void unregisterProtocolHandler(DOMString scheme, DOMString url);
1613
  void unregisterContentHandler(DOMString mimeType, DOMString url);
1614
};
1615
 
1616
[NoInterfaceObject]
1617
interface NavigatorStorageUtils {
1618
  void yieldForStorageUpdates();
1619
};
1620
 
1621
interface External {
1622
  void AddSearchProvider(DOMString engineURL);
1623
  unsigned long IsSearchProviderInstalled(DOMString engineURL);
1624
};
1625
 
1626
interface DataTransfer {
1627
           attribute DOMString dropEffect;
1628
           attribute DOMString effectAllowed;
1629
 
1630
  readonly attribute DataTransferItemList items;
1631
 
1632
  void setDragImage(Element image, long x, long y);
1633
 
1634
  /* old interface */
1635
  readonly attribute DOMString[] types;
1636
  DOMString getData(DOMString format);
1637
  void setData(DOMString format, DOMString data);
1638
  void clearData(optional DOMString format);
1639
  readonly attribute FileList files;
1640
};
1641
 
1642
interface DataTransferItemList {
1643
  readonly attribute unsigned long length;
1644
  getter DataTransferItem (unsigned long index);
1645
  deleter void (unsigned long index);
1646
  void clear();
1647
 
1648
  DataTransferItem? add(DOMString data, DOMString type);
1649
  DataTransferItem? add(File data);
1650
};
1651
 
1652
interface DataTransferItem {
1653
  readonly attribute DOMString kind;
1654
  readonly attribute DOMString type;
1655
  void getAsString(FunctionStringCallback? _callback);
1656
 
1657
  File? getAsFile();
1658
};
1659
 
1660
[Callback, NoInterfaceObject]
1661
interface FunctionStringCallback {
1662
  void handleEvent(DOMString data);
1663
};
1664
 
1665
[Constructor(DOMString type, optional DragEventInit eventInitDict)]
1666
interface DragEvent : MouseEvent {
1667
  readonly attribute DataTransfer? dataTransfer;
1668
};
1669
 
1670
dictionary DragEventInit : MouseEventInit {
1671
  DataTransfer? dataTransfer;
1672
};
1673
 
1674
interface WorkerGlobalScope : EventTarget {
1675
  readonly attribute WorkerGlobalScope self;
1676
  readonly attribute WorkerLocation location;
1677
 
1678
  void close();
1679
           attribute EventHandler onerror;
1680
           attribute EventHandler onoffline;
1681
           attribute EventHandler ononline;
1682
};
1683
WorkerGlobalScope implements WorkerUtils;
1684
 
1685
interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
1686
  void postMessage(any message, optional sequence transfer);
1687
           attribute EventHandler onmessage;
1688
};
1689
 
1690
interface SharedWorkerGlobalScope : WorkerGlobalScope {
1691
  readonly attribute DOMString name;
1692
  readonly attribute ApplicationCache applicationCache;
1693
           attribute EventHandler onconnect;
1694
};
1695
 
1696
[Constructor(DOMString type, optional ErrorEventInit eventInitDict)]
1697
interface ErrorEvent : Event {
1698
  readonly attribute DOMString message;
1699
  readonly attribute DOMString filename;
1700
  readonly attribute unsigned long lineno;
1701
  readonly attribute unsigned long column;
1702
};
1703
 
1704
dictionary ErrorEventInit : EventInit {
1705
  DOMString message;
1706
  DOMString filename;
1707
  unsigned long lineno;
1708
  unsigned long column;
1709
};
1710
 
1711
[NoInterfaceObject]
1712
interface AbstractWorker {
1713
           attribute EventHandler onerror;
1714
 
1715
};
1716
 
1717
[Constructor(DOMString scriptURL)]
1718
interface Worker : EventTarget {
1719
  void terminate();
1720
 
1721
  void postMessage(any message, optional sequence transfer);
1722
           attribute EventHandler onmessage;
1723
};
1724
Worker implements AbstractWorker;
1725
 
1726
[Constructor(DOMString scriptURL, optional DOMString name)]
1727
interface SharedWorker : EventTarget {
1728
  readonly attribute MessagePort port;
1729
};
1730
SharedWorker implements AbstractWorker;
1731
 
1732
[NoInterfaceObject]
1733
interface WorkerUtils {
1734
  void importScripts(DOMString... urls);
1735
  readonly attribute WorkerNavigator navigator;
1736
};
1737
WorkerUtils implements WindowTimers;
1738
WorkerUtils implements WindowBase64;
1739
 
1740
interface WorkerNavigator {};
1741
WorkerNavigator implements NavigatorID;
1742
WorkerNavigator implements NavigatorOnLine;
1743
 
1744
interface WorkerLocation {
1745
  // URL decomposition IDL attributes
1746
  stringifier readonly attribute DOMString href;
1747
  readonly attribute DOMString protocol;
1748
  readonly attribute DOMString host;
1749
  readonly attribute DOMString hostname;
1750
  readonly attribute DOMString port;
1751
  readonly attribute DOMString pathname;
1752
  readonly attribute DOMString search;
1753
  readonly attribute DOMString hash;
1754
};
1755
 
1756
[Constructor(DOMString type, optional MessageEventInit eventInitDict)]
1757
interface MessageEvent : Event {
1758
  readonly attribute any data;
1759
  readonly attribute DOMString origin;
1760
  readonly attribute DOMString lastEventId;
1761
  readonly attribute (WindowProxy or MessagePort)? source;
1762
  readonly attribute MessagePort[]? ports;
1763
};
1764
 
1765
dictionary MessageEventInit : EventInit {
1766
  any data;
1767
  DOMString origin;
1768
  DOMString lastEventId;
1769
  WindowProxy? source;
1770
  MessagePort[]? ports;
1771
};
1772
 
1773
[Constructor(DOMString url, optional EventSourceInit eventSourceInitDict)]
1774
interface EventSource : EventTarget {
1775
  readonly attribute DOMString url;
1776
  readonly attribute boolean withCredentials;
1777
 
1778
  // ready state
1779
  const unsigned short CONNECTING = 0;
1780
  const unsigned short OPEN = 1;
1781
  const unsigned short CLOSED = 2;
1782
  readonly attribute unsigned short readyState;
1783
 
1784
  // networking
1785
           attribute EventHandler onopen;
1786
           attribute EventHandler onmessage;
1787
           attribute EventHandler onerror;
1788
  void close();
1789
};
1790
 
1791
dictionary EventSourceInit {
1792
  boolean withCredentials = false;
1793
};
1794
 
1795
enum BinaryType { "blob", "arraybuffer" };
1796
[Constructor(DOMString url, optional (DOMString or DOMString[]) protocols)]
1797
interface WebSocket : EventTarget {
1798
  readonly attribute DOMString url;
1799
 
1800
  // ready state
1801
  const unsigned short CONNECTING = 0;
1802
  const unsigned short OPEN = 1;
1803
  const unsigned short CLOSING = 2;
1804
  const unsigned short CLOSED = 3;
1805
  readonly attribute unsigned short readyState;
1806
  readonly attribute unsigned long bufferedAmount;
1807
 
1808
  // networking
1809
           attribute EventHandler onopen;
1810
           attribute EventHandler onerror;
1811
           attribute EventHandler onclose;
1812
  readonly attribute DOMString extensions;
1813
  readonly attribute DOMString protocol;
1814
  void close([Clamp] optional unsigned short code, optional DOMString reason);
1815
 
1816
  // messaging
1817
           attribute EventHandler onmessage;
1818
           attribute BinaryType binaryType;
1819
  void send(DOMString data);
1820
  void send(Blob data);
1821
  void send(ArrayBuffer data);
1822
  void send(ArrayBufferView data);
1823
};
1824
 
1825
[Constructor(DOMString type, optional CloseEventInit eventInitDict)]
1826
interface CloseEvent : Event {
1827
  readonly attribute boolean wasClean;
1828
  readonly attribute unsigned short code;
1829
  readonly attribute DOMString reason;
1830
};
1831
 
1832
dictionary CloseEventInit : EventInit {
1833
  boolean wasClean;
1834
  unsigned short code;
1835
  DOMString reason;
1836
};
1837
 
1838
[Constructor]
1839
interface MessageChannel {
1840
  readonly attribute MessagePort port1;
1841
  readonly attribute MessagePort port2;
1842
};
1843
 
1844
interface MessagePort : EventTarget {
1845
  void postMessage(any message, optional sequence transfer);
1846
  void start();
1847
  void close();
1848
 
1849
  // event handlers
1850
           attribute EventHandler onmessage;
1851
};
1852
MessagePort implements Transferable;
1853
 
1854
interface Storage {
1855
  readonly attribute unsigned long length;
1856
  DOMString? key(unsigned long index);
1857
  getter DOMString getItem(DOMString key);
1858
  setter creator void setItem(DOMString key, DOMString value);
1859
  deleter void removeItem(DOMString key);
1860
  void clear();
1861
};
1862
 
1863
[NoInterfaceObject]
1864
interface WindowSessionStorage {
1865
  readonly attribute Storage sessionStorage;
1866
};
1867
Window implements WindowSessionStorage;
1868
 
1869
[NoInterfaceObject]
1870
interface WindowLocalStorage {
1871
  readonly attribute Storage localStorage;
1872
};
1873
Window implements WindowLocalStorage;
1874
 
1875
[Constructor(DOMString type, optional StorageEventInit eventInitDict)]
1876
interface StorageEvent : Event {
1877
  readonly attribute DOMString? key;
1878
  readonly attribute DOMString? oldValue;
1879
  readonly attribute DOMString? newValue;
1880
  readonly attribute DOMString url;
1881
  readonly attribute Storage? storageArea;
1882
};
1883
 
1884
dictionary StorageEventInit : EventInit {
1885
  DOMString? key;
1886
  DOMString? oldValue;
1887
  DOMString? newValue;
1888
  DOMString url;
1889
  Storage? storageArea;
1890
};
1891
 
1892
interface HTMLAppletElement : HTMLElement {
1893
           attribute DOMString align;
1894
           attribute DOMString alt;
1895
           attribute DOMString archive;
1896
           attribute DOMString code;
1897
           attribute DOMString codeBase;
1898
           attribute DOMString height;
1899
           attribute unsigned long hspace;
1900
           attribute DOMString name;
1901
           attribute DOMString _object; // the underscore is not part of the identifier
1902
           attribute unsigned long vspace;
1903
           attribute DOMString width;
1904
};
1905
 
1906
interface HTMLMarqueeElement : HTMLElement {
1907
           attribute DOMString behavior;
1908
           attribute DOMString bgColor;
1909
           attribute DOMString direction;
1910
           attribute DOMString height;
1911
           attribute unsigned long hspace;
1912
           attribute long loop;
1913
           attribute unsigned long scrollAmount;
1914
           attribute unsigned long scrollDelay;
1915
           attribute boolean trueSpeed;
1916
           attribute unsigned long vspace;
1917
           attribute DOMString width;
1918
 
1919
           attribute EventHandler onbounce;
1920
           attribute EventHandler onfinish;
1921
           attribute EventHandler onstart;
1922
 
1923
  void start();
1924
  void stop();
1925
};
1926
 
1927
interface HTMLFrameSetElement : HTMLElement {
1928
           attribute DOMString cols;
1929
           attribute DOMString rows;
1930
           attribute EventHandler onafterprint;
1931
           attribute EventHandler onbeforeprint;
1932
           attribute EventHandler onbeforeunload;
1933
           attribute EventHandler onblur;
1934
           attribute EventHandler onerror;
1935
           attribute EventHandler onfocus;
1936
           attribute EventHandler onhashchange;
1937
           attribute EventHandler onload;
1938
           attribute EventHandler onmessage;
1939
           attribute EventHandler onoffline;
1940
           attribute EventHandler ononline;
1941
           attribute EventHandler onpagehide;
1942
           attribute EventHandler onpageshow;
1943
           attribute EventHandler onpopstate;
1944
           attribute EventHandler onresize;
1945
           attribute EventHandler onscroll;
1946
           attribute EventHandler onstorage;
1947
           attribute EventHandler onunload;
1948
};
1949
 
1950
interface HTMLFrameElement : HTMLElement {
1951
           attribute DOMString name;
1952
           attribute DOMString scrolling;
1953
           attribute DOMString src;
1954
           attribute DOMString frameBorder;
1955
           attribute DOMString longDesc;
1956
           attribute boolean noResize;
1957
  readonly attribute Document? contentDocument;
1958
  readonly attribute WindowProxy? contentWindow;
1959
 
1960
  [TreatNullAs=EmptyString] attribute DOMString marginHeight;
1961
  [TreatNullAs=EmptyString] attribute DOMString marginWidth;
1962
};
1963
 
1964
partial interface HTMLAnchorElement {
1965
           attribute DOMString coords;
1966
           attribute DOMString charset;
1967
           attribute DOMString name;
1968
           attribute DOMString rev;
1969
           attribute DOMString shape;
1970
};
1971
 
1972
partial interface HTMLAreaElement {
1973
           attribute boolean noHref;
1974
};
1975
 
1976
interface HTMLBaseFontElement : HTMLElement {
1977
           attribute DOMString color;
1978
           attribute DOMString face;
1979
           attribute long size;
1980
 
1981
};
1982
 
1983
partial interface HTMLBodyElement {
1984
  [TreatNullAs=EmptyString] attribute DOMString text;
1985
  [TreatNullAs=EmptyString] attribute DOMString link;
1986
  [TreatNullAs=EmptyString] attribute DOMString vLink;
1987
  [TreatNullAs=EmptyString] attribute DOMString aLink;
1988
  [TreatNullAs=EmptyString] attribute DOMString bgColor;
1989
                            attribute DOMString background;
1990
};
1991
 
1992
partial interface HTMLBRElement {
1993
           attribute DOMString clear;
1994
};
1995
 
1996
partial interface HTMLTableCaptionElement {
1997
           attribute DOMString align;
1998
};
1999
 
2000
partial interface HTMLTableColElement {
2001
           attribute DOMString align;
2002
           attribute DOMString ch;
2003
           attribute DOMString chOff;
2004
           attribute DOMString vAlign;
2005
           attribute DOMString width;
2006
};
2007
 
2008
interface HTMLDirectoryElement : HTMLElement {
2009
           attribute boolean compact;
2010
};
2011
 
2012
partial interface HTMLDivElement {
2013
           attribute DOMString align;
2014
};
2015
 
2016
partial interface HTMLDListElement {
2017
           attribute boolean compact;
2018
};
2019
 
2020
partial interface HTMLEmbedElement {
2021
           attribute DOMString align;
2022
           attribute DOMString name;
2023
};
2024
 
2025
interface HTMLFontElement : HTMLElement {
2026
  [TreatNullAs=EmptyString] attribute DOMString color;
2027
                            attribute DOMString face;
2028
                            attribute DOMString size;
2029
 
2030
};
2031
 
2032
partial interface HTMLHeadingElement {
2033
           attribute DOMString align;
2034
};
2035
 
2036
partial interface HTMLHRElement {
2037
           attribute DOMString align;
2038
           attribute DOMString color;
2039
           attribute boolean noShade;
2040
           attribute DOMString size;
2041
           attribute DOMString width;
2042
};
2043
 
2044
partial interface HTMLHtmlElement {
2045
           attribute DOMString version;
2046
};
2047
 
2048
partial interface HTMLIFrameElement {
2049
           attribute DOMString align;
2050
           attribute DOMString scrolling;
2051
           attribute DOMString frameBorder;
2052
           attribute DOMString longDesc;
2053
 
2054
  [TreatNullAs=EmptyString] attribute DOMString marginHeight;
2055
  [TreatNullAs=EmptyString] attribute DOMString marginWidth;
2056
};
2057
 
2058
partial interface HTMLImageElement {
2059
           attribute DOMString name;
2060
           attribute DOMString align;
2061
           attribute unsigned long hspace;
2062
           attribute unsigned long vspace;
2063
           attribute DOMString longDesc;
2064
 
2065
  [TreatNullAs=EmptyString] attribute DOMString border;
2066
};
2067
 
2068
partial interface HTMLInputElement {
2069
           attribute DOMString align;
2070
           attribute DOMString useMap;
2071
};
2072
 
2073
partial interface HTMLLegendElement {
2074
           attribute DOMString align;
2075
};
2076
 
2077
partial interface HTMLLIElement {
2078
           attribute DOMString type;
2079
};
2080
 
2081
partial interface HTMLLinkElement {
2082
           attribute DOMString charset;
2083
           attribute DOMString rev;
2084
           attribute DOMString target;
2085
};
2086
 
2087
partial interface HTMLMenuElement {
2088
           attribute boolean compact;
2089
};
2090
 
2091
partial interface HTMLMetaElement {
2092
           attribute DOMString scheme;
2093
};
2094
 
2095
partial interface HTMLObjectElement {
2096
           attribute DOMString align;
2097
           attribute DOMString archive;
2098
           attribute DOMString code;
2099
           attribute boolean declare;
2100
           attribute unsigned long hspace;
2101
           attribute DOMString standby;
2102
           attribute unsigned long vspace;
2103
           attribute DOMString codeBase;
2104
           attribute DOMString codeType;
2105
 
2106
  [TreatNullAs=EmptyString] attribute DOMString border;
2107
};
2108
 
2109
partial interface HTMLOListElement {
2110
           attribute boolean compact;
2111
};
2112
 
2113
partial interface HTMLParagraphElement {
2114
           attribute DOMString align;
2115
};
2116
 
2117
partial interface HTMLParamElement {
2118
           attribute DOMString type;
2119
           attribute DOMString valueType;
2120
};
2121
 
2122
partial interface HTMLPreElement {
2123
           attribute long width;
2124
};
2125
 
2126
partial interface HTMLScriptElement {
2127
           attribute DOMString event;
2128
           attribute DOMString htmlFor;
2129
};
2130
 
2131
partial interface HTMLTableElement {
2132
           attribute DOMString align;
2133
           attribute DOMString border;
2134
           attribute DOMString frame;
2135
           attribute DOMString rules;
2136
           attribute DOMString summary;
2137
           attribute DOMString width;
2138
 
2139
  [TreatNullAs=EmptyString] attribute DOMString bgColor;
2140
  [TreatNullAs=EmptyString] attribute DOMString cellPadding;
2141
  [TreatNullAs=EmptyString] attribute DOMString cellSpacing;
2142
};
2143
 
2144
partial interface HTMLTableSectionElement {
2145
           attribute DOMString align;
2146
           attribute DOMString ch;
2147
           attribute DOMString chOff;
2148
           attribute DOMString vAlign;
2149
};
2150
 
2151
partial interface HTMLTableCellElement {
2152
           attribute DOMString abbr;
2153
           attribute DOMString align;
2154
           attribute DOMString axis;
2155
           attribute DOMString height;
2156
           attribute DOMString width;
2157
 
2158
           attribute DOMString ch;
2159
           attribute DOMString chOff;
2160
           attribute boolean noWrap;
2161
           attribute DOMString vAlign;
2162
 
2163
  [TreatNullAs=EmptyString] attribute DOMString bgColor;
2164
};
2165
 
2166
partial interface HTMLTableRowElement {
2167
           attribute DOMString align;
2168
           attribute DOMString ch;
2169
           attribute DOMString chOff;
2170
           attribute DOMString vAlign;
2171
 
2172
  [TreatNullAs=EmptyString] attribute DOMString bgColor;
2173
};
2174
 
2175
partial interface HTMLUListElement {
2176
           attribute boolean compact;
2177
           attribute DOMString type;
2178
};
2179
 
2180
partial interface Document {
2181
  [TreatNullAs=EmptyString] attribute DOMString fgColor;
2182
  [TreatNullAs=EmptyString] attribute DOMString linkColor;
2183
  [TreatNullAs=EmptyString] attribute DOMString vlinkColor;
2184
  [TreatNullAs=EmptyString] attribute DOMString alinkColor;
2185
  [TreatNullAs=EmptyString] attribute DOMString bgColor;
2186
 
2187
  readonly attribute HTMLCollection anchors;
2188
  readonly attribute HTMLCollection applets;
2189
 
2190
  void clear();
2191
 
2192
  readonly attribute HTMLAllCollection all;
2193
};
2194