Merge. Refresh from viewer-release after 3.6.10 release

31 files changed, 1096 insertions, 73 deletions

diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt
index 34a08603fa..589ceac501 100755
--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@@ -75,6 +75,7 @@ set(llui_SOURCE_FILES
     llmultislider.cpp
     llmultisliderctrl.cpp
     llnotifications.cpp
+    llnotificationslistener.cpp
     llnotificationsutil.cpp
     llpanel.cpp
     llprogressbar.cpp
@@ -128,6 +129,7 @@ set(llui_SOURCE_FILES
     llviewmodel.cpp
     llview.cpp
     llviewquery.cpp
+    llviewereventrecorder.cpp
     llwindowshade.cpp
     llxuiparser.cpp
     )
@@ -183,6 +185,7 @@ set(llui_HEADER_FILES
     llmultislider.h
     llnotificationptr.h
     llnotifications.h
+    llnotificationslistener.h
     llnotificationsutil.h
     llnotificationtemplate.h
     llnotificationvisibilityrule.h
@@ -240,6 +243,7 @@ set(llui_HEADER_FILES
     llviewinject.h
     llviewmodel.h
     llview.h
+    llviewereventrecorder.h
     llviewquery.h
     llwindowshade.h
     llxuiparser.h
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 44f2c1efe9..50ac511d18 100755
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -49,6 +49,7 @@
 #include "lluictrlfactory.h"
 #include "llhelp.h"
 #include "lldockablefloater.h"
+#include "llviewereventrecorder.h"
 
 static LLDefaultChildRegistry::Register<LLButton> r("button");
 
@@ -443,6 +444,8 @@ BOOL LLButton::handleMouseDown(S32 x, S32 y, MASK mask)
 		 */
 		LLUICtrl::handleMouseDown(x, y, mask);
 
+		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname());
+
 		if(mMouseDownSignal) (*mMouseDownSignal)(this, LLSD());
 
 		mMouseDownTimer.start();
@@ -473,6 +476,7 @@ BOOL LLButton::handleMouseUp(S32 x, S32 y, MASK mask)
 		 * by calling LLUICtrl::mMouseUpSignal(x, y, mask);
 		 */
 		LLUICtrl::handleMouseUp(x, y, mask);
+		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname()); 
 
 		// Regardless of where mouseup occurs, handle callback
 		if(mMouseUpSignal) (*mMouseUpSignal)(this, LLSD());
diff --git a/indra/llui/llchatentry.h b/indra/llui/llchatentry.h
index e67f39b21b..3f13691a30 100755
--- a/indra/llui/llchatentry.h
+++ b/indra/llui/llchatentry.h
@@ -62,8 +62,8 @@ public:
 
 	virtual void	draw();
 	virtual	void	onCommit();
-	/*virtual*/ void	onFocusReceived();
-	/*virtual*/ void	onFocusLost();
+    /*virtual*/ void	onFocusReceived();
+    /*virtual*/ void	onFocusLost();
 
 	void enableSingleLineMode(bool single_line_mode);
 	boost::signals2::connection setTextExpandedCallback(const commit_signal_t::slot_type& cb);
diff --git a/indra/llui/llcombobox.cpp b/indra/llui/llcombobox.cpp
index d4e14d9419..56be52f69a 100755
--- a/indra/llui/llcombobox.cpp
+++ b/indra/llui/llcombobox.cpp
@@ -534,6 +534,13 @@ void LLComboBox::createLineEditor(const LLComboBox::Params& p)
 	}
 }
 
+void LLComboBox::setLeftTextPadding(S32 pad)
+{
+	S32 left_pad, right_pad;
+	mTextEntry->getTextPadding(&left_pad, &right_pad);
+	mTextEntry->setTextPadding(pad, right_pad);
+}
+
 void* LLComboBox::getCurrentUserdata()
 {
 	LLScrollListItem* item = mList->getFirstSelected();
diff --git a/indra/llui/llcombobox.h b/indra/llui/llcombobox.h
index 64dbaea306..1e04fb0866 100755
--- a/indra/llui/llcombobox.h
+++ b/indra/llui/llcombobox.h
@@ -190,6 +190,8 @@ public:
 	virtual BOOL	operateOnAll(EOperation op);
 
 	//========================================================================
+
+	void			setLeftTextPadding(S32 pad);
 	
 	void*			getCurrentUserdata();
 
diff --git a/indra/llui/llcommandmanager.cpp b/indra/llui/llcommandmanager.cpp
index 625fb8e870..49cfb2255e 100755
--- a/indra/llui/llcommandmanager.cpp
+++ b/indra/llui/llcommandmanager.cpp
@@ -50,6 +50,8 @@ const LLCommandId LLCommandId::null = LLCommandId("null command");
 LLCommand::Params::Params()
 	: available_in_toybox("available_in_toybox", false)
 	, icon("icon")
+	, hover_icon_unselected("hover_icon_unselected")
+	, hover_icon_selected("hover_icon_selected")
 	, label_ref("label_ref")
 	, name("name")
 	, tooltip_ref("tooltip_ref")
@@ -71,6 +73,8 @@ LLCommand::LLCommand(const LLCommand::Params& p)
 	: mIdentifier(p.name)
 	, mAvailableInToybox(p.available_in_toybox)
 	, mIcon(p.icon)
+	, mHoverIconUnselected(p.hover_icon_unselected)
+	, mHoverIconSelected(p.hover_icon_selected)
 	, mLabelRef(p.label_ref)
 	, mName(p.name)
 	, mTooltipRef(p.tooltip_ref)
diff --git a/indra/llui/llcommandmanager.h b/indra/llui/llcommandmanager.h
index ff5a8a3257..9f276f712d 100755
--- a/indra/llui/llcommandmanager.h
+++ b/indra/llui/llcommandmanager.h
@@ -96,6 +96,9 @@ public:
 		Mandatory<std::string>	name;
 		Mandatory<std::string>	tooltip_ref;
 
+		Optional<std::string>   hover_icon_selected;
+		Optional<std::string>   hover_icon_unselected;
+
 		Mandatory<std::string>	execute_function;
 		Optional<LLSD>			execute_parameters;
 
@@ -124,6 +127,8 @@ public:
 	const std::string& labelRef() const { return mLabelRef; }
 	const std::string& name() const { return mName; }
 	const std::string& tooltipRef() const { return mTooltipRef; }
+	const std::string& hoverIconUnselected() const {return mHoverIconUnselected; }
+	const std::string& hoverIconSelected() const {return mHoverIconSelected; }
 
 	const std::string& executeFunctionName() const { return mExecuteFunction; }
 	const LLSD& executeParameters() const { return mExecuteParameters; }
@@ -150,6 +155,8 @@ private:
 	std::string mLabelRef;
 	std::string mName;
 	std::string mTooltipRef;
+	std::string mHoverIconUnselected;
+	std::string mHoverIconSelected;
 
 	std::string mExecuteFunction;
 	LLSD        mExecuteParameters;
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index 273ceb4038..6e6bcd6ab5 100755
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -29,7 +29,7 @@
 // mini-map floater, etc.
 
 #include "linden_common.h"
-
+#include "llviewereventrecorder.h"
 #include "llfloater.h"
 
 #include "llfocusmgr.h"
@@ -509,8 +509,8 @@ LLFloater::~LLFloater()
 	
 	if( gFocusMgr.childHasKeyboardFocus(this))
 	{
-		// Just in case we might still have focus here, release it.
-		releaseFocus();
+	// Just in case we might still have focus here, release it.
+	releaseFocus();
 	}
 
 	// This is important so that floaters with persistent rects (i.e., those
@@ -642,7 +642,10 @@ void LLFloater::handleVisibilityChange ( BOOL new_visibility )
 
 void LLFloater::openFloater(const LLSD& key)
 {
-	llinfos << "Opening floater " << getName() << llendl;
+    llinfos << "Opening floater " << getName() << " full path: " << getPathname() << llendl;
+
+	LLViewerEventRecorder::instance().logVisibilityChange( getPathname(), getName(), true,"floater"); // Last param is event subtype or empty string
+
 	mKey = key; // in case we need to open ourselves again
 
 	if (getSoundFlags() != SILENT 
@@ -696,6 +699,7 @@ void LLFloater::openFloater(const LLSD& key)
 void LLFloater::closeFloater(bool app_quitting)
 {
 	llinfos << "Closing floater " << getName() << llendl;
+	LLViewerEventRecorder::instance().logVisibilityChange( getPathname(), getName(), false,"floater"); // Last param is event subtype or empty string
 	if (app_quitting)
 	{
 		LLFloater::sQuitting = true;
@@ -1335,7 +1339,7 @@ void LLFloater::setFocus( BOOL b )
 	{
 		return;
 	}
-	LLUICtrl* last_focus = gFocusMgr.getLastFocusForGroup(this);
+	LLView* last_focus = gFocusMgr.getLastFocusForGroup(this);
 	// a descendent already has focus
 	BOOL child_had_focus = hasFocus();
 
@@ -1543,6 +1547,17 @@ BOOL LLFloater::handleScrollWheel(S32 x, S32 y, S32 clicks)
 }
 
 // virtual
+BOOL LLFloater::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	lldebugs << "LLFloater::handleMouseUp calling LLPanel (really LLView)'s handleMouseUp (first initialized xui to: " << getPathname() << " )" << llendl;
+	BOOL handled = LLPanel::handleMouseUp(x,y,mask); // Not implemented in LLPanel so this actually calls LLView
+	if (handled) {
+		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname());
+	}
+	return handled;
+}
+
+// virtual
 BOOL LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	if( mMinimized )
@@ -1562,7 +1577,11 @@ BOOL LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
 	else
 	{
 		bringToFront( x, y );
-		return LLPanel::handleMouseDown( x, y, mask );
+		BOOL handled = LLPanel::handleMouseDown( x, y, mask ); 
+		if (handled) {
+			LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname()); 
+		}
+		return handled;
 	}
 }
 
