dijit-rails 0.9.0 → 0.10.0

data/vendor/assets/javascripts/dijit/Editor.js.uncompressed.js

@@ -0,0 +1,864 @@
+define("dijit/Editor", [
+	"dojo/_base/array", // array.forEach
+	"dojo/_base/declare", // declare
+	"dojo/_base/Deferred", // Deferred
+	"dojo/i18n", // i18n.getLocalization
+	"dojo/dom-attr", // domAttr.set
+	"dojo/dom-class", // domClass.add
+	"dojo/dom-geometry",
+	"dojo/dom-style", // domStyle.set, get
+	"dojo/_base/event", // event.stop
+	"dojo/keys", // keys.F1 keys.F15 keys.TAB
+	"dojo/_base/lang", // lang.getObject lang.hitch
+	"dojo/sniff", // has("ie") has("mac") has("webkit")
+	"dojo/string", // string.substitute
+	"dojo/topic", // topic.publish()
+	"dojo/_base/window", // win.withGlobal
+	"./_base/focus",	// dijit.getBookmark()
+	"./_Container",
+	"./Toolbar",
+	"./ToolbarSeparator",
+	"./layout/_LayoutWidget",
+	"./form/ToggleButton",
+	"./_editor/_Plugin",
+	"./_editor/plugins/EnterKeyHandling",
+	"./_editor/html",
+	"./_editor/range",
+	"./_editor/RichText",
+	"./main",	// dijit._scopeName
+	"dojo/i18n!./_editor/nls/commands"
+], function(array, declare, Deferred, i18n, domAttr, domClass, domGeometry, domStyle,
+			event, keys, lang, has, string, topic, win,
+			focusBase, _Container, Toolbar, ToolbarSeparator, _LayoutWidget, ToggleButton,
+			_Plugin, EnterKeyHandling, html, rangeapi, RichText, dijit){
+
+	// module:
+	//		dijit/Editor
+
+	var Editor = declare("dijit.Editor", RichText, {
+		// summary:
+		//		A rich text Editing widget
+		//
+		// description:
+		//		This widget provides basic WYSIWYG editing features, based on the browser's
+		//		underlying rich text editing capability, accompanied by a toolbar (`dijit.Toolbar`).
+		//		A plugin model is available to extend the editor's capabilities as well as the
+		//		the options available in the toolbar.  Content generation may vary across
+		//		browsers, and clipboard operations may have different results, to name
+		//		a few limitations.  Note: this widget should not be used with the HTML
+		//		<TEXTAREA> tag -- see dijit/_editor/RichText for details.
+
+		// plugins: [const] Object[]
+		//		A list of plugin names (as strings) or instances (as objects)
+		//		for this widget.
+		//
+		//		When declared in markup, it might look like:
+		//	|	plugins="['bold',{name:'dijit._editor.plugins.FontChoice', command:'fontName', generic:true}]"
+		plugins: null,
+
+		// extraPlugins: [const] Object[]
+		//		A list of extra plugin names which will be appended to plugins array
+		extraPlugins: null,
+
+		constructor: function(/*===== params, srcNodeRef =====*/){
+			// summary:
+			//		Create the widget.
+			// params: Object|null
+			//		Initial settings for any of the attributes, except readonly attributes.
+			// srcNodeRef: DOMNode
+			//		The editor replaces the specified DOMNode.
+
+			if(!lang.isArray(this.plugins)){
+				this.plugins=["undo","redo","|","cut","copy","paste","|","bold","italic","underline","strikethrough","|",
+				"insertOrderedList","insertUnorderedList","indent","outdent","|","justifyLeft","justifyRight","justifyCenter","justifyFull",
+				EnterKeyHandling /*, "createLink"*/];
+			}
+
+			this._plugins=[];
+			this._editInterval = this.editActionInterval * 1000;
+
+			//IE will always lose focus when other element gets focus, while for FF and safari,
+			//when no iframe is used, focus will be lost whenever another element gets focus.
+			//For IE, we can connect to onBeforeDeactivate, which will be called right before
+			//the focus is lost, so we can obtain the selected range. For other browsers,
+			//no equivalent of onBeforeDeactivate, so we need to do two things to make sure
+			//selection is properly saved before focus is lost: 1) when user clicks another
+			//element in the page, in which case we listen to mousedown on the entire page and
+			//see whether user clicks out of a focus editor, if so, save selection (focus will
+			//only lost after onmousedown event is fired, so we can obtain correct caret pos.)
+			//2) when user tabs away from the editor, which is handled in onKeyDown below.
+			if(has("ie")){
+				this.events.push("onBeforeDeactivate");
+				this.events.push("onBeforeActivate");
+			}
+		},
+
+		postMixInProperties: function(){
+			// summary:
+			//	Extension to make sure a deferred is in place before certain functions
+			//	execute, like making sure all the plugins are properly inserted.
+
+			// Set up a deferred so that the value isn't applied to the editor
+			// until all the plugins load, needed to avoid timing condition
+			// reported in #10537.
+			this.setValueDeferred = new Deferred();
+			this.inherited(arguments);
+		},
+
+		postCreate: function(){
+			//for custom undo/redo, if enabled.
+			this._steps=this._steps.slice(0);
+			this._undoedSteps=this._undoedSteps.slice(0);
+
+			if(lang.isArray(this.extraPlugins)){
+				this.plugins=this.plugins.concat(this.extraPlugins);
+			}
+
+			this.inherited(arguments);
+
+			this.commands = i18n.getLocalization("dijit._editor", "commands", this.lang);
+
+			if(!this.toolbar){
+				// if we haven't been assigned a toolbar, create one
+				this.toolbar = new Toolbar({
+					ownerDocument: this.ownerDocument,
+					dir: this.dir,
+					lang: this.lang
+				});
+				this.header.appendChild(this.toolbar.domNode);
+			}
+
+			array.forEach(this.plugins, this.addPlugin, this);
+
+			// Okay, denote the value can now be set.
+			this.setValueDeferred.resolve(true);
+
+			domClass.add(this.iframe.parentNode, "dijitEditorIFrameContainer");
+			domClass.add(this.iframe, "dijitEditorIFrame");
+			domAttr.set(this.iframe, "allowTransparency", true);
+
+			if(has("webkit")){
+				// Disable selecting the entire editor by inadvertent double-clicks.
+				// on buttons, title bar, etc.  Otherwise clicking too fast on
+				// a button such as undo/redo selects the entire editor.
+				domStyle.set(this.domNode, "KhtmlUserSelect", "none");
+			}
+			this.toolbar.startup();
+			this.onNormalizedDisplayChanged(); //update toolbar button status
+		},
+		destroy: function(){
+			array.forEach(this._plugins, function(p){
+				if(p && p.destroy){
+					p.destroy();
+				}
+			});
+			this._plugins=[];
+			this.toolbar.destroyRecursive();
+			delete this.toolbar;
+			this.inherited(arguments);
+		},
+		addPlugin: function(/*String||Object||Function*/ 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, plugin instance, or plugin constructor
+			// args:
+			//		This object will be passed to the plugin constructor
+			// index:
+			//		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=lang.isString(plugin)?{name:plugin}:lang.isFunction(plugin)?{ctor:plugin}:plugin;
+			if(!args.setEditor){
+				var o={"args":args,"plugin":null,"editor":this};
+				if(args.name){
+					// search registry for a plugin factory matching args.name, if it's not there then
+					// fallback to 1.0 API:
+					// ask all loaded plugin modules to fill in o.plugin if they can (ie, if they implement args.name)
+					// remove fallback for 2.0.
+					if(_Plugin.registry[args.name]){
+						o.plugin = _Plugin.registry[args.name](args);
+					}else{
+						topic.publish(dijit._scopeName + ".Editor.getPlugin", o);	// publish
+					}
+				}
+				if(!o.plugin){
+					try{
+						// TODO: remove lang.getObject() call in 2.0
+						var pc = args.ctor || lang.getObject(args.name) || require(args.name);
+						if(pc){
+							o.plugin = new pc(args);
+						}
+					}catch(e){
+						throw new Error(this.id + ": cannot find plugin [" + args.name + "]");
+					}
+				}
+				if(!o.plugin){
+					throw new Error(this.id + ": cannot find plugin [" + args.name + "]");
+				}
+				plugin=o.plugin;
+			}
+			if(arguments.length > 1){
+				this._plugins[index] = plugin;
+			}else{
+				this._plugins.push(plugin);
+			}
+			plugin.setEditor(this);
+			if(lang.isFunction(plugin.setToolbar)){
+				plugin.setToolbar(this.toolbar);
+			}
+		},
+
+		//the following 2 functions are required to make the editor play nice under a layout widget, see #4070
+
+		resize: function(size){
+			// summary:
+			//		Resize the editor to the specified size, see `dijit/layout/_LayoutWidget.resize()`
+			if(size){
+				// we've been given a height/width for the entire editor (toolbar + contents), calls layout()
+				// to split the allocated size between the toolbar and the contents
+				_LayoutWidget.prototype.resize.apply(this, arguments);
+			}
+			/*
+			else{
+				// do nothing, the editor is already laid out correctly.   The user has probably specified
+				// the height parameter, which was used to set a size on the iframe
+			}
+			*/
+		},
+		layout: function(){
+			// summary:
+			//		Called from `dijit/layout/_LayoutWidget.resize()`.  This shouldn't be called directly
+			// tags:
+			//		protected
+
+			// Converts the iframe (or rather the <div> surrounding it) to take all the available space
+			// except what's needed for the header (toolbars) and footer (breadcrumbs, etc).
+			// A class was added to the iframe container and some themes style it, so we have to
+			// calc off the added margins and padding too. See tracker: #10662
+			var areaHeight = (this._contentBox.h -
+				(this.getHeaderHeight() + this.getFooterHeight() +
+				 domGeometry.getPadBorderExtents(this.iframe.parentNode).h +
+				 domGeometry.getMarginExtents(this.iframe.parentNode).h));
+			this.editingArea.style.height = areaHeight + "px";
+			if(this.iframe){
+				this.iframe.style.height="100%";
+			}
+			this._layoutMode = true;
+		},
+
+		_onIEMouseDown: function(/*Event*/ e){
+			// summary:
+			//		IE only to prevent 2 clicks to focus
+			// tags:
+			//		private
+			var outsideClientArea;
+			// IE 8's componentFromPoint is broken, which is a shame since it
+			// was smaller code, but oh well.  We have to do this brute force
+			// to detect if the click was scroller or not.
+			var b = this.document.body;
+			var clientWidth = b.clientWidth;
+			var clientHeight = b.clientHeight;
+			var clientLeft = b.clientLeft;
+			var offsetWidth = b.offsetWidth;
+			var offsetHeight = b.offsetHeight;
+			var offsetLeft = b.offsetLeft;
+
+			//Check for vertical scroller click.
+			if(/^rtl$/i.test(b.dir || "")){
+				if(clientWidth < offsetWidth && e.x > clientWidth && e.x < offsetWidth){
+					// Check the click was between width and offset width, if so, scroller
+					outsideClientArea = true;
+				}
+			}else{
+				// RTL mode, we have to go by the left offsets.
+				if(e.x < clientLeft && e.x > offsetLeft){
+					// Check the click was between width and offset width, if so, scroller
+					outsideClientArea = true;
+				}
+			}
+			if(!outsideClientArea){
+				// Okay, might be horiz scroller, check that.
+				if(clientHeight < offsetHeight && e.y > clientHeight && e.y < offsetHeight){
+					// Horizontal scroller.
+					outsideClientArea = true;
+				}
+			}
+			if(!outsideClientArea){
+				delete this._cursorToStart; // Remove the force to cursor to start position.
+				delete this._savedSelection; // new mouse position overrides old selection
+				if(e.target.tagName == "BODY"){
+					this.defer("placeCursorAtEnd");
+				}
+				this.inherited(arguments);
+			}
+		},
+		onBeforeActivate: function(){
+			this._restoreSelection();
+		},
+		onBeforeDeactivate: function(e){
+			// summary:
+			//		Called on IE right before focus is lost.   Saves the selected range.
+			// tags:
+			//		private
+			if(this.customUndo){
+				this.endEditing(true);
+			}
+			//in IE, the selection will be lost when other elements get focus,
+			//let's save focus before the editor is deactivated
+			if(e.target.tagName != "BODY"){
+				this._saveSelection();
+			}
+			//console.log('onBeforeDeactivate',this);
+		},
+
+		/* 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 now use custom undo.  It works better
+		//		than native browser support and provides a consistent behavior across
+		//		browsers with a minimal performance hit.  We already had the hit on
+		//		the slowest browser, IE, anyway.
+		customUndo: true,
+
+		// 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 stops 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){
+			// summary:
+			//		Called to note that the user has started typing alphanumeric characters, if it's not already noted.
+			//		Deals with saving undo; see editActionInterval parameter.
+			// tags:
+			//		private
+			if(!this._inEditing){
+				this._inEditing=true;
+				this._beginEditing(cmd);
+			}
+			if(this.editActionInterval>0){
+				if(this._editTimer){
+					this._editTimer.remove();
+				}
+				this._editTimer = this.defer("endEditing", this._editInterval);
+			}
+		},
+
+		// TODO: declaring these in the prototype is meaningless, just create in the constructor/postCreate
+		_steps:[],
+		_undoedSteps:[],
+
+		execCommand: function(cmd){
+			// summary:
+			//		Main handler for executing any commands to the editor, like paste, bold, etc.
+			//		Called by plugins, but not meant to be called by end users.
+			// tags:
+			//		protected
+			if(this.customUndo && (cmd == 'undo' || cmd == 'redo')){
+				return this[cmd]();
+			}else{
+				if(this.customUndo){
+					this.endEditing();
+					this._beginEditing();
+				}
+				var r = this.inherited(arguments);
+				if(this.customUndo){
+					this._endEditing();
+				}
+				return r;
+			}
+		},
+
+		_pasteImpl: function(){
+			// summary:
+			//		Over-ride of paste command control to make execCommand cleaner
+			// tags:
+			//		Protected
+			return this._clipboardCommand("paste");
+		},
+
+		_cutImpl: function(){
+			// summary:
+			//		Over-ride of cut command control to make execCommand cleaner
+			// tags:
+			//		Protected
+			return this._clipboardCommand("cut");
+		},
+
+		_copyImpl: function(){
+			// summary:
+			//		Over-ride of copy command control to make execCommand cleaner
+			// tags:
+			//		Protected
+			return this._clipboardCommand("copy");
+		},
+
+		_clipboardCommand: function(cmd){
+			// summary:
+			//		Function to handle processing clipboard commands (or at least try to).
+			// tags:
+			//		Private
+			var r;
+			try{
+				// Try to exec the superclass exec-command and see if it works.
+				r = this.document.execCommand(cmd, false, null);
+				if(has("webkit") && !r){ //see #4598: webkit does not guarantee clipboard support from js
+					throw { code: 1011 }; // throw an object like Mozilla's error
+				}
+			}catch(e){
+				//TODO: when else might we get an exception?  Do we need the Mozilla test below?
+				if(e.code == 1011 /* Mozilla: service denied */ ||
+					(e.code == 9 && has("opera") /* Opera not supported */)){
+					// Warn user of platform limitation.  Cannot programmatically access clipboard. See ticket #4136
+					var sub = string.substitute,
+						accel = {cut:'X', copy:'C', paste:'V'};
+					alert(sub(this.commands.systemShortcut,
+						[this.commands[cmd], sub(this.commands[has("mac") ? 'appleKey' : 'ctrlKey'], [accel[cmd]])]));
+				}
+				r = false;
+			}
+			return r;
+		},
+
+		queryCommandEnabled: function(cmd){
+			// summary:
+			//		Returns true if specified editor command is enabled.
+			//		Used by the plugins to know when to highlight/not highlight buttons.
+			// tags:
+			//		protected
+			if(this.customUndo && (cmd == 'undo' || cmd == 'redo')){
+				return cmd == 'undo' ? (this._steps.length > 1) : (this._undoedSteps.length > 0);
+			}else{
+				return this.inherited(arguments);
+			}
+		},
+		_moveToBookmark: function(b){
+			// summary:
+			//		Selects the text specified in bookmark b
+			// tags:
+			//		private
+			var bookmark = b.mark;
+			var mark = b.mark;
+			var col = b.isCollapsed;
+			var r, sNode, eNode, sel;
+			if(mark){
+				if(has("ie") < 9){
+					if(lang.isArray(mark)){
+						//IE CONTROL, have to use the native bookmark.
+						bookmark = [];
+						array.forEach(mark,function(n){
+							bookmark.push(rangeapi.getNode(n,this.editNode));
+						},this);
+						win.withGlobal(this.window,'moveToBookmark',focusBase,[{mark: bookmark, isCollapsed: col}]);
+					}else{
+						if(mark.startContainer && mark.endContainer){
+							// Use the pseudo WC3 range API.  This works better for positions
+							// than the IE native bookmark code.
+							sel = rangeapi.getSelection(this.window);
+							if(sel && sel.removeAllRanges){
+								sel.removeAllRanges();
+								r = rangeapi.create(this.window);
+								sNode = rangeapi.getNode(mark.startContainer,this.editNode);
+								eNode = rangeapi.getNode(mark.endContainer,this.editNode);
+								if(sNode && eNode){
+									// Okay, we believe we found the position, so add it into the selection
+									// There are cases where it may not be found, particularly in undo/redo, when
+									// IE changes the underlying DOM on us (wraps text in a <p> tag or similar.
+									// So, in those cases, don't bother restoring selection.
+									r.setStart(sNode,mark.startOffset);
+									r.setEnd(eNode,mark.endOffset);
+									sel.addRange(r);
+								}
+							}
+						}
+					}
+				}else{//w3c range
+					sel = rangeapi.getSelection(this.window);
+					if(sel && sel.removeAllRanges){
+						sel.removeAllRanges();
+						r = rangeapi.create(this.window);
+						sNode = rangeapi.getNode(mark.startContainer,this.editNode);
+						eNode = rangeapi.getNode(mark.endContainer,this.editNode);
+						if(sNode && eNode){
+							// Okay, we believe we found the position, so add it into the selection
+							// There are cases where it may not be found, particularly in undo/redo, when
+							// formatting as been done and so on, so don't restore selection then.
+							r.setStart(sNode,mark.startOffset);
+							r.setEnd(eNode,mark.endOffset);
+							sel.addRange(r);
+						}
+					}
+				}
+			}
+		},
+		_changeToStep: function(from, to){
+			// summary:
+			//		Reverts editor to "to" setting, from the undo stack.
+			// tags:
+			//		private
+			this.setValue(to.text);
+			var b=to.bookmark;
+			if(!b){ return; }
+			this._moveToBookmark(b);
+		},
+		undo: function(){
+			// summary:
+			//		Handler for editor undo (ex: ctrl-z) operation
+			// tags:
+			//		private
+			var ret = false;
+			if(!this._undoRedoActive){
+				this._undoRedoActive = true;
+				this.endEditing(true);
+				var s=this._steps.pop();
+				if(s && this._steps.length>0){
+					this.focus();
+					this._changeToStep(s,this._steps[this._steps.length-1]);
+					this._undoedSteps.push(s);
+					this.onDisplayChanged();
+					delete this._undoRedoActive;
+					ret = true;
+				}
+				delete this._undoRedoActive;
+			}
+			return ret;
+		},
+		redo: function(){
+			// summary:
+			//		Handler for editor redo (ex: ctrl-y) operation
+			// tags:
+			//		private
+			var ret = false;
+			if(!this._undoRedoActive){
+				this._undoRedoActive = true;
+				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();
+					ret = true;
+				}
+				delete this._undoRedoActive;
+			}
+			return ret;
+		},
+		endEditing: function(ignore_caret){
+			// summary:
+			//		Called to note that the user has stopped typing alphanumeric characters, if it's not already noted.
+			//		Deals with saving undo; see editActionInterval parameter.
+			// tags:
+			//		private
+			if(this._editTimer){
+				this._editTimer = this._editTimer.remove();
+			}
+			if(this._inEditing){
+				this._endEditing(ignore_caret);
+				this._inEditing=false;
+			}
+		},
+
+		_getBookmark: function(){
+			// summary:
+			//		Get the currently selected text
+			// tags:
+			//		protected
+			var b=win.withGlobal(this.window,focusBase.getBookmark);
+			var tmp=[];
+			if(b && b.mark){
+				var mark = b.mark;
+				if(has("ie") < 9){
+					// Try to use the pseudo range API on IE for better accuracy.
+					var sel = rangeapi.getSelection(this.window);
+					if(!lang.isArray(mark)){
+						if(sel){
+							var range;
+							if(sel.rangeCount){
+								range = sel.getRangeAt(0);
+							}
+							if(range){
+								b.mark = range.cloneRange();
+							}else{
+								b.mark = win.withGlobal(this.window,focusBase.getBookmark);
+							}
+						}
+					}else{
+						// Control ranges (img, table, etc), handle differently.
+						array.forEach(b.mark,function(n){
+							tmp.push(rangeapi.getIndex(n,this.editNode).o);
+						},this);
+						b.mark = tmp;
+					}
+				}
+				try{
+					if(b.mark && b.mark.startContainer){
+						tmp=rangeapi.getIndex(b.mark.startContainer,this.editNode).o;
+						b.mark={startContainer:tmp,
+							startOffset:b.mark.startOffset,
+							endContainer:b.mark.endContainer===b.mark.startContainer?tmp:rangeapi.getIndex(b.mark.endContainer,this.editNode).o,
+							endOffset:b.mark.endOffset};
+					}
+				}catch(e){
+					b.mark = null;
+				}
+			}
+			return b;
+		},
+		_beginEditing: function(){
+			// summary:
+			//		Called when the user starts typing alphanumeric characters.
+			//		Deals with saving undo; see editActionInterval parameter.
+			// tags:
+			//		private
+			if(this._steps.length === 0){
+				// You want to use the editor content without post filtering
+				// to make sure selection restores right for the 'initial' state.
+				// and undo is called.  So not using this.value, as it was 'processed'
+				// and the line-up for selections may have been altered.
+				this._steps.push({'text':html.getChildrenHtml(this.editNode),'bookmark':this._getBookmark()});
+			}
+		},
+		_endEditing: function(){
+			// summary:
+			//		Called when the user stops typing alphanumeric characters.
+			//		Deals with saving undo; see editActionInterval parameter.
+			// tags:
+			//		private
+			
+			// Avoid filtering to make sure selections restore.
+			var v = html.getChildrenHtml(this.editNode);
+
+			this._undoedSteps=[];//clear undoed steps
+			this._steps.push({text: v, bookmark: this._getBookmark()});
+		},
+		onKeyDown: function(e){
+			// summary:
+			//		Handler for onkeydown event.
+			// tags:
+			//		private
+
+			//We need to save selection if the user TAB away from this editor
+			//no need to call _saveSelection for IE, as that will be taken care of in onBeforeDeactivate
+			if(!has("ie") && !this.iframe && e.keyCode == keys.TAB && !this.tabIndent){
+				this._saveSelection();
+			}
+			if(!this.customUndo){
+				this.inherited(arguments);
+				return;
+			}
+			var k = e.keyCode;
+			if(e.ctrlKey && !e.altKey){//undo and redo only if the special right Alt + z/y are not pressed #5892
+				if(k == 90 || k == 122){ //z
+					event.stop(e);
+					this.undo();
+					return;
+				}else if(k == 89 || k == 121){ //y
+					event.stop(e);
+					this.redo();
+					return;
+				}
+			}
+			this.inherited(arguments);
+
+			switch(k){
+					case keys.ENTER:
+					case keys.BACKSPACE:
+					case keys.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');
+							}else{
+								this.beginEditing('paste');
+							}
+							//use timeout to trigger after the paste is complete
+							this.defer("endEditing", 1);
+							break;
+						}
+						//pass through
+					default:
+						if(!e.ctrlKey && !e.altKey && !e.metaKey && (e.keyCode<keys.F1 || e.keyCode>keys.F15)){
+							this.beginEditing();
+							break;
+						}
+						//pass through
+					case keys.ALT:
+						this.endEditing();
+						break;
+					case keys.UP_ARROW:
+					case keys.DOWN_ARROW:
+					case keys.LEFT_ARROW:
+					case keys.RIGHT_ARROW:
+					case keys.HOME:
+					case keys.END:
+					case keys.PAGE_UP:
+					case keys.PAGE_DOWN:
+						this.endEditing(true);
+						break;
+					//maybe ctrl+backspace/delete, so don't endEditing when ctrl is pressed
+					case keys.CTRL:
+					case keys.SHIFT:
+					case keys.TAB:
+						break;
+				}
+		},
+		_onBlur: function(){
+			// summary:
+			//		Called from focus manager when focus has moved away from this editor
+			// tags:
+			//		protected
+
+			//this._saveSelection();
+			this.inherited(arguments);
+			this.endEditing(true);
+		},
+		_saveSelection: function(){
+			// summary:
+			//		Save the currently selected text in _savedSelection attribute
+			// tags:
+			//		private
+			try{
+				this._savedSelection=this._getBookmark();
+			}catch(e){ /* Squelch any errors that occur if selection save occurs due to being hidden simultaneously. */}
+		},
+		_restoreSelection: function(){
+			// summary:
+			//		Re-select the text specified in _savedSelection attribute;
+			//		see _saveSelection().
+			// tags:
+			//		private
+			if(this._savedSelection){
+				// Clear off cursor to start, we're deliberately going to a selection.
+				delete this._cursorToStart;
+				// only restore the selection if the current range is collapsed
+				// if not collapsed, then it means the editor does not lose
+				// selection and there is no need to restore it
+				if(win.withGlobal(this.window,'isCollapsed',focusBase)){
+					this._moveToBookmark(this._savedSelection);
+				}
+				delete this._savedSelection;
+			}
+		},
+
+		onClick: function(){
+			// summary:
+			//		Handler for when editor is clicked
+			// tags:
+			//		protected
+			this.endEditing(true);
+			this.inherited(arguments);
+		},
+
+		replaceValue: function(/*String*/ html){
+			// summary:
+			//		over-ride of replaceValue to support custom undo and stack maintenance.
+			// tags:
+			//		protected
+			if(!this.customUndo){
+				this.inherited(arguments);
+			}else{
+				if(this.isClosed){
+					this.setValue(html);
+				}else{
+					this.beginEditing();
+					if(!html){
+						html = "&#160;";	// &nbsp;
+					}
+					this.setValue(html);
+					this.endEditing();
+				}
+			}
+		},
+
+		_setDisabledAttr: function(/*Boolean*/ value){
+			this.setValueDeferred.then(lang.hitch(this, function(){
+				if((!this.disabled && value) || (!this._buttonEnabledPlugins && value)){
+					// Disable editor: disable all enabled buttons and remember that list
+					array.forEach(this._plugins, function(p){
+						p.set("disabled", true);
+					});
+				}else if(this.disabled && !value){
+					// Restore plugins to being active.
+					array.forEach(this._plugins, function(p){
+						p.set("disabled", false);
+					});
+				}
+			}));
+			this.inherited(arguments);
+		},
+
+		_setStateClass: function(){
+			try{
+				this.inherited(arguments);
+
+				// Let theme set the editor's text color based on editor enabled/disabled state.
+				// We need to jump through hoops because the main document (where the theme CSS is)
+				// is separate from the iframe's document.
+				if(this.document && this.document.body){
+					domStyle.set(this.document.body, "color", domStyle.get(this.iframe, "color"));
+				}
+			}catch(e){ /* Squelch any errors caused by focus change if hidden during a state change */}
+		}
+	});
+
+	// Register the "default plugins", ie, the built-in editor commands
+	function simplePluginFactory(args){
+		return new _Plugin({ command: args.name });
+	}
+	function togglePluginFactory(args){
+		return new _Plugin({ buttonClass: ToggleButton, command: args.name });
+	}
+	lang.mixin(_Plugin.registry, {
+		"undo": simplePluginFactory,
+		"redo": simplePluginFactory,
+		"cut": simplePluginFactory,
+		"copy": simplePluginFactory,
+		"paste": simplePluginFactory,
+		"insertOrderedList": simplePluginFactory,
+		"insertUnorderedList": simplePluginFactory,
+		"indent": simplePluginFactory,
+		"outdent": simplePluginFactory,
+		"justifyCenter": simplePluginFactory,
+		"justifyFull": simplePluginFactory,
+		"justifyLeft": simplePluginFactory,
+		"justifyRight": simplePluginFactory,
+		"delete": simplePluginFactory,
+		"selectAll": simplePluginFactory,
+		"removeFormat": simplePluginFactory,
+		"unlink": simplePluginFactory,
+		"insertHorizontalRule": simplePluginFactory,
+
+		"bold": togglePluginFactory,
+		"italic": togglePluginFactory,
+		"underline": togglePluginFactory,
+		"strikethrough": togglePluginFactory,
+		"subscript": togglePluginFactory,
+		"superscript": togglePluginFactory,
+
+		"|": function(){
+			return new _Plugin({
+				setEditor: function(editor){
+					this.editor = editor;
+					this.button = new ToolbarSeparator({ownerDocument: editor.ownerDocument});
+				}
+			});
+		}
+	});
+
+	return Editor;
+});