*/
insertNode: function (node) {
var first = node, length = 1;
if (node.nodeType == 11) {
first = node.firstChild;
length = node.childNodes.length;
}
this.trimBoundary(true);
var start = this.startContainer,
offset = this.startOffset;
var nextNode = start.childNodes[offset];
if (nextNode) {
start.insertBefore(node, nextNode);
} else {
start.appendChild(node);
}
if (first.parentNode === this.endContainer) {
this.endOffset = this.endOffset + length;
}
return this.setStartBefore(first);
},
/**
* 设置光标闭合位置,toEnd设置为true时光标将闭合到选区的结尾
* @name setCursor
* @grammar range.setCursor([toEnd]) => Range //toEnd为true时，光标闭合到选区的末尾
*/
setCursor: function (toEnd, noFillData) {
return this.collapse(!toEnd).select(noFillData);
},
/**
* 创建当前range的一个书签，记录下当前range的位置，方便当dom树改变时，还能找回原来的选区位置
* @name createBookmark
* @grammar range.createBookmark([serialize]) => Object //{start:开始标记,end:结束标记,id:serialize} serialize为真时，开始结束标记是插入节点的id，否则是插入节点的引用
*/
createBookmark: function (serialize, same) {
var endNode,
startNode = this.document.createElement('span');
startNode.style.cssText = 'display:none;line-height:0px;';
startNode.appendChild(this.document.createTextNode('\u200D'));
startNode.id = '_baidu_bookmark_start_' + (same ? '' : guid++);
if (!this.collapsed) {
endNode = startNode.cloneNode(true);
endNode.id = '_baidu_bookmark_end_' + (same ? '' : guid++);
}
this.insertNode(startNode);
if (endNode) {
this.collapse().insertNode(endNode).setEndBefore(endNode);
}
this.setStartAfter(startNode);
return {
start: serialize ? startNode.id : startNode,
end: endNode ? serialize ? endNode.id : endNode : null,
id: serialize
}
},
/**
* 移动边界到书签位置，并删除插入的书签节点
* @name moveToBookmark
* @grammar range.moveToBookmark(bookmark) => Range //让当前的range选到给定bookmark的位置,bookmark对象是由range.createBookmark创建的
*/
moveToBookmark: function (bookmark) {
var start = bookmark.id ? this.document.getElementById(bookmark.start) : bookmark.start,
end = bookmark.end && bookmark.id ? this.document.getElementById(bookmark.end) : bookmark.end;
this.setStartBefore(start);
domUtils.remove(start);
if (end) {
this.setEndBefore(end);
domUtils.remove(end);
} else {
this.collapse(true);
}
return this;
},
/**
* 调整Range的边界，使其"缩小"到最合适的位置
* @name adjustmentBoundary
* @grammar range.adjustmentBoundary() => Range //参见shrinkBoundary
* @example
* xx[xxxxx] ==> xx[xxxxx]
* x[xx]xxx ==> x[xx]xxx
*/
adjustmentBoundary: function () {
if (!this.collapsed) {
while (!domUtils.isBody(this.startContainer) &&
this.startOffset == this.startContainer[this.startContainer.nodeType == 3 ? 'nodeValue' : 'childNodes'].length &&
this.startContainer[this.startContainer.nodeType == 3 ? 'nodeValue' : 'childNodes'].length
) {
this.setStartAfter(this.startContainer);
}
while (!domUtils.isBody(this.endContainer) && !this.endOffset &&
this.endContainer[this.endContainer.nodeType == 3 ? 'nodeValue' : 'childNodes'].length
) {
this.setEndBefore(this.endContainer);
}
}
return this;
},
/**
* 得到一个自闭合的节点,常用于获取自闭和的节点，例如图片节点
* @name getClosedNode
* @grammar range.getClosedNode() => node|null
* @example
* xxxx[]xxx
*/
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选中内容节点（在页面上表现为反白显示）
* @name select
* @grammar range.select(); => Range
*/
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.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;
},
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;
},
moveToAddress: function (addr, ignoreEnd) {
var me = this;
function getNode(address, isStart) {
var tmpNode = me.body,
parentNode, offset;
for (var i = 0, ci, l = address.length; i < l; i++) {
ci = address[i];
parentNode = tmpNode;
tmpNode = tmpNode.childNodes[ci];
if (!tmpNode) {
offset = ci;
break;
}
}
if (isStart) {
if (tmpNode) {
me.setStartBefore(tmpNode)
} else {
me.setStart(parentNode, offset)
}
} else {
if (tmpNode) {
me.setEndBefore(tmpNode)
} else {
me.setEnd(parentNode, offset)
}
}
}
getNode(addr.startAddress, true);
!ignoreEnd && addr.endAddress && getNode(addr.endAddress);
return me;
},
equals: function (rng) {
for (var p in this) {
if (this.hasOwnProperty(p)) {
if (this[p] !== rng[p])
return false
}
}
return true;
},
scrollIntoView: function () {
var $span = $('');
this.cloneRange().insertNode($span.get(0));
var winScrollTop = $(window).scrollTop(),
winHeight = $(window).height(),
spanTop = $span.offset().top;
if (spanTop < winScrollTop - winHeight || spanTop > winScrollTop + winHeight) {
if (spanTop > winScrollTop + winHeight) {
window.scrollTo(0, spanTop - winHeight + $span.height())
} else {
window.scrollTo(0, winScrollTop - spanTop)
}
}
$span.remove();
},
getOffset: function () {
var bk = this.createBookmark();
var offset = $(bk.start).css('display', 'inline-block').offset();
this.moveToBookmark(bk);
return offset
}
};
})();
///import editor.js
///import core/browser.js
///import core/dom/dom.js
///import core/dom/dtd.js
///import core/dom/domUtils.js
///import core/dom/Range.js
/**
* @class UM.dom.Selection Selection类
*/
(function () {
function getBoundaryInformation(range, start) {
var getIndex = domUtils.getNodeIndex;
range = range.duplicate();
range.collapse(start);
var parent = range.parentElement();
//如果节点里没有子节点，直接退出
if (!parent.hasChildNodes()) {
return {container: parent, offset: 0};
}
var siblings = parent.children,
child,
testRange = range.duplicate(),
startIndex = 0, endIndex = siblings.length - 1, index = -1,
distance;
while (startIndex <= endIndex) {
index = Math.floor((startIndex + endIndex) / 2);
child = siblings[index];
testRange.moveToElementText(child);
var position = testRange.compareEndPoints('StartToStart', range);
if (position > 0) {
endIndex = index - 1;
} else if (position < 0) {
startIndex = index + 1;
} else {
//trace:1043
return {container: parent, offset: getIndex(child)};
}
}
if (index == -1) {
testRange.moveToElementText(parent);
testRange.setEndPoint('StartToStart', range);
distance = testRange.text.replace(/(\r\n|\r)/g, '\n').length;
siblings = parent.childNodes;
if (!distance) {
child = siblings[siblings.length - 1];
return {container: child, offset: child.nodeValue.length};
}
var i = siblings.length;
while (distance > 0) {
distance -= siblings[--i].nodeValue.length;
}
return {container: siblings[i], offset: -distance};
}
testRange.collapse(position > 0);
testRange.setEndPoint(position > 0 ? 'StartToStart' : 'EndToStart', range);
distance = testRange.text.replace(/(\r\n|\r)/g, '\n').length;
if (!distance) {
return dtd.$empty[child.tagName] || dtd.$nonChild[child.tagName] ?
{container: parent, offset: getIndex(child) + (position > 0 ? 0 : 1)} :
{container: child, offset: position > 0 ? 0 : child.childNodes.length}
}
while (distance > 0) {
try {
var pre = child;
child = child[position > 0 ? 'previousSibling' : 'nextSibling'];
distance -= child.nodeValue.length;
} catch (e) {
return {container: parent, offset: getIndex(pre)};
}
}
return {container: child, offset: position > 0 ? -distance : child.nodeValue.length + distance}
}
/**
* 将ieRange转换为Range对象
* @param {Range} ieRange ieRange对象
* @param {Range} range Range对象
* @return {Range} range 返回转换后的Range对象
*/
function transformIERangeToRange(ieRange, range) {
if (ieRange.item) {
range.selectNode(ieRange.item(0));
} else {
var bi = getBoundaryInformation(ieRange, true);
range.setStart(bi.container, bi.offset);
if (ieRange.compareEndPoints('StartToEnd', ieRange) != 0) {
bi = getBoundaryInformation(ieRange, false);
range.setEnd(bi.container, bi.offset);
}
}
return range;
}
/**
* 获得ieRange
* @param {Selection} sel Selection对象
* @return {ieRange} 得到ieRange
*/
function _getIERange(sel, txtRange) {
var ieRange;
//ie下有可能报错
try {
ieRange = sel.getNative(txtRange).createRange();
} catch (e) {
return null;
}
var el = ieRange.item ? ieRange.item(0) : ieRange.parentElement();
if ((el.ownerDocument || el) === sel.document) {
return ieRange;
}
return null;
}
var Selection = dom.Selection = function (doc, body) {
var me = this;
me.document = doc;
me.body = body;
if (browser.ie9below) {
$(body).on('beforedeactivate', function () {
me._bakIERange = me.getIERange();
}).on('activate', function () {
try {
var ieNativRng = _getIERange(me);
if ((!ieNativRng || !me.rangeInBody(ieNativRng)) && me._bakIERange) {
me._bakIERange.select();
}
} catch (ex) {
}
me._bakIERange = null;
});
}
};
Selection.prototype = {
hasNativeRange: function () {
var rng;
if (!browser.ie || browser.ie9above) {
var nativeSel = this.getNative();
if (!nativeSel.rangeCount) {
return false;
}
rng = nativeSel.getRangeAt(0);
} else {
rng = _getIERange(this);
}
return this.rangeInBody(rng);
},
/**
* 获取原生seleciton对象
* @public
* @function
* @name UM.dom.Selection.getNative
* @return {Selection} 获得selection对象
*/
getNative: function (txtRange) {
var doc = this.document;
try {
return !doc ? null : browser.ie9below || txtRange ? doc.selection : domUtils.getWindow(doc).getSelection();
} catch (e) {
return null;
}
},
/**
* 获得ieRange
* @public
* @function
* @name UM.dom.Selection.getIERange
* @return {ieRange} 返回ie原生的Range
*/
getIERange: function (txtRange) {
var ieRange = _getIERange(this, txtRange);
if (!ieRange || !this.rangeInBody(ieRange, txtRange)) {
if (this._bakIERange) {
return this._bakIERange;
}
}
return ieRange;
},
rangeInBody: function (rng, txtRange) {
var node = browser.ie9below || txtRange ? rng.item ? rng.item() : rng.parentElement() : rng.startContainer;
return node === this.body || domUtils.inDoc(node, this.body);
},
/**
* 缓存当前选区的range和选区的开始节点
* @public
* @function
* @name UM.dom.Selection.cache
*/
cache: function () {
this.clear();
this._cachedRange = this.getRange();
this._cachedStartElement = this.getStart();
this._cachedStartElementPath = this.getStartElementPath();
},
getStartElementPath: function () {
if (this._cachedStartElementPath) {
return this._cachedStartElementPath;
}
var start = this.getStart();
if (start) {
return domUtils.findParents(start, true, null, true)
}
return [];
},
/**
* 清空缓存
* @public
* @function
* @name UM.dom.Selection.clear
*/
clear: function () {
this._cachedStartElementPath = this._cachedRange = this._cachedStartElement = null;
},
/**
* 编辑器是否得到了选区
*/
isFocus: function () {
return this.hasNativeRange()
},
/**
* 获取选区对应的Range
* @public
* @function
* @name UM.dom.Selection.getRange
* @returns {UM.dom.Range} 得到Range对象
*/
getRange: function () {
var me = this;
function optimze(range) {
var child = me.body.firstChild,
collapsed = range.collapsed;
while (child && child.firstChild) {
range.setStart(child, 0);
child = child.firstChild;
}
if (!range.startContainer) {
range.setStart(me.body, 0)
}
if (collapsed) {
range.collapse(true);
}
}
if (me._cachedRange != null) {
return this._cachedRange;
}
var range = new dom.Range(me.document, me.body);
if (browser.ie9below) {
var nativeRange = me.getIERange();
if (nativeRange && this.rangeInBody(nativeRange)) {
try {
transformIERangeToRange(nativeRange, range);
} catch (e) {
optimze(range);
}
} else {
optimze(range);
}
} else {
var sel = me.getNative();
if (sel && sel.rangeCount && me.rangeInBody(sel.getRangeAt(0))) {
var firstRange = sel.getRangeAt(0);
var lastRange = sel.getRangeAt(sel.rangeCount - 1);
range.setStart(firstRange.startContainer, firstRange.startOffset).setEnd(lastRange.endContainer, lastRange.endOffset);
if (range.collapsed && domUtils.isBody(range.startContainer) && !range.startOffset) {
optimze(range);
}
} else {
//trace:1734 有可能已经不在dom树上了，标识的节点
if (this._bakRange && (this._bakRange.startContainer === this.body || domUtils.inDoc(this._bakRange.startContainer, this.body))) {
return this._bakRange;
}
optimze(range);
}
}
return this._bakRange = range;
},
/**
* 获取开始元素，用于状态反射
* @public
* @function
* @name UM.dom.Selection.getStart
* @return {Element} 获得开始元素
*/
getStart: function () {
if (this._cachedStartElement) {
return this._cachedStartElement;
}
var range = browser.ie9below ? this.getIERange() : this.getRange(),
tmpRange,
start, tmp, parent;
if (browser.ie9below) {
if (!range) {
//todo 给第一个值可能会有问题
return this.document.body.firstChild;
}
//control元素
if (range.item) {
return range.item(0);
}
tmpRange = range.duplicate();
//修正ie下x[xx] 闭合后 x|xx
tmpRange.text.length > 0 && tmpRange.moveStart('character', 1);
tmpRange.collapse(1);
start = tmpRange.parentElement();
parent = tmp = range.parentElement();
while (tmp = tmp.parentNode) {
if (tmp == start) {
start = parent;
break;
}
}
} else {
start = range.startContainer;
if (start.nodeType == 1 && start.hasChildNodes()) {
start = start.childNodes[Math.min(start.childNodes.length - 1, range.startOffset)];
}
if (start.nodeType == 3) {
return start.parentNode;
}
}
return start;
},
/**
* 得到选区中的文本
* @public
* @function
* @name UM.dom.Selection.getText
* @return {String} 选区中包含的文本
*/
getText: function () {
var nativeSel, nativeRange;
if (this.isFocus() && (nativeSel = this.getNative())) {
nativeRange = browser.ie9below ? nativeSel.createRange() : nativeSel.getRangeAt(0);
return browser.ie9below ? nativeRange.text : nativeRange.toString();
}
return '';
}
};
})();
/**
* @file
* @name UM.Editor
* @short Editor
* @import editor.js,core/utils.js,core/EventBase.js,core/browser.js,core/dom/dtd.js,core/dom/domUtils.js,core/dom/Range.js,core/dom/Selection.js,plugins/serialize.js
* @desc 编辑器主类，包含编辑器提供的大部分公用接口
*/
(function () {
var uid = 0, _selectionChangeTimer;
/**
* @private
* @ignore
* @param form 编辑器所在的form元素
* @param editor 编辑器实例对象
*/
function setValue(form, editor) {
var textarea;
if (editor.textarea) {
if (utils.isString(editor.textarea)) {
for (var i = 0, ti, tis = domUtils.getElementsByTagName(form, 'textarea'); ti = tis[i++];) {
if (ti.id == 'umeditor_textarea_' + editor.options.textarea) {
textarea = ti;
break;
}
}
} else {
textarea = editor.textarea;
}
}
if (!textarea) {
form.appendChild(textarea = domUtils.createElement(document, 'textarea', {
'name': editor.options.textarea,
'id': 'umeditor_textarea_' + editor.options.textarea,
'style': "display:none"
}));
//不要产生多个textarea
editor.textarea = textarea;
}
textarea.value = editor.hasContents() ?
(editor.options.allHtmlEnabled ? editor.getAllHtml() : editor.getContent(null, null, true)) :
''
}
function loadPlugins(me) {
//初始化插件
for (var pi in UM.plugins) {
if (me.options.excludePlugins.indexOf(pi) == -1) {
UM.plugins[pi].call(me);
me.plugins[pi] = 1;
}
}
me.langIsReady = true;
me.fireEvent("langReady");
}
function checkCurLang(I18N) {
for (var lang in I18N) {
return lang
}
}
/**
* UEditor编辑器类
* @name Editor
* @desc 创建一个跟编辑器实例
* - ***container*** 编辑器容器对象
* - ***iframe*** 编辑区域所在的iframe对象
* - ***window*** 编辑区域所在的window
* - ***document*** 编辑区域所在的document对象
* - ***body*** 编辑区域所在的body对象
* - ***selection*** 编辑区域的选区对象
*/
var Editor = UM.Editor = function (options) {
var me = this;
me.uid = uid++;
EventBase.call(me);
me.commands = {};
me.options = utils.extend(utils.clone(options || {}), UMEDITOR_CONFIG, true);
me.shortcutkeys = {};
me.inputRules = [];
me.outputRules = [];
//设置默认的常用属性
me.setOpt({
isShow: true,
initialContent: '',
initialStyle: '',
autoClearinitialContent: false,
textarea: 'editorValue',
focus: false,
focusInEnd: true,
autoClearEmptyNode: true,
fullscreen: false,
readonly: false,
zIndex: 999,
enterTag: 'p',
lang: 'zh-cn',
langPath: me.options.UMEDITOR_HOME_URL + 'lang/',
theme: 'default',
themePath: me.options.UMEDITOR_HOME_URL + 'themes/',
allHtmlEnabled: false,
autoSyncData: true,
autoHeightEnabled: true,
excludePlugins: ''
});
me.plugins = {};
if (!utils.isEmptyObject(UM.I18N)) {
//修改默认的语言类型
me.options.lang = checkCurLang(UM.I18N);
loadPlugins(me)
} else {
utils.loadFile(document, {
src: me.options.langPath + me.options.lang + "/" + me.options.lang + ".js",
tag: "script",
type: "text/javascript",
defer: "defer"
}, function () {
loadPlugins(me)
});
}
};
Editor.prototype = {
/**
* 当编辑器ready后执行传入的fn,如果编辑器已经完成ready，就马上执行fn，fn的中的this是编辑器实例。
* 大部分的实例接口都需要放在该方法内部执行，否则在IE下可能会报错。
* @name ready
* @grammar editor.ready(fn) fn是当编辑器渲染好后执行的function
* @example
* var editor = new UM.ui.Editor();
* editor.render("myEditor");
* editor.ready(function(){
* editor.setContent("欢迎使用UEditor！");
* })
*/
ready: function (fn) {
var me = this;
if (fn) {
me.isReady ? fn.apply(me) : me.addListener('ready', fn);
}
},
/**
* 为编辑器设置默认参数值。若用户配置为空，则以默认配置为准
* @grammar editor.setOpt(key,value); //传入一个键、值对
* @grammar editor.setOpt({ key:value}); //传入一个json对象
*/
setOpt: function (key, val) {
var obj = {};
if (utils.isString(key)) {
obj[key] = val
} else {
obj = key;
}
utils.extend(this.options, obj, true);
},
getOpt: function (key) {
return this.options[key] || ''
},
/**
* 销毁编辑器实例对象
* @name destroy
* @grammar editor.destroy();
*/
destroy: function () {
var me = this;
me.fireEvent('destroy');
var container = me.container.parentNode;
if (container === document.body) {
container = me.container;
}
var textarea = me.textarea;
if (!textarea) {
textarea = document.createElement('textarea');
container.parentNode.insertBefore(textarea, container);
} else {
textarea.style.display = ''
}
textarea.style.width = me.body.offsetWidth + 'px';
textarea.style.height = me.body.offsetHeight + 'px';
textarea.value = me.getContent();
textarea.id = me.key;
if (container.contains(textarea)) {
$(textarea).insertBefore(container);
}
container.innerHTML = '';
domUtils.remove(container);
UM.clearCache(me.id);
//trace:2004
for (var p in me) {
if (me.hasOwnProperty(p)) {
delete this[p];
}
}
},
initialCont: function (holder) {
if (holder) {
holder.getAttribute('name') && (this.options.textarea = holder.getAttribute('name'));
if (holder && /script|textarea/ig.test(holder.tagName)) {
var newDiv = document.createElement('div');
holder.parentNode.insertBefore(newDiv, holder);
this.options.initialContent = UM.htmlparser(holder.value || holder.innerHTML || this.options.initialContent).toHtml();
holder.className && (newDiv.className = holder.className);
holder.style.cssText && (newDiv.style.cssText = holder.style.cssText);
if (/textarea/i.test(holder.tagName)) {
this.textarea = holder;
this.textarea.style.display = 'none';
} else {
holder.parentNode.removeChild(holder);
holder.id && (newDiv.id = holder.id);
}
holder = newDiv;
holder.innerHTML = '';
}
return holder;
} else {
return null;
}
},
/**
* 渲染编辑器的DOM到指定容器，必须且只能调用一次
* @name render
* @grammar editor.render(containerId); //可以指定一个容器ID
* @grammar editor.render(containerDom); //也可以直接指定容器对象
*/
render: function (container) {
var me = this,
options = me.options,
getStyleValue = function (attr) {
return parseInt($(container).css(attr));
};
if (utils.isString(container)) {
container = document.getElementById(container);
}
if (container) {
this.id = container.getAttribute('id');
UM.setEditor(this);
utils.cssRule('edui-style-body', me.options.initialStyle, document);
container = this.initialCont(container);
container.className += ' edui-body-container';
if (options.initialFrameWidth) {
options.minFrameWidth = options.initialFrameWidth
} else {
//都没给值，先写死了
options.minFrameWidth = options.initialFrameWidth = $(container).width() || UM.defaultWidth;
}
if (options.initialFrameHeight) {
options.minFrameHeight = options.initialFrameHeight
} else {
options.initialFrameHeight = options.minFrameHeight = $(container).height() || UM.defaultHeight;
}
container.style.width = /%$/.test(options.initialFrameWidth) ? '100%' : options.initialFrameWidth -
getStyleValue("padding-left") -
getStyleValue("padding-right") + 'px';
var height = /%$/.test(options.initialFrameHeight) ? '100%' : (options.initialFrameHeight - getStyleValue("padding-top") - getStyleValue("padding-bottom"));
if (this.options.autoHeightEnabled) {
container.style.minHeight = height + 'px';
container.style.height = '';
if (browser.ie && browser.version <= 6) {
container.style.height = height;
container.style.setExpression('height', 'this.scrollHeight <= ' + height + ' ? "' + height + 'px" : "auto"');
}
} else {
$(container).height(height)
}
container.style.zIndex = options.zIndex;
this._setup(container);
}
},
/**
* 编辑器初始化
* @private
* @ignore
* @param {Element} doc 编辑器Iframe中的文档对象
*/
_setup: function (cont) {
var me = this,
options = me.options;
cont.contentEditable = true;
document.body.spellcheck = false;
me.document = document;
me.window = document.defaultView || document.parentWindow;
me.body = cont;
me.$body = $(cont);
me.selection = new dom.Selection(document, me.body);
me._isEnabled = false;
//gecko初始化就能得到range,无法判断isFocus了
var geckoSel;
if (browser.gecko && (geckoSel = this.selection.getNative())) {
geckoSel.removeAllRanges();
}
this._initEvents();
//为form提交提供一个隐藏的textarea
for (var form = cont.parentNode; form && !domUtils.isBody(form); form = form.parentNode) {
if (form.tagName == 'FORM') {
me.form = form;
if (me.options.autoSyncData) {
$(cont).on('blur', function () {
setValue(form, me);
})
} else {
$(form).on('submit', function () {
setValue(this, me);
})
}
break;
}
}
if (options.initialContent) {
if (options.autoClearinitialContent) {
var oldExecCommand = me.execCommand;
me.execCommand = function () {
me.fireEvent('firstBeforeExecCommand');
return oldExecCommand.apply(me, arguments);
};
this._setDefaultContent(options.initialContent);
} else
this.setContent(options.initialContent, false, true);
}
//编辑器不能为空内容
if (domUtils.isEmptyNode(me.body)) {
me.body.innerHTML = '
' + (browser.ie ? '' : ' ') + '
';
}
//如果要求focus, 就把光标定位到内容开始
if (options.focus) {
setTimeout(function () {
me.focus(me.options.focusInEnd);
//如果自动清除开着，就不需要做selectionchange;
!me.options.autoClearinitialContent && me._selectionChange();
}, 0);
}
if (!me.container) {
me.container = cont.parentNode;
}
me._bindshortcutKeys();
me.isReady = 1;
me.fireEvent('ready');
options.onready && options.onready.call(me);
if (!browser.ie || browser.ie9above) {
$(me.body).on('blur focus', function (e) {
var nSel = me.selection.getNative();
//chrome下会出现alt+tab切换时，导致选区位置不对
if (e.type == 'blur') {
if (nSel.rangeCount > 0) {
me._bakRange = nSel.getRangeAt(0);
}
} else {
try {
me._bakRange && nSel.addRange(me._bakRange)
} catch (e) {
}
me._bakRange = null;
}
});
}
!options.isShow && me.setHide();
options.readonly && me.setDisabled();
},
/**
* 同步编辑器的数据，为提交数据做准备，主要用于你是手动提交的情况
* @name sync
* @grammar editor.sync(); //从编辑器的容器向上查找，如果找到就同步数据
* @grammar editor.sync(formID); //formID制定一个要同步数据的form的id,编辑器的数据会同步到你指定form下
* @desc
* 后台取得数据得键值使用你容器上得''name''属性，如果没有就使用参数传入的''textarea''
* @example
* editor.sync();
* form.sumbit(); //form变量已经指向了form元素
*
*/
sync: function (formId) {
var me = this,
form = formId ? document.getElementById(formId) :
domUtils.findParent(me.body.parentNode, function (node) {
return node.tagName == 'FORM'
}, true);
form && setValue(form, me);
},
/**
* 设置编辑器高度
* @name setHeight
* @grammar editor.setHeight(number); //纯数值，不带单位
*/
setHeight: function (height, notSetHeight) {
!notSetHeight && (this.options.initialFrameHeight = height);
if (this.options.autoHeightEnabled) {
$(this.body).css({
'min-height': height + 'px'
});
if (browser.ie && browser.version <= 6 && this.container) {
this.container.style.height = height;
this.container.style.setExpression('height', 'this.scrollHeight <= ' + height + ' ? "' + height + 'px" : "auto"');
}
} else {
$(this.body).height(height)
}
this.fireEvent('resize');
},
/**
* 设置编辑器宽度
* @name setWidth
* @grammar editor.setWidth(number); //纯数值，不带单位
*/
setWidth: function (width) {
this.$container && this.$container.width(width);
$(this.body).width(width - $(this.body).css('padding-left').replace('px', '') * 1 - $(this.body).css('padding-right').replace('px', '') * 1);
this.fireEvent('resize');
},
addshortcutkey: function (cmd, keys) {
var obj = {};
if (keys) {
obj[cmd] = keys
} else {
obj = cmd;
}
utils.extend(this.shortcutkeys, obj)
},
_bindshortcutKeys: function () {
var me = this, shortcutkeys = this.shortcutkeys;
me.addListener('keydown', function (type, e) {
var keyCode = e.keyCode || e.which;
for (var i in shortcutkeys) {
var tmp = shortcutkeys[i].split(',');
for (var t = 0, ti; ti = tmp[t++];) {
ti = ti.split(':');
var key = ti[0], param = ti[1];
if (/^(ctrl)(\+shift)?\+(\d+)$/.test(key.toLowerCase()) || /^(\d+)$/.test(key)) {
if (((RegExp.$1 == 'ctrl' ? (e.ctrlKey || e.metaKey) : 0)
&& (RegExp.$2 != "" ? e[RegExp.$2.slice(1) + "Key"] : 1)
&& keyCode == RegExp.$3
) ||
keyCode == RegExp.$1
) {
if (me.queryCommandState(i, param) != -1)
me.execCommand(i, param);
domUtils.preventDefault(e);
}
}
}
}
});
},
/**
* 获取编辑器内容
* @name getContent
* @grammar editor.getContent() => String //若编辑器中只包含字符"<p><br /></p/>"会返回空。
* @grammar editor.getContent(fn) => String
* @example
* getContent默认是会现调用hasContents来判断编辑器是否为空，如果是，就直接返回空字符串
* 你也可以传入一个fn来接替hasContents的工作，定制判断的规则
* editor.getContent(function(){
* return false //编辑器没有内容 ，getContent直接返回空
* })
*/
getContent: function (cmd, fn, notSetCursor, ignoreBlank, formatter) {
var me = this;
if (cmd && utils.isFunction(cmd)) {
fn = cmd;
cmd = '';
}
if (fn ? !fn() : !this.hasContents()) {
return '';
}
me.fireEvent('beforegetcontent');
var root = UM.htmlparser(me.body.innerHTML, ignoreBlank);
me.filterOutputRule(root);
me.fireEvent('aftergetcontent', root);
return root.toHtml(formatter);
},
/**
* 取得完整的html代码，可以直接显示成完整的html文档
* @name getAllHtml
* @grammar editor.getAllHtml() => String
*/
getAllHtml: function () {
var me = this,
headHtml = [],
html = '';
me.fireEvent('getAllHtml', headHtml);
if (browser.ie && browser.version > 8) {
var headHtmlForIE9 = '';
utils.each(me.document.styleSheets, function (si) {
headHtmlForIE9 += (si.href ? '' : '');
});
utils.each(me.document.getElementsByTagName('script'), function (si) {
headHtmlForIE9 += si.outerHTML;
});
}
return '' + (me.options.charset ? '' : '')
+ (headHtmlForIE9 || me.document.getElementsByTagName('head')[0].innerHTML) + headHtml.join('\n') + ''
+ '' + me.getContent(null, null, true) + '';
},
/**
* 得到编辑器的纯文本内容，但会保留段落格式
* @name getPlainTxt
* @grammar editor.getPlainTxt() => String
*/
getPlainTxt: function () {
var reg = new RegExp(domUtils.fillChar, 'g'),
html = this.body.innerHTML.replace(/[\n\r]/g, '');//ie要先去了\n在处理
html = html.replace(/<(p|div)[^>]*>(| )<\/\1>/gi, '\n')
.replace(//gi, '\n')
.replace(/<[^>/]+>/g, '')
.replace(/(\n)?<\/([^>]+)>/g, function (a, b, c) {
return dtd.$block[c] ? '\n' : b ? b : '';
});
//取出来的空格会有c2a0会变成乱码，处理这种情况\u00a0
return html.replace(reg, '').replace(/\u00a0/g, ' ').replace(/ /g, ' ');
},
/**
* 获取编辑器中的纯文本内容,没有段落格式
* @name getContentTxt
* @grammar editor.getContentTxt() => String
*/
getContentTxt: function () {
var reg = new RegExp(domUtils.fillChar, 'g');
//取出来的空格会有c2a0会变成乱码，处理这种情况\u00a0
return this.body[browser.ie ? 'innerText' : 'textContent'].replace(reg, '').replace(/\u00a0/g, ' ');
},
/**
* 将html设置到编辑器中, 如果是用于初始化时给编辑器赋初值，则必须放在ready方法内部执行
* @name setContent
* @grammar editor.setContent(html)
* @example
* var editor = new UM.ui.Editor()
* editor.ready(function(){
* //需要ready后执行，否则可能报错
* editor.setContent("欢迎使用UEditor！");
* })
*/
setContent: function (html, isAppendTo, notFireSelectionchange) {
var me = this;
me.fireEvent('beforesetcontent', html);
var root = UM.htmlparser(html);
me.filterInputRule(root);
html = root.toHtml();
me.body.innerHTML = (isAppendTo ? me.body.innerHTML : '') + html;
function isCdataDiv(node) {
return node.tagName == 'DIV' && node.getAttribute('cdata_tag');
}
//给文本或者inline节点套p标签
if (me.options.enterTag == 'p') {
var child = this.body.firstChild, tmpNode;
if (!child || child.nodeType == 1 &&
(dtd.$cdata[child.tagName] || isCdataDiv(child) ||
domUtils.isCustomeNode(child)
)
&& child === this.body.lastChild) {
this.body.innerHTML = '
' + (browser.ie ? ' ' : ' ') + '
' + this.body.innerHTML;
} else {
var p = me.document.createElement('p');
while (child) {
while (child && (child.nodeType == 3 || child.nodeType == 1 && dtd.p[child.tagName] && !dtd.$cdata[child.tagName])) {
tmpNode = child.nextSibling;
p.appendChild(child);
child = tmpNode;
}
if (p.firstChild) {
if (!child) {
me.body.appendChild(p);
break;
} else {
child.parentNode.insertBefore(p, child);
p = me.document.createElement('p');
}
}
child = child.nextSibling;
}
}
}
me.fireEvent('aftersetcontent');
me.fireEvent('contentchange');
!notFireSelectionchange && me._selectionChange();
//清除保存的选区
me._bakRange = me._bakIERange = me._bakNativeRange = null;
//trace:1742 setContent后gecko能得到焦点问题
var geckoSel;
if (browser.gecko && (geckoSel = this.selection.getNative())) {
geckoSel.removeAllRanges();
}
if (me.options.autoSyncData) {
me.form && setValue(me.form, me);
}
},
/**
* 让编辑器获得焦点，toEnd确定focus位置
* @name focus
* @grammar editor.focus([toEnd]) //默认focus到编辑器头部，toEnd为true时focus到内容尾部
*/
focus: function (toEnd) {
try {
var me = this,
rng = me.selection.getRange();
if (toEnd) {
rng.setStartAtLast(me.body.lastChild).setCursor(false, true);
} else {
rng.select(true);
}
this.fireEvent('focus');
} catch (e) {
}
},
/**
* 使编辑区域失去焦点
*/
blur: function () {
var sel = this.selection.getNative();
sel.empty ? sel.empty() : sel.removeAllRanges();
this.fireEvent('blur')
},
/**
* 判断编辑器当前是否获得了焦点
*/
isFocus: function () {
if (this.fireEvent('isfocus') === true) {
return true;
}
return this.selection.isFocus();
},
/**
* 初始化UE事件及部分事件代理
* @private
* @ignore
*/
_initEvents: function () {
var me = this,
cont = me.body,
_proxyDomEvent = function () {
me._proxyDomEvent.apply(me, arguments);
};
$(cont)
.on('click contextmenu mousedown keydown keyup keypress mouseup mouseover mouseout selectstart', _proxyDomEvent)
.on('focus blur', _proxyDomEvent)
.on('mouseup keydown', function (evt) {
//特殊键不触发selectionchange
if (evt.type == 'keydown' && (evt.ctrlKey || evt.metaKey || evt.shiftKey || evt.altKey)) {
return;
}
if (evt.button == 2) return;
me._selectionChange(250, evt);
});
},
/**
* 触发事件代理
* @private
* @ignore
*/
_proxyDomEvent: function (evt) {
return this.fireEvent(evt.type.replace(/^on/, ''), evt);
},
/**
* 变化选区
* @private
* @ignore
*/
_selectionChange: function (delay, evt) {
var me = this;
//有光标才做selectionchange 为了解决未focus时点击source不能触发更改工具栏状态的问题（source命令notNeedUndo=1）
// if ( !me.selection.isFocus() ){
// return;
// }
var hackForMouseUp = false;
var mouseX, mouseY;
if (browser.ie && browser.version < 9 && evt && evt.type == 'mouseup') {
var range = this.selection.getRange();
if (!range.collapsed) {
hackForMouseUp = true;
mouseX = evt.clientX;
mouseY = evt.clientY;
}
}
clearTimeout(_selectionChangeTimer);
_selectionChangeTimer = setTimeout(function () {
if (!me.selection.getNative()) {
return;
}
//修复一个IE下的bug: 鼠标点击一段已选择的文本中间时，可能在mouseup后的一段时间内取到的range是在selection的type为None下的错误值.
//IE下如果用户是拖拽一段已选择文本，则不会触发mouseup事件，所以这里的特殊处理不会对其有影响
var ieRange;
if (hackForMouseUp && me.selection.getNative().type == 'None') {
ieRange = me.document.body.createTextRange();
try {
ieRange.moveToPoint(mouseX, mouseY);
} catch (ex) {
ieRange = null;
}
}
var bakGetIERange;
if (ieRange) {
bakGetIERange = me.selection.getIERange;
me.selection.getIERange = function () {
return ieRange;
};
}
me.selection.cache();
if (bakGetIERange) {
me.selection.getIERange = bakGetIERange;
}
if (me.selection._cachedRange && me.selection._cachedStartElement) {
me.fireEvent('beforeselectionchange');
// 第二个参数causeByUi为true代表由用户交互造成的selectionchange.
me.fireEvent('selectionchange', !!evt);
me.fireEvent('afterselectionchange');
me.selection.clear();
}
}, delay || 50);
},
_callCmdFn: function (fnName, args) {
args = Array.prototype.slice.call(args, 0);
var cmdName = args.shift().toLowerCase(),
cmd, cmdFn;
cmd = this.commands[cmdName] || UM.commands[cmdName];
cmdFn = cmd && cmd[fnName];
//没有querycommandstate或者没有command的都默认返回0
if ((!cmd || !cmdFn) && fnName == 'queryCommandState') {
return 0;
} else if (cmdFn) {
return cmdFn.apply(this, [cmdName].concat(args));
}
},
/**
* 执行编辑命令cmdName，完成富文本编辑效果
* @name execCommand
* @grammar editor.execCommand(cmdName) => {*}
*/
execCommand: function (cmdName) {
if (!this.isFocus()) {
var bakRange = this.selection._bakRange;
if (bakRange) {
bakRange.select()
} else {
this.focus(true)
}
}
cmdName = cmdName.toLowerCase();
var me = this,
result,
cmd = me.commands[cmdName] || UM.commands[cmdName];
if (!cmd || !cmd.execCommand) {
return null;
}
if (!cmd.notNeedUndo && !me.__hasEnterExecCommand) {
me.__hasEnterExecCommand = true;
if (me.queryCommandState.apply(me, arguments) != -1) {
me.fireEvent('saveScene');
me.fireEvent('beforeexeccommand', cmdName);
result = this._callCmdFn('execCommand', arguments);
(!cmd.ignoreContentChange && !me._ignoreContentChange) && me.fireEvent('contentchange');
me.fireEvent('afterexeccommand', cmdName);
me.fireEvent('saveScene');
}
me.__hasEnterExecCommand = false;
} else {
result = this._callCmdFn('execCommand', arguments);
(!me.__hasEnterExecCommand && !cmd.ignoreContentChange && !me._ignoreContentChange) && me.fireEvent('contentchange')
}
(!me.__hasEnterExecCommand && !cmd.ignoreContentChange && !me._ignoreContentChange) && me._selectionChange();
return result;
},
/**
* 根据传入的command命令，查选编辑器当前的选区，返回命令的状态
* @name queryCommandState
* @grammar editor.queryCommandState(cmdName) => (-1|0|1)
* @desc
* * ''-1'' 当前命令不可用
* * ''0'' 当前命令可用
* * ''1'' 当前命令已经执行过了
*/
queryCommandState: function (cmdName) {
try {
return this._callCmdFn('queryCommandState', arguments);
} catch (e) {
return 0
}
},
/**
* 根据传入的command命令，查选编辑器当前的选区，根据命令返回相关的值
* @name queryCommandValue
* @grammar editor.queryCommandValue(cmdName) => {*}
*/
queryCommandValue: function (cmdName) {
try {
return this._callCmdFn('queryCommandValue', arguments);
} catch (e) {
return null
}
},
/**
* 检查编辑区域中是否有内容，若包含tags中的节点类型，直接返回true
* @name hasContents
* @desc
* 默认有文本内容，或者有以下节点都不认为是空
* {table:1,ul:1,ol:1,dl:1,iframe:1,area:1,base:1,col:1,hr:1,img:1,embed:1,input:1,link:1,meta:1,param:1}
* @grammar editor.hasContents() => (true|false)
* @grammar editor.hasContents(tags) => (true|false) //若文档中包含tags数组里对应的tag，直接返回true
* @example
* editor.hasContents(['span']) //如果编辑器里有这些，不认为是空
*/
hasContents: function (tags) {
if (tags) {
for (var i = 0, ci; ci = tags[i++];) {
if (this.body.getElementsByTagName(ci).length > 0) {
return true;
}
}
}
if (!domUtils.isEmptyBlock(this.body)) {
return true
}
//随时添加,定义的特殊标签如果存在，不能认为是空
tags = ['div'];
for (i = 0; ci = tags[i++];) {
var nodes = domUtils.getElementsByTagName(this.body, ci);
for (var n = 0, cn; cn = nodes[n++];) {
if (domUtils.isCustomeNode(cn)) {
return true;
}
}
}
return false;
},
/**
* 重置编辑器，可用来做多个tab使用同一个编辑器实例
* @name reset
* @desc
* * 清空编辑器内容
* * 清空回退列表
* @grammar editor.reset()
*/
reset: function () {
this.fireEvent('reset');
},
isEnabled: function () {
return this._isEnabled != true;
},
setEnabled: function () {
var me = this, range;
me.body.contentEditable = true;
/* 恢复选区 */
if (me.lastBk) {
range = me.selection.getRange();
try {
range.moveToBookmark(me.lastBk);
delete me.lastBk
} catch (e) {
range.setStartAtFirst(me.body).collapse(true)
}
range.select(true);
}
/* 恢复query函数 */
if (me.bkqueryCommandState) {
me.queryCommandState = me.bkqueryCommandState;
delete me.bkqueryCommandState;
}
/* 恢复原生事件 */
if (me._bkproxyDomEvent) {
me._proxyDomEvent = me._bkproxyDomEvent;
delete me._bkproxyDomEvent;
}
/* 触发事件 */
me.fireEvent('setEnabled');
},
/**
* 设置当前编辑区域可以编辑
* @name enable
* @grammar editor.enable()
*/
enable: function () {
return this.setEnabled();
},
setDisabled: function (except, keepDomEvent) {
var me = this;
me.body.contentEditable = false;
me._except = except ? utils.isArray(except) ? except : [except] : [];
/* 备份最后的选区 */
if (!me.lastBk) {
me.lastBk = me.selection.getRange().createBookmark(true);
}
/* 备份并重置query函数 */
if (!me.bkqueryCommandState) {
me.bkqueryCommandState = me.queryCommandState;
me.queryCommandState = function (type) {
if (utils.indexOf(me._except, type) != -1) {
return me.bkqueryCommandState.apply(me, arguments);
}
return -1;
};
}
/* 备份并墙原生事件 */
if (!keepDomEvent && !me._bkproxyDomEvent) {
me._bkproxyDomEvent = me._proxyDomEvent;
me._proxyDomEvent = function () {
return false;
};
}
/* 触发事件 */
me.fireEvent('selectionchange');
me.fireEvent('setDisabled', me._except);
},
/** 设置当前编辑区域不可编辑,except中的命令除外
* @name disable
* @grammar editor.disable()
* @grammar editor.disable(except) //例外的命令，也即即使设置了disable，此处配置的命令仍然可以执行
* @example
* //禁用工具栏中除加粗和插入图片之外的所有功能
* editor.disable(['bold','insertimage']);//可以是单一的String,也可以是Array
*/
disable: function (except) {
return this.setDisabled(except);
},
/**
* 设置默认内容
* @ignore
* @private
* @param {String} cont 要存入的内容
*/
_setDefaultContent: function () {
function clear() {
var me = this;
if (me.document.getElementById('initContent')) {
me.body.innerHTML = '
' + (ie ? '' : ' ') + '
';
me.removeListener('firstBeforeExecCommand focus', clear);
setTimeout(function () {
me.focus();
me._selectionChange();
}, 0)
}
}
return function (cont) {
var me = this;
me.body.innerHTML = '
' + cont + '
';
me.addListener('firstBeforeExecCommand focus', clear);
}
}(),
/**
* show方法的兼容版本
* @private
* @ignore
*/
setShow: function () {
var me = this, range = me.selection.getRange();
if (me.container.style.display == 'none') {
//有可能内容丢失了
try {
range.moveToBookmark(me.lastBk);
delete me.lastBk
} catch (e) {
range.setStartAtFirst(me.body).collapse(true)
}
//ie下focus实效，所以做了个延迟
setTimeout(function () {
range.select(true);
}, 100);
me.container.style.display = '';
}
},
/**
* 显示编辑器
* @name show
* @grammar editor.show()
*/
show: function () {
return this.setShow();
},
/**
* hide方法的兼容版本
* @private
* @ignore
*/
setHide: function () {
var me = this;
if (!me.lastBk) {
me.lastBk = me.selection.getRange().createBookmark(true);
}
me.container.style.display = 'none'
},
/**
* 隐藏编辑器
* @name hide
* @grammar editor.hide()
*/
hide: function () {
return this.setHide();
},
/**
* 根据制定的路径，获取对应的语言资源
* @name getLang
* @grammar editor.getLang(path) => （JSON|String) 路径根据的是lang目录下的语言文件的路径结构
* @example
* editor.getLang('contextMenu.delete') //如果当前是中文，那返回是的是删除
*/
getLang: function (path) {
var lang = UM.I18N[this.options.lang];
if (!lang) {
throw Error("not import language file");
}
path = (path || "").split(".");
for (var i = 0, ci; ci = path[i++];) {
lang = lang[ci];
if (!lang) break;
}
return lang;
},
/**
* 计算编辑器当前内容的长度
* @name getContentLength
* @grammar editor.getContentLength(ingoneHtml,tagNames) =>
* @example
* editor.getLang(true)
*/
getContentLength: function (ingoneHtml, tagNames) {
var count = this.getContent(false, false, true).length;
if (ingoneHtml) {
tagNames = (tagNames || []).concat(['hr', 'img', 'iframe']);
count = this.getContentTxt().replace(/[\t\r\n]+/g, '').length;
for (var i = 0, ci; ci = tagNames[i++];) {
count += this.body.getElementsByTagName(ci).length;
}
}
return count;
},
addInputRule: function (rule, ignoreUndo) {
rule.ignoreUndo = ignoreUndo;
this.inputRules.push(rule);
},
filterInputRule: function (root, isUndoLoad) {
for (var i = 0, ci; ci = this.inputRules[i++];) {
if (isUndoLoad && ci.ignoreUndo) {
continue;
}
ci.call(this, root)
}
},
addOutputRule: function (rule, ignoreUndo) {
rule.ignoreUndo = ignoreUndo;
this.outputRules.push(rule)
},
filterOutputRule: function (root, isUndoLoad) {
for (var i = 0, ci; ci = this.outputRules[i++];) {
if (isUndoLoad && ci.ignoreUndo) {
continue;
}
ci.call(this, root)
}
}
};
utils.inherits(Editor, EventBase);
})();
/**
* @file
* @name UM.filterWord
* @short filterWord
* @desc 用来过滤word粘贴过来的字符串
* @import editor.js,core/utils.js
* @anthor zhanyi
*/
var filterWord = UM.filterWord = function () {
//是否是word过来的内容
function isWordDocument(str) {
return /(class="?Mso|style="[^"]*\bmso\-|w:WordDocument|<(v|o):|lang=)/ig.test(str);
}
//去掉小数
function transUnit(v) {
v = v.replace(/[\d.]+\w+/g, function (m) {
return utils.transUnitToPx(m);
});
return v;
}
function filterPasteWord(str) {
return str.replace(/[\t\r\n]+/g, ' ')
.replace(//ig, "")
//转换图片
.replace(/]*>[\s\S]*?.<\/v:shape>/gi, function (str) {
//opera能自己解析出image所这里直接返回空
if (browser.opera) {
return '';
}
try {
//有可能是bitmap占为图，无用，直接过滤掉，主要体现在粘贴excel表格中
if (/Bitmap/i.test(str)) {
return '';
}
var width = str.match(/width:([ \d.]*p[tx])/i)[1],
height = str.match(/height:([ \d.]*p[tx])/i)[1],
src = str.match(/src=\s*"([^"]*)"/i)[1];
return '';
} catch (e) {
return '';
}
})
//针对wps添加的多余标签处理
.replace(/<\/?div[^>]*>/g, '')
//去掉多余的属性
.replace(/v:\w+=(["']?)[^'"]+\1/g, '')
.replace(/<(!|script[^>]*>.*?<\/script(?=[>\s])|\/?(\?xml(:\w+)?|xml|meta|link|style|\w+:\w+)(?=[\s\/>]))[^>]*>/gi, "")
.replace(/
]*class="?MsoHeading"?[^>]*>(.*?)<\/p>/gi, "
$1
")
//去掉多余的属性
.replace(/\s+(class|lang|align)\s*=\s*(['"]?)([\w-]+)\2/ig, function (str, name, marks, val) {
//保留list的标示
return name == 'class' && val == 'MsoListParagraph' ? str : ''
})
//清除多余的font/span不能匹配 有可能是空格
.replace(/<(font|span)[^>]*>(\s*)<\/\1>/gi, function (a, b, c) {
return c.replace(/[\t\r\n ]+/g, ' ')
})
//处理style的问题
.replace(/(<[a-z][^>]*)\sstyle=(["'])([^\2]*?)\2/gi, function (str, tag, tmp, style) {
var n = [],
s = style.replace(/^\s+|\s+$/, '')
.replace(/'/g, '\'')
.replace(/"/gi, "'")
.split(/;\s*/g);
for (var i = 0, v; v = s[i]; i++) {
var name, value,
parts = v.split(":");
if (parts.length == 2) {
name = parts[0].toLowerCase();
value = parts[1].toLowerCase();
if (/^(background)\w*/.test(name) && value.replace(/(initial|\s)/g, '').length == 0
||
/^(margin)\w*/.test(name) && /^0\w+$/.test(value)
) {
continue;
}
switch (name) {
case "mso-padding-alt":
case "mso-padding-top-alt":
case "mso-padding-right-alt":
case "mso-padding-bottom-alt":
case "mso-padding-left-alt":
case "mso-margin-alt":
case "mso-margin-top-alt":
case "mso-margin-right-alt":
case "mso-margin-bottom-alt":
case "mso-margin-left-alt":
//ie下会出现挤到一起的情况
//case "mso-table-layout-alt":
case "mso-height":
case "mso-width":
case "mso-vertical-align-alt":
//trace:1819 ff下会解析出padding在table上
if (!/
]/.test(html)) {
return UM.htmlparser(html).children[0]
} else {
return new uNode({
type: 'element',
children: [],
tagName: html
})
}
};
uNode.createText = function (data, noTrans) {
return new UM.uNode({
type: 'text',
'data': noTrans ? data : utils.unhtml(data || '')
})
};
function nodeToHtml(node, arr, formatter, current) {
switch (node.type) {
case 'root':
for (var i = 0, ci; ci = node.children[i++];) {
//插入新行
if (formatter && ci.type == 'element' && !dtd.$inlineWithA[ci.tagName] && i > 1) {
insertLine(arr, current, true);
insertIndent(arr, current)
}
nodeToHtml(ci, arr, formatter, current)
}
break;
case 'text':
isText(node, arr);
break;
case 'element':
isElement(node, arr, formatter, current);
break;
case 'comment':
isComment(node, arr, formatter);
}
return arr;
}
function isText(node, arr) {
if (node.parentNode.tagName == 'pre') {
//源码模式下输入html标签，不能做转换处理，直接输出
arr.push(node.data)
} else {
arr.push(notTransTagName[node.parentNode.tagName] ? utils.html(node.data) : node.data.replace(/[ ]{2}/g, ' '))
}
}
function isElement(node, arr, formatter, current) {
var attrhtml = '';
if (node.attrs) {
attrhtml = [];
var attrs = node.attrs;
for (var a in attrs) {
//这里就针对
//
'
//这里边的\"做转换，要不用innerHTML直接被截断了，属性src
//有可能做的不够
attrhtml.push(a + (attrs[a] !== undefined ? '="' + (notTransAttrs[a] ? utils.html(attrs[a]).replace(/["]/g, function (a) {
return '"'
}) : utils.unhtml(attrs[a])) + '"' : ''))
}
attrhtml = attrhtml.join(' ');
}
arr.push('<' + node.tagName +
(attrhtml ? ' ' + attrhtml : '') +
(dtd.$empty[node.tagName] ? '\/' : '') + '>'
);
//插入新行
if (formatter && !dtd.$inlineWithA[node.tagName] && node.tagName != 'pre') {
if (node.children && node.children.length) {
current = insertLine(arr, current, true);
insertIndent(arr, current)
}
}
if (node.children && node.children.length) {
for (var i = 0, ci; ci = node.children[i++];) {
if (formatter && ci.type == 'element' && !dtd.$inlineWithA[ci.tagName] && i > 1) {
insertLine(arr, current);
insertIndent(arr, current)
}
nodeToHtml(ci, arr, formatter, current)
}
}
if (!dtd.$empty[node.tagName]) {
if (formatter && !dtd.$inlineWithA[node.tagName] && node.tagName != 'pre') {
if (node.children && node.children.length) {
current = insertLine(arr, current);
insertIndent(arr, current)
}
}
arr.push('<\/' + node.tagName + '>');
}
}
function isComment(node, arr) {
arr.push('');
}
function getNodeById(root, id) {
var node;
if (root.type == 'element' && root.getAttr('id') == id) {
return root;
}
if (root.children && root.children.length) {
for (var i = 0, ci; ci = root.children[i++];) {
if (node = getNodeById(ci, id)) {
return node;
}
}
}
}
function getNodesByTagName(node, tagName, arr) {
if (node.type == 'element' && node.tagName == tagName) {
arr.push(node);
}
if (node.children && node.children.length) {
for (var i = 0, ci; ci = node.children[i++];) {
getNodesByTagName(ci, tagName, arr)
}
}
}
function nodeTraversal(root, fn) {
if (root.children && root.children.length) {
for (var i = 0, ci; ci = root.children[i];) {
nodeTraversal(ci, fn);
//ci被替换的情况，这里就不再走 fn了
if (ci.parentNode) {
if (ci.children && ci.children.length) {
fn(ci)
}
if (ci.parentNode) i++
}
}
} else {
fn(root)
}
}
uNode.prototype = {
/**
* 当前节点对象，转换成html文本
* @method toHtml
* @return { String } 返回转换后的html字符串
* @example
* ```javascript
* node.toHtml();
* ```
*/
/**
* 当前节点对象，转换成html文本
* @method toHtml
* @param { Boolean } formatter 是否格式化返回值
* @return { String } 返回转换后的html字符串
* @example
* ```javascript
* node.toHtml( true );
* ```
*/
toHtml: function (formatter) {
var arr = [];
nodeToHtml(this, arr, formatter, 0);
return arr.join('')
},
/**
* 获取节点的html内容
* @method innerHTML
* @warning 假如节点的type不是'element'，或节点的标签名称不在dtd列表里，直接返回当前节点
* @return { String } 返回节点的html内容
* @example
* ```javascript
* var htmlstr = node.innerHTML();
* ```
*/
/**
* 设置节点的html内容
* @method innerHTML
* @warning 假如节点的type不是'element'，或节点的标签名称不在dtd列表里，直接返回当前节点
* @param { String } htmlstr 传入要设置的html内容
* @return { UM.uNode } 返回节点本身
* @example
* ```javascript
* node.innerHTML('text');
* ```
*/
innerHTML: function (htmlstr) {
if (this.type != 'element' || dtd.$empty[this.tagName]) {
return this;
}
if (utils.isString(htmlstr)) {
if (this.children) {
for (var i = 0, ci; ci = this.children[i++];) {
ci.parentNode = null;
}
}
this.children = [];
var tmpRoot = UM.htmlparser(htmlstr);
for (var i = 0, ci; ci = tmpRoot.children[i++];) {
this.children.push(ci);
ci.parentNode = this;
}
return this;
} else {
var tmpRoot = new UM.uNode({
type: 'root',
children: this.children
});
return tmpRoot.toHtml();
}
},
/**
* 获取节点的纯文本内容
* @method innerText
* @warning 假如节点的type不是'element'，或节点的标签名称不在dtd列表里，直接返回当前节点
* @return { String } 返回节点的存文本内容
* @example
* ```javascript
* var textStr = node.innerText();
* ```
*/
/**
* 设置节点的纯文本内容
* @method innerText
* @warning 假如节点的type不是'element'，或节点的标签名称不在dtd列表里，直接返回当前节点
* @param { String } textStr 传入要设置的文本内容
* @return { UM.uNode } 返回节点本身
* @example
* ```javascript
* node.innerText('text');
* ```
*/
innerText: function (textStr, noTrans) {
if (this.type != 'element' || dtd.$empty[this.tagName]) {
return this;
}
if (textStr) {
if (this.children) {
for (var i = 0, ci; ci = this.children[i++];) {
ci.parentNode = null;
}
}
this.children = [];
this.appendChild(uNode.createText(textStr, noTrans));
return this;
} else {
return this.toHtml().replace(/<[^>]+>/g, '');
}
},
/**
* 获取当前对象的data属性
* @method getData
* @return { Object } 若节点的type值是elemenet，返回空字符串，否则返回节点的data属性
* @example
* ```javascript
* node.getData();
* ```
*/
getData: function () {
if (this.type == 'element')
return '';
return this.data
},
/**
* 获取当前节点下的第一个子节点
* @method firstChild
* @return { UM.uNode } 返回第一个子节点
* @example
* ```javascript
* node.firstChild(); //返回第一个子节点
* ```
*/
firstChild: function () {
// if (this.type != 'element' || dtd.$empty[this.tagName]) {
// return this;
// }
return this.children ? this.children[0] : null;
},
/**
* 获取当前节点下的最后一个子节点
* @method lastChild
* @return { UM.uNode } 返回最后一个子节点
* @example
* ```javascript
* node.lastChild(); //返回最后一个子节点
* ```
*/
lastChild: function () {
// if (this.type != 'element' || dtd.$empty[this.tagName] ) {
// return this;
// }
return this.children ? this.children[this.children.length - 1] : null;
},
/**
* 获取和当前节点有相同父亲节点的前一个节点
* @method previousSibling
* @return { UM.uNode } 返回前一个节点
* @example
* ```javascript
* node.children[2].previousSibling(); //返回子节点node.children[1]
* ```
*/
previousSibling: function () {
var parent = this.parentNode;
for (var i = 0, ci; ci = parent.children[i]; i++) {
if (ci === this) {
return i == 0 ? null : parent.children[i - 1];
}
}
},
/**
* 获取和当前节点有相同父亲节点的后一个节点
* @method nextSibling
* @return { UM.uNode } 返回后一个节点,找不到返回null
* @example
* ```javascript
* node.children[2].nextSibling(); //如果有，返回子节点node.children[3]
* ```
*/
nextSibling: function () {
var parent = this.parentNode;
for (var i = 0, ci; ci = parent.children[i++];) {
if (ci === this) {
return parent.children[i];
}
}
},
/**
* 用新的节点替换当前节点
* @method replaceChild
* @param { UM.uNode } target 要替换成该节点参数
* @param { UM.uNode } source 要被替换掉的节点
* @return { UM.uNode } 返回替换之后的节点对象
* @example
* ```javascript
* node.replaceChild(newNode, childNode); //用newNode替换childNode,childNode是node的子节点
* ```
*/
replaceChild: function (target, source) {
if (this.children) {
if (target.parentNode) {
target.parentNode.removeChild(target);
}
for (var i = 0, ci; ci = this.children[i]; i++) {
if (ci === source) {
this.children.splice(i, 1, target);
source.parentNode = null;
target.parentNode = this;
return target;
}
}
}
},
/**
* 在节点的子节点列表最后位置插入一个节点
* @method appendChild
* @param { UM.uNode } node 要插入的节点
* @return { UM.uNode } 返回刚插入的子节点
* @example
* ```javascript
* node.appendChild( newNode ); //在node内插入子节点newNode
* ```
*/
appendChild: function (node) {
if (this.type == 'root' || (this.type == 'element' && !dtd.$empty[this.tagName])) {
if (!this.children) {
this.children = []
}
if (node.parentNode) {
node.parentNode.removeChild(node);
}
for (var i = 0, ci; ci = this.children[i]; i++) {
if (ci === node) {
this.children.splice(i, 1);
break;
}
}
this.children.push(node);
node.parentNode = this;
return node;
}
},
/**
* 在传入节点的前面插入一个节点
* @method insertBefore
* @param { UM.uNode } target 要插入的节点
* @param { UM.uNode } source 在该参数节点前面插入
* @return { UM.uNode } 返回刚插入的子节点
* @example
* ```javascript
* node.parentNode.insertBefore(newNode, node); //在node节点后面插入newNode
* ```
*/
insertBefore: function (target, source) {
if (this.children) {
if (target.parentNode) {
target.parentNode.removeChild(target);
}
for (var i = 0, ci; ci = this.children[i]; i++) {
if (ci === source) {
this.children.splice(i, 0, target);
target.parentNode = this;
return target;
}
}
}
},
/**
* 在传入节点的后面插入一个节点
* @method insertAfter
* @param { UM.uNode } target 要插入的节点
* @param { UM.uNode } source 在该参数节点后面插入
* @return { UM.uNode } 返回刚插入的子节点
* @example
* ```javascript
* node.parentNode.insertAfter(newNode, node); //在node节点后面插入newNode
* ```
*/
insertAfter: function (target, source) {
if (this.children) {
if (target.parentNode) {
target.parentNode.removeChild(target);
}
for (var i = 0, ci; ci = this.children[i]; i++) {
if (ci === source) {
this.children.splice(i + 1, 0, target);
target.parentNode = this;
return target;
}
}
}
},
/**
* 从当前节点的子节点列表中，移除节点
* @method removeChild
* @param { UM.uNode } node 要移除的节点引用
* @param { Boolean } keepChildren 是否保留移除节点的子节点，若传入true，自动把移除节点的子节点插入到移除的位置
* @return { * } 返回刚移除的子节点
* @example
* ```javascript
* node.removeChild(childNode,true); //在node的子节点列表中移除child节点，并且吧child的子节点插入到移除的位置
* ```
*/
removeChild: function (node, keepChildren) {
if (this.children) {
for (var i = 0, ci; ci = this.children[i]; i++) {
if (ci === node) {
this.children.splice(i, 1);
ci.parentNode = null;
if (keepChildren && ci.children && ci.children.length) {
for (var j = 0, cj; cj = ci.children[j]; j++) {
this.children.splice(i + j, 0, cj);
cj.parentNode = this;
}
}
return ci;
}
}
}
},
/**
* 获取当前节点所代表的元素属性，即获取attrs对象下的属性值
* @method getAttr
* @param { String } attrName 要获取的属性名称
* @return { * } 返回attrs对象下的属性值
* @example
* ```javascript
* node.getAttr('title');
* ```
*/
getAttr: function (attrName) {
return this.attrs && this.attrs[attrName.toLowerCase()]
},
/**
* 设置当前节点所代表的元素属性，即设置attrs对象下的属性值
* @method setAttr
* @param { String } attrName 要设置的属性名称
* @param { * } attrVal 要设置的属性值，类型视设置的属性而定
* @return { * } 返回attrs对象下的属性值
* @example
* ```javascript
* node.setAttr('title','标题');
* ```
*/
setAttr: function (attrName, attrVal) {
if (!attrName) {
delete this.attrs;
return;
}
if (!this.attrs) {
this.attrs = {};
}
if (utils.isObject(attrName)) {
for (var a in attrName) {
if (!attrName[a]) {
delete this.attrs[a]
} else {
this.attrs[a.toLowerCase()] = attrName[a];
}
}
} else {
if (!attrVal) {
delete this.attrs[attrName]
} else {
this.attrs[attrName.toLowerCase()] = attrVal;
}
}
},
hasAttr: function (attrName) {
var attrVal = this.getAttr(attrName);
return (attrVal !== null) && (attrVal !== undefined);
},
/**
* 获取当前节点在父节点下的位置索引
* @method getIndex
* @return { Number } 返回索引数值，如果没有父节点，返回-1
* @example
* ```javascript
* node.getIndex();
* ```
*/
getIndex: function () {
var parent = this.parentNode;
for (var i = 0, ci; ci = parent.children[i]; i++) {
if (ci === this) {
return i;
}
}
return -1;
},
/**
* 在当前节点下，根据id查找节点
* @method getNodeById
* @param { String } id 要查找的id
* @return { UM.uNode } 返回找到的节点
* @example
* ```javascript
* node.getNodeById('textId');
* ```
*/
getNodeById: function (id) {
var node;
if (this.children && this.children.length) {
for (var i = 0, ci; ci = this.children[i++];) {
if (node = getNodeById(ci, id)) {
return node;
}
}
}
},
/**
* 在当前节点下，根据元素名称查找节点列表
* @method getNodesByTagName
* @param { String } tagNames 要查找的元素名称
* @return { Array } 返回找到的节点列表
* @example
* ```javascript
* node.getNodesByTagName('span');
* ```
*/
getNodesByTagName: function (tagNames) {
tagNames = utils.trim(tagNames).replace(/[ ]{2,}/g, ' ').split(' ');
var arr = [], me = this;
utils.each(tagNames, function (tagName) {
if (me.children && me.children.length) {
for (var i = 0, ci; ci = me.children[i++];) {
getNodesByTagName(ci, tagName, arr)
}
}
});
return arr;
},
/**
* 根据样式名称，获取节点的样式值
* @method getStyle
* @param { String } name 要获取的样式名称
* @return { String } 返回样式值
* @example
* ```javascript
* node.getStyle('font-size');
* ```
*/
getStyle: function (name) {
var cssStyle = this.getAttr('style');
if (!cssStyle) {
return ''
}
var reg = new RegExp('(^|;)\\s*' + name + ':([^;]+)', 'i');
var match = cssStyle.match(reg);
if (match && match[0]) {
return match[2]
}
return '';
},
/**
* 给节点设置样式
* @method setStyle
* @param { String } name 要设置的的样式名称
* @param { String } val 要设置的的样值
* @example
* ```javascript
* node.setStyle('font-size', '12px');
* ```
*/
setStyle: function (name, val) {
function exec(name, val) {
var reg = new RegExp('(^|;)\\s*' + name + ':([^;]+;?)', 'gi');
cssStyle = cssStyle.replace(reg, '$1');
if (val) {
cssStyle = name + ':' + utils.unhtml(val) + ';' + cssStyle
}
}
var cssStyle = this.getAttr('style');
if (!cssStyle) {
cssStyle = '';
}
if (utils.isObject(name)) {
for (var a in name) {
exec(a, name[a])
}
} else {
exec(name, val)
}
this.setAttr('style', utils.trim(cssStyle))
},
hasClass: function (className) {
if (this.hasAttr('class')) {
var classNames = this.getAttr('class').split(/\s+/),
hasClass = false;
$.each(classNames, function (key, item) {
if (item === className) {
hasClass = true;
}
});
return hasClass;
} else {
return false;
}
},
addClass: function (className) {
var classes = null,
hasClass = false;
if (this.hasAttr('class')) {
classes = this.getAttr('class');
classes = classes.split(/\s+/);
classes.forEach(function (item) {
if (item === className) {
hasClass = true;
return;
}
});
!hasClass && classes.push(className);
this.setAttr('class', classes.join(" "));
} else {
this.setAttr('class', className);
}
},
removeClass: function (className) {
if (this.hasAttr('class')) {
var cl = this.getAttr('class');
cl = cl.replace(new RegExp('\\b' + className + '\\b', 'g'), '');
this.setAttr('class', utils.trim(cl).replace(/[ ]{2,}/g, ' '));
}
},
/**
* 传入一个函数，递归遍历当前节点下的所有节点
* @method traversal
* @param { Function } fn 遍历到节点的时，传入节点作为参数，运行此函数
* @example
* ```javascript
* traversal(node, function(){
* console.log(node.type);
* });
* ```
*/
traversal: function (fn) {
if (this.children && this.children.length) {
nodeTraversal(this, fn);
}
return this;
}
}
})();
//html字符串转换成uNode节点
//by zhanyi
var htmlparser = UM.htmlparser = function (htmlstr, ignoreBlank) {
//todo 原来的方式 [^"'<>\/] 有\/就不能配对上
'
:
'';
}
function switchImgAndEmbed(root, img2embed) {
utils.each(root.getNodesByTagName(img2embed ? 'img' : 'embed'), function (node) {
if (node.getAttr('class') == 'edui-faked-video') {
var html = creatInsertStr(img2embed ? node.getAttr('_url') : node.getAttr('src'), node.getAttr('width'), node.getAttr('height'), null, node.getStyle('float') || '', img2embed);
node.parentNode.replaceChild(UM.uNode.createElement(html), node)
}
})
}
me.addOutputRule(function (root) {
switchImgAndEmbed(root, true)
});
me.addInputRule(function (root) {
switchImgAndEmbed(root)
});
me.commands["insertvideo"] = {
execCommand: function (cmd, videoObjs) {
videoObjs = utils.isArray(videoObjs) ? videoObjs : [videoObjs];
var html = [], id = 'tmpVedio';
for (var i = 0, vi, len = videoObjs.length; i < len; i++) {
vi = videoObjs[i];
vi.url = utils.unhtml(vi.url, /[<">'](?:(amp|lt|quot|gt|#39|nbsp);)?/g);
html.push(creatInsertStr(vi.url, vi.width || 420, vi.height || 280, id + i, vi.align, false));
}
me.execCommand("inserthtml", html.join(""), true);
},
queryCommandState: function () {
var img = me.selection.getRange().getClosedNode(),
flag = img && (img.className == "edui-faked-video");
return flag ? 1 : 0;
}
};
};
///import core
///commands 全选
///commandsName SelectAll
///commandsTitle 全选
/**
* 选中所有
* @function
* @name UM.execCommand
* @param {String} cmdName selectall选中编辑器里的所有内容
* @author zhanyi
*/
UM.plugins['selectall'] = function () {
var me = this;
me.commands['selectall'] = {
execCommand: function () {
//去掉了原生的selectAll,因为会出现报错和当内容为空时，不能出现闭合状态的光标
var me = this, body = me.body,
range = me.selection.getRange();
range.selectNodeContents(body);
if (domUtils.isEmptyBlock(body)) {
//opera不能自动合并到元素的里边，要手动处理一下
if (browser.opera && body.firstChild && body.firstChild.nodeType == 1) {
range.setStartAtFirst(body.firstChild);
}
range.collapse(true);
}
range.select(true);
},
notNeedUndo: 1
};
//快捷键
me.addshortcutkey({
"selectAll": "ctrl+65"
});
};
//UM.plugins['removeformat'] = function () {
// var me = this;
// me.commands['removeformat'] = {
// execCommand: function () {
// me.document.execCommand('removeformat');
//
// /* 处理ie8和firefox选区有链接时,清除格式的bug */
// if (browser.gecko || browser.ie8 || browser.webkit) {
// var nativeRange = this.selection.getNative().getRangeAt(0),
// common = nativeRange.commonAncestorContainer,
// rng = me.selection.getRange(),
// bk = rng.createBookmark();
//
// function isEleInBookmark(node, bk){
// if ( (domUtils.getPosition(node, bk.start) & domUtils.POSITION_FOLLOWING) &&
// (domUtils.getPosition(bk.end, node) & domUtils.POSITION_FOLLOWING) ) {
// return true;
// } else if ( (domUtils.getPosition(node, bk.start) & domUtils.POSITION_CONTAINS) ||
// (domUtils.getPosition(node, bk.end) & domUtils.POSITION_CONTAINS) ) {
// return true;
// }
// return false;
// }
//
// $(common).find('a').each(function (k, a) {
// if ( isEleInBookmark(a, bk) ) {
// a.removeAttribute('style');
// }
// });
//
// }
// }
// };
//
//};
//
UM.plugins['removeformat'] = function () {
var me = this;
me.setOpt({
'removeFormatTags': 'b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var',
'removeFormatAttributes': 'class,style,lang,width,height,align,hspace,valign'
});
me.commands['removeformat'] = {
execCommand: function (cmdName, tags, style, attrs, notIncludeA) {
var tagReg = new RegExp('^(?:' + (tags || this.options.removeFormatTags).replace(/,/g, '|') + ')$', 'i'),
removeFormatAttributes = style ? [] : (attrs || this.options.removeFormatAttributes).split(','),
range = new dom.Range(this.document),
bookmark, node, parent,
filter = function (node) {
return node.nodeType == 1;
};
function isRedundantSpan(node) {
if (node.nodeType == 3 || node.tagName.toLowerCase() != 'span') {
return 0;
}
if (browser.ie) {
//ie 下判断实效，所以只能简单用style来判断
//return node.style.cssText == '' ? 1 : 0;
var attrs = node.attributes;
if (attrs.length) {
for (var i = 0, l = attrs.length; i < l; i++) {
if (attrs[i].specified) {
return 0;
}
}
return 1;
}
}
return !node.attributes.length;
}
function doRemove(range) {
var bookmark1 = range.createBookmark();
if (range.collapsed) {
range.enlarge(true);
}
//不能把a标签切了
if (!notIncludeA) {
var aNode = domUtils.findParentByTagName(range.startContainer, 'a', true);
if (aNode) {
range.setStartBefore(aNode);
}
aNode = domUtils.findParentByTagName(range.endContainer, 'a', true);
if (aNode) {
range.setEndAfter(aNode);
}
}
bookmark = range.createBookmark();
node = bookmark.start;
//切开始
while ((parent = node.parentNode) && !domUtils.isBlockElm(parent)) {
domUtils.breakParent(node, parent);
domUtils.clearEmptySibling(node);
}
if (bookmark.end) {
//切结束
node = bookmark.end;
while ((parent = node.parentNode) && !domUtils.isBlockElm(parent)) {
domUtils.breakParent(node, parent);
domUtils.clearEmptySibling(node);
}
//开始去除样式
var current = domUtils.getNextDomNode(bookmark.start, false, filter),
next;
while (current) {
if (current == bookmark.end) {
break;
}
next = domUtils.getNextDomNode(current, true, filter);
if (!dtd.$empty[current.tagName.toLowerCase()] && !domUtils.isBookmarkNode(current)) {
if (tagReg.test(current.tagName)) {
if (style) {
domUtils.removeStyle(current, style);
if (isRedundantSpan(current) && style != 'text-decoration') {
domUtils.remove(current, true);
}
} else {
domUtils.remove(current, true);
}
} else {
//trace:939 不能把list上的样式去掉
if (!dtd.$tableContent[current.tagName] && !dtd.$list[current.tagName]) {
domUtils.removeAttributes(current, removeFormatAttributes);
if (isRedundantSpan(current)) {
domUtils.remove(current, true);
}
}
}
}
current = next;
}
}
//trace:1035
//trace:1096 不能把td上的样式去掉，比如边框
var pN = bookmark.start.parentNode;
if (domUtils.isBlockElm(pN) && !dtd.$tableContent[pN.tagName] && !dtd.$list[pN.tagName]) {
var remove_check = pN.getAttribute('class'); //新增
if (remove_check && remove_check.indexOf('edui-body-container') > -1) {
} else {
domUtils.removeAttributes(pN, removeFormatAttributes);
}
}
pN = bookmark.end.parentNode;
if (bookmark.end && domUtils.isBlockElm(pN) && !dtd.$tableContent[pN.tagName] && !dtd.$list[pN.tagName]) {
var remove_check = pN.getAttribute('class'); //新增
if (remove_check && remove_check.indexOf('edui-body-container') > -1) {
} else {
domUtils.removeAttributes(pN, removeFormatAttributes);
}
}
range.moveToBookmark(bookmark).moveToBookmark(bookmark1);
//清除冗余的代码 ![](http://nsclick.baidu.com/u.gif?&asdf=\"sdf&asdfasdfs;asdf)