6 files changed, 470 insertions, 345 deletions

diff --git a/linden/indra/llui/lllineeditor.cpp b/linden/indra/llui/lllineeditor.cpp
index c1d8efa..e95af79 100644
--- a/linden/indra/llui/lllineeditor.cpp
+++ b/linden/indra/llui/lllineeditor.cpp
@@ -171,7 +171,7 @@ LLLineEditor::LLLineEditor(const std::string& name, const LLRect& rect,
                 mHaveHistory(FALSE),
                 mImage( sImage ),
                 mReplaceNewlinesWithSpaces( TRUE ),
-                mOverRideAndShowMisspellings( FALSE )
+                mShowMisspellings( FALSE )
 {
         llassert( max_length_bytes > 0 );
 
@@ -546,19 +546,19 @@ void LLLineEditor::spell_show(void * data)
         SpellMenuBind* tempBind = (SpellMenuBind*)data;
         LLLineEditor* line = tempBind->origin;
 
-        if(tempBind && line)
+        if( tempBind && line)
         {
-                if(tempBind->word=="Show Misspellings")
+                if (tempBind->word=="Show Misspellings")
                 {
-                        line->setOverRideAndShowMisspellings(TRUE);
-                }else
+                        line->setShowMisspellings(TRUE);
+                }
+                else
                 {
-                        line->setOverRideAndShowMisspellings(FALSE);
+                        line->setShowMisspellings(FALSE);
                 }
         }
-
-
 }
+
 std::vector<S32> LLLineEditor::getMisspelledWordsPositions()
 {
         std::vector<S32> thePosesOfBadWords;
@@ -604,25 +604,29 @@ std::vector<S32> LLLineEditor::getMisspelledWordsPositions()
         }
         return thePosesOfBadWords;
 }
+
 void LLLineEditor::spell_add(void* data)
 {
         SpellMenuBind* tempBind = (SpellMenuBind*)data;
-        if(tempBind)
+        if (tempBind)
         {
                 glggHunSpell->addWordToCustomDictionary(tempBind->word);
                 tempBind->origin->mPrevSpelledText="";//make it update
         }
 }
+
 void LLLineEditor::context_paste(void* data)
 {
         LLLineEditor* line = (LLLineEditor*)data;
         if(line)line->paste();
 }
+
 void LLLineEditor::context_delete(void* data)
 {
         LLLineEditor* line = (LLLineEditor*)data;
         if(line)line->doDelete();
 }
+
 void LLLineEditor::context_selectall(void* data)
 {
         LLLineEditor* line = (LLLineEditor*)data;
@@ -728,16 +732,17 @@ BOOL LLLineEditor::handleRightMouseDown( S32 x, S32 y, MASK mask )
         S32 wordStart = 0;
         S32 wordEnd = calculateCursorFromMouse(x);
 
-
         LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
         if (menu)
         {
                 if(menu->isOpen())
+                {
                         menu->setVisible(FALSE);
-                for(int i = 0;i<(int)suggestionMenuItems.size();i++)
+                }
+                for (int i = 0;i<(int)suggestionMenuItems.size();i++)
                 {
                         SpellMenuBind * tempBind = suggestionMenuItems[i];
-                        if(tempBind)
+                        if (tempBind)
                         {
                                 menu->remove((LLMenuItemCallGL *)tempBind->menuItem);
                                 ((LLMenuItemCallGL *)tempBind->menuItem)->die();
@@ -748,69 +753,74 @@ BOOL LLLineEditor::handleRightMouseDown( S32 x, S32 y, MASK mask )
                 }
                 suggestionMenuItems.clear();
 
-                menu->setItemVisible("Translate To",!mReadOnly);
-                menu->setItemVisible("Transep",!mReadOnly);
+                menu->setItemVisible("Translate To", !mReadOnly);
+                menu->setItemVisible("Transep", !mReadOnly);
 
-                const LLWString& text = mText.getWString();
-                if(( LLTextEditor::isPartOfWord( text[wordEnd] ) ) 
-                        &&(!mReadOnly))
+                // spell_check="true" in xui
+                if (!mReadOnly && mShowMisspellings)
                 {
-                        // Select word the cursor is over
-                        while ((wordEnd > 0) && LLTextEditor::isPartOfWord(text[wordEnd-1]))
-                        {
-                                wordEnd--;
-                        }
-                        wordStart=wordEnd;
-                        //startSelection();
+                        const LLWString& text = mText.getWString();
 
-                        while ((wordEnd < (S32)text.length()) && LLTextEditor::isPartOfWord( text[wordEnd] ) )
+                        // search for word matches
+                        if (LLTextEditor::isPartOfWord(text[wordEnd]))
                         {
-                                wordEnd++;
-                        }               
-                        std::string selectedWord(std::string(text.begin(), 
-                                text.end()).substr(wordStart,wordEnd-wordStart));
-                        if(!glggHunSpell->isSpelledRight(selectedWord))
-                        {       
-                                //misspelled word here, and you have just right clicked on it!
-                                std::vector<std::string> suggs = glggHunSpell->getSuggestionList(selectedWord);
-                                //menu->setItemVisible("Transep",(suggs.size()>0));
+                                // Select word the cursor is over
+                                while ((wordEnd > 0) && LLTextEditor::isPartOfWord(text[wordEnd-1]))
+                                {
+                                        wordEnd--;
+                                }
+                                wordStart = wordEnd;
+                                //startSelection();
 
-                                for(int i = 0;i<(int)suggs.size();i++)
+                                while ((wordEnd < (S32)text.length()) && LLTextEditor::isPartOfWord( text[wordEnd] ) )
                                 {
+                                        wordEnd++;
+                                }               
+                                std::string selectedWord(std::string(text.begin(), text.end()).substr(wordStart,wordEnd-wordStart));
+                                
+                                if (!glggHunSpell->isSpelledRight(selectedWord))
+                                {       
+                                        //misspelled word here, and you have just right clicked on it!
+                                        std::vector<std::string> suggs = glggHunSpell->getSuggestionList(selectedWord);
+                                        //menu->setItemVisible("Transep",(suggs.size()>0));
+
+                                        for (int i = 0; i<(int)suggs.size() ;i++)
+                                        {
+                                                SpellMenuBind * tempStruct = new SpellMenuBind;
+                                                tempStruct->origin = this;
+                                                tempStruct->word = suggs[i];
+                                                tempStruct->wordPositionEnd = wordEnd;
+                                                tempStruct->wordPositionStart=wordStart;
+                                                LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
+                                                        tempStruct->word, spell_correct, NULL, tempStruct);
+                                                //new LLMenuItemCallGL("Select All", context_selectall, NULL, this));
+                                                tempStruct->menuItem = suggMenuItem;
+                                                suggestionMenuItems.push_back(tempStruct);
+                                                menu->append(suggMenuItem);
+                                        }
                                         SpellMenuBind * tempStruct = new SpellMenuBind;
                                         tempStruct->origin = this;
-                                        tempStruct->word = suggs[i];
+                                        tempStruct->word = selectedWord;
                                         tempStruct->wordPositionEnd = wordEnd;
                                         tempStruct->wordPositionStart=wordStart;
                                         LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
-                                                tempStruct->word, spell_correct, NULL, tempStruct);
-                                        //new LLMenuItemCallGL("Select All", context_selectall, NULL, this));
+                                                "Add Word", spell_add, NULL, tempStruct);
                                         tempStruct->menuItem = suggMenuItem;
                                         suggestionMenuItems.push_back(tempStruct);
                                         menu->append(suggMenuItem);
                                 }
-                                SpellMenuBind * tempStruct = new SpellMenuBind;
-                                tempStruct->origin = this;
-                                tempStruct->word = selectedWord;
-                                tempStruct->wordPositionEnd = wordEnd;
-                                tempStruct->wordPositionStart=wordStart;
-                                LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
-                                        "Add Word", spell_add, NULL, tempStruct);
-                                tempStruct->menuItem = suggMenuItem;
-                                suggestionMenuItems.push_back(tempStruct);
-                                menu->append(suggMenuItem);
                         }
 