@@ -1802,7 +1821,7 @@ void LLFloater::onClickClose( LLFloater* self )
 	self->onClickCloseBtn();
 }
 
-void	LLFloater::onClickCloseBtn()
+void LLFloater::onClickCloseBtn(bool app_quitting)
 {
 	closeFloater(false);
 }
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
index 59448530d9..75715ef296 100755
--- a/indra/llui/llfloater.h
+++ b/indra/llui/llfloater.h
@@ -289,6 +289,7 @@ public:
 	S32				getHeaderHeight() const { return mHeaderHeight; }
 
 	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleMiddleMouseDown(S32 x, S32 y, MASK mask);
@@ -389,7 +390,7 @@ protected:
 
 	void			destroy(); // Don't call this directly.  You probably want to call closeFloater()
 
-	virtual	void	onClickCloseBtn();
+	virtual	void	onClickCloseBtn(bool app_quitting = false);
 
 	virtual void	updateTitleButtons();
 
diff --git a/indra/llui/llfocusmgr.cpp b/indra/llui/llfocusmgr.cpp
index 724d190307..f03c8d444b 100755
--- a/indra/llui/llfocusmgr.cpp
+++ b/indra/llui/llfocusmgr.cpp
@@ -469,7 +469,7 @@ void LLFocusMgr::setAppHasFocus(BOOL focus)
 	mAppHasFocus = focus; 
 }
 
