You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
860 lines
18 KiB
860 lines
18 KiB
if(!window.CreateRTELoader)new function()
|
|
{
|
|
var _debugmode=false;
|
|
if(location.href.indexOf("://127.0.0.1")!=-1||location.href.indexOf("rtenocache")!=-1)
|
|
_debugmode=true;
|
|
var debugloadingsteps=false;
|
|
if(location.href.indexOf("rteloadstep")!=-1)
|
|
debugloadingsteps=true;
|
|
|
|
var d=new Date();
|
|
var urlsuffix="2013061202" //String(d.getFullYear()*10000+(1+d.getMonth())*100+d.getDate());
|
|
|
|
if(_debugmode)
|
|
urlsuffix=d.getTime();
|
|
|
|
var _showLangWarning=false;
|
|
|
|
var ismsie=/MSIE/.test(navigator.userAgent);
|
|
|
|
function createxh()
|
|
{
|
|
return window.XMLHttpRequest?new XMLHttpRequest():new ActiveXObject("Microsoft.XMLHTTP");
|
|
}
|
|
|
|
function trace(msg)
|
|
{
|
|
if(debugloadingsteps)document.title=msg;
|
|
}
|
|
|
|
var textmap={}
|
|
function asyncloadtext(url,callback)
|
|
{
|
|
var item=textmap[url];
|
|
if(item)
|
|
{
|
|
if(!callback)
|
|
return;
|
|
if(item.loading!='loading')
|
|
{
|
|
setTimeout(function()
|
|
{
|
|
callback(item.text,item.xml);
|
|
},0);
|
|
}
|
|
else
|
|
{
|
|
item.callbacks.push(callback);
|
|
}
|
|
return;
|
|
}
|
|
|
|
item={url:url,loading:'loading',callbacks:callback?[callback]:[]};
|
|
textmap[url]=item;
|
|
|
|
var index=0;
|
|
function runcallbacks()
|
|
{
|
|
var func=item.callbacks[index];
|
|
index++;
|
|
if(index<item.callbacks.length)setTimeout(runcallbacks,0);
|
|
if(func)func(item.text,item.xml);
|
|
}
|
|
|
|
var xh=createxh();
|
|
xh.open("GET",url,true);
|
|
xh.onreadystatechange=function()
|
|
{
|
|
if(xh.readyState!=4)return;
|
|
xh.onreadystatechange=new Function("","");
|
|
|
|
if(xh.status!=200)
|
|
{
|
|
item.succeed=false;
|
|
item.loading='httperror:'+xh.status;
|
|
if(xh.status!=0)
|
|
throw(new Error("failed to load "+url+" , \r\n http"+xh.status));
|
|
return;
|
|
}
|
|
|
|
item.loading='ready';
|
|
item.text=xh.responseText;
|
|
item.xml=xh.responseXML;
|
|
setTimeout(runcallbacks,1);
|
|
}
|
|
xh.send("");
|
|
}
|
|
|
|
function asyncloadscript(url,callback,runcode)
|
|
{
|
|
asyncloadtext(url,function(code)
|
|
{
|
|
if(!runcode)
|
|
runcode=new Function("","eval(arguments[0])");
|
|
try
|
|
{
|
|
runcode(code);
|
|
}
|
|
catch(x)
|
|
{
|
|
callback();
|
|
throw(new Error("failed to load "+url+" , \r\n"+x.message));
|
|
}
|
|
callback();
|
|
});
|
|
}
|
|
|
|
var stylemap={};
|
|
function asyncloadstyle(url,callback)
|
|
{
|
|
var item=stylemap[url];
|
|
if(item)
|
|
{
|
|
setTimeout(function()
|
|
{
|
|
callback();
|
|
},0);
|
|
return;
|
|
}
|
|
|
|
item={url:url,callbacks:[callback]};
|
|
stylemap[url]=item;
|
|
|
|
var index=0;
|
|
function runcallbacks()
|
|
{
|
|
var func=item.callbacks[index];
|
|
index++;
|
|
if(index<item.callbacks.length)setTimeout(runcallbacks,0);
|
|
if(func)func(3);
|
|
}
|
|
|
|
var csscontainer=document.getElementsByTagName("head")[0]||document.body;
|
|
var stytag=document.createElement("LINK");
|
|
if("onload" in stytag)
|
|
{
|
|
stytag.onload=runcallbacks;
|
|
stytag.onerror=runcallbacks;
|
|
setTimeout(runcallbacks,3000);
|
|
}
|
|
else
|
|
{
|
|
setTimeout(runcallbacks,100);
|
|
}
|
|
stytag.setAttribute("type","text/css");
|
|
stytag.setAttribute("rel","stylesheet");
|
|
stytag.setAttribute("href",url);
|
|
csscontainer.appendChild(stytag);
|
|
}
|
|
|
|
window.CreateRTELoader=function(config)
|
|
{
|
|
var loader={};
|
|
|
|
loader._config=config;
|
|
config._debugmode=_debugmode;
|
|
|
|
var folder=config.folder;
|
|
if(folder.indexOf("://")==-1&&folder.charAt(0)!="/")
|
|
{
|
|
var url=window.location.href.split('#')[0].split('?')[0].split('/');
|
|
url[url.length-1]=folder;
|
|
url.splice(0,3);
|
|
config.folder=folder="/"+url.join('/');
|
|
}
|
|
|
|
config.initdate=new Date();
|
|
config._urlsuffix=urlsuffix;
|
|
loader._html5=!!document.createElement("canvas").getContext;
|
|
|
|
config.configjsurl=config.folder+"scripts/config.js?"+config._urlsuffix;
|
|
config.rtecssurl=config.folder+"styles/richtexteditor.css?"+config._urlsuffix;
|
|
config.jsmljsurl=config.folder+"core/jsml.js?"+config._urlsuffix;
|
|
config.commonxmlurl=config.folder+"scripts/common.xml?"+config._urlsuffix;
|
|
config.editorjsurl=config.folder+"scripts/editor.js?"+config._urlsuffix;
|
|
config.corejsurl=config.folder+"core/core.js?"+config._urlsuffix;
|
|
|
|
var langs=[];
|
|
|
|
function runlangcode(lang,code)
|
|
{
|
|
var func=new Function("lang,__code","eval(__code)");
|
|
if(!lang._data)lang._data={};
|
|
func(lang._data,code);
|
|
}
|
|
function asyncloadlangindex(index)
|
|
{
|
|
var lang=langs[index];
|
|
if(!lang)return;
|
|
if(lang.loading)return;
|
|
lang.loading=true;
|
|
function runcode(code)
|
|
{
|
|
runlangcode(lang,code);
|
|
}
|
|
function nextstep(err)
|
|
{
|
|
lang.loading=false;
|
|
lang.loaded=true;
|
|
if(index>0)asyncloadlangindex(index+1);
|
|
}
|
|
if(!lang.loaded)
|
|
{
|
|
asyncloadscript(lang.langurl,nextstep,runcode)
|
|
}
|
|
else
|
|
{
|
|
nextstep();
|
|
}
|
|
}
|
|
function syncloadlang(lang)
|
|
{
|
|
var xh=createxh();
|
|
xh.open("GET",lang.langurl,false);
|
|
xh.send("");
|
|
if(xh.status!=200)return;
|
|
runlangcode(lang,xh.responseText);
|
|
}
|
|
|
|
loader.getLangKeys=function(urlfilter)
|
|
{
|
|
var map={}
|
|
var arr=[];
|
|
for(var i=0;i<langs.length;i++)
|
|
{
|
|
var lang=langs[i];
|
|
if(urlfilter&&!urlfilter(lang.langurl))
|
|
continue;
|
|
var dict=lang._data;
|
|
if(!dict)
|
|
{
|
|
syncloadlang(lang);
|
|
dict=lang._data;
|
|
}
|
|
if(!dict)continue;
|
|
for(var key in dict)
|
|
{
|
|
if(map[key])continue;
|
|
map[key]=true;
|
|
arr.push(key);
|
|
}
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
loader.getLangText=function(name,nullifnotfound)
|
|
{
|
|
var showWarning=_showLangWarning;
|
|
if(!name)return nullifnotfound?null:"{empty}";
|
|
|
|
name=name.toLowerCase().replace(/(^\s+|\s+$)/g,"");
|
|
for(var i=0;i<langs.length;i++)
|
|
{
|
|
var lang=langs[i];
|
|
var dict=lang._data;
|
|
if(!dict)
|
|
{
|
|
if(showWarning)
|
|
{
|
|
showWarning=false;
|
|
setTimeout(function()
|
|
{
|
|
throw(new Error("Warning,sync load "+lang.langurl+" for text {"+name+"}"));
|
|
},1);
|
|
}
|
|
syncloadlang(lang);
|
|
dict=lang._data;
|
|
}
|
|
if(!dict)continue;
|
|
var text=dict[name];
|
|
if(!text)continue;
|
|
if(text.indexOf("{")!=-1&&text.indexOf("}")!=-1)
|
|
{
|
|
for(var i=1;i<arguments.length;i++)
|
|
{
|
|
text=text.split("{"+(i-1)+"}").join(arguments[i]);
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
|
|
if(nullifnotfound)
|
|
return null;
|
|
|
|
if(config._debugmode)
|
|
return "{"+name+"}";
|
|
return name;
|
|
}
|
|
|
|
|
|
function translate_lang(val)
|
|
{
|
|
if(val.indexOf("|")==-1)
|
|
return loader.getLangText(val.substring(1));
|
|
var pairs=val.split("|");
|
|
for(var i=0;i<pairs.length;i++)
|
|
{
|
|
val=pairs[i];
|
|
if(val.charAt(0)=="@")
|
|
{
|
|
if(val.length==1)
|
|
pairs[i]="";
|
|
else
|
|
pairs[i]=loader.getLangText(val.substring(1));
|
|
}
|
|
}
|
|
return pairs.join("");
|
|
}
|
|
|
|
loader.translateText=function(text)
|
|
{
|
|
if(!text)return "";
|
|
if(text.charAt(0)=="@")
|
|
return translate_lang(text);
|
|
return text;
|
|
}
|
|
|
|
|
|
function _loadmain()
|
|
{
|
|
if(loader._loadcalled)return;
|
|
loader._loadcalled=true;
|
|
|
|
trace("_loadmain");
|
|
|
|
loader.preloadScripts();
|
|
|
|
function nextstep(err)
|
|
{
|
|
if(err)
|
|
{
|
|
alert("Unable to load config.js \r\n"+err);
|
|
}
|
|
else
|
|
{
|
|
_configready()
|
|
}
|
|
};
|
|
if(config.baseconfig||window.RTE_Configuration)
|
|
_configready();
|
|
else
|
|
asyncloadscript(config.configjsurl,nextstep)
|
|
}
|
|
|
|
function onstyleload()
|
|
{
|
|
loader._stylestep++;
|
|
|
|
trace("onstyleload "+loader._stylestep+","+onstyleload.caller);
|
|
|
|
if(loader._stylestep!=3)
|
|
return;
|
|
|
|
_loadeditorui();
|
|
}
|
|
|
|
function _configready()
|
|
{
|
|
trace("configready");
|
|
|
|
var baseconfig=config.baseconfig||window.RTE_Configuration;
|
|
|
|
if(baseconfig)
|
|
{
|
|
for(var p in baseconfig)
|
|
{
|
|
if(!config.hasOwnProperty(p))
|
|
config[p]=baseconfig[p];
|
|
}
|
|
}
|
|
|
|
var skin=config.skin.toLowerCase();
|
|
|
|
switch(skin)
|
|
{
|
|
case "office2007blue":
|
|
skin="office2007-blue";
|
|
break;
|
|
case "office2007silver":
|
|
skin="office2007-silver";
|
|
break;
|
|
case "office2007silver2":
|
|
skin="office2007-silver2";
|
|
break;
|
|
case "office2010blue":
|
|
skin="office2010-blue";
|
|
break;
|
|
case "office2010blue2":
|
|
skin="office2010-blue2";
|
|
break;
|
|
case "office2010silver2":
|
|
skin="office2010-silver2";
|
|
break;
|
|
case "office2010silver":
|
|
skin="office2010-silver";
|
|
break;
|
|
case "office2010black":
|
|
skin="office2010-black";
|
|
break;
|
|
case "office2003blue":
|
|
skin="office2003-blue";
|
|
break;
|
|
case "office2003silver":
|
|
skin="office2003-silver";
|
|
break;
|
|
case "office2003silver2":
|
|
skin = "office2003-silver2";
|
|
break;
|
|
case "officexpblue":
|
|
skin="officexp-blue";
|
|
break;
|
|
case "officexpsilver":
|
|
skin="officexp-silver";
|
|
break;
|
|
case "smartblue":
|
|
skin="smart-blue";
|
|
break;
|
|
case "smartsilver":
|
|
skin="smart-silver";
|
|
break;
|
|
case "smartgray":
|
|
skin="smart-gray";
|
|
break;
|
|
case "phonesilver":
|
|
skin = "phone-lightsilver";
|
|
break;
|
|
}
|
|
|
|
if(/Android|iPhone|iPad|iPod/i.test(navigator.userAgent))
|
|
{
|
|
skin = "phone-lightsilver";
|
|
}
|
|
|
|
var skinpair=skin.split('-');
|
|
if(skinpair.length>1)
|
|
{
|
|
config.skin=skinpair[0];
|
|
config.color=skinpair[1];
|
|
}
|
|
else
|
|
{
|
|
//invalid toolbar set!
|
|
}
|
|
|
|
if(config.toolbaritems||config.toolbar!="custom")
|
|
{
|
|
config._toolbartemplate="template";
|
|
}
|
|
|
|
if(config.skin=="phone"||config.skin=="pad")
|
|
{
|
|
config.ismobileversion=true;
|
|
}
|
|
|
|
if(!config.containerid)
|
|
{
|
|
alert("Fail to load editor because the ID is not set.");
|
|
return;
|
|
}
|
|
|
|
config.editorelement=document.getElementById(config.containerid);
|
|
config.skin_div=config.editorelement;
|
|
config.skin_div_holder=config.skin_div;
|
|
config.skin_div_parent=config.skin_div.parentNode;
|
|
config.skin_divborder=config.skin_div.style.border;
|
|
config.skin_div.style.border="solid 1px #eeeeee";
|
|
|
|
config.skin_div.innerHTML="<table style='width:100%;height:100%;'><tr>"
|
|
+"<td style='vertical-align:center;text-align:center;'>"
|
|
+"<img src='"+config.folder+"images/"+config.loader_loadingimage+"'/></td></tr></table>";
|
|
|
|
|
|
if(config.langfiles)
|
|
{
|
|
var langarr=config.langfiles.split(',');
|
|
for(var i=0;i<langarr.length;i++)
|
|
{
|
|
langs.push({langfile:langarr[i],langurl:config.folder+"lang/"+langarr[i]+".js?"+config._urlsuffix});
|
|
}
|
|
asyncloadlangindex(0);
|
|
}
|
|
|
|
config.blankfileurl=config.folder+"scripts/blank"+(config.designdoctype||"")+".htm?"+config._urlsuffix;
|
|
|
|
|
|
if(!window.localStorage&&ismsie)
|
|
{
|
|
config.userDataBehavior=document.createElement("textarea");
|
|
config.userDataBehavior.style.cssText="behavior:url('#default#userData');display:none;position:absolute;width:0px;height:0px;"
|
|
document.body.insertBefore(config.userDataBehavior,document.body.firstChild);
|
|
}
|
|
else
|
|
{
|
|
config.localStorage=window.localStorage;
|
|
}
|
|
|
|
config.skincssurl=config.folder+"skins/"+config.skin+"/skin.css?"+config._urlsuffix;
|
|
config.skinxmlurl=config.folder+"skins/"+(config.skin)+"/skin.xml?"+config._urlsuffix;
|
|
|
|
//preload
|
|
asyncloadtext(config.skinxmlurl);
|
|
|
|
loader._stylestep=0;
|
|
asyncloadstyle(config.rtecssurl,onstyleload);
|
|
asyncloadstyle(config.skincssurl,onstyleload);
|
|
|
|
setTimeout(function()
|
|
{
|
|
_loadjsml();
|
|
},config.loader_loadcodedelay||1);
|
|
}
|
|
|
|
function _loadjsml()
|
|
{
|
|
trace("_loadjsml");
|
|
|
|
function nextstep()
|
|
{
|
|
jsml.jsmlfolder=config.folder+"core"
|
|
jsml.default_textbox_bordercolor="#eeeeee";
|
|
if(config.ismobileversion)
|
|
jsml.mobile=true;
|
|
jsml.enableieborderradius=config.enableieborderradius;
|
|
_loadicache();
|
|
};
|
|
|
|
if(window.jsml)
|
|
nextstep();
|
|
else
|
|
asyncloadscript(config.jsmljsurl,nextstep)
|
|
}
|
|
function _loadicache()
|
|
{
|
|
if(!loader._html5||!config.useimagedatacache)
|
|
{
|
|
_loadcommonxml();
|
|
return;
|
|
}
|
|
|
|
function nextstep(err)
|
|
{
|
|
if(!err)config._rte_image_cache=window._rte_image_cache;
|
|
_loadcommonxml();
|
|
};
|
|
if(config._rte_image_cache)
|
|
nextstep();
|
|
else
|
|
asyncloadscript(config.folder+"scripts/ihtml5.js?"+config._urlsuffix,nextstep)
|
|
}
|
|
|
|
function translate_value(val)
|
|
{
|
|
if(val.charAt(0)=="@")
|
|
return translate_lang(val);
|
|
if(val.indexOf('}')==-1)
|
|
return val;
|
|
val=val.split('{skin}').join(config.skin);
|
|
val=val.split('{color}').join(config.color);
|
|
val=val.split('{folder}').join(config.folder);
|
|
val=val.split('{toolbar}').join(config._toolbartemplate||config.toolbar);
|
|
val=val.split('{timems}').join(config._debugmode?new Date().getTime():config._urlsuffix);
|
|
return val;
|
|
}
|
|
|
|
function _load_jsml_xml(url,callback)
|
|
{
|
|
asyncloadtext(url,function(text,xml)
|
|
{
|
|
try
|
|
{
|
|
jsml.parse_xmldoc(xml,null,null,null,translate_value);
|
|
}
|
|
catch(x)
|
|
{
|
|
alert("Unable to parse "+url+" , "+x.message);
|
|
return;
|
|
}
|
|
setTimeout(callback,12);
|
|
});
|
|
}
|
|
|
|
function _loadcommonxml()
|
|
{
|
|
trace("_loadcommonxml");
|
|
|
|
if(jsml.rtecommonlibraryloaded)
|
|
{
|
|
_loadskinxml();
|
|
return;
|
|
}
|
|
|
|
_load_jsml_xml(config.commonxmlurl,function()
|
|
{
|
|
_loadskinxml();
|
|
});
|
|
}
|
|
function _loadskinxml()
|
|
{
|
|
trace("_loadskinxml");
|
|
|
|
config.skinxmlclass="rteskin_"+(config.skin)+"_"+config.color;
|
|
if(jsml.class_exists(config.skinxmlclass))
|
|
{
|
|
onstyleload();
|
|
return;
|
|
}
|
|
|
|
_load_jsml_xml(config.skinxmlurl,onstyleload);
|
|
}
|
|
|
|
function _loadeditorui()
|
|
{
|
|
trace("_loadeditorui");
|
|
|
|
try
|
|
{
|
|
config.skin_div.style.border=config.skin_divborder;
|
|
config.skin_div.innerHTML="";
|
|
jsml.suppend_layout();
|
|
config.skin_control=jsml.class_create_instance(config.skinxmlclass);
|
|
config.skin_control._rteconfig=config;
|
|
config.skin_container=config.skin_control.editor_frame_container;
|
|
var width=config.skin_div.clientWidth||parseInt(config.skin_div.style.width)||760;
|
|
var height=config.skin_div.clientHeight||parseInt(config.skin_div.style.height)||480;
|
|
config.skin_control.set_width(width);
|
|
config.skin_control.set_height(height);
|
|
config.skin_control.set_parent(config.skin_div);
|
|
jsml.resume_layout();
|
|
}
|
|
catch(x)
|
|
{
|
|
alert("Unable to initialize the UI , "+x.message);
|
|
}
|
|
|
|
setTimeout(function()
|
|
{
|
|
try
|
|
{
|
|
_loadframe();
|
|
}
|
|
catch(x)
|
|
{
|
|
alert("Unable to initialize the IFrame , "+x.message);
|
|
}
|
|
},1);
|
|
}
|
|
|
|
|
|
function _loadframe()
|
|
{
|
|
trace("_loadframe");
|
|
|
|
var frame=document.createElement("IFRAME");
|
|
config.skin_frame=frame;
|
|
function handle_resize()
|
|
{
|
|
frame.style.width=Math.max(0,config.skin_container.get_client_width()-0)+"px";
|
|
frame.style.height=Math.max(0,config.skin_container.get_client_height()-0)+"px";
|
|
}
|
|
var frameurl=config.blankfileurl;
|
|
var frameloaded=false;
|
|
function frameonload()
|
|
{
|
|
frameloaded=true;
|
|
frame.onload=new Function();
|
|
|
|
if(config.designtimeblankhtml)
|
|
{
|
|
_loadscript();
|
|
return;
|
|
}
|
|
|
|
var url=frameurl;
|
|
var xh=jsml.xmlhttp();
|
|
xh.onreadystatechange=function()
|
|
{
|
|
if(xh.readyState<4)return;
|
|
xh.onreadystatechange=new Function();
|
|
if(xh.status==0)return;
|
|
if(xh.status!=200)
|
|
{
|
|
if(xh.status!=0)
|
|
alert("Unable to load "+url+" , http"+xh.status);
|
|
return;
|
|
}
|
|
|
|
config.designtimeblankhtml=xh.responseText;
|
|
_loadscript();
|
|
};
|
|
xh.open("GET",url,true);
|
|
xh.send("");
|
|
};
|
|
//frame.onload=frameonload;
|
|
frame.frameBorder=0;
|
|
frame.setAttribute("src",frameurl);
|
|
config.skin_container._content.appendChild(frame);
|
|
config.skin_container.attach_event("resize",handle_resize);
|
|
handle_resize();
|
|
|
|
//some browsers has trouble on frame.onload
|
|
function checkframeload()
|
|
{
|
|
if(frameloaded)return;
|
|
var win=frame.contentWindow;
|
|
//if(win&&win.document&&win.document.readyState=="complete")
|
|
// return frameonload();
|
|
if(win&&win.document&&win.document.body)
|
|
return frameonload();
|
|
setTimeout(checkframeload,10);
|
|
|
|
}
|
|
setTimeout(checkframeload,10);
|
|
}
|
|
|
|
function _loadscript()
|
|
{
|
|
trace("_loadscript");
|
|
|
|
function editorjsready()
|
|
{
|
|
try
|
|
{
|
|
_loadeditor()
|
|
}
|
|
catch(x)
|
|
{
|
|
alert("Unable to initialize the Editor class , "+x.message);
|
|
}
|
|
};
|
|
|
|
if($rte.Editor)
|
|
{
|
|
editorjsready();
|
|
return;
|
|
}
|
|
|
|
function corejsready()
|
|
{
|
|
asyncloadscript(config.editorjsurl,editorjsready);
|
|
if(loader.oncoreload)
|
|
{
|
|
loader.oncoreload(loader);
|
|
}
|
|
if(window.RichTextEditor_OnCoreLoad)
|
|
{
|
|
window.RichTextEditor_OnCoreLoad(loader);
|
|
}
|
|
};
|
|
|
|
if($rte.Core)
|
|
{
|
|
corejsready();
|
|
return;
|
|
}
|
|
|
|
asyncloadscript(config.corejsurl,corejsready);
|
|
}
|
|
|
|
function _loadeditor()
|
|
{
|
|
trace("_loadeditor");
|
|
|
|
var frame=config.skin_frame;
|
|
var editor=new $rte.Editor(config,frame,frame.contentWindow,loader);
|
|
config.skin_control._rteinstance=editor;
|
|
config.skin_control.invoke_recursive("editor_ready",editor);
|
|
//config.skin_div.onclick=editor.delegate(editor.Focus);
|
|
|
|
var timerid;
|
|
function disposeeditor()
|
|
{
|
|
window.clearInterval(timerid);
|
|
jsml.dom_detach_event(window,"unload",windowunload);
|
|
editor.Dispose();
|
|
}
|
|
function windowunload()
|
|
{
|
|
disposeeditor()
|
|
jsml.disposeall();
|
|
}
|
|
|
|
timerid=window.setInterval(function()
|
|
{
|
|
for(var n=config.skin_div;n;n=n.parentNode)
|
|
if(n.nodeName=="BODY")
|
|
return;
|
|
disposeeditor()
|
|
},200);
|
|
|
|
jsml.dom_attach_event(window,"unload",windowunload);
|
|
|
|
asyncloadlangindex(1);
|
|
if(config.preloadplugins)
|
|
{
|
|
var arr=config.preloadplugins.split(',');
|
|
for(var i=0;i<arr.length;i++)
|
|
editor.LoadPlugin(arr[i]);
|
|
}
|
|
|
|
|
|
if(config.autofocus)
|
|
{
|
|
setTimeout(function()
|
|
{
|
|
editor.Focus();
|
|
},222);
|
|
}
|
|
|
|
if(config.initialtabmode)
|
|
editor.ExecUICommand(null,"tab"+config.initialtabmode);
|
|
if(!config.initialtoggleborder)
|
|
editor.ExecUICommand(null,"ToggleBorder");
|
|
|
|
|
|
if(config.initialfullscreen)
|
|
{
|
|
setTimeout(function()
|
|
{
|
|
editor.ExecUICommand(null,"FullScreen");
|
|
editor.Focus();
|
|
},55);
|
|
}
|
|
}
|
|
|
|
loader.asyncloadscript=asyncloadscript;
|
|
|
|
loader.translate_value=translate_value;
|
|
|
|
loader.load=function()
|
|
{
|
|
_loadmain();
|
|
}
|
|
loader.startLoadTimer=function(timeout)
|
|
{
|
|
clearTimeout(loader._loadtimerid);
|
|
loader._loadtimerid=setTimeout(_loadmain,timeout);
|
|
}
|
|
loader.cancelLoadTimer=function()
|
|
{
|
|
clearTimeout(loader._loadtimerid);
|
|
}
|
|
|
|
loader.preloadScripts=function()
|
|
{
|
|
asyncloadtext(config.configjsurl);
|
|
asyncloadtext(config.rtecssurl);
|
|
asyncloadtext(config.jsmljsurl);
|
|
asyncloadtext(config.commonxmlurl);
|
|
asyncloadtext(config.corejsurl);
|
|
asyncloadtext(config.editorjsurl);
|
|
}
|
|
|
|
if(window.RichTextEditor_OnLoader)
|
|
window.RichTextEditor_OnLoader(loader);
|
|
|
|
return loader;
|
|
|
|
}
|
|
}
|
|
|