Automated merge with https://hg.aws.productengine.com/secondlife/viewer-2-0/

--HG--
branch : product-engine

69 files changed, 2252 insertions, 423 deletions

diff --git a/indra/lib/python/indra/util/llmanifest.py b/indra/lib/python/indra/util/llmanifest.py
index 8c05210618..7e5b86c53f 100644
--- a/indra/lib/python/indra/util/llmanifest.py
+++ b/indra/lib/python/indra/util/llmanifest.py
@@ -119,6 +119,7 @@ ARGUMENTS=[
         On Linux this would try to use Linux_i686Manifest.""",
          default=""),
     dict(name='build', description='Build directory.', default=DEFAULT_SRCTREE),
+    dict(name='buildtype', description='Build type (i.e. Debug, Release, RelWithDebInfo).', default=None),
     dict(name='configuration',
          description="""The build configuration used.""",
          default="Release"),
diff --git a/indra/llplugin/llpluginclassmedia.cpp b/indra/llplugin/llpluginclassmedia.cpp
index 1a382643da..ed8d10a88c 100644
--- a/indra/llplugin/llpluginclassmedia.cpp
+++ b/indra/llplugin/llpluginclassmedia.cpp
@@ -124,7 +124,8 @@ void LLPluginClassMedia::reset()
 	mCanPaste = false;
 	mMediaName.clear();
 	mMediaDescription.clear();
-
+	mBackgroundColor = LLColor4::white;
+	
 	// media_browser class
 	mNavigateURI.clear();
 	mNavigateResultCode = -1;
@@ -234,6 +235,10 @@ void LLPluginClassMedia::idle(void)
 			message.setValueS32("height", mRequestedMediaHeight);
 			message.setValueS32("texture_width", mRequestedTextureWidth);
 			message.setValueS32("texture_height", mRequestedTextureHeight);
+			message.setValueReal("background_r", mBackgroundColor.mV[VX]);
+			message.setValueReal("background_g", mBackgroundColor.mV[VY]);
+			message.setValueReal("background_b", mBackgroundColor.mV[VZ]);
+			message.setValueReal("background_a", mBackgroundColor.mV[VW]);
 			mPlugin->sendMessage(message);	// DO NOT just use sendMessage() here -- we want this to jump ahead of the queue.
 			
 			LL_DEBUGS("Plugin") << "Sending size_change" << LL_ENDL;
diff --git a/indra/llplugin/llpluginclassmedia.h b/indra/llplugin/llpluginclassmedia.h
index b58067733b..5a1928ab1d 100644
--- a/indra/llplugin/llpluginclassmedia.h
+++ b/indra/llplugin/llpluginclassmedia.h
@@ -39,7 +39,7 @@
 #include "llrect.h"
 #include "llpluginclassmediaowner.h"
 #include <queue>
-
+#include "v4color.h"
 
 class LLPluginClassMedia : public LLPluginProcessParentOwner
 {
@@ -86,6 +86,8 @@ public:
 	void setSize(int width, int height);
 	void setAutoScale(bool auto_scale);
 	
+	void setBackgroundColor(LLColor4 color) { mBackgroundColor = color; };
+	
 	// Returns true if all of the texture parameters (depth, format, size, and texture size) are set up and consistent.
 	// This will initially be false, and will also be false for some time after setSize while the resize is processed.
 	// Note that if this returns true, it is safe to use all the get() functions above without checking for invalid return values
@@ -328,6 +330,8 @@ protected:
 	std::string		mMediaName;
 	std::string		mMediaDescription;
 	
+	LLColor4		mBackgroundColor;
+	
 	/////////////////////////////////////////
 	// media_browser class
 	std::string		mNavigateURI;
diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index 3400a72385..187a9a984e 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -1919,6 +1919,16 @@ LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, G
 : mPrevDepthEnabled(sDepthEnabled), mPrevDepthFunc(sDepthFunc), mPrevWriteEnabled(sWriteEnabled)
 {
 	stop_glerror();
+	
+	checkState();
+
+	if (!depth_enabled)
+	{ // always disable depth writes if depth testing is disabled
+	  // GL spec defines this as a requirement, but some implementations allow depth writes with testing disabled
+	  // The proper way to write to depth buffer with testing disabled is to enable testing and use a depth_func of GL_ALWAYS
+		write_enabled = FALSE;
+	}
+
 	if (depth_enabled != sDepthEnabled)
 	{
 		gGL.flush();
@@ -1942,6 +1952,7 @@ LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, G
 
 LLGLDepthTest::~LLGLDepthTest()
 {
+	checkState();
 	if (sDepthEnabled != mPrevDepthEnabled )
 	{
 		gGL.flush();
@@ -1963,6 +1974,32 @@ LLGLDepthTest::~LLGLDepthTest()
 	}
 }
 
+void LLGLDepthTest::checkState()
+{
+	if (gDebugGL)
+	{
+		GLint func = 0;
+		GLboolean mask = FALSE;
+
+		glGetIntegerv(GL_DEPTH_FUNC, &func);
+		glGetBooleanv(GL_DEPTH_WRITEMASK, &mask);
+
+		if (glIsEnabled(GL_DEPTH_TEST) != sDepthEnabled ||
+			sWriteEnabled != mask ||
+			sDepthFunc != func)
+		{
+			if (gDebugSession)
+			{
+				gFailLog << "Unexpected depth testing state." << std::endl;
+			}
+			else
+			{
+				LL_GL_ERRS << "Unexpected depth testing state." << LL_ENDL;
+			}
+		}
+	}
+}
+
 LLGLClampToFarClip::LLGLClampToFarClip(glh::matrix4f P)
 {
 	for (U32 i = 0; i < 4; i++)
diff --git a/indra/llrender/llglstates.h b/indra/llrender/llglstates.h
index 4a51cac438..968a37cab0 100644
--- a/indra/llrender/llglstates.h
+++ b/indra/llrender/llglstates.h
@@ -46,6 +46,8 @@ public:
 	
 	~LLGLDepthTest();
 	
+	void checkState();
+
 	GLboolean mPrevDepthEnabled;
 	GLenum mPrevDepthFunc;
 	GLboolean mPrevWriteEnabled;
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index fc45df8153..f97d81126e 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -162,6 +162,8 @@ void LLTexUnit::enable(eTextureType type)
 			disable(); // Force a disable of a previous texture type if it's enabled.
 		}
 		mCurrTexType = type;
+
+		gGL.flush();
 		glEnable(sGLTextureType[type]);
 	}
 }
diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt
index 82ec02d2eb..ce068618e2 100644
--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@@ -26,6 +26,8 @@ include_directories(
     )
 
 set(llui_SOURCE_FILES
+    llaccordionctrl.cpp
+    llaccordionctrltab.cpp
     llbutton.cpp
     llcheckboxctrl.cpp
     llclipboard.cpp
@@ -111,6 +113,8 @@ set(llui_SOURCE_FILES
 set(llui_HEADER_FILES
     CMakeLists.txt
 
+    llaccordionctrl.h
+    llaccordionctrltab.h
     llbutton.h
     llcallbackmap.h
     llcheckboxctrl.h
diff --git a/indra/llui/llaccordionctrl.cpp b/indra/llui/llaccordionctrl.cpp
new file mode 100644
index 0000000000..b5e870228a
--- /dev/null
+++ b/indra/llui/llaccordionctrl.cpp
@@ -0,0 +1,578 @@
+/** 
+ * @file llaccordionctrl.cpp
+ * @brief Accordion panel  implementation
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, 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 "llaccordionctrl.h"
+#include "llaccordionctrltab.h"
+
+#include "lluictrlfactory.h" // builds floaters from XML
+
+#include "llwindow.h"
+#include "llfocusmgr.h"
+#include "lllocalcliprect.h"
+
+#include "boost/bind.hpp"
+
+static const S32 DRAGGER_BAR_MARGIN = 4;
+static const S32 DRAGGER_BAR_HEIGHT = 5;
+static const S32 BORDER_MARGIN = 2;
+static const S32 PARENT_BORDER_MARGIN = 5;
+
+static const S32 panel_delta = DRAGGER_BAR_MARGIN;  // Distanse between two panels 
+
+static const S32 HORIZONTAL_MULTIPLE = 8;
+static const S32 VERTICAL_MULTIPLE = 16;
+static const F32 MIN_AUTO_SCROLL_RATE = 120.f;
+static const F32 MAX_AUTO_SCROLL_RATE = 500.f;
+static const F32 AUTO_SCROLL_RATE_ACCEL = 120.f;
+
+
+// LLAccordionCtrl =================================================================|
+
+static LLDefaultChildRegistry::Register<LLAccordionCtrl>	t2("accordion");
+
+
+LLAccordionCtrl::LLAccordionCtrl(const Params& params):LLPanel(params)
+ , mFitParent(params.fit_parent)
+{
+  mSingleExpansion = params.single_expansion;
+	if(mFitParent && !mSingleExpansion)
+	{
+		llinfos << "fit_parent works best when combined with single_expansion" << llendl;
+	}
+}
+
+LLAccordionCtrl::LLAccordionCtrl() : LLPanel()
+{
+	mSingleExpansion = false;
+	mFitParent = false;
+	LLUICtrlFactory::getInstance()->buildPanel(this, "accordion_parent.xml");	
+}
+
+//---------------------------------------------------------------------------------
+void LLAccordionCtrl::draw()
+{
+	LLRect local_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
+	
+	LLLocalClipRect clip(local_rect);
+	
+	LLPanel::draw();
+}
+
+
+//---------------------------------------------------------------------------------
+BOOL LLAccordionCtrl::postBuild()
+{
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+
+	LLRect scroll_rect;
+	scroll_rect.setOriginAndSize( 
+		getRect().getWidth() - scrollbar_size,
+		1,
+		scrollbar_size,
+		getRect().getHeight() - 1);
+	
+
+	LLScrollbar::Params sbparams;
+	sbparams.name("scrollable vertical");
+	sbparams.rect(scroll_rect);
+	sbparams.orientation(LLScrollbar::VERTICAL);
+	sbparams.doc_size(mInnerRect.getHeight());
+	sbparams.doc_pos(0);
+	sbparams.page_size(mInnerRect.getHeight());
+	sbparams.step_size(VERTICAL_MULTIPLE);
+	sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
+	sbparams.change_callback(boost::bind(&LLAccordionCtrl::onScrollPosChangeCallback, this, _1, _2));
+	
+	mScrollbar = LLUICtrlFactory::create<LLScrollbar> (sbparams);
+	LLView::addChild( mScrollbar );
+	mScrollbar->setVisible( false );
+	mScrollbar->setFollowsRight();
+	mScrollbar->setFollowsTop();
+	mScrollbar->setFollowsBottom();
+
+	//if it was created from xml...
+	std::vector<LLUICtrl*> accordion_tabs;
+	for(child_list_const_iter_t it = getChildList()->begin(); 
+		getChildList()->end() != it; ++it)
+	{
+		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(*it);
+		if(accordion_tab == NULL)
+			continue;
+		if(std::find(mAccordionTabs.begin(),mAccordionTabs.end(),accordion_tab) == mAccordionTabs.end())
+		{
+			accordion_tabs.push_back(accordion_tab);
+		}
+	}
+
+	for(std::vector<LLUICtrl*>::reverse_iterator it = accordion_tabs.rbegin();it!=accordion_tabs.rend();++it)
+		addCollapsibleCtrl(*it);
+
+	arrange	();
+
+	if(mSingleExpansion)
+	{
+		if(!mAccordionTabs[0]->getDisplayChildren())
+			mAccordionTabs[0]->setDisplayChildren(true);
+		for(size_t i=1;i<mAccordionTabs.size();++i)
+		{
+			if(mAccordionTabs[i]->getDisplayChildren())
+				mAccordionTabs[i]->setDisplayChildren(false);
+		}
+	}
+
+	return TRUE;
+}
+
+
+//---------------------------------------------------------------------------------
+LLAccordionCtrl::~LLAccordionCtrl()
+{
+  mAccordionTabs.clear();
+}
+
+//---------------------------------------------------------------------------------
+
+void LLAccordionCtrl::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	// adjust our rectangle
+	LLRect rcLocal = getRect();
+	rcLocal.mRight = rcLocal.mLeft + width;
+	rcLocal.mTop = rcLocal.mBottom + height;
+
+	setRect(rcLocal);
+
+	arrange();
+}
+
+//---------------------------------------------------------------------------------
+BOOL LLAccordionCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	return LLPanel::handleRightMouseDown(x, y, mask);
+}
+
+//---------------------------------------------------------------------------------
+void LLAccordionCtrl::shiftAccordionTabs(S16 panel_num, S32 delta)
+{
+	for(size_t i = panel_num; i < mAccordionTabs.size(); i++ )
+	{
+		ctrlShiftVertical(mAccordionTabs[i],delta);
+	}	
+}
+
+
+//---------------------------------------------------------------------------------
+void LLAccordionCtrl::onCollapseCtrlCloseOpen(S16 panel_num) 
+{
+	if(mSingleExpansion)
+	{
+		for(size_t i=0;i<mAccordionTabs.size();++i)
+		{
+			if(i==panel_num)
+				continue;
+			if(mAccordionTabs[i]->getDisplayChildren())
+				mAccordionTabs[i]->setDisplayChildren(false);
+		}
+
+	}
+	arrange();
+}
+
+void LLAccordionCtrl::show_hide_scrollbar(S32 width, S32 height)
+{
+	calcRecuiredHeight();
+	if(getRecuiredHeight() > height )
+		showScrollbar(width,height);
+	else
+		hideScrollbar(width,height);
+}
+
+void	LLAccordionCtrl::showScrollbar(S32 width, S32 height)
+{
+	bool was_visible = mScrollbar->getVisible();
+
+	mScrollbar->setVisible(true);
+	
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+
+	ctrlSetLeftTopAndSize(mScrollbar
+		,width-scrollbar_size - PARENT_BORDER_MARGIN/2
+		,height-PARENT_BORDER_MARGIN
+		,scrollbar_size
+		,height-2*PARENT_BORDER_MARGIN);
+	
+	mScrollbar->setPageSize(height);
+	mScrollbar->setDocParams(mInnerRect.getHeight(),mScrollbar->getDocPos());
+
+	if(was_visible)
+	{
+		S32 scroll_pos = llmin(mScrollbar->getDocPos(), getRecuiredHeight() - height - 1);
+		mScrollbar->setDocPos(scroll_pos);
+	}
+}
+
+void	LLAccordionCtrl::hideScrollbar( S32 width, S32 height )
+{
+	if(mScrollbar->getVisible() == false)
+		return;
+	mScrollbar->setVisible(false);
+
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+
+	S32 panel_width = width - 2*BORDER_MARGIN;
+
+	//reshape all accordeons and shift all draggers
+	for(size_t i=0;i<mAccordionTabs.size();++i)
+	{
+		LLRect panel_rect = mAccordionTabs[i]->getRect();
+		ctrlSetLeftTopAndSize(mAccordionTabs[i],panel_rect.mLeft,panel_rect.mTop,panel_width,panel_rect.getHeight());
+	}
+
+	mScrollbar->setDocPos(0);
+
+	if(mAccordionTabs.size()>0)
+	{
+		S32 panel_top = height - BORDER_MARGIN;		  // Top coordinate of the first panel
+		S32 diff = panel_top - mAccordionTabs[0]->getRect().mTop;
+		shiftAccordionTabs(0,diff);
+	}
+}
+
+
+//---------------------------------------------------------------------------------
+S32 LLAccordionCtrl::calcRecuiredHeight()
+{
+	S32 rec_height = 0;
+	
+	std::vector<LLAccordionCtrlTab*>::iterator panel;
+	for(panel=mAccordionTabs.begin(); panel!=mAccordionTabs.end(); ++panel)
+	{
+		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(*panel);
+		if(accordion_tab && accordion_tab->getVisible())
+		{
+			rec_height += accordion_tab->getRect().getHeight();
+		}
+	}
+
+	mInnerRect.setLeftTopAndSize(0,rec_height + BORDER_MARGIN*2,getRect().getWidth(),rec_height + BORDER_MARGIN);
+
+	return mInnerRect.getHeight();
+}
+
+//---------------------------------------------------------------------------------
+void LLAccordionCtrl::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S32 width, S32 height)
+{
+	if(!panel)
+		return;
+	LLRect panel_rect = panel->getRect();
+	panel_rect.setLeftTopAndSize( left, top, width, height);
+	panel->reshape( width, height, 1);
+	panel->setRect(panel_rect);
+}
+
+void LLAccordionCtrl::ctrlShiftVertical(LLView* panel,S32 delta)
+{
+	if(!panel)
+		return;
+	panel->translate(0,delta);
+}
+
+//---------------------------------------------------------------------------------
+
+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())
+		addChild(accordion_tab);
+	mAccordionTabs.push_back(accordion_tab);
+	
+	accordion_tab->setDropDownStateChangedCallback( boost::bind(&LLAccordionCtrl::onCollapseCtrlCloseOpen, this, mAccordionTabs.size() - 1) );
+
+}
+
+
+void LLAccordionCtrl::arrange()
+{
+	if( mAccordionTabs.size() == 0)
+	{
+		//We do not arrange if we do not have what should be arranged
+		return;
+	}
+
+	//Calculate params	
+	S32 panel_left = BORDER_MARGIN;	  // Margin from left side of Splitter
+	S32 panel_top = getRect().getHeight() - BORDER_MARGIN;		  // Top coordinate of the first panel
+	S32 panel_width = getRect().getWidth() - 4;		  // Top coordinate of the first panel
+
+	
+	if(mAccordionTabs.size() == 1)
+	{
+		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[0]);
+		
+		LLRect panel_rect = accordion_tab->getRect();
+		
+		S32 panel_height = getRect().getHeight() - 2*BORDER_MARGIN;
+
+		ctrlSetLeftTopAndSize(accordion_tab,panel_rect.mLeft,panel_top,panel_width,panel_height);
+		
+		show_hide_scrollbar(getRect().getWidth(),getRect().getHeight());
+		return;
+
+	}
+
+	for(size_t i = 0; i < mAccordionTabs.size(); i++ )
+	{
+		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+		
+		if(accordion_tab->getVisible() == false) //skip hidden accordion tabs
+			continue;
+		
+		if(!accordion_tab->isExpanded() )
+		{
+			ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, accordion_tab->getRect().getHeight());
+			panel_top-=mAccordionTabs[i]->getRect().getHeight();
+		}
+		else
+		{
+			S32 panel_height = accordion_tab->getRect().getHeight();
+			
+			if(mFitParent)
+			{
+				// all expanded tabs will have equal height
+				panel_height = calcExpandedTabHeight(i, panel_top);
+				ctrlSetLeftTopAndSize(accordion_tab, panel_left, panel_top, panel_width, panel_height);
+
+				// try to make accordion tab fit accordion view height.
+				// Accordion View should implement getRequiredRect() and provide valid height
+				S32 optimal_height = accordion_tab->getAccordionView()->getRequiredRect().getHeight();
+				optimal_height += accordion_tab->getHeaderHeight() + 2 * BORDER_MARGIN;
+				if(optimal_height < panel_height)
+				{
+					panel_height = optimal_height;
+				}
+
+				// minimum tab height is equal to header height
+				if(mAccordionTabs[i]->getHeaderHeight() > panel_height)
+				{
+					panel_height = mAccordionTabs[i]->getHeaderHeight();
+				}
+			}
+			
+			ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, panel_height);
+			panel_top-=panel_height;
+			
+		}
+	}	
+
+	show_hide_scrollbar(getRect().getWidth(),getRect().getHeight());
+
+	updateLayout(getRect().getWidth(),getRect().getHeight());
+
+}
+
+//---------------------------------------------------------------------------------
+
+BOOL LLAccordionCtrl::handleScrollWheel		( S32 x, S32 y, S32 clicks )
+{
+	if(LLPanel::handleScrollWheel(x,y,clicks))
+		return TRUE;
+	if( mScrollbar->getVisible() && mScrollbar->handleScrollWheel( 0, 0, clicks ) )
+		return TRUE;
+	return false;
+
+}
+
+BOOL LLAccordionCtrl::handleKeyHere			(KEY key, MASK mask)
+{
+	if( mScrollbar->getVisible() && mScrollbar->handleKeyHere( key,mask ) )
+		return TRUE;
+	return LLPanel::handleKeyHere(key,mask);
+}
+
+void	LLAccordionCtrl::updateLayout	(S32 width, S32 height)
+{
+	S32 panel_top = height - BORDER_MARGIN ;
+	if(mScrollbar->getVisible())
+		panel_top+=mScrollbar->getDocPos();
+
+	S32 panel_width = width - 2*BORDER_MARGIN;
+
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+	if(mScrollbar->getVisible())
+		panel_width-=scrollbar_size;
+
+	//set sizes for first panels and dragbars
+	for(size_t i=0;i<mAccordionTabs.size();++i)
+	{
+		if(!mAccordionTabs[i]->getVisible())
+			continue;
+		LLRect panel_rect = mAccordionTabs[i]->getRect();
+		ctrlSetLeftTopAndSize(mAccordionTabs[i],panel_rect.mLeft,panel_top,panel_width,panel_rect.getHeight());
+		panel_top-=panel_rect.getHeight();
+	}
+}
+
+void	LLAccordionCtrl::onScrollPosChangeCallback(S32, LLScrollbar*)
+{
+	updateLayout(getRect().getWidth(),getRect().getHeight());
+}
+void	LLAccordionCtrl::onOpen		(const LLSD& key)
+{
+	for(size_t i=0;i<mAccordionTabs.size();++i)
+	{
+		LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+		LLPanel* panel = dynamic_cast<LLPanel*>(accordion_tab->getAccordionView());
+		if(panel!=NULL)
+		{
+			panel->onOpen(key);
+		}
+	}
+}
+S32	LLAccordionCtrl::notifyParent(const LLSD& info)
+{
+	if(info.has("action"))
+	{
+		std::string str_action = info["action"];
+		if(str_action == "size_changes")
+		{
+			//
+			arrange();
+			return 1;
+		}
+		else if(str_action == "select_next")
+		{
+			for(size_t i=0;i<mAccordionTabs.size();++i)
+			{
+				LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+				if(accordion_tab->hasFocus())
+				{
+					while(++i<mAccordionTabs.size())
+					{
+						if(mAccordionTabs[i]->getVisible())
+							break;
+					}
+					if(i<mAccordionTabs.size())
+					{
+						accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+						accordion_tab->notify(LLSD().with("action","select_first"));
+						return 1;
+					}
+					break;
+				}
+			}
+			return 0;
+		}
+		else if(str_action == "select_prev")
+		{
+			for(size_t i=0;i<mAccordionTabs.size();++i)
+			{
+				LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+				if(accordion_tab->hasFocus() && i>0)
+				{
+					while(i>0)
+					{
+						if(mAccordionTabs[--i]->getVisible())
+							break;
+					}
+					
+					accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
+					accordion_tab->notify(LLSD().with("action","select_last"));
+					return 1;
+				}
+			}
+			return 0;
+		}
+	}
+	else if (info.has("scrollToShowRect"))
+	{
+		LLRect screen_rc, local_rc;
+		screen_rc.setValue(info["scrollToShowRect"]);
+		screenRectToLocal(screen_rc, &local_rc);
+
+		// Translate to parent coordinatess to check if we are in visible rectangle
+		local_rc.translate( getRect().mLeft, getRect().mBottom );
+
+		if ( !getRect().contains (local_rc) )
+		{
+			// Back to local coords and calculate position for scroller
+			S32 bottom = mScrollbar->getDocPos() - local_rc.mBottom + getRect().mBottom;
+			S32 top = mScrollbar->getDocPos() - local_rc.mTop + getRect().mTop;
+
+			S32 scroll_pos = llclamp(mScrollbar->getDocPos(),
+									 bottom, // min vertical scroll
+									 top); // max vertical scroll 
+
+			mScrollbar->setDocPos( scroll_pos );
+		}
+		return 1;
+	}
+	return LLPanel::notifyParent(info);
+}
+void	LLAccordionCtrl::reset		()
+{
+	if(mScrollbar)
+		mScrollbar->setDocPos(0);
+}
+
+S32 LLAccordionCtrl::calcExpandedTabHeight(S32 tab_index /* = 0 */, S32 available_height /* = 0 */)
+{
+	if(tab_index < 0)
+	{
+		return available_height;
+	}
+
+	S32 collapsed_tabs_height = 0;
+	S32 num_expanded = 0;
+
+	for(size_t n = tab_index; n < mAccordionTabs.size(); ++n)
+	{
+		if(!mAccordionTabs[n]->isExpanded())
+		{
+			collapsed_tabs_height += mAccordionTabs[n]->getHeaderHeight();
+		}
+		else
+		{
+			++num_expanded;
+		}
+	}
+
+	if(0 == num_expanded)
+	{
+		return available_height;
+	}
+
+	S32 expanded_tab_height = available_height - collapsed_tabs_height - BORDER_MARGIN; // top BORDER_MARGIN is added in arrange(), here we add bottom BORDER_MARGIN
+	expanded_tab_height /= num_expanded;
+	return expanded_tab_height;
+}
diff --git a/indra/llui/llaccordionctrl.h b/indra/llui/llaccordionctrl.h
new file mode 100644
index 0000000000..4cb0f38281
--- /dev/null
+++ b/indra/llui/llaccordionctrl.h
@@ -0,0 +1,123 @@
+/** 
+ * @file LLAccordionCtrl.h
+ * @brief Accordion Panel implementation
+ *
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, 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_ACCORDIONCTRL_H
+#define LL_ACCORDIONCTRL_H
+
+#include "llpanel.h"
+#include "llscrollbar.h"
+
+#include <vector>
+#include <algorithm>
+#include <string>
+
+class LLAccordionCtrlTab;
+
+class LLAccordionCtrl: public LLPanel
+{
+private:
+
+	std::vector<LLAccordionCtrlTab*> mAccordionTabs;
+
+	void ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S32 width, S32 height);
+	void ctrlShiftVertical(LLView* panel,S32 delta);
+	
+	void onCollapseCtrlCloseOpen(S16 panel_num); 
+	void shiftAccordionTabs(S16 panel_num, S32 delta);
+
+
+public:
+	struct Params 
+		: public LLInitParam::Block<Params, LLPanel::Params>
+	{
+		Optional<bool>			single_expansion,
+								fit_parent; /* Accordion will fit its parent size, controls that are placed into 
+								accordion tabs are responsible for scrolling their content.
+								*NOTE fit_parent works best when combined with single_expansion.
+								Accordion view should implement getRequiredRect() and provide valid height*/
+
+		Params()
+			: single_expansion("single_expansion",false)
+			, fit_parent("fit_parent", false)
+		{};
+	};
+
+	LLAccordionCtrl(const Params& params);
+
+    LLAccordionCtrl();
+    virtual ~LLAccordionCtrl();
+
+	virtual BOOL postBuild();
+	
+	virtual BOOL handleRightMouseDown	( S32 x, S32 y, MASK mask); 
+	virtual BOOL handleScrollWheel		( S32 x, S32 y, S32 clicks );
+	virtual BOOL handleKeyHere			(KEY key, MASK mask);
+	//
+
+	// Call reshape after changing splitter's size
+	virtual void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+	void addCollapsibleCtrl(LLView* view);
+	void arrange();
+
+
+	void	draw();
+	
+	void	onScrollPosChangeCallback(S32, LLScrollbar*);
+
+	void	onOpen		(const LLSD& key);
+	S32		notifyParent(const LLSD& info);
+
+	void	reset		();
+
+private:
+	// Calc Splitter's height that is necessary to display all child content
+	S32		calcRecuiredHeight();
+	S32		getRecuiredHeight() const { return mInnerRect.getHeight(); }
+	S32		calcExpandedTabHeight(S32 tab_index = 0, S32 available_height = 0);
+
+	void	updateLayout			(S32 width, S32 height);
+
+	void	show_hide_scrollbar		(S32 width, S32 height);
+
+	void	showScrollbar			(S32 width, S32 height);
+	void	hideScrollbar			(S32 width, S32 height);
+
+private:
+	LLRect			mInnerRect;
+	LLScrollbar*	mScrollbar;
+	bool			mSingleExpansion;
+	bool			mFitParent;
+};
+
+
+#endif // LL_LLSPLITTER_H
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
new file mode 100644
index 0000000000..9d6ba57c29
--- /dev/null
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -0,0 +1,599 @@
+/** 
+ * @file LLAccordionCtrlTab.cpp
+ * @brief Collapsible control implementation
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, 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 "lluictrl.h"
+
+#include "llaccordionctrltab.h"
+
+#include "lltextbox.h"
+
+static const std::string DD_BUTTON_NAME = "dd_button";
+static const std::string DD_TEXTBOX_NAME = "dd_textbox";
+static const std::string DD_HEADER_NAME = "dd_header";
+
+static const S32 HEADER_HEIGHT = 20;
+static const S32 HEADER_IMAGE_LEFT_OFFSET = 5;
+static const S32 HEADER_TEXT_LEFT_OFFSET = 30;
+
+static LLDefaultChildRegistry::Register<LLAccordionCtrlTab> t1("accordion_tab");
+
+class LLAccordionCtrlTab::LLAccordionCtrlTabHeader : public LLUICtrl
+{
+public:
+	friend class LLUICtrlFactory;
+
+	struct Params : public LLInitParam::Block<Params, LLAccordionCtrlTab::Params>
+	{
+		Params();
+	};
+
+	LLAccordionCtrlTabHeader(const LLAccordionCtrlTabHeader::Params& p);
+	
+	virtual ~LLAccordionCtrlTabHeader();
+
+	virtual void draw();
+
+	virtual void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+	virtual BOOL postBuild();
+
+	void	setTitle(const std::string& title);
+
+	virtual void onMouseEnter(S32 x, S32 y, MASK mask);
+	virtual void onMouseLeave(S32 x, S32 y, MASK mask);
+	virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
+private:
+
+	LLTextBox* mHeaderTextbox;
+
+	// Overlay images (arrows)
+	LLPointer<LLUIImage> mImageCollapsed;
+	LLPointer<LLUIImage> mImageExpanded;
+	LLPointer<LLUIImage> mImageCollapsedPressed;
+	LLPointer<LLUIImage> mImageExpandedPressed;
+
+	// Background images
+	LLPointer<LLUIImage> mImageHeader;
+	LLPointer<LLUIImage> mImageHeaderOver;
+	LLPointer<LLUIImage> mImageHeaderPressed;
+	LLPointer<LLUIImage> mImageHeaderFocused;
+
+	LLUIColor mHeaderBGColor;
+
+	bool mNeedsHighlight;
+};
+
+LLAccordionCtrlTab::LLAccordionCtrlTabHeader::Params::Params()
+{
+}
+
+LLAccordionCtrlTab::LLAccordionCtrlTabHeader::LLAccordionCtrlTabHeader(
+	const LLAccordionCtrlTabHeader::Params& p)
+: LLUICtrl(p)
+, mHeaderBGColor(p.header_bg_color())
+,mNeedsHighlight(false),
+	mImageCollapsed(p.header_collapse_img),
+	mImageCollapsedPressed(p.header_collapse_img_pressed),
+	mImageExpanded(p.header_expand_img),
+	mImageExpandedPressed(p.header_expand_img_pressed),
+	mImageHeader(p.header_image),
+	mImageHeaderOver(p.header_image_over),
+	mImageHeaderPressed(p.header_image_pressed),
+	mImageHeaderFocused(p.header_image_focused)
+{
+	LLTextBox::Params textboxParams;
+	textboxParams.name(DD_TEXTBOX_NAME);
+	textboxParams.initial_value(p.title());
+	textboxParams.text_color(p.header_text_color());
+	textboxParams.follows.flags(FOLLOWS_NONE);
+	textboxParams.font( p.font() );
+	textboxParams.font_shadow(LLFontGL::NO_SHADOW);
+	textboxParams.use_ellipses = true;
+	textboxParams.bg_visible = false;
+	textboxParams.mouse_opaque = false;
+	mHeaderTextbox = LLUICtrlFactory::create<LLTextBox>(textboxParams);
+	addChild(mHeaderTextbox);
+}
+
+LLAccordionCtrlTab::LLAccordionCtrlTabHeader::~LLAccordionCtrlTabHeader()
+{
+}
+
+BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::postBuild()
+{
+	return TRUE;
+}
+
+void	LLAccordionCtrlTab::LLAccordionCtrlTabHeader::setTitle(const std::string& title)
+{
+	if(mHeaderTextbox)
+		mHeaderTextbox->setText(title);
+}
+
+void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::draw()
+{
+	S32 width = getRect().getWidth();
+	S32 height = getRect().getHeight();
+
+	gl_rect_2d(0,0,width - 1 ,height - 1,mHeaderBGColor.get(),true);
+
+	LLAccordionCtrlTab* parent = dynamic_cast<LLAccordionCtrlTab*>(getParent());
+	bool collapsible = (parent && parent->getCollapsible());
+	bool expanded = (parent && parent->getDisplayChildren());
+
+	// Handle overlay images, if needed
+	// Only show green "focus" background image if the accordion is open,
+	// because the user's mental model of focus is that it goes away after
+	// the accordion is closed.
+	if (getParent()->hasFocus()
+		&& !(collapsible && !expanded))
+	{
+		mImageHeaderFocused->draw(0,0,width,height);
+	}
+	else
+	{
+		mImageHeader->draw(0,0,width,height);
+	}
+
+	if(mNeedsHighlight)
+	{
+		mImageHeaderOver->draw(0,0,width,height);
+	}
+	
+
+	if(collapsible)
+	{
+		LLPointer<LLUIImage> overlay_image;
+		if(expanded)
+		{
+			overlay_image = mImageExpanded;
+		}
+		else
+		{
+			overlay_image = mImageCollapsed;
+		}
+		overlay_image->draw(HEADER_IMAGE_LEFT_OFFSET,
+							(height - overlay_image->getHeight()) / 2);
+	}
+	
+	LLUICtrl::draw();
+}
+
+void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::reshape(S32 width, S32 height, BOOL called_from_parent /* = TRUE */)
+{
+	S32 header_height = mHeaderTextbox->getTextPixelHeight();
+
+	LLRect textboxRect(HEADER_TEXT_LEFT_OFFSET,(height+header_height)/2 ,width,(height-header_height)/2);
+	mHeaderTextbox->reshape(textboxRect.getWidth(), textboxRect.getHeight());
+	mHeaderTextbox->setRect(textboxRect);
+}
+
+void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::onMouseEnter(S32 x, S32 y, MASK mask)
+{
+	LLUICtrl::onMouseEnter(x, y, mask);
+	mNeedsHighlight = true;
+}
+void LLAccordionCtrlTab::LLAccordionCtrlTabHeader::onMouseLeave(S32 x, S32 y, MASK mask)
+{
+	LLUICtrl::onMouseLeave(x, y, mask);
+	mNeedsHighlight = false;
+}
+BOOL LLAccordionCtrlTab::LLAccordionCtrlTabHeader::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	if ( ( key == KEY_LEFT || key == KEY_RIGHT) && mask == MASK_NONE)
+	{
+		return getParent()->handleKey(key, mask, called_from_parent);
+	}
+	return LLUICtrl::handleKey(key, mask, called_from_parent);
+}
+
+
+LLAccordionCtrlTab::Params::Params()
+	: title("title")
+	,display_children("expanded", true)
+	,header_height("header_height", HEADER_HEIGHT),
+	min_width("min_width", 0),
+	min_height("min_height", 0)
+	,collapsible("collapsible", true)
+	,header_bg_color("header_bg_color")
+	,dropdown_bg_color("dropdown_bg_color")
+	,header_visible("header_visible",true)
+	,padding_left("padding_left",2)
+	,padding_right("padding_right",2)
+	,padding_top("padding_top",2)
+	,padding_bottom("padding_bottom",2)
+	,header_expand_img("header_expand_img")
+	,header_expand_img_pressed("header_expand_img_pressed")
+	,header_collapse_img("header_collapse_img")
+	,header_collapse_img_pressed("header_collapse_img_pressed")
+	,header_image("header_image")
+	,header_image_over("header_image_over")
+	,header_image_pressed("header_image_pressed")
+	,header_image_focused("header_image_focused")
+	,header_text_color("header_text_color")
+{
+	mouse_opaque(false);
+}
+
+LLAccordionCtrlTab::LLAccordionCtrlTab(const LLAccordionCtrlTab::Params&p)
+	: LLUICtrl(p)
+	,mDisplayChildren(p.display_children)
+	,mCollapsible(p.collapsible)
+	,mExpandedHeight(0)
+	,mDropdownBGColor(p.dropdown_bg_color())
+	,mHeaderVisible(p.header_visible)
+	,mPaddingLeft(p.padding_left)
+	,mPaddingRight(p.padding_right)
+	,mPaddingTop(p.padding_top)
+	,mPaddingBottom(p.padding_bottom)
+	,mCanOpenClose(true)
+{
+	mStoredOpenCloseState = false;
+	mWasStateStored = false;
+	
+	mDropdownBGColor = LLColor4::white;
+	LLAccordionCtrlTabHeader::Params headerParams;
+	headerParams.name(DD_HEADER_NAME);
+	headerParams.title(p.title);
+	mHeader = LLUICtrlFactory::create<LLAccordionCtrlTabHeader>(headerParams);
+	addChild(mHeader, 1);
+
+	reshape(100, 200,FALSE);
+}
+
+LLAccordionCtrlTab::~LLAccordionCtrlTab()
+{
+}
+
+
+void LLAccordionCtrlTab::setDisplayChildren(bool display)
+{
+	mDisplayChildren = display;
+	LLRect rect = getRect();
+
+	rect.mBottom = rect.mTop - (getDisplayChildren() ? 
+		mExpandedHeight : HEADER_HEIGHT);
+	setRect(rect);
+
+	for(child_list_const_iter_t it = getChildList()->begin();
+		getChildList()->end() != it; ++it)
+	{
+		LLView* child = *it;
+		if(DD_HEADER_NAME == child->getName())
+			continue;
+
+		child->setVisible(getDisplayChildren());
+	}
+}
+
+void LLAccordionCtrlTab::reshape(S32 width, S32 height, BOOL called_from_parent /* = TRUE */)
+{
+	LLRect headerRect;
+
+	LLUICtrl::reshape(width, height, TRUE);
+
+	headerRect.setLeftTopAndSize(
+		0,height,width,HEADER_HEIGHT);
+	mHeader->setRect(headerRect);
+	mHeader->reshape(headerRect.getWidth(), headerRect.getHeight());
+
+	for(child_list_const_iter_t it = getChildList()->begin(); 
+		getChildList()->end() != it; ++it)
+	{
+		LLView* child = *it;
+		if(DD_HEADER_NAME == child->getName())
+			continue;
+		if(!child->getVisible())
+			continue;
+
+		LLRect childRect = child->getRect();
+		S32 childWidth = width - getPaddingLeft() - getPaddingRight();
+		S32 childHeight = height - getHeaderHeight() - getPaddingTop() - getPaddingBottom();
+
+		child->reshape(childWidth,childHeight);
+		
+		childRect.setLeftTopAndSize(
+			getPaddingLeft(),
+			childHeight + getPaddingBottom(),
+			childWidth, 
+			childHeight);
+
+		child->setRect(childRect);
+		
+		break;//suppose that there is only one panel
+	}
+
+}
+
+void LLAccordionCtrlTab::changeOpenClose(bool is_open)
+{
+	if(is_open)
+		mExpandedHeight = getRect().getHeight();
+
+	setDisplayChildren(!is_open);
+	reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
+	if (mCommitSignal)
+	{
+		(*mCommitSignal)(this, getDisplayChildren());
+	}
+}
+
+BOOL LLAccordionCtrlTab::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if(mCollapsible && mHeaderVisible && mCanOpenClose)
+	{
+		if(y >= (getRect().getHeight() - HEADER_HEIGHT) )
+		{
+			LLAccordionCtrlTabHeader* header = getChild<LLAccordionCtrlTabHeader>(DD_HEADER_NAME);
+			header->setFocus(true);
+			changeOpenClose(getDisplayChildren());
+
+			//reset stored state
+			mWasStateStored = false;
+			return TRUE;
+		}
+	}
+	return LLUICtrl::handleMouseDown(x,y,mask);
+}
+
+BOOL LLAccordionCtrlTab::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	return LLUICtrl::handleMouseUp(x,y,mask);
+}
+
+boost::signals2::connection LLAccordionCtrlTab::setDropDownStateChangedCallback(commit_callback_t cb)
+{
+	return setCommitCallback(cb);
+}
+
+bool LLAccordionCtrlTab::addChild(LLView* child, S32 tab_group)
+{
+	if(DD_HEADER_NAME != child->getName())
+	{
+		reshape(child->getRect().getWidth() , child->getRect().getHeight() + HEADER_HEIGHT );
+		mExpandedHeight = getRect().getHeight();
+	}
+
+	bool res = LLUICtrl::addChild(child, tab_group);
+
+	if(DD_HEADER_NAME != child->getName())
+	{
+		if(!mCollapsible)
+			setDisplayChildren(true);
+		else
+			setDisplayChildren(getDisplayChildren());	
+	}
+
+	return res;
+}
+
+void LLAccordionCtrlTab::setAccordionView(LLView* panel)
+{
+	addChild(panel,0);
+}
+
+
+LLView*	LLAccordionCtrlTab::getAccordionView()
+{
+	for(child_list_const_iter_t it = getChildList()->begin(); 
+		getChildList()->end() != it; ++it)
+	{
+		LLView* child = *it;
+		if(DD_HEADER_NAME == child->getName())
+			continue;
+		if(!child->getVisible())
+			continue;
+		return child;
+	}
+	return NULL;
+}
+
+
+S32 LLAccordionCtrlTab::getHeaderHeight()
+{
+	return mHeaderVisible?HEADER_HEIGHT:0; 
+}
+
+void LLAccordionCtrlTab::setHeaderVisible(bool value) 
+{
+	if(mHeaderVisible == value)
+		return;
+	mHeaderVisible = value;
+	if(mHeader)
+		mHeader->setVisible(value);
+	reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
+};
+
+//vurtual
+BOOL LLAccordionCtrlTab::postBuild()
+{
+	mHeader->setVisible(mHeaderVisible);
+	return LLUICtrl::postBuild();
+}
+bool	LLAccordionCtrlTab::notifyChildren	(const LLSD& info)
+{
+	if(info.has("action"))
+	{
+		std::string str_action = info["action"];
+		if(str_action == "store_state")
+		{
+			storeOpenCloseState();
+			return true;
+		}
+		if(str_action == "restore_state")
+		{
+			restoreOpenCloseState();
+			return true;
+		}
+	}	
+	return LLUICtrl::notifyChildren(info);
+}
+
+S32	LLAccordionCtrlTab::notifyParent(const LLSD& info)
+{
+	if(info.has("action"))
+	{
+		std::string str_action = info["action"];
+		if(str_action == "size_changes")
+		{
+			//
+			S32 height = info["height"];
+			height = llmax(height,10) + HEADER_HEIGHT + getPaddingTop() + getPaddingBottom();
+			
+			mExpandedHeight = height;
+			
+			if(isExpanded())
+			{
+				LLRect panel_rect = getRect();
+				panel_rect.setLeftTopAndSize( panel_rect.mLeft, panel_rect.mTop, panel_rect.getWidth(), height);
+				reshape(getRect().getWidth(),height);
+				setRect(panel_rect);
+			}
+			
+			//LLAccordionCtrl should rearrange accodion tab if one of accordion change its size
+			getParent()->notifyParent(info);
+			return 1;
+		}
+		else if(str_action == "select_prev") 
+		{
+			showAndFocusHeader();
+			return 1;
+		}
+	}
+	return LLUICtrl::notifyParent(info);
+}
+
+S32 LLAccordionCtrlTab::notify(const LLSD& info)
+{
+	if(info.has("action"))
+	{
+		std::string str_action = info["action"];
+		if(str_action == "select_first")
+		{
+			showAndFocusHeader();
+			return 1;
+		}
+		else if( str_action == "select_last" )
+		{
+			if(getDisplayChildren() == false)
+			{
+				showAndFocusHeader();
+			}
+			else
+			{
+				LLView* view = getAccordionView();
+				if(view)
+					view->notify(LLSD().with("action","select_last"));
+			}
+		}
+	}
+	return 0;
+}
+
+BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	LLAccordionCtrlTabHeader* header = getChild<LLAccordionCtrlTabHeader>(DD_HEADER_NAME);	
+	if( !header->hasFocus() )
+		return LLUICtrl::handleKey(key, mask, called_from_parent);
+
+	if ( (key == KEY_ADD || key == KEY_RIGHT)&& mask == MASK_NONE)
+	{
+		if(getDisplayChildren() == false)
+		{
+			changeOpenClose(getDisplayChildren());
+			return TRUE;
+		}
+	}
+	if ( (key == KEY_SUBTRACT || key == KEY_LEFT)&& mask == MASK_NONE)
+	{
+		if(getDisplayChildren() == true)
+		{
+			changeOpenClose(getDisplayChildren());
+			return TRUE;
+		}
+	}
+
+	if ( key == KEY_DOWN && mask == MASK_NONE)
+	{
+		//if collapsed go to the next accordion
+		if(getDisplayChildren() == false)
+			//we processing notifyParent so let call parent directly
+			getParent()->notifyParent(LLSD().with("action","select_next"));
+		else
+		{
+			getAccordionView()->notify(LLSD().with("action","select_first"));
+		}
+		return TRUE;
+	}
+
+	if ( key == KEY_UP && mask == MASK_NONE)
+	{
+		//go to the previous accordion
+
+		//we processing notifyParent so let call parent directly
+		getParent()->notifyParent(LLSD().with("action","select_prev"));
+		return TRUE;
+	}
+
+	return LLUICtrl::handleKey(key, mask, called_from_parent);
+}
+
+void LLAccordionCtrlTab::showAndFocusHeader()
+{
+	LLAccordionCtrlTabHeader* header = getChild<LLAccordionCtrlTabHeader>(DD_HEADER_NAME);	
+	header->setFocus(true);
+
+	LLRect screen_rc;
+	LLRect selected_rc = header->getRect();
+	localRectToScreen(selected_rc, &screen_rc);
+	notifyParent(LLSD().with("scrollToShowRect",screen_rc.getValue()));
+
+}
+void    LLAccordionCtrlTab::storeOpenCloseState()
+{
+	if(mWasStateStored)
+		return;
+	mStoredOpenCloseState = getDisplayChildren();
+	mWasStateStored = true;
+}
+void   LLAccordionCtrlTab::restoreOpenCloseState()
+{
+	if(!mWasStateStored)
+		return;
+	if(getDisplayChildren() != mStoredOpenCloseState)
+	{
+		changeOpenClose(getDisplayChildren());
+	}
+	mWasStateStored = false;
+}
diff --git a/indra/llui/llaccordionctrltab.h b/indra/llui/llaccordionctrltab.h
new file mode 100644
index 0000000000..b200d43438
--- /dev/null
+++ b/indra/llui/llaccordionctrltab.h
@@ -0,0 +1,191 @@
+/** 
+ * @file LLAccordionCtrlTab.h
+ * @brief Collapsible box control implementation
+ *
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, 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_ACCORDIONCTRLTAB_H_
+#define LL_ACCORDIONCTRLTAB_H_
+
+#include <string>
+#include "llrect.h"
+
+class LLUICtrl;
+class LLUICtrlFactory;
+class LLUIImage;
+class LLButton;
+class LLTextBox;
+
+
+
+// LLAccordionCtrlTab is a container for other controls. 
+// It has a Header, by clicking on which hosted controls are shown or hidden.
+// When hosted controls are show - LLAccordionCtrlTab is expanded.
+// When hosted controls are hidden - LLAccordionCtrlTab is collapsed.
+
+class LLAccordionCtrlTab : public LLUICtrl
+{
+// Interface
+public:
+
+	struct Params 
+	 : public LLInitParam::Block<Params, LLUICtrl::Params>
+	{
+		Optional<bool>			display_children, //expanded or collapsed after initialization
+								collapsible;
+
+		Optional<std::string>	title;
+
+		Optional<S32>			header_height,
+								min_width,
+								min_height;
+
+		// Overlay images (arrows on the left)
+		Mandatory<LLUIImage*>	header_expand_img,
+								header_expand_img_pressed,
+								header_collapse_img,
+								header_collapse_img_pressed;
+
+		// Background images for the accordion tabs
+		Mandatory<LLUIImage*>	header_image,
+								header_image_over,
+								header_image_pressed,
+								header_image_focused;
+
+		Optional<LLUIColor>		header_bg_color,
+								header_text_color,
+								dropdown_bg_color;
+
+		Optional<bool>			header_visible;
+
+		Optional<S32>			padding_left;
+		Optional<S32>			padding_right;
+		Optional<S32>			padding_top;
+		Optional<S32>			padding_bottom;
+
+		Params();
+	};
+
+	typedef LLDefaultChildRegistry child_registry_t;
+
+	virtual ~LLAccordionCtrlTab();
+	
+	// Registers callback for expand/collapse events.
+	boost::signals2::connection setDropDownStateChangedCallback(commit_callback_t cb);
+
+	// Changes expand/collapse state
+	virtual void setDisplayChildren(bool display);
+
+	// Returns expand/collapse state
+	virtual bool getDisplayChildren() const {return mDisplayChildren;};
+
+	//set LLAccordionCtrlTab panel
+	void		setAccordionView(LLView* panel);
+	LLView*		getAccordionView();
+
+	bool getCollapsible() {return mCollapsible;};
+
+	void setCollapsible(bool collapsible) {mCollapsible = collapsible;};
+	void changeOpenClose(bool is_open);
+
+	void canOpenClose(bool can_open_close) { mCanOpenClose = can_open_close;};
+
+	virtual BOOL postBuild();
+
+	S32	notifyParent(const LLSD& info);
+	S32 notify(const LLSD& info);
+	bool notifyChildren(const LLSD& info);
+
+	void    storeOpenCloseState		();
+	void    restoreOpenCloseState	();
+
+protected:
+	LLAccordionCtrlTab(const LLAccordionCtrlTab::Params&);
+	friend class LLUICtrlFactory;
+
+// Overrides
+public:
+
+	// Call reshape after changing size
+	virtual void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+	// Changes expand/collapse state and triggers expand/collapse callbacks
+	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+
+	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
+
+	virtual bool addChild(LLView* child, S32 tab_group);
+
+	bool isExpanded() { return mDisplayChildren; }
+
+	S32 getHeaderHeight();
+
+	// Min size functions
+
+	void setHeaderVisible(bool value);
+
+	bool getHeaderVisible() { return mHeaderVisible;}
+
+	S32 mExpandedHeight; // Height of expanded ctrl.
+						 // Used to restore height after expand.
+
+	S32	getPaddingLeft() const { return mPaddingLeft;}
+	S32	getPaddingRight() const { return mPaddingRight;}
+	S32	getPaddingTop() const { return mPaddingTop;}
+	S32	getPaddingBottom() const { return mPaddingBottom;}
+
+	void showAndFocusHeader();
+
+private:
+
+	
+
+	class LLAccordionCtrlTabHeader;
+	LLAccordionCtrlTabHeader* mHeader; //Header
+
+	bool mDisplayChildren; //Expanded/collapsed
+	bool mCollapsible;
+	bool mHeaderVisible;
+
+	bool mCanOpenClose;
+
+	S32	mPaddingLeft;
+	S32	mPaddingRight;
+	S32	mPaddingTop;
+	S32	mPaddingBottom;
+
+	bool mStoredOpenCloseState;
+	bool mWasStateStored;
+
+
+	LLUIColor mDropdownBGColor;
+};
+
+#endif
diff --git a/indra/llui/llconsole.cpp b/indra/llui/llconsole.cpp
index e08d93b232..59499f987b 100644
--- a/indra/llui/llconsole.cpp
+++ b/indra/llui/llconsole.cpp
@@ -180,7 +180,7 @@ void LLConsole::draw()
 	// draw remaining lines
 	F32 y_pos = 0.f;
 
-	LLUIImagePtr imagep = LLUI::getUIImage("rounded_square.tga");
+	LLUIImagePtr imagep = LLUI::getUIImage("Rounded_Square");
 
 //	F32 console_opacity = llclamp(gSavedSettings.getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
 	F32 console_opacity = llclamp(LLUI::sSettingGroups["config"]->getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index 29adb0d8b6..21f3f15739 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -46,6 +46,7 @@
 
 #include "llmenugl.h"
 
+#include "llgl.h"
 #include "llmath.h"
 #include "llrender.h"
 #include "llfocusmgr.h"
@@ -477,6 +478,7 @@ void LLMenuItemGL::draw( void )
 		if (dynamic_cast<LLMenuItemCallGL*>(this))
 			debug_count++;
 		gGL.color4fv( mHighlightBackground.get().mV );
+
 		gl_rect_2d( 0, getRect().getHeight(), getRect().getWidth(), 0 );
 	}
 
diff --git a/indra/llui/llmultislider.cpp b/indra/llui/llmultislider.cpp
index aea7c5f87c..27a727fdf5 100644
--- a/indra/llui/llmultislider.cpp
+++ b/indra/llui/llmultislider.cpp
@@ -490,7 +490,7 @@ void LLMultiSlider::draw()
 	F32 opacity = getEnabled() ? 1.f : 0.3f;
 
 	// Track
-	LLUIImagePtr thumb_imagep = LLUI::getUIImage("rounded_square.tga");
+	LLUIImagePtr thumb_imagep = LLUI::getUIImage("Rounded_Square");
 
 	static LLUICachedControl<S32> multi_track_height ("UIMultiTrackHeight", 0);
 	S32 height_offset = (getRect().getHeight() - multi_track_height) / 2;
diff --git a/indra/llui/llpanel.cpp b/indra/llui/llpanel.cpp
index db32882438..143f19eea6 100644
--- a/indra/llui/llpanel.cpp
+++ b/indra/llui/llpanel.cpp
@@ -43,6 +43,7 @@
 #include "llerror.h"
 #include "lltimer.h"
 
+#include "llaccordionctrltab.h"
 #include "llbutton.h"
 #include "llmenugl.h"
 //#include "llstatusbar.h"
@@ -851,14 +852,26 @@ static LLPanel *childGetVisibleTabWithHelp(LLView *parent)
 	// look through immediate children first for an active tab with help
 	for (child = parent->getFirstChild(); child; child = parent->findNextSibling(child))
 	{
+		LLPanel *curTabPanel = NULL;
+
+		// do we have a tab container?
 		LLTabContainer *tab = dynamic_cast<LLTabContainer *>(child);
 		if (tab && tab->getVisible())
 		{
-			LLPanel *curTabPanel = tab->getCurrentPanel();
-			if (curTabPanel && !curTabPanel->getHelpTopic().empty())
-			{
-				return curTabPanel;
-			}
+			curTabPanel = tab->getCurrentPanel();
+		}
+
+		// do we have an accordion tab?
+		LLAccordionCtrlTab* accordion = dynamic_cast<LLAccordionCtrlTab *>(child);
+		if (accordion && accordion->getDisplayChildren())
+		{
+			curTabPanel = dynamic_cast<LLPanel *>(accordion->getAccordionView());
+		}
+
+		// if we found a valid tab, does it have a help topic?
+		if (curTabPanel && !curTabPanel->getHelpTopic().empty())
+		{
+			return curTabPanel;
 		}
 	}
 
diff --git a/indra/llui/llscrolllistcell.cpp b/indra/llui/llscrolllistcell.cpp
index 7238d903a3..3cc92baa8d 100644
--- a/indra/llui/llscrolllistcell.cpp
+++ b/indra/llui/llscrolllistcell.cpp
@@ -188,7 +188,7 @@ LLScrollListText::LLScrollListText(const LLScrollListCell::Params& p)
 	// initialize rounded rect image
 	if (!mRoundedRectImage)
 	{
-		mRoundedRectImage = LLUI::getUIImage("rounded_square.tga");
+		mRoundedRectImage = LLUI::getUIImage("Rounded_Square");
 	}
 }
 
diff --git a/indra/llui/llurlentry.cpp b/indra/llui/llurlentry.cpp
index f7528bc62a..1b6dd1b264 100644
--- a/indra/llui/llurlentry.cpp
+++ b/indra/llui/llurlentry.cpp
@@ -101,7 +101,7 @@ std::string LLUrlEntryBase::getLabelFromWikiLink(const std::string &url)
 	{
 		start++;
 	}
-	return url.substr(start, url.size()-start-1);
+	return unescapeUrl(url.substr(start, url.size()-start-1));
 }
 
 std::string LLUrlEntryBase::getUrlFromWikiLink(const std::string &string)
diff --git a/indra/llui/tests/llurlentry_test.cpp b/indra/llui/tests/llurlentry_test.cpp
index 128cd134c1..38cf7124ce 100644
--- a/indra/llui/tests/llurlentry_test.cpp
+++ b/indra/llui/tests/llurlentry_test.cpp
@@ -545,4 +545,50 @@ namespace tut
 				  "XXX [secondlife:///app/teleport/Ahern/50/50/50/ Teleport to Ahern] YYY",
 				  "[secondlife:///app/teleport/Ahern/50/50/50/ Teleport to Ahern]");
 	}
+
+	template<> template<>
+	void object::test<11>()
+	{
+		//
+		// test LLUrlEntryHTTPNoProtocol - general URLs without a protocol
+		//
+		LLUrlEntryHTTPNoProtocol url;
+		boost::regex r = url.getPattern();
+
+		testRegex("naked .com URL", r,
+				  "see google.com",
+				  "google.com");
+
+		testRegex("naked .org URL", r,
+				  "see en.wikipedia.org for details",
+				  "en.wikipedia.org");
+
+		testRegex("naked .net URL", r,
+				  "example.net",
+				  "example.net");
+
+		testRegex("naked .edu URL (2 instances)", r,
+				  "MIT web site is at web.mit.edu and also www.mit.edu",
+				  "web.mit.edu");
+
+		testRegex("invalid .com URL [1]", r,
+				  "..com",
+				  "");
+
+		testRegex("invalid .com URL [2]", r,
+				  "you.come",
+				  "");
+
+		testRegex("invalid .com URL [3]", r,
+				  "recommended",
+				  "");
+
+		testRegex("invalid .edu URL", r,
+				  "hi there scheduled maitenance has begun",
+				  "");
+
+		testRegex("invalid .net URL", r,
+				  "foo.netty",
+				  "");
+	}
 }
diff --git a/indra/media_plugins/webkit/media_plugin_webkit.cpp b/indra/media_plugins/webkit/media_plugin_webkit.cpp
index 02f0045800..a0336f6156 100644
--- a/indra/media_plugins/webkit/media_plugin_webkit.cpp
+++ b/indra/media_plugins/webkit/media_plugin_webkit.cpp
@@ -98,6 +98,9 @@ private:
 	int mLastMouseX;
 	int mLastMouseY;
 	bool mFirstFocus;
+	F32 mBackgroundR;
+	F32 mBackgroundG;
+	F32 mBackgroundB;
 	
 	void setInitState(int state)
 	{
@@ -237,8 +240,9 @@ private:
 			// don't flip bitmap
 			LLQtWebKit::getInstance()->flipWindow( mBrowserWindowId, true );
 			
-			// set background color to be black - mostly for initial login page
-			LLQtWebKit::getInstance()->setBackgroundColor( mBrowserWindowId, 0x00, 0x00, 0x00 );
+			// set background color
+			// convert background color channels from [0.0, 1.0] to [0, 255];
+			LLQtWebKit::getInstance()->setBackgroundColor( mBrowserWindowId, int(mBackgroundR * 255.0f), int(mBackgroundG * 255.0f), int(mBackgroundB * 255.0f) );
 
 			// Set state _before_ starting the navigate, since onNavigateBegin might get called before this call returns.
 			setInitState(INIT_STATE_NAVIGATING);
@@ -246,7 +250,21 @@ private:
 			// Don't do this here -- it causes the dreaded "white flash" when loading a browser instance.
 			// FIXME: Re-added this because navigating to a "page" initializes things correctly - especially
 			// for the HTTP AUTH dialog issues (DEV-41731). Will fix at a later date.
-			LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, "about:blank" );
+			// Build a data URL like this: "data:text/html,%3Chtml%3E%3Cbody bgcolor=%22#RRGGBB%22%3E%3C/body%3E%3C/html%3E"
+			// where RRGGBB is the background color in HTML style
+			std::stringstream url;
+			
+			url << "data:text/html,%3Chtml%3E%3Cbody%20bgcolor=%22#";
+			// convert background color channels from [0.0, 1.0] to [0, 255];
+			url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundR * 255.0f);
+			url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundG * 255.0f);
+			url << std::setfill('0') << std::setw(2) << std::hex << int(mBackgroundB * 255.0f);
+			url << "%22%3E%3C/body%3E%3C/html%3E";
+			
+			lldebugs << "data url is: " << url.str() << llendl;
+						
+			LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, url.str() );
+//			LLQtWebKit::getInstance()->navigateTo( mBrowserWindowId, "about:blank" );
 
 			return true;
 		};
@@ -318,7 +336,9 @@ private:
 
 		if(mInitState == INIT_STATE_NAVIGATE_COMPLETE)
 		{
-			setInitState(INIT_STATE_WAIT_REDRAW);
+			// Skip the WAIT_REDRAW state now -- with the right background color set, it should no longer be necessary.
+//			setInitState(INIT_STATE_WAIT_REDRAW);
+			setInitState(INIT_STATE_WAIT_COMPLETE);
 		}
 		
 	}
@@ -704,7 +724,11 @@ void MediaPluginWebKit::receiveMessage(const char *message_string)
 				S32 height = message_in.getValueS32("height");
 				S32 texture_width = message_in.getValueS32("texture_width");
 				S32 texture_height = message_in.getValueS32("texture_height");
-				
+				mBackgroundR = message_in.getValueReal("background_r");
+				mBackgroundG = message_in.getValueReal("background_g");
+				mBackgroundB = message_in.getValueReal("background_b");
+//				mBackgroundA = message_in.setValueReal("background_a");		// Ignore any alpha
+								
 				if(!name.empty())
 				{
 					// Find the shared memory region with this name
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 8918fc3018..6f8ccb3d11 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -63,8 +63,6 @@ include_directories(
     )
 
 set(viewer_SOURCE_FILES
-    llaccordionctrl.cpp
-    llaccordionctrltab.cpp
     llagent.cpp
     llagentaccess.cpp
     llagentdata.cpp
@@ -569,8 +567,6 @@ endif (LINUX)
 set(viewer_HEADER_FILES
     CMakeLists.txt
     ViewerInstall.cmake
-    llaccordionctrl.h
-    llaccordionctrltab.h
     llagent.h
     llagentaccess.h
     llagentdata.h
@@ -1499,6 +1495,7 @@ if (WINDOWS)
         --actions=copy
         --artwork=${ARTWORK_DIR}
         --build=${CMAKE_CURRENT_BINARY_DIR}
+        --buildtype=${CMAKE_BUILD_TYPE}
         --configuration=${CMAKE_CFG_INTDIR}
         --dest=${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
         --grid=${GRID}
@@ -1569,6 +1566,7 @@ if (WINDOWS)
           ${CMAKE_CURRENT_SOURCE_DIR}/viewer_manifest.py
           --artwork=${ARTWORK_DIR}
           --build=${CMAKE_CURRENT_BINARY_DIR}
+          --buildtype=${CMAKE_BUILD_TYPE}
           --channel=${VIEWER_CHANNEL}
           --configuration=${CMAKE_CFG_INTDIR}
           --dest=${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
@@ -1650,6 +1648,7 @@ if (LINUX)
         --arch=${ARCH}
         --artwork=${ARTWORK_DIR}
         --build=${CMAKE_CURRENT_BINARY_DIR}
+        --buildtype=${CMAKE_BUILD_TYPE}
         --channel=${VIEWER_CHANNEL}
         --configuration=${CMAKE_CFG_INTDIR}
         --dest=${CMAKE_CURRENT_BINARY_DIR}/packaged
@@ -1695,6 +1694,7 @@ if (DARWIN)
       --actions=copy
       --artwork=${ARTWORK_DIR}
       --build=${CMAKE_CURRENT_BINARY_DIR}
+      --buildtype=${CMAKE_BUILD_TYPE}
       --configuration=${CMAKE_CFG_INTDIR}
       --dest=${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${product}.app
       --grid=${GRID}
@@ -1715,6 +1715,7 @@ if (DARWIN)
         ARGS
           ${CMAKE_CURRENT_SOURCE_DIR}/viewer_manifest.py
           --grid=${GRID}
+          --buildtype=${CMAKE_BUILD_TYPE}
           --configuration=${CMAKE_CFG_INTDIR}
           --channel=${VIEWER_CHANNEL}
           --login_channel=${VIEWER_LOGIN_CHANNEL}
@@ -1734,6 +1735,7 @@ if (DARWIN)
         ARGS
           ${CMAKE_CURRENT_SOURCE_DIR}/viewer_manifest.py
           --grid=${GRID}
+          --buildtype=${CMAKE_BUILD_TYPE}
           --configuration=${CMAKE_CFG_INTDIR}
           --channel=${VIEWER_CHANNEL}
           --login_channel=${VIEWER_LOGIN_CHANNEL}
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 7d98a4b6ce..382793a497 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -3257,17 +3257,6 @@
       <key>Value</key>
       <real>0.75</real>
     </map>
-    <key>FolderIndentation</key>
-    <map>
-      <key>Comment</key>
-      <string>Number of pixels to indent subfolders in inventory</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>S32</string>
-      <key>Value</key>
-      <integer>8</integer>
-    </map>
     <key>FolderLoadingMessageWaitTime</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp
index 5f845c3721..03a8b108e2 100644
--- a/indra/newview/lldrawpoolbump.cpp
+++ b/indra/newview/lldrawpoolbump.cpp
@@ -1149,14 +1149,14 @@ void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerTexture *src_vi, LLI
 			if (!LLPipeline::sRenderDeferred)
 			{
 				bump->setExplicitFormat(GL_ALPHA8, GL_ALPHA);
-				bump->createGLTexture(bump->getDiscardLevel(), dst_image);
+				bump->createGLTexture(0, dst_image);
 			}
 			else
 			{
 				LLPointer<LLImageRaw> nrm_image = new LLImageRaw(src->getWidth(), src->getHeight(), 4);
 				generateNormalMapFromAlpha(src, nrm_image);
 				bump->setExplicitFormat(GL_RGBA, GL_RGBA);
-				bump->createGLTexture(bump->getDiscardLevel(), nrm_image);
+				bump->createGLTexture(0, nrm_image);
 			}
 
 			
diff --git a/indra/newview/llfasttimerview.cpp b/indra/newview/llfasttimerview.cpp
index 7d8bb6e104..4fa97e789b 100644
--- a/indra/newview/llfasttimerview.cpp
+++ b/indra/newview/llfasttimerview.cpp
@@ -314,7 +314,7 @@ void LLFastTimerView::draw()
 	S32 left, top, right, bottom;
 	S32 x, y, barw, barh, dx, dy;
 	S32 texth, textw;
-	LLPointer<LLUIImage> box_imagep = LLUI::getUIImage("rounded_square.tga");
+	LLPointer<LLUIImage> box_imagep = LLUI::getUIImage("Rounded_Square");
 
 	// Draw the window background
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
diff --git a/indra/newview/llfloatersearch.cpp b/indra/newview/llfloatersearch.cpp
index c6d9fee630..a7401fdb6f 100644
--- a/indra/newview/llfloatersearch.cpp
+++ b/indra/newview/llfloatersearch.cpp
@@ -32,6 +32,9 @@
  */
 
 #include "llviewerprecompiledheaders.h"
+
+#include "llcommandhandler.h"
+#include "llfloaterreg.h"
 #include "llfloatersearch.h"
 #include "llmediactrl.h"
 #include "lllogininstance.h"
@@ -41,6 +44,42 @@
 #include "llviewercontrol.h"
 #include "llweb.h"
 
+// support secondlife:///app/search/{CATEGORY}/{QUERY} SLapps
+class LLSearchHandler : public LLCommandHandler
+{
+public:
+	// requires trusted browser to trigger
+	LLSearchHandler() : LLCommandHandler("search", UNTRUSTED_THROTTLE) { }
+	bool handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web)
+	{
+		const size_t parts = tokens.size();
+
+		// get the (optional) category for the search
+		std::string category;
+		if (parts > 0)
+		{
+			category = tokens[0].asString();
+		}
+
+		// get the (optional) search string
+		std::string search_text;
+		if (parts > 1)
+		{
+			search_text = tokens[1].asString();
+		}
+
+		// create the LLSD arguments for the search floater
+		LLSD args;
+		args["category"] = category;
+		args["id"] = LLURI::unescape(search_text);
+
+		// open the search floater and perform the requested search
+		LLFloaterReg::showInstance("search", args);
+		return true;
+	}
+};
+LLSearchHandler gSearchHandler;
+
 LLFloaterSearch::LLFloaterSearch(const LLSD& key) :
 	LLFloater(key),
 	LLViewerMediaObserver(),
diff --git a/indra/newview/llfloatertools.cpp b/indra/newview/llfloatertools.cpp
index 9cae6f0ebd..1287e14961 100644
--- a/indra/newview/llfloatertools.cpp
+++ b/indra/newview/llfloatertools.cpp
@@ -1269,18 +1269,15 @@ void LLFloaterTools::getMediaState()
 // called when a user wants to add media to a prim or prim face
 void LLFloaterTools::onClickBtnAddMedia()
 {
-	// check for the edit tool and now many faces are selected
-	LLTool *tool = LLToolMgr::getInstance()->getCurrentTool();
-	if((tool != LLToolFace::getInstance()) || LLSelectMgr::getInstance()->getSelection()->isMultipleTESelected())
+	// check if multiple faces are selected
+	if(LLSelectMgr::getInstance()->getSelection()->isMultipleTESelected())
 	{
-		LLNotificationsUtil::add("MultipleFacesSelected",LLSD(), LLSD(), multipleFacesSelectedConfirm);
-		
+		LLNotificationsUtil::add("MultipleFacesSelected", LLSD(), LLSD(), multipleFacesSelectedConfirm);
 	}
 	else
 	{
 		onClickBtnEditMedia();
 	}
-
 }
 
 // static
diff --git a/indra/newview/llfolderview.cpp b/indra/newview/llfolderview.cpp
index 1ea5868491..9aed403991 100644
--- a/indra/newview/llfolderview.cpp
+++ b/indra/newview/llfolderview.cpp
@@ -206,7 +206,9 @@ LLFolderView::LLFolderView(const Params& p)
 	mAutoOpenCandidate = NULL;
 	mAutoOpenTimer.stop();
 	mKeyboardSelection = FALSE;
-    static LLUICachedControl<S32> indentation("FolderIndentation", 0);
+	const LLFolderViewItem::Params& item_params =
+		LLUICtrlFactory::getDefaultParams<LLFolderViewItem>();
+	S32 indentation = item_params.folder_indentation();
 	mIndentation = -indentation; // children start at indentation 0
 	gIdleCallbacks.addFunction(idle, this);
 
@@ -395,7 +397,7 @@ S32 LLFolderView::arrange( S32* unused_width, S32* unused_height, S32 filter_gen
 		getRoot()->getFilter()->getShowFolderState();
 
 	S32 total_width = LEFT_PAD;
-	S32 running_height = mDebugFilters ? llceil(sSmallFont->getLineHeight()) : 0;
+	S32 running_height = mDebugFilters ? llceil(LLFontGL::getFontMonospace()->getLineHeight()) : 0;
 	S32 target_height = running_height;
 	S32 parent_item_height = getRect().getHeight();
 
@@ -867,8 +869,8 @@ void LLFolderView::draw()
 	{
 		std::string current_filter_string = llformat("Current Filter: %d, Least Filter: %d, Auto-accept Filter: %d",
 										mFilter->getCurrentGeneration(), mFilter->getMinRequiredGeneration(), mFilter->getMustPassGeneration());
-		sSmallFont->renderUTF8(current_filter_string, 0, 2, 
-			getRect().getHeight() - sSmallFont->getLineHeight(), LLColor4(0.5f, 0.5f, 0.8f, 1.f), 
+		LLFontGL::getFontMonospace()->renderUTF8(current_filter_string, 0, 2, 
+			getRect().getHeight() - LLFontGL::getFontMonospace()->getLineHeight(), LLColor4(0.5f, 0.5f, 0.8f, 1.f), 
 			LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, S32_MAX, S32_MAX, NULL, FALSE );
 	}
 
diff --git a/indra/newview/llfolderviewitem.cpp b/indra/newview/llfolderviewitem.cpp
index 9d54aafd67..2363f51d80 100644
--- a/indra/newview/llfolderviewitem.cpp
+++ b/indra/newview/llfolderviewitem.cpp
@@ -51,11 +51,10 @@
 /// Class LLFolderViewItem
 ///----------------------------------------------------------------------------
 
+static LLDefaultChildRegistry::Register<LLFolderViewItem> r("folder_view_item");
+
 // statics 
 std::map<U8, LLFontGL*> LLFolderViewItem::sFonts; // map of styles to fonts
-const LLFontGL* LLFolderViewItem::sSmallFont = NULL;
-LLUIImagePtr LLFolderViewItem::sArrowImage;
-LLUIImagePtr LLFolderViewItem::sBoxImage;
 
 // only integers can be initialized in header
 const F32 LLFolderViewItem::FOLDER_CLOSE_TIME_CONSTANT = 0.02f;
@@ -84,33 +83,34 @@ LLFontGL* LLFolderViewItem::getLabelFontForStyle(U8 style)
 //static
 void LLFolderViewItem::initClass()
 {
-	sSmallFont = LLFontGL::getFontMonospace();
-	sArrowImage = LLUI::getUIImage("folder_arrow.tga"); 
-	sBoxImage = LLUI::getUIImage("rounded_square.tga");
 }
 
 //static
 void LLFolderViewItem::cleanupClass()
 {
 	sFonts.clear();
-	sArrowImage = NULL;
-	sBoxImage = NULL;
 }
 
 
 // NOTE: Optimize this, we call it a *lot* when opening a large inventory
 LLFolderViewItem::Params::Params()
-:	icon("icon"),
-	folder_arrow_image("folder_arrow_image", LLUI::getUIImage("folder_arrow.tga")),
-	selection_image("selection_image", LLUI::getUIImage("rounded_square.tga"))
+:	icon(),
+	icon_open(),
+	root(),
+	listener(),
+	folder_arrow_image("folder_arrow_image"),
+	folder_indentation("folder_indentation"),
+	selection_image("selection_image"),
+	item_height("item_height"),
+	item_top_pad("item_top_pad"),
+	creation_date()
 {
 	mouse_opaque(true);
 	follows.flags(FOLLOWS_LEFT|FOLLOWS_TOP|FOLLOWS_RIGHT);
-	// JAMESDEBUG tab_stop(false);
 }
 
 // Default constructor
-LLFolderViewItem::LLFolderViewItem(LLFolderViewItem::Params p)
+LLFolderViewItem::LLFolderViewItem(const LLFolderViewItem::Params& p)
 :	LLView(p),
 	mLabelWidth(0),
 	mLabelWidthDirty(false),
@@ -121,6 +121,7 @@ LLFolderViewItem::LLFolderViewItem(LLFolderViewItem::Params p)
 	mLabelStyle( LLFontGL::NORMAL ),
 	mHasVisibleChildren(FALSE),
 	mIndentation(0),
+	mItemHeight(p.item_height),
 	mNumDescendantsSelected(0),
 	mPassedFilter(FALSE),
 	mLastFilterGeneration(-1),
@@ -134,8 +135,6 @@ LLFolderViewItem::LLFolderViewItem(LLFolderViewItem::Params p)
 	mIcon(p.icon),
 	mIconOpen(p.icon_open),
 	mListener(p.listener),
-	mArrowImage(p.folder_arrow_image),
-	mBoxImage(p.selection_image),
 	mHidden(false),
 	mShowLoadStatus(false)
 {
@@ -392,10 +391,11 @@ BOOL LLFolderViewItem::addToFolder(LLFolderViewFolder* folder, LLFolderView* roo
 // makes sure that this view and it's children are the right size.
 S32 LLFolderViewItem::arrange( S32* width, S32* height, S32 filter_generation)
 {
-    static LLUICachedControl<S32> indentation("FolderIndentation", 0);
+	const Params& p = LLUICtrlFactory::getDefaultParams<LLFolderViewItem>();
+	S32 indentation = p.folder_indentation();
+	// Only indent deeper items in hierarchy
 	mIndentation = (getParentFolder() 
-					&& getParentFolder()->getParentFolder() 
-					&& getParentFolder()->getParentFolder()->getParentFolder())
+					&& getParentFolder()->getParentFolder() )
 		? mParentFolder->getIndentation() + indentation
 		: 0;
 	if (mLabelWidthDirty)
@@ -421,9 +421,10 @@ S32 LLFolderViewItem::getItemHeight()
 {
 	if (mHidden) return 0;
 
-	S32 icon_height = mIcon->getHeight();
-	S32 label_height = llround(getLabelFontForStyle(mLabelStyle)->getLineHeight());
-	return llmax( icon_height, label_height ) + ICON_PAD;
+	//S32 icon_height = mIcon->getHeight();
+	//S32 label_height = llround(getLabelFontForStyle(mLabelStyle)->getLineHeight());
+	//return llmax( icon_height, label_height ) + ICON_PAD;
+	return mItemHeight;
 }
 
 void LLFolderViewItem::filter( LLInventoryFilter& filter)
@@ -829,11 +830,16 @@ void LLFolderViewItem::draw()
 	static LLUIColor sFgColor = LLUIColorTable::instance().getColor("MenuItemEnabledColor", DEFAULT_WHITE);
 	static LLUIColor sHighlightBgColor = LLUIColorTable::instance().getColor("MenuItemHighlightBgColor", DEFAULT_WHITE);
 	static LLUIColor sHighlightFgColor = LLUIColorTable::instance().getColor("MenuItemHighlightFgColor", DEFAULT_WHITE);
+	static LLUIColor sFocusOutlineColor =
+		LLUIColorTable::instance().getColor("InventoryFocusOutlineColor", DEFAULT_WHITE);
 	static LLUIColor sFilterBGColor = LLUIColorTable::instance().getColor("FilterBackgroundColor", DEFAULT_WHITE);
 	static LLUIColor sFilterTextColor = LLUIColorTable::instance().getColor("FilterTextColor", DEFAULT_WHITE);
 	static LLUIColor sSuffixColor = LLUIColorTable::instance().getColor("InventoryItemSuffixColor", DEFAULT_WHITE);
 	static LLUIColor sSearchStatusColor = LLUIColorTable::instance().getColor("InventorySearchStatusColor", DEFAULT_WHITE);
 
+	const Params& default_params = LLUICtrlFactory::getDefaultParams<LLFolderViewItem>();
+	const S32 TOP_PAD = default_params.item_top_pad;
+
 	bool possibly_has_children = false;
 	bool up_to_date = mListener && mListener->isUpToDate();
 	if((up_to_date && hasVisibleChildren() ) || // we fetched our children and some of them have passed the filter...
@@ -843,11 +849,10 @@ void LLFolderViewItem::draw()
 	}
 	if(/*mControlLabel[0] != '\0' && */possibly_has_children)
 	{
-		if (sArrowImage)
-		{
-			gl_draw_scaled_rotated_image(mIndentation, getRect().getHeight() - ARROW_SIZE - TEXT_PAD,
-				ARROW_SIZE, ARROW_SIZE, mControlLabelRotation, sArrowImage->getImage(), sFgColor);
-		}
+		LLUIImage* arrow_image = default_params.folder_arrow_image;
+		gl_draw_scaled_rotated_image(
+			mIndentation, getRect().getHeight() - ARROW_SIZE - TEXT_PAD - TOP_PAD,
+			ARROW_SIZE, ARROW_SIZE, mControlLabelRotation, arrow_image->getImage(), sFgColor);
 	}
 
 	F32 text_left = (F32)(ARROW_SIZE + TEXT_PAD + ICON_WIDTH + ICON_PAD + mIndentation);
@@ -857,6 +862,10 @@ void LLFolderViewItem::draw()
 	// If we have keyboard focus, draw selection filled
 	BOOL show_context = getRoot()->getShowSelectionContext();
 	BOOL filled = show_context || (getRoot()->getParentPanel()->hasFocus());
+	const S32 FOCUS_LEFT = 1;
+	S32 focus_top = getRect().getHeight();
+	S32 focus_bottom = getRect().getHeight() - mItemHeight;
+	bool folder_open = (getRect().getHeight() > mItemHeight + 4);
 
 	// always render "current" item, only render other selected items if
 	// mShowSingleSelection is FALSE
@@ -864,7 +873,6 @@ void LLFolderViewItem::draw()
 	{
 		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 		LLColor4 bg_color = sHighlightBgColor;
-		//const S32 TRAILING_PAD = 5;  // It just looks better with this.
 		if (!mIsCurSelection)
 		{
 			// do time-based fade of extra objects
@@ -882,35 +890,35 @@ void LLFolderViewItem::draw()
 		}
 
 		gl_rect_2d(
-			0, 
-			getRect().getHeight(), 
+			FOCUS_LEFT,
+			focus_top, 
 			getRect().getWidth() - 2,
-			llfloor(getRect().getHeight() - font->getLineHeight() - ICON_PAD),
+			focus_bottom,
 			bg_color, filled);
 		if (mIsCurSelection)
 		{
 			gl_rect_2d(
-				0, 
-				getRect().getHeight(), 
+				FOCUS_LEFT, 
+				focus_top, 
 				getRect().getWidth() - 2,
-				llfloor(getRect().getHeight() - font->getLineHeight() - ICON_PAD),
-				sHighlightFgColor, FALSE);
+				focus_bottom,
+				sFocusOutlineColor, FALSE);
 		}
-		if (getRect().getHeight() > llround(font->getLineHeight()) + ICON_PAD + 4)
+		if (folder_open)
 		{
 			gl_rect_2d(
-				0, 
-				llfloor(getRect().getHeight() - font->getLineHeight() - ICON_PAD) - 4, 
+				FOCUS_LEFT,
+				focus_bottom + 1, // overlap with bottom edge of above rect
 				getRect().getWidth() - 2,
-				2,
-				sHighlightFgColor, FALSE);
+				0,
+				sFocusOutlineColor, FALSE);
 			if (show_context)
 			{
 				gl_rect_2d(
-					0, 
-					llfloor(getRect().getHeight() - font->getLineHeight() - ICON_PAD) - 4, 
+					FOCUS_LEFT,
+					focus_bottom + 1,
 					getRect().getWidth() - 2,
-					2,
+					0,
 					sHighlightBgColor, TRUE);
 			}
 		}
@@ -919,32 +927,32 @@ void LLFolderViewItem::draw()
 	{
 		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 		gl_rect_2d(
-			0, 
-			getRect().getHeight(), 
+			FOCUS_LEFT, 
+			focus_top, 
 			getRect().getWidth() - 2,
-			llfloor(getRect().getHeight() - font->getLineHeight() - ICON_PAD),
+			focus_bottom,
 			sHighlightBgColor, FALSE);
-
-		if (getRect().getHeight() > llround(font->getLineHeight()) + ICON_PAD + 2)
+		if (folder_open)
 		{
 			gl_rect_2d(
-				0, 
-				llfloor(getRect().getHeight() - font->getLineHeight() - ICON_PAD) - 2, 
+				FOCUS_LEFT,
+				focus_bottom + 1, // overlap with bottom edge of above rect
 				getRect().getWidth() - 2,
-				2,
+				0,
 				sHighlightBgColor, FALSE);
 		}
 		mDragAndDropTarget = FALSE;
 	}
 
+	S32 icon_x = mIndentation + ARROW_SIZE + TEXT_PAD;
 	// First case is used for open folders
 	if (!mIconOpen.isNull() && (llabs(mControlLabelRotation) > 80))
  	{
-		mIconOpen->draw(mIndentation + ARROW_SIZE + TEXT_PAD, getRect().getHeight() - mIcon->getHeight());
+		mIconOpen->draw(icon_x, getRect().getHeight() - mIconOpen->getHeight() - TOP_PAD + 1);
 	}
 	else if(mIcon)
 	{
- 		mIcon->draw(mIndentation + ARROW_SIZE + TEXT_PAD, getRect().getHeight() - mIcon->getHeight());
+ 		mIcon->draw(icon_x, getRect().getHeight() - mIcon->getHeight() - TOP_PAD + 1);
  	}
 
 	if (!mLabel.empty())
@@ -953,7 +961,7 @@ void LLFolderViewItem::draw()
 		BOOL debug_filters = getRoot()->getDebugFilters();
 		LLColor4 color = ( (mIsSelected && filled) ? sHighlightFgColor : sFgColor );
 		F32 right_x;
-		F32 y = (F32)getRect().getHeight() - font->getLineHeight() - (F32)TEXT_PAD;
+		F32 y = (F32)getRect().getHeight() - font->getLineHeight() - (F32)TEXT_PAD - (F32)TOP_PAD;
 
 		if (debug_filters)
 		{
@@ -963,7 +971,8 @@ void LLFolderViewItem::draw()
 			}
 
 			LLColor4 filter_color = mLastFilterGeneration >= getRoot()->getFilter()->getCurrentGeneration() ? LLColor4(0.5f, 0.8f, 0.5f, 1.f) : LLColor4(0.8f, 0.5f, 0.5f, 1.f);
-			sSmallFont->renderUTF8(mStatusText, 0, text_left, y, filter_color,
+			LLFontGL::getFontMonospace()->renderUTF8(
+				mStatusText, 0, text_left, y, filter_color,
 				LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
 				S32_MAX, S32_MAX, &right_x, FALSE );
 			text_left = right_x;
@@ -1004,7 +1013,7 @@ void LLFolderViewItem::draw()
 				S32_MAX, S32_MAX, &right_x, FALSE );
 		}
 
-		if (sBoxImage.notNull() && mStringMatchOffset != std::string::npos)
+		if (mStringMatchOffset != std::string::npos)
 		{
 			// don't draw backgrounds for zero-length strings
 			S32 filter_string_length = getRoot()->getFilterSubString().size();
@@ -1013,14 +1022,15 @@ void LLFolderViewItem::draw()
 				std::string combined_string = mLabel + mLabelSuffix;
 				S32 left = llround(text_left) + font->getWidth(combined_string, 0, mStringMatchOffset) - 1;
 				S32 right = left + font->getWidth(combined_string, mStringMatchOffset, filter_string_length) + 2;
-				S32 bottom = llfloor(getRect().getHeight() - font->getLineHeight() - 3);
-				S32 top = getRect().getHeight();
-				
+				S32 bottom = llfloor(getRect().getHeight() - font->getLineHeight() - 3 - TOP_PAD);
+				S32 top = getRect().getHeight() - TOP_PAD;
+		
+				LLUIImage* box_image = default_params.selection_image;
 				LLRect box_rect(left, top, right, bottom);
-				sBoxImage->draw(box_rect, sFilterBGColor);
+				box_image->draw(box_rect, sFilterBGColor);
 				F32 match_string_left = text_left + font->getWidthF32(combined_string, 0, mStringMatchOffset);
-				F32 y = (F32)getRect().getHeight() - font->getLineHeight() - (F32)TEXT_PAD;
-				font->renderUTF8( combined_string, mStringMatchOffset, match_string_left, y,
+				F32 yy = (F32)getRect().getHeight() - font->getLineHeight() - (F32)TEXT_PAD - (F32)TOP_PAD;
+				font->renderUTF8( combined_string, mStringMatchOffset, match_string_left, yy,
 								  sFilterTextColor, LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
 								  filter_string_length, S32_MAX, &right_x, FALSE );
 			}
diff --git a/indra/newview/llfolderviewitem.h b/indra/newview/llfolderviewitem.h
index 03bb296d29..be8e73a5a9 100644
--- a/indra/newview/llfolderviewitem.h
+++ b/indra/newview/llfolderviewitem.h
@@ -101,7 +101,10 @@ public:
 		Optional<LLFolderViewEventListener*>	listener;
 
 		Optional<LLUIImage*>					folder_arrow_image;
+		Optional<S32>							folder_indentation; // pixels
 		Optional<LLUIImage*>					selection_image;
+		Optional<S32>							item_height; // pixels
+		Optional<S32>							item_top_pad; // pixels
 
 		Optional<S32>							creation_date; //UTC seconds
 
@@ -110,7 +113,7 @@ public:
 
 	// layout constants
 	static const S32 LEFT_PAD = 5;
-    // LEFT_INDENTATION is set via settings.xml FolderIndentation
+    // LEFT_INDENTATION is set via folder_indentation above
 	static const S32 ICON_PAD = 2;
 	static const S32 ICON_WIDTH = 16;
 	static const S32 TEXT_PAD = 1;
@@ -127,11 +130,7 @@ protected:
 	friend class LLUICtrlFactory;
 	friend class LLFolderViewEventListener;
 
-	LLFolderViewItem(Params p = LLFolderViewItem::Params());
-
-	static const LLFontGL*		sSmallFont;
-	static LLUIImagePtr			sArrowImage;
-	static LLUIImagePtr			sBoxImage;
+	LLFolderViewItem(const Params& p);
 
 	std::string					mLabel;
 	std::string					mSearchableLabel;
@@ -150,6 +149,7 @@ protected:
 	LLUIImagePtr				mIconOpen;
 	BOOL						mHasVisibleChildren;
 	S32							mIndentation;
+	S32							mItemHeight;
 	S32							mNumDescendantsSelected;
 	BOOL						mPassedFilter;
 	S32							mLastFilterGeneration;
@@ -157,8 +157,6 @@ protected:
 	F32							mControlLabelRotation;
 	LLFolderView*				mRoot;
 	BOOL						mDragAndDropTarget;
-	LLUIImagePtr				mArrowImage;
-	LLUIImagePtr				mBoxImage;
 	BOOL                        mIsLoading;
 	LLTimer                     mTimeSinceRequestStart;
 	bool						mHidden;
diff --git a/indra/newview/llhudtext.cpp b/indra/newview/llhudtext.cpp
index 08cf86df4a..8ad94b957d 100644
--- a/indra/newview/llhudtext.cpp
+++ b/indra/newview/llhudtext.cpp
@@ -287,7 +287,7 @@ void LLHUDText::renderText(BOOL for_select)
 	mOffsetY = lltrunc(mHeight * ((mVertAlignment == ALIGN_VERT_CENTER) ? 0.5f : 1.f));
 
 	// *TODO: cache this image
-	LLUIImagePtr imagep = LLUI::getUIImage("rounded_square.tga");
+	LLUIImagePtr imagep = LLUI::getUIImage("Rounded_Square");
 
 	// *TODO: make this a per-text setting
 	LLColor4 bg_color = LLUIColorTable::instance().getColor("BackgroundChatColor");
diff --git a/indra/newview/llinspectavatar.cpp b/indra/newview/llinspectavatar.cpp
index acbca60103..0374a1d25b 100644
--- a/indra/newview/llinspectavatar.cpp
+++ b/indra/newview/llinspectavatar.cpp
@@ -278,7 +278,7 @@ void LLInspectAvatar::onOpen(const LLSD& data)
 	
 	getChild<LLUICtrl>("gear_self_btn")->setVisible(self);
 	getChild<LLUICtrl>("gear_btn")->setVisible(!self);
-	
+
 	// Position the inspector relative to the mouse cursor
 	// Similar to how tooltips are positioned
 	// See LLToolTipMgr::createToolTip
@@ -403,7 +403,8 @@ void LLInspectAvatar::updateModeratorPanel()
 {
 	bool enable_moderator_panel = false;
 
-    if (LLVoiceChannel::getCurrentVoiceChannel())
+    if (LLVoiceChannel::getCurrentVoiceChannel() &&
+		mAvatarID != gAgent.getID())
     {
 		LLUUID session_id = LLVoiceChannel::getCurrentVoiceChannel()->getSessionID();
 
@@ -515,42 +516,58 @@ void LLInspectAvatar::toggleSelectedVoice(bool enabled)
 
 void LLInspectAvatar::updateVolumeSlider()
 {
-	// By convention, we only display and toggle voice mutes, not all mutes
-	bool is_muted = LLMuteList::getInstance()->
-						isMuted(mAvatarID, LLMute::flagVoiceChat);
-	bool voice_enabled = gVoiceClient->getVoiceEnabled(mAvatarID);
 
-	LLUICtrl* mute_btn = getChild<LLUICtrl>("mute_btn");
-	mute_btn->setEnabled( voice_enabled );
-	mute_btn->setValue( is_muted );
+	bool voice_enabled = gVoiceClient->getVoiceEnabled(mAvatarID);
 
-	LLUICtrl* volume_slider = getChild<LLUICtrl>("volume_slider");
-	volume_slider->setEnabled( voice_enabled && !is_muted );
-	const F32 DEFAULT_VOLUME = 0.5f;
-	F32 volume;
-	if (is_muted)
+	// Do not display volume slider and mute button if it 
+	// is ourself or we are not in a voice channel together
+	if (!voice_enabled || (mAvatarID == gAgent.getID()))
 	{
-		// it's clearer to display their volume as zero
-		volume = 0.f;
+		getChild<LLUICtrl>("mute_btn")->setVisible(false);
+		getChild<LLUICtrl>("volume_slider")->setVisible(false);
 	}
-	else if (!voice_enabled)
-	{
-		// use nominal value rather than 0
-		volume = DEFAULT_VOLUME;
-	}
-	else
+
+	else 
 	{
-		// actual volume
-		volume = gVoiceClient->getUserVolume(mAvatarID);
+		getChild<LLUICtrl>("mute_btn")->setVisible(true);
+		getChild<LLUICtrl>("volume_slider")->setVisible(true);
+
+		// By convention, we only display and toggle voice mutes, not all mutes
+		bool is_muted = LLMuteList::getInstance()->
+							isMuted(mAvatarID, LLMute::flagVoiceChat);
+
+		LLUICtrl* mute_btn = getChild<LLUICtrl>("mute_btn");
 
-		// *HACK: Voice client doesn't have any data until user actually
-		// says something.
-		if (volume == 0.f)
+		bool is_linden = LLStringUtil::endsWith(mAvatarName, " Linden");
+
+		mute_btn->setEnabled( !is_linden);
+		mute_btn->setValue( is_muted );
+
+		LLUICtrl* volume_slider = getChild<LLUICtrl>("volume_slider");
+		volume_slider->setEnabled( !is_muted );
+
+		const F32 DEFAULT_VOLUME = 0.5f;
+		F32 volume;
+		if (is_muted)
 		{
-			volume = DEFAULT_VOLUME;
+			// it's clearer to display their volume as zero
+			volume = 0.f;
 		}
+		else
+		{
+			// actual volume
+			volume = gVoiceClient->getUserVolume(mAvatarID);
+
+			// *HACK: Voice client doesn't have any data until user actually
+			// says something.
+			if (volume == 0.f)
+			{
+				volume = DEFAULT_VOLUME;
+			}
+		}
+		volume_slider->setValue( (F64)volume );
 	}
-	volume_slider->setValue( (F64)volume );
+
 }
 
 void LLInspectAvatar::onClickMuteVolume()
diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index 498a29728c..9141d50829 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -98,10 +98,6 @@ LLInventoryPanel::LLInventoryPanel(const LLInventoryPanel::Params& p) :
 	mCommitCallbackRegistrar.add("Inventory.AttachObject", boost::bind(&LLInventoryPanel::attachObject, this, _2));
 	mCommitCallbackRegistrar.add("Inventory.BeginIMSession", boost::bind(&LLInventoryPanel::beginIMSession, this));
 	
-	setBackgroundColor(LLUIColorTable::instance().getColor("InventoryBackgroundColor"));
-	setBackgroundVisible(TRUE);
-	setBackgroundOpaque(TRUE);
-	
 	if (mStartFolderString != "")
 	{
 		mBuildDefaultHierarchy = false;
diff --git a/indra/newview/llmanip.cpp b/indra/newview/llmanip.cpp
index f30821cacf..a96240e31c 100644
--- a/indra/newview/llmanip.cpp
+++ b/indra/newview/llmanip.cpp
@@ -436,7 +436,7 @@ void LLManip::renderXYZ(const LLVector3 &vec)
 
 	glPushMatrix();
 	{
-		LLUIImagePtr imagep = LLUI::getUIImage("rounded_square.tga");
+		LLUIImagePtr imagep = LLUI::getUIImage("Rounded_Square");
 		gViewerWindow->setup2DRender();
 		const LLVector2& display_scale = gViewerWindow->getDisplayScale();
 		glScalef(display_scale.mV[VX], display_scale.mV[VY], 1.f);
diff --git a/indra/newview/llmediactrl.cpp b/indra/newview/llmediactrl.cpp
index 93f926b5d0..6b0f9b709d 100644
--- a/indra/newview/llmediactrl.cpp
+++ b/indra/newview/llmediactrl.cpp
@@ -632,6 +632,7 @@ bool LLMediaCtrl::ensureMediaSourceExists()
 			mMediaSource->setHomeURL(mHomePageUrl);
 			mMediaSource->setVisible( getVisible() );
 			mMediaSource->addObserver( this );
+			mMediaSource->setBackgroundColor( getBackgroundColor() );
 			if(mClearCache)
 			{
 				mMediaSource->clearCache();
@@ -671,34 +672,12 @@ LLPluginClassMedia* LLMediaCtrl::getMediaPlugin()
 //
 void LLMediaCtrl::draw()
 {
-	LLPluginClassMedia* media_plugin = NULL;
-	
-	if(mMediaSource && mMediaSource->hasMedia())
-	{
-		media_plugin = mMediaSource->getMediaPlugin();
-	}
-	else
-	{
-		return;
-	}
-	
-	if(!media_plugin || (!media_plugin->textureValid()))
-	{
-		// Don't try to draw without a valid texture
-		return;
-	}
-
-	LLViewerMediaTexture* media_texture = LLViewerTextureManager::findMediaTexture(mMediaTextureID);
-	
-	if (!media_texture )
-		return;
-	
 	if ( gRestoreGL == 1 )
 	{
 		LLRect r = getRect();
 		reshape( r.getWidth(), r.getHeight(), FALSE );
 		return;
-	};
+	}
 
 	// NOTE: optimization needed here - probably only need to do this once
 	// unless tearoffs change the parent which they probably do.
@@ -712,125 +691,161 @@ void LLMediaCtrl::draw()
 		setFrequentUpdates( false );
 	};
 	
+	bool draw_media = false;
+	
+	LLPluginClassMedia* media_plugin = NULL;
+	LLViewerMediaTexture* media_texture = NULL;
+	
+	if(mMediaSource && mMediaSource->hasMedia())
+	{
+		media_plugin = mMediaSource->getMediaPlugin();
+
+		if(media_plugin && (media_plugin->textureValid()))
+		{
+			media_texture = LLViewerTextureManager::findMediaTexture(mMediaTextureID);
+			if(media_texture)
+			{
+				draw_media = true;
+			}
+		}
+	}
+	
 	if(mHidingInitialLoad)
 	{
 		// If we're hiding loading, don't draw at all.
-		return;
+		draw_media = false;
 	}
 	
-	// alpha off for this
-	LLGLSUIDefault gls_ui;
-	LLGLDisable gls_alphaTest( GL_ALPHA_TEST );
-
-	gGL.pushMatrix();
+	bool background_visible = isBackgroundVisible();
+	bool background_opaque = isBackgroundOpaque();
+	
+	if(draw_media)
 	{
-		if (mIgnoreUIScale)
+		// alpha off for this
+		LLGLSUIDefault gls_ui;
+		LLGLDisable gls_alphaTest( GL_ALPHA_TEST );
+
+		gGL.pushMatrix();
 		{
-			glLoadIdentity();
-			// font system stores true screen origin, need to scale this by UI scale factor
-			// to get render origin for this view (with unit scale)
-			gGL.translatef(floorf(LLFontGL::sCurOrigin.mX * LLUI::sGLScaleFactor.mV[VX]), 
-						floorf(LLFontGL::sCurOrigin.mY * LLUI::sGLScaleFactor.mV[VY]), 
-						LLFontGL::sCurOrigin.mZ);
-		}
+			if (mIgnoreUIScale)
+			{
+				glLoadIdentity();
+				// font system stores true screen origin, need to scale this by UI scale factor
+				// to get render origin for this view (with unit scale)
+				gGL.translatef(floorf(LLFontGL::sCurOrigin.mX * LLUI::sGLScaleFactor.mV[VX]), 
+							floorf(LLFontGL::sCurOrigin.mY * LLUI::sGLScaleFactor.mV[VY]), 
+							LLFontGL::sCurOrigin.mZ);
+			}
 
-		// scale texture to fit the space using texture coords
-		gGL.getTexUnit(0)->bind(media_texture);
-		gGL.color4fv( LLColor4::white.mV );
-		F32 max_u = ( F32 )media_plugin->getWidth() / ( F32 )media_plugin->getTextureWidth();
-		F32 max_v = ( F32 )media_plugin->getHeight() / ( F32 )media_plugin->getTextureHeight();
+			// scale texture to fit the space using texture coords
+			gGL.getTexUnit(0)->bind(media_texture);
+			gGL.color4fv( LLColor4::white.mV );
+			F32 max_u = ( F32 )media_plugin->getWidth() / ( F32 )media_plugin->getTextureWidth();
+			F32 max_v = ( F32 )media_plugin->getHeight() / ( F32 )media_plugin->getTextureHeight();
 
-		LLRect r = getRect();
-		S32 width, height;
-		S32 x_offset = 0;
-		S32 y_offset = 0;
-		
-		if(mStretchToFill)
-		{
-			if(mMaintainAspectRatio)
+			LLRect r = getRect();
+			S32 width, height;
+			S32 x_offset = 0;
+			S32 y_offset = 0;
+			
+			if(mStretchToFill)
 			{
-				F32 media_aspect = (F32)(media_plugin->getWidth()) / (F32)(media_plugin->getHeight());
-				F32 view_aspect = (F32)(r.getWidth()) / (F32)(r.getHeight());
-				if(media_aspect > view_aspect)
+				if(mMaintainAspectRatio)
 				{
-					// max width, adjusted height
-					width = r.getWidth();
-					height = llmin(llmax(llround(width / media_aspect), 0), r.getHeight());
+					F32 media_aspect = (F32)(media_plugin->getWidth()) / (F32)(media_plugin->getHeight());
+					F32 view_aspect = (F32)(r.getWidth()) / (F32)(r.getHeight());
+					if(media_aspect > view_aspect)
+					{
+						// max width, adjusted height
+						width = r.getWidth();
+						height = llmin(llmax(llround(width / media_aspect), 0), r.getHeight());
+					}
+					else
+					{
+						// max height, adjusted width
+						height = r.getHeight();
+						width = llmin(llmax(llround(height * media_aspect), 0), r.getWidth());
+					}
 				}
 				else
 				{
-					// max height, adjusted width
+					width = r.getWidth();
 					height = r.getHeight();
-					width = llmin(llmax(llround(height * media_aspect), 0), r.getWidth());
 				}
 			}
 			else
 			{
-				width = r.getWidth();
-				height = r.getHeight();
+				width = llmin(media_plugin->getWidth(), r.getWidth());
+				height = llmin(media_plugin->getHeight(), r.getHeight());
 			}
-		}
-		else
-		{
-			width = llmin(media_plugin->getWidth(), r.getWidth());
-			height = llmin(media_plugin->getHeight(), r.getHeight());
-		}
-		
-		x_offset = (r.getWidth() - width) / 2;
-		y_offset = (r.getHeight() - height) / 2;		
+			
+			x_offset = (r.getWidth() - width) / 2;
+			y_offset = (r.getHeight() - height) / 2;		
 
-		if(mIgnoreUIScale)
-		{
-			x_offset = llround((F32)x_offset * LLUI::sGLScaleFactor.mV[VX]);
-			y_offset = llround((F32)y_offset * LLUI::sGLScaleFactor.mV[VY]);
-			width = llround((F32)width * LLUI::sGLScaleFactor.mV[VX]);
-			height = llround((F32)height * LLUI::sGLScaleFactor.mV[VY]);
-		}
+			if(mIgnoreUIScale)
+			{
+				x_offset = llround((F32)x_offset * LLUI::sGLScaleFactor.mV[VX]);
+				y_offset = llround((F32)y_offset * LLUI::sGLScaleFactor.mV[VY]);
+				width = llround((F32)width * LLUI::sGLScaleFactor.mV[VX]);
+				height = llround((F32)height * LLUI::sGLScaleFactor.mV[VY]);
+			}
 
-		// draw the browser
-		gGL.setSceneBlendType(LLRender::BT_REPLACE);
-		gGL.begin( LLRender::QUADS );
-		if (! media_plugin->getTextureCoordsOpenGL())
-		{
-			// render using web browser reported width and height, instead of trying to invert GL scale
-			gGL.texCoord2f( max_u, 0.f );
-			gGL.vertex2i( x_offset + width, y_offset + height );
+			// draw the browser
+			gGL.setSceneBlendType(LLRender::BT_REPLACE);
+			gGL.begin( LLRender::QUADS );
+			if (! media_plugin->getTextureCoordsOpenGL())
+			{
+				// render using web browser reported width and height, instead of trying to invert GL scale
+				gGL.texCoord2f( max_u, 0.f );
+				gGL.vertex2i( x_offset + width, y_offset + height );
 
-			gGL.texCoord2f( 0.f, 0.f );
-			gGL.vertex2i( x_offset, y_offset + height );
+				gGL.texCoord2f( 0.f, 0.f );
+				gGL.vertex2i( x_offset, y_offset + height );
 
-			gGL.texCoord2f( 0.f, max_v );
-			gGL.vertex2i( x_offset, y_offset );
+				gGL.texCoord2f( 0.f, max_v );
+				gGL.vertex2i( x_offset, y_offset );
 
-			gGL.texCoord2f( max_u, max_v );
-			gGL.vertex2i( x_offset + width, y_offset );
-		}
-		else
-		{
-			// render using web browser reported width and height, instead of trying to invert GL scale
-			gGL.texCoord2f( max_u, max_v );
-			gGL.vertex2i( x_offset + width, y_offset + height );
+				gGL.texCoord2f( max_u, max_v );
+				gGL.vertex2i( x_offset + width, y_offset );
+			}
+			else
+			{
+				// render using web browser reported width and height, instead of trying to invert GL scale
+				gGL.texCoord2f( max_u, max_v );
+				gGL.vertex2i( x_offset + width, y_offset + height );
 
-			gGL.texCoord2f( 0.f, max_v );
-			gGL.vertex2i( x_offset, y_offset + height );
+				gGL.texCoord2f( 0.f, max_v );
+				gGL.vertex2i( x_offset, y_offset + height );
 
-			gGL.texCoord2f( 0.f, 0.f );
-			gGL.vertex2i( x_offset, y_offset );
+				gGL.texCoord2f( 0.f, 0.f );
+				gGL.vertex2i( x_offset, y_offset );
 
-			gGL.texCoord2f( max_u, 0.f );
-			gGL.vertex2i( x_offset + width, y_offset );
+				gGL.texCoord2f( max_u, 0.f );
+				gGL.vertex2i( x_offset + width, y_offset );
+			}
+			gGL.end();
+			gGL.setSceneBlendType(LLRender::BT_ALPHA);
 		}
-		gGL.end();
-		gGL.setSceneBlendType(LLRender::BT_ALPHA);
+		gGL.popMatrix();
+	
 	}
-	gGL.popMatrix();
-
+	else
+	{
+		// Setting these will make LLPanel::draw draw the opaque background color.
+		setBackgroundVisible(true);
+		setBackgroundOpaque(true);
+	}
+	
 	// highlight if keyboard focus here. (TODO: this needs some work)
 	if ( mBorder && mBorder->getVisible() )
 		mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus( this ) );
 
 	
 	LLPanel::draw();
+
+	// Restore the previous values
+	setBackgroundVisible(background_visible);
+	setBackgroundOpaque(background_opaque);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/indra/newview/llpanelavatar.cpp b/indra/newview/llpanelavatar.cpp
index a55979bb89..6c0a3880fa 100644
--- a/indra/newview/llpanelavatar.cpp
+++ b/indra/newview/llpanelavatar.cpp
@@ -594,8 +594,9 @@ void LLPanelAvatarProfile::processGroupProperties(const LLAvatarGroups* avatar_g
 		if (it != mGroups.begin())
 			groups += ", ";
 
+		std::string group_name = LLURI::escape(it->first);
 		std::string group_url= it->second.notNull()
-				? "[secondlife:///app/group/" + it->second.asString() + "/about " + it->first + "]"
+				? "[secondlife:///app/group/" + it->second.asString() + "/about " + group_name + "]"
 						: getString("no_group_text");
 
 		groups += group_url;
diff --git a/indra/newview/llpaneloutfitsinventory.cpp b/indra/newview/llpaneloutfitsinventory.cpp
index a1c12412b5..550fee71bf 100644
--- a/indra/newview/llpaneloutfitsinventory.cpp
+++ b/indra/newview/llpaneloutfitsinventory.cpp
@@ -181,6 +181,10 @@ void LLPanelOutfitsInventory::onNew()
 {
 	const std::string& outfit_name = LLViewerFolderType::lookupNewCategoryName(LLFolderType::FT_OUTFIT);
 	LLUUID outfit_folder = gAgentWearables.makeNewOutfitLinks(outfit_name);
+	if (mAppearanceTabs)
+	{
+		mAppearanceTabs->selectTabByName("outfitslist_tab");
+	}
 }
 
 void LLPanelOutfitsInventory::onSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action)
@@ -412,8 +416,7 @@ BOOL LLPanelOutfitsInventory::isActionEnabled(const LLSD& userdata)
 		return (getCorrectListenerForAction() != NULL) && hasItemsSelected();
 	}
 	
-	if (command_name == "wear" ||
-		command_name == "make_outfit")
+	if (command_name == "wear")
 	{
 		const BOOL is_my_outfits = (mActivePanel->getName() == "outfitslist_tab");
 		if (!is_my_outfits)
@@ -421,6 +424,10 @@ BOOL LLPanelOutfitsInventory::isActionEnabled(const LLSD& userdata)
 			return FALSE;
 		}
 	}
+	if (command_name == "make_outfit")
+	{
+		return TRUE;
+	}
    
 	if (command_name == "edit" || 
 		command_name == "add"
diff --git a/indra/newview/llsidepanelappearance.cpp b/indra/newview/llsidepanelappearance.cpp
index 0ae62843ac..77a370cc3f 100644
--- a/indra/newview/llsidepanelappearance.cpp
+++ b/indra/newview/llsidepanelappearance.cpp
@@ -62,6 +62,7 @@ public:
 	{
 		mPanel->inventoryFetched();
 		gInventory.removeObserver(this);
+		delete this;
 	}
 private:
 	LLSidepanelAppearance *mPanel;
@@ -94,14 +95,12 @@ LLSidepanelAppearance::LLSidepanelAppearance() :
 	mLookInfo(NULL),
 	mCurrOutfitPanel(NULL)
 {
-	//LLUICtrlFactory::getInstance()->buildPanel(this, "panel_appearance.xml"); // Called from LLRegisterPanelClass::defaultPanelClassBuilder()
-	mFetchWorn = new LLCurrentlyWornFetchObserver(this);
-	
-	mOutfitRenameWatcher = new LLWatchForOutfitRenameObserver(this);
 }
 
 LLSidepanelAppearance::~LLSidepanelAppearance()
 {
+	gInventory.removeObserver(mOutfitRenameWatcher);
+	delete mOutfitRenameWatcher;
 }
 
 // virtual
@@ -156,6 +155,7 @@ BOOL LLSidepanelAppearance::postBuild()
 	
 	mCurrOutfitPanel = getChild<LLPanel>("panel_currentlook");
 
+	mOutfitRenameWatcher = new LLWatchForOutfitRenameObserver(this);
 	gInventory.addObserver(mOutfitRenameWatcher);
 
 	return TRUE;
@@ -389,16 +389,17 @@ void LLSidepanelAppearance::fetchInventory()
 		}
 	}
 
-	mFetchWorn->fetchItems(ids);
+	LLCurrentlyWornFetchObserver *fetch_worn = new LLCurrentlyWornFetchObserver(this);
+	fetch_worn->fetchItems(ids);
 	// If no items to be fetched, done will never be triggered.
 	// TODO: Change LLInventoryFetchObserver::fetchItems to trigger done() on this condition.
-	if (mFetchWorn->isEverythingComplete())
+	if (fetch_worn->isEverythingComplete())
 	{
-		mFetchWorn->done();
+		fetch_worn->done();
 	}
 	else
 	{
-		gInventory.addObserver(mFetchWorn);
+		gInventory.addObserver(fetch_worn);
 	}
 }
 
diff --git a/indra/newview/llsidetray.cpp b/indra/newview/llsidetray.cpp
index 608165022f..d1236b948e 100644
--- a/indra/newview/llsidetray.cpp
+++ b/indra/newview/llsidetray.cpp
@@ -641,24 +641,60 @@ LLPanel*	LLSideTray::showPanel		(const std::string& panel_name, const LLSD& para
 	return NULL;
 }
 
-LLPanel*	LLSideTray::getPanel		(const std::string& panel_name)
+// This is just LLView::findChildView specialized to restrict the search to LLPanels.
+// Optimization for EXT-4068 to avoid searching down to the individual item level
+// when inventories are large.
+LLPanel *findChildPanel(LLPanel *panel, const std::string& name, bool recurse, S32& count)
 {
-	child_vector_const_iter_t child_it;
-	for ( child_it = mTabs.begin(); child_it != mTabs.end(); ++child_it)
+	for (LLView::child_list_const_iter_t child_it = panel->beginChild();
+		 child_it != panel->endChild(); ++child_it)
 	{
-		LLView* view = (*child_it)->findChildView(panel_name,true);
-		if(view)
+		count++;
+		LLPanel *child_panel = dynamic_cast<LLPanel*>(*child_it);
+		if (!child_panel)
+			continue;
+		if (child_panel->getName() == name)
+			return child_panel;
+	}
+	if (recurse)
+	{
+		for (LLView::child_list_const_iter_t child_it = panel->beginChild();
+			 child_it != panel->endChild(); ++child_it)
 		{
-			LLPanel* panel = dynamic_cast<LLPanel*>(view);
-			if(panel)
+			count++;
+			LLPanel *child_panel = dynamic_cast<LLPanel*>(*child_it);
+			if (!child_panel)
+				continue;
+			LLPanel *found_panel = findChildPanel(child_panel,name,recurse,count);
+			if (found_panel)
 			{
-				return panel;
+				return found_panel;
 			}
 		}
 	}
 	return NULL;
 }
 
+LLPanel* LLSideTray::getPanel(const std::string& panel_name)
+{
+	static S32 max_count = 0;
+	S32 count = 0;
+	for ( child_vector_const_iter_t child_it = mTabs.begin(); child_it != mTabs.end(); ++child_it)
+	{
+		LLPanel *panel = findChildPanel(*child_it,panel_name,true,count);
+		if (count > max_count)
+		{
+			max_count = count;
+			llwarns << "max_count " << max_count << llendl;
+		}
+		if(panel)
+		{
+			return panel;
+		}
+	}
+	return NULL;
+}
+
 LLPanel*	LLSideTray::getActivePanel()
 {
 	if (mActiveTab && !mCollapsed)
diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 6ca6734598..514d8facb4 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2460,7 +2460,6 @@ void renderOctree(LLSpatialGroup* group)
 	gGL.color4fv(col.mV);
 	drawBox(group->mObjectBounds[0], group->mObjectBounds[1]*1.01f+LLVector3(0.001f, 0.001f, 0.001f));
 	
-	glDepthMask(GL_TRUE);
 	gGL.setSceneBlendType(LLRender::BT_ALPHA);
 
 	if (group->mBuilt <= 0.f)
diff --git a/indra/newview/lltexturectrl.cpp b/indra/newview/lltexturectrl.cpp
index 25e5e23e6f..a5ddb0a620 100644
--- a/indra/newview/lltexturectrl.cpp
+++ b/indra/newview/lltexturectrl.cpp
@@ -1242,11 +1242,11 @@ void LLTextureCtrl::draw()
 		 (mTexturep->getDiscardLevel() != 1) &&
 		 (mTexturep->getDiscardLevel() != 0))
 	{
-		LLFontGL* font = LLFontGL::getFontSansSerifBig();
+		LLFontGL* font = LLFontGL::getFontSansSerif();
 		font->renderUTF8(
 			mLoadingPlaceholderString, 0,
-			llfloor(interior.mLeft+10), 
-			llfloor(interior.mTop-20),
+			llfloor(interior.mLeft+3), 
+			llfloor(interior.mTop-25),
 			LLColor4::white,
 			LLFontGL::LEFT,
 			LLFontGL::BASELINE,
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 7e8c8eb92e..023c288d92 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -48,12 +48,15 @@
 #include "llviewerwindow.h"
 #include "llfocusmgr.h"
 #include "llcallbacklist.h"
+#include "llparcel.h"
+#include "llaudioengine.h"  // for gAudiop
 
 #include "llevent.h"		// LLSimpleListener
 #include "llnotificationsutil.h"
 #include "lluuid.h"
 #include "llkeyboard.h"
 #include "llmutelist.h"
+#include "llfirstuse.h"
 
 #include <boost/bind.hpp>	// for SkinFolder listener
 #include <boost/signals2.hpp>
@@ -708,6 +711,8 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
 	
 	std::vector<LLViewerMediaImpl*> proximity_order;
 	
+	bool inworld_media_enabled = gSavedSettings.getBOOL("AudioStreamingMedia");
+	bool needs_first_run = LLViewerMedia::needsMediaFirstRun();
 	U32 max_instances = gSavedSettings.getU32("PluginInstancesTotal");
 	U32 max_normal = gSavedSettings.getU32("PluginInstancesNormal");
 	U32 max_low = gSavedSettings.getU32("PluginInstancesLow");
@@ -822,6 +827,21 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
 			new_priority = LLPluginClassMedia::PRIORITY_LOW;
 		}
 		
+		if(!inworld_media_enabled)
+		{
+			// If inworld media is locked out, force all inworld media to stay unloaded.
+			if(!pimpl->getUsedInUI())
+			{
+				new_priority = LLPluginClassMedia::PRIORITY_UNLOADED;
+				if(needs_first_run)
+				{
+					// Don't do this more than once in this loop.
+					needs_first_run = false;
+					LLViewerMedia::displayMediaFirstRun();
+				}
+			}
+		}
+		
 		pimpl->setPriority(new_priority);
 		
 		if(pimpl->getUsedInUI())
@@ -888,6 +908,61 @@ void LLViewerMedia::cleanupClass()
 	gIdleCallbacks.deleteFunction(LLViewerMedia::updateMedia, NULL);
 }
 
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+bool LLViewerMedia::needsMediaFirstRun()
+{
+	return gWarningSettings.getBOOL("FirstStreamingMedia");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+void LLViewerMedia::displayMediaFirstRun()
+{
+	gWarningSettings.setBOOL("FirstStreamingMedia", FALSE);
+
+	LLNotificationsUtil::add("ParcelCanPlayMedia", LLSD(), LLSD(),
+		boost::bind(firstRunCallback, _1, _2));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+bool LLViewerMedia::firstRunCallback(const LLSD& notification, const LLSD& response)
+{
+	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+	if (option == 0)
+	{
+		// user has elected to automatically play media.
+		gSavedSettings.setBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING, TRUE);
+		gSavedSettings.setBOOL("AudioStreamingVideo", TRUE);
+		gSavedSettings.setBOOL("AudioStreamingMusic", TRUE);
+		gSavedSettings.setBOOL("AudioStreamingMedia", TRUE);
+
+		LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+				
+		if (parcel)
+		{
+			// play media right now, if available
+			LLViewerParcelMedia::play(parcel);
+		
+			// play music right now, if available
+			std::string music_url = parcel->getMusicURL();
+			if (gAudiop && !music_url.empty())
+				gAudiop->startInternetStream(music_url);
+		}
+	}
+	else
+	{
+		gSavedSettings.setBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING, FALSE);
+		gSavedSettings.setBOOL("AudioStreamingMedia", FALSE);
+		gSavedSettings.setBOOL("AudioStreamingVideo", FALSE);
+		gSavedSettings.setBOOL("AudioStreamingMusic", FALSE);
+	}
+	return false;
+}
+
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // LLViewerMediaImpl
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -930,6 +1005,7 @@ LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
 	mMediaAutoPlay(false),
 	mInNearbyMediaList(false),
 	mClearCache(false),
+	mBackgroundColor(LLColor4::white),
 	mIsUpdated(false)
 { 
 
@@ -1142,6 +1218,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type)
 		media_source->setAutoScale(mMediaAutoScale);
 		media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
 		media_source->focus(mHasFocus);
+		media_source->setBackgroundColor(mBackgroundColor);
 		
 		if(mClearCache)
 		{
@@ -1908,8 +1985,8 @@ LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage()
 		|| placeholder_image->getUseMipMaps()
 		|| (placeholder_image->getWidth() != mMediaSource->getTextureWidth())
 		|| (placeholder_image->getHeight() != mMediaSource->getTextureHeight())
-		|| (mTextureUsedWidth > mMediaSource->getWidth())
-		|| (mTextureUsedHeight > mMediaSource->getHeight())
+		|| (mTextureUsedWidth != mMediaSource->getWidth())
+		|| (mTextureUsedHeight != mMediaSource->getHeight())
 		)
 	{
 		LL_DEBUGS("Media") << "initializing media placeholder" << LL_ENDL;
@@ -1927,7 +2004,9 @@ LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage()
 		// MEDIAOPT: seems insane that we actually have to make an imageraw then
 		// immediately discard it
 		LLPointer<LLImageRaw> raw = new LLImageRaw(texture_width, texture_height, texture_depth);
-		raw->clear(0x00, 0x00, 0x00, 0xff);
+		// Clear the texture to the background color, ignoring alpha.
+		// convert background color channels from [0.0, 1.0] to [0, 255];
+		raw->clear(int(mBackgroundColor.mV[VX] * 255.0f), int(mBackgroundColor.mV[VY] * 255.0f), int(mBackgroundColor.mV[VZ] * 255.0f), 0xff);
 		int discard_level = 0;
 
 		// ask media source for correct GL image format constants
@@ -2398,6 +2477,16 @@ void LLViewerMediaImpl::setUsedInUI(bool used_in_ui)
 	}
 };
 
+void LLViewerMediaImpl::setBackgroundColor(LLColor4 color)
+{
+	mBackgroundColor = color; 
+
+	if(mMediaSource)
+	{
+		mMediaSource->setBackgroundColor(mBackgroundColor);
+	}
+};
+
 F64 LLViewerMediaImpl::getCPUUsage() const
 {
 	F64 result = 0.0f;
diff --git a/indra/newview/llviewermedia.h b/indra/newview/llviewermedia.h
index b103c48bd8..8a5cd804aa 100644
--- a/indra/newview/llviewermedia.h
+++ b/indra/newview/llviewermedia.h
@@ -42,6 +42,7 @@
 #include "llviewermediaobserver.h"
 
 #include "llpluginclassmedia.h"
+#include "v4color.h"
 
 class LLViewerMediaImpl;
 class LLUUID;
@@ -115,6 +116,12 @@ class LLViewerMedia
 		
 		// This is the comparitor used to sort the list.
 		static bool priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2);
+		
+		// For displaying the media first-run dialog.
+		static bool needsMediaFirstRun();
+		static void displayMediaFirstRun();
+		static bool firstRunCallback(const LLSD& notification, const LLSD& response);
+
 };
 
 // Implementation functions not exported into header file
@@ -289,6 +296,8 @@ public:
 	// This will be used as part of the interest sorting algorithm.
 	void setUsedInUI(bool used_in_ui);
 	bool getUsedInUI() const { return mUsedInUI; };
+
+	void setBackgroundColor(LLColor4 color);
 	
 	F64 getCPUUsage() const;
 	
@@ -362,6 +371,7 @@ private:
 	std::string mMediaEntryURL;
 	bool mInNearbyMediaList;	// used by LLFloaterNearbyMedia::refreshList() for performance reasons
 	bool mClearCache;
+	LLColor4 mBackgroundColor;
 	
 private:
 	BOOL mIsUpdated ;
diff --git a/indra/newview/llviewerparcelmedia.cpp b/indra/newview/llviewerparcelmedia.cpp
index 0f7903a7a5..56dee6b34c 100644
--- a/indra/newview/llviewerparcelmedia.cpp
+++ b/indra/newview/llviewerparcelmedia.cpp
@@ -56,10 +56,6 @@ LLUUID LLViewerParcelMedia::sMediaRegionID;
 viewer_media_t LLViewerParcelMedia::sMediaImpl;
 
 
-// Local functions
-bool callback_play_media(const LLSD& notification, const LLSD& response, LLParcel* parcel);
-
-
 // static
 void LLViewerParcelMedia::initClass()
 {
@@ -112,12 +108,10 @@ void LLViewerParcelMedia::update(LLParcel* parcel)
 			// First use warning
 			if( (!mediaUrl.empty() ||
 			     !parcel->getMusicURL().empty())
-			    && gWarningSettings.getBOOL("FirstStreamingMedia") )
+			    && LLViewerMedia::needsMediaFirstRun())
 			{
-				LLNotificationsUtil::add("ParcelCanPlayMedia", LLSD(), LLSD(),
-					boost::bind(callback_play_media, _1, _2, parcel));
+				LLViewerMedia::displayMediaFirstRun();
 				return;
-
 			}
 
 			// if we have a current (link sharing) url, use it instead
@@ -591,36 +585,6 @@ void LLViewerParcelMedia::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent
 	};
 }
 
-bool callback_play_media(const LLSD& notification, const LLSD& response, LLParcel* parcel)
-{
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	if (option == 0)
-	{
-		// user has elected to automatically play media.
-		gSavedSettings.setBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING, TRUE);
-		gSavedSettings.setBOOL("AudioStreamingVideo", TRUE);
-		gSavedSettings.setBOOL("AudioStreamingMusic", TRUE);
-		if(!gSavedSettings.getBOOL("AudioStreamingMedia")) 
-			gSavedSettings.setBOOL("AudioStreamingMedia", TRUE);
-		// play media right now, if available
-		LLViewerParcelMedia::play(parcel);
-		// play music right now, if available
-		if (parcel)
-		{
-			std::string music_url = parcel->getMusicURL();
-			if (gAudiop && !music_url.empty())
-				gAudiop->startInternetStream(music_url);
-		}
-	}
-	else
-	{
-		gSavedSettings.setBOOL("AudioStreamingVideo", FALSE);
-		gSavedSettings.setBOOL("AudioStreamingMusic", FALSE);
-	}
-	gWarningSettings.setBOOL("FirstStreamingMedia", FALSE);
-	return false;
-}
-
 // TODO: observer
 /*
 void LLViewerParcelMediaNavigationObserver::onNavigateComplete( const EventType& event_in )
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 6e93bf1bf2..d0acb0bd39 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -6822,7 +6822,7 @@ void LLVOAvatar::useBakedTexture( const LLUUID& id )
 				 local_tex_iter != baked_dict->mLocalTextures.end();
 				 ++local_tex_iter)
 			{
-				setBakedReady(*local_tex_iter, TRUE);
+				if (isSelf()) setBakedReady(*local_tex_iter, TRUE);
 			}
 
 			// ! BACKWARDS COMPATIBILITY !
diff --git a/indra/newview/skins/default/colors.xml b/indra/newview/skins/default/colors.xml
index 887cff56f6..6da38fa0d4 100644
--- a/indra/newview/skins/default/colors.xml
+++ b/indra/newview/skins/default/colors.xml
@@ -292,7 +292,7 @@
      reference="White" />
      <color
      name="FilterBackgroundColor"
-     reference="MouseGray" />
+     reference="Black" />
     <color
      name="FilterTextColor"
      value="0.38 0.69 0.57 1" />
@@ -394,7 +394,10 @@
      reference="White" />
     <color
      name="InventoryBackgroundColor"
-     reference="Unused?" />
+     reference="DkGray2" />
+    <color
+     name="InventoryFocusOutlineColor"
+     reference="EmphasisColor" />
     <color
      name="InventoryItemSuffixColor"
      reference="White_25" />
diff --git a/indra/newview/skins/default/textures/icons/Inv_Landmark.png b/indra/newview/skins/default/textures/icons/Inv_Landmark.png
index f8ce765c50..76df984596 100644
--- a/indra/newview/skins/default/textures/icons/Inv_Landmark.png
+++ b/indra/newview/skins/default/textures/icons/Inv_Landmark.png
diff --git a/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Off.png b/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Off.png
index ada28e01da..f5a5f7a846 100644
--- a/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Off.png
+++ b/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Off.png
diff --git a/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Selected.png b/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Selected.png
index 0f8d5619ec..8e0fb9661e 100644
--- a/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Selected.png
+++ b/indra/newview/skins/default/textures/taskpanel/TabIcon_Places_Selected.png
diff --git a/indra/newview/skins/default/textures/textures.xml b/indra/newview/skins/default/textures/textures.xml
index 75424e71f5..dab11149b9 100644
--- a/indra/newview/skins/default/textures/textures.xml
+++ b/indra/newview/skins/default/textures/textures.xml
@@ -167,6 +167,7 @@ with the same filename but different name
 
   <texture name="Flag" file_name="navbar/Flag.png" preload="false" />
 
+  <texture name="Folder_Arrow" file_name="folder_arrow.tga" preload="false" />
   <texture name="ForSale_Badge" file_name="icons/ForSale_Badge.png" preload="false" />
   <texture name="ForwardArrow_Off" file_name="icons/ForwardArrow_Off.png" preload="false" />
   <texture name="ForwardArrow_Press" file_name="icons/ForwardArrow_Press.png" preload="false" />
@@ -439,6 +440,7 @@ with the same filename but different name
 
   <texture name="Resize_Corner" file_name="windows/Resize_Corner.png" preload="true" />
 
+  <texture name="Rounded_Square"	file_name="rounded_square.j2c" preload="true" scale.left="16" scale.top="16" scale.right="112" scale.bottom="16" />
   <texture name="Row_Selection" file_name="navbar/Row_Selection.png" preload="false" />
 
   <texture name="ScrollArrow_Down" file_name="widgets/ScrollArrow_Down.png"	preload="true" scale.left="2" scale.top="13" scale.right="13" scale.bottom="2" />
@@ -676,7 +678,6 @@ with the same filename but different name
   <texture name="toggle_button_selected" file_name="toggle_button_selected.png" preload="true" />
 
   <texture name="sm_rounded_corners_simple.tga" scale.left="4" scale.top="4" scale.bottom="4" scale.right="4" />
-  <texture name="rounded_square.tga"	file_name="rounded_square.j2c" preload="true" scale.left="16" scale.top="16" scale.right="112" scale.bottom="16" />
   <texture name="color_swatch_alpha.tga" preload="true" />
 
   <texture name="button_anim_pause.tga" />
diff --git a/indra/newview/skins/default/xui/en/floater_bulk_perms.xml b/indra/newview/skins/default/xui/en/floater_bulk_perms.xml
index 53ae24fe3f..d007ceff98 100644
--- a/indra/newview/skins/default/xui/en/floater_bulk_perms.xml
+++ b/indra/newview/skins/default/xui/en/floater_bulk_perms.xml
@@ -287,7 +287,7 @@
     <button
      follows="left|top"
      height="23"
-     label="Ok"
+     label="OK"
      layout="topleft"
      left="65"
      name="apply"
diff --git a/indra/newview/skins/default/xui/en/floater_color_picker.xml b/indra/newview/skins/default/xui/en/floater_color_picker.xml
index 4380ff8f4b..fbecebc363 100644
--- a/indra/newview/skins/default/xui/en/floater_color_picker.xml
+++ b/indra/newview/skins/default/xui/en/floater_color_picker.xml
@@ -186,8 +186,8 @@
     <button
      follows="right|bottom"
      height="20"
-     label="Ok"
-     label_selected="Ok"
+     label="OK"
+     label_selected="OK"
      layout="topleft"
      right="-120"
      top_delta="9"
diff --git a/indra/newview/skins/default/xui/en/floater_help_browser.xml b/indra/newview/skins/default/xui/en/floater_help_browser.xml
index 446b7138c4..e83bc1555c 100644
--- a/indra/newview/skins/default/xui/en/floater_help_browser.xml
+++ b/indra/newview/skins/default/xui/en/floater_help_browser.xml
@@ -43,7 +43,6 @@
              left="0"
              name="browser"
              top="0"
-             start_url="data:text/html,%3Chtml%3E%3Cbody bgcolor=%22#2A2A2A%22%3E%3C/body%3E%3C/html%3E"
              width="590" />
         </layout_panel>
     </layout_stack>
diff --git a/indra/newview/skins/default/xui/en/floater_im_container.xml b/indra/newview/skins/default/xui/en/floater_im_container.xml
index cd297af99d..ccbba61ddf 100644
--- a/indra/newview/skins/default/xui/en/floater_im_container.xml
+++ b/indra/newview/skins/default/xui/en/floater_im_container.xml
@@ -9,7 +9,7 @@
  save_rect="true"

  save_visibility="true"

  single_instance="true"

- title="Instant Messages"

+ title="CONVERSATIONS"

  width="392">

     <tab_container

      follows="left|right|top|bottom"

diff --git a/indra/newview/skins/default/xui/en/floater_mute_object.xml b/indra/newview/skins/default/xui/en/floater_mute_object.xml
index 454b1c43b2..22b0a1783f 100644
--- a/indra/newview/skins/default/xui/en/floater_mute_object.xml
+++ b/indra/newview/skins/default/xui/en/floater_mute_object.xml
@@ -47,7 +47,7 @@
     <button
      follows="bottom|left"
      height="23"
-     label="Ok"
+     label="OK"
      layout="topleft"
      left="155"
      name="OK"
diff --git a/indra/newview/skins/default/xui/en/floater_search.xml b/indra/newview/skins/default/xui/en/floater_search.xml
index 5a9e2ebe6e..b0bb282abd 100644
--- a/indra/newview/skins/default/xui/en/floater_search.xml
+++ b/indra/newview/skins/default/xui/en/floater_search.xml
@@ -42,7 +42,6 @@
              left="0"
              name="browser"
              top="0"
-             start_url="data:text/html,%3Chtml%3E%3Cbody bgcolor=%22#2A2A2A%22%3E%3C/body%3E%3C/html%3E"
              height="600"
              width="650" />
             <text
diff --git a/indra/newview/skins/default/xui/en/floater_texture_ctrl.xml b/indra/newview/skins/default/xui/en/floater_texture_ctrl.xml
index 695021f755..cad7d72ed7 100644
--- a/indra/newview/skins/default/xui/en/floater_texture_ctrl.xml
+++ b/indra/newview/skins/default/xui/en/floater_texture_ctrl.xml
@@ -131,8 +131,8 @@
          <button
      follows="right|bottom"
      height="20"
-     label="Ok"
-     label_selected="Ok"
+     label="OK"
+     label_selected="OK"
      layout="topleft"
      right="-120"
      name="Select"
diff --git a/indra/newview/skins/default/xui/en/floater_whitelist_entry.xml b/indra/newview/skins/default/xui/en/floater_whitelist_entry.xml
index 4ece0fa3ba..897d959b98 100644
--- a/indra/newview/skins/default/xui/en/floater_whitelist_entry.xml
+++ b/indra/newview/skins/default/xui/en/floater_whitelist_entry.xml
@@ -5,6 +5,9 @@
  height="108"
  layout="topleft"
  name="whitelist_entry"
+ single_instance="true"
+ help_topic="whitelist_entry"
+ title="WHITELIST ENTRY"
  width="390">
 
   <text type="string" length="1" bottom="20" follows="top|left" height="15" layout="topleft"
diff --git a/indra/newview/skins/default/xui/en/notifications.xml b/indra/newview/skins/default/xui/en/notifications.xml
index 6d5f0bedb0..410c398ea5 100644
--- a/indra/newview/skins/default/xui/en/notifications.xml
+++ b/indra/newview/skins/default/xui/en/notifications.xml
@@ -157,7 +157,7 @@ No tutorial is currently available.
  An error occurred while updating [APP_NAME].  Please [http://get.secondlife.com download the latest version] of the Viewer.
     <usetemplate
      name="okbutton"
-     yestext="Ok"/>
+     yestext="OK"/>
   </notification>
 
   <notification
@@ -169,7 +169,7 @@ Could not connect to the [SECOND_LIFE_GRID].
 Make sure your Internet connection is working properly.
 	<usetemplate
      name="okbutton"
-     yestext="Ok"/>
+     yestext="OK"/>
   </notification>
 
   <notification
@@ -179,7 +179,7 @@ Make sure your Internet connection is working properly.
 Message Template [PATH] not found.
 	<usetemplate
      name="okbutton"
-     yestext="Ok"/>
+     yestext="OK"/>
   </notification>
 
   <notification
@@ -5793,7 +5793,7 @@ Are you sure you want to close all IMs?
     <usetemplate
      name="okcancelignore"
      notext="Cancel"
-     yestext="Ok"/>
+     yestext="OK"/>
   </notification>
 
   <notification icon="notifytip.tga"
diff --git a/indra/newview/skins/default/xui/en/panel_group_notify.xml b/indra/newview/skins/default/xui/en/panel_group_notify.xml
index 9b0b81cd0a..65b2e81d50 100644
--- a/indra/newview/skins/default/xui/en/panel_group_notify.xml
+++ b/indra/newview/skins/default/xui/en/panel_group_notify.xml
@@ -93,7 +93,7 @@
      bottom="85"
      follows="bottom"
      height="20"
-     label="Ok"
+     label="OK"
      layout="topleft"
      right="-10"
      name="btn_ok"
diff --git a/indra/newview/skins/default/xui/en/panel_landmarks.xml b/indra/newview/skins/default/xui/en/panel_landmarks.xml
index c899dcb750..039e1ae086 100644
--- a/indra/newview/skins/default/xui/en/panel_landmarks.xml
+++ b/indra/newview/skins/default/xui/en/panel_landmarks.xml
@@ -25,7 +25,7 @@
          title="Favorites bar">
             <places_inventory_panel
              allow_multi_select="true"
-             border="true"
+             border="false"
              bottom="0"
              follows="left|top|right|bottom"
              height="126"
@@ -41,7 +41,7 @@
          title="Landmarks">
             <places_inventory_panel
              allow_multi_select="true"
-             border="true"
+             border="false"
              bottom="0"
              follows="left|top|right|bottom"
              height="126"
@@ -57,7 +57,7 @@
          title="My Inventory">
             <places_inventory_panel
              allow_multi_select="true"
-             border="true"
+             border="false"
              bottom="0"
              follows="left|top|right|bottom"
              height="126"
@@ -73,7 +73,7 @@
            title="Library">
             <places_inventory_panel
              allow_multi_select="true"
-             border="true"
+             border="false"
              bottom="0"
              follows="left|top|right|bottom"
              height="120"
diff --git a/indra/newview/skins/default/xui/en/panel_login.xml b/indra/newview/skins/default/xui/en/panel_login.xml
index 6187b8f1e2..e5df37e366 100644
--- a/indra/newview/skins/default/xui/en/panel_login.xml
+++ b/indra/newview/skins/default/xui/en/panel_login.xml
@@ -24,6 +24,7 @@ top="600"
 </panel.string>
 <!-- *NOTE: Custom resize logic for login_html in llpanellogin.cpp -->
 <web_browser
+bg_opaque_color="Black"
 border_visible="false"
 bottom="600"
 follows="all"
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_chat.xml b/indra/newview/skins/default/xui/en/panel_preferences_chat.xml
index 017c321767..6e0b94ac2b 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_chat.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_chat.xml
@@ -318,15 +318,15 @@
      height="20"
      width="300"
      top_pad="20">
-     Show IMs in:
+     Show IMs in: (Requires restart)
     </text>
     <radio_group
      height="30"
      layout="topleft"
-     left="30"
+     left_delta="30"
      control_name="ChatWindow"
      name="chat_window"
-     top_pad="10"
+     top_pad="0"
      tool_tip="Show your Instant Messages in separate windows, or in one window with many tabs (Requires restart)"
      width="331">
      <radio_item
@@ -342,10 +342,10 @@
       height="16"
       label="One window"
       layout="topleft"
-      left_delta="145"
+      left_delta="0"
       name="radio2"
       value="1"
-      top_delta="0"
+      top_pad="5"
       width="150" />
     </radio_group>
 </panel>
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_graphics1.xml b/indra/newview/skins/default/xui/en/panel_preferences_graphics1.xml
index f97ccafecc..cc00abf5a0 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_graphics1.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_graphics1.xml
@@ -76,7 +76,7 @@
     <icon
      color="0.12 0.12 0.12 1"
      height="14"
-     image_name="rounded_square.tga"
+     image_name="Rounded_Square"
      layout="topleft"
      left="128"
      name="LowGraphicsDivet"
@@ -85,7 +85,7 @@
     <icon
      color="0.12 0.12 0.12 1"
      height="14"
-     image_name="rounded_square.tga"
+     image_name="Rounded_Square"
      layout="topleft"
      left_pad="83"
      name="MidGraphicsDivet"
@@ -94,7 +94,7 @@
     <icon
      color="0.12 0.12 0.12 1"
      height="14"
-     image_name="rounded_square.tga"
+     image_name="Rounded_Square"
      layout="topleft"
      left_pad="85"
      name="HighGraphicsDivet"
@@ -103,7 +103,7 @@
     <icon
      color="0.12 0.12 0.12 1"
      height="14"
-     image_name="rounded_square.tga"
+     image_name="Rounded_Square"
      layout="topleft"
      left_pad="83"
      name="UltraGraphicsDivet"
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml b/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml
index 5dd93d0f7e..1c1e17eb5a 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml
@@ -134,18 +134,6 @@
      name="show_timestamps_check_im"
      top_pad="10"
      width="237" />
-    <line_editor
-     bottom="366"
-     control_name="InstantMessageLogFolder"
-     enabled="false"
-     follows="top|left|right"
-     halign="right"
-     height="19"
-     layout="topleft"
-     left_delta="0"
-     mouse_opaque="false"
-     name="log_path_string"
-     top_pad="5" />
     <text
      type="string"
      length="1"
@@ -155,11 +143,23 @@
      left_delta="0"
      mouse_opaque="false"
      name="log_path_desc"
-     top_pad="1"
-     width="128"
-     text_color="LtGray_50">
-        Location of logs
+     top_pad="5"
+     width="128">
+        Location of logs:
     </text>    
+    <line_editor
+     bottom="366"
+     control_name="InstantMessageLogFolder"
+     enabled="false"
+     follows="top|left|right"
+     halign="right"
+     height="23"
+     layout="topleft"
+     left_delta="0"
+     mouse_opaque="false"
+     name="log_path_string"
+     top_pad="5"
+     width="250"/>
     <button
 	 enabled="false"
      follows="right|bottom"
@@ -167,9 +167,9 @@
      label="Browse"
      label_selected="Browse"
      layout="topleft"
-     left_pad="115"
+     left_pad="5"
      name="log_path_button"
-     top_delta="-21"
+     top_delta="0"
      width="145">
         <button.commit_callback
          function="Pref.LogPath" />
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_setup.xml b/indra/newview/skins/default/xui/en/panel_preferences_setup.xml
index 34bd6fb091..f6900cc31c 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_setup.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_setup.xml
@@ -176,7 +176,7 @@
      max_val="1024"
      min_val="32"
      name="cache_size"
-     top_delta="-1"
+     top_delta="-2"
      width="180" />
     <text
      type="string"
@@ -191,6 +191,18 @@
      width="40">
         MB
     </text>
+    <text
+     type="string"
+     length="1"
+     follows="left|top"
+     height="10"
+     layout="topleft"
+     left="80"
+     name="Cache location"
+     top_delta="20"
+     width="300">
+        Cache location:
+    </text>
     <line_editor
      control_name="CacheLocationTopFolder"
      border_style="line"
@@ -199,12 +211,12 @@
      follows="left|top"
      font="SansSerif"
      handle_edit_keys_directly="true"
-     height="20"
+     height="23"
      layout="topleft"
      left="80"
      max_length="4096"
      name="cache_location"
-     top_pad="20"
+     top_pad="5"
      width="205" />
     <button
      follows="left|top"
@@ -232,20 +244,6 @@
         <button.commit_callback
          function="Pref.ResetCache" />
     </button>
-
-    <text
-     type="string"
-     length="1"
-     follows="left|top"
-     height="10"
-     layout="topleft"
-     left="80"
-     name="Cache location"
-     top_delta="20"
-     width="300"
-     text_color="LtGray_50">
-        Cache location
-    </text>
     <text
      type="string"
      length="1"
@@ -301,15 +299,28 @@
      mouse_opaque="true"
      name="web_proxy_enabled"
      radio_style="false"
-     width="400" />
+     width="400"
+     top_pad="5"/>
+    <text
+     type="string"
+     length="1"
+     follows="left|top"
+     height="10"
+     layout="topleft"
+     left_delta="1"
+     name="Proxy location"
+     top_delta="20"
+     width="300">
+        Proxy location:
+    </text>
     <line_editor
      control_name="BrowserProxyAddress"
      enabled_control="BrowserProxyEnabled"
 	 follows="left|top"
      font="SansSerif"
-     height="20"
+     height="23"
      layout="topleft"
-     left_delta="1"
+     left_delta="0"
      name="web_proxy_editor"
      tool_tip="The name or IP address of the proxy you would like to use"
      top_pad="4"
@@ -328,16 +339,4 @@
         <button.commit_callback
          function="Pref.SetCache" />
     </button>
-    <text
-     type="string"
-     length="1"
-     follows="left|top"
-     height="10"
-     layout="topleft"
-     left_delta="-203"
-     name="Proxy location"
-     top_delta="20"
-     width="300"
-     text_color="LtGray_50">
-        Proxy location
-    </text></panel>
+  </panel>
diff --git a/indra/newview/skins/default/xui/en/panel_progress.xml b/indra/newview/skins/default/xui/en/panel_progress.xml
index 18c2228906..727c5fb7b2 100644
--- a/indra/newview/skins/default/xui/en/panel_progress.xml
+++ b/indra/newview/skins/default/xui/en/panel_progress.xml
@@ -54,7 +54,7 @@
                      color="LoginProgressBoxCenterColor"
                      follows="left|right|bottom|top"
                      height="250"
-                     image_name="rounded_square.tga"
+                     image_name="Rounded_Square"
                      layout="topleft"
                      left="0"
                      top="0"
diff --git a/indra/newview/skins/default/xui/en/panel_region_texture.xml b/indra/newview/skins/default/xui/en/panel_region_texture.xml
index a4d24cb0fc..502a5804c3 100644
--- a/indra/newview/skins/default/xui/en/panel_region_texture.xml
+++ b/indra/newview/skins/default/xui/en/panel_region_texture.xml
@@ -136,7 +136,7 @@
      layout="topleft"
      left="10"
      name="height_text_lbl5"
-     top="186"
+     top="170"
      width="300">
         Texture Elevation Ranges
     </text>
@@ -146,7 +146,7 @@
      layout="topleft"
      left="51"
      name="height_text_lbl6"
-     top="201"
+     top="185"
      width="100">
         Southwest
     </text>
@@ -171,7 +171,7 @@
     max_val="500"
     min_val="-500"
     name="height_start_spin_0"
-    top_delta="20"
+    top_delta="15"
     width="100" />
   <spinner
    follows="left|top"
@@ -216,9 +216,9 @@
      follows="left|top"
      height="20"
      layout="topleft"
-     left_pad="10"
+     left="51"
      name="height_text_lbl8"
-     top_delta="0"
+     top_pad="10"
      width="100">
         Southeast
     </text>
@@ -243,7 +243,7 @@
        max_val="500"
        min_val="-500"
        name="height_start_spin_2"
-       top_delta="20"
+       top_delta="15"
        width="100" />
       <spinner
        follows="left|top"
@@ -291,9 +291,9 @@
        left="10"
        name="height_text_lbl10"
        top_delta="30"
-       width="270">
-        These values represent the blend range
-        for the textures above.
+       width="400"
+       wrap="true">
+        These values represent the blend range for the textures above.
       </text>
       <text
        follows="left|top"
@@ -302,11 +302,9 @@
        left_delta="0"
        name="height_text_lbl11"
        top_delta="32"
-       width="270">
-        Measured in meters, the LOW value
-        is the MAXIMUM height of Texture #1,
-        and the HIGH value is the MINIMUM
-        height of Texture #4.
+       width="400"
+       wrap="true">
+        Measured in meters, the LOW value is the MAXIMUM height of Texture #1, and the HIGH value is the MINIMUM height of Texture #4.
       </text>
     <button
      enabled="false"
diff --git a/indra/newview/skins/default/xui/en/widgets/folder_view_item.xml b/indra/newview/skins/default/xui/en/widgets/folder_view_item.xml
new file mode 100644
index 0000000000..e6bdcccfdf
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/widgets/folder_view_item.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<folder_view_item
+  folder_arrow_image="Folder_Arrow"
+  folder_indentation="8"
+  item_height="20" 
+  item_top_pad="4"
+  selection_image="Rounded_Square"
+  />
diff --git a/indra/newview/skins/default/xui/en/widgets/inventory_panel.xml b/indra/newview/skins/default/xui/en/widgets/inventory_panel.xml
new file mode 100644
index 0000000000..93875d66e6
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/widgets/inventory_panel.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<panel
+  bg_opaque_color="InventoryBackgroundColor"
+  background_visible="true"
+  background_opaque="true"
+  />
diff --git a/indra/newview/viewer_manifest.py b/indra/newview/viewer_manifest.py
index 0db18525d7..00a903431a 100755
--- a/indra/newview/viewer_manifest.py
+++ b/indra/newview/viewer_manifest.py
@@ -822,13 +822,15 @@ class LinuxManifest(ViewerManifest):
             'dst': self.get_dst_prefix(),
             'inst': self.build_path_of(installer_name)})
         try:
-            # --numeric-owner hides the username of the builder for
-            # security etc.
-            self.run_command('tar -C %(dir)s --numeric-owner -cjf '
-                             '%(inst_path)s.tar.bz2 %(inst_name)s' % {
-                'dir': self.get_build_prefix(),
-                'inst_name': installer_name,
-                'inst_path':self.build_path_of(installer_name)})
+            # only create tarball if it's not a debug build.
+            if self.args['buildtype'].lower() != 'debug':
+                # --numeric-owner hides the username of the builder for
+                # security etc.
+                self.run_command('tar -C %(dir)s --numeric-owner -cjf '
+                                 '%(inst_path)s.tar.bz2 %(inst_name)s' % {
+                        'dir': self.get_build_prefix(),
+                        'inst_name': installer_name,
+                        'inst_path':self.build_path_of(installer_name)})
         finally:
             self.run_command("mv %(inst)s %(dst)s" % {
                 'dst': self.get_dst_prefix(),
@@ -852,7 +854,14 @@ class Linux_i686Manifest(LinuxManifest):
                 print "Skipping %s - not found" % libfile
                 pass
 
-        self.path("secondlife-stripped","bin/do-not-directly-run-secondlife-bin")
+            
+        if(self.args['buildtype'].lower() != 'debug'):
+            print "* packaging stripped viewer binary."
+            self.path("secondlife-stripped","bin/do-not-directly-run-secondlife-bin")
+        else:
+            print "* packaging un-stripped viewer binary."
+            self.path("secondlife-bin","bin/do-not-directly-run-secondlife-bin")
+
         self.path("../linux_crash_logger/linux-crash-logger-stripped","bin/linux-crash-logger.bin")
         self.path("../linux_updater/linux-updater-stripped", "bin/linux-updater.bin")
         self.path("../llplugin/slplugin/SLPlugin", "bin/SLPlugin")