-                }
-                if((!mReadOnly)&&((!glggHunSpell->highlightInRed)
-                        ||(mOverRideAndShowMisspellings)))
-                {
                         SpellMenuBind * tempStruct = new SpellMenuBind;
                         tempStruct->origin = this;
-                        if(mOverRideAndShowMisspellings)
+                        if (glggHunSpell->mSpellCheckHighlight)
+                        {
                                 tempStruct->word = "Hide Misspellings";
+                        }
                         else
+                        {
                                 tempStruct->word = "Show Misspellings";
+                        }
                         LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
                                 tempStruct->word, spell_show, NULL, tempStruct);
                         tempStruct->menuItem = suggMenuItem;
@@ -1838,36 +1848,43 @@ void LLLineEditor::doDelete()
                 }
         }
 }
+
 void LLLineEditor::autoCorrectText()
 {
         static BOOL *doAnything = rebind_llcontrol<BOOL>("EmeraldEnableAutoCorrect", &gSavedSettings, true);
-        if( (!mReadOnly) && (*doAnything) && (isSpellDirty()))
+        if (!mReadOnly && *doAnything && isSpellDirty())
         {
                 S32 wordStart = 0;
                 S32 wordEnd = mCursorPos-1;
                 //llinfos <<"Checking Word, Cursor is at "<<mCursorPos<<" and text is "<<mText.getString().c_str()<<llendl;
-                if(wordEnd<1)return;
+                if (wordEnd < 1)
+                {
+                        return;
+                }
                 const LLWString& text = mText.getWString();
-                if(text.size()<1)return;
-                if( LLTextEditor::isPartOfWord( text[wordEnd] )) return;//we only check on word breaks
+                if (text.size() < 1 || LLTextEditor::isPartOfWord(text[wordEnd]))
+                {
+                        return;//we only check on word breaks
+                }
+
                 wordEnd--;
-                if( LLTextEditor::isPartOfWord( text[wordEnd] ) )
+                if (LLTextEditor::isPartOfWord(text[wordEnd]))
                 {
                         while ((wordEnd > 0) && (' '!=text[wordEnd-1]))
                         {
                                 wordEnd--;
                         }
-                        wordStart=wordEnd;              
+                        wordStart = wordEnd;            
                         while ((wordEnd < (S32)text.length()) && (' '!=text[wordEnd] ) )
                         {
                                 wordEnd++;
                         }
                         std::string lastTypedWord(std::string(text.begin(), 
-                        text.end()).substr(wordStart,wordEnd-wordStart));
+                        text.end()).substr(wordStart, wordEnd-wordStart));
                         //llinfos << " The last typed word has been chosen, it is "<<lastTypedWord.c_str()<<llendl;
                 
                         std::string correctedWord(LGGAutoCorrect::getInstance()->replaceWord(lastTypedWord));
-                        if(correctedWord!=lastTypedWord)
+                        if(correctedWord != lastTypedWord)
                         {
                                 int dif = correctedWord.length()-lastTypedWord.length();
                                 std::string regText(mText);
@@ -1879,53 +1896,56 @@ void LLLineEditor::autoCorrectText()
                 }
         }
 }
+
 void LLLineEditor::drawMisspelled(LLRect background)
 {
-        if((glggHunSpell->highlightInRed || mOverRideAndShowMisspellings)
-                &&(!mReadOnly))
+        if (!mReadOnly && mShowMisspellings)
         {
-                S32 newStartSpellHere =mScrollHPos;
-                S32 cursorloc =calculateCursorFromMouse(mMaxHPixels);
-                S32 newStopSpellHere = ( ((S32)mText.length())>cursorloc)?cursorloc:(S32)mText.length();
+                S32 newStartSpellHere = mScrollHPos;
+                S32 cursorloc = calculateCursorFromMouse(mMaxHPixels);
+                S32 newStopSpellHere = (((S32)mText.length())>cursorloc) ? cursorloc : (S32)mText.length();
 
                 F32 elapsed = mSpellTimer.getElapsedTimeF32();
-                if(S32(elapsed / 1) & 1) 
+                if (S32(elapsed / 1) & 1) 
                 {
-                        if(isSpellDirty()||(newStartSpellHere!=mStartSpellHere)||(newStopSpellHere!=mEndSpellHere))
+                        if (isSpellDirty() || (newStartSpellHere != mStartSpellHere) || ( newStopSpellHere != mEndSpellHere))
                         {
-                                mStartSpellHere=newStartSpellHere;
-                                mEndSpellHere= newStopSpellHere;
+                                mStartSpellHere = newStartSpellHere;
+                                mEndSpellHere = newStopSpellHere;
                                 resetSpellDirty();
                                 misspellLocations=getMisspelledWordsPositions();
                         }
                 }
-                for(int i =0;i<(int)misspellLocations.size();i++)
-                {
-                        S32 wstart =findPixelNearestPos( misspellLocations[i]-getCursor());
-                        S32 wend = findPixelNearestPos(misspellLocations[++i]-getCursor());
-                        S32 maxw = getRect().getWidth();
 
-                        if(wend > maxw)
-                        {
-                                wend=maxw;
-                        }
-                        if(wstart > maxw)
-                        {
-                                wstart=maxw;
-                        }
-                        gGL.color4ub(255,0,0,200);
-                        //3 line zig zags..
-                        while(wstart<wend)
+                if (glggHunSpell->mSpellCheckHighlight)
+                {
+                        for (int i =0; i<(int)misspellLocations.size(); i++)
                         {
-                                gl_line_2d(wstart,background.mBottom-1,wstart+3,background.mBottom+2);
-                                gl_line_2d(wstart+3,background.mBottom+2,wstart+6,background.mBottom-1);
-                                wstart+=6;
-                        }
+                                S32 wstart =findPixelNearestPos( misspellLocations[i]-getCursor());
+                                S32 wend = findPixelNearestPos(misspellLocations[++i]-getCursor());
+                                S32 maxw = getRect().getWidth();
 
+                                if (wend > maxw)
+                                {
+                                        wend = maxw;
+                                }
+                                if (wstart > maxw)
+                                {
+                                        wstart = maxw;
+                                }
+                                gGL.color4ub(255,0,0,200);
+                                //3 line zig zags..
+                                while (wstart < wend)
+                                {
+                                        gl_line_2d(wstart, background.mBottom-1, wstart+3, background.mBottom+2);
+                                        gl_line_2d(wstart+3, background.mBottom+2, wstart+6, background.mBottom-1);
+                                        wstart+=6;
+                                }
+                        }
                 }
         }
-
 }
