Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dijit.Editor"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dijit.Editor"] = true;

dojo.provide("dijit.Editor");

dojo.require("dijit._editor.RichText");

dojo.require("dijit.Toolbar");

dojo.require("dijit._editor._Plugin");

dojo.require("dijit._Container");

dojo.require("dojo.i18n");

dojo.requireLocalization("dijit._editor", "commands", null, "ko,zh,ja,zh-tw,ru,it,hu,fr,pt,pl,es,ROOT,de,cs");

dojo.declare(

	"dijit.Editor",

	dijit._editor.RichText,

	{

	// summary: A rich-text Editing widget

		// plugins: Array

		//		a list of plugin names (as strings) or instances (as objects)

		//		for this widget.

		plugins: null,

		// extraPlugins: Array

		//		a list of extra plugin names which will be appended to plugins array

		extraPlugins: null,

		constructor: function(){

			this.plugins=["undo","redo","|","cut","copy","paste","|","bold","italic","underline","strikethrough","|",

			"insertOrderedList","insertUnorderedList","indent","outdent","|","justifyLeft","justifyRight","justifyCenter","justifyFull"/*"createLink"*/];

			this._plugins=[];

			this._editInterval = this.editActionInterval * 1000;

		},

		postCreate: function(){

			//for custom undo/redo

			if(this.customUndo){

				dojo['require']("dijit._editor.range");

				this._steps=this._steps.slice(0);

				this._undoedSteps=this._undoedSteps.slice(0);

//				this.addKeyHandler('z',this.KEY_CTRL,this.undo);

//				this.addKeyHandler('y',this.KEY_CTRL,this.redo);

			}

			if(dojo.isArray(this.extraPlugins)){

				this.plugins=this.plugins.concat(this.extraPlugins);

			}

//			try{

			dijit.Editor.superclass.postCreate.apply(this, arguments);

			this.commands = dojo.i18n.getLocalization("dijit._editor", "commands", this.lang);

			if(!this.toolbar){

				// if we haven't been assigned a toolbar, create one

				var toolbarNode = dojo.doc.createElement("div");

				dojo.place(toolbarNode, this.editingArea, "before");

				this.toolbar = new dijit.Toolbar({}, toolbarNode);

			}

			dojo.forEach(this.plugins, this.addPlugin, this);

			this.onNormalizedDisplayChanged(); //update toolbar button status

//			}catch(e){ console.debug(e); }

		},

		destroy: function(){

			dojo.forEach(this._plugins, function(p){

				if(p.destroy){

					p.destroy();

				}

			});

			this._plugins=[];

			this.toolbar.destroy(); delete this.toolbar;

			this.inherited('destroy',arguments);

		},

		addPlugin: function(/*String||Object*/plugin, /*Integer?*/index){

			//	summary:

			//		takes a plugin name as a string or a plugin instance and

			//		adds it to the toolbar and associates it with this editor

			//		instance. The resulting plugin is added to the Editor's

			//		plugins array. If index is passed, it's placed in the plugins

			//		array at that index. No big magic, but a nice helper for

			//		passing in plugin names via markup.

			//	plugin: String, args object or plugin instance. Required.

			//	args: This object will be passed to the plugin constructor.

			//	index:

			//		Integer, optional. Used when creating an instance from

			//		something already in this.plugins. Ensures that the new

			//		instance is assigned to this.plugins at that index.

			var args=dojo.isString(plugin)?{name:plugin}:plugin;

			if(!args.setEditor){

				var o={"args":args,"plugin":null,"editor":this};

				dojo.publish("dijit.Editor.getPlugin",[o]);

				if(!o.plugin){

					var pc = dojo.getObject(args.name);

					if(pc){

						o.plugin=new pc(args);

					}

				}

				if(!o.plugin){

					console.debug('Cannot find plugin',plugin);

					return;

				}

				plugin=o.plugin;

			}

			if(arguments.length > 1){

				this._plugins[index] = plugin;

			}else{

				this._plugins.push(plugin);

			}

			plugin.setEditor(this);

			if(dojo.isFunction(plugin.setToolbar)){

				plugin.setToolbar(this.toolbar);

			}

		},

		/* beginning of custom undo/redo support */

		// customUndo: Boolean

		//		Whether we shall use custom undo/redo support instead of the native

		//		browser support. By default, we only enable customUndo for IE, as it

		//		has broken native undo/redo support. Note: the implementation does

		//		support other browsers which have W3C DOM2 Range API.

		customUndo: dojo.isIE,

		//	editActionInterval: Integer

		//		When using customUndo, not every keystroke will be saved as a step.

		//		Instead typing (including delete) will be grouped together: after

		//		a user stop typing for editActionInterval seconds, a step will be

		//		saved; if a user resume typing within editActionInterval seconds,

		//		the timeout will be restarted. By default, editActionInterval is 3

		//		seconds.

		editActionInterval: 3,

		beginEditing: function(cmd){

			if(!this._inEditing){

				this._inEditing=true;

				this._beginEditing(cmd);

			}

			if(this.editActionInterval>0){

				if(this._editTimer){

					clearTimeout(this._editTimer);

				}

				this._editTimer = setTimeout(dojo.hitch(this, this.endEditing), this._editInterval);

			}

		},

		_steps:[],

		_undoedSteps:[],

		execCommand: function(cmd){

			if(this.customUndo && (cmd=='undo' || cmd=='redo')){

				return this[cmd]();

			}else{

				try{

					if(this.customUndo){

						this.endEditing();

						this._beginEditing();

					}

					var r = this.inherited('execCommand',arguments);

					if(this.customUndo){

						this._endEditing();

					}

					return r;

				}catch(e){

					if(dojo.isMoz && /copy|cut|paste/.test(cmd)){

						// Warn user of platform limitation.  Cannot programmatically access keyboard. See ticket #4136

						var sub = dojo.string.substitute,

							accel = {cut:'X', copy:'C', paste:'V'},

							isMac = navigator.userAgent.indexOf("Macintosh") != -1;

						alert(sub(this.commands.systemShortcutFF,

							[this.commands[cmd], sub(this.commands[isMac ? 'appleKey' : 'ctrlKey'], [accel[cmd]])]));

					}

					return false;

				}

			}

		},

		queryCommandEnabled: function(cmd){

			if(this.customUndo && (cmd=='undo' || cmd=='redo')){

				return cmd=='undo'?(this._steps.length>1):(this._undoedSteps.length>0);

			}else{

				return this.inherited('queryCommandEnabled',arguments);

			}

		},

		_changeToStep: function(from,to){

			this.setValue(to.text);

			var b=to.bookmark;

			if(!b){ return; }

			if(dojo.isIE){

				if(dojo.isArray(b)){//IE CONTROL

					var tmp=[];

					dojo.forEach(b,function(n){

						tmp.push(dijit.range.getNode(n,this.editNode));

					},this);

					b=tmp;

				}

			}else{//w3c range

				var r=dijit.range.create();

				r.setStart(dijit.range.getNode(b.startContainer,this.editNode),b.startOffset);

				r.setEnd(dijit.range.getNode(b.endContainer,this.editNode),b.endOffset);

				b=r;

			}

			dojo.withGlobal(this.window,'moveToBookmark',dijit,[b]);

		},

		undo: function(){

//			console.log('undo');

			this.endEditing(true);

			var s=this._steps.pop();

			if(this._steps.length>0){

				this.focus();

				this._changeToStep(s,this._steps[this._steps.length-1]);

				this._undoedSteps.push(s);

				this.onDisplayChanged();

				return true;

			}

			return false;

		},

		redo: function(){

//			console.log('redo');

			this.endEditing(true);

			var s=this._undoedSteps.pop();

			if(s && this._steps.length>0){

				this.focus();

				this._changeToStep(this._steps[this._steps.length-1],s);

				this._steps.push(s);

				this.onDisplayChanged();

				return true;

			}

			return false;

		},

		endEditing: function(ignore_caret){

			if(this._editTimer){

				clearTimeout(this._editTimer);

			}

			if(this._inEditing){

				this._endEditing(ignore_caret);

				this._inEditing=false;

			}

		},

		_getBookmark: function(){

			var b=dojo.withGlobal(this.window,dijit.getBookmark);

			if(dojo.isIE){

				if(dojo.isArray(b)){//CONTROL

					var tmp=[];

					dojo.forEach(b,function(n){

						tmp.push(dijit.range.getIndex(n,this.editNode).o);

					},this);

					b=tmp;

				}

			}else{//w3c range

				var tmp=dijit.range.getIndex(b.startContainer,this.editNode).o

				b={startContainer:tmp,

					startOffset:b.startOffset,

					endContainer:b.endContainer===b.startContainer?tmp:dijit.range.getIndex(b.endContainer,this.editNode).o,

					endOffset:b.endOffset};

			}

			return b;

		},

		_beginEditing: function(cmd){

			if(this._steps.length===0){

				this._steps.push({'text':this.savedContent,'bookmark':this._getBookmark()});

			}

		},

		_endEditing: function(ignore_caret){

			var v=this.getValue(true);

			this._undoedSteps=[];//clear undoed steps

			this._steps.push({'text':v,'bookmark':this._getBookmark()});

		},

		onKeyDown: function(e){

			if(!this.customUndo){

				this.inherited('onKeyDown',arguments);

				return;

			}

			var k=e.keyCode,ks=dojo.keys;

			if(e.ctrlKey){

				if(k===90||k===122){ //z

					dojo.stopEvent(e);

					this.undo();

					return;

				}else if(k===89||k===121){ //y

					dojo.stopEvent(e);

					this.redo();

					return;

				}

			}

			this.inherited('onKeyDown',arguments);

			switch(k){

					case ks.ENTER:

						this.beginEditing();

						break;

					case ks.BACKSPACE:

					case ks.DELETE:

						this.beginEditing();

						break;

					case 88: //x

					case 86: //v

						if(e.ctrlKey && !e.altKey && !e.metaKey){

							this.endEditing();//end current typing step if any

							if(e.keyCode == 88){

								this.beginEditing('cut');

								//use timeout to trigger after the cut is complete

								setTimeout(dojo.hitch(this, this.endEditing), 1);

							}else{

								this.beginEditing('paste');

								//use timeout to trigger after the paste is complete

								setTimeout(dojo.hitch(this, this.endEditing), 1);

							}

							break;

						}

						//pass through

					default:

						if(!e.ctrlKey && !e.altKey && !e.metaKey && (e.keyCode<dojo.keys.F1 || e.keyCode>dojo.keys.F15)){

							this.beginEditing();

							break;

						}

						//pass through

					case ks.ALT:

						this.endEditing();

						break;

					case ks.UP_ARROW:

					case ks.DOWN_ARROW:

					case ks.LEFT_ARROW:

					case ks.RIGHT_ARROW:

					case ks.HOME:

					case ks.END:

					case ks.PAGE_UP:

					case ks.PAGE_DOWN:

						this.endEditing(true);

						break;

					//maybe ctrl+backspace/delete, so don't endEditing when ctrl is pressed

					case ks.CTRL:

					case ks.SHIFT:

					case ks.TAB:

						break;

				}

		},

		_onBlur: function(){

			this.inherited('_onBlur',arguments);

			this.endEditing(true);

		},

		onClick: function(){

			this.endEditing(true);

			this.inherited('onClick',arguments);

		}

		/* end of custom undo/redo support */

	}

);

