#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 2010 insertions, 2010 deletions

diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 5768ceacd3..a41b7ba4a8 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llview.cpp
  * @author James Cook
  * @brief Container for other views, anything that draws.
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -57,27 +57,27 @@
 
 static const S32 LINE_HEIGHT = 15;
 
-S32		LLView::sDepth = 0;
-bool	LLView::sDebugRects = false;
-bool	LLView::sDebugUnicode = false;
-bool	LLView::sDebugCamera = false;
-bool	LLView::sIsRectDirty = false;
-LLRect	LLView::sDirtyRect;
-bool	LLView::sDebugRectsShowNames = true;
-bool	LLView::sDebugKeys = false;
-bool	LLView::sDebugMouseHandling = false;
+S32     LLView::sDepth = 0;
+bool    LLView::sDebugRects = false;
+bool    LLView::sDebugUnicode = false;
+bool    LLView::sDebugCamera = false;
+bool    LLView::sIsRectDirty = false;
+LLRect  LLView::sDirtyRect;
+bool    LLView::sDebugRectsShowNames = true;
+bool    LLView::sDebugKeys = false;
+bool    LLView::sDebugMouseHandling = false;
 std::string LLView::sMouseHandlerMessage;
-BOOL	LLView::sForceReshape = FALSE;
+BOOL    LLView::sForceReshape = FALSE;
 std::set<LLView*> LLView::sPreviewHighlightedElements;
 BOOL LLView::sHighlightingDiffs = FALSE;
 LLView* LLView::sPreviewClickedElement = NULL;
-BOOL	LLView::sDrawPreviewHighlights = FALSE;
-S32		LLView::sLastLeftXML = S32_MIN;
-S32		LLView::sLastBottomXML = S32_MIN;
+BOOL    LLView::sDrawPreviewHighlights = FALSE;
+S32     LLView::sLastLeftXML = S32_MIN;
+S32     LLView::sLastBottomXML = S32_MIN;
 std::vector<LLViewDrawContext*> LLViewDrawContext::sDrawContextStack;
 
 LLView::DrilldownFunc LLView::sDrilldown =
-	boost::bind(&LLView::pointInView, _1, _2, _3, HIT_TEST_USE_BOUNDING_RECT);
+    boost::bind(&LLView::pointInView, _1, _2, _3, HIT_TEST_USE_BOUNDING_RECT);
 
 //#if LL_DEBUG
 BOOL LLView::sIsDrawing = FALSE;
@@ -85,233 +85,233 @@ BOOL LLView::sIsDrawing = FALSE;
 
 // Compiler optimization, generate extern template
 template class LLView* LLView::getChild<class LLView>(
-	const std::string& name, BOOL recurse) const;
+    const std::string& name, BOOL recurse) const;
 
 static LLDefaultChildRegistry::Register<LLView> r("view");
 
 void deleteView(LLView *aView)
 {
-	delete aView;
+    delete aView;
 }
 
 namespace LLInitParam
 {
-	void TypeValues<LLView::EOrientation>::declareValues()
-	{
-		declare("horizontal", LLView::HORIZONTAL);
-		declare("vertical", LLView::VERTICAL);	
-	}
+    void TypeValues<LLView::EOrientation>::declareValues()
+    {
+        declare("horizontal", LLView::HORIZONTAL);
+        declare("vertical", LLView::VERTICAL);
+    }
 }
 
 
 LLView::Follows::Follows()
 :   string(""),
-	flags("flags", FOLLOWS_LEFT | FOLLOWS_TOP)
+    flags("flags", FOLLOWS_LEFT | FOLLOWS_TOP)
 {}
 
 LLView::Params::Params()