-LLUICtrl* LLFocusMgr::getLastFocusForGroup(LLView* subtree_root) const
+LLView* LLFocusMgr::getLastFocusForGroup(LLView* subtree_root) const
 {
 	if (subtree_root)
 	{
@@ -477,7 +477,7 @@ LLUICtrl* LLFocusMgr::getLastFocusForGroup(LLView* subtree_root) const
 		if (found_it != mImpl->mFocusHistory.end())
 		{
 			// found last focus for this subtree
-			return static_cast<LLUICtrl*>(found_it->second.get());
+			return found_it->second.get();
 		}
 	}
 	return NULL;
diff --git a/indra/llui/llfocusmgr.h b/indra/llui/llfocusmgr.h
index 25ae1d2579..1c7326260c 100755
--- a/indra/llui/llfocusmgr.h
+++ b/indra/llui/llfocusmgr.h
@@ -97,7 +97,7 @@ public:
 	void			triggerFocusFlash();
 	BOOL			getAppHasFocus() const { return mAppHasFocus; }
 	void			setAppHasFocus(BOOL focus);
-	LLUICtrl*		getLastFocusForGroup(LLView* subtree_root) const;
+	LLView*		getLastFocusForGroup(LLView* subtree_root) const;
 	void			clearLastFocusForGroup(LLView* subtree_root);
 
 	// If setKeyboardFocus(NULL) is called, and there is a non-NULL default
diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp
index cf449217f5..f32a52e6c6 100755
--- a/indra/llui/llfolderview.cpp
+++ b/indra/llui/llfolderview.cpp
@@ -185,7 +185,7 @@ LLFolderView::LLFolderView(const Params& p)
 	mAutoOpenCandidate = NULL;
 	mAutoOpenTimer.stop();
 	mKeyboardSelection = FALSE;
-	mIndentation = p.folder_indentation;
+	mIndentation = 	getParentFolder() ? getParentFolder()->getIndentation() + mLocalIndentation : 0;  
 
 	//clear label
 	// go ahead and render root folder as usual
@@ -1613,7 +1613,7 @@ void LLFolderView::update()
 	{
 		getFolderViewModel()->getFilter().clearModified();
 	}
-    
+
 	// automatically show matching items, and select first one if we had a selection
 	if (mNeedsAutoSelect)
 	{
@@ -1653,13 +1653,13 @@ void LLFolderView::update()
 
   BOOL is_visible = isInVisibleChain();
 
-  // Puts folders/items in proper positions
+  //Puts folders/items in proper positions
   // arrange() takes the model filter flag into account and call sort() if necessary (CHUI-849)
   // It also handles the open/close folder animation
-  if (is_visible)
+  if ( is_visible )
   {
     sanitizeSelection();
-    if (needsArrange())
+    if( needsArrange() )
     {
       S32 height = 0;
       S32 width = 0;
diff --git a/indra/llui/llfolderviewitem.cpp b/indra/llui/llfolderviewitem.cpp
index 6c147ccc12..aa2343226c 100644
--- a/indra/llui/llfolderviewitem.cpp
+++ b/indra/llui/llfolderviewitem.cpp
@@ -307,7 +307,12 @@ std::set<LLFolderViewItem*> LLFolderViewItem::getSelectionList() const
 // addToFolder() returns TRUE if it succeeds. FALSE otherwise
 void LLFolderViewItem::addToFolder(LLFolderViewFolder* folder)
 {
-	folder->addItem(this);
+	folder->addItem(this); 
+
+	// Compute indentation since parent folder changed
+	mIndentation = (getParentFolder())
+		? getParentFolder()->getIndentation() + mLocalIndentation
+		: 0; 
 }
 
 
@@ -521,7 +526,7 @@ BOOL LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
 
 BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
 {
-	static LLCachedControl<S32> drag_and_drop_threshold(*LLUI::sSettingGroups["config"],"DragAndDropDistanceThreshold");
+	static LLCachedControl<S32> drag_and_drop_threshold(*LLUI::sSettingGroups["config"],"DragAndDropDistanceThreshold", 3);
 
 	mIsMouseOverTitle = (y > (getRect().getHeight() - mItemHeight));
 
@@ -940,6 +945,11 @@ LLFolderViewFolder::~LLFolderViewFolder( void )
 void LLFolderViewFolder::addToFolder(LLFolderViewFolder* folder)
 {
 	folder->addFolder(this);
+
+	// Compute indentation since parent folder changed
+	mIndentation = (getParentFolder())
+		? getParentFolder()->getIndentation() + mLocalIndentation
+		: 0; 
 }
 
 static LLFastTimer::DeclareTimer FTM_ARRANGE("Arrange");
@@ -1109,7 +1119,7 @@ S32 LLFolderViewFolder::arrange( S32* width, S32* height )
 
 BOOL LLFolderViewFolder::needsArrange()
 {
-	return mLastArrangeGeneration < getRoot()->getArrangeGeneration(); 
+	return mLastArrangeGeneration < getRoot()->getArrangeGeneration();
 }
 
 // Passes selection information on to children and record selection
diff --git a/indra/llui/llmodaldialog.cpp b/indra/llui/llmodaldialog.cpp
index 8c2be44904..ff85b0ad09 100755
--- a/indra/llui/llmodaldialog.cpp
+++ b/indra/llui/llmodaldialog.cpp
@@ -34,7 +34,7 @@
 #include "llui.h"
 #include "llwindow.h"
 #include "llkeyboard.h"
-
+#include "llmenugl.h"
 // static
 std::list<LLModalDialog*> LLModalDialog::sModalStack;
 
@@ -161,6 +161,18 @@ void LLModalDialog::setVisible( BOOL visible )
 
 BOOL LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
 {
+	LLView* popup_menu = LLMenuGL::sMenuContainer->getVisibleMenu();
+	if (popup_menu != NULL)
+	{
+		S32 mx, my;
+		LLUI::getMousePositionScreen(&mx, &my);
+		LLRect menu_screen_rc = popup_menu->calcScreenRect();
+		if(!menu_screen_rc.pointInRect(mx, my))
+		{
+			LLMenuGL::sMenuContainer->hideMenus();
+		}
+	}
+
 	if (mModal)
 	{
 		if (!LLFloater::handleMouseDown(x, y, mask))
@@ -173,16 +185,34 @@ BOOL LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
 	{
 		LLFloater::handleMouseDown(x, y, mask);
 	}
+
+
 	return TRUE;
 }
 
 BOOL LLModalDialog::handleHover(S32 x, S32 y, MASK mask)		
-{ 
+{
 	if( childrenHandleHover(x, y, mask) == NULL )
 	{
 		getWindow()->setCursor(UI_CURSOR_ARROW);
-		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;		
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;
 	}
+
+	LLView* popup_menu = LLMenuGL::sMenuContainer->getVisibleMenu();
+	if (popup_menu != NULL)
+	{
+		S32 mx, my;
+		LLUI::getMousePositionScreen(&mx, &my);
+		LLRect menu_screen_rc = popup_menu->calcScreenRect();
+		if(menu_screen_rc.pointInRect(mx, my))
+		{
+			S32 local_x = mx - popup_menu->getRect().mLeft;
+			S32 local_y = my - popup_menu->getRect().mBottom;
+			popup_menu->handleHover(local_x, local_y, mask);
+			gFocusMgr.setMouseCapture(NULL);
+		}
+	}
+
 	return TRUE;
 }
 
@@ -210,6 +240,7 @@ BOOL LLModalDialog::handleDoubleClick(S32 x, S32 y, MASK mask)
 
 BOOL LLModalDialog::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
+	LLMenuGL::sMenuContainer->hideMenus();
 	childrenHandleRightMouseDown(x, y, mask);
 	return TRUE;
 }
diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 3186c5460a..5c288c3f03 100755
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -1206,6 +1206,7 @@ LLNotifications::LLNotifications()
 :	LLNotificationChannelBase(LLNotificationFilters::includeEverything),
 	mIgnoreAllNotifications(false)
 {
+        mListener.reset(new LLNotificationsListener(*this));
 	LLUICtrl::CommitCallbackRegistry::currentRegistrar().add("Notification.Show", boost::bind(&LLNotifications::addFromCallback, this, _2));
 }
 
diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h
index 3b620084ee..6ac4a98806 100755
--- a/indra/llui/llnotifications.h
+++ b/indra/llui/llnotifications.h
@@ -98,6 +98,8 @@
 #include "llrefcount.h"
 #include "llsdparam.h"
 
+#include "llnotificationslistener.h"
+
 class LLAvatarName;
 typedef enum e_notification_priority
 {
@@ -978,6 +980,8 @@ private:
 
 	bool mIgnoreAllNotifications;
 
+	boost::scoped_ptr<LLNotificationsListener> mListener;
+
 	std::vector<LLNotificationChannelPtr> mDefaultChannels;
 };
 
diff --git a/indra/llui/llnotificationslistener.cpp b/indra/llui/llnotificationslistener.cpp
new file mode 100644
index 0000000000..9e8e943ee6
--- /dev/null
+++ b/indra/llui/llnotificationslistener.cpp
@@ -0,0 +1,359 @@
+/**
+ * @file   llnotificationslistener.cpp
+ * @author Brad Kittenbrink
+ * @date   2009-07-08
+ * @brief  Implementation for llnotificationslistener.
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llnotificationslistener.h"
+#include "llnotifications.h"
+#include "llnotificationtemplate.h"
+#include "llsd.h"
+#include "llui.h"
+
+LLNotificationsListener::LLNotificationsListener(LLNotifications & notifications) :
+    LLEventAPI("LLNotifications",
+               "LLNotifications listener to (e.g.) pop up a notification"),
+    mNotifications(notifications)
+{
+    add("requestAdd",
+        "Add a notification with specified [\"name\"], [\"substitutions\"] and [\"payload\"].\n"
+        "If optional [\"reply\"] specified, arrange to send user response on that LLEventPump.",
+        &LLNotificationsListener::requestAdd);
+    /*    add("listChannels",
+        "Post to [\"reply\"] a map of info on existing channels",
+        &LLNotificationsListener::listChannels,
+        LLSD().with("reply", LLSD()));
+    */
+    add("listChannelNotifications",
+        "Post to [\"reply\"] an array of info on notifications in channel [\"channel\"]",
+        &LLNotificationsListener::listChannelNotifications,
+        LLSD().with("reply", LLSD()).with("channel", LLSD()));
+    add("respond",
+        "Respond to notification [\"uuid\"] with data in [\"response\"]",
+        &LLNotificationsListener::respond,
+        LLSD().with("uuid", LLSD()));
+    add("cancel",
+        "Cancel notification [\"uuid\"]",
+        &LLNotificationsListener::cancel,
+        LLSD().with("uuid", LLSD()));
+    add("ignore",
+        "Ignore future notification [\"name\"]\n"
+        "(from <notification name= > in notifications.xml)\n"
+        "according to boolean [\"ignore\"].\n"
+        "If [\"name\"] is omitted or undefined, [un]ignore all future notifications.\n"
+        "Note that ignored notifications are not forwarded unless intercepted before\n"
+        "the \"Ignore\" channel.",
+        &LLNotificationsListener::ignore);
+    add("forward",
+        "Forward to [\"pump\"] future notifications on channel [\"channel\"]\n"
+        "according to boolean [\"forward\"]. When enabled, only types matching\n"
+        "[\"types\"] are forwarded, as follows:\n"
+        "omitted or undefined: forward all notifications\n"
+        "string: forward only the specific named [sig]type\n"
+        "array of string: forward any notification matching any named [sig]type.\n"
+        "When boolean [\"respond\"] is true, we auto-respond to each forwarded\n"
+        "notification.",
+        &LLNotificationsListener::forward,
+        LLSD().with("channel", LLSD()));
+}
+
+// This is here in the .cpp file so we don't need the definition of class
+// Forwarder in the header file.
+LLNotificationsListener::~LLNotificationsListener()
+{
+}
+
+void LLNotificationsListener::requestAdd(const LLSD& event_data) const
+{
+	if(event_data.has("reply"))
+	{
+		mNotifications.add(event_data["name"], 
+						   event_data["substitutions"], 
+						   event_data["payload"],
+						   boost::bind(&LLNotificationsListener::NotificationResponder, 
+									   this, 
+									   event_data["reply"].asString(), 
+									   _1, _2
+									   )
+						   );
+	}
+	else
+	{
+		mNotifications.add(event_data["name"], 
+						   event_data["substitutions"], 
+						   event_data["payload"]);
+	}
+}
+
+void LLNotificationsListener::NotificationResponder(const std::string& reply_pump, 
+										const LLSD& notification, 
+										const LLSD& response) const
+{
+	LLSD reponse_event;
+	reponse_event["notification"] = notification;
+	reponse_event["response"] = response;
+	LLEventPumps::getInstance()->obtain(reply_pump).post(reponse_event);
+}
+/*
+void LLNotificationsListener::listChannels(const LLSD& params) const
+{
+    LLReqID reqID(params);
+    LLSD response(reqID.makeResponse());
+    for (LLNotifications::
+
+
+
+    for (LLNotifications::ChannelMap::const_iterator cmi(mNotifications.mChannels.begin()),
+                                                     cmend(mNotifications.mChannels.end());
+         cmi != cmend; ++cmi)
+    {
+        LLSD channelInfo;
+        channelInfo["parent"] = cmi->second->getParentChannelName();
+        response[cmi->first] = channelInfo;
+    }
+    LLEventPumps::instance().obtain(params["reply"]).post(response);
+}
+*/
+void LLNotificationsListener::listChannelNotifications(const LLSD& params) const
+{
+    LLReqID reqID(params);
+    LLSD response(reqID.makeResponse());
+    LLNotificationChannelPtr channel(mNotifications.getChannel(params["channel"]));
+    if (channel)
+    {
+        LLSD notifications(LLSD::emptyArray());
+        for (LLNotificationChannel::Iterator ni(channel->begin()), nend(channel->end());
+             ni != nend; ++ni)
+        {
+            notifications.append(asLLSD(*ni));
+        }
+        response["notifications"] = notifications;
+    }
+    LLEventPumps::instance().obtain(params["reply"]).post(response);
+}
+
+void LLNotificationsListener::respond(const LLSD& params) const
+{
+    LLNotificationPtr notification(mNotifications.find(params["uuid"]));
+    if (notification)
+    {
+        notification->respond(params["response"]);
+    }
+}
+
+void LLNotificationsListener::cancel(const LLSD& params) const
+{
+    LLNotificationPtr notification(mNotifications.find(params["uuid"]));
+    if (notification)
+    {
+        mNotifications.cancel(notification);
+    }
+}
+
+void LLNotificationsListener::ignore(const LLSD& params) const
+{
+    // Calling a method named "ignore", but omitting its "ignore" Boolean
+    // argument, should by default cause something to be ignored. Explicitly
+    // pass ["ignore"] = false to cancel ignore.
+    bool ignore = true;
+    if (params.has("ignore"))
+    {
+        ignore = params["ignore"].asBoolean();
+    }
+    // This method can be used to affect either a single notification name or
+    // all future notifications. The two use substantially different mechanisms.
+    if (params["name"].isDefined())
+    {
+        // ["name"] was passed: ignore just that notification
+		LLNotificationTemplatePtr templatep = mNotifications.getTemplate(params["name"]);
+		if (templatep)
+		{
+			templatep->mForm->setIgnored(ignore);
+		}
+    }
+    else
+    {
+        // no ["name"]: ignore all future notifications
+        mNotifications.setIgnoreAllNotifications(ignore);
+    }
+}
+
+class LLNotificationsListener::Forwarder: public LLEventTrackable
+{
+    LOG_CLASS(LLNotificationsListener::Forwarder);
+public:
+    Forwarder(LLNotifications& llnotifications, const std::string& channel):
+        mNotifications(llnotifications),
+        mRespond(false)
+    {
+        // Connect to the specified channel on construction. Because
+        // LLEventTrackable is a base, we should automatically disconnect when
+        // destroyed.
+        LLNotificationChannelPtr channelptr(llnotifications.getChannel(channel));
+        if (channelptr)
+        {
+            // Insert our processing as a "passed filter" listener. This way
+            // we get to run before all the "changed" listeners, and we get to
+            // swipe it (hide it from the other listeners) if desired.
+            channelptr->connectPassedFilter(boost::bind(&Forwarder::handle, this, _1));
+        }
+    }
+
+    void setPumpName(const std::string& name) { mPumpName = name; }
+    void setTypes(const LLSD& types) { mTypes = types; }
+    void setRespond(bool respond) { mRespond = respond; }
+
+private:
+    bool handle(const LLSD& notification) const;
+    bool matchType(const LLSD& filter, const std::string& type) const;
+
+    LLNotifications& mNotifications;
+    std::string mPumpName;
+    LLSD mTypes;
+    bool mRespond;
+};
+
+void LLNotificationsListener::forward(const LLSD& params)
+{
+    std::string channel(params["channel"]);
+    // First decide whether we're supposed to start forwarding or stop it.
+    // Default to true.
+    bool forward = true;
+    if (params.has("forward"))
+    {
+        forward = params["forward"].asBoolean();
+    }
+    if (! forward)
+    {
+        // This is a request to stop forwarding notifications on the specified
+        // channel. The rest of the params don't matter.
+        // Because mForwarders contains scoped_ptrs, erasing the map entry
+        // DOES delete the heap Forwarder object. Because Forwarder derives
+        // from LLEventTrackable, destroying it disconnects it from the
+        // channel.
+        mForwarders.erase(channel);
+        return;
+    }
+    // From here on, we know we're being asked to start (or modify) forwarding
+    // on the specified channel. Find or create an appropriate Forwarder.
+    ForwarderMap::iterator
+        entry(mForwarders.insert(ForwarderMap::value_type(channel, ForwarderMap::mapped_type())).first);
+    if (! entry->second)
+    {
+        entry->second.reset(new Forwarder(mNotifications, channel));
+    }
+    // Now, whether this Forwarder is brand-new or not, update it with the new
+    // request info.
+    Forwarder& fwd(*entry->second);
+    fwd.setPumpName(params["pump"]);
+    fwd.setTypes(params["types"]);
+    fwd.setRespond(params["respond"]);
+}
+
+bool LLNotificationsListener::Forwarder::handle(const LLSD& notification) const
+{
+    LL_INFOS("LLNotificationsListener") << "handle(" << notification << ")" << LL_ENDL;
+    if (notification["sigtype"].asString() == "delete")
+    {
+        LL_INFOS("LLNotificationsListener") << "ignoring delete" << LL_ENDL;
+        // let other listeners see the "delete" operation
+        return false;
+    }
+    LLNotificationPtr note(mNotifications.find(notification["id"]));
+    if (! note)
+    {
+        LL_INFOS("LLNotificationsListener") << notification["id"] << " not found" << LL_ENDL;
+        return false;
+    }
+    if (! matchType(mTypes, note->getType()))
+    {
+        LL_INFOS("LLNotificationsListener") << "didn't match types " << mTypes << LL_ENDL;
+        // We're not supposed to intercept this particular notification. Let
+        // other listeners process it.
+        return false;
+    }
+    LL_INFOS("LLNotificationsListener") << "sending via '" << mPumpName << "'" << LL_ENDL;
+    // This is a notification we care about. Forward it through specified
+    // LLEventPump.
+    LLEventPumps::instance().obtain(mPumpName).post(asLLSD(note));
+    // Are we also being asked to auto-respond?
+    if (mRespond)
+    {
+        LL_INFOS("LLNotificationsListener") << "should respond" << LL_ENDL;
+        note->respond(LLSD::emptyMap());
+        // Did that succeed in removing the notification? Only cancel() if
+        // it's still around -- otherwise we get an LL_ERRS crash!
+        note = mNotifications.find(notification["id"]);
+        if (note)
+        {
+            LL_INFOS("LLNotificationsListener") << "respond() didn't clear, canceling" << LL_ENDL;
+            mNotifications.cancel(note);
+        }
+    }
+    // If we've auto-responded to this notification, then it's going to be
+    // deleted. Other listeners would get the change operation, try to look it
+    // up and be baffled by lookup failure. So when we auto-respond, suppress
+    // this notification: don't pass it to other listeners.
+    return mRespond;
+}
+
+bool LLNotificationsListener::Forwarder::matchType(const LLSD& filter, const std::string& type) const
+{
+    // Decide whether this notification matches filter:
+    // undefined: forward all notifications
+    if (filter.isUndefined())
+    {
+        return true;
+    }
+    // array of string: forward any notification matching any named type
+    if (filter.isArray())
+    {
+        for (LLSD::array_const_iterator ti(filter.beginArray()), tend(filter.endArray());
+             ti != tend; ++ti)
+        {
+            if (ti->asString() == type)
+            {
+                return true;
+            }
+        }
+        // Didn't match any entry in the array
+        return false;
+    }
+    // string: forward only the specific named type
+    return (filter.asString() == type);
+}
+
+LLSD LLNotificationsListener::asLLSD(LLNotificationPtr note)
+{
+    LLSD notificationInfo(note->asLLSD());
+    // For some reason the following aren't included in LLNotification::asLLSD().
+    notificationInfo["summary"] = note->summarize();
+    notificationInfo["id"]      = note->id();
+    notificationInfo["type"]    = note->getType();
+    notificationInfo["message"] = note->getMessage();
+    notificationInfo["label"]   = note->getLabel();
+    return notificationInfo;
+}
diff --git a/indra/llui/llnotificationslistener.h b/indra/llui/llnotificationslistener.h
new file mode 100644
index 0000000000..f9f7641de6
--- /dev/null
+++ b/indra/llui/llnotificationslistener.h
@@ -0,0 +1,69 @@
+/**
+ * @file   llnotificationslistener.h
+ * @author Brad Kittenbrink
+ * @date   2009-07-08
+ * @brief  Wrap subset of LLNotifications API in event API for test scripts.
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLNOTIFICATIONSLISTENER_H
+#define LL_LLNOTIFICATIONSLISTENER_H
+
+#include "lleventapi.h"
+#include "llnotificationptr.h"
+#include <boost/shared_ptr.hpp>
+#include <map>
+#include <string>
+
+class LLNotifications;
+class LLSD;
+
+class LLNotificationsListener : public LLEventAPI
+{
+public:
+    LLNotificationsListener(LLNotifications & notifications);
+    ~LLNotificationsListener();
+
+private:
+    void requestAdd(LLSD const & event_data) const;
+
+	void NotificationResponder(const std::string& replypump, 
+							   const LLSD& notification, 
+							   const LLSD& response) const;
+
+    void listChannels(const LLSD& params) const;
+    void listChannelNotifications(const LLSD& params) const;
+    void respond(const LLSD& params) const;
+    void cancel(const LLSD& params) const;
+    void ignore(const LLSD& params) const;
+    void forward(const LLSD& params);
+
+    static LLSD asLLSD(LLNotificationPtr);
+
+    class Forwarder;
+    typedef std::map<std::string, boost::shared_ptr<Forwarder> > ForwarderMap;
+    ForwarderMap mForwarders;
+	LLNotifications & mNotifications;
+};
+
+#endif // LL_LLNOTIFICATIONSLISTENER_H
diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
index cbcce0ece5..238eae21c2 100755
--- a/indra/llui/llscrollcontainer.cpp
+++ b/indra/llui/llscrollcontainer.cpp
@@ -519,7 +519,7 @@ bool LLScrollContainer::addChild(LLView* view, S32 tab_group)
 
 void LLScrollContainer::updateScroll()
 {
-	if (!mScrolledView)
+	if (!getVisible() || !mScrolledView)
 	{
 		return;
 	}
diff --git a/indra/llui/lltabcontainer.cpp b/indra/llui/lltabcontainer.cpp
index fd98155704..6fd2bb1b36 100755
--- a/indra/llui/lltabcontainer.cpp
+++ b/indra/llui/lltabcontainer.cpp
@@ -27,7 +27,7 @@
 #include "linden_common.h"
 
 #include "lltabcontainer.h"
-
+#include "llviewereventrecorder.h"
 #include "llfocusmgr.h"
 #include "lllocalcliprect.h"
 #include "llrect.h"
@@ -193,12 +193,15 @@ LLTabContainer::TabParams::TabParams()
 :	tab_top_image_unselected("tab_top_image_unselected"),
 	tab_top_image_selected("tab_top_image_selected"),
 	tab_top_image_flash("tab_top_image_flash"),
+	tab_top_image_hovered("tab_top_image_hovered"),
 	tab_bottom_image_unselected("tab_bottom_image_unselected"),
 	tab_bottom_image_selected("tab_bottom_image_selected"),
 	tab_bottom_image_flash("tab_bottom_image_flash"),
+	tab_bottom_image_hovered("tab_bottom_image_hovered"),
 	tab_left_image_unselected("tab_left_image_unselected"),
 	tab_left_image_selected("tab_left_image_selected"),
-	tab_left_image_flash("tab_left_image_flash")
+	tab_left_image_flash("tab_left_image_flash"),
+	tab_left_image_hovered("tab_left_image_hovered")
 {}
 
 LLTabContainer::Params::Params()
@@ -218,7 +221,8 @@ LLTabContainer::Params::Params()
 	open_tabs_on_drag_and_drop("open_tabs_on_drag_and_drop", false),
 	tab_icon_ctrl_pad("tab_icon_ctrl_pad", 0),
 	use_ellipses("use_ellipses"),
-	font_halign("halign")
+	font_halign("halign"),
+	use_highlighting_on_hover("use_highlighting_on_hover",false)
 {}
 
 LLTabContainer::LLTabContainer(const LLTabContainer::Params& p)
@@ -254,7 +258,8 @@ LLTabContainer::LLTabContainer(const LLTabContainer::Params& p)
 	mCustomIconCtrlUsed(p.use_custom_icon_ctrl),
 	mOpenTabsOnDragAndDrop(p.open_tabs_on_drag_and_drop),
 	mTabIconCtrlPad(p.tab_icon_ctrl_pad),
-	mUseTabEllipses(p.use_ellipses)
+	mUseTabEllipses(p.use_ellipses),
+	mUseHighlightingOnHover(p.use_highlighting_on_hover)
 {
 	static LLUICachedControl<S32> tabcntr_vert_tab_min_width ("UITabCntrVertTabMinWidth", 0);
 
@@ -578,6 +583,11 @@ BOOL LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
 			tab_button->setFocus(TRUE);
 		}
 	}
+	if (handled) {
+		// Note: May need to also capture local coords right here ?
+		LLViewerEventRecorder::instance().update_xui(getPathname( ));
+	}
+
 	return handled;
 }
 
@@ -629,30 +639,33 @@ BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
 	BOOL handled = FALSE;
 	BOOL has_scroll_arrows = (getMaxScrollPos() > 0)  && !getTabsHidden();
 
+	S32 local_x = x - getRect().mLeft;
+	S32 local_y = y - getRect().mBottom;
+
 	if (has_scroll_arrows)
 	{
 		if (mJumpPrevArrowBtn && mJumpPrevArrowBtn->getRect().pointInRect(x, y))
 		{
-			S32 local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
-			S32 local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
+			local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
+			local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
 			handled = mJumpPrevArrowBtn->handleMouseUp(local_x, local_y, mask);
 		}
 		else if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x,	y))
 		{
-			S32	local_x	= x	- mJumpNextArrowBtn->getRect().mLeft;
-			S32	local_y	= y	- mJumpNextArrowBtn->getRect().mBottom;
+			local_x	= x	- mJumpNextArrowBtn->getRect().mLeft;
+			local_y	= y	- mJumpNextArrowBtn->getRect().mBottom;
 			handled = mJumpNextArrowBtn->handleMouseUp(local_x,	local_y, mask);
 		}
 		else if (mPrevArrowBtn && mPrevArrowBtn->getRect().pointInRect(x, y))
 		{
-			S32 local_x = x - mPrevArrowBtn->getRect().mLeft;
-			S32 local_y = y - mPrevArrowBtn->getRect().mBottom;
+			local_x = x - mPrevArrowBtn->getRect().mLeft;
+			local_y = y - mPrevArrowBtn->getRect().mBottom;
 			handled = mPrevArrowBtn->handleMouseUp(local_x, local_y, mask);
 		}
 		else if (mNextArrowBtn && mNextArrowBtn->getRect().pointInRect(x, y))
 		{
-			S32 local_x = x - mNextArrowBtn->getRect().mLeft;
-			S32 local_y = y - mNextArrowBtn->getRect().mBottom;
+			local_x = x - mNextArrowBtn->getRect().mLeft;
+			local_y = y - mNextArrowBtn->getRect().mBottom;
 			handled = mNextArrowBtn->handleMouseUp(local_x, local_y, mask);
 		}
 	}
@@ -676,6 +689,10 @@ BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
 		}
 		gFocusMgr.setMouseCapture(NULL);
 	}
+	if (handled) {
+		// Note: may need to capture local coords here
+		LLViewerEventRecorder::instance().update_xui(getPathname( ));
+	}
 	return handled;
 }
 
@@ -891,18 +908,30 @@ void LLTabContainer::update_images(LLTabTuple* tuple, TabParams params, LLTabCon
 			tuple->mButton->setImageUnselected(static_cast<LLUIImage*>(params.tab_top_image_unselected));
 			tuple->mButton->setImageSelected(static_cast<LLUIImage*>(params.tab_top_image_selected));
 			tuple->mButton->setImageFlash(static_cast<LLUIImage*>(params.tab_top_image_flash));
+			if(mUseHighlightingOnHover)
+			{
+				tuple->mButton->setImageHoverUnselected(static_cast<LLUIImage*>(params.tab_top_image_hovered));
+			}
 		}
 		else if (pos == LLTabContainer::BOTTOM)
 		{
 			tuple->mButton->setImageUnselected(static_cast<LLUIImage*>(params.tab_bottom_image_unselected));
 			tuple->mButton->setImageSelected(static_cast<LLUIImage*>(params.tab_bottom_image_selected));
 			tuple->mButton->setImageFlash(static_cast<LLUIImage*>(params.tab_bottom_image_flash));
+			if(mUseHighlightingOnHover)
+			{
+				tuple->mButton->setImageHoverUnselected(static_cast<LLUIImage*>(params.tab_bottom_image_hovered));
+			}
 		}
 		else if (pos == LLTabContainer::LEFT)
 		{
 			tuple->mButton->setImageUnselected(static_cast<LLUIImage*>(params.tab_left_image_unselected));
 			tuple->mButton->setImageSelected(static_cast<LLUIImage*>(params.tab_left_image_selected));
 			tuple->mButton->setImageFlash(static_cast<LLUIImage*>(params.tab_left_image_flash));
+			if(mUseHighlightingOnHover)
+			{
+				tuple->mButton->setImageHoverUnselected(static_cast<LLUIImage*>(params.tab_left_image_hovered));
+			}
 		}
 	}
 }
@@ -1059,21 +1088,21 @@ void LLTabContainer::addTabPanel(const TabPanelParams& panel)
 		
 		if (mIsVertical)
 		{
-			p.name(std::string("vert tab button"));
-			p.image_unselected(mMiddleTabParams.tab_left_image_unselected);
-			p.image_selected(mMiddleTabParams.tab_left_image_selected);
-			p.follows.flags = p.follows.flags() | FOLLOWS_TOP;
+		  p.name("vtab_"+std::string(child->getName()));
+		  p.image_unselected(mMiddleTabParams.tab_left_image_unselected);
+		  p.image_selected(mMiddleTabParams.tab_left_image_selected);
+		  p.follows.flags = p.follows.flags() | FOLLOWS_TOP;
 		}
 		else
-		{
-			p.name(std::string(child->getName()) + " tab");
-			p.visible(false);
-			p.image_unselected(tab_img);
-			p.image_selected(tab_selected_img);
-			p.follows.flags = p.follows.flags() | (getTabPosition() == TOP ? FOLLOWS_TOP : FOLLOWS_BOTTOM);
-			// Try to squeeze in a bit more text
-			p.pad_left( mLabelPadLeft );
-			p.pad_right(2);
+		  { 
+		    p.name("htab_"+std::string(child->getName()));
+		    p.visible(false);
+		    p.image_unselected(tab_img);
+		    p.image_selected(tab_selected_img);
+		    p.follows.flags = p.follows.flags() | (getTabPosition() == TOP ? FOLLOWS_TOP : FOLLOWS_BOTTOM);
+		    // Try to squeeze in a bit more text
+		    p.pad_left( mLabelPadLeft );
+		    p.pad_right(2);
 		}
 		
 		// *TODO : It seems wrong not to use p in both cases considering the way p is initialized
diff --git a/indra/llui/lltabcontainer.h b/indra/llui/lltabcontainer.h
index 57862fc626..7e7d4ac6e6 100755
--- a/indra/llui/lltabcontainer.h
+++ b/indra/llui/lltabcontainer.h
@@ -62,12 +62,15 @@ public:
 		Optional<LLUIImage*>				tab_top_image_unselected,
 											tab_top_image_selected,
 											tab_top_image_flash,
+											tab_top_image_hovered,
 											tab_bottom_image_unselected,
 											tab_bottom_image_selected,
 											tab_bottom_image_flash,
+											tab_bottom_image_hovered,
 											tab_left_image_unselected,
 											tab_left_image_selected,
-											tab_left_image_flash;		
+											tab_left_image_flash,
+											tab_left_image_hovered;
 		TabParams();
 	};
 
@@ -114,6 +117,11 @@ public:
 		 */
 		Optional<S32>						tab_icon_ctrl_pad;
 
+		/**
+		 *  This variable is used to found out should we highlight tab button on hover
+		*/
+		Optional<bool>						use_highlighting_on_hover;
+
 		Params();
 	};
 
@@ -307,6 +315,7 @@ private:
 	bool							mOpenTabsOnDragAndDrop;
 	S32								mTabIconCtrlPad;
 	bool							mUseTabEllipses;
+	bool                            mUseHighlightingOnHover;
 };
 
 #endif  // LL_TABCONTAINER_H
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index cc171661ce..5ec4cf4fe5 100755
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -1029,7 +1029,7 @@ BOOL LLTextBase::handleMouseDown(S32 x, S32 y, MASK mask)
 BOOL LLTextBase::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
-	if (cur_segment && cur_segment->handleMouseUp(x, y, mask))
+	if (hasMouseCapture() && cur_segment && cur_segment->handleMouseUp(x, y, mask))
 	{
 		// Did we just click on a link?
 		if (mURLClickSignal
diff --git a/indra/llui/lltextbox.cpp b/indra/llui/lltextbox.cpp
index 11cfa1d263..d175204e6d 100755
--- a/indra/llui/lltextbox.cpp
+++ b/indra/llui/lltextbox.cpp
@@ -60,10 +60,13 @@ BOOL LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
 
 	if (!handled && mClickedCallback)
 	{
+		handled = TRUE;
+	}
+
+	if (handled)
+	{
 		// Route future Mouse messages here preemptively.  (Release on mouse up.)
 		gFocusMgr.setMouseCapture( this );
-
-		handled = TRUE;
 	}
 
 	return handled;
@@ -71,7 +74,7 @@ BOOL LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
 
 BOOL LLTextBox::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	BOOL	handled = LLTextBase::handleMouseUp(x, y, mask);
 
 	if (getSoundFlags() & MOUSE_UP)
 	{
@@ -93,10 +96,6 @@ BOOL LLTextBox::handleMouseUp(S32 x, S32 y, MASK mask)
 			handled = TRUE;
 		}
 	}
-	else
-	{
-		handled = LLTextBase::handleMouseUp(x, y, mask);
-	}
 
 	return handled;
 }
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index 0c16e06109..62140dd9d6 100755
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -666,6 +666,14 @@ void LLTextEditor::selectAll()
 	updatePrimary();
 }
 
+void LLTextEditor::selectByCursorPosition(S32 prev_cursor_pos, S32 next_cursor_pos)
+{
+	setCursorPos(prev_cursor_pos);
+	startSelection();
+	setCursorPos(next_cursor_pos);
+	endSelection();
+}
+
 BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	BOOL	handled = FALSE;
@@ -713,7 +721,6 @@ BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 				setCursorAtLocalPos( x, y, true );
 				startSelection();
 			}
-			gFocusMgr.setMouseCapture( this );
 		}
 
 		handled = TRUE;
