| // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| part of $LIBRARYNAME; |
| |
| /** |
| * Lazy implementation of the child nodes of an element that does not request |
| * the actual child nodes of an element until strictly necessary greatly |
| * improving performance for the typical cases where it is not required. |
| */ |
| class _ChildNodeListLazy extends ListBase<Node> { |
| final Node _this; |
| |
| _ChildNodeListLazy(this._this); |
| |
| |
| $if DART2JS |
| Node get first { |
| Node result = JS('Node|Null', '#.firstChild', _this); |
| if (result == null) throw new StateError("No elements"); |
| return result; |
| } |
| Node get last { |
| Node result = JS('Node|Null', '#.lastChild', _this); |
| if (result == null) throw new StateError("No elements"); |
| return result; |
| } |
| Node get single { |
| int l = this.length; |
| if (l == 0) throw new StateError("No elements"); |
| if (l > 1) throw new StateError("More than one element"); |
| return JS('Node|Null', '#.firstChild', _this); |
| } |
| $else |
| Node get first { |
| Node result = _this.$dom_firstChild; |
| if (result == null) throw new StateError("No elements"); |
| return result; |
| } |
| Node get last { |
| Node result = _this.$dom_lastChild; |
| if (result == null) throw new StateError("No elements"); |
| return result; |
| } |
| Node get single { |
| int l = this.length; |
| if (l == 0) throw new StateError("No elements"); |
| if (l > 1) throw new StateError("More than one element"); |
| return _this.$dom_firstChild; |
| } |
| $endif |
| |
| void add(Node value) { |
| _this.append(value); |
| } |
| |
| void addAll(Iterable<Node> iterable) { |
| if (iterable is _ChildNodeListLazy) { |
| _ChildNodeListLazy otherList = iterable; |
| if (!identical(otherList._this, _this)) { |
| // Optimized route for copying between nodes. |
| for (var i = 0, len = otherList.length; i < len; ++i) { |
| // Should use $dom_firstChild, Bug 8886. |
| _this.append(otherList[0]); |
| } |
| } |
| return; |
| } |
| for (Node node in iterable) { |
| _this.append(node); |
| } |
| } |
| |
| void insert(int index, Node node) { |
| if (index < 0 || index > length) { |
| throw new RangeError.range(index, 0, length); |
| } |
| if (index == length) { |
| _this.append(node); |
| } else { |
| _this.insertBefore(node, this[index]); |
| } |
| } |
| |
| void insertAll(int index, Iterable<Node> iterable) { |
| var item = this[index]; |
| _this.insertAllBefore(iterable, item); |
| } |
| |
| void setAll(int index, Iterable<Node> iterable) { |
| throw new UnsupportedError("Cannot setAll on Node list"); |
| } |
| |
| Node removeLast() { |
| final result = last; |
| if (result != null) { |
| _this.$dom_removeChild(result); |
| } |
| return result; |
| } |
| |
| Node removeAt(int index) { |
| var result = this[index]; |
| if (result != null) { |
| _this.$dom_removeChild(result); |
| } |
| return result; |
| } |
| |
| bool remove(Object object) { |
| if (object is! Node) return false; |
| Node node = object; |
| if (!identical(_this, node.parentNode)) return false; |
| _this.$dom_removeChild(node); |
| return true; |
| } |
| |
| void _filter(bool test(Node node), bool removeMatching) { |
| // This implementation of removeWhere/retainWhere is more efficient |
| // than the default in ListBase. Child nodes can be removed in constant |
| // time. |
| Node child = _this.$dom_firstChild; |
| while (child != null) { |
| Node nextChild = child.nextNode; |
| if (test(child) == removeMatching) { |
| _this.$dom_removeChild(child); |
| } |
| child = nextChild; |
| } |
| } |
| |
| void removeWhere(bool test(Node node)) { |
| _filter(test, true); |
| } |
| |
| void retainWhere(bool test(Node node)) { |
| _filter(test, false); |
| } |
| |
| void clear() { |
| _this.text = ''; |
| } |
| |
| void operator []=(int index, Node value) { |
| _this.$dom_replaceChild(value, this[index]); |
| } |
| |
| Iterator<Node> get iterator => _this.$dom_childNodes.iterator; |
| |
| // From List<Node>: |
| |
| // TODO(jacobr): this could be implemented for child node lists. |
| // The exception we throw here is misleading. |
| void sort([Comparator<Node> compare]) { |
| throw new UnsupportedError("Cannot sort Node list"); |
| } |
| |
| // FIXME: implement these. |
| void setRange(int start, int end, Iterable<Node> iterable, |
| [int skipCount = 0]) { |
| throw new UnsupportedError("Cannot setRange on Node list"); |
| } |
| |
| void fillRange(int start, int end, [Node fill]) { |
| throw new UnsupportedError("Cannot fillRange on Node list"); |
| } |
| // -- end List<Node> mixins. |
| |
| // TODO(jacobr): benchmark whether this is more efficient or whether caching |
| // a local copy of $dom_childNodes is more efficient. |
| int get length => _this.$dom_childNodes.length; |
| |
| void set length(int value) { |
| throw new UnsupportedError( |
| "Cannot set length on immutable List."); |
| } |
| |
| Node operator[](int index) => _this.$dom_childNodes[index]; |
| } |
| |
| $(ANNOTATIONS)class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC { |
| List<Node> get nodes { |
| return new _ChildNodeListLazy(this); |
| } |
| |
| void set nodes(Iterable<Node> value) { |
| // Copy list first since we don't want liveness during iteration. |
| // TODO(jacobr): there is a better way to do this. |
| List copy = new List.from(value); |
| text = ''; |
| for (Node node in copy) { |
| append(node); |
| } |
| } |
| |
| /** |
| * Removes this node from the DOM. |
| */ |
| @DomName('Node.removeChild') |
| void remove() { |
| // TODO(jacobr): should we throw an exception if parent is already null? |
| // TODO(vsm): Use the native remove when available. |
| if (this.parentNode != null) { |
| final Node parent = this.parentNode; |
| parentNode.$dom_removeChild(this); |
| } |
| } |
| |
| /** |
| * Replaces this node with another node. |
| */ |
| @DomName('Node.replaceChild') |
| Node replaceWith(Node otherNode) { |
| try { |
| final Node parent = this.parentNode; |
| parent.$dom_replaceChild(otherNode, this); |
| } catch (e) { |
| |
| }; |
| return this; |
| } |
| |
| /** |
| * Inserts all of the nodes into this node directly before refChild. |
| * |
| * See also: |
| * |
| * * [insertBefore] |
| */ |
| Node insertAllBefore(Iterable<Node> newNodes, Node refChild) { |
| if (newNodes is _ChildNodeListLazy) { |
| _ChildNodeListLazy otherList = newNodes; |
| if (identical(otherList._this, this)) { |
| throw new ArgumentError(newNodes); |
| } |
| |
| // Optimized route for copying between nodes. |
| for (var i = 0, len = otherList.length; i < len; ++i) { |
| // Should use $dom_firstChild, Bug 8886. |
| this.insertBefore(otherList[0], refChild); |
| } |
| } else { |
| for (var node in newNodes) { |
| this.insertBefore(node, refChild); |
| } |
| } |
| } |
| |
| /** |
| * Print out a String representation of this Node. |
| */ |
| String toString() => nodeValue == null ? super.toString() : nodeValue; |
| |
| /** |
| * Binds the attribute [name] to the [path] of the [model]. |
| * Path is a String of accessors such as `foo.bar.baz`. |
| */ |
| @Experimental |
| void bind(String name, model, String path) { |
| // TODO(jmesserly): should we throw instead? |
| window.console.error('Unhandled binding to Node: ' |
| '$this $name $model $path'); |
| } |
| |
| /** Unbinds the attribute [name]. */ |
| @Experimental |
| void unbind(String name) {} |
| |
| /** Unbinds all bound attributes. */ |
| @Experimental |
| void unbindAll() {} |
| |
| TemplateInstance _templateInstance; |
| |
| /** Gets the template instance that instantiated this node, if any. */ |
| @Experimental |
| TemplateInstance get templateInstance => |
| _templateInstance != null ? _templateInstance : |
| (parent != null ? parent.templateInstance : null); |
| |
| $!MEMBERS |
| } |