merge from dessie/viewer-public right before SLE code landed

51 files changed, 1196 insertions, 570 deletions

diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt
index 532b6b6524..3ecab90756 100644
--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@@ -52,6 +52,7 @@ set(llui_SOURCE_FILES
     llkeywords.cpp
     lllayoutstack.cpp
     lllineeditor.cpp
+    llloadingindicator.cpp
     lllocalcliprect.cpp
     llmenubutton.cpp
     llmenugl.cpp
@@ -144,6 +145,7 @@ set(llui_HEADER_FILES
     lllayoutstack.h
     lllazyvalue.h
     lllineeditor.h
+    llloadingindicator.h
     lllocalcliprect.h
     llmenubutton.h
     llmenugl.h
diff --git a/indra/llui/llaccordionctrl.cpp b/indra/llui/llaccordionctrl.cpp
index 2ed1082f56..5d1d57cbb2 100644
--- a/indra/llui/llaccordionctrl.cpp
+++ b/indra/llui/llaccordionctrl.cpp
@@ -329,14 +329,34 @@ void LLAccordionCtrl::addCollapsibleCtrl(LLView* view)
 	LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(view);
 	if(!accordion_tab)
 		return;
-	if(std::find(getChildList()->begin(),getChildList()->end(),accordion_tab) == getChildList()->end())
+	if(std::find(beginChild(), endChild(), accordion_tab) == endChild())
 		addChild(accordion_tab);
 	mAccordionTabs.push_back(accordion_tab);
-	
+
 	accordion_tab->setDropDownStateChangedCallback( boost::bind(&LLAccordionCtrl::onCollapseCtrlCloseOpen, this, mAccordionTabs.size() - 1) );
 
 }
 
+void LLAccordionCtrl::removeCollapsibleCtrl(LLView* view)
+{
+	LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(view);
+	if(!accordion_tab)
+		return;
+
+	if(std::find(beginChild(), endChild(), accordion_tab) != endChild())
+		removeChild(accordion_tab);
+
+	for (std::vector<LLAccordionCtrlTab*>::iterator iter = mAccordionTabs.begin();
+			iter != mAccordionTabs.end(); ++iter)
+	{
+		if (accordion_tab == (*iter))
+		{
+			mAccordionTabs.erase(iter);
+			break;
+		}
+	}
+}
+
 void	LLAccordionCtrl::arrangeSinge()
 {
 	S32 panel_left = BORDER_MARGIN;	  // Margin from left side of Splitter
@@ -372,11 +392,33 @@ void	LLAccordionCtrl::arrangeSinge()
 		}
 		else
 		{
-			panel_height = expanded_height;
+			if(mFitParent)
+			{
+				panel_height = expanded_height;
+			}
+			else
+			{
+				if(accordion_tab->getAccordionView())
+				{
+					panel_height = accordion_tab->getAccordionView()->getRect().getHeight() + 
+						accordion_tab->getHeaderHeight() + 2*BORDER_MARGIN;
+				}
+				else
+				{
+					panel_height = accordion_tab->getRect().getHeight();
+				}
+			}
 		}
+
+		// make sure at least header is shown
+		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();
 	}
+
+	show_hide_scrollbar(getRect().getWidth(), getRect().getHeight());
+	updateLayout(getRect().getWidth(), getRect().getHeight());
 }
 
 void	LLAccordionCtrl::arrangeMultiple()
@@ -626,15 +668,23 @@ S32	LLAccordionCtrl::notifyParent(const LLSD& info)
 				LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
 				if(accordion_tab->hasFocus() && i>0)
 				{
+					bool prev_visible_tab_found = false;
 					while(i>0)
 					{
 						if(mAccordionTabs[--i]->getVisible())
+						{
+							prev_visible_tab_found = true;
 							break;
+						}
+					}
+
+					if (prev_visible_tab_found)
+					{
+						accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+						accordion_tab->notify(LLSD().with("action","select_last"));
+						return 1;
 					}
-					
-					accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
-					accordion_tab->notify(LLSD().with("action","select_last"));
-					return 1;
+					break;
 				}
 			}
 			return 0;
diff --git a/indra/llui/llaccordionctrl.h b/indra/llui/llaccordionctrl.h
index 7c29e545b7..ab7d6548ca 100644
--- a/indra/llui/llaccordionctrl.h
+++ b/indra/llui/llaccordionctrl.h
@@ -92,6 +92,7 @@ public:
 	virtual void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
 
 	void addCollapsibleCtrl(LLView* view);
+	void removeCollapsibleCtrl(LLView* view);
 	void arrange();
 
 
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
index e12776f83a..596da782ce 100644
--- a/indra/llui/llaccordionctrltab.cpp
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -425,6 +425,9 @@ bool LLAccordionCtrlTab::addChild(LLView* child, S32 tab_group)
 			setDisplayChildren(getDisplayChildren());	
 	}
 
+	if (!mContainerPanel)
+		mContainerPanel = findContainerView();
+
 	return res;
 }
 
@@ -433,6 +436,34 @@ void LLAccordionCtrlTab::setAccordionView(LLView* panel)
 	addChild(panel,0);
 }
 
+void LLAccordionCtrlTab::setTitle(const std::string& title)
+{
+	LLAccordionCtrlTabHeader* header = findChild<LLAccordionCtrlTabHeader>(DD_HEADER_NAME);
+	if (header)
+	{
+		header->setTitle(title);
+	}
+}
+
+boost::signals2::connection LLAccordionCtrlTab::setFocusReceivedCallback(const focus_signal_t::slot_type& cb)
+{
+	LLAccordionCtrlTabHeader* header = findChild<LLAccordionCtrlTabHeader>(DD_HEADER_NAME);
+	if (header)
+	{
+		return header->setFocusReceivedCallback(cb);
+	}
+	return boost::signals2::connection();
+}
+
+boost::signals2::connection LLAccordionCtrlTab::setFocusLostCallback(const focus_signal_t::slot_type& cb)
+{
+	LLAccordionCtrlTabHeader* header = findChild<LLAccordionCtrlTabHeader>(DD_HEADER_NAME);
+	if (header)
+	{
+		return header->setFocusLostCallback(cb);
+	}
+	return boost::signals2::connection();
+}
 
 LLView*	LLAccordionCtrlTab::findContainerView()
 {
@@ -465,10 +496,11 @@ void LLAccordionCtrlTab::setHeaderVisible(bool value)
 	reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
 };
 
-//vurtual
+//virtual
 BOOL LLAccordionCtrlTab::postBuild()
 {
-	mHeader->setVisible(mHeaderVisible);
+	if(mHeader)
+		mHeader->setVisible(mHeaderVisible);
 	
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 
@@ -504,7 +536,8 @@ BOOL LLAccordionCtrlTab::postBuild()
 		mScrollbar->setVisible(false);
 	}
 
-	mContainerPanel->setVisible(mDisplayChildren);
+	if(mContainerPanel)
+		mContainerPanel->setVisible(mDisplayChildren);
 
 	return LLUICtrl::postBuild();
 }
@@ -549,7 +582,8 @@ S32	LLAccordionCtrlTab::notifyParent(const LLSD& info)
 			}
 			
 			//LLAccordionCtrl should rearrange accodion tab if one of accordion change its size
-			getParent()->notifyParent(info);
+			if (getParent()) // A parent may not be set if tabs are added dynamically.
+				getParent()->notifyParent(info);
 			return 1;
 		}
 		else if(str_action == "select_prev") 
@@ -858,5 +892,16 @@ void LLAccordionCtrlTab::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top,
 	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) )
+	{
+		//inside tab header
+		//fix for EXT-6619
+		return TRUE;
+	}
+	return LLUICtrl::handleToolTip(x, y, mask);
+}
 
 
diff --git a/indra/llui/llaccordionctrltab.h b/indra/llui/llaccordionctrltab.h
index 462ccc6d53..de254ed3eb 100644
--- a/indra/llui/llaccordionctrltab.h
+++ b/indra/llui/llaccordionctrltab.h
@@ -35,8 +35,9 @@
 
 #include <string>
 #include "llrect.h"
+#include "lluictrl.h"
+#include "lluicolor.h"
 
-class LLUICtrl;
 class LLUICtrlFactory;
 class LLUIImage;
 class LLButton;
@@ -112,6 +113,12 @@ public:
 	void		setAccordionView(LLView* panel);
 	LLView*		getAccordionView() { return mContainerPanel; };
 
+	// Set text in LLAccordionCtrlTabHeader
+	void setTitle(const std::string& title);
+
+	boost::signals2::connection setFocusReceivedCallback(const focus_signal_t::slot_type& cb);
+	boost::signals2::connection setFocusLostCallback(const focus_signal_t::slot_type& cb);
+
 	bool getCollapsible() {return mCollapsible;};
 
 	void setCollapsible(bool collapsible) {mCollapsible = collapsible;};
@@ -147,6 +154,8 @@ public:
 	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
 	virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
 
+	virtual BOOL handleToolTip(S32 x, S32 y, MASK mask);
+
 	virtual bool addChild(LLView* child, S32 tab_group);
 
 	bool isExpanded() { return mDisplayChildren; }
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 1d4dc35cee..0255061b12 100644
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -824,7 +824,7 @@ void LLButton::draw()
 			x = text_right;
 			break;
 		case LLFontGL::HCENTER:
-			x = getRect().getWidth() / 2;
+			x = text_left + (text_width / 2);
 			break;
 		case LLFontGL::LEFT:
 		default:
@@ -1003,6 +1003,11 @@ void LLButton::setImageDisabledSelected(LLPointer<LLUIImage> image)
 	mFadeWhenDisabled = TRUE;
 }
 
+void LLButton::setImagePressed(LLPointer<LLUIImage> image)
+{
+	mImagePressed = image;
+}
+
 void LLButton::setImageHoverSelected(LLPointer<LLUIImage> image)
 {
 	mImageHoverSelected = image;
diff --git a/indra/llui/llbutton.h b/indra/llui/llbutton.h
index 6a1e3a9425..a4d81ed6c3 100644
--- a/indra/llui/llbutton.h
+++ b/indra/llui/llbutton.h
@@ -246,6 +246,7 @@ public:
 	void			setImageHoverUnselected(LLPointer<LLUIImage> image);
 	void			setImageDisabled(LLPointer<LLUIImage> image);
 	void			setImageDisabledSelected(LLPointer<LLUIImage> image);
+	void			setImagePressed(LLPointer<LLUIImage> image);
 
 	void			setCommitOnReturn(BOOL commit) { mCommitOnReturn = commit; }
 	BOOL			getCommitOnReturn() const { return mCommitOnReturn; }
diff --git a/indra/llui/llcombobox.cpp b/indra/llui/llcombobox.cpp
index 9127a22875..f49069f065 100644
--- a/indra/llui/llcombobox.cpp
+++ b/indra/llui/llcombobox.cpp
@@ -493,7 +493,6 @@ void LLComboBox::createLineEditor(const LLComboBox::Params& p)
 		params.max_length_bytes(mMaxChars);
 		params.commit_callback.function(boost::bind(&LLComboBox::onTextCommit, this, _2));
 		params.keystroke_callback(boost::bind(&LLComboBox::onTextEntry, this, _1));
-		params.handle_edit_keys_directly(true);
 		params.commit_on_focus_lost(false);
 		params.follows.flags(FOLLOWS_ALL);
 		params.label(mLabel);
diff --git a/indra/llui/lldraghandle.cpp b/indra/llui/lldraghandle.cpp
index 832f148902..9f83fcca35 100644
--- a/indra/llui/lldraghandle.cpp
+++ b/indra/llui/lldraghandle.cpp
@@ -248,15 +248,14 @@ void LLDragHandleTop::reshapeTitleBox()
 		return;
 	}
 	const LLFontGL* font = LLFontGL::getFontSansSerif();
-	S32 title_width = font->getWidth( mTitleBox->getText() ) + TITLE_HPAD;
-	if (getMaxTitleWidth() > 0)
-		title_width = llmin(title_width, getMaxTitleWidth());
+	S32 title_width = getRect().getWidth();
+	title_width -= LEFT_PAD + 2 * BORDER_PAD + getButtonsRect().getWidth();
 	S32 title_height = llround(font->getLineHeight());
 	LLRect title_rect;
 	title_rect.setLeftTopAndSize( 
 		LEFT_PAD, 
 		getRect().getHeight() - title_vpad,
-		getRect().getWidth() - LEFT_PAD - RIGHT_PAD,
+		title_width,
 		title_height);
 
 	// calls reshape on mTitleBox
diff --git a/indra/llui/lldraghandle.h b/indra/llui/lldraghandle.h
index dc5410787b..825bc9303e 100644
--- a/indra/llui/lldraghandle.h
+++ b/indra/llui/lldraghandle.h
@@ -71,6 +71,8 @@ public:
 	BOOL			getForeground() const		{ return mForeground; }
 	void			setMaxTitleWidth(S32 max_width) {mMaxTitleWidth = llmin(max_width, mMaxTitleWidth); }
 	S32				getMaxTitleWidth() const { return mMaxTitleWidth; }
+	void			setButtonsRect(const LLRect& rect){ mButtonsRect = rect; }
+	LLRect			getButtonsRect() { return mButtonsRect; }
 	void			setTitleVisible(BOOL visible);
 
 	virtual void	setTitle( const std::string& title ) = 0;
@@ -88,6 +90,7 @@ protected:
 	LLTextBox*		mTitleBox;
 	
 private:
+	LLRect			mButtonsRect;
 	S32				mDragLastScreenX;
 	S32				mDragLastScreenY;
 	S32				mLastMouseScreenX;
diff --git a/indra/llui/lleditmenuhandler.cpp b/indra/llui/lleditmenuhandler.cpp
index 821afae8fd..245bce76f5 100644
--- a/indra/llui/lleditmenuhandler.cpp
+++ b/indra/llui/lleditmenuhandler.cpp
@@ -37,3 +37,10 @@
 /* static */
 LLEditMenuHandler* LLEditMenuHandler::gEditMenuHandler = NULL;
 
