dojo_src 1.4.102 → 1.5.0

data/dojo/dojox/editor/plugins/FindReplace.js

@@ -6,8 +6,6 @@ dojo.require("dijit.form.TextBox");
 dojo.require("dijit.form.CheckBox");
 dojo.require("dijit.form.Button");
 dojo.require("dijit.TooltipDialog");
-dojo.require("dijit.Menu");
-dojo.require("dijit.CheckedMenuItem");
 dojo.require("dojox.editor.plugins.ToolbarLineBreak");
 dojo.require("dojo.i18n");
 dojo.require("dojo.string");
@@ -16,6 +14,34 @@ dojo.requireLocalization("dojox.editor.plugins", "FindReplace");
 
 dojo.experimental("dojox.editor.plugins.FindReplace");
 
+dojo.declare("dojox.editor.plugins._FindReplaceCloseBox", [dijit._Widget, dijit._Templated], {
+	// summary:
+	//		Base class for widgets that contains a button labeled X
+	//		to close the tool bar.
+	
+	btnId: "",
+	widget: null,
+	widgetsInTemplate: true,
+	
+	templateString:
+		"<span style='float: right' class='dijitInline' tabindex='-1'>" +
+			"<button class='dijit dijitReset dijitInline' " +
+				"id='${btnId}' dojoAttachPoint='button' dojoType='dijit.form.Button' tabindex='-1' iconClass='dijitEditorIconsFindReplaceClose' showLabel='false'>X</button>" +
+		"</span>",
+	
+	postMixInProperties: function(){
+		// Set some substitution variables used in the template
+		this.id = dijit.getUniqueId(this.declaredClass.replace(/\./g,"_"));		
+		this.btnId = this.id + "_close";
+		this.inherited(arguments);
+	},
+	startup: function(){
+		this.connect(this.button, "onClick", "onClick");
+	},
+	onClick: function(){
+	}
+});
+
 
 dojo.declare("dojox.editor.plugins._FindReplaceTextBox",
 	[dijit._Widget, dijit._Templated],{
@@ -24,20 +50,29 @@ dojo.declare("dojox.editor.plugins._FindReplaceTextBox",
 	//		and a TextBox to pick a value.
 	//		Used as Toolbar entry.
 
-	textId: "", 
+	// textId: [public] String
+	//		The id of the enhanced textbox
+	textId: "",
+	
+	// label: [public] String
+	//		The label of the enhanced textbox 
 	label: "",
+	
+	// tooltip: [public] String
+	//		The tooltip of the enhanced textbox when the mouse is hovering on it
+	toolTip: "",
 	widget: null,
 	widgetsInTemplate: true,
 
 	templateString:
-		"<span style='white-space: nowrap' class='dijit dijitReset dijitInline findReplaceTextBox'>" +
-			"<label class='dijitLeft dijitInline' for='${textId}'>${label}</label>" +
-			"<input dojoType='dijit.form.TextBox' required=false intermediateChanges='true'" +
-					"tabIndex='-1' id='${textId}' dojoAttachPoint='textBox' value='' style='width: 20em;'/>" +
+		"<span style='white-space: nowrap' class='dijit dijitReset dijitInline dijitEditorFindReplaceTextBox' " +
+			"title='${tooltip}' tabindex='-1'>" +
+			"<label class='dijitLeft dijitInline' for='${textId}' tabindex='-1'>${label}</label>" +
+			"<input dojoType='dijit.form.TextBox' required='false' intermediateChanges='true' class='focusTextBox'" +
+					"tabIndex='0' id='${textId}' dojoAttachPoint='textBox, focusNode' value='' dojoAttachEvent='onKeyPress: _onKeyPress'/>" +
 		"</span>",
 
 	postMixInProperties: function(){
-		this.inherited(arguments);
 		// Set some substitution variables used in the template
 		this.id = dijit.getUniqueId(this.declaredClass.replace(/\./g,"_"));		
 		this.textId = this.id + "_text";
@@ -46,33 +81,69 @@ dojo.declare("dojox.editor.plugins._FindReplaceTextBox",
 	},
 
 	postCreate: function(){
-		this.textBox.attr("value", "");
-		this.disabled =  this.textBox.attr("disabled");
+		this.textBox.set("value", "");
+		this.disabled =  this.textBox.get("disabled");
 		this.connect(this.textBox, "onChange", "onChange");
 	},
 
-	_setValueAttr: function(value){
-		//if the value is not a permitted value, just set empty string to prevent showing the warning icon
+	_setValueAttr: function(/*String*/ value){
+		//If the value is not a permitted value, just set empty string to prevent showing the warning icon
 		this.value = value;
-		this.textBox.attr('value', value);
+		this.textBox.set("value", value);
 	},
 
 	focus: function(){
 		this.textBox.focus();
 	},
 
-	_setDisabledAttr: function(value){
+	_setDisabledAttr: function(/*Boolean*/ value){
 		// summary:
-		//		Over-ride for the button's 'disabled' attribute so that it can be 
+		//		Over-ride for the textbox's 'disabled' attribute so that it can be 
 		//		disabled programmatically.
+		// value:
+		//		The boolean value to indicate if the textbox should be disabled or not
+		// tags:
+		//		private 
 		this.disabled = value;
-		this.textBox.attr("disabled", value);
+		this.textBox.set("disabled", value);
 	},
 
-	onChange: function(val){
+	onChange: function(/*String*/ val){
 		// summary:
 		//		Stub function for change events on the box.
+		// tags:
+		//		public
 		this.value= val;
+	},
+	
+	_onKeyPress: function(/*Event*/ evt){
+		// summary:
+		//		Handle the arrow key events
+		// evt:
+		//		Event object passed to this handler
+		// tags:
+		//		private
+		var start = 0;
+		var end = 0;
+		
+		// If CTRL, ALT or SHIFT is not held on
+		if(evt.target && !evt.ctrlKey && !evt.altKey && !evt.shiftKey){
+			if(evt.keyCode == dojo.keys.LEFT_ARROW){
+				start = evt.target.selectionStart;
+				end = evt.target.selectionEnd;
+				if(start < end){
+					dijit.selectInputText(evt.target, start, start);
+					dojo.stopEvent(evt);
+				}
+			}else if(evt.keyCode == dojo.keys.RIGHT_ARROW){
+				start = evt.target.selectionStart;
+				end = evt.target.selectionEnd;
+				if(start < end){
+					dijit.selectInputText(evt.target, end, end);
+					dojo.stopEvent(evt);
+				}
+			}
+		}
 	}
 });
 
@@ -84,20 +155,30 @@ dojo.declare("dojox.editor.plugins._FindReplaceCheckBox",
 	//		and a checkbox to indicate if it is checked or not.
 	//		Used as Toolbar entry.
 
-	checkId: "", 
+	// checkId: [public] String
+	//		The id of the enhanced checkbox
+	checkId: "",
+	
+	// label: [public] String
+	//		The label of the enhanced checkbox
 	label: "",
+	
+	// tooltip: [public] String
+	//		The tooltip of the enhanced checkbox when the mouse is hovering it
+	tooltip: "",
+	
 	widget: null,
 	widgetsInTemplate: true,
 
 	templateString:
-		"<span style='white-space: nowrap' class='dijit dijitReset dijitInline findReplaceCheckBox'>" +
+		"<span style='white-space: nowrap' tabindex='-1' " +
+			"class='dijit dijitReset dijitInline dijitEditorFindReplaceCheckBox' title='${tooltip}' >" +
 			"<input dojoType='dijit.form.CheckBox' required=false " +
-					"tabIndex='-1' id='${checkId}' dojoAttachPoint='checkBox' value=''/>" +
-			"<label class='dijitLeft dijitInline' for='${checkId}'>${label}</label>" +
+					"tabIndex='0' id='${checkId}' dojoAttachPoint='checkBox, focusNode' value=''/>" +
+			"<label tabindex='-1' class='dijitLeft dijitInline' for='${checkId}'>${label}</label>" +
 		"</span>",
 
 	postMixInProperties: function(){
-		this.inherited(arguments);
 		// Set some substitution variables used in the template
 		this.id = dijit.getUniqueId(this.declaredClass.replace(/\./g,"_"));		
 		this.checkId = this.id + "_check";
@@ -105,17 +186,17 @@ dojo.declare("dojox.editor.plugins._FindReplaceCheckBox",
 	},
 
 	postCreate: function(){
-		this.checkBox.attr("checked", false);
-		this.disabled =  this.checkBox.attr("disabled");
-		this.checkBox.isFocusable = function() {return false;};
+		this.checkBox.set("checked", false);
+		this.disabled =  this.checkBox.get("disabled");
+		this.checkBox.isFocusable = function(){ return false; };
 	},
 
-	_setValueAttr: function(value){
+	_setValueAttr: function(/*Boolean*/ value){
 		// summary:
 		//		Passthrough for checkbox.
 		// tags:
 		//		private
-		this.checkBox.attr('value', value);
+		this.checkBox.set('value', value);
 	},
 
 	_getValueAttr: function(){
@@ -123,23 +204,62 @@ dojo.declare("dojox.editor.plugins._FindReplaceCheckBox",
 		//		Passthrough for checkbox.
 		// tags:
 		//		private
-		return this.checkBox.attr('value');
+		return this.checkBox.get('value');
 	},
 
 	focus: function(){
+		// summary:
+		//		Handle the focus event when this widget gets focused
+		// tags:
+		//		private
 		this.checkBox.focus();
 	},
 
-	_setDisabledAttr: function(value){
+	_setDisabledAttr: function(/*Boolean*/ value){
 		// summary:
 		//		Over-ride for the button's 'disabled' attribute so that it can be 
 		//		disabled programmatically.
+		// value:
+		//		The flag that indicates if the checkbox is disabled or not.
+		// tags:
+		//		private
 		this.disabled = value;
-		this.checkBox.attr("disabled", value);
+		this.checkBox.set("disabled", value);
 	}
 });
 
 
+dojo.declare("dojox.editor.plugins._FindReplaceToolbar", dijit.Toolbar, {
+	// summary:
+	//		A toolbar that derived from dijit.Toolbar, which
+	//		eliminates some unnecessary event response such as LEFT_ARROW pressing
+	//		and click bubbling.
+
+	postCreate: function(){
+		this.connectKeyNavHandlers([], []); // Prevent arrow key navigation
+		this.connect(this.containerNode, "onclick", "_onToolbarEvent");
+		this.connect(this.containerNode, "onkeydown", "_onToolbarEvent");
+		dojo.addClass(this.domNode, "dijitToolbar");
+	},
+	
+	addChild: function(/*dijit._Widget*/ widget, /*int?*/ insertIndex){
+		// summary:
+		//		Add a child to our _Container and prevent the default
+		//		arrow key navigation function. This function may bring in
+		//		side effect
+		dijit._KeyNavContainer.superclass.addChild.apply(this, arguments);
+	},
+	
+	_onToolbarEvent: function(/*Event*/ evt){
+		// Editor may have special treatment to some events, so stop the bubbling.
+		// evt:
+		//		The Event object
+		// tages:
+		//		private
+		evt.stopPropagation();
+	}
+});
+
 dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 	//	summary:
 	//		This plugin provides a Find/Replace cabability for the editor.
@@ -152,32 +272,89 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 
 	// iconClassPrefix: [const] String
 	//		The CSS class name for the button node is formed from `iconClassPrefix` and `command`
-	iconClassPrefix: "dijitAdditionalEditorIcon",
+	iconClassPrefix: "dijitEditorIconsFindReplace",
+
+	// editor: [protected]
+	//		The editor this plugin belongs to
+	editor: null,
+	
+	// button: [protected]
+	//		The toggle button
+	button: null,
+	
+	// _frToolbar: [private]
+	//		The toolbar that contain all the entries and buttons
+	_frToolbar: null,
+	
+	// _closeBox: [private]
+	//		The close button of the F/R toolbar
+	_closeBox: null,
+	
+	// _findField: [private]
+	//		The Find field of the F/R toolbar
+	_findField: null,
+	
+	// _replaceField: [private]
+	//		The Replace field of the F/R toolbar
+	_replaceField: null,
+	
+	// _findButton: [private]
+	//		The Find button of the F/R toolbar
+	_findButton: null,
+	
+	// _replaceButton: [private]
+	//		The Replace button of the F/R toolbar
+	_replaceButton: null,
+	
+	// _replaceAllButton: [private]
+	//		The ReplaceAll button of the F/R toolbar
+	_replaceAllButton: null,
+	
+	// _caseSensitive: [private]
+	//		The case sensitive checkbox
+	_caseSensitive: null,
+	
+	// _backwards: [private]
+	//		The backwards checkbox
+	_backwards: null,
+	
+	// _promDialog: [private]
+	//		The prompt message box that shows the user some messages
+	//		such as the end of a search, the end of a replacement, etc.
+	_promDialog: null,
+	_promDialogTimeout: null,
+
+	// _strings: [private]
+	//		The array that contains globalized strings
+	_strings: null,
 
 	_initButton: function(){
 		//	summary:
 		//		Over-ride for creation of the resize button.
-		var strings = dojo.i18n.getLocalization("dojox.editor.plugins", "FindReplace");
+		this._strings = dojo.i18n.getLocalization("dojox.editor.plugins", "FindReplace");
 		this.button = new dijit.form.ToggleButton({
-			label: strings["findReplace"],
+			label: this._strings["findReplace"],
 			showLabel: false,
-			iconClass: this.iconClassPrefix + " " + this.iconClassPrefix + "FindReplace",
+			iconClass: this.iconClassPrefix + " dijitEditorIconFindString",
 			tabIndex: "-1",
 			onChange: dojo.hitch(this, "_toggleFindReplace")
 		});
 		if(dojo.isOpera){
 			// Not currently supported on Opera!
-			this.button.attr("disabled", true);
+			this.button.set("disabled", true);
 		}
 		//Link up so that if the toggle is disabled, then the view of Find/Replace is closed.
-		this.connect(this.button, "attr", dojo.hitch(this, function(attr, val){
+		this.connect(this.button, "set", dojo.hitch(this, function(attr, val){
 			if(attr === "disabled"){
-	            this._toggleFindReplace((!val && this._displayed), true);
+				this._toggleFindReplace((!val && this._displayed), true, true);
 			}
 		}));
 	},
 
 	setEditor: function(editor){
+		// summary:
+		//		This is a callback handler that set a reference to the editor this plugin
+		//		hosts in
 		this.editor = editor;
 		this._initButton();
 	},
@@ -185,16 +362,27 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 	toggle: function(){
 		// summary:
 		//		Function to allow programmatic toggling of the find toolbar.
-		this.button.attr("checked", !this.button.attr("checked"));
+		// tags:
+		//		public
+		this.button.set("checked", !this.button.get("checked"));
 	},
 
-	_toggleFindReplace: function(show, ignoreState){
-		//	summary:
+	_toggleFindReplace: function(/*Boolean*/ show, /*Boolean?*/ ignoreState, /*Boolean?*/ buttonDisabled){
+		// summary:
 		//		Function to toggle whether or not find/replace is displayed.
-		//	tags:
+		// show:
+		//		Indicate if the toolbar is shown or not
+		// ignoreState:
+		//		Indicate if the status should be ignored or not
+		// blurEditor:
+		//		Indicate if the focus should be removed from the editor or not
+		// tags:
 		//		private
+		var size = dojo.marginBox(this.editor.domNode);
 		if(show && !dojo.isOpera){
 			dojo.style(this._frToolbar.domNode, "display", "block");
+			// Auto populate the Find field
+			this._populateFindField();
 			if(!ignoreState){
 				this._displayed = true;
 			}
@@ -203,118 +391,213 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 			if(!ignoreState){
 				this._displayed = false;
 			}
+			
+			// If the toggle button is disabled, it is most likely that 
+			// another plugin such as ViewSource disables it.
+			// So we do not need to focus the text area of the editor to
+			// prevent the editor from an invalid status.
+			// Please refer to dijit._editor.plugins.ViewSource for more details.
+			if(!buttonDisabled){
+				this.editor.focus();
+			}
+		}
+
+		// Resize the editor.
+		this.editor.resize({h: size.h});
+	},
+
+	_populateFindField: function(){
+		// summary:
+		//		Populate the Find field with selected text when dialog initially displayed.
+		//		Auto-select text in Find field after it’s populated.
+		//		If nothing selected, restore previous entry from the same session.
+		// tags:
+		//		private
+		var ed = this.editor;
+		var win = ed.window;
+		var selectedTxt = dojo.withGlobal(ed.window, "getSelectedText", dijit._editor.selection, [null]);
+		if(this._findField && this._findField.textBox){
+			if(selectedTxt){
+				this._findField.textBox.set("value", selectedTxt);
+			}
+			this._findField.textBox.focus();
+			dijit.selectInputText(this._findField.textBox.focusNode);
 		}
-		this.editor.resize();
 	},
 
-	setToolbar: function(toolbar){
+	setToolbar: function(/*dijit.Toolbar*/ toolbar){
 		// summary:
 		//		Over-ride so that find/replace toolbar is appended after the current toolbar.
+		// toolbar:
+		//		The current toolbar of the editor
+		// tags:
+		//		public
 		this.inherited(arguments);
 		if(!dojo.isOpera){
-			var strings = dojo.i18n.getLocalization("dojox.editor.plugins", "FindReplace");
-			this._frToolbar = new dijit.Toolbar();
-			dojo.style(this._frToolbar.domNode, "display", "none");
-			dojo.place(this._frToolbar.domNode, toolbar.domNode, "after");
-			this._frToolbar.startup();
-
-			// Build options.
-			this._caseSensitive = new dojox.editor.plugins._FindReplaceCheckBox({label: strings["matchCase"]});
-			this._backwards = new dojox.editor.plugins._FindReplaceCheckBox({label: strings["backwards"]});
-			this._replaceAll = new dojox.editor.plugins._FindReplaceCheckBox({label: strings["replaceAll"]});
-
-			//Define the search/replace fields.
-			this._findField = new dojox.editor.plugins._FindReplaceTextBox({label: strings.findLabel});
-			this._frToolbar.addChild(this._findField);
-			this._findButton = new dijit.form.Button({label: strings["findButton"], showLabel: true, 
-				iconClass: this.iconClassPrefix + " " + this.iconClassPrefix + "FindRun"});
-			this._frToolbar.addChild(this._findButton);
-			this._frToolbar.addChild(this._caseSensitive);
-			this._frToolbar.addChild(this._backwards);
-
-			this._frToolbar.addChild(new dojox.editor.plugins._ToolbarLineBreak());
-
-			this._replaceField = new dojox.editor.plugins._FindReplaceTextBox({label: strings.replaceLabel});
-			this._frToolbar.addChild(this._replaceField);
-			this._replaceButton = new dijit.form.Button({label: strings["replaceButton"], showLabel: true,
-				iconClass: this.iconClassPrefix + " " + this.iconClassPrefix + "ReplaceRun"});
-			this._frToolbar.addChild(this._replaceButton);
-			this._frToolbar.addChild(this._replaceAll);
-
-			//Set initial states, buttons should be disabled unless content is 
-			//present in the fields.
-			this._findButton.attr("disabled", true);
-			this._replaceButton.attr("disabled", true);
+			var _tb = this._frToolbar = new dojox.editor.plugins._FindReplaceToolbar();
+			dojo.style(_tb.domNode, "display", "none");
+			dojo.place(_tb.domNode, toolbar.domNode, "after");
+			_tb.startup();
+
+			// IE6 will put the close box in a new line when its style is "float: right".
+			// So place the close box ahead of the other fields, which makes it align with
+			// the other components.
+			this._closeBox = new dojox.editor.plugins._FindReplaceCloseBox();
+			_tb.addChild(this._closeBox);
+			
+			// Define the search/replace fields.
+			this._findField = new dojox.editor.plugins._FindReplaceTextBox(
+				{label: this._strings["findLabel"], tooltip: this._strings["findTooltip"]});
+			_tb.addChild(this._findField);
+			
+			this._replaceField = new dojox.editor.plugins._FindReplaceTextBox(
+				{label: this._strings["replaceLabel"], tooltip: this._strings["replaceTooltip"]});
+			_tb.addChild(this._replaceField);
 
+			// Define the Find/Replace/ReplaceAll buttons.
+			_tb.addChild(new dojox.editor.plugins._ToolbarLineBreak());
+			
+			this._findButton = new dijit.form.Button({label: this._strings["findButton"], showLabel: true, 
+				iconClass: this.iconClassPrefix + " dijitEditorIconFind"});
+			this._findButton.titleNode.title = this._strings["findButtonTooltip"];
+			_tb.addChild(this._findButton);
+			
+			this._replaceButton = new dijit.form.Button({label: this._strings["replaceButton"], showLabel: true,
+				iconClass: this.iconClassPrefix + " dijitEditorIconReplace"});
+			this._replaceButton.titleNode.title = this._strings["replaceButtonTooltip"];
+			_tb.addChild(this._replaceButton);
+			
+			this._replaceAllButton = new dijit.form.Button({label: this._strings["replaceAllButton"], showLabel: true,
+				iconClass: this.iconClassPrefix + " dijitEditorIconReplaceAll"});
+			this._replaceAllButton.titleNode.title = this._strings["replaceAllButtonTooltip"];
+			_tb.addChild(this._replaceAllButton);
+			
+			// Define the option checkboxes.
+			this._caseSensitive = new dojox.editor.plugins._FindReplaceCheckBox(
+				{label: this._strings["matchCase"], tooltip: this._strings["matchCaseTooltip"]});
+			_tb.addChild(this._caseSensitive);
+			
+			this._backwards = new dojox.editor.plugins._FindReplaceCheckBox(
+				{label: this._strings["backwards"], tooltip: this._strings["backwardsTooltip"]});
+			_tb.addChild(this._backwards);
+
+			// Set initial states, buttons should be disabled unless content is 
+			// present in the fields.
+			this._findButton.set("disabled", true);
+			this._replaceButton.set("disabled", true);
+			this._replaceAllButton.set("disabled", true);
+
+			// Connect the event to the status of the items
 			this.connect(this._findField, "onChange", "_checkButtons");
-			this.connect(this._replaceField, "onChange", "_checkButtons");
+			this.connect(this._findField, "onKeyDown", "_onFindKeyDown");
+			this.connect(this._replaceField, "onKeyDown", "_onReplaceKeyDown");
 
-			//Connect up the actual search events.
+			// Connect up the actual search events.
 			this.connect(this._findButton, "onClick", "_find");
 			this.connect(this._replaceButton, "onClick", "_replace");
+			this.connect(this._replaceAllButton, "onClick", "_replaceAll");
+			
+			// Connect up the close event
+			this.connect(this._closeBox, "onClick", "toggle");
 			
-			this._replDialog = new dijit.TooltipDialog();
-			this._replDialog.startup();
-			this._replDialog.attr("content", "");
-			this._dialogTemplate = strings.replaceDialogText;
+			// Prompt for the message
+			this._promDialog = new dijit.TooltipDialog();
+			this._promDialog.startup();
+			this._promDialog.set("content", "");
 		}
 	},
 
 	_checkButtons: function(){
-		 var fText = this._findField.attr("value");
-		 var rText = this._replaceField.attr("value");
-		 if(fText){
-			 //Only enable if find text is not empty or just blank/spaces.
-			 this._findButton.attr("disabled", false);
-		 }else{
-			 this._findButton.attr("disabled", true);
-		 }
-		 if(fText && rText && fText !== rText){
-			 this._replaceButton.attr("disabled", false);
-		 }else{
-			 this._replaceButton.attr("disabled", true);
-		 }
+		// summary:
+		//		Ensure that all the buttons are in a correct status
+		//		when certain events are fired.
+		var fText = this._findField.get("value");
+
+		if(fText){
+			// Only enable if find text is not empty or just blank/spaces.
+			this._findButton.set("disabled", false);
+			this._replaceButton.set("disabled", false);
+			this._replaceAllButton.set("disabled", false);
+		}else{
+			this._findButton.set("disabled", true);
+			this._replaceButton.set("disabled", true);
+			this._replaceAllButton.set("disabled", true);
+		}
+	},
+	
+	_onFindKeyDown: function(evt){
+		if(evt.keyCode == dojo.keys.ENTER){
+			// Perform the default search action
+			this._find();
+			dojo.stopEvent(evt);
+		}
+	},
+	
+	_onReplaceKeyDown: function(evt){
+		if(evt.keyCode == dojo.keys.ENTER){
+			// Perform the default replace action
+			if(!this._replace()) this._replace();
+			dojo.stopEvent(evt);
+		}
 	},
 
-	_find: function(){
+	_find: function(/*Boolean?*/ showMessage){
 		// summary:
 		//		This function invokes a find on the editor document with the noted options for
 		//		find.
+		// showMessage:
+		//		Indicated whether the tooltip is shown or not when the search reaches the end
 		// tags:
 		//		private.
 		// returns:
 		//		Boolean indicating if the content was found or not.
-		var txt = this._findField.attr("value"); 
+		var txt = this._findField.get("value") || ""; 
 		if(txt){
-			var caseSensitive = this._caseSensitive.attr("value");
-			var backwards = this._backwards.attr("value");
-			return this._findText(txt, caseSensitive, backwards);
+			var caseSensitive = this._caseSensitive.get("value");
+			var backwards = this._backwards.get("value");
+			var isFound = this._findText(txt, caseSensitive, backwards);
+			if(!isFound && showMessage){
+				this._promDialog.set("content", dojo.string.substitute(
+					this._strings["eofDialogText"], {"0": this._strings["eofDialogTextFind"]}));
+				dijit.popup.open({popup: this._promDialog, around: this._findButton.domNode});
+				this._promDialogTimeout = setTimeout(dojo.hitch(this, function(){
+					clearTimeout(this._promDialogTimeout);
+					this._promDialogTimeout = null;
+					dijit.popup.close(this._promDialog);
+				}), 3000);
+				setTimeout(dojo.hitch(this, function(){
+					this.editor.focus();
+				}), 0);
+			}
+			return isFound;
 		}
+		
 		return false;
 	},
 
-	_replace: function(){
-		 var ed = this.editor;
-		 ed.focus();
-		 var txt = this._findField.attr("value"); 
-		 var repTxt = this._replaceField.attr("value"); 
-
-		 var replaced = 0;
-
-		 if(txt){
-			if(this._replaceDialogTimeout){
-				clearTimeout(this._replaceDialogTimeout);
-				this._replaceDialogTimeout = null;
-				dijit.popup.close(this._replDialog);	
-			}
-
-			var replaceAll = this._replaceAll.attr("value");
-			var caseSensitive = this._caseSensitive.attr("value");
-			var backwards = this._backwards.attr("value");
-
-			var selected = dojo.withGlobal(ed.window, 
-				"getSelectedText", dijit._editor.selection, [null]);
+	_replace: function(/*Boolean?*/ showMessage){
+		// summary:
+		//		This function invokes a replace on the editor document with the noted options for replace
+		// showMessage:
+		//		Indicate if the prompt message is shown or not when the replacement
+		//		reaches the end
+		// tags:
+		//		private
+		// returns:
+		//		Boolean indicating if the content was replaced or not.
+		var isReplaced = false;
+		var ed = this.editor;
+		ed.focus();
+		var txt = this._findField.get("value") || "";
+		var repTxt = this._replaceField.get("value") || "";
+		 
+		if(txt){
+			var caseSensitive = this._caseSensitive.get("value");
+			// Check if it is forced to be forwards or backwards
+			var backwards = this._backwards.get("value");
 			
+			//Replace the current selected text if it matches the pattern
+			var selected = dojo.withGlobal(ed.window, "getSelectedText", dijit._editor.selection, [null]);
 			// Handle checking/replacing current selection.  For some reason on Moz
 			// leading whitespace is trimmed, so we have to trim it down on this check
 			// or we don't always replace.  Moz bug!
@@ -322,51 +605,94 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 				txt = dojo.trim(txt);
 				selected = dojo.trim(selected);
 			}
+			
 			var regExp = this._filterRegexp(txt, !caseSensitive);
 			if(selected && regExp.test(selected)){
 				ed.execCommand("inserthtml", repTxt);
-				replaced++;
+				isReplaced = true;
+			
+				if(backwards){
+					// Move to the beginning of the replaced text
+					// to avoid the infinite recursive replace
+					this._findText(repTxt, caseSensitive, backwards);
+					dojo.withGlobal(ed.window, "collapse", dijit._editor.selection, [true]);
+				}	
 			}
-			 
-			// If replaceAll was set, we have to keep find/replacing till all are replaced.
-			if(replaceAll){
-				// Do the replace via timeouts to avoid locking the browser up for a lot of
-				// replaces.
-				var found = this._findText(txt, caseSensitive, backwards);
-				var loopFind = function(){
-					ed.execCommand("inserthtml", repTxt);
-					replaced++;
-					found = this._findText(txt, caseSensitive, backwards);
-					if(found){
-						setTimeout(dojo.hitch(this, loopFind), 10);
-					}else{
-						this._replDialog.attr("content", 
-							dojo.string.substitute(this._dialogTemplate, {"0": "" + replaced})
-						);
-						dijit.popup.open({popup: this._replDialog, around: this._replaceButton.domNode});
-						this._replaceDialogTimeout = setTimeout(dojo.hitch(this, function(){
-							clearTimeout(this._replaceDialogTimeout);
-							this._replaceDialogTimeout = null;
-							dijit.popup.close(this._replDialog);	
-						}), 5000);
-					}
-				};
-				if(found){
-					var newF = dojo.hitch(this, loopFind);
-					newF();
-				}
+			
+			if(!this._find(false) && showMessage){	// Find the next
+				this._promDialog.set("content", dojo.string.substitute(
+					this._strings["eofDialogText"], {"0": this._strings["eofDialogTextReplace"]}));
+				dijit.popup.open({popup: this._promDialog, around: this._replaceButton.domNode});
+				this._promDialogTimeout = setTimeout(dojo.hitch(this, function(){
+					clearTimeout(this._promDialogTimeout);
+					this._promDialogTimeout = null;
+					dijit.popup.close(this._promDialog);
+				}), 3000);
+				setTimeout(dojo.hitch(this, function(){
+					this.editor.focus();
+				}), 0);
 			}
+			return isReplaced;
+		 }
+	},
+	
+	_replaceAll: function(/*Boolean?*/ showMessage){
+		// summary:
+		//		This function replaces all the matched content on the editor document
+		//		with the noted options for replace
+		// showMessage:
+		//		Indicate if the prompt message is shown or not when the action is done.
+		// tags:
+		//		private
+		var replaced = 0;
+		var backwards = this._backwards.get("value");
+		
+		if(backwards){
+			this.editor.placeCursorAtEnd();
+		}else{
+			this.editor.placeCursorAtStart();
 		}
+		
+		// The _replace will return false if the current selection deos not match
+		// the searched text. So try the first attempt so that the selection 
+		// is always the searched text if there is one that matches
+		if(this._replace(false)) { replaced++; }
+		// Do the replace via timeouts to avoid locking the browser up for a lot of replaces.
+		var loopBody = dojo.hitch(this, function(){
+			if(this._replace(false)){
+				replaced++;
+				setTimeout(loopBody, 10);
+			}else{
+				if(showMessage){
+					this._promDialog.set("content", dojo.string.substitute(
+						this._strings["replaceDialogText"], {"0": "" + replaced}));
+					dijit.popup.open({
+						popup: this._promDialog,
+						around: this._replaceAllButton.domNode
+					});
+					this._promDialogTimeout = setTimeout(dojo.hitch(this, function(){
+						clearTimeout(this._promDialogTimeout);
+						this._promDialogTimeout = null;
+						dijit.popup.close(this._promDialog);
+					}), 3000);
+					setTimeout(dojo.hitch(this, function(){
+						this._findField.focus();
+						this._findField.textBox.focusNode.select();
+					}), 0);
+				}
+			}
+		});
+		loopBody();
 	},
 
-	_findText: function(txt, caseSensitive, backwards){
+	_findText: function(/*String*/ txt, /*Boolean*/ caseSensitive, /*Boolean*/ backwards){
 		// summary:
 		//		This function invokes a find with specific options
 		// txt: String
 		//		The text to locate in the document.
-		// caseSensitive: boolean
+		// caseSensitive: Boolean
 		//		Whether or ot to search case-sensitively.
-		// backwards: boolean
+		// backwards: Boolean
 		//		Whether or not to search backwards in the document.
 		// tags:
 		//		private.
@@ -399,7 +725,7 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 						flags = flags | 1;
 					}
 					//flags = flags |
-					found = txtRg.findText(txt,null,flags);
+					found = txtRg.findText(txt,txtRg.text.length,flags);
 					if(found){
 						txtRg.select();
 					}
@@ -409,7 +735,7 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 		return found;
 	},
 
-	_filterRegexp: function(/*String*/pattern, /*boolean?*/ ignoreCase){
+	_filterRegexp: function(/*String*/ pattern, /*Boolean*/ ignoreCase){
 		// summary:  
 		//		Helper function to convert a simple pattern to a regular expression for matching.
 		// description:
@@ -432,6 +758,8 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 		//	ignoreCase:
 		//		An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing
 		//		By default, it is assumed case sensitive.
+		// tags:
+		//		private
 		var rxp = "";
 		var c = null;
 		for(var i = 0; i < pattern.length; i++){
@@ -472,18 +800,18 @@ dojo.declare("dojox.editor.plugins.FindReplace",[dijit._editor._Plugin],{
 		// summary:
 		//		Cleanup of our custom toolbar.
 		this.inherited(arguments);
-		if(this._replaceDialogTimeout){
-			clearTimeout(this._replaceDialogTimeout);
-			this._replaceDialogTimeout = null;
-			dijit.popup.close(this._replDialog);	
+		if(this._promDialogTimeout){
+			clearTimeout(this._promDialogTimeout);
+			this._promDialogTimeout = null;
+			dijit.popup.close(this._promDialog);	
 		}
 		if(this._frToolbar){
 			this._frToolbar.destroyRecursive();
 			this._frToolbar = null;
 		}
-		if(this._replDialog){
-			this._replDialog.destroyRecursive();
-			this._replDialog = null;
+		if(this._promDialog){
+			this._promDialog.destroyRecursive();
+			this._promDialog = null;
 		}
 	}
 });
@@ -497,4 +825,3 @@ dojo.subscribe(dijit._scopeName + ".Editor.getPlugin",null,function(o){
 		o.plugin = new dojox.editor.plugins.FindReplace({});
 	}
 });
-