Automated merge with http://hg.secondlife.com/viewer-development

17 files changed, 845 insertions, 134 deletions

diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt
index 5914c3551a..0bbdcfd6ff 100644
--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@@ -28,6 +28,8 @@ include_directories(
 set(llui_SOURCE_FILES
     llaccordionctrl.cpp
     llaccordionctrltab.cpp
+    llbadge.cpp
+    llbadgeowner.cpp
     llbutton.cpp
     llcheckboxctrl.cpp
     llclipboard.cpp
@@ -120,6 +122,8 @@ set(llui_HEADER_FILES
 
     llaccordionctrl.h
     llaccordionctrltab.h
+    llbadge.h
+    llbadgeowner.h
     llbutton.h
     llcallbackmap.h
     llcheckboxctrl.h
@@ -247,11 +251,11 @@ target_link_libraries(llui
     )
 
 # Add tests
-if (LL_TESTS)
-	include(LLAddBuildTest)
-	SET(llui_TEST_SOURCE_FILES
-		llurlmatch.cpp
-		llurlentry.cpp
-		)
-	LL_ADD_PROJECT_UNIT_TESTS(llui "${llui_TEST_SOURCE_FILES}")
-endif (LL_TESTS)
\ No newline at end of file
+if(LL_TESTS)
+  include(LLAddBuildTest)
+  SET(llui_TEST_SOURCE_FILES
+      llurlmatch.cpp
+      llurlentry.cpp
+      )
+  LL_ADD_PROJECT_UNIT_TESTS(llui "${llui_TEST_SOURCE_FILES}")
+endif(LL_TESTS)
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
index 9e4849c58b..6afe276379 100644
--- a/indra/llui/llaccordionctrltab.cpp
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -1022,7 +1022,7 @@ void	LLAccordionCtrlTab::updateLayout	( const LLRect& child_rect )
 	S32 panel_width = child_rect.getWidth();
 
 	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
-	if(mScrollbar->getVisible() != false)
+	if(mScrollbar && mScrollbar->getVisible() != false)
 	{
 		panel_top+=mScrollbar->getDocPos();
 		panel_width-=scrollbar_size;
diff --git a/indra/llui/llbadge.cpp b/indra/llui/llbadge.cpp
new file mode 100644
index 0000000000..c28a947a7f
--- /dev/null
+++ b/indra/llui/llbadge.cpp
@@ -0,0 +1,274 @@
+/** 
+ * @file llbadge.cpp
+ * @brief Implementation for badges
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#define LLBADGE_CPP
+#include "llbadge.h"
+
+#include "lluictrlfactory.h"
+
+
+static LLDefaultChildRegistry::Register<LLBadge> r("badge");
+
+// Compiler optimization, generate extern template
+template class LLBadge* LLView::getChild<class LLBadge>(const std::string& name, BOOL recurse) const;
+
+
+LLBadge::Params::Params()
+	: image("image")
+	, border_image("border_image")
+	, border_color("border_color")
+	, image_color("image_color")
+	, label("label")
+	, label_color("label_color")
+	, location("location", LLRelPos::TOP_LEFT)
+	, location_percent_hcenter("location_percent_hcenter")
+	, location_percent_vcenter("location_percent_vcenter")
+	, padding_horiz("padding_horiz")
+	, padding_vert("padding_vert")
+{
+	// We set a name here so the name isn't necessary in any xml files that use badges
+	name = "badge";
+}
+
+bool LLBadge::Params::equals(const Params& a) const
+{
+	bool comp = true;
+	
+	// skip owner in comparison on purpose
+	
+	comp &= (border_image() == a.border_image());
+	comp &= (border_color() == a.border_color());
+	comp &= (image() == a.image());
+	comp &= (image_color() == a.image_color());
+	comp &= (label() == a.label());
+	comp &= (label_color() == a.label_color());
+	comp &= (location() == a.location());
+	comp &= (location_percent_hcenter() == a.location_percent_hcenter());
+	comp &= (location_percent_vcenter() == a.location_percent_vcenter());
+	comp &= (padding_horiz() == a.padding_horiz());
+	comp &= (padding_vert() == a.padding_vert());
+	
+	return comp;
+}
+
+LLBadge::LLBadge(const LLBadge::Params& p)
+	: LLUICtrl(p)
+	, mOwner(p.owner)
+	, mBorderImage(p.border_image)
+	, mBorderColor(p.border_color)
+	, mGLFont(p.font)
+	, mImage(p.image)
+	, mImageColor(p.image_color)
+	, mLabel(p.label)
+	, mLabelColor(p.label_color)
+	, mLocation(p.location)
+	, mLocationPercentHCenter(0.5f)
+	, mLocationPercentVCenter(0.5f)
+	, mPaddingHoriz(p.padding_horiz)
+	, mPaddingVert(p.padding_vert)
+{
+	if (mImage.isNull())
+	{
+		llwarns << "Badge: " << getName() << " with no image!" << llendl;
+	}
+
+	//
+	// The following logic is to set the mLocationPercentHCenter and mLocationPercentVCenter
+	// based on the Location enum and our horizontal and vertical location percentages.  The
+	// draw code then uses this on the owner rectangle to compute the screen location for
+	// the badge.
+	//
+
+	if (!LLRelPos::IsCenter(mLocation))
+	{
+		F32 h_center = p.location_percent_hcenter * 0.01f;
+		F32 v_center = p.location_percent_vcenter * 0.01f;
+
+		if (LLRelPos::IsRight(mLocation))
+		{
+			mLocationPercentHCenter = 0.5f * (1.0f + h_center);
+		}
+		else if (LLRelPos::IsLeft(mLocation))
+		{
+			mLocationPercentHCenter = 0.5f * (1.0f - h_center);
+		}
+			
+		if (LLRelPos::IsTop(mLocation))
+		{
+			mLocationPercentVCenter = 0.5f * (1.0f + v_center);
+		}
+		else if (LLRelPos::IsBottom(mLocation))
+		{
+			mLocationPercentVCenter = 0.5f * (1.0f - v_center);
+		}
+	}
+}
+
+LLBadge::~LLBadge()
+{
+}
+
+void LLBadge::setLabel(const LLStringExplicit& label)
+{
+	mLabel = label;
+}
+
+//
+// This is a fallback function to render a rectangle for badges without a valid image
+//
+void renderBadgeBackground(F32 centerX, F32 centerY, F32 width, F32 height, const LLColor4U &color)
+{
+	gGL.pushUIMatrix();
+	gGL.loadUIIdentity();
+	gGL.setSceneBlendType(LLRender::BT_REPLACE);
+	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+	
+	gGL.color4ubv(color.mV);
+	gGL.texCoord2i(0, 0);
+	
+	F32 x = LLFontGL::sCurOrigin.mX + centerX - width * 0.5f;
+	F32 y = LLFontGL::sCurOrigin.mY + centerY - height * 0.5f;
+	
+	LLRectf screen_rect(llround(x),
+						llround(y),
+						llround(x) + width,
+						llround(y) + height);
+	
+	LLVector3 vertices[4];
+	vertices[0] = LLVector3(screen_rect.mRight, screen_rect.mTop,    1.0f);
+	vertices[1] = LLVector3(screen_rect.mLeft,  screen_rect.mTop,    1.0f);
+	vertices[2] = LLVector3(screen_rect.mLeft,  screen_rect.mBottom, 1.0f);
+	vertices[3] = LLVector3(screen_rect.mRight, screen_rect.mBottom, 1.0f);
+	
+	gGL.begin(LLRender::QUADS);
+	{
+		gGL.vertexBatchPreTransformed(vertices, 4);
+	}
+	gGL.end();
+	
+	gGL.popUIMatrix();
+}
+
+
+// virtual
+void LLBadge::draw()
+{
+	if (!mLabel.empty())
+	{
+		LLView* owner_view = mOwner.get();
+
+		if (owner_view)
+		{
+			//
+			// Calculate badge position based on owner
+			//
+			
+			LLRect owner_rect;
+			owner_view->localRectToOtherView(owner_view->getLocalRect(), & owner_rect, this);
+			
+			F32 badge_center_x = owner_rect.mLeft + owner_rect.getWidth() * mLocationPercentHCenter;
+			F32 badge_center_y = owner_rect.mBottom + owner_rect.getHeight() * mLocationPercentVCenter;
+
+			//
+			// Calculate badge size based on label text
+			//
+
+			LLWString badge_label_wstring = mLabel;
+			
+			S32 badge_label_begin_offset = 0;
+			S32 badge_char_length = S32_MAX;
+			S32 badge_pixel_length = S32_MAX;
+			F32 *right_position_out = NULL;
+			BOOL do_not_use_ellipses = false;
+
+			F32 badge_width = (2.0f * mPaddingHoriz) +
+				mGLFont->getWidthF32(badge_label_wstring.c_str(), badge_label_begin_offset, badge_char_length);
+
+			F32 badge_height = (2.0f * mPaddingVert) + mGLFont->getLineHeight();
+
+			//
+			// Draw button image, if available.
+			// Otherwise draw basic rectangular button.
+			//
+
+			F32 alpha = getDrawContext().mAlpha;
+
+			if (!mImage.isNull())
+			{
+				F32 badge_x = badge_center_x - badge_width * 0.5f;
+				F32 badge_y = badge_center_y - badge_height * 0.5f;
+			
+				mImage->drawSolid((S32) badge_x, (S32) badge_y, (S32) badge_width, (S32) badge_height, mImageColor % alpha);
+
+				if (!mBorderImage.isNull())
+				{
+					mBorderImage->drawSolid((S32) badge_x, (S32) badge_y, (S32) badge_width, (S32) badge_height, mBorderColor % alpha);
+				}
+			}
+			else
+			{
+				lldebugs << "No image for badge " << getName() << " on owner " << owner_view->getName() << llendl;
+				
+				renderBadgeBackground(badge_center_x, badge_center_y,
+									  badge_width, badge_height,
+									  mImageColor % alpha);
+			}
+
+			//
+			// Draw the label
+			//
+
+			mGLFont->render(badge_label_wstring, badge_label_begin_offset,
+							badge_center_x, badge_center_y,
+							mLabelColor % alpha,
+							LLFontGL::HCENTER, LLFontGL::VCENTER, // centered around the position
+							LLFontGL::NORMAL, // normal text (not bold, italics, etc.)
+							LLFontGL::DROP_SHADOW_SOFT,
+							badge_char_length, badge_pixel_length,
+							right_position_out, do_not_use_ellipses);
+		}
+	}
+}
+
+
+namespace LLInitParam
+{
+	void TypeValues<LLRelPos::Location>::declareValues()
+	{
+		declare("bottom",		LLRelPos::BOTTOM);
+		declare("bottom_left",	LLRelPos::BOTTOM_LEFT);
+		declare("bottom_right", LLRelPos::BOTTOM_RIGHT);
+		declare("center",		LLRelPos::CENTER);
+		declare("left",			LLRelPos::LEFT);
+		declare("right",		LLRelPos::RIGHT);
+		declare("top",			LLRelPos::TOP);
+		declare("top_left",		LLRelPos::TOP_LEFT);
+		declare("top_right",	LLRelPos::TOP_RIGHT);
+	}
+}
+
+
+// eof
diff --git a/indra/llui/llbadge.h b/indra/llui/llbadge.h
new file mode 100644
index 0000000000..0f923ef01b
--- /dev/null
+++ b/indra/llui/llbadge.h
@@ -0,0 +1,159 @@
+/** 
+ * @file llbadge.h
+ * @brief Header for badges
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLBADGE_H
+#define LL_LLBADGE_H
+
+#include <string>
+
+#include "lluicolor.h"
+#include "lluictrl.h"
+#include "llstring.h"
+#include "lluiimage.h"
+#include "llview.h"
+
+//
+// Declarations
+//
+
+class LLUICtrlFactory;
+class LLFontGL;
+
+//
+// Relative Position Alignment
+//
+
+namespace LLRelPos
+{
+	enum Location
+	{
+		CENTER	= 0,
+
+		LEFT	= (1 << 0),
+		RIGHT	= (1 << 1),
+
+		TOP		= (1 << 2),
+		BOTTOM	= (1 << 3),
+
+		BOTTOM_LEFT		= (BOTTOM | LEFT),
+		BOTTOM_RIGHT	= (BOTTOM | RIGHT),
+
+		TOP_LEFT		= (TOP | LEFT),
+		TOP_RIGHT		= (TOP | RIGHT),
+	};
+
+	inline bool IsBottom(Location relPos)	{ return (relPos & BOTTOM) == BOTTOM; }
+	inline bool IsCenter(Location relPos)	{ return (relPos == CENTER); }
+	inline bool IsLeft(Location relPos)		{ return (relPos & LEFT) == LEFT; }
+	inline bool IsRight(Location relPos)	{ return (relPos & RIGHT) == RIGHT; }
+	inline bool IsTop(Location relPos)		{ return (relPos & TOP) == TOP; }
+}
+
+// NOTE: This needs to occur before Optional<LLRelPos::Location> declaration for proper compilation.
+namespace LLInitParam
+{
+	template<>
+	struct TypeValues<LLRelPos::Location> : public TypeValuesHelper<LLRelPos::Location>
+	{
+		static void declareValues();
+	};
+}
+
+//
+// Classes
+//
+
+class LLBadge
+: public LLUICtrl
+{
+public:
+	struct Params 
+	: public LLInitParam::Block<Params, LLUICtrl::Params>
+	{
+		Optional< LLHandle<LLView> >	owner;	// Mandatory in code but not in xml
+		
+		Optional< LLUIImage* >			border_image;
+		Optional< LLUIColor >			border_color;
+
+		Optional< LLUIImage* >			image;
+		Optional< LLUIColor >			image_color;
+		
+		Optional< std::string >			label;
+		Optional< LLUIColor >			label_color;
+
+		Optional< LLRelPos::Location >	location;
+		Optional< U32 >					location_percent_hcenter;
+		Optional< U32 >					location_percent_vcenter;
+
+		Optional< F32 >					padding_horiz;
+		Optional< F32 >					padding_vert;
+		
+		Params();
+		
+		bool equals(const Params&) const;
+	};
+	
+protected:
+	friend class LLUICtrlFactory;
+	LLBadge(const Params& p);
+
+public:
+
+	~LLBadge();
+	
+	virtual void		draw();
+
+	const std::string	getLabel() const { return wstring_to_utf8str(mLabel); }
+	void				setLabel( const LLStringExplicit& label);
+
+private:
+	LLPointer< LLUIImage >	mBorderImage;
+	LLUIColor				mBorderColor;
+
+	const LLFontGL*			mGLFont;
+	
+	LLPointer< LLUIImage >	mImage;
+	LLUIColor				mImageColor;
+	
+	LLUIString				mLabel;
+	LLUIColor				mLabelColor;
+
+	LLRelPos::Location		mLocation;
+	F32						mLocationPercentHCenter;
+	F32						mLocationPercentVCenter;
+	
+	LLHandle< LLView >		mOwner;
+
+	F32						mPaddingHoriz;
+	F32						mPaddingVert;
+};
+
+// Build time optimization, generate once in .cpp file
+#ifndef LLBADGE_CPP
+extern template class LLBadge* LLView::getChild<class LLBadge>(const std::string& name, BOOL recurse) const;
+#endif
+
+#endif  // LL_LLBADGE_H
diff --git a/indra/llui/llbadgeowner.cpp b/indra/llui/llbadgeowner.cpp
new file mode 100644
index 0000000000..77f15567bf
--- /dev/null
+++ b/indra/llui/llbadgeowner.cpp
@@ -0,0 +1,126 @@
+/** 
+ * @file llbadgeowner.cpp
+ * @brief Class to manage badges attached to a UI control
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llbadgeowner.h"
+#include "llpanel.h"
+
+//
+// Classes
+//
+
+LLBadgeOwner::LLBadgeOwner(LLHandle< LLView > viewHandle)
+	: mBadge(NULL)
+	, mBadgeOwnerView(viewHandle)
+{
+}
+
+void LLBadgeOwner::initBadgeParams(const LLBadge::Params& p)
+{
+	if (!p.equals(LLUICtrlFactory::getDefaultParams<LLBadge>()))
+	{
+		mBadge = createBadge(p);
+	}
+}
+
+void LLBadgeOwner::setBadgeLabel(const LLStringExplicit& label)
+{
+	if (mBadge == NULL)
+	{
+		mBadge = createBadge(LLUICtrlFactory::getDefaultParams<LLBadge>());
+
+		addBadgeToParentPanel();
+	}
+
+	if (mBadge)
+	{
+		mBadge->setLabel(label);
+
+		//
+		// Push the badge to the front so it renders on top
+		//
+
+		LLView * parent = mBadge->getParent();
+
+		if (parent)
+		{
+			parent->sendChildToFront(mBadge);
+		}
+	}
+}
+
+void LLBadgeOwner::setBadgeVisibility(bool visible)
+{
+	if (mBadge)
+	{
+		mBadge->setVisible(visible);
+	}
+}
+
+void LLBadgeOwner::addBadgeToParentPanel()
+{
+	LLView * owner_view = mBadgeOwnerView.get();
+	
+	if (mBadge && owner_view)
+	{
+		// Badge parent is badge owner by default
+		LLView * badge_parent = owner_view;
+
+		// Find the appropriate parent for the badge
+		LLView * parent = owner_view->getParent();
+
+		while (parent)
+		{
+			LLPanel * parent_panel = dynamic_cast<LLPanel *>(parent);
+
+			if (parent_panel && parent_panel->acceptsBadge())
+			{
+				badge_parent = parent;
+				break;
+			}
+
+			parent = parent->getParent();
+		}
+
+		if (badge_parent)
+		{
+			badge_parent->addChild(mBadge);
+		}
+		else
+		{
+			llwarns << "Unable to find parent panel for badge " << mBadge->getName() << " on " << owner_view->getName() << llendl;
+		}
+	}
+}
+
+LLBadge* LLBadgeOwner::createBadge(const LLBadge::Params& p)
+{
+	LLBadge::Params badge_params(p);
+	badge_params.owner = mBadgeOwnerView;
+
+	return LLUICtrlFactory::create<LLBadge>(badge_params);
+}
diff --git a/indra/llui/llbadgeowner.h b/indra/llui/llbadgeowner.h
new file mode 100644
index 0000000000..a2399189a5
--- /dev/null
+++ b/indra/llui/llbadgeowner.h
@@ -0,0 +1,61 @@
+/** 
+ * @file llbadgeowner.h
+ * @brief Header for badge owners
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLBADGEOWNER_H
+#define LL_LLBADGEOWNER_H
+
+#include "llbadge.h"
+#include "llview.h"
+
+//
+// Classes
+//
+
+class LLBadgeOwner
+{
+public:
+
+	LLBadgeOwner(LLHandle< LLView > viewHandle);
+
+	void initBadgeParams(const LLBadge::Params& p);
+	void addBadgeToParentPanel();
+	
+	bool badgeHasParent() const { return (mBadge && mBadge->getParent()); }
+
+	void setBadgeLabel(const LLStringExplicit& label);
+	void setBadgeVisibility(bool visible);
+
+private:
+
+	LLBadge* createBadge(const LLBadge::Params& p);
+
+private:
+
+	LLBadge*			mBadge;
+	LLHandle< LLView >	mBadgeOwnerView;
+};
+
+#endif  // LL_LLBADGEOWNER_H
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 45ceaff696..7b015bd576 100644
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -99,7 +99,9 @@ LLButton::Params::Params()
 	scale_image("scale_image", true),
 	hover_glow_amount("hover_glow_amount"),
 	commit_on_return("commit_on_return", true),
-	use_draw_context_alpha("use_draw_context_alpha", true)
+	use_draw_context_alpha("use_draw_context_alpha", true),
+	badge("badge"),
+	handle_right_mouse("handle_right_mouse")
 {
 	addSynonym(is_toggle, "toggle");
 	held_down_delay.seconds = 0.5f;
@@ -109,6 +111,7 @@ LLButton::Params::Params()
 
 LLButton::LLButton(const LLButton::Params& p)
 :	LLUICtrl(p),
+	LLBadgeOwner(LLView::getHandle()),
 	mMouseDownFrame(0),
 	mMouseHeldDownCount(0),
 	mBorderEnabled( FALSE ),
@@ -160,8 +163,8 @@ LLButton::LLButton(const LLButton::Params& p)
 	mMouseDownSignal(NULL),
 	mMouseUpSignal(NULL),
 	mHeldDownSignal(NULL),
-	mUseDrawContextAlpha(p.use_draw_context_alpha)
-
+	mUseDrawContextAlpha(p.use_draw_context_alpha),
+	mHandleRightMouse(p.handle_right_mouse)
 {
 	static LLUICachedControl<S32> llbutton_orig_h_pad ("UIButtonOrigHPad", 0);
 	static Params default_params(LLUICtrlFactory::getDefaultParams<LLButton>());
@@ -244,6 +247,11 @@ LLButton::LLButton(const LLButton::Params& p)
 	{
 		setHeldDownCallback(initCommitCallback(p.mouse_held_callback));
 	}
+
+	if (p.badge.isProvided())
+	{
+		LLBadgeOwner::initBadgeParams(p.badge());
+	}
 }
 
 LLButton::~LLButton()
@@ -327,8 +335,12 @@ boost::signals2::connection LLButton::setHeldDownCallback( button_callback_t cb,
 BOOL LLButton::postBuild()
 {
 	autoResize();
-	return TRUE;
+
+	addBadgeToParentPanel();
+
+	return LLUICtrl::postBuild();
 }
+
 BOOL LLButton::handleUnicodeCharHere(llwchar uni_char)
 {
 	BOOL handled = FALSE;
@@ -447,7 +459,7 @@ BOOL LLButton::handleMouseUp(S32 x, S32 y, MASK mask)
 
 BOOL	LLButton::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	if (!childrenHandleRightMouseDown(x, y, mask))
+	if (mHandleRightMouse && !childrenHandleRightMouseDown(x, y, mask))
 	{
 		// Route future Mouse messages here preemptively.  (Release on mouse up.)
 		gFocusMgr.setMouseCapture( this );
@@ -460,37 +472,42 @@ BOOL	LLButton::handleRightMouseDown(S32 x, S32 y, MASK mask)
 //		if (pointInView(x, y))
 //		{
 //		}
+		// send the mouse down signal
+		LLUICtrl::handleRightMouseDown(x,y,mask);
+		// *TODO: Return result of LLUICtrl call above?  Should defer to base class
+		// but this might change the mouse handling of existing buttons in a bad way
+		// if they are not mouse opaque.
 	}
-	// send the mouse down signal
-	LLUICtrl::handleRightMouseDown(x,y,mask);
-	// *TODO: Return result of LLUICtrl call above?  Should defer to base class
-	// but this might change the mouse handling of existing buttons in a bad way
-	// if they are not mouse opaque.
+
 	return TRUE;
 }
 
 BOOL	LLButton::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
-	// We only handle the click if the click both started and ended within us
-	if( hasMouseCapture() )
+	if (mHandleRightMouse)
 	{
-		// Always release the mouse
-		gFocusMgr.setMouseCapture( NULL );
+		// We only handle the click if the click both started and ended within us
+		if( hasMouseCapture() )
+		{
+			// Always release the mouse
+			gFocusMgr.setMouseCapture( NULL );
 
-//		if (pointInView(x, y))
-//		{
-//			mRightMouseUpSignal(this, x,y,mask);
-//		}
-	}
-	else 
-	{
-		childrenHandleRightMouseUp(x, y, mask);
+	//		if (pointInView(x, y))
+	//		{
+	//			mRightMouseUpSignal(this, x,y,mask);
+	//		}
+		}
+		else 
+		{
+			childrenHandleRightMouseUp(x, y, mask);
+		}
+	
+		// send the mouse up signal
+		LLUICtrl::handleRightMouseUp(x,y,mask);
+		// *TODO: Return result of LLUICtrl call above?  Should defer to base class
+		// but this might change the mouse handling of existing buttons in a bad way.
+		// if they are not mouse opaque.
 	}
-	// send the mouse up signal
-	LLUICtrl::handleRightMouseUp(x,y,mask);
-	// *TODO: Return result of LLUICtrl call above?  Should defer to base class
-	// but this might change the mouse handling of existing buttons in a bad way.
-	// if they are not mouse opaque.
 	return TRUE;
 }
 
diff --git a/indra/llui/llbutton.h b/indra/llui/llbutton.h
index 0cfc393e05..5968916006 100644
--- a/indra/llui/llbutton.h
+++ b/indra/llui/llbutton.h
@@ -27,6 +27,8 @@
 #ifndef LL_LLBUTTON_H
 #define LL_LLBUTTON_H
 
+#include "lluuid.h"
+#include "llbadgeowner.h"
 #include "llcontrol.h"
 #include "lluictrl.h"
 #include "v4color.h"
@@ -52,15 +54,13 @@ S32 round_up(S32 grid, S32 value);
 
 
 class LLUICtrlFactory;
-class LLUIImage;
-class LLUUID;
 
 //
 // Classes
 //
 
 class LLButton
-: public LLUICtrl
+: public LLUICtrl, public LLBadgeOwner
 {
 public:
 	struct Params 
@@ -125,7 +125,11 @@ public:
 		Optional<F32>				hover_glow_amount;
 		Optional<TimeIntervalParam>	held_down_delay;
 
-		Optional<bool>			use_draw_context_alpha;
+		Optional<bool>				use_draw_context_alpha;
+		
+		Optional<LLBadge::Params>	badge;
+
+		Optional<bool>				handle_right_mouse;
 
 		Params();
 	};
@@ -249,7 +253,7 @@ public:
 	void			setImageDisabledSelected(LLPointer<LLUIImage> image);
 	void			setImageFlash(LLPointer<LLUIImage> image);
 	void			setImagePressed(LLPointer<LLUIImage> image);
-
+	
 	void			setCommitOnReturn(BOOL commit) { mCommitOnReturn = commit; }
 	BOOL			getCommitOnReturn() const { return mCommitOnReturn; }
 
@@ -357,6 +361,8 @@ private:
 	bool						mForcePressedState;
 
 	LLFrameTimer				mFlashingTimer;
+
+	bool						mHandleRightMouse;
 };
 
 // Build time optimization, generate once in .cpp file
diff --git a/indra/llui/lllayoutstack.cpp b/indra/llui/lllayoutstack.cpp
index 9b6830a816..6a91ec56e4 100644
--- a/indra/llui/lllayoutstack.cpp
+++ b/indra/llui/lllayoutstack.cpp
@@ -49,6 +49,8 @@ void LLLayoutStack::OrientationNames::declareValues()
 //
 LLLayoutPanel::LLLayoutPanel(const Params& p)	
 :	LLPanel(p),
+	mExpandedMinDimSpecified(false),
+	mExpandedMinDim(p.min_dim),
  	mMinDim(p.min_dim), 
  	mMaxDim(p.max_dim), 
  	mAutoResize(p.auto_resize),
@@ -58,6 +60,13 @@ LLLayoutPanel::LLLayoutPanel(const Params& p)
 	mVisibleAmt(1.f), // default to fully visible
 	mResizeBar(NULL) 
 {
+	// Set the expanded min dim if it is provided, otherwise it gets the p.min_dim value
+	if (p.expanded_min_dim.isProvided())
+	{
+		mExpandedMinDimSpecified = true;
+		mExpandedMinDim = p.expanded_min_dim();
+	}
+	
 	// panels initialized as hidden should not start out partially visible
 	if (!getVisible())
 	{
@@ -78,20 +87,20 @@ LLLayoutPanel::~LLLayoutPanel()
 	delete mResizeBar;
 	mResizeBar = NULL;
 }
-	
+
 F32 LLLayoutPanel::getCollapseFactor(LLLayoutStack::ELayoutOrientation orientation)
 {
 	if (orientation == LLLayoutStack::HORIZONTAL)
 	{
 		F32 collapse_amt = 
-		clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, (F32)mMinDim / (F32)llmax(1, getRect().getWidth()));
+			clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, (F32)getRelevantMinDim() / (F32)llmax(1, getRect().getWidth()));
 		return mVisibleAmt * collapse_amt;
 	}
 	else
 	{
-			F32 collapse_amt = 
-			clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, llmin(1.f, (F32)mMinDim / (F32)llmax(1, getRect().getHeight())));
-			return mVisibleAmt * collapse_amt;
+		F32 collapse_amt = 
+			clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, llmin(1.f, (F32)getRelevantMinDim() / (F32)llmax(1, getRect().getHeight())));
+		return mVisibleAmt * collapse_amt;
 	}
 }
 
@@ -182,14 +191,14 @@ BOOL LLLayoutStack::postBuild()
 }
 
 bool LLLayoutStack::addChild(LLView* child, S32 tab_group)
-		{
+{
 	LLLayoutPanel* panelp = dynamic_cast<LLLayoutPanel*>(child);
-			if (panelp)
-			{
+	if (panelp)
+	{
 		mPanels.push_back(panelp);
-			}
+	}
 	return LLView::addChild(child, tab_group);
-		}
+}
 
 
 S32 LLLayoutStack::getDefaultHeight(S32 cur_height)
@@ -281,9 +290,9 @@ bool LLLayoutStack::getPanelMinSize(const std::string& panel_name, S32* min_dimp
 {
 	LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
 
-	if (panel)
+	if (panel && min_dimp)
 	{
-		if (min_dimp) *min_dimp = panel->mMinDim;
+		*min_dimp = panel->getRelevantMinDim();
 	}
 
 	return NULL != panel;
@@ -316,23 +325,23 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 	e_panel_list_t::iterator panel_it;
 	for (panel_it = mPanels.begin(); panel_it != mPanels.end();	++panel_it)
 	{
-		LLPanel* panelp = (*panel_it);
+		LLLayoutPanel* panelp = (*panel_it);
 		if (panelp->getVisible()) 
 		{
 			if (mAnimate)
 			{
 				if (!mAnimatedThisFrame)
 				{
-					(*panel_it)->mVisibleAmt = lerp((*panel_it)->mVisibleAmt, 1.f, LLCriticalDamp::getInterpolant(mOpenTimeConstant));
-					if ((*panel_it)->mVisibleAmt > 0.99f)
+					panelp->mVisibleAmt = lerp(panelp->mVisibleAmt, 1.f, LLCriticalDamp::getInterpolant(mOpenTimeConstant));
+					if (panelp->mVisibleAmt > 0.99f)
 					{
-						(*panel_it)->mVisibleAmt = 1.f;
+						panelp->mVisibleAmt = 1.f;
 					}
 				}
 			}
 			else
 			{
-				(*panel_it)->mVisibleAmt = 1.f;
+				panelp->mVisibleAmt = 1.f;
 			}
 		}
 		else // not visible
@@ -341,36 +350,36 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 			{
 				if (!mAnimatedThisFrame)
 				{
-					(*panel_it)->mVisibleAmt = lerp((*panel_it)->mVisibleAmt, 0.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
-					if ((*panel_it)->mVisibleAmt < 0.001f)
+					panelp->mVisibleAmt = lerp(panelp->mVisibleAmt, 0.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
+					if (panelp->mVisibleAmt < 0.001f)
 					{
-						(*panel_it)->mVisibleAmt = 0.f;
+						panelp->mVisibleAmt = 0.f;
 					}
 				}
 			}
 			else
 			{
-				(*panel_it)->mVisibleAmt = 0.f;
+				panelp->mVisibleAmt = 0.f;
 			}
 		}
 
-		if ((*panel_it)->mCollapsed)
+		if (panelp->mCollapsed)
 		{
-			(*panel_it)->mCollapseAmt = lerp((*panel_it)->mCollapseAmt, 1.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
+			panelp->mCollapseAmt = lerp(panelp->mCollapseAmt, 1.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
 		}
 		else
 		{
-			(*panel_it)->mCollapseAmt = lerp((*panel_it)->mCollapseAmt, 0.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
+			panelp->mCollapseAmt = lerp(panelp->mCollapseAmt, 0.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
 		}
 
 		if (mOrientation == HORIZONTAL)
 		{
 			// enforce minimize size constraint by default
-			if (panelp->getRect().getWidth() < (*panel_it)->mMinDim)
+			if (panelp->getRect().getWidth() < panelp->getRelevantMinDim())
 			{
-				panelp->reshape((*panel_it)->mMinDim, panelp->getRect().getHeight());
+				panelp->reshape(panelp->getRelevantMinDim(), panelp->getRect().getHeight());
 			}
-        	total_width += llround(panelp->getRect().getWidth() * (*panel_it)->getCollapseFactor(mOrientation));
+        	total_width += llround(panelp->getRect().getWidth() * panelp->getCollapseFactor(mOrientation));
         	// want n-1 panel gaps for n panels
 			if (panel_it != mPanels.begin())
 			{
@@ -380,11 +389,11 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 		else //VERTICAL
 		{
 			// enforce minimize size constraint by default
-			if (panelp->getRect().getHeight() < (*panel_it)->mMinDim)
+			if (panelp->getRect().getHeight() < panelp->getRelevantMinDim())
 			{
-				panelp->reshape(panelp->getRect().getWidth(), (*panel_it)->mMinDim);
+				panelp->reshape(panelp->getRect().getWidth(), panelp->getRelevantMinDim());
 			}
-			total_height += llround(panelp->getRect().getHeight() * (*panel_it)->getCollapseFactor(mOrientation));
+			total_height += llround(panelp->getRect().getHeight() * panelp->getCollapseFactor(mOrientation));
 			if (panel_it != mPanels.begin())
 			{
 				total_height += mPanelSpacing;
@@ -403,34 +412,23 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 			continue;
 		}
 
+		S32 relevant_dimension = (mOrientation == HORIZONTAL) ? (*panel_it)->getRect().getWidth() : (*panel_it)->getRect().getHeight();
+		S32 relevant_min = (*panel_it)->getRelevantMinDim();
+		
 		// if currently resizing a panel or the panel is flagged as not automatically resizing
 		// only track total available headroom, but don't use it for automatic resize logic
 		if ((*panel_it)->mResizeBar->hasMouseCapture() 
 			|| (!(*panel_it)->mAutoResize 
 				&& !force_resize))
 		{
-			if (mOrientation == HORIZONTAL)
-			{
-				shrink_headroom_total += (*panel_it)->getRect().getWidth() - (*panel_it)->mMinDim;
-			}
-			else //VERTICAL
-			{
-				shrink_headroom_total += (*panel_it)->getRect().getHeight() - (*panel_it)->mMinDim;
-			}
+			shrink_headroom_total += relevant_dimension - relevant_min;
 		}
 		else
 		{
 			num_resizable_panels++;
-			if (mOrientation == HORIZONTAL)
-			{
-				shrink_headroom_available += (*panel_it)->getRect().getWidth() - (*panel_it)->mMinDim;
-				shrink_headroom_total += (*panel_it)->getRect().getWidth() - (*panel_it)->mMinDim;
-			}
-			else //VERTICAL
-			{
-				shrink_headroom_available += (*panel_it)->getRect().getHeight() - (*panel_it)->mMinDim;
-				shrink_headroom_total += (*panel_it)->getRect().getHeight() - (*panel_it)->mMinDim;
-			}
+			
+			shrink_headroom_available += relevant_dimension - relevant_min;
+			shrink_headroom_total += relevant_dimension - relevant_min;
 		}
 	}
 
@@ -452,27 +450,28 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 
 	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
 	{
-		LLPanel* panelp = (*panel_it);
+		LLLayoutPanel* panelp = (*panel_it);
 
 		S32 cur_width = panelp->getRect().getWidth();
 		S32 cur_height = panelp->getRect().getHeight();
 		S32 new_width = cur_width;
-		S32 new_height = cur_height; 
+		S32 new_height = cur_height;
+		S32 relevant_min = panelp->getRelevantMinDim();
 
 		if (mOrientation == HORIZONTAL)
 		{
-			new_width = llmax((*panel_it)->mMinDim, new_width);
+			new_width = llmax(relevant_min, new_width);
 		}
 		else
 		{
-			new_height = llmax((*panel_it)->mMinDim, new_height);
+			new_height = llmax(relevant_min, new_height);
 		}
 		S32 delta_size = 0;
 
 		// if panel can automatically resize (not animating, and resize flag set)...
-		if ((*panel_it)->getCollapseFactor(mOrientation) == 1.f 
-			&& (force_resize || (*panel_it)->mAutoResize) 
-			&& !(*panel_it)->mResizeBar->hasMouseCapture()) 
+		if (panelp->getCollapseFactor(mOrientation) == 1.f 
+			&& (force_resize || panelp->mAutoResize) 
+			&& !panelp->mResizeBar->hasMouseCapture()) 
 		{
 			if (mOrientation == HORIZONTAL)
 			{
@@ -481,8 +480,8 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 				{
 					// shrink proportionally to amount over minimum
 					// so we can do this in one pass
-					delta_size = (shrink_headroom_available > 0) ? llround((F32)pixels_to_distribute * ((F32)(cur_width - (*panel_it)->mMinDim) / (F32)shrink_headroom_available)) : 0;
-					shrink_headroom_available -= (cur_width - (*panel_it)->mMinDim);
+					delta_size = (shrink_headroom_available > 0) ? llround((F32)pixels_to_distribute * ((F32)(cur_width - relevant_min) / (F32)shrink_headroom_available)) : 0;
+					shrink_headroom_available -= (cur_width - relevant_min);
 				}
 				else
 				{
@@ -491,7 +490,7 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 					num_resizable_panels--;
 				}
 				pixels_to_distribute -= delta_size;
-				new_width = llmax((*panel_it)->mMinDim, cur_width + delta_size);
+				new_width = llmax(relevant_min, cur_width + delta_size);
 			}
 			else
 			{
@@ -504,8 +503,8 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 				{
 					// shrink proportionally to amount over minimum
 					// so we can do this in one pass
-					delta_size = (shrink_headroom_available > 0) ? llround((F32)pixels_to_distribute * ((F32)(cur_height - (*panel_it)->mMinDim) / (F32)shrink_headroom_available)) : 0;
-					shrink_headroom_available -= (cur_height - (*panel_it)->mMinDim);
+					delta_size = (shrink_headroom_available > 0) ? llround((F32)pixels_to_distribute * ((F32)(cur_height - relevant_min) / (F32)shrink_headroom_available)) : 0;
+					shrink_headroom_available -= (cur_height - relevant_min);
 				}
 				else
 				{
@@ -513,7 +512,7 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 					num_resizable_panels--;
 				}
 				pixels_to_distribute -= delta_size;
-				new_height = llmax((*panel_it)->mMinDim, cur_height + delta_size);
+				new_height = llmax(relevant_min, cur_height + delta_size);
 			}
 			else
 			{
@@ -566,19 +565,20 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
 	LLLayoutPanel* last_resizeable_panel = NULL;
 	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
 	{
-		LLPanel* panelp = (*panel_it);
+		LLLayoutPanel* panelp = (*panel_it);
+		S32 relevant_min = panelp->getRelevantMinDim();
 
 		if (mOrientation == HORIZONTAL)
 		{
 			(*panel_it)->mResizeBar->setResizeLimits(
-				(*panel_it)->mMinDim, 
-				(*panel_it)->mMinDim + shrink_headroom_total);
+				relevant_min, 
+				relevant_min + shrink_headroom_total);
 		}
 		else //VERTICAL
 		{
 			(*panel_it)->mResizeBar->setResizeLimits(
-				(*panel_it)->mMinDim, 
-				(*panel_it)->mMinDim + shrink_headroom_total);
+				relevant_min, 
+				relevant_min + shrink_headroom_total);
 		}
 
 		// toggle resize bars based on panel visibility, resizability, etc
@@ -658,7 +658,7 @@ void LLLayoutStack::calcMinExtents()
 	{
 		if (mOrientation == HORIZONTAL)
 		{
-            mMinWidth += (*panel_it)->mMinDim;
+            mMinWidth += (*panel_it)->getRelevantMinDim();
 			if (panel_it != mPanels.begin())
 			{
 				mMinWidth += mPanelSpacing;
@@ -666,7 +666,7 @@ void LLLayoutStack::calcMinExtents()
 		}
 		else //VERTICAL
 		{
-			mMinHeight += (*panel_it)->mMinDim;
+			mMinHeight += (*panel_it)->getRelevantMinDim();
 			if (panel_it != mPanels.begin())
 			{
 				mMinHeight += mPanelSpacing;
@@ -688,7 +688,7 @@ void LLLayoutStack::createResizeBars()
 			LLResizeBar::Params resize_params;
 			resize_params.name("resize");
 			resize_params.resizing_view(lp);
-			resize_params.min_size(lp->mMinDim);
+			resize_params.min_size(lp->getRelevantMinDim());
 			resize_params.side(side);
 			resize_params.snapping_enabled(false);
 			LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
diff --git a/indra/llui/lllayoutstack.h b/indra/llui/lllayoutstack.h
index 4ac8ef0ee9..d8ef0aeaca 100644
--- a/indra/llui/lllayoutstack.h
+++ b/indra/llui/lllayoutstack.h
@@ -30,10 +30,10 @@
 
 #include "llpanel.h"
 
-class LLPanel;
 
 class LLLayoutPanel;
 
+
 class LLLayoutStack : public LLView, public LLInstanceTracker<LLLayoutStack>
 {
 public:
@@ -149,6 +149,7 @@ private:
 	F32 mCloseTimeConstant;
 }; // end class LLLayoutStack
 
+
 class LLLayoutPanel : public LLPanel
 {
 friend class LLLayoutStack;
@@ -156,13 +157,15 @@ friend class LLUICtrlFactory;
 public:
 	struct Params : public LLInitParam::Block<Params, LLPanel::Params>
 	{
-		Optional<S32>			min_dim,
+		Optional<S32>			expanded_min_dim,
+								min_dim,
 								max_dim;
 		Optional<bool>			user_resize,
 								auto_resize;
 
 		Params()
-		:	min_dim("min_dim", 0),
+		:	expanded_min_dim("expanded_min_dim", 0),
+			min_dim("min_dim", 0),
 			max_dim("max_dim", 0),
 			user_resize("user_resize", true),
 			auto_resize("auto_resize", true)
@@ -177,15 +180,36 @@ public:
 	~LLLayoutPanel();
 
 	void initFromParams(const Params& p);
-	void setMinDim(S32 value) { mMinDim = value; }
+
+	S32 getMinDim() const { return mMinDim; }
+	void setMinDim(S32 value) { mMinDim = value; if (!mExpandedMinDimSpecified) mExpandedMinDim = value; }
+
+	S32 getMaxDim() const { return mMaxDim; }
 	void setMaxDim(S32 value) { mMaxDim = value; }
 
-protected:
-	LLLayoutPanel(const Params& p)	;
+	S32 getExpandedMinDim() const { return mExpandedMinDim; }
+	void setExpandedMinDim(S32 value) { mExpandedMinDim = value; mExpandedMinDimSpecified = true; }
+	
+	S32 getRelevantMinDim() const
+	{
+		S32 min_dim = mMinDim;
+		
+		if (!mCollapsed)
+		{
+			min_dim = mExpandedMinDim;
+		}
+		
+		return min_dim;
+	}
 
+protected:
+	LLLayoutPanel(const Params& p);
 	
 	F32 getCollapseFactor(LLLayoutStack::ELayoutOrientation orientation);
 
+	bool mExpandedMinDimSpecified;
+	S32 mExpandedMinDim;
+	
 	S32 mMinDim;
 	S32 mMaxDim;
 	BOOL mAutoResize;
diff --git a/indra/llui/llloadingindicator.h b/indra/llui/llloadingindicator.h
index 4c47cc267c..7c44478848 100644
--- a/indra/llui/llloadingindicator.h
+++ b/indra/llui/llloadingindicator.h
@@ -86,6 +86,8 @@ public:
 	 */
 	void start();
 
+	void reset() { mCurImageIdx = 0; }
+
 private:
 	LLLoadingIndicator(const Params&);
 	void initFromParams(const Params&);
diff --git a/indra/llui/llpanel.cpp b/indra/llui/llpanel.cpp
index b2383106a8..1dcdd79efa 100644
--- a/indra/llui/llpanel.cpp
+++ b/indra/llui/llpanel.cpp
@@ -87,7 +87,8 @@ LLPanel::Params::Params()
 	filename("filename"),
 	class_name("class"),
 	help_topic("help_topic"),
-	visible_callback("visible_callback")
+	visible_callback("visible_callback"),
+	accepts_badge("accepts_badge")
 {
 	name = "panel";
 	addSynonym(background_visible, "bg_visible");
@@ -113,7 +114,8 @@ LLPanel::LLPanel(const LLPanel::Params& p)
 	mCommitCallbackRegistrar(false),
 	mEnableCallbackRegistrar(false),
 	mXMLFilename(p.filename),
-	mVisibleSignal(NULL)
+	mVisibleSignal(NULL),
+	mAcceptsBadge(p.accepts_badge)
 	// *NOTE: Be sure to also change LLPanel::initFromParams().  We have too
 	// many classes derived from LLPanel to retrofit them all to pass in params.
 {
@@ -485,6 +487,8 @@ void LLPanel::initFromParams(const LLPanel::Params& p)
 	mBgAlphaImage = p.bg_alpha_image();
 	mBgOpaqueImageOverlay = p.bg_opaque_image_overlay;
 	mBgAlphaImageOverlay = p.bg_alpha_image_overlay;
+
+	mAcceptsBadge = p.accepts_badge;
 }
 
 static LLFastTimer::DeclareTimer FTM_PANEL_SETUP("Panel Setup");
diff --git a/indra/llui/llpanel.h b/indra/llui/llpanel.h
index 7bbbeaf709..67674fab7e 100644
--- a/indra/llui/llpanel.h
+++ b/indra/llui/llpanel.h
@@ -89,6 +89,8 @@ public:
 		Multiple<LocalizedString>	strings;
 		
 		Optional<CommitCallbackParam> visible_callback;
+
+		Optional<bool>			accepts_badge;
 		
 		Params();
 	};
@@ -250,6 +252,8 @@ public:
 	
 	boost::signals2::connection setVisibleCallback( const commit_signal_t::slot_type& cb );
 
+	bool acceptsBadge() const { return mAcceptsBadge; }
+
 protected:
 	// Override to set not found list
 	LLButton*		getDefaultButton() { return mDefaultBtn; }
@@ -264,6 +268,7 @@ protected:
 	static factory_stack_t	sFactoryStack;
 	
 private:
+	bool			mAcceptsBadge;
 	BOOL			mBgVisible;				// any background at all?
 	BOOL			mBgOpaque;				// use opaque color or image
 	LLUIColor		mBgOpaqueColor;
diff --git a/indra/llui/lluictrl.cpp b/indra/llui/lluictrl.cpp
index 0a06b5e74f..d58df5801b 100644
--- a/indra/llui/lluictrl.cpp
+++ b/indra/llui/lluictrl.cpp
@@ -68,6 +68,7 @@ LLUICtrl::ControlVisibility::ControlVisibility()
 LLUICtrl::Params::Params()
 :	tab_stop("tab_stop", true),
 	chrome("chrome", false),
+	requests_front("requests_front", false),
 	label("label"),
 	initial_value("value"),
 	init_callback("init_callback"),
@@ -96,9 +97,10 @@ const LLUICtrl::Params& LLUICtrl::getDefaultParams()
 
 LLUICtrl::LLUICtrl(const LLUICtrl::Params& p, const LLViewModelPtr& viewmodel) 
 :	LLView(p),
-	mTentative(FALSE),
 	mIsChrome(FALSE),
+	mRequestsFront(p.requests_front),
 	mTabStop(FALSE),
+	mTentative(FALSE),
     mViewModel(viewmodel),
 	mControlVariable(NULL),
 	mEnabledControlVariable(NULL),
@@ -123,6 +125,8 @@ void LLUICtrl::initFromParams(const Params& p)
 {
 	LLView::initFromParams(p);
 
+	mRequestsFront = p.requests_front;
+
 	setIsChrome(p.chrome);
 	setControlName(p.control_name);
 	if(p.enabled_controls.isProvided())
@@ -403,6 +407,36 @@ LLViewModel* LLUICtrl::getViewModel() const
 	return mViewModel;
 }
 
+//virtual
+BOOL LLUICtrl::postBuild()
+{
+	//
+	// Find all of the children that want to be in front and move them to the front
+	//
+
+	if (getChildCount() > 0)
+	{
+		std::vector<LLUICtrl*> childrenToMoveToFront;
+
+		for (LLView::child_list_const_iter_t child_it = beginChild(); child_it != endChild(); ++child_it)
+		{
+			LLUICtrl* uictrl = dynamic_cast<LLUICtrl*>(*child_it);
+
+			if (uictrl && uictrl->mRequestsFront)
+			{
+				childrenToMoveToFront.push_back(uictrl);
+			}
+		}
+
+		for (std::vector<LLUICtrl*>::iterator it = childrenToMoveToFront.begin(); it != childrenToMoveToFront.end(); ++it)
+		{
+			sendChildToFront(*it);
+		}
+	}
+
+	return LLView::postBuild();
+}
+
 bool LLUICtrl::setControlValue(const LLSD& value)
 {
 	if (mControlVariable)
diff --git a/indra/llui/lluictrl.h b/indra/llui/lluictrl.h
index b37e9f6b1b..09bed9b958 100644
--- a/indra/llui/lluictrl.h
+++ b/indra/llui/lluictrl.h
@@ -94,7 +94,8 @@ public:
 	{
 		Optional<std::string>			label;
 		Optional<bool>					tab_stop,
-										chrome;
+										chrome,
+										requests_front;
 		Optional<LLSD>					initial_value;
 
 		Optional<CommitCallbackParam>	init_callback,
@@ -143,6 +144,8 @@ protected:
 	virtual LLViewModel* getViewModel() const;
     // We shouldn't ever need to set this directly
     //virtual void    setViewModel(const LLViewModelPtr&);
+
+	virtual BOOL	postBuild();
 	
 public:
 	// LLView interface
@@ -301,8 +304,9 @@ protected:
 
 private:
 
-	BOOL			mTabStop;
 	BOOL			mIsChrome;
+	BOOL			mRequestsFront;
+	BOOL			mTabStop;
 	BOOL			mTentative;
 	LLRootHandle<LLUICtrl> mUICtrlHandle;
 
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 245126d178..8803d106ba 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -1299,15 +1299,7 @@ void LLView::drawChildren()
 {
 	if (!mChildList.empty())
 	{
-		static const LLRect* rootRect = NULL;
-		
-		if (!mParentView)
-		{
-			rootRect = &mRect;
-		}
-
-		LLRect screenRect;
-
+		LLView* rootp = LLUI::getRootView();		
 		++sDepth;
 
 		for (child_list_reverse_iter_t child_iter = mChildList.rbegin(); child_iter != mChildList.rend();)  // ++child_iter)
@@ -1317,9 +1309,8 @@ void LLView::drawChildren()
 
 			if (viewp->getVisible() && viewp->getRect().isValid())
 			{
-				// Only draw views that are within the root view
-				localRectToScreen(viewp->getRect(),&screenRect);
-				if ( rootRect->overlaps(screenRect)  && LLUI::sDirtyRect.overlaps(screenRect))
+				LLRect screen_rect = viewp->calcScreenRect();
+				if ( rootp->getLocalRect().overlaps(screen_rect)  && LLUI::sDirtyRect.overlaps(screen_rect))
 				{
 					LLUI::pushMatrix();
 					{
diff --git a/indra/llui/tests/llurlmatch_test.cpp b/indra/llui/tests/llurlmatch_test.cpp
index e09ef33d49..3cd61e574e 100644
--- a/indra/llui/tests/llurlmatch_test.cpp
+++ b/indra/llui/tests/llurlmatch_test.cpp
@@ -95,7 +95,7 @@ namespace LLInitParam
 	{
 		const U8* my_addr = reinterpret_cast<const U8*>(this);
 		const U8* block_addr = reinterpret_cast<const U8*>(enclosing_block);
-		mEnclosingBlockOffset = (U16)(my_addr - block_addr);
+		mEnclosingBlockOffset = 0x7FFFffff & ((U32)(my_addr - block_addr));
 	}
 
 	bool BaseBlock::deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack, S32 generation){ return true; }