+LLEditMenuHandler::~LLEditMenuHandler()
+{
+	if (gEditMenuHandler == this)
+	{
+		gEditMenuHandler = NULL;
+	}
+}
diff --git a/indra/llui/lleditmenuhandler.h b/indra/llui/lleditmenuhandler.h
index 1de9c56afb..d72283cd99 100644
--- a/indra/llui/lleditmenuhandler.h
+++ b/indra/llui/lleditmenuhandler.h
@@ -38,7 +38,7 @@ class LLEditMenuHandler
 {
 public:
 	// this is needed even though this is just an interface class.
-	virtual ~LLEditMenuHandler() {};
+	virtual ~LLEditMenuHandler();
 	
 	virtual void	undo() {};
 	virtual BOOL	canUndo() const { return FALSE; }
diff --git a/indra/llui/llfiltereditor.cpp b/indra/llui/llfiltereditor.cpp
index 390504234d..6c80275713 100644
--- a/indra/llui/llfiltereditor.cpp
+++ b/indra/llui/llfiltereditor.cpp
@@ -39,6 +39,7 @@
 LLFilterEditor::LLFilterEditor(const LLFilterEditor::Params& p)
 :	LLSearchEditor(p)
 {
+	setCommitOnFocusLost(FALSE); // we'll commit on every keystroke, don't re-commit when we take focus away (i.e. we go to interact with the actual results!)
 }
 
 
diff --git a/indra/llui/llflatlistview.cpp b/indra/llui/llflatlistview.cpp
index 2e5aeec41d..6bd16c9ee6 100644
--- a/indra/llui/llflatlistview.cpp
+++ b/indra/llui/llflatlistview.cpp
@@ -1,10 +1,10 @@
 /** 
  * @file llflatlistview.cpp
- * @brief LLFlatListView base class
+ * @brief LLFlatListView base class and extension to support messages for several cases of an empty list.
  *
  * $LicenseInfo:firstyear=2009&license=viewergpl$
  * 
- * Copyright (c) 2009, Linden Research, Inc.
+ * Copyright (c) 2009-2010, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -243,7 +243,7 @@ LLUUID LLFlatListView::getSelectedUUID() const
 	}
 }
 
-void LLFlatListView::getSelectedUUIDs(std::vector<LLUUID>& selected_uuids) const
+void LLFlatListView::getSelectedUUIDs(uuid_vec_t& selected_uuids) const
 {
 	if (mSelectedItemPairs.empty()) return;
 
@@ -297,6 +297,27 @@ void LLFlatListView::setNoItemsCommentText(const std::string& comment_text)
 	mNoItemsCommentTextbox->setValue(comment_text);
 }
 
+U32 LLFlatListView::size(const bool only_visible_items) const
+{
+	if (only_visible_items)
+	{
+		U32 size = 0;
+		for (pairs_const_iterator_t
+				 iter = mItemPairs.begin(),
+				 iter_end = mItemPairs.end();
+			 iter != iter_end; ++iter)
+		{
+			if ((*iter)->first->getVisible())
+				++size;
+		}
+		return size;
+	}
+	else
+	{
+		return mItemPairs.size();
+	}
+}
+
 void LLFlatListView::clear()
 {
 	// do not use LLView::deleteAllChildren to avoid removing nonvisible items. drag-n-drop for ex.
@@ -358,6 +379,7 @@ LLFlatListView::LLFlatListView(const LLFlatListView::Params& p)
   , mCommitOnSelectionChange(false)
   , mPrevNotifyParentRect(LLRect())
   , mNoItemsCommentTextbox(NULL)
+  , mIsConsecutiveSelection(false)
 {
 	mBorderThickness = getBorderWidth();
 
@@ -426,7 +448,7 @@ void LLFlatListView::rearrangeItems()
 {
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 
-	setNoItemsCommentVisible(mItemPairs.empty());
+	setNoItemsCommentVisible(0==size());
 
 	if (mItemPairs.empty()) return;
 
@@ -504,7 +526,80 @@ void LLFlatListView::onItemMouseClick(item_pair_t* item_pair, MASK mask)
 
 	//*TODO find a better place for that enforcing stuff
 	if (mKeepOneItemSelected && numSelected() == 1 && !select_item) return;
-	
+
+	if ( (mask & MASK_SHIFT) && !(mask & MASK_CONTROL)
+		 && mMultipleSelection && !mSelectedItemPairs.empty() )
+	{
+		item_pair_t* last_selected_pair = mSelectedItemPairs.back();
+
+		// If item_pair is already selected - do nothing
+		if (last_selected_pair == item_pair)
+			return;
+
+		bool grab_items = false;
+		bool reverse = false;
+		pairs_list_t pairs_to_select;
+
+		// Pick out items from list between last selected and current clicked item_pair.
+		for (pairs_iterator_t
+				 iter = mItemPairs.begin(),
+				 iter_end = mItemPairs.end();
+			 iter != iter_end; ++iter)
+		{
+			item_pair_t* cur = *iter;
+			if (cur == last_selected_pair || cur == item_pair)
+			{
+				// We've got reverse selection if last grabed item isn't a new selection.
+				reverse = grab_items && (cur != item_pair);
+				grab_items = !grab_items;
+				// Skip last selected and current clicked item pairs.
+				continue;
+			}
+			if (!cur->first->getVisible())
+			{
+				// Skip invisible item pairs.
+				continue;
+			}
+			if (grab_items)
+			{
+				pairs_to_select.push_back(cur);
+			}
+		}
+
+		if (reverse)
+		{
+			pairs_to_select.reverse();
+		}
+
+		pairs_to_select.push_back(item_pair);
+
+		for (pairs_iterator_t
+				 iter = pairs_to_select.begin(),
+				 iter_end = pairs_to_select.end();
+			 iter != iter_end; ++iter)
+		{
+			item_pair_t* pair_to_select = *iter;
+			if (isSelected(pair_to_select))
+			{
+				// Item was already selected but there is a need to keep order from last selected pair to new selection.
+				// Do it here to prevent extra mCommitOnSelectionChange in selectItemPair().
+				mSelectedItemPairs.remove(pair_to_select);
+				mSelectedItemPairs.push_back(pair_to_select);
+			}
+			else
+			{
+				selectItemPair(pair_to_select, true);
+			}
+		}
+
+		if (!select_item)
+		{
+			// Update last selected item border.
+			mSelectedItemsBorder->setRect(getLastSelectedItemRect().stretch(-1));
+		}
+		return;
+	}
+
 	if (!(mask & MASK_CONTROL) || !mMultipleSelection) resetSelection();
 	selectItemPair(item_pair, select_item);
 }
@@ -558,15 +653,6 @@ BOOL LLFlatListView::handleKeyHere(KEY key, MASK mask)
 			}
 			break;
 		}
-		case 'A':
-		{
-			if(MASK_CONTROL & mask)
-			{
-				selectAll();
-				handled = TRUE;
-			}
-			break;
-		}
 		default:
 			break;
 	}
@@ -676,6 +762,8 @@ bool LLFlatListView::selectItemPair(item_pair_t* item_pair, bool select)
 
 	// Stretch selected item rect to ensure it won't be clipped
 	mSelectedItemsBorder->setRect(getLastSelectedItemRect().stretch(-1));
+	// By default mark it as not consecutive selection
+	mIsConsecutiveSelection = false;
 
 	return true;
 }
@@ -692,14 +780,44 @@ LLRect LLFlatListView::getLastSelectedItemRect()
 
 void LLFlatListView::selectFirstItem	()
 {
-	selectItemPair(mItemPairs.front(), true);
-	ensureSelectedVisible();
+	// No items - no actions!
+	if (0 == size()) return;
+
+	// Select first visible item
+	for (pairs_iterator_t
+			 iter = mItemPairs.begin(),
+			 iter_end = mItemPairs.end();
+		 iter != iter_end; ++iter)
+	{
+		// skip invisible items
+		if ( (*iter)->first->getVisible() )
+		{
+			selectItemPair(*iter, true);
+			ensureSelectedVisible();
+			break;
+		}
+	}
 }
 
 void LLFlatListView::selectLastItem		()
 {
-	selectItemPair(mItemPairs.back(), true);
-	ensureSelectedVisible();
+	// No items - no actions!
+	if (0 == size()) return;
+
+	// Select last visible item
+	for (pairs_list_t::reverse_iterator
+			 r_iter = mItemPairs.rbegin(),
+			 r_iter_end = mItemPairs.rend();
+		 r_iter != r_iter_end; ++r_iter)
+	{
+		// skip invisible items
+		if ( (*r_iter)->first->getVisible() )
+		{
+			selectItemPair(*r_iter, true);
+			ensureSelectedVisible();
+			break;
+		}
+	}
 }
 
 void LLFlatListView::ensureSelectedVisible()
@@ -717,14 +835,25 @@ void LLFlatListView::ensureSelectedVisible()
 bool LLFlatListView::selectNextItemPair(bool is_up_direction, bool reset_selection)
 {
 	// No items - no actions!
-	if ( !mItemPairs.size() )
+	if ( 0 == size() )
 		return false;
 
-	
-	item_pair_t* to_sel_pair = NULL;
-	item_pair_t* cur_sel_pair = NULL;
+	if (!mIsConsecutiveSelection)
+	{
+		// Leave only one item selected if list has not consecutive selection
+		if (mSelectedItemPairs.size() && !reset_selection)
+		{
+			item_pair_t* cur_sel_pair = mSelectedItemPairs.back();
+			resetSelection();
+			selectItemPair (cur_sel_pair, true);
+		}
+	}
+
 	if ( mSelectedItemPairs.size() )
 	{
+		item_pair_t* to_sel_pair = NULL;
+		item_pair_t* cur_sel_pair = NULL;
+
 		// Take the last selected pair
 		cur_sel_pair = mSelectedItemPairs.back();
 		// Bases on given direction choose next item to select
@@ -758,43 +887,52 @@ bool LLFlatListView::selectNextItemPair(bool is_up_direction, bool reset_selecti
 				}
 			}
 		}
+
+		if ( to_sel_pair )
+		{
+			bool select = true;
+			if ( reset_selection )
+			{
+				// Reset current selection if we were asked about it
+				resetSelection();
+			}
+			else
+			{
+				// If item already selected and no reset request than we should deselect last selected item.
+				select = (mSelectedItemPairs.end() == std::find(mSelectedItemPairs.begin(), mSelectedItemPairs.end(), to_sel_pair));
+			}
+			// Select/Deselect next item
+			selectItemPair(select ? to_sel_pair : cur_sel_pair, select);
+			// Mark it as consecutive selection
+			mIsConsecutiveSelection = true;
+			return true;
+		}
 	}
 	else
 	{
 		// If there weren't selected items then choose the first one bases on given direction
-		cur_sel_pair = (is_up_direction) ? mItemPairs.back() : mItemPairs.front();
 		// Force selection to first item
-		to_sel_pair = cur_sel_pair;
-	}
-
-
-	if ( to_sel_pair )
-	{
-		bool select = true;
-
-		if ( reset_selection )
-		{
-			// Reset current selection if we were asked about it
-			resetSelection();
-		}
+		if (is_up_direction)
+			selectLastItem();
 		else
-		{
-			// If item already selected and no reset request than we should deselect last selected item.
-			select = (mSelectedItemPairs.end() == std::find(mSelectedItemPairs.begin(), mSelectedItemPairs.end(), to_sel_pair));
-		}
-
-		// Select/Deselect next item
-		selectItemPair(select ? to_sel_pair : cur_sel_pair, select);
-
+			selectFirstItem();
+		// Mark it as consecutive selection
+		mIsConsecutiveSelection = true;
 		return true;
 	}
+
 	return false;
 }
 
-bool LLFlatListView::selectAll()
+BOOL LLFlatListView::canSelectAll() const
 {
-	if (!mAllowSelection)
-		return false;
+	return 0 != size() && mAllowSelection && mMultipleSelection;
+}
+
+void LLFlatListView::selectAll()
+{
+	if (!mAllowSelection || !mMultipleSelection)
+		return;
 
 	mSelectedItemPairs.clear();
 
@@ -814,8 +952,6 @@ bool LLFlatListView::selectAll()
 
 	// Stretch selected item rect to ensure it won't be clipped
 	mSelectedItemsBorder->setRect(getLastSelectedItemRect().stretch(-1));
-
-	return true;
 }
 
 bool LLFlatListView::isSelected(item_pair_t* item_pair) const
@@ -953,11 +1089,17 @@ void LLFlatListView::getValues(std::vector<LLSD>& values) const
 void LLFlatListView::onFocusReceived()
 {
 	mSelectedItemsBorder->setVisible(TRUE);
+	gEditMenuHandler = this;
 }
 // virtual
 void LLFlatListView::onFocusLost()
 {
 	mSelectedItemsBorder->setVisible(FALSE);
+	// Route menu back to the default
+ 	if( gEditMenuHandler == this )
+	{
+		gEditMenuHandler = NULL;
+	}
 }
 
 //virtual 
@@ -1061,4 +1203,90 @@ void LLFlatListView::detachItems(std::vector<LLPanel*>& detached_items)
 	}
 }
 
+
+/************************************************************************/
+/*             LLFlatListViewEx implementation                          */
+/************************************************************************/
+LLFlatListViewEx::Params::Params()
+: no_items_msg("no_items_msg")
+, no_filtered_items_msg("no_filtered_items_msg")
+{
+
+}
+
+LLFlatListViewEx::LLFlatListViewEx(const Params& p)
+:	LLFlatListView(p)
+, mNoFilteredItemsMsg(p.no_filtered_items_msg)
+, mNoItemsMsg(p.no_items_msg)
+{
+
+}
+
+void LLFlatListViewEx::updateNoItemsMessage(const std::string& filter_string)
+{
+	bool items_filtered = !filter_string.empty();
+	if (items_filtered)
+	{
+		// items were filtered
+		LLStringUtil::format_map_t args;
+		args["[SEARCH_TERM]"] = LLURI::escape(filter_string);
+		std::string text = mNoFilteredItemsMsg;
+		LLStringUtil::format(text, args);
+		setNoItemsCommentText(text);
+	}
+	else
+	{
+		// list does not contain any items at all
+		setNoItemsCommentText(mNoItemsMsg);
+	}
+
+}
+
+void LLFlatListViewEx::setFilterSubString(const std::string& filter_str)
+{
+	if (0 != LLStringUtil::compareInsensitive(filter_str, mFilterSubString))
+	{
+		mFilterSubString = filter_str;
+		updateNoItemsMessage(mFilterSubString);
+		filterItems();
+	}
+}
+
+void LLFlatListViewEx::filterItems()
+{
+	typedef std::vector <LLPanel*> item_panel_list_t;
+
+	std::string cur_filter = mFilterSubString;
+	LLStringUtil::toUpper(cur_filter);
+
+	LLSD action;
+	action.with("match_filter", cur_filter);
+
+	item_panel_list_t items;
+	getItems(items);
+
+	for (item_panel_list_t::iterator
+			 iter = items.begin(),
+			 iter_end = items.end();
+		 iter != iter_end; ++iter)
+	{
+		LLPanel* pItem = (*iter);
+		// 0 signifies that filter is matched,
+		// i.e. we don't hide items that don't support 'match_filter' action, separators etc.
+		if (0 == pItem->notify(action))
+		{
+			pItem->setVisible(true);
+		}
+		else
+		{
+			// TODO: implement (re)storing of current selection.
+			selectItem(pItem, false);
+			pItem->setVisible(false);
+		}
+	}
+
+	rearrangeItems();
+	notifyParentItemsRectChanged();
+}
+
 //EOF
diff --git a/indra/llui/llflatlistview.h b/indra/llui/llflatlistview.h
index 92cb40332e..f4e0426f15 100644
--- a/indra/llui/llflatlistview.h
+++ b/indra/llui/llflatlistview.h
@@ -1,10 +1,10 @@
 /** 
  * @file llflatlistview.h
- * @brief LLFlatListView base class
+ * @brief LLFlatListView base class and extension to support messages for several cases of an empty list.
  *
  * $LicenseInfo:firstyear=2009&license=viewergpl$
  * 
- * Copyright (c) 2009, Linden Research, Inc.
+ * Copyright (c) 2009-2010, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -58,7 +58,7 @@
  * - Order of returned selected items are not guaranteed
  * - The control assumes that all items being added are unique.
  */
-class LLFlatListView : public LLScrollContainer
+class LLFlatListView : public LLScrollContainer, public LLEditMenuHandler
 {
 public:
 
@@ -114,8 +114,6 @@ public:
 		Params();
 	};
 	
-	virtual ~LLFlatListView() { clear(); };
-
 	/**
 	 * Connects callback to signal called when Return key is pressed.
 	 */
@@ -224,7 +222,7 @@ public:
 	 * Get LLUUIDs associated with selected items
 	 * @param selected_uuids An std::vector being populated with LLUUIDs associated with selected items
 	 */
-	virtual void getSelectedUUIDs(std::vector<LLUUID>& selected_uuids) const;
+	virtual void getSelectedUUIDs(uuid_vec_t& selected_uuids) const;
 
 	/** Get the top selected item */
 	virtual LLPanel* getSelectedItem() const;
@@ -266,9 +264,8 @@ public:
 	/** Get number of selected items in the list */
 	U32 numSelected() const {return mSelectedItemPairs.size(); }
 
-	/** Get number of items in the list */
-	U32 size() const { return mItemPairs.size(); }
-
+	/** Get number of (visible) items in the list */
+	U32 size(const bool only_visible_items = true) const;
 
 	/** Removes all items from the list */
 	virtual void clear();
@@ -344,7 +341,8 @@ protected:
 
 	virtual bool selectNextItemPair(bool is_up_direction, bool reset_selection);
 
-	virtual bool selectAll();
+	virtual BOOL canSelectAll() const;
+	virtual void selectAll();
 
 	virtual bool isSelected(item_pair_t* item_pair) const;
 
@@ -379,11 +377,14 @@ private:
 
 	void setNoItemsCommentVisible(bool visible) const;
 
-private:
+protected:
 
 	/** Comparator to use when sorting the list. */
 	const ItemComparator* mItemComparator;
 
+
+private:
+
 	LLPanel* mItemsPanel;
 
 	S32 mItemsNoScrollWidth;
@@ -409,6 +410,8 @@ private:
 
 	bool mKeepOneItemSelected;
 
+	bool mIsConsecutiveSelection;
+
 	/** All pairs of the list */
 	pairs_list_t mItemPairs;
 
@@ -428,4 +431,66 @@ private:
 	commit_signal_t	mOnReturnSignal;
 };
 
