https://www.mediawiki.org/wiki/Special:Code/MediaWiki/102008
Revision: 102008
Author: tparscal
Date: 2011-11-04 16:41:34 +0000 (Fri, 04 Nov 2011)
Log Message:
-----------
Removed unused file
Removed Paths:
-------------
trunk/extensions/VisualEditor/modules/es/bases/es.DocumentNode.js
Deleted: trunk/extensions/VisualEditor/modules/es/bases/es.DocumentNode.js
===================================================================
--- trunk/extensions/VisualEditor/modules/es/bases/es.DocumentNode.js
2011-11-04 16:40:00 UTC (rev 102007)
+++ trunk/extensions/VisualEditor/modules/es/bases/es.DocumentNode.js
2011-11-04 16:41:34 UTC (rev 102008)
@@ -1,244 +0,0 @@
-/**
- * Creates an es.DocumentNode object.
- *
- * @class
- * @abstract
- * @constructor
- * @param {es.DocumentNode[]} nodes List of document nodes to initially add
- */
-es.DocumentNode = function( nodes ) {
- this.children = es.isArray( nodes ) ? nodes : [];
-};
-
-/* Abstract Methods */
-
-/**
- * Gets the element length.
- *
- * @abstract
- * @method
- * @returns {Integer} Length of element and it's content
- */
-es.DocumentNode.prototype.getElementLength = function() {
- throw 'DocumentNode.getElementLength not implemented in this subclass:
' + this.constructor;
-};
-
-es.DocumentNode.prototype.getContentLength = function() {
- throw 'DocumentNode.getContentLength not implemented in this subclass:
' + this.constructor;
-};
-
-/* Methods */
-
-/**
- * Gets a list of child nodes.
- *
- * @abstract
- * @method
- * @returns {es.DocumentNode[]} List of document nodes
- */
-es.DocumentNode.prototype.getChildren = function() {
- return this.children;
-};
-
-/**
- * Gets the range within this node that a given child node covers.
- *
- * @method
- * @param {es.ModelNode} node Node to get range for
- * @param {Boolean} [shallow] Do not iterate into child nodes of child nodes
- * @returns {es.Range|null} Range of node or null if node was not found
- */
-es.DocumentNode.prototype.getRangeFromNode = function( node, shallow ) {
- if ( this.children.length ) {
- for ( var i = 0, length = this.children.length, left = 0; i <
length; i++ ) {
- if ( this.children[i] === node ) {
- return new es.Range( left, left +
this.children[i].getElementLength() );
- }
- if ( !shallow && this.children[i].getChildren().length
) {
- var range = this.children[i].getRangeFromNode(
node );
- if ( range !== null ) {
- // Include opening of parent
- left++;
- return es.Range.newFromTranslatedRange(
range, left );
- }
- }
- left += this.children[i].getElementLength();
- }
- }
- return null;
-};
-
-/**
- * Gets the content offset of a node.
- *
- * This method is pretty expensive. If you need to get different slices of the
same content, get
- * the content first, then slice it up locally.
- *
- * TODO: Rewrite this method to not use recursion, because the function call
overhead is expensive
- *
- * @method
- * @param {es.DocumentModelNode} node Node to get offset of
- * @param {Boolean} [shallow] Do not iterate into child nodes of child nodes
- * @returns {Integer} Offset of node or -1 of node was not found
- */
-es.DocumentNode.prototype.getOffsetFromNode = function( node, shallow ) {
- if ( this.children.length ) {
- var offset = 0;
- for ( var i = 0, length = this.children.length; i < length; i++
) {
- if ( this.children[i] === node ) {
- return offset;
- }
- if ( !shallow && this.children[i].getChildren().length
) {
- var childOffset = this.getOffsetFromNode.call(
this.children[i], node );
- if ( childOffset !== -1 ) {
- return offset + 1 + childOffset;
- }
- }
- offset += this.children[i].getElementLength();
- }
- }
- return -1;
-};
-
-/**
- * Gets the node at a given offset.
- *
- * This method is pretty expensive. If you need to get different slices of the
same content, get
- * the content first, then slice it up locally.
- *
- * TODO: Rewrite this method to not use recursion, because the function call
overhead is expensive
- *
- * @method
- * @param {Integer} offset Offset get node for
- * @param {Boolean} [shallow] Do not iterate into child nodes of child nodes
- * @returns {es.DocumentModelNode|null} Node at offset, or null if non was
found
- */
-es.DocumentNode.prototype.getNodeFromOffset = function( offset, shallow ) {
- if ( this.children.length ) {
- var nodeOffset = 0,
- nodeLength;
- for ( var i = 0, length = this.children.length; i < length; i++
) {
- nodeLength = this.children[i].getElementLength();
- if ( offset >= nodeOffset && offset < nodeOffset +
nodeLength ) {
- if ( !shallow &&
this.children[i].getChildren().length ) {
- return this.getNodeFromOffset.call(
this.children[i], offset - nodeOffset - 1 );
- } else {
- return this.children[i];
- }
- }
- nodeOffset += nodeLength;
- }
- }
- return null;
-};
-
-/**
- * Gets a list of nodes and their sub-ranges which are covered by a given
range.
- *
- * @method
- * @param {es.Range} range Range to select nodes within
- * @param {Boolean} [shallow] Do not recurse into child nodes of child nodes
- * @returns {Array} List of objects with 'node' and 'range' properties
describing nodes which are
- * covered by the range and the range within the node that is covered
- */
-es.DocumentNode.prototype.selectNodes = function( range, shallow ) {
- if ( typeof range === 'undefined' ) {
- range = new es.Range( 0, this.model.getContentLength() );
- } else {
- range.normalize();
- }
- var nodes = [],
- i,
- left,
- right,
- start = range.start,
- end = range.end,
- startInside,
- endInside;
-
- if ( start < 0 ) {
- throw 'The start offset of the range is negative';
- }
-
- if ( this.children.length === 0 ) {
- // Special case: this node doesn't have any children
- // The return value is simply the range itself, if it is not
out of bounds
- if ( end > this.getContentLength() ) {
- throw 'The end offset of the range is past the end of
the node';
- }
- return [{ 'node': this, 'range': new es.Range( start, end ) }];
- }
-
- // This node has children, loop over them
- left = 1; // First offset inside the first child. Offset 0 is before
the first child
- for ( i = 0; i < this.children.length; i++ ) {
- // left <= any offset inside this.children[i] <= right
- right = left + this.children[i].getContentLength();
-
- if ( start == end && ( start == left - 1 || start == right + 1
) ) {
- // Empty range outside of any node
- return [];
- }
- if ( start == left - 1 && end == right + 1 ) {
- // The range covers the entire node, including its
opening and closing elements
- return [ { 'node': this.children[i] } ];
- }
- if ( start == left - 1 ) {
- // start is between this.children[i-1] and
this.children[i], move it to left for convenience
- // We don't need to check for start < end here because
we already have start != end and
- // start <= end
- start = left;
- }
- if ( end == right + 1 ) {
- // end is between this.children[i] and
this.children[i+1], move it to right for convenience
- // We don't need to check for start < end here because
we already have start != end and
- // start <= end
- end = right;
- }
-
- startInside = start >= left && start <= right; // is the start
inside this.children[i]?
- endInside = end >= left && end <= right; // is the end inside
this.children[i]?
-
- if ( startInside && endInside ) {
- // The range is entirely inside this.children[i]
- if ( shallow ) {
- nodes = [{ 'node': this.children[i], 'range':
new es.Range( start - left, end - left ) }];
- } else {
- // Recurse into this.children[i]
- nodes = this.children[i].selectNodes( new
es.Range( start - left, end - left ) );
- }
- // Since the start and end are both inside
this.children[i], we know for sure that we're done, so
- // return
- return nodes;
- } else if ( startInside ) {
- // The start is inside this.children[i] but the end
isn't
- // Add a range from the start of the range to the end
of this.children[i]
- nodes.push( { 'node': this.children[i], 'range': new
es.Range( start - left, right - left ) } );
- } else if ( endInside ) {
- // The end is inside this.children[i] but the start
isn't
- // Add a range from the start of this.children[i] to
the end of the range
- nodes.push( { 'node': this.children[i], 'range': new
es.Range( 0, end - left ) } );
- // We've found the end, so we're done
- return nodes;
- } else if ( nodes.length > 0 ) {
- // Neither the start nor the end is inside
this.children[i], but nodes is non-empty,
- // so this.children[i] must be between the start and
the end
- // Add the entire node, so no range property
- nodes.push( { 'node': this.children[i] } );
- }
-
- // Move left to the start of this.children[i+1] for the next
iteration
- // +2 because we need to jump over the offset between
this.children[i] and this.children[i+1]
- left = right + 2;
- }
-
- // If we got here, that means that at least some part of the range is
out of bounds
- // This is an error
- if ( nodes.length === 0 ) {
- throw 'The start offset of the range is past the end of the
node';
- } else {
- // Apparently the start was inside this node, but the end wasn't
- throw 'The end offset of the range is past the end of the node';
- }
- return nodes;
-};
_______________________________________________
MediaWiki-CVS mailing list
[email protected]
https://lists.wikimedia.org/mailman/listinfo/mediawiki-cvs
