Merge branch 'DRTVWR-559' into DRTVWR-592

38 files changed, 866 insertions, 485 deletions

diff --git a/indra/llui/llaccordionctrl.cpp b/indra/llui/llaccordionctrl.cpp
index 809d72208f..0a82bed896 100644
--- a/indra/llui/llaccordionctrl.cpp
+++ b/indra/llui/llaccordionctrl.cpp
@@ -60,7 +60,7 @@ LLAccordionCtrl::LLAccordionCtrl(const Params& params):LLPanel(params)
 	initNoTabsWidget(params.no_matched_tabs_text);
 
 	mSingleExpansion = params.single_expansion;
-	if(mFitParent && !mSingleExpansion)
+	if (mFitParent && !mSingleExpansion)
 	{
 		LL_INFOS() << "fit_parent works best when combined with single_expansion" << LL_ENDL;
 	}
@@ -102,14 +102,13 @@ void LLAccordionCtrl::draw()
 	LLPanel::draw();
 }
 
-
 //---------------------------------------------------------------------------------
 BOOL LLAccordionCtrl::postBuild()
 {
-	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+	static LLUICachedControl<S32> scrollbar_size("UIScrollbarSize", 0);
 
 	LLRect scroll_rect;
-	scroll_rect.setOriginAndSize( 
+	scroll_rect.setOriginAndSize(
 		getRect().getWidth() - scrollbar_size,
 		1,
 		scrollbar_size,
@@ -126,39 +125,42 @@ BOOL LLAccordionCtrl::postBuild()
 	sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
 	sbparams.change_callback(boost::bind(&LLAccordionCtrl::onScrollPosChangeCallback, this, _1, _2));
 	
-	mScrollbar = LLUICtrlFactory::create<LLScrollbar> (sbparams);
-	LLView::addChild( mScrollbar );
-	mScrollbar->setVisible( false );
+	mScrollbar = LLUICtrlFactory::create<LLScrollbar>(sbparams);
+	LLView::addChild(mScrollbar);
+	mScrollbar->setVisible(FALSE);
 	mScrollbar->setFollowsRight();
 	mScrollbar->setFollowsTop();
 	mScrollbar->setFollowsBottom();
 
 	//if it was created from xml...
 	std::vector<LLUICtrl*> accordion_tabs;
-	for(child_list_const_iter_t it = getChildList()->begin(); 
+	for (child_list_const_iter_t it = getChildList()->begin(); 
 		getChildList()->end() != it; ++it)
 	{
 		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(*it);
-		if(accordion_tab == NULL)
+		if (accordion_tab == NULL)
 			continue;
-		if(std::find(mAccordionTabs.begin(),mAccordionTabs.end(),accordion_tab) == mAccordionTabs.end())
+		if (std::find(mAccordionTabs.begin(), mAccordionTabs.end(), accordion_tab) == mAccordionTabs.end())
 		{
 			accordion_tabs.push_back(accordion_tab);
 		}
 	}
 
-	for(std::vector<LLUICtrl*>::reverse_iterator it = accordion_tabs.rbegin();it!=accordion_tabs.rend();++it)
+	for (std::vector<LLUICtrl*>::reverse_iterator it = accordion_tabs.rbegin();
+		it < accordion_tabs.rend(); ++it)
+	{
 		addCollapsibleCtrl(*it);
+	}
 
-	arrange	();
+	arrange();
 
-	if(mSingleExpansion)
+	if (mSingleExpansion)
 	{
-		if(!mAccordionTabs[0]->getDisplayChildren())
+		if (!mAccordionTabs[0]->getDisplayChildren())
 			mAccordionTabs[0]->setDisplayChildren(true);
-		for(size_t i=1;i<mAccordionTabs.size();++i)
+		for (size_t i = 1; i < mAccordionTabs.size(); ++i)
 		{
-			if(mAccordionTabs[i]->getDisplayChildren())
+			if (mAccordionTabs[i]->getDisplayChildren())
 				mAccordionTabs[i]->setDisplayChildren(false);
 		}
 	}
@@ -205,23 +207,22 @@ BOOL LLAccordionCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
 //---------------------------------------------------------------------------------
 void LLAccordionCtrl::shiftAccordionTabs(S16 panel_num, S32 delta)
 {
-	for(size_t i = panel_num; i < mAccordionTabs.size(); i++ )
+	for (size_t i = panel_num; i < mAccordionTabs.size(); ++i)
 	{
 		ctrlShiftVertical(mAccordionTabs[i],delta);
 	}	
 }
 
-
 //---------------------------------------------------------------------------------
 void LLAccordionCtrl::onCollapseCtrlCloseOpen(S16 panel_num) 
 {
-	if(mSingleExpansion)
+	if (mSingleExpansion)
 	{
-		for(size_t i=0;i<mAccordionTabs.size();++i)
+		for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 		{
-			if(i==panel_num)
+			if (i == panel_num)
 				continue;
-			if(mAccordionTabs[i]->getDisplayChildren())
+			if (mAccordionTabs[i]->getDisplayChildren())
 				mAccordionTabs[i]->setDisplayChildren(false);
 		}
 
@@ -232,64 +233,63 @@ void LLAccordionCtrl::onCollapseCtrlCloseOpen(S16 panel_num)
 void LLAccordionCtrl::show_hide_scrollbar(S32 width, S32 height)
 {
 	calcRecuiredHeight();
-	if(getRecuiredHeight() > height )
-		showScrollbar(width,height);
+	if (getRecuiredHeight() > height)
+		showScrollbar(width, height);
 	else
-		hideScrollbar(width,height);
+		hideScrollbar(width, height);
 }
 
-void	LLAccordionCtrl::showScrollbar(S32 width, S32 height)
+void LLAccordionCtrl::showScrollbar(S32 width, S32 height)
 {
 	bool was_visible = mScrollbar->getVisible();
 
-	mScrollbar->setVisible(true);
+	mScrollbar->setVisible(TRUE);
 	
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 
 	ctrlSetLeftTopAndSize(mScrollbar
-		,width-scrollbar_size - PARENT_BORDER_MARGIN/2
-		,height-PARENT_BORDER_MARGIN
-		,scrollbar_size
-		,height-2*PARENT_BORDER_MARGIN);
+		, width - scrollbar_size - PARENT_BORDER_MARGIN / 2
+		, height - PARENT_BORDER_MARGIN
+		, scrollbar_size
+		, height - PARENT_BORDER_MARGIN * 2);
 	
 	mScrollbar->setPageSize(height);
-	mScrollbar->setDocParams(mInnerRect.getHeight(),mScrollbar->getDocPos());
+	mScrollbar->setDocParams(mInnerRect.getHeight(), mScrollbar->getDocPos());
 
-	if(was_visible)
+	if (was_visible)
 	{
 		S32 scroll_pos = llmin(mScrollbar->getDocPos(), getRecuiredHeight() - height - 1);
 		mScrollbar->setDocPos(scroll_pos);
 	}
 }
 
-void	LLAccordionCtrl::hideScrollbar( S32 width, S32 height )
+void LLAccordionCtrl::hideScrollbar(S32 width, S32 height)
 {
-	if(mScrollbar->getVisible() == false)
+	if (mScrollbar->getVisible() == FALSE)
 		return;
-	mScrollbar->setVisible(false);
+	mScrollbar->setVisible(FALSE);
 
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 
 	S32 panel_width = width - 2*BORDER_MARGIN;
 
-	//reshape all accordeons and shift all draggers
-	for(size_t i=0;i<mAccordionTabs.size();++i)
+	// Reshape all accordions and shift all draggers
+	for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 	{
 		LLRect panel_rect = mAccordionTabs[i]->getRect();
-		ctrlSetLeftTopAndSize(mAccordionTabs[i],panel_rect.mLeft,panel_rect.mTop,panel_width,panel_rect.getHeight());
+		ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_rect.mLeft, panel_rect.mTop, panel_width, panel_rect.getHeight());
 	}
 
 	mScrollbar->setDocPos(0);
 
-	if(mAccordionTabs.size()>0)
+	if (!mAccordionTabs.empty())
 	{
-		S32 panel_top = height - BORDER_MARGIN;		  // Top coordinate of the first panel
+		S32 panel_top = height - BORDER_MARGIN; // Top coordinate of the first panel
 		S32 diff = panel_top - mAccordionTabs[0]->getRect().mTop;
-		shiftAccordionTabs(0,diff);
+		shiftAccordionTabs(0, diff);
 	}
 }
 
-
 //---------------------------------------------------------------------------------
 S32 LLAccordionCtrl::calcRecuiredHeight()
 {
@@ -305,7 +305,7 @@ S32 LLAccordionCtrl::calcRecuiredHeight()
 		}
 	}
 
-	mInnerRect.setLeftTopAndSize(0,rec_height + BORDER_MARGIN*2,getRect().getWidth(),rec_height + BORDER_MARGIN);
+	mInnerRect.setLeftTopAndSize(0, rec_height + BORDER_MARGIN * 2, getRect().getWidth(), rec_height + BORDER_MARGIN);
 
 	return mInnerRect.getHeight();
 }
@@ -313,7 +313,7 @@ S32 LLAccordionCtrl::calcRecuiredHeight()
 //---------------------------------------------------------------------------------
 void LLAccordionCtrl::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S32 width, S32 height)
 {
-	if(!panel)
+	if (!panel)
 		return;
 	LLRect panel_rect = panel->getRect();
 	panel_rect.setLeftTopAndSize( left, top, width, height);
@@ -321,9 +321,9 @@ void LLAccordionCtrl::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S3
 	panel->setRect(panel_rect);
 }
 
-void LLAccordionCtrl::ctrlShiftVertical(LLView* panel,S32 delta)
+void LLAccordionCtrl::ctrlShiftVertical(LLView* panel, S32 delta)
 {
-	if(!panel)
+	if (!panel)
 		return;
 	panel->translate(0,delta);
 }
@@ -333,9 +333,9 @@ void LLAccordionCtrl::ctrlShiftVertical(LLView* panel,S32 delta)
 void LLAccordionCtrl::addCollapsibleCtrl(LLView* view)
 {
 	LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(view);
-	if(!accordion_tab)
+	if (!accordion_tab)
 		return;
-	if(std::find(beginChild(), endChild(), accordion_tab) == endChild())
+	if (std::find(beginChild(), endChild(), accordion_tab) == endChild())
 		addChild(accordion_tab);
 	mAccordionTabs.push_back(accordion_tab);
 
@@ -369,7 +369,7 @@ void LLAccordionCtrl::removeCollapsibleCtrl(LLView* view)
 	}
 }
 
-void	LLAccordionCtrl::initNoTabsWidget(const LLTextBox::Params& tb_params)
+void LLAccordionCtrl::initNoTabsWidget(const LLTextBox::Params& tb_params)
 {
 	LLTextBox::Params tp = tb_params;
 	tp.rect(getLocalRect());
@@ -377,39 +377,39 @@ void	LLAccordionCtrl::initNoTabsWidget(const LLTextBox::Params& tb_params)
 	mNoVisibleTabsHelpText = LLUICtrlFactory::create<LLTextBox>(tp, this);
 }
 
-void	LLAccordionCtrl::updateNoTabsHelpTextVisibility()
+void LLAccordionCtrl::updateNoTabsHelpTextVisibility()
 {
 	bool visible_exists = false;
 	std::vector<LLAccordionCtrlTab*>::const_iterator it = mAccordionTabs.begin();
 	const std::vector<LLAccordionCtrlTab*>::const_iterator it_end = mAccordionTabs.end();
-	for (; it != it_end; ++it)
+	while (it < it_end)
 	{
-		if ((*it)->getVisible())
+		if ((*(it++))->getVisible())
 		{
 			visible_exists = true;
 			break;
 		}
 	}
 
-	mNoVisibleTabsHelpText->setVisible(!visible_exists);
+	mNoVisibleTabsHelpText->setVisible(visible_exists ? FALSE : TRUE);
 }
 
-void	LLAccordionCtrl::arrangeSinge()
+void LLAccordionCtrl::arrangeSingle()
 {
-	S32 panel_left = BORDER_MARGIN;	  // Margin from left side of Splitter
-	S32 panel_top = getRect().getHeight() - BORDER_MARGIN;		  // Top coordinate of the first panel
-	S32 panel_width = getRect().getWidth() - 4;		  // Top coordinate of the first panel
+	S32 panel_left = BORDER_MARGIN; // Margin from left side of Splitter
+	S32 panel_top = getRect().getHeight() - BORDER_MARGIN; // Top coordinate of the first panel
+	S32 panel_width = getRect().getWidth() - 4;
 	S32 panel_height;
 
 	S32 collapsed_height = 0;
 
-	for(size_t i=0;i<mAccordionTabs.size();++i)
+	for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 	{
 		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
 		
-		if(accordion_tab->getVisible() == false) //skip hidden accordion tabs
+		if (accordion_tab->getVisible() == FALSE) // Skip hidden accordion tabs
 			continue;
-		if(!accordion_tab->isExpanded() )
+		if (!accordion_tab->isExpanded() )
 		{
 			collapsed_height+=mAccordionTabs[i]->getRect().getHeight();
 		}
@@ -417,28 +417,28 @@ void	LLAccordionCtrl::arrangeSinge()
 
 	S32 expanded_height = getRect().getHeight() - BORDER_MARGIN - collapsed_height;
 	
-	for(size_t i=0;i<mAccordionTabs.size();++i)
+	for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 	{
 		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
 		
-		if(accordion_tab->getVisible() == false) //skip hidden accordion tabs
+		if (accordion_tab->getVisible() == FALSE) // Skip hidden accordion tabs
 			continue;
-		if(!accordion_tab->isExpanded() )
+		if (!accordion_tab->isExpanded() )
 		{
 			panel_height = accordion_tab->getRect().getHeight();
 		}
 		else
 		{
-			if(mFitParent)
+			if (mFitParent)
 			{
 				panel_height = expanded_height;
 			}
 			else
 			{
-				if(accordion_tab->getAccordionView())
+				if (accordion_tab->getAccordionView())
 				{
 					panel_height = accordion_tab->getAccordionView()->getRect().getHeight() + 
-						accordion_tab->getHeaderHeight() + 2*BORDER_MARGIN;
+						accordion_tab->getHeaderHeight() + BORDER_MARGIN * 2;
 				}
 				else
 				{
@@ -451,67 +451,67 @@ void	LLAccordionCtrl::arrangeSinge()
 		panel_height = llmax(panel_height, accordion_tab->getHeaderHeight());
 
 		ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, panel_height);
-		panel_top-=mAccordionTabs[i]->getRect().getHeight();
+		panel_top -= mAccordionTabs[i]->getRect().getHeight();
 	}
 
 	show_hide_scrollbar(getRect().getWidth(), getRect().getHeight());
 	updateLayout(getRect().getWidth(), getRect().getHeight());
 }
 
-void	LLAccordionCtrl::arrangeMultiple()
+void LLAccordionCtrl::arrangeMultiple()
 {
-	S32 panel_left = BORDER_MARGIN;	  // Margin from left side of Splitter
-	S32 panel_top = getRect().getHeight() - BORDER_MARGIN;		  // Top coordinate of the first panel
-	S32 panel_width = getRect().getWidth() - 4;		  // Top coordinate of the first panel
+	S32 panel_left = BORDER_MARGIN; // Margin from left side of Splitter
+	S32 panel_top = getRect().getHeight() - BORDER_MARGIN; // Top coordinate of the first panel
+	S32 panel_width = getRect().getWidth() - 4;
 
 	//Calculate params	
-	for(size_t i = 0; i < mAccordionTabs.size(); i++ )
+	for (size_t i = 0; i < mAccordionTabs.size(); i++ )
 	{
 		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
 		
-		if(accordion_tab->getVisible() == false) //skip hidden accordion tabs
+		if (accordion_tab->getVisible() == FALSE) // Skip hidden accordion tabs
 			continue;
 		
-		if(!accordion_tab->isExpanded() )
+		if (!accordion_tab->isExpanded() )
 		{
 			ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, accordion_tab->getRect().getHeight());
-			panel_top-=mAccordionTabs[i]->getRect().getHeight();
+			panel_top -= mAccordionTabs[i]->getRect().getHeight();
 		}
 		else
 		{
 			S32 panel_height = accordion_tab->getRect().getHeight();
 			
-			if(mFitParent)
+			if (mFitParent)
 			{
-				// all expanded tabs will have equal height
+				// All expanded tabs will have equal height
 				panel_height = calcExpandedTabHeight(i, panel_top);
 				ctrlSetLeftTopAndSize(accordion_tab, panel_left, panel_top, panel_width, panel_height);
 
-				// try to make accordion tab fit accordion view height.
+				// Try to make accordion tab fit accordion view height.
 				// Accordion View should implement getRequiredRect() and provide valid height
 				S32 optimal_height = accordion_tab->getAccordionView()->getRequiredRect().getHeight();
 				optimal_height += accordion_tab->getHeaderHeight() + 2 * BORDER_MARGIN;
-				if(optimal_height < panel_height)
+				if (optimal_height < panel_height)
 				{
 					panel_height = optimal_height;
 				}
 
 				// minimum tab height is equal to header height
-				if(mAccordionTabs[i]->getHeaderHeight() > panel_height)
+				if (mAccordionTabs[i]->getHeaderHeight() > panel_height)
 				{
 					panel_height = mAccordionTabs[i]->getHeaderHeight();
 				}
 			}
 			
 			ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, panel_height);
-			panel_top-=panel_height;
+			panel_top -= panel_height;
 			
 		}
 	}	
 
-	show_hide_scrollbar(getRect().getWidth(),getRect().getHeight());
+	show_hide_scrollbar(getRect().getWidth(), getRect().getHeight());
 
-	updateLayout(getRect().getWidth(),getRect().getHeight());
+	updateLayout(getRect().getWidth(), getRect().getHeight());
 }
 
 
@@ -519,70 +519,67 @@ void LLAccordionCtrl::arrange()
 {
 	updateNoTabsHelpTextVisibility();
 
-	if( mAccordionTabs.size() == 0)
+	if (mAccordionTabs.empty())
 	{
-		//We do not arrange if we do not have what should be arranged
+		// Nothing to arrange
 		return;
 	}
 
-
-	if(mAccordionTabs.size() == 1)
+	if (mAccordionTabs.size() == 1)
 	{
-		S32 panel_top = getRect().getHeight() - BORDER_MARGIN;		  // Top coordinate of the first panel
-		S32 panel_width = getRect().getWidth() - 4;		  // Top coordinate of the first panel
+		S32 panel_top = getRect().getHeight() - BORDER_MARGIN; // Top coordinate of the first panel
+		S32 panel_width = getRect().getWidth() - 4;
 		
 		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[0]);
 		
 		LLRect panel_rect = accordion_tab->getRect();
 		
-		S32 panel_height = getRect().getHeight() - 2*BORDER_MARGIN;
-
+		S32 panel_height = getRect().getHeight() - BORDER_MARGIN * 2;
 		if (accordion_tab->getFitParent())
 			panel_height = accordion_tab->getRect().getHeight();
-		ctrlSetLeftTopAndSize(accordion_tab,panel_rect.mLeft,panel_top,panel_width,panel_height);
+
+		ctrlSetLeftTopAndSize(accordion_tab, panel_rect.mLeft, panel_top, panel_width, panel_height);
 		
-		show_hide_scrollbar(getRect().getWidth(),getRect().getHeight());
+		show_hide_scrollbar(getRect().getWidth(), getRect().getHeight());
 		return;
-
 	}
 
-	if(mSingleExpansion)
-		arrangeSinge ();
+	if (mSingleExpansion)
+		arrangeSingle();
 	else
-		arrangeMultiple ();
+		arrangeMultiple();
 }
 
 //---------------------------------------------------------------------------------
 