+/**
+ * Extends LLFlatListView functionality to show different messages when there are no items in the
+ * list depend on whether they are filtered or not.
+ *
+ * Class provides one message per case of empty list.
+ * It also provides protected updateNoItemsMessage() method to be called each time when derived list
+ * is changed to update base mNoItemsCommentTextbox value.
+ *
+ * It is implemented to avoid duplication of this functionality in concrete implementations of the
+ * lists. It is intended to be used as a base class for lists which should support two different
+ * messages for empty state. Can be improved to support more than two messages via state-to-message map.
+ */
+class LLFlatListViewEx : public LLFlatListView
+{
+public:
+	struct Params : public LLInitParam::Block<Params, LLFlatListView::Params>
+	{
+		/**
+		 * Contains a message for empty list when it does not contain any items at all.
+		 */
+		Optional<std::string>	no_items_msg;
+
+		/**
+		 * Contains a message for empty list when its items are removed by filtering.
+		 */
+		Optional<std::string>	no_filtered_items_msg;
+		Params();
+	};
+
+	// *WORKAROUND: two methods to overload appropriate Params due to localization issue:
+	// no_items_msg & no_filtered_items_msg attributes are not defined as translatable in VLT. See EXT-5931
+	void setNoItemsMsg(const std::string& msg) { mNoItemsMsg = msg; }
+	void setNoFilteredItemsMsg(const std::string& msg) { mNoFilteredItemsMsg = msg; }
+
+	/**
+	 * Sets up new filter string and filters the list.
+	 */
+	void setFilterSubString(const std::string& filter_str);
+	
+	/**
+	 * Filters the list, rearranges and notifies parent about shape changes.
+	 * Derived classes may want to overload rearrangeItems() to exclude repeated separators after filtration.
+	 */
+	void filterItems();
+
+protected:
+	LLFlatListViewEx(const Params& p);
+
+	/**
+	 * Applies a message for empty list depend on passed argument.
+	 *
+	 * @param filter_string - if is not empty, message for filtered items will be set, otherwise for
+	 * completely empty list. Value of filter string will be passed as search_term in SLURL.
+	 */
+	void updateNoItemsMessage(const std::string& filter_string);
+
+private:
+	std::string mNoFilteredItemsMsg;
+	std::string mNoItemsMsg;
+	std::string	mFilterSubString;
+};
+
 #endif
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index ab14c08948..79c47a1136 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -346,7 +346,7 @@ void LLFloater::layoutDragHandle()
 		rect = getLocalRect();
 	}
 	mDragHandle->setRect(rect);
-	updateButtons();
+	updateTitleButtons();
 	applyTitle();
 }
 
@@ -563,6 +563,7 @@ void LLFloater::handleVisibilityChange ( BOOL new_visibility )
 
 void LLFloater::openFloater(const LLSD& key)
 {
+	llinfos << "Opening floater " << getName() << llendl;
 	mKey = key; // in case we need to open ourselves again
 	
 	if (getSoundFlags() != SILENT 
@@ -603,6 +604,7 @@ void LLFloater::openFloater(const LLSD& key)
 
 void LLFloater::closeFloater(bool app_quitting)
 {
+	llinfos << "Closing floater " << getName() << llendl;
 	if (app_quitting)
 	{
 		LLFloater::sQuitting = true;
@@ -1061,11 +1063,10 @@ void LLFloater::setMinimized(BOOL minimize)
 		// Reshape *after* setting mMinimized
 		reshape( mExpandedRect.getWidth(), mExpandedRect.getHeight(), TRUE );
 	}
-	
-	applyTitle ();
 
 	make_ui_sound("UISndWindowClose");
-	updateButtons();
+	updateTitleButtons();
+	applyTitle ();
 }
 
 void LLFloater::setFocus( BOOL b )
@@ -1121,6 +1122,7 @@ void LLFloater::setIsChrome(BOOL is_chrome)
 		setFocus(FALSE);
 		// can't Ctrl-Tab to "chrome" floaters
 		setFocusRoot(FALSE);
+		mButtons[BUTTON_CLOSE]->setToolTip(LLStringExplicit(getButtonTooltip(Params(), BUTTON_CLOSE, is_chrome)));
 	}
 	
 	// no titles displayed on "chrome" floaters
@@ -1190,7 +1192,7 @@ void LLFloater::setHost(LLMultiFloater* host)
 		mButtonScale = 1.f;
 		//mButtonsEnabled[BUTTON_TEAR_OFF] = FALSE;
 	}
-	updateButtons();
+	updateTitleButtons();
 	if (host)
 	{
 		mHostHandle = host->getHandle();
@@ -1389,7 +1391,7 @@ void LLFloater::setCanDock(bool b)
 			mButtonsEnabled[BUTTON_DOCK] = FALSE;
 		}
 	}
-	updateButtons();
+	updateTitleButtons();
 }
 
 void LLFloater::setDocked(bool docked, bool pop_on_undock)
@@ -1398,7 +1400,7 @@ void LLFloater::setDocked(bool docked, bool pop_on_undock)
 	{
 		mDocked = docked;
 		mButtonsEnabled[BUTTON_DOCK] = !mDocked;
-		updateButtons();
+		updateTitleButtons();
 
 		storeDockStateControl();
 	}
@@ -1451,7 +1453,7 @@ void LLFloater::onClickTearOff(LLFloater* self)
 		}
 		self->setTornOff(false);
 	}
-	self->updateButtons();
+	self->updateTitleButtons();
 }
 
 // static
@@ -1691,7 +1693,7 @@ void	LLFloater::setCanMinimize(BOOL can_minimize)
 	mButtonsEnabled[BUTTON_MINIMIZE] = can_minimize && !isMinimized();
 	mButtonsEnabled[BUTTON_RESTORE]  = can_minimize &&  isMinimized();
 
-	updateButtons();
+	updateTitleButtons();
 }
 
 void	LLFloater::setCanClose(BOOL can_close)
@@ -1699,7 +1701,7 @@ void	LLFloater::setCanClose(BOOL can_close)
 	mCanClose = can_close;
 	mButtonsEnabled[BUTTON_CLOSE] = can_close;
 
-	updateButtons();
+	updateTitleButtons();
 }
 
 void	LLFloater::setCanTearOff(BOOL can_tear_off)
@@ -1707,7 +1709,7 @@ void	LLFloater::setCanTearOff(BOOL can_tear_off)
 	mCanTearOff = can_tear_off;
 	mButtonsEnabled[BUTTON_TEAR_OFF] = mCanTearOff && !mHostHandle.isDead();
 
-	updateButtons();
+	updateTitleButtons();
 }
 
 
@@ -1731,10 +1733,11 @@ void LLFloater::setCanDrag(BOOL can_drag)
 	}
 }
 
-void LLFloater::updateButtons()
+void LLFloater::updateTitleButtons()
 {
 	static LLUICachedControl<S32> floater_close_box_size ("UIFloaterCloseBoxSize", 0);
 	static LLUICachedControl<S32> close_box_from_top ("UICloseBoxFromTop", 0);
+	LLRect buttons_rect;
 	S32 button_count = 0;
 	for (S32 i = 0; i < BUTTON_COUNT; i++)
 	{
@@ -1785,6 +1788,18 @@ void LLFloater::updateButtons()
 					llround((F32)floater_close_box_size * mButtonScale));
 			}
 
+			// first time here, init 'buttons_rect'
+			if(1 == button_count)
+			{
+				buttons_rect = btn_rect;
+			}
+			else
+			{
+				// if mDragOnLeft=true then buttons are on top-left side vertically aligned
+				// title is not displayed in this case, calculating 'buttons_rect' for future use
+				mDragOnLeft ? buttons_rect.mBottom -= btn_rect.mBottom : 
+					buttons_rect.mLeft = btn_rect.mLeft;
+			}
 			mButtons[i]->setRect(btn_rect);
 			mButtons[i]->setVisible(TRUE);
 			// the restore button should have a tab stop so that it takes action when you Ctrl-Tab to a minimized floater
@@ -1796,7 +1811,10 @@ void LLFloater::updateButtons()
 		}
 	}
 	if (mDragHandle)
-		mDragHandle->setMaxTitleWidth(getRect().getWidth() - (button_count * (floater_close_box_size + 1)));
+	{
+		localRectToOtherView(buttons_rect, &buttons_rect, mDragHandle);
+		mDragHandle->setButtonsRect(buttons_rect);
+	}
 }
 
 void LLFloater::buildButtons(const Params& floater_params)
@@ -1844,7 +1862,7 @@ void LLFloater::buildButtons(const Params& floater_params)
 		p.click_callback.function(boost::bind(sButtonCallbacks[i], this));
 		p.tab_stop(false);
 		p.follows.flags(FOLLOWS_TOP|FOLLOWS_RIGHT);
-		p.tool_tip = getButtonTooltip(floater_params, (EFloaterButton)i);
+		p.tool_tip = getButtonTooltip(floater_params, (EFloaterButton)i, getIsChrome());
 		p.scale_image(true);
 		p.chrome(true);
 
@@ -1853,7 +1871,7 @@ void LLFloater::buildButtons(const Params& floater_params)
 		mButtons[i] = buttonp;
 	}
 
-	updateButtons();
+	updateTitleButtons();
 }
 
 // static
@@ -1899,8 +1917,15 @@ LLUIImage* LLFloater::getButtonPressedImage(const Params& p, EFloaterButton e)
 }
 
 // static
-std::string LLFloater::getButtonTooltip(const Params& p, EFloaterButton e)
+std::string LLFloater::getButtonTooltip(const Params& p, EFloaterButton e, bool is_chrome)
 {
+	// EXT-4081 (Lag Meter: Ctrl+W does not close floater)
+	// If floater is chrome set 'Close' text for close button's tooltip
+	if(is_chrome && BUTTON_CLOSE == e)
+	{
+		static std::string close_tooltip_chrome = LLTrans::getString("BUTTON_CLOSE_CHROME");
+		return close_tooltip_chrome;
+	}
 	// TODO: per-floater localizable tooltips set in XML
 	return sButtonToolTips[e];
 }