@@ -722,6 +729,10 @@ BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 	// Delay cursor flashing
 	resetCursorBlink();
 
+	if (handled && !gFocusMgr.getMouseCapture())
+	{
+		gFocusMgr.setMouseCapture( this );
+	}
 	return handled;
 }
 
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index 32b543ec0e..d3b7bc0eb7 100755
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -144,6 +144,8 @@ public:
 	virtual void	selectAll();
 	virtual BOOL	canSelectAll()	const;
 
+	void 			selectByCursorPosition(S32 prev_cursor_pos, S32 next_cursor_pos);
+
 	virtual bool	canLoadOrSaveToFile();
 
 	void			selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap = TRUE);
diff --git a/indra/llui/lltoolbar.cpp b/indra/llui/lltoolbar.cpp
index 928e82cb8c..6bfe113933 100755
--- a/indra/llui/lltoolbar.cpp
+++ b/indra/llui/lltoolbar.cpp
@@ -928,6 +928,8 @@ LLToolBarButton* LLToolBar::createButton(const LLCommandId& id)
 	button_p.label = LLTrans::getString(commandp->labelRef());
 	button_p.tool_tip = LLTrans::getString(commandp->tooltipRef());
 	button_p.image_overlay = LLUI::getUIImage(commandp->icon());