-BOOL LLAccordionCtrl::handleScrollWheel		( S32 x, S32 y, S32 clicks )
+BOOL LLAccordionCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	if(LLPanel::handleScrollWheel(x,y,clicks))
+	if (LLPanel::handleScrollWheel(x, y, clicks))
 		return TRUE;
-	if( mScrollbar->getVisible() && mScrollbar->handleScrollWheel( 0, 0, clicks ) )
+	if (mScrollbar->getVisible() && mScrollbar->handleScrollWheel(0, 0, clicks))
 		return TRUE;
-	return false;
-
+	return FALSE;
 }
 
-BOOL LLAccordionCtrl::handleKeyHere			(KEY key, MASK mask)
+BOOL LLAccordionCtrl::handleKeyHere(KEY key, MASK mask)
 {
-	if( mScrollbar->getVisible() && mScrollbar->handleKeyHere( key,mask ) )
+	if (mScrollbar->getVisible() && mScrollbar->handleKeyHere(key, mask))
 		return TRUE;
-	return LLPanel::handleKeyHere(key,mask);
+	return LLPanel::handleKeyHere(key, mask);
 }
 
-BOOL LLAccordionCtrl::handleDragAndDrop		(S32 x, S32 y, MASK mask,
-											 BOOL drop,
-											 EDragAndDropType cargo_type,
-											 void* cargo_data,
-											 EAcceptance* accept,
-											 std::string& tooltip_msg)
+BOOL LLAccordionCtrl::handleDragAndDrop(S32 x, S32 y, MASK mask,
+										BOOL drop,
+										EDragAndDropType cargo_type,
+										void* cargo_data,
+										EAcceptance* accept,
+										std::string& tooltip_msg)
 {
 	// Scroll folder view if needed.  Never accepts a drag or drop.
 	*accept = ACCEPT_NO;
 	BOOL handled = autoScroll(x, y);
 
-	if( !handled )
+	if (!handled)
 	{
 		handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
 											cargo_data, accept, tooltip_msg) != NULL;
@@ -590,14 +587,14 @@ BOOL LLAccordionCtrl::handleDragAndDrop		(S32 x, S32 y, MASK mask,
 	return TRUE;
 }
 
-BOOL LLAccordionCtrl::autoScroll		(S32 x, S32 y)
+BOOL LLAccordionCtrl::autoScroll(S32 x, S32 y)
 {
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 
 	bool scrolling = false;
-	if( mScrollbar->getVisible() )
+	if (mScrollbar->getVisible())
 	{
-		LLRect rect_local( 0, getRect().getHeight(), getRect().getWidth() - scrollbar_size, 0 );
+		LLRect rect_local(0, getRect().getHeight(), getRect().getWidth() - scrollbar_size, 0);
 		LLRect screen_local_extents;
 
 		// clip rect against root view
@@ -610,51 +607,52 @@ BOOL LLAccordionCtrl::autoScroll		(S32 x, S32 y)
 
 		LLRect bottom_scroll_rect = screen_local_extents;
 		bottom_scroll_rect.mTop = rect_local.mBottom + auto_scroll_region_height;
-		if( bottom_scroll_rect.pointInRect( x, y ) && (mScrollbar->getDocPos() < mScrollbar->getDocPosMax()) )
+		if (bottom_scroll_rect.pointInRect( x, y ) && (mScrollbar->getDocPos() < mScrollbar->getDocPosMax()))
 		{
-			mScrollbar->setDocPos( mScrollbar->getDocPos() + auto_scroll_speed );
+			mScrollbar->setDocPos(mScrollbar->getDocPos() + auto_scroll_speed);
 			mAutoScrolling = true;
 			scrolling = true;
 		}
 
 		LLRect top_scroll_rect = screen_local_extents;
 		top_scroll_rect.mBottom = rect_local.mTop - auto_scroll_region_height;
-		if( top_scroll_rect.pointInRect( x, y ) && (mScrollbar->getDocPos() > 0) )
+		if (top_scroll_rect.pointInRect(x, y) && (mScrollbar->getDocPos() > 0))
 		{
-			mScrollbar->setDocPos( mScrollbar->getDocPos() - auto_scroll_speed );
+			mScrollbar->setDocPos(mScrollbar->getDocPos() - auto_scroll_speed);
 			mAutoScrolling = true;
 			scrolling = true;
 		}
 	}
-	return scrolling;
+
+	return scrolling ? TRUE : FALSE;
 }
 
-void	LLAccordionCtrl::updateLayout	(S32 width, S32 height)
+void LLAccordionCtrl::updateLayout(S32 width, S32 height)
 {
 	S32 panel_top = height - BORDER_MARGIN ;
-	if(mScrollbar->getVisible())
-		panel_top+=mScrollbar->getDocPos();
+	if (mScrollbar->getVisible())
+		panel_top += mScrollbar->getDocPos();
 
-	S32 panel_width = width - 2*BORDER_MARGIN;
+	S32 panel_width = width - BORDER_MARGIN * 2;
 
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
-	if(mScrollbar->getVisible())
-		panel_width-=scrollbar_size;
+	if (mScrollbar->getVisible())
+		panel_width -= scrollbar_size;
 
-	//set sizes for first panels and dragbars
-	for(size_t i=0;i<mAccordionTabs.size();++i)
+	// set sizes for first panels and dragbars
+	for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 	{
-		if(!mAccordionTabs[i]->getVisible())
+		if (!mAccordionTabs[i]->getVisible())
 			continue;
 		LLRect panel_rect = mAccordionTabs[i]->getRect();
-		ctrlSetLeftTopAndSize(mAccordionTabs[i],panel_rect.mLeft,panel_top,panel_width,panel_rect.getHeight());
-		panel_top-=panel_rect.getHeight();
+		ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_rect.mLeft, panel_top, panel_width, panel_rect.getHeight());
+		panel_top -= panel_rect.getHeight();
 	}
 }
 
-void	LLAccordionCtrl::onScrollPosChangeCallback(S32, LLScrollbar*)
+void LLAccordionCtrl::onScrollPosChangeCallback(S32, LLScrollbar*)
 {
-	updateLayout(getRect().getWidth(),getRect().getHeight());
+	updateLayout(getRect().getWidth(), getRect().getHeight());
 }
 
 // virtual
@@ -687,42 +685,43 @@ void LLAccordionCtrl::onUpdateScrollToChild(const LLUICtrl *cntrl)
     LLUICtrl::onUpdateScrollToChild(cntrl);
 }
 
-void	LLAccordionCtrl::onOpen		(const LLSD& key)
+void LLAccordionCtrl::onOpen(const LLSD& key)
 {
-	for(size_t i=0;i<mAccordionTabs.size();++i)
+	for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 	{
 		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
 		LLPanel* panel = dynamic_cast<LLPanel*>(accordion_tab->getAccordionView());
-		if(panel!=NULL)
+		if (panel != NULL)
 		{
 			panel->onOpen(key);
 		}
 	}
 }