@@ -2810,3 +2835,15 @@ bool LLFloater::isShown(const LLFloater* floater)
 {
     return floater && floater->isShown();
 }
+
+/* static */
+bool LLFloater::isMinimized(const LLFloater* floater)
+{
+    return floater && floater->isMinimized();
+}
+
+/* static */
+bool LLFloater::isVisible(const LLFloater* floater)
+{
+    return floater && floater->getVisible();
+}
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
index c1e8813f87..444711de81 100644
--- a/indra/llui/llfloater.h
+++ b/indra/llui/llfloater.h
@@ -194,6 +194,8 @@ public:
 	/// The static isShown() can accept a NULL pointer (which of course
 	/// returns false). When non-NULL, it calls the non-static isShown().
 	static bool		isShown(const LLFloater* floater);
+	static bool     isVisible(const LLFloater* floater);
+	static bool     isMinimized(const LLFloater* floater);
 	BOOL			isFirstLook() { return mFirstLook; } // EXT-2653: This function is necessary to prevent overlapping for secondary showed toasts
 	BOOL			isFrontmost();
 	BOOL			isDependent()					{ return !mDependeeHandle.isDead(); }
@@ -309,19 +311,26 @@ protected:
 
 	virtual	void	onClickCloseBtn();
 
+	virtual void	updateTitleButtons();
+
 private:
 	void			setForeground(BOOL b);	// called only by floaterview
 	void			cleanupHandles(); // remove handles to dead floaters
 	void			createMinimizeButton();
-	void			updateButtons();
 	void			buildButtons(const Params& p);
 	
 	// Images and tooltips are named in the XML, but we want to look them
 	// up by index.
 	static LLUIImage*	getButtonImage(const Params& p, EFloaterButton e);
 	static LLUIImage*	getButtonPressedImage(const Params& p, EFloaterButton e);
-	static std::string	getButtonTooltip(const Params& p, EFloaterButton e);
 	
+	/**
+	 * @params is_chrome - if floater is Chrome it means that floater will never get focus.
+	 * Therefore it can't be closed with 'Ctrl+W'. So the tooltip text of close button( X )
+	 * should be 'Close' not 'Close(Ctrl+W)' as for usual floaters.
+	 */
+	static std::string	getButtonTooltip(const Params& p, EFloaterButton e, bool is_chrome);
+
 	BOOL			offerClickToButton(S32 x, S32 y, MASK mask, EFloaterButton index);
 	void			addResizeCtrls();
 	void			layoutResizeCtrls();
@@ -423,11 +432,15 @@ private:
 
 class LLFloaterView : public LLUICtrl
 {
+public:
+	struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>{};
+
 protected:
 	LLFloaterView (const Params& p);
 	friend class LLUICtrlFactory;
 
 public:
+
 	/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
 	void reshapeFloater(S32 width, S32 height, BOOL called_from_parent, BOOL adjust_vertical);
 
diff --git a/indra/llui/llfloaterreg.cpp b/indra/llui/llfloaterreg.cpp
index 5de3934c8a..7588d8ab7a 100644
--- a/indra/llui/llfloaterreg.cpp
+++ b/indra/llui/llfloaterreg.cpp
@@ -272,11 +272,11 @@ bool LLFloaterReg::toggleInstance(const std::string& name, const LLSD& key)
 }
 
 //static
-// returns true if the instance exists and is visible
+// returns true if the instance exists and is visible (doesnt matter minimized or not)
 bool LLFloaterReg::instanceVisible(const std::string& name, const LLSD& key)
 {
 	LLFloater* instance = findInstance(name, key); 
-	return LLFloater::isShown(instance);
+	return LLFloater::isVisible(instance);
 }
 
 //static
@@ -463,3 +463,12 @@ bool LLFloaterReg::floaterInstanceVisible(const LLSD& sdname)
 	return instanceVisible(name, key);
 }
 
+//static
+bool LLFloaterReg::floaterInstanceMinimized(const LLSD& sdname)
+{
+	LLSD key;
+	std::string name = sdname.asString();
+	parse_name_key(name, key);
+	LLFloater* instance = findInstance(name, key); 
+	return LLFloater::isShown(instance);
+}
diff --git a/indra/llui/llfloaterreg.h b/indra/llui/llfloaterreg.h
index 8a11d5c3f2..5cacf76771 100644
--- a/indra/llui/llfloaterreg.h
+++ b/indra/llui/llfloaterreg.h
@@ -134,6 +134,7 @@ public:
 	static void hideFloaterInstance(const LLSD& sdname);
 	static void toggleFloaterInstance(const LLSD& sdname);
 	static bool floaterInstanceVisible(const LLSD& sdname);
+	static bool floaterInstanceMinimized(const LLSD& sdname);
 	
 	// Typed find / get / show
 	template <class T>
diff --git a/indra/llui/lliconctrl.h b/indra/llui/lliconctrl.h
index 66368f979b..7e37600409 100644
--- a/indra/llui/lliconctrl.h
+++ b/indra/llui/lliconctrl.h
@@ -73,6 +73,7 @@ public:
 	std::string	getImageName() const;
 
 	void			setColor(const LLColor4& color) { mColor = color; }
+	void			setImage(LLPointer<LLUIImage> image) { mImagep = image; }
 	
 private:
 	void setIconImageDrawSize() ;
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
index 483a394bbd..45f9de8e8d 100644
--- a/indra/llui/lllineeditor.cpp
+++ b/indra/llui/lllineeditor.cpp
@@ -91,7 +91,6 @@ LLLineEditor::Params::Params()
 	background_image_disabled("background_image_disabled"),
 	background_image_focused("background_image_focused"),
 	select_on_focus("select_on_focus", false),
-	handle_edit_keys_directly("handle_edit_keys_directly", false),
 	revert_on_esc("revert_on_esc", true),
 	commit_on_focus_lost("commit_on_focus_lost", true),
 	ignore_tab("ignore_tab", true),
@@ -136,7 +135,6 @@ LLLineEditor::LLLineEditor(const LLLineEditor::Params& p)
 	mIgnoreArrowKeys( FALSE ),
 	mIgnoreTab( p.ignore_tab ),
 	mDrawAsterixes( FALSE ),
-	mHandleEditKeysDirectly(p.handle_edit_keys_directly),
 	mSelectAllonFocusReceived( p.select_on_focus ),
 	mPassDelete(FALSE),
 	mReadOnly(FALSE),
@@ -192,12 +190,8 @@ LLLineEditor::~LLLineEditor()
 {
 	mCommitOnFocusLost = FALSE;
 
+	// calls onCommit() while LLLineEditor still valid
 	gFocusMgr.releaseFocusIfNeeded( this );
-
-	if( gEditMenuHandler == this )
-	{
-		gEditMenuHandler = NULL;
-	}
 }
 
 
@@ -497,6 +491,7 @@ void LLLineEditor::selectAll()
 	setCursor(mSelectionEnd);
 	//mScrollHPos = 0;
 	mIsSelecting = TRUE;
+	updatePrimary();
 }
 
 
@@ -788,7 +783,7 @@ void LLLineEditor::removeChar()
 	}
 	else
 	{
-		reportBadKeystroke();
+		LLUI::reportBadKeystroke();
 	}
 }
 
@@ -827,7 +822,7 @@ void LLLineEditor::addChar(const llwchar uni_char)
 	}
 	else
 	{
-		reportBadKeystroke();
+		LLUI::reportBadKeystroke();
 	}
 
 	getWindow()->hideCursorUntilMouseMove();
@@ -916,7 +911,7 @@ BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			break;
 
@@ -932,7 +927,7 @@ BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			break;
 
@@ -958,22 +953,6 @@ BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
 		}
 	}
 
-	if (!handled && mHandleEditKeysDirectly)
-	{
-		if( (MASK_CONTROL & mask) && ('A' == key) )
-		{
-			if( canSelectAll() )
-			{
-				selectAll();
-			}
-			else
-			{
-				reportBadKeystroke();
-			}
-			handled = TRUE;
-		}
-	}
-
 	if(handled)
 	{
 		// take selection to 'primary' clipboard
@@ -1020,7 +999,7 @@ void LLLineEditor::cut()
 		if( need_to_rollback )
 		{
 			rollback.doRollback( this );
-			reportBadKeystroke();
+			LLUI::reportBadKeystroke();
 		}
 		else
 		if( mKeystrokeCallback )
@@ -1129,7 +1108,7 @@ void LLLineEditor::pasteHelper(bool is_primary)
 				}
 				// Truncate the clean string at the limit of what will fit
 				clean_string = clean_string.substr(0, wchars_that_fit);
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
  
 			mText.insert(getCursor(), clean_string);
@@ -1141,7 +1120,7 @@ void LLLineEditor::pasteHelper(bool is_primary)
 			if( need_to_rollback )
 			{
 				rollback.doRollback( this );
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			else
 			if( mKeystrokeCallback )
@@ -1206,7 +1185,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 		}
 		handled = TRUE;
@@ -1255,7 +1234,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			handled = TRUE;
 		}
@@ -1282,7 +1261,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			handled = TRUE;
 		}
@@ -1299,7 +1278,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			handled = TRUE;
 		}
@@ -1316,7 +1295,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
 			}
 			else
 			{
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 			handled = TRUE;
 		}
@@ -1339,64 +1318,6 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
 		break;
 	}
 
-	if( !handled && mHandleEditKeysDirectly )
-	{
-		// Standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system.
-		if( KEY_DELETE == key )
-		{
-			if( canDoDelete() )
-			{
-				doDelete();
-			}
-			else
-			{
-				reportBadKeystroke();
-			}
-			handled = TRUE;
-		}
-		else
-		if( MASK_CONTROL & mask )
-		{
-			if( 'C' == key )
-			{
-				if( canCopy() )
-				{
-					copy();
-				}
-				else
-				{
-					reportBadKeystroke();
-				}
-				handled = TRUE;
-			}
-			else
-			if( 'V' == key )
-			{
-				if( canPaste() )
-				{
-					paste();
-				}
-				else
-				{
-					reportBadKeystroke();
-				}
-				handled = TRUE;
-			}
-			else
-			if( 'X' == key )
-			{
-				if( canCut() )
-				{
-					cut();
-				}
-				else
-				{
-					reportBadKeystroke();
-				}
-				handled = TRUE;
-			}
-		}
-	}
 	return handled;
 }
 
@@ -1451,7 +1372,7 @@ BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask )
 			{
 				rollback.doRollback(this);
 
-				reportBadKeystroke();
+				LLUI::reportBadKeystroke();
 			}
 
 			// Notify owner if requested
@@ -1499,7 +1420,7 @@ BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
 		{
 			rollback.doRollback( this );
 
-			reportBadKeystroke();
+			LLUI::reportBadKeystroke();
 		}
 
 		// Notify owner if requested
@@ -1519,7 +1440,7 @@ BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
 
 BOOL LLLineEditor::canDoDelete() const
 {
-	return ( !mReadOnly && (!mPassDelete || (hasSelection() || (getCursor() < mText.length()))) );
+	return ( !mReadOnly && mText.length() > 0 && (!mPassDelete || (hasSelection() || (getCursor() < mText.length()))) );
 }
 
 void LLLineEditor::doDelete()
@@ -1544,7 +1465,7 @@ void LLLineEditor::doDelete()
 		if( need_to_rollback )
 		{
 			rollback.doRollback( this );
-			reportBadKeystroke();
+			LLUI::reportBadKeystroke();
 		}
 		else
 		{
@@ -1879,11 +1800,6 @@ S32 LLLineEditor::findPixelNearestPos(const S32 cursor_offset) const
 	return result;
 }
 
