viewer#961 Add a notification appearing when user tries to insert a disallowed character

29 files changed, 691 insertions, 471 deletions

diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp
index cbe8cf2dac..23891cad7f 100644
--- a/indra/llui/llfolderview.cpp
+++ b/indra/llui/llfolderview.cpp
@@ -220,7 +220,7 @@ LLFolderView::LLFolderView(const Params& p)
 	params.font(getLabelFontForStyle(LLFontGL::NORMAL));
 	params.max_length.bytes(DB_INV_ITEM_NAME_STR_LEN);
 	params.commit_callback.function(boost::bind(&LLFolderView::commitRename, this, _2));
-	params.prevalidate_callback(&LLTextValidate::validateASCIIPrintableNoPipe);
+	params.prevalidator(&LLTextValidate::validateASCIIPrintableNoPipe);
 	params.commit_on_focus_lost(true);
 	params.visible(false);
 	mRenamer = LLUICtrlFactory::create<LLLineEditor> (params);
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
index 3bf77cdb1c..406cc36119 100644
--- a/indra/llui/lllineeditor.cpp
+++ b/indra/llui/lllineeditor.cpp
@@ -82,9 +82,9 @@ template class LLLineEditor* LLView::getChild<class LLLineEditor>(
 
 LLLineEditor::Params::Params()
 :	max_length(""),
-    keystroke_callback("keystroke_callback"),
-	prevalidate_callback("prevalidate_callback"),
-	prevalidate_input_callback("prevalidate_input_callback"),
+	keystroke_callback("keystroke_callback"),
+	prevalidator("prevalidator"),
+	input_prevalidator("input_prevalidator"),
 	background_image("background_image"),
 	background_image_disabled("background_image_disabled"),
 	background_image_focused("background_image_focused"),
@@ -112,6 +112,8 @@ LLLineEditor::Params::Params()
 	default_text("default_text")
 {
 	changeDefault(mouse_opaque, true);
+	addSynonym(prevalidator, "prevalidate_callback");
+	addSynonym(input_prevalidator, "prevalidate_input_callback");
 	addSynonym(select_on_focus, "select_all_on_focus_received");
 	addSynonym(border, "border");
 	addSynonym(label, "watermark_text");
@@ -159,6 +161,8 @@ LLLineEditor::LLLineEditor(const LLLineEditor::Params& p)
 	mUseBgColor(p.use_bg_color),
 	mHaveHistory(FALSE),
 	mReplaceNewlinesWithSpaces( TRUE ),
+	mPrevalidator(p.prevalidator()),
+	mInputPrevalidator(p.input_prevalidator()),
 	mLabel(p.label),
 	mCursorColor(p.cursor_color()),
 	mBgColor(p.bg_color()),
@@ -212,8 +216,7 @@ LLLineEditor::LLLineEditor(const LLLineEditor::Params& p)
 	}
 	mSpellCheckTimer.reset();
 
-	setPrevalidateInput(p.prevalidate_input_callback());
-	setPrevalidate(p.prevalidate_callback());
+	updateAllowingLanguageInput();
 }
  
 LLLineEditor::~LLLineEditor()
@@ -1210,11 +1213,12 @@ void LLLineEditor::cut()
 		deleteSelection();
 
 		// Validate new string and rollback the if needed.
-		BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
-		if( need_to_rollback )
+		BOOL need_to_rollback = mPrevalidator && !mPrevalidator.validate(mText.getWString());
+		if (need_to_rollback)
 		{
 			rollback.doRollback( this );
 			LLUI::getInstance()->reportBadKeystroke();
+			mPrevalidator.showLastErrorUsingTimeout();
 		}
 		else
 		{
@@ -1343,11 +1347,12 @@ void LLLineEditor::pasteHelper(bool is_primary)
 			deselect();
 
 			// Validate new string and rollback the if needed.
-			BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
-			if( need_to_rollback )
+			BOOL need_to_rollback = mPrevalidator && !mPrevalidator.validate(mText.getWString());
+			if (need_to_rollback)
 			{
 				rollback.doRollback( this );
 				LLUI::getInstance()->reportBadKeystroke();
+				mPrevalidator.showLastErrorUsingTimeout();
 			}
 			else
 			{
@@ -1590,19 +1595,27 @@ BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask )
 				deselect();
 			}
 
-			BOOL need_to_rollback = FALSE;
+			bool prevalidator_failed = false;
 
 			// If read-only, don't allow changes
-			need_to_rollback |= (mReadOnly && (mText.getString() == rollback.getText()));
+			bool need_to_rollback = mReadOnly && (mText.getString() == rollback.getText());
 
 			// Validate new string and rollback the keystroke if needed.
-			need_to_rollback |= (mPrevalidateFunc && !mPrevalidateFunc(mText.getWString()));
+			if (!need_to_rollback && mPrevalidator)
+			{
+				prevalidator_failed = !mPrevalidator.validate(mText.getWString());
+				need_to_rollback |= prevalidator_failed;
+			}
 
 			if (need_to_rollback)
 			{
 				rollback.doRollback(this);
 
 				LLUI::getInstance()->reportBadKeystroke();
+				if (prevalidator_failed)
+				{
+					mPrevalidator.showLastErrorUsingTimeout();
+				}
 			}
 
 			// Notify owner if requested
@@ -1649,20 +1662,18 @@ BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
 
 		deselect();
 
-		BOOL need_to_rollback = FALSE;
-
 		// Validate new string and rollback the keystroke if needed.
-		need_to_rollback |= ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
-
-		if( need_to_rollback )
+		bool need_to_rollback = mPrevalidator && !mPrevalidator.validate(mText.getWString());
+		if (need_to_rollback)
 		{
 			rollback.doRollback( this );
 
 			LLUI::getInstance()->reportBadKeystroke();
+			mPrevalidator.showLastErrorUsingTimeout();
 		}
 
 		// Notify owner if requested
-		if( !need_to_rollback && handled )
+		if (!need_to_rollback && handled)
 		{
 			// HACK! The only usage of this callback doesn't do anything with the character.
 			// We'll have to do something about this if something ever changes! - Doug
@@ -1692,7 +1703,7 @@ void LLLineEditor::doDelete()
 			deleteSelection();
 		}
 		else if ( getCursor() < mText.length())
-		{	
+		{
 			const LLWString& text_to_delete = mText.getWString().substr(getCursor(), 1);
 
 			if (!prevalidateInput(text_to_delete))
@@ -1705,11 +1716,12 @@ void LLLineEditor::doDelete()
 		}
 
 		// Validate new string and rollback the if needed.
-		BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
-		if( need_to_rollback )
+		bool need_to_rollback = mPrevalidator && !mPrevalidator.validate(mText.getWString());
+		if (need_to_rollback)
 		{
-			rollback.doRollback( this );
+			rollback.doRollback(this);
 			LLUI::getInstance()->reportBadKeystroke();
+			mPrevalidator.showLastErrorUsingTimeout();
 		}
 		else
 		{
@@ -2241,7 +2253,7 @@ void LLLineEditor::setFocus( BOOL new_state )
 		// fine on 1.15.0.2, since all prevalidate func reject any
 		// non-ASCII characters.  I'm not sure on future versions,
 		// however.
-		getWindow()->allowLanguageTextInput(this, mPrevalidateFunc == NULL);
+		getWindow()->allowLanguageTextInput(this, !mPrevalidator);
 	}
 }
 
@@ -2260,26 +2272,21 @@ void LLLineEditor::setRect(const LLRect& rect)
 	}
 }
 
-void LLLineEditor::setPrevalidate(LLTextValidate::validate_func_t func)
+void LLLineEditor::setPrevalidate(LLTextValidate::Validator validator)
 {
-	mPrevalidateFunc = func;
+	mPrevalidator = validator;
 	updateAllowingLanguageInput();
 }
 
-void LLLineEditor::setPrevalidateInput(LLTextValidate::validate_func_t func)
+void LLLineEditor::setPrevalidateInput(LLTextValidate::Validator validator)
 {
-	mPrevalidateInputFunc = func;
+	mInputPrevalidator = validator;
 	updateAllowingLanguageInput();
 }
 
 bool LLLineEditor::prevalidateInput(const LLWString& wstr)
 {
-	if (mPrevalidateInputFunc && !mPrevalidateInputFunc(wstr))
-	{
-		return false;
-	}
-
-	return true;
+	return mInputPrevalidator.validate(wstr);
 }
 
 // static
