OLD | NEW |
1 library html; | 1 library html; |
2 | 2 |
| 3 import 'dart:html_common'; |
3 import 'dart:isolate'; | 4 import 'dart:isolate'; |
4 import 'dart:json'; | 5 import 'dart:json'; |
5 import 'dart:nativewrappers'; | 6 import 'dart:nativewrappers'; |
6 import 'dart:svg' as svg; | 7 import 'dart:svg' as svg; |
7 import 'dart:web_audio' as web_audio; | 8 import 'dart:web_audio' as web_audio; |
8 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 9 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
9 // for details. All rights reserved. Use of this source code is governed by a | 10 // for details. All rights reserved. Use of this source code is governed by a |
10 // BSD-style license that can be found in the LICENSE file. | 11 // BSD-style license that can be found in the LICENSE file. |
11 | 12 |
12 // DO NOT EDIT | 13 // DO NOT EDIT |
(...skipping 5951 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5964 | 5965 |
5965 /** @domName Clipboard.effectAllowed */ | 5966 /** @domName Clipboard.effectAllowed */ |
5966 String get effectAllowed native "Clipboard_effectAllowed_Getter"; | 5967 String get effectAllowed native "Clipboard_effectAllowed_Getter"; |
5967 | 5968 |
5968 | 5969 |
5969 /** @domName Clipboard.effectAllowed */ | 5970 /** @domName Clipboard.effectAllowed */ |
5970 void set effectAllowed(String value) native "Clipboard_effectAllowed_Setter"; | 5971 void set effectAllowed(String value) native "Clipboard_effectAllowed_Setter"; |
5971 | 5972 |
5972 | 5973 |
5973 /** @domName Clipboard.files */ | 5974 /** @domName Clipboard.files */ |
5974 List<File> get files native "Clipboard_files_Getter"; | 5975 FileList get files native "Clipboard_files_Getter"; |
5975 | 5976 |
5976 | 5977 |
5977 /** @domName Clipboard.items */ | 5978 /** @domName Clipboard.items */ |
5978 DataTransferItemList get items native "Clipboard_items_Getter"; | 5979 DataTransferItemList get items native "Clipboard_items_Getter"; |
5979 | 5980 |
5980 | 5981 |
5981 /** @domName Clipboard.types */ | 5982 /** @domName Clipboard.types */ |
5982 List get types native "Clipboard_types_Getter"; | 5983 List get types native "Clipboard_types_Getter"; |
5983 | 5984 |
5984 | 5985 |
(...skipping 633 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6618 } | 6619 } |
6619 | 6620 |
6620 void addLast(DOMMimeType value) { | 6621 void addLast(DOMMimeType value) { |
6621 throw new UnsupportedError("Cannot add to immutable List."); | 6622 throw new UnsupportedError("Cannot add to immutable List."); |
6622 } | 6623 } |
6623 | 6624 |
6624 void addAll(Collection<DOMMimeType> collection) { | 6625 void addAll(Collection<DOMMimeType> collection) { |
6625 throw new UnsupportedError("Cannot add to immutable List."); | 6626 throw new UnsupportedError("Cannot add to immutable List."); |
6626 } | 6627 } |
6627 | 6628 |
6628 bool contains(DOMMimeType element) => _Collections.contains(this, element); | 6629 bool contains(DOMMimeType element) => Collections.contains(this, element); |
6629 | 6630 |
6630 void forEach(void f(DOMMimeType element)) => _Collections.forEach(this, f); | 6631 void forEach(void f(DOMMimeType element)) => Collections.forEach(this, f); |
6631 | 6632 |
6632 Collection map(f(DOMMimeType element)) => _Collections.map(this, [], f); | 6633 Collection map(f(DOMMimeType element)) => Collections.map(this, [], f); |
6633 | 6634 |
6634 Collection<DOMMimeType> filter(bool f(DOMMimeType element)) => | 6635 Collection<DOMMimeType> filter(bool f(DOMMimeType element)) => |
6635 _Collections.filter(this, <DOMMimeType>[], f); | 6636 Collections.filter(this, <DOMMimeType>[], f); |
6636 | 6637 |
6637 bool every(bool f(DOMMimeType element)) => _Collections.every(this, f); | 6638 bool every(bool f(DOMMimeType element)) => Collections.every(this, f); |
6638 | 6639 |
6639 bool some(bool f(DOMMimeType element)) => _Collections.some(this, f); | 6640 bool some(bool f(DOMMimeType element)) => Collections.some(this, f); |
6640 | 6641 |
6641 bool get isEmpty => this.length == 0; | 6642 bool get isEmpty => this.length == 0; |
6642 | 6643 |
6643 // From List<DOMMimeType>: | 6644 // From List<DOMMimeType>: |
6644 | 6645 |
6645 void sort([Comparator<DOMMimeType> compare = Comparable.compare]) { | 6646 void sort([Comparator<DOMMimeType> compare = Comparable.compare]) { |
6646 throw new UnsupportedError("Cannot sort immutable List."); | 6647 throw new UnsupportedError("Cannot sort immutable List."); |
6647 } | 6648 } |
6648 | 6649 |
6649 int indexOf(DOMMimeType element, [int start = 0]) => | 6650 int indexOf(DOMMimeType element, [int start = 0]) => |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6781 } | 6782 } |
6782 | 6783 |
6783 void addLast(DOMPlugin value) { | 6784 void addLast(DOMPlugin value) { |
6784 throw new UnsupportedError("Cannot add to immutable List."); | 6785 throw new UnsupportedError("Cannot add to immutable List."); |
6785 } | 6786 } |
6786 | 6787 |
6787 void addAll(Collection<DOMPlugin> collection) { | 6788 void addAll(Collection<DOMPlugin> collection) { |
6788 throw new UnsupportedError("Cannot add to immutable List."); | 6789 throw new UnsupportedError("Cannot add to immutable List."); |
6789 } | 6790 } |
6790 | 6791 |
6791 bool contains(DOMPlugin element) => _Collections.contains(this, element); | 6792 bool contains(DOMPlugin element) => Collections.contains(this, element); |
6792 | 6793 |
6793 void forEach(void f(DOMPlugin element)) => _Collections.forEach(this, f); | 6794 void forEach(void f(DOMPlugin element)) => Collections.forEach(this, f); |
6794 | 6795 |
6795 Collection map(f(DOMPlugin element)) => _Collections.map(this, [], f); | 6796 Collection map(f(DOMPlugin element)) => Collections.map(this, [], f); |
6796 | 6797 |
6797 Collection<DOMPlugin> filter(bool f(DOMPlugin element)) => | 6798 Collection<DOMPlugin> filter(bool f(DOMPlugin element)) => |
6798 _Collections.filter(this, <DOMPlugin>[], f); | 6799 Collections.filter(this, <DOMPlugin>[], f); |
6799 | 6800 |
6800 bool every(bool f(DOMPlugin element)) => _Collections.every(this, f); | 6801 bool every(bool f(DOMPlugin element)) => Collections.every(this, f); |
6801 | 6802 |
6802 bool some(bool f(DOMPlugin element)) => _Collections.some(this, f); | 6803 bool some(bool f(DOMPlugin element)) => Collections.some(this, f); |
6803 | 6804 |
6804 bool get isEmpty => this.length == 0; | 6805 bool get isEmpty => this.length == 0; |
6805 | 6806 |
6806 // From List<DOMPlugin>: | 6807 // From List<DOMPlugin>: |
6807 | 6808 |
6808 void sort([Comparator<DOMPlugin> compare = Comparable.compare]) { | 6809 void sort([Comparator<DOMPlugin> compare = Comparable.compare]) { |
6809 throw new UnsupportedError("Cannot sort immutable List."); | 6810 throw new UnsupportedError("Cannot sort immutable List."); |
6810 } | 6811 } |
6811 | 6812 |
6812 int indexOf(DOMPlugin element, [int start = 0]) => | 6813 int indexOf(DOMPlugin element, [int start = 0]) => |
(...skipping 3187 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10000 String toString() native "FileException_toString_Callback"; | 10001 String toString() native "FileException_toString_Callback"; |
10001 | 10002 |
10002 } | 10003 } |
10003 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 10004 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
10004 // for details. All rights reserved. Use of this source code is governed by a | 10005 // for details. All rights reserved. Use of this source code is governed by a |
10005 // BSD-style license that can be found in the LICENSE file. | 10006 // BSD-style license that can be found in the LICENSE file. |
10006 | 10007 |
10007 // WARNING: Do not edit - generated code. | 10008 // WARNING: Do not edit - generated code. |
10008 | 10009 |
10009 | 10010 |
| 10011 /// @domName FileList |
| 10012 class FileList extends NativeFieldWrapperClass1 implements List<File> { |
| 10013 FileList.internal(); |
| 10014 |
| 10015 |
| 10016 /** @domName FileList.length */ |
| 10017 int get length native "FileList_length_Getter"; |
| 10018 |
| 10019 File operator[](int index) native "FileList_item_Callback"; |
| 10020 |
| 10021 void operator[]=(int index, File value) { |
| 10022 throw new UnsupportedError("Cannot assign element of immutable List."); |
| 10023 } |
| 10024 // -- start List<File> mixins. |
| 10025 // File is the element type. |
| 10026 |
| 10027 // From Iterable<File>: |
| 10028 |
| 10029 Iterator<File> iterator() { |
| 10030 // Note: NodeLists are not fixed size. And most probably length shouldn't |
| 10031 // be cached in both iterator _and_ forEach method. For now caching it |
| 10032 // for consistency. |
| 10033 return new FixedSizeListIterator<File>(this); |
| 10034 } |
| 10035 |
| 10036 // From Collection<File>: |
| 10037 |
| 10038 void add(File value) { |
| 10039 throw new UnsupportedError("Cannot add to immutable List."); |
| 10040 } |
| 10041 |
| 10042 void addLast(File value) { |
| 10043 throw new UnsupportedError("Cannot add to immutable List."); |
| 10044 } |
| 10045 |
| 10046 void addAll(Collection<File> collection) { |
| 10047 throw new UnsupportedError("Cannot add to immutable List."); |
| 10048 } |
| 10049 |
| 10050 bool contains(File element) => Collections.contains(this, element); |
| 10051 |
| 10052 void forEach(void f(File element)) => Collections.forEach(this, f); |
| 10053 |
| 10054 Collection map(f(File element)) => Collections.map(this, [], f); |
| 10055 |
| 10056 Collection<File> filter(bool f(File element)) => |
| 10057 Collections.filter(this, <File>[], f); |
| 10058 |
| 10059 bool every(bool f(File element)) => Collections.every(this, f); |
| 10060 |
| 10061 bool some(bool f(File element)) => Collections.some(this, f); |
| 10062 |
| 10063 bool get isEmpty => this.length == 0; |
| 10064 |
| 10065 // From List<File>: |
| 10066 |
| 10067 void sort([Comparator<File> compare = Comparable.compare]) { |
| 10068 throw new UnsupportedError("Cannot sort immutable List."); |
| 10069 } |
| 10070 |
| 10071 int indexOf(File element, [int start = 0]) => |
| 10072 _Lists.indexOf(this, element, start, this.length); |
| 10073 |
| 10074 int lastIndexOf(File element, [int start]) { |
| 10075 if (start == null) start = length - 1; |
| 10076 return _Lists.lastIndexOf(this, element, start); |
| 10077 } |
| 10078 |
| 10079 File get first => this[0]; |
| 10080 |
| 10081 File get last => this[length - 1]; |
| 10082 |
| 10083 File removeLast() { |
| 10084 throw new UnsupportedError("Cannot removeLast on immutable List."); |
| 10085 } |
| 10086 |
| 10087 void setRange(int start, int rangeLength, List<File> from, [int startFrom]) { |
| 10088 throw new UnsupportedError("Cannot setRange on immutable List."); |
| 10089 } |
| 10090 |
| 10091 void removeRange(int start, int rangeLength) { |
| 10092 throw new UnsupportedError("Cannot removeRange on immutable List."); |
| 10093 } |
| 10094 |
| 10095 void insertRange(int start, int rangeLength, [File initialValue]) { |
| 10096 throw new UnsupportedError("Cannot insertRange on immutable List."); |
| 10097 } |
| 10098 |
| 10099 List<File> getRange(int start, int rangeLength) => |
| 10100 _Lists.getRange(this, start, rangeLength, <File>[]); |
| 10101 |
| 10102 // -- end List<File> mixins. |
| 10103 |
| 10104 |
| 10105 /** @domName FileList.item */ |
| 10106 File item(int index) native "FileList_item_Callback"; |
| 10107 |
| 10108 } |
| 10109 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
| 10110 // for details. All rights reserved. Use of this source code is governed by a |
| 10111 // BSD-style license that can be found in the LICENSE file. |
| 10112 |
| 10113 // WARNING: Do not edit - generated code. |
| 10114 |
| 10115 |
10010 /// @domName FileReader | 10116 /// @domName FileReader |
10011 class FileReader extends EventTarget { | 10117 class FileReader extends EventTarget { |
10012 | 10118 |
10013 factory FileReader() => _FileReaderFactoryProvider.createFileReader(); | 10119 factory FileReader() => _FileReaderFactoryProvider.createFileReader(); |
10014 FileReader.internal(): super.internal(); | 10120 FileReader.internal(): super.internal(); |
10015 | 10121 |
10016 /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, Ev
entTarget.dispatchEvent; @docsEditable true | 10122 /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, Ev
entTarget.dispatchEvent; @docsEditable true |
10017 FileReaderEvents get on => | 10123 FileReaderEvents get on => |
10018 new FileReaderEvents(this); | 10124 new FileReaderEvents(this); |
10019 | 10125 |
(...skipping 299 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10319 } | 10425 } |
10320 | 10426 |
10321 void addLast(num value) { | 10427 void addLast(num value) { |
10322 throw new UnsupportedError("Cannot add to immutable List."); | 10428 throw new UnsupportedError("Cannot add to immutable List."); |
10323 } | 10429 } |
10324 | 10430 |
10325 void addAll(Collection<num> collection) { | 10431 void addAll(Collection<num> collection) { |
10326 throw new UnsupportedError("Cannot add to immutable List."); | 10432 throw new UnsupportedError("Cannot add to immutable List."); |
10327 } | 10433 } |
10328 | 10434 |
10329 bool contains(num element) => _Collections.contains(this, element); | 10435 bool contains(num element) => Collections.contains(this, element); |
10330 | 10436 |
10331 void forEach(void f(num element)) => _Collections.forEach(this, f); | 10437 void forEach(void f(num element)) => Collections.forEach(this, f); |
10332 | 10438 |
10333 Collection map(f(num element)) => _Collections.map(this, [], f); | 10439 Collection map(f(num element)) => Collections.map(this, [], f); |
10334 | 10440 |
10335 Collection<num> filter(bool f(num element)) => | 10441 Collection<num> filter(bool f(num element)) => |
10336 _Collections.filter(this, <num>[], f); | 10442 Collections.filter(this, <num>[], f); |
10337 | 10443 |
10338 bool every(bool f(num element)) => _Collections.every(this, f); | 10444 bool every(bool f(num element)) => Collections.every(this, f); |
10339 | 10445 |
10340 bool some(bool f(num element)) => _Collections.some(this, f); | 10446 bool some(bool f(num element)) => Collections.some(this, f); |
10341 | 10447 |
10342 bool get isEmpty => this.length == 0; | 10448 bool get isEmpty => this.length == 0; |
10343 | 10449 |
10344 // From List<num>: | 10450 // From List<num>: |
10345 | 10451 |
10346 void sort([Comparator<num> compare = Comparable.compare]) { | 10452 void sort([Comparator<num> compare = Comparable.compare]) { |
10347 throw new UnsupportedError("Cannot sort immutable List."); | 10453 throw new UnsupportedError("Cannot sort immutable List."); |
10348 } | 10454 } |
10349 | 10455 |
10350 int indexOf(num element, [int start = 0]) => | 10456 int indexOf(num element, [int start = 0]) => |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10452 } | 10558 } |
10453 | 10559 |
10454 void addLast(num value) { | 10560 void addLast(num value) { |
10455 throw new UnsupportedError("Cannot add to immutable List."); | 10561 throw new UnsupportedError("Cannot add to immutable List."); |
10456 } | 10562 } |
10457 | 10563 |
10458 void addAll(Collection<num> collection) { | 10564 void addAll(Collection<num> collection) { |
10459 throw new UnsupportedError("Cannot add to immutable List."); | 10565 throw new UnsupportedError("Cannot add to immutable List."); |
10460 } | 10566 } |
10461 | 10567 |
10462 bool contains(num element) => _Collections.contains(this, element); | 10568 bool contains(num element) => Collections.contains(this, element); |
10463 | 10569 |
10464 void forEach(void f(num element)) => _Collections.forEach(this, f); | 10570 void forEach(void f(num element)) => Collections.forEach(this, f); |
10465 | 10571 |
10466 Collection map(f(num element)) => _Collections.map(this, [], f); | 10572 Collection map(f(num element)) => Collections.map(this, [], f); |
10467 | 10573 |
10468 Collection<num> filter(bool f(num element)) => | 10574 Collection<num> filter(bool f(num element)) => |
10469 _Collections.filter(this, <num>[], f); | 10575 Collections.filter(this, <num>[], f); |
10470 | 10576 |
10471 bool every(bool f(num element)) => _Collections.every(this, f); | 10577 bool every(bool f(num element)) => Collections.every(this, f); |
10472 | 10578 |
10473 bool some(bool f(num element)) => _Collections.some(this, f); | 10579 bool some(bool f(num element)) => Collections.some(this, f); |
10474 | 10580 |
10475 bool get isEmpty => this.length == 0; | 10581 bool get isEmpty => this.length == 0; |
10476 | 10582 |
10477 // From List<num>: | 10583 // From List<num>: |
10478 | 10584 |
10479 void sort([Comparator<num> compare = Comparable.compare]) { | 10585 void sort([Comparator<num> compare = Comparable.compare]) { |
10480 throw new UnsupportedError("Cannot sort immutable List."); | 10586 throw new UnsupportedError("Cannot sort immutable List."); |
10481 } | 10587 } |
10482 | 10588 |
10483 int indexOf(num element, [int start = 0]) => | 10589 int indexOf(num element, [int start = 0]) => |
(...skipping 529 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11013 } | 11119 } |
11014 | 11120 |
11015 void addLast(Node value) { | 11121 void addLast(Node value) { |
11016 throw new UnsupportedError("Cannot add to immutable List."); | 11122 throw new UnsupportedError("Cannot add to immutable List."); |
11017 } | 11123 } |
11018 | 11124 |
11019 void addAll(Collection<Node> collection) { | 11125 void addAll(Collection<Node> collection) { |
11020 throw new UnsupportedError("Cannot add to immutable List."); | 11126 throw new UnsupportedError("Cannot add to immutable List."); |
11021 } | 11127 } |
11022 | 11128 |
11023 bool contains(Node element) => _Collections.contains(this, element); | 11129 bool contains(Node element) => Collections.contains(this, element); |
11024 | 11130 |
11025 void forEach(void f(Node element)) => _Collections.forEach(this, f); | 11131 void forEach(void f(Node element)) => Collections.forEach(this, f); |
11026 | 11132 |
11027 Collection map(f(Node element)) => _Collections.map(this, [], f); | 11133 Collection map(f(Node element)) => Collections.map(this, [], f); |
11028 | 11134 |
11029 Collection<Node> filter(bool f(Node element)) => | 11135 Collection<Node> filter(bool f(Node element)) => |
11030 _Collections.filter(this, <Node>[], f); | 11136 Collections.filter(this, <Node>[], f); |
11031 | 11137 |
11032 bool every(bool f(Node element)) => _Collections.every(this, f); | 11138 bool every(bool f(Node element)) => Collections.every(this, f); |
11033 | 11139 |
11034 bool some(bool f(Node element)) => _Collections.some(this, f); | 11140 bool some(bool f(Node element)) => Collections.some(this, f); |
11035 | 11141 |
11036 bool get isEmpty => this.length == 0; | 11142 bool get isEmpty => this.length == 0; |
11037 | 11143 |
11038 // From List<Node>: | 11144 // From List<Node>: |
11039 | 11145 |
11040 void sort([Comparator<Node> compare = Comparable.compare]) { | 11146 void sort([Comparator<Node> compare = Comparable.compare]) { |
11041 throw new UnsupportedError("Cannot sort immutable List."); | 11147 throw new UnsupportedError("Cannot sort immutable List."); |
11042 } | 11148 } |
11043 | 11149 |
11044 int indexOf(Node element, [int start = 0]) => | 11150 int indexOf(Node element, [int start = 0]) => |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11126 } | 11232 } |
11127 | 11233 |
11128 void addLast(Node value) { | 11234 void addLast(Node value) { |
11129 throw new UnsupportedError("Cannot add to immutable List."); | 11235 throw new UnsupportedError("Cannot add to immutable List."); |
11130 } | 11236 } |
11131 | 11237 |
11132 void addAll(Collection<Node> collection) { | 11238 void addAll(Collection<Node> collection) { |
11133 throw new UnsupportedError("Cannot add to immutable List."); | 11239 throw new UnsupportedError("Cannot add to immutable List."); |
11134 } | 11240 } |
11135 | 11241 |
11136 bool contains(Node element) => _Collections.contains(this, element); | 11242 bool contains(Node element) => Collections.contains(this, element); |
11137 | 11243 |
11138 void forEach(void f(Node element)) => _Collections.forEach(this, f); | 11244 void forEach(void f(Node element)) => Collections.forEach(this, f); |
11139 | 11245 |
11140 Collection map(f(Node element)) => _Collections.map(this, [], f); | 11246 Collection map(f(Node element)) => Collections.map(this, [], f); |
11141 | 11247 |
11142 Collection<Node> filter(bool f(Node element)) => | 11248 Collection<Node> filter(bool f(Node element)) => |
11143 _Collections.filter(this, <Node>[], f); | 11249 Collections.filter(this, <Node>[], f); |
11144 | 11250 |
11145 bool every(bool f(Node element)) => _Collections.every(this, f); | 11251 bool every(bool f(Node element)) => Collections.every(this, f); |
11146 | 11252 |
11147 bool some(bool f(Node element)) => _Collections.some(this, f); | 11253 bool some(bool f(Node element)) => Collections.some(this, f); |
11148 | 11254 |
11149 bool get isEmpty => this.length == 0; | 11255 bool get isEmpty => this.length == 0; |
11150 | 11256 |
11151 // From List<Node>: | 11257 // From List<Node>: |
11152 | 11258 |
11153 void sort([Comparator<Node> compare = Comparable.compare]) { | 11259 void sort([Comparator<Node> compare = Comparable.compare]) { |
11154 throw new UnsupportedError("Cannot sort immutable List."); | 11260 throw new UnsupportedError("Cannot sort immutable List."); |
11155 } | 11261 } |
11156 | 11262 |
11157 int indexOf(Node element, [int start = 0]) => | 11263 int indexOf(Node element, [int start = 0]) => |
(...skipping 1858 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
13016 | 13122 |
13017 /** @domName HTMLInputElement.disabled */ | 13123 /** @domName HTMLInputElement.disabled */ |
13018 bool get disabled native "HTMLInputElement_disabled_Getter"; | 13124 bool get disabled native "HTMLInputElement_disabled_Getter"; |
13019 | 13125 |
13020 | 13126 |
13021 /** @domName HTMLInputElement.disabled */ | 13127 /** @domName HTMLInputElement.disabled */ |
13022 void set disabled(bool value) native "HTMLInputElement_disabled_Setter"; | 13128 void set disabled(bool value) native "HTMLInputElement_disabled_Setter"; |
13023 | 13129 |
13024 | 13130 |
13025 /** @domName HTMLInputElement.files */ | 13131 /** @domName HTMLInputElement.files */ |
13026 List<File> get files native "HTMLInputElement_files_Getter"; | 13132 FileList get files native "HTMLInputElement_files_Getter"; |
13027 | 13133 |
13028 | 13134 |
13029 /** @domName HTMLInputElement.files */ | 13135 /** @domName HTMLInputElement.files */ |
13030 void set files(List<File> value) native "HTMLInputElement_files_Setter"; | 13136 void set files(FileList value) native "HTMLInputElement_files_Setter"; |
13031 | 13137 |
13032 | 13138 |
13033 /** @domName HTMLInputElement.form */ | 13139 /** @domName HTMLInputElement.form */ |
13034 FormElement get form native "HTMLInputElement_form_Getter"; | 13140 FormElement get form native "HTMLInputElement_form_Getter"; |
13035 | 13141 |
13036 | 13142 |
13037 /** @domName HTMLInputElement.formAction */ | 13143 /** @domName HTMLInputElement.formAction */ |
13038 String get formAction native "HTMLInputElement_formAction_Getter"; | 13144 String get formAction native "HTMLInputElement_formAction_Getter"; |
13039 | 13145 |
13040 | 13146 |
(...skipping 399 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
13440 } | 13546 } |
13441 | 13547 |
13442 void addLast(int value) { | 13548 void addLast(int value) { |
13443 throw new UnsupportedError("Cannot add to immutable List."); | 13549 throw new UnsupportedError("Cannot add to immutable List."); |
13444 } | 13550 } |
13445 | 13551 |
13446 void addAll(Collection<int> collection) { | 13552 void addAll(Collection<int> collection) { |
13447 throw new UnsupportedError("Cannot add to immutable List."); | 13553 throw new UnsupportedError("Cannot add to immutable List."); |
13448 } | 13554 } |
13449 | 13555 |
13450 bool contains(int element) => _Collections.contains(this, element); | 13556 bool contains(int element) => Collections.contains(this, element); |
13451 | 13557 |
13452 void forEach(void f(int element)) => _Collections.forEach(this, f); | 13558 void forEach(void f(int element)) => Collections.forEach(this, f); |
13453 | 13559 |
13454 Collection map(f(int element)) => _Collections.map(this, [], f); | 13560 Collection map(f(int element)) => Collections.map(this, [], f); |
13455 | 13561 |
13456 Collection<int> filter(bool f(int element)) => | 13562 Collection<int> filter(bool f(int element)) => |
13457 _Collections.filter(this, <int>[], f); | 13563 Collections.filter(this, <int>[], f); |
13458 | 13564 |
13459 bool every(bool f(int element)) => _Collections.every(this, f); | 13565 bool every(bool f(int element)) => Collections.every(this, f); |
13460 | 13566 |
13461 bool some(bool f(int element)) => _Collections.some(this, f); | 13567 bool some(bool f(int element)) => Collections.some(this, f); |
13462 | 13568 |
13463 bool get isEmpty => this.length == 0; | 13569 bool get isEmpty => this.length == 0; |
13464 | 13570 |
13465 // From List<int>: | 13571 // From List<int>: |
13466 | 13572 |
13467 void sort([Comparator<int> compare = Comparable.compare]) { | 13573 void sort([Comparator<int> compare = Comparable.compare]) { |
13468 throw new UnsupportedError("Cannot sort immutable List."); | 13574 throw new UnsupportedError("Cannot sort immutable List."); |
13469 } | 13575 } |
13470 | 13576 |
13471 int indexOf(int element, [int start = 0]) => | 13577 int indexOf(int element, [int start = 0]) => |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
13573 } | 13679 } |
13574 | 13680 |
13575 void addLast(int value) { | 13681 void addLast(int value) { |
13576 throw new UnsupportedError("Cannot add to immutable List."); | 13682 throw new UnsupportedError("Cannot add to immutable List."); |
13577 } | 13683 } |
13578 | 13684 |
13579 void addAll(Collection<int> collection) { | 13685 void addAll(Collection<int> collection) { |
13580 throw new UnsupportedError("Cannot add to immutable List."); | 13686 throw new UnsupportedError("Cannot add to immutable List."); |
13581 } | 13687 } |
13582 | 13688 |
13583 bool contains(int element) => _Collections.contains(this, element); | 13689 bool contains(int element) => Collections.contains(this, element); |
13584 | 13690 |
13585 void forEach(void f(int element)) => _Collections.forEach(this, f); | 13691 void forEach(void f(int element)) => Collections.forEach(this, f); |
13586 | 13692 |
13587 Collection map(f(int element)) => _Collections.map(this, [], f); | 13693 Collection map(f(int element)) => Collections.map(this, [], f); |
13588 | 13694 |
13589 Collection<int> filter(bool f(int element)) => | 13695 Collection<int> filter(bool f(int element)) => |
13590 _Collections.filter(this, <int>[], f); | 13696 Collections.filter(this, <int>[], f); |
13591 | 13697 |
13592 bool every(bool f(int element)) => _Collections.every(this, f); | 13698 bool every(bool f(int element)) => Collections.every(this, f); |
13593 | 13699 |
13594 bool some(bool f(int element)) => _Collections.some(this, f); | 13700 bool some(bool f(int element)) => Collections.some(this, f); |
13595 | 13701 |
13596 bool get isEmpty => this.length == 0; | 13702 bool get isEmpty => this.length == 0; |
13597 | 13703 |
13598 // From List<int>: | 13704 // From List<int>: |
13599 | 13705 |
13600 void sort([Comparator<int> compare = Comparable.compare]) { | 13706 void sort([Comparator<int> compare = Comparable.compare]) { |
13601 throw new UnsupportedError("Cannot sort immutable List."); | 13707 throw new UnsupportedError("Cannot sort immutable List."); |
13602 } | 13708 } |
13603 | 13709 |
13604 int indexOf(int element, [int start = 0]) => | 13710 int indexOf(int element, [int start = 0]) => |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
13706 } | 13812 } |
13707 | 13813 |
13708 void addLast(int value) { | 13814 void addLast(int value) { |
13709 throw new UnsupportedError("Cannot add to immutable List."); | 13815 throw new UnsupportedError("Cannot add to immutable List."); |
13710 } | 13816 } |
13711 | 13817 |
13712 void addAll(Collection<int> collection) { | 13818 void addAll(Collection<int> collection) { |
13713 throw new UnsupportedError("Cannot add to immutable List."); | 13819 throw new UnsupportedError("Cannot add to immutable List."); |
13714 } | 13820 } |
13715 | 13821 |
13716 bool contains(int element) => _Collections.contains(this, element); | 13822 bool contains(int element) => Collections.contains(this, element); |
13717 | 13823 |
13718 void forEach(void f(int element)) => _Collections.forEach(this, f); | 13824 void forEach(void f(int element)) => Collections.forEach(this, f); |
13719 | 13825 |
13720 Collection map(f(int element)) => _Collections.map(this, [], f); | 13826 Collection map(f(int element)) => Collections.map(this, [], f); |
13721 | 13827 |
13722 Collection<int> filter(bool f(int element)) => | 13828 Collection<int> filter(bool f(int element)) => |
13723 _Collections.filter(this, <int>[], f); | 13829 Collections.filter(this, <int>[], f); |
13724 | 13830 |
13725 bool every(bool f(int element)) => _Collections.every(this, f); | 13831 bool every(bool f(int element)) => Collections.every(this, f); |
13726 | 13832 |
13727 bool some(bool f(int element)) => _Collections.some(this, f); | 13833 bool some(bool f(int element)) => Collections.some(this, f); |
13728 | 13834 |
13729 bool get isEmpty => this.length == 0; | 13835 bool get isEmpty => this.length == 0; |
13730 | 13836 |
13731 // From List<int>: | 13837 // From List<int>: |
13732 | 13838 |
13733 void sort([Comparator<int> compare = Comparable.compare]) { | 13839 void sort([Comparator<int> compare = Comparable.compare]) { |
13734 throw new UnsupportedError("Cannot sort immutable List."); | 13840 throw new UnsupportedError("Cannot sort immutable List."); |
13735 } | 13841 } |
13736 | 13842 |
13737 int indexOf(int element, [int start = 0]) => | 13843 int indexOf(int element, [int start = 0]) => |
(...skipping 2804 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
16542 } | 16648 } |
16543 | 16649 |
16544 void addLast(Node value) { | 16650 void addLast(Node value) { |
16545 throw new UnsupportedError("Cannot add to immutable List."); | 16651 throw new UnsupportedError("Cannot add to immutable List."); |
16546 } | 16652 } |
16547 | 16653 |
16548 void addAll(Collection<Node> collection) { | 16654 void addAll(Collection<Node> collection) { |
16549 throw new UnsupportedError("Cannot add to immutable List."); | 16655 throw new UnsupportedError("Cannot add to immutable List."); |
16550 } | 16656 } |
16551 | 16657 |
16552 bool contains(Node element) => _Collections.contains(this, element); | 16658 bool contains(Node element) => Collections.contains(this, element); |
16553 | 16659 |
16554 void forEach(void f(Node element)) => _Collections.forEach(this, f); | 16660 void forEach(void f(Node element)) => Collections.forEach(this, f); |
16555 | 16661 |
16556 Collection map(f(Node element)) => _Collections.map(this, [], f); | 16662 Collection map(f(Node element)) => Collections.map(this, [], f); |
16557 | 16663 |
16558 Collection<Node> filter(bool f(Node element)) => | 16664 Collection<Node> filter(bool f(Node element)) => |
16559 _Collections.filter(this, <Node>[], f); | 16665 Collections.filter(this, <Node>[], f); |
16560 | 16666 |
16561 bool every(bool f(Node element)) => _Collections.every(this, f); | 16667 bool every(bool f(Node element)) => Collections.every(this, f); |
16562 | 16668 |
16563 bool some(bool f(Node element)) => _Collections.some(this, f); | 16669 bool some(bool f(Node element)) => Collections.some(this, f); |
16564 | 16670 |
16565 bool get isEmpty => this.length == 0; | 16671 bool get isEmpty => this.length == 0; |
16566 | 16672 |
16567 // From List<Node>: | 16673 // From List<Node>: |
16568 | 16674 |
16569 void sort([Comparator<Node> compare = Comparable.compare]) { | 16675 void sort([Comparator<Node> compare = Comparable.compare]) { |
16570 throw new UnsupportedError("Cannot sort immutable List."); | 16676 throw new UnsupportedError("Cannot sort immutable List."); |
16571 } | 16677 } |
16572 | 16678 |
16573 int indexOf(Node element, [int start = 0]) => | 16679 int indexOf(Node element, [int start = 0]) => |
(...skipping 231 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
16805 } | 16911 } |
16806 | 16912 |
16807 void operator []=(int index, Node value) { | 16913 void operator []=(int index, Node value) { |
16808 _this.$dom_replaceChild(value, this[index]); | 16914 _this.$dom_replaceChild(value, this[index]); |
16809 } | 16915 } |
16810 | 16916 |
16811 Iterator<Node> iterator() => _this.$dom_childNodes.iterator(); | 16917 Iterator<Node> iterator() => _this.$dom_childNodes.iterator(); |
16812 | 16918 |
16813 // TODO(jacobr): We can implement these methods much more efficiently by | 16919 // TODO(jacobr): We can implement these methods much more efficiently by |
16814 // looking up the nodeList only once instead of once per iteration. | 16920 // looking up the nodeList only once instead of once per iteration. |
16815 bool contains(Node element) => _Collections.contains(this, element); | 16921 bool contains(Node element) => Collections.contains(this, element); |
16816 | 16922 |
16817 void forEach(void f(Node element)) => _Collections.forEach(this, f); | 16923 void forEach(void f(Node element)) => Collections.forEach(this, f); |
16818 | 16924 |
16819 Collection map(f(Node element)) => _Collections.map(this, [], f); | 16925 Collection map(f(Node element)) => Collections.map(this, [], f); |
16820 | 16926 |
16821 Collection<Node> filter(bool f(Node element)) => | 16927 Collection<Node> filter(bool f(Node element)) => |
16822 _Collections.filter(this, <Node>[], f); | 16928 Collections.filter(this, <Node>[], f); |
16823 | 16929 |
16824 bool every(bool f(Node element)) => _Collections.every(this, f); | 16930 bool every(bool f(Node element)) => Collections.every(this, f); |
16825 | 16931 |
16826 bool some(bool f(Node element)) => _Collections.some(this, f); | 16932 bool some(bool f(Node element)) => Collections.some(this, f); |
16827 | 16933 |
16828 bool get isEmpty => this.length == 0; | 16934 bool get isEmpty => this.length == 0; |
16829 | 16935 |
16830 // From List<Node>: | 16936 // From List<Node>: |
16831 | 16937 |
16832 // TODO(jacobr): this could be implemented for child node lists. | 16938 // TODO(jacobr): this could be implemented for child node lists. |
16833 // The exception we throw here is misleading. | 16939 // The exception we throw here is misleading. |
16834 void sort([Comparator<Node> compare = Comparable.compare]) { | 16940 void sort([Comparator<Node> compare = Comparable.compare]) { |
16835 throw new UnsupportedError("Cannot sort immutable List."); | 16941 throw new UnsupportedError("Cannot sort immutable List."); |
16836 } | 16942 } |
(...skipping 2349 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
19186 } | 19292 } |
19187 | 19293 |
19188 void addLast(Map value) { | 19294 void addLast(Map value) { |
19189 throw new UnsupportedError("Cannot add to immutable List."); | 19295 throw new UnsupportedError("Cannot add to immutable List."); |
19190 } | 19296 } |
19191 | 19297 |
19192 void addAll(Collection<Map> collection) { | 19298 void addAll(Collection<Map> collection) { |
19193 throw new UnsupportedError("Cannot add to immutable List."); | 19299 throw new UnsupportedError("Cannot add to immutable List."); |
19194 } | 19300 } |
19195 | 19301 |
19196 bool contains(Map element) => _Collections.contains(this, element); | 19302 bool contains(Map element) => Collections.contains(this, element); |
19197 | 19303 |
19198 void forEach(void f(Map element)) => _Collections.forEach(this, f); | 19304 void forEach(void f(Map element)) => Collections.forEach(this, f); |
19199 | 19305 |
19200 Collection map(f(Map element)) => _Collections.map(this, [], f); | 19306 Collection map(f(Map element)) => Collections.map(this, [], f); |
19201 | 19307 |
19202 Collection<Map> filter(bool f(Map element)) => | 19308 Collection<Map> filter(bool f(Map element)) => |
19203 _Collections.filter(this, <Map>[], f); | 19309 Collections.filter(this, <Map>[], f); |
19204 | 19310 |
19205 bool every(bool f(Map element)) => _Collections.every(this, f); | 19311 bool every(bool f(Map element)) => Collections.every(this, f); |
19206 | 19312 |
19207 bool some(bool f(Map element)) => _Collections.some(this, f); | 19313 bool some(bool f(Map element)) => Collections.some(this, f); |
19208 | 19314 |
19209 bool get isEmpty => this.length == 0; | 19315 bool get isEmpty => this.length == 0; |
19210 | 19316 |
19211 // From List<Map>: | 19317 // From List<Map>: |
19212 | 19318 |
19213 void sort([Comparator<Map> compare = Comparable.compare]) { | 19319 void sort([Comparator<Map> compare = Comparable.compare]) { |
19214 throw new UnsupportedError("Cannot sort immutable List."); | 19320 throw new UnsupportedError("Cannot sort immutable List."); |
19215 } | 19321 } |
19216 | 19322 |
19217 int indexOf(Map element, [int start = 0]) => | 19323 int indexOf(Map element, [int start = 0]) => |
(...skipping 659 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
19877 } | 19983 } |
19878 | 19984 |
19879 void addLast(SourceBuffer value) { | 19985 void addLast(SourceBuffer value) { |
19880 throw new UnsupportedError("Cannot add to immutable List."); | 19986 throw new UnsupportedError("Cannot add to immutable List."); |
19881 } | 19987 } |
19882 | 19988 |
19883 void addAll(Collection<SourceBuffer> collection) { | 19989 void addAll(Collection<SourceBuffer> collection) { |
19884 throw new UnsupportedError("Cannot add to immutable List."); | 19990 throw new UnsupportedError("Cannot add to immutable List."); |
19885 } | 19991 } |
19886 | 19992 |
19887 bool contains(SourceBuffer element) => _Collections.contains(this, element); | 19993 bool contains(SourceBuffer element) => Collections.contains(this, element); |
19888 | 19994 |
19889 void forEach(void f(SourceBuffer element)) => _Collections.forEach(this, f); | 19995 void forEach(void f(SourceBuffer element)) => Collections.forEach(this, f); |
19890 | 19996 |
19891 Collection map(f(SourceBuffer element)) => _Collections.map(this, [], f); | 19997 Collection map(f(SourceBuffer element)) => Collections.map(this, [], f); |
19892 | 19998 |
19893 Collection<SourceBuffer> filter(bool f(SourceBuffer element)) => | 19999 Collection<SourceBuffer> filter(bool f(SourceBuffer element)) => |
19894 _Collections.filter(this, <SourceBuffer>[], f); | 20000 Collections.filter(this, <SourceBuffer>[], f); |
19895 | 20001 |
19896 bool every(bool f(SourceBuffer element)) => _Collections.every(this, f); | 20002 bool every(bool f(SourceBuffer element)) => Collections.every(this, f); |
19897 | 20003 |
19898 bool some(bool f(SourceBuffer element)) => _Collections.some(this, f); | 20004 bool some(bool f(SourceBuffer element)) => Collections.some(this, f); |
19899 | 20005 |
19900 bool get isEmpty => this.length == 0; | 20006 bool get isEmpty => this.length == 0; |
19901 | 20007 |
19902 // From List<SourceBuffer>: | 20008 // From List<SourceBuffer>: |
19903 | 20009 |
19904 void sort([Comparator<SourceBuffer> compare = Comparable.compare]) { | 20010 void sort([Comparator<SourceBuffer> compare = Comparable.compare]) { |
19905 throw new UnsupportedError("Cannot sort immutable List."); | 20011 throw new UnsupportedError("Cannot sort immutable List."); |
19906 } | 20012 } |
19907 | 20013 |
19908 int indexOf(SourceBuffer element, [int start = 0]) => | 20014 int indexOf(SourceBuffer element, [int start = 0]) => |
(...skipping 169 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
20078 } | 20184 } |
20079 | 20185 |
20080 void addLast(SpeechGrammar value) { | 20186 void addLast(SpeechGrammar value) { |
20081 throw new UnsupportedError("Cannot add to immutable List."); | 20187 throw new UnsupportedError("Cannot add to immutable List."); |
20082 } | 20188 } |
20083 | 20189 |
20084 void addAll(Collection<SpeechGrammar> collection) { | 20190 void addAll(Collection<SpeechGrammar> collection) { |
20085 throw new UnsupportedError("Cannot add to immutable List."); | 20191 throw new UnsupportedError("Cannot add to immutable List."); |
20086 } | 20192 } |
20087 | 20193 |
20088 bool contains(SpeechGrammar element) => _Collections.contains(this, element); | 20194 bool contains(SpeechGrammar element) => Collections.contains(this, element); |
20089 | 20195 |
20090 void forEach(void f(SpeechGrammar element)) => _Collections.forEach(this, f); | 20196 void forEach(void f(SpeechGrammar element)) => Collections.forEach(this, f); |
20091 | 20197 |
20092 Collection map(f(SpeechGrammar element)) => _Collections.map(this, [], f); | 20198 Collection map(f(SpeechGrammar element)) => Collections.map(this, [], f); |
20093 | 20199 |
20094 Collection<SpeechGrammar> filter(bool f(SpeechGrammar element)) => | 20200 Collection<SpeechGrammar> filter(bool f(SpeechGrammar element)) => |
20095 _Collections.filter(this, <SpeechGrammar>[], f); | 20201 Collections.filter(this, <SpeechGrammar>[], f); |
20096 | 20202 |
20097 bool every(bool f(SpeechGrammar element)) => _Collections.every(this, f); | 20203 bool every(bool f(SpeechGrammar element)) => Collections.every(this, f); |
20098 | 20204 |
20099 bool some(bool f(SpeechGrammar element)) => _Collections.some(this, f); | 20205 bool some(bool f(SpeechGrammar element)) => Collections.some(this, f); |
20100 | 20206 |
20101 bool get isEmpty => this.length == 0; | 20207 bool get isEmpty => this.length == 0; |
20102 | 20208 |
20103 // From List<SpeechGrammar>: | 20209 // From List<SpeechGrammar>: |
20104 | 20210 |
20105 void sort([Comparator<SpeechGrammar> compare = Comparable.compare]) { | 20211 void sort([Comparator<SpeechGrammar> compare = Comparable.compare]) { |
20106 throw new UnsupportedError("Cannot sort immutable List."); | 20212 throw new UnsupportedError("Cannot sort immutable List."); |
20107 } | 20213 } |
20108 | 20214 |
20109 int indexOf(SpeechGrammar element, [int start = 0]) => | 20215 int indexOf(SpeechGrammar element, [int start = 0]) => |
(...skipping 1627 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
21737 } | 21843 } |
21738 | 21844 |
21739 void addLast(TextTrackCue value) { | 21845 void addLast(TextTrackCue value) { |
21740 throw new UnsupportedError("Cannot add to immutable List."); | 21846 throw new UnsupportedError("Cannot add to immutable List."); |
21741 } | 21847 } |
21742 | 21848 |
21743 void addAll(Collection<TextTrackCue> collection) { | 21849 void addAll(Collection<TextTrackCue> collection) { |
21744 throw new UnsupportedError("Cannot add to immutable List."); | 21850 throw new UnsupportedError("Cannot add to immutable List."); |
21745 } | 21851 } |
21746 | 21852 |
21747 bool contains(TextTrackCue element) => _Collections.contains(this, element); | 21853 bool contains(TextTrackCue element) => Collections.contains(this, element); |
21748 | 21854 |
21749 void forEach(void f(TextTrackCue element)) => _Collections.forEach(this, f); | 21855 void forEach(void f(TextTrackCue element)) => Collections.forEach(this, f); |
21750 | 21856 |
21751 Collection map(f(TextTrackCue element)) => _Collections.map(this, [], f); | 21857 Collection map(f(TextTrackCue element)) => Collections.map(this, [], f); |
21752 | 21858 |
21753 Collection<TextTrackCue> filter(bool f(TextTrackCue element)) => | 21859 Collection<TextTrackCue> filter(bool f(TextTrackCue element)) => |
21754 _Collections.filter(this, <TextTrackCue>[], f); | 21860 Collections.filter(this, <TextTrackCue>[], f); |
21755 | 21861 |
21756 bool every(bool f(TextTrackCue element)) => _Collections.every(this, f); | 21862 bool every(bool f(TextTrackCue element)) => Collections.every(this, f); |
21757 | 21863 |
21758 bool some(bool f(TextTrackCue element)) => _Collections.some(this, f); | 21864 bool some(bool f(TextTrackCue element)) => Collections.some(this, f); |
21759 | 21865 |
21760 bool get isEmpty => this.length == 0; | 21866 bool get isEmpty => this.length == 0; |
21761 | 21867 |
21762 // From List<TextTrackCue>: | 21868 // From List<TextTrackCue>: |
21763 | 21869 |
21764 void sort([Comparator<TextTrackCue> compare = Comparable.compare]) { | 21870 void sort([Comparator<TextTrackCue> compare = Comparable.compare]) { |
21765 throw new UnsupportedError("Cannot sort immutable List."); | 21871 throw new UnsupportedError("Cannot sort immutable List."); |
21766 } | 21872 } |
21767 | 21873 |
21768 int indexOf(TextTrackCue element, [int start = 0]) => | 21874 int indexOf(TextTrackCue element, [int start = 0]) => |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
21850 } | 21956 } |
21851 | 21957 |
21852 void addLast(TextTrack value) { | 21958 void addLast(TextTrack value) { |
21853 throw new UnsupportedError("Cannot add to immutable List."); | 21959 throw new UnsupportedError("Cannot add to immutable List."); |
21854 } | 21960 } |
21855 | 21961 |
21856 void addAll(Collection<TextTrack> collection) { | 21962 void addAll(Collection<TextTrack> collection) { |
21857 throw new UnsupportedError("Cannot add to immutable List."); | 21963 throw new UnsupportedError("Cannot add to immutable List."); |
21858 } | 21964 } |
21859 | 21965 |
21860 bool contains(TextTrack element) => _Collections.contains(this, element); | 21966 bool contains(TextTrack element) => Collections.contains(this, element); |
21861 | 21967 |
21862 void forEach(void f(TextTrack element)) => _Collections.forEach(this, f); | 21968 void forEach(void f(TextTrack element)) => Collections.forEach(this, f); |
21863 | 21969 |
21864 Collection map(f(TextTrack element)) => _Collections.map(this, [], f); | 21970 Collection map(f(TextTrack element)) => Collections.map(this, [], f); |
21865 | 21971 |
21866 Collection<TextTrack> filter(bool f(TextTrack element)) => | 21972 Collection<TextTrack> filter(bool f(TextTrack element)) => |
21867 _Collections.filter(this, <TextTrack>[], f); | 21973 Collections.filter(this, <TextTrack>[], f); |
21868 | 21974 |
21869 bool every(bool f(TextTrack element)) => _Collections.every(this, f); | 21975 bool every(bool f(TextTrack element)) => Collections.every(this, f); |
21870 | 21976 |
21871 bool some(bool f(TextTrack element)) => _Collections.some(this, f); | 21977 bool some(bool f(TextTrack element)) => Collections.some(this, f); |
21872 | 21978 |
21873 bool get isEmpty => this.length == 0; | 21979 bool get isEmpty => this.length == 0; |
21874 | 21980 |
21875 // From List<TextTrack>: | 21981 // From List<TextTrack>: |
21876 | 21982 |
21877 void sort([Comparator<TextTrack> compare = Comparable.compare]) { | 21983 void sort([Comparator<TextTrack> compare = Comparable.compare]) { |
21878 throw new UnsupportedError("Cannot sort immutable List."); | 21984 throw new UnsupportedError("Cannot sort immutable List."); |
21879 } | 21985 } |
21880 | 21986 |
21881 int indexOf(TextTrack element, [int start = 0]) => | 21987 int indexOf(TextTrack element, [int start = 0]) => |
(...skipping 241 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
22123 } | 22229 } |
22124 | 22230 |
22125 void addLast(Touch value) { | 22231 void addLast(Touch value) { |
22126 throw new UnsupportedError("Cannot add to immutable List."); | 22232 throw new UnsupportedError("Cannot add to immutable List."); |
22127 } | 22233 } |
22128 | 22234 |
22129 void addAll(Collection<Touch> collection) { | 22235 void addAll(Collection<Touch> collection) { |
22130 throw new UnsupportedError("Cannot add to immutable List."); | 22236 throw new UnsupportedError("Cannot add to immutable List."); |
22131 } | 22237 } |
22132 | 22238 |
22133 bool contains(Touch element) => _Collections.contains(this, element); | 22239 bool contains(Touch element) => Collections.contains(this, element); |
22134 | 22240 |
22135 void forEach(void f(Touch element)) => _Collections.forEach(this, f); | 22241 void forEach(void f(Touch element)) => Collections.forEach(this, f); |
22136 | 22242 |
22137 Collection map(f(Touch element)) => _Collections.map(this, [], f); | 22243 Collection map(f(Touch element)) => Collections.map(this, [], f); |
22138 | 22244 |
22139 Collection<Touch> filter(bool f(Touch element)) => | 22245 Collection<Touch> filter(bool f(Touch element)) => |
22140 _Collections.filter(this, <Touch>[], f); | 22246 Collections.filter(this, <Touch>[], f); |
22141 | 22247 |
22142 bool every(bool f(Touch element)) => _Collections.every(this, f); | 22248 bool every(bool f(Touch element)) => Collections.every(this, f); |
22143 | 22249 |
22144 bool some(bool f(Touch element)) => _Collections.some(this, f); | 22250 bool some(bool f(Touch element)) => Collections.some(this, f); |
22145 | 22251 |
22146 bool get isEmpty => this.length == 0; | 22252 bool get isEmpty => this.length == 0; |
22147 | 22253 |
22148 // From List<Touch>: | 22254 // From List<Touch>: |
22149 | 22255 |
22150 void sort([Comparator<Touch> compare = Comparable.compare]) { | 22256 void sort([Comparator<Touch> compare = Comparable.compare]) { |
22151 throw new UnsupportedError("Cannot sort immutable List."); | 22257 throw new UnsupportedError("Cannot sort immutable List."); |
22152 } | 22258 } |
22153 | 22259 |
22154 int indexOf(Touch element, [int start = 0]) => | 22260 int indexOf(Touch element, [int start = 0]) => |
(...skipping 338 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
22493 } | 22599 } |
22494 | 22600 |
22495 void addLast(int value) { | 22601 void addLast(int value) { |
22496 throw new UnsupportedError("Cannot add to immutable List."); | 22602 throw new UnsupportedError("Cannot add to immutable List."); |
22497 } | 22603 } |
22498 | 22604 |
22499 void addAll(Collection<int> collection) { | 22605 void addAll(Collection<int> collection) { |
22500 throw new UnsupportedError("Cannot add to immutable List."); | 22606 throw new UnsupportedError("Cannot add to immutable List."); |
22501 } | 22607 } |
22502 | 22608 |
22503 bool contains(int element) => _Collections.contains(this, element); | 22609 bool contains(int element) => Collections.contains(this, element); |
22504 | 22610 |
22505 void forEach(void f(int element)) => _Collections.forEach(this, f); | 22611 void forEach(void f(int element)) => Collections.forEach(this, f); |
22506 | 22612 |
22507 Collection map(f(int element)) => _Collections.map(this, [], f); | 22613 Collection map(f(int element)) => Collections.map(this, [], f); |
22508 | 22614 |
22509 Collection<int> filter(bool f(int element)) => | 22615 Collection<int> filter(bool f(int element)) => |
22510 _Collections.filter(this, <int>[], f); | 22616 Collections.filter(this, <int>[], f); |
22511 | 22617 |
22512 bool every(bool f(int element)) => _Collections.every(this, f); | 22618 bool every(bool f(int element)) => Collections.every(this, f); |
22513 | 22619 |
22514 bool some(bool f(int element)) => _Collections.some(this, f); | 22620 bool some(bool f(int element)) => Collections.some(this, f); |
22515 | 22621 |
22516 bool get isEmpty => this.length == 0; | 22622 bool get isEmpty => this.length == 0; |
22517 | 22623 |
22518 // From List<int>: | 22624 // From List<int>: |
22519 | 22625 |
22520 void sort([Comparator<int> compare = Comparable.compare]) { | 22626 void sort([Comparator<int> compare = Comparable.compare]) { |
22521 throw new UnsupportedError("Cannot sort immutable List."); | 22627 throw new UnsupportedError("Cannot sort immutable List."); |
22522 } | 22628 } |
22523 | 22629 |
22524 int indexOf(int element, [int start = 0]) => | 22630 int indexOf(int element, [int start = 0]) => |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
22626 } | 22732 } |
22627 | 22733 |
22628 void addLast(int value) { | 22734 void addLast(int value) { |
22629 throw new UnsupportedError("Cannot add to immutable List."); | 22735 throw new UnsupportedError("Cannot add to immutable List."); |
22630 } | 22736 } |
22631 | 22737 |
22632 void addAll(Collection<int> collection) { | 22738 void addAll(Collection<int> collection) { |
22633 throw new UnsupportedError("Cannot add to immutable List."); | 22739 throw new UnsupportedError("Cannot add to immutable List."); |
22634 } | 22740 } |
22635 | 22741 |
22636 bool contains(int element) => _Collections.contains(this, element); | 22742 bool contains(int element) => Collections.contains(this, element); |
22637 | 22743 |
22638 void forEach(void f(int element)) => _Collections.forEach(this, f); | 22744 void forEach(void f(int element)) => Collections.forEach(this, f); |
22639 | 22745 |
22640 Collection map(f(int element)) => _Collections.map(this, [], f); | 22746 Collection map(f(int element)) => Collections.map(this, [], f); |
22641 | 22747 |
22642 Collection<int> filter(bool f(int element)) => | 22748 Collection<int> filter(bool f(int element)) => |
22643 _Collections.filter(this, <int>[], f); | 22749 Collections.filter(this, <int>[], f); |
22644 | 22750 |
22645 bool every(bool f(int element)) => _Collections.every(this, f); | 22751 bool every(bool f(int element)) => Collections.every(this, f); |
22646 | 22752 |
22647 bool some(bool f(int element)) => _Collections.some(this, f); | 22753 bool some(bool f(int element)) => Collections.some(this, f); |
22648 | 22754 |
22649 bool get isEmpty => this.length == 0; | 22755 bool get isEmpty => this.length == 0; |
22650 | 22756 |
22651 // From List<int>: | 22757 // From List<int>: |
22652 | 22758 |
22653 void sort([Comparator<int> compare = Comparable.compare]) { | 22759 void sort([Comparator<int> compare = Comparable.compare]) { |
22654 throw new UnsupportedError("Cannot sort immutable List."); | 22760 throw new UnsupportedError("Cannot sort immutable List."); |
22655 } | 22761 } |
22656 | 22762 |
22657 int indexOf(int element, [int start = 0]) => | 22763 int indexOf(int element, [int start = 0]) => |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
22759 } | 22865 } |
22760 | 22866 |
22761 void addLast(int value) { | 22867 void addLast(int value) { |
22762 throw new UnsupportedError("Cannot add to immutable List."); | 22868 throw new UnsupportedError("Cannot add to immutable List."); |
22763 } | 22869 } |
22764 | 22870 |
22765 void addAll(Collection<int> collection) { | 22871 void addAll(Collection<int> collection) { |
22766 throw new UnsupportedError("Cannot add to immutable List."); | 22872 throw new UnsupportedError("Cannot add to immutable List."); |
22767 } | 22873 } |
22768 | 22874 |
22769 bool contains(int element) => _Collections.contains(this, element); | 22875 bool contains(int element) => Collections.contains(this, element); |
22770 | 22876 |
22771 void forEach(void f(int element)) => _Collections.forEach(this, f); | 22877 void forEach(void f(int element)) => Collections.forEach(this, f); |
22772 | 22878 |
22773 Collection map(f(int element)) => _Collections.map(this, [], f); | 22879 Collection map(f(int element)) => Collections.map(this, [], f); |
22774 | 22880 |
22775 Collection<int> filter(bool f(int element)) => | 22881 Collection<int> filter(bool f(int element)) => |
22776 _Collections.filter(this, <int>[], f); | 22882 Collections.filter(this, <int>[], f); |
22777 | 22883 |
22778 bool every(bool f(int element)) => _Collections.every(this, f); | 22884 bool every(bool f(int element)) => Collections.every(this, f); |
22779 | 22885 |
22780 bool some(bool f(int element)) => _Collections.some(this, f); | 22886 bool some(bool f(int element)) => Collections.some(this, f); |
22781 | 22887 |
22782 bool get isEmpty => this.length == 0; | 22888 bool get isEmpty => this.length == 0; |
22783 | 22889 |
22784 // From List<int>: | 22890 // From List<int>: |
22785 | 22891 |
22786 void sort([Comparator<int> compare = Comparable.compare]) { | 22892 void sort([Comparator<int> compare = Comparable.compare]) { |
22787 throw new UnsupportedError("Cannot sort immutable List."); | 22893 throw new UnsupportedError("Cannot sort immutable List."); |
22788 } | 22894 } |
22789 | 22895 |
22790 int indexOf(int element, [int start = 0]) => | 22896 int indexOf(int element, [int start = 0]) => |
(...skipping 2622 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
25413 } | 25519 } |
25414 | 25520 |
25415 void addLast(CSSRule value) { | 25521 void addLast(CSSRule value) { |
25416 throw new UnsupportedError("Cannot add to immutable List."); | 25522 throw new UnsupportedError("Cannot add to immutable List."); |
25417 } | 25523 } |
25418 | 25524 |
25419 void addAll(Collection<CSSRule> collection) { | 25525 void addAll(Collection<CSSRule> collection) { |
25420 throw new UnsupportedError("Cannot add to immutable List."); | 25526 throw new UnsupportedError("Cannot add to immutable List."); |
25421 } | 25527 } |
25422 | 25528 |
25423 bool contains(CSSRule element) => _Collections.contains(this, element); | 25529 bool contains(CSSRule element) => Collections.contains(this, element); |
25424 | 25530 |
25425 void forEach(void f(CSSRule element)) => _Collections.forEach(this, f); | 25531 void forEach(void f(CSSRule element)) => Collections.forEach(this, f); |
25426 | 25532 |
25427 Collection map(f(CSSRule element)) => _Collections.map(this, [], f); | 25533 Collection map(f(CSSRule element)) => Collections.map(this, [], f); |
25428 | 25534 |
25429 Collection<CSSRule> filter(bool f(CSSRule element)) => | 25535 Collection<CSSRule> filter(bool f(CSSRule element)) => |
25430 _Collections.filter(this, <CSSRule>[], f); | 25536 Collections.filter(this, <CSSRule>[], f); |
25431 | 25537 |
25432 bool every(bool f(CSSRule element)) => _Collections.every(this, f); | 25538 bool every(bool f(CSSRule element)) => Collections.every(this, f); |
25433 | 25539 |
25434 bool some(bool f(CSSRule element)) => _Collections.some(this, f); | 25540 bool some(bool f(CSSRule element)) => Collections.some(this, f); |
25435 | 25541 |
25436 bool get isEmpty => this.length == 0; | 25542 bool get isEmpty => this.length == 0; |
25437 | 25543 |
25438 // From List<CSSRule>: | 25544 // From List<CSSRule>: |
25439 | 25545 |
25440 void sort([Comparator<CSSRule> compare = Comparable.compare]) { | 25546 void sort([Comparator<CSSRule> compare = Comparable.compare]) { |
25441 throw new UnsupportedError("Cannot sort immutable List."); | 25547 throw new UnsupportedError("Cannot sort immutable List."); |
25442 } | 25548 } |
25443 | 25549 |
25444 int indexOf(CSSRule element, [int start = 0]) => | 25550 int indexOf(CSSRule element, [int start = 0]) => |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
25518 } | 25624 } |
25519 | 25625 |
25520 void addLast(CSSValue value) { | 25626 void addLast(CSSValue value) { |
25521 throw new UnsupportedError("Cannot add to immutable List."); | 25627 throw new UnsupportedError("Cannot add to immutable List."); |
25522 } | 25628 } |
25523 | 25629 |
25524 void addAll(Collection<CSSValue> collection) { | 25630 void addAll(Collection<CSSValue> collection) { |
25525 throw new UnsupportedError("Cannot add to immutable List."); | 25631 throw new UnsupportedError("Cannot add to immutable List."); |
25526 } | 25632 } |
25527 | 25633 |
25528 bool contains(CSSValue element) => _Collections.contains(this, element); | 25634 bool contains(CSSValue element) => Collections.contains(this, element); |
25529 | 25635 |
25530 void forEach(void f(CSSValue element)) => _Collections.forEach(this, f); | 25636 void forEach(void f(CSSValue element)) => Collections.forEach(this, f); |
25531 | 25637 |
25532 Collection map(f(CSSValue element)) => _Collections.map(this, [], f); | 25638 Collection map(f(CSSValue element)) => Collections.map(this, [], f); |
25533 | 25639 |
25534 Collection<CSSValue> filter(bool f(CSSValue element)) => | 25640 Collection<CSSValue> filter(bool f(CSSValue element)) => |
25535 _Collections.filter(this, <CSSValue>[], f); | 25641 Collections.filter(this, <CSSValue>[], f); |
25536 | 25642 |
25537 bool every(bool f(CSSValue element)) => _Collections.every(this, f); | 25643 bool every(bool f(CSSValue element)) => Collections.every(this, f); |
25538 | 25644 |
25539 bool some(bool f(CSSValue element)) => _Collections.some(this, f); | 25645 bool some(bool f(CSSValue element)) => Collections.some(this, f); |
25540 | 25646 |
25541 bool get isEmpty => this.length == 0; | 25647 bool get isEmpty => this.length == 0; |
25542 | 25648 |
25543 // From List<CSSValue>: | 25649 // From List<CSSValue>: |
25544 | 25650 |
25545 void sort([Comparator<CSSValue> compare = Comparable.compare]) { | 25651 void sort([Comparator<CSSValue> compare = Comparable.compare]) { |
25546 throw new UnsupportedError("Cannot sort immutable List."); | 25652 throw new UnsupportedError("Cannot sort immutable List."); |
25547 } | 25653 } |
25548 | 25654 |
25549 int indexOf(CSSValue element, [int start = 0]) => | 25655 int indexOf(CSSValue element, [int start = 0]) => |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
25623 } | 25729 } |
25624 | 25730 |
25625 void addLast(ClientRect value) { | 25731 void addLast(ClientRect value) { |
25626 throw new UnsupportedError("Cannot add to immutable List."); | 25732 throw new UnsupportedError("Cannot add to immutable List."); |
25627 } | 25733 } |
25628 | 25734 |
25629 void addAll(Collection<ClientRect> collection) { | 25735 void addAll(Collection<ClientRect> collection) { |
25630 throw new UnsupportedError("Cannot add to immutable List."); | 25736 throw new UnsupportedError("Cannot add to immutable List."); |
25631 } | 25737 } |
25632 | 25738 |
25633 bool contains(ClientRect element) => _Collections.contains(this, element); | 25739 bool contains(ClientRect element) => Collections.contains(this, element); |
25634 | 25740 |
25635 void forEach(void f(ClientRect element)) => _Collections.forEach(this, f); | 25741 void forEach(void f(ClientRect element)) => Collections.forEach(this, f); |
25636 | 25742 |
25637 Collection map(f(ClientRect element)) => _Collections.map(this, [], f); | 25743 Collection map(f(ClientRect element)) => Collections.map(this, [], f); |
25638 | 25744 |
25639 Collection<ClientRect> filter(bool f(ClientRect element)) => | 25745 Collection<ClientRect> filter(bool f(ClientRect element)) => |
25640 _Collections.filter(this, <ClientRect>[], f); | 25746 Collections.filter(this, <ClientRect>[], f); |
25641 | 25747 |
25642 bool every(bool f(ClientRect element)) => _Collections.every(this, f); | 25748 bool every(bool f(ClientRect element)) => Collections.every(this, f); |
25643 | 25749 |
25644 bool some(bool f(ClientRect element)) => _Collections.some(this, f); | 25750 bool some(bool f(ClientRect element)) => Collections.some(this, f); |
25645 | 25751 |
25646 bool get isEmpty => this.length == 0; | 25752 bool get isEmpty => this.length == 0; |
25647 | 25753 |
25648 // From List<ClientRect>: | 25754 // From List<ClientRect>: |
25649 | 25755 |
25650 void sort([Comparator<ClientRect> compare = Comparable.compare]) { | 25756 void sort([Comparator<ClientRect> compare = Comparable.compare]) { |
25651 throw new UnsupportedError("Cannot sort immutable List."); | 25757 throw new UnsupportedError("Cannot sort immutable List."); |
25652 } | 25758 } |
25653 | 25759 |
25654 int indexOf(ClientRect element, [int start = 0]) => | 25760 int indexOf(ClientRect element, [int start = 0]) => |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
25738 void addLast(String value) { | 25844 void addLast(String value) { |
25739 throw new UnsupportedError("Cannot add to immutable List."); | 25845 throw new UnsupportedError("Cannot add to immutable List."); |
25740 } | 25846 } |
25741 | 25847 |
25742 void addAll(Collection<String> collection) { | 25848 void addAll(Collection<String> collection) { |
25743 throw new UnsupportedError("Cannot add to immutable List."); | 25849 throw new UnsupportedError("Cannot add to immutable List."); |
25744 } | 25850 } |
25745 | 25851 |
25746 // contains() defined by IDL. | 25852 // contains() defined by IDL. |
25747 | 25853 |
25748 void forEach(void f(String element)) => _Collections.forEach(this, f); | 25854 void forEach(void f(String element)) => Collections.forEach(this, f); |
25749 | 25855 |
25750 Collection map(f(String element)) => _Collections.map(this, [], f); | 25856 Collection map(f(String element)) => Collections.map(this, [], f); |
25751 | 25857 |
25752 Collection<String> filter(bool f(String element)) => | 25858 Collection<String> filter(bool f(String element)) => |
25753 _Collections.filter(this, <String>[], f); | 25859 Collections.filter(this, <String>[], f); |
25754 | 25860 |
25755 bool every(bool f(String element)) => _Collections.every(this, f); | 25861 bool every(bool f(String element)) => Collections.every(this, f); |
25756 | 25862 |
25757 bool some(bool f(String element)) => _Collections.some(this, f); | 25863 bool some(bool f(String element)) => Collections.some(this, f); |
25758 | 25864 |
25759 bool get isEmpty => this.length == 0; | 25865 bool get isEmpty => this.length == 0; |
25760 | 25866 |
25761 // From List<String>: | 25867 // From List<String>: |
25762 | 25868 |
25763 void sort([Comparator<String> compare = Comparable.compare]) { | 25869 void sort([Comparator<String> compare = Comparable.compare]) { |
25764 throw new UnsupportedError("Cannot sort immutable List."); | 25870 throw new UnsupportedError("Cannot sort immutable List."); |
25765 } | 25871 } |
25766 | 25872 |
25767 int indexOf(String element, [int start = 0]) => | 25873 int indexOf(String element, [int start = 0]) => |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
25989 } | 26095 } |
25990 | 26096 |
25991 void addLast(Entry value) { | 26097 void addLast(Entry value) { |
25992 throw new UnsupportedError("Cannot add to immutable List."); | 26098 throw new UnsupportedError("Cannot add to immutable List."); |
25993 } | 26099 } |
25994 | 26100 |
25995 void addAll(Collection<Entry> collection) { | 26101 void addAll(Collection<Entry> collection) { |
25996 throw new UnsupportedError("Cannot add to immutable List."); | 26102 throw new UnsupportedError("Cannot add to immutable List."); |
25997 } | 26103 } |
25998 | 26104 |
25999 bool contains(Entry element) => _Collections.contains(this, element); | 26105 bool contains(Entry element) => Collections.contains(this, element); |
26000 | 26106 |
26001 void forEach(void f(Entry element)) => _Collections.forEach(this, f); | 26107 void forEach(void f(Entry element)) => Collections.forEach(this, f); |
26002 | 26108 |
26003 Collection map(f(Entry element)) => _Collections.map(this, [], f); | 26109 Collection map(f(Entry element)) => Collections.map(this, [], f); |
26004 | 26110 |
26005 Collection<Entry> filter(bool f(Entry element)) => | 26111 Collection<Entry> filter(bool f(Entry element)) => |
26006 _Collections.filter(this, <Entry>[], f); | 26112 Collections.filter(this, <Entry>[], f); |
26007 | 26113 |
26008 bool every(bool f(Entry element)) => _Collections.every(this, f); | 26114 bool every(bool f(Entry element)) => Collections.every(this, f); |
26009 | 26115 |
26010 bool some(bool f(Entry element)) => _Collections.some(this, f); | 26116 bool some(bool f(Entry element)) => Collections.some(this, f); |
26011 | 26117 |
26012 bool get isEmpty => this.length == 0; | 26118 bool get isEmpty => this.length == 0; |
26013 | 26119 |
26014 // From List<Entry>: | 26120 // From List<Entry>: |
26015 | 26121 |
26016 void sort([Comparator<Entry> compare = Comparable.compare]) { | 26122 void sort([Comparator<Entry> compare = Comparable.compare]) { |
26017 throw new UnsupportedError("Cannot sort immutable List."); | 26123 throw new UnsupportedError("Cannot sort immutable List."); |
26018 } | 26124 } |
26019 | 26125 |
26020 int indexOf(Entry element, [int start = 0]) => | 26126 int indexOf(Entry element, [int start = 0]) => |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26094 } | 26200 } |
26095 | 26201 |
26096 void addLast(EntrySync value) { | 26202 void addLast(EntrySync value) { |
26097 throw new UnsupportedError("Cannot add to immutable List."); | 26203 throw new UnsupportedError("Cannot add to immutable List."); |
26098 } | 26204 } |
26099 | 26205 |
26100 void addAll(Collection<EntrySync> collection) { | 26206 void addAll(Collection<EntrySync> collection) { |
26101 throw new UnsupportedError("Cannot add to immutable List."); | 26207 throw new UnsupportedError("Cannot add to immutable List."); |
26102 } | 26208 } |
26103 | 26209 |
26104 bool contains(EntrySync element) => _Collections.contains(this, element); | 26210 bool contains(EntrySync element) => Collections.contains(this, element); |
26105 | 26211 |
26106 void forEach(void f(EntrySync element)) => _Collections.forEach(this, f); | 26212 void forEach(void f(EntrySync element)) => Collections.forEach(this, f); |
26107 | 26213 |
26108 Collection map(f(EntrySync element)) => _Collections.map(this, [], f); | 26214 Collection map(f(EntrySync element)) => Collections.map(this, [], f); |
26109 | 26215 |
26110 Collection<EntrySync> filter(bool f(EntrySync element)) => | 26216 Collection<EntrySync> filter(bool f(EntrySync element)) => |
26111 _Collections.filter(this, <EntrySync>[], f); | 26217 Collections.filter(this, <EntrySync>[], f); |
26112 | 26218 |
26113 bool every(bool f(EntrySync element)) => _Collections.every(this, f); | 26219 bool every(bool f(EntrySync element)) => Collections.every(this, f); |
26114 | 26220 |
26115 bool some(bool f(EntrySync element)) => _Collections.some(this, f); | 26221 bool some(bool f(EntrySync element)) => Collections.some(this, f); |
26116 | 26222 |
26117 bool get isEmpty => this.length == 0; | 26223 bool get isEmpty => this.length == 0; |
26118 | 26224 |
26119 // From List<EntrySync>: | 26225 // From List<EntrySync>: |
26120 | 26226 |
26121 void sort([Comparator<EntrySync> compare = Comparable.compare]) { | 26227 void sort([Comparator<EntrySync> compare = Comparable.compare]) { |
26122 throw new UnsupportedError("Cannot sort immutable List."); | 26228 throw new UnsupportedError("Cannot sort immutable List."); |
26123 } | 26229 } |
26124 | 26230 |
26125 int indexOf(EntrySync element, [int start = 0]) => | 26231 int indexOf(EntrySync element, [int start = 0]) => |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26165 // BSD-style license that can be found in the LICENSE file. | 26271 // BSD-style license that can be found in the LICENSE file. |
26166 | 26272 |
26167 | 26273 |
26168 class _EventSourceFactoryProvider { | 26274 class _EventSourceFactoryProvider { |
26169 static EventSource createEventSource(String scriptUrl) native "EventSource_con
structor_Callback"; | 26275 static EventSource createEventSource(String scriptUrl) native "EventSource_con
structor_Callback"; |
26170 } | 26276 } |
26171 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 26277 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
26172 // for details. All rights reserved. Use of this source code is governed by a | 26278 // for details. All rights reserved. Use of this source code is governed by a |
26173 // BSD-style license that can be found in the LICENSE file. | 26279 // BSD-style license that can be found in the LICENSE file. |
26174 | 26280 |
26175 // WARNING: Do not edit - generated code. | |
26176 | |
26177 | |
26178 /// @domName FileList | |
26179 class _FileList extends NativeFieldWrapperClass1 implements List<File> { | |
26180 _FileList.internal(); | |
26181 | |
26182 | |
26183 /** @domName FileList.length */ | |
26184 int get length native "FileList_length_Getter"; | |
26185 | |
26186 File operator[](int index) native "FileList_item_Callback"; | |
26187 | |
26188 void operator[]=(int index, File value) { | |
26189 throw new UnsupportedError("Cannot assign element of immutable List."); | |
26190 } | |
26191 // -- start List<File> mixins. | |
26192 // File is the element type. | |
26193 | |
26194 // From Iterable<File>: | |
26195 | |
26196 Iterator<File> iterator() { | |
26197 // Note: NodeLists are not fixed size. And most probably length shouldn't | |
26198 // be cached in both iterator _and_ forEach method. For now caching it | |
26199 // for consistency. | |
26200 return new FixedSizeListIterator<File>(this); | |
26201 } | |
26202 | |
26203 // From Collection<File>: | |
26204 | |
26205 void add(File value) { | |
26206 throw new UnsupportedError("Cannot add to immutable List."); | |
26207 } | |
26208 | |
26209 void addLast(File value) { | |
26210 throw new UnsupportedError("Cannot add to immutable List."); | |
26211 } | |
26212 | |
26213 void addAll(Collection<File> collection) { | |
26214 throw new UnsupportedError("Cannot add to immutable List."); | |
26215 } | |
26216 | |
26217 bool contains(File element) => _Collections.contains(this, element); | |
26218 | |
26219 void forEach(void f(File element)) => _Collections.forEach(this, f); | |
26220 | |
26221 Collection map(f(File element)) => _Collections.map(this, [], f); | |
26222 | |
26223 Collection<File> filter(bool f(File element)) => | |
26224 _Collections.filter(this, <File>[], f); | |
26225 | |
26226 bool every(bool f(File element)) => _Collections.every(this, f); | |
26227 | |
26228 bool some(bool f(File element)) => _Collections.some(this, f); | |
26229 | |
26230 bool get isEmpty => this.length == 0; | |
26231 | |
26232 // From List<File>: | |
26233 | |
26234 void sort([Comparator<File> compare = Comparable.compare]) { | |
26235 throw new UnsupportedError("Cannot sort immutable List."); | |
26236 } | |
26237 | |
26238 int indexOf(File element, [int start = 0]) => | |
26239 _Lists.indexOf(this, element, start, this.length); | |
26240 | |
26241 int lastIndexOf(File element, [int start]) { | |
26242 if (start == null) start = length - 1; | |
26243 return _Lists.lastIndexOf(this, element, start); | |
26244 } | |
26245 | |
26246 File get first => this[0]; | |
26247 | |
26248 File get last => this[length - 1]; | |
26249 | |
26250 File removeLast() { | |
26251 throw new UnsupportedError("Cannot removeLast on immutable List."); | |
26252 } | |
26253 | |
26254 void setRange(int start, int rangeLength, List<File> from, [int startFrom]) { | |
26255 throw new UnsupportedError("Cannot setRange on immutable List."); | |
26256 } | |
26257 | |
26258 void removeRange(int start, int rangeLength) { | |
26259 throw new UnsupportedError("Cannot removeRange on immutable List."); | |
26260 } | |
26261 | |
26262 void insertRange(int start, int rangeLength, [File initialValue]) { | |
26263 throw new UnsupportedError("Cannot insertRange on immutable List."); | |
26264 } | |
26265 | |
26266 List<File> getRange(int start, int rangeLength) => | |
26267 _Lists.getRange(this, start, rangeLength, <File>[]); | |
26268 | |
26269 // -- end List<File> mixins. | |
26270 | |
26271 | |
26272 /** @domName FileList.item */ | |
26273 File item(int index) native "FileList_item_Callback"; | |
26274 | |
26275 } | |
26276 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
26277 // for details. All rights reserved. Use of this source code is governed by a | |
26278 // BSD-style license that can be found in the LICENSE file. | |
26279 | |
26280 | 26281 |
26281 class _FileReaderFactoryProvider { | 26282 class _FileReaderFactoryProvider { |
26282 static FileReader createFileReader() native "FileReader_constructor_Callback"; | 26283 static FileReader createFileReader() native "FileReader_constructor_Callback"; |
26283 } | 26284 } |
26284 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 26285 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
26285 // for details. All rights reserved. Use of this source code is governed by a | 26286 // for details. All rights reserved. Use of this source code is governed by a |
26286 // BSD-style license that can be found in the LICENSE file. | 26287 // BSD-style license that can be found in the LICENSE file. |
26287 | 26288 |
26288 | 26289 |
26289 class _FileReaderSyncFactoryProvider { | 26290 class _FileReaderSyncFactoryProvider { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26336 } | 26337 } |
26337 | 26338 |
26338 void addLast(Gamepad value) { | 26339 void addLast(Gamepad value) { |
26339 throw new UnsupportedError("Cannot add to immutable List."); | 26340 throw new UnsupportedError("Cannot add to immutable List."); |
26340 } | 26341 } |
26341 | 26342 |
26342 void addAll(Collection<Gamepad> collection) { | 26343 void addAll(Collection<Gamepad> collection) { |
26343 throw new UnsupportedError("Cannot add to immutable List."); | 26344 throw new UnsupportedError("Cannot add to immutable List."); |
26344 } | 26345 } |
26345 | 26346 |
26346 bool contains(Gamepad element) => _Collections.contains(this, element); | 26347 bool contains(Gamepad element) => Collections.contains(this, element); |
26347 | 26348 |
26348 void forEach(void f(Gamepad element)) => _Collections.forEach(this, f); | 26349 void forEach(void f(Gamepad element)) => Collections.forEach(this, f); |
26349 | 26350 |
26350 Collection map(f(Gamepad element)) => _Collections.map(this, [], f); | 26351 Collection map(f(Gamepad element)) => Collections.map(this, [], f); |
26351 | 26352 |
26352 Collection<Gamepad> filter(bool f(Gamepad element)) => | 26353 Collection<Gamepad> filter(bool f(Gamepad element)) => |
26353 _Collections.filter(this, <Gamepad>[], f); | 26354 Collections.filter(this, <Gamepad>[], f); |
26354 | 26355 |
26355 bool every(bool f(Gamepad element)) => _Collections.every(this, f); | 26356 bool every(bool f(Gamepad element)) => Collections.every(this, f); |
26356 | 26357 |
26357 bool some(bool f(Gamepad element)) => _Collections.some(this, f); | 26358 bool some(bool f(Gamepad element)) => Collections.some(this, f); |
26358 | 26359 |
26359 bool get isEmpty => this.length == 0; | 26360 bool get isEmpty => this.length == 0; |
26360 | 26361 |
26361 // From List<Gamepad>: | 26362 // From List<Gamepad>: |
26362 | 26363 |
26363 void sort([Comparator<Gamepad> compare = Comparable.compare]) { | 26364 void sort([Comparator<Gamepad> compare = Comparable.compare]) { |
26364 throw new UnsupportedError("Cannot sort immutable List."); | 26365 throw new UnsupportedError("Cannot sort immutable List."); |
26365 } | 26366 } |
26366 | 26367 |
26367 int indexOf(Gamepad element, [int start = 0]) => | 26368 int indexOf(Gamepad element, [int start = 0]) => |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26490 } | 26491 } |
26491 | 26492 |
26492 void addLast(MediaStream value) { | 26493 void addLast(MediaStream value) { |
26493 throw new UnsupportedError("Cannot add to immutable List."); | 26494 throw new UnsupportedError("Cannot add to immutable List."); |
26494 } | 26495 } |
26495 | 26496 |
26496 void addAll(Collection<MediaStream> collection) { | 26497 void addAll(Collection<MediaStream> collection) { |
26497 throw new UnsupportedError("Cannot add to immutable List."); | 26498 throw new UnsupportedError("Cannot add to immutable List."); |
26498 } | 26499 } |
26499 | 26500 |
26500 bool contains(MediaStream element) => _Collections.contains(this, element); | 26501 bool contains(MediaStream element) => Collections.contains(this, element); |
26501 | 26502 |
26502 void forEach(void f(MediaStream element)) => _Collections.forEach(this, f); | 26503 void forEach(void f(MediaStream element)) => Collections.forEach(this, f); |
26503 | 26504 |
26504 Collection map(f(MediaStream element)) => _Collections.map(this, [], f); | 26505 Collection map(f(MediaStream element)) => Collections.map(this, [], f); |
26505 | 26506 |
26506 Collection<MediaStream> filter(bool f(MediaStream element)) => | 26507 Collection<MediaStream> filter(bool f(MediaStream element)) => |
26507 _Collections.filter(this, <MediaStream>[], f); | 26508 Collections.filter(this, <MediaStream>[], f); |
26508 | 26509 |
26509 bool every(bool f(MediaStream element)) => _Collections.every(this, f); | 26510 bool every(bool f(MediaStream element)) => Collections.every(this, f); |
26510 | 26511 |
26511 bool some(bool f(MediaStream element)) => _Collections.some(this, f); | 26512 bool some(bool f(MediaStream element)) => Collections.some(this, f); |
26512 | 26513 |
26513 bool get isEmpty => this.length == 0; | 26514 bool get isEmpty => this.length == 0; |
26514 | 26515 |
26515 // From List<MediaStream>: | 26516 // From List<MediaStream>: |
26516 | 26517 |
26517 void sort([Comparator<MediaStream> compare = Comparable.compare]) { | 26518 void sort([Comparator<MediaStream> compare = Comparable.compare]) { |
26518 throw new UnsupportedError("Cannot sort immutable List."); | 26519 throw new UnsupportedError("Cannot sort immutable List."); |
26519 } | 26520 } |
26520 | 26521 |
26521 int indexOf(MediaStream element, [int start = 0]) => | 26522 int indexOf(MediaStream element, [int start = 0]) => |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26611 } | 26612 } |
26612 | 26613 |
26613 void addLast(Node value) { | 26614 void addLast(Node value) { |
26614 throw new UnsupportedError("Cannot add to immutable List."); | 26615 throw new UnsupportedError("Cannot add to immutable List."); |
26615 } | 26616 } |
26616 | 26617 |
26617 void addAll(Collection<Node> collection) { | 26618 void addAll(Collection<Node> collection) { |
26618 throw new UnsupportedError("Cannot add to immutable List."); | 26619 throw new UnsupportedError("Cannot add to immutable List."); |
26619 } | 26620 } |
26620 | 26621 |
26621 bool contains(Node element) => _Collections.contains(this, element); | 26622 bool contains(Node element) => Collections.contains(this, element); |
26622 | 26623 |
26623 void forEach(void f(Node element)) => _Collections.forEach(this, f); | 26624 void forEach(void f(Node element)) => Collections.forEach(this, f); |
26624 | 26625 |
26625 Collection map(f(Node element)) => _Collections.map(this, [], f); | 26626 Collection map(f(Node element)) => Collections.map(this, [], f); |
26626 | 26627 |
26627 Collection<Node> filter(bool f(Node element)) => | 26628 Collection<Node> filter(bool f(Node element)) => |
26628 _Collections.filter(this, <Node>[], f); | 26629 Collections.filter(this, <Node>[], f); |
26629 | 26630 |
26630 bool every(bool f(Node element)) => _Collections.every(this, f); | 26631 bool every(bool f(Node element)) => Collections.every(this, f); |
26631 | 26632 |
26632 bool some(bool f(Node element)) => _Collections.some(this, f); | 26633 bool some(bool f(Node element)) => Collections.some(this, f); |
26633 | 26634 |
26634 bool get isEmpty => this.length == 0; | 26635 bool get isEmpty => this.length == 0; |
26635 | 26636 |
26636 // From List<Node>: | 26637 // From List<Node>: |
26637 | 26638 |
26638 void sort([Comparator<Node> compare = Comparable.compare]) { | 26639 void sort([Comparator<Node> compare = Comparable.compare]) { |
26639 throw new UnsupportedError("Cannot sort immutable List."); | 26640 throw new UnsupportedError("Cannot sort immutable List."); |
26640 } | 26641 } |
26641 | 26642 |
26642 int indexOf(Node element, [int start = 0]) => | 26643 int indexOf(Node element, [int start = 0]) => |
(...skipping 161 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26804 } | 26805 } |
26805 | 26806 |
26806 void addLast(SpeechInputResult value) { | 26807 void addLast(SpeechInputResult value) { |
26807 throw new UnsupportedError("Cannot add to immutable List."); | 26808 throw new UnsupportedError("Cannot add to immutable List."); |
26808 } | 26809 } |
26809 | 26810 |
26810 void addAll(Collection<SpeechInputResult> collection) { | 26811 void addAll(Collection<SpeechInputResult> collection) { |
26811 throw new UnsupportedError("Cannot add to immutable List."); | 26812 throw new UnsupportedError("Cannot add to immutable List."); |
26812 } | 26813 } |
26813 | 26814 |
26814 bool contains(SpeechInputResult element) => _Collections.contains(this, elemen
t); | 26815 bool contains(SpeechInputResult element) => Collections.contains(this, element
); |
26815 | 26816 |
26816 void forEach(void f(SpeechInputResult element)) => _Collections.forEach(this,
f); | 26817 void forEach(void f(SpeechInputResult element)) => Collections.forEach(this, f
); |
26817 | 26818 |
26818 Collection map(f(SpeechInputResult element)) => _Collections.map(this, [], f); | 26819 Collection map(f(SpeechInputResult element)) => Collections.map(this, [], f); |
26819 | 26820 |
26820 Collection<SpeechInputResult> filter(bool f(SpeechInputResult element)) => | 26821 Collection<SpeechInputResult> filter(bool f(SpeechInputResult element)) => |
26821 _Collections.filter(this, <SpeechInputResult>[], f); | 26822 Collections.filter(this, <SpeechInputResult>[], f); |
26822 | 26823 |
26823 bool every(bool f(SpeechInputResult element)) => _Collections.every(this, f); | 26824 bool every(bool f(SpeechInputResult element)) => Collections.every(this, f); |
26824 | 26825 |
26825 bool some(bool f(SpeechInputResult element)) => _Collections.some(this, f); | 26826 bool some(bool f(SpeechInputResult element)) => Collections.some(this, f); |
26826 | 26827 |
26827 bool get isEmpty => this.length == 0; | 26828 bool get isEmpty => this.length == 0; |
26828 | 26829 |
26829 // From List<SpeechInputResult>: | 26830 // From List<SpeechInputResult>: |
26830 | 26831 |
26831 void sort([Comparator<SpeechInputResult> compare = Comparable.compare]) { | 26832 void sort([Comparator<SpeechInputResult> compare = Comparable.compare]) { |
26832 throw new UnsupportedError("Cannot sort immutable List."); | 26833 throw new UnsupportedError("Cannot sort immutable List."); |
26833 } | 26834 } |
26834 | 26835 |
26835 int indexOf(SpeechInputResult element, [int start = 0]) => | 26836 int indexOf(SpeechInputResult element, [int start = 0]) => |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
26917 } | 26918 } |
26918 | 26919 |
26919 void addLast(SpeechRecognitionResult value) { | 26920 void addLast(SpeechRecognitionResult value) { |
26920 throw new UnsupportedError("Cannot add to immutable List."); | 26921 throw new UnsupportedError("Cannot add to immutable List."); |
26921 } | 26922 } |
26922 | 26923 |
26923 void addAll(Collection<SpeechRecognitionResult> collection) { | 26924 void addAll(Collection<SpeechRecognitionResult> collection) { |
26924 throw new UnsupportedError("Cannot add to immutable List."); | 26925 throw new UnsupportedError("Cannot add to immutable List."); |
26925 } | 26926 } |
26926 | 26927 |
26927 bool contains(SpeechRecognitionResult element) => _Collections.contains(this,
element); | 26928 bool contains(SpeechRecognitionResult element) => Collections.contains(this, e
lement); |
26928 | 26929 |
26929 void forEach(void f(SpeechRecognitionResult element)) => _Collections.forEach(
this, f); | 26930 void forEach(void f(SpeechRecognitionResult element)) => Collections.forEach(t
his, f); |
26930 | 26931 |
26931 Collection map(f(SpeechRecognitionResult element)) => _Collections.map(this, [
], f); | 26932 Collection map(f(SpeechRecognitionResult element)) => Collections.map(this, []
, f); |
26932 | 26933 |
26933 Collection<SpeechRecognitionResult> filter(bool f(SpeechRecognitionResult elem
ent)) => | 26934 Collection<SpeechRecognitionResult> filter(bool f(SpeechRecognitionResult elem
ent)) => |
26934 _Collections.filter(this, <SpeechRecognitionResult>[], f); | 26935 Collections.filter(this, <SpeechRecognitionResult>[], f); |
26935 | 26936 |
26936 bool every(bool f(SpeechRecognitionResult element)) => _Collections.every(this
, f); | 26937 bool every(bool f(SpeechRecognitionResult element)) => Collections.every(this,
f); |
26937 | 26938 |
26938 bool some(bool f(SpeechRecognitionResult element)) => _Collections.some(this,
f); | 26939 bool some(bool f(SpeechRecognitionResult element)) => Collections.some(this, f
); |
26939 | 26940 |
26940 bool get isEmpty => this.length == 0; | 26941 bool get isEmpty => this.length == 0; |
26941 | 26942 |
26942 // From List<SpeechRecognitionResult>: | 26943 // From List<SpeechRecognitionResult>: |
26943 | 26944 |
26944 void sort([Comparator<SpeechRecognitionResult> compare = Comparable.compare])
{ | 26945 void sort([Comparator<SpeechRecognitionResult> compare = Comparable.compare])
{ |
26945 throw new UnsupportedError("Cannot sort immutable List."); | 26946 throw new UnsupportedError("Cannot sort immutable List."); |
26946 } | 26947 } |
26947 | 26948 |
26948 int indexOf(SpeechRecognitionResult element, [int start = 0]) => | 26949 int indexOf(SpeechRecognitionResult element, [int start = 0]) => |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
27022 } | 27023 } |
27023 | 27024 |
27024 void addLast(StyleSheet value) { | 27025 void addLast(StyleSheet value) { |
27025 throw new UnsupportedError("Cannot add to immutable List."); | 27026 throw new UnsupportedError("Cannot add to immutable List."); |
27026 } | 27027 } |
27027 | 27028 |
27028 void addAll(Collection<StyleSheet> collection) { | 27029 void addAll(Collection<StyleSheet> collection) { |
27029 throw new UnsupportedError("Cannot add to immutable List."); | 27030 throw new UnsupportedError("Cannot add to immutable List."); |
27030 } | 27031 } |
27031 | 27032 |
27032 bool contains(StyleSheet element) => _Collections.contains(this, element); | 27033 bool contains(StyleSheet element) => Collections.contains(this, element); |
27033 | 27034 |
27034 void forEach(void f(StyleSheet element)) => _Collections.forEach(this, f); | 27035 void forEach(void f(StyleSheet element)) => Collections.forEach(this, f); |
27035 | 27036 |
27036 Collection map(f(StyleSheet element)) => _Collections.map(this, [], f); | 27037 Collection map(f(StyleSheet element)) => Collections.map(this, [], f); |
27037 | 27038 |
27038 Collection<StyleSheet> filter(bool f(StyleSheet element)) => | 27039 Collection<StyleSheet> filter(bool f(StyleSheet element)) => |
27039 _Collections.filter(this, <StyleSheet>[], f); | 27040 Collections.filter(this, <StyleSheet>[], f); |
27040 | 27041 |
27041 bool every(bool f(StyleSheet element)) => _Collections.every(this, f); | 27042 bool every(bool f(StyleSheet element)) => Collections.every(this, f); |
27042 | 27043 |
27043 bool some(bool f(StyleSheet element)) => _Collections.some(this, f); | 27044 bool some(bool f(StyleSheet element)) => Collections.some(this, f); |
27044 | 27045 |
27045 bool get isEmpty => this.length == 0; | 27046 bool get isEmpty => this.length == 0; |
27046 | 27047 |
27047 // From List<StyleSheet>: | 27048 // From List<StyleSheet>: |
27048 | 27049 |
27049 void sort([Comparator<StyleSheet> compare = Comparable.compare]) { | 27050 void sort([Comparator<StyleSheet> compare = Comparable.compare]) { |
27050 throw new UnsupportedError("Cannot sort immutable List."); | 27051 throw new UnsupportedError("Cannot sort immutable List."); |
27051 } | 27052 } |
27052 | 27053 |
27053 int indexOf(StyleSheet element, [int start = 0]) => | 27054 int indexOf(StyleSheet element, [int start = 0]) => |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
27135 } | 27136 } |
27136 | 27137 |
27137 void addLast(Animation value) { | 27138 void addLast(Animation value) { |
27138 throw new UnsupportedError("Cannot add to immutable List."); | 27139 throw new UnsupportedError("Cannot add to immutable List."); |
27139 } | 27140 } |
27140 | 27141 |
27141 void addAll(Collection<Animation> collection) { | 27142 void addAll(Collection<Animation> collection) { |
27142 throw new UnsupportedError("Cannot add to immutable List."); | 27143 throw new UnsupportedError("Cannot add to immutable List."); |
27143 } | 27144 } |
27144 | 27145 |
27145 bool contains(Animation element) => _Collections.contains(this, element); | 27146 bool contains(Animation element) => Collections.contains(this, element); |
27146 | 27147 |
27147 void forEach(void f(Animation element)) => _Collections.forEach(this, f); | 27148 void forEach(void f(Animation element)) => Collections.forEach(this, f); |
27148 | 27149 |
27149 Collection map(f(Animation element)) => _Collections.map(this, [], f); | 27150 Collection map(f(Animation element)) => Collections.map(this, [], f); |
27150 | 27151 |
27151 Collection<Animation> filter(bool f(Animation element)) => | 27152 Collection<Animation> filter(bool f(Animation element)) => |
27152 _Collections.filter(this, <Animation>[], f); | 27153 Collections.filter(this, <Animation>[], f); |
27153 | 27154 |
27154 bool every(bool f(Animation element)) => _Collections.every(this, f); | 27155 bool every(bool f(Animation element)) => Collections.every(this, f); |
27155 | 27156 |
27156 bool some(bool f(Animation element)) => _Collections.some(this, f); | 27157 bool some(bool f(Animation element)) => Collections.some(this, f); |
27157 | 27158 |
27158 bool get isEmpty => this.length == 0; | 27159 bool get isEmpty => this.length == 0; |
27159 | 27160 |
27160 // From List<Animation>: | 27161 // From List<Animation>: |
27161 | 27162 |
27162 void sort([Comparator<Animation> compare = Comparable.compare]) { | 27163 void sort([Comparator<Animation> compare = Comparable.compare]) { |
27163 throw new UnsupportedError("Cannot sort immutable List."); | 27164 throw new UnsupportedError("Cannot sort immutable List."); |
27164 } | 27165 } |
27165 | 27166 |
27166 int indexOf(Animation element, [int start = 0]) => | 27167 int indexOf(Animation element, [int start = 0]) => |
(...skipping 1435 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
28602 canceller = window.clearInterval; | 28603 canceller = window.clearInterval; |
28603 } else { | 28604 } else { |
28604 maker = window.setTimeout; | 28605 maker = window.setTimeout; |
28605 canceller = window.clearTimeout; | 28606 canceller = window.clearTimeout; |
28606 } | 28607 } |
28607 Timer timer; | 28608 Timer timer; |
28608 final int id = maker(() { callback(timer); }, milliSeconds); | 28609 final int id = maker(() { callback(timer); }, milliSeconds); |
28609 timer = new _Timer(() { canceller(id); }); | 28610 timer = new _Timer(() { canceller(id); }); |
28610 return timer; | 28611 return timer; |
28611 }; | 28612 }; |
28612 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | |
28613 // for details. All rights reserved. Use of this source code is governed by a | |
28614 // BSD-style license that can be found in the LICENSE file. | |
28615 | |
28616 | |
28617 /** | |
28618 * The [Collections] class implements static methods useful when | |
28619 * writing a class that implements [Collection] and the [iterator] | |
28620 * method. | |
28621 */ | |
28622 class _Collections { | |
28623 static bool contains(Iterable<Object> iterable, Object element) { | |
28624 for (final e in iterable) { | |
28625 if (e == element) return true; | |
28626 } | |
28627 return false; | |
28628 } | |
28629 | |
28630 static void forEach(Iterable<Object> iterable, void f(Object o)) { | |
28631 for (final e in iterable) { | |
28632 f(e); | |
28633 } | |
28634 } | |
28635 | |
28636 static List map(Iterable<Object> source, | |
28637 List<Object> destination, | |
28638 f(o)) { | |
28639 for (final e in source) { | |
28640 destination.add(f(e)); | |
28641 } | |
28642 return destination; | |
28643 } | |
28644 | |
28645 static bool some(Iterable<Object> iterable, bool f(Object o)) { | |
28646 for (final e in iterable) { | |
28647 if (f(e)) return true; | |
28648 } | |
28649 return false; | |
28650 } | |
28651 | |
28652 static bool every(Iterable<Object> iterable, bool f(Object o)) { | |
28653 for (final e in iterable) { | |
28654 if (!f(e)) return false; | |
28655 } | |
28656 return true; | |
28657 } | |
28658 | |
28659 static List filter(Iterable<Object> source, | |
28660 List<Object> destination, | |
28661 bool f(o)) { | |
28662 for (final e in source) { | |
28663 if (f(e)) destination.add(e); | |
28664 } | |
28665 return destination; | |
28666 } | |
28667 | |
28668 static bool isEmpty(Iterable<Object> iterable) { | |
28669 return !iterable.iterator().hasNext; | |
28670 } | |
28671 } | |
28672 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 28613 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
28673 // for details. All rights reserved. Use of this source code is governed by a | 28614 // for details. All rights reserved. Use of this source code is governed by a |
28674 // BSD-style license that can be found in the LICENSE file. | 28615 // BSD-style license that can be found in the LICENSE file. |
28675 | 28616 |
28676 | 28617 |
28677 class _HttpRequestUtils { | 28618 class _HttpRequestUtils { |
28678 | 28619 |
28679 // Helper for factory HttpRequest.get | 28620 // Helper for factory HttpRequest.get |
28680 static HttpRequest get(String url, | 28621 static HttpRequest get(String url, |
28681 onSuccess(HttpRequest request), | 28622 onSuccess(HttpRequest request), |
(...skipping 1126 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
29808 bool get isEmpty => Maps.isEmpty(this); | 29749 bool get isEmpty => Maps.isEmpty(this); |
29809 } | 29750 } |
29810 | 29751 |
29811 get _printClosure => (s) { | 29752 get _printClosure => (s) { |
29812 try { | 29753 try { |
29813 window.console.log(s); | 29754 window.console.log(s); |
29814 } catch (_) { | 29755 } catch (_) { |
29815 _Utils.print(s); | 29756 _Utils.print(s); |
29816 } | 29757 } |
29817 }; | 29758 }; |
OLD | NEW |