-void LLLineEditor::reportBadKeystroke()
-{
-	make_ui_sound("UISndBadKeystroke");
-}
-
 //virtual
 void LLLineEditor::clear()
 {
diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
index b62138426b..9489e723e3 100644
--- a/indra/llui/lllineeditor.h
+++ b/indra/llui/lllineeditor.h
@@ -81,7 +81,6 @@ public:
 										background_image_focused;
 
 		Optional<bool>					select_on_focus,
-										handle_edit_keys_directly,
 										revert_on_esc,
 										commit_on_focus_lost,
 										ignore_tab;
@@ -215,7 +214,6 @@ public:
 	void			extendSelection(S32 new_cursor_pos);
 	void			deleteSelection();
 
-	void			setHandleEditKeysDirectly( BOOL b ) { mHandleEditKeysDirectly = b; }
 	void			setSelectAllonFocusReceived(BOOL b);
 	
 	typedef boost::function<void (LLLineEditor* caller, void* user_data)> callback_t;
@@ -247,7 +245,6 @@ private:
 	void			addChar(const llwchar c);
 	void			setCursorAtLocalPos(S32 local_mouse_x);
 	S32				findPixelNearestPos(S32 cursor_offset = 0) const;
-	void			reportBadKeystroke();
 	BOOL			handleSpecialKey(KEY key, MASK mask);
 	BOOL			handleSelectionKey(KEY key, MASK mask);
 	BOOL			handleControlKey(KEY key, MASK mask);
@@ -325,7 +322,6 @@ protected:
 	BOOL		mIgnoreTab;
 	BOOL		mDrawAsterixes;
 
-	BOOL		mHandleEditKeysDirectly;  // If true, the standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system
 	BOOL		mSelectAllonFocusReceived;
 	BOOL		mPassDelete;
 
diff --git a/indra/llui/llloadingindicator.cpp b/indra/llui/llloadingindicator.cpp
new file mode 100644
index 0000000000..f8b029e19c
--- /dev/null
+++ b/indra/llui/llloadingindicator.cpp
@@ -0,0 +1,133 @@
+/** 
+ * @file llloadingindicator.cpp
+ * @brief Perpetual loading indicator
+ *
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llloadingindicator.h"
+
+// Linden library includes
+#include "llsingleton.h"
+
+// Project includes
+#include "lluictrlfactory.h"
+#include "lluiimage.h"
+
+static LLDefaultChildRegistry::Register<LLLoadingIndicator> r("loading_indicator");
+
+///////////////////////////////////////////////////////////////////////////////
+// LLLoadingIndicator::Data class
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Pre-loaded images shared by all instances of the widget
+ */
+class LLLoadingIndicator::Data: public LLSingleton<LLLoadingIndicator::Data>
+{
+public:
+	/*virtual*/ void		initSingleton(); // from LLSingleton
+
+	LLPointer<LLUIImage>	getNextImage(S8& idx) const;
+	U8						getImagesCount() const	{ return NIMAGES; }
+private:
+
+	static const U8			NIMAGES = 12;
+	LLPointer<LLUIImage>	mImages[NIMAGES];
+};
+
+// virtual
+// Called right after the instance gets constructed.
+void LLLoadingIndicator::Data::initSingleton()
+{
+	// Load images.
+	for (U8 i = 0; i < NIMAGES; ++i)
+	{
+		std::string img_name = llformat("Progress_%d", i+1);
+		mImages[i] = LLUI::getUIImage(img_name, 0);
+		llassert(mImages[i]);
+	}
+}
+
+LLPointer<LLUIImage> LLLoadingIndicator::Data::getNextImage(S8& idx) const
+{
+	// Calculate next index, performing array bounds checking.
+	idx = (idx >= NIMAGES || idx < 0) ? 0 : (idx + 1) % NIMAGES; 
+	return mImages[idx];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// LLLoadingIndicator class
+///////////////////////////////////////////////////////////////////////////////
+
+LLLoadingIndicator::LLLoadingIndicator(const Params& p)
+:	LLUICtrl(p)
+	, mRotationsPerSec(p.rotations_per_sec > 0 ? p.rotations_per_sec : 1.0f)
+	, mCurImageIdx(-1)
+{
+	// Select initial image.
+	mCurImagep = Data::instance().getNextImage(mCurImageIdx);
+
+	// Start timer for switching images.
+	start();
+}
+
+void LLLoadingIndicator::draw()
+{
+	// Time to switch to the next image?
+	if (mImageSwitchTimer.getStarted() && mImageSwitchTimer.hasExpired())
+	{
+		// Switch to the next image.
+		mCurImagep = Data::instance().getNextImage(mCurImageIdx);
+
+		// Restart timer.
+		start();
+	}
+
+	// Draw current image.
+	if( mCurImagep.notNull() )
+	{
+		mCurImagep->draw(getLocalRect(), LLColor4::white % getDrawContext().mAlpha);
+	}
+
+	LLUICtrl::draw();
+}
+
+void LLLoadingIndicator::stop()
+{
+	mImageSwitchTimer.stop();
+}
+
+void LLLoadingIndicator::start()
+{
+	mImageSwitchTimer.start();
+	F32 period = 1.0f / (Data::instance().getImagesCount() * mRotationsPerSec);
+	mImageSwitchTimer.setTimerExpirySec(period);
+}
diff --git a/indra/llui/llloadingindicator.h b/indra/llui/llloadingindicator.h
new file mode 100644
index 0000000000..32dd1fead8
--- /dev/null
+++ b/indra/llui/llloadingindicator.h
@@ -0,0 +1,93 @@
+/** 
+ * @file llloadingindicator.h
+ * @brief Perpetual loading indicator
+ *
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLLOADINGINDICATOR_H
+#define LL_LLLOADINGINDICATOR_H
+
+#include "lluictrl.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// class LLLoadingIndicator
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Perpetual loading indicator (a la MacOSX or YouTube)
+ * 
+ * Number of rotations per second can be overriden
+ * with the "roations_per_sec" parameter.
+ * 
+ * Can start/stop spinning.
+ * 
+ * @see start()
+ * @see stop()
+ */
+class LLLoadingIndicator
+: public LLUICtrl
+{
+	LOG_CLASS(LLLoadingIndicator);
+public:
+	struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
+	{
+		Optional<F32>	rotations_per_sec;
+		Params()
+		:	rotations_per_sec("rotations_per_sec", 1.0f)
+		{}
+	};
+
+	virtual ~LLLoadingIndicator() {}
+
+	// llview overrides
+	virtual void draw();
+
+	/**
+	 * Stop spinning.
+	 */
+	void stop();
+
+	/**
+	 * Start spinning.
+	 */
+	void start();
+
+private:
+	LLLoadingIndicator(const Params&);
+	friend class LLUICtrlFactory;
+
+	class Data;
+
+	F32						mRotationsPerSec;
+	S8						mCurImageIdx;
+	LLPointer<LLUIImage>	mCurImagep;
+	LLFrameTimer			mImageSwitchTimer;
+};
+
+#endif // LL_LLLOADINGINDICATOR_H
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index fb4a9d032d..e0e86ae228 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -3345,7 +3345,7 @@ void LLMenuHolderGL::draw()
 	LLView::draw();
 	// now draw last selected item as overlay
 	LLMenuItemGL* selecteditem = (LLMenuItemGL*)sItemLastSelectedHandle.get();
-	if (selecteditem && sItemActivationTimer.getStarted() && sItemActivationTimer.getElapsedTimeF32() < ACTIVATE_HIGHLIGHT_TIME)
+	if (selecteditem && selecteditem->getVisible() && sItemActivationTimer.getStarted() && sItemActivationTimer.getElapsedTimeF32() < ACTIVATE_HIGHLIGHT_TIME)
 	{
 		// make sure toggle items, for example, show the proper state when fading out
 		selecteditem->buildDrawLabel();
diff --git a/indra/llui/llmenugl.h b/indra/llui/llmenugl.h
index 39d1986461..6f0f83d4b9 100644
--- a/indra/llui/llmenugl.h
+++ b/indra/llui/llmenugl.h
@@ -295,7 +295,7 @@ private:
 // class, by allowing another method to be specified which determines
 // if the menu item should consider itself checked as true or not.  Be
 // careful that the provided callback is fast - it needs to be VERY
-// FUCKING EFFICIENT, because it may need to be checked a lot.
+// EFFICIENT because it may need to be checked a lot.
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 class LLMenuItemCheckGL 
diff --git a/indra/llui/llmultifloater.cpp b/indra/llui/llmultifloater.cpp
index 4af9108329..3aea648562 100644
--- a/indra/llui/llmultifloater.cpp
+++ b/indra/llui/llmultifloater.cpp
@@ -345,7 +345,7 @@ void LLMultiFloater::setVisible(BOOL visible)
 
 BOOL LLMultiFloater::handleKeyHere(KEY key, MASK mask)
 {
-	if (key == 'W' && mask == MASK_CONTROL)
+	if (key == 'W' && mask == (MASK_CONTROL|MASK_SHIFT))
 	{
 		LLFloater* floater = getActiveFloater();
 		// is user closeable and is system closeable
diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index d7424cf05a..7b8f51ae3c 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -48,122 +48,38 @@
 
 const std::string NOTIFICATION_PERSIST_VERSION = "0.93";
 
-// local channel for notification history
-class LLNotificationHistoryChannel : public LLNotificationChannel
+// Local channel for persistent notifications
+// Stores only persistent notifications.
+// Class users can use connectChanged() to process persistent notifications
+// (see LLNotificationStorage for example).
+class LLPersistentNotificationChannel : public LLNotificationChannel
 {
-	LOG_CLASS(LLNotificationHistoryChannel);
+	LOG_CLASS(LLPersistentNotificationChannel);
 public:
-	LLNotificationHistoryChannel(const std::string& filename) : 
-		LLNotificationChannel("History", "Visible", &historyFilter, LLNotificationComparators::orderByUUID()),
-		mFileName(filename)
+	LLPersistentNotificationChannel() :
+		LLNotificationChannel("Persistent", "Visible", &notificationFilter, LLNotificationComparators::orderByUUID())
 	{
-		connectChanged(boost::bind(&LLNotificationHistoryChannel::historyHandler, this, _1));
-		loadPersistentNotifications();
 	}
 
 private:
-	bool historyHandler(const LLSD& payload)
-	{
-		// we ignore "load" messages, but rewrite the persistence file on any other
-		std::string sigtype = payload["sigtype"];
-		if (sigtype != "load")
-		{
-			savePersistentNotifications();
-		}
-		return false;
-	}
-
-	// The history channel gets all notifications except those that have been cancelled
-	static bool historyFilter(LLNotificationPtr pNotification)
-	{
-		return !pNotification->isCancelled();
-	}
 
-	void savePersistentNotifications()
+	// The channel gets all persistent notifications except those that have been canceled
+	static bool notificationFilter(LLNotificationPtr pNotification)
 	{
-		/* NOTE: As of 2009-11-09 the reload of notifications on startup does not
-		work, and has not worked for months.  Skip saving notifications until the
-		read can be fixed, because this hits the disk once per notification and
-		causes log spam.  James
-
-		llinfos << "Saving open notifications to " << mFileName << llendl;
-
-		llofstream notify_file(mFileName.c_str());
-		if (!notify_file.is_open()) 
-		{
-			llwarns << "Failed to open " << mFileName << llendl;
-			return;
-		}
-
-		LLSD output;
-		output["version"] = NOTIFICATION_PERSIST_VERSION;
-		LLSD& data = output["data"];
-
-		for (LLNotificationSet::iterator it = mItems.begin(); it != mItems.end(); ++it)
-		{
-			if (!LLNotifications::instance().templateExists((*it)->getName())) continue;
-
-			// only store notifications flagged as persisting
-			LLNotificationTemplatePtr templatep = LLNotifications::instance().getTemplate((*it)->getName());
-			if (!templatep->mPersist) continue;
+		bool handle_notification = false;
 
-			data.append((*it)->asLLSD());
-		}
+		handle_notification = pNotification->isPersistent()
+			&& !pNotification->isCancelled();
 
-		LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
-		formatter->format(output, notify_file, LLSDFormatter::OPTIONS_PRETTY);
-		*/
+		return handle_notification;
 	}
 
-	void loadPersistentNotifications()
-	{
-		llinfos << "Loading open notifications from " << mFileName << llendl;
-
-		llifstream notify_file(mFileName.c_str());
-		if (!notify_file.is_open()) 
-		{
-			llwarns << "Failed to open " << mFileName << llendl;
-			return;
-		}
-
-		LLSD input;
-		LLPointer<LLSDParser> parser = new LLSDXMLParser();
-		if (parser->parse(notify_file, input, LLSDSerialize::SIZE_UNLIMITED) < 0)
-		{
-			llwarns << "Failed to parse open notifications" << llendl;
-			return;
-		}
-
-		if (input.isUndefined()) return;
-		std::string version = input["version"];
-		if (version != NOTIFICATION_PERSIST_VERSION)
-		{
-			llwarns << "Bad open notifications version: " << version << llendl;
-			return;
-		}
-		LLSD& data = input["data"];
-		if (data.isUndefined()) return;
-
-		LLNotifications& instance = LLNotifications::instance();
-		for (LLSD::array_const_iterator notification_it = data.beginArray();
-			notification_it != data.endArray();
-			++notification_it)
-		{
-			instance.add(LLNotificationPtr(new LLNotification(*notification_it)));
-		}
-	}
-
-	//virtual
 	void onDelete(LLNotificationPtr pNotification)
 	{
-		// we want to keep deleted notifications in our log
+		// we want to keep deleted notifications in our log, otherwise some 
+		// notifications will be lost on exit.
 		mItems.insert(pNotification);
-		
-		return;
 	}
-	
-private:
-	std::string mFileName;
 };
 
 bool filterIgnoredNotifications(LLNotificationPtr notification)
@@ -417,6 +333,10 @@ LLNotification::LLNotification(const LLNotification::Params& p) :
 
 		mTemporaryResponder = true;
 	}
+	else if(p.functor.responder.isChosen())
+	{
+		mResponder = p.functor.responder;
+	}
 
 	if(p.responder.isProvided())
 	{
@@ -462,6 +382,12 @@ LLSD LLNotification::asLLSD()
 	output["priority"] = (S32)mPriority;
 	output["responseFunctor"] = mResponseFunctorName;
 	output["reusable"] = mIsReusable;
+
+	if(mResponder)
+	{
+		output["responder"] = mResponder->asLLSD();
+	}
+
 	return output;
 }
 
@@ -571,12 +497,20 @@ void LLNotification::respond(const LLSD& response)
 	// *TODO may remove mRespondedTo and use mResponce.isDefined() in isRespondedTo()
 	mRespondedTo = true;
 	mResponse = response;
-	// look up the functor
-	LLNotificationFunctorRegistry::ResponseFunctor functor = 
-		LLNotificationFunctorRegistry::instance().getFunctor(mResponseFunctorName);
-	// and then call it
-	functor(asLLSD(), response);
-	
+
+	if(mResponder)
+	{
+		mResponder->handleRespond(asLLSD(), response);
+	}
+	else
+	{
+		// look up the functor
+		LLNotificationFunctorRegistry::ResponseFunctor functor =
+			LLNotificationFunctorRegistry::instance().getFunctor(mResponseFunctorName);
+		// and then call it
+		functor(asLLSD(), response);
+	}
+
 	if (mTemporaryResponder && !isReusable())
 	{
 		LLNotificationFunctorRegistry::instance().unregisterFunctor(mResponseFunctorName);
@@ -621,6 +555,11 @@ void LLNotification::setResponseFunctor(const LLNotificationFunctorRegistry::Res
 	LLNotificationFunctorRegistry::instance().registerFunctor(mResponseFunctorName, cb);
 }
 
+void LLNotification::setResponseFunctor(const LLNotificationResponderPtr& responder)
+{
+	mResponder = responder;
+}
+
 bool LLNotification::payloadContainsAll(const std::vector<std::string>& required_fields) const
 {
 	for(std::vector<std::string>::const_iterator required_fields_it = required_fields.begin(); 
@@ -1116,12 +1055,9 @@ void LLNotifications::createDefaultChannels()
 	LLNotificationChannel::buildChannel("Visible", "Ignore",
 		&LLNotificationFilters::includeEverything);
 
-	// create special history channel
-	//std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_PER_SL_ACCOUNT, "open_notifications.xml" );
-	// use ^^^ when done debugging notifications serialization
-	std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_USER_SETTINGS, "open_notifications.xml" );
+	// create special persistent notification channel
 	// this isn't a leak, don't worry about the empty "new"
-	new LLNotificationHistoryChannel(notifications_log_file);
+	new LLPersistentNotificationChannel();
 
 	// connect action methods to these channels
 	LLNotifications::instance().getChannel("Expiration")->
@@ -1552,3 +1488,11 @@ std::ostream& operator<<(std::ostream& s, const LLNotification& notification)
 	return s;
 }
 
+void LLPostponedNotification::onCachedNameReceived(const LLUUID& id, const std::string& first,
+		const std::string& last, bool is_group)
+{
+	gCacheName->getFullName(id, mName);
+	modifyNotificationParams();
+	LLNotifications::instance().add(mParams);
+	cleanup();
+}
diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h
index 400491a154..c942a32512 100644
--- a/indra/llui/llnotifications.h
+++ b/indra/llui/llnotifications.h
@@ -104,6 +104,7 @@
 #include "llinitparam.h"
 #include "llnotificationslistener.h"
 #include "llnotificationptr.h"
+#include "llcachename.h"
 
 	
 typedef enum e_notification_priority
@@ -115,8 +116,23 @@ typedef enum e_notification_priority
 	NOTIFICATION_PRIORITY_CRITICAL
 } ENotificationPriority;
 
+class LLNotificationResponderInterface
+{
+public:
+	LLNotificationResponderInterface(){};
+	virtual ~LLNotificationResponderInterface(){};
+
+	virtual void handleRespond(const LLSD& notification, const LLSD& response) = 0;
+
+	virtual LLSD asLLSD() = 0;
+
+	virtual void fromLLSD(const LLSD& params) = 0;
+};
+
 typedef boost::function<void (const LLSD&, const LLSD&)> LLNotificationResponder;
 
+typedef boost::shared_ptr<LLNotificationResponderInterface> LLNotificationResponderPtr;
+
 typedef LLFunctorRegistry<LLNotificationResponder> LLNotificationFunctorRegistry;
 typedef LLFunctorRegistration<LLNotificationResponder> LLNotificationFunctorRegistration;
 
@@ -302,10 +318,12 @@ public:
 		{
 			Alternative<std::string>										name;
 			Alternative<LLNotificationFunctorRegistry::ResponseFunctor>	function;
+			Alternative<LLNotificationResponderPtr>						responder;
 
 			Functor()
 			:	name("functor_name"),
-				function("functor")
+				function("functor"),
+				responder("responder")
 			{}
 		};
 		Optional<Functor>						functor;
@@ -348,12 +366,13 @@ private:
 	bool mIgnored;
 	ENotificationPriority mPriority;
 	LLNotificationFormPtr mForm;
-	void* mResponderObj;
+	void* mResponderObj; // TODO - refactor/remove this field
 	bool mIsReusable;
-	
+	LLNotificationResponderPtr mResponder;
+
 	// a reference to the template
 	LLNotificationTemplatePtr mTemplatep;
-	
+
 	/*
 	 We want to be able to store and reload notifications so that they can survive
 	 a shutdown/restart of the client. So we can't simply pass in callbacks;
@@ -392,6 +411,8 @@ public:
 
 	void setResponseFunctor(const LLNotificationFunctorRegistry::ResponseFunctor& cb);
 
+	void setResponseFunctor(const LLNotificationResponderPtr& responder);
+
 	typedef enum e_response_template_type
 	{
 		WITHOUT_DEFAULT_BUTTON,
@@ -458,7 +479,12 @@ public:
 	{
 		return mTemplatep->mName;
 	}
-	
+
+	bool isPersistent() const
+	{
+		return mTemplatep->mPersist;
+	}
+
 	const LLUUID& id() const
 	{
 		return mId;
@@ -949,6 +975,62 @@ private:
     boost::scoped_ptr<LLNotificationsListener> mListener;
 };
 
+/**
+ * Abstract class for postponed notifications.
+ * Provides possibility to add notification after specified by id avatar or group will be
+ * received from cache name. The object of this type automatically well be deleted
+ * by cleanup method after respond will be received from cache name.
+ *
+ * To add custom postponed notification to the notification system client should:
+ *  1 create class derived from LLPostponedNotification;
+ *  2 call LLPostponedNotification::add method;
+ */
+class LLPostponedNotification
+{
+public:
+	/**
+	 * Performs hooking cache name callback which will add notification to notifications system.
+	 * Type of added notification should be specified by template parameter T
+	 * and non-private derived from LLPostponedNotification class,
+	 * otherwise compilation error will occur.
+	 */
+	template<class T>
+	static void add(const LLNotification::Params& params,
+			const LLUUID& id, bool is_group)
+	{
+		// upcast T to the base type to restrict T derivation from LLPostponedNotification
+		LLPostponedNotification* thiz = new T();
+
+		thiz->mParams = params;
+
+		gCacheName->get(id, is_group, boost::bind(
+				&LLPostponedNotification::onCachedNameReceived, thiz, _1, _2,
+				_3, _4));
+	}
+
+private:
+	void onCachedNameReceived(const LLUUID& id, const std::string& first,
+			const std::string& last, bool is_group);
+
+	void cleanup()
+	{
+		delete this;
+	}
+
+protected:
+	LLPostponedNotification() {}
+	virtual ~LLPostponedNotification() {}
+
+	/**
+	 * Abstract method provides possibility to modify notification parameters and
+	 * will be called after cache name retrieve information about avatar or group
+	 * and before notification will be added to the notification system.
+	 */
+	virtual void modifyNotificationParams() = 0;
+
+	LLNotification::Params mParams;
+	std::string mName;
+};
 
 #endif//LL_LLNOTIFICATIONS_H
 
diff --git a/indra/llui/llscrollingpanellist.cpp b/indra/llui/llscrollingpanellist.cpp
index 4f55c0507c..b7840d1b59 100644
--- a/indra/llui/llscrollingpanellist.cpp
+++ b/indra/llui/llscrollingpanellist.cpp
@@ -47,7 +47,12 @@ void LLScrollingPanelList::clearPanels()
 {
 	deleteAllChildren();
 	mPanelList.clear();
-	reshape( 1, 1, FALSE );
+
+	LLRect rc = getRect();
+	rc.setLeftTopAndSize(rc.mLeft, rc.mTop, 1, 1);
+	setRect(rc);
+
+	notifySizeChanged(rc.getHeight());
 }
 
 S32 LLScrollingPanelList::addPanel( LLScrollingPanel* panel )
@@ -67,7 +72,11 @@ S32 LLScrollingPanelList::addPanel( LLScrollingPanel* panel )
 		max_width = llmax( max_width, childp->getRect().getWidth() );
 		cur_gap = GAP_BETWEEN_PANELS;
 	}
-	reshape( max_width, total_height, FALSE );
+ 	LLRect rc = getRect();
+ 	rc.setLeftTopAndSize(rc.mLeft, rc.mTop, max_width, total_height);
+ 	setRect(rc);
+
+	notifySizeChanged(rc.getHeight());
 
 	// Reposition each of the child views
 	S32 cur_y = total_height;
@@ -131,7 +140,11 @@ void LLScrollingPanelList::removePanel( U32 panel_index )
 		max_width = llmax( max_width, childp->getRect().getWidth() );
 		cur_gap = GAP_BETWEEN_PANELS;
 	}
-	reshape( max_width, total_height, FALSE );
+	LLRect rc = getRect();
+	rc.setLeftTopAndSize(rc.mLeft, rc.mTop, max_width, total_height);
+	setRect(rc);
+
+	notifySizeChanged(rc.getHeight());
 
 	// Reposition each of the child views
 	S32 cur_y = total_height;
@@ -200,3 +213,12 @@ void LLScrollingPanelList::draw()
 	LLUICtrl::draw();
 }
 
+void LLScrollingPanelList::notifySizeChanged(S32 height)
+{
+	LLSD info;
+	info["action"] = "size_changes";
+	info["height"] = height;
+	notifyParent(info);
+}
+
+// EOF
diff --git a/indra/llui/llscrollingpanellist.h b/indra/llui/llscrollingpanellist.h
index 3abfbcbbe7..5f1996159b 100644
--- a/indra/llui/llscrollingpanellist.h
+++ b/indra/llui/llscrollingpanellist.h
@@ -61,7 +61,6 @@ public:
 		Params()
 		{
 			name = "scrolling_panel_list";
-			follows.flags = FOLLOWS_LEFT | FOLLOWS_BOTTOM;
 		}
 	};
 	LLScrollingPanelList(const Params& p)