-:	name("name", std::string("unnamed")),
-	enabled("enabled", true),
-	visible("visible", true),
-	mouse_opaque("mouse_opaque", true),
-	follows("follows"),
-	hover_cursor("hover_cursor", "UI_CURSOR_ARROW"),
-	use_bounding_rect("use_bounding_rect", false),
-	tab_group("tab_group", 0),
-	default_tab_group("default_tab_group"),
-	tool_tip("tool_tip"),
-	sound_flags("sound_flags", MOUSE_UP),
-	layout("layout"),
-	rect("rect"),
-	bottom_delta("bottom_delta", S32_MAX),
-	top_pad("top_pad"),
-	top_delta("top_delta", S32_MAX),
-	left_pad("left_pad"),
-	left_delta("left_delta", S32_MAX),
-	from_xui("from_xui", false),
-	focus_root("focus_root", false),
-	needs_translate("translate"),
-	xmlns("xmlns"),
-	xmlns_xsi("xmlns:xsi"),
-	xsi_schemaLocation("xsi:schemaLocation"),
-	xsi_type("xsi:type")
-
-{
-	addSynonym(rect, "");
+:   name("name", std::string("unnamed")),
+    enabled("enabled", true),
+    visible("visible", true),
+    mouse_opaque("mouse_opaque", true),
+    follows("follows"),
+    hover_cursor("hover_cursor", "UI_CURSOR_ARROW"),
+    use_bounding_rect("use_bounding_rect", false),
+    tab_group("tab_group", 0),
+    default_tab_group("default_tab_group"),
+    tool_tip("tool_tip"),
+    sound_flags("sound_flags", MOUSE_UP),
+    layout("layout"),
+    rect("rect"),
+    bottom_delta("bottom_delta", S32_MAX),
+    top_pad("top_pad"),
+    top_delta("top_delta", S32_MAX),
+    left_pad("left_pad"),
+    left_delta("left_delta", S32_MAX),
+    from_xui("from_xui", false),
+    focus_root("focus_root", false),
+    needs_translate("translate"),
+    xmlns("xmlns"),
+    xmlns_xsi("xmlns:xsi"),
+    xsi_schemaLocation("xsi:schemaLocation"),
+    xsi_type("xsi:type")
+
+{
+    addSynonym(rect, "");
 }
 
 LLView::LLView(const LLView::Params& p)
-:	mVisible(p.visible),
-	mInDraw(false),
-	mName(p.name),
-	mParentView(NULL),
-	mReshapeFlags(FOLLOWS_NONE),
-	mFromXUI(p.from_xui),
-	mIsFocusRoot(p.focus_root),
-	mLastVisible(FALSE),
-	mHoverCursor(getCursorFromString(p.hover_cursor)),
-	mEnabled(p.enabled),
-	mMouseOpaque(p.mouse_opaque),
-	mSoundFlags(p.sound_flags),
-	mUseBoundingRect(p.use_bounding_rect),
-	mDefaultTabGroup(p.default_tab_group),
-	mLastTabGroup(0),
-	mToolTipMsg((LLStringExplicit)p.tool_tip()),
-	mDefaultWidgets(NULL)
-{
-	// create rect first, as this will supply initial follows flags
-	setShape(p.rect);
-	parseFollowsFlags(p);
+:   mVisible(p.visible),
+    mInDraw(false),
+    mName(p.name),
+    mParentView(NULL),
+    mReshapeFlags(FOLLOWS_NONE),
+    mFromXUI(p.from_xui),
+    mIsFocusRoot(p.focus_root),
+    mLastVisible(FALSE),
+    mHoverCursor(getCursorFromString(p.hover_cursor)),
+    mEnabled(p.enabled),
+    mMouseOpaque(p.mouse_opaque),
+    mSoundFlags(p.sound_flags),
+    mUseBoundingRect(p.use_bounding_rect),
+    mDefaultTabGroup(p.default_tab_group),
+    mLastTabGroup(0),
+    mToolTipMsg((LLStringExplicit)p.tool_tip()),
+    mDefaultWidgets(NULL)
+{
+    // create rect first, as this will supply initial follows flags
+    setShape(p.rect);
+    parseFollowsFlags(p);
 }
 
 LLView::~LLView()
 {
-	dirtyRect();
-	//LL_INFOS() << "Deleting view " << mName << ":" << (void*) this << LL_ENDL;
-	if (LLView::sIsDrawing)
-	{
-		LL_DEBUGS() << "Deleting view " << mName << " during UI draw() phase" << LL_ENDL;
-	}
-// 	llassert(LLView::sIsDrawing == FALSE);
-	
-//	llassert_always(sDepth == 0); // avoid deleting views while drawing! It can subtly break list iterators
-	
-	if( hasMouseCapture() )
-	{
-		//LL_WARNS() << "View holding mouse capture deleted: " << getName() << ".  Mouse capture removed." << LL_ENDL;
-		gFocusMgr.removeMouseCaptureWithoutCallback( this );
-	}
-
-	deleteAllChildren();
-
-	if (mParentView != NULL)
-	{
-		mParentView->removeChild(this);
-	}
-
-	if (mDefaultWidgets)
-	{
-		delete mDefaultWidgets;
-		mDefaultWidgets = NULL;
-	}
+    dirtyRect();
+    //LL_INFOS() << "Deleting view " << mName << ":" << (void*) this << LL_ENDL;
+    if (LLView::sIsDrawing)
+    {
+        LL_DEBUGS() << "Deleting view " << mName << " during UI draw() phase" << LL_ENDL;
+    }
+//  llassert(LLView::sIsDrawing == FALSE);
+
+//  llassert_always(sDepth == 0); // avoid deleting views while drawing! It can subtly break list iterators
+
+    if( hasMouseCapture() )
+    {
+        //LL_WARNS() << "View holding mouse capture deleted: " << getName() << ".  Mouse capture removed." << LL_ENDL;
+        gFocusMgr.removeMouseCaptureWithoutCallback( this );
+    }
+
+    deleteAllChildren();
+
+    if (mParentView != NULL)
+    {
+        mParentView->removeChild(this);
+    }
+
+    if (mDefaultWidgets)
+    {
+        delete mDefaultWidgets;
+        mDefaultWidgets = NULL;
+    }
 }
 
 // virtual
 BOOL LLView::isCtrl() const
 {
-	return FALSE;
+    return FALSE;
 }
 
 // virtual
 BOOL LLView::isPanel() const
 {
-	return FALSE;
+    return FALSE;
 }
 
 void LLView::setToolTip(const LLStringExplicit& msg)
 {
-	mToolTipMsg = msg;
+    mToolTipMsg = msg;
 }
 
 BOOL LLView::setToolTipArg(const LLStringExplicit& key, const LLStringExplicit& text)
 {
-	mToolTipMsg.setArg(key, text);
-	return TRUE;
+    mToolTipMsg.setArg(key, text);
+    return TRUE;
 }
 
 void LLView::setToolTipArgs( const LLStringUtil::format_map_t& args )
 {
-	mToolTipMsg.setArgList(args);
+    mToolTipMsg.setArgList(args);
 }
 
 // virtual
 void LLView::setRect(const LLRect& rect)
 {
-	mRect = rect;
-	updateBoundingRect();
+    mRect = rect;
+    updateBoundingRect();
 }
 
-void LLView::setUseBoundingRect( BOOL use_bounding_rect ) 
+void LLView::setUseBoundingRect( BOOL use_bounding_rect )
 {
-	if (mUseBoundingRect != use_bounding_rect)
-	{
-        mUseBoundingRect = use_bounding_rect; 
-		updateBoundingRect();
-	}
+    if (mUseBoundingRect != use_bounding_rect)
+    {
+        mUseBoundingRect = use_bounding_rect;
+        updateBoundingRect();
+    }
 }
 
 BOOL LLView::getUseBoundingRect() const
 {
-	return mUseBoundingRect;
+    return mUseBoundingRect;
 }
 
 // virtual
 const std::string& LLView::getName() const
 {
-	static std::string no_name("(no name)");
+    static std::string no_name("(no name)");
 
-	return mName.empty() ? no_name : mName;
+    return mName.empty() ? no_name : mName;
 }
 
 void LLView::sendChildToFront(LLView* child)
 {
-// 	llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
-	if (child && child->getParent() == this) 
-	{
-		// minor optimization, but more importantly,
-		//  won't temporarily create an empty list
-		if (child != mChildList.front())
-		{
-			mChildList.remove( child );
-			mChildList.push_front(child);
-		}
-	}
+//  llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
+    if (child && child->getParent() == this)
+    {
+        // minor optimization, but more importantly,
+        //  won't temporarily create an empty list
+        if (child != mChildList.front())
+        {
+            mChildList.remove( child );
+            mChildList.push_front(child);
+        }
+    }
 }
 
 void LLView::sendChildToBack(LLView* child)
 {
-// 	llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
-	if (child && child->getParent() == this) 
-	{
-		// minor optimization, but more importantly,
-		//  won't temporarily create an empty list
-		if (child != mChildList.back())
-		{
-			mChildList.remove( child );
-			mChildList.push_back(child);
-		}
-	}
+//  llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
+    if (child && child->getParent() == this)
+    {
+        // minor optimization, but more importantly,
+        //  won't temporarily create an empty list
+        if (child != mChildList.back())
+        {
+            mChildList.remove( child );
+            mChildList.push_back(child);
+        }
+    }
 }
 
 // virtual
 bool LLView::addChild(LLView* child, S32 tab_group)
 {
-	if (!child)
-	{
-		return false;
-	}
+    if (!child)
+    {
+        return false;
+    }
 
-	if (this == child) 
-	{
-		LL_ERRS() << "Adding view " << child->getName() << " as child of itself" << LL_ENDL;
-	}
+    if (this == child)
+    {
+        LL_ERRS() << "Adding view " << child->getName() << " as child of itself" << LL_ENDL;
+    }
 
-	// remove from current parent
-	if (child->mParentView) 
-	{
-		child->mParentView->removeChild(child);
-	}
+    // remove from current parent
+    if (child->mParentView)
+    {
+        child->mParentView->removeChild(child);
+    }
 
-	// add to front of child list, as normal
-	mChildList.push_front(child);
+    // add to front of child list, as normal
+    mChildList.push_front(child);
 
-	// add to tab order list
-	if (tab_group != 0)
-	{
-		mTabOrder.insert(tab_order_pair_t(child, tab_group));
-	}
+    // add to tab order list
+    if (tab_group != 0)
+    {
+        mTabOrder.insert(tab_order_pair_t(child, tab_group));
+    }
 
-	child->mParentView = this;
+    child->mParentView = this;
     if (getVisible() && child->getVisible())
     {
         // if child isn't visible it won't affect bounding rect
@@ -319,119 +319,119 @@ bool LLView::addChild(LLView* child, S32 tab_group)
         // on visibility change
         updateBoundingRect();
     }
-	mLastTabGroup = tab_group;
-	return true;
+    mLastTabGroup = tab_group;
+    return true;
 }
 
 
 bool LLView::addChildInBack(LLView* child, S32 tab_group)
 {
-	if(addChild(child, tab_group))
-	{
-		sendChildToBack(child);
-		return true;
-	}
+    if(addChild(child, tab_group))
+    {
+        sendChildToBack(child);
+        return true;
+    }
 
-	return false;
+    return false;
 }
 
 // remove the specified child from the view, and set it's parent to NULL.
 void LLView::removeChild(LLView* child)
 {
-	//llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
-	if (child->mParentView == this) 
-	{
-		// if we are removing an item we are currently iterating over, that would be bad
-		llassert(child->mInDraw == false);
-		mChildList.remove( child );
-		child->mParentView = NULL;
-		child_tab_order_t::iterator found = mTabOrder.find(child);
-		if(found != mTabOrder.end())
-		{
-			mTabOrder.erase(found);
-		}
-	}
-	else
-	{
-		LL_WARNS() << "\"" << child->getName() << "\" is not a child of " << getName() << LL_ENDL;
-	}
-	updateBoundingRect();
+    //llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
+    if (child->mParentView == this)
+    {
+        // if we are removing an item we are currently iterating over, that would be bad
+        llassert(child->mInDraw == false);
+        mChildList.remove( child );
+        child->mParentView = NULL;
+        child_tab_order_t::iterator found = mTabOrder.find(child);
+        if(found != mTabOrder.end())
+        {
+            mTabOrder.erase(found);
+        }
+    }
+    else
+    {
+        LL_WARNS() << "\"" << child->getName() << "\" is not a child of " << getName() << LL_ENDL;
+    }
+    updateBoundingRect();
 }
 
 BOOL LLView::isInVisibleChain() const
 {
-	BOOL visible = TRUE;
+    BOOL visible = TRUE;
 
-	const LLView* viewp = this;
-	while(viewp)
-	{
-		if (!viewp->getVisible())
-		{
-			visible = FALSE;
-			break;
-		}
-		viewp = viewp->getParent();
-	}
-	
-	return visible;
+    const LLView* viewp = this;
+    while(viewp)
+    {
+        if (!viewp->getVisible())
+        {
+            visible = FALSE;
+            break;
+        }
+        viewp = viewp->getParent();
+    }
+
+    return visible;
 }
 
 BOOL LLView::isInEnabledChain() const
 {
-	BOOL enabled = TRUE;
+    BOOL enabled = TRUE;
 
-	const LLView* viewp = this;
-	while(viewp)
-	{
-		if (!viewp->getEnabled())
-		{
-			enabled = FALSE;
-			break;
-		}
-		viewp = viewp->getParent();
-	}
-	
-	return enabled;
+    const LLView* viewp = this;
+    while(viewp)
+    {
+        if (!viewp->getEnabled())
+        {
+            enabled = FALSE;
+            break;
+        }
+        viewp = viewp->getParent();
+    }
+
+    return enabled;
 }
 
 static void buildPathname(std::ostream& out, const LLView* view)
 {
-	if (! (view && view->getParent()))
-	{
-		return; // Don't include root in the path.
-	}
-
-	buildPathname(out, view->getParent());
-
-	// Build pathname into ostream on the way back from recursion.
-	out << '/';
-
-	// substitute all '/' in name with appropriate code
-	std::string name = view->getName();
-	std::size_t found = name.find('/');
-	std::size_t start = 0;
-	while (found != std::string::npos)
-	{
-		std::size_t sub_len = found - start;
-		if (sub_len > 0)
-		{
-			out << name.substr(start, sub_len);
-		}
-		out << "%2F";
-		start = found + 1;
-		found = name.find('/', start);
-	}
-	if (start < name.size())
-	{
-		out << name.substr(start, name.size() - start);
-	}
+    if (! (view && view->getParent()))
+    {
+        return; // Don't include root in the path.
+    }
+
+    buildPathname(out, view->getParent());
+
+    // Build pathname into ostream on the way back from recursion.
+    out << '/';
+
+    // substitute all '/' in name with appropriate code
+    std::string name = view->getName();
+    std::size_t found = name.find('/');
+    std::size_t start = 0;
+    while (found != std::string::npos)
+    {
+        std::size_t sub_len = found - start;
+        if (sub_len > 0)
+        {
+            out << name.substr(start, sub_len);
+        }
+        out << "%2F";
+        start = found + 1;
+        found = name.find('/', start);
+    }
+    if (start < name.size())
+    {
+        out << name.substr(start, name.size() - start);
+    }
 }
 
 std::string LLView::getPathname() const
 {
-	std::ostringstream out;
-	buildPathname(out, this);
-	return out.str();
+    std::ostringstream out;
+    buildPathname(out, this);
+    return out.str();
 }
 
 //static
@@ -447,13 +447,13 @@ std::string LLView::getPathname(const LLView* view)
 // virtual
 BOOL LLView::canFocusChildren() const
 {
-	return TRUE;
+    return TRUE;
 }
 
 //virtual
 void LLView::setEnabled(BOOL enabled)
 {
-	mEnabled = enabled;
+    mEnabled = enabled;
 }
 
 //virtual
@@ -471,106 +471,106 @@ bool LLView::isAvailable(const LLView* view)
 //virtual
 BOOL LLView::setLabelArg( const std::string& key, const LLStringExplicit& text )
 {
-	return FALSE;
+    return FALSE;
 }
 
 //virtual
 LLRect LLView::getSnapRect() const
 {
-	return mRect;
+    return mRect;
 }
 
 //virtual
 LLRect LLView::getRequiredRect()
 {
-	return mRect;
+    return mRect;
 }
 
 BOOL LLView::focusNextRoot()
 {
-	LLView::child_list_t result = LLView::getFocusRootsQuery().run(this);
-	return LLView::focusNext(result);
+    LLView::child_list_t result = LLView::getFocusRootsQuery().run(this);
+    return LLView::focusNext(result);
 }
 
 BOOL LLView::focusPrevRoot()
 {
-	LLView::child_list_t result = LLView::getFocusRootsQuery().run(this);
-	return LLView::focusPrev(result);
+    LLView::child_list_t result = LLView::getFocusRootsQuery().run(this);
+    return LLView::focusPrev(result);
 }
 
 // static
 BOOL LLView::focusNext(LLView::child_list_t & result)
 {
-	LLView::child_list_reverse_iter_t focused = result.rend();
-	for(LLView::child_list_reverse_iter_t iter = result.rbegin();
-		iter != result.rend();
-		++iter)
-	{
-		if(gFocusMgr.childHasKeyboardFocus(*iter))
-		{
-			focused = iter;
-			break;
-		}
-	}
-	LLView::child_list_reverse_iter_t next = focused;
-	next = (next == result.rend()) ? result.rbegin() : ++next;
-	while(next != focused)
-	{
-		// wrap around to beginning if necessary
-		if(next == result.rend())
-		{
-			next = result.rbegin();
-		}
-		if ((*next)->isCtrl() && ((LLUICtrl*)*next)->hasTabStop())
-		{
-			LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
-			ctrl->setFocus(TRUE);
-			ctrl->onTabInto();  
-			gFocusMgr.triggerFocusFlash();
-			return TRUE;
-		}
-		++next;
-	}
-	return FALSE;
+    LLView::child_list_reverse_iter_t focused = result.rend();
+    for(LLView::child_list_reverse_iter_t iter = result.rbegin();
+        iter != result.rend();
+        ++iter)
+    {
+        if(gFocusMgr.childHasKeyboardFocus(*iter))
+        {
+            focused = iter;
+            break;
+        }
+    }
+    LLView::child_list_reverse_iter_t next = focused;
+    next = (next == result.rend()) ? result.rbegin() : ++next;
+    while(next != focused)
+    {
+        // wrap around to beginning if necessary
+        if(next == result.rend())
+        {
+            next = result.rbegin();
+        }
+        if ((*next)->isCtrl() && ((LLUICtrl*)*next)->hasTabStop())
+        {
+            LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
+            ctrl->setFocus(TRUE);
+            ctrl->onTabInto();
+            gFocusMgr.triggerFocusFlash();
+            return TRUE;
+        }
+        ++next;
+    }
+    return FALSE;
 }
 
 // static
 BOOL LLView::focusPrev(LLView::child_list_t & result)
 {
-	LLView::child_list_iter_t focused = result.end();
-	for(LLView::child_list_iter_t iter = result.begin();
-		iter != result.end();
-		++iter)
-	{
-		if(gFocusMgr.childHasKeyboardFocus(*iter))
-		{
-			focused = iter;
-			break;
-		}
-	}
-	LLView::child_list_iter_t next = focused;
-	next = (next == result.end()) ? result.begin() : ++next;
-	while(next != focused)
-	{
-		// wrap around to beginning if necessary
-		if(next == result.end())
-		{
-			next = result.begin();
-		}
-		if((*next)->isCtrl())
-		{
-			LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
-			if (!ctrl->hasFocus())
-			{
-				ctrl->setFocus(TRUE);
-				ctrl->onTabInto();  
-				gFocusMgr.triggerFocusFlash();
-			}
-			return TRUE;
-		}
-		++next;
-	}
-	return FALSE;
+    LLView::child_list_iter_t focused = result.end();
+    for(LLView::child_list_iter_t iter = result.begin();
+        iter != result.end();
+        ++iter)
+    {
+        if(gFocusMgr.childHasKeyboardFocus(*iter))
+        {
+            focused = iter;
+            break;
+        }
+    }
+    LLView::child_list_iter_t next = focused;
+    next = (next == result.end()) ? result.begin() : ++next;
+    while(next != focused)
+    {
+        // wrap around to beginning if necessary
+        if(next == result.end())
+        {
+            next = result.begin();
+        }
+        if((*next)->isCtrl())
+        {
+            LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
+            if (!ctrl->hasFocus())
+            {
+                ctrl->setFocus(TRUE);
+                ctrl->onTabInto();
+                gFocusMgr.triggerFocusFlash();
+            }
+            return TRUE;
+        }
+        ++next;
+    }
+    return FALSE;
 }
 
 // delete all children. Override this function if you need to
@@ -578,82 +578,82 @@ BOOL LLView::focusPrev(LLView::child_list_t & result)
 // children, etc.
 void LLView::deleteAllChildren()
 {
-	// clear out the control ordering
-	mTabOrder.clear();
+    // clear out the control ordering
+    mTabOrder.clear();
 
-	while (!mChildList.empty())
-	{
+    while (!mChildList.empty())
+    {
         LLView* viewp = mChildList.front();
         viewp->mParentView = NULL;
         delete viewp;
         mChildList.pop_front();
-	}
+    }
     updateBoundingRect();
 }
 
 void LLView::setAllChildrenEnabled(BOOL b)
 {
-	for (LLView* viewp : mChildList)
-	{
-		viewp->setEnabled(b);
-	}
+    for (LLView* viewp : mChildList)
+    {
+        viewp->setEnabled(b);
+    }
 }
 
 // virtual
 void LLView::setVisible(BOOL visible)
 {
-	if ( mVisible != visible )
-	{
-		mVisible = visible;
-
-		// notify children of visibility change if root, or part of visible hierarchy
-		if (!getParent() || getParent()->isInVisibleChain())
-		{
-			// tell all children of this view that the visibility may have changed
-			dirtyRect();
-			onVisibilityChange( visible );
-		}
-		updateBoundingRect();
-	}
+    if ( mVisible != visible )
+    {
+        mVisible = visible;
+
+        // notify children of visibility change if root, or part of visible hierarchy
+        if (!getParent() || getParent()->isInVisibleChain())
+        {
+            // tell all children of this view that the visibility may have changed
+            dirtyRect();
+            onVisibilityChange( visible );
+        }
+        updateBoundingRect();
+    }
 }
 
 // virtual
 void LLView::onVisibilityChange ( BOOL new_visibility )
 {
-	BOOL old_visibility;
-	BOOL log_visibility_change = LLViewerEventRecorder::instance().getLoggingStatus();
-	for (LLView* viewp : mChildList)
-	{
-		if (!viewp)
-		{
-			continue;
-		}
-
-		// only views that are themselves visible will have their overall visibility affected by their ancestors
-		old_visibility=viewp->getVisible();
-
-		if(log_visibility_change)
-		{
-		if (old_visibility!=new_visibility)
-		{
-			LLViewerEventRecorder::instance().logVisibilityChange( viewp->getPathname(), viewp->getName(), new_visibility,"widget");
-		}
-		}
-
-		if (old_visibility)
-		{
-			viewp->onVisibilityChange ( new_visibility );
-		}
-
-		if(log_visibility_change)
-		{
-			// Consider changing returns to confirm success and know which widget grabbed it
-			// For now assume success and log at highest xui possible 
-			// NOTE we log actual state - which may differ if it somehow failed to set visibility
-			LL_DEBUGS() << "LLView::handleVisibilityChange	 - now: " << getVisible()  << " xui: " << viewp->getPathname() << " name: " << viewp->getName() << LL_ENDL;
-		
-		}
-	}
+    BOOL old_visibility;
+    BOOL log_visibility_change = LLViewerEventRecorder::instance().getLoggingStatus();
+    for (LLView* viewp : mChildList)
+    {
+        if (!viewp)
+        {
+            continue;
+        }
+
+        // only views that are themselves visible will have their overall visibility affected by their ancestors
+        old_visibility=viewp->getVisible();
+
+        if(log_visibility_change)
+        {
+        if (old_visibility!=new_visibility)
+        {
+            LLViewerEventRecorder::instance().logVisibilityChange( viewp->getPathname(), viewp->getName(), new_visibility,"widget");
+        }
+        }
+
+        if (old_visibility)
+        {
+            viewp->onVisibilityChange ( new_visibility );
+        }
+
+        if(log_visibility_change)
+        {
+            // Consider changing returns to confirm success and know which widget grabbed it
+            // For now assume success and log at highest xui possible
+            // NOTE we log actual state - which may differ if it somehow failed to set visibility
+            LL_DEBUGS() << "LLView::handleVisibilityChange   - now: " << getVisible()  << " xui: " << viewp->getPathname() << " name: " << viewp->getName() << LL_ENDL;
+
+        }
+    }
 }
 
 // virtual
@@ -669,14 +669,14 @@ void LLView::onUpdateScrollToChild(const LLUICtrl * cntrl)
 // virtual
 void LLView::translate(S32 x, S32 y)
 {
-	mRect.translate(x, y);
-	updateBoundingRect();
+    mRect.translate(x, y);
+    updateBoundingRect();
 }
 
 // virtual
 BOOL LLView::canSnapTo(const LLView* other_view)
 {
-	return other_view != this && other_view->getVisible();
+    return other_view != this && other_view->getVisible();
 }
 
 // virtual
@@ -686,58 +686,58 @@ void LLView::setSnappedTo(const LLView* snap_view)
 
 BOOL LLView::handleHover(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleHover( x, y, mask ) != NULL;
+    return childrenHandleHover( x, y, mask ) != NULL;
 }
 
 void LLView::onMouseEnter(S32 x, S32 y, MASK mask)
 {
-	//LL_INFOS() << "Mouse entered " << getName() << LL_ENDL;
+    //LL_INFOS() << "Mouse entered " << getName() << LL_ENDL;
 }
 
 void LLView::onMouseLeave(S32 x, S32 y, MASK mask)
 {
-	//LL_INFOS() << "Mouse left " << getName() << LL_ENDL;
+    //LL_INFOS() << "Mouse left " << getName() << LL_ENDL;
 }
 
 bool LLView::visibleAndContains(S32 local_x, S32 local_y)
 {
-	return sDrilldown(this, local_x, local_y)
-		&& getVisible();
+    return sDrilldown(this, local_x, local_y)
+        && getVisible();
 }
 
 bool LLView::visibleEnabledAndContains(S32 local_x, S32 local_y)
 {
-	return visibleAndContains(local_x, local_y)
-		&& getEnabled();
+    return visibleAndContains(local_x, local_y)
+        && getEnabled();
 }
 
 // This is NOT event recording related
 void LLView::logMouseEvent()
 {
-	if (sDebugMouseHandling)
-	{
-		sMouseHandlerMessage = std::string("/") + mName + sMouseHandlerMessage;
-	}
+    if (sDebugMouseHandling)
+    {
+        sMouseHandlerMessage = std::string("/") + mName + sMouseHandlerMessage;
+    }
 }
 
 template <typename METHOD, typename CHARTYPE>
 LLView* LLView::childrenHandleCharEvent(const std::string& desc, const METHOD& method,
-										CHARTYPE c, MASK mask)
-{
-	if ( getVisible() && getEnabled() )
-	{
-		for (LLView* viewp : mChildList)
-		{
-			if ((viewp->*method)(c, mask, TRUE))
-			{
-				if (LLView::sDebugKeys)
-				{
-					LL_INFOS() << desc << " handled by " << viewp->getName() << LL_ENDL;
-				}
-				return viewp;
-			}
-		}
-	}
+                                        CHARTYPE c, MASK mask)
+{
+    if ( getVisible() && getEnabled() )
+    {
+        for (LLView* viewp : mChildList)
+        {
+            if ((viewp->*method)(c, mask, TRUE))
+            {
+                if (LLView::sDebugKeys)
+                {
+                    LL_INFOS() << desc << " handled by " << viewp->getName() << LL_ENDL;
+                }
+                return viewp;
+            }
+        }
+    }
     return NULL;
 }
 
@@ -745,146 +745,146 @@ LLView* LLView::childrenHandleCharEvent(const std::string& desc, const METHOD& m
 template <typename METHOD, typename XDATA>
 LLView* LLView::childrenHandleMouseEvent(const METHOD& method, S32 x, S32 y, XDATA extra, bool allow_mouse_block)
 {
-	for (LLView* viewp : mChildList)
-	{
-		S32 local_x = x - viewp->getRect().mLeft;
-		S32 local_y = y - viewp->getRect().mBottom;
+    for (LLView* viewp : mChildList)
+    {
+        S32 local_x = x - viewp->getRect().mLeft;
+        S32 local_y = y - viewp->getRect().mBottom;
 
-		if (!viewp->visibleEnabledAndContains(local_x, local_y))
-		{
-			continue;
-		}
+        if (!viewp->visibleEnabledAndContains(local_x, local_y))
+        {
+            continue;
+        }
 
-		if ((viewp->*method)( local_x, local_y, extra )
-			|| (allow_mouse_block && viewp->blockMouseEvent( local_x, local_y )))
-		{
-			LL_DEBUGS() << "LLView::childrenHandleMouseEvent calling updatemouseeventinfo - local_x|global x  "<< local_x << " " << x	<< "local/global y " << local_y << " " << y << LL_ENDL;
-			LL_DEBUGS() << "LLView::childrenHandleMouseEvent  getPathname for viewp result: " << viewp->getPathname() << "for this view: " << getPathname() << LL_ENDL;
+        if ((viewp->*method)( local_x, local_y, extra )
+            || (allow_mouse_block && viewp->blockMouseEvent( local_x, local_y )))
+        {
+            LL_DEBUGS() << "LLView::childrenHandleMouseEvent calling updatemouseeventinfo - local_x|global x  "<< local_x << " " << x   << "local/global y " << local_y << " " << y << LL_ENDL;
+            LL_DEBUGS() << "LLView::childrenHandleMouseEvent  getPathname for viewp result: " << viewp->getPathname() << "for this view: " << getPathname() << LL_ENDL;
 
-			LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname()); 
+            LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname());
 
-			// This is NOT event recording related
-			viewp->logMouseEvent();
+            // This is NOT event recording related
+            viewp->logMouseEvent();
 
-			return viewp;
-		}
-	}
-	return NULL;
+            return viewp;
+        }
+    }
+    return NULL;
 }
 
 LLView* LLView::childrenHandleToolTip(S32 x, S32 y, MASK mask)
 {
-	for (LLView* viewp : mChildList)
-	{
-		S32 local_x = x - viewp->getRect().mLeft;
-		S32 local_y = y - viewp->getRect().mBottom;
-		// Differs from childrenHandleMouseEvent() in that we want to offer
-		// tooltips even for disabled widgets.
-		if(!viewp->visibleAndContains(local_x, local_y))
-		{
-			continue;
-		}
-
-		if (viewp->handleToolTip(local_x, local_y, mask) 
-			|| viewp->blockMouseEvent(local_x, local_y))
-		{
-			// This is NOT event recording related
-			viewp->logMouseEvent();
-			return viewp;
-		}
-	}
-	return NULL;
+    for (LLView* viewp : mChildList)
+    {
+        S32 local_x = x - viewp->getRect().mLeft;
+        S32 local_y = y - viewp->getRect().mBottom;
+        // Differs from childrenHandleMouseEvent() in that we want to offer
+        // tooltips even for disabled widgets.
+        if(!viewp->visibleAndContains(local_x, local_y))
+        {
+            continue;
+        }
+
+        if (viewp->handleToolTip(local_x, local_y, mask)
+            || viewp->blockMouseEvent(local_x, local_y))
+        {
+            // This is NOT event recording related
+            viewp->logMouseEvent();
+            return viewp;
+        }
+    }
+    return NULL;
 }
 
 LLView* LLView::childrenHandleDragAndDrop(S32 x, S32 y, MASK mask,
-									   BOOL drop,
-									   EDragAndDropType cargo_type,
-									   void* cargo_data,
-									   EAcceptance* accept,
-									   std::string& tooltip_msg)
-{
-	// default to not accepting drag and drop, will be overridden by handler
-	*accept = ACCEPT_NO;
-
-	for (LLView* viewp : mChildList)
-	{
-		S32 local_x = x - viewp->getRect().mLeft;
-		S32 local_y = y - viewp->getRect().mBottom;
-		if( !viewp->visibleEnabledAndContains(local_x, local_y))
-		{
-			continue;
-		}
-
-		// Differs from childrenHandleMouseEvent() simply in that this virtual
-		// method call diverges pretty radically from the usual (x, y, int).
-		if (viewp->handleDragAndDrop(local_x, local_y, mask, drop,
-									 cargo_type,
-									 cargo_data,
-									 accept,
-									 tooltip_msg)
-			|| viewp->blockMouseEvent(local_x, local_y))
-		{
-			return viewp;
-		}
-	}
-	return NULL;
+                                       BOOL drop,
+                                       EDragAndDropType cargo_type,
+                                       void* cargo_data,
+                                       EAcceptance* accept,
+                                       std::string& tooltip_msg)
+{
+    // default to not accepting drag and drop, will be overridden by handler
+    *accept = ACCEPT_NO;
+
+    for (LLView* viewp : mChildList)
+    {
+        S32 local_x = x - viewp->getRect().mLeft;
+        S32 local_y = y - viewp->getRect().mBottom;
+        if( !viewp->visibleEnabledAndContains(local_x, local_y))
+        {
+            continue;
+        }
+
+        // Differs from childrenHandleMouseEvent() simply in that this virtual
+        // method call diverges pretty radically from the usual (x, y, int).
+        if (viewp->handleDragAndDrop(local_x, local_y, mask, drop,
+                                     cargo_type,
+                                     cargo_data,
+                                     accept,
+                                     tooltip_msg)
+            || viewp->blockMouseEvent(local_x, local_y))
+        {
+            return viewp;
+        }
+    }
+    return NULL;
 }
 
 LLView* LLView::childrenHandleHover(S32 x, S32 y, MASK mask)
 {
-	for (LLView* viewp : mChildList)
-	{
-		S32 local_x = x - viewp->getRect().mLeft;
-		S32 local_y = y - viewp->getRect().mBottom;
-		if(!viewp->visibleEnabledAndContains(local_x, local_y))
-		{
-			continue;
-		}
-
-		// This call differentiates this method from childrenHandleMouseEvent().
-		LLUI::getInstance()->mWindow->setCursor(viewp->getHoverCursor());
-
-		if (viewp->handleHover(local_x, local_y, mask)
-			|| viewp->blockMouseEvent(local_x, local_y))
-		{
-			// This is NOT event recording related
-			viewp->logMouseEvent();
-			return viewp;
-		}
-	}
-	return NULL;
-}
-
-LLView*	LLView::childFromPoint(S32 x, S32 y, bool recur)
-{
-	if (!getVisible())
-		return NULL;
-
-	for (LLView* viewp : mChildList)
-	{
-		S32 local_x = x - viewp->getRect().mLeft;
-		S32 local_y = y - viewp->getRect().mBottom;
-		if (!viewp->visibleAndContains(local_x, local_y))
-		{
-			continue;
-		}
-		// Here we've found the first (frontmost) visible child at this level
-		// containing the specified point. Is the caller asking us to drill
-		// down and return the innermost leaf child at this point, or just the
-		// top-level child?
-		if (recur)
-		{
-			LLView* leaf(viewp->childFromPoint(local_x, local_y, recur));
-			// Maybe viewp is already a leaf LLView, or maybe it has children
-			// but this particular (x, y) point falls between them. If the
-			// recursive call returns non-NULL, great, use that; else just use
-			// viewp.
-			return leaf? leaf : viewp;
-		}
-		return viewp;
-
-	}
-	return 0;
+    for (LLView* viewp : mChildList)
+    {
+        S32 local_x = x - viewp->getRect().mLeft;
+        S32 local_y = y - viewp->getRect().mBottom;
+        if(!viewp->visibleEnabledAndContains(local_x, local_y))
+        {
+            continue;
+        }
+
+        // This call differentiates this method from childrenHandleMouseEvent().
+        LLUI::getInstance()->mWindow->setCursor(viewp->getHoverCursor());
+
+        if (viewp->handleHover(local_x, local_y, mask)
+            || viewp->blockMouseEvent(local_x, local_y))
+        {
+            // This is NOT event recording related
+            viewp->logMouseEvent();
+            return viewp;
+        }
+    }
+    return NULL;
+}
+
+LLView* LLView::childFromPoint(S32 x, S32 y, bool recur)
+{
+    if (!getVisible())
+        return NULL;
+
+    for (LLView* viewp : mChildList)
+    {
+        S32 local_x = x - viewp->getRect().mLeft;
+        S32 local_y = y - viewp->getRect().mBottom;
+        if (!viewp->visibleAndContains(local_x, local_y))
+        {
+            continue;
+        }
+        // Here we've found the first (frontmost) visible child at this level
+        // containing the specified point. Is the caller asking us to drill
+        // down and return the innermost leaf child at this point, or just the
+        // top-level child?
+        if (recur)
+        {
+            LLView* leaf(viewp->childFromPoint(local_x, local_y, recur));
+            // Maybe viewp is already a leaf LLView, or maybe it has children
+            // but this particular (x, y) point falls between them. If the
+            // recursive call returns non-NULL, great, use that; else just use
+            // viewp.
+            return leaf? leaf : viewp;
+        }
+        return viewp;
+
+    }
+    return 0;
 }
 
 F32 LLView::getTooltipTimeout()
@@ -900,163 +900,163 @@ F32 LLView::getTooltipTimeout()
 
 BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+    BOOL handled = FALSE;
 
-	// parents provide tooltips first, which are optionally
-	// overridden by children, in case child is mouse_opaque
-	std::string tooltip = getToolTip();
-	if (!tooltip.empty())
-	{
+    // parents provide tooltips first, which are optionally
+    // overridden by children, in case child is mouse_opaque
+    std::string tooltip = getToolTip();
+    if (!tooltip.empty())
+    {
         static LLCachedControl<bool> allow_ui_tooltips(*LLUI::getInstance()->mSettingGroups["config"], "BasicUITooltips", true);
 
-		// Even if we don't show tooltips, consume the event, nothing below should show tooltip
-		if (allow_ui_tooltips)
-		{
-			LLToolTipMgr::instance().show(LLToolTip::Params()
-			                              .message(tooltip)
-			                              .sticky_rect(calcScreenRect())
-			                              .delay_time(getTooltipTimeout()));
-		}
-		handled = TRUE;
-	}
+        // Even if we don't show tooltips, consume the event, nothing below should show tooltip
+        if (allow_ui_tooltips)
+        {
+            LLToolTipMgr::instance().show(LLToolTip::Params()
+                                          .message(tooltip)
+                                          .sticky_rect(calcScreenRect())
+                                          .delay_time(getTooltipTimeout()));
+        }
+        handled = TRUE;
+    }
 
-	// child tooltips will override our own
-	LLView* child_handler = childrenHandleToolTip(x, y, mask);
-	if (child_handler)
-	{
-		handled = TRUE;
-	}
+    // child tooltips will override our own
+    LLView* child_handler = childrenHandleToolTip(x, y, mask);
+    if (child_handler)
+    {
+        handled = TRUE;
+    }
 
-	return handled;
+    return handled;
 }
 
 BOOL LLView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 {
-	BOOL handled = FALSE;
-
-	if (getVisible() && getEnabled())
-	{
-		if( called_from_parent )
-		{
-			// Downward traversal
-			handled = childrenHandleKey( key, mask ) != NULL;
-		}
-
-		if (!handled)
-		{
-			// For event logging we don't care which widget handles it
-			// So we capture the key at the end of this function once we know if it was handled
-			handled = handleKeyHere( key, mask );
-			if (handled)
-			{
-				LL_DEBUGS() << "Key handled by " << getName() << LL_ENDL;
-			}
-		}
-	}
-
-	if( !handled && !called_from_parent && mParentView)
-	{
-		// Upward traversal
-		handled = mParentView->handleKey( key, mask, FALSE );
-	}
-	return handled;
+    BOOL handled = FALSE;
+
+    if (getVisible() && getEnabled())
+    {
+        if( called_from_parent )
+        {
+            // Downward traversal
+            handled = childrenHandleKey( key, mask ) != NULL;
+        }
+
+        if (!handled)
+        {
+            // For event logging we don't care which widget handles it
+            // So we capture the key at the end of this function once we know if it was handled
+            handled = handleKeyHere( key, mask );
+            if (handled)
+            {
+                LL_DEBUGS() << "Key handled by " << getName() << LL_ENDL;
+            }
+        }
+    }
+
+    if( !handled && !called_from_parent && mParentView)
+    {
+        // Upward traversal
+        handled = mParentView->handleKey( key, mask, FALSE );
+    }
+    return handled;
 }
 
 BOOL LLView::handleKeyUp(KEY key, MASK mask, BOOL called_from_parent)
 {
-	BOOL handled = FALSE;
-
-	if (getVisible() && getEnabled())
-	{
-		if (called_from_parent)
-		{
-			// Downward traversal
-			handled = childrenHandleKeyUp(key, mask) != NULL;
-		}
-
-		if (!handled)
-		{
-			// For event logging we don't care which widget handles it
-			// So we capture the key at the end of this function once we know if it was handled
-			handled = handleKeyUpHere(key, mask);
-			if (handled)
-			{
-				LL_DEBUGS() << "Key handled by " << getName() << LL_ENDL;
-			}
-		}
-	}
-
-	if (!handled && !called_from_parent && mParentView)
-	{
-		// Upward traversal
-		handled = mParentView->handleKeyUp(key, mask, FALSE);
-	}
-	return handled;
+    BOOL handled = FALSE;
+
+    if (getVisible() && getEnabled())
+    {
+        if (called_from_parent)
+        {
+            // Downward traversal
+            handled = childrenHandleKeyUp(key, mask) != NULL;
+        }
+
+        if (!handled)
+        {
+            // For event logging we don't care which widget handles it
+            // So we capture the key at the end of this function once we know if it was handled
+            handled = handleKeyUpHere(key, mask);
+            if (handled)
+            {
+                LL_DEBUGS() << "Key handled by " << getName() << LL_ENDL;
+            }
+        }
+    }
+
+    if (!handled && !called_from_parent && mParentView)
+    {
+        // Upward traversal
+        handled = mParentView->handleKeyUp(key, mask, FALSE);
+    }
+    return handled;
 }
 
 // Called from handleKey()
 // Handles key in this object.  Checking parents and children happens in handleKey()
 BOOL LLView::handleKeyHere(KEY key, MASK mask)
 {
-	return FALSE;
+    return FALSE;
 }
 
 // Called from handleKey()
 // Handles key in this object.  Checking parents and children happens in handleKey()
 BOOL LLView::handleKeyUpHere(KEY key, MASK mask)
 {
-	return FALSE;
+    return FALSE;
 }
 
 BOOL LLView::handleUnicodeChar(llwchar uni_char, BOOL called_from_parent)
 {
-	BOOL handled = FALSE;
-
-	if (getVisible() && getEnabled())
-	{
-		if( called_from_parent )
-		{
-			// Downward traversal
-			handled = childrenHandleUnicodeChar( uni_char ) != NULL;
-		}
-
-		if (!handled)
-		{
-			handled = handleUnicodeCharHere(uni_char);
-			if (handled && LLView::sDebugKeys)
-			{
-				LL_INFOS() << "Unicode key " << wchar_utf8_preview(uni_char) << " is handled by " << getName() << LL_ENDL;
-			}
-		}
-	}
-
-	if (!handled && !called_from_parent && mParentView)
-	{
-		// Upward traversal
-		handled = mParentView->handleUnicodeChar(uni_char, FALSE);
-	}
-
-	if (handled)
-	{
-		LLViewerEventRecorder::instance().logKeyUnicodeEvent(uni_char);
-	}
-	
-	return handled;
+    BOOL handled = FALSE;
+
+    if (getVisible() && getEnabled())
+    {
+        if( called_from_parent )
+        {
+            // Downward traversal
+            handled = childrenHandleUnicodeChar( uni_char ) != NULL;
+        }
+
+        if (!handled)
+        {
+            handled = handleUnicodeCharHere(uni_char);
+            if (handled && LLView::sDebugKeys)
+            {
+                LL_INFOS() << "Unicode key " << wchar_utf8_preview(uni_char) << " is handled by " << getName() << LL_ENDL;
+            }
+        }
+    }
+
+    if (!handled && !called_from_parent && mParentView)
+    {
+        // Upward traversal
+        handled = mParentView->handleUnicodeChar(uni_char, FALSE);
+    }
+
+    if (handled)
+    {
+        LLViewerEventRecorder::instance().logKeyUnicodeEvent(uni_char);
+    }
+
+    return handled;
 }
 
 
 BOOL LLView::handleUnicodeCharHere(llwchar uni_char )
 {
-	return FALSE;
+    return FALSE;
 }
 
 
 BOOL LLView::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