+
 S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 {
-	if(info.has("action"))
+	if (info.has("action"))
 	{
 		std::string str_action = info["action"];
-		if(str_action == "size_changes")
+		if (str_action == "size_changes")
 		{
 			//
 			arrange();
 			return 1;
 		}
-		else if(str_action == "select_next")
+		if (str_action == "select_next")
 		{
-			for(size_t i=0;i<mAccordionTabs.size();++i)
+			for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 			{
 				LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
-				if(accordion_tab->hasFocus())
+				if (accordion_tab->hasFocus())
 				{
-					while(++i<mAccordionTabs.size())
+					while (++i < mAccordionTabs.size())
 					{
-						if(mAccordionTabs[i]->getVisible())
+						if (mAccordionTabs[i]->getVisible())
 							break;
 					}
-					if(i<mAccordionTabs.size())
+					if (i < mAccordionTabs.size())
 					{
 						accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
 						accordion_tab->notify(LLSD().with("action","select_first"));
@@ -733,17 +732,17 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 			}
 			return 0;
 		}
-		else if(str_action == "select_prev")
+		if (str_action == "select_prev")
 		{
-			for(size_t i=0;i<mAccordionTabs.size();++i)
+			for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 			{
 				LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
-				if(accordion_tab->hasFocus() && i>0)
+				if (accordion_tab->hasFocus() && i > 0)
 				{
 					bool prev_visible_tab_found = false;
-					while(i>0)
+					while (i > 0)
 					{
-						if(mAccordionTabs[--i]->getVisible())
+						if (mAccordionTabs[--i]->getVisible())
 						{
 							prev_visible_tab_found = true;
 							break;
@@ -761,12 +760,12 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 			}
 			return 0;
 		}
-		else if(str_action == "select_current")
+		if (str_action == "select_current")
 		{
-			for(size_t i=0;i<mAccordionTabs.size();++i)
+			for (size_t i = 0; i < mAccordionTabs.size(); ++i)
 			{
 				// Set selection to the currently focused tab.
-				if(mAccordionTabs[i]->hasFocus())
+				if (mAccordionTabs[i]->hasFocus())
 				{
 					if (mAccordionTabs[i] != mSelectedTab)
 					{
@@ -783,7 +782,7 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 			}
 			return 0;
 		}
-		else if(str_action == "deselect_current")
+		if (str_action == "deselect_current")
 		{
 			// Reset selection to the currently selected tab.
 			if (mSelectedTab)
@@ -802,9 +801,9 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 		screenRectToLocal(screen_rc, &local_rc);
 
 		// Translate to parent coordinatess to check if we are in visible rectangle
-		local_rc.translate( getRect().mLeft, getRect().mBottom );
+		local_rc.translate(getRect().mLeft, getRect().mBottom);
 
-		if ( !getRect().contains (local_rc) )
+		if (!getRect().contains (local_rc))
 		{
 			// Back to local coords and calculate position for scroller
 			S32 bottom = mScrollbar->getDocPos() - local_rc.mBottom + getRect().mBottom;
@@ -814,7 +813,7 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 									 bottom, // min vertical scroll
 									 top); // max vertical scroll 
 
-			mScrollbar->setDocPos( scroll_pos );
+			mScrollbar->setDocPos(scroll_pos);
 		}
 		return 1;
 	}
@@ -834,15 +833,16 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 	}
 	return LLPanel::notifyParent(info);
 }
-void	LLAccordionCtrl::reset		()
+
+void LLAccordionCtrl::reset()
 {
-	if(mScrollbar)
+	if (mScrollbar)
 		mScrollbar->setDocPos(0);
 }
 
 void LLAccordionCtrl::expandDefaultTab()
 {
-	if (mAccordionTabs.size() > 0)
+	if (!mAccordionTabs.empty())
 	{
 		LLAccordionCtrlTab* tab = mAccordionTabs.front();
 
@@ -877,7 +877,7 @@ void LLAccordionCtrl::sort()
 	arrange();
 }
 
-void	LLAccordionCtrl::setFilterSubString(const std::string& filter_string)
+void LLAccordionCtrl::setFilterSubString(const std::string& filter_string)
 {
 	LLStringUtil::format_map_t args;
 	args["[SEARCH_TERM]"] = LLURI::escape(filter_string);
@@ -907,7 +907,7 @@ const LLAccordionCtrlTab* LLAccordionCtrl::getExpandedTab() const
 
 S32 LLAccordionCtrl::calcExpandedTabHeight(S32 tab_index /* = 0 */, S32 available_height /* = 0 */)
 {
-	if(tab_index < 0)
+	if (tab_index < 0)
 	{
 		return available_height;
 	}
@@ -915,9 +915,9 @@ S32 LLAccordionCtrl::calcExpandedTabHeight(S32 tab_index /* = 0 */, S32 availabl
 	S32 collapsed_tabs_height = 0;
 	S32 num_expanded = 0;
 
-	for(size_t n = tab_index; n < mAccordionTabs.size(); ++n)
+	for (size_t n = tab_index; n < mAccordionTabs.size(); ++n)
 	{
-		if(!mAccordionTabs[n]->isExpanded())
+		if (!mAccordionTabs[n]->isExpanded())
 		{
 			collapsed_tabs_height += mAccordionTabs[n]->getHeaderHeight();
 		}
@@ -927,7 +927,7 @@ S32 LLAccordionCtrl::calcExpandedTabHeight(S32 tab_index /* = 0 */, S32 availabl
 		}
 	}
 
-	if(0 == num_expanded)
+	if (0 == num_expanded)
 	{
 		return available_height;
 	}
diff --git a/indra/llui/llaccordionctrl.h b/indra/llui/llaccordionctrl.h
index 2828254472..6a1989afba 100644
--- a/indra/llui/llaccordionctrl.h
+++ b/indra/llui/llaccordionctrl.h
@@ -144,7 +144,7 @@ private:
 	void	initNoTabsWidget(const LLTextBox::Params& tb_params);
 	void	updateNoTabsHelpTextVisibility();
 
-	void	arrangeSinge();
+	void	arrangeSingle();
 	void	arrangeMultiple();
 
 	// Calc Splitter's height that is necessary to display all child content
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
index 04485c6262..20da568746 100644
--- a/indra/llui/llaccordionctrltab.cpp
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -69,13 +69,13 @@ public:
 	virtual BOOL postBuild();
 
 	std::string getTitle();
-	void	setTitle(const std::string& title, const std::string& hl);
+	void setTitle(const std::string& title, const std::string& hl);
 
-	void	setTitleFontStyle(std::string style);
+	void setTitleFontStyle(std::string style);
 
-	void	setTitleColor(LLUIColor);
+	void setTitleColor(LLUIColor);
 
-	void	setSelected(bool is_selected) { mIsSelected = is_selected; }
+	void setSelected(bool is_selected) { mIsSelected = is_selected; }
 
 	virtual void onMouseEnter(S32 x, S32 y, MASK mask);
 	virtual void onMouseLeave(S32 x, S32 y, MASK mask);
@@ -85,8 +85,8 @@ public:
 								   void* cargo_data,
 								   EAcceptance* accept,
 								   std::string& tooltip_msg);
-private:
 
+private:
 	LLTextBox* mHeaderTextbox;
 
 	// Overlay images (arrows)
@@ -102,7 +102,7 @@ private:
 	LLPointer<LLUIImage> mImageHeaderFocused;
 
 	// style saved when applying it in setTitleFontStyle
-	LLStyle::Params			mStyleParams;
+	LLStyle::Params mStyleParams;
 
 	LLUIColor mHeaderBGColor;
 
@@ -157,19 +157,17 @@ BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::postBuild()
 
 std::string LLAccordionCtrlTab::LLAccordionCtrlTabHeader::getTitle()
 {
-	if(mHeaderTextbox)
+	if (mHeaderTextbox)
 	{
 		return mHeaderTextbox->getText();
 	}
-	else
-	{
-		return LLStringUtil::null;
-	}
+
+	return LLStringUtil::null;
 }
 
 void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::setTitle(const std::string& title, const std::string& hl)
 {
-	if(mHeaderTextbox)
+	if (mHeaderTextbox)
 	{
 		LLTextUtil::textboxSetHighlightedVal(
 			mHeaderTextbox,
@@ -192,7 +190,7 @@ void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::setTitleFontStyle(std::string
 
 void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::setTitleColor(LLUIColor color)
 {
-	if(mHeaderTextbox)
+	if (mHeaderTextbox)
 	{
 		mHeaderTextbox->setColor(color);
 	}
@@ -204,11 +202,11 @@ void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::draw()
 	S32 height = getRect().getHeight();
 
 	F32 alpha = getCurrentTransparency();
-	gl_rect_2d(0,0,width - 1 ,height - 1,mHeaderBGColor.get() % alpha,true);
+	gl_rect_2d(0, 0, width - 1, height - 1, mHeaderBGColor.get() % alpha, TRUE);
 
 	LLAccordionCtrlTab* parent = dynamic_cast<LLAccordionCtrlTab*>(getParent());
-	bool collapsible = (parent && parent->getCollapsible());
-	bool expanded = (parent && parent->getDisplayChildren());
+	bool collapsible = parent && parent->getCollapsible();
+	bool expanded = parent && parent->getDisplayChildren();
 
 	// Handle overlay images, if needed
 	// Only show green "focus" background image if the accordion is open,
@@ -218,23 +216,22 @@ void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::draw()
 		/*&& !(collapsible && !expanded)*/ // WHY??
 		)
 	{
-		mImageHeaderFocused->draw(0,0,width,height);
+		mImageHeaderFocused->draw(0, 0, width, height);
 	}
 	else
 	{
-		mImageHeader->draw(0,0,width,height);
+		mImageHeader->draw(0, 0, width, height);
 	}
 
-	if(mNeedsHighlight)
+	if (mNeedsHighlight)
 	{
-		mImageHeaderOver->draw(0,0,width,height);
+		mImageHeaderOver->draw(0, 0, width, height);
 	}
-	
 
-	if(collapsible)
+	if (collapsible)
 	{
 		LLPointer<LLUIImage> overlay_image;
-		if(expanded)
+		if (expanded)
 		{
 			overlay_image = mImageExpanded;
 		}
@@ -242,8 +239,7 @@ void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::draw()
 		{
 			overlay_image = mImageCollapsed;
 		}
-		overlay_image->draw(HEADER_IMAGE_LEFT_OFFSET,
-							(height - overlay_image->getHeight()) / 2);
+		overlay_image->draw(HEADER_IMAGE_LEFT_OFFSET, (height - overlay_image->getHeight()) / 2);
 	}
 	
 	LLUICtrl::draw();
@@ -253,7 +249,7 @@ void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::reshape(S32 width, S32 height
 {
 	S32 header_height = mHeaderTextbox->getTextPixelHeight();
 
-	LLRect textboxRect(HEADER_TEXT_LEFT_OFFSET,(height+header_height)/2 ,width,(height-header_height)/2);
+	LLRect textboxRect(HEADER_TEXT_LEFT_OFFSET, (height + header_height) / 2, width, (height - header_height) / 2);
 	mHeaderTextbox->reshape(textboxRect.getWidth(), textboxRect.getHeight());
 	mHeaderTextbox->setRect(textboxRect);
 
@@ -272,20 +268,24 @@ void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::onMouseEnter(S32 x, S32 y, MA
 	LLUICtrl::onMouseEnter(x, y, mask);
 	mNeedsHighlight = true;
 }
+
 void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::onMouseLeave(S32 x, S32 y, MASK mask)
 {
 	LLUICtrl::onMouseLeave(x, y, mask);
 	mNeedsHighlight = false;
 	mAutoOpenTimer.stop();
 }
+
 BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 {
-	if ( ( key == KEY_LEFT || key == KEY_RIGHT) && mask == MASK_NONE)
+	if ((key == KEY_LEFT || key == KEY_RIGHT) && mask == MASK_NONE)
 	{
 		return getParent()->handleKey(key, mask, called_from_parent);
 	}
+
 	return LLUICtrl::handleKey(key, mask, called_from_parent);
 }
+
 BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::handleDragAndDrop(S32 x, S32 y, MASK mask,
 																	 BOOL drop,
 																	 EDragAndDropType cargo_type,
@@ -295,7 +295,7 @@ BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::handleDragAndDrop(S32 x, S32
 {
 	LLAccordionCtrlTab* parent = dynamic_cast<LLAccordionCtrlTab*>(getParent());
 
-	if ( parent && !parent->getDisplayChildren() && parent->getCollapsible() && parent->canOpenClose() )
+	if (parent && !parent->getDisplayChildren() && parent->getCollapsible() && parent->canOpenClose())
 	{
 		if (mAutoOpenTimer.getStarted())
 		{
@@ -307,12 +307,15 @@ BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::handleDragAndDrop(S32 x, S32
 			}
 		}
 		else
+		{
 			mAutoOpenTimer.start();
+		}
 	}
 
 	return LLUICtrl::handleDragAndDrop(x, y, mask, drop, cargo_type,
 									   cargo_data, accept, tooltip_msg);
 }
+
 LLAccordionCtrlTab::Params::Params()
 	: title("title")
 	,display_children("expanded", true)
@@ -384,41 +387,39 @@ LLAccordionCtrlTab::~LLAccordionCtrlTab()
 {
 }
 
-
 void LLAccordionCtrlTab::setDisplayChildren(bool display)
 {
 	mDisplayChildren = display;
 	LLRect rect = getRect();
 
-	rect.mBottom = rect.mTop - (getDisplayChildren() ? 
-		mExpandedHeight : HEADER_HEIGHT);
+	rect.mBottom = rect.mTop - (getDisplayChildren() ? mExpandedHeight : HEADER_HEIGHT);
 	setRect(rect);
 
-	if(mContainerPanel)
+	if (mContainerPanel)
+	{
 		mContainerPanel->setVisible(getDisplayChildren());
+	}
 
-	if(mDisplayChildren)
+	if (mDisplayChildren)
 	{
 		adjustContainerPanel();
 	}
 	else
 	{
-		if(mScrollbar)
-			mScrollbar->setVisible(false);
+		if (mScrollbar)
+			mScrollbar->setVisible(FALSE);
 	}
-
 }
 
 void LLAccordionCtrlTab::reshape(S32 width, S32 height, BOOL called_from_parent /* = TRUE */)
 {
 	LLRect headerRect;
 
-	headerRect.setLeftTopAndSize(
-		0,height,width,HEADER_HEIGHT);
+	headerRect.setLeftTopAndSize(0, height, width, HEADER_HEIGHT);
 	mHeader->setRect(headerRect);
 	mHeader->reshape(headerRect.getWidth(), headerRect.getHeight());
 
-	if(!mDisplayChildren)
+	if (!mDisplayChildren)
 		return;
 
 	LLRect childRect;
@@ -426,7 +427,7 @@ void LLAccordionCtrlTab::reshape(S32 width, S32 height, BOOL called_from_parent
 	childRect.setLeftTopAndSize(
 		getPaddingLeft(),
 		height - getHeaderHeight() - getPaddingTop(),
-		width - getPaddingLeft() - getPaddingRight(), 
+		width - getPaddingLeft() - getPaddingRight(),
 		height - getHeaderHeight() - getPaddingTop() - getPaddingBottom() );
 
 	adjustContainerPanel(childRect);
@@ -434,7 +435,7 @@ void LLAccordionCtrlTab::reshape(S32 width, S32 height, BOOL called_from_parent
 
 void LLAccordionCtrlTab::changeOpenClose(bool is_open)
 {
-	if(is_open)
+	if (is_open)
 		mExpandedHeight = getRect().getHeight();
 
 	setDisplayChildren(!is_open);
@@ -483,14 +484,14 @@ void LLAccordionCtrlTab::onUpdateScrollToChild(const LLUICtrl *cntrl)
 
 BOOL LLAccordionCtrlTab::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	if(mCollapsible && mHeaderVisible && mCanOpenClose)
+	if (mCollapsible && mHeaderVisible && mCanOpenClose)
 	{
-		if(y >= (getRect().getHeight() - HEADER_HEIGHT) )
+		if (y >= (getRect().getHeight() - HEADER_HEIGHT))
 		{
 			mHeader->setFocus(true);
 			changeOpenClose(getDisplayChildren());
 
-			//reset stored state
+			// Reset stored state
 			mWasStateStored = false;
 			return TRUE;
 		}
@@ -510,7 +511,7 @@ boost::signals2::connection LLAccordionCtrlTab::setDropDownStateChangedCallback(
 
 bool LLAccordionCtrlTab::addChild(LLView* child, S32 tab_group)
 {
-	if(DD_HEADER_NAME != child->getName())
+	if (DD_HEADER_NAME != child->getName())
 	{
 		reshape(child->getRect().getWidth() , child->getRect().getHeight() + HEADER_HEIGHT );
 		mExpandedHeight = getRect().getHeight();
@@ -518,12 +519,12 @@ bool LLAccordionCtrlTab::addChild(LLView* child, S32 tab_group)
 
 	bool res = LLUICtrl::addChild(child, tab_group);
 
-	if(DD_HEADER_NAME != child->getName())
+	if (DD_HEADER_NAME != child->getName())
 	{
-		if(!mCollapsible)
+		if (!mCollapsible)
 			setDisplayChildren(true);
 		else
-			setDisplayChildren(getDisplayChildren());	
+			setDisplayChildren(getDisplayChildren());
 	}
 
 	if (!mContainerPanel)
@@ -534,7 +535,7 @@ bool LLAccordionCtrlTab::addChild(LLView* child, S32 tab_group)
 
 void LLAccordionCtrlTab::setAccordionView(LLView* panel)
 {
-	addChild(panel,0);
+	addChild(panel, 0);
 }
 
 std::string LLAccordionCtrlTab::getTitle() const
@@ -543,10 +544,8 @@ std::string LLAccordionCtrlTab::getTitle() const
 	{
 		return mHeader->getTitle();
 	}
-	else
-	{
-		return LLStringUtil::null;
-	}
+
+	return LLStringUtil::null;
 }
 
 void LLAccordionCtrlTab::setTitle(const std::string& title, const std::string& hl)
@@ -579,6 +578,7 @@ boost::signals2::connection LLAccordionCtrlTab::setFocusReceivedCallback(const f
 	{
 		return mHeader->setFocusReceivedCallback(cb);
 	}
+
 	return boost::signals2::connection();
 }
 
@@ -588,6 +588,7 @@ boost::signals2::connection LLAccordionCtrlTab::setFocusLostCallback(const focus
 	{
 		return mHeader->setFocusLostCallback(cb);
 	}
+
 	return boost::signals2::connection();
 }
 
@@ -601,59 +602,65 @@ void LLAccordionCtrlTab::setSelected(bool is_selected)
 
 LLView*	LLAccordionCtrlTab::findContainerView()
 {
-	for(child_list_const_iter_t it = getChildList()->begin(); 
-		getChildList()->end() != it; ++it)
+	child_list_const_iter_t it = getChildList()->begin(), it_end = getChildList()->end();
+	while (it != it_end)
 	{
-		LLView* child = *it;
-		if(DD_HEADER_NAME == child->getName())
-			continue;
-		if(!child->getVisible())
-			continue;
-		return child;
+		LLView* child = *(it++);
+		if (DD_HEADER_NAME != child->getName() && child->getVisible())
+			return child;
 	}
+
 	return NULL;
 }
 
 void LLAccordionCtrlTab::selectOnFocusReceived()
 {
 	if (getParent()) // A parent may not be set if tabs are added dynamically.
+	{
 		getParent()->notifyParent(LLSD().with("action", "select_current"));
+	}
 }
 
 void LLAccordionCtrlTab::deselectOnFocusLost()
 {
-	if(getParent()) // A parent may not be set if tabs are added dynamically.
+	if (getParent()) // A parent may not be set if tabs are added dynamically.
 	{
 		getParent()->notifyParent(LLSD().with("action", "deselect_current"));
 	}
-
 }
 
 S32 LLAccordionCtrlTab::getHeaderHeight()
 {
-	return mHeaderVisible?HEADER_HEIGHT:0; 
+	return mHeaderVisible ? HEADER_HEIGHT : 0;
 }
 
-void LLAccordionCtrlTab::setHeaderVisible(bool value) 
+void LLAccordionCtrlTab::setHeaderVisible(bool value)
 {
-	if(mHeaderVisible == value)
+	if (mHeaderVisible == value)
 		return;
+
 	mHeaderVisible = value;
-	if(mHeader)
-		mHeader->setVisible(value);
+
+	if (mHeader)
+	{
+		mHeader->setVisible(value ? TRUE : FALSE);
+	}
+
 	reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
 };
 
 //virtual
 BOOL LLAccordionCtrlTab::postBuild()
 {
-	if(mHeader)
+	if (mHeader)
+	{
 		mHeader->setVisible(mHeaderVisible);
-	
-	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+	}
+
+	static LLUICachedControl<S32> scrollbar_size("UIScrollbarSize", 0);
 
 	LLRect scroll_rect;
-	scroll_rect.setOriginAndSize( 
+	scroll_rect.setOriginAndSize(
 		getRect().getWidth() - scrollbar_size,
 		1,
 		scrollbar_size,
@@ -661,7 +668,7 @@ BOOL LLAccordionCtrlTab::postBuild()
 
 	mContainerPanel = findContainerView();
 
-	if(!mFitPanel)
+	if (!mFitPanel)
 	{
 		LLScrollbar::Params sbparams;
 		sbparams.name("scrollable vertical");
@@ -674,9 +681,8 @@ BOOL LLAccordionCtrlTab::postBuild()
 		sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
 		sbparams.change_callback(boost::bind(&LLAccordionCtrlTab::onScrollPosChangeCallback, this, _1, _2));
 
-
-		mScrollbar = LLUICtrlFactory::create<LLScrollbar> (sbparams);
-		LLView::addChild( mScrollbar );
+		mScrollbar = LLUICtrlFactory::create<LLScrollbar>(sbparams);
+		LLView::addChild(mScrollbar);
 		mScrollbar->setFollowsRight();
 		mScrollbar->setFollowsTop();
 		mScrollbar->setFollowsBottom();
@@ -684,44 +690,48 @@ BOOL LLAccordionCtrlTab::postBuild()
 		mScrollbar->setVisible(false);
 	}
 
-	if(mContainerPanel)
+	if (mContainerPanel)
+	{
 		mContainerPanel->setVisible(mDisplayChildren);
+	}
 
 	return LLUICtrl::postBuild();
 }
-bool	LLAccordionCtrlTab::notifyChildren	(const LLSD& info)
+
+bool LLAccordionCtrlTab::notifyChildren	(const LLSD& info)
 {
-	if(info.has("action"))
+	if (info.has("action"))
 	{
 		std::string str_action = info["action"];
-		if(str_action == "store_state")
+		if (str_action == "store_state")
 		{
 			storeOpenCloseState();
 			return true;
 		}
-		if(str_action == "restore_state")
+
+		if (str_action == "restore_state")
 		{
 			restoreOpenCloseState();
 			return true;
 		}
 	}	
+
 	return LLUICtrl::notifyChildren(info);
 }
 
 S32	LLAccordionCtrlTab::notifyParent(const LLSD& info)
 {
-	if(info.has("action"))
+	if (info.has("action"))
 	{
 		std::string str_action = info["action"];
-		if(str_action == "size_changes")
+		if (str_action == "size_changes")
 		{
-			//
 			S32 height = info["height"];
-			height = llmax(height,10) + HEADER_HEIGHT + getPaddingTop() + getPaddingBottom();
+			height = llmax(height, 10) + HEADER_HEIGHT + getPaddingTop() + getPaddingBottom();
 			
 			mExpandedHeight = height;
 			
-			if(isExpanded() && !mSkipChangesOnNotifyParent)
+			if (isExpanded() && !mSkipChangesOnNotifyParent)
 			{
 				LLRect panel_rect = getRect();
 				panel_rect.setLeftTopAndSize( panel_rect.mLeft, panel_rect.mTop, panel_rect.getWidth(), height);
@@ -729,12 +739,13 @@ S32	LLAccordionCtrlTab::notifyParent(const LLSD& info)
 				setRect(panel_rect);
 			}
 			
-			//LLAccordionCtrl should rearrange accordion tab if one of accordion change its size
+			// LLAccordionCtrl should rearrange accordion tab if one of accordions changed its size
 			if (getParent()) // A parent may not be set if tabs are added dynamically.
 				getParent()->notifyParent(info);
 			return 1;
 		}
-		else if(str_action == "select_prev") 
+
+		if (str_action == "select_prev") 
 		{
 			showAndFocusHeader();
 			return 1;
@@ -772,78 +783,85 @@ S32	LLAccordionCtrlTab::notifyParent(const LLSD& info)
 
 S32 LLAccordionCtrlTab::notify(const LLSD& info)
 {
-	if(info.has("action"))
+	if (info.has("action"))
 	{
 		std::string str_action = info["action"];
-		if(str_action == "select_first")
+		if (str_action == "select_first")
 		{
 			showAndFocusHeader();
 			return 1;
 		}
-		else if( str_action == "select_last" )
+
+		if (str_action == "select_last")
 		{
-			if(getDisplayChildren() == false)
+			if (!getDisplayChildren())
 			{
 				showAndFocusHeader();
 			}
 			else
 			{
 				LLView* view = getAccordionView();
-				if(view)
-					view->notify(LLSD().with("action","select_last"));
+				if (view)
+				{
+					view->notify(LLSD().with("action", "select_last"));
+				}
 			}
 		}
 	}
+
 	return 0;
 }
 
 BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 {
-	if( !mHeader->hasFocus() )
+	if (!mHeader->hasFocus())
 		return LLUICtrl::handleKey(key, mask, called_from_parent);
 
-	if ( (key == KEY_RETURN )&& mask == MASK_NONE)
+	if ((key == KEY_RETURN) && mask == MASK_NONE)
 	{
 		changeOpenClose(getDisplayChildren());
 		return TRUE;
 	}
 
-	if ( (key == KEY_ADD || key == KEY_RIGHT)&& mask == MASK_NONE)
+	if ((key == KEY_ADD || key == KEY_RIGHT) && mask == MASK_NONE)
 	{
-		if(getDisplayChildren() == false)
+		if (!getDisplayChildren())
 		{
 			changeOpenClose(getDisplayChildren());
 			return TRUE;
 		}
 	}
-	if ( (key == KEY_SUBTRACT || key == KEY_LEFT)&& mask == MASK_NONE)
+
+	if ((key == KEY_SUBTRACT || key == KEY_LEFT) && mask == MASK_NONE)
 	{
-		if(getDisplayChildren() == true)
+		if (getDisplayChildren())
 		{
 			changeOpenClose(getDisplayChildren());
 			return TRUE;
 		}
 	}
 
-	if ( key == KEY_DOWN && mask == MASK_NONE)
+	if (key == KEY_DOWN && mask == MASK_NONE)
 	{
-		//if collapsed go to the next accordion
-		if(getDisplayChildren() == false)
-			//we processing notifyParent so let call parent directly
-			getParent()->notifyParent(LLSD().with("action","select_next"));
+		// if collapsed go to the next accordion
+		if (!getDisplayChildren())
+		{
+			// we're processing notifyParent so let call parent directly
+			getParent()->notifyParent(LLSD().with("action", "select_next"));
+		}
 		else
 		{
-			getAccordionView()->notify(LLSD().with("action","select_first"));
+			getAccordionView()->notify(LLSD().with("action", "select_first"));
 		}
 		return TRUE;
 	}
 
-	if ( key == KEY_UP && mask == MASK_NONE)
+	if (key == KEY_UP && mask == MASK_NONE)
 	{
-		//go to the previous accordion
+		// go to the previous accordion
 
-		//we processing notifyParent so let call parent directly
-		getParent()->notifyParent(LLSD().with("action","select_prev"));
+		// we're processing notifyParent so let call parent directly
+		getParent()->notifyParent(LLSD().with("action", "select_prev"));
 		return TRUE;
 	}
 
@@ -869,28 +887,29 @@ void LLAccordionCtrlTab::showAndFocusHeader()
 	// accordion tab (assuming that the parent is an LLAccordionCtrl) the calls chain
 	// is shortened and messages from inside the collapsed tabs are avoided.
 	// See STORM-536.
-	getParent()->notifyParent(LLSD().with("scrollToShowRect",screen_rc.getValue()));
+	getParent()->notifyParent(LLSD().with("scrollToShowRect", screen_rc.getValue()));
 }
-void    LLAccordionCtrlTab::storeOpenCloseState()
+
+void LLAccordionCtrlTab::storeOpenCloseState()
 {
-	if(mWasStateStored)
+	if (mWasStateStored)
 		return;
 	mStoredOpenCloseState = getDisplayChildren();
 	mWasStateStored = true;
 }
 
-void   LLAccordionCtrlTab::restoreOpenCloseState()
+void LLAccordionCtrlTab::restoreOpenCloseState()
 {
-	if(!mWasStateStored)
+	if (!mWasStateStored)
 		return;
-	if(getDisplayChildren() != mStoredOpenCloseState)
+	if (getDisplayChildren() != mStoredOpenCloseState)
 	{
 		changeOpenClose(getDisplayChildren());
 	}
 	mWasStateStored = false;
 }
 
-void LLAccordionCtrlTab::adjustContainerPanel	()
+void LLAccordionCtrlTab::adjustContainerPanel()
 {
 	S32 width = getRect().getWidth();
 	S32 height = getRect().getHeight();
@@ -907,83 +926,83 @@ void LLAccordionCtrlTab::adjustContainerPanel	()
 
 void LLAccordionCtrlTab::adjustContainerPanel(const LLRect& child_rect)
 {
-	if(!mContainerPanel)
+	if (!mContainerPanel)
 		return; 
 
-	if(!mFitPanel)
+	if (!mFitPanel)
 	{
 		show_hide_scrollbar(child_rect);
 		updateLayout(child_rect);
 	}
 	else
 	{
-		mContainerPanel->reshape(child_rect.getWidth(),child_rect.getHeight());
+		mContainerPanel->reshape(child_rect.getWidth(), child_rect.getHeight());
 		mContainerPanel->setRect(child_rect);
 	}
 }
 
 S32 LLAccordionCtrlTab::getChildViewHeight()
 {
-	if(!mContainerPanel)
+	if (!mContainerPanel)
 		return 0;
 	return mContainerPanel->getRect().getHeight();
 }
 
 void LLAccordionCtrlTab::show_hide_scrollbar(const LLRect& child_rect)
 {
-	if(getChildViewHeight() > child_rect.getHeight() )
+	if (getChildViewHeight() > child_rect.getHeight())
 		showScrollbar(child_rect);
 	else
 		hideScrollbar(child_rect);
 }
+
 void LLAccordionCtrlTab::showScrollbar(const LLRect& child_rect)
 {
-	if(!mContainerPanel || !mScrollbar)
+	if (!mContainerPanel || !mScrollbar)
 		return;
 	bool was_visible = mScrollbar->getVisible();
 	mScrollbar->setVisible(true);
 	
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 
-	{
-		ctrlSetLeftTopAndSize(mScrollbar,child_rect.getWidth()-scrollbar_size, 
-			child_rect.getHeight()-PARENT_BORDER_MARGIN, 
-			scrollbar_size, 
-			child_rect.getHeight()-2*PARENT_BORDER_MARGIN);
-	}
+	ctrlSetLeftTopAndSize(mScrollbar,
+		child_rect.getWidth() - scrollbar_size,
+		child_rect.getHeight() - PARENT_BORDER_MARGIN,
+		scrollbar_size, 
+		child_rect.getHeight() - PARENT_BORDER_MARGIN * 2);
 
 	LLRect orig_rect = mContainerPanel->getRect();
 
 	mScrollbar->setPageSize(child_rect.getHeight());
-	mScrollbar->setDocParams(orig_rect.getHeight(),mScrollbar->getDocPos());
+	mScrollbar->setDocParams(orig_rect.getHeight(), mScrollbar->getDocPos());
 	
-	if(was_visible)
+	if (was_visible)
 	{
 		S32 scroll_pos = llmin(mScrollbar->getDocPos(), orig_rect.getHeight() - child_rect.getHeight() - 1);
 		mScrollbar->setDocPos(scroll_pos);
 	}
-	else//shrink child panel
+	else // Shrink child panel
 	{
 		updateLayout(child_rect);
 	}
-	
 }
 
-void	LLAccordionCtrlTab::hideScrollbar( const LLRect& child_rect )
+void LLAccordionCtrlTab::hideScrollbar(const LLRect& child_rect)
 {
-	if(!mContainerPanel || !mScrollbar)
+	if (!mContainerPanel || !mScrollbar)
 		return;
 
-	if(mScrollbar->getVisible() == false)
+	if (mScrollbar->getVisible() == FALSE)
 		return;
-	mScrollbar->setVisible(false);
+
+	mScrollbar->setVisible(FALSE);
 	mScrollbar->setDocPos(0);
 
 	//shrink child panel
 	updateLayout(child_rect);
 }
 
-void	LLAccordionCtrlTab::onScrollPosChangeCallback(S32, LLScrollbar*)
+void LLAccordionCtrlTab::onScrollPosChangeCallback(S32, LLScrollbar*)
 {
 	LLRect child_rect;
 
@@ -999,21 +1018,20 @@ void	LLAccordionCtrlTab::onScrollPosChangeCallback(S32, LLScrollbar*)
 	updateLayout(child_rect);
 }
 
-void LLAccordionCtrlTab::drawChild(const LLRect& root_rect,LLView* child)
+void LLAccordionCtrlTab::drawChild(const LLRect& root_rect, LLView* child)
 {
 	if (child && child->getVisible() && child->getRect().isValid())
 	{
 		LLRect screen_rect;
-		localRectToScreen(child->getRect(),&screen_rect);
-		
-		if ( root_rect.overlaps(screen_rect)  && sDirtyRect.overlaps(screen_rect))
+		localRectToScreen(child->getRect(), &screen_rect);
+
+		if (root_rect.overlaps(screen_rect) && sDirtyRect.overlaps(screen_rect))
 		{
 			gGL.matrixMode(LLRender::MM_MODELVIEW);
 			LLUI::pushMatrix();
 			{
 				LLUI::translate((F32)child->getRect().mLeft, (F32)child->getRect().mBottom);
 				child->draw();
-
 			}
 			LLUI::popMatrix();
 		}
@@ -1022,64 +1040,67 @@ void LLAccordionCtrlTab::drawChild(const LLRect& root_rect,LLView* child)
 
 void LLAccordionCtrlTab::draw()
 {
-	if(mFitPanel)
+	if (mFitPanel)
+	{
 		LLUICtrl::draw();
+	}
 	else
 	{
-		LLRect root_rect = getRootView()->getRect();
-		drawChild(root_rect,mHeader);
-		drawChild(root_rect,mScrollbar );
-		{
-			LLRect child_rect;
+		LLRect root_rect(getRootView()->getRect());
+		drawChild(root_rect, mHeader);
+		drawChild(root_rect, mScrollbar);
 
-			S32 width = getRect().getWidth();
-			S32 height = getRect().getHeight();
+		LLRect child_rect;
 
-			child_rect.setLeftTopAndSize(
-				getPaddingLeft(),
-				height - getHeaderHeight() - getPaddingTop(),
-				width - getPaddingLeft() - getPaddingRight(), 
-				height - getHeaderHeight() - getPaddingTop() - getPaddingBottom() );
+		S32 width = getRect().getWidth();
+		S32 height = getRect().getHeight();
 
-			LLLocalClipRect clip(child_rect);
-			drawChild(root_rect,mContainerPanel);
-		}
+		child_rect.setLeftTopAndSize(
+			getPaddingLeft(),
+			height - getHeaderHeight() - getPaddingTop(),
+			width - getPaddingLeft() - getPaddingRight(),
+			height - getHeaderHeight() - getPaddingTop() - getPaddingBottom());
+
+		LLLocalClipRect clip(child_rect);
+		drawChild(root_rect,mContainerPanel);
 	}
 }
 
-void	LLAccordionCtrlTab::updateLayout	( const LLRect& child_rect )
+void LLAccordionCtrlTab::updateLayout(const LLRect& child_rect)
 {
 	LLView*	child = getAccordionView();
-	if(!mContainerPanel)
+	if (!mContainerPanel)
 		return;
 
 	S32 panel_top = child_rect.getHeight();
 	S32 panel_width = child_rect.getWidth();
 
-	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
-	if(mScrollbar && mScrollbar->getVisible() != false)
+	static LLUICachedControl<S32> scrollbar_size("UIScrollbarSize", 0);
+	if (mScrollbar && mScrollbar->getVisible())
 	{
-		panel_top+=mScrollbar->getDocPos();
-		panel_width-=scrollbar_size;
+		panel_top += mScrollbar->getDocPos();
+		panel_width -= scrollbar_size;
 	}
 
-	//set sizes for first panels and dragbars
+	// Set sizes for first panels and dragbars
 	LLRect panel_rect = child->getRect();
-	ctrlSetLeftTopAndSize(mContainerPanel,child_rect.mLeft,panel_top,panel_width,panel_rect.getHeight());
+	ctrlSetLeftTopAndSize(mContainerPanel, child_rect.mLeft, panel_top, panel_width, panel_rect.getHeight());
 }
+
 void LLAccordionCtrlTab::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S32 width, S32 height)
 {
-	if(!panel)
+	if (!panel)
 		return;
 	LLRect panel_rect = panel->getRect();
-	panel_rect.setLeftTopAndSize( left, top, width, height);
+	panel_rect.setLeftTopAndSize(left, top, width, height);
 	panel->reshape( width, height, 1);
 	panel->setRect(panel_rect);
 }
+
 BOOL LLAccordionCtrlTab::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	//header may be not the first child but we need to process it first
-	if(y >= (getRect().getHeight() - HEADER_HEIGHT - HEADER_HEIGHT/2) )
+	if (y >= (getRect().getHeight() - HEADER_HEIGHT - HEADER_HEIGHT / 2))
 	{
 		//inside tab header
 		//fix for EXT-6619
@@ -1088,16 +1109,18 @@ BOOL LLAccordionCtrlTab::handleToolTip(S32 x, S32 y, MASK mask)
 	}
 	return LLUICtrl::handleToolTip(x, y, mask);
 }
-BOOL LLAccordionCtrlTab::handleScrollWheel		( S32 x, S32 y, S32 clicks )
+
+BOOL LLAccordionCtrlTab::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	if( LLUICtrl::handleScrollWheel(x,y,clicks))
+	if (LLUICtrl::handleScrollWheel(x, y, clicks))
 	{
 		return TRUE;
 	}
-	if( mScrollbar && mScrollbar->getVisible() && mScrollbar->handleScrollWheel( 0, 0, clicks ) )
+
+	if (mScrollbar && mScrollbar->getVisible() && mScrollbar->handleScrollWheel(0, 0, clicks))
 	{
 		return TRUE;
 	}
+
 	return FALSE;
 }
-
diff --git a/indra/llui/llaccordionctrltab.h b/indra/llui/llaccordionctrltab.h
index 2c72e8c036..896a34cac4 100644
--- a/indra/llui/llaccordionctrltab.h
+++ b/indra/llui/llaccordionctrltab.h
@@ -104,7 +104,7 @@ public:
 	virtual void setDisplayChildren(bool display);
 
 	// Returns expand/collapse state
-	virtual bool getDisplayChildren() const {return mDisplayChildren;};
+	virtual bool getDisplayChildren() const { return mDisplayChildren; };
 
 	//set LLAccordionCtrlTab panel
 	void		setAccordionView(LLView* panel);
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 8028f397f3..49d275997a 100644
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -203,7 +203,8 @@ LLButton::LLButton(const LLButton::Params& p)
 	}
 
 	// Hack to make sure there is space for at least one character
-	if (getRect().getWidth() - (mRightHPad + mLeftHPad) < mGLFont->getWidth(std::string(" ")))
+	if (getRect().mRight >= 0 && getRect().getWidth() > 0 &&
+		getRect().getWidth() - (mRightHPad + mLeftHPad) < mGLFont->getWidth(std::string(" ")))
 	{
 		// Use old defaults
 		mLeftHPad = llbutton_orig_h_pad;
@@ -942,11 +943,8 @@ void LLButton::draw()
 			break;
 		}
 
-		S32 y_offset = 2 + (getRect().getHeight() - 20)/2;
-	
 		if (pressed && mDisplayPressedState)
 		{
-			y_offset--;
 			x++;
 		}
 
diff --git a/indra/llui/lldraghandle.cpp b/indra/llui/lldraghandle.cpp
index 48bf5bb80f..220f5ee825 100644
--- a/indra/llui/lldraghandle.cpp
+++ b/indra/llui/lldraghandle.cpp
@@ -68,6 +68,7 @@ LLDragHandle::LLDragHandle(const LLDragHandle::Params& p)
 
 LLDragHandle::~LLDragHandle()
 {
+    gFocusMgr.removeKeyboardFocusWithoutCallback(this);
 	removeChild(mTitleBox);
 	delete mTitleBox;
 }
diff --git a/indra/llui/llflatlistview.cpp b/indra/llui/llflatlistview.cpp
index b13e7389cc..460bd0945b 100644
--- a/indra/llui/llflatlistview.cpp
+++ b/indra/llui/llflatlistview.cpp
@@ -1198,7 +1198,7 @@ void LLFlatListView::onFocusReceived()
 {
 	if (size())
 	{
-	mSelectedItemsBorder->setVisible(TRUE);
+		mSelectedItemsBorder->setVisible(TRUE);
 	}
 	gEditMenuHandler = this;
 }
@@ -1207,7 +1207,7 @@ void LLFlatListView::onFocusLost()
 {
 	mSelectedItemsBorder->setVisible(FALSE);
 	// Route menu back to the default
- 	if( gEditMenuHandler == this )
+	if (gEditMenuHandler == this)
 	{
 		gEditMenuHandler = NULL;
 	}
@@ -1216,16 +1216,16 @@ void LLFlatListView::onFocusLost()
 //virtual 
 S32 LLFlatListView::notify(const LLSD& info)
 {
-	if(info.has("action"))
+	if (info.has("action"))
 	{
 		std::string str_action = info["action"];
-		if(str_action == "select_first")
+		if (str_action == "select_first")
 		{
 			setFocus(true);
 			selectFirstItem();
 			return 1;
 		}
-		else if(str_action == "select_last")
+		else if (str_action == "select_last")
 		{
 			setFocus(true);
 			selectLastItem();
@@ -1238,6 +1238,7 @@ S32 LLFlatListView::notify(const LLSD& info)
 		notifyParentItemsRectChanged();
 		return 1;
 	}
+
 	return 0;
 }
 
@@ -1249,10 +1250,8 @@ void LLFlatListView::detachItems(std::vector<LLPanel*>& detached_items)
 	detached_items.clear();
 	// Go through items and detach valid items, remove them from items panel
 	// and add to detached_items.
-	for (pairs_iterator_t
-			 iter = mItemPairs.begin(),
-			 iter_end = mItemPairs.end();
-		 iter != iter_end; ++iter)
+	pairs_iterator_t iter = mItemPairs.begin(), iter_end = mItemPairs.end();
+	while (iter != iter_end)
 	{
 		LLPanel* pItem = (*iter)->first;
 		if (1 == pItem->notify(action))
@@ -1261,6 +1260,7 @@ void LLFlatListView::detachItems(std::vector<LLPanel*>& detached_items)
 			mItemsPanel->removeChild(pItem);
 			detached_items.push_back(pItem);
 		}
+		iter++;
 	}
 	if (!detached_items.empty())
 	{
@@ -1268,13 +1268,12 @@ void LLFlatListView::detachItems(std::vector<LLPanel*>& detached_items)
 		if (detached_items.size() == mItemPairs.size())
 		{
 			// This way will be faster if all items were disconnected
-			for (pairs_iterator_t
-					 iter = mItemPairs.begin(),
-					 iter_end = mItemPairs.end();
-				 iter != iter_end; ++iter)
+			pairs_iterator_t iter = mItemPairs.begin(), iter_end = mItemPairs.end();
+			while (iter != iter_end)
 			{
 				(*iter)->first = NULL;
 				delete *iter;
+				iter++;
 			}
 			mItemPairs.clear();
 			// Also set items panel height to zero.
@@ -1287,16 +1286,14 @@ void LLFlatListView::detachItems(std::vector<LLPanel*>& detached_items)
 		}
 		else
 		{
-			for (std::vector<LLPanel*>::const_iterator
-					 detached_iter = detached_items.begin(),
-					 detached_iter_end = detached_items.end();
-				 detached_iter != detached_iter_end; ++detached_iter)
+			std::vector<LLPanel*>::const_iterator
+				detached_iter = detached_items.begin(),
+				detached_iter_end = detached_items.end();
+			while (detached_iter < detached_iter_end)
 			{
 				LLPanel* pDetachedItem = *detached_iter;
-				for (pairs_iterator_t
-						 iter = mItemPairs.begin(),
-						 iter_end = mItemPairs.end();
-					 iter != iter_end; ++iter)
+				pairs_iterator_t iter = mItemPairs.begin(), iter_end = mItemPairs.end();
+				while (iter != iter_end)
 				{
 					item_pair_t* item_pair = *iter;
 					if (item_pair->first == pDetachedItem)
@@ -1306,7 +1303,9 @@ void LLFlatListView::detachItems(std::vector<LLPanel*>& detached_items)
 						delete item_pair;
 						break;
 					}
+					iter++;
 				}
+				detached_iter++;
 			}
 			rearrangeItems();
 		}
@@ -1322,7 +1321,6 @@ LLFlatListViewEx::Params::Params()
 : no_items_msg("no_items_msg")
 , no_filtered_items_msg("no_filtered_items_msg")
 {
-
 }
 
 LLFlatListViewEx::LLFlatListViewEx(const Params& p)
@@ -1332,7 +1330,6 @@ LLFlatListViewEx::LLFlatListViewEx(const Params& p)
 , mForceShowingUnmatchedItems(false)
 , mHasMatchedItems(false)
 {
-
 }
 
 void LLFlatListViewEx::updateNoItemsMessage(const std::string& filter_string)
@@ -1352,7 +1349,6 @@ void LLFlatListViewEx::updateNoItemsMessage(const std::string& filter_string)
 		// list does not contain any items at all
 		setNoItemsCommentText(mNoItemsMsg);
 	}
-
 }
 
 bool LLFlatListViewEx::getForceShowingUnmatchedItems()
@@ -1411,12 +1407,10 @@ void LLFlatListViewEx::filterItems()
 	getItems(items);
 
 	mHasMatchedItems = false;
-	for (item_panel_list_t::iterator
-			 iter = items.begin(),
-			 iter_end = items.end();
-		 iter != iter_end; ++iter)
+    item_panel_list_t::iterator iter = items.begin(), iter_end = items.end();
+	while (iter < iter_end)
 	{
-		LLPanel* pItem = (*iter);
+		LLPanel* pItem = *(iter++);
 		updateItemVisibility(pItem, action);
 	}
 
diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp
index 62c311f522..650ae9ae75 100644
--- a/indra/llui/llfolderview.cpp
+++ b/indra/llui/llfolderview.cpp
@@ -189,7 +189,9 @@ LLFolderView::LLFolderView(const Params& p)
 	mStatusTextBox(NULL),
 	mShowItemLinkOverlays(p.show_item_link_overlays),
 	mViewModel(p.view_model),
-    mGroupedItemModel(p.grouped_item_model)
+    mGroupedItemModel(p.grouped_item_model),
+    mForceArrange(false),
+    mSingleFolderMode(false)
 {
     LLPanel* panel = p.parent_panel;
     mParentPanel = panel->getHandle();
@@ -609,6 +611,7 @@ void LLFolderView::clearSelection()
 	}
 
 	mSelectedItems.clear();
+    mNeedsScroll = false;
 }
 
 std::set<LLFolderViewItem*> LLFolderView::getSelectionList() const
@@ -665,7 +668,7 @@ void LLFolderView::draw()
 	}
 	else if (mShowEmptyMessage)
 	{
-		mStatusTextBox->setValue(getFolderViewModel()->getStatusText());
+		mStatusTextBox->setValue(getFolderViewModel()->getStatusText(mItems.empty() && mFolders.empty()));
 		mStatusTextBox->setVisible( TRUE );
 		
 		// firstly reshape message textbox with current size. This is necessary to
@@ -693,12 +696,16 @@ void LLFolderView::draw()
 		}
 	}
 
-	if (mRenameItem && mRenamer && mRenamer->getVisible() && !getVisibleRect().overlaps(mRenamer->getRect()))
-	{
-		// renamer is not connected to the item we are renaming in any form so manage it manually
-		// TODO: consider stopping on any scroll action instead of when out of visible area
-		finishRenamingItem();
-	}
+    if (mRenameItem
+        && mRenamer
+        && mRenamer->getVisible()
+        && !getVisibleRect().overlaps(mRenamer->getRect()))
+    {
+        // renamer is not connected to the item we are renaming in any form so manage it manually
+        // TODO: consider stopping on any scroll action instead of when out of visible area
+        LL_DEBUGS("Inventory") << "Renamer out of bounds, hiding" << LL_ENDL;
+        finishRenamingItem();
+    }
 
 	// skip over LLFolderViewFolder::draw since we don't want the folder icon, label, 
 	// and arrow for the root folder
@@ -832,9 +839,12 @@ void LLFolderView::autoOpenItem( LLFolderViewFolder* item )
 	mAutoOpenItems.push(item);
 	
 	item->setOpen(TRUE);
+    if(!item->isSingleFolderMode())
+    {
 	LLRect content_rect = (mScrollContainer ? mScrollContainer->getContentWindowRect() : LLRect());
 	LLRect constraint_rect(0,content_rect.getHeight(), content_rect.getWidth(), 0);
 	scrollToShowItem(item, constraint_rect);
+    }
 }
 
 void LLFolderView::closeAutoOpenedFolders()
@@ -1038,6 +1048,8 @@ void LLFolderView::paste()
 // public rename functionality - can only start the process
 void LLFolderView::startRenamingSelectedItem( void )
 {
+    LL_DEBUGS("Inventory") << "Starting inventory renamer" << LL_ENDL;
+
 	// make sure selection is visible
 	scrollToShowSelection();
 
@@ -1273,6 +1285,11 @@ BOOL LLFolderView::handleKeyHere( KEY key, MASK mask )
 		if(mSelectedItems.size())
 		{
 			LLFolderViewItem* last_selected = getCurSelectedItem();
+            if(last_selected && last_selected->isSingleFolderMode())
+            {
+                handled = FALSE;
+                break;
+            }
 			LLFolderViewItem* parent_folder = last_selected->getParentFolder();
 			if (!last_selected->isOpen() && parent_folder && parent_folder->getParentFolder())
 			{
@@ -1458,9 +1475,19 @@ BOOL LLFolderView::handleRightMouseDown( S32 x, S32 y, MASK mask )
 			mCallbackRegistrar->popScope();
 		}
 	}
+
+    BOOL item_clicked = FALSE;
+    for (selected_items_t::iterator item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
+    {
+        item_clicked |= (*item_it)->getRect().pointInRect(x, y);
+    }
+    if(!item_clicked && mSingleFolderMode)
+    {
+        clearSelection();
+    }
 	bool hide_folder_menu = mSuppressFolderMenu && isFolderSelected();
-	if (menu && (handled
-		&& ( count > 0 && (hasVisibleChildren()) )) && // show menu only if selected items are visible
+	if (menu && (mSingleFolderMode || (handled
+		&& ( count > 0 && (hasVisibleChildren()) ))) && // show menu only if selected items are visible
 		!hide_folder_menu)
 	{
 		if (mCallbackRegistrar)
@@ -1532,6 +1559,22 @@ BOOL LLFolderView::handleHover( S32 x, S32 y, MASK mask )
 	return LLView::handleHover( x, y, mask );
 }
 
+LLFolderViewItem* LLFolderView::getHoveredItem() const
+{
+	return dynamic_cast<LLFolderViewItem*>(mHoveredItem.get());
+}
+
+void LLFolderView::setHoveredItem(LLFolderViewItem* itemp)
+{
+	if (mHoveredItem.get() != itemp)
+	{
+		if (itemp)
+			mHoveredItem = itemp->getHandle();
+		else
+			mHoveredItem.markDead();
+	}
+}
+
 BOOL LLFolderView::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 									 EDragAndDropType cargo_type,
 									 void* cargo_data, 
@@ -1716,7 +1759,7 @@ void LLFolderView::update()
 		mNeedsAutoSelect = FALSE;
 	}
 
-  BOOL is_visible = isInVisibleChain();
+  BOOL is_visible = isInVisibleChain() || mForceArrange;
 
   //Puts folders/items in proper positions
   // arrange() takes the model filter flag into account and call sort() if necessary (CHUI-849)
@@ -1817,13 +1860,28 @@ void LLFolderView::update()
         }
 	}
 
-	if (mSignalSelectCallback)
-	{
-		//RN: we use keyboard focus as a proxy for user-explicit actions
-		BOOL take_keyboard_focus = (mSignalSelectCallback == SIGNAL_KEYBOARD_FOCUS);
-		mSelectSignal(mSelectedItems, take_keyboard_focus);
-	}
-	mSignalSelectCallback = FALSE;
+    if (mSelectedItems.size())
+    {
+        LLFolderViewItem* item = mSelectedItems.back();
+        // If the goal is to show renamer, don't callback untill
+        // item is visible or is no longer being scrolled to.
+        // Otherwise renamer will be instantly closed
+        // Todo: consider moving renamer out of selection callback
+        if (!mNeedsAutoRename || !mNeedsScroll || item->getVisible())
+        {
+            if (mSignalSelectCallback)
+            {
+                //RN: we use keyboard focus as a proxy for user-explicit actions
+                BOOL take_keyboard_focus = (mSignalSelectCallback == SIGNAL_KEYBOARD_FOCUS);
+                mSelectSignal(mSelectedItems, take_keyboard_focus);
+            }
+            mSignalSelectCallback = FALSE;
+        }
+    }
+    else
+    {
+        mSignalSelectCallback = FALSE;
+    }
 }
 
 void LLFolderView::dumpSelectionInformation()
@@ -1886,6 +1944,11 @@ void LLFolderView::updateMenuOptions(LLMenuGL* menu)
 		flags = multi_select_flag;
 	}
 
+    if(mSingleFolderMode && (mSelectedItems.size() == 0))
+    {
+        buildContextMenu(*menu, flags);
+    }
+
 	// This adds a check for restrictions based on the entire
 	// selection set - for example, any one wearable may not push you
 	// over the limit, but all wearables together still might.
@@ -2042,7 +2105,7 @@ LLFolderViewItem* LLFolderView::getNextUnselectedItem()
 	return new_selection;
 }
 
-S32 LLFolderView::getItemHeight()
+S32 LLFolderView::getItemHeight() const
 {
 	if(!hasVisibleChildren())
 {
diff --git a/indra/llui/llfolderview.h b/indra/llui/llfolderview.h
index 7dfa04828a..5f8a173889 100644
--- a/indra/llui/llfolderview.h
+++ b/indra/llui/llfolderview.h
@@ -127,6 +127,9 @@ public:
 	bool getAllowMultiSelect() { return mAllowMultiSelect; }
 	bool getAllowDrag() { return mAllowDrag; }
 
+    void setSingleFolderMode(bool is_single_mode) { mSingleFolderMode = is_single_mode; }
+    bool isSingleFolderMode() { return mSingleFolderMode; }
+
 	// Close all folders in the view
 	void closeAllFolders();
 	void openTopLevelFolders();
@@ -136,7 +139,7 @@ public:
 	// Find width and height of this object and its children. Also
 	// makes sure that this view and its children are the right size.
 	virtual S32 arrange( S32* width, S32* height );
-	virtual S32 getItemHeight();
+	virtual S32 getItemHeight() const;
 
 	void arrangeAll() { mArrangeGeneration++; }
 	S32 getArrangeGeneration() { return mArrangeGeneration; }
@@ -144,6 +147,10 @@ public:
 	// applies filters to control visibility of items
 	virtual void filter( LLFolderViewFilter& filter);
 
+	void              clearHoveredItem() { setHoveredItem(nullptr); }
+	LLFolderViewItem* getHoveredItem() const;
+	void              setHoveredItem(LLFolderViewItem* itemp);
+
 	// Get the last selected item
 	virtual LLFolderViewItem* getCurSelectedItem( void );
     selected_items_t& getSelectedItems( void );
@@ -210,6 +217,7 @@ public:
 	virtual void draw();
 	virtual void deleteAllChildren();
 
+    void stopAutoScollining() {mNeedsScroll = false;}
 	void scrollToShowSelection();
 	void scrollToShowItem(LLFolderViewItem* item, const LLRect& constraint_rect);
 	void setScrollContainer( LLScrollContainer* parent ) { mScrollContainer = parent; }
@@ -237,11 +245,15 @@ public:
 	void setCallbackRegistrar(LLUICtrl::CommitCallbackRegistry::ScopedRegistrar* registrar) { mCallbackRegistrar = registrar; }
 	void setEnableRegistrar(LLUICtrl::EnableCallbackRegistry::ScopedRegistrar* registrar) { mEnableRegistrar = registrar; }
 
+    void setForceArrange(bool force) { mForceArrange = force; }
+
 	LLPanel* getParentPanel() { return mParentPanel.get(); }
 	// DEBUG only
 	void dumpSelectionInformation();
 
 	virtual S32	notify(const LLSD& info) ;
+
+	void setShowEmptyMessage(bool show_msg) { mShowEmptyMessage = show_msg; }
 	
 	bool useLabelSuffix() { return mUseLabelSuffix; }
 	virtual void updateMenu();
@@ -275,6 +287,7 @@ protected:
 	LLHandle<LLView>					mPopupMenuHandle;
 	std::string						mMenuFileName;
 	
+	LLHandle<LLView>				mHoveredItem;
 	selected_items_t				mSelectedItems;
 	bool							mKeyboardSelection,
 									mAllowMultiSelect,
@@ -291,7 +304,8 @@ protected:
 									mShowItemLinkOverlays,
 									mShowSelectionContext,
 									mShowSingleSelection,
-									mSuppressFolderMenu;
+									mSuppressFolderMenu,
+                                    mSingleFolderMode;
 
 	// Renaming variables and methods
 	LLFolderViewItem*				mRenameItem;  // The item currently being renamed
@@ -330,6 +344,8 @@ protected:
 
 	LLUICtrl::CommitCallbackRegistry::ScopedRegistrar* mCallbackRegistrar;
 	LLUICtrl::EnableCallbackRegistry::ScopedRegistrar* mEnableRegistrar;
+
+    bool mForceArrange;
 	
 public:
 	static F32 sAutoOpenTime;
diff --git a/indra/llui/llfolderviewitem.cpp b/indra/llui/llfolderviewitem.cpp
index eba93beed9..0dc66bf37a 100644
--- a/indra/llui/llfolderviewitem.cpp
+++ b/indra/llui/llfolderviewitem.cpp
@@ -32,6 +32,7 @@
 #include "llfolderview.h"
 #include "llfolderviewmodel.h"
 #include "llpanel.h"
+#include "llcallbacklist.h"
 #include "llcriticaldamp.h"
 #include "llclipboard.h"
 #include "llfocusmgr.h"		// gFocusMgr
@@ -113,6 +114,8 @@ LLFolderViewItem::Params::Params()
     icon_width("icon_width", 0),
     text_pad("text_pad", 0),
     text_pad_right("text_pad_right", 0),
+    single_folder_mode("single_folder_mode", false),
+    double_click_override("double_click_override", false),
     arrow_size("arrow_size", 0),
     max_folder_item_overlap("max_folder_item_overlap", 0)
 { }
@@ -151,7 +154,9 @@ LLFolderViewItem::LLFolderViewItem(const LLFolderViewItem::Params& p)
     mTextPad(p.text_pad),
     mTextPadRight(p.text_pad_right),
     mArrowSize(p.arrow_size),
-    mMaxFolderItemOverlap(p.max_folder_item_overlap)
+    mSingleFolderMode(p.single_folder_mode),
+    mMaxFolderItemOverlap(p.max_folder_item_overlap),
+    mDoubleClickOverride(p.double_click_override)
 {
 	if (!sColorSetInitialized)
 	{
@@ -162,7 +167,7 @@ LLFolderViewItem::LLFolderViewItem(const LLFolderViewItem::Params& p)
 		sMouseOverColor = LLUIColorTable::instance().getColor("InventoryMouseOverColor", DEFAULT_WHITE);
 		sFilterBGColor = LLUIColorTable::instance().getColor("FilterBackgroundColor", DEFAULT_WHITE);
 		sFilterTextColor = LLUIColorTable::instance().getColor("FilterTextColor", DEFAULT_WHITE);
-		sSuffixColor = LLUIColorTable::instance().getColor("InventoryItemColor", DEFAULT_WHITE);
+		sSuffixColor = LLUIColorTable::instance().getColor("InventoryItemLinkColor", DEFAULT_WHITE);
 		sSearchStatusColor = LLUIColorTable::instance().getColor("InventorySearchStatusColor", DEFAULT_WHITE);
 		sColorSetInitialized = true;
 	}
@@ -177,6 +182,7 @@ LLFolderViewItem::LLFolderViewItem(const LLFolderViewItem::Params& p)
 LLFolderViewItem::~LLFolderViewItem()
 {
 	mViewModelItem = NULL;
+    gFocusMgr.removeKeyboardFocusWithoutCallback(this);
 }
 
 BOOL LLFolderViewItem::postBuild()
@@ -395,7 +401,7 @@ S32 LLFolderViewItem::arrange( S32* width, S32* height )
             // it is purely visual, so it is fine to do at our laisure
             refreshSuffix();
         }
-		mLabelWidth = getLabelXPos() + getLabelFontForStyle(mLabelStyle)->getWidth(mLabel) + getLabelFontForStyle(mLabelStyle)->getWidth(mLabelSuffix) + mLabelPaddingRight; 
+		mLabelWidth = getLabelXPos() + getLabelFontForStyle(mLabelStyle)->getWidth(mLabel) + getLabelFontForStyle(LLFontGL::NORMAL)->getWidth(mLabelSuffix) + mLabelPaddingRight;
 		mLabelWidthDirty = false;
 	}
 
@@ -412,7 +418,7 @@ S32 LLFolderViewItem::arrange( S32* width, S32* height )
 	return *height;
 }
 
-S32 LLFolderViewItem::getItemHeight()
+S32 LLFolderViewItem::getItemHeight() const
 {
 	return mItemHeight;
 }
@@ -624,11 +630,14 @@ BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
 			getWindow()->setCursor(UI_CURSOR_NOLOCKED);
 		}
 
+		root->clearHoveredItem();
 		return TRUE;
 	}
 	else
 	{
-		getRoot()->setShowSelectionContext(FALSE);
+		LLFolderView* pRoot = getRoot();
+		pRoot->setHoveredItem(this);
+		pRoot->setShowSelectionContext(FALSE);
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		// let parent handle this then...
 		return FALSE;
@@ -683,6 +692,13 @@ BOOL LLFolderViewItem::handleMouseUp( S32 x, S32 y, MASK mask )
 void LLFolderViewItem::onMouseLeave(S32 x, S32 y, MASK mask)
 {
 	mIsMouseOverTitle = false;
+
+	// NOTE: LLViewerWindow::updateUI() calls "enter" before "leave"; if the mouse moved to another item, we can't just outright clear it
+	LLFolderView* pRoot = getRoot();
+	if (this == pRoot->getHoveredItem())
+	{
+		pRoot->clearHoveredItem();
+	}
 }
 
 BOOL LLFolderViewItem::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
@@ -889,7 +905,10 @@ void LLFolderViewItem::draw()
 
     getViewModelItem()->update();
 
-    drawOpenFolderArrow(default_params, sFgColor);
+    if(!mSingleFolderMode)
+    {
+        drawOpenFolderArrow(default_params, sFgColor);
+    }
 
     drawHighlight(show_context, filled, sHighlightBgColor, sFlashBgColor, sFocusOutlineColor, sMouseOverColor);
 
@@ -925,16 +944,43 @@ void LLFolderViewItem::draw()
 	F32 text_left = (F32)getLabelXPos();
 	std::string combined_string = mLabel + mLabelSuffix;
 
+    const LLFontGL* suffix_font = getLabelFontForStyle(LLFontGL::NORMAL);
+    S32 filter_offset = mViewModelItem->getFilterStringOffset();
 	if (filter_string_length > 0)
 	{
-		S32 left = ll_round(text_left) + font->getWidth(combined_string, 0, mViewModelItem->getFilterStringOffset()) - 2;
+        S32 bottom = llfloor(getRect().getHeight() - font->getLineHeight() - 3 - TOP_PAD);
+        S32 top = getRect().getHeight() - TOP_PAD;
+        if(mLabelSuffix.empty() || (font == suffix_font))
+        {
+        S32 left = ll_round(text_left) + font->getWidth(combined_string, 0, mViewModelItem->getFilterStringOffset()) - 2;
 		S32 right = left + font->getWidth(combined_string, mViewModelItem->getFilterStringOffset(), filter_string_length) + 2;
-		S32 bottom = llfloor(getRect().getHeight() - font->getLineHeight() - 3 - TOP_PAD);
-		S32 top = getRect().getHeight() - TOP_PAD;
 
 		LLUIImage* box_image = default_params.selection_image;
 		LLRect box_rect(left, top, right, bottom);
 		box_image->draw(box_rect, sFilterBGColor);
+        }
+        else
+        {
+            S32 label_filter_length = llmin((S32)mLabel.size() - filter_offset, (S32)filter_string_length);
+            if(label_filter_length > 0)
+            {
+                S32 left = ll_round(text_left) + font->getWidthF32(mLabel, 0, llmin(filter_offset, (S32)mLabel.size())) - 2;
+                S32 right = left + font->getWidthF32(mLabel, filter_offset, label_filter_length) + 2;
+                LLUIImage* box_image = default_params.selection_image;
+                LLRect box_rect(left, top, right, bottom);
+                box_image->draw(box_rect, sFilterBGColor);
+            }
+            S32 suffix_filter_length = label_filter_length > 0 ? filter_string_length - label_filter_length : filter_string_length;
+            if(suffix_filter_length > 0)
+            {
+                S32 suffix_offset = llmax(0, filter_offset - (S32)mLabel.size());
+                S32 left = ll_round(text_left) + font->getWidthF32(mLabel, 0, mLabel.size()) + suffix_font->getWidthF32(mLabelSuffix, 0, suffix_offset) - 2;
+                S32 right = left + suffix_font->getWidthF32(mLabelSuffix, suffix_offset, suffix_filter_length) + 2;
+                LLUIImage* box_image = default_params.selection_image;
+                LLRect box_rect(left, top, right, bottom);
+                box_image->draw(box_rect, sFilterBGColor);
+            }
+        }
     }
 
     LLColor4 color = (mIsSelected && filled) ? mFontHighlightColor : mFontColor;
@@ -951,7 +997,7 @@ void LLFolderViewItem::draw()
 	//
 	if (!mLabelSuffix.empty())
 	{
-		font->renderUTF8( mLabelSuffix, 0, right_x, y, isFadeItem() ? color : (LLColor4)sSuffixColor,
+        suffix_font->renderUTF8( mLabelSuffix, 0, right_x, y, isFadeItem() ? color : (LLColor4)sSuffixColor,
 						  LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
 						  S32_MAX, S32_MAX, &right_x, FALSE );
 	}
@@ -961,12 +1007,35 @@ void LLFolderViewItem::draw()
 	//
     if (filter_string_length > 0)
     {
-        S32 filter_offset = mViewModelItem->getFilterStringOffset();
-        F32 match_string_left = text_left + font->getWidthF32(combined_string, 0, filter_offset + filter_string_length) - font->getWidthF32(combined_string, filter_offset, filter_string_length);
-        F32 yy = (F32)getRect().getHeight() - font->getLineHeight() - (F32)mTextPad - (F32)TOP_PAD;
-        font->renderUTF8( combined_string, filter_offset, match_string_left, yy,
+        if(mLabelSuffix.empty() || (font == suffix_font))
+        {
+            F32 match_string_left = text_left + font->getWidthF32(combined_string, 0, filter_offset + filter_string_length) - font->getWidthF32(combined_string, filter_offset, filter_string_length);
+            F32 yy = (F32)getRect().getHeight() - font->getLineHeight() - (F32)mTextPad - (F32)TOP_PAD;
+            font->renderUTF8( combined_string, filter_offset, match_string_left, yy,
             sFilterTextColor, LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
             filter_string_length, S32_MAX, &right_x, FALSE );
+        }
+        else
+        {
+            S32 label_filter_length = llmin((S32)mLabel.size() - filter_offset, (S32)filter_string_length);
+            if(label_filter_length > 0)
+            {
+                F32 match_string_left = text_left + font->getWidthF32(mLabel, 0, filter_offset + label_filter_length) - font->getWidthF32(mLabel, filter_offset, label_filter_length);
+                F32 yy = (F32)getRect().getHeight() - font->getLineHeight() - (F32)mTextPad - (F32)TOP_PAD;
+                font->renderUTF8( mLabel, filter_offset, match_string_left, yy,
+ sFilterTextColor, LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, label_filter_length, S32_MAX, &right_x, FALSE );
+            }
+            
+            S32 suffix_filter_length = label_filter_length > 0 ? filter_string_length - label_filter_length : filter_string_length;
+            if(suffix_filter_length > 0)
+            {
+                S32 suffix_offset = llmax(0, filter_offset - (S32)mLabel.size());
+                F32 match_string_left = text_left + font->getWidthF32(mLabel, 0, mLabel.size()) + suffix_font->getWidthF32(mLabelSuffix, 0, suffix_offset + suffix_filter_length) - suffix_font->getWidthF32(mLabelSuffix, suffix_offset, suffix_filter_length);
+                F32 yy = (F32)getRect().getHeight() - suffix_font->getLineHeight() - (F32)mTextPad - (F32)TOP_PAD;
+                suffix_font->renderUTF8( mLabelSuffix, suffix_offset, match_string_left, yy, sFilterTextColor, LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, suffix_filter_length, S32_MAX, &right_x, FALSE );
+            }
+        }
+
     }
 
     //Gilbert Linden 9-20-2012: Although this should be legal, removing it because it causes the mLabelSuffix rendering to
@@ -1277,7 +1346,7 @@ BOOL LLFolderViewFolder::setSelection(LLFolderViewItem* selection, BOOL openitem
 			child_selected = TRUE;
 		}
 	}
-	if(openitem && child_selected)
+	if(openitem && child_selected && !mSingleFolderMode)
 	{
 		setOpenArrangeRecursively(TRUE);
 	}
@@ -1702,6 +1771,11 @@ BOOL LLFolderViewFolder::isRemovable()
 	return TRUE;
 }
 
+void LLFolderViewFolder::destroyRoot()
+{
+    delete this;
+}
+
 // this is an internal method used for adding items to folders. 
 void LLFolderViewFolder::addItem(LLFolderViewItem* item)
 {
@@ -1770,7 +1844,19 @@ void LLFolderViewFolder::toggleOpen()
 // Force a folder open or closed
 void LLFolderViewFolder::setOpen(BOOL openitem)
 {
-	setOpenArrangeRecursively(openitem);
+    if(mSingleFolderMode)
+    {
+        // navigateToFolder can destroy this view
+        // delay it in case setOpen was called from click or key processing
+        doOnIdleOneTime([this]()
+                        {
+                            getViewModelItem()->navigateToFolder();
+                        });
+    }
+    else
+    {
+        setOpenArrangeRecursively(openitem);
+    }
 }
 
 void LLFolderViewFolder::setOpenArrangeRecursively(BOOL openitem, ERecurseType recurse)
@@ -1973,7 +2059,8 @@ BOOL LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
 	}
 	if( !handled )
 	{
-		if(mIndentation < x && x < mIndentation + (isCollapsed() ? 0 : mArrowSize) + mTextPad)
+		if((mIndentation < x && x < mIndentation + (isCollapsed() ? 0 : mArrowSize) + mTextPad)
+           && !mSingleFolderMode)
 		{
 			toggleOpen();
 			handled = TRUE;
@@ -1991,12 +2078,45 @@ BOOL LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
 BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
 {
 	BOOL handled = FALSE;
+    if(mSingleFolderMode)
+    {
+        static LLUICachedControl<bool> double_click_new_window("SingleModeDoubleClickOpenWindow", false);
+        if (double_click_new_window)
+        {
+            getViewModelItem()->navigateToFolder(true);
+        }
+        else
+        {
+            // navigating is going to destroy views and change children
+            // delay it untill handleDoubleClick processing is complete
+            doOnIdleOneTime([this]()
+                            {
+                                getViewModelItem()->navigateToFolder(false);
+                            });
+        }
+        return TRUE;
+    }
+
 	if( isOpen() )
 	{
 		handled = childrenHandleDoubleClick( x, y, mask ) != NULL;
 	}
 	if( !handled )
 	{
+        if(mDoubleClickOverride)
+        {
+            static LLUICachedControl<U32> double_click_action("MultiModeDoubleClickFolder", false);
+            if (double_click_action == 1)
+            {
+                getViewModelItem()->navigateToFolder(true);
+                return TRUE;
+            }
+            if (double_click_action == 2)
+            {
+                getViewModelItem()->navigateToFolder(false, true);
+                return TRUE;
+            }
+        }
 		if(mIndentation < x && x < mIndentation + (isCollapsed() ? 0 : mArrowSize) + mTextPad)
 		{
 			// don't select when user double-clicks plus sign
diff --git a/indra/llui/llfolderviewitem.h b/indra/llui/llfolderviewitem.h
index a5157266c5..5c2a1ecff0 100644
--- a/indra/llui/llfolderviewitem.h
+++ b/indra/llui/llfolderviewitem.h
@@ -72,6 +72,8 @@ public:
                                                     text_pad_right,
                                                     arrow_size,
                                                     max_folder_item_overlap;
+        Optional<bool>                              single_folder_mode,
+                                                    double_click_override;
 		Params();
 	};
 
@@ -121,6 +123,8 @@ protected:
 								mIsMouseOverTitle,
 								mAllowWear,
                                 mAllowDrop,
+                                mSingleFolderMode,
+                                mDoubleClickOverride,
 								mSelectPending,
 								mIsItemCut;
 
@@ -174,7 +178,7 @@ public:
 	// Finds width and height of this object and it's children.  Also
 	// makes sure that this view and it's children are the right size.
 	virtual S32 arrange( S32* width, S32* height );
-	virtual S32 getItemHeight();
+	virtual S32 getItemHeight() const;
     virtual S32 getLabelXPos();
     S32 getIconPad();
     S32 getTextPad();
@@ -213,9 +217,9 @@ public:
 
 	void setIsCurSelection(BOOL select) { mIsCurSelection = select; }
 
-	BOOL getIsCurSelection() { return mIsCurSelection; }
+	BOOL getIsCurSelection() const { return mIsCurSelection; }
 
-	BOOL hasVisibleChildren() { return mHasVisibleChildren; }
+	BOOL hasVisibleChildren() const { return mHasVisibleChildren; }
 
 	// true if object can't have children
 	virtual bool isFolderComplete() { return true; }
@@ -264,7 +268,7 @@ public:
 	virtual LLFolderView*	getRoot();
 	virtual const LLFolderView*	getRoot() const;
 	BOOL			isDescendantOf( const LLFolderViewFolder* potential_ancestor );
-	S32				getIndentation() { return mIndentation; }
+	S32				getIndentation() const { return mIndentation; }
 
 	virtual BOOL	passedFilter(S32 filter_generation = -1);
 	virtual BOOL	isPotentiallyVisible(S32 filter_generation = -1);
@@ -277,6 +281,8 @@ public:
     // Does not need filter update
 	virtual void refreshSuffix();
 
+    bool isSingleFolderMode() { return mSingleFolderMode; }
+
 	// LLView functionality
 	virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
 	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
@@ -387,6 +393,7 @@ public:
 
 	// destroys this folder, and all children
 	virtual void destroyView();
+    void destroyRoot();
 
     // whether known children are fully loaded (arrange sets to true)
     virtual bool isFolderComplete() { return mIsFolderComplete; }
diff --git a/indra/llui/llfolderviewmodel.cpp b/indra/llui/llfolderviewmodel.cpp
index 93122503d1..f217b743a0 100644
--- a/indra/llui/llfolderviewmodel.cpp
+++ b/indra/llui/llfolderviewmodel.cpp
@@ -34,7 +34,7 @@ bool LLFolderViewModelCommon::needsSort(LLFolderViewModelItem* item)
 	return item->getSortVersion() < mTargetSortVersion;
 }
 
-std::string LLFolderViewModelCommon::getStatusText()
+std::string LLFolderViewModelCommon::getStatusText(bool is_empty_folder)
 {
 	if (!contentsReady() || mFolderView->getViewModelItem()->getLastFilterGeneration() < getFilter().getCurrentGeneration())
 	{
@@ -42,7 +42,7 @@ std::string LLFolderViewModelCommon::getStatusText()
 	}
 	else
 	{
-		return getFilter().getEmptyLookupMessage();
+		return getFilter().getEmptyLookupMessage(is_empty_folder);
 	}
 }
 
diff --git a/indra/llui/llfolderviewmodel.h b/indra/llui/llfolderviewmodel.h
index c5e027d314..551a60e097 100644
--- a/indra/llui/llfolderviewmodel.h
+++ b/indra/llui/llfolderviewmodel.h
@@ -69,7 +69,7 @@ public:
 	virtual bool				checkFolder(const LLFolderViewModelItem* folder) const = 0;
 
 	virtual void 				setEmptyLookupMessage(const std::string& message) = 0;
-	virtual std::string			getEmptyLookupMessage() const = 0;
+    virtual std::string			getEmptyLookupMessage(bool is_empty_folder = false) const = 0;
 
 	virtual bool				showAllResults() const = 0;
 
@@ -125,7 +125,7 @@ public:
 	virtual void setFolderView(LLFolderView* folder_view) = 0;
 	virtual LLFolderViewFilter& getFilter() = 0;
 	virtual const LLFolderViewFilter& getFilter() const = 0;
-	virtual std::string getStatusText() = 0;
+	virtual std::string getStatusText(bool is_empty_folder = false) = 0;
 
 	virtual bool startDrag(std::vector<LLFolderViewModelItem*>& items) = 0;
 };
@@ -159,6 +159,8 @@ public:
 	virtual void openItem( void ) = 0;
 	virtual void closeItem( void ) = 0;
 	virtual void selectItem(void) = 0;
+
+    virtual void navigateToFolder(bool new_window = false, bool change_mode = false) = 0;
     
     virtual BOOL isItemWearable() const { return FALSE; }
 
@@ -392,7 +394,7 @@ public:
 		// sort everything
 		mTargetSortVersion++;
 	}
-	virtual std::string getStatusText();
+	virtual std::string getStatusText(bool is_empty_folder = false);
 	virtual void filter();
 
 	void setFolderView(LLFolderView* folder_view) { mFolderView = folder_view;}
diff --git a/indra/llui/lliconctrl.cpp b/indra/llui/lliconctrl.cpp
index e01aba402e..2791377a5e 100644
--- a/indra/llui/lliconctrl.cpp
+++ b/indra/llui/lliconctrl.cpp
@@ -37,6 +37,8 @@
 #include "lluiimage.h"
 #include "llwindow.h"
 
+#include "llgltexture.h"
+
 static LLDefaultChildRegistry::Register<LLIconCtrl> r("icon");
 
 LLIconCtrl::Params::Params()
@@ -94,6 +96,22 @@ BOOL LLIconCtrl::handleHover(S32 x, S32 y, MASK mask)
     return LLUICtrl::handleHover(x, y, mask);
 }
 
+void LLIconCtrl::onVisibilityChange(BOOL new_visibility)
+{
+	LLUICtrl::onVisibilityChange(new_visibility);
+	if (mPriority == LLGLTexture::BOOST_ICON)
+	{
+		if (new_visibility)
+		{
+			loadImage(getValue(), mPriority);
+		}
+		else
+		{
+			mImagep = nullptr;
+		}
+	}
+}
+
 // virtual
 // value might be a string or a UUID
 void LLIconCtrl::setValue(const LLSD& value)
@@ -110,6 +128,14 @@ void LLIconCtrl::setValue(const LLSD& value, S32 priority)
 		tvalue = LLSD(LLUUID(value.asString()));
 	}
 	LLUICtrl::setValue(tvalue);
+
+	loadImage(tvalue, priority);
+}
+
+void LLIconCtrl::loadImage(const LLSD& tvalue, S32 priority)
+{
+	if(mPriority == LLGLTexture::BOOST_ICON && !getVisible()) return;
+
 	if (tvalue.isUUID())
 	{
         mImagep = LLUI::getUIImageByID(tvalue.asUUID(), priority);
diff --git a/indra/llui/lliconctrl.h b/indra/llui/lliconctrl.h
index 9c3b517bca..e983d63a01 100644
--- a/indra/llui/lliconctrl.h
+++ b/indra/llui/lliconctrl.h
@@ -39,7 +39,9 @@ class LLUICtrlFactory;
 // Classes
 //
 
-// 
+// Class for diplaying named UI textures
+// Do not use for displaying textures from network,
+// UI textures are stored permanently!
 class LLIconCtrl
 : public LLUICtrl
 {
@@ -72,6 +74,7 @@ public:
     virtual BOOL handleHover(S32 x, S32 y, MASK mask);
 
 	// lluictrl overrides
+	void onVisibilityChange(BOOL new_visibility);
 	virtual void	setValue(const LLSD& value );
 
 	std::string	getImageName() const;
@@ -95,6 +98,8 @@ protected:
     bool mInteractable;
 
 private:
+	void loadImage(const LLSD& value, S32 priority);
+
 	LLUIColor mColor;
 	LLPointer<LLUIImage> mImagep;
 };
diff --git a/indra/llui/lllayoutstack.cpp b/indra/llui/lllayoutstack.cpp
index 77938edf27..7e4e828a88 100644
--- a/indra/llui/lllayoutstack.cpp
+++ b/indra/llui/lllayoutstack.cpp
@@ -89,6 +89,8 @@ LLLayoutPanel::~LLLayoutPanel()
 	// probably not necessary, but...
 	delete mResizeBar;
 	mResizeBar = NULL;
+
+    gFocusMgr.removeKeyboardFocusWithoutCallback(this);
 }
 
 F32 LLLayoutPanel::getAutoResizeFactor() const
@@ -214,7 +216,8 @@ LLLayoutStack::Params::Params()
 	drag_handle_first_indent("drag_handle_first_indent", 0),
 	drag_handle_second_indent("drag_handle_second_indent", 0),
 	drag_handle_thickness("drag_handle_thickness", 5),
-	drag_handle_shift("drag_handle_shift", 2)
+	drag_handle_shift("drag_handle_shift", 2),
+    drag_handle_color("drag_handle_color", LLUIColorTable::instance().getColor("ResizebarBody"))
 {
 	addSynonym(border_size, "drag_handle_gap");
 }
@@ -234,7 +237,8 @@ LLLayoutStack::LLLayoutStack(const LLLayoutStack::Params& p)
 	mDragHandleFirstIndent(p.drag_handle_first_indent),
 	mDragHandleSecondIndent(p.drag_handle_second_indent),
 	mDragHandleThickness(p.drag_handle_thickness),
-	mDragHandleShift(p.drag_handle_shift)
+	mDragHandleShift(p.drag_handle_shift),
+    mDragHandleColor(p.drag_handle_color())
 {
 }
 
@@ -282,6 +286,17 @@ void LLLayoutStack::draw()
 	}
 }
 
+void LLLayoutStack::deleteAllChildren()
+{
+    mPanels.clear();
+    LLView::deleteAllChildren();
+
+    // Not really needed since nothing is left to
+    // display, but for the sake of consistency
+    updateFractionalSizes();
+    mNeedsLayout = true;
+}
+
 void LLLayoutStack::removeChild(LLView* view)
 {
 	LLLayoutPanel* embedded_panelp = findEmbeddedPanel(dynamic_cast<LLPanel*>(view));
@@ -289,12 +304,14 @@ void LLLayoutStack::removeChild(LLView* view)
 	if (embedded_panelp)
 	{
 		mPanels.erase(std::find(mPanels.begin(), mPanels.end(), embedded_panelp));
-		delete embedded_panelp;
+        LLView::removeChild(view);
 		updateFractionalSizes();
 		mNeedsLayout = true;
 	}
-
-	LLView::removeChild(view);
+    else
+    {
+        LLView::removeChild(view);
+    }
 }
 
 BOOL LLLayoutStack::postBuild()
@@ -508,6 +525,15 @@ void LLLayoutStack::updateLayout()
 	mNeedsLayout = continue_animating;
 } // end LLLayoutStack::updateLayout
 
+void LLLayoutStack::setPanelSpacing(S32 val)
+{
+    if (mPanelSpacing != val)
+    {
+        mPanelSpacing = val;
+        mNeedsLayout = true;
+    }
+}
+
 LLLayoutPanel* LLLayoutStack::findEmbeddedPanel(LLPanel* panelp) const
 {
 	if (!panelp) return NULL;
@@ -561,7 +587,7 @@ void LLLayoutStack::createResizeBar(LLLayoutPanel* panelp)
 				resize_bar_bg_panel_p.follows.flags = FOLLOWS_ALL;
 				resize_bar_bg_panel_p.tab_stop = false;
 				resize_bar_bg_panel_p.background_visible = true;
-				resize_bar_bg_panel_p.bg_alpha_color = LLUIColorTable::instance().getColor("ResizebarBody");
+				resize_bar_bg_panel_p.bg_alpha_color = mDragHandleColor;
 				resize_bar_bg_panel_p.has_border = true;
 				resize_bar_bg_panel_p.border.border_thickness = 1;
 				resize_bar_bg_panel_p.border.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
diff --git a/indra/llui/lllayoutstack.h b/indra/llui/lllayoutstack.h
index f772dbc6b4..000b919ae7 100644
--- a/indra/llui/lllayoutstack.h
+++ b/indra/llui/lllayoutstack.h
@@ -59,6 +59,8 @@ public:
 		Optional<S32>			drag_handle_thickness;
 		Optional<S32>			drag_handle_shift;
 
+        Optional<LLUIColor>     drag_handle_color;
+
 		Params();
 	};
 
@@ -67,6 +69,7 @@ public:
 	virtual ~LLLayoutStack();
 
 	/*virtual*/ void draw();
+    /*virtual*/ void deleteAllChildren();
 	/*virtual*/ void removeChild(LLView*);
 	/*virtual*/ BOOL postBuild();
 	/*virtual*/ bool addChild(LLView* child, S32 tab_group = 0);
@@ -88,6 +91,7 @@ public:
 	void updateLayout();
 
 	S32 getPanelSpacing() const { return mPanelSpacing; }
+    void setPanelSpacing(S32 val);
 	
 	static void updateClass();
 
@@ -127,6 +131,7 @@ private:
 	S32  mDragHandleSecondIndent;
 	S32  mDragHandleThickness;
 	S32  mDragHandleShift;
+    LLUIColor mDragHandleColor;
 }; // end class LLLayoutStack
 
 
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index 5cb840fd61..cebca70b59 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -487,9 +487,6 @@ void LLMenuItemGL::draw( void )
 	// let disabled items be highlighted, just don't draw them as such
 	if( getEnabled() && getHighlight() && !mBriefItem)
 	{
-		int debug_count = 0;
-		if (dynamic_cast<LLMenuItemCallGL*>(this))
-			debug_count++;
 		gGL.color4fv( mHighlightBackground.get().mV );
 
 		gl_rect_2d( 0, getRect().getHeight(), getRect().getWidth(), 0 );
@@ -576,13 +573,13 @@ void LLMenuItemGL::onVisibilityChange(BOOL new_visibility)
 //
 // This class represents a separator.
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-LLMenuItemSeparatorGL::Params::Params()
-{
-}
-
 LLMenuItemSeparatorGL::LLMenuItemSeparatorGL(const LLMenuItemSeparatorGL::Params& p) :
 	LLMenuItemGL( p )
 {
+    if (p.on_visible.isProvided())
+    {
+        mVisibleSignal.connect(initEnableCallback(p.on_visible));
+    }
 }
 
 //virtual
@@ -599,6 +596,15 @@ void LLMenuItemSeparatorGL::draw( void )
 	gl_line_2d( PAD, y, getRect().getWidth() - PAD, y );
 }
 
+void LLMenuItemSeparatorGL::buildDrawLabel( void )
+{
+    if (mVisibleSignal.num_slots() > 0)
+    {
+        bool visible = mVisibleSignal(this, LLSD());
+        setVisible(visible);
+    }
+}
+
 BOOL LLMenuItemSeparatorGL::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLMenuGL* parent_menu = getMenu();
@@ -1882,6 +1888,13 @@ bool LLMenuGL::addContextChild(LLView* view, S32 tab_group)
 	return false;
 }
 
+
+void LLMenuGL::deleteAllChildren()
+{
+    mItems.clear();
+    LLUICtrl::deleteAllChildren();
+}
+
 void LLMenuGL::removeChild( LLView* ctrl)
 {
 	// previously a dynamic_cast with if statement to check validity
diff --git a/indra/llui/llmenugl.h b/indra/llui/llmenugl.h
index f84c4d41eb..87e3f18ebc 100644
--- a/indra/llui/llmenugl.h
+++ b/indra/llui/llmenugl.h
@@ -234,7 +234,9 @@ class LLMenuItemSeparatorGL : public LLMenuItemGL
 public:
 	struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
 	{
-		Params();
+        Optional<EnableCallbackParam > on_visible;
+        Params() : on_visible("on_visible")
+        {}
 	};
 	LLMenuItemSeparatorGL(const LLMenuItemSeparatorGL::Params& p = LLMenuItemSeparatorGL::Params());
 
@@ -243,7 +245,12 @@ public:
 	/*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
 	/*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
 
+    virtual void buildDrawLabel();
+
 	/*virtual*/ U32 getNominalHeight( void ) const;
+
+private:
+    enable_signal_t mVisibleSignal;
 };
 
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -442,6 +449,7 @@ public:
 	/*virtual*/ void drawBackground(LLMenuItemGL* itemp, F32 alpha);
 	/*virtual*/ void setVisible(BOOL visible);
 	/*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
+    /*virtual*/ void deleteAllChildren();
 	/*virtual*/ void removeChild( LLView* ctrl);
 	/*virtual*/ BOOL postBuild();
 	
diff --git a/indra/llui/llpanel.h b/indra/llui/llpanel.h
index b8f47ef6ba..8018365d3e 100644
--- a/indra/llui/llpanel.h
+++ b/indra/llui/llpanel.h
@@ -127,6 +127,7 @@ public:
 	virtual 	void	clearCtrls(); // overridden in LLPanelObject and LLPanelVolume
 
 	// Border controls
+	const LLViewBorder* getBorder() const { return mBorder; }
 	void addBorder( LLViewBorder::Params p);
 	void addBorder();
 	void			removeBorder();
diff --git a/indra/llui/llresizehandle.cpp b/indra/llui/llresizehandle.cpp
index 24794305ac..13ef0fdb7f 100644
--- a/indra/llui/llresizehandle.cpp
+++ b/indra/llui/llresizehandle.cpp
@@ -70,6 +70,11 @@ LLResizeHandle::LLResizeHandle(const LLResizeHandle::Params& p)
 	}
 }
 
+LLResizeHandle::~LLResizeHandle()
+{
+    gFocusMgr.removeKeyboardFocusWithoutCallback(this);
+}
+
 
 BOOL LLResizeHandle::handleMouseDown(S32 x, S32 y, MASK mask)
 {
diff --git a/indra/llui/llresizehandle.h b/indra/llui/llresizehandle.h
index 7541b9e6c0..ae20ecaa77 100644
--- a/indra/llui/llresizehandle.h
+++ b/indra/llui/llresizehandle.h
@@ -45,6 +45,7 @@ public:
 		Params();
 	};
 
+    ~LLResizeHandle();
 protected:
 	LLResizeHandle(const LLResizeHandle::Params&);
 	friend class LLUICtrlFactory;
diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp
index fde6de4921..735e2d529e 100644
--- a/indra/llui/llscrollbar.cpp
+++ b/indra/llui/llscrollbar.cpp
@@ -188,12 +188,12 @@ void LLScrollbar::setPageSize( S32 page_size )
 	}
 }
 
-BOOL LLScrollbar::isAtBeginning()
+bool LLScrollbar::isAtBeginning() const
 {
 	return mDocPos == 0;
 }
 
-BOOL LLScrollbar::isAtEnd()
+bool LLScrollbar::isAtEnd() const
 {
 	return mDocPos == getDocPosMax();
 }
@@ -591,7 +591,12 @@ void LLScrollbar::setValue(const LLSD& value)
 
 BOOL LLScrollbar::handleKeyHere(KEY key, MASK mask)
 {
-	BOOL handled = FALSE;
+    if (getDocPosMax() == 0 && !getVisible())
+    {
+        return FALSE;
+    }
+
+    BOOL handled = FALSE;
 
 	switch( key )
 	{
diff --git a/indra/llui/llscrollbar.h b/indra/llui/llscrollbar.h
index 5f2f490d81..9be9d22db8 100644
--- a/indra/llui/llscrollbar.h
+++ b/indra/llui/llscrollbar.h
@@ -105,8 +105,8 @@ public:
 	bool				setDocPos( S32 pos, BOOL update_thumb = TRUE );
 	S32					getDocPos() const		{ return mDocPos; }
 
-	BOOL				isAtBeginning();
-	BOOL				isAtEnd();
+	bool				isAtBeginning() const;
+	bool				isAtEnd() const;
 
 	// Setting both at once.
 	void				setDocParams( S32 size, S32 pos );
diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
index 3db38bbfac..ad32f7186c 100644
--- a/indra/llui/llscrollcontainer.cpp
+++ b/indra/llui/llscrollcontainer.cpp
@@ -105,8 +105,8 @@ LLScrollContainer::LLScrollContainer(const LLScrollContainer::Params& p)
 	mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
 	LLView::addChild( mBorder );
 
-	mInnerRect.set( 0, getRect().getHeight(), getRect().getWidth(), 0 );
-	mInnerRect.stretch( -getBorderWidth()  );
+	mInnerRect = getLocalRect();
+	mInnerRect.stretch( -getBorderWidth() );
 
 	LLRect vertical_scroll_rect = mInnerRect;
 	vertical_scroll_rect.mLeft = vertical_scroll_rect.mRight - scrollbar_size;
@@ -124,8 +124,9 @@ LLScrollContainer::LLScrollContainer(const LLScrollContainer::Params& p)
 	mScrollbar[VERTICAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
 	LLView::addChild( mScrollbar[VERTICAL] );
 	
-	LLRect horizontal_scroll_rect = mInnerRect;
-	horizontal_scroll_rect.mTop = horizontal_scroll_rect.mBottom + scrollbar_size;
+	LLRect horizontal_scroll_rect;
+	horizontal_scroll_rect.mTop = scrollbar_size;
+	horizontal_scroll_rect.mRight = mInnerRect.getWidth();
 	sbparams.name("scrollable horizontal");
 	sbparams.rect(horizontal_scroll_rect);
 	sbparams.orientation(LLScrollbar::HORIZONTAL);
@@ -134,7 +135,7 @@ LLScrollContainer::LLScrollContainer(const LLScrollContainer::Params& p)
 	sbparams.page_size(mInnerRect.getWidth());
 	sbparams.step_size(VERTICAL_MULTIPLE);
 	sbparams.visible(false);
-	sbparams.follows.flags(FOLLOWS_LEFT | FOLLOWS_RIGHT);
+	sbparams.follows.flags(FOLLOWS_LEFT | FOLLOWS_RIGHT | FOLLOWS_BOTTOM);
 	sbparams.change_callback(p.scroll_callback);
 	mScrollbar[HORIZONTAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
 	LLView::addChild( mScrollbar[HORIZONTAL] );
diff --git a/indra/llui/llscrollcontainer.h b/indra/llui/llscrollcontainer.h
index c14099dbd5..dacea2a987 100644
--- a/indra/llui/llscrollcontainer.h
+++ b/indra/llui/llscrollcontainer.h
@@ -98,8 +98,10 @@ public:
 	void			pageDown(S32 overlap = 0);
 	void			goToTop();
 	void			goToBottom();
-	bool			isAtTop() { return mScrollbar[VERTICAL]->isAtBeginning(); }
-	bool			isAtBottom() { return mScrollbar[VERTICAL]->isAtEnd(); }
+	bool			isAtTop() const { return mScrollbar[VERTICAL]->isAtBeginning(); }
+	bool			isAtBottom() const { return mScrollbar[VERTICAL]->isAtEnd(); }
+    S32             getDocPosVertical() const { return mScrollbar[VERTICAL]->getDocPos(); }
+    S32             getDocPosHorizontal() const { return mScrollbar[HORIZONTAL]->getDocPos(); }
 	S32				getBorderWidth() const;
 
 	// LLView functionality
diff --git a/indra/llui/lltabcontainer.cpp b/indra/llui/lltabcontainer.cpp
index 8c841540a5..76b9e448a1 100644
--- a/indra/llui/lltabcontainer.cpp
+++ b/indra/llui/lltabcontainer.cpp
@@ -605,6 +605,7 @@ BOOL LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
 			LLButton* tab_button = getTab(index)->mButton;
 			gFocusMgr.setMouseCapture(this);
 			tab_button->setFocus(TRUE);
+            mMouseDownTimer.start();
 		}
 	}
 	if (handled) {
@@ -653,7 +654,11 @@ BOOL LLTabContainer::handleHover( S32 x, S32 y, MASK mask )
 		handled = LLPanel::handleHover(x, y, mask);
 	}
 
-	commitHoveredButton(x, y);
+    F32 drag_delay = 0.25f; // filter out clicks from dragging
+    if (mMouseDownTimer.getElapsedTimeF32() > drag_delay)
+    {
+        commitHoveredButton(x, y);
+    }
 	return handled;
 }
 
@@ -699,6 +704,7 @@ BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
 	}
 
 	commitHoveredButton(x, y);
+    mMouseDownTimer.stop();
 	LLPanel* cur_panel = getCurrentPanel();
 	if (hasMouseCapture())
 	{
@@ -1002,7 +1008,7 @@ void LLTabContainer::addTabPanel(const TabPanelParams& panel)
 	}
 	else
 	{
-		//Scip tab button space if they are invisible(EXT - 576)
+		// Skip tab button space if tabs are invisible (EXT-576)
 		tab_panel_top = getRect().getHeight();
 		tab_panel_bottom = LLPANEL_BORDER_WIDTH;
 	}
@@ -1017,9 +1023,9 @@ void LLTabContainer::addTabPanel(const TabPanelParams& panel)
 	}
 	else
 	{
-		tab_panel_rect = LLRect(LLPANEL_BORDER_WIDTH, 
+		tab_panel_rect = LLRect(LLPANEL_BORDER_WIDTH * 3,
 								tab_panel_top,
-								getRect().getWidth()-LLPANEL_BORDER_WIDTH,
+								getRect().getWidth() - LLPANEL_BORDER_WIDTH * 2,
 								tab_panel_bottom );
 	}
 	child->setFollowsAll();
@@ -1106,7 +1112,7 @@ void LLTabContainer::addTabPanel(const TabPanelParams& panel)
 		  p.follows.flags = p.follows.flags() | FOLLOWS_TOP;
 		}
 		else
-		  { 
+		{ 
 		    p.name("htab_"+std::string(child->getName()));
 		    p.visible(false);
 		    p.image_unselected(tab_img);
diff --git a/indra/llui/lltabcontainer.h b/indra/llui/lltabcontainer.h
index 8f8cedb1b9..aa4a08c4ff 100644
--- a/indra/llui/lltabcontainer.h
+++ b/indra/llui/lltabcontainer.h
@@ -320,6 +320,7 @@ private:
 	LLUIColor						mTabsFlashingColor;
 	S32								mTabIconCtrlPad;
 	bool							mUseTabEllipses;
+    LLFrameTimer					mMouseDownTimer;
 };
 
 #endif  // LL_TABCONTAINER_H
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index 82a3c01c6d..8732a7ce45 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -361,7 +361,7 @@ void LLTextBase::onValueChange(S32 start, S32 end)
 {
 }
 
-std::vector<LLRect> LLTextBase::getSelctionRects()
+std::vector<LLRect> LLTextBase::getSelectionRects()
 {
     // Nor supposed to be called without selection
     llassert(hasSelection());
@@ -458,7 +458,7 @@ void LLTextBase::drawSelectionBackground()
     // Draw selection even if we don't have keyboard focus for search/replace
     if (hasSelection() && !mLineInfoList.empty())
     {
-        std::vector<LLRect> selection_rects = getSelctionRects();
+        std::vector<LLRect> selection_rects = getSelectionRects();
 		
 		// Draw the selection box (we're using a box instead of reversing the colors on the selected text).
 		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
@@ -1356,9 +1356,9 @@ void LLTextBase::draw()
 		drawCursor();
 	}
  
-	mDocumentView->setVisible(FALSE);
+	mDocumentView->setVisibleDirect(FALSE);
 	LLUICtrl::draw();
-	mDocumentView->setVisible(TRUE);
+	mDocumentView->setVisibleDirect(TRUE);
 }
 
 
@@ -3464,7 +3464,7 @@ bool LLNormalTextSegment::getDimensionsF32(S32 first_char, S32 num_chars, F32& w
 		height = mFontHeight;
 		const LLWString &text = getWText();
 		// if last character is a newline, then return true, forcing line break
-		width = mStyle->getFont()->getWidthF32(text.c_str(), mStart + first_char, num_chars);
+		width = mStyle->getFont()->getWidthF32(text.c_str(), mStart + first_char, num_chars, true);
 	}
 	return false;
 }
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index e3cf56a5ee..3611ab0499 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -638,7 +638,7 @@ protected:
 		return mLabel.getString() + getToolTip();
 	}
 
-    std::vector<LLRect> getSelctionRects();
+    std::vector<LLRect> getSelectionRects();
 
 protected:
 	// text segmentation and flow
diff --git a/indra/llui/lltextbox.cpp b/indra/llui/lltextbox.cpp
index c567451973..521dabf9d4 100644
--- a/indra/llui/lltextbox.cpp
+++ b/indra/llui/lltextbox.cpp
@@ -171,7 +171,8 @@ void LLTextBox::reshapeToFitText(BOOL called_from_parent)
 
 	S32 width = getTextPixelWidth();
 	S32 height = getTextPixelHeight();
-	reshape( width + 2 * mHPad, height + 2 * mVPad, called_from_parent );
+    //consider investigating reflow() to find missing width pixel (see SL-17045 changes)
+	reshape( width + 2 * mHPad + 1, height + 2 * mVPad, called_from_parent );
 }
 
 
diff --git a/indra/llui/lltooltip.cpp b/indra/llui/lltooltip.cpp
index 2f56a8b1d0..a6552d4ff1 100644
--- a/indra/llui/lltooltip.cpp
+++ b/indra/llui/lltooltip.cpp
@@ -163,6 +163,7 @@ LLToolTip::LLToolTip(const LLToolTip::Params& p)
 :	LLPanel(p),
 	mHasClickCallback(p.click_callback.isProvided()),
 	mPadding(p.padding),
+	mMaxWidth(p.max_width),
 	mTextBox(NULL),
 	mInfoButton(NULL),
 	mPlayMediaButton(NULL),
@@ -272,7 +273,7 @@ void LLToolTip::initFromParams(const LLToolTip::Params& p)
 
 	// do this *after* we've had our size set in LLPanel::initFromParams();
 	const S32 REALLY_LARGE_HEIGHT = 10000;
-	mTextBox->reshape(p.max_width, REALLY_LARGE_HEIGHT);
+	mTextBox->reshape(mMaxWidth, REALLY_LARGE_HEIGHT);
 
 	if (p.styled_message.isProvided())
 	{
@@ -288,16 +289,19 @@ void LLToolTip::initFromParams(const LLToolTip::Params& p)
 		mTextBox->setText(p.message());
 	}
 
-	S32 text_width = llmin(p.max_width(), mTextBox->getTextPixelWidth() + 1);
+	updateTextBox();
+	snapToChildren();
+}
+
+void LLToolTip::updateTextBox()
+{
+	S32 text_width = llmin(mMaxWidth, mTextBox->getTextPixelWidth() + 1);
 	S32 text_height = mTextBox->getTextPixelHeight();
 	mTextBox->reshape(text_width, text_height);
-	if (mInfoButton)
-	{
-		LLRect text_rect = mTextBox->getRect();
-		LLRect icon_rect = mInfoButton->getRect();
-		mTextBox->translate(0, icon_rect.getCenterY() - text_rect.getCenterY());
-	}
-
+}
+ 
+void LLToolTip::snapToChildren()
+{
 	// reshape tooltip panel to fit text box
 	LLRect tooltip_rect = calcBoundingRect();
 	tooltip_rect.mTop += mPadding;
@@ -305,7 +309,14 @@ void LLToolTip::initFromParams(const LLToolTip::Params& p)
 	tooltip_rect.mBottom = 0;
 	tooltip_rect.mLeft = 0;
 
-	mTextBox->reshape(mTextBox->getRect().getWidth(), llmax(mTextBox->getRect().getHeight(), tooltip_rect.getHeight() - 2 * mPadding));
+	if (mInfoButton)
+	{
+		mTextBox->reshape(mTextBox->getRect().getWidth(), llmax(mTextBox->getRect().getHeight(), tooltip_rect.getHeight() - 2 * mPadding));
+
+		LLRect text_rect = mTextBox->getRect();
+		LLRect icon_rect = mInfoButton->getRect();
+		mInfoButton->translate(0, text_rect.getCenterY() - icon_rect.getCenterY());
+	}
 
 	setShape(tooltip_rect);
 }
@@ -428,7 +439,10 @@ void LLToolTipMgr::createToolTip(const LLToolTip::Params& params)
 	}
 	tooltip_params.rect = LLRect (0, 1, 1, 0);
 
-	mToolTip = LLUICtrlFactory::create<LLToolTip> (tooltip_params);
+	if (tooltip_params.create_callback.isProvided())
+		mToolTip = tooltip_params.create_callback()(tooltip_params);
+	else
+		mToolTip = LLUICtrlFactory::create<LLToolTip> (tooltip_params);
 
 	gToolTipView->addChild(mToolTip);
 
diff --git a/indra/llui/lltooltip.h b/indra/llui/lltooltip.h
index 0b1fbe5367..86943625ff 100644
--- a/indra/llui/lltooltip.h
+++ b/indra/llui/lltooltip.h
@@ -68,6 +68,7 @@ public:
 	struct Params : public LLInitParam::Block<Params, LLPanel::Params> 
 	{
 		typedef boost::function<void(void)> click_callback_t;
+		typedef boost::function<LLToolTip*(LLToolTip::Params)> create_callback_t;
 
 		Optional<std::string>		message;
 		Multiple<StyledText>		styled_message;
@@ -84,6 +85,8 @@ public:
 		Optional<bool>				time_based_media,
 									web_based_media,
 									media_playing;
+		Optional<create_callback_t>	create_callback;
+		Optional<LLSD>				create_params;
 		Optional<click_callback_t>	click_callback,
 									click_playmedia_callback,
 									click_homepage_callback;
@@ -103,11 +106,15 @@ public:
 	bool hasClickCallback();
 
 	LLToolTip(const Params& p);
-	void initFromParams(const LLToolTip::Params& params);
+	virtual void initFromParams(const LLToolTip::Params& params);
 
 	void getToolTipMessage(std::string & message);
 
-private:
+protected:
+	void updateTextBox();
+	void snapToChildren();
+
+protected:
 	class LLTextBox*	mTextBox;
 	class LLButton*     mInfoButton;
 	class LLButton*     mPlayMediaButton;
@@ -117,6 +124,7 @@ private:
 	LLFrameTimer	mVisibleTimer;
 	bool			mHasClickCallback;
 	S32				mPadding;	// pixels
+	S32				mMaxWidth;
 };
 
 // used for the inspector tooltips which need different background images etc.
diff --git a/indra/llui/lluicolortable.cpp b/indra/llui/lluicolortable.cpp
index 244f0c6f00..096336045c 100644
--- a/indra/llui/lluicolortable.cpp
+++ b/indra/llui/lluicolortable.cpp
@@ -200,7 +200,6 @@ LLUIColor LLUIColorTable::getColor(const std::string& name, const LLColor4& defa
 void LLUIColorTable::setColor(const std::string& name, const LLColor4& color)
 {
 	setColor(name, color, mUserSetColors);
-	setColor(name, color, mLoadedColors);
 }
 
 bool LLUIColorTable::loadFromSettings()
@@ -229,6 +228,11 @@ void LLUIColorTable::saveUserSettings() const
 		it != mUserSetColors.end();
 		++it)
 	{
+		// Compare user color value with the default value, skip if equal
+		string_color_map_t::const_iterator itd = mLoadedColors.find(it->first);
+		if(itd != mLoadedColors.end() && itd->second == it->second)
+			continue;
+
 		ColorEntryParams color_entry;
 		color_entry.name = it->first;
 		color_entry.color.value = it->second;
diff --git a/indra/llui/lluictrl.cpp b/indra/llui/lluictrl.cpp
index 2196ba201b..21afcae7c3 100644
--- a/indra/llui/lluictrl.cpp
+++ b/indra/llui/lluictrl.cpp
@@ -531,6 +531,15 @@ void LLUICtrl::setControlVariable(LLControlVariable* control)
 	}
 }
 
+void LLUICtrl::removeControlVariable()
+{
+    if (mControlVariable)
+    {
+        mControlConnection.disconnect();
+        mControlVariable = NULL;
+    }
+}
+
 //virtual
 void LLUICtrl::setControlName(const std::string& control_name, LLView *context)
 {
diff --git a/indra/llui/lluictrl.h b/indra/llui/lluictrl.h
index 67dd24341c..be1c7dd0b6 100644
--- a/indra/llui/lluictrl.h
+++ b/indra/llui/lluictrl.h
@@ -175,6 +175,7 @@ public:
 	bool setControlValue(const LLSD& value);
 	void setControlVariable(LLControlVariable* control);
 	virtual void setControlName(const std::string& control, LLView *context = NULL);
+    void removeControlVariable();
 	
 	LLControlVariable* getControlVariable() { return mControlVariable; } 
 	
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 9ba71913d0..da7868d804 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -311,7 +311,13 @@ bool LLView::addChild(LLView* child, S32 tab_group)
 	}
 
 	child->mParentView = this;
-	updateBoundingRect();
+    if (getVisible() && child->getVisible())
+    {
+        // if child isn't visible it won't affect bounding rect
+        // if current view is not visible it will be recalculated
+        // on visibility change
+        updateBoundingRect();
+    }
 	mLastTabGroup = tab_group;
 	return true;
 }
@@ -576,9 +582,12 @@ void LLView::deleteAllChildren()
 
 	while (!mChildList.empty())
 	{
-		LLView* viewp = mChildList.front();
-		delete viewp; // will remove the child from mChildList
+        LLView* viewp = mChildList.front();
+        viewp->mParentView = NULL;
+        delete viewp;
+        mChildList.pop_front();
 	}
+    updateBoundingRect();
 }
 
 void LLView::setAllChildrenEnabled(BOOL b)
@@ -877,6 +886,17 @@ LLView*	LLView::childFromPoint(S32 x, S32 y, bool recur)
 	return 0;
 }
 