@@ -86,6 +85,11 @@ public:
 private:
 	void				updatePanelVisiblilty();
 
+	/**
+	 * Notify parent about size change, makes sense when used inside accordion
+	 */
+	void				notifySizeChanged(S32 height);
+
 	panel_list_t		mPanelList;
 };
 
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 77caaaa425..94eade06ad 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -282,6 +282,8 @@ LLScrollListCtrl::LLScrollListCtrl(const LLScrollListCtrl::Params& p)
 	text_p.border_visible(false);
 	text_p.rect(mItemListRect);
 	text_p.follows.flags(FOLLOWS_ALL);
+	// word wrap was added accroding to the EXT-6841
+	text_p.wrap(true);
 	addChild(LLUICtrlFactory::create<LLTextBox>(text_p));
 }
 
@@ -324,11 +326,6 @@ LLScrollListCtrl::~LLScrollListCtrl()
 	delete mSortCallback;
 
 	std::for_each(mItemList.begin(), mItemList.end(), DeletePointer());
-
-	if( gEditMenuHandler == this )
-	{
-		gEditMenuHandler = NULL;
-	}
 }
 
 
@@ -957,14 +954,14 @@ void LLScrollListCtrl::mouseOverHighlightNthItem(S32 target_index)
 	}
 }
 