+	button_p.image_hover_unselected = LLUI::getUIImage(commandp->hoverIconUnselected());
+	button_p.image_hover_selected = LLUI::getUIImage(commandp->hoverIconSelected());
 	button_p.button_flash_enable = commandp->isFlashingAllowed();
 	button_p.overwriteFrom(mButtonParams[mButtonType]);
 	LLToolBarButton* button = LLUICtrlFactory::create<LLToolBarButton>(button_p);
diff --git a/indra/llui/llui.h b/indra/llui/llui.h
index 0a0e0e164e..0bc4424a8c 100755
--- a/indra/llui/llui.h
+++ b/indra/llui/llui.h
@@ -405,11 +405,6 @@ public:
 					  const std::string& comment = "Declared In Code")
 	:	LLCachedControl<T>(LLUI::getControlControlGroup(name), name, default_value, comment)
 	{}
-
-	// This constructor will signal an error if the control doesn't exist in the control group
-	LLUICachedControl(const std::string& name)
-	:	LLCachedControl<T>(LLUI::getControlControlGroup(name), name)
-	{}
 };
 
 namespace LLInitParam
diff --git a/indra/llui/lluictrl.cpp b/indra/llui/lluictrl.cpp
index b9c843e931..1722bf27bd 100755
--- a/indra/llui/lluictrl.cpp
+++ b/indra/llui/lluictrl.cpp
@@ -29,7 +29,7 @@
 
 #define LLUICTRL_CPP
 #include "lluictrl.h"
