OLD | NEW |
1 library svg; | 1 library svg; |
2 | 2 |
3 import 'dart:html'; | 3 import 'dart:html'; |
4 // DO NOT EDIT | 4 // DO NOT EDIT |
5 // Auto-generated dart:svg library. | 5 // Auto-generated dart:svg library. |
6 | 6 |
7 | 7 |
8 | 8 |
9 | 9 |
10 | 10 |
(...skipping 337 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
348 } | 348 } |
349 | 349 |
350 void addLast(AnimatedLength value) { | 350 void addLast(AnimatedLength value) { |
351 throw new UnsupportedError("Cannot add to immutable List."); | 351 throw new UnsupportedError("Cannot add to immutable List."); |
352 } | 352 } |
353 | 353 |
354 void addAll(Collection<AnimatedLength> collection) { | 354 void addAll(Collection<AnimatedLength> collection) { |
355 throw new UnsupportedError("Cannot add to immutable List."); | 355 throw new UnsupportedError("Cannot add to immutable List."); |
356 } | 356 } |
357 | 357 |
358 bool contains(AnimatedLength element) => Collections.contains(this, element); | 358 bool contains(AnimatedLength element) => _Collections.contains(this, element); |
359 | 359 |
360 void forEach(void f(AnimatedLength element)) => Collections.forEach(this, f); | 360 void forEach(void f(AnimatedLength element)) => _Collections.forEach(this, f); |
361 | 361 |
362 Collection map(f(AnimatedLength element)) => Collections.map(this, [], f); | 362 Collection map(f(AnimatedLength element)) => _Collections.map(this, [], f); |
363 | 363 |
364 Collection<AnimatedLength> filter(bool f(AnimatedLength element)) => | 364 Collection<AnimatedLength> filter(bool f(AnimatedLength element)) => |
365 Collections.filter(this, <AnimatedLength>[], f); | 365 _Collections.filter(this, <AnimatedLength>[], f); |
366 | 366 |
367 bool every(bool f(AnimatedLength element)) => Collections.every(this, f); | 367 bool every(bool f(AnimatedLength element)) => _Collections.every(this, f); |
368 | 368 |
369 bool some(bool f(AnimatedLength element)) => Collections.some(this, f); | 369 bool some(bool f(AnimatedLength element)) => _Collections.some(this, f); |
370 | 370 |
371 bool get isEmpty => this.length == 0; | 371 bool get isEmpty => this.length == 0; |
372 | 372 |
373 // From List<AnimatedLength>: | 373 // From List<AnimatedLength>: |
374 | 374 |
375 void sort([Comparator<AnimatedLength> compare = Comparable.compare]) { | 375 void sort([Comparator<AnimatedLength> compare = Comparable.compare]) { |
376 throw new UnsupportedError("Cannot sort immutable List."); | 376 throw new UnsupportedError("Cannot sort immutable List."); |
377 } | 377 } |
378 | 378 |
379 int indexOf(AnimatedLength element, [int start = 0]) => | 379 int indexOf(AnimatedLength element, [int start = 0]) => |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
461 } | 461 } |
462 | 462 |
463 void addLast(AnimatedNumber value) { | 463 void addLast(AnimatedNumber value) { |
464 throw new UnsupportedError("Cannot add to immutable List."); | 464 throw new UnsupportedError("Cannot add to immutable List."); |
465 } | 465 } |
466 | 466 |
467 void addAll(Collection<AnimatedNumber> collection) { | 467 void addAll(Collection<AnimatedNumber> collection) { |
468 throw new UnsupportedError("Cannot add to immutable List."); | 468 throw new UnsupportedError("Cannot add to immutable List."); |
469 } | 469 } |
470 | 470 |
471 bool contains(AnimatedNumber element) => Collections.contains(this, element); | 471 bool contains(AnimatedNumber element) => _Collections.contains(this, element); |
472 | 472 |
473 void forEach(void f(AnimatedNumber element)) => Collections.forEach(this, f); | 473 void forEach(void f(AnimatedNumber element)) => _Collections.forEach(this, f); |
474 | 474 |
475 Collection map(f(AnimatedNumber element)) => Collections.map(this, [], f); | 475 Collection map(f(AnimatedNumber element)) => _Collections.map(this, [], f); |
476 | 476 |
477 Collection<AnimatedNumber> filter(bool f(AnimatedNumber element)) => | 477 Collection<AnimatedNumber> filter(bool f(AnimatedNumber element)) => |
478 Collections.filter(this, <AnimatedNumber>[], f); | 478 _Collections.filter(this, <AnimatedNumber>[], f); |
479 | 479 |
480 bool every(bool f(AnimatedNumber element)) => Collections.every(this, f); | 480 bool every(bool f(AnimatedNumber element)) => _Collections.every(this, f); |
481 | 481 |
482 bool some(bool f(AnimatedNumber element)) => Collections.some(this, f); | 482 bool some(bool f(AnimatedNumber element)) => _Collections.some(this, f); |
483 | 483 |
484 bool get isEmpty => this.length == 0; | 484 bool get isEmpty => this.length == 0; |
485 | 485 |
486 // From List<AnimatedNumber>: | 486 // From List<AnimatedNumber>: |
487 | 487 |
488 void sort([Comparator<AnimatedNumber> compare = Comparable.compare]) { | 488 void sort([Comparator<AnimatedNumber> compare = Comparable.compare]) { |
489 throw new UnsupportedError("Cannot sort immutable List."); | 489 throw new UnsupportedError("Cannot sort immutable List."); |
490 } | 490 } |
491 | 491 |
492 int indexOf(AnimatedNumber element, [int start = 0]) => | 492 int indexOf(AnimatedNumber element, [int start = 0]) => |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
602 } | 602 } |
603 | 603 |
604 void addLast(AnimateTransformElement value) { | 604 void addLast(AnimateTransformElement value) { |
605 throw new UnsupportedError("Cannot add to immutable List."); | 605 throw new UnsupportedError("Cannot add to immutable List."); |
606 } | 606 } |
607 | 607 |
608 void addAll(Collection<AnimateTransformElement> collection) { | 608 void addAll(Collection<AnimateTransformElement> collection) { |
609 throw new UnsupportedError("Cannot add to immutable List."); | 609 throw new UnsupportedError("Cannot add to immutable List."); |
610 } | 610 } |
611 | 611 |
612 bool contains(AnimateTransformElement element) => Collections.contains(this, e
lement); | 612 bool contains(AnimateTransformElement element) => _Collections.contains(this,
element); |
613 | 613 |
614 void forEach(void f(AnimateTransformElement element)) => Collections.forEach(t
his, f); | 614 void forEach(void f(AnimateTransformElement element)) => _Collections.forEach(
this, f); |
615 | 615 |
616 Collection map(f(AnimateTransformElement element)) => Collections.map(this, []
, f); | 616 Collection map(f(AnimateTransformElement element)) => _Collections.map(this, [
], f); |
617 | 617 |
618 Collection<AnimateTransformElement> filter(bool f(AnimateTransformElement elem
ent)) => | 618 Collection<AnimateTransformElement> filter(bool f(AnimateTransformElement elem
ent)) => |
619 Collections.filter(this, <AnimateTransformElement>[], f); | 619 _Collections.filter(this, <AnimateTransformElement>[], f); |
620 | 620 |
621 bool every(bool f(AnimateTransformElement element)) => Collections.every(this,
f); | 621 bool every(bool f(AnimateTransformElement element)) => _Collections.every(this
, f); |
622 | 622 |
623 bool some(bool f(AnimateTransformElement element)) => Collections.some(this, f
); | 623 bool some(bool f(AnimateTransformElement element)) => _Collections.some(this,
f); |
624 | 624 |
625 bool get isEmpty => this.length == 0; | 625 bool get isEmpty => this.length == 0; |
626 | 626 |
627 // From List<AnimateTransformElement>: | 627 // From List<AnimateTransformElement>: |
628 | 628 |
629 void sort([Comparator<AnimateTransformElement> compare = Comparable.compare])
{ | 629 void sort([Comparator<AnimateTransformElement> compare = Comparable.compare])
{ |
630 throw new UnsupportedError("Cannot sort immutable List."); | 630 throw new UnsupportedError("Cannot sort immutable List."); |
631 } | 631 } |
632 | 632 |
633 int indexOf(AnimateTransformElement element, [int start = 0]) => | 633 int indexOf(AnimateTransformElement element, [int start = 0]) => |
(...skipping 2297 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2931 } | 2931 } |
2932 | 2932 |
2933 void addLast(Length value) { | 2933 void addLast(Length value) { |
2934 throw new UnsupportedError("Cannot add to immutable List."); | 2934 throw new UnsupportedError("Cannot add to immutable List."); |
2935 } | 2935 } |
2936 | 2936 |
2937 void addAll(Collection<Length> collection) { | 2937 void addAll(Collection<Length> collection) { |
2938 throw new UnsupportedError("Cannot add to immutable List."); | 2938 throw new UnsupportedError("Cannot add to immutable List."); |
2939 } | 2939 } |
2940 | 2940 |
2941 bool contains(Length element) => Collections.contains(this, element); | 2941 bool contains(Length element) => _Collections.contains(this, element); |
2942 | 2942 |
2943 void forEach(void f(Length element)) => Collections.forEach(this, f); | 2943 void forEach(void f(Length element)) => _Collections.forEach(this, f); |
2944 | 2944 |
2945 Collection map(f(Length element)) => Collections.map(this, [], f); | 2945 Collection map(f(Length element)) => _Collections.map(this, [], f); |
2946 | 2946 |
2947 Collection<Length> filter(bool f(Length element)) => | 2947 Collection<Length> filter(bool f(Length element)) => |
2948 Collections.filter(this, <Length>[], f); | 2948 _Collections.filter(this, <Length>[], f); |
2949 | 2949 |
2950 bool every(bool f(Length element)) => Collections.every(this, f); | 2950 bool every(bool f(Length element)) => _Collections.every(this, f); |
2951 | 2951 |
2952 bool some(bool f(Length element)) => Collections.some(this, f); | 2952 bool some(bool f(Length element)) => _Collections.some(this, f); |
2953 | 2953 |
2954 bool get isEmpty => this.length == 0; | 2954 bool get isEmpty => this.length == 0; |
2955 | 2955 |
2956 // From List<Length>: | 2956 // From List<Length>: |
2957 | 2957 |
2958 void sort([Comparator<Length> compare = Comparable.compare]) { | 2958 void sort([Comparator<Length> compare = Comparable.compare]) { |
2959 throw new UnsupportedError("Cannot sort immutable List."); | 2959 throw new UnsupportedError("Cannot sort immutable List."); |
2960 } | 2960 } |
2961 | 2961 |
2962 int indexOf(Length element, [int start = 0]) => | 2962 int indexOf(Length element, [int start = 0]) => |
(...skipping 469 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3432 } | 3432 } |
3433 | 3433 |
3434 void addLast(Number value) { | 3434 void addLast(Number value) { |
3435 throw new UnsupportedError("Cannot add to immutable List."); | 3435 throw new UnsupportedError("Cannot add to immutable List."); |
3436 } | 3436 } |
3437 | 3437 |
3438 void addAll(Collection<Number> collection) { | 3438 void addAll(Collection<Number> collection) { |
3439 throw new UnsupportedError("Cannot add to immutable List."); | 3439 throw new UnsupportedError("Cannot add to immutable List."); |
3440 } | 3440 } |
3441 | 3441 |
3442 bool contains(Number element) => Collections.contains(this, element); | 3442 bool contains(Number element) => _Collections.contains(this, element); |
3443 | 3443 |
3444 void forEach(void f(Number element)) => Collections.forEach(this, f); | 3444 void forEach(void f(Number element)) => _Collections.forEach(this, f); |
3445 | 3445 |
3446 Collection map(f(Number element)) => Collections.map(this, [], f); | 3446 Collection map(f(Number element)) => _Collections.map(this, [], f); |
3447 | 3447 |
3448 Collection<Number> filter(bool f(Number element)) => | 3448 Collection<Number> filter(bool f(Number element)) => |
3449 Collections.filter(this, <Number>[], f); | 3449 _Collections.filter(this, <Number>[], f); |
3450 | 3450 |
3451 bool every(bool f(Number element)) => Collections.every(this, f); | 3451 bool every(bool f(Number element)) => _Collections.every(this, f); |
3452 | 3452 |
3453 bool some(bool f(Number element)) => Collections.some(this, f); | 3453 bool some(bool f(Number element)) => _Collections.some(this, f); |
3454 | 3454 |
3455 bool get isEmpty => this.length == 0; | 3455 bool get isEmpty => this.length == 0; |
3456 | 3456 |
3457 // From List<Number>: | 3457 // From List<Number>: |
3458 | 3458 |
3459 void sort([Comparator<Number> compare = Comparable.compare]) { | 3459 void sort([Comparator<Number> compare = Comparable.compare]) { |
3460 throw new UnsupportedError("Cannot sort immutable List."); | 3460 throw new UnsupportedError("Cannot sort immutable List."); |
3461 } | 3461 } |
3462 | 3462 |
3463 int indexOf(Number element, [int start = 0]) => | 3463 int indexOf(Number element, [int start = 0]) => |
(...skipping 631 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4095 } | 4095 } |
4096 | 4096 |
4097 void addLast(PathSeg value) { | 4097 void addLast(PathSeg value) { |
4098 throw new UnsupportedError("Cannot add to immutable List."); | 4098 throw new UnsupportedError("Cannot add to immutable List."); |
4099 } | 4099 } |
4100 | 4100 |
4101 void addAll(Collection<PathSeg> collection) { | 4101 void addAll(Collection<PathSeg> collection) { |
4102 throw new UnsupportedError("Cannot add to immutable List."); | 4102 throw new UnsupportedError("Cannot add to immutable List."); |
4103 } | 4103 } |
4104 | 4104 |
4105 bool contains(PathSeg element) => Collections.contains(this, element); | 4105 bool contains(PathSeg element) => _Collections.contains(this, element); |
4106 | 4106 |
4107 void forEach(void f(PathSeg element)) => Collections.forEach(this, f); | 4107 void forEach(void f(PathSeg element)) => _Collections.forEach(this, f); |
4108 | 4108 |
4109 Collection map(f(PathSeg element)) => Collections.map(this, [], f); | 4109 Collection map(f(PathSeg element)) => _Collections.map(this, [], f); |
4110 | 4110 |
4111 Collection<PathSeg> filter(bool f(PathSeg element)) => | 4111 Collection<PathSeg> filter(bool f(PathSeg element)) => |
4112 Collections.filter(this, <PathSeg>[], f); | 4112 _Collections.filter(this, <PathSeg>[], f); |
4113 | 4113 |
4114 bool every(bool f(PathSeg element)) => Collections.every(this, f); | 4114 bool every(bool f(PathSeg element)) => _Collections.every(this, f); |
4115 | 4115 |
4116 bool some(bool f(PathSeg element)) => Collections.some(this, f); | 4116 bool some(bool f(PathSeg element)) => _Collections.some(this, f); |
4117 | 4117 |
4118 bool get isEmpty => this.length == 0; | 4118 bool get isEmpty => this.length == 0; |
4119 | 4119 |
4120 // From List<PathSeg>: | 4120 // From List<PathSeg>: |
4121 | 4121 |
4122 void sort([Comparator<PathSeg> compare = Comparable.compare]) { | 4122 void sort([Comparator<PathSeg> compare = Comparable.compare]) { |
4123 throw new UnsupportedError("Cannot sort immutable List."); | 4123 throw new UnsupportedError("Cannot sort immutable List."); |
4124 } | 4124 } |
4125 | 4125 |
4126 int indexOf(PathSeg element, [int start = 0]) => | 4126 int indexOf(PathSeg element, [int start = 0]) => |
(...skipping 664 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4791 } | 4791 } |
4792 | 4792 |
4793 void addLast(String value) { | 4793 void addLast(String value) { |
4794 throw new UnsupportedError("Cannot add to immutable List."); | 4794 throw new UnsupportedError("Cannot add to immutable List."); |
4795 } | 4795 } |
4796 | 4796 |
4797 void addAll(Collection<String> collection) { | 4797 void addAll(Collection<String> collection) { |
4798 throw new UnsupportedError("Cannot add to immutable List."); | 4798 throw new UnsupportedError("Cannot add to immutable List."); |
4799 } | 4799 } |
4800 | 4800 |
4801 bool contains(String element) => Collections.contains(this, element); | 4801 bool contains(String element) => _Collections.contains(this, element); |
4802 | 4802 |
4803 void forEach(void f(String element)) => Collections.forEach(this, f); | 4803 void forEach(void f(String element)) => _Collections.forEach(this, f); |
4804 | 4804 |
4805 Collection map(f(String element)) => Collections.map(this, [], f); | 4805 Collection map(f(String element)) => _Collections.map(this, [], f); |
4806 | 4806 |
4807 Collection<String> filter(bool f(String element)) => | 4807 Collection<String> filter(bool f(String element)) => |
4808 Collections.filter(this, <String>[], f); | 4808 _Collections.filter(this, <String>[], f); |
4809 | 4809 |
4810 bool every(bool f(String element)) => Collections.every(this, f); | 4810 bool every(bool f(String element)) => _Collections.every(this, f); |
4811 | 4811 |
4812 bool some(bool f(String element)) => Collections.some(this, f); | 4812 bool some(bool f(String element)) => _Collections.some(this, f); |
4813 | 4813 |
4814 bool get isEmpty => this.length == 0; | 4814 bool get isEmpty => this.length == 0; |
4815 | 4815 |
4816 // From List<String>: | 4816 // From List<String>: |
4817 | 4817 |
4818 void sort([Comparator<String> compare = Comparable.compare]) { | 4818 void sort([Comparator<String> compare = Comparable.compare]) { |
4819 throw new UnsupportedError("Cannot sort immutable List."); | 4819 throw new UnsupportedError("Cannot sort immutable List."); |
4820 } | 4820 } |
4821 | 4821 |
4822 int indexOf(String element, [int start = 0]) => | 4822 int indexOf(String element, [int start = 0]) => |
(...skipping 891 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5714 } | 5714 } |
5715 | 5715 |
5716 void addLast(Transform value) { | 5716 void addLast(Transform value) { |
5717 throw new UnsupportedError("Cannot add to immutable List."); | 5717 throw new UnsupportedError("Cannot add to immutable List."); |
5718 } | 5718 } |
5719 | 5719 |
5720 void addAll(Collection<Transform> collection) { | 5720 void addAll(Collection<Transform> collection) { |
5721 throw new UnsupportedError("Cannot add to immutable List."); | 5721 throw new UnsupportedError("Cannot add to immutable List."); |
5722 } | 5722 } |
5723 | 5723 |
5724 bool contains(Transform element) => Collections.contains(this, element); | 5724 bool contains(Transform element) => _Collections.contains(this, element); |
5725 | 5725 |
5726 void forEach(void f(Transform element)) => Collections.forEach(this, f); | 5726 void forEach(void f(Transform element)) => _Collections.forEach(this, f); |
5727 | 5727 |
5728 Collection map(f(Transform element)) => Collections.map(this, [], f); | 5728 Collection map(f(Transform element)) => _Collections.map(this, [], f); |
5729 | 5729 |
5730 Collection<Transform> filter(bool f(Transform element)) => | 5730 Collection<Transform> filter(bool f(Transform element)) => |
5731 Collections.filter(this, <Transform>[], f); | 5731 _Collections.filter(this, <Transform>[], f); |
5732 | 5732 |
5733 bool every(bool f(Transform element)) => Collections.every(this, f); | 5733 bool every(bool f(Transform element)) => _Collections.every(this, f); |
5734 | 5734 |
5735 bool some(bool f(Transform element)) => Collections.some(this, f); | 5735 bool some(bool f(Transform element)) => _Collections.some(this, f); |
5736 | 5736 |
5737 bool get isEmpty => this.length == 0; | 5737 bool get isEmpty => this.length == 0; |
5738 | 5738 |
5739 // From List<Transform>: | 5739 // From List<Transform>: |
5740 | 5740 |
5741 void sort([Comparator<Transform> compare = Comparable.compare]) { | 5741 void sort([Comparator<Transform> compare = Comparable.compare]) { |
5742 throw new UnsupportedError("Cannot sort immutable List."); | 5742 throw new UnsupportedError("Cannot sort immutable List."); |
5743 } | 5743 } |
5744 | 5744 |
5745 int indexOf(Transform element, [int start = 0]) => | 5745 int indexOf(Transform element, [int start = 0]) => |
(...skipping 354 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6100 } | 6100 } |
6101 | 6101 |
6102 void addLast(ElementInstance value) { | 6102 void addLast(ElementInstance value) { |
6103 throw new UnsupportedError("Cannot add to immutable List."); | 6103 throw new UnsupportedError("Cannot add to immutable List."); |
6104 } | 6104 } |
6105 | 6105 |
6106 void addAll(Collection<ElementInstance> collection) { | 6106 void addAll(Collection<ElementInstance> collection) { |
6107 throw new UnsupportedError("Cannot add to immutable List."); | 6107 throw new UnsupportedError("Cannot add to immutable List."); |
6108 } | 6108 } |
6109 | 6109 |
6110 bool contains(ElementInstance element) => Collections.contains(this, element); | 6110 bool contains(ElementInstance element) => _Collections.contains(this, element)
; |
6111 | 6111 |
6112 void forEach(void f(ElementInstance element)) => Collections.forEach(this, f); | 6112 void forEach(void f(ElementInstance element)) => _Collections.forEach(this, f)
; |
6113 | 6113 |
6114 Collection map(f(ElementInstance element)) => Collections.map(this, [], f); | 6114 Collection map(f(ElementInstance element)) => _Collections.map(this, [], f); |
6115 | 6115 |
6116 Collection<ElementInstance> filter(bool f(ElementInstance element)) => | 6116 Collection<ElementInstance> filter(bool f(ElementInstance element)) => |
6117 Collections.filter(this, <ElementInstance>[], f); | 6117 _Collections.filter(this, <ElementInstance>[], f); |
6118 | 6118 |
6119 bool every(bool f(ElementInstance element)) => Collections.every(this, f); | 6119 bool every(bool f(ElementInstance element)) => _Collections.every(this, f); |
6120 | 6120 |
6121 bool some(bool f(ElementInstance element)) => Collections.some(this, f); | 6121 bool some(bool f(ElementInstance element)) => _Collections.some(this, f); |
6122 | 6122 |
6123 bool get isEmpty => this.length == 0; | 6123 bool get isEmpty => this.length == 0; |
6124 | 6124 |
6125 // From List<ElementInstance>: | 6125 // From List<ElementInstance>: |
6126 | 6126 |
6127 void sort([Comparator<ElementInstance> compare = Comparable.compare]) { | 6127 void sort([Comparator<ElementInstance> compare = Comparable.compare]) { |
6128 throw new UnsupportedError("Cannot sort immutable List."); | 6128 throw new UnsupportedError("Cannot sort immutable List."); |
6129 } | 6129 } |
6130 | 6130 |
6131 int indexOf(ElementInstance element, [int start = 0]) => | 6131 int indexOf(ElementInstance element, [int start = 0]) => |
(...skipping 25 matching lines...) Expand all Loading... |
6157 } | 6157 } |
6158 | 6158 |
6159 List<ElementInstance> getRange(int start, int rangeLength) => | 6159 List<ElementInstance> getRange(int start, int rangeLength) => |
6160 _Lists.getRange(this, start, rangeLength, <ElementInstance>[]); | 6160 _Lists.getRange(this, start, rangeLength, <ElementInstance>[]); |
6161 | 6161 |
6162 // -- end List<ElementInstance> mixins. | 6162 // -- end List<ElementInstance> mixins. |
6163 | 6163 |
6164 /// @domName SVGElementInstanceList.item; @docsEditable true | 6164 /// @domName SVGElementInstanceList.item; @docsEditable true |
6165 ElementInstance item(int index) native; | 6165 ElementInstance item(int index) native; |
6166 } | 6166 } |
OLD | NEW |