-S32	LLScrollListCtrl::selectMultiple( std::vector<LLUUID> ids )
+S32	LLScrollListCtrl::selectMultiple( uuid_vec_t ids )
 {
 	item_list::iterator iter;
 	S32 count = 0;
 	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
 	{
 		LLScrollListItem* item = *iter;
-		std::vector<LLUUID>::iterator iditr;
+		uuid_vec_t::iterator iditr;
 		for(iditr = ids.begin(); iditr != ids.end(); ++iditr)
 		{
 			if (item->getEnabled() && (item->getUUID() == (*iditr)))
diff --git a/indra/llui/llscrolllistctrl.h b/indra/llui/llscrolllistctrl.h
index ebdc82115f..1f0ef585db 100644
--- a/indra/llui/llscrolllistctrl.h
+++ b/indra/llui/llscrolllistctrl.h
@@ -379,7 +379,7 @@ public:
 	BOOL			getSortAscending() { return mSortColumns.empty() ? TRUE : mSortColumns.back().second; }
 	BOOL			hasSortOrder() const;
 
-	S32		selectMultiple( std::vector<LLUUID> ids );
+	S32		selectMultiple( uuid_vec_t ids );
 	// conceptually const, but mutates mItemList
 	void			updateSort() const;
 	// sorts a list without affecting the permanent sort order (so further list insertions can be unsorted, for example)
diff --git a/indra/llui/llsliderctrl.cpp b/indra/llui/llsliderctrl.cpp
index 80ee5d0984..04958075db 100644
--- a/indra/llui/llsliderctrl.cpp
+++ b/indra/llui/llsliderctrl.cpp
@@ -63,7 +63,8 @@ LLSliderCtrl::LLSliderCtrl(const LLSliderCtrl::Params& p)
 	mCanEditText(p.can_edit_text),
 	mPrecision(p.decimal_digits),
 	mTextEnabledColor(p.text_color()),
-	mTextDisabledColor(p.text_disabled_color())
+	mTextDisabledColor(p.text_disabled_color()),
+	mLabelWidth(p.label_width)
 {
 	S32 top = getRect().getHeight();
 	S32 bottom = 0;
@@ -86,6 +87,7 @@ LLSliderCtrl::LLSliderCtrl(const LLSliderCtrl::Params& p)
 		params.initial_value(p.label());
 		mLabelBox = LLUICtrlFactory::create<LLTextBox> (params);
 		addChild(mLabelBox);
+		mLabelFont = params.font();
 	}
 
 	if (p.show_text && !p.text_width.isProvided())
@@ -186,9 +188,9 @@ BOOL LLSliderCtrl::setLabelArg( const std::string& key, const LLStringExplicit&
 	if (mLabelBox)
 	{
 		res = mLabelBox->setTextArg(key, text);
-		if (res && mLabelWidth == 0)
+		if (res && mLabelFont && mLabelWidth == 0)
 		{
-			S32 label_width = mFont->getWidth(mLabelBox->getText());
+			S32 label_width = mLabelFont->getWidth(mLabelBox->getText());
 			LLRect rect = mLabelBox->getRect();
 			S32 prev_right = rect.mRight;
 			rect.mRight = rect.mLeft + label_width;
diff --git a/indra/llui/llsliderctrl.h b/indra/llui/llsliderctrl.h
index c425849782..482c81a0f4 100644
--- a/indra/llui/llsliderctrl.h
+++ b/indra/llui/llsliderctrl.h
@@ -141,6 +141,7 @@ private:
 	void			reportInvalidData();
 
 	const LLFontGL*	mFont;
+	const LLFontGL*	mLabelFont;
 	BOOL			mShowText;
 	BOOL			mCanEditText;
 	
@@ -158,3 +159,4 @@ private:
 };
 
 #endif  // LL_LLSLIDERCTRL_H
+
diff --git a/indra/llui/llspinctrl.cpp b/indra/llui/llspinctrl.cpp
index 491cd7b6f3..b47f21ed8a 100644
--- a/indra/llui/llspinctrl.cpp
+++ b/indra/llui/llspinctrl.cpp
@@ -457,3 +457,8 @@ BOOL LLSpinCtrl::handleKeyHere(KEY key, MASK mask)
 	return FALSE;
 }
 
+BOOL LLSpinCtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	// just treat a double click as a second click
+	return handleMouseDown(x, y, mask);
+}
diff --git a/indra/llui/llspinctrl.h b/indra/llui/llspinctrl.h
index 00d6f86f83..06201255d2 100644
--- a/indra/llui/llspinctrl.h
+++ b/indra/llui/llspinctrl.h
@@ -94,6 +94,7 @@ public:
 
 	virtual BOOL	handleScrollWheel(S32 x,S32 y,S32 clicks);
 	virtual BOOL	handleKeyHere(KEY key, MASK mask);
+	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
 
 	void			onEditorCommit(const LLSD& data);
 	static void		onEditorGainFocus(LLFocusableElement* caller, void *userdata);
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index 9f7a684ce5..78312eba73 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -962,7 +962,18 @@ void LLTextBase::reshape(S32 width, S32 height, BOOL called_from_parent)
 {
 	if (width != getRect().getWidth() || height != getRect().getHeight())
 	{
+		//EXT-4288
+		//to keep consistance scrolling behaviour 
+		//when scrolling from top and from bottom...
+		bool is_scrolled_to_end = (mScroller!=NULL) && scrolledToEnd();
+		
 		LLUICtrl::reshape( width, height, called_from_parent );
+	
+		if (is_scrolled_to_end)
+		{
+			deselect();
+			endOfDoc();
+		}		
 
 		// do this first after reshape, because other things depend on
 		// up-to-date mVisibleTextRect
@@ -1048,6 +1059,13 @@ void LLTextBase::setValue(const LLSD& value )
 }
 
 //virtual
+BOOL LLTextBase::canDeselect() const 
+{ 
+	return hasSelection(); 
+}
+
+
+//virtual
 void LLTextBase::deselect()
 {
 	mSelectionStart = 0;
@@ -1489,6 +1507,7 @@ void LLTextBase::createUrlContextMenu(S32 x, S32 y, const std::string &in_url)
 	registrar.add("Url.OpenExternal", boost::bind(&LLUrlAction::openURLExternal, url));
 	registrar.add("Url.Execute", boost::bind(&LLUrlAction::executeSLURL, url));
 	registrar.add("Url.Teleport", boost::bind(&LLUrlAction::teleportToLocation, url));
+	registrar.add("Url.ShowProfile", boost::bind(&LLUrlAction::showProfile, url));
 	registrar.add("Url.ShowOnMap", boost::bind(&LLUrlAction::showLocationOnMap, url));
 	registrar.add("Url.CopyLabel", boost::bind(&LLUrlAction::copyLabelToClipboard, url));
 	registrar.add("Url.CopyUrl", boost::bind(&LLUrlAction::copyURLToClipboard, url));
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index 39cdaa0a58..3a3a5d0e20 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -132,6 +132,7 @@ public:
 	/*virtual*/ LLTextViewModel* getViewModel() const;
 
 	// LLEditMenuHandler interface
+	/*virtual*/ BOOL		canDeselect() const;
 	/*virtual*/ void		deselect();
 
 	// used by LLTextSegment layout code
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index 7d230f7d42..4fd62045e8 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -240,7 +240,6 @@ LLTextEditor::Params::Params()
 	prevalidate_callback("prevalidate_callback"),
 	embedded_items("embedded_items", false),
 	ignore_tab("ignore_tab", true),
-	handle_edit_keys_directly("handle_edit_keys_directly", false),
 	show_line_numbers("show_line_numbers", false),
 	default_color("default_color"),
     commit_on_focus_lost("commit_on_focus_lost", false),
@@ -258,7 +257,6 @@ LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
 	mShowLineNumbers ( p.show_line_numbers ),
 	mCommitOnFocusLost( p.commit_on_focus_lost),
 	mAllowEmbeddedItems( p.embedded_items ),
-	mHandleEditKeysDirectly( p.handle_edit_keys_directly ),
 	mMouseDownX(0),
 	mMouseDownY(0),
 	mTabsToNextField(p.ignore_tab),
@@ -305,12 +303,6 @@ LLTextEditor::~LLTextEditor()
 {
 	gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit() while LLTextEditor still valid
 
-	// Route menu back to the default
-	if( gEditMenuHandler == this )
-	{
-		gEditMenuHandler = NULL;
-	}
-
 	// Scrollbar is deleted by LLView
 	std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
 
@@ -507,21 +499,6 @@ void LLTextEditor::getSegmentsInRange(LLTextEditor::segment_vec_t& segments_out,
 	}
 }
 
-// virtual
-BOOL LLTextEditor::canDeselect() const
-{
-	return hasSelection(); 
-}
-
-
-void LLTextEditor::deselect()
-{
-	mSelectionStart = 0;
-	mSelectionEnd = 0;
-	mIsSelecting = FALSE;
-}
-
-
 BOOL LLTextEditor::selectionContainsLineBreaks()
 {
 	if (hasSelection())
@@ -668,6 +645,7 @@ void LLTextEditor::selectAll()
 	mSelectionStart = getLength();
 	mSelectionEnd = 0;
 	setCursorPos(mSelectionEnd);
+	updatePrimary();
 }
 
 BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
@@ -735,7 +713,8 @@ BOOL LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
 	{
 		setFocus(TRUE);
 	}
-	if (!LLTextBase::handleRightMouseDown(x, y, mask))
+	// Prefer editor menu if it has selection. See EXT-6806.
+	if (hasSelection() || !LLTextBase::handleRightMouseDown(x, y, mask))
 	{
 		if(getShowContextMenu())
 		{
@@ -1025,7 +1004,7 @@ void LLTextEditor::removeCharOrTab()
 	}
 	else
 	{
-		reportBadKeystroke();
+		LLUI::reportBadKeystroke();
 	}
 }
 
@@ -1048,7 +1027,7 @@ void LLTextEditor::removeChar()
 	}
 	else
 	{
-		reportBadKeystroke();
+		LLUI::reportBadKeystroke();
 	}
 }
 
@@ -1198,22 +1177,6 @@ BOOL LLTextEditor::handleSelectionKey(const KEY key, const MASK mask)
 		}
 	}
 
-	if( !handled && mHandleEditKeysDirectly )
-	{
-		if( (MASK_CONTROL & mask) && ('A' == key) )
-		{
-			if( canSelectAll() )
-			{
-				selectAll();
-			}
-			else
-			{
-				reportBadKeystroke();
-			}
-			handled = TRUE;
-		}
-	}
-
 	if( handled )
 	{
 		// take selection to 'primary' clipboard
@@ -1247,6 +1210,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
 
 		case KEY_DOWN:
 			changeLine( 1 );
+			deselect();
 			break;
 
 		case KEY_PAGE_DOWN:
@@ -1260,7 +1224,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
 		case KEY_LEFT:
 			if( hasSelection() )
 			{
-				setCursorPos(llmin( mCursorPos - 1, mSelectionStart, mSelectionEnd ));
+				setCursorPos(llmin( mSelectionStart, mSelectionEnd ));
 			}
 			else
 			{
@@ -1270,7 +1234,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
 				}
 				else
 				{
-					reportBadKeystroke();
+					LLUI::reportBadKeystroke();
 				}
 			}
 			break;
@@ -1278,7 +1242,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
 		case KEY_RIGHT:
 			if( hasSelection() )
 			{
-				setCursorPos(llmax( mCursorPos + 1, mSelectionStart, mSelectionEnd ));
+				setCursorPos(llmax( mSelectionStart, mSelectionEnd ));
 			}
 			else
 			{
@@ -1288,7 +1252,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
 				}
 				else
 				{
-					reportBadKeystroke();
+					LLUI::reportBadKeystroke();
 				}
 			}	
 			break;
@@ -1299,6 +1263,11 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
 		}
 	}
 	
+	if (handled)
+	{
+		deselect();
+	}
+	
 	return handled;
 }
 
@@ -1551,75 +1520,13 @@ BOOL LLTextEditor::handleControlKey(const KEY key, const MASK mask)
 	return handled;
 }
 
-BOOL LLTextEditor::handleEditKey(const KEY key, const MASK mask)
-{
-	BOOL handled = FALSE;
 
-	// Standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system.
-	if( KEY_DELETE == key )
-	{
-		if( canDoDelete() )
-		{
-			doDelete();
-		}
-		else
-		{
-			reportBadKeystroke();
-		}
-		handled = TRUE;
-	}
-	else
-	if( MASK_CONTROL & mask )
+BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask)	
 	{
-		if( 'C' == key )
-		{
-			if( canCopy() )
-			{
-				copy();
-			}
-			else
-			{
-				reportBadKeystroke();
-			}
-			handled = TRUE;
-		}
-		else
-		if( 'V' == key )
-		{
-			if( canPaste() )
-			{
-				paste();
-			}
-			else
-			{
-				reportBadKeystroke();
-			}
-			handled = TRUE;
-		}
-		else
-		if( 'X' == key )
-		{
-			if( canCut() )
-			{
-				cut();
-			}
-			else
-			{
-				reportBadKeystroke();
-			}
-			handled = TRUE;
-		}
-	}
-
-	return handled;
-}
-
-	
-BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask, BOOL* return_key_hit)	
-{
-	*return_key_hit = FALSE;
 	BOOL handled = TRUE;
 
+	if (mReadOnly) return FALSE;
+
 	switch( key )
 	{
 	case KEY_INSERT:
@@ -1641,7 +1548,7 @@ BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask, BOOL* return
 		}
 		else
 		{
-			reportBadKeystroke();
+			LLUI::reportBadKeystroke();
 		}
 		break;
 
@@ -1694,6 +1601,10 @@ BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask, BOOL* return
 		break;
 	}
 
+	if (handled)
+	{
+		onKeyStroke();
+	}
 	return handled;
 }
 
@@ -1714,9 +1625,6 @@ void LLTextEditor::unindentLineBeforeCloseBrace()
 BOOL LLTextEditor::handleKeyHere(KEY key, MASK mask )
 {
 	BOOL	handled = FALSE;
-	BOOL	selection_modified = FALSE;
-	BOOL	return_key_hit = FALSE;
-	BOOL	text_may_have_changed = TRUE;
 
 	// Special case for TAB.  If want to move to next field, report
 	// not handled and let the parent take care of field movement.
@@ -1724,116 +1632,24 @@ BOOL LLTextEditor::handleKeyHere(KEY key, MASK mask )
 	{
 		return FALSE;
 	}
-	/*
-	if (KEY_F10 == key)
-	{
-		LLComboBox::Params cp;
-		cp.name = "combo box";
-		cp.label = "my combo";
-		cp.rect.width = 100;
-		cp.rect.height = 20;
-		cp.items.add().label = "item 1";
-		cp.items.add().label = "item 2";
-		cp.items.add().label = "item 3";
 		
-		appendWidget(LLUICtrlFactory::create<LLComboBox>(cp), "combo", true, false);
-	}
-	if (KEY_F11 == key)
-	{
-		LLButton::Params bp;
-		bp.name = "text button";
-		bp.label = "Click me";
-		bp.rect.width = 100;
-		bp.rect.height = 20;
-
-		appendWidget(LLUICtrlFactory::create<LLButton>(bp), "button", true, false);
-	}
-	*/
-	if (mReadOnly)
+	if (mReadOnly && mScroller)
 	{
-		if(mScroller)
-		{
-			handled = mScroller->handleKeyHere( key, mask );
+		handled = (mScroller && mScroller->handleKeyHere( key, mask ))
+				|| handleSelectionKey(key, mask)
+				|| handleControlKey(key, mask);
 		}
 		else 
 		{
-			handled = handleNavigationKey( key, mask );
-		}
-
-	}
-	else
-	{
-		// handle navigation keys ourself
-		handled = handleNavigationKey( key, mask );
-	}
-
-
-	if( handled )
-	{
-		text_may_have_changed = FALSE;
-	}
-		
-	if( !handled )
-	{
-		handled = handleSelectionKey( key, mask );
-		if( handled )
-		{
-			selection_modified = TRUE;
-		}
-	}
-
-	if( !handled )
-	{
-		handled = handleControlKey( key, mask );
-		if( handled )
-		{
-			selection_modified = TRUE;
-		}
-	}
-
-	if( !handled && mHandleEditKeysDirectly )
-	{
-		handled = handleEditKey( key, mask );
-		if( handled )
-		{
-			selection_modified = TRUE;
-			text_may_have_changed = TRUE;
-		}
-	}
-
-	// Handle most keys only if the text editor is writeable.
-	if( !mReadOnly )
-	{
-		if( !handled )
-		{
-			handled = handleSpecialKey( key, mask, &return_key_hit );
-			if( handled )
-			{
-				selection_modified = TRUE;
-				text_may_have_changed = TRUE;
-			}
-		}
-
+		handled = handleNavigationKey( key, mask )
+				|| handleSelectionKey(key, mask)
+				|| handleControlKey(key, mask)
+				|| handleSpecialKey(key, mask);
 	}
 
 	if( handled )
 	{
 		resetCursorBlink();
-
-		// Most keystrokes will make the selection box go away, but not all will.
-		if( !selection_modified &&
-			KEY_SHIFT != key &&
-			KEY_CONTROL != key &&
-			KEY_ALT != key &&
-			KEY_CAPSLOCK )
-		{
-			deselect();
-		}
-
-		if(text_may_have_changed)
-		{
-			onKeyStroke();
-		}
 		needsScroll();
 	}
 
@@ -2334,7 +2150,7 @@ void LLTextEditor::getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wo
 void LLTextEditor::autoIndent()
 {
 	// Count the number of spaces in the current line
-	S32 line = getLineNumFromDocIndex(mCursorPos);
+	S32 line = getLineNumFromDocIndex(mCursorPos, false);
 	S32 line_start = getLineStart(line);
 	S32 space_count = 0;
 	S32 i;
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index 71d937b2c4..9b3ab9414c 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -68,7 +68,6 @@ public:
 
 		Optional<bool>			embedded_items,
 								ignore_tab,
-								handle_edit_keys_directly,
 								show_line_numbers,
 								commit_on_focus_lost,
 								show_context_menu;
@@ -146,8 +145,6 @@ public:
 	virtual BOOL	canDoDelete() const;
 	virtual void	selectAll();
 	virtual BOOL	canSelectAll()	const;
-	virtual void	deselect();
-	virtual BOOL	canDeselect() const;
 
 	void			selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap = TRUE);
 	BOOL			replaceText(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive, BOOL wrap = TRUE);
@@ -218,13 +215,10 @@ protected:
 	S32				indentLine( S32 pos, S32 spaces );
 	void			unindentLineBeforeCloseBrace();
 
-	void			reportBadKeystroke() { make_ui_sound("UISndBadKeystroke"); }
-
 	BOOL			handleNavigationKey(const KEY key, const MASK mask);
-	BOOL			handleSpecialKey(const KEY key, const MASK mask, BOOL* return_key_hit);
+	BOOL			handleSpecialKey(const KEY key, const MASK mask);
 	BOOL			handleSelectionKey(const KEY key, const MASK mask);
 	BOOL			handleControlKey(const KEY key, const MASK mask);
-	BOOL			handleEditKey(const KEY key, const MASK mask);
 
 	BOOL			selectionContainsLineBreaks();
 	void			deleteSelection(BOOL transient_operation);
@@ -329,10 +323,6 @@ private:
 
 	LLUUID			mSourceID;
 
-	// If true, the standard edit keys (Ctrl-X, Delete, etc,) are handled here 
-	//instead of routed by the menu system
-	BOOL			mHandleEditKeysDirectly;  
-
 	LLCoordGL		mLastIMEPosition;		// Last position of the IME editor
 
 	keystroke_signal_t mKeystrokeSignal;
diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
index b049895526..bf12384a28 100644
--- a/indra/llui/llui.cpp
+++ b/indra/llui/llui.cpp
@@ -56,6 +56,7 @@
 #include "llfloaterreg.h"
 #include "llmenugl.h"
 #include "llmenubutton.h"
+#include "llloadingindicator.h"
 #include "llwindow.h"
 
 // for registration
@@ -94,7 +95,10 @@ std::list<std::string> gUntranslated;
 static LLDefaultChildRegistry::Register<LLFilterEditor> register_filter_editor("filter_editor");
 static LLDefaultChildRegistry::Register<LLFlyoutButton> register_flyout_button("flyout_button");
 static LLDefaultChildRegistry::Register<LLSearchEditor> register_search_editor("search_editor");
+
+// register other widgets which otherwise may not be linked in
 static LLDefaultChildRegistry::Register<LLMenuButton> register_menu_button("menu_button");
+static LLDefaultChildRegistry::Register<LLLoadingIndicator> register_loading_indicator("loading_indicator");
 
 
 //
@@ -1914,7 +1918,12 @@ void LLUI::clearPopups()
 	}
 }
 