-
+#include "llviewereventrecorder.h"
 #include "llfocusmgr.h"
 #include "llpanel.h"
 #include "lluictrlfactory.h"
@@ -308,22 +308,40 @@ void LLUICtrl::onMouseLeave(S32 x, S32 y, MASK mask)
 //virtual 
 BOOL LLUICtrl::handleMouseDown(S32 x, S32 y, MASK mask)
 {
+
+	lldebugs << "LLUICtrl::handleMouseDown calling	LLView)'s handleMouseUp (first initialized xui to: " << getPathname() << " )" << llendl;
+  
 	BOOL handled  = LLView::handleMouseDown(x,y,mask);
+	
 	if (mMouseDownSignal)
 	{
 		(*mMouseDownSignal)(this,x,y,mask);
 	}
+	lldebugs << "LLUICtrl::handleMousedown - handled is returning as: " << handled << "	  " << llendl;
+	
+	if (handled) {
+		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-56,-56,getPathname());
+	}
 	return handled;
 }
 
 //virtual
 BOOL LLUICtrl::handleMouseUp(S32 x, S32 y, MASK mask)
 {
+
+	lldebugs << "LLUICtrl::handleMouseUp calling LLView)'s handleMouseUp (first initialized xui to: " << getPathname() << " )" << llendl;
+
 	BOOL handled  = LLView::handleMouseUp(x,y,mask);
+	if (handled) {
+		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-56,-56,getPathname()); 
+	}
 	if (mMouseUpSignal)
 	{
 		(*mMouseUpSignal)(this,x,y,mask);
 	}
+
+	lldebugs << "LLUICtrl::handleMouseUp - handled for xui " << getPathname() << "  -  is returning as: " << handled << "   " << llendl;
+
 	return handled;
 }
 
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 3613a40e2c..20015dca1a 100755
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -48,7 +48,9 @@
 #include "lluictrlfactory.h"
 #include "lltooltip.h"
 #include "llsdutil.h"
-
+#include "llsdserialize.h"
+#include "llviewereventrecorder.h"
+#include "llkeyboard.h"
 // for ui edit hack
 #include "llbutton.h"
 #include "lllineeditor.h"
@@ -642,13 +644,27 @@ void LLView::setVisible(BOOL visible)
 // virtual
 void LLView::handleVisibilityChange ( BOOL new_visibility )
 {
+	BOOL old_visibility;
 	BOOST_FOREACH(LLView* viewp, mChildList)
 	{
 		// only views that are themselves visible will have their overall visibility affected by their ancestors
-		if (viewp->getVisible())
+		old_visibility=viewp->getVisible();
+
+		if (old_visibility!=new_visibility)
+		{
+			LLViewerEventRecorder::instance().logVisibilityChange( viewp->getPathname(), viewp->getName(), new_visibility,"widget");
+		}
+
+		if (old_visibility)
 		{
 			viewp->handleVisibilityChange ( new_visibility );
 		}
+
+		// Consider changing returns to confirm success and know which widget grabbed it
+		// For now assume success and log at highest xui possible 
+		// NOTE we log actual state - which may differ if it somehow failed to set visibility
+		lldebugs << "LLView::handleVisibilityChange	 - now: " << getVisible()  << " xui: " << viewp->getPathname() << " name: " << viewp->getName() << llendl;
+		
 	}
 }
 