/* the following code is to registered a handler to get default plugins */

dojo.subscribe("dijit.Editor.getPlugin",null,function(o){

	if(o.plugin){ return; }

	var args=o.args, p;

	var _p = dijit._editor._Plugin;

	var name=args.name;

	switch(name){

		case "undo": case "redo": case "cut": case "copy": case "paste": case "insertOrderedList":

		case "insertUnorderedList": case "indent": case "outdent": case "justifyCenter":

		case "justifyFull": case "justifyLeft": case "justifyRight": case "delete":

		case "selectAll": case "removeFormat":

			p = new _p({ command: name });

			break;

		case "bold": case "italic": case "underline": case "strikethrough":

		case "subscript": case "superscript":

			p = new _p({ buttonClass: dijit.form.ToggleButton, command: name });

			break;

		case "|":

			p = new _p({ button: new dijit.ToolbarSeparator() });

			break;

		case "createLink":

//					dojo['require']('dijit._editor.plugins.LinkDialog');

			p = new dijit._editor.plugins.LinkDialog({ command: name });

			break;

		case "foreColor": case "hiliteColor":

			p = new dijit._editor.plugins.TextColor({ command: name });

			break;

		case "fontName": case "fontSize": case "formatBlock":

			p = new dijit._editor.plugins.FontChoice({ command: name });

	}

//	console.log('name',name,p);

	o.plugin=p;

});

}