-							   EDragAndDropType cargo_type, void* cargo_data,
-							   EAcceptance* accept,
-							   std::string& tooltip_msg)
+                               EDragAndDropType cargo_type, void* cargo_data,
+                               EAcceptance* accept,
+                               std::string& tooltip_msg)
 {
-	return childrenHandleDragAndDrop( x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg) != NULL;
+    return childrenHandleDragAndDrop( x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg) != NULL;
 }
 
 void LLView::onMouseCaptureLost()
@@ -1064,189 +1064,189 @@ void LLView::onMouseCaptureLost()
 }
 
 BOOL LLView::hasMouseCapture()
-{ 
-	return gFocusMgr.getMouseCapture() == this; 
+{
+    return gFocusMgr.getMouseCapture() == this;
 }
 
 BOOL LLView::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	LLView* r = childrenHandleMouseUp( x, y, mask );
+    LLView* r = childrenHandleMouseUp( x, y, mask );
 
-	return (r!=NULL);
+    return (r!=NULL);
 }
 
 BOOL LLView::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	LLView* r= childrenHandleMouseDown(x, y, mask );
+    LLView* r= childrenHandleMouseDown(x, y, mask );
 
-	return (r!=NULL);
+    return (r!=NULL);
 }
 
 BOOL LLView::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleDoubleClick( x, y, mask ) != NULL;
+    return childrenHandleDoubleClick( x, y, mask ) != NULL;
 }
 
 BOOL LLView::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	return childrenHandleScrollWheel( x, y, clicks ) != NULL;
+    return childrenHandleScrollWheel( x, y, clicks ) != NULL;
 }
 
 BOOL LLView::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
-	return childrenHandleScrollHWheel( x, y, clicks ) != NULL;
+    return childrenHandleScrollHWheel( x, y, clicks ) != NULL;
 }
 
 BOOL LLView::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleRightMouseDown( x, y, mask ) != NULL;
+    return childrenHandleRightMouseDown( x, y, mask ) != NULL;
 }
 
 BOOL LLView::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleRightMouseUp( x, y, mask ) != NULL;
+    return childrenHandleRightMouseUp( x, y, mask ) != NULL;
 }
- 
+
 BOOL LLView::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMiddleMouseDown( x, y, mask ) != NULL;
+    return childrenHandleMiddleMouseDown( x, y, mask ) != NULL;
 }
 
 BOOL LLView::handleMiddleMouseUp(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMiddleMouseUp( x, y, mask ) != NULL;
+    return childrenHandleMiddleMouseUp( x, y, mask ) != NULL;
 }
 
 LLView* LLView::childrenHandleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	return childrenHandleMouseEvent(&LLView::handleScrollWheel, x, y, clicks, false);
+    return childrenHandleMouseEvent(&LLView::handleScrollWheel, x, y, clicks, false);
 }
 
 LLView* LLView::childrenHandleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
-	return childrenHandleMouseEvent(&LLView::handleScrollHWheel, x, y, clicks, false);
+    return childrenHandleMouseEvent(&LLView::handleScrollHWheel, x, y, clicks, false);
 }
 
 // Called during downward traversal
 LLView* LLView::childrenHandleKey(KEY key, MASK mask)
 {
-	return childrenHandleCharEvent("Key", &LLView::handleKey, key, mask);
+    return childrenHandleCharEvent("Key", &LLView::handleKey, key, mask);
 }
 
 // Called during downward traversal
 LLView* LLView::childrenHandleKeyUp(KEY key, MASK mask)
 {
-	return childrenHandleCharEvent("Key Up", &LLView::handleKeyUp, key, mask);
+    return childrenHandleCharEvent("Key Up", &LLView::handleKeyUp, key, mask);
 }
 
 // Called during downward traversal
 LLView* LLView::childrenHandleUnicodeChar(llwchar uni_char)
 {
-	return childrenHandleCharEvent("Unicode character", &LLView::handleUnicodeCharWithDummyMask,
-								   uni_char, MASK_NONE);
+    return childrenHandleCharEvent("Unicode character", &LLView::handleUnicodeCharWithDummyMask,
+                                   uni_char, MASK_NONE);
 }
 
 LLView* LLView::childrenHandleMouseDown(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleMouseDown, x, y, mask);
+    return childrenHandleMouseEvent(&LLView::handleMouseDown, x, y, mask);
 }
 
 LLView* LLView::childrenHandleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleRightMouseDown, x, y, mask);
+    return childrenHandleMouseEvent(&LLView::handleRightMouseDown, x, y, mask);
 }
 
 LLView* LLView::childrenHandleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleMiddleMouseDown, x, y, mask);
+    return childrenHandleMouseEvent(&LLView::handleMiddleMouseDown, x, y, mask);
 }
 
 LLView* LLView::childrenHandleDoubleClick(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleDoubleClick, x, y, mask);
+    return childrenHandleMouseEvent(&LLView::handleDoubleClick, x, y, mask);
 }
 
 LLView* LLView::childrenHandleMouseUp(S32 x, S32 y, MASK mask)
 {
-	return	childrenHandleMouseEvent(&LLView::handleMouseUp, x, y, mask);
+    return  childrenHandleMouseEvent(&LLView::handleMouseUp, x, y, mask);
 }
 
 LLView* LLView::childrenHandleRightMouseUp(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleRightMouseUp, x, y, mask);
+    return childrenHandleMouseEvent(&LLView::handleRightMouseUp, x, y, mask);
 }
 
 LLView* LLView::childrenHandleMiddleMouseUp(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleMiddleMouseUp, x, y, mask);