@@ -697,6 +713,7 @@ bool LLView::visibleEnabledAndContains(S32 local_x, S32 local_y)
 		&& getEnabled();
 }
 
+// This is NOT event recording related
 void LLView::logMouseEvent()
 {
 	if (sDebugMouseHandling)
@@ -743,7 +760,14 @@ LLView* LLView::childrenHandleMouseEvent(const METHOD& method, S32 x, S32 y, XDA
 		if ((viewp->*method)( local_x, local_y, extra )
 			|| (allow_mouse_block && viewp->blockMouseEvent( local_x, local_y )))
 		{
+			lldebugs << "LLView::childrenHandleMouseEvent calling updatemouseeventinfo - local_x|global x  "<< local_x << " " << x	<< "local/global y " << local_y << " " << y << llendl;
+			lldebugs << "LLView::childrenHandleMouseEvent  getPathname for viewp result: " << viewp->getPathname() << "for this view: " << getPathname() << llendl;
+
+			LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname()); 
+
+			// This is NOT event recording related
 			viewp->logMouseEvent();
+
 			return viewp;
 		}
 	}
@@ -766,6 +790,7 @@ LLView* LLView::childrenHandleToolTip(S32 x, S32 y, MASK mask)
 		if (viewp->handleToolTip(local_x, local_y, mask) 
 			|| viewp->blockMouseEvent(local_x, local_y))
 		{
+			// This is NOT event recording related
 			viewp->logMouseEvent();
 			return viewp;
 		}
@@ -824,6 +849,7 @@ LLView* LLView::childrenHandleHover(S32 x, S32 y, MASK mask)
 		if (viewp->handleHover(local_x, local_y, mask)
 			|| viewp->blockMouseEvent(local_x, local_y))
 		{
+			// This is NOT event recording related
 			viewp->logMouseEvent();
 			return viewp;
 		}
@@ -907,10 +933,12 @@ BOOL LLView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 
 		if (!handled)
 		{
+			// For event logging we don't care which widget handles it
+			// So we capture the key at the end of this function once we know if it was handled
 			handled = handleKeyHere( key, mask );
-			if (handled && LLView::sDebugKeys)
+			if (handled)
 			{
-				llinfos << "Key handled by " << getName() << llendl;
+				llwarns << "Key handled by " << getName() << llendl;
 			}
 		}
 	}
@@ -958,6 +986,11 @@ BOOL LLView::handleUnicodeChar(llwchar uni_char, BOOL called_from_parent)
 		handled = mParentView->handleUnicodeChar(uni_char, FALSE);
 	}
 
+	if (handled)
+	{
+		LLViewerEventRecorder::instance().logKeyUnicodeEvent(uni_char);
+	}
+	
 	return handled;
 }
 
@@ -987,12 +1020,16 @@ BOOL LLView::hasMouseCapture()
 
 BOOL LLView::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseUp( x, y, mask ) != NULL;
+	LLView* r = childrenHandleMouseUp( x, y, mask );
+
+	return (r!=NULL);
 }
 
 BOOL LLView::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseDown( x, y, mask ) != NULL;
+	LLView* r= childrenHandleMouseDown(x, y, mask );
+
+	return (r!=NULL);
 }
 
 BOOL LLView::handleDoubleClick(S32 x, S32 y, MASK mask)
@@ -1065,7 +1102,7 @@ LLView* LLView::childrenHandleDoubleClick(S32 x, S32 y, MASK mask)
 
 LLView* LLView::childrenHandleMouseUp(S32 x, S32 y, MASK mask)
 {
-	return childrenHandleMouseEvent(&LLView::handleMouseUp, x, y, mask);
+	return	childrenHandleMouseEvent(&LLView::handleMouseUp, x, y, mask);
 }
 
 LLView* LLView::childrenHandleRightMouseUp(S32 x, S32 y, MASK mask)