@@ -2421,7 +2428,7 @@ void LLLineEditor::updateAllowingLanguageInput()
 		// test app, no window available
 		return;	
 	}
-	if (hasFocus() && !mReadOnly && !mDrawAsterixes && mPrevalidateFunc == NULL)
+	if (hasFocus() && !mReadOnly && !mDrawAsterixes && !mPrevalidator)
 	{
 		window->allowLanguageTextInput(this, TRUE);
 	}
diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
index 87afa9a1d5..15eb789897 100644
--- a/indra/llui/lllineeditor.h
+++ b/indra/llui/lllineeditor.h
@@ -76,8 +76,8 @@ public:
 		Optional<MaxLength>				max_length;
 		Optional<keystroke_callback_t>	keystroke_callback;
 
-		Optional<LLTextValidate::validate_func_t, LLTextValidate::ValidateTextNamedFuncs>	prevalidate_callback;
-		Optional<LLTextValidate::validate_func_t, LLTextValidate::ValidateTextNamedFuncs>	prevalidate_input_callback;
+		Optional<LLTextValidate::Validator, LLTextValidate::Validators>	prevalidator;
+		Optional<LLTextValidate::Validator, LLTextValidate::Validators>	input_prevalidator;
 		
 		Optional<LLViewBorder::Params>	border;
 
@@ -268,12 +268,12 @@ public:
 	void setTextPadding(S32 left, S32 right);
 
 	// Prevalidation controls which keystrokes can affect the editor
-	void			setPrevalidate( LLTextValidate::validate_func_t func );
+	void			setPrevalidate(LLTextValidate::Validator validator);
 	// This method sets callback that prevents from:
 	// - deleting, selecting, typing, cutting, pasting characters that are not valid.
 	// Also callback that this method sets differs from setPrevalidate in a way that it validates just inputed
 	// symbols, before existing text is modified, but setPrevalidate validates line after it was modified.
-	void			setPrevalidateInput(LLTextValidate::validate_func_t func);
+	void			setPrevalidateInput(LLTextValidate::Validator validator);
 	static BOOL		postvalidateFloat(const std::string &str);
 
 	bool			prevalidateInput(const LLWString& wstr);
@@ -375,8 +375,8 @@ protected:
 	std::list<std::pair<U32, U32> > mMisspellRanges;
 	std::vector<std::string>		mSuggestionList;
 
-	LLTextValidate::validate_func_t mPrevalidateFunc;
-	LLTextValidate::validate_func_t mPrevalidateInputFunc;
+	LLTextValidate::Validator mPrevalidator;
+	LLTextValidate::Validator mInputPrevalidator;
 
 	LLFrameTimer mKeystrokeTimer;
 	LLTimer		mTripleClickTimer;
diff --git a/indra/llui/llmultisliderctrl.cpp b/indra/llui/llmultisliderctrl.cpp
index b3df7c154b..b651d85970 100644
--- a/indra/llui/llmultisliderctrl.cpp
+++ b/indra/llui/llmultisliderctrl.cpp
@@ -138,7 +138,7 @@ LLMultiSliderCtrl::LLMultiSliderCtrl(const LLMultiSliderCtrl::Params& p)
 			params.font(p.font);
 			params.max_length.bytes(MAX_STRING_LENGTH);
 			params.commit_callback.function(LLMultiSliderCtrl::onEditorCommit);
-			params.prevalidate_callback(&LLTextValidate::validateFloat);
+			params.prevalidator(&LLTextValidate::validateFloat);
 			params.follows.flags(FOLLOWS_LEFT | FOLLOWS_BOTTOM);
 			mEditor = LLUICtrlFactory::create<LLLineEditor> (params);
 			mEditor->setFocusReceivedCallback( boost::bind(LLMultiSliderCtrl::onEditorGainFocus, _1, this) );
diff --git a/indra/llui/llresmgr.cpp b/indra/llui/llresmgr.cpp
index d65c220974..f18569d47f 100644
--- a/indra/llui/llresmgr.cpp
+++ b/indra/llui/llresmgr.cpp
@@ -47,9 +47,9 @@ void LLResMgr::setLocale( LLLOCALE_ID locale_id )
 	mLocale = locale_id;
 }
 
-char LLResMgr::getDecimalPoint() const					
+char LLResMgr::getDecimalPoint() const
 { 
-	char decimal = localeconv()->decimal_point[0]; 
+	char decimal = localeconv()->decimal_point[0];
 
 #if LL_DARWIN
 	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
@@ -62,9 +62,9 @@ char LLResMgr::getDecimalPoint() const
 	return decimal;
 }
 
