OLD | NEW |
1 library svg; | 1 library svg; |
2 | 2 |
3 import 'dart:html'; | 3 import 'dart:html'; |
4 import 'dart:nativewrappers'; | 4 import 'dart:nativewrappers'; |
5 // DO NOT EDIT | 5 // DO NOT EDIT |
6 // Auto-generated dart:svg library. | 6 // Auto-generated dart:svg library. |
7 | 7 |
8 | 8 |
9 | 9 |
10 | 10 |
(...skipping 461 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
472 } | 472 } |
473 | 473 |
474 void addLast(AnimatedLength value) { | 474 void addLast(AnimatedLength value) { |
475 throw new UnsupportedError("Cannot add to immutable List."); | 475 throw new UnsupportedError("Cannot add to immutable List."); |
476 } | 476 } |
477 | 477 |
478 void addAll(Collection<AnimatedLength> collection) { | 478 void addAll(Collection<AnimatedLength> collection) { |
479 throw new UnsupportedError("Cannot add to immutable List."); | 479 throw new UnsupportedError("Cannot add to immutable List."); |
480 } | 480 } |
481 | 481 |
482 bool contains(AnimatedLength element) => _Collections.contains(this, element); | 482 bool contains(AnimatedLength element) => Collections.contains(this, element); |
483 | 483 |
484 void forEach(void f(AnimatedLength element)) => _Collections.forEach(this, f); | 484 void forEach(void f(AnimatedLength element)) => Collections.forEach(this, f); |
485 | 485 |
486 Collection map(f(AnimatedLength element)) => _Collections.map(this, [], f); | 486 Collection map(f(AnimatedLength element)) => Collections.map(this, [], f); |
487 | 487 |
488 Collection<AnimatedLength> filter(bool f(AnimatedLength element)) => | 488 Collection<AnimatedLength> filter(bool f(AnimatedLength element)) => |
489 _Collections.filter(this, <AnimatedLength>[], f); | 489 Collections.filter(this, <AnimatedLength>[], f); |
490 | 490 |
491 bool every(bool f(AnimatedLength element)) => _Collections.every(this, f); | 491 bool every(bool f(AnimatedLength element)) => Collections.every(this, f); |
492 | 492 |
493 bool some(bool f(AnimatedLength element)) => _Collections.some(this, f); | 493 bool some(bool f(AnimatedLength element)) => Collections.some(this, f); |
494 | 494 |
495 bool get isEmpty => this.length == 0; | 495 bool get isEmpty => this.length == 0; |
496 | 496 |
497 // From List<AnimatedLength>: | 497 // From List<AnimatedLength>: |
498 | 498 |
499 void sort([Comparator<AnimatedLength> compare = Comparable.compare]) { | 499 void sort([Comparator<AnimatedLength> compare = Comparable.compare]) { |
500 throw new UnsupportedError("Cannot sort immutable List."); | 500 throw new UnsupportedError("Cannot sort immutable List."); |
501 } | 501 } |
502 | 502 |
503 int indexOf(AnimatedLength element, [int start = 0]) => | 503 int indexOf(AnimatedLength element, [int start = 0]) => |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
601 } | 601 } |
602 | 602 |
603 void addLast(AnimatedNumber value) { | 603 void addLast(AnimatedNumber value) { |
604 throw new UnsupportedError("Cannot add to immutable List."); | 604 throw new UnsupportedError("Cannot add to immutable List."); |
605 } | 605 } |
606 | 606 |
607 void addAll(Collection<AnimatedNumber> collection) { | 607 void addAll(Collection<AnimatedNumber> collection) { |
608 throw new UnsupportedError("Cannot add to immutable List."); | 608 throw new UnsupportedError("Cannot add to immutable List."); |
609 } | 609 } |
610 | 610 |
611 bool contains(AnimatedNumber element) => _Collections.contains(this, element); | 611 bool contains(AnimatedNumber element) => Collections.contains(this, element); |
612 | 612 |
613 void forEach(void f(AnimatedNumber element)) => _Collections.forEach(this, f); | 613 void forEach(void f(AnimatedNumber element)) => Collections.forEach(this, f); |
614 | 614 |
615 Collection map(f(AnimatedNumber element)) => _Collections.map(this, [], f); | 615 Collection map(f(AnimatedNumber element)) => Collections.map(this, [], f); |
616 | 616 |
617 Collection<AnimatedNumber> filter(bool f(AnimatedNumber element)) => | 617 Collection<AnimatedNumber> filter(bool f(AnimatedNumber element)) => |
618 _Collections.filter(this, <AnimatedNumber>[], f); | 618 Collections.filter(this, <AnimatedNumber>[], f); |
619 | 619 |
620 bool every(bool f(AnimatedNumber element)) => _Collections.every(this, f); | 620 bool every(bool f(AnimatedNumber element)) => Collections.every(this, f); |
621 | 621 |
622 bool some(bool f(AnimatedNumber element)) => _Collections.some(this, f); | 622 bool some(bool f(AnimatedNumber element)) => Collections.some(this, f); |
623 | 623 |
624 bool get isEmpty => this.length == 0; | 624 bool get isEmpty => this.length == 0; |
625 | 625 |
626 // From List<AnimatedNumber>: | 626 // From List<AnimatedNumber>: |
627 | 627 |
628 void sort([Comparator<AnimatedNumber> compare = Comparable.compare]) { | 628 void sort([Comparator<AnimatedNumber> compare = Comparable.compare]) { |
629 throw new UnsupportedError("Cannot sort immutable List."); | 629 throw new UnsupportedError("Cannot sort immutable List."); |
630 } | 630 } |
631 | 631 |
632 int indexOf(AnimatedNumber element, [int start = 0]) => | 632 int indexOf(AnimatedNumber element, [int start = 0]) => |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
770 } | 770 } |
771 | 771 |
772 void addLast(AnimateTransformElement value) { | 772 void addLast(AnimateTransformElement value) { |
773 throw new UnsupportedError("Cannot add to immutable List."); | 773 throw new UnsupportedError("Cannot add to immutable List."); |
774 } | 774 } |
775 | 775 |
776 void addAll(Collection<AnimateTransformElement> collection) { | 776 void addAll(Collection<AnimateTransformElement> collection) { |
777 throw new UnsupportedError("Cannot add to immutable List."); | 777 throw new UnsupportedError("Cannot add to immutable List."); |
778 } | 778 } |
779 | 779 |
780 bool contains(AnimateTransformElement element) => _Collections.contains(this,
element); | 780 bool contains(AnimateTransformElement element) => Collections.contains(this, e
lement); |
781 | 781 |
782 void forEach(void f(AnimateTransformElement element)) => _Collections.forEach(
this, f); | 782 void forEach(void f(AnimateTransformElement element)) => Collections.forEach(t
his, f); |
783 | 783 |
784 Collection map(f(AnimateTransformElement element)) => _Collections.map(this, [
], f); | 784 Collection map(f(AnimateTransformElement element)) => Collections.map(this, []
, f); |
785 | 785 |
786 Collection<AnimateTransformElement> filter(bool f(AnimateTransformElement elem
ent)) => | 786 Collection<AnimateTransformElement> filter(bool f(AnimateTransformElement elem
ent)) => |
787 _Collections.filter(this, <AnimateTransformElement>[], f); | 787 Collections.filter(this, <AnimateTransformElement>[], f); |
788 | 788 |
789 bool every(bool f(AnimateTransformElement element)) => _Collections.every(this
, f); | 789 bool every(bool f(AnimateTransformElement element)) => Collections.every(this,
f); |
790 | 790 |
791 bool some(bool f(AnimateTransformElement element)) => _Collections.some(this,
f); | 791 bool some(bool f(AnimateTransformElement element)) => Collections.some(this, f
); |
792 | 792 |
793 bool get isEmpty => this.length == 0; | 793 bool get isEmpty => this.length == 0; |
794 | 794 |
795 // From List<AnimateTransformElement>: | 795 // From List<AnimateTransformElement>: |
796 | 796 |
797 void sort([Comparator<AnimateTransformElement> compare = Comparable.compare])
{ | 797 void sort([Comparator<AnimateTransformElement> compare = Comparable.compare])
{ |
798 throw new UnsupportedError("Cannot sort immutable List."); | 798 throw new UnsupportedError("Cannot sort immutable List."); |
799 } | 799 } |
800 | 800 |
801 int indexOf(AnimateTransformElement element, [int start = 0]) => | 801 int indexOf(AnimateTransformElement element, [int start = 0]) => |
(...skipping 2913 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3715 } | 3715 } |
3716 | 3716 |
3717 void addLast(Length value) { | 3717 void addLast(Length value) { |
3718 throw new UnsupportedError("Cannot add to immutable List."); | 3718 throw new UnsupportedError("Cannot add to immutable List."); |
3719 } | 3719 } |
3720 | 3720 |
3721 void addAll(Collection<Length> collection) { | 3721 void addAll(Collection<Length> collection) { |
3722 throw new UnsupportedError("Cannot add to immutable List."); | 3722 throw new UnsupportedError("Cannot add to immutable List."); |
3723 } | 3723 } |
3724 | 3724 |
3725 bool contains(Length element) => _Collections.contains(this, element); | 3725 bool contains(Length element) => Collections.contains(this, element); |
3726 | 3726 |
3727 void forEach(void f(Length element)) => _Collections.forEach(this, f); | 3727 void forEach(void f(Length element)) => Collections.forEach(this, f); |
3728 | 3728 |
3729 Collection map(f(Length element)) => _Collections.map(this, [], f); | 3729 Collection map(f(Length element)) => Collections.map(this, [], f); |
3730 | 3730 |
3731 Collection<Length> filter(bool f(Length element)) => | 3731 Collection<Length> filter(bool f(Length element)) => |
3732 _Collections.filter(this, <Length>[], f); | 3732 Collections.filter(this, <Length>[], f); |
3733 | 3733 |
3734 bool every(bool f(Length element)) => _Collections.every(this, f); | 3734 bool every(bool f(Length element)) => Collections.every(this, f); |
3735 | 3735 |
3736 bool some(bool f(Length element)) => _Collections.some(this, f); | 3736 bool some(bool f(Length element)) => Collections.some(this, f); |
3737 | 3737 |
3738 bool get isEmpty => this.length == 0; | 3738 bool get isEmpty => this.length == 0; |
3739 | 3739 |
3740 // From List<Length>: | 3740 // From List<Length>: |
3741 | 3741 |
3742 void sort([Comparator<Length> compare = Comparable.compare]) { | 3742 void sort([Comparator<Length> compare = Comparable.compare]) { |
3743 throw new UnsupportedError("Cannot sort immutable List."); | 3743 throw new UnsupportedError("Cannot sort immutable List."); |
3744 } | 3744 } |
3745 | 3745 |
3746 int indexOf(Length element, [int start = 0]) => | 3746 int indexOf(Length element, [int start = 0]) => |
(...skipping 627 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4374 } | 4374 } |
4375 | 4375 |
4376 void addLast(Number value) { | 4376 void addLast(Number value) { |
4377 throw new UnsupportedError("Cannot add to immutable List."); | 4377 throw new UnsupportedError("Cannot add to immutable List."); |
4378 } | 4378 } |
4379 | 4379 |
4380 void addAll(Collection<Number> collection) { | 4380 void addAll(Collection<Number> collection) { |
4381 throw new UnsupportedError("Cannot add to immutable List."); | 4381 throw new UnsupportedError("Cannot add to immutable List."); |
4382 } | 4382 } |
4383 | 4383 |
4384 bool contains(Number element) => _Collections.contains(this, element); | 4384 bool contains(Number element) => Collections.contains(this, element); |
4385 | 4385 |
4386 void forEach(void f(Number element)) => _Collections.forEach(this, f); | 4386 void forEach(void f(Number element)) => Collections.forEach(this, f); |
4387 | 4387 |
4388 Collection map(f(Number element)) => _Collections.map(this, [], f); | 4388 Collection map(f(Number element)) => Collections.map(this, [], f); |
4389 | 4389 |
4390 Collection<Number> filter(bool f(Number element)) => | 4390 Collection<Number> filter(bool f(Number element)) => |
4391 _Collections.filter(this, <Number>[], f); | 4391 Collections.filter(this, <Number>[], f); |
4392 | 4392 |
4393 bool every(bool f(Number element)) => _Collections.every(this, f); | 4393 bool every(bool f(Number element)) => Collections.every(this, f); |
4394 | 4394 |
4395 bool some(bool f(Number element)) => _Collections.some(this, f); | 4395 bool some(bool f(Number element)) => Collections.some(this, f); |
4396 | 4396 |
4397 bool get isEmpty => this.length == 0; | 4397 bool get isEmpty => this.length == 0; |
4398 | 4398 |
4399 // From List<Number>: | 4399 // From List<Number>: |
4400 | 4400 |
4401 void sort([Comparator<Number> compare = Comparable.compare]) { | 4401 void sort([Comparator<Number> compare = Comparable.compare]) { |
4402 throw new UnsupportedError("Cannot sort immutable List."); | 4402 throw new UnsupportedError("Cannot sort immutable List."); |
4403 } | 4403 } |
4404 | 4404 |
4405 int indexOf(Number element, [int start = 0]) => | 4405 int indexOf(Number element, [int start = 0]) => |
(...skipping 1039 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5445 } | 5445 } |
5446 | 5446 |
5447 void addLast(PathSeg value) { | 5447 void addLast(PathSeg value) { |
5448 throw new UnsupportedError("Cannot add to immutable List."); | 5448 throw new UnsupportedError("Cannot add to immutable List."); |
5449 } | 5449 } |
5450 | 5450 |
5451 void addAll(Collection<PathSeg> collection) { | 5451 void addAll(Collection<PathSeg> collection) { |
5452 throw new UnsupportedError("Cannot add to immutable List."); | 5452 throw new UnsupportedError("Cannot add to immutable List."); |
5453 } | 5453 } |
5454 | 5454 |
5455 bool contains(PathSeg element) => _Collections.contains(this, element); | 5455 bool contains(PathSeg element) => Collections.contains(this, element); |
5456 | 5456 |
5457 void forEach(void f(PathSeg element)) => _Collections.forEach(this, f); | 5457 void forEach(void f(PathSeg element)) => Collections.forEach(this, f); |
5458 | 5458 |
5459 Collection map(f(PathSeg element)) => _Collections.map(this, [], f); | 5459 Collection map(f(PathSeg element)) => Collections.map(this, [], f); |
5460 | 5460 |
5461 Collection<PathSeg> filter(bool f(PathSeg element)) => | 5461 Collection<PathSeg> filter(bool f(PathSeg element)) => |
5462 _Collections.filter(this, <PathSeg>[], f); | 5462 Collections.filter(this, <PathSeg>[], f); |
5463 | 5463 |
5464 bool every(bool f(PathSeg element)) => _Collections.every(this, f); | 5464 bool every(bool f(PathSeg element)) => Collections.every(this, f); |
5465 | 5465 |
5466 bool some(bool f(PathSeg element)) => _Collections.some(this, f); | 5466 bool some(bool f(PathSeg element)) => Collections.some(this, f); |
5467 | 5467 |
5468 bool get isEmpty => this.length == 0; | 5468 bool get isEmpty => this.length == 0; |
5469 | 5469 |
5470 // From List<PathSeg>: | 5470 // From List<PathSeg>: |
5471 | 5471 |
5472 void sort([Comparator<PathSeg> compare = Comparable.compare]) { | 5472 void sort([Comparator<PathSeg> compare = Comparable.compare]) { |
5473 throw new UnsupportedError("Cannot sort immutable List."); | 5473 throw new UnsupportedError("Cannot sort immutable List."); |
5474 } | 5474 } |
5475 | 5475 |
5476 int indexOf(PathSeg element, [int start = 0]) => | 5476 int indexOf(PathSeg element, [int start = 0]) => |
(...skipping 878 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6355 } | 6355 } |
6356 | 6356 |
6357 void addLast(String value) { | 6357 void addLast(String value) { |
6358 throw new UnsupportedError("Cannot add to immutable List."); | 6358 throw new UnsupportedError("Cannot add to immutable List."); |
6359 } | 6359 } |
6360 | 6360 |
6361 void addAll(Collection<String> collection) { | 6361 void addAll(Collection<String> collection) { |
6362 throw new UnsupportedError("Cannot add to immutable List."); | 6362 throw new UnsupportedError("Cannot add to immutable List."); |
6363 } | 6363 } |
6364 | 6364 |
6365 bool contains(String element) => _Collections.contains(this, element); | 6365 bool contains(String element) => Collections.contains(this, element); |
6366 | 6366 |
6367 void forEach(void f(String element)) => _Collections.forEach(this, f); | 6367 void forEach(void f(String element)) => Collections.forEach(this, f); |
6368 | 6368 |
6369 Collection map(f(String element)) => _Collections.map(this, [], f); | 6369 Collection map(f(String element)) => Collections.map(this, [], f); |
6370 | 6370 |
6371 Collection<String> filter(bool f(String element)) => | 6371 Collection<String> filter(bool f(String element)) => |
6372 _Collections.filter(this, <String>[], f); | 6372 Collections.filter(this, <String>[], f); |
6373 | 6373 |
6374 bool every(bool f(String element)) => _Collections.every(this, f); | 6374 bool every(bool f(String element)) => Collections.every(this, f); |
6375 | 6375 |
6376 bool some(bool f(String element)) => _Collections.some(this, f); | 6376 bool some(bool f(String element)) => Collections.some(this, f); |
6377 | 6377 |
6378 bool get isEmpty => this.length == 0; | 6378 bool get isEmpty => this.length == 0; |
6379 | 6379 |
6380 // From List<String>: | 6380 // From List<String>: |
6381 | 6381 |
6382 void sort([Comparator<String> compare = Comparable.compare]) { | 6382 void sort([Comparator<String> compare = Comparable.compare]) { |
6383 throw new UnsupportedError("Cannot sort immutable List."); | 6383 throw new UnsupportedError("Cannot sort immutable List."); |
6384 } | 6384 } |
6385 | 6385 |
6386 int indexOf(String element, [int start = 0]) => | 6386 int indexOf(String element, [int start = 0]) => |
(...skipping 1145 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7532 } | 7532 } |
7533 | 7533 |
7534 void addLast(Transform value) { | 7534 void addLast(Transform value) { |
7535 throw new UnsupportedError("Cannot add to immutable List."); | 7535 throw new UnsupportedError("Cannot add to immutable List."); |
7536 } | 7536 } |
7537 | 7537 |
7538 void addAll(Collection<Transform> collection) { | 7538 void addAll(Collection<Transform> collection) { |
7539 throw new UnsupportedError("Cannot add to immutable List."); | 7539 throw new UnsupportedError("Cannot add to immutable List."); |
7540 } | 7540 } |
7541 | 7541 |
7542 bool contains(Transform element) => _Collections.contains(this, element); | 7542 bool contains(Transform element) => Collections.contains(this, element); |
7543 | 7543 |
7544 void forEach(void f(Transform element)) => _Collections.forEach(this, f); | 7544 void forEach(void f(Transform element)) => Collections.forEach(this, f); |
7545 | 7545 |
7546 Collection map(f(Transform element)) => _Collections.map(this, [], f); | 7546 Collection map(f(Transform element)) => Collections.map(this, [], f); |
7547 | 7547 |
7548 Collection<Transform> filter(bool f(Transform element)) => | 7548 Collection<Transform> filter(bool f(Transform element)) => |
7549 _Collections.filter(this, <Transform>[], f); | 7549 Collections.filter(this, <Transform>[], f); |
7550 | 7550 |
7551 bool every(bool f(Transform element)) => _Collections.every(this, f); | 7551 bool every(bool f(Transform element)) => Collections.every(this, f); |
7552 | 7552 |
7553 bool some(bool f(Transform element)) => _Collections.some(this, f); | 7553 bool some(bool f(Transform element)) => Collections.some(this, f); |
7554 | 7554 |
7555 bool get isEmpty => this.length == 0; | 7555 bool get isEmpty => this.length == 0; |
7556 | 7556 |
7557 // From List<Transform>: | 7557 // From List<Transform>: |
7558 | 7558 |
7559 void sort([Comparator<Transform> compare = Comparable.compare]) { | 7559 void sort([Comparator<Transform> compare = Comparable.compare]) { |
7560 throw new UnsupportedError("Cannot sort immutable List."); | 7560 throw new UnsupportedError("Cannot sort immutable List."); |
7561 } | 7561 } |
7562 | 7562 |
7563 int indexOf(Transform element, [int start = 0]) => | 7563 int indexOf(Transform element, [int start = 0]) => |
(...skipping 459 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8023 } | 8023 } |
8024 | 8024 |
8025 void addLast(ElementInstance value) { | 8025 void addLast(ElementInstance value) { |
8026 throw new UnsupportedError("Cannot add to immutable List."); | 8026 throw new UnsupportedError("Cannot add to immutable List."); |
8027 } | 8027 } |
8028 | 8028 |
8029 void addAll(Collection<ElementInstance> collection) { | 8029 void addAll(Collection<ElementInstance> collection) { |
8030 throw new UnsupportedError("Cannot add to immutable List."); | 8030 throw new UnsupportedError("Cannot add to immutable List."); |
8031 } | 8031 } |
8032 | 8032 |
8033 bool contains(ElementInstance element) => _Collections.contains(this, element)
; | 8033 bool contains(ElementInstance element) => Collections.contains(this, element); |
8034 | 8034 |
8035 void forEach(void f(ElementInstance element)) => _Collections.forEach(this, f)
; | 8035 void forEach(void f(ElementInstance element)) => Collections.forEach(this, f); |
8036 | 8036 |
8037 Collection map(f(ElementInstance element)) => _Collections.map(this, [], f); | 8037 Collection map(f(ElementInstance element)) => Collections.map(this, [], f); |
8038 | 8038 |
8039 Collection<ElementInstance> filter(bool f(ElementInstance element)) => | 8039 Collection<ElementInstance> filter(bool f(ElementInstance element)) => |
8040 _Collections.filter(this, <ElementInstance>[], f); | 8040 Collections.filter(this, <ElementInstance>[], f); |
8041 | 8041 |
8042 bool every(bool f(ElementInstance element)) => _Collections.every(this, f); | 8042 bool every(bool f(ElementInstance element)) => Collections.every(this, f); |
8043 | 8043 |
8044 bool some(bool f(ElementInstance element)) => _Collections.some(this, f); | 8044 bool some(bool f(ElementInstance element)) => Collections.some(this, f); |
8045 | 8045 |
8046 bool get isEmpty => this.length == 0; | 8046 bool get isEmpty => this.length == 0; |
8047 | 8047 |
8048 // From List<ElementInstance>: | 8048 // From List<ElementInstance>: |
8049 | 8049 |
8050 void sort([Comparator<ElementInstance> compare = Comparable.compare]) { | 8050 void sort([Comparator<ElementInstance> compare = Comparable.compare]) { |
8051 throw new UnsupportedError("Cannot sort immutable List."); | 8051 throw new UnsupportedError("Cannot sort immutable List."); |
8052 } | 8052 } |
8053 | 8053 |
8054 int indexOf(ElementInstance element, [int start = 0]) => | 8054 int indexOf(ElementInstance element, [int start = 0]) => |
(...skipping 27 matching lines...) Expand all Loading... |
8082 List<ElementInstance> getRange(int start, int rangeLength) => | 8082 List<ElementInstance> getRange(int start, int rangeLength) => |
8083 _Lists.getRange(this, start, rangeLength, <ElementInstance>[]); | 8083 _Lists.getRange(this, start, rangeLength, <ElementInstance>[]); |
8084 | 8084 |
8085 // -- end List<ElementInstance> mixins. | 8085 // -- end List<ElementInstance> mixins. |
8086 | 8086 |
8087 | 8087 |
8088 /** @domName SVGElementInstanceList.item */ | 8088 /** @domName SVGElementInstanceList.item */ |
8089 ElementInstance item(int index) native "SVGElementInstanceList_item_Callback"; | 8089 ElementInstance item(int index) native "SVGElementInstanceList_item_Callback"; |
8090 | 8090 |
8091 } | 8091 } |
OLD | NEW |