+
 void LLLineEditor::draw()
 {
         autoCorrectText();
@@ -2797,6 +2817,11 @@ LLView* LLLineEditor::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory
         {
                 line_editor->setCommitOnFocusLost(commit_on_focus_lost);
         }
+        BOOL show_misspellings = FALSE;
+        if (node->getAttributeBOOL("spell_check", show_misspellings))
+        {
+                line_editor->setShowMisspellings(show_misspellings);
+        }
         
         line_editor->setColorParameters(node);
         
diff --git a/linden/indra/llui/lllineeditor.h b/linden/indra/llui/lllineeditor.h
index 6de57ec..1d24803 100644
--- a/linden/indra/llui/lllineeditor.h
+++ b/linden/indra/llui/lllineeditor.h
@@ -198,7 +198,7 @@ public:
         void setWriteableBgColor( const LLColor4& c )   { mWriteableBgColor = c; }
         void setReadOnlyBgColor( const LLColor4& c )    { mReadOnlyBgColor = c; }
         void setFocusBgColor(const LLColor4& c)                 { mFocusBgColor = c; }
-        void setOverRideAndShowMisspellings(BOOL b)             { mOverRideAndShowMisspellings =b;}
+        void setShowMisspellings(BOOL b)                { mShowMisspellings = b;}
 
         const LLColor4& getFgColor() const                      { return mFgColor; }
         const LLColor4& getReadOnlyFgColor() const      { return mReadOnlyFgColor; }
@@ -293,7 +293,7 @@ protected:
         std::vector<S32> misspellLocations;     // where all the mispelled words are
         S32                             mStartSpellHere;                // the position of the first char on the screen, stored so we know when to update
         S32                             mEndSpellHere;                  // the location of the last char on the screen
-        BOOL            mOverRideAndShowMisspellings;
+        BOOL                    mShowMisspellings;
         LLFrameTimer mSpellTimer;
         //to keep track of what we have to remove before showing menu
         std::vector<SpellMenuBind* > suggestionMenuItems;
diff --git a/linden/indra/llui/lltexteditor.cpp b/linden/indra/llui/lltexteditor.cpp
index 6e5cdc4..d2469c3 100644
--- a/linden/indra/llui/lltexteditor.cpp
+++ b/linden/indra/llui/lltexteditor.cpp
@@ -323,7 +323,7 @@ LLTextEditor::LLTextEditor(
         mLastSelectionY(-1),
         mReflowNeeded(FALSE),
         mScrollNeeded(FALSE),
-        mOverRideAndShowMisspellings(FALSE)
+        mShowMisspellings(FALSE)
 {
         mSourceID.generate();
 
@@ -490,10 +490,10 @@ void LLTextEditor::spell_show(void * data)
         {
                 if(tempBind->word=="Show Misspellings")
                 {
-                        line->setOverRideAndShowMisspellings(TRUE);
+                        line->setShowMisspellings(TRUE);
                 }else
                 {
-                        line->setOverRideAndShowMisspellings(FALSE);
+                        line->setShowMisspellings(FALSE);
                 }
         }
 }
@@ -1426,7 +1426,6 @@ BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 }
 BOOL LLTextEditor::handleRightMouseDown( S32 x, S32 y, MASK mask )
 {
-
         setFocus(TRUE);
 
         //setCursorAtLocalPos( x, y, TRUE );
@@ -1450,69 +1449,73 @@ BOOL LLTextEditor::handleRightMouseDown( S32 x, S32 y, MASK mask )
                 }
                 suggestionMenuItems.clear();
 
-                menu->setItemVisible("Translate To",!mReadOnly);
-                menu->setItemVisible("Transep",!mReadOnly);
-
-                const LLWString &text = mWText;
+                menu->setItemVisible("Translate To", !mReadOnly);
+                menu->setItemVisible("Transep", !mReadOnly);
 
-                if(( isPartOfWord( text[wordEnd] ) )&&(!mReadOnly))
+                // spell_check="true" in xui
+                if (!mReadOnly && mShowMisspellings)
                 {
-                        // Select word the cursor is over
-                        while ((wordEnd > 0) && isPartOfWord(text[wordEnd-1]))
-                        {
-                                wordEnd--;
-                        }
-                        wordStart=wordEnd;
-                        //startSelection();
-
-                        while ((wordEnd < (S32)text.length()) && isPartOfWord( text[wordEnd] ) )
-                        {
-                                wordEnd++;
-                        }               
-                        std::string selectedWord(std::string(text.begin(), text.end()).substr(wordStart,wordEnd-wordStart));
-                        if(!glggHunSpell->isSpelledRight(selectedWord))
+                        const LLWString &text = mWText;
+                        
+                        if (isPartOfWord(text[wordEnd]) && !mReadOnly)
                         {
-                                //misspelled word here, and you have just right clicked on it!
-                                std::vector<std::string> suggs = glggHunSpell->getSuggestionList(selectedWord);
+                                // Select word the cursor is over
+                                while ((wordEnd > 0) && isPartOfWord(text[wordEnd-1]))
+                                {
+                                        wordEnd--;
+                                }
+                                wordStart = wordEnd;
+                                //startSelection();
 
-                                //menu->setItemVisible("Transep",(suggs.size()>0));
-                                for(int i = 0;i<(int)suggs.size();i++)
+                                while ((wordEnd < (S32)text.length()) && isPartOfWord( text[wordEnd] ) )
+                                {
+                                        wordEnd++;
+                                }               
+                                std::string selectedWord(std::string(text.begin(), text.end()).substr(wordStart,wordEnd-wordStart));
+                                if (!glggHunSpell->isSpelledRight(selectedWord))
                                 {
+                                        //misspelled word here, and you have just right clicked on it!
+                                        std::vector<std::string> suggs = glggHunSpell->getSuggestionList(selectedWord);
+
+                                        //menu->setItemVisible("Transep",(suggs.size()>0));
+                                        for (int i = 0; i<(int)suggs.size(); i++)
+                                        {
+                                                SpellMenuBind * tempStruct = new SpellMenuBind;
+                                                tempStruct->origin = this;
+                                                tempStruct->word = suggs[i];
+                                                tempStruct->wordPositionEnd = wordEnd;
+                                                tempStruct->wordPositionStart=wordStart;
+                                                tempStruct->wordY=y;
+                                                LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
+                                                        tempStruct->word, spell_correct, NULL, tempStruct);
+                                                tempStruct->menuItem = suggMenuItem;
+                                                suggestionMenuItems.push_back(tempStruct);
+                                                menu->append(suggMenuItem);
+                                        }
                                         SpellMenuBind * tempStruct = new SpellMenuBind;
                                         tempStruct->origin = this;
-                                        tempStruct->word = suggs[i];
+                                        tempStruct->word = selectedWord;
                                         tempStruct->wordPositionEnd = wordEnd;
                                         tempStruct->wordPositionStart=wordStart;
                                         tempStruct->wordY=y;
                                         LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
-                                                tempStruct->word, spell_correct, NULL, tempStruct);
+                                                "Add Word", spell_add, NULL, tempStruct);
                                         tempStruct->menuItem = suggMenuItem;
                                         suggestionMenuItems.push_back(tempStruct);
                                         menu->append(suggMenuItem);
                                 }
-                                SpellMenuBind * tempStruct = new SpellMenuBind;
-                                tempStruct->origin = this;
-                                tempStruct->word = selectedWord;
-                                tempStruct->wordPositionEnd = wordEnd;
-                                tempStruct->wordPositionStart=wordStart;
-                                tempStruct->wordY=y;
-                                LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
-                                        "Add Word", spell_add, NULL, tempStruct);
-                                tempStruct->menuItem = suggMenuItem;
-                                suggestionMenuItems.push_back(tempStruct);
-                                menu->append(suggMenuItem);
                         }
 
