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;
			});

}