-
+//static
+void LLUI::reportBadKeystroke()
+{
+	make_ui_sound("UISndBadKeystroke");
+}
+	
 //static
 // spawn_x and spawn_y are top left corner of view in screen GL coordinates
 void LLUI::positionViewNearMouse(LLView* view, S32 spawn_x, S32 spawn_y)
diff --git a/indra/llui/llui.h b/indra/llui/llui.h
index 30f3623ded..c18262ef76 100644
--- a/indra/llui/llui.h
+++ b/indra/llui/llui.h
@@ -217,6 +217,8 @@ public:
 	static void removePopup(LLView*);
 	static void clearPopups();
 
+	static void reportBadKeystroke();
+
 	// Ensures view does not overlap mouse cursor, but is inside
 	// the view's parent rectangle.  Used for tooltips, inspectors.
 	// Optionally override the view's default X/Y, which are relative to the
diff --git a/indra/llui/lluictrlfactory.cpp b/indra/llui/lluictrlfactory.cpp
index 27237800d4..930dadc377 100644
--- a/indra/llui/lluictrlfactory.cpp
+++ b/indra/llui/lluictrlfactory.cpp
@@ -435,7 +435,10 @@ void LLUICtrlFactory::registerWidget(const std::type_info* widget_type, const st
 	std::string* existing_tag = LLWidgetNameRegistry::instance().getValue(param_block_type);
 	if (existing_tag != NULL && *existing_tag != tag)
 	{
-		llerrs << "Duplicate entry for T::Params, try creating empty param block in derived classes that inherit T::Params" << llendl;
+		std::cerr << "Duplicate entry for T::Params, try creating empty param block in derived classes that inherit T::Params" << std::endl;
+		// forcing crash here
+		char* foo = 0;
+		*foo = 1;
 	}
 	LLWidgetNameRegistry ::instance().defaultRegistrar().add(param_block_type, tag);
 	// associate widget type with factory function
diff --git a/indra/llui/lluifwd.h b/indra/llui/lluifwd.h
index f99bb39fdd..d6047b943c 100644
--- a/indra/llui/lluifwd.h
+++ b/indra/llui/lluifwd.h
@@ -39,6 +39,7 @@ class LLComboBox;
 class LLDragHandle;
 class LLFloater;
 class LLIconCtrl;
+class LLLoadingIndicator;
 class LLLineEditor;
 class LLMenuGL;
 class LLPanel;
diff --git a/indra/llui/llurlaction.cpp b/indra/llui/llurlaction.cpp
index 679db5e39b..2f13a56b42 100644
--- a/indra/llui/llurlaction.cpp
+++ b/indra/llui/llurlaction.cpp
@@ -146,3 +146,20 @@ void LLUrlAction::copyLabelToClipboard(std::string url)
 		LLView::getWindow()->copyTextToClipboard(utf8str_to_wstring(match.getLabel()));
 	}	
 }
+
+void LLUrlAction::showProfile(std::string url)
+{
+	// Get id from 'secondlife:///app/{cmd}/{id}/{action}'
+	// and show its profile
+	LLURI uri(url);
+	LLSD path_array = uri.pathArray();
+	if (path_array.size() == 4)
+	{
+		std::string id_str = path_array.get(2).asString();
+		if (LLUUID::validate(id_str))
+		{
+			std::string cmd_str = path_array.get(1).asString();
+			executeSLURL("secondlife:///app/" + cmd_str + "/" + id_str + "/about");
+		}
+	}
+}
diff --git a/indra/llui/llurlaction.h b/indra/llui/llurlaction.h
index 4830cf27ef..b96faf1b3f 100644
--- a/indra/llui/llurlaction.h
+++ b/indra/llui/llurlaction.h
@@ -79,6 +79,9 @@ public:
 	/// copy a Url to the clipboard
 	static void copyURLToClipboard(std::string url);
 
+	/// if the Url specifies an SL command in the form like 'app/{cmd}/{id}/*', show its profile
+	static void showProfile(std::string url);
+
 	/// specify the callbacks to enable this class's functionality
 	static void	setOpenURLCallback(void (*cb) (const std::string& url));
 	static void	setOpenURLInternalCallback(void (*cb) (const std::string& url));
diff --git a/indra/llui/llurlentry.cpp b/indra/llui/llurlentry.cpp
index e1daa0ab19..f3e1a07fbc 100644
--- a/indra/llui/llurlentry.cpp
+++ b/indra/llui/llurlentry.cpp
@@ -549,6 +549,35 @@ std::string LLUrlEntryInventory::getLabel(const std::string &url, const LLUrlLab
 	return LLURI::unescape(label.empty() ? url : label);
 }
 
+//
+// LLUrlEntryObjectIM Describes a Second Life inspector for the object Url, e.g.,
+// secondlife:///app/objectim/7bcd7864-da6b-e43f-4486-91d28a28d95b?name=Object&owner=3de548e1-57be-cfea-2b78-83ae3ad95998&slurl=Danger!%20Danger!/200/200/30/&groupowned=1
+//
+LLUrlEntryObjectIM::LLUrlEntryObjectIM()
+{
+	mPattern = boost::regex("secondlife:///app/objectim/[\\da-f-]+\?.*",
+							boost::regex::perl|boost::regex::icase);
+	mMenuName = "menu_url_objectim.xml";
+}
+
+std::string LLUrlEntryObjectIM::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
+{
+	LLURI uri(url);
+	LLSD query_map = uri.queryMap();
+	if (query_map.has("name"))
+		return query_map["name"];
+	return unescapeUrl(url);
+}
+
+std::string LLUrlEntryObjectIM::getLocation(const std::string &url) const
+{
+	LLURI uri(url);
+	LLSD query_map = uri.queryMap();
+	if (query_map.has("slurl"))
+		return query_map["slurl"];
+	return LLUrlEntryBase::getLocation(url);
+}
+
 ///
 /// LLUrlEntryParcel Describes a Second Life parcel Url, e.g.,
 /// secondlife:///app/parcel/0000060e-4b39-e00b-d0c3-d98b1934e3a8/about
@@ -759,7 +788,7 @@ std::string LLUrlEntryWorldMap::getLabel(const std::string &url, const LLUrlLabe
 	}
 
 	const std::string label = LLTrans::getString("SLurlLabelShowOnMap");
-	std::string location = path_array[2];
+	std::string location = unescapeUrl(path_array[2]);
 	std::string x = (path_parts > 3) ? path_array[3] : "128";
 	std::string y = (path_parts > 4) ? path_array[4] : "128";
 	std::string z = (path_parts > 5) ? path_array[5] : "0";
@@ -792,3 +821,35 @@ std::string LLUrlEntryNoLink::getLabel(const std::string &url, const LLUrlLabelC
 {
 	return getUrl(url);
 }
+
+//
+// LLUrlEntryIcon describes an icon with <icon>...</icon> tags
+//
+LLUrlEntryIcon::LLUrlEntryIcon()
+{
+	mPattern = boost::regex("<icon\\s*>\\s*([^<]*)?\\s*</icon\\s*>",
+							boost::regex::perl|boost::regex::icase);
+	mDisabledLink = true;
+}
+
+std::string LLUrlEntryIcon::getUrl(const std::string &url) const
+{
+	return LLStringUtil::null;
+}
+
+std::string LLUrlEntryIcon::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
+{
+	return LLStringUtil::null;
+}
+
+std::string LLUrlEntryIcon::getIcon(const std::string &url)
+{
+	// Grep icon info between <icon>...</icon> tags
+	// matches[1] contains the icon name/path
+	boost::match_results<std::string::const_iterator> matches;
+	mIcon = (boost::regex_match(url, matches, mPattern) && matches[1].matched)
+		? matches[1]
+		: LLStringUtil::null;
+	LLStringUtil::trim(mIcon);
+	return mIcon;
+}
diff --git a/indra/llui/llurlentry.h b/indra/llui/llurlentry.h
index b6e422f09e..d89f647a55 100644
--- a/indra/llui/llurlentry.h
+++ b/indra/llui/llurlentry.h
@@ -204,6 +204,18 @@ public:
 private:
 };
 
+///
+/// LLUrlEntryObjectIM Describes a Second Life inspector for the object Url, e.g.,
+/// secondlife:///app/objectim/7bcd7864-da6b-e43f-4486-91d28a28d95b?name=Object&owner=3de548e1-57be-cfea-2b78-83ae3ad95998&slurl=Danger!%20Danger!/200/200/30/&groupowned=1
+///
+class LLUrlEntryObjectIM : public LLUrlEntryBase
+{
+public:
+	LLUrlEntryObjectIM();
+	/*virtual*/ std::string getLabel(const std::string &url, const LLUrlLabelCallback &cb);
+	/*virtual*/ std::string getLocation(const std::string &url) const;
+private:
+};
 
 ///
 /// LLUrlEntryParcel Describes a Second Life parcel Url, e.g.,
@@ -287,4 +299,17 @@ public:
 	/*virtual*/ std::string getUrl(const std::string &string) const;
 };
 
+///
+/// LLUrlEntryIcon describes an icon with <icon>...</icon> tags
+///
+class LLUrlEntryIcon : public LLUrlEntryBase
+{
+public:
+	LLUrlEntryIcon();
+	/*virtual*/ std::string getUrl(const std::string &string) const;
+	/*virtual*/ std::string getLabel(const std::string &url, const LLUrlLabelCallback &cb);
+	/*virtual*/ std::string getIcon(const std::string &url) const;
+};
+
+
 #endif
diff --git a/indra/llui/llurlregistry.cpp b/indra/llui/llurlregistry.cpp
index 3fadf3dd11..7a866f44c2 100644
--- a/indra/llui/llurlregistry.cpp
+++ b/indra/llui/llurlregistry.cpp
@@ -47,6 +47,7 @@ LLUrlRegistry::LLUrlRegistry()
 
 	// Urls are matched in the order that they were registered
 	registerUrl(new LLUrlEntryNoLink());
+	registerUrl(new LLUrlEntryIcon());
 	registerUrl(new LLUrlEntrySLURL());
 	registerUrl(new LLUrlEntryHTTP());
 	registerUrl(new LLUrlEntryHTTPLabel());
@@ -55,8 +56,10 @@ LLUrlRegistry::LLUrlRegistry()
 	registerUrl(new LLUrlEntryParcel());
 	registerUrl(new LLUrlEntryTeleport());
 	registerUrl(new LLUrlEntryWorldMap());
+	registerUrl(new LLUrlEntryObjectIM());
 	registerUrl(new LLUrlEntryPlace());
 	registerUrl(new LLUrlEntryInventory());
+	registerUrl(new LLUrlEntryObjectIM());
 	//LLUrlEntrySL and LLUrlEntrySLLabel have more common pattern, 
 	//so it should be registered in the end of list
 	registerUrl(new LLUrlEntrySL());
@@ -138,7 +141,8 @@ static bool stringHasUrl(const std::string &text)
 			text.find(".net") != std::string::npos ||
 			text.find(".edu") != std::string::npos ||
 			text.find(".org") != std::string::npos ||
-			text.find("<nolink>") != std::string::npos);
+			text.find("<nolink>") != std::string::npos ||
+			text.find("<icon") != std::string::npos);
 }
 
 bool LLUrlRegistry::findUrl(const std::string &text, LLUrlMatch &match, const LLUrlLabelCallback &cb)
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 781c111474..e67f0ec3fc 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -1321,6 +1321,8 @@ void LLView::drawChildren()
 
 			if (viewp->getVisible() && viewp->getRect().isValid())
 			{
+				// check for bad data
+				llassert_always(viewp->getVisible() == TRUE);
 				// Only draw views that are within the root view
 				localRectToScreen(viewp->getRect(),&screenRect);
 				if ( rootRect.overlaps(screenRect)  && LLUI::sDirtyRect.overlaps(screenRect))