-                }
-                if((!mReadOnly)&&((!glggHunSpell->highlightInRed)
-                        ||(mOverRideAndShowMisspellings)||(mShowLineNumbers)))
-                {
                         SpellMenuBind * tempStruct = new SpellMenuBind;
                         tempStruct->origin = this;
-                        if(mOverRideAndShowMisspellings)
+                        if (glggHunSpell->mSpellCheckHighlight)
+                        {
                                 tempStruct->word = "Hide Misspellings";
+                        }
                         else
+                        {
                                 tempStruct->word = "Show Misspellings";
+                        }
                         LLMenuItemCallGL * suggMenuItem = new LLMenuItemCallGL(
                                 tempStruct->word, spell_show, NULL, tempStruct);
                         tempStruct->menuItem = suggMenuItem;
@@ -3077,51 +3080,57 @@ void LLTextEditor::drawSelectionBackground()
                 }
         }
 }
+
 void LLTextEditor::autoCorrectText()
-{
-        
+{       
         static BOOL *doAnything = rebind_llcontrol<BOOL>("EmeraldEnableAutoCorrect", &gSavedSettings, true);
-        if( (!mReadOnly) && (*doAnything) && (isSpellDirty()) )
+        if (!mReadOnly && *doAnything && isSpellDirty())
         {
                 S32 wordStart = 0;
                 S32 wordEnd = mCursorPos-1;
-                if(wordEnd<1)return;
+                if (wordEnd < 1)
+                {
+                        return;
+                }
                 LLWString& text = mWText;
-                if(text.size()<1)return;
-                if( LLTextEditor::isPartOfWord( text[wordEnd] )) return;//we only check on word breaks
+                if (text.size() < 1 || LLTextEditor::isPartOfWord(text[wordEnd]))
+                {
+                        return;//we only check on word breaks
+                }
+
                 wordEnd--;
-                if( LLTextEditor::isPartOfWord( text[wordEnd] ) )
+                if (LLTextEditor::isPartOfWord(text[wordEnd]))
                 {
                         while ((wordEnd > 0) && (text[wordEnd-1]!=' '))
                         {
                                 wordEnd--;
                         }
-                        wordStart=wordEnd;              
+                        wordStart = wordEnd;            
                         while ((wordEnd < (S32)text.length()) && (' '!= text[wordEnd] ) )
                         {
                                 wordEnd++;
                         }
                         std::string lastTypedWord(std::string(text.begin(), 
-                                text.end()).substr(wordStart,wordEnd-wordStart));
+                                text.end()).substr(wordStart, wordEnd-wordStart));
 
-                        std::string regText(text.begin(),text.end());
+                        std::string regText(text.begin(), text.end());
 
                         std::string correctedWord(LGGAutoCorrect::getInstance()->replaceWord(lastTypedWord));
-                        if(correctedWord!=lastTypedWord)
+                        if (correctedWord != lastTypedWord)
                         {
-                                int dif = correctedWord.length()-lastTypedWord.length();
-                                regText.replace(wordStart,lastTypedWord.length(),correctedWord);
-                                mWText=utf8str_to_wstring(regText);
-                                mCursorPos+=dif;
+                                int dif = correctedWord.length() - lastTypedWord.length();
+                                regText.replace(wordStart, lastTypedWord.length(), correctedWord);
+                                mWText = utf8str_to_wstring(regText);
+                                mCursorPos += dif;
                                 needsReflow();
                         }
                 }
         }
 }