diff --git a/indra/llui/llviewereventrecorder.cpp b/indra/llui/llviewereventrecorder.cpp
new file mode 100644
index 0000000000..a352f621eb
--- /dev/null
+++ b/indra/llui/llviewereventrecorder.cpp
@@ -0,0 +1,296 @@
+/**
+ * @file llviewereventrecorder.cpp
+ * @brief Viewer event recording and playback support for mouse and keyboard events
+ *
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
+ * 
+ * Copyright (c) 2013, Linden Research, Inc.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+
+#include "llviewereventrecorder.h"
+#include "llui.h"
+#include "llleap.h"
+
+LLViewerEventRecorder::LLViewerEventRecorder() {
+
+  clear(UNDEFINED);
+
+  // Remove any previous event log file
+  std::string old_log_ui_events_to_llsd_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "SecondLife_Events_log.old");
+  LLFile::remove(old_log_ui_events_to_llsd_file);
+  
+
+  mLogFilename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "SecondLife_Events_log.llsd");
+  LLFile::rename(mLogFilename, old_log_ui_events_to_llsd_file);
+
+}
+
+
+bool LLViewerEventRecorder::displayViewerEventRecorderMenuItems() {
+  return LLUI::sSettingGroups["config"]->getBOOL("ShowEventRecorderMenuItems");
+}
+
+
+void LLViewerEventRecorder::setEventLoggingOn() {
+  if (! mLog.is_open()) {
+    mLog.open(mLogFilename, llofstream::out);
+  }
+  logEvents=true; 
+  lldebugs << "LLViewerEventRecorder::setEventLoggingOn event logging turned on" << llendl;
+}
+
+void LLViewerEventRecorder::setEventLoggingOff() {
+  logEvents=false;
+  mLog.flush();
+  mLog.close();
+  lldebugs << "LLViewerEventRecorder::setEventLoggingOff event logging turned off" << llendl;
+}
+
+
+ LLViewerEventRecorder::~LLViewerEventRecorder() {
+  if (mLog.is_open()) {
+      mLog.close();
+    }
+}
+
+void LLViewerEventRecorder::clear_xui() {
+  xui.clear();
+}
+
+void LLViewerEventRecorder::clear(S32 r) {
+
+  xui.clear();
+
+  local_x=r;
+  local_y=r;
+
+  global_x=r;
+  global_y=r;
+    
+
+}
+
+void LLViewerEventRecorder::setMouseLocalCoords(S32 x, S32 y) {
+  local_x=x;
+  local_y=y;
+}
+
+void LLViewerEventRecorder::setMouseGlobalCoords(S32 x, S32 y) {
+  global_x=x;
+  global_y=y;
+}
+
+void LLViewerEventRecorder::updateMouseEventInfo(S32 local_x, S32 local_y, S32 global_x, S32 global_y, std::string mName) {
+
+  LLView * target_view = LLUI::resolvePath(LLUI::getRootView(), xui);
+  if (! target_view) {
+    lldebugs << "LLViewerEventRecorder::updateMouseEventInfo - xui path on file at moment is NOT valid - so DO NOT record these local coords" << llendl;
+    return;
+  }
+  lldebugs << "LLViewerEventRecorder::updateMouseEventInfo b4 updatemouseeventinfo - local_x|global x   "<< this->local_x << " " << this->global_x  << "local/global y " << this->local_y << " " << this->global_y << " mname: " << mName << " xui: " << xui << llendl;
+
+
+  if (this->local_x < 1 && this->local_y<1 && local_x && local_y) {
+    this->local_x=local_x;
+    this->local_y=local_y;
+  }
+  this->global_x=global_x;
+  this->global_y=global_y;
+
+  // ONLY record deepest xui path for hierarchy searches - or first/only xui for floaters/panels reached via mouse captor - and llmousehandler
+  if (mName!="" &&  mName!="/" && xui=="") { 
+    //	xui=std::string("/")+mName+xui; 
+    //xui=mName+xui; 
+    xui = mName; // TODO review confirm we never call with partial path - also cAN REMOVE CHECK FOR "" - ON OTHER HAND IT'S PRETTY HARMLESS
+  }
+
+  lldebugs << "LLViewerEventRecorder::updateMouseEventInfo after updatemouseeventinfo - local_x|global x   "<< this->local_x << " " << this->global_x  << "local/global y " << this->local_y << " " << this->global_y << " mname: " << mName << " xui: " << xui << llendl;
+}
+
+void LLViewerEventRecorder::logVisibilityChange(std::string xui, std::string name, BOOL visibility, std::string event_subtype) {
+
+  LLSD  event=LLSD::emptyMap();
+
+  event.insert("event",LLSD(std::string("visibility")));
+
+  if (visibility) {
+    event.insert("visibility",LLSD(true));
+  } else {
+    event.insert("visibility",LLSD(false));
+  }
+
+  if (event_subtype!="") {
+    event.insert("event_subtype", LLSD(event_subtype));
+  }
+
+  if(name!="") {
+    event.insert("name",LLSD(name));
+  }
+
+  if (xui!="") {
+    event.insert("path",LLSD(xui));
+  }
+
+  event.insert("timestamp",LLSD(LLDate::now().asString())); 
+  recordEvent(event);
+}
+
+
+std::string LLViewerEventRecorder::get_xui() {
+  return xui;
+}
+void LLViewerEventRecorder::update_xui(std::string xui) {
+  if (xui!="" && this->xui=="" ) {
+    lldebugs << "LLViewerEventRecorder::update_xui to " << xui << llendl;
+    this->xui=xui;
+  } else {
+    lldebugs << "LLViewerEventRecorder::update_xui called with empty string" << llendl;
+  }
+}
+
+void LLViewerEventRecorder::logKeyEvent(KEY key, MASK mask) {
+
+  // NOTE: Event recording only logs keydown events - the viewer itself hides keyup events at a fairly low level in the code and does not appear to care about them anywhere
+
+  LLSD event = LLSD::emptyMap();
+
+  event.insert("event",LLSD("type"));
+
+  // keysym ...or
+  // keycode...or
+  // char
+  event.insert("keysym",LLSD(LLKeyboard::stringFromKey(key)));
+
+  // path (optional) - for now we are not recording path for key events during record - should not be needed for full record and playback of recorded steps
+  // as a vita script - it does become useful if you edit the resulting vita script and wish to remove some steps leading to a key event - that sort of edit might
+  // break the test script and it would be useful to have more context to make these sorts of edits safer
+ 
+  // TODO  replace this with a call which extracts to an array of names of masks (just like vita expects during playback)
+  // This is looking more and more like an object is a good idea, for this part a handy method call to setMask(mask) would be nice :-)
+  // call the func - llkeyboard::llsdStringarrayFromMask
+
+  LLSD key_mask=LLSD::emptyArray();
+
+  if (mask & MASK_CONTROL)     { key_mask.append(LLSD("CTL")); }  // Mac command key - has code of 0x1  in llcommon/indra_contstants
+  if (mask & MASK_ALT)         { key_mask.append(LLSD("ALT")); }
+  if (mask & MASK_SHIFT)       { key_mask.append(LLSD("SHIFT")); }
+  if (mask & MASK_MAC_CONTROL) { key_mask.append(LLSD("MAC_CONTROL")); }
+
+  event.insert("mask",key_mask); 
+  event.insert("timestamp",LLSD(LLDate::now().asString())); 
+
+  // Although vita has keyDown and keyUp requests it does not have type as a high-level concept 
+  // (maybe it should) - instead it has a convenience method that generates the keydown and keyup events 
+  // Here  we will use  "type" as  our event type
+
+  lldebugs << "LLVIewerEventRecorder::logKeyEvent Serialized LLSD for event " << event.asString() << "\n" << llendl;
+
+
+  //lldebugs  << "[VITA] key_name: "  << LLKeyboard::stringFromKey(key) << "mask: "<< mask  << "handled by " << getName() << llendl;
+  lldebugs  << "LLVIewerEventRecorder::logKeyEvent  key_name: "  << LLKeyboard::stringFromKey(key) << "mask: "<< mask  << llendl;
+
+
+  recordEvent(event);
+
+}
+
+void LLViewerEventRecorder::playbackRecording() {
+
+  LLSD LeapCommand;
+
+  // ivita sets this on startup, it also sends commands to the viewer to make start, stop, and playback menu items visible in viewer
+  LeapCommand =LLUI::sSettingGroups["config"]->getLLSD("LeapPlaybackEventsCommand");
+  
+  lldebugs << "[VITA] launching playback - leap command is: " << LLSDXMLStreamer(LeapCommand) << llendl;
+  LLLeap::create("", LeapCommand, false); // exception=false
+  
+}
+
+
+void LLViewerEventRecorder::recordEvent(LLSD event) {
+  lldebugs << "LLViewerEventRecorder::recordEvent event written to log: " << LLSDXMLStreamer(event) << llendl;
+  mLog << event << std::endl;
+  
+}
+void LLViewerEventRecorder::logKeyUnicodeEvent(llwchar uni_char) {
+  if (! logEvents) return;
+
+  // Note: keyUp is not captured since the viewer seems to not care about keyUp events
+
+  LLSD event=LLSD::emptyMap();
+
+  event.insert("timestamp",LLSD(LLDate::now().asString()));
+
+  
+  // keysym ...or
+  // keycode...or
+  // char
+
+  lldebugs << "Wrapped in conversion to wstring " <<  wstring_to_utf8str(LLWString( 1, uni_char)) << "\n" << llendl;
+  
+  event.insert("char",
+	       LLSD(  wstring_to_utf8str(LLWString( 1,uni_char))  )
+	       ); 
+
+  // path (optional) - for now we are not recording path for key events during record - should not be needed for full record and playback of recorded steps
+  // as a vita script - it does become useful if you edit the resulting vita script and wish to remove some steps leading to a key event - that sort of edit might
+  // break the test script and it would be useful to have more context to make these sorts of edits safer
+
+  // TODO need to consider mask keys too? Doesn't seem possible - at least not easily at this point
+
+  event.insert("event",LLSD("keyDown")); 
+
+  lldebugs  << "[VITA] unicode key: " << uni_char   << llendl;
+  lldebugs  << "[VITA] dumpxml " << LLSDXMLStreamer(event) << "\n" << llendl;
+
+
+  recordEvent(event);
+
+}
+
+void LLViewerEventRecorder::logMouseEvent(std::string button_state,std::string button_name)
+{
+  if (! logEvents) return; 
+
+  LLSD  event=LLSD::emptyMap();
+
+  event.insert("event",LLSD(std::string("mouse"+ button_state)));
+  event.insert("button",LLSD(button_name));
+  if (xui!="") {
+    event.insert("path",LLSD(xui));
+  }
+
+  if (local_x>0 && local_y>0) {
+    event.insert("local_x",LLSD(local_x));
+    event.insert("local_y",LLSD(local_y));
+  }
+
+  if (global_x>0 && global_y>0) {
+    event.insert("global_x",LLSD(global_x));
+    event.insert("global_y",LLSD(global_y));
+  }
+  event.insert("timestamp",LLSD(LLDate::now().asString())); 
+  recordEvent(event);
+
+
+  clear(UNDEFINED);
+   
+
+}
diff --git a/indra/llui/llviewereventrecorder.h b/indra/llui/llviewereventrecorder.h
new file mode 100644
index 0000000000..72ca643ced
--- /dev/null
+++ b/indra/llui/llviewereventrecorder.h
@@ -0,0 +1,103 @@
+/**
+ * @file llviewereventrecorder.h
+ * @brief Viewer event recording and playback support for mouse and keyboard events
+ *
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
+ * 
+ * Copyright (c) 2013, Linden Research, Inc.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_VIEWER_EVENT_RECORDER
+#define LL_VIEWER_EVENT_RECORDER
+
+
+#include "linden_common.h" 
+
+#include "lldir.h" 
+#include "llsd.h"  
+#include "llfile.h"
+#include "llvfile.h"
+#include "lldate.h"
+#include "llsdserialize.h"
+#include "llkeyboard.h"
+#include "llstring.h"
+
+#include <sstream>
+
+#include "llsingleton.h" // includes llerror which we need here so we can skip the include here
+
+class LLViewerEventRecorder : public LLSingleton<LLViewerEventRecorder>
+{
+
+ public:
+
+  LLViewerEventRecorder(); // TODO Protect constructor better if we can (not happy in private section) - could add a factory... - we are singleton
+  ~LLViewerEventRecorder();
+
+
+  void updateMouseEventInfo(S32 local_x,S32 local_y, S32 global_x, S32 global_y,  std::string mName);
+  void setMouseLocalCoords(S32 x,S32 y);
+  void setMouseGlobalCoords(S32 x,S32 y);
+
+  void logMouseEvent(std::string button_state, std::string button_name );
+  void logKeyEvent(KEY key, MASK mask);
+  void logKeyUnicodeEvent(llwchar uni_char);
+
+  void logVisibilityChange(std::string xui, std::string name, BOOL visibility, std::string event_subtype);
+
+  void clear_xui();
+  std::string get_xui();
+  void update_xui(std::string xui);
+
+  bool getLoggingStatus();
+  void setEventLoggingOn();
+  void setEventLoggingOff();
+
+  void playbackRecording();
+
+  bool displayViewerEventRecorderMenuItems();
+
+
+ protected:
+  // On if we wish to log events at the moment - toggle via Develop/Recorder submenu
+  bool logEvents;
+
+  std::string mLogFilename;
+  llofstream  mLog; 
+
+
+ private:
+
+  // Mouse event info 
+  S32 global_x;
+  S32 global_y;
+  S32 local_x;
+  S32 local_y;
+
+  // XUI path of UI element
+  std::string xui;
+
+  // Actually write the event out to llsd log file
+  void recordEvent(LLSD event);
+
+  void clear(S32 r); 
+
+  static const S32 UNDEFINED=-1;
+};
+#endif