+F32 LLView::getTooltipTimeout()
+{
+    static LLCachedControl<F32> tooltip_fast_delay(*LLUI::getInstance()->mSettingGroups["config"], "ToolTipFastDelay", 0.1f);
+    static LLCachedControl<F32> tooltip_delay(*LLUI::getInstance()->mSettingGroups["config"], "ToolTipDelay", 0.7f);
+    // allow "scrubbing" over ui by showing next tooltip immediately
+    // if previous one was still visible
+    return (F32)(LLToolTipMgr::instance().toolTipVisible()
+    ? tooltip_fast_delay
+    : tooltip_delay);
+}
+
 BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	BOOL handled = FALSE;
@@ -886,14 +906,7 @@ BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
 	std::string tooltip = getToolTip();
 	if (!tooltip.empty())
 	{
-        static LLCachedControl<F32> tooltip_fast_delay(*LLUI::getInstance()->mSettingGroups["config"], "ToolTipFastDelay", 0.1f);
-        static LLCachedControl<F32> tooltip_delay(*LLUI::getInstance()->mSettingGroups["config"], "ToolTipDelay", 0.7f);
         static LLCachedControl<bool> allow_ui_tooltips(*LLUI::getInstance()->mSettingGroups["config"], "BasicUITooltips", true);
-		// allow "scrubbing" over ui by showing next tooltip immediately
-		// if previous one was still visible
-		F32 timeout = LLToolTipMgr::instance().toolTipVisible() 
-		              ? tooltip_fast_delay
-		              : tooltip_delay;
 
 		// Even if we don't show tooltips, consume the event, nothing below should show tooltip
 		if (allow_ui_tooltips)
@@ -901,7 +914,7 @@ BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
 			LLToolTipMgr::instance().show(LLToolTip::Params()
 			                              .message(tooltip)
 			                              .sticky_rect(calcScreenRect())
-			                              .delay_time(timeout));
+			                              .delay_time(getTooltipTimeout()));
 		}
 		handled = TRUE;
 	}
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
index bec45df78a..7360fd0fb9 100644
--- a/indra/llui/llview.h
+++ b/indra/llui/llview.h
@@ -243,6 +243,7 @@ public:
 
 	ECursorType	getHoverCursor() { return mHoverCursor; }
 
+    static F32 getTooltipTimeout();
 	virtual const std::string getToolTip() const			{ return mToolTipMsg.getString(); }
 
 	void		sendChildToFront(LLView* child);
@@ -287,6 +288,7 @@ public:
 	void 	setAllChildrenEnabled(BOOL b);
 
 	virtual void	setVisible(BOOL visible);
+	void			setVisibleDirect(BOOL visible) { mVisible = visible; }
 	const BOOL&		getVisible() const			{ return mVisible; }
 	virtual void	setEnabled(BOOL enabled);
 	BOOL			getEnabled() const			{ return mEnabled; }