+
 void LLTextEditor::drawMisspelled()
 {
-        if(mReadOnly)return;
-        if(glggHunSpell->highlightInRed || mOverRideAndShowMisspellings)
+        if (!mReadOnly && mShowMisspellings)
         {
                 if(
                         ( ((getLength()<400)||(false))  &&(  (S32(mSpellTimer.getElapsedTimeF32() / 1) & 1) ))
@@ -3132,80 +3141,86 @@ void LLTextEditor::drawMisspelled()
                         S32 newSpellStart = getLineStart(mScrollbar->getDocPos());//start at the scroll start
                         S32 newSpellEnd = getLineStart(mScrollbar->getDocPos() + 1 + mScrollbar->getDocSize()-mScrollbar->getDocPosMax());//end at the end o.o
 
-                        if(mScrollbar->getDocPos() == mScrollbar->getDocPosMax())
+                        if (mScrollbar->getDocPos() == mScrollbar->getDocPosMax())
                         {
-                                newSpellEnd=(S32)mWText.length();
+                                newSpellEnd = (S32)mWText.length();
                         }
-                        if((isSpellDirty())||(newSpellEnd!=spellEnd || newSpellStart!=spellStart))
+                        if (isSpellDirty() || (newSpellEnd!=spellEnd || newSpellStart!=spellStart))
                         {
                                 spellEnd = newSpellEnd;
                                 spellStart = newSpellStart;
-                                misspellLocations=getMisspelledWordsPositions();
+                                misspellLocations = getMisspelledWordsPositions();
                         }
                 }
                 //draw
-                for(int i =0;i<(int)misspellLocations.size();i++)
+                if (glggHunSpell->mSpellCheckHighlight)
                 {
-                        S32 wstart = misspellLocations[i];
-                        S32 wend = misspellLocations[++i];
-                        //start curor code mod
-                        const LLWString &text = mWText;
-                        const S32 text_len = getLength();
-                        // Skip through the lines we aren't drawing.
-                        S32 search_pos = mScrollbar->getDocPos();
-                        S32 num_lines = getLineCount();
-                        if (search_pos >= num_lines)return;
-                        S32 line_start = getLineStart(search_pos);
-                        F32 line_height = mGLFont->getLineHeight();
-                        F32 text_y = (F32)(mTextRect.mTop) - line_height;
-
-                        F32 word_left = 0.f; 
-                        F32 word_right = 0.f;
-                        F32 word_bottom = 0.f;
-                        BOOL word_visible = FALSE;
-
-                        S32 line_end = 0;
-                        // Determine if the cursor is visible and if so what its coordinates are.
-                        while( (mTextRect.mBottom <= llround(text_y)) && (search_pos < num_lines))
+                        for (int i = 0; i<(int)misspellLocations.size() ;i++)
                         {
-                                line_end = text_len + 1;
-                                S32 next_line = -1;
-
-                                if ((search_pos + 1) < num_lines)
+                                S32 wstart = misspellLocations[i];
+                                S32 wend = misspellLocations[++i];
+                                //start curor code mod
+                                const LLWString &text = mWText;
+                                const S32 text_len = getLength();
+                                // Skip through the lines we aren't drawing.
+                                S32 search_pos = mScrollbar->getDocPos();
+                                S32 num_lines = getLineCount();
+                                if (search_pos >= num_lines)
                                 {
-                                        next_line = getLineStart(search_pos + 1);
-                                        line_end = next_line - 1;
+                                        return;
                                 }
-                                const llwchar* line = text.c_str() + line_start;
-                                // Find the cursor and selection bounds
-                                if( line_start <= wstart && wend <= line_end )
+                                S32 line_start = getLineStart(search_pos);
+                                F32 line_height = mGLFont->getLineHeight();
+                                F32 text_y = (F32)(mTextRect.mTop) - line_height;
+
+                                F32 word_left = 0.f; 
+                                F32 word_right = 0.f;
+                                F32 word_bottom = 0.f;
+                                BOOL word_visible = FALSE;
+
+                                S32 line_end = 0;
+                                // Determine if the cursor is visible and if so what its coordinates are.
+                                while( (mTextRect.mBottom <= llround(text_y)) && (search_pos < num_lines))
                                 {
-                                        word_visible = TRUE;
-                                        word_left = (F32)mTextRect.mLeft + mGLFont->getWidthF32(line, 0, wstart - line_start, mAllowEmbeddedItems )-1.f;
-                                        word_right = (F32)mTextRect.mLeft + mGLFont->getWidthF32(line, 0, wend - line_start, mAllowEmbeddedItems )+1.f;
-                                        word_bottom = text_y;
-                                        break;
+                                        line_end = text_len + 1;
+                                        S32 next_line = -1;
+
+                                        if ((search_pos + 1) < num_lines)
+                                        {
+                                                next_line = getLineStart(search_pos + 1);
+                                                line_end = next_line - 1;
+                                        }
+                                        const llwchar* line = text.c_str() + line_start;
+                                        // Find the cursor and selection bounds
+                                        if( line_start <= wstart && wend <= line_end )
+                                        {
+                                                word_visible = TRUE;
+                                                word_left = (F32)mTextRect.mLeft + mGLFont->getWidthF32(line, 0, wstart - line_start, mAllowEmbeddedItems )-1.f;
+                                                word_right = (F32)mTextRect.mLeft + mGLFont->getWidthF32(line, 0, wend - line_start, mAllowEmbeddedItems )+1.f;
+                                                word_bottom = text_y;
+                                                break;
+                                        }
+                                        // move down one line
+                                        text_y -= line_height;
+                                        line_start = next_line;
+                                        search_pos++;
                                 }
-                                // move down one line
-                                text_y -= line_height;
-                                line_start = next_line;
-                                search_pos++;
-                        }
-                        if(mShowLineNumbers)
-                        {
-                                word_left += UI_TEXTEDITOR_LINE_NUMBER_MARGIN;
-                                word_right += UI_TEXTEDITOR_LINE_NUMBER_MARGIN;
-                        }
-                        // Draw the cursor
-                        if( word_visible )
-                        {
-                                //end cursos code mod
-                                gGL.color4ub(255,0,0,200);
-                                while(word_left<word_right)
+                                if (mShowLineNumbers)
                                 {
-                                        gl_line_2d(word_left,word_bottom-2,word_left+3,word_bottom+1);
-                                        gl_line_2d(word_left+3,word_bottom+1,word_left+6,word_bottom-2);
-                                        word_left+=6;
+                                        word_left += UI_TEXTEDITOR_LINE_NUMBER_MARGIN;
+                                        word_right += UI_TEXTEDITOR_LINE_NUMBER_MARGIN;
+                                }
+                                // Draw the cursor
+                                if (word_visible)
+                                {
+                                        //end cursor code mod
+                                        gGL.color4ub(255,0,0,200);
+                                        while (word_left<word_right)
+                                        {
+                                                gl_line_2d(word_left,word_bottom-2, word_left+3,word_bottom+1);
+                                                gl_line_2d(word_left+3,word_bottom+1, word_left+6,word_bottom-2);
+                                                word_left += 6;
+                                        }
                                 }
                         }
                 }
@@ -3214,8 +3229,7 @@ void LLTextEditor::drawMisspelled()
 
 void LLTextEditor::drawCursor()
 {
-        if( gFocusMgr.getKeyboardFocus() == this
-                && gShowTextEditCursor && !mReadOnly)
+        if (!mReadOnly && gFocusMgr.getKeyboardFocus() == this && gShowTextEditCursor)
         {
                 const LLWString &text = mWText;
                 const S32 text_len = getLength();
@@ -3696,10 +3710,7 @@ void LLTextEditor::draw()
                         drawPreeditMarker();
                         drawText();
                         drawCursor();
-                        if(!mShowLineNumbers || mOverRideAndShowMisspellings)
-                        {
-                                drawMisspelled();
-                        }
+                        drawMisspelled();
                         resetSpellDirty();
                         unbindEmbeddedChars(mGLFont);
 
@@ -4879,6 +4890,8 @@ void LLTextEditor::setTextEditorParameters(LLXMLNodePtr node)
 
         node->getAttributeBOOL("track_bottom", mTrackBottom);
 
+        node->getAttributeBOOL("spell_check", mShowMisspellings);
+
         LLColor4 color;
         if (LLUICtrlFactory::getAttributeColor(node,"cursor_color", color)) 
         {
diff --git a/linden/indra/llui/lltexteditor.h b/linden/indra/llui/lltexteditor.h
index 6b372d7..c5c3af8 100644
--- a/linden/indra/llui/lltexteditor.h
+++ b/linden/indra/llui/lltexteditor.h
@@ -229,7 +229,7 @@ public:
         void                    setThumbColor( const LLColor4& color );
         void                    setHighlightColor( const LLColor4& color );
         void                    setShadowColor( const LLColor4& color );
-        void                    setOverRideAndShowMisspellings(BOOL b){ mOverRideAndShowMisspellings =b;}
+        void                    setShowMisspellings(BOOL b)             { mShowMisspellings = b; }
 
         // Hacky methods to make it into a word-wrapping, potentially scrolling,
         // read-only text box.
@@ -526,7 +526,7 @@ private:
         S32 spellStart;
         S32 spellEnd;
         std::vector<S32> misspellLocations;     // where all the mispelled words are
-        BOOL            mOverRideAndShowMisspellings;
+        BOOL                    mShowMisspellings;              // set in xui as "spell_check". Default value for a field
         
         S32                             mMaxTextByteLength;             // Maximum length mText is allowed to be in bytes
 
diff --git a/linden/indra/newview/lgghunspell_wrapper.cpp b/linden/indra/newview/lgghunspell_wrapper.cpp
index 5879bac..632c117 100644
--- a/linden/indra/newview/lgghunspell_wrapper.cpp
+++ b/linden/indra/newview/lgghunspell_wrapper.cpp
@@ -468,53 +468,64 @@ static char * languageCodesraw[]={
 };
 //#define LANGUAGE_CODES_RAW_SIZE ((__LINE__ - 1 - LANGUAGE_CODES_RAW_START_LINE) * 2)
 #define LANGUAGE_CODES_RAW_SIZE 368
+
 lggHunSpell_Wrapper::lggHunSpell_Wrapper()
+        :
+        mSpellCheckHighlight(false)
 {
-        highlightInRed=false;
         //languageCodes(begin(languageCodesraw), end(languageCodesraw));    
 }
-lggHunSpell_Wrapper::~lggHunSpell_Wrapper(){}
+
+lggHunSpell_Wrapper::~lggHunSpell_Wrapper()
+{
+}
+
 std::string lggHunSpell_Wrapper::getCorrectPath(std::string file)
 {
         //finds out if it is in user dir, if not, takes it from app dir
         std::string dicpath1(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", file).c_str());
-        if(!gDirUtilp->fileExists(dicpath1))
+        if (!gDirUtilp->fileExists(dicpath1))
+        {
                 dicpath1=gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "dictionaries", file).c_str();
-
+        }
         return dicpath1;
 }
+
 void lggHunSpell_Wrapper::setNewDictionary(std::string newDict)
 {
 
         llinfos << "Setting new base dictionary long name is-> " << newDict.c_str() << llendl;
 
-        currentBaseDic=newDict;
+        currentBaseDic = newDict;
         
         //expecting a full name comming in
         newDict = fullName2DictName(newDict);
 
-        if(myHunspell)delete myHunspell;
+        if (myHunspell)
+        {
+                delete myHunspell;
+        }
 
-        std::string dicaffpath=getCorrectPath(newDict+".aff");
-        std::string dicdicpath=getCorrectPath(newDict+".dic");
+        std::string dicaffpath = getCorrectPath(newDict+".aff");
+        std::string dicdicpath = getCorrectPath(newDict+".dic");
         
         llinfos << "Setting new base dictionary -> " << dicaffpath.c_str() << llendl;
 
-        myHunspell = new Hunspell(dicaffpath.c_str(),dicdicpath.c_str());
+        myHunspell = new Hunspell(dicaffpath.c_str(), dicdicpath.c_str());
         llinfos << "Adding custom dictionary " << llendl;
         createCustomDic();
         addDictionary("custom");
         std::vector<std::string> toInstall = getInstalledDicts();
-        for(int i =0;i<(int)toInstall.size();i++)
+        for (int i = 0; i < (int)toInstall.size(); i++)
+        {
                 addDictionary(toInstall[i]);
-
-
+        }
 }
+
 void lggHunSpell_Wrapper::createCustomDic()
 {
-        std::string filename(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,
-                "dictionaries", "custom.dic"));
-        if(!gDirUtilp->fileExists(filename))
+        std::string filename(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", "custom.dic"));
+        if (!gDirUtilp->fileExists(filename))
         {
                 llofstream export_file; 
                 export_file.open(filename);
@@ -523,49 +534,67 @@ void lggHunSpell_Wrapper::createCustomDic()
                 export_file.close();
         }
 }
+
 void lggHunSpell_Wrapper::addWordToCustomDictionary(std::string wordToAdd)
 {
-        if(!myHunspell)return;
+        if (!myHunspell)
+        {
+                return;
+        }
+
         myHunspell->add(wordToAdd.c_str());
         std::string filename(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", "custom.dic"));
         std::vector<std::string> lines;
-        if(gDirUtilp->fileExists(filename))
+        if (gDirUtilp->fileExists(filename))
         {
                 //get words already there..
                 llifstream importer(filename);
                 std::string line;
-                if(getline( importer, line ))//ignored the size
+                if (getline( importer, line ))//ignored the size
                 {
-                        while( getline( importer, line ) ) lines.push_back(line);
+                        while ( getline( importer, line ) ) lines.push_back(line);
                 }
                 importer.close();
         }
+
         llofstream export_file; 
         export_file.open(filename);
-        std::string sizePart(llformat("%i",(int)(lines.size()+1))+"\n");
-        export_file.write(sizePart.c_str(),sizePart.length());
-        for(int i=0;i<(int)lines.size();i++)
+        std::string sizePart(llformat("%i", (int)(lines.size()+1)) + "\n");
+        export_file.write(sizePart.c_str(), sizePart.length());
+        for (int i = 0; i < (int)lines.size() ;i++)
+        {
                 export_file.write(std::string(lines[i]+"\n").c_str(),lines[i].length()+1);
+        }
         //LLStringUtil::toLower(wordToAdd);
-        wordToAdd=wordToAdd+std::string("\n");
-        export_file.write(wordToAdd.c_str(),wordToAdd.length());
+        wordToAdd = wordToAdd+std::string("\n");
+        export_file.write(wordToAdd.c_str(), wordToAdd.length());
         //export_file << std::hex << 10 ;
         export_file.close();
 }
+
 BOOL lggHunSpell_Wrapper::isSpelledRight(std::string wordToCheck)
 {
-        if(!myHunspell)return TRUE;
-        if(wordToCheck.length()<3)return TRUE;
+        if (!myHunspell || wordToCheck.length() < 3)
+        {
+                return TRUE;
+        }
         return myHunspell->spell(wordToCheck.c_str());
 }
+
 std::vector<std::string> lggHunSpell_Wrapper::getSuggestionList(std::string badWord)
 {
         std::vector<std::string> toReturn;
-        if(!myHunspell)return toReturn;
-        char ** suggestionList; 
+        if (!myHunspell)
+        {
+                return toReturn;
+        }
+
+        char** suggestionList;  
         int numberOfSuggestions = myHunspell->suggest(&suggestionList, badWord.c_str());        
-        if(numberOfSuggestions <= 0)
-                return toReturn;        
+        if (numberOfSuggestions <= 0)
+        {
+                return toReturn;
+        }
         for (int i = 0; i < numberOfSuggestions; i++) 
         {
                 std::string tempSugg(suggestionList[i]);
@@ -574,14 +603,16 @@ std::vector<std::string> lggHunSpell_Wrapper::getSuggestionList(std::string badW
         myHunspell->free_list(&suggestionList,numberOfSuggestions);     
         return toReturn;
 }
+
 void lggHunSpell_Wrapper::debugTest(std::string testWord)
 {
         llinfos << "Testing to see if " << testWord.c_str() << " is spelled correct" << llendl;
 
-        if( isSpelledRight(testWord))
+        if (isSpelledRight(testWord))
         {
                 llinfos << testWord.c_str() << " is spelled correctly" << llendl;
-        }else
+        }
+        else
         {
                 llinfos << testWord.c_str() << " is not spelled correctly, getting suggestions" << llendl;
                 std::vector<std::string> suggList;
@@ -589,148 +620,167 @@ void lggHunSpell_Wrapper::debugTest(std::string testWord)
                 suggList = getSuggestionList(testWord);
                 llinfos << "Got suggestions.. " << llendl;
 
-                for(int i = 0; i<(int)suggList.size();i++)
+                for (int i = 0; i < (int)suggList.size(); i++)
                 {
                         llinfos << "Suggestion for " << testWord.c_str() << ":" << suggList[i].c_str() << llendl;
                 }
-
         }
-
 }
+
 void lggHunSpell_Wrapper::initSettings()
 {
         glggHunSpell = new lggHunSpell_Wrapper();
         glggHunSpell->processSettings();
 }
+
 void lggHunSpell_Wrapper::processSettings()
 {
         //expects everything to already be in saved settings
         //this will also reload and read the installed dicts
         setNewDictionary(gSavedSettings.getString("EmeraldSpellBase"));
-        highlightInRed= gSavedSettings.getBOOL("EmeraldSpellDisplay");
+        mSpellCheckHighlight = gSavedSettings.getBOOL("EmeraldSpellDisplay");
         
 }
+
 void lggHunSpell_Wrapper::addDictionary(std::string additionalDictionary)
 {
-        if(!myHunspell)return;
-        if(additionalDictionary=="")return;
+        if (!myHunspell || additionalDictionary.empty())
+        {
+                return;
+        }
+
         //expecting a full name here
-        std::string dicpath=getCorrectPath(fullName2DictName(additionalDictionary)+".dic");
-        if(gDirUtilp->fileExists(dicpath))
+        std::string dicpath = getCorrectPath(fullName2DictName(additionalDictionary)+".dic");
+        if (gDirUtilp->fileExists(dicpath))
         {
                 llinfos << "Adding additional dictionary -> " << dicpath.c_str() << llendl;
                 myHunspell->add_dic(dicpath.c_str());
         }
 }
+
 std::string lggHunSpell_Wrapper::dictName2FullName(std::string dictName)
 {
-        if(dictName==std::string(""))return std::string("");
-        std::string countryCode="";
-        std::string languageCode="";
+        if (dictName.empty())
+        {
+                return dictName;
+        }
+
+        std::string countryCode("");
+        std::string languageCode("");
+
         //remove extension
         dictName = dictName.substr(0,dictName.find("."));
+
         //break it up by - or _
         S32 breakPoint = dictName.find("-");
-        if(breakPoint==std::string::npos)
+        if (breakPoint == std::string::npos)
+        {
                 breakPoint = dictName.find("_");
-        if(breakPoint==std::string::npos)
+        }
+        if (breakPoint == std::string::npos)
         {
                 //no country code given
-                languageCode=dictName;
-        }else
+                languageCode = dictName;
+        }
+        else
         {
-                languageCode=dictName.substr(0,breakPoint);
-                countryCode=dictName.substr(breakPoint+1);
+                languageCode = dictName.substr(0,breakPoint);
+                countryCode = dictName.substr(breakPoint+1);
         }
+
         //get long language code
-        for(int i =0;i<LANGUAGE_CODES_RAW_SIZE;i++)
+        for (int i = 0; i<LANGUAGE_CODES_RAW_SIZE; i++)
         {               
-                if(0==LLStringUtil::compareInsensitive(languageCode,std::string(languageCodesraw[i])))
+                if (0 == LLStringUtil::compareInsensitive(languageCode, std::string(languageCodesraw[i])))
                 {
-                        languageCode=languageCodesraw[i+1];
+                        languageCode = languageCodesraw[i+1];
                         break;
                 }
         }
+
         //get long country code
-        if(countryCode!="")
+        if (!countryCode.empty())
         {
-                for(int i =0;i<COUNTRY_CODES_RAW_SIZE;i++)
+                for (int i =0; i<COUNTRY_CODES_RAW_SIZE; i++)
                 {               
                         //llinfos << i << llendl;
-                        if(0==LLStringUtil::compareInsensitive(countryCode,std::string(countryCodesraw[i])))
+                        if (0 == LLStringUtil::compareInsensitive(countryCode, std::string(countryCodesraw[i])))
                         {
-                                countryCode=countryCodesraw[i+1];
+                                countryCode = countryCodesraw[i+1];
                                 break;
                         }
                 }
-                countryCode=" ("+countryCode+")";
+                countryCode = " (" + countryCode + ")";
         }
         
         return std::string(languageCode+countryCode);
 }
+
 std::string lggHunSpell_Wrapper::fullName2DictName(std::string fullName)
 {
         std::string countryCode("");
         std::string languageCode("");
         S32 breakPoint = fullName.find(" (");
-        if(breakPoint==std::string::npos)
+        if (breakPoint == std::string::npos)
         {
-                languageCode=fullName;
-        }else
+                languageCode = fullName;
+        }
+        else
         {
-                languageCode=fullName.substr(0,breakPoint);
-                countryCode=fullName.substr(breakPoint+2,fullName.length()-3-breakPoint);
+                languageCode = fullName.substr(0, breakPoint);
+                countryCode = fullName.substr(breakPoint+2, fullName.length()-3-breakPoint);
         }
         //get long language code
-        for(int i =1;i<LANGUAGE_CODES_RAW_SIZE;i+=2)
+        for (int i = 1; i<LANGUAGE_CODES_RAW_SIZE; i+=2)
         {
                 //llinfos << i << llendl;
-                if(0==LLStringUtil::compareInsensitive(languageCode,std::string(languageCodesraw[i])))
+                if (0 == LLStringUtil::compareInsensitive(languageCode, std::string(languageCodesraw[i])))
                 {
-                        languageCode=std::string(languageCodesraw[i-1]);
+                        languageCode = std::string(languageCodesraw[i-1]);
                         break;
                 }
         }
         //get long country code
-        if(countryCode!="")
-                for(int i =1;i<COUNTRY_CODES_RAW_SIZE;i+=2)
+        std::string toReturn = languageCode;
+        if (!countryCode.empty())
+        {
+                for (int i = 1; i<COUNTRY_CODES_RAW_SIZE; i+=2)
                 {
                         //llinfos << i << " comparing " <<countryCode<<" and "<<std::string(countryCodesraw[i]).c_str()<< llendl;
-                        if(0==LLStringUtil::compareInsensitive(countryCode,std::string(countryCodesraw[i])))
+                        if (0 == LLStringUtil::compareInsensitive(countryCode, std::string(countryCodesraw[i])))
                         {
-                                countryCode=std::string(countryCodesraw[i-1]);
+                                countryCode = std::string(countryCodesraw[i-1]);
                                 break;
                         }
                 }
-                std::string toReturn = languageCode;
-                if(countryCode!="")
-                {
-                        toReturn+="_"+countryCode;
-                }
-                LLStringUtil::toLower(toReturn);
-                return toReturn;
+                toReturn += "_" + countryCode;
+        }
+
+        LLStringUtil::toLower(toReturn);
+        return toReturn;
 }
+
 std::vector <std::string> lggHunSpell_Wrapper::getDicts()
 {
         std::vector<std::string> names; 
         std::string path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "dictionaries", ""));
         bool found = true;                      
-        while(found) 
+        while (found) 
         {
                 std::string name;
                 found = gDirUtilp->getNextFileInDir(path_name, "*.aff", name, false);
-                if(found)
+                if (found)
                 {
                         names.push_back(dictName2FullName(name));
                 }
         }
-        path_name=gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", "");
-        found=true;
-        while(found) 
+        path_name = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", "");
+        found = true;
+        while (found) 
         {
                 std::string name;
                 found = gDirUtilp->getNextFileInDir(path_name, "*.aff", name, false);
-                if(found)
+                if (found)
                 {
                         names.push_back(dictName2FullName(name));
                 }
@@ -738,123 +788,159 @@ std::vector <std::string> lggHunSpell_Wrapper::getDicts()
 
         return names;
 }
+
 std::vector <std::string> lggHunSpell_Wrapper::getExtraDicts()
 {
         std::vector<std::string> names; 
         std::string path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "dictionaries", ""));
         bool found = true;                      
-        while(found) 
+        while (found) 
         {
                 std::string name;
                 found = gDirUtilp->getNextFileInDir(path_name, "*.dic", name, false);
-                if(found)
+                if (found)
                 {
                         names.push_back(dictName2FullName(name));
                 }
         }
-        path_name=gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", "");
-        found=true;
-        while(found) 
+        path_name = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", "");
+        found = true;
+        while (found) 
         {
                 std::string name;
                 found = gDirUtilp->getNextFileInDir(path_name, "*.dic", name, false);
-                if(found)
+                if (found)
                 {
                         names.push_back(dictName2FullName(name));
                 }
         }
         return names;
 }
+
 std::vector<std::string> lggHunSpell_Wrapper::getInstalledDicts()
 {
         std::vector<std::string> toReturn;
         //expecting short names to be stored...
-        std::vector<std::string> shortNames =  CSV2VEC(gSavedSettings.getString("EmeraldSpellInstalled"));
-        for(int i =0;i<(int)shortNames.size();i++)
+        std::vector<std::string> shortNames = CSV2VEC(gSavedSettings.getString("EmeraldSpellInstalled"));
+        for (int i =0; i < (int)shortNames.size(); i++)
+        {
                 toReturn.push_back(dictName2FullName(shortNames[i]));
+        }
         return toReturn;
 }
+
 std::vector<std::string> lggHunSpell_Wrapper::getAvailDicts()
 {
         std::vector<std::string> toReturn;
         std::vector<std::string> dics = getExtraDicts();
         std::vector<std::string> installedDics = getInstalledDicts();
-        for(int i =0;i<(int)dics.size();i++)
+        for (int i = 0; i < (int)dics.size(); i++)
         {
                 bool found = false;
-                for(int j=0;j<(int)installedDics.size();j++)
+                for (int j = 0; j < (int)installedDics.size(); j++)
+                {
+                        if (0 == LLStringUtil::compareInsensitive(dics[i], installedDics[j]))
+                        {
+                                found = true;//this dic is already installed
+                        }
+                }
+                if (0 == LLStringUtil::compareInsensitive(dics[i], currentBaseDic))
                 {
-                        if(0==LLStringUtil::compareInsensitive(dics[i],installedDics[j]))
-                                found=true;//this dic is already installed
+                        found = true;
+                }
+                if (0 == LLStringUtil::compareInsensitive(dics[i], "Emerald (CUSTOM)"))
+                {
+                        found = true;
+                }
+                if (!found)
+                {
+                        toReturn.push_back(dics[i]);
                 }
-                if(0==LLStringUtil::compareInsensitive(dics[i],currentBaseDic))
-                        found=true;
-                if(0==LLStringUtil::compareInsensitive(dics[i],"Emerald (CUSTOM)"))
-                        found=true;
-                if(!found)toReturn.push_back(dics[i]);
         }
         return toReturn;
 }
+
 std::vector<std::string> lggHunSpell_Wrapper::CSV2VEC(std::string csv)
 {
         std::vector<std::string> toReturn;
         boost::regex re(",");
         boost::sregex_token_iterator i(csv.begin(), csv.end(), re, -1);
         boost::sregex_token_iterator j;
-        while(i != j)
+        while (i != j)
+        {
                 toReturn.push_back(*i++);
+        }
         return toReturn;
 }
+
 std::string lggHunSpell_Wrapper::VEC2CSV(std::vector<std::string> vec)
 {
-        std::string toReturn="";
-        if(vec.size()<1)return toReturn;
-        for(int i = 0;i<(int)vec.size();i++)
-                toReturn+=vec[i]+",";
+        std::string toReturn("");
+        if (vec.size() < 1)
+        {
+                return toReturn;
+        }
+
+        for (int i = 0;i < (int)vec.size() ;i++)
+        {
+                toReturn += vec[i] + ",";
+        }
         return toReturn.erase(toReturn.length()-1);
 }
+
 void lggHunSpell_Wrapper::addButton(std::string selection)
 {
-        if(selection=="")return;
+        if (selection.empty())
+        {
+                return;
+        }
         addDictionary(selection);
         std::vector<std::string> alreadyInstalled = CSV2VEC(gSavedSettings.getString("EmeraldSpellInstalled"));
         alreadyInstalled.push_back(fullName2DictName(selection));       
-        gSavedSettings.setString("EmeraldSpellInstalled",VEC2CSV(alreadyInstalled));
+        gSavedSettings.setString("EmeraldSpellInstalled", VEC2CSV(alreadyInstalled));
 }
+
 void lggHunSpell_Wrapper::removeButton(std::string selection)
 {
-        if(selection=="")return;
+        if (selection.empty())
+        {
+                return;
+        }
         std::vector<std::string> newInstalledDics;
         std::vector<std::string> currentlyInstalled = getInstalledDicts();
-        for(int i =0;i<(int)currentlyInstalled.size();i++)
+        for (int i = 0; i < (int)currentlyInstalled.size(); i++)
         {
-                if(0!=LLStringUtil::compareInsensitive(selection,currentlyInstalled[i]))
+                if (0 != LLStringUtil::compareInsensitive(selection, currentlyInstalled[i]))
+                {
                         newInstalledDics.push_back(fullName2DictName(currentlyInstalled[i]));
+                }
         }
-        gSavedSettings.setString("EmeraldSpellInstalled",VEC2CSV(newInstalledDics));
+        gSavedSettings.setString("EmeraldSpellInstalled", VEC2CSV(newInstalledDics));
         processSettings();
 }
+
 void lggHunSpell_Wrapper::newDictSelection(std::string selection)
 {
-        currentBaseDic=selection;
-        gSavedSettings.setString("EmeraldSpellBase",selection);
+        currentBaseDic = selection;
+        gSavedSettings.setString("EmeraldSpellBase", selection);
         //better way to do this would be to check and see if there is a installed conflict
         //and then only remove that one.. messy
-        gSavedSettings.setString("EmeraldSpellInstalled","en_sl");
+        gSavedSettings.setString("EmeraldSpellInstalled", "en_sl");
         processSettings();
 }
-void lggHunSpell_Wrapper::getMoreButton(void * data)
+
+void lggHunSpell_Wrapper::getMoreButton(void* data)
 {
         std::vector<std::string> shortNames;
         std::vector<std::string> longNames;
         LLSD response = LLHTTPClient::blockingGet(gSavedSettings.getString("DicDownloadBaseURL")+"dic_list.xml");
-        if(response.has("body"))
+        if (response.has("body"))
         {
                 const LLSD &dict_list = response["body"];
-                if(dict_list.has("isComplete"))
+                if (dict_list.has("isComplete"))
                 {
                         LLSD dics = dict_list["data"];
-                        for(int i = 0; i < dics.size(); i++)
+                        for (int i = 0; i < dics.size(); i++)
                         {
                                 std::string dicFullName = dictName2FullName(dics[i].asString());
                                 longNames.push_back(dicFullName);
@@ -864,11 +950,12 @@ void lggHunSpell_Wrapper::getMoreButton(void * data)
                 }
         }
 }
+
 void lggHunSpell_Wrapper::editCustomButton()
 {
         std::string dicdicpath(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "dictionaries", std::string("custom.dic")).c_str());
 
-        if(!gDirUtilp->fileExists(dicdicpath))
+        if (!gDirUtilp->fileExists(dicdicpath))
         {
                         createCustomDic();
                         //glggHunSpell->addWordToCustomDictionary("temp");
@@ -877,7 +964,7 @@ void lggHunSpell_Wrapper::editCustomButton()
         gViewerWindow->getWindow()->ShellEx(dicdicpath);
 }
 
-void lggHunSpell_Wrapper::setNewHighlightSetting( BOOL highlight )
+void lggHunSpell_Wrapper::setNewHighlightSetting(BOOL highlight)
 {
-        highlightInRed=highlight;
+        mSpellCheckHighlight = highlight;
 }
diff --git a/linden/indra/newview/lgghunspell_wrapper.h b/linden/indra/newview/lgghunspell_wrapper.h
index 348f479..4d07ff8 100644
--- a/linden/indra/newview/lgghunspell_wrapper.h
+++ b/linden/indra/newview/lgghunspell_wrapper.h
@@ -28,9 +28,9 @@ class lggHunSpell_Wrapper
 {
 
 public:
-        static Hunspell * myHunspell;
+        static Hunspell* myHunspell;
 
-        BOOL highlightInRed;
+        BOOL mSpellCheckHighlight;
 
         static void initSettings();
         void processSettings();
@@ -69,6 +69,6 @@ private:
         //std::vector<std::string> countryCodes;
 };
 
-extern lggHunSpell_Wrapper *glggHunSpell; // the singleton hunspell wrapper
+extern lggHunSpell_Wrapper* glggHunSpell; // the singleton hunspell wrapper
 
 #endif