-char LLResMgr::getThousandsSeparator() const			
+char LLResMgr::getThousandsSeparator() const
 {
-	char separator = localeconv()->thousands_sep[0]; 
+	char separator = localeconv()->thousands_sep[0];
 
 #if LL_DARWIN
 	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
@@ -79,7 +79,7 @@ char LLResMgr::getThousandsSeparator() const
 
 char LLResMgr::getMonetaryDecimalPoint() const
 {
-	char decimal = localeconv()->mon_decimal_point[0]; 
+	char decimal = localeconv()->mon_decimal_point[0];
 
 #if LL_DARWIN
 	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
@@ -92,9 +92,9 @@ char LLResMgr::getMonetaryDecimalPoint() const
 	return decimal;
 }
 
-char LLResMgr::getMonetaryThousandsSeparator() const	
+char LLResMgr::getMonetaryThousandsSeparator() const
 {
-	char separator = localeconv()->mon_thousands_sep[0]; 
+	char separator = localeconv()->mon_thousands_sep[0];
 
 #if LL_DARWIN
 	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
diff --git a/indra/llui/llsliderctrl.cpp b/indra/llui/llsliderctrl.cpp
index d80a434f22..e6cb739702 100644
--- a/indra/llui/llsliderctrl.cpp
+++ b/indra/llui/llsliderctrl.cpp
@@ -167,7 +167,7 @@ LLSliderCtrl::LLSliderCtrl(const LLSliderCtrl::Params& p)
 			}
 			
 			line_p.commit_callback.function(&LLSliderCtrl::onEditorCommit);
-			line_p.prevalidate_callback(&LLTextValidate::validateFloat);
+			line_p.prevalidator(&LLTextValidate::validateFloat);
 			mEditor = LLUICtrlFactory::create<LLLineEditor>(line_p);
 
 			mEditor->setFocusReceivedCallback( boost::bind(&LLSliderCtrl::onEditorGainFocus, _1, this ));
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index e9ddc6cf0b..875a5faa2b 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -232,17 +232,18 @@ private:
 ///////////////////////////////////////////////////////////////////
 LLTextEditor::Params::Params()
 :	default_text("default_text"),
-	prevalidate_callback("prevalidate_callback"),
+	prevalidator("prevalidator"),
 	embedded_items("embedded_items", false),
 	ignore_tab("ignore_tab", true),
 	auto_indent("auto_indent", true),
 	default_color("default_color"),
-    commit_on_focus_lost("commit_on_focus_lost", false),
+	commit_on_focus_lost("commit_on_focus_lost", false),
 	show_context_menu("show_context_menu"),
 	show_emoji_helper("show_emoji_helper"),
 	enable_tooltip_paste("enable_tooltip_paste")
 {
-	addSynonym(prevalidate_callback, "text_type");
+	addSynonym(prevalidator, "prevalidate_callback");
+	addSynonym(prevalidator, "text_type");
 }
 
 LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
@@ -253,16 +254,17 @@ LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
 	mLastCmd( NULL ),
 	mDefaultColor( p.default_color() ),
 	mAutoIndent(p.auto_indent),
+	mParseOnTheFly(false),
 	mCommitOnFocusLost( p.commit_on_focus_lost),
 	mAllowEmbeddedItems( p.embedded_items ),
 	mMouseDownX(0),
 	mMouseDownY(0),
 	mTabsToNextField(p.ignore_tab),
-	mPrevalidateFunc(p.prevalidate_callback()),
+	mPrevalidator(p.prevalidator()),
 	mShowContextMenu(p.show_context_menu),
 	mShowEmojiHelper(p.show_emoji_helper),
 	mEnableTooltipPaste(p.enable_tooltip_paste),
-	mPassDelete(FALSE),
+	mPassDelete(false),
 	mKeepSelectionOnReturn(false)
 {
 	mSourceID.generate();
@@ -278,7 +280,7 @@ LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
 	addChild( mBorder );
 	setText(p.default_text());
 	
-	mParseOnTheFly = TRUE;
+	mParseOnTheFly = true;
 }
 
 void LLTextEditor::initFromParams( const LLTextEditor::Params& p)
@@ -319,11 +321,13 @@ LLTextEditor::~LLTextEditor()
 void LLTextEditor::setText(const LLStringExplicit &utf8str, const LLStyle::Params& input_params)
 {
 	// validate incoming text if necessary
-	if (mPrevalidateFunc)
+	if (mPrevalidator)
 	{
-		LLWString test_text = utf8str_to_wstring(utf8str);
-		if (!mPrevalidateFunc(test_text))
+		if (!mPrevalidator.validate(utf8str))
 		{
+			LLUI::getInstance()->reportBadKeystroke();
+			mPrevalidator.showLastErrorUsingTimeout();
+
 			// not valid text, nothing to do
 			return;
 		}
@@ -332,9 +336,9 @@ void LLTextEditor::setText(const LLStringExplicit &utf8str, const LLStyle::Param
 	blockUndo();
 	deselect();
 	
-	mParseOnTheFly = FALSE;
+	mParseOnTheFly = false;
 	LLTextBase::setText(utf8str, input_params);
-	mParseOnTheFly = TRUE;
+	mParseOnTheFly = true;
 
 	resetDirty();
 }
@@ -609,7 +613,7 @@ void LLTextEditor::indentSelectedLines( S32 spaces )
 
 		// Disabling parsing on the fly to avoid updating text segments
 		// until all indentation commands are executed.
-		mParseOnTheFly = FALSE;
+		mParseOnTheFly = false;
 
 		// Find each start-of-line and indent it
 		do
@@ -636,7 +640,7 @@ void LLTextEditor::indentSelectedLines( S32 spaces )
 		}
 		while( cur < right );
 
-		mParseOnTheFly = TRUE;
+		mParseOnTheFly = true;
 
 		if( (right < getLength()) && (text[right] == '\n') )
 		{
@@ -986,10 +990,12 @@ S32 LLTextEditor::execute( TextCmd* cmd )
 		mUndoStack.push_front(cmd);
 		mLastCmd = cmd;
 
-		bool need_to_rollback = mPrevalidateFunc 
-								&& !mPrevalidateFunc(getViewModel()->getDisplay());
+		bool need_to_rollback = mPrevalidator && !mPrevalidator.validate(getViewModel()->getDisplay());
 		if (need_to_rollback)
 		{
+			LLUI::getInstance()->reportBadKeystroke();
+			mPrevalidator.showLastErrorUsingTimeout();
+
 			// get rid of this last command and clean up undo stack
 			undo();
 
@@ -1125,16 +1131,15 @@ void LLTextEditor::removeChar()
 // Add a single character to the text
 S32 LLTextEditor::addChar(S32 pos, llwchar wc)
 {
-	if ( (wstring_utf8_length( getWText() ) + wchar_utf8_length( wc ))  > mMaxTextByteLength)
+	if ((wstring_utf8_length(getWText()) + wchar_utf8_length(wc)) > mMaxTextByteLength)
 	{
-		make_ui_sound("UISndBadKeystroke");
+		LLUI::getInstance()->reportBadKeystroke();
 		return 0;
 	}
 
 	if (mLastCmd && mLastCmd->canExtend(pos))
 	{
-		S32 delta = 0;
-		if (mPrevalidateFunc)
+		if (mPrevalidator)
 		{
 			// get a copy of current text contents
 			LLWString test_string(getViewModel()->getDisplay());
@@ -1142,28 +1147,31 @@ S32 LLTextEditor::addChar(S32 pos, llwchar wc)
 			// modify text contents as if this addChar succeeded
 			llassert(pos <= (S32)test_string.size());
 			test_string.insert(pos, 1, wc);
-			if (!mPrevalidateFunc( test_string))
+			if (!mPrevalidator.validate(test_string))
 			{
+				LLUI::getInstance()->reportBadKeystroke();
+				mPrevalidator.showLastErrorUsingTimeout();
 				return 0;
 			}
 		}
+
+		S32 delta = 0;
 		mLastCmd->extendAndExecute(this, pos, wc, &delta);
 
 		return delta;
 	}
-	else
-	{
-		return execute(new TextCmdAddChar(pos, FALSE, wc, LLTextSegmentPtr()));
-	}
+
+	return execute(new TextCmdAddChar(pos, FALSE, wc, LLTextSegmentPtr()));
 }
 
 void LLTextEditor::addChar(llwchar wc)
 {
-	if( !getEnabled() )
+	if (!getEnabled())
 	{
 		return;
 	}
-	if( hasSelection() )
+
+	if (hasSelection())
 	{
 		deleteSelection(TRUE);
 	}
@@ -1508,7 +1516,13 @@ void LLTextEditor::pastePrimary()
 // paste from primary (itsprimary==true) or clipboard (itsprimary==false)
 void LLTextEditor::pasteHelper(bool is_primary)
 {
-	mParseOnTheFly = FALSE;
+    struct BoolReset
+    {
+        BoolReset(bool& value) : mValuePtr(&value) { *mValuePtr = false; }
+        ~BoolReset() { *mValuePtr = true; }
+        bool* mValuePtr;
+    } reset(mParseOnTheFly);
+
 	bool can_paste_it;
 	if (is_primary)
 	{
@@ -1550,7 +1564,6 @@ void LLTextEditor::pasteHelper(bool is_primary)
 	deselect();
 
 	onKeyStroke();
-	mParseOnTheFly = TRUE;
 }
 
 
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index 521405ec25..ded1444008 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -54,7 +54,7 @@ public:
 	struct Params : public LLInitParam::Block<Params, LLTextBase::Params>
 	{
 		Optional<std::string>	default_text;
-		Optional<LLTextValidate::validate_func_t, LLTextValidate::ValidateTextNamedFuncs>	prevalidate_callback;
+		Optional<LLTextValidate::Validator, LLTextValidate::Validators>	prevalidator;
 
 		Optional<bool>			embedded_items,
 								ignore_tab,
@@ -337,7 +337,7 @@ private:
 	LLCoordGL		mLastIMEPosition;		// Last position of the IME editor
 
 	keystroke_signal_t mKeystrokeSignal;
-	LLTextValidate::validate_func_t mPrevalidateFunc;
+	LLTextValidate::Validator mPrevalidator;
 
 	LLHandle<LLContextMenu> mContextMenuHandle;
 }; // end class LLTextEditor
diff --git a/indra/llui/lltextvalidate.cpp b/indra/llui/lltextvalidate.cpp
index bfe0a5bb5d..9e27ed6232 100644
--- a/indra/llui/lltextvalidate.cpp
+++ b/indra/llui/lltextvalidate.cpp
@@ -27,330 +27,452 @@
 // Text editor widget to let users enter a single line.
 
 #include "linden_common.h"
- 
+
 #include "lltextvalidate.h"
+
+#include "llnotificationsutil.h"
+#include "lltrans.h"
+
 #include "llresmgr.h" // for LLLocale
 
 namespace LLTextValidate
 {
-	void ValidateTextNamedFuncs::declareValues()
-	{
-		declare("ascii", validateASCII);
-		declare("float", validateFloat);
-		declare("int", validateInt);
-		declare("positive_s32", validatePositiveS32);
-		declare("non_negative_s32", validateNonNegativeS32);
-		declare("alpha_num", validateAlphaNum);
-		declare("alpha_num_space", validateAlphaNumSpace);
-		declare("ascii_printable_no_pipe", validateASCIIPrintableNoPipe);
-		declare("ascii_printable_no_space", validateASCIIPrintableNoSpace);
-		declare("ascii_with_newline", validateASCIIWithNewLine);
-	}
-
-	// Limits what characters can be used to [1234567890.-] with [-] only valid in the first position.
-	// Does NOT ensure that the string is a well-formed number--that's the job of post-validation--for
-	// the simple reasons that intermediate states may be invalid even if the final result is valid.
-	// 
-	bool validateFloat(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		bool success = TRUE;
-		LLWString trimmed = str;
-		LLWStringUtil::trim(trimmed);
-		S32 len = trimmed.length();
-		if( 0 < len )
-		{
-			// May be a comma or period, depending on the locale
-			llwchar decimal_point = (llwchar)LLResMgr::getInstance()->getDecimalPoint();
-
-			S32 i = 0;
-
-			// First character can be a negative sign
-			if( '-' == trimmed[0] )
-			{
-				i++;
-			}
-
-			for( ; i < len; i++ )
-			{
-				if( (decimal_point != trimmed[i] ) && !LLStringOps::isDigit( trimmed[i] ) )
-				{
-					success = FALSE;
-					break;
-				}
-			}
-		}		
-
-		return success;
-	}
-
-	// Limits what characters can be used to [1234567890-] with [-] only valid in the first position.
-	// Does NOT ensure that the string is a well-formed number--that's the job of post-validation--for
-	// the simple reasons that intermediate states may be invalid even if the final result is valid.
-	//
-	bool validateInt(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		bool success = TRUE;
-		LLWString trimmed = str;
-		LLWStringUtil::trim(trimmed);
-		S32 len = trimmed.length();
-		if( 0 < len )
-		{
-			S32 i = 0;
-
-			// First character can be a negative sign
-			if( '-' == trimmed[0] )
-			{
-				i++;
-			}
-
-			for( ; i < len; i++ )
-			{
-				if( !LLStringOps::isDigit( trimmed[i] ) )
-				{
-					success = FALSE;
-					break;
-				}
-			}
-		}		
-
-		return success;
-	}
-
-	bool validatePositiveS32(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		LLWString trimmed = str;
-		LLWStringUtil::trim(trimmed);
-		S32 len = trimmed.length();
-		bool success = TRUE;
-		if(0 < len)
-		{
-			if(('-' == trimmed[0]) || ('0' == trimmed[0]))
-			{
-				success = FALSE;
-			}
-			S32 i = 0;
-			while(success && (i < len))
-			{
-				if(!LLStringOps::isDigit(trimmed[i++]))
-				{
-					success = FALSE;
-				}
-			}
-		}
-		if (success)
-		{
-			S32 val = strtol(wstring_to_utf8str(trimmed).c_str(), NULL, 10);
-			if (val <= 0)
-			{
-				success = FALSE;
-			}
-		}
-		return success;
-	}
-
-	bool validateNonNegativeS32(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		LLWString trimmed = str;
-		LLWStringUtil::trim(trimmed);
-		S32 len = trimmed.length();
-		bool success = TRUE;
-		if(0 < len)
-		{
-			if('-' == trimmed[0])
-			{
-				success = FALSE;
-			}
-			S32 i = 0;
-			while(success && (i < len))
-			{
-				if(!LLStringOps::isDigit(trimmed[i++]))
-				{
-					success = FALSE;
-				}
-			}
-		}
-		if (success)
-		{
-			S32 val = strtol(wstring_to_utf8str(trimmed).c_str(), NULL, 10);
-			if (val < 0)
-			{
-				success = FALSE;
-			}
-		}
-		return success;
-	}
-
-	bool validateNonNegativeS32NoSpace(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		LLWString test_str = str;
-		S32 len = test_str.length();
-		bool success = TRUE;
-		if(0 < len)
-		{
-			if('-' == test_str[0])
-			{
-				success = FALSE;
-			}
-			S32 i = 0;
-			while(success && (i < len))
-			{
-				if(!LLStringOps::isDigit(test_str[i]) || LLStringOps::isSpace(test_str[i++]))
-				{
-					success = FALSE;
-				}
-			}
-		}
-		if (success)
-		{
-			S32 val = strtol(wstring_to_utf8str(test_str).c_str(), NULL, 10);
-			if (val < 0)
-			{
-				success = FALSE;
-			}
-		}
-		return success;
-	}
-
-	bool validateAlphaNum(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		bool rv = TRUE;
-		S32 len = str.length();
-		if(len == 0) return rv;
-		while(len--)
-		{
-			if( !LLStringOps::isAlnum((char)str[len]) )
-			{
-				rv = FALSE;
-				break;
-			}
-		}
-		return rv;
-	}
-
-	bool validateAlphaNumSpace(const LLWString &str)
-	{
-		LLLocale locale(LLLocale::USER_LOCALE);
-
-		bool rv = TRUE;
-		S32 len = str.length();
-		if(len == 0) return rv;
-		while(len--)
-		{
-			if(!(LLStringOps::isAlnum((char)str[len]) || (' ' == str[len])))
-			{
-				rv = FALSE;
-				break;
-			}
-		}
-		return rv;
-	}
-
-	// Used for most names of things stored on the server, due to old file-formats
-	// that used the pipe (|) for multiline text storage.  Examples include
-	// inventory item names, parcel names, object names, etc.
-	bool validateASCIIPrintableNoPipe(const LLWString &str)
-	{
-		bool rv = TRUE;
-		S32 len = str.length();
-		if(len == 0) return rv;
-		while(len--)
-		{
-			llwchar wc = str[len];
-			if (wc < 0x20
-				|| wc > 0x7f
-				|| wc == '|')
-			{
-				rv = FALSE;
-				break;
-			}
-			if(!(wc == ' '
-				 || LLStringOps::isAlnum((char)wc)
-				 || LLStringOps::isPunct((char)wc) ) )
-			{
-				rv = FALSE;
-				break;
-			}
-		}
-		return rv;
-	}
-
-
-	// Used for avatar names
-	bool validateASCIIPrintableNoSpace(const LLWString &str)
-	{
-		bool rv = TRUE;
-		S32 len = str.length();
-		if(len == 0) return rv;
-		while(len--)
-		{
-			llwchar wc = str[len];
-			if (wc < 0x20
-				|| wc > 0x7f
-				|| LLStringOps::isSpace(wc))
-			{
-				rv = FALSE;
-				break;
-			}
-			if( !(LLStringOps::isAlnum((char)str[len]) ||
-				  LLStringOps::isPunct((char)str[len]) ) )
-			{
-				rv = FALSE;
-				break;
-			}
-		}
-		return rv;
-	}
-
-	bool validateASCII(const LLWString &str)
-	{
-		bool rv = TRUE;
-		S32 len = str.length();
-		while(len--)
-		{
-			if (str[len] < 0x20 || str[len] > 0x7f)
-			{
-				rv = FALSE;
-				break;
-			}
-		}
-		return rv;
-	}
-
-	bool validateASCIINoLeadingSpace(const LLWString &str)
-	{
-		if (LLStringOps::isSpace(str[0]))
-		{
-			return FALSE;
-		}
-		return validateASCII(str);
-	}
-
-	// Used for multiline text stored on the server.
-	// Example is landmark description in Places SP.
-	bool validateASCIIWithNewLine(const LLWString &str)
-	{
-		bool rv = TRUE;
-		S32 len = str.length();
-		while(len--)
-		{
-			if ((str[len] < 0x20 && str[len] != 0xA) || str[len] > 0x7f)
-			{
-				rv = FALSE;
-				break;
-			}
-		}
-		return rv;
-	}
+
+static S32 strtol(const std::string& str) { return ::strtol(str.c_str(), NULL, 10); }
+static S32 strtol(const LLWString& str) { return ::strtol(wstring_to_utf8str(str).c_str(), NULL, 10); }
+
+static LLSD llsd(const std::string& str) { return LLSD(str); }
+static LLSD llsd(const LLWString& str) { return LLSD(wstring_to_utf8str(str)); }
+template <class CHAR>
+LLSD llsd(CHAR ch) { return llsd(std::basic_string<CHAR>(1, ch)); }
+
+void ValidatorImpl::setLastErrorShowTime()
+{
+    mLastErrorShowTime = (U32Seconds)LLTimer::getTotalTime();
+}
+
+void Validator::showLastErrorUsingTimeout(U32 timeout)
+{
+    if (mImpl && (U32Seconds)LLTimer::getTotalTime() >= mImpl->getLastErrorShowTime() + timeout)
+    {
+        mImpl->setLastErrorShowTime();
+        std::string reason = LLTrans::getString(mImpl->getLastErrorName(), mImpl->getLastErrorValues());
+        LLNotificationsUtil::add("InvalidKeystroke", LLSD().with("REASON", reason));
+    }
 }
+
+// Limits what characters can be used to [1234567890.-] with [-] only valid in the first position.
+// Does NOT ensure that the string is a well-formed number--that's the job of post-validation--for
+// the simple reasons that intermediate states may be invalid even if the final result is valid.
+class ValidatorFloat : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR> &str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        std::basic_string<CHAR> trimmed = str;
+        LLStringUtilBase<CHAR>::trim(trimmed);
+        S32 len = trimmed.length();
+        if (0 < len)
+        {
+            // May be a comma or period, depending on the locale
+            CHAR decimal_point = LLResMgr::getInstance()->getDecimalPoint();
+
+            S32 i = 0;
+
+            // First character can be a negative sign
+            if ('-' == trimmed.front())
+            {
+                i++;
+            }
+
+            for (; i < len; i++)
+            {
+                CHAR ch = trimmed[i];
+                if ((decimal_point != ch) && !LLStringOps::isDigit(ch))
+                {
+                    return setError("Validator_ShouldBeDigitOrDot", LLSD().with("NR", i + 1).with("CH", llsd(ch)));
+                }
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorFloatImpl;
+Validator validateFloat(validatorFloatImpl);
+
+// Limits what characters can be used to [1234567890-] with [-] only valid in the first position.
+// Does NOT ensure that the string is a well-formed number--that's the job of post-validation--for
+// the simple reasons that intermediate states may be invalid even if the final result is valid.
+class ValidatorInt : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR> &str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        std::basic_string<CHAR> trimmed = str;
+        LLStringUtilBase<CHAR>::trim(trimmed);
+        S32 len = trimmed.length();
+        if (0 < len)
+        {
+            S32 i = 0;
+
+            // First character can be a negative sign
+            if ('-' == trimmed.front())
+            {
+                i++;
+            }
+
+            for (; i < len; i++)
+            {
+                CHAR ch = trimmed[i];
+                if (!LLStringOps::isDigit(ch))
+                {
+                    return setError("Validator_ShouldBeDigit", LLSD().with("NR", i + 1).with("CH", llsd(ch)));
+                }
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorIntImpl;
+Validator validateInt(validatorIntImpl);
+
+class ValidatorPositiveS32 : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        std::basic_string<CHAR> trimmed = str;
+        LLStringUtilBase<CHAR>::trim(trimmed);
+        S32 len = trimmed.length();
+        if (0 < len)
+        {
+            CHAR ch = trimmed.front();
+
+            if (('-' == ch) || ('0' == ch))
+            {
+                return setError("Validator_ShouldNotBeMinusOrZero", LLSD().with("CH", llsd(ch)));
+            }
+
+            for (S32 i = 0; i < len; ++i)
+            {
+                ch = trimmed[i];
+                if (!LLStringOps::isDigit(ch))
+                {
+                    return setError("Validator_ShouldBeDigit", LLSD().with("NR", i + 1).with("CH", llsd(ch)));
+                }
+            }
+        }
+
+        S32 val = strtol(trimmed);
+        if (val <= 0)
+        {
+            return setError("Validator_InvalidNumericString", LLSD().with("STR", llsd(trimmed)));
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorPositiveS32Impl;
+Validator validatePositiveS32(validatorPositiveS32Impl);
+
+class ValidatorNonNegativeS32 : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        std::basic_string<CHAR> trimmed = str;
+        LLStringUtilBase<CHAR>::trim(trimmed);
+        S32 len = trimmed.length();
+        if (0 < len)
+        {
+            CHAR ch = trimmed.front();
+
+            if ('-' == ch)
+            {
+                return setError("Validator_ShouldNotBeMinus", LLSD().with("CH", llsd(ch)));
+            }
+
+            for (S32 i = 0; i < len; ++i)
+            {
+                ch = trimmed[i];
+                if (!LLStringOps::isDigit(ch))
+                {
+                    return setError("Validator_ShouldBeDigit", LLSD().with("NR", i + 1).with("CH", llsd(ch)));
+                }
+            }
+        }
+
+        S32 val = strtol(trimmed);
+        if (val < 0)
+        {
+            return setError("Validator_InvalidNumericString", LLSD().with("STR", llsd(trimmed)));
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorNonNegativeS32Impl;
+Validator validateNonNegativeS32(validatorNonNegativeS32Impl);
+
+class ValidatorNonNegativeS32NoSpace : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        std::basic_string<CHAR> test_str = str;
+        S32 len = test_str.length();
+        if (0 < len)
+        {
+            CHAR ch = test_str.front();
+
+            if ('-' == ch)
+            {
+                return setError("Validator_ShouldNotBeMinus", LLSD().with("CH", llsd(ch)));
+            }
+
+            for (S32 i = 0; i < len; ++i)
+            {
+                ch = test_str[i];
+                if (!LLStringOps::isDigit(ch) || LLStringOps::isSpace(ch))
+                {
+                    return setError("Validator_ShouldBeDigitNotSpace", LLSD().with("NR", i + 1).with("CH", llsd(ch)));
+                }
+            }
+        }
+
+        S32 val = strtol(test_str);
+        if (val < 0)
+        {
+            return setError("Validator_InvalidNumericString", LLSD().with("STR", llsd(test_str)));
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorNonNegativeS32NoSpaceImpl;
+Validator validateNonNegativeS32NoSpace(validatorNonNegativeS32NoSpaceImpl);
+
+class ValidatorAlphaNum : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        S32 len = str.length();
+        while (len--)
+        {
+            CHAR ch = str[len];
+
+            if (!LLStringOps::isAlnum(ch))
+            {
+                return setError("Validator_ShouldBeDigitOrAlpha", LLSD().with("NR", len + 1).with("CH", llsd(ch)));
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorAlphaNumImpl;
+Validator validateAlphaNum(validatorAlphaNumImpl);
+
+class ValidatorAlphaNumSpace : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        LLLocale locale(LLLocale::USER_LOCALE);
+
+        S32 len = str.length();
+        while (len--)
+        {
+            CHAR ch = str[len];
+
+            if (!LLStringOps::isAlnum(ch) && (' ' != ch))
+            {
+                return setError("Validator_ShouldBeDigitOrAlphaOrSpace", LLSD().with("NR", len + 1).with("CH", llsd(ch)));
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorAlphaNumSpaceImpl;
+Validator validateAlphaNumSpace(validatorAlphaNumSpaceImpl);
+
+// Used for most names of things stored on the server, due to old file-formats
+// that used the pipe (|) for multiline text storage.  Examples include
+// inventory item names, parcel names, object names, etc.
+class ValidatorASCIIPrintableNoPipe : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        S32 len = str.length();
+        while (len--)
+        {
+            CHAR ch = str[len];
+
+            if (ch < 0x20 || ch > 0x7f || ch == '|' ||
+                (ch != ' ' && !LLStringOps::isAlnum(ch) && !LLStringOps::isPunct(ch)))
+            {
+                return setError("Validator_ShouldBeDigitOrAlphaOrPunct", LLSD().with("NR", len + 1).with("CH", llsd(ch)));
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorASCIIPrintableNoPipeImpl;
+Validator validateASCIIPrintableNoPipe(validatorASCIIPrintableNoPipeImpl);
+
+// Used for avatar names
+class ValidatorASCIIPrintableNoSpace : public ValidatorImpl
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        S32 len = str.length();
+        while (len--)
+        {
+            CHAR ch = str[len];
+
+            if (ch <= 0x20 || ch > 0x7f || LLStringOps::isSpace(ch) ||
+                (!LLStringOps::isAlnum(ch) && !LLStringOps::isPunct(ch)))
+            {
+                return setError("Validator_ShouldBeDigitOrAlphaOrPunctNotSpace", LLSD().with("NR", len + 1).with("CH", llsd(ch)));
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorASCIIPrintableNoSpaceImpl;
+Validator validateASCIIPrintableNoSpace(validatorASCIIPrintableNoSpaceImpl);
+
+class ValidatorASCII : public ValidatorImpl
+{
+protected:
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        S32 len = str.length();
+        while (len--)
+        {
+            CHAR ch = str[len];
+
+            if (ch < 0x20 || ch > 0x7f)
+            {
+                return setError("Validator_ShouldBeASCII", LLSD().with("NR", len + 1).with("CH", llsd(ch)));
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorASCIIImpl;
+Validator validateASCII(validatorASCIIImpl);
+
+class ValidatorASCIINoLeadingSpace : public ValidatorASCII
+{
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        if (LLStringOps::isSpace(str.front()))
+        {
+            return false;
+        }
+
+        return ValidatorASCII::validate<CHAR>(str);
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorASCIINoLeadingSpaceImpl;
+Validator validateASCIINoLeadingSpace(validatorASCIINoLeadingSpaceImpl);
+
+class ValidatorASCIIWithNewLine : public ValidatorImpl
+{
+    // Used for multiline text stored on the server.
+    // Example is landmark description in Places SP.
+    template <class CHAR>
+    bool validate(const std::basic_string<CHAR>& str)
+    {
+        S32 len = str.length();
+        while (len--)
+        {
+            CHAR ch = str[len];
+
+            if ((ch < 0x20 && ch != 0xA) || ch > 0x7f)
+            {
+                return setError("Validator_ShouldBeNewLineOrASCII", LLSD().with("NR", len + 1).with("CH", llsd(ch)));
+            }
+        }
+
+        return resetError();
+    }
+
+public:
+    /*virtual*/ bool validate(const std::string& str) override { return validate<char>(str); }
+    /*virtual*/ bool validate(const LLWString& str) override { return validate<llwchar>(str); }
+} validatorASCIIWithNewLineImpl;
+Validator validateASCIIWithNewLine(validatorASCIIWithNewLineImpl);
+
+void Validators::declareValues()
+{
+    declare("ascii", validateASCII);
+    declare("float", validateFloat);
+    declare("int", validateInt);
+    declare("positive_s32", validatePositiveS32);
+    declare("non_negative_s32", validateNonNegativeS32);
+    declare("alpha_num", validateAlphaNum);
+    declare("alpha_num_space", validateAlphaNumSpace);
+    declare("ascii_printable_no_pipe", validateASCIIPrintableNoPipe);
+    declare("ascii_printable_no_space", validateASCIIPrintableNoSpace);
+    declare("ascii_with_newline", validateASCIIWithNewLine);
+}
+
+} // namespace LLTextValidate
diff --git a/indra/llui/lltextvalidate.h b/indra/llui/lltextvalidate.h
index e2b6c313d6..2c2941de7f 100644
--- a/indra/llui/lltextvalidate.h
+++ b/indra/llui/lltextvalidate.h
@@ -34,27 +34,68 @@
 
 namespace LLTextValidate
 {
-	typedef boost::function<BOOL (const LLWString &wstr)> validate_func_t;
-
-	struct ValidateTextNamedFuncs
-	:	public LLInitParam::TypeValuesHelper<validate_func_t, ValidateTextNamedFuncs>
-	{
-		static void declareValues();
-	};
-
-	bool	validateFloat(const LLWString &str );
-	bool	validateInt(const LLWString &str );
-	bool	validatePositiveS32(const LLWString &str);
-	bool	validateNonNegativeS32(const LLWString &str);
-	bool 	validateNonNegativeS32NoSpace(const LLWString &str);
-	bool	validateAlphaNum(const LLWString &str );
-	bool	validateAlphaNumSpace(const LLWString &str );
-	bool	validateASCIIPrintableNoPipe(const LLWString &str); 
-	bool	validateASCIIPrintableNoSpace(const LLWString &str);
-	bool	validateASCII(const LLWString &str);
-	bool	validateASCIINoLeadingSpace(const LLWString &str);
-	bool	validateASCIIWithNewLine(const LLWString &str);
-}
+    class ValidatorImpl
+    {
+    public:
+        ValidatorImpl() {}
+        virtual ~ValidatorImpl() {}
 
+        virtual bool validate(const std::string& str) = 0;
+        virtual bool validate(const LLWString& str) = 0;
+
+        bool setError(std::string name, LLSD values = LLSD()) { return mLastErrorName = name, mLastErrorValues = values, false; }
+        bool resetError() { return mLastErrorName.clear(), mLastErrorValues.clear(), true; }
+        const std::string& getLastErrorName() const { return mLastErrorName; }
+        const LLSD& getLastErrorValues() const { return mLastErrorValues; }
+
+        void setLastErrorShowTime();
+        U32 getLastErrorShowTime() const { return mLastErrorShowTime; }
+
+    protected:
+        std::string mLastErrorName;
+        LLSD mLastErrorValues;
+        U32 mLastErrorShowTime { 0 };
+    };
+
+    class Validator
+    {
+    public:
+        Validator() : mImpl(nullptr) {}
+        Validator(ValidatorImpl& impl) : mImpl(&impl) {}
+        Validator(const Validator& validator) : mImpl(validator.mImpl) {}
+        Validator(const Validator* validator) : mImpl(validator->mImpl) {}
+
+        bool validate(const std::string& str) const { return !mImpl || mImpl->validate(str); }
+        bool validate(const LLWString& str) const { return !mImpl || mImpl->validate(str); }
+
+        operator bool() const { return mImpl; }
+
+        static const U32 SHOW_LAST_ERROR_TIMEOUT_SEC = 30;
+        void showLastErrorUsingTimeout(U32 timeout = SHOW_LAST_ERROR_TIMEOUT_SEC);
+
+    private:
+        ValidatorImpl* mImpl;
+    };
+
+    // Available validators
+    extern Validator validateFloat;
+    extern Validator validateInt;
+    extern Validator validatePositiveS32;
+    extern Validator validateNonNegativeS32;
+    extern Validator validateNonNegativeS32NoSpace;
+    extern Validator validateAlphaNum;
+    extern Validator validateAlphaNumSpace;
+    extern Validator validateASCIIPrintableNoPipe;
+    extern Validator validateASCIIPrintableNoSpace;
+    extern Validator validateASCII;
+    extern Validator validateASCIINoLeadingSpace;
+    extern Validator validateASCIIWithNewLine;
+
+    // Add available validators to the internal map
+    struct Validators : public LLInitParam::TypeValuesHelper<Validator, Validators>
+    {
+        static void declareValues();
+    };
+};
 
 #endif
diff --git a/indra/llui/lltimectrl.cpp b/indra/llui/lltimectrl.cpp
index 516057f8fd..564d0b6264 100644
--- a/indra/llui/lltimectrl.cpp
+++ b/indra/llui/lltimectrl.cpp
@@ -49,6 +49,36 @@ const U32 HOURS_MAX = 12;
 const U32 MINUTES_PER_HOUR = 60;
 const U32 MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
 
+class LLTimeValidatorImpl : public LLTextValidate::ValidatorImpl
+{
+public:
+    // virtual
+    bool validate(const std::string& str) override
+    {
+        std::string hours = LLTimeCtrl::getHoursString(str);
+        if (!LLTimeCtrl::isHoursStringValid(hours))
+            return setError("ValidatorInvalidHours", LLSD().with("STR", hours));
+
+        std::string minutes = LLTimeCtrl::getMinutesString(str);
+        if (!LLTimeCtrl::isMinutesStringValid(minutes))
+            return setError("ValidatorInvalidMinutes", LLSD().with("STR", minutes));
+
+        std::string ampm = LLTimeCtrl::getAMPMString(str);
+        if (!LLTimeCtrl::isPMAMStringValid(ampm))
+            return setError("ValidatorInvalidAMPM", LLSD().with("STR", ampm));
+
+        return resetError();
+    }
+
+    // virtual
+    bool validate(const LLWString& wstr) override
+    {
+        std::string str = wstring_to_utf8str(wstr);
+
+        return validate(str);
+    }
+} validateTimeImpl;
+LLTextValidate::Validator validateTime(validateTimeImpl);
 
 LLTimeCtrl::Params::Params()
 :	label_width("label_width"),
@@ -111,7 +141,7 @@ LLTimeCtrl::LLTimeCtrl(const LLTimeCtrl::Params& p)
 	params.keystroke_callback(boost::bind(&LLTimeCtrl::onTextEntry, this, _1));
 	mEditor = LLUICtrlFactory::create<LLLineEditor> (params);
 	mEditor->setPrevalidateInput(LLTextValidate::validateNonNegativeS32NoSpace);
-	mEditor->setPrevalidate(boost::bind(&LLTimeCtrl::isTimeStringValid, this, _1));
+	mEditor->setPrevalidate(validateTime);
 	mEditor->setText(LLStringExplicit("12:00 AM"));
 	addChild(mEditor);
 
@@ -247,15 +277,6 @@ void LLTimeCtrl::onTextEntry(LLLineEditor* line_editor)
 	mTime = h24 * MINUTES_PER_HOUR + m;
 }
 
-bool LLTimeCtrl::isTimeStringValid(const LLWString &wstr)
-{
-	std::string str = wstring_to_utf8str(wstr);
-
-	return isHoursStringValid(getHoursString(str)) &&
-		isMinutesStringValid(getMinutesString(str)) &&
-		isPMAMStringValid(getAMPMString(str));
-}
-
 void LLTimeCtrl::increaseMinutes()
 {
 	mTime = (mTime + mSnapToMin) % MINUTES_PER_DAY - (mTime % mSnapToMin);
diff --git a/indra/llui/lltimectrl.h b/indra/llui/lltimectrl.h
index b5f268c76a..1c8ac78289 100644
--- a/indra/llui/lltimectrl.h
+++ b/indra/llui/lltimectrl.h
@@ -60,6 +60,18 @@ public:
 
 	void setTime24(F32 time);	// 0.0 - 23.98(3)
 
+	static std::string getHoursString(const std::string& str);
+	static std::string getMinutesString(const std::string& str);
+	static std::string getAMPMString(const std::string& str);
+
+	static bool isHoursStringValid(const std::string& str);
+	static bool isMinutesStringValid(const std::string& str);
+	static bool isPMAMStringValid(const std::string& str);
+
+	static U32	parseHours(const std::string& str);
+	static U32	parseMinutes(const std::string& str);
+	static bool	parseAMPM(const std::string& str);
+
 protected:
 	LLTimeCtrl(const Params&);
 	friend class LLUICtrlFactory;
@@ -87,8 +99,6 @@ private:
 	void	onDownBtn();
 	void	onTextEntry(LLLineEditor* line_editor);
 
-	bool	isTimeStringValid(const LLWString& wstr);
-
 	void increaseMinutes();
 	void increaseHours();
 
@@ -102,18 +112,6 @@ private:
 
 	EEditingPart getEditingPart();
 
-	static std::string getHoursString(const std::string& str);
-	static std::string getMinutesString(const std::string& str);
-	static std::string getAMPMString(const std::string& str);
-
-	static bool isHoursStringValid(const std::string& str);
-	static bool isMinutesStringValid(const std::string& str);
-	static bool isPMAMStringValid(const std::string& str);
-
-	static U32		parseHours(const std::string& str);
-	static U32		parseMinutes(const std::string& str);
-	static bool		parseAMPM(const std::string& str);
-
 	class LLTextBox*	mLabelBox;
 
 	class LLLineEditor*	mEditor;
diff --git a/indra/newview/llfloatersellland.cpp b/indra/newview/llfloatersellland.cpp
index b139e5daf5..7e7bebf968 100644
--- a/indra/newview/llfloatersellland.cpp
+++ b/indra/newview/llfloatersellland.cpp
@@ -283,9 +283,7 @@ void LLFloaterSellLandUI::refreshUI()
 	getChild<LLUICtrl>("info_size")->setTextArg("[AREA]", llformat("%d", mParcelActualArea));
 
 	std::string price_str = getChild<LLUICtrl>("price")->getValue().asString();
-	bool valid_price = false;
-	valid_price = (price_str != "") && LLTextValidate::validateNonNegativeS32(utf8str_to_wstring(price_str));
-
+	bool valid_price = !price_str.empty() && LLTextValidate::validateNonNegativeS32.validate(price_str);
 	if (valid_price && mParcelActualArea > 0)
 	{
 		F32 per_meter_price = 0;
@@ -299,7 +297,7 @@ void LLFloaterSellLandUI::refreshUI()
 	{
 		getChildView("price_per_m")->setVisible(FALSE);
 
-		if ("" == price_str)
+		if (price_str.empty())
 		{
 			setBadge("step_price", BADGE_NOTE);
 		}
@@ -331,9 +329,7 @@ void LLFloaterSellLandUI::refreshUI()
 
 	// Must select Sell To: Anybody, or User (with a specified username)
 	std::string sell_to = getChild<LLUICtrl>("sell_to")->getValue().asString();
-	bool valid_sell_to = "select" != sell_to &&
-		("user" != sell_to || mAuthorizedBuyer.notNull());
-
+	bool valid_sell_to = "select" != sell_to && ("user" != sell_to || mAuthorizedBuyer.notNull());
 	if (!valid_sell_to)
 	{
 		setBadge("step_sell_to", BADGE_NOTE);
@@ -344,7 +340,6 @@ void LLFloaterSellLandUI::refreshUI()
 	}
 
 	bool valid_sell_objects = ("none" != getChild<LLUICtrl>("sell_objects")->getValue().asString());
-
 	if (!valid_sell_objects)
 	{
 		setBadge("step_sell_objects", BADGE_NOTE);
diff --git a/indra/newview/llurllineeditorctrl.cpp b/indra/newview/llurllineeditorctrl.cpp
index 2b7e598a59..081f4dcf23 100644
--- a/indra/newview/llurllineeditorctrl.cpp
+++ b/indra/newview/llurllineeditorctrl.cpp
@@ -62,7 +62,7 @@ void LLURLLineEditor::cut()
 		deleteSelection();
 
 		// Validate new string and rollback the if needed.
-		BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
+		bool need_to_rollback = mPrevalidator && !mPrevalidator.validate(mText.getWString());
 		if( need_to_rollback )
 		{
 			rollback.doRollback( this );
diff --git a/indra/newview/skins/default/xui/en/floater_create_landmark.xml b/indra/newview/skins/default/xui/en/floater_create_landmark.xml
index 632daaec7e..c88ebc71c9 100644
--- a/indra/newview/skins/default/xui/en/floater_create_landmark.xml
+++ b/indra/newview/skins/default/xui/en/floater_create_landmark.xml
@@ -39,7 +39,7 @@
      layout="topleft"
      max_length_bytes="63"
      name="title_editor"
-     prevalidate_callback="ascii"
+     prevalidator="ascii"
      text_readonly_color="white"
      top_pad="5"
      width="290" />
@@ -87,7 +87,7 @@
      name="notes_editor"
      spellcheck="true"
      text_readonly_color="white"
-     text_type="ascii_with_newline"
+     prevalidator="ascii_with_newline"
      commit_on_focus_lost="true"
      top_pad="5"
      width="290"
diff --git a/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml b/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml
index f3d7c38a76..ff5465d031 100644
--- a/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml
+++ b/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml
@@ -60,7 +60,7 @@
                     left_pad="10"
                     max_length_bytes="100"
                     name="day_cycle_name"
-                    prevalidate_callback="ascii"
+                    prevalidator="ascii"
                     top="5"
                     width="200"
                     height="21" />
diff --git a/indra/newview/skins/default/xui/en/floater_fixedenvironment.xml b/indra/newview/skins/default/xui/en/floater_fixedenvironment.xml
index 45f3880a15..8bf62e157a 100644
--- a/indra/newview/skins/default/xui/en/floater_fixedenvironment.xml
+++ b/indra/newview/skins/default/xui/en/floater_fixedenvironment.xml
@@ -44,7 +44,7 @@
                     left_delta="45"
                     width="250"
                     name="settings_name"
-                    prevalidate_callback="ascii"
+                    prevalidator="ascii"
                     max_length_chars="63"
                     height="20"/>
             <button
diff --git a/indra/newview/skins/default/xui/en/floater_model_preview.xml b/indra/newview/skins/default/xui/en/floater_model_preview.xml
index 21c894d3af..bc7e3c905d 100644
--- a/indra/newview/skins/default/xui/en/floater_model_preview.xml
+++ b/indra/newview/skins/default/xui/en/floater_model_preview.xml
@@ -93,7 +93,7 @@
           height="19"
           max_length_bytes="63"
           name="description_form"
-          prevalidate_callback="ascii"
+          prevalidator="ascii"
           top_pad="5"
           width="290" />
     </panel>
diff --git a/indra/newview/skins/default/xui/en/floater_test_line_editor.xml b/indra/newview/skins/default/xui/en/floater_test_line_editor.xml
index 2894ad2a32..b6088a6b51 100644
--- a/indra/newview/skins/default/xui/en/floater_test_line_editor.xml
+++ b/indra/newview/skins/default/xui/en/floater_test_line_editor.xml
@@ -23,7 +23,7 @@
    layout="topleft"
    left_delta="0"
    name="ascii_line_editor"
-   prevalidate_callback="ascii"
+   prevalidator="ascii"
    tool_tip="ascii line editor"
    top_pad="10" 
    width="200">
diff --git a/indra/newview/skins/default/xui/en/floater_test_text_editor.xml b/indra/newview/skins/default/xui/en/floater_test_text_editor.xml
index e1fefc3631..3749d358b4 100644
--- a/indra/newview/skins/default/xui/en/floater_test_text_editor.xml
+++ b/indra/newview/skins/default/xui/en/floater_test_text_editor.xml
@@ -38,7 +38,7 @@
    name="numeric_text_editor"
    tool_tip="text editor for numeric text entry only"
    top_pad="10"
-   text_type="int"
+   prevalidator="int"
    width="200">
     This is text that is NOT a number, so shouldn't appear
   </text_editor>
diff --git a/indra/newview/skins/default/xui/en/notifications.xml b/indra/newview/skins/default/xui/en/notifications.xml
index c2c7a303f6..f082774590 100644
--- a/indra/newview/skins/default/xui/en/notifications.xml
+++ b/indra/newview/skins/default/xui/en/notifications.xml
@@ -414,6 +414,15 @@ Initialization with the Marketplace failed because of a system or network error.
     </notification>
 
     <notification
+     icon="notifytip.tga"
+     name="InvalidKeystroke"
+     type="notifytip">
+There was an invalid keystroke entered.
+[REASON].
+Please input a valid text.
+    </notification>
+
+    <notification
         icon="alertmodal.tga"
         name="MerchantForceValidateListing"
         type="alertmodal">
diff --git a/indra/newview/skins/default/xui/en/panel_edit_wearable.xml b/indra/newview/skins/default/xui/en/panel_edit_wearable.xml
index 85d73ece48..473437160f 100644
--- a/indra/newview/skins/default/xui/en/panel_edit_wearable.xml
+++ b/indra/newview/skins/default/xui/en/panel_edit_wearable.xml
@@ -260,7 +260,7 @@
          left="10"
          max_length_bytes="63"
          name="description"
-         prevalidate_callback="ascii"
+         prevalidator="ascii"
          select_on_focus="true"
          text_color="Black"
          top_pad="3"
diff --git a/indra/newview/skins/default/xui/en/panel_group_notices.xml b/indra/newview/skins/default/xui/en/panel_group_notices.xml
index a5aca5c72b..ead1c69ee2 100644
--- a/indra/newview/skins/default/xui/en/panel_group_notices.xml
+++ b/indra/newview/skins/default/xui/en/panel_group_notices.xml
@@ -141,7 +141,7 @@ Maximum 200 per group daily
          left_pad="3"
          max_length_bytes="63"
          name="create_subject"
-         prevalidate_callback="ascii"
+         prevalidator="ascii"
          spellcheck="true"
          width="218" />
         <text
diff --git a/indra/newview/skins/default/xui/en/panel_landmark_info.xml b/indra/newview/skins/default/xui/en/panel_landmark_info.xml
index e82305ef17..0315864fb6 100644
--- a/indra/newview/skins/default/xui/en/panel_landmark_info.xml
+++ b/indra/newview/skins/default/xui/en/panel_landmark_info.xml
@@ -308,7 +308,7 @@
                  left="0"
                  max_length_bytes="63"
                  name="title_editor"
-                 prevalidate_callback="ascii"
+                 prevalidator="ascii"
                  text_readonly_color="white"
                  top_delta="1"
                  width="290"/>
@@ -332,7 +332,7 @@
                  read_only="true"
                  spellcheck="true"
                  text_readonly_color="white"
-                 text_type="ascii_with_newline"
+                 prevalidator="ascii_with_newline"
                  top_pad="5"
                  width="290"
                  wrap="true" />
diff --git a/indra/newview/skins/default/xui/en/panel_login.xml b/indra/newview/skins/default/xui/en/panel_login.xml
index 3aba80909a..f013682bc8 100644
--- a/indra/newview/skins/default/xui/en/panel_login.xml
+++ b/indra/newview/skins/default/xui/en/panel_login.xml
@@ -54,7 +54,7 @@
     combo_editor.font="SansSerifLarge"
     max_chars="128"
     combo_editor.commit_on_focus_lost="false"
-    combo_editor.prevalidate_callback="ascii"
+    combo_editor.prevalidator="ascii"
     tool_tip="The username you chose when you registered, like bobsmith12 or Steller Sunshine"
     name="username_combo"
     width="206">
diff --git a/indra/newview/skins/default/xui/en/panel_login_first.xml b/indra/newview/skins/default/xui/en/panel_login_first.xml
index d36c83d292..6f3812b2d2 100644
--- a/indra/newview/skins/default/xui/en/panel_login_first.xml
+++ b/indra/newview/skins/default/xui/en/panel_login_first.xml
@@ -111,7 +111,7 @@
             combo_editor.font="SansSerifLarge"
             max_chars="128"
             top="0"
-            combo_editor.prevalidate_callback="ascii"
+            combo_editor.prevalidator="ascii"
             tool_tip="The username you chose when you registered, like bobsmith12 or Steller Sunshine"
             name="username_combo"
             width="232">
diff --git a/indra/newview/skins/default/xui/en/panel_profile_classified.xml b/indra/newview/skins/default/xui/en/panel_profile_classified.xml
index c9e8b242d4..c999c86472 100644
--- a/indra/newview/skins/default/xui/en/panel_profile_classified.xml
+++ b/indra/newview/skins/default/xui/en/panel_profile_classified.xml
@@ -483,7 +483,7 @@
                  layout="topleft"
                  font="SansSerif"
                  max_length_bytes="30"
-                 prevalidate_callback="ascii"
+                 prevalidator="ascii"
                  commit_on_focus_lost="false"
                  text_color="black"
                 />
diff --git a/indra/newview/skins/default/xui/en/sidepanel_item_info.xml b/indra/newview/skins/default/xui/en/sidepanel_item_info.xml
index ad521cb1af..7e92ebabbf 100644
--- a/indra/newview/skins/default/xui/en/sidepanel_item_info.xml
+++ b/indra/newview/skins/default/xui/en/sidepanel_item_info.xml
@@ -208,7 +208,7 @@ TestString PleaseIgnore
         Description:
       </text>
       <text_editor
-        text_type="ascii_printable_no_pipe"
+        prevalidator="ascii_printable_no_pipe"
         commit_on_focus_lost="true"
         border_style="line"
         border_thickness="1"
diff --git a/indra/newview/skins/default/xui/en/strings.xml b/indra/newview/skins/default/xui/en/strings.xml
index c065aeb1d4..df310bd074 100644
--- a/indra/newview/skins/default/xui/en/strings.xml
+++ b/indra/newview/skins/default/xui/en/strings.xml
@@ -581,7 +581,21 @@ http://secondlife.com/support for help fixing this problem.
 	<string name="script_files">Scripts</string>
 	<string name="dictionary_files">Dictionaries</string>
 
-  <!-- LSL Usage Hover Tips -->
+    <!-- Text validator error messages -->
+    <string name="Validator_InvalidNumericString">Invalid numeric string: "[STR]"</string>
+    <string name="Validator_ShouldNotBeMinus">Invalid initial character: '[CH]' (shouldn't be a minus)</string>
+    <string name="Validator_ShouldNotBeMinusOrZero">Invalid initial character: '[CH]' (shouldn't be either a minus or a zero)</string>
+    <string name="Validator_ShouldBeDigit">Invalid character [NR]: '[CH]' (should only be a digit)</string>
+    <string name="Validator_ShouldBeDigitOrDot">Invalid character [NR]: '[CH]' (should only be a digit or a decimal point)</string>
+    <string name="Validator_ShouldBeDigitOrAlpha">Invalid character [NR]: '[CH]' (should only be a digit or an alpha-numeric ASCII character)</string>
+    <string name="Validator_ShouldBeDigitOrAlphaOrSpace">Invalid character [NR]: '[CH]' (should only be a digit or an alpha-numeric ASCII character or a space)</string>
+    <string name="Validator_ShouldBeDigitOrAlphaOrPunct">Invalid character [NR]: '[CH]' (should only be a digit or an alpha-numeric ASCII character or a punctuation)</string>
+    <string name="Validator_ShouldBeDigitOrAlphaOrPunctNotSpace">Invalid character [NR]: '[CH]' (should only be a digit or an alpha-numeric ASCII character or a punctuation with no space)</string>
+    <string name="Validator_ShouldBeDigitNotSpace">Invalid character [NR]: '[CH]' (should only be a digit with no space)</string>
+    <string name="Validator_ShouldBeASCII">Invalid character [NR]: '[CH]' (should only be an ASCII character)</string>
+    <string name="Validator_ShouldBeNewLineOrASCII">Invalid character [NR]: '[CH]' (should only be an ASCII character or a new line)</string>
+
+    <!-- LSL Usage Hover Tips -->
   <!-- NOTE: For now these are set as translate="false", until DEV-40761 is implemented (to internationalize the rest of tooltips in the same window).
              This has no effect on viewer code, but prevents Linden Lab internal localization tool from scraping these strings.  -->
 	<string name="LSLTipSleepTime" translate="false">