*
*
*
*
* ```
*/
findParent:function (node, filterFn, includeSelf) {
if (node && !domUtils.isBody(node)) {
node = includeSelf ? node : node.parentNode;
while (node) {
if (!filterFn || filterFn(node) || domUtils.isBody(node)) {
return filterFn && !filterFn(node) && domUtils.isBody(node) ? null : node;
}
node = node.parentNode;
}
}
return null;
},
/**
* 查找node的节点名为tagName的第一个祖先节点， 查找的起点是node节点的父节点。
* @method findParentByTagName
* @param { Node } node 需要查找的节点对象
* @param { Array } tagNames 需要查找的父节点的名称数组
* @warning 查找的终点是到body节点为止
* @return { Node | NULL } 如果找到符合条件的节点， 则返回该节点， 否则返回NULL
* @example
* ```javascript
* var node = UE.dom.domUtils.findParentByTagName( document.getElementsByTagName("div")[0], [ "BODY" ] );
* //output: BODY
* console.log( node.tagName );
* ```
*/
/**
* 查找node的节点名为tagName的祖先节点， 如果includeSelf的值为true，则查找的起点是给定的节点node，
* 否则， 起点是node的父节点。
* @method findParentByTagName
* @param { Node } node 需要查找的节点对象
* @param { Array } tagNames 需要查找的父节点的名称数组
* @param { Boolean } includeSelf 查找过程是否包含node节点自身
* @warning 查找的终点是到body节点为止
* @return { Node | NULL } 如果找到符合条件的节点， 则返回该节点， 否则返回NULL
* @example
* ```javascript
* var queryTarget = document.getElementsByTagName("div")[0];
* var node = UE.dom.domUtils.findParentByTagName( queryTarget, [ "DIV" ], true );
* //output: true
* console.log( queryTarget === node );
* ```
*/
findParentByTagName:function (node, tagNames, includeSelf, excludeFn) {
tagNames = utils.listToMap(utils.isArray(tagNames) ? tagNames : [tagNames]);
return domUtils.findParent(node, function (node) {
return tagNames[node.tagName] && !(excludeFn && excludeFn(node));
}, includeSelf);
},
/**
* 查找节点node的祖先节点集合， 查找的起点是给定节点的父节点，结果集中不包含给定的节点。
* @method findParents
* @param { Node } node 需要查找的节点对象
* @return { Array } 给定节点的祖先节点数组
* @grammar UE.dom.domUtils.findParents(node) => Array //返回一个祖先节点数组集合，不包含自身
* @grammar UE.dom.domUtils.findParents(node,includeSelf) => Array //返回一个祖先节点数组集合，includeSelf指定是否包含自身
* @grammar UE.dom.domUtils.findParents(node,includeSelf,filterFn) => Array //返回一个祖先节点数组集合，filterFn指定过滤条件，返回true的node将被选取
* @grammar UE.dom.domUtils.findParents(node,includeSelf,filterFn,closerFirst) => Array //返回一个祖先节点数组集合，closerFirst为true的话，node的直接父亲节点是数组的第0个
*/
/**
* 查找节点node的祖先节点集合， 如果includeSelf的值为true，
* 则返回的结果集中允许出现当前给定的节点， 否则， 该节点不会出现在其结果集中。
* @method findParents
* @param { Node } node 需要查找的节点对象
* @param { Boolean } includeSelf 查找的结果中是否允许包含当前查找的节点对象
* @return { Array } 给定节点的祖先节点数组
*/
findParents:function (node, includeSelf, filterFn, closerFirst) {
var parents = includeSelf && ( filterFn && filterFn(node) || !filterFn ) ? [node] : [];
while (node = domUtils.findParent(node, filterFn)) {
parents.push(node);
}
return closerFirst ? parents : parents.reverse();
},
/**
* 在节点node后面插入新节点newNode
* @method insertAfter
* @param { Node } node 目标节点
* @param { Node } newNode 新插入的节点， 该节点将置于目标节点之后
* @return { Node } 新插入的节点
*/
insertAfter:function (node, newNode) {
return node.nextSibling ? node.parentNode.insertBefore(newNode, node.nextSibling):
node.parentNode.appendChild(newNode);
},
/**
* 删除节点node及其下属的所有节点
* @method remove
* @param { Node } node 需要删除的节点对象
* @return { Node } 返回刚删除的节点对象
* @example
* ```html
*
*
*
* ```
*/
/**
* 删除节点node，并根据keepChildren的值决定是否保留子节点
* @method remove
* @param { Node } node 需要删除的节点对象
* @param { Boolean } keepChildren 是否需要保留子节点
* @return { Node } 返回刚删除的节点对象
* @example
* ```html
* 你好
*
*
*
* ```
*/
remove:function (node, keepChildren) {
var parent = node.parentNode,
child;
if (parent) {
if (keepChildren && node.hasChildNodes()) {
while (child = node.firstChild) {
parent.insertBefore(child, node);
}
}
parent.removeChild(node);
}
return node;
},
/**
* 取得node节点的下一个兄弟节点， 如果该节点其后没有兄弟节点， 则递归查找其父节点之后的第一个兄弟节点，
* 直到找到满足条件的节点或者递归到BODY节点之后才会结束。
* @method getNextDomNode
* @param { Node } node 需要获取其后的兄弟节点的节点对象
* @return { Node | NULL } 如果找满足条件的节点， 则返回该节点， 否则返回NULL
* @example
* ```html
*
* 你好
*
*
*
* xxx
*
*
* ```
* @example
* ```html
*
*
*
* xxx
*
* xxx
*
*
* ```
*/
/**
* 取得node节点的下一个兄弟节点， 如果startFromChild的值为ture，则先获取其子节点，
* 如果有子节点则直接返回第一个子节点；如果没有子节点或者startFromChild的值为false，
* 则执行getNextDomNode(Node node)的查找过程。
* @method getNextDomNode
* @param { Node } node 需要获取其后的兄弟节点的节点对象
* @param { Boolean } startFromChild 查找过程是否从其子节点开始
* @return { Node | NULL } 如果找满足条件的节点， 则返回该节点， 否则返回NULL
* @see UE.dom.domUtils.getNextDomNode(Node)
*/
getNextDomNode:function (node, startFromChild, filterFn, guard) {
return getDomNode(node, 'firstChild', 'nextSibling', startFromChild, filterFn, guard);
},
getPreDomNode:function (node, startFromChild, filterFn, guard) {
return getDomNode(node, 'lastChild', 'previousSibling', startFromChild, filterFn, guard);
},
/**
* 检测节点node是否属是UEditor定义的bookmark节点
* @method isBookmarkNode
* @private
* @param { Node } node 需要检测的节点对象
* @return { Boolean } 是否是bookmark节点
* @example
* ```html
*
*
* ```
*/
isBookmarkNode:function (node) {
return node.nodeType == 1 && node.id && /^_baidu_bookmark_/i.test(node.id);
},
/**
* 获取节点node所属的window对象
* @method getWindow
* @param { Node } node 节点对象
* @return { Window } 当前节点所属的window对象
* @example
* ```javascript
* //output: true
* console.log( UE.dom.domUtils.getWindow( document.body ) === window );
* ```
*/
getWindow:function (node) {
var doc = node.ownerDocument || node;
return doc.defaultView || doc.parentWindow;
},
/**
* 获取离nodeA与nodeB最近的公共的祖先节点
* @method getCommonAncestor
* @param { Node } nodeA 第一个节点
* @param { Node } nodeB 第二个节点
* @remind 如果给定的两个节点是同一个节点， 将直接返回该节点。
* @return { Node | NULL } 如果未找到公共节点， 返回NULL， 否则返回最近的公共祖先节点。
* @example
* ```javascript
* var commonAncestor = UE.dom.domUtils.getCommonAncestor( document.body, document.body.firstChild );
* //output: true
* console.log( commonAncestor.tagName.toLowerCase() === 'body' );
* ```
*/
getCommonAncestor:function (nodeA, nodeB) {
if (nodeA === nodeB)
return nodeA;
var parentsA = [nodeA] , parentsB = [nodeB], parent = nodeA, i = -1;
while (parent = parent.parentNode) {
if (parent === nodeB) {
return parent;
}
parentsA.push(parent);
}
parent = nodeB;
while (parent = parent.parentNode) {
if (parent === nodeA)
return parent;
parentsB.push(parent);
}
parentsA.reverse();
parentsB.reverse();
while (i++, parentsA[i] === parentsB[i]) {
}
return i == 0 ? null : parentsA[i - 1];
},
/**
* 清除node节点左右连续为空的兄弟inline节点
* @method clearEmptySibling
* @param { Node } node 执行的节点对象， 如果该节点的左右连续的兄弟节点是空的inline节点，
* 则这些兄弟节点将被删除
* @grammar UE.dom.domUtils.clearEmptySibling(node,ignoreNext) //ignoreNext指定是否忽略右边空节点
* @grammar UE.dom.domUtils.clearEmptySibling(node,ignoreNext,ignorePre) //ignorePre指定是否忽略左边空节点
* @example
* ```html
*
*
*
*
*
* xxx
*
*
*
* ```
*/
/**
* 清除node节点左右连续为空的兄弟inline节点， 如果ignoreNext的值为true，
* 则忽略对右边兄弟节点的操作。
* @method clearEmptySibling
* @param { Node } node 执行的节点对象， 如果该节点的左右连续的兄弟节点是空的inline节点，
* @param { Boolean } ignoreNext 是否忽略忽略对右边的兄弟节点的操作
* 则这些兄弟节点将被删除
* @see UE.dom.domUtils.clearEmptySibling(Node)
*/
/**
* 清除node节点左右连续为空的兄弟inline节点， 如果ignoreNext的值为true，
* 则忽略对右边兄弟节点的操作， 如果ignorePre的值为true，则忽略对左边兄弟节点的操作。
* @method clearEmptySibling
* @param { Node } node 执行的节点对象， 如果该节点的左右连续的兄弟节点是空的inline节点，
* @param { Boolean } ignoreNext 是否忽略忽略对右边的兄弟节点的操作
* @param { Boolean } ignorePre 是否忽略忽略对左边的兄弟节点的操作
* 则这些兄弟节点将被删除
* @see UE.dom.domUtils.clearEmptySibling(Node)
*/
clearEmptySibling:function (node, ignoreNext, ignorePre) {
function clear(next, dir) {
var tmpNode;
while (next && !domUtils.isBookmarkNode(next) && (domUtils.isEmptyInlineElement(next)
//这里不能把空格算进来会吧空格干掉，出现文字间的空格丢掉了
|| !new RegExp('[^\t\n\r' + domUtils.fillChar + ']').test(next.nodeValue) )) {
tmpNode = next[dir];
domUtils.remove(next);
next = tmpNode;
}
}
!ignoreNext && clear(node.nextSibling, 'nextSibling');
!ignorePre && clear(node.previousSibling, 'previousSibling');
},
/**
* 将一个文本节点textNode拆分成两个文本节点，offset指定拆分位置
* @method split
* @param { Node } textNode 需要拆分的文本节点对象
* @param { int } offset 需要拆分的位置， 位置计算从0开始
* @return { Node } 拆分后形成的新节点
* @example
* ```html
* abcdef
*
* ```
*/
split:function (node, offset) {
var doc = node.ownerDocument;
if (browser.ie && offset == node.nodeValue.length) {
var next = doc.createTextNode('');
return domUtils.insertAfter(node, next);
}
var retval = node.splitText(offset);
//ie8下splitText不会跟新childNodes,我们手动触发他的更新
if (browser.ie8) {
var tmpNode = doc.createTextNode('');
domUtils.insertAfter(retval, tmpNode);
domUtils.remove(tmpNode);
}
return retval;
},
/**
* 检测文本节点textNode是否为空节点（包括空格、换行、占位符等字符）
* @method isWhitespace
* @param { Node } node 需要检测的节点对象
* @return { Boolean } 检测的节点是否为空
* @example
* ```html
*
*
*
*
* ```
*/
isWhitespace:function (node) {
return !new RegExp('[^ \t\n\r' + domUtils.fillChar + ']').test(node.nodeValue);
},
/**
* 获取元素element相对于viewport的位置坐标
* @method getXY
* @param { Node } element 需要计算位置的节点对象
* @return { Object } 返回形如{x:left,y:top}的一个key-value映射对象， 其中键x代表水平偏移距离，
* y代表垂直偏移距离。
*
* @example
* ```javascript
* var location = UE.dom.domUtils.getXY( document.getElementById("test") );
* //output: test的坐标为: 12, 24
* console.log( 'test的坐标为： ', location.x, ',', location.y );
* ```
*/
getXY:function (element) {
var x = 0, y = 0;
while (element.offsetParent) {
y += element.offsetTop;
x += element.offsetLeft;
element = element.offsetParent;
}
return { 'x':x, 'y':y};
},
/**
* 为元素element绑定原生DOM事件，type为事件类型，handler为处理函数
* @method on
* @param { Node } element 需要绑定事件的节点对象
* @param { String } type 绑定的事件类型
* @param { Function } handler 事件处理器
* @example
* ```javascript
* UE.dom.domUtils.on(document.body,"click",function(e){
* //e为事件对象，this为被点击元素对戏那个
* });
* ```
*/
/**
* 为元素element绑定原生DOM事件，type为事件类型，handler为处理函数
* @method on
* @param { Node } element 需要绑定事件的节点对象
* @param { Array } type 绑定的事件类型数组
* @param { Function } handler 事件处理器
* @example
* ```javascript
* UE.dom.domUtils.on(document.body,["click","mousedown"],function(evt){
* //evt为事件对象，this为被点击元素对象
* });
* ```
*/
on:function (element, type, handler) {
var types = utils.isArray(type) ? type : utils.trim(type).split(/\s+/),
k = types.length;
if (k) while (k--) {
type = types[k];
if (element.addEventListener) {
element.addEventListener(type, handler, false);
} else {
if (!handler._d) {
handler._d = {
els : []
};
}
var key = type + handler.toString(),index = utils.indexOf(handler._d.els,element);
if (!handler._d[key] || index == -1) {
if(index == -1){
handler._d.els.push(element);
}
if(!handler._d[key]){
handler._d[key] = function (evt) {
return handler.call(evt.srcElement, evt || window.event);
};
}
element.attachEvent('on' + type, handler._d[key]);
}
}
}
element = null;
},
/**
* 解除DOM事件绑定
* @method un
* @param { Node } element 需要解除事件绑定的节点对象
* @param { String } type 需要接触绑定的事件类型
* @param { Function } handler 对应的事件处理器
* @example
* ```javascript
* UE.dom.domUtils.un(document.body,"click",function(evt){
* //evt为事件对象，this为被点击元素对象
* });
* ```
*/
/**
* 解除DOM事件绑定
* @method un
* @param { Node } element 需要解除事件绑定的节点对象
* @param { Array } type 需要接触绑定的事件类型数组
* @param { Function } handler 对应的事件处理器
* @example
* ```javascript
* UE.dom.domUtils.un(document.body, ["click","mousedown"],function(evt){
* //evt为事件对象，this为被点击元素对象
* });
* ```
*/
un:function (element, type, handler) {
var types = utils.isArray(type) ? type : utils.trim(type).split(/\s+/),
k = types.length;
if (k) while (k--) {
type = types[k];
if (element.removeEventListener) {
element.removeEventListener(type, handler, false);
} else {
var key = type + handler.toString();
try{
element.detachEvent('on' + type, handler._d ? handler._d[key] : handler);
}catch(e){}
if (handler._d && handler._d[key]) {
var index = utils.indexOf(handler._d.els,element);
if(index!=-1){
handler._d.els.splice(index,1);
}
handler._d.els.length == 0 && delete handler._d[key];
}
}
}
},
/**
* 比较节点nodeA与节点nodeB是否具有相同的标签名、属性名以及属性值
* @method isSameElement
* @param { Node } nodeA 需要比较的节点
* @param { Node } nodeB 需要比较的节点
* @return { Boolean } 两个节点是否具有相同的标签名、属性名以及属性值
* @example
* ```html
* ssss
* bbbbb
* ssss
* bbbbb
*
*
* ```
*/
isSameElement:function (nodeA, nodeB) {
if (nodeA.tagName != nodeB.tagName) {
return false;
}
var thisAttrs = nodeA.attributes,
otherAttrs = nodeB.attributes;
if (!ie && thisAttrs.length != otherAttrs.length) {
return false;
}
var attrA, attrB, al = 0, bl = 0;
for (var i = 0; attrA = thisAttrs[i++];) {
if (attrA.nodeName == 'style') {
if (attrA.specified) {
al++;
}
if (domUtils.isSameStyle(nodeA, nodeB)) {
continue;
} else {
return false;
}
}
if (ie) {
if (attrA.specified) {
al++;
attrB = otherAttrs.getNamedItem(attrA.nodeName);
} else {
continue;
}
} else {
attrB = nodeB.attributes[attrA.nodeName];
}
if (!attrB.specified || attrA.nodeValue != attrB.nodeValue) {
return false;
}
}
// 有可能attrB的属性包含了attrA的属性之外还有自己的属性
if (ie) {
for (i = 0; attrB = otherAttrs[i++];) {
if (attrB.specified) {
bl++;
}
}
if (al != bl) {
return false;
}
}
return true;
},
/**
* 判断节点nodeA与节点nodeB的元素的style属性是否一致
* @method isSameStyle
* @param { Node } nodeA 需要比较的节点
* @param { Node } nodeB 需要比较的节点
* @return { Boolean } 两个节点是否具有相同的style属性值
* @example
* ```html
* ssss
* bbbbb
* ssss
* bbbbb
*
*
* ```
*/
isSameStyle:function (nodeA, nodeB) {
var styleA = nodeA.style.cssText.replace(/( ?; ?)/g, ';').replace(/( ?: ?)/g, ':'),
styleB = nodeB.style.cssText.replace(/( ?; ?)/g, ';').replace(/( ?: ?)/g, ':');
if (browser.opera) {
styleA = nodeA.style;
styleB = nodeB.style;
if (styleA.length != styleB.length)
return false;
for (var p in styleA) {
if (/^(\d+|csstext)$/i.test(p)) {
continue;
}
if (styleA[p] != styleB[p]) {
return false;
}
}
return true;
}
if (!styleA || !styleB) {
return styleA == styleB;
}
styleA = styleA.split(';');
styleB = styleB.split(';');
if (styleA.length != styleB.length) {
return false;
}
for (var i = 0, ci; ci = styleA[i++];) {
if (utils.indexOf(styleB, ci) == -1) {
return false;
}
}
return true;
},
/**
* 检查节点node是否为block元素
* @method isBlockElm
* @param { Node } node 需要检测的节点对象
* @return { Boolean } 是否是block元素节点
* @warning 该方法的判断规则如下： 如果该元素原本是block元素， 则不论该元素当前的css样式是什么都会返回true；
* 否则，检测该元素的css样式， 如果该元素当前是block元素， 则返回true。 其余情况下都返回false。
* @example
* ```html
*
*
*
*
*
* ```
*/
isBlockElm:function (node) {
return node.nodeType == 1 && (dtd.$block[node.tagName] || styleBlock[domUtils.getComputedStyle(node, 'display')]) && !dtd.$nonChild[node.tagName];
},
/**
* 检测node节点是否为body节点
* @method isBody
* @param { Element } node 需要检测的dom元素
* @return { Boolean } 给定的元素是否是body元素
* @example
* ```javascript
* //output: true
* console.log( UE.dom.domUtils.isBody( document.body ) );
* ```
*/
isBody:function (node) {
return node && node.nodeType == 1 && node.tagName.toLowerCase() == 'body';
},
/**
* 以node节点为分界，将该节点的指定祖先节点parent拆分成两个独立的节点，
* 拆分形成的两个节点之间是node节点
* @method breakParent
* @param { Node } node 作为分界的节点对象
* @param { Node } parent 该节点必须是node节点的祖先节点， 且是block节点。
* @return { Node } 给定的node分界节点
* @example
* ```javascript
*
* var node = document.createElement("span"),
* wrapNode = document.createElement( "div" ),
* parent = document.createElement("p");
*
* parent.appendChild( node );
* wrapNode.appendChild( parent );
*
* //拆分前
* //output: * console.log( wrapNode.innerHTML ); * * * UE.dom.domUtils.breakParent( node, parent ); * //拆分后 * //output: * console.log( wrapNode.innerHTML ); * * ``` */ breakParent:function (node, parent) { var tmpNode, parentClone = node, clone = node, leftNodes, rightNodes; do { parentClone = parentClone.parentNode; if (leftNodes) { tmpNode = parentClone.cloneNode(false); tmpNode.appendChild(leftNodes); leftNodes = tmpNode; tmpNode = parentClone.cloneNode(false); tmpNode.appendChild(rightNodes); rightNodes = tmpNode; } else { leftNodes = parentClone.cloneNode(false); rightNodes = leftNodes.cloneNode(false); } while (tmpNode = clone.previousSibling) { leftNodes.insertBefore(tmpNode, leftNodes.firstChild); } while (tmpNode = clone.nextSibling) { rightNodes.appendChild(tmpNode); } clone = parentClone; } while (parent !== parentClone); tmpNode = parent.parentNode; tmpNode.insertBefore(leftNodes, parent); tmpNode.insertBefore(rightNodes, parent); tmpNode.insertBefore(node, rightNodes); domUtils.remove(parent); return node; }, /** * 检查节点node是否是空inline节点 * @method isEmptyInlineElement * @param { Node } node 需要检测的节点对象 * @return { Number } 如果给定的节点是空的inline节点， 则返回1, 否则返回0。 * @example * ```html * => 1 * => 1 * => 1 * xx => 0 * ``` */ isEmptyInlineElement:function (node) { if (node.nodeType != 1 || !dtd.$removeEmpty[ node.tagName ]) { return 0; } node = node.firstChild; while (node) { //如果是创建的bookmark就跳过 if (domUtils.isBookmarkNode(node)) { return 0; } if (node.nodeType == 1 && !domUtils.isEmptyInlineElement(node) || node.nodeType == 3 && !domUtils.isWhitespace(node) ) { return 0; } node = node.nextSibling; } return 1; }, /** * 删除node节点下首尾两端的空白文本子节点 * @method trimWhiteTextNode * @param { Element } node 需要执行删除操作的元素对象 * @example * ```javascript * var node = document.createElement("div"); * * node.appendChild( document.createTextNode( "" ) ); * * node.appendChild( document.createElement("div") ); * * node.appendChild( document.createTextNode( "" ) ); * * //3 * console.log( node.childNodes.length ); * * UE.dom.domUtils.trimWhiteTextNode( node ); * * //1 * console.log( node.childNodes.length ); * ``` */ trimWhiteTextNode:function (node) { function remove(dir) { var child; while ((child = node[dir]) && child.nodeType == 3 && domUtils.isWhitespace(child)) { node.removeChild(child); } } remove('firstChild'); remove('lastChild'); }, /** * 合并node节点下相同的子节点 * @name mergeChild * @desc * UE.dom.domUtils.mergeChild(node,tagName) //tagName要合并的子节点的标签 * @example *
xxaaxx
* ==> UE.dom.domUtils.mergeChild(node,'span') *xxaaxx
*/ mergeChild:function (node, tagName, attrs) { var list = domUtils.getElementsByTagName(node, node.tagName.toLowerCase()); for (var i = 0, ci; ci = list[i++];) { if (!ci.parentNode || domUtils.isBookmarkNode(ci)) { continue; } //span单独处理 if (ci.tagName.toLowerCase() == 'span') { if (node === ci.parentNode) { domUtils.trimWhiteTextNode(node); if (node.childNodes.length == 1) { node.style.cssText = ci.style.cssText + ";" + node.style.cssText; domUtils.remove(ci, true); continue; } } ci.style.cssText = node.style.cssText + ';' + ci.style.cssText; if (attrs) { var style = attrs.style; if (style) { style = style.split(';'); for (var j = 0, s; s = style[j++];) { ci.style[utils.cssStyleToDomStyle(s.split(':')[0])] = s.split(':')[1]; } } } if (domUtils.isSameStyle(ci, node)) { domUtils.remove(ci, true); } continue; } if (domUtils.isSameElement(node, ci)) { domUtils.remove(ci, true); } } }, /** * 原生方法getElementsByTagName的封装 * @method getElementsByTagName * @param { Node } node 目标节点对象 * @param { String } tagName 需要查找的节点的tagName， 多个tagName以空格分割 * @return { Array } 符合条件的节点集合 */ getElementsByTagName:function (node, name,filter) { if(filter && utils.isString(filter)){ var className = filter; filter = function(node){return domUtils.hasClass(node,className)} } name = utils.trim(name).replace(/[ ]{2,}/g,' ').split(' '); var arr = []; for(var n = 0,ni;ni=name[n++];){ var list = node.getElementsByTagName(ni); for (var i = 0, ci; ci = list[i++];) { if(!filter || filter(ci)) arr.push(ci); } } return arr; }, /** * 将节点node提取到父节点上 * @method mergeToParent * @param { Element } node 需要提取的元素对象 * @example * ```html *
*
*
*
* ```
*/
mergeToParent:function (node) {
var parent = node.parentNode;
while (parent && dtd.$removeEmpty[parent.tagName]) {
if (parent.tagName == node.tagName || parent.tagName == 'A') {//针对a标签单独处理
domUtils.trimWhiteTextNode(parent);
//span需要特殊处理 不处理这样的情况 xxxxxxxxx
if (parent.tagName == 'SPAN' && !domUtils.isSameStyle(parent, node)
|| (parent.tagName == 'A' && node.tagName == 'SPAN')) {
if (parent.childNodes.length > 1 || parent !== node.parentNode) {
node.style.cssText = parent.style.cssText + ";" + node.style.cssText;
parent = parent.parentNode;
continue;
} else {
parent.style.cssText += ";" + node.style.cssText;
//trace:952 a标签要保持下划线
if (parent.tagName == 'A') {
parent.style.textDecoration = 'underline';
}
}
}
if (parent.tagName != 'A') {
parent === node.parentNode && domUtils.remove(node, true);
break;
}
}
parent = parent.parentNode;
}
},
/**
* 合并节点node的左右兄弟节点
* @method mergeSibling
* @param { Element } node 需要合并的目标节点
* @example
* ```html
* xxxxoooxxxx
*
*
* ```
*/
/**
* 合并节点node的左右兄弟节点， 可以根据给定的条件选择是否忽略合并左节点。
* @method mergeSibling
* @param { Element } node 需要合并的目标节点
* @param { Boolean } ignorePre 是否忽略合并左节点
* @example
* ```html
* xxxxoooxxxx
*
*
* ```
*/
/**
* 合并节点node的左右兄弟节点，可以根据给定的条件选择是否忽略合并左右节点。
* @method mergeSibling
* @param { Element } node 需要合并的目标节点
* @param { Boolean } ignorePre 是否忽略合并左节点
* @param { Boolean } ignoreNext 是否忽略合并右节点
* @remind 如果同时忽略左右节点， 则该操作什么也不会做
* @example
* ```html
* xxxxoooxxxx
*
*
* ```
*/
mergeSibling:function (node, ignorePre, ignoreNext) {
function merge(rtl, start, node) {
var next;
if ((next = node[rtl]) && !domUtils.isBookmarkNode(next) && next.nodeType == 1 && domUtils.isSameElement(node, next)) {
while (next.firstChild) {
if (start == 'firstChild') {
node.insertBefore(next.lastChild, node.firstChild);
} else {
node.appendChild(next.firstChild);
}
}
domUtils.remove(next);
}
}
!ignorePre && merge('previousSibling', 'firstChild', node);
!ignoreNext && merge('nextSibling', 'lastChild', node);
},
/**
* 设置节点node及其子节点不会被选中
* @method unSelectable
* @param { Element } node 需要执行操作的dom元素
* @remind 执行该操作后的节点， 将不能被鼠标选中
* @example
* ```javascript
* UE.dom.domUtils.unSelectable( document.body );
* ```
*/
unSelectable:ie && browser.ie9below || browser.opera ? function (node) {
//for ie9
node.onselectstart = function () {
return false;
};
node.onclick = node.onkeyup = node.onkeydown = function () {
return false;
};
node.unselectable = 'on';
node.setAttribute("unselectable", "on");
for (var i = 0, ci; ci = node.all[i++];) {
switch (ci.tagName.toLowerCase()) {
case 'iframe' :
case 'textarea' :
case 'input' :
case 'select' :
break;
default :
ci.unselectable = 'on';
node.setAttribute("unselectable", "on");
}
}
} : function (node) {
node.style.MozUserSelect =
node.style.webkitUserSelect =
node.style.msUserSelect =
node.style.KhtmlUserSelect = 'none';
},
/**
* 删除节点node上的指定属性名称的属性
* @method removeAttributes
* @param { Node } node 需要删除属性的节点对象
* @param { String } attrNames 可以是空格隔开的多个属性名称，该操作将会依次删除相应的属性
* @example
* ```html
*
*
*
*
* xxxxx
*
*
*
* ```
*/
/**
* 删除节点node上的指定属性名称的属性
* @method removeAttributes
* @param { Node } node 需要删除属性的节点对象
* @param { Array } attrNames 需要删除的属性名数组
* @example
* ```html
*
* xxxxx
*
*
*
* ```
*/
removeAttributes:function (node, attrNames) {
attrNames = utils.isArray(attrNames) ? attrNames : utils.trim(attrNames).replace(/[ ]{2,}/g,' ').split(' ');
for (var i = 0, ci; ci = attrNames[i++];) {
ci = attrFix[ci] || ci;
switch (ci) {
case 'className':
node[ci] = '';
break;
case 'style':
node.style.cssText = '';
var val = node.getAttributeNode('style');
!browser.ie && val && node.removeAttributeNode(val);
}
node.removeAttribute(ci);
}
},
/**
* 在doc下创建一个标签名为tag，属性为attrs的元素
* @method createElement
* @param { DomDocument } doc 新创建的元素属于该document节点创建
* @param { String } tagName 需要创建的元素的标签名
* @param { Object } attrs 新创建的元素的属性key-value集合
* @return { Element } 新创建的元素对象
* @example
* ```javascript
* var ele = UE.dom.domUtils.createElement( document, 'div', {
* id: 'test'
* } );
*
* //output: DIV
* console.log( ele.tagName );
*
* //output: test
* console.log( ele.id );
*
* ```
*/
createElement:function (doc, tag, attrs) {
return domUtils.setAttributes(doc.createElement(tag), attrs)
},
/**
* 为节点node添加属性attrs，attrs为属性键值对
* @method setAttributes
* @param { Element } node 需要设置属性的元素对象
* @param { Object } attrs 需要设置的属性名-值对
* @return { Element } 设置属性的元素对象
* @example
* ```html
*
*
*
*
*/
setAttributes:function (node, attrs) {
for (var attr in attrs) {
if(attrs.hasOwnProperty(attr)){
var value = attrs[attr];
switch (attr) {
case 'class':
//ie下要这样赋值，setAttribute不起作用
node.className = value;
break;
case 'style' :
node.style.cssText = node.style.cssText + ";" + value;
break;
case 'innerHTML':
node[attr] = value;
break;
case 'value':
node.value = value;
break;
default:
node.setAttribute(attrFix[attr] || attr, value);
}
}
}
return node;
},
/**
* 获取元素element经过计算后的样式值
* @method getComputedStyle
* @param { Element } element 需要获取样式的元素对象
* @param { String } styleName 需要获取的样式名
* @return { String } 获取到的样式值
* @example
* ```html
*
*
*
*
*
* ```
*/
getComputedStyle:function (element, styleName) {
//一下的属性单独处理
var pros = 'width height top left';
if(pros.indexOf(styleName) > -1){
return element['offset' + styleName.replace(/^\w/,function(s){return s.toUpperCase()})] + 'px';
}
//忽略文本节点
if (element.nodeType == 3) {
element = element.parentNode;
}
//ie下font-size若body下定义了font-size，则从currentStyle里会取到这个font-size. 取不到实际值，故此修改.
if (browser.ie && browser.version < 9 && styleName == 'font-size' && !element.style.fontSize &&
!dtd.$empty[element.tagName] && !dtd.$nonChild[element.tagName]) {
var span = element.ownerDocument.createElement('span');
span.style.cssText = 'padding:0;border:0;font-family:simsun;';
span.innerHTML = '.';
element.appendChild(span);
var result = span.offsetHeight;
element.removeChild(span);
span = null;
return result + 'px';
}
try {
var value = domUtils.getStyle(element, styleName) ||
(window.getComputedStyle ? domUtils.getWindow(element).getComputedStyle(element, '').getPropertyValue(styleName) :
( element.currentStyle || element.style )[utils.cssStyleToDomStyle(styleName)]);
} catch (e) {
return "";
}
return utils.transUnitToPx(utils.fixColor(styleName, value));
},
/**
* 删除元素element指定的className
* @method removeClasses
* @param { Element } ele 需要删除class的元素节点
* @param { String } classNames 需要删除的className， 多个className之间以空格分开
* @example
* ```html
* xxx
*
*
* ```
*/
/**
* 删除元素element指定的className
* @method removeClasses
* @param { Element } ele 需要删除class的元素节点
* @param { Array } classNames 需要删除的className数组
* @example
* ```html
* xxx
*
*
* ```
*/
removeClasses:function (elm, classNames) {
classNames = utils.isArray(classNames) ? classNames :
utils.trim(classNames).replace(/[ ]{2,}/g,' ').split(' ');
for(var i = 0,ci,cls = elm.className;ci=classNames[i++];){
cls = cls.replace(new RegExp('\\b' + ci + '\\b'),'')
}
cls = utils.trim(cls).replace(/[ ]{2,}/g,' ');
if(cls){
elm.className = cls;
}else{
domUtils.removeAttributes(elm,['class']);
}
},
/**
* 给元素element添加className
* @method addClass
* @param { Node } ele 需要增加className的元素
* @param { String } classNames 需要添加的className， 多个className之间以空格分割
* @remind 相同的类名不会被重复添加
* @example
* ```html
*
*
*
* ```
*/
/**
* 判断元素element是否包含给定的样式类名className
* @method hasClass
* @param { Node } ele 需要检测的元素
* @param { Array } classNames 需要检测的className数组
* @return { Boolean } 元素是否包含所有给定的className
* @example
* ```html
*
*
*
* ```
*/
hasClass:function (element, className) {
if(utils.isRegExp(className)){
return className.test(element.className)
}
className = utils.trim(className).replace(/[ ]{2,}/g,' ').split(' ');
for(var i = 0,ci,cls = element.className;ci=className[i++];){
if(!new RegExp('\\b' + ci + '\\b','i').test(cls)){
return false;
}
}
return i - 1 == className.length;
},
/**
* 阻止事件默认行为
* @method preventDefault
* @param { Event } evt 需要阻止默认行为的事件对象
* @example
* ```javascript
* UE.dom.domUtils.preventDefault( evt );
* ```
*/
preventDefault:function (evt) {
evt.preventDefault ? evt.preventDefault() : (evt.returnValue = false);
},
/**
* 删除元素element指定的样式
* @method removeStyle
* @param { Element } element 需要删除样式的元素
* @param { String } styleName 需要删除的样式名
* @example
* ```html
*
*
*
* ```
*/
removeStyle:function (element, name) {
if(browser.ie ){
//针对color先单独处理一下
if(name == 'color'){
name = '(^|;)' + name;
}
element.style.cssText = element.style.cssText.replace(new RegExp(name + '[^:]*:[^;]+;?','ig'),'')
}else{
if (element.style.removeProperty) {
element.style.removeProperty (name);
}else {
element.style.removeAttribute (utils.cssStyleToDomStyle(name));
}
}
if (!element.style.cssText) {
domUtils.removeAttributes(element, ['style']);
}
},
/**
* 获取元素element的style属性的指定值
* @method getStyle
* @param { Element } element 需要获取属性值的元素
* @param { String } styleName 需要获取的style的名称
* @warning 该方法仅获取元素style属性中所标明的值
* @return { String } 该元素包含指定的style属性值
* @example
* ```html
*
*
*
* ```
*/
getStyle:function (element, name) {
var value = element.style[ utils.cssStyleToDomStyle(name) ];
return utils.fixColor(name, value);
},
/**
* 为元素element设置样式属性值
* @method setStyle
* @param { Element } element 需要设置样式的元素
* @param { String } styleName 样式名
* @param { String } styleValue 样式值
* @example
* ```html
*
*
*
* ```
*/
setStyle:function (element, name, value) {
element.style[utils.cssStyleToDomStyle(name)] = value;
if(!utils.trim(element.style.cssText)){
this.removeAttributes(element,'style')
}
},
/**
* 为元素element设置多个样式属性值
* @method setStyles
* @param { Element } element 需要设置样式的元素
* @param { Object } styles 样式名值对
* @example
* ```html
*
*
*
* ```
*/
setStyles:function (element, styles) {
for (var name in styles) {
if (styles.hasOwnProperty(name)) {
domUtils.setStyle(element, name, styles[name]);
}
}
},
/**
* 删除_moz_dirty属性
* @private
* @method removeDirtyAttr
*/
removeDirtyAttr:function (node) {
for (var i = 0, ci, nodes = node.getElementsByTagName('*'); ci = nodes[i++];) {
ci.removeAttribute('_moz_dirty');
}
node.removeAttribute('_moz_dirty');
},
/**
* 获取子节点的数量
* @method getChildCount
* @param { Element } node 需要检测的元素
* @return { Number } 给定的node元素的子节点数量
* @example
* ```html
*
*
*
*
*
* ```
*/
/**
* 根据给定的过滤规则， 获取符合条件的子节点的数量
* @method getChildCount
* @param { Element } node 需要检测的元素
* @param { Function } fn 过滤器， 要求对符合条件的子节点返回true， 反之则要求返回false
* @return { Number } 符合过滤条件的node元素的子节点数量
* @example
* ```html
*
*
*
*
*
* ```
*/
getChildCount:function (node, fn) {
var count = 0, first = node.firstChild;
fn = fn || function () {
return 1;
};
while (first) {
if (fn(first)) {
count++;
}
first = first.nextSibling;
}
return count;
},
/**
* 判断给定节点是否为空节点
* @method isEmptyNode
* @param { Node } node 需要检测的节点对象
* @return { Boolean } 节点是否为空
* @example
* ```javascript
* UE.dom.domUtils.isEmptyNode( document.body );
* ```
*/
isEmptyNode:function (node) {
return !node.firstChild || domUtils.getChildCount(node, function (node) {
return !domUtils.isBr(node) && !domUtils.isBookmarkNode(node) && !domUtils.isWhitespace(node)
}) == 0
},
clearSelectedArr:function (nodes) {
var node;
while (node = nodes.pop()) {
domUtils.removeAttributes(node, ['class']);
}
},
/**
* 将显示区域滚动到指定节点的位置
* @method scrollToView
* @param {Node} node 节点
* @param {window} win window对象
* @param {Number} offsetTop 距离上方的偏移量
*/
scrollToView:function (node, win, offsetTop) {
var getViewPaneSize = function () {
var doc = win.document,
mode = doc.compatMode == 'CSS1Compat';
return {
width:( mode ? doc.documentElement.clientWidth : doc.body.clientWidth ) || 0,
height:( mode ? doc.documentElement.clientHeight : doc.body.clientHeight ) || 0
};
},
getScrollPosition = function (win) {
if ('pageXOffset' in win) {
return {
x:win.pageXOffset || 0,
y:win.pageYOffset || 0
};
}
else {
var doc = win.document;
return {
x:doc.documentElement.scrollLeft || doc.body.scrollLeft || 0,
y:doc.documentElement.scrollTop || doc.body.scrollTop || 0
};
}
};
var winHeight = getViewPaneSize().height, offset = winHeight * -1 + offsetTop;
offset += (node.offsetHeight || 0);
var elementPosition = domUtils.getXY(node);
offset += elementPosition.y;
var currentScroll = getScrollPosition(win).y;
// offset += 50;
if (offset > currentScroll || offset < currentScroll - winHeight) {
win.scrollTo(0, offset + (offset < 0 ? -20 : 20));
}
},
/**
* 判断给定节点是否为br
* @method isBr
* @param { Node } node 需要判断的节点对象
* @return { Boolean } 给定的节点是否是br节点
*/
isBr:function (node) {
return node.nodeType == 1 && node.tagName == 'BR';
},
/**
* 判断给定的节点是否是一个“填充”节点
* @private
* @method isFillChar
* @param { Node } node 需要判断的节点
* @param { Boolean } isInStart 是否从节点内容的开始位置匹配
* @returns { Boolean } 节点是否是填充节点
*/
isFillChar:function (node,isInStart) {
if(node.nodeType != 3)
return false;
var text = node.nodeValue;
if(isInStart){
return new RegExp('^' + domUtils.fillChar).test(text)
}
return !text.replace(new RegExp(domUtils.fillChar,'g'), '').length
},
isStartInblock:function (range) {
var tmpRange = range.cloneRange(),
flag = 0,
start = tmpRange.startContainer,
tmp;
if(start.nodeType == 1 && start.childNodes[tmpRange.startOffset]){
start = start.childNodes[tmpRange.startOffset];
var pre = start.previousSibling;
while(pre && domUtils.isFillChar(pre)){
start = pre;
pre = pre.previousSibling;
}
}
if(this.isFillChar(start,true) && tmpRange.startOffset == 1){
tmpRange.setStartBefore(start);
start = tmpRange.startContainer;
}
while (start && domUtils.isFillChar(start)) {
tmp = start;
start = start.previousSibling
}
if (tmp) {
tmpRange.setStartBefore(tmp);
start = tmpRange.startContainer;
}
if (start.nodeType == 1 && domUtils.isEmptyNode(start) && tmpRange.startOffset == 1) {
tmpRange.setStart(start, 0).collapse(true);
}
while (!tmpRange.startOffset) {
start = tmpRange.startContainer;
if (domUtils.isBlockElm(start) || domUtils.isBody(start)) {
flag = 1;
break;
}
var pre = tmpRange.startContainer.previousSibling,
tmpNode;
if (!pre) {
tmpRange.setStartBefore(tmpRange.startContainer);
} else {
while (pre && domUtils.isFillChar(pre)) {
tmpNode = pre;
pre = pre.previousSibling;
}
if (tmpNode) {
tmpRange.setStartBefore(tmpNode);
} else {
tmpRange.setStartBefore(tmpRange.startContainer);
}
}
}
return flag && !domUtils.isBody(tmpRange.startContainer) ? 1 : 0;
},
/**
* 判断给定的元素是否是一个空元素
* @method isEmptyBlock
* @param { Element } node 需要判断的元素
* @return { Boolean } 是否是空元素
* @example
* ```html
*
*
*
* ```
*/
/**
* 根据指定的判断规则判断给定的元素是否是一个空元素
* @method isEmptyBlock
* @param { Element } node 需要判断的元素
* @param { RegExp } reg 对内容执行判断的正则表达式对象
* @return { Boolean } 是否是空元素
*/
isEmptyBlock:function (node,reg) {
if(node.nodeType != 1)
return 0;
reg = reg || new RegExp('[ \xa0\t\r\n' + domUtils.fillChar + ']', 'g');
if (node[browser.ie ? 'innerText' : 'textContent'].replace(reg, '').length > 0) {
return 0;
}
for (var n in dtd.$isNotEmpty) {
if (node.getElementsByTagName(n).length) {
return 0;
}
}
return 1;
},
/**
* 移动元素使得该元素的位置移动指定的偏移量的距离
* @method setViewportOffset
* @param { Element } element 需要设置偏移量的元素
* @param { Object } offset 偏移量， 形如{ left: 100, top: 50 }的一个键值对， 表示该元素将在
* 现有的位置上向水平方向偏移offset.left的距离， 在竖直方向上偏移
* offset.top的距离
* @example
* ```html
*
*
*
* ```
*/
setViewportOffset:function (element, offset) {
var left = parseInt(element.style.left) | 0;
var top = parseInt(element.style.top) | 0;
var rect = element.getBoundingClientRect();
var offsetLeft = offset.left - rect.left;
var offsetTop = offset.top - rect.top;
if (offsetLeft) {
element.style.left = left + offsetLeft + 'px';
}
if (offsetTop) {
element.style.top = top + offsetTop + 'px';
}
},
/**
* 用“填充字符”填充节点
* @method fillNode
* @private
* @param { DomDocument } doc 填充的节点所在的docment对象
* @param { Node } node 需要填充的节点对象
* @example
* ```html
*
*
*
* ```
*/
fillNode:function (doc, node) {
var tmpNode = browser.ie ? doc.createTextNode(domUtils.fillChar) : doc.createElement('br');
node.innerHTML = '';
node.appendChild(tmpNode);
},
/**
* 把节点src的所有子节点追加到另一个节点tag上去
* @method moveChild
* @param { Node } src 源节点， 该节点下的所有子节点将被删除
* @param { Node } tag 目标节点， 从源节点删除的子节点将被追加到该节点下
* @example
* ```html
*
*
*
*
*
*
*
*
* ```
*/
/**
* 把节点src的所有子节点移动到另一个节点tag上去, 可以通过dir参数控制附加的行为是“追加”还是“插入顶部”
* @method moveChild
* @param { Node } src 源节点， 该节点下的所有子节点将被删除
* @param { Node } tag 目标节点， 从源节点删除的子节点将被附加到该节点下
* @param { Boolean } dir 附加方式， 如果为true， 则附加进去的节点将被放到目标节点的顶部， 反之，则放到末尾
* @example
* ```html
*
*
*
*
*
*
*
*
* ```
*/
moveChild:function (src, tag, dir) {
while (src.firstChild) {
if (dir && tag.firstChild) {
tag.insertBefore(src.lastChild, tag.firstChild);
} else {
tag.appendChild(src.firstChild);
}
}
},
/**
* 判断节点的标签上是否不存在任何属性
* @method hasNoAttributes
* @private
* @param { Node } node 需要检测的节点对象
* @return { Boolean } 节点是否不包含任何属性
* @example
* ```html
* xxxx
*
*
* ```
*/
hasNoAttributes:function (node) {
return browser.ie ? /^<\w+\s*?>/.test(node.outerHTML) : node.attributes.length == 0;
},
/**
* 检测节点是否是UEditor所使用的辅助节点
* @method isCustomeNode
* @private
* @param { Node } node 需要检测的节点
* @remind 辅助节点是指编辑器要完成工作临时添加的节点， 在输出的时候将会从编辑器内删除， 不会影响最终的结果。
* @return { Boolean } 给定的节点是否是一个辅助节点
*/
isCustomeNode:function (node) {
return node.nodeType == 1 && node.getAttribute('_ue_custom_node_');
},
/**
* 检测节点的标签是否是给定的标签
* @method isTagNode
* @param { Node } node 需要检测的节点对象
* @param { String } tagName 标签
* @return { Boolean } 节点的标签是否是给定的标签
* @example
* ```html
*
*
*
* ```
*/
isTagNode:function (node, tagNames) {
return node.nodeType == 1 && new RegExp('\\b' + node.tagName + '\\b','i').test(tagNames)
},
/**
* 给定一个节点数组，在通过指定的过滤器过滤后， 获取其中满足过滤条件的第一个节点
* @method filterNodeList
* @param { Array } nodeList 需要过滤的节点数组
* @param { Function } fn 过滤器， 对符合条件的节点， 执行结果返回true， 反之则返回false
* @return { Node | NULL } 如果找到符合过滤条件的节点， 则返回该节点， 否则返回NULL
* @example
* ```javascript
* var divNodes = document.getElementsByTagName("div");
* divNodes = [].slice.call( divNodes, 0 );
*
* //output: null
* console.log( UE.dom.domUtils.filterNodeList( divNodes, function ( node ) {
* return node.tagName.toLowerCase() !== 'div';
* } ) );
* ```
*/
/**
* 给定一个节点数组nodeList和一组标签名tagNames， 获取其中能够匹配标签名的节点集合中的第一个节点
* @method filterNodeList
* @param { Array } nodeList 需要过滤的节点数组
* @param { String } tagNames 需要匹配的标签名， 多个标签名之间用空格分割
* @return { Node | NULL } 如果找到标签名匹配的节点， 则返回该节点， 否则返回NULL
* @example
* ```javascript
* var divNodes = document.getElementsByTagName("div");
* divNodes = [].slice.call( divNodes, 0 );
*
* //output: null
* console.log( UE.dom.domUtils.filterNodeList( divNodes, 'a span' ) );
* ```
*/
/**
* 给定一个节点数组，在通过指定的过滤器过滤后， 如果参数forAll为true， 则会返回所有满足过滤
* 条件的节点集合， 否则， 返回满足条件的节点集合中的第一个节点
* @method filterNodeList
* @param { Array } nodeList 需要过滤的节点数组
* @param { Function } fn 过滤器， 对符合条件的节点， 执行结果返回true， 反之则返回false
* @param { Boolean } forAll 是否返回整个节点数组, 如果该参数为false， 则返回节点集合中的第一个节点
* @return { Array | Node | NULL } 如果找到符合过滤条件的节点， 则根据参数forAll的值决定返回满足
* 过滤条件的节点数组或第一个节点， 否则返回NULL
* @example
* ```javascript
* var divNodes = document.getElementsByTagName("div");
* divNodes = [].slice.call( divNodes, 0 );
*
* //output: 3（假定有3个div）
* console.log( divNodes.length );
*
* var nodes = UE.dom.domUtils.filterNodeList( divNodes, function ( node ) {
* return node.tagName.toLowerCase() === 'div';
* }, true );
*
* //output: 3
* console.log( nodes.length );
*
* var node = UE.dom.domUtils.filterNodeList( divNodes, function ( node ) {
* return node.tagName.toLowerCase() === 'div';
* }, false );
*
* //output: div
* console.log( node.nodeName );
* ```
*/
filterNodeList : function(nodelist,filter,forAll){
var results = [];
if(!utils .isFunction(filter)){
var str = filter;
filter = function(n){
return utils.indexOf(utils.isArray(str) ? str:str.split(' '), n.tagName.toLowerCase()) != -1
};
}
utils.each(nodelist,function(n){
filter(n) && results.push(n)
});
return results.length == 0 ? null : results.length == 1 || !forAll ? results[0] : results
},
/**
* 查询给定的range选区是否在给定的node节点内，且在该节点的最末尾
* @method isInNodeEndBoundary
* @param { UE.dom.Range } rng 需要判断的range对象， 该对象的startContainer不能为NULL
* @param node 需要检测的节点对象
* @return { Number } 如果给定的选取range对象是在node内部的最末端， 则返回1, 否则返回0
*/
isInNodeEndBoundary : function (rng,node){
var start = rng.startContainer;
if(start.nodeType == 3 && rng.startOffset != start.nodeValue.length){
return 0;
}
if(start.nodeType == 1 && rng.startOffset != start.childNodes.length){
return 0;
}
while(start !== node){
if(start.nextSibling){
return 0
};
start = start.parentNode;
}
return 1;
},
isBoundaryNode : function (node,dir){
var tmp;
while(!domUtils.isBody(node)){
tmp = node;
node = node.parentNode;
if(tmp !== node[dir]){
return false;
}
}
return true;
},
fillHtml : browser.ie11below ? ' ' : '' }; var fillCharReg = new RegExp(domUtils.fillChar, 'g'); // core/Range.js /** * Range封装 * @file * @module UE.dom * @class Range * @since 1.2.6.1 */ /** * dom操作封装 * @unfile * @module UE.dom */ /** * Range实现类，本类是UEditor底层核心类，封装不同浏览器之间的Range操作。 * @unfile * @module UE.dom * @class Range */ (function () { var guid = 0, fillChar = domUtils.fillChar, fillData; /** * 更新range的collapse状态 * @param {Range} range range对象 */ function updateCollapse(range) { range.collapsed = range.startContainer && range.endContainer && range.startContainer === range.endContainer && range.startOffset == range.endOffset; } function selectOneNode(rng){ return !rng.collapsed && rng.startContainer.nodeType == 1 && rng.startContainer === rng.endContainer && rng.endOffset - rng.startOffset == 1 } function setEndPoint(toStart, node, offset, range) { //如果node是自闭合标签要处理 if (node.nodeType == 1 && (dtd.$empty[node.tagName] || dtd.$nonChild[node.tagName])) { offset = domUtils.getNodeIndex(node) + (toStart ? 0 : 1); node = node.parentNode; } if (toStart) { range.startContainer = node; range.startOffset = offset; if (!range.endContainer) { range.collapse(true); } } else { range.endContainer = node; range.endOffset = offset; if (!range.startContainer) { range.collapse(false); } } updateCollapse(range); return range; } function execContentsAction(range, action) { //调整边界 //range.includeBookmark(); var start = range.startContainer, end = range.endContainer, startOffset = range.startOffset, endOffset = range.endOffset, doc = range.document, frag = doc.createDocumentFragment(), tmpStart, tmpEnd; if (start.nodeType == 1) { start = start.childNodes[startOffset] || (tmpStart = start.appendChild(doc.createTextNode(''))); } if (end.nodeType == 1) { end = end.childNodes[endOffset] || (tmpEnd = end.appendChild(doc.createTextNode(''))); } if (start === end && start.nodeType == 3) { frag.appendChild(doc.createTextNode(start.substringData(startOffset, endOffset - startOffset))); //is not clone if (action) { start.deleteData(startOffset, endOffset - startOffset); range.collapse(true); } return frag; } var current, currentLevel, clone = frag, startParents = domUtils.findParents(start, true), endParents = domUtils.findParents(end, true); for (var i = 0; startParents[i] == endParents[i];) { i++; } for (var j = i, si; si = startParents[j]; j++) { current = si.nextSibling; if (si == start) { if (!tmpStart) { if (range.startContainer.nodeType == 3) { clone.appendChild(doc.createTextNode(start.nodeValue.slice(startOffset))); //is not clone if (action) { start.deleteData(startOffset, start.nodeValue.length - startOffset); } } else { clone.appendChild(!action ? start.cloneNode(true) : start); } } } else { currentLevel = si.cloneNode(false); clone.appendChild(currentLevel); } while (current) { if (current === end || current === endParents[j]) { break; } si = current.nextSibling; clone.appendChild(!action ? current.cloneNode(true) : current); current = si; } clone = currentLevel; } clone = frag; if (!startParents[i]) { clone.appendChild(startParents[i - 1].cloneNode(false)); clone = clone.firstChild; } for (var j = i, ei; ei = endParents[j]; j++) { current = ei.previousSibling; if (ei == end) { if (!tmpEnd && range.endContainer.nodeType == 3) { clone.appendChild(doc.createTextNode(end.substringData(0, endOffset))); //is not clone if (action) { end.deleteData(0, endOffset); } } } else { currentLevel = ei.cloneNode(false); clone.appendChild(currentLevel); } //如果两端同级，右边第一次已经被开始做了 if (j != i || !startParents[i]) { while (current) { if (current === start) { break; } ei = current.previousSibling; clone.insertBefore(!action ? current.cloneNode(true) : current, clone.firstChild); current = ei; } } clone = currentLevel; } if (action) { range.setStartBefore(!endParents[i] ? endParents[i - 1] : !startParents[i] ? startParents[i - 1] : endParents[i]).collapse(true); } tmpStart && domUtils.remove(tmpStart); tmpEnd && domUtils.remove(tmpEnd); return frag; } /** * 创建一个跟document绑定的空的Range实例 * @constructor * @param { Document } document 新建的选区所属的文档对象 */ /** * @property { Node } startContainer 当前Range的开始边界的容器节点, 可以是一个元素节点或者是文本节点 */ /** * @property { Node } startOffset 当前Range的开始边界容器节点的偏移量, 如果是元素节点， * 该值就是childNodes中的第几个节点， 如果是文本节点就是文本内容的第几个字符 */ /** * @property { Node } endContainer 当前Range的结束边界的容器节点, 可以是一个元素节点或者是文本节点 */ /** * @property { Node } endOffset 当前Range的结束边界容器节点的偏移量, 如果是元素节点， * 该值就是childNodes中的第几个节点， 如果是文本节点就是文本内容的第几个字符 */ /** * @property { Boolean } collapsed 当前Range是否闭合 * @default true * @remind Range是闭合的时候， startContainer === endContainer && startOffset === endOffset */ /** * @property { Document } document 当前Range所属的Document对象 * @remind 不同range的的document属性可以是不同的 */ var Range = dom.Range = function (document) { var me = this; me.startContainer = me.startOffset = me.endContainer = me.endOffset = null; me.document = document; me.collapsed = true; }; /** * 删除fillData * @param doc * @param excludeNode */ function removeFillData(doc, excludeNode) { try { if (fillData && domUtils.inDoc(fillData, doc)) { if (!fillData.nodeValue.replace(fillCharReg, '').length) { var tmpNode = fillData.parentNode; domUtils.remove(fillData); while (tmpNode && domUtils.isEmptyInlineElement(tmpNode) && //safari的contains有bug (browser.safari ? !(domUtils.getPosition(tmpNode,excludeNode) & domUtils.POSITION_CONTAINS) : !tmpNode.contains(excludeNode)) ) { fillData = tmpNode.parentNode; domUtils.remove(tmpNode); tmpNode = fillData; } } else { fillData.nodeValue = fillData.nodeValue.replace(fillCharReg, ''); } } } catch (e) { } } /** * @param node * @param dir */ function mergeSibling(node, dir) { var tmpNode; node = node[dir]; while (node && domUtils.isFillChar(node)) { tmpNode = node[dir]; domUtils.remove(node); node = tmpNode; } } Range.prototype = { /** * 克隆选区的内容到一个DocumentFragment里 * @method cloneContents * @return { DocumentFragment | NULL } 如果选区是闭合的将返回null， 否则， 返回包含所clone内容的DocumentFragment元素 * @example * ```html * * * xx[xxx]x * * * * ``` */ cloneContents:function () { return this.collapsed ? null : execContentsAction(this, 0); }, /** * 删除当前选区范围中的所有内容 * @method deleteContents * @remind 执行完该操作后， 当前Range对象变成了闭合状态 * @return { UE.dom.Range } 当前操作的Range对象 * @example * ```html * * * xx[xxx]x * * * * ``` */ deleteContents:function () { var txt; if (!this.collapsed) { execContentsAction(this, 1); } if (browser.webkit) { txt = this.startContainer; if (txt.nodeType == 3 && !txt.nodeValue.length) { this.setStartBefore(txt).collapse(true); domUtils.remove(txt); } } return this; }, /** * 将当前选区的内容提取到一个DocumentFragment里 * @method extractContents * @remind 执行该操作后， 选区将变成闭合状态 * @warning 执行该操作后， 原来选区所选中的内容将从dom树上剥离出来 * @return { DocumentFragment } 返回包含所提取内容的DocumentFragment对象 * @example * ```html * * * xx[xxx]x * * * */ extractContents:function () { return this.collapsed ? null : execContentsAction(this, 2); }, /** * 设置Range的开始容器节点和偏移量 * @method setStart * @remind 如果给定的节点是元素节点，那么offset指的是其子元素中索引为offset的元素， * 如果是文本节点，那么offset指的是其文本内容的第offset个字符 * @remind 如果提供的容器节点是一个不能包含子元素的节点， 则该选区的开始容器将被设置 * 为该节点的父节点， 此时， 其距离开始容器的偏移量也变成了该节点在其父节点 * 中的索引 * @param { Node } node 将被设为当前选区开始边界容器的节点对象 * @param { int } offset 选区的开始位置偏移量 * @return { UE.dom.Range } 当前range对象 * @example * ```html * * xxxxxxxxxxxxx[xxx] * * * ``` * @example * ```html * * xxx
xxxx[xxxx]x
==> range.applyInlineStyle("strong") ==>xxxx[xxxx]x
* ``` */ /** * 给range选区中的内容添加给定的inline标签， 并且为标签附加上一些初始化属性。 * @method applyInlineStyle * @param { String } tagName 需要添加的标签名 * @param { Object } attrs 跟随新添加的标签的属性 * @return { UE.dom.Range } 当前选区 * @example * ```html *xxxx[xxxx]x
* * ==> * * * range.applyInlineStyle("strong",{"style":"font-size:12px"}) * * ==> * *xxxx[xxxx]x
* ``` */ applyInlineStyle:function (tagName, attrs, list) { if (this.collapsed)return this; this.trimBoundary().enlarge(false, function (node) { return node.nodeType == 1 && domUtils.isBlockElm(node) }).adjustmentBoundary(); var bookmark = this.createBookmark(), end = bookmark.end, filterFn = function (node) { return node.nodeType == 1 ? node.tagName.toLowerCase() != 'br' : !domUtils.isWhitespace(node); }, current = domUtils.getNextDomNode(bookmark.start, false, filterFn), node, pre, range = this.cloneRange(); while (current && (domUtils.getPosition(current, end) & domUtils.POSITION_PRECEDING)) { if (current.nodeType == 3 || dtd[tagName][current.tagName]) { range.setStartBefore(current); node = current; while (node && (node.nodeType == 3 || dtd[tagName][node.tagName]) && node !== end) { pre = node; node = domUtils.getNextDomNode(node, node.nodeType == 1, null, function (parent) { return dtd[tagName][parent.tagName]; }); } var frag = range.setEndAfter(pre).extractContents(), elm; if (list && list.length > 0) { var level, top; top = level = list[0].cloneNode(false); for (var i = 1, ci; ci = list[i++];) { level.appendChild(ci.cloneNode(false)); level = level.firstChild; } elm = level; } else { elm = range.document.createElement(tagName); } if (attrs) { domUtils.setAttributes(elm, attrs); } elm.appendChild(frag); range.insertNode(list ? top : elm); //处理下滑线在a上的情况 var aNode; if (tagName == 'span' && attrs.style && /text\-decoration/.test(attrs.style) && (aNode = domUtils.findParentByTagName(elm, 'a', true))) { domUtils.setAttributes(aNode, attrs); domUtils.remove(elm, true); elm = aNode; } else { domUtils.mergeSibling(elm); domUtils.clearEmptySibling(elm); } //去除子节点相同的 domUtils.mergeChild(elm, attrs); current = domUtils.getNextDomNode(elm, false, filterFn); domUtils.mergeToParent(elm); if (node === end) { break; } } else { current = domUtils.getNextDomNode(current, true, filterFn); } } return this.moveToBookmark(bookmark); }, /** * 删除当前选区内指定的inline标签，但保留其中的内容 * @method removeInlineStyle * @param { String } tagName 需要删除的标签名 * @return { UE.dom.Range } 当前的range对象 * @example * ```html * xx[xxxxyyyzz]z => range.removeInlineStyle(["em"]) => xx[xxxxyyyzz]z * ``` */ /** * 删除当前选区内指定的一组inline标签，但保留其中的内容 * @method removeInlineStyle * @param { Array } tagNameArr 需要删除的标签名的数组 * @return { UE.dom.Range } 当前的range对象 * @see UE.dom.Range:removeInlineStyle(String) */ removeInlineStyle:function (tagNames) { if (this.collapsed)return this; tagNames = utils.isArray(tagNames) ? tagNames : [tagNames]; this.shrinkBoundary().adjustmentBoundary(); var start = this.startContainer, end = this.endContainer; while (1) { if (start.nodeType == 1) { if (utils.indexOf(tagNames, start.tagName.toLowerCase()) > -1) { break; } if (start.tagName.toLowerCase() == 'body') { start = null; break; } } start = start.parentNode; } while (1) { if (end.nodeType == 1) { if (utils.indexOf(tagNames, end.tagName.toLowerCase()) > -1) { break; } if (end.tagName.toLowerCase() == 'body') { end = null; break; } } end = end.parentNode; } var bookmark = this.createBookmark(), frag, tmpRange; if (start) { tmpRange = this.cloneRange().setEndBefore(bookmark.start).setStartBefore(start); frag = tmpRange.extractContents(); tmpRange.insertNode(frag); domUtils.clearEmptySibling(start, true); start.parentNode.insertBefore(bookmark.start, start); } if (end) { tmpRange = this.cloneRange().setStartAfter(bookmark.end).setEndAfter(end); frag = tmpRange.extractContents(); tmpRange.insertNode(frag); domUtils.clearEmptySibling(end, false, true); end.parentNode.insertBefore(bookmark.end, end.nextSibling); } var current = domUtils.getNextDomNode(bookmark.start, false, function (node) { return node.nodeType == 1; }), next; while (current && current !== bookmark.end) { next = domUtils.getNextDomNode(current, true, function (node) { return node.nodeType == 1; }); if (utils.indexOf(tagNames, current.tagName.toLowerCase()) > -1) { domUtils.remove(current, true); } current = next; } return this.moveToBookmark(bookmark); }, /** * 获取当前选中的自闭合的节点 * @method getClosedNode * @return { Node | NULL } 如果当前选中的是自闭合节点， 则返回该节点， 否则返回NULL */ getClosedNode:function () { var node; if (!this.collapsed) { var range = this.cloneRange().adjustmentBoundary().shrinkBoundary(); if (selectOneNode(range)) { var child = range.startContainer.childNodes[range.startOffset]; if (child && child.nodeType == 1 && (dtd.$empty[child.tagName] || dtd.$nonChild[child.tagName])) { node = child; } } } return node; }, /** * 在页面上高亮range所表示的选区 * @method select * @return { UE.dom.Range } 返回当前Range对象 */ //这里不区分ie9以上，trace:3824 select:browser.ie ? function (noFillData, textRange) { var nativeRange; if (!this.collapsed) this.shrinkBoundary(); var node = this.getClosedNode(); if (node && !textRange) { try { nativeRange = this.document.body.createControlRange(); nativeRange.addElement(node); nativeRange.select(); } catch (e) {} return this; } var bookmark = this.createBookmark(), start = bookmark.start, end; nativeRange = this.document.body.createTextRange(); nativeRange.moveToElementText(start); nativeRange.moveStart('character', 1); if (!this.collapsed) { var nativeRangeEnd = this.document.body.createTextRange(); end = bookmark.end; nativeRangeEnd.moveToElementText(end); nativeRange.setEndPoint('EndToEnd', nativeRangeEnd); } else { if (!noFillData && this.startContainer.nodeType != 3) { //使用|x固定住光标 var tmpText = this.document.createTextNode(fillChar), tmp = this.document.createElement('span'); tmp.appendChild(this.document.createTextNode(fillChar)); start.parentNode.insertBefore(tmp, start); start.parentNode.insertBefore(tmpText, start); //当点b,i,u时，不能清除i上边的b removeFillData(this.document, tmpText); fillData = tmpText; mergeSibling(tmp, 'previousSibling'); mergeSibling(start, 'nextSibling'); nativeRange.moveStart('character', -1); nativeRange.collapse(true); } } this.moveToBookmark(bookmark); tmp && domUtils.remove(tmp); //IE在隐藏状态下不支持range操作，catch一下 try { nativeRange.select(); } catch (e) { } return this; } : function (notInsertFillData) { function checkOffset(rng){ function check(node,offset,dir){ if(node.nodeType == 3 && node.nodeValue.length < offset){ rng[dir + 'Offset'] = node.nodeValue.length } } check(rng.startContainer,rng.startOffset,'start'); check(rng.endContainer,rng.endOffset,'end'); } var win = domUtils.getWindow(this.document), sel = win.getSelection(), txtNode; //FF下关闭自动长高时滚动条在关闭dialog时会跳 //ff下如果不body.focus将不能定位闭合光标到编辑器内 browser.gecko ? this.document.body.focus() : win.focus(); if (sel) { sel.removeAllRanges(); // trace:870 chrome/safari后边是br对于闭合得range不能定位 所以去掉了判断 // this.startContainer.nodeType != 3 &&! ((child = this.startContainer.childNodes[this.startOffset]) && child.nodeType == 1 && child.tagName == 'BR' if (this.collapsed && !notInsertFillData) { // //opear如果没有节点接着，原生的不能够定位,不能在body的第一级插入空白节点 // if (notInsertFillData && browser.opera && !domUtils.isBody(this.startContainer) && this.startContainer.nodeType == 1) { // var tmp = this.document.createTextNode(''); // this.insertNode(tmp).setStart(tmp, 0).collapse(true); // } // //处理光标落在文本节点的情况 //处理以下的情况 //|xxxx //xxxx|xxxx //xxxx| var start = this.startContainer,child = start; if(start.nodeType == 1){ child = start.childNodes[this.startOffset]; } if( !(start.nodeType == 3 && this.startOffset) && (child ? (!child.previousSibling || child.previousSibling.nodeType != 3) : (!start.lastChild || start.lastChild.nodeType != 3) ) ){ txtNode = this.document.createTextNode(fillChar); //跟着前边走 this.insertNode(txtNode); removeFillData(this.document, txtNode); mergeSibling(txtNode, 'previousSibling'); mergeSibling(txtNode, 'nextSibling'); fillData = txtNode; this.setStart(txtNode, browser.webkit ? 1 : 0).collapse(true); } } var nativeRange = this.document.createRange(); if(this.collapsed && browser.opera && this.startContainer.nodeType == 1){ var child = this.startContainer.childNodes[this.startOffset]; if(!child){ //往前靠拢 child = this.startContainer.lastChild; if( child && domUtils.isBr(child)){ this.setStartBefore(child).collapse(true); } }else{ //向后靠拢 while(child && domUtils.isBlockElm(child)){ if(child.nodeType == 1 && child.childNodes[0]){ child = child.childNodes[0] }else{ break; } } child && this.setStartBefore(child).collapse(true) } } //是createAddress最后一位算的不准，现在这里进行微调 checkOffset(this); nativeRange.setStart(this.startContainer, this.startOffset); nativeRange.setEnd(this.endContainer, this.endOffset); sel.addRange(nativeRange); } return this; }, /** * 滚动到当前range开始的位置 * @method scrollToView * @param { Window } win 当前range对象所属的window对象 * @return { UE.dom.Range } 当前Range对象 */ /** * 滚动到距离当前range开始位置 offset 的位置处 * @method scrollToView * @param { Window } win 当前range对象所属的window对象 * @param { Number } offset 距离range开始位置处的偏移量， 如果为正数， 则向下偏移， 反之， 则向上偏移 * @return { UE.dom.Range } 当前Range对象 */ scrollToView:function (win, offset) { win = win ? window : domUtils.getWindow(this.document); var me = this, span = me.document.createElement('span'); //trace:717 span.innerHTML = ' '; me.cloneRange().insertNode(span); domUtils.scrollToView(span, win, offset); domUtils.remove(span); return me; }, /** * 判断当前选区内容是否占位符 * @private * @method inFillChar * @return { Boolean } 如果是占位符返回true，否则返回false */ inFillChar : function(){ var start = this.startContainer; if(this.collapsed && start.nodeType == 3 && start.nodeValue.replace(new RegExp('^' + domUtils.fillChar),'').length + 1 == start.nodeValue.length ){ return true; } return false; }, /** * 保存 * @method createAddress * @private * @return { Boolean } 返回开始和结束的位置 * @example * ```html * ** aaaa * * * bbbb * * *
* * * * ``` */ createAddress : function(ignoreEnd,ignoreTxt){ var addr = {},me = this; function getAddress(isStart){ var node = isStart ? me.startContainer : me.endContainer; var parents = domUtils.findParents(node,true,function(node){return !domUtils.isBody(node)}), addrs = []; for(var i = 0,ci;ci = parents[i++];){ addrs.push(domUtils.getNodeIndex(ci,ignoreTxt)); } var firstIndex = 0; if(ignoreTxt){ if(node.nodeType == 3){ var tmpNode = node.previousSibling; while(tmpNode && tmpNode.nodeType == 3){ firstIndex += tmpNode.nodeValue.replace(fillCharReg,'').length; tmpNode = tmpNode.previousSibling; } firstIndex += (isStart ? me.startOffset : me.endOffset)// - (fillCharReg.test(node.nodeValue) ? 1 : 0 ) }else{ node = node.childNodes[ isStart ? me.startOffset : me.endOffset]; if(node){ firstIndex = domUtils.getNodeIndex(node,ignoreTxt); }else{ node = isStart ? me.startContainer : me.endContainer; var first = node.firstChild; while(first){ if(domUtils.isFillChar(first)){ first = first.nextSibling; continue; } firstIndex++; if(first.nodeType == 3){ while( first && first.nodeType == 3){ first = first.nextSibling; } }else{ first = first.nextSibling; } } } } }else{ firstIndex = isStart ? domUtils.isFillChar(node) ? 0 : me.startOffset : me.endOffset } if(firstIndex < 0){ firstIndex = 0; } addrs.push(firstIndex); return addrs; } addr.startAddress = getAddress(true); if(!ignoreEnd){ addr.endAddress = me.collapsed ? [].concat(addr.startAddress) : getAddress(); } return addr; }, /** * 保存 * @method createAddress * @private * @return { Boolean } 返回开始和结束的位置 * @example * ```html * ** aaaa * * * bbbb * * *
* * * * ``` */ moveToAddress : function(addr,ignoreEnd){ var me = this; function getNode(address,isStart){ var tmpNode = me.document.body, parentNode,offset; for(var i= 0,ci,l=address.length;i