+    return childrenHandleMouseEvent(&LLView::handleMiddleMouseUp, x, y, mask);
 }
 
 void LLView::draw()
 {
-	drawChildren();
+    drawChildren();
 }
 
 void LLView::drawChildren()
 {
-	if (!mChildList.empty())
-	{
-		LLView* rootp = LLUI::getInstance()->getRootView();		
-		++sDepth;
-
-		for (child_list_reverse_iter_t child_iter = mChildList.rbegin(); child_iter != mChildList.rend();)  // ++child_iter)
-		{
-			child_list_reverse_iter_t child = child_iter++;
-			LLView *viewp = *child;
-			
-			if (viewp == NULL)
-			{
-				continue;
-			}
-
-			if (viewp->getVisible() && viewp->getRect().isValid())
-			{
-				LLRect screen_rect = viewp->calcScreenRect();
-				if ( rootp->getLocalRect().overlaps(screen_rect)  && sDirtyRect.overlaps(screen_rect))
-				{
-					LLUI::pushMatrix();
-					{
-						LLUI::translate((F32)viewp->getRect().mLeft, (F32)viewp->getRect().mBottom);
-						// flag the fact we are in draw here, in case overridden draw() method attempts to remove this widget
-						viewp->mInDraw = true;
-						viewp->draw();
-						viewp->mInDraw = false;
-
-						if (sDebugRects)
-						{
-							viewp->drawDebugRect();
-
-							// Check for bogus rectangle
-							if (!getRect().isValid())
-							{
-								LL_WARNS() << "Bogus rectangle for " << getName() << " with " << mRect << LL_ENDL;
-							}
-						}
-					}
-					LLUI::popMatrix();
-				}
-			}
-
-		}
-		--sDepth;
-	}
+    if (!mChildList.empty())
+    {
+        LLView* rootp = LLUI::getInstance()->getRootView();
+        ++sDepth;
+
+        for (child_list_reverse_iter_t child_iter = mChildList.rbegin(); child_iter != mChildList.rend();)  // ++child_iter)
+        {
+            child_list_reverse_iter_t child = child_iter++;
+            LLView *viewp = *child;
+
+            if (viewp == NULL)
+            {
+                continue;
+            }
+
+            if (viewp->getVisible() && viewp->getRect().isValid())
+            {
+                LLRect screen_rect = viewp->calcScreenRect();
+                if ( rootp->getLocalRect().overlaps(screen_rect)  && sDirtyRect.overlaps(screen_rect))
+                {
+                    LLUI::pushMatrix();
+                    {
+                        LLUI::translate((F32)viewp->getRect().mLeft, (F32)viewp->getRect().mBottom);
+                        // flag the fact we are in draw here, in case overridden draw() method attempts to remove this widget
+                        viewp->mInDraw = true;
+                        viewp->draw();
+                        viewp->mInDraw = false;
+
+                        if (sDebugRects)
+                        {
+                            viewp->drawDebugRect();
+
+                            // Check for bogus rectangle
+                            if (!getRect().isValid())
+                            {
+                                LL_WARNS() << "Bogus rectangle for " << getName() << " with " << mRect << LL_ENDL;
+                            }
+                        }
+                    }
+                    LLUI::popMatrix();
+                }
+            }
+
+        }
+        --sDepth;
+    }
 }
 
 void LLView::dirtyRect()
 {
-	LLView* child = getParent();
-	LLView* parent = child ? child->getParent() : NULL;
-	LLView* cur = this;
-	while (child && parent && parent->getParent())
-	{ //find third to top-most view
-		cur = child;
-		child = parent;
-		parent = parent->getParent();
-	}
+    LLView* child = getParent();
+    LLView* parent = child ? child->getParent() : NULL;
+    LLView* cur = this;
+    while (child && parent && parent->getParent())
+    { //find third to top-most view
+        cur = child;
+        child = parent;
+        parent = parent->getParent();
+    }
 
     if (!sIsRectDirty)
     {
@@ -1262,343 +1262,343 @@ void LLView::dirtyRect()
 //Draw a box for debugging.
 void LLView::drawDebugRect()
 {
-	std::set<LLView*>::iterator preview_iter = std::find(sPreviewHighlightedElements.begin(), sPreviewHighlightedElements.end(), this);	// figure out if it's a previewed element
-
-	LLUI::pushMatrix();
-	{
-		// drawing solids requires texturing be disabled
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-		if (getUseBoundingRect())
-		{
-			LLUI::translate((F32)mBoundingRect.mLeft - (F32)mRect.mLeft, (F32)mBoundingRect.mBottom - (F32)mRect.mBottom);
-		}
-
-		LLRect debug_rect = getUseBoundingRect() ? mBoundingRect : mRect;
-
-		// draw red rectangle for the border
-		LLColor4 border_color(0.25f, 0.25f, 0.25f, 1.f);
-		if(preview_iter != sPreviewHighlightedElements.end())
-		{
-			if(LLView::sPreviewClickedElement && this == sPreviewClickedElement)
-			{
-				border_color = LLColor4::red;
-			}
-			else
-			{
-				static LLUIColor scroll_highlighted_color = LLUIColorTable::instance().getColor("ScrollHighlightedColor");
-				border_color = scroll_highlighted_color;
-			}
-		}
-		else
-		{
-			border_color.mV[sDepth%3] = 1.f;
-		}
-
-		gGL.color4fv( border_color.mV );
-
-		gGL.begin(LLRender::LINES);
-			gGL.vertex2i(0, debug_rect.getHeight() - 1);
-			gGL.vertex2i(0, 0);
-
-			gGL.vertex2i(0, 0);
-			gGL.vertex2i(debug_rect.getWidth() - 1, 0);
-
-			gGL.vertex2i(debug_rect.getWidth() - 1, 0);
-			gGL.vertex2i(debug_rect.getWidth() - 1, debug_rect.getHeight() - 1);
-
-			gGL.vertex2i(debug_rect.getWidth() - 1, debug_rect.getHeight() - 1);
-			gGL.vertex2i(0, debug_rect.getHeight() - 1);
-		gGL.end();
-
-		// Draw the name if it's not a leaf node or not in editing or preview mode
-		if (mChildList.size()
-			&& preview_iter == sPreviewHighlightedElements.end()
-			&& sDebugRectsShowNames)
-		{
-			S32 x, y;
-			gGL.color4fv( border_color.mV );
-
-			x = debug_rect.getWidth() / 2;
-
-			S32 rect_height = debug_rect.getHeight();
-			S32 lines = rect_height / LINE_HEIGHT + 1;
-
-			S32 depth = 0;
-			LLView * viewp = this;
-			while (NULL != viewp)
-			{
-				viewp = viewp->getParent();
-				depth++;
-			}
-
-			y = rect_height - LINE_HEIGHT * (depth % lines + 1);
-
-			std::string debug_text = llformat("%s (%d x %d)", getName().c_str(),
-										debug_rect.getWidth(), debug_rect.getHeight());
-			LLFontGL::getFontSansSerifSmall()->renderUTF8(debug_text, 0, (F32)x, (F32)y, border_color,
-					LLFontGL::HCENTER, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::NO_SHADOW);
-		}
-	}
-	LLUI::popMatrix();
+    std::set<LLView*>::iterator preview_iter = std::find(sPreviewHighlightedElements.begin(), sPreviewHighlightedElements.end(), this); // figure out if it's a previewed element
+
+    LLUI::pushMatrix();
+    {
+        // drawing solids requires texturing be disabled
+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
+        if (getUseBoundingRect())
+        {
+            LLUI::translate((F32)mBoundingRect.mLeft - (F32)mRect.mLeft, (F32)mBoundingRect.mBottom - (F32)mRect.mBottom);
+        }
+
+        LLRect debug_rect = getUseBoundingRect() ? mBoundingRect : mRect;
+
+        // draw red rectangle for the border
+        LLColor4 border_color(0.25f, 0.25f, 0.25f, 1.f);
+        if(preview_iter != sPreviewHighlightedElements.end())
+        {
+            if(LLView::sPreviewClickedElement && this == sPreviewClickedElement)
+            {
+                border_color = LLColor4::red;
+            }
+            else
+            {
+                static LLUIColor scroll_highlighted_color = LLUIColorTable::instance().getColor("ScrollHighlightedColor");
+                border_color = scroll_highlighted_color;
+            }
+        }
+        else
+        {
+            border_color.mV[sDepth%3] = 1.f;
+        }
+
+        gGL.color4fv( border_color.mV );
+
+        gGL.begin(LLRender::LINES);
+            gGL.vertex2i(0, debug_rect.getHeight() - 1);
+            gGL.vertex2i(0, 0);
+
+            gGL.vertex2i(0, 0);
+            gGL.vertex2i(debug_rect.getWidth() - 1, 0);
+
+            gGL.vertex2i(debug_rect.getWidth() - 1, 0);
+            gGL.vertex2i(debug_rect.getWidth() - 1, debug_rect.getHeight() - 1);
+
+            gGL.vertex2i(debug_rect.getWidth() - 1, debug_rect.getHeight() - 1);
+            gGL.vertex2i(0, debug_rect.getHeight() - 1);
+        gGL.end();
+
+        // Draw the name if it's not a leaf node or not in editing or preview mode
+        if (mChildList.size()
+            && preview_iter == sPreviewHighlightedElements.end()
+            && sDebugRectsShowNames)
+        {
+            S32 x, y;
+            gGL.color4fv( border_color.mV );
+
+            x = debug_rect.getWidth() / 2;
+
+            S32 rect_height = debug_rect.getHeight();
+            S32 lines = rect_height / LINE_HEIGHT + 1;
+
+            S32 depth = 0;
+            LLView * viewp = this;
+            while (NULL != viewp)
+            {
+                viewp = viewp->getParent();
+                depth++;
+            }
+
+            y = rect_height - LINE_HEIGHT * (depth % lines + 1);
+
+            std::string debug_text = llformat("%s (%d x %d)", getName().c_str(),
+                                        debug_rect.getWidth(), debug_rect.getHeight());
+            LLFontGL::getFontSansSerifSmall()->renderUTF8(debug_text, 0, (F32)x, (F32)y, border_color,
+                    LLFontGL::HCENTER, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::NO_SHADOW);
+        }
+    }
+    LLUI::popMatrix();
 }
 
 void LLView::drawChild(LLView* childp, S32 x_offset, S32 y_offset, BOOL force_draw)
 {
-	if (childp && childp->getParent() == this)
-	{
-		++sDepth;
-
-		if ((childp->getVisible() && childp->getRect().isValid()) 
-			|| force_draw)
-		{
-			gGL.matrixMode(LLRender::MM_MODELVIEW);
-			LLUI::pushMatrix();
-			{
-				LLUI::translate((F32)childp->getRect().mLeft + x_offset, (F32)childp->getRect().mBottom + y_offset);
-				childp->draw();
-			}
-			LLUI::popMatrix();
-		}
-
-		--sDepth;
-	}
+    if (childp && childp->getParent() == this)
+    {
+        ++sDepth;
+
+        if ((childp->getVisible() && childp->getRect().isValid())
+            || force_draw)
+        {
+            gGL.matrixMode(LLRender::MM_MODELVIEW);
+            LLUI::pushMatrix();
+            {
+                LLUI::translate((F32)childp->getRect().mLeft + x_offset, (F32)childp->getRect().mBottom + y_offset);
+                childp->draw();
+            }
+            LLUI::popMatrix();
+        }
+
+        --sDepth;
+    }
 }
 
 
 void LLView::reshape(S32 width, S32 height, BOOL called_from_parent)
 {
-	// compute how much things changed and apply reshape logic to children
-	S32 delta_width = width - getRect().getWidth();
-	S32 delta_height = height - getRect().getHeight();
-
-	if (delta_width || delta_height || sForceReshape)
-	{
-		// adjust our rectangle
-		mRect.mRight = getRect().mLeft + width;
-		mRect.mTop = getRect().mBottom + height;
-
-		// move child views according to reshape flags
-		for (LLView* viewp : mChildList)
-		{
-			if (viewp != NULL)
-			{
-			LLRect child_rect( viewp->mRect );
-
-			if (viewp->followsRight() && viewp->followsLeft())
-			{
-				child_rect.mRight += delta_width;
-			}
-			else if (viewp->followsRight())
-			{
-				child_rect.mLeft += delta_width;
-				child_rect.mRight += delta_width;
-			}
-			else if (viewp->followsLeft())
-			{
-				// left is 0, don't need to adjust coords
-			}
-			else
-			{
-				// BUG what to do when we don't follow anyone?
-				// for now, same as followsLeft
-			}
-
-			if (viewp->followsTop() && viewp->followsBottom())
-			{
-				child_rect.mTop += delta_height;
-			}
-			else if (viewp->followsTop())
-			{
-				child_rect.mTop += delta_height;
-				child_rect.mBottom += delta_height;
-			}
-			else if (viewp->followsBottom())
-			{
-				// bottom is 0, so don't need to adjust coords
-			}
-			else
-			{
-				// BUG what to do when we don't follow?
-				// for now, same as bottom
-			}
-
-			S32 delta_x = child_rect.mLeft - viewp->getRect().mLeft;
-			S32 delta_y = child_rect.mBottom - viewp->getRect().mBottom;
-			viewp->translate( delta_x, delta_y );
-			if (child_rect.getWidth() != viewp->getRect().getWidth()
+    // compute how much things changed and apply reshape logic to children
+    S32 delta_width = width - getRect().getWidth();
+    S32 delta_height = height - getRect().getHeight();
+
+    if (delta_width || delta_height || sForceReshape)
+    {
+        // adjust our rectangle
+        mRect.mRight = getRect().mLeft + width;
+        mRect.mTop = getRect().mBottom + height;
+
+        // move child views according to reshape flags
+        for (LLView* viewp : mChildList)
+        {
+            if (viewp != NULL)
+            {
+            LLRect child_rect( viewp->mRect );
+
+            if (viewp->followsRight() && viewp->followsLeft())
+            {
+                child_rect.mRight += delta_width;
+            }
+            else if (viewp->followsRight())
+            {
+                child_rect.mLeft += delta_width;
+                child_rect.mRight += delta_width;
+            }
+            else if (viewp->followsLeft())
+            {
+                // left is 0, don't need to adjust coords
+            }
+            else
+            {
+                // BUG what to do when we don't follow anyone?
+                // for now, same as followsLeft
+            }
+
+            if (viewp->followsTop() && viewp->followsBottom())
+            {
+                child_rect.mTop += delta_height;
+            }
+            else if (viewp->followsTop())
+            {
+                child_rect.mTop += delta_height;
+                child_rect.mBottom += delta_height;
+            }
+            else if (viewp->followsBottom())
+            {
+                // bottom is 0, so don't need to adjust coords
+            }
+            else
+            {
+                // BUG what to do when we don't follow?
+                // for now, same as bottom
+            }
+
+            S32 delta_x = child_rect.mLeft - viewp->getRect().mLeft;
+            S32 delta_y = child_rect.mBottom - viewp->getRect().mBottom;
+            viewp->translate( delta_x, delta_y );
+            if (child_rect.getWidth() != viewp->getRect().getWidth()
                 || child_rect.getHeight() != viewp->getRect().getHeight()
                 || sForceReshape)
-			{
-				viewp->reshape(child_rect.getWidth(), child_rect.getHeight());
-			}
-		}
-	}
-	}
+            {
+                viewp->reshape(child_rect.getWidth(), child_rect.getHeight());
+            }
+        }
+    }
+    }
 
-	if (!called_from_parent)
-	{
-		if (mParentView)
-		{
-			mParentView->reshape(mParentView->getRect().getWidth(), mParentView->getRect().getHeight(), FALSE);
-		}
-	}
+    if (!called_from_parent)
+    {
+        if (mParentView)
+        {
+            mParentView->reshape(mParentView->getRect().getWidth(), mParentView->getRect().getHeight(), FALSE);
+        }
+    }
 
-	updateBoundingRect();
+    updateBoundingRect();
 }
 
 LLRect LLView::calcBoundingRect()
 {
-	LLRect local_bounding_rect = LLRect::null;
+    LLRect local_bounding_rect = LLRect::null;
 
-	for (LLView* childp : mChildList)
-	{
-		// ignore invisible and "top" children when calculating bounding rect
-		// such as combobox popups
-		if (!childp->getVisible() || childp == gFocusMgr.getTopCtrl()) 
-		{
-			continue;
-		}
-
-		LLRect child_bounding_rect = childp->getBoundingRect();
-
-		if (local_bounding_rect.isEmpty())
-		{
-			// start out with bounding rect equal to first visible child's bounding rect
-			local_bounding_rect = child_bounding_rect;
-		}
-		else
-		{
-			// accumulate non-null children rectangles
-			if (!child_bounding_rect.isEmpty())
-			{
-				local_bounding_rect.unionWith(child_bounding_rect);
-			}
-		}
-	}
+    for (LLView* childp : mChildList)
+    {
+        // ignore invisible and "top" children when calculating bounding rect
+        // such as combobox popups
+        if (!childp->getVisible() || childp == gFocusMgr.getTopCtrl())
+        {
+            continue;
+        }
+
+        LLRect child_bounding_rect = childp->getBoundingRect();
+
+        if (local_bounding_rect.isEmpty())
+        {
+            // start out with bounding rect equal to first visible child's bounding rect
+            local_bounding_rect = child_bounding_rect;
+        }
+        else
+        {
+            // accumulate non-null children rectangles
+            if (!child_bounding_rect.isEmpty())
+            {
+                local_bounding_rect.unionWith(child_bounding_rect);
+            }
+        }
+    }
 
-	// convert to parent-relative coordinates
-	local_bounding_rect.translate(mRect.mLeft, mRect.mBottom);
-	return local_bounding_rect;
+    // convert to parent-relative coordinates
+    local_bounding_rect.translate(mRect.mLeft, mRect.mBottom);
+    return local_bounding_rect;
 }
 
 
 void LLView::updateBoundingRect()
 {
-	if (isDead()) return;
+    if (isDead()) return;
 
-	LLRect cur_rect = mBoundingRect;
+    LLRect cur_rect = mBoundingRect;
 
-	if (getUseBoundingRect())
-	{
-		mBoundingRect = calcBoundingRect();
-	}
-	else
-	{
-		mBoundingRect = mRect;
-	}
+    if (getUseBoundingRect())
+    {
+        mBoundingRect = calcBoundingRect();
+    }
+    else
+    {
+        mBoundingRect = mRect;
+    }
 
-	// give parent view a chance to resize, in case we just moved, for example
-	if (getParent() && getParent()->getUseBoundingRect())
-	{
-		getParent()->updateBoundingRect();
-	}
+    // give parent view a chance to resize, in case we just moved, for example
+    if (getParent() && getParent()->getUseBoundingRect())
+    {
+        getParent()->updateBoundingRect();
+    }
 
-	if (mBoundingRect != cur_rect)
-	{
-		dirtyRect();
-	}
+    if (mBoundingRect != cur_rect)
+    {
+        dirtyRect();
+    }
 
 }
 
 LLRect LLView::calcScreenRect() const
 {
-	LLRect screen_rect;
-	localPointToScreen(0, 0, &screen_rect.mLeft, &screen_rect.mBottom);
-	localPointToScreen(getRect().getWidth(), getRect().getHeight(), &screen_rect.mRight, &screen_rect.mTop);
-	return screen_rect;
+    LLRect screen_rect;
+    localPointToScreen(0, 0, &screen_rect.mLeft, &screen_rect.mBottom);
+    localPointToScreen(getRect().getWidth(), getRect().getHeight(), &screen_rect.mRight, &screen_rect.mTop);
+    return screen_rect;
 }
 
 LLRect LLView::calcScreenBoundingRect() const
 {
-	LLRect screen_rect;
-	// get bounding rect, if used
-	LLRect bounding_rect = getUseBoundingRect() ? mBoundingRect : mRect;
+    LLRect screen_rect;
+    // get bounding rect, if used
+    LLRect bounding_rect = getUseBoundingRect() ? mBoundingRect : mRect;
 
-	// convert to local coordinates, as defined by mRect
-	bounding_rect.translate(-mRect.mLeft, -mRect.mBottom);
+    // convert to local coordinates, as defined by mRect
+    bounding_rect.translate(-mRect.mLeft, -mRect.mBottom);
 
-	localPointToScreen(bounding_rect.mLeft, bounding_rect.mBottom, &screen_rect.mLeft, &screen_rect.mBottom);
-	localPointToScreen(bounding_rect.mRight, bounding_rect.mTop, &screen_rect.mRight, &screen_rect.mTop);
-	return screen_rect;
+    localPointToScreen(bounding_rect.mLeft, bounding_rect.mBottom, &screen_rect.mLeft, &screen_rect.mBottom);
+    localPointToScreen(bounding_rect.mRight, bounding_rect.mTop, &screen_rect.mRight, &screen_rect.mTop);
+    return screen_rect;
 }
 
 LLRect LLView::getLocalBoundingRect() const
 {
-	LLRect local_bounding_rect = getBoundingRect();
-	local_bounding_rect.translate(-mRect.mLeft, -mRect.mBottom);
+    LLRect local_bounding_rect = getBoundingRect();
+    local_bounding_rect.translate(-mRect.mLeft, -mRect.mBottom);
 
-	return local_bounding_rect;
+    return local_bounding_rect;
 }
 
 
 LLRect LLView::getLocalRect() const
 {
-	LLRect local_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
-	return local_rect;
+    LLRect local_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
+    return local_rect;
 }
 
 LLRect LLView::getLocalSnapRect() const
 {
-	LLRect local_snap_rect = getSnapRect();
-	local_snap_rect.translate(-getRect().mLeft, -getRect().mBottom);
-	return local_snap_rect;
+    LLRect local_snap_rect = getSnapRect();
+    local_snap_rect.translate(-getRect().mLeft, -getRect().mBottom);
+    return local_snap_rect;
 }
 
 BOOL LLView::hasAncestor(const LLView* parentp) const
 {
-	if (!parentp)
-	{
-		return FALSE;
-	}
+    if (!parentp)
+    {
+        return FALSE;
+    }
 
-	LLView* viewp = getParent();
-	while(viewp)
-	{
-		if (viewp == parentp)
-		{
-			return TRUE;
-		}
-		viewp = viewp->getParent();
-	}
+    LLView* viewp = getParent();
+    while(viewp)
+    {
+        if (viewp == parentp)
+        {
+            return TRUE;
+        }
+        viewp = viewp->getParent();
+    }
 
-	return FALSE;
+    return FALSE;
 }
 
 //-----------------------------------------------------------------------------
 
 BOOL LLView::childHasKeyboardFocus( const std::string& childname ) const
 {
-	LLView *focus = dynamic_cast<LLView *>(gFocusMgr.getKeyboardFocus());
-	
-	while (focus != NULL)
-	{
-		if (focus->getName() == childname)
-		{
-			return TRUE;
-		}
-		
-		focus = focus->getParent();
-	}
-	
-	return FALSE;
+    LLView *focus = dynamic_cast<LLView *>(gFocusMgr.getKeyboardFocus());
+
+    while (focus != NULL)
+    {
+        if (focus->getName() == childname)
+        {
+            return TRUE;
+        }
+
+        focus = focus->getParent();
+    }
+
+    return FALSE;
 }
 
 //-----------------------------------------------------------------------------
 
 BOOL LLView::hasChild(const std::string& childname, BOOL recurse) const
 {
-	return findChildView(childname, recurse) != NULL;
+    return findChildView(childname, recurse) != NULL;
 }
 
 //-----------------------------------------------------------------------------
@@ -1606,176 +1606,176 @@ BOOL LLView::hasChild(const std::string& childname, BOOL recurse) const
 //-----------------------------------------------------------------------------
 LLView* LLView::getChildView(const std::string& name, BOOL recurse) const
 {
-	return getChild<LLView>(name, recurse);
+    return getChild<LLView>(name, recurse);
 }
 
 LLView* LLView::findChildView(const std::string& name, BOOL recurse) const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
-	
+
     // Look for direct children *first*
-	for (LLView* childp : mChildList)
-	{
-		llassert(childp);
-		if (childp->getName() == name)
-		{
-			return childp;
-		}
-	}
-	if (recurse)
-	{
-		// Look inside each child as well.
-		for (LLView* childp : mChildList)
-		{
-			llassert(childp);
-			LLView* viewp = childp->findChildView(name, recurse);
-			if ( viewp )
-			{
-				return viewp;
-			}
-		}
-	}
-	return NULL;
-}
-
-BOOL LLView::parentPointInView(S32 x, S32 y, EHitTestType type) const 
-{ 
-	return (getUseBoundingRect() && type == HIT_TEST_USE_BOUNDING_RECT)
-		? mBoundingRect.pointInRect( x, y ) 
-		: mRect.pointInRect( x, y ); 
-}
-
-BOOL LLView::pointInView(S32 x, S32 y, EHitTestType type) const 
-{ 
-	return (getUseBoundingRect() && type == HIT_TEST_USE_BOUNDING_RECT)
-		? mBoundingRect.pointInRect( x + mRect.mLeft, y + mRect.mBottom ) 
-		: mRect.localPointInRect( x, y ); 
+    for (LLView* childp : mChildList)
+    {
+        llassert(childp);
+        if (childp->getName() == name)
+        {
+            return childp;
+        }
+    }
+    if (recurse)
+    {
+        // Look inside each child as well.
+        for (LLView* childp : mChildList)
+        {
+            llassert(childp);
+            LLView* viewp = childp->findChildView(name, recurse);
+            if ( viewp )
+            {
+                return viewp;
+            }
+        }
+    }
+    return NULL;
+}
+
+BOOL LLView::parentPointInView(S32 x, S32 y, EHitTestType type) const
+{
+    return (getUseBoundingRect() && type == HIT_TEST_USE_BOUNDING_RECT)
+        ? mBoundingRect.pointInRect( x, y )
+        : mRect.pointInRect( x, y );
+}
+
+BOOL LLView::pointInView(S32 x, S32 y, EHitTestType type) const
+{
+    return (getUseBoundingRect() && type == HIT_TEST_USE_BOUNDING_RECT)
+        ? mBoundingRect.pointInRect( x + mRect.mLeft, y + mRect.mBottom )
+        : mRect.localPointInRect( x, y );
 }
 
 BOOL LLView::blockMouseEvent(S32 x, S32 y) const
 {
-	return mMouseOpaque && pointInView(x, y, HIT_TEST_IGNORE_BOUNDING_RECT);
+    return mMouseOpaque && pointInView(x, y, HIT_TEST_IGNORE_BOUNDING_RECT);
 }
 
 // virtual
 void LLView::screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const
 {
-	*local_x = screen_x - getRect().mLeft;
-	*local_y = screen_y - getRect().mBottom;
+    *local_x = screen_x - getRect().mLeft;
+    *local_y = screen_y - getRect().mBottom;
 
-	const LLView* cur = this;
-	while( cur->mParentView )
-	{
-		cur = cur->mParentView;
-		*local_x -= cur->getRect().mLeft;
-		*local_y -= cur->getRect().mBottom;
-	}
+    const LLView* cur = this;
+    while( cur->mParentView )
+    {
+        cur = cur->mParentView;
+        *local_x -= cur->getRect().mLeft;
+        *local_y -= cur->getRect().mBottom;
+    }
 }
 
 void LLView::localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const
 {
-	*screen_x = local_x;
-	*screen_y = local_y;
+    *screen_x = local_x;
+    *screen_y = local_y;
 
-	const LLView* cur = this;
-	do
-	{
-		LLRect cur_rect = cur->getRect();
-		*screen_x += cur_rect.mLeft;
-		*screen_y += cur_rect.mBottom;
-		cur = cur->mParentView;
-	}
-	while( cur );
+    const LLView* cur = this;
+    do
+    {
+        LLRect cur_rect = cur->getRect();
+        *screen_x += cur_rect.mLeft;
+        *screen_y += cur_rect.mBottom;
+        cur = cur->mParentView;
+    }
+    while( cur );
 }
 
 void LLView::screenRectToLocal(const LLRect& screen, LLRect* local) const
 {
-	*local = screen;
-	local->translate( -getRect().mLeft, -getRect().mBottom );
+    *local = screen;
+    local->translate( -getRect().mLeft, -getRect().mBottom );
 
-	const LLView* cur = this;
-	while( cur->mParentView )
-	{
-		cur = cur->mParentView;
-		local->translate( -cur->getRect().mLeft, -cur->getRect().mBottom );
-	}
+    const LLView* cur = this;
+    while( cur->mParentView )
+    {
+        cur = cur->mParentView;
+        local->translate( -cur->getRect().mLeft, -cur->getRect().mBottom );
+    }
 }
 
 void LLView::localRectToScreen(const LLRect& local, LLRect* screen) const
 {
-	*screen = local;
-	screen->translate( getRect().mLeft, getRect().mBottom );
+    *screen = local;
+    screen->translate( getRect().mLeft, getRect().mBottom );
 
-	const LLView* cur = this;
-	while( cur->mParentView )
-	{
-		cur = cur->mParentView;
-		screen->translate( cur->getRect().mLeft, cur->getRect().mBottom );
-	}
+    const LLView* cur = this;
+    while( cur->mParentView )
+    {
+        cur = cur->mParentView;
+        screen->translate( cur->getRect().mLeft, cur->getRect().mBottom );
+    }
 }
 
 LLView* LLView::getRootView()
 {
-	LLView* view = this;
-	while( view->mParentView )
-	{
-		view = view->mParentView;
-	}
-	return view;
+    LLView* view = this;
+    while( view->mParentView )
+    {
+        view = view->mParentView;
+    }
+    return view;
 }
 
 LLView* LLView::findPrevSibling(LLView* child)
 {
-	child_list_t::iterator prev_it = std::find(mChildList.begin(), mChildList.end(), child);
-	if (prev_it != mChildList.end() && prev_it != mChildList.begin())
-	{
-		return *(--prev_it);
-	}
-	return NULL;
+    child_list_t::iterator prev_it = std::find(mChildList.begin(), mChildList.end(), child);
+    if (prev_it != mChildList.end() && prev_it != mChildList.begin())
+    {
+        return *(--prev_it);
+    }
+    return NULL;
 }
 
 LLView* LLView::findNextSibling(LLView* child)
 {
-	child_list_t::iterator next_it = std::find(mChildList.begin(), mChildList.end(), child);
-	if (next_it != mChildList.end())
-	{
-		next_it++;
-	}
+    child_list_t::iterator next_it = std::find(mChildList.begin(), mChildList.end(), child);
+    if (next_it != mChildList.end())
+    {
+        next_it++;
+    }
 
-	return (next_it != mChildList.end()) ? *next_it : NULL;
+    return (next_it != mChildList.end()) ? *next_it : NULL;
 }
 
 
 LLCoordGL getNeededTranslation(const LLRect& input, const LLRect& constraint, S32 min_overlap_pixels)
 {
-	LLCoordGL delta;
+    LLCoordGL delta;
 
-	const S32 KEEP_ONSCREEN_PIXELS_WIDTH = llmin(min_overlap_pixels, input.getWidth());
-	const S32 KEEP_ONSCREEN_PIXELS_HEIGHT = llmin(min_overlap_pixels, input.getHeight());
+    const S32 KEEP_ONSCREEN_PIXELS_WIDTH = llmin(min_overlap_pixels, input.getWidth());
+    const S32 KEEP_ONSCREEN_PIXELS_HEIGHT = llmin(min_overlap_pixels, input.getHeight());
 
-	if (KEEP_ONSCREEN_PIXELS_WIDTH <= constraint.getWidth() &&
-		KEEP_ONSCREEN_PIXELS_HEIGHT <= constraint.getHeight())
-	{
-		if (input.mRight - KEEP_ONSCREEN_PIXELS_WIDTH < constraint.mLeft)
-		{
-			delta.mX = constraint.mLeft - (input.mRight - KEEP_ONSCREEN_PIXELS_WIDTH);
-		}
-		else if (input.mLeft + KEEP_ONSCREEN_PIXELS_WIDTH > constraint.mRight)
-		{
-			delta.mX = constraint.mRight - (input.mLeft + KEEP_ONSCREEN_PIXELS_WIDTH);
-		}
-
-		if (input.mTop > constraint.mTop)
-		{
-			delta.mY = constraint.mTop - input.mTop;
-		}
-		else if (input.mTop - KEEP_ONSCREEN_PIXELS_HEIGHT < constraint.mBottom)
-		{
-			delta.mY = constraint.mBottom - (input.mTop - KEEP_ONSCREEN_PIXELS_HEIGHT);
-		}
-	}
+    if (KEEP_ONSCREEN_PIXELS_WIDTH <= constraint.getWidth() &&
+        KEEP_ONSCREEN_PIXELS_HEIGHT <= constraint.getHeight())
+    {
+        if (input.mRight - KEEP_ONSCREEN_PIXELS_WIDTH < constraint.mLeft)
+        {
+            delta.mX = constraint.mLeft - (input.mRight - KEEP_ONSCREEN_PIXELS_WIDTH);
+        }
+        else if (input.mLeft + KEEP_ONSCREEN_PIXELS_WIDTH > constraint.mRight)
+        {
+            delta.mX = constraint.mRight - (input.mLeft + KEEP_ONSCREEN_PIXELS_WIDTH);
+        }
+
+        if (input.mTop > constraint.mTop)
+        {
+            delta.mY = constraint.mTop - input.mTop;
+        }
+        else if (input.mTop - KEEP_ONSCREEN_PIXELS_HEIGHT < constraint.mBottom)
+        {
+            delta.mY = constraint.mBottom - (input.mTop - KEEP_ONSCREEN_PIXELS_HEIGHT);
+        }
+    }
 
-	return delta;
+    return delta;
 }
 
 // Moves the view so that it is entirely inside of constraint.
@@ -1788,487 +1788,487 @@ BOOL LLView::translateIntoRect(const LLRect& constraint, S32 min_overlap_pixels)
 
 BOOL LLView::translateRectIntoRect(const LLRect& rect, const LLRect& constraint, S32 min_overlap_pixels)
 {
-	LLCoordGL translation = getNeededTranslation(rect, constraint, min_overlap_pixels);
+    LLCoordGL translation = getNeededTranslation(rect, constraint, min_overlap_pixels);
 
-	if (translation.mX != 0 || translation.mY != 0)
-	{
-		translate(translation.mX, translation.mY);
-		return TRUE;
-	}
+    if (translation.mX != 0 || translation.mY != 0)
+    {
+        translate(translation.mX, translation.mY);
+        return TRUE;
+    }
 
-	return FALSE;
+    return FALSE;
 }
 
 // move this view into "inside" but not onto "exclude"
 // NOTE: if this view is already contained in "inside", we ignore the "exclude" rect
 BOOL LLView::translateIntoRectWithExclusion( const LLRect& inside, const LLRect& exclude, S32 min_overlap_pixels)
 {
-	LLCoordGL translation = getNeededTranslation(getRect(), inside, min_overlap_pixels);
-	
-	if (translation.mX != 0 || translation.mY != 0)
-	{
-		// translate ourselves into constraint rect
-		translate(translation.mX, translation.mY);
-	
-		// do we overlap with exclusion area?
-		// keep moving in the same direction to the other side of the exclusion rect
-		if (exclude.overlaps(getRect()))
-		{
-			// moving right
-			if (translation.mX > 0)
-			{
-				translate(exclude.mRight - getRect().mLeft, 0);
-			}
-			// moving left
-			else if (translation.mX < 0)
-			{
-				translate(exclude.mLeft - getRect().mRight, 0);
-			}
-
-			// moving up
-			if (translation.mY > 0)
-			{
-				translate(0, exclude.mTop - getRect().mBottom);
-			}
-			// moving down
-			else if (translation.mY < 0)
-			{
-				translate(0, exclude.mBottom - getRect().mTop);
-			}
-		}
-
-		return TRUE;
-	}
-	return FALSE;
+    LLCoordGL translation = getNeededTranslation(getRect(), inside, min_overlap_pixels);
+
+    if (translation.mX != 0 || translation.mY != 0)
+    {
+        // translate ourselves into constraint rect
+        translate(translation.mX, translation.mY);
+
+        // do we overlap with exclusion area?
+        // keep moving in the same direction to the other side of the exclusion rect
+        if (exclude.overlaps(getRect()))
+        {
+            // moving right
+            if (translation.mX > 0)
+            {
+                translate(exclude.mRight - getRect().mLeft, 0);
+            }
+            // moving left
+            else if (translation.mX < 0)
+            {
+                translate(exclude.mLeft - getRect().mRight, 0);
+            }
+
+            // moving up
+            if (translation.mY > 0)
+            {
+                translate(0, exclude.mTop - getRect().mBottom);
+            }
+            // moving down
+            else if (translation.mY < 0)
+            {
+                translate(0, exclude.mBottom - getRect().mTop);
+            }
+        }
+
+        return TRUE;
+    }
+    return FALSE;
 }
 
 
 void LLView::centerWithin(const LLRect& bounds)
 {
-	S32 left   = bounds.mLeft + (bounds.getWidth() - getRect().getWidth()) / 2;
-	S32 bottom = bounds.mBottom + (bounds.getHeight() - getRect().getHeight()) / 2;
+    S32 left   = bounds.mLeft + (bounds.getWidth() - getRect().getWidth()) / 2;
+    S32 bottom = bounds.mBottom + (bounds.getHeight() - getRect().getHeight()) / 2;
 
-	translate( left - getRect().mLeft, bottom - getRect().mBottom );
+    translate( left - getRect().mLeft, bottom - getRect().mBottom );
 }
 
 BOOL LLView::localPointToOtherView( S32 x, S32 y, S32 *other_x, S32 *other_y, const LLView* other_view) const
 {
-	const LLView* cur_view = this;
-	const LLView* root_view = NULL;
-
-	while (cur_view)
-	{
-		if (cur_view == other_view)
-		{
-			*other_x = x;
-			*other_y = y;
-			return TRUE;
-		}
+    const LLView* cur_view = this;
+    const LLView* root_view = NULL;
 
-		x += cur_view->getRect().mLeft;
-		y += cur_view->getRect().mBottom;
-
-		cur_view = cur_view->getParent();
-		root_view = cur_view;
-	}
+    while (cur_view)
+    {
+        if (cur_view == other_view)
+        {
+            *other_x = x;
+            *other_y = y;
+            return TRUE;
+        }
+
+        x += cur_view->getRect().mLeft;
+        y += cur_view->getRect().mBottom;
+
+        cur_view = cur_view->getParent();
+        root_view = cur_view;
+    }
 
-	// assuming common root between two views, chase other_view's parents up to root
-	cur_view = other_view;
-	while (cur_view)
-	{
-		x -= cur_view->getRect().mLeft;
-		y -= cur_view->getRect().mBottom;
+    // assuming common root between two views, chase other_view's parents up to root
+    cur_view = other_view;
+    while (cur_view)
+    {
+        x -= cur_view->getRect().mLeft;
+        y -= cur_view->getRect().mBottom;
 
-		cur_view = cur_view->getParent();
+        cur_view = cur_view->getParent();
 
-		if (cur_view == root_view)
-		{
-			*other_x = x;
-			*other_y = y;
-			return TRUE;
-		}
-	}
+        if (cur_view == root_view)
+        {
+            *other_x = x;
+            *other_y = y;
+            return TRUE;
+        }
+    }
 
-	*other_x = x;
-	*other_y = y;
-	return FALSE;
+    *other_x = x;
+    *other_y = y;
+    return FALSE;
 }
 
 BOOL LLView::localRectToOtherView( const LLRect& local, LLRect* other, const LLView* other_view ) const
 {
-	LLRect cur_rect = local;
-	const LLView* cur_view = this;
-	const LLView* root_view = NULL;
+    LLRect cur_rect = local;
+    const LLView* cur_view = this;
+    const LLView* root_view = NULL;
 
-	while (cur_view)
-	{
-		if (cur_view == other_view)
-		{
-			*other = cur_rect;
-			return TRUE;
-		}
+    while (cur_view)
+    {
+        if (cur_view == other_view)
+        {
+            *other = cur_rect;
+            return TRUE;
+        }
 
-		cur_rect.translate(cur_view->getRect().mLeft, cur_view->getRect().mBottom);
+        cur_rect.translate(cur_view->getRect().mLeft, cur_view->getRect().mBottom);
 
-		cur_view = cur_view->getParent();
-		root_view = cur_view;
-	}
+        cur_view = cur_view->getParent();
+        root_view = cur_view;
+    }
 
-	// assuming common root between two views, chase other_view's parents up to root
-	cur_view = other_view;
-	while (cur_view)
-	{
-		cur_rect.translate(-cur_view->getRect().mLeft, -cur_view->getRect().mBottom);
+    // assuming common root between two views, chase other_view's parents up to root
+    cur_view = other_view;
+    while (cur_view)
+    {
+        cur_rect.translate(-cur_view->getRect().mLeft, -cur_view->getRect().mBottom);
 
-		cur_view = cur_view->getParent();
+        cur_view = cur_view->getParent();
 
-		if (cur_view == root_view)
-		{
-			*other = cur_rect;
-			return TRUE;
-		}
-	}
+        if (cur_view == root_view)
+        {
+            *other = cur_rect;
+            return TRUE;
+        }
+    }
 
-	*other = cur_rect;
-	return FALSE;
+    *other = cur_rect;
+    return FALSE;
 }
 
 
 class CompareByTabOrder
 {
 public:
-	CompareByTabOrder(const LLView::child_tab_order_t& order, S32 default_tab_group = 0) 
-		:	mTabOrder(order),
-		mDefaultTabGroup(default_tab_group)
-	{}
-	virtual ~CompareByTabOrder() {}
-
-	// This method compares two LLViews by the tab order specified in the comparator object.  The
-	// code for this is a little convoluted because each argument can have four states:
-	// 1) not a control, 2) a control but not in the tab order, 3) a control in the tab order, 4) null
-	bool operator() (const LLView* const a, const LLView* const b) const
-	{
-		S32 a_group = 0, b_group = 0;
-		if(!a) return false;
-		if(!b) return true;
-
-		LLView::child_tab_order_const_iter_t a_found = mTabOrder.find(a), b_found = mTabOrder.find(b);
-		if(a_found != mTabOrder.end())
-		{
-			a_group = a_found->second;
-		}
-		if(b_found != mTabOrder.end())
-		{
-			b_group = b_found->second;
-		}
-
-		if(a_group < mDefaultTabGroup && b_group >= mDefaultTabGroup) return true;
-		if(b_group < mDefaultTabGroup && a_group >= mDefaultTabGroup) return false;
-		return a_group > b_group;  // sort correctly if they're both on the same side of the default tab groupreturn a > b; 
-	}
+    CompareByTabOrder(const LLView::child_tab_order_t& order, S32 default_tab_group = 0)
+        :   mTabOrder(order),
+        mDefaultTabGroup(default_tab_group)
+    {}
+    virtual ~CompareByTabOrder() {}
+
+    // This method compares two LLViews by the tab order specified in the comparator object.  The
+    // code for this is a little convoluted because each argument can have four states:
+    // 1) not a control, 2) a control but not in the tab order, 3) a control in the tab order, 4) null
+    bool operator() (const LLView* const a, const LLView* const b) const
+    {
+        S32 a_group = 0, b_group = 0;
+        if(!a) return false;
+        if(!b) return true;
+
+        LLView::child_tab_order_const_iter_t a_found = mTabOrder.find(a), b_found = mTabOrder.find(b);
+        if(a_found != mTabOrder.end())
+        {
+            a_group = a_found->second;
+        }
+        if(b_found != mTabOrder.end())
+        {
+            b_group = b_found->second;
+        }
+
+        if(a_group < mDefaultTabGroup && b_group >= mDefaultTabGroup) return true;
+        if(b_group < mDefaultTabGroup && a_group >= mDefaultTabGroup) return false;
+        return a_group > b_group;  // sort correctly if they're both on the same side of the default tab groupreturn a > b;
+    }
 private:
-	// ok to store a reference, as this should only be allocated on stack during view query operations
-	const LLView::child_tab_order_t& mTabOrder;
-	const S32 mDefaultTabGroup;
+    // ok to store a reference, as this should only be allocated on stack during view query operations
+    const LLView::child_tab_order_t& mTabOrder;
+    const S32 mDefaultTabGroup;
 };
 
 class SortByTabOrder : public LLQuerySorter, public LLSingleton<SortByTabOrder>
 {
-	LLSINGLETON_EMPTY_CTOR(SortByTabOrder);
-	/*virtual*/ void sort(LLView * parent, LLView::child_list_t &children) const override
-	{
-		children.sort(CompareByTabOrder(parent->getTabOrder(), parent->getDefaultTabGroup()));
-	}
+    LLSINGLETON_EMPTY_CTOR(SortByTabOrder);
+    /*virtual*/ void sort(LLView * parent, LLView::child_list_t &children) const override
+    {
+        children.sort(CompareByTabOrder(parent->getTabOrder(), parent->getDefaultTabGroup()));
+    }
 };
 
 // static
 const LLViewQuery & LLView::getTabOrderQuery()
 {
-	static LLViewQuery query;
-	if(query.getPreFilters().size() == 0) {
-		query.addPreFilter(LLVisibleFilter::getInstance());
-		query.addPreFilter(LLEnabledFilter::getInstance());
-		query.addPreFilter(LLTabStopFilter::getInstance());
-		query.addPostFilter(LLLeavesFilter::getInstance());
-		query.setSorter(SortByTabOrder::getInstance());
-	}
-	return query;
+    static LLViewQuery query;
+    if(query.getPreFilters().size() == 0) {
+        query.addPreFilter(LLVisibleFilter::getInstance());
+        query.addPreFilter(LLEnabledFilter::getInstance());
+        query.addPreFilter(LLTabStopFilter::getInstance());
+        query.addPostFilter(LLLeavesFilter::getInstance());
+        query.setSorter(SortByTabOrder::getInstance());
+    }
+    return query;
 }
 
-// This class is only used internally by getFocusRootsQuery below. 
+// This class is only used internally by getFocusRootsQuery below.
 class LLFocusRootsFilter : public LLQueryFilter, public LLSingleton<LLFocusRootsFilter>
 {
-	LLSINGLETON_EMPTY_CTOR(LLFocusRootsFilter);
-	/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const override
-	{
-		return filterResult_t(view->isCtrl() && view->isFocusRoot(), !view->isFocusRoot());
-	}
+    LLSINGLETON_EMPTY_CTOR(LLFocusRootsFilter);
+    /*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const override
+    {
+        return filterResult_t(view->isCtrl() && view->isFocusRoot(), !view->isFocusRoot());
+    }
 };
 
 // static
 const LLViewQuery & LLView::getFocusRootsQuery()
 {
-	static LLViewQuery query;
-	if(query.getPreFilters().size() == 0) {
-		query.addPreFilter(LLVisibleFilter::getInstance());
-		query.addPreFilter(LLEnabledFilter::getInstance());
-		query.addPreFilter(LLFocusRootsFilter::getInstance());
-		query.addPostFilter(LLRootsFilter::getInstance());
-	}
-	return query;
+    static LLViewQuery query;
+    if(query.getPreFilters().size() == 0) {
+        query.addPreFilter(LLVisibleFilter::getInstance());
+        query.addPreFilter(LLEnabledFilter::getInstance());
+        query.addPreFilter(LLFocusRootsFilter::getInstance());
+        query.addPostFilter(LLRootsFilter::getInstance());
+    }
+    return query;
 }
 
 
-void	LLView::setShape(const LLRect& new_rect, bool by_user)
+void    LLView::setShape(const LLRect& new_rect, bool by_user)
 {
-	if (new_rect != getRect())
-	{
-		handleReshape(new_rect, by_user);
-	}
+    if (new_rect != getRect())
+    {
+        handleReshape(new_rect, by_user);
+    }
 }
 
 void LLView::handleReshape(const LLRect& new_rect, bool by_user)
 {
-	reshape(new_rect.getWidth(), new_rect.getHeight());
-	translate(new_rect.mLeft - getRect().mLeft, new_rect.mBottom - getRect().mBottom);
+    reshape(new_rect.getWidth(), new_rect.getHeight());
+    translate(new_rect.mLeft - getRect().mLeft, new_rect.mBottom - getRect().mBottom);
 }
 
 LLView* LLView::findSnapRect(LLRect& new_rect, const LLCoordGL& mouse_dir,
-							 LLView::ESnapType snap_type, S32 threshold, S32 padding)
-{
-	new_rect = mRect;
-	LLView* snap_view = NULL;
-
-	if (!mParentView)
-	{
-		return NULL;
-	}
-	
-	S32 delta_x = 0;
-	S32 delta_y = 0;
-	if (mouse_dir.mX >= 0)
-	{
-		S32 new_right = mRect.mRight;
-		LLView* view = findSnapEdge(new_right, mouse_dir, SNAP_RIGHT, snap_type, threshold, padding);
-		delta_x = new_right - mRect.mRight;
-		snap_view = view ? view : snap_view;
-	}
-
-	if (mouse_dir.mX <= 0)
-	{
-		S32 new_left = mRect.mLeft;
-		LLView* view = findSnapEdge(new_left, mouse_dir, SNAP_LEFT, snap_type, threshold, padding);
-		delta_x = new_left - mRect.mLeft;
-		snap_view = view ? view : snap_view;
-	}
-
-	if (mouse_dir.mY >= 0)
-	{
-		S32 new_top = mRect.mTop;
-		LLView* view = findSnapEdge(new_top, mouse_dir, SNAP_TOP, snap_type, threshold, padding);
-		delta_y = new_top - mRect.mTop;
-		snap_view = view ? view : snap_view;
-	}
-
-	if (mouse_dir.mY <= 0)
-	{
-		S32 new_bottom = mRect.mBottom;
-		LLView* view = findSnapEdge(new_bottom, mouse_dir, SNAP_BOTTOM, snap_type, threshold, padding);
-		delta_y = new_bottom - mRect.mBottom;
-		snap_view = view ? view : snap_view;
-	}
-
-	new_rect.translate(delta_x, delta_y);
-	return snap_view;
-}
-
-LLView*	LLView::findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESnapEdge snap_edge, ESnapType snap_type, S32 threshold, S32 padding)
-{
-	LLRect snap_rect = getSnapRect();
-	S32 snap_pos = 0;
-	switch(snap_edge)
-	{
-	case SNAP_LEFT:
-		snap_pos = snap_rect.mLeft;
-		break;
-	case SNAP_RIGHT:
-		snap_pos = snap_rect.mRight;
-		break;
-	case SNAP_TOP:
-		snap_pos = snap_rect.mTop;
-		break;
-	case SNAP_BOTTOM:
-		snap_pos = snap_rect.mBottom;
-		break;
-	}
-
-	if (!mParentView)
-	{
-		new_edge_val = snap_pos;
-		return NULL;
-	}
-
-	LLView* snap_view = NULL;
-
-	// If the view is near the edge of its parent, snap it to
-	// the edge.
-	LLRect test_rect = snap_rect;
-	test_rect.stretch(padding);
-
-	S32 x_threshold = threshold;
-	S32 y_threshold = threshold;
-
-	LLRect parent_local_snap_rect = mParentView->getLocalSnapRect();
-
-	if (snap_type == SNAP_PARENT || snap_type == SNAP_PARENT_AND_SIBLINGS)
-	{
-		switch(snap_edge)
-		{
-		case SNAP_RIGHT:
-			if (llabs(parent_local_snap_rect.mRight - test_rect.mRight) <= x_threshold 
-				&& (parent_local_snap_rect.mRight - test_rect.mRight) * mouse_dir.mX >= 0)
-			{
-				snap_pos = parent_local_snap_rect.mRight - padding;
-				snap_view = mParentView;
-				x_threshold = llabs(parent_local_snap_rect.mRight - test_rect.mRight);
-			}
-			break;
-		case SNAP_LEFT:
-			if (llabs(test_rect.mLeft - parent_local_snap_rect.mLeft) <= x_threshold 
-				&& test_rect.mLeft * mouse_dir.mX <= 0)
-			{
-				snap_pos = parent_local_snap_rect.mLeft + padding;
-				snap_view = mParentView;
-				x_threshold = llabs(test_rect.mLeft - parent_local_snap_rect.mLeft);
-			}
-			break;
-		case SNAP_BOTTOM:
-			if (llabs(test_rect.mBottom - parent_local_snap_rect.mBottom) <= y_threshold 
-				&& test_rect.mBottom * mouse_dir.mY <= 0)
-			{
-				snap_pos = parent_local_snap_rect.mBottom + padding;
-				snap_view = mParentView;
-				y_threshold = llabs(test_rect.mBottom - parent_local_snap_rect.mBottom);
-			}
-			break;
-		case SNAP_TOP:
-			if (llabs(parent_local_snap_rect.mTop - test_rect.mTop) <= y_threshold && (parent_local_snap_rect.mTop - test_rect.mTop) * mouse_dir.mY >= 0)
-			{
-				snap_pos = parent_local_snap_rect.mTop - padding;
-				snap_view = mParentView;
-				y_threshold = llabs(parent_local_snap_rect.mTop - test_rect.mTop);
-			}
-			break;
-		default:
-			LL_ERRS() << "Invalid snap edge" << LL_ENDL;
-		}
-	}
-
-	if (snap_type == SNAP_SIBLINGS || snap_type == SNAP_PARENT_AND_SIBLINGS)
-	{
-		for ( child_list_const_iter_t child_it = mParentView->getChildList()->begin();
-			  child_it != mParentView->getChildList()->end(); ++child_it)
-		{
-			LLView* siblingp = *child_it;
-
-			if (!canSnapTo(siblingp)) continue;
-
-			LLRect sibling_rect = siblingp->getSnapRect();
-
-			switch(snap_edge)
-			{
-			case SNAP_RIGHT:
-				if (llabs(test_rect.mRight - sibling_rect.mLeft) <= x_threshold 
-					&& (test_rect.mRight - sibling_rect.mLeft) * mouse_dir.mX <= 0)
-				{
-					snap_pos = sibling_rect.mLeft - padding;
-					snap_view = siblingp;
-					x_threshold = llabs(test_rect.mRight - sibling_rect.mLeft);
-				}
-				// if snapped with sibling along other axis, check for shared edge
-				else if (llabs(sibling_rect.mTop - (test_rect.mBottom - padding)) <= y_threshold 
-					|| llabs(sibling_rect.mBottom - (test_rect.mTop + padding)) <= x_threshold)
-				{
-					if (llabs(test_rect.mRight - sibling_rect.mRight) <= x_threshold 
-						&& (test_rect.mRight - sibling_rect.mRight) * mouse_dir.mX <= 0)
-					{
-						snap_pos = sibling_rect.mRight;
-						snap_view = siblingp;
-						x_threshold = llabs(test_rect.mRight - sibling_rect.mRight);
-					}
-				}
-				break;
-			case SNAP_LEFT:
-				if (llabs(test_rect.mLeft - sibling_rect.mRight) <= x_threshold 
-					&& (test_rect.mLeft - sibling_rect.mRight) * mouse_dir.mX <= 0)
-				{
-					snap_pos = sibling_rect.mRight + padding;
-					snap_view = siblingp;
-					x_threshold = llabs(test_rect.mLeft - sibling_rect.mRight);				
-				}
-				// if snapped with sibling along other axis, check for shared edge
-				else if (llabs(sibling_rect.mTop - (test_rect.mBottom - padding)) <= y_threshold 
-					|| llabs(sibling_rect.mBottom - (test_rect.mTop + padding)) <= y_threshold)
-				{
-					if (llabs(test_rect.mLeft - sibling_rect.mLeft) <= x_threshold 
-						&& (test_rect.mLeft - sibling_rect.mLeft) * mouse_dir.mX <= 0)
-					{
-						snap_pos = sibling_rect.mLeft;
-						snap_view = siblingp;
-						x_threshold = llabs(test_rect.mLeft - sibling_rect.mLeft);									
-					}
-				}
-				break;
-			case SNAP_BOTTOM:
-				if (llabs(test_rect.mBottom - sibling_rect.mTop) <= y_threshold 
-					&& (test_rect.mBottom - sibling_rect.mTop) * mouse_dir.mY <= 0)
-				{
-					snap_pos = sibling_rect.mTop + padding;
-					snap_view = siblingp;
-					y_threshold = llabs(test_rect.mBottom - sibling_rect.mTop);
-				}
-				// if snapped with sibling along other axis, check for shared edge
-				else if (llabs(sibling_rect.mRight - (test_rect.mLeft - padding)) <= x_threshold 
-					|| llabs(sibling_rect.mLeft - (test_rect.mRight + padding)) <= x_threshold)
-				{
-					if (llabs(test_rect.mBottom - sibling_rect.mBottom) <= y_threshold 
-						&& (test_rect.mBottom - sibling_rect.mBottom) * mouse_dir.mY <= 0)
-					{
-						snap_pos = sibling_rect.mBottom;
-						snap_view = siblingp;
-						y_threshold = llabs(test_rect.mBottom - sibling_rect.mBottom);
-					}
-				}
-				break;
-			case SNAP_TOP:
-				if (llabs(test_rect.mTop - sibling_rect.mBottom) <= y_threshold 
-					&& (test_rect.mTop - sibling_rect.mBottom) * mouse_dir.mY <= 0)
-				{
-					snap_pos = sibling_rect.mBottom - padding;
-					snap_view = siblingp;
-					y_threshold = llabs(test_rect.mTop - sibling_rect.mBottom);
-				}
-				// if snapped with sibling along other axis, check for shared edge
-				else if (llabs(sibling_rect.mRight - (test_rect.mLeft - padding)) <= x_threshold 
-					|| llabs(sibling_rect.mLeft - (test_rect.mRight + padding)) <= x_threshold)
-				{
-					if (llabs(test_rect.mTop - sibling_rect.mTop) <= y_threshold 
-						&& (test_rect.mTop - sibling_rect.mTop) * mouse_dir.mY <= 0)
-					{
-						snap_pos = sibling_rect.mTop;
-						snap_view = siblingp;
-						y_threshold = llabs(test_rect.mTop - sibling_rect.mTop);
-					}
-				}
-				break;
-			default:
-				LL_ERRS() << "Invalid snap edge" << LL_ENDL;
-			}
-		}
-	}
-
-	new_edge_val = snap_pos;
-	return snap_view;
+                             LLView::ESnapType snap_type, S32 threshold, S32 padding)
+{
+    new_rect = mRect;
+    LLView* snap_view = NULL;
+
+    if (!mParentView)
+    {
+        return NULL;
+    }
+
+    S32 delta_x = 0;
+    S32 delta_y = 0;
+    if (mouse_dir.mX >= 0)
+    {
+        S32 new_right = mRect.mRight;
+        LLView* view = findSnapEdge(new_right, mouse_dir, SNAP_RIGHT, snap_type, threshold, padding);
+        delta_x = new_right - mRect.mRight;
+        snap_view = view ? view : snap_view;
+    }
+
+    if (mouse_dir.mX <= 0)
+    {
+        S32 new_left = mRect.mLeft;
+        LLView* view = findSnapEdge(new_left, mouse_dir, SNAP_LEFT, snap_type, threshold, padding);
+        delta_x = new_left - mRect.mLeft;
+        snap_view = view ? view : snap_view;
+    }
+
+    if (mouse_dir.mY >= 0)
+    {
+        S32 new_top = mRect.mTop;
+        LLView* view = findSnapEdge(new_top, mouse_dir, SNAP_TOP, snap_type, threshold, padding);
+        delta_y = new_top - mRect.mTop;
+        snap_view = view ? view : snap_view;
+    }
+
+    if (mouse_dir.mY <= 0)
+    {
+        S32 new_bottom = mRect.mBottom;
+        LLView* view = findSnapEdge(new_bottom, mouse_dir, SNAP_BOTTOM, snap_type, threshold, padding);
+        delta_y = new_bottom - mRect.mBottom;
+        snap_view = view ? view : snap_view;
+    }
+
+    new_rect.translate(delta_x, delta_y);
+    return snap_view;
+}
+
+LLView* LLView::findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESnapEdge snap_edge, ESnapType snap_type, S32 threshold, S32 padding)
+{
+    LLRect snap_rect = getSnapRect();
+    S32 snap_pos = 0;
+    switch(snap_edge)
+    {
+    case SNAP_LEFT:
+        snap_pos = snap_rect.mLeft;
+        break;
+    case SNAP_RIGHT:
+        snap_pos = snap_rect.mRight;
+        break;
+    case SNAP_TOP:
+        snap_pos = snap_rect.mTop;
+        break;
+    case SNAP_BOTTOM:
+        snap_pos = snap_rect.mBottom;
+        break;
+    }
+
+    if (!mParentView)
+    {
+        new_edge_val = snap_pos;
+        return NULL;
+    }
+
+    LLView* snap_view = NULL;
+
+    // If the view is near the edge of its parent, snap it to
+    // the edge.
+    LLRect test_rect = snap_rect;
+    test_rect.stretch(padding);
+
+    S32 x_threshold = threshold;
+    S32 y_threshold = threshold;
+
+    LLRect parent_local_snap_rect = mParentView->getLocalSnapRect();
+
+    if (snap_type == SNAP_PARENT || snap_type == SNAP_PARENT_AND_SIBLINGS)
+    {
+        switch(snap_edge)
+        {
+        case SNAP_RIGHT:
+            if (llabs(parent_local_snap_rect.mRight - test_rect.mRight) <= x_threshold
+                && (parent_local_snap_rect.mRight - test_rect.mRight) * mouse_dir.mX >= 0)
+            {
+                snap_pos = parent_local_snap_rect.mRight - padding;
+                snap_view = mParentView;
+                x_threshold = llabs(parent_local_snap_rect.mRight - test_rect.mRight);
+            }
+            break;
+        case SNAP_LEFT:
+            if (llabs(test_rect.mLeft - parent_local_snap_rect.mLeft) <= x_threshold
+                && test_rect.mLeft * mouse_dir.mX <= 0)
+            {
+                snap_pos = parent_local_snap_rect.mLeft + padding;
+                snap_view = mParentView;
+                x_threshold = llabs(test_rect.mLeft - parent_local_snap_rect.mLeft);
+            }
+            break;
+        case SNAP_BOTTOM:
+            if (llabs(test_rect.mBottom - parent_local_snap_rect.mBottom) <= y_threshold
+                && test_rect.mBottom * mouse_dir.mY <= 0)
+            {
+                snap_pos = parent_local_snap_rect.mBottom + padding;
+                snap_view = mParentView;
+                y_threshold = llabs(test_rect.mBottom - parent_local_snap_rect.mBottom);
+            }
+            break;
+        case SNAP_TOP:
+            if (llabs(parent_local_snap_rect.mTop - test_rect.mTop) <= y_threshold && (parent_local_snap_rect.mTop - test_rect.mTop) * mouse_dir.mY >= 0)
+            {
+                snap_pos = parent_local_snap_rect.mTop - padding;
+                snap_view = mParentView;
+                y_threshold = llabs(parent_local_snap_rect.mTop - test_rect.mTop);
+            }
+            break;
+        default:
+            LL_ERRS() << "Invalid snap edge" << LL_ENDL;
+        }
+    }
+
+    if (snap_type == SNAP_SIBLINGS || snap_type == SNAP_PARENT_AND_SIBLINGS)
+    {
+        for ( child_list_const_iter_t child_it = mParentView->getChildList()->begin();
+              child_it != mParentView->getChildList()->end(); ++child_it)
+        {
+            LLView* siblingp = *child_it;
+
+            if (!canSnapTo(siblingp)) continue;
+
+            LLRect sibling_rect = siblingp->getSnapRect();
+
+            switch(snap_edge)
+            {
+            case SNAP_RIGHT:
+                if (llabs(test_rect.mRight - sibling_rect.mLeft) <= x_threshold
+                    && (test_rect.mRight - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+                {
+                    snap_pos = sibling_rect.mLeft - padding;
+                    snap_view = siblingp;
+                    x_threshold = llabs(test_rect.mRight - sibling_rect.mLeft);
+                }
+                // if snapped with sibling along other axis, check for shared edge
+                else if (llabs(sibling_rect.mTop - (test_rect.mBottom - padding)) <= y_threshold
+                    || llabs(sibling_rect.mBottom - (test_rect.mTop + padding)) <= x_threshold)
+                {
+                    if (llabs(test_rect.mRight - sibling_rect.mRight) <= x_threshold
+                        && (test_rect.mRight - sibling_rect.mRight) * mouse_dir.mX <= 0)
+                    {
+                        snap_pos = sibling_rect.mRight;
+                        snap_view = siblingp;
+                        x_threshold = llabs(test_rect.mRight - sibling_rect.mRight);
+                    }
+                }
+                break;
+            case SNAP_LEFT:
+                if (llabs(test_rect.mLeft - sibling_rect.mRight) <= x_threshold
+                    && (test_rect.mLeft - sibling_rect.mRight) * mouse_dir.mX <= 0)
+                {
+                    snap_pos = sibling_rect.mRight + padding;
+                    snap_view = siblingp;
+                    x_threshold = llabs(test_rect.mLeft - sibling_rect.mRight);
+                }
+                // if snapped with sibling along other axis, check for shared edge
+                else if (llabs(sibling_rect.mTop - (test_rect.mBottom - padding)) <= y_threshold
+                    || llabs(sibling_rect.mBottom - (test_rect.mTop + padding)) <= y_threshold)
+                {
+                    if (llabs(test_rect.mLeft - sibling_rect.mLeft) <= x_threshold
+                        && (test_rect.mLeft - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+                    {
+                        snap_pos = sibling_rect.mLeft;
+                        snap_view = siblingp;
+                        x_threshold = llabs(test_rect.mLeft - sibling_rect.mLeft);
+                    }
+                }
+                break;
+            case SNAP_BOTTOM:
+                if (llabs(test_rect.mBottom - sibling_rect.mTop) <= y_threshold
+                    && (test_rect.mBottom - sibling_rect.mTop) * mouse_dir.mY <= 0)
+                {
+                    snap_pos = sibling_rect.mTop + padding;
+                    snap_view = siblingp;
+                    y_threshold = llabs(test_rect.mBottom - sibling_rect.mTop);
+                }
+                // if snapped with sibling along other axis, check for shared edge
+                else if (llabs(sibling_rect.mRight - (test_rect.mLeft - padding)) <= x_threshold
+                    || llabs(sibling_rect.mLeft - (test_rect.mRight + padding)) <= x_threshold)
+                {
+                    if (llabs(test_rect.mBottom - sibling_rect.mBottom) <= y_threshold
+                        && (test_rect.mBottom - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+                    {
+                        snap_pos = sibling_rect.mBottom;
+                        snap_view = siblingp;
+                        y_threshold = llabs(test_rect.mBottom - sibling_rect.mBottom);
+                    }
+                }
+                break;
+            case SNAP_TOP:
+                if (llabs(test_rect.mTop - sibling_rect.mBottom) <= y_threshold
+                    && (test_rect.mTop - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+                {
+                    snap_pos = sibling_rect.mBottom - padding;
+                    snap_view = siblingp;
+                    y_threshold = llabs(test_rect.mTop - sibling_rect.mBottom);
+                }
+                // if snapped with sibling along other axis, check for shared edge
+                else if (llabs(sibling_rect.mRight - (test_rect.mLeft - padding)) <= x_threshold
+                    || llabs(sibling_rect.mLeft - (test_rect.mRight + padding)) <= x_threshold)
+                {
+                    if (llabs(test_rect.mTop - sibling_rect.mTop) <= y_threshold
+                        && (test_rect.mTop - sibling_rect.mTop) * mouse_dir.mY <= 0)
+                    {
+                        snap_pos = sibling_rect.mTop;
+                        snap_view = siblingp;
+                        y_threshold = llabs(test_rect.mTop - sibling_rect.mTop);
+                    }
+                }
+                break;
+            default:
+                LL_ERRS() << "Invalid snap edge" << LL_ENDL;
+            }
+        }
+    }
+
+    new_edge_val = snap_pos;
+    return snap_view;
 }
 
 //-----------------------------------------------------------------------------
@@ -2278,114 +2278,114 @@ LLView*	LLView::findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESna
 
 LLControlVariable *LLView::findControl(const std::string& name)
 {
-	// parse the name to locate which group it belongs to
-	std::size_t key_pos= name.find(".");
-	if(key_pos!=  std::string::npos )
-	{
-		std::string control_group_key = name.substr(0, key_pos);
-		LLControlVariable* control;
-		// check if it's in the control group that name indicated
-		if(LLUI::getInstance()->mSettingGroups[control_group_key])
-		{
-			control = LLUI::getInstance()->mSettingGroups[control_group_key]->getControl(name);
-			if (control)
-			{
-				return control;
-			}
-		}
-	}
-	
-	LLControlGroup& control_group = LLUI::getInstance()->getControlControlGroup(name);
-	return control_group.getControl(name);	
+    // parse the name to locate which group it belongs to
+    std::size_t key_pos= name.find(".");
+    if(key_pos!=  std::string::npos )
+    {
+        std::string control_group_key = name.substr(0, key_pos);
+        LLControlVariable* control;
+        // check if it's in the control group that name indicated
+        if(LLUI::getInstance()->mSettingGroups[control_group_key])
+        {
+            control = LLUI::getInstance()->mSettingGroups[control_group_key]->getControl(name);
+            if (control)
+            {
+                return control;
+            }
+        }
+    }
+
+    LLControlGroup& control_group = LLUI::getInstance()->getControlControlGroup(name);
+    return control_group.getControl(name);
 }
 
 void LLView::initFromParams(const LLView::Params& params)
 {
-	LLRect required_rect = getRequiredRect();
+    LLRect required_rect = getRequiredRect();
 
-	S32 width = llmax(getRect().getWidth(), required_rect.getWidth());
-	S32 height = llmax(getRect().getHeight(), required_rect.getHeight());
+    S32 width = llmax(getRect().getWidth(), required_rect.getWidth());
+    S32 height = llmax(getRect().getHeight(), required_rect.getHeight());
 
-	reshape(width, height);
+    reshape(width, height);
 
-	// call virtual methods with most recent data
-	// use getters because these values might not come through parameter block
-	setEnabled(getEnabled());
-	setVisible(getVisible());
+    // call virtual methods with most recent data
+    // use getters because these values might not come through parameter block
+    setEnabled(getEnabled());
+    setVisible(getVisible());
 
-	if (!params.name().empty())
-	{
-		setName(params.name());
-	}
+    if (!params.name().empty())
+    {
+        setName(params.name());
+    }
 
-	mLayout = params.layout();
+    mLayout = params.layout();
 }
 
 void LLView::parseFollowsFlags(const LLView::Params& params)
 {
-	// preserve follows flags set by code if user did not override
-	if (!params.follows.isProvided()) 
-	{
-		return;
-	}
-
-	// interpret either string or bitfield version of follows
-	if (params.follows.string.isChosen())
-	{
-		setFollows(FOLLOWS_NONE);
-
-		std::string follows = params.follows.string;
-
-		typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-		boost::char_separator<char> sep("|");
-		tokenizer tokens(follows, sep);
-		tokenizer::iterator token_iter = tokens.begin();
-
-		while(token_iter != tokens.end())
-		{
-			const std::string& token_str = *token_iter;
-			if (token_str == "left")
-			{
-				setFollowsLeft();
-			}
-			else if (token_str == "right")
-			{
-				setFollowsRight();
-			}
-			else if (token_str == "top")
-			{
-				setFollowsTop();
-			}
-			else if (token_str == "bottom")
-			{
-				setFollowsBottom();
-			}
-			else if (token_str == "all")
-			{
-				setFollowsAll();
-			}
-			++token_iter;
-		}
-	}
-	else if (params.follows.flags.isChosen())
-	{
-		setFollows(params.follows.flags);
-	}
+    // preserve follows flags set by code if user did not override
+    if (!params.follows.isProvided())
+    {
+        return;
+    }
+
+    // interpret either string or bitfield version of follows
+    if (params.follows.string.isChosen())
+    {
+        setFollows(FOLLOWS_NONE);
+
+        std::string follows = params.follows.string;
+
+        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+        boost::char_separator<char> sep("|");
+        tokenizer tokens(follows, sep);
+        tokenizer::iterator token_iter = tokens.begin();
+
+        while(token_iter != tokens.end())
+        {
+            const std::string& token_str = *token_iter;
+            if (token_str == "left")
+            {
+                setFollowsLeft();
+            }
+            else if (token_str == "right")
+            {
+                setFollowsRight();
+            }
+            else if (token_str == "top")
+            {
+                setFollowsTop();
+            }
+            else if (token_str == "bottom")
+            {
+                setFollowsBottom();
+            }
+            else if (token_str == "all")
+            {
+                setFollowsAll();
+            }
+            ++token_iter;
+        }
+    }
+    else if (params.follows.flags.isChosen())
+    {
+        setFollows(params.follows.flags);
+    }
 }
 
 
 // static
 //LLFontGL::HAlign LLView::selectFontHAlign(LLXMLNodePtr node)
 //{
-//	LLFontGL::HAlign gl_hfont_align = LLFontGL::LEFT;
+//  LLFontGL::HAlign gl_hfont_align = LLFontGL::LEFT;
 //
-//	if (node->hasAttribute("halign"))
-//	{
-//		std::string horizontal_align_name;
-//		node->getAttributeString("halign", horizontal_align_name);
-//		gl_hfont_align = LLFontGL::hAlignFromName(horizontal_align_name);
-//	}
-//	return gl_hfont_align;
+//  if (node->hasAttribute("halign"))
+//  {
+//      std::string horizontal_align_name;
+//      node->getAttributeString("halign", horizontal_align_name);
+//      gl_hfont_align = LLFontGL::hAlignFromName(horizontal_align_name);
+//  }
+//  return gl_hfont_align;
 //}
 
 // Return the rectangle of the last-constructed child,
@@ -2393,395 +2393,395 @@ void LLView::parseFollowsFlags(const LLView::Params& params)
 // Returns true if found
 static bool get_last_child_rect(LLView* parent, LLRect *rect)
 {
-	if (!parent) return false;
+    if (!parent) return false;
 
-	LLView::child_list_t::const_iterator itor = 
-		parent->getChildList()->begin();
-	for (;itor != parent->getChildList()->end(); ++itor)
-	{
-		LLView *last_view = (*itor);
-		if (last_view->getFromXUI())
-		{
-			*rect = last_view->getRect();
-			return true;
-		}
-	}
-	return false;
+    LLView::child_list_t::const_iterator itor =
+        parent->getChildList()->begin();
+    for (;itor != parent->getChildList()->end(); ++itor)
+    {
+        LLView *last_view = (*itor);
+        if (last_view->getFromXUI())
+        {
+            *rect = last_view->getRect();
+            return true;
+        }
+    }
+    return false;
 }
 
 //static
 void LLView::applyXUILayout(LLView::Params& p, LLView* parent, LLRect layout_rect)
 {
-	if (!parent) return;
-
-	const S32 VPAD = 4;
-	const S32 MIN_WIDGET_HEIGHT = 10;
-	
-	// *NOTE:  This will confuse export of floater/panel coordinates unless
-	// the default is also "topleft".  JC
-	if (p.layout().empty())
-	{
-		p.layout = parent->getLayout();
-	}
-
-	if (layout_rect.isEmpty())
-	{
-		layout_rect = parent->getLocalRect();
-	}
-
-	// overwrite uninitialized rect params, using context
-	LLRect default_rect = parent->getLocalRect();
-
-	bool layout_topleft = (p.layout() == "topleft");
-
-	// convert negative or centered coordinates to parent relative values
-	// Note: some of this logic matches the logic in TypedParam<LLRect>::setValueFromBlock()
-	if (p.rect.left.isProvided()) 
-	{
-		p.rect.left = p.rect.left + ((p.rect.left >= 0) ? layout_rect.mLeft : layout_rect.mRight);
-	}
-	if (p.rect.right.isProvided())
-	{
-		p.rect.right = p.rect.right + ((p.rect.right >= 0) ? layout_rect.mLeft : layout_rect.mRight);
-	}
-	if (p.rect.bottom.isProvided()) 
-	{
-		p.rect.bottom = p.rect.bottom + ((p.rect.bottom >= 0) ? layout_rect.mBottom : layout_rect.mTop);
-		if (layout_topleft)
-		{
-			//invert top to bottom
-			p.rect.bottom = layout_rect.mBottom + layout_rect.mTop - p.rect.bottom;
-		}
-	}
-	if (p.rect.top.isProvided())
-	{
-		p.rect.top = p.rect.top + ((p.rect.top >= 0) ? layout_rect.mBottom : layout_rect.mTop);
-		if (layout_topleft)
-		{
-			//invert top to bottom
-			p.rect.top = layout_rect.mBottom + layout_rect.mTop - p.rect.top;
-		}
-	}
-
-	// DEPRECATE: automatically fall back to height of MIN_WIDGET_HEIGHT pixels
-	if (!p.rect.height.isProvided() && !p.rect.top.isProvided() && p.rect.height == 0)
-	{
-		p.rect.height = MIN_WIDGET_HEIGHT;
-	}
-
-	default_rect.translate(0, default_rect.getHeight());
-
-	// If there was a recently constructed child, use its rectangle
-	get_last_child_rect(parent, &default_rect);
-
-	if (layout_topleft)
-	{
-		// Invert the sense of bottom_delta for topleft layout
-		if (p.bottom_delta.isProvided())
-		{
-			p.bottom_delta = -p.bottom_delta;
-		}
-		else if (p.top_pad.isProvided()) 
-		{
-			p.bottom_delta = -(p.rect.height + p.top_pad);
-		}
-		else if (p.top_delta.isProvided())
-		{
-			p.bottom_delta =
-				-(p.top_delta + p.rect.height - default_rect.getHeight());
-		}
-		else if (!p.left_delta.isProvided()
-					&& !p.left_pad.isProvided())
-		{
-			// set default position is just below last rect
-			p.bottom_delta.set(-(p.rect.height + VPAD), false);
-		}
-		else
-		{
-			p.bottom_delta.set(0, false);
-		}
-	
-		// default to same left edge
-		if (!p.left_delta.isProvided())
-		{
-			p.left_delta.set(0, false);
-		}
-		if (p.left_pad.isProvided())
-		{
-			// left_pad is based on prior widget's right edge
-			p.left_delta.set(p.left_pad + default_rect.getWidth(), false);
-		}
-			
-		default_rect.translate(p.left_delta, p.bottom_delta);				
-	}
-	else
-	{	
-		// set default position is just below last rect
-		if (!p.bottom_delta.isProvided())
-		{
-			p.bottom_delta.set(-(p.rect.height + VPAD), false);
-		}
-		if (!p.left_delta.isProvided())
-		{
-			p.left_delta.set(0, false);
-		}
-		default_rect.translate(p.left_delta, p.bottom_delta);
-	}
-
-	// this handles case where *both* x and x_delta are provided
-	// ignore x in favor of default x + x_delta
-	if (p.bottom_delta.isProvided()) p.rect.bottom.set(0, false);
-	if (p.left_delta.isProvided()) p.rect.left.set(0, false);
-
-	// selectively apply rectangle defaults, making sure that
-	// params are not flagged as having been "provided"
-	// as rect params are overconstrained and rely on provided flags
-	if (!p.rect.left.isProvided())
-	{
-		p.rect.left.set(default_rect.mLeft, false);
-		//HACK: get around the fact that setting a rect param component value won't invalidate the existing rect object value
-		p.rect.paramChanged(p.rect.left, true);
-	}
-	if (!p.rect.bottom.isProvided())
-	{
-		p.rect.bottom.set(default_rect.mBottom, false);
-		p.rect.paramChanged(p.rect.bottom, true);
-	}
-	if (!p.rect.top.isProvided())
-	{
-		p.rect.top.set(default_rect.mTop, false);
-		p.rect.paramChanged(p.rect.top, true);
-	}
-	if (!p.rect.right.isProvided())
-	{
-		p.rect.right.set(default_rect.mRight, false);
-		p.rect.paramChanged(p.rect.right, true);
-
-	}
-	if (!p.rect.width.isProvided())
-	{
-		p.rect.width.set(default_rect.getWidth(), false);
-		p.rect.paramChanged(p.rect.width, true);
-	}
-	if (!p.rect.height.isProvided())
-	{
-		p.rect.height.set(default_rect.getHeight(), false);
-		p.rect.paramChanged(p.rect.height, true);
-	}
+    if (!parent) return;
+
+    const S32 VPAD = 4;
+    const S32 MIN_WIDGET_HEIGHT = 10;
+
+    // *NOTE:  This will confuse export of floater/panel coordinates unless
+    // the default is also "topleft".  JC
+    if (p.layout().empty())
+    {
+        p.layout = parent->getLayout();
+    }
+
+    if (layout_rect.isEmpty())
+    {
+        layout_rect = parent->getLocalRect();
+    }
+
+    // overwrite uninitialized rect params, using context
+    LLRect default_rect = parent->getLocalRect();
+
+    bool layout_topleft = (p.layout() == "topleft");
+
+    // convert negative or centered coordinates to parent relative values
+    // Note: some of this logic matches the logic in TypedParam<LLRect>::setValueFromBlock()
+    if (p.rect.left.isProvided())
+    {
+        p.rect.left = p.rect.left + ((p.rect.left >= 0) ? layout_rect.mLeft : layout_rect.mRight);
+    }
+    if (p.rect.right.isProvided())
+    {
+        p.rect.right = p.rect.right + ((p.rect.right >= 0) ? layout_rect.mLeft : layout_rect.mRight);
+    }
+    if (p.rect.bottom.isProvided())
+    {
+        p.rect.bottom = p.rect.bottom + ((p.rect.bottom >= 0) ? layout_rect.mBottom : layout_rect.mTop);
+        if (layout_topleft)
+        {
+            //invert top to bottom
+            p.rect.bottom = layout_rect.mBottom + layout_rect.mTop - p.rect.bottom;
+        }
+    }
+    if (p.rect.top.isProvided())
+    {
+        p.rect.top = p.rect.top + ((p.rect.top >= 0) ? layout_rect.mBottom : layout_rect.mTop);
+        if (layout_topleft)
+        {
+            //invert top to bottom
+            p.rect.top = layout_rect.mBottom + layout_rect.mTop - p.rect.top;
+        }
+    }
+
+    // DEPRECATE: automatically fall back to height of MIN_WIDGET_HEIGHT pixels
+    if (!p.rect.height.isProvided() && !p.rect.top.isProvided() && p.rect.height == 0)
+    {
+        p.rect.height = MIN_WIDGET_HEIGHT;
+    }
+
+    default_rect.translate(0, default_rect.getHeight());
+
+    // If there was a recently constructed child, use its rectangle
+    get_last_child_rect(parent, &default_rect);
+
+    if (layout_topleft)
+    {
+        // Invert the sense of bottom_delta for topleft layout
+        if (p.bottom_delta.isProvided())
+        {
+            p.bottom_delta = -p.bottom_delta;
+        }
+        else if (p.top_pad.isProvided())
+        {
+            p.bottom_delta = -(p.rect.height + p.top_pad);
+        }
+        else if (p.top_delta.isProvided())
+        {
+            p.bottom_delta =
+                -(p.top_delta + p.rect.height - default_rect.getHeight());
+        }
+        else if (!p.left_delta.isProvided()
+                    && !p.left_pad.isProvided())
+        {
+            // set default position is just below last rect
+            p.bottom_delta.set(-(p.rect.height + VPAD), false);
+        }
+        else
+        {
+            p.bottom_delta.set(0, false);
+        }
+
+        // default to same left edge
+        if (!p.left_delta.isProvided())
+        {
+            p.left_delta.set(0, false);
+        }
+        if (p.left_pad.isProvided())
+        {
+            // left_pad is based on prior widget's right edge
+            p.left_delta.set(p.left_pad + default_rect.getWidth(), false);
+        }
+
+        default_rect.translate(p.left_delta, p.bottom_delta);
+    }
+    else
+    {
+        // set default position is just below last rect
+        if (!p.bottom_delta.isProvided())
+        {
+            p.bottom_delta.set(-(p.rect.height + VPAD), false);
+        }
+        if (!p.left_delta.isProvided())
+        {
+            p.left_delta.set(0, false);
+        }
+        default_rect.translate(p.left_delta, p.bottom_delta);
+    }
+
+    // this handles case where *both* x and x_delta are provided
+    // ignore x in favor of default x + x_delta
+    if (p.bottom_delta.isProvided()) p.rect.bottom.set(0, false);
+    if (p.left_delta.isProvided()) p.rect.left.set(0, false);
+
+    // selectively apply rectangle defaults, making sure that
+    // params are not flagged as having been "provided"
+    // as rect params are overconstrained and rely on provided flags
+    if (!p.rect.left.isProvided())
+    {
+        p.rect.left.set(default_rect.mLeft, false);
+        //HACK: get around the fact that setting a rect param component value won't invalidate the existing rect object value
+        p.rect.paramChanged(p.rect.left, true);
+    }
+    if (!p.rect.bottom.isProvided())
+    {
+        p.rect.bottom.set(default_rect.mBottom, false);
+        p.rect.paramChanged(p.rect.bottom, true);
+    }
+    if (!p.rect.top.isProvided())
+    {
+        p.rect.top.set(default_rect.mTop, false);
+        p.rect.paramChanged(p.rect.top, true);
+    }
+    if (!p.rect.right.isProvided())
+    {
+        p.rect.right.set(default_rect.mRight, false);
+        p.rect.paramChanged(p.rect.right, true);
+
+    }
+    if (!p.rect.width.isProvided())
+    {
+        p.rect.width.set(default_rect.getWidth(), false);
+        p.rect.paramChanged(p.rect.width, true);
+    }
+    if (!p.rect.height.isProvided())
+    {
+        p.rect.height.set(default_rect.getHeight(), false);
+        p.rect.paramChanged(p.rect.height, true);
+    }
 }
 
 static S32 invert_vertical(S32 y, LLView* parent)
 {
-	if (y < 0)
-	{
-		// already based on top-left, just invert
-		return -y;
-	}
-	else if (parent)
-	{
-		// use parent to flip coordinate
-		S32 parent_height = parent->getRect().getHeight();
-		return parent_height - y;
-	}
-	else
-	{
-		LL_WARNS() << "Attempting to convert layout to top-left with no parent" << LL_ENDL;
-		return y;
-	}
+    if (y < 0)
+    {
+        // already based on top-left, just invert
+        return -y;
+    }
+    else if (parent)
+    {
+        // use parent to flip coordinate
+        S32 parent_height = parent->getRect().getHeight();
+        return parent_height - y;
+    }
+    else
+    {
+        LL_WARNS() << "Attempting to convert layout to top-left with no parent" << LL_ENDL;
+        return y;
+    }
 }
 
 // Assumes that input is in bottom-left coordinates, hence must call
 // _before_ convert_coords_to_top_left().
 static void convert_to_relative_layout(LLView::Params& p, LLView* parent)
 {
-	// Use setupParams to get the final widget rectangle
-	// according to our wacky layout rules.
-	LLView::Params final = p;
-	LLView::applyXUILayout(final, parent);
-	// Must actually extract the rectangle to get consistent
-	// right = left+width, top = bottom+height
-	LLRect final_rect = final.rect;
-
-	// We prefer to write out top edge instead of bottom, regardless
-	// of whether we use relative positioning
-	bool converted_top = false;
-
-	// Look for a last rectangle
-	LLRect last_rect;
-	if (get_last_child_rect(parent, &last_rect))
-	{
-		// ...we have a previous widget to compare to
-		const S32 EDGE_THRESHOLD_PIXELS = 4;
-		S32 left_pad = final_rect.mLeft - last_rect.mRight;
-		S32 left_delta = final_rect.mLeft - last_rect.mLeft;
-		S32 top_pad = final_rect.mTop - last_rect.mBottom;
-		S32 top_delta = final_rect.mTop - last_rect.mTop;
-		// If my left edge is almost the same, or my top edge is
-		// almost the same...
-		if (llabs(left_delta) <= EDGE_THRESHOLD_PIXELS
-			|| llabs(top_delta) <= EDGE_THRESHOLD_PIXELS)
-		{
-			// ...use relative positioning
-			// prefer top_pad if widgets are stacking vertically
-			// (coordinate system is still bottom-left here)
-			if (top_pad < 0)
-			{
-				p.top_pad = top_pad;
-				p.top_delta.setProvided(false);
-			}
-			else
-			{
-				p.top_pad.setProvided(false);
-				p.top_delta = top_delta;
-			}
-			// null out other vertical specifiers
-			p.rect.top.setProvided(false);
-			p.rect.bottom.setProvided(false);
-			p.bottom_delta.setProvided(false);
-			converted_top = true;
-
-			// prefer left_pad if widgets are stacking horizontally
-			if (left_pad > 0)
-			{
-				p.left_pad = left_pad;
-				p.left_delta.setProvided(false);
-			}
-			else
-			{
-				p.left_pad.setProvided(false);
-				p.left_delta = left_delta;
-			}
-			p.rect.left.setProvided(false);
-			p.rect.right.setProvided(false);
-		}
-	}
-
-	if (!converted_top)
-	{
-		// ...this is the first widget, or one that wasn't aligned
-		// prefer top/left specification
-		p.rect.top = final_rect.mTop;
-		p.rect.bottom.setProvided(false);
-		p.bottom_delta.setProvided(false);
-		p.top_pad.setProvided(false);
-		p.top_delta.setProvided(false);
-	}
+    // Use setupParams to get the final widget rectangle
+    // according to our wacky layout rules.
+    LLView::Params final = p;
+    LLView::applyXUILayout(final, parent);
+    // Must actually extract the rectangle to get consistent
+    // right = left+width, top = bottom+height
+    LLRect final_rect = final.rect;
+
+    // We prefer to write out top edge instead of bottom, regardless
+    // of whether we use relative positioning
+    bool converted_top = false;
+
+    // Look for a last rectangle
+    LLRect last_rect;
+    if (get_last_child_rect(parent, &last_rect))
+    {
+        // ...we have a previous widget to compare to
+        const S32 EDGE_THRESHOLD_PIXELS = 4;
+        S32 left_pad = final_rect.mLeft - last_rect.mRight;
+        S32 left_delta = final_rect.mLeft - last_rect.mLeft;
+        S32 top_pad = final_rect.mTop - last_rect.mBottom;
+        S32 top_delta = final_rect.mTop - last_rect.mTop;
+        // If my left edge is almost the same, or my top edge is
+        // almost the same...
+        if (llabs(left_delta) <= EDGE_THRESHOLD_PIXELS
+            || llabs(top_delta) <= EDGE_THRESHOLD_PIXELS)
+        {
+            // ...use relative positioning
+            // prefer top_pad if widgets are stacking vertically
+            // (coordinate system is still bottom-left here)
+            if (top_pad < 0)
+            {
+                p.top_pad = top_pad;
+                p.top_delta.setProvided(false);
+            }
+            else
+            {
+                p.top_pad.setProvided(false);
+                p.top_delta = top_delta;
+            }
+            // null out other vertical specifiers
+            p.rect.top.setProvided(false);
+            p.rect.bottom.setProvided(false);
+            p.bottom_delta.setProvided(false);
+            converted_top = true;
+
+            // prefer left_pad if widgets are stacking horizontally
+            if (left_pad > 0)
+            {
+                p.left_pad = left_pad;
+                p.left_delta.setProvided(false);
+            }
+            else
+            {
+                p.left_pad.setProvided(false);
+                p.left_delta = left_delta;
+            }
+            p.rect.left.setProvided(false);
+            p.rect.right.setProvided(false);
+        }
+    }
+
+    if (!converted_top)
+    {
+        // ...this is the first widget, or one that wasn't aligned
+        // prefer top/left specification
+        p.rect.top = final_rect.mTop;
+        p.rect.bottom.setProvided(false);
+        p.bottom_delta.setProvided(false);
+        p.top_pad.setProvided(false);
+        p.top_delta.setProvided(false);
+    }
 }
 
 static void convert_coords_to_top_left(LLView::Params& p, LLView* parent)
 {
-	// Convert the coordinate system to be top-left based.
-	if (p.rect.top.isProvided())
-	{
-		p.rect.top = invert_vertical(p.rect.top, parent);
-	}
-	if (p.rect.bottom.isProvided())
-	{
-		p.rect.bottom = invert_vertical(p.rect.bottom, parent);
-	}
-	if (p.top_pad.isProvided())
-	{
-		p.top_pad = -p.top_pad;
-	}
-	if (p.top_delta.isProvided())
-	{
-		p.top_delta = -p.top_delta;
-	}
-	if (p.bottom_delta.isProvided())
-	{
-		p.bottom_delta = -p.bottom_delta;
-	}
-	p.layout = "topleft";
+    // Convert the coordinate system to be top-left based.
+    if (p.rect.top.isProvided())
+    {
+        p.rect.top = invert_vertical(p.rect.top, parent);
+    }
+    if (p.rect.bottom.isProvided())
+    {
+        p.rect.bottom = invert_vertical(p.rect.bottom, parent);
+    }
+    if (p.top_pad.isProvided())
+    {
+        p.top_pad = -p.top_pad;
+    }
+    if (p.top_delta.isProvided())
+    {
+        p.top_delta = -p.top_delta;
+    }
+    if (p.bottom_delta.isProvided())
+    {
+        p.bottom_delta = -p.bottom_delta;
+    }
+    p.layout = "topleft";
 }
 
 //static
 void LLView::setupParamsForExport(Params& p, LLView* parent)
 {
-	// Don't convert if already top-left based
-	if (p.layout() == "topleft") 
-	{
-		return;
-	}
-
-	// heuristic:  Many of our floaters and panels were bulk-exported.
-	// These specify exactly bottom/left and height/width.
-	// Others were done by hand using bottom_delta and/or left_delta.
-	// Some rely on not specifying left to mean align with left edge.
-	// Try to convert both to use relative layout, but using top-left
-	// coordinates.
-	// Avoid rectangles where top/bottom/left/right was specified.
-	if (p.rect.height.isProvided() && p.rect.width.isProvided())
-	{
-		if (p.rect.bottom.isProvided() && p.rect.left.isProvided())
-		{
-			// standard bulk export, convert it
-			convert_to_relative_layout(p, parent);
-		}
-		else if (p.rect.bottom.isProvided() && p.left_delta.isProvided())
-		{
-			// hand layout with left_delta
-			convert_to_relative_layout(p, parent);
-		}
-		else if (p.bottom_delta.isProvided())
-		{
-			// hand layout with bottom_delta
-			// don't check for p.rect.left or p.left_delta because sometimes
-			// this layout doesn't set it for widgets that are left-aligned
-			convert_to_relative_layout(p, parent);
-		}
-	}
-
-	convert_coords_to_top_left(p, parent);
-}
-
-LLView::tree_iterator_t LLView::beginTreeDFS() 
-{ 
-	return tree_iterator_t(this, 
-							boost::bind(boost::mem_fn(&LLView::beginChild), _1), 
-							boost::bind(boost::mem_fn(&LLView::endChild), _1)); 
-}
-
-LLView::tree_iterator_t LLView::endTreeDFS() 
-{ 
-	// an empty iterator is an "end" iterator
-	return tree_iterator_t();
-}
-
-LLView::tree_post_iterator_t LLView::beginTreeDFSPost() 
-{ 
-	return tree_post_iterator_t(this, 
-							boost::bind(boost::mem_fn(&LLView::beginChild), _1), 
-							boost::bind(boost::mem_fn(&LLView::endChild), _1)); 
-}
-
-LLView::tree_post_iterator_t LLView::endTreeDFSPost() 
-{ 
-	// an empty iterator is an "end" iterator
-	return tree_post_iterator_t();
-}
-
-LLView::bfs_tree_iterator_t LLView::beginTreeBFS() 
-{ 
-	return bfs_tree_iterator_t(this, 
-							boost::bind(boost::mem_fn(&LLView::beginChild), _1), 
-							boost::bind(boost::mem_fn(&LLView::endChild), _1)); 
-}
-
-LLView::bfs_tree_iterator_t LLView::endTreeBFS() 
-{ 
-	// an empty iterator is an "end" iterator
-	return bfs_tree_iterator_t();
+    // Don't convert if already top-left based
+    if (p.layout() == "topleft")
+    {
+        return;
+    }
+
+    // heuristic:  Many of our floaters and panels were bulk-exported.
+    // These specify exactly bottom/left and height/width.
+    // Others were done by hand using bottom_delta and/or left_delta.
+    // Some rely on not specifying left to mean align with left edge.
+    // Try to convert both to use relative layout, but using top-left
+    // coordinates.
+    // Avoid rectangles where top/bottom/left/right was specified.
+    if (p.rect.height.isProvided() && p.rect.width.isProvided())
+    {
+        if (p.rect.bottom.isProvided() && p.rect.left.isProvided())
+        {
+            // standard bulk export, convert it
+            convert_to_relative_layout(p, parent);
+        }
+        else if (p.rect.bottom.isProvided() && p.left_delta.isProvided())
+        {
+            // hand layout with left_delta
+            convert_to_relative_layout(p, parent);
+        }
+        else if (p.bottom_delta.isProvided())
+        {
+            // hand layout with bottom_delta
+            // don't check for p.rect.left or p.left_delta because sometimes
+            // this layout doesn't set it for widgets that are left-aligned
+            convert_to_relative_layout(p, parent);
+        }
+    }
+
+    convert_coords_to_top_left(p, parent);
+}
+
+LLView::tree_iterator_t LLView::beginTreeDFS()
+{
+    return tree_iterator_t(this,
+                            boost::bind(boost::mem_fn(&LLView::beginChild), _1),
+                            boost::bind(boost::mem_fn(&LLView::endChild), _1));
+}
+
+LLView::tree_iterator_t LLView::endTreeDFS()
+{
+    // an empty iterator is an "end" iterator
+    return tree_iterator_t();
+}
+
+LLView::tree_post_iterator_t LLView::beginTreeDFSPost()
+{
+    return tree_post_iterator_t(this,
+                            boost::bind(boost::mem_fn(&LLView::beginChild), _1),
+                            boost::bind(boost::mem_fn(&LLView::endChild), _1));
+}
+
+LLView::tree_post_iterator_t LLView::endTreeDFSPost()
+{
+    // an empty iterator is an "end" iterator
+    return tree_post_iterator_t();
+}
+
+LLView::bfs_tree_iterator_t LLView::beginTreeBFS()
+{
+    return bfs_tree_iterator_t(this,
+                            boost::bind(boost::mem_fn(&LLView::beginChild), _1),
+                            boost::bind(boost::mem_fn(&LLView::endChild), _1));
+}
+
+LLView::bfs_tree_iterator_t LLView::endTreeBFS()
+{
+    // an empty iterator is an "end" iterator
+    return bfs_tree_iterator_t();
 }
 
 
 LLView::root_to_view_iterator_t LLView::beginRootToView()
 {
-	return root_to_view_iterator_t(this, boost::bind(&LLView::getParent, _1));
+    return root_to_view_iterator_t(this, boost::bind(&LLView::getParent, _1));
 }
 
 LLView::root_to_view_iterator_t LLView::endRootToView()
 {
-	return root_to_view_iterator_t();
+    return root_to_view_iterator_t();
 }
 
 
@@ -2789,66 +2789,66 @@ LLView::root_to_view_iterator_t LLView::endRootToView()
 // when a view is constructed/deconstructed
 LLView& LLView::getDefaultWidgetContainer() const
 {
-	if (!mDefaultWidgets)
-	{
-		LLView::Params p;
-		p.name = "default widget container";
-		p.visible = false; // ensures default widgets can't steal focus, etc.
-		mDefaultWidgets = new LLView(p);
-	}
-	return *mDefaultWidgets;
+    if (!mDefaultWidgets)
+    {
+        LLView::Params p;
+        p.name = "default widget container";
+        p.visible = false; // ensures default widgets can't steal focus, etc.
+        mDefaultWidgets = new LLView(p);
+    }
+    return *mDefaultWidgets;
 }
 
-S32	LLView::notifyParent(const LLSD& info)
+S32 LLView::notifyParent(const LLSD& info)
 {
-	LLView* parent = getParent();
-	if(parent)
-		return parent->notifyParent(info);
-	return 0;
+    LLView* parent = getParent();
+    if(parent)
+        return parent->notifyParent(info);
+    return 0;
 }
-bool	LLView::notifyChildren(const LLSD& info)
+bool    LLView::notifyChildren(const LLSD& info)
 {
-	bool ret = false;
-	for (LLView* childp : mChildList)
-	{
-		ret = ret || childp->notifyChildren(info);
-	}
-	return ret;
+    bool ret = false;
+    for (LLView* childp : mChildList)
+    {
+        ret = ret || childp->notifyChildren(info);
+    }
+    return ret;
 }
 
 // convenient accessor for draw context
 const LLViewDrawContext& LLView::getDrawContext()
 {
-	return LLViewDrawContext::getCurrentContext();
+    return LLViewDrawContext::getCurrentContext();
 }
 
 const LLViewDrawContext& LLViewDrawContext::getCurrentContext()
 {
-	static LLViewDrawContext default_context;
+    static LLViewDrawContext default_context;
+
+    if (sDrawContextStack.empty())
+        return default_context;
 
-	if (sDrawContextStack.empty())
-		return default_context;
-		
-	return *sDrawContextStack.back();
+    return *sDrawContextStack.back();
 }
 
 LLSD LLView::getInfo(void)
 {
-	LLSD info;
-	addInfo(info);
-	return info;
+    LLSD info;
+    addInfo(info);
+    return info;
 }
 
 void LLView::addInfo(LLSD & info)
 {
-	info["path"] = getPathname();
-	info["class"] = typeid(*this).name();
-	info["visible"] = getVisible();
-	info["visible_chain"] = isInVisibleChain();
-	info["enabled"] = getEnabled();
-	info["enabled_chain"] = isInEnabledChain();
-	info["available"] = isAvailable();
-	LLRect rect(calcScreenRect());
-	info["rect"] = LLSDMap("left", rect.mLeft)("top", rect.mTop)
-				("right", rect.mRight)("bottom", rect.mBottom);
+    info["path"] = getPathname();
+    info["class"] = typeid(*this).name();
+    info["visible"] = getVisible();
+    info["visible_chain"] = isInVisibleChain();
+    info["enabled"] = getEnabled();
+    info["enabled_chain"] = isInEnabledChain();
+    info["available"] = isAvailable();
+    LLRect rect(calcScreenRect());
+    info["rect"] = LLSDMap("left", rect.mLeft)("top", rect.mTop)
+                ("right", rect.mRight)("bottom", rect.mBottom);
 }