1 files changed, 685 insertions, 414 deletions

diff --git a/indra/llui/lllayoutstack.cpp b/indra/llui/lllayoutstack.cpp
index 19ac4c58a8..69246a2f57 100644..100755
--- a/indra/llui/lllayoutstack.cpp
+++ b/indra/llui/lllayoutstack.cpp
@@ -32,31 +32,43 @@
 
 #include "lllocalcliprect.h"
 #include "llpanel.h"
-#include "llresizebar.h"
 #include "llcriticaldamp.h"
+#include "lliconctrl.h"
+#include "boost/foreach.hpp"
+
+static const F32 MIN_FRACTIONAL_SIZE = 0.00001f;
+static const F32 MAX_FRACTIONAL_SIZE = 1.f;
 
 static LLDefaultChildRegistry::Register<LLLayoutStack> register_layout_stack("layout_stack");
 static LLLayoutStack::LayoutStackRegistry::Register<LLLayoutPanel> register_layout_panel("layout_panel");
 
-void LLLayoutStack::OrientationNames::declareValues()
-{
-	declare("horizontal", HORIZONTAL);
-	declare("vertical", VERTICAL);
-}
-
 //
 // LLLayoutPanel
 //
+LLLayoutPanel::Params::Params()	
+:	expanded_min_dim("expanded_min_dim", 0),
+	min_dim("min_dim", -1),
+	user_resize("user_resize", false),
+	auto_resize("auto_resize", true)
+{
+	addSynonym(min_dim, "min_width");
+	addSynonym(min_dim, "min_height");
+}
+
 LLLayoutPanel::LLLayoutPanel(const Params& p)	
 :	LLPanel(p),
+	mExpandedMinDim(p.expanded_min_dim.isProvided() ? p.expanded_min_dim : p.min_dim),
  	mMinDim(p.min_dim), 
- 	mMaxDim(p.max_dim), 
  	mAutoResize(p.auto_resize),
  	mUserResize(p.user_resize),
 	mCollapsed(FALSE),
 	mCollapseAmt(0.f),
 	mVisibleAmt(1.f), // default to fully visible
-	mResizeBar(NULL) 
+	mResizeBar(NULL),
+	mFractionalSize(0.f),
+	mTargetDim(0),
+	mIgnoreReshape(false),
+	mOrientation(LLLayoutStack::HORIZONTAL)
 {
 	// panels initialized as hidden should not start out partially visible
 	if (!getVisible())
@@ -78,21 +90,112 @@ LLLayoutPanel::~LLLayoutPanel()
 	delete mResizeBar;
 	mResizeBar = NULL;
 }
-	
-F32 LLLayoutPanel::getCollapseFactor(LLLayoutStack::ELayoutOrientation orientation)
+
+F32 LLLayoutPanel::getAutoResizeFactor() const
+{
+	return mVisibleAmt * (1.f - mCollapseAmt);
+}
+ 
+F32 LLLayoutPanel::getVisibleAmount() const
+{
+	return mVisibleAmt;
+}
+
+S32 LLLayoutPanel::getLayoutDim() const
+{
+	return ll_round((F32)((mOrientation == LLLayoutStack::HORIZONTAL)
+					? getRect().getWidth()
+					: getRect().getHeight()));
+}
+
+S32 LLLayoutPanel::getTargetDim() const
+{
+	return mTargetDim;
+}
+
+void LLLayoutPanel::setTargetDim(S32 value)
 {
-	if (orientation == LLLayoutStack::HORIZONTAL)
+	LLRect new_rect(getRect());
+	if (mOrientation == LLLayoutStack::HORIZONTAL)
 	{
-		F32 collapse_amt = 
-		clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, (F32)mMinDim / (F32)llmax(1, getRect().getWidth()));
-		return mVisibleAmt * collapse_amt;
+		new_rect.mRight = new_rect.mLeft + value;
 	}
 	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;
+		new_rect.mTop = new_rect.mBottom + value;
+	}
+	setShape(new_rect, true);
+}
+
+S32 LLLayoutPanel::getVisibleDim() const
+{
+	F32 min_dim = getRelevantMinDim();
+	return ll_round(mVisibleAmt
+					* (min_dim
+						+ (((F32)mTargetDim - min_dim) * (1.f - mCollapseAmt))));
+}
+ 
+void LLLayoutPanel::setOrientation( LLView::EOrientation orientation )
+{
+	mOrientation = orientation;
+	S32 layout_dim = ll_round((F32)((mOrientation == LLLayoutStack::HORIZONTAL)
+		? getRect().getWidth()
+		: getRect().getHeight()));
+
+	if (mAutoResize == FALSE 
+		&& mUserResize == TRUE 
+		&& mMinDim == -1 )
+	{
+		setMinDim(layout_dim);
+	}
+	mTargetDim = llmax(layout_dim, getMinDim());
+}
+ 
+void LLLayoutPanel::setVisible( BOOL visible )
+{
+	if (visible != getVisible())
+	{
+		LLLayoutStack* stackp = dynamic_cast<LLLayoutStack*>(getParent());
+		if (stackp)
+		{
+			stackp->mNeedsLayout = true;
+		}
+	}
+	LLPanel::setVisible(visible);
+}
+
+void LLLayoutPanel::reshape( S32 width, S32 height, BOOL called_from_parent /*= TRUE*/ )
+{
+	if (width == getRect().getWidth() && height == getRect().getHeight()) return;
+
+	if (!mIgnoreReshape && mAutoResize == false)
+	{
+		mTargetDim = (mOrientation == LLLayoutStack::HORIZONTAL) ? width : height;
+		LLLayoutStack* stackp = dynamic_cast<LLLayoutStack*>(getParent());
+		if (stackp)
+		{
+			stackp->mNeedsLayout = true;
+		}
+	}
+	LLPanel::reshape(width, height, called_from_parent);
+}
+
+void LLLayoutPanel::handleReshape(const LLRect& new_rect, bool by_user)
+{
+	LLLayoutStack* stackp = dynamic_cast<LLLayoutStack*>(getParent());
+	if (stackp)
+	{
+		if (by_user)
+		{	// tell layout stack to account for new shape
+			
+			// make sure that panels have already been auto resized
+			stackp->updateLayout();
+			// now apply requested size to panel
+			stackp->updatePanelRect(this, new_rect);
+		}
+		stackp->mNeedsLayout = true;
 	}
+	LLPanel::handleReshape(new_rect, by_user);
 }
 
 //
@@ -105,23 +208,35 @@ LLLayoutStack::Params::Params()
 	clip("clip", true),
 	open_time_constant("open_time_constant", 0.02f),
 	close_time_constant("close_time_constant", 0.03f),
-	border_size("border_size", LLCachedControl<S32>(*LLUI::sSettingGroups["config"], "UIResizeBarHeight", 0))
+	resize_bar_overlap("resize_bar_overlap", 1),
+	border_size("border_size", LLCachedControl<S32>(*LLUI::sSettingGroups["config"], "UIResizeBarHeight", 0)),
+	show_drag_handle("show_drag_handle", false),
+	drag_handle_first_indent("drag_handle_first_indent", 0),
+	drag_handle_second_indent("drag_handle_second_indent", 0),
+	drag_handle_thickness("drag_handle_thickness", 5),
+	drag_handle_shift("drag_handle_shift", 2)
 {
-	name="stack";
+	addSynonym(border_size, "drag_handle_gap");
 }
 
 LLLayoutStack::LLLayoutStack(const LLLayoutStack::Params& p) 
 :	LLView(p),
-	mMinWidth(0),
-	mMinHeight(0),
 	mPanelSpacing(p.border_size),
 	mOrientation(p.orientation),
 	mAnimate(p.animate),
 	mAnimatedThisFrame(false),
+	mNeedsLayout(true),
 	mClip(p.clip),
 	mOpenTimeConstant(p.open_time_constant),
-	mCloseTimeConstant(p.close_time_constant)
-{}
+	mCloseTimeConstant(p.close_time_constant),
+	mResizeBarOverlap(p.resize_bar_overlap),
+	mShowDragHandle(p.show_drag_handle),
+	mDragHandleFirstIndent(p.drag_handle_first_indent),
+	mDragHandleSecondIndent(p.drag_handle_second_indent),
+	mDragHandleThickness(p.drag_handle_thickness),
+	mDragHandleShift(p.drag_handle_shift)
+{
+}
 
 LLLayoutStack::~LLLayoutStack()
 {
@@ -134,28 +249,31 @@ void LLLayoutStack::draw()
 {
 	updateLayout();
 
-	e_panel_list_t::iterator panel_it;
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	// always clip to stack itself
+	LLLocalClipRect clip(getLocalRect());
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
 	{
 		// clip to layout rectangle, not bounding rectangle
-		LLRect clip_rect = (*panel_it)->getRect();
+		LLRect clip_rect = panelp->getRect();
 		// scale clipping rectangle by visible amount
 		if (mOrientation == HORIZONTAL)
 		{
-			clip_rect.mRight = clip_rect.mLeft + llround((F32)clip_rect.getWidth() * (*panel_it)->getCollapseFactor(mOrientation));
+			clip_rect.mRight = clip_rect.mLeft + panelp->getVisibleDim();
 		}
 		else
 		{
-			clip_rect.mBottom = clip_rect.mTop - llround((F32)clip_rect.getHeight() * (*panel_it)->getCollapseFactor(mOrientation));
+			clip_rect.mBottom = clip_rect.mTop - panelp->getVisibleDim();
 		}
 
-		LLPanel* panelp = (*panel_it);
-
-		LLLocalClipRect clip(clip_rect, mClip);
-		// only force drawing invisible children if visible amount is non-zero
-		drawChild(panelp, 0, 0, !clip_rect.isEmpty());
+		{LLLocalClipRect clip(clip_rect, mClip);
+			// only force drawing invisible children if visible amount is non-zero
+			drawChild(panelp, 0, 0, !clip_rect.isEmpty());
+		}
+		if (panelp->getResizeBar()->getVisible())
+		{
+			drawChild(panelp->getResizeBar());
+		}
 	}
-	mAnimatedThisFrame = false;
 }
 
 void LLLayoutStack::removeChild(LLView* view)
@@ -166,12 +284,10 @@ void LLLayoutStack::removeChild(LLView* view)
 	{
 		mPanels.erase(std::find(mPanels.begin(), mPanels.end(), embedded_panelp));
 		delete embedded_panelp;
+		updateFractionalSizes();
+		mNeedsLayout = true;
 	}
 
-	// need to update resizebars
-
-	calcMinExtents();
-
 	LLView::removeChild(view);
 }
 
@@ -182,54 +298,19 @@ BOOL LLLayoutStack::postBuild()
 }
 
 bool LLLayoutStack::addChild(LLView* child, S32 tab_group)
-		{
-	LLLayoutPanel* panelp = dynamic_cast<LLLayoutPanel*>(child);
-			if (panelp)
-			{
-		mPanels.push_back(panelp);
-			}
-	return LLView::addChild(child, tab_group);
-		}
-
-
-S32 LLLayoutStack::getDefaultHeight(S32 cur_height)
-{
-	// if we are spanning our children (crude upward propagation of size)
-	// then don't enforce our size on our children
-	if (mOrientation == HORIZONTAL)
-	{
-		cur_height = llmax(mMinHeight, getRect().getHeight());
-	}
-
-	return cur_height;
-}
-
-S32 LLLayoutStack::getDefaultWidth(S32 cur_width)
 {
-	// if we are spanning our children (crude upward propagation of size)
-	// then don't enforce our size on our children
-	if (mOrientation == VERTICAL)
+	LLLayoutPanel* panelp = dynamic_cast<LLLayoutPanel*>(child);
+	if (panelp)
 	{
-		cur_width = llmax(mMinWidth, getRect().getWidth());
+		panelp->setOrientation(mOrientation);
+		mPanels.push_back(panelp);
+		createResizeBar(panelp);
+		mNeedsLayout = true;
 	}
+	BOOL result = LLView::addChild(child, tab_group);
 
-	return cur_width;
-}
-
-void LLLayoutStack::movePanel(LLPanel* panel_to_move, LLPanel* target_panel, bool move_to_front)
-{
-	LLLayoutPanel* embedded_panel_to_move = findEmbeddedPanel(panel_to_move);
-	LLLayoutPanel* embedded_target_panel = move_to_front ? *mPanels.begin() : findEmbeddedPanel(target_panel);
-
-	if (!embedded_panel_to_move || !embedded_target_panel || embedded_panel_to_move == embedded_target_panel)
-	{
-		llwarns << "One of the panels was not found in stack or NULL was passed instead of valid panel" << llendl;
-		return;
-	}
-	e_panel_list_t::iterator it = std::find(mPanels.begin(), mPanels.end(), embedded_panel_to_move);
-	mPanels.erase(it);
-	it = move_to_front ? mPanels.begin() : std::find(mPanels.begin(), mPanels.end(), embedded_target_panel);
-	mPanels.insert(it, embedded_panel_to_move);
+	updateFractionalSizes();
+	return result;
 }
 
 void LLLayoutStack::addPanel(LLLayoutPanel* panel, EAnimate animate)
@@ -244,480 +325,670 @@ void LLLayoutStack::addPanel(LLLayoutPanel* panel, EAnimate animate)
 	}
 }
 
-void LLLayoutStack::removePanel(LLPanel* panel)
-{
-	removeChild(panel);
-}
-
 void LLLayoutStack::collapsePanel(LLPanel* panel, BOOL collapsed)
 {
 	LLLayoutPanel* panel_container = findEmbeddedPanel(panel);
 	if (!panel_container) return;
 
 	panel_container->mCollapsed = collapsed;
+	mNeedsLayout = true;
 }
 
-void LLLayoutStack::updatePanelAutoResize(const std::string& panel_name, BOOL auto_resize)
-{
-	LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
-
-	if (panel)
-	{
-		panel->mAutoResize = auto_resize;
-	}
-}
+static LLTrace::BlockTimerStatHandle FTM_UPDATE_LAYOUT("Update LayoutStacks");
 
-void LLLayoutStack::setPanelUserResize(const std::string& panel_name, BOOL user_resize)
+class LLImagePanel : public LLPanel
 {
-	LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+public:
+	struct Params :	public LLInitParam::Block<Params, LLPanel::Params>
+	{
+		Optional<bool> horizontal;
+		Params() : horizontal("horizontal", false) {}
+	};
+	LLImagePanel(const Params& p) : LLPanel(p), mHorizontal(p.horizontal) {}
+	virtual ~LLImagePanel() {}
 
-	if (panel)
+	void draw()
 	{
-		panel->mUserResize = user_resize;
+		const LLRect& parent_rect = getParent()->getRect();
+		const LLRect& rect = getRect();
+		LLRect clip_rect( -rect.mLeft, parent_rect.getHeight() - rect.mBottom - 2
+			, parent_rect.getWidth() - rect.mLeft - (mHorizontal ? 2 : 0), -rect.mBottom);
+		LLLocalClipRect clip(clip_rect);
+		LLPanel::draw();
 	}
-}
 
-bool LLLayoutStack::getPanelMinSize(const std::string& panel_name, S32* min_dimp)
-{
-	LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+private:
+	bool mHorizontal;
+};
 
-	if (panel)
-	{
-		if (min_dimp) *min_dimp = panel->mMinDim;
-	}
+void LLLayoutStack::updateLayout()
+{	
+	LL_RECORD_BLOCK_TIME(FTM_UPDATE_LAYOUT);
 
-	return NULL != panel;
-}
+	if (!mNeedsLayout) return;
 
-bool LLLayoutStack::getPanelMaxSize(const std::string& panel_name, S32* max_dimp)
-{
-	LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+	bool continue_animating = animatePanels();
+	F32 total_visible_fraction = 0.f;
+	S32 space_to_distribute = (mOrientation == HORIZONTAL)
+							? getRect().getWidth()
+							: getRect().getHeight();
 
-	if (panel)
+	// first, assign minimum dimensions
+	LLLayoutPanel* panelp = NULL;
+	BOOST_FOREACH(panelp, mPanels)
 	{
-		if (max_dimp) *max_dimp = panel->mMaxDim;
+		if (panelp->mAutoResize)
+		{
+			panelp->mTargetDim = panelp->getRelevantMinDim();
+		}
+		space_to_distribute -= panelp->getVisibleDim() + ll_round((F32)mPanelSpacing * panelp->getVisibleAmount());
+		total_visible_fraction += panelp->mFractionalSize * panelp->getAutoResizeFactor();
 	}
 
-	return NULL != panel;
-}
-
-static LLFastTimer::DeclareTimer FTM_UPDATE_LAYOUT("Update LayoutStacks");
-void LLLayoutStack::updateLayout(BOOL force_resize)
-{
-	LLFastTimer ft(FTM_UPDATE_LAYOUT);
-	static LLUICachedControl<S32> resize_bar_overlap ("UIResizeBarOverlap", 0);
-	calcMinExtents();
-	createResizeBars();
+	llassert(total_visible_fraction < 1.05f);
 
-	// calculate current extents
-	S32 total_width = 0;
-	S32 total_height = 0;
+	// don't need spacing after last panel
+	space_to_distribute += panelp ? ll_round((F32)mPanelSpacing * panelp->getVisibleAmount()) : 0;
 
-	e_panel_list_t::iterator panel_it;
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end();	++panel_it)
-	{
-		LLPanel* panelp = (*panel_it);
-		if (panelp->getVisible()) 
+	S32 remaining_space = space_to_distribute;
+	F32 fraction_distributed = 0.f;
+	if (space_to_distribute > 0 && total_visible_fraction > 0.f)
+	{	// give space proportionally to visible auto resize panels
+		BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
 		{
-			if (mAnimate)
-			{
-				if (!mAnimatedThisFrame)
-				{
-					(*panel_it)->mVisibleAmt = lerp((*panel_it)->mVisibleAmt, 1.f, LLCriticalDamp::getInterpolant(mOpenTimeConstant));
-					if ((*panel_it)->mVisibleAmt > 0.99f)
-					{
-						(*panel_it)->mVisibleAmt = 1.f;
-					}
-				}
-			}
-			else
+			if (panelp->mAutoResize)
 			{
-				(*panel_it)->mVisibleAmt = 1.f;
+				F32 fraction_to_distribute = (panelp->mFractionalSize * panelp->getAutoResizeFactor()) / (total_visible_fraction);
+				S32 delta = ll_round((F32)space_to_distribute * fraction_to_distribute);
+				fraction_distributed += fraction_to_distribute;
+				panelp->mTargetDim += delta;
+				remaining_space -= delta;
 			}
 		}
-		else // not visible
+	}
+
+	// distribute any left over pixels to non-collapsed, visible panels
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+	{
+		if (remaining_space == 0) break;
+
+		if (panelp->mAutoResize 
+			&& !panelp->mCollapsed 
+			&& panelp->getVisible())
 		{
-			if (mAnimate)
-			{
-				if (!mAnimatedThisFrame)
-				{
-					(*panel_it)->mVisibleAmt = lerp((*panel_it)->mVisibleAmt, 0.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
-					if ((*panel_it)->mVisibleAmt < 0.001f)
-					{
-						(*panel_it)->mVisibleAmt = 0.f;
-					}
-				}
-			}
-			else
-			{
-				(*panel_it)->mVisibleAmt = 0.f;
-			}
+			S32 space_for_panel = remaining_space > 0 ? 1 : -1;
+			panelp->mTargetDim += space_for_panel;
+			remaining_space -= space_for_panel;
 		}
+	}
+
+	F32 cur_pos = (mOrientation == HORIZONTAL) ? 0.f : (F32)getRect().getHeight();
 
-		if ((*panel_it)->mCollapsed)
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+	{
+		F32 panel_dim = llmax(panelp->getExpandedMinDim(), panelp->mTargetDim);
+
+		LLRect panel_rect;
+		if (mOrientation == HORIZONTAL)
 		{
-			(*panel_it)->mCollapseAmt = lerp((*panel_it)->mCollapseAmt, 1.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
+			panel_rect.setLeftTopAndSize(ll_round(cur_pos),
+										getRect().getHeight(),
+										ll_round(panel_dim),
+										getRect().getHeight());
 		}
 		else
 		{
-			(*panel_it)->mCollapseAmt = lerp((*panel_it)->mCollapseAmt, 0.f, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
+			panel_rect.setLeftTopAndSize(0,
+										ll_round(cur_pos),
+										getRect().getWidth(),
+										ll_round(panel_dim));
 		}
 
+		LLRect resize_bar_rect(panel_rect);
+		F32 panel_spacing = (F32)mPanelSpacing * panelp->getVisibleAmount();
+		F32 panel_visible_dim = panelp->getVisibleDim();
+		S32 panel_spacing_round = (S32)(ll_round(panel_spacing));
+
 		if (mOrientation == HORIZONTAL)
 		{
-			// enforce minimize size constraint by default
-			if (panelp->getRect().getWidth() < (*panel_it)->mMinDim)
+			cur_pos += panel_visible_dim + panel_spacing;
+
+			if (mShowDragHandle && panel_spacing_round > mDragHandleThickness)
 			{
-				panelp->reshape((*panel_it)->mMinDim, panelp->getRect().getHeight());
+				resize_bar_rect.mLeft = panel_rect.mRight + mDragHandleShift;
+				resize_bar_rect.mRight = resize_bar_rect.mLeft + mDragHandleThickness;
 			}
-        	total_width += llround(panelp->getRect().getWidth() * (*panel_it)->getCollapseFactor(mOrientation));
-        	// want n-1 panel gaps for n panels
-			if (panel_it != mPanels.begin())
+			else
+			{
+				resize_bar_rect.mLeft = panel_rect.mRight - mResizeBarOverlap;
+				resize_bar_rect.mRight = panel_rect.mRight + panel_spacing_round + mResizeBarOverlap;
+			}
+
+			if (mShowDragHandle)
 			{
-				total_width += mPanelSpacing;
+				resize_bar_rect.mBottom += mDragHandleSecondIndent;
+				resize_bar_rect.mTop -= mDragHandleFirstIndent;
 			}
+
 		}
 		else //VERTICAL
 		{
-			// enforce minimize size constraint by default
-			if (panelp->getRect().getHeight() < (*panel_it)->mMinDim)
+			cur_pos -= panel_visible_dim + panel_spacing;
+
+			if (mShowDragHandle && panel_spacing_round > mDragHandleThickness)
 			{
-				panelp->reshape(panelp->getRect().getWidth(), (*panel_it)->mMinDim);
+				resize_bar_rect.mTop = panel_rect.mBottom - mDragHandleShift;
+				resize_bar_rect.mBottom = resize_bar_rect.mTop - mDragHandleThickness;
 			}
-			total_height += llround(panelp->getRect().getHeight() * (*panel_it)->getCollapseFactor(mOrientation));
-			if (panel_it != mPanels.begin())
+			else
+			{
+				resize_bar_rect.mTop = panel_rect.mBottom + mResizeBarOverlap;
+				resize_bar_rect.mBottom = panel_rect.mBottom - panel_spacing_round - mResizeBarOverlap;
+			}
+
+			if (mShowDragHandle)
 			{
-				total_height += mPanelSpacing;
+				resize_bar_rect.mLeft += mDragHandleFirstIndent;
+				resize_bar_rect.mRight -= mDragHandleSecondIndent;
 			}
 		}
+
+		panelp->setIgnoreReshape(true);
+		panelp->setShape(panel_rect);
+		panelp->setIgnoreReshape(false);
+		panelp->mResizeBar->setShape(resize_bar_rect);
 	}
 
-	S32 num_resizable_panels = 0;
-	S32 shrink_headroom_available = 0;
-	S32 shrink_headroom_total = 0;
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	updateResizeBarLimits();
+
+	// clear animation flag at end, since panel resizes will set it
+	// and leave it set if there is any animation in progress
+	mNeedsLayout = continue_animating;
+} // end LLLayoutStack::updateLayout
+
+LLLayoutPanel* LLLayoutStack::findEmbeddedPanel(LLPanel* panelp) const
+{
+	if (!panelp) return NULL;
+
+	e_panel_list_t::const_iterator panel_it;
+	BOOST_FOREACH(LLLayoutPanel* p, mPanels)
 	{
-		// panels that are not fully visible do not count towards shrink headroom
-		if ((*panel_it)->getCollapseFactor(mOrientation) < 1.f) 
+		if (p == panelp)
 		{
-			continue;
+			return p;
 		}
+	}
+	return NULL;
+}
 
-		// 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))
+LLLayoutPanel* LLLayoutStack::findEmbeddedPanelByName(const std::string& name) const
+{
+	LLLayoutPanel* result = NULL;
+
+	BOOST_FOREACH(LLLayoutPanel* p, mPanels)
+	{
+		if (p->getName() == name)
 		{
-			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;
-			}
+			result = p;
+			break;
 		}
-		else
+	}
+
+	return result;
+}
+
+void LLLayoutStack::createResizeBar(LLLayoutPanel* panelp)
+{
+	BOOST_FOREACH(LLLayoutPanel* lp, mPanels)
+	{
+		if (lp->mResizeBar == NULL)
 		{
-			num_resizable_panels++;
-			if (mOrientation == HORIZONTAL)
+			LLResizeBar::Params resize_params;
+			resize_params.name("resize");
+			resize_params.resizing_view(lp);
+			resize_params.min_size(lp->getRelevantMinDim());
+			resize_params.side((mOrientation == HORIZONTAL) ? LLResizeBar::RIGHT : LLResizeBar::BOTTOM);
+			resize_params.snapping_enabled(false);
+			LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
+			lp->mResizeBar = resize_bar;
+
+			if (mShowDragHandle)
 			{
-				shrink_headroom_available += (*panel_it)->getRect().getWidth() - (*panel_it)->mMinDim;
-				shrink_headroom_total += (*panel_it)->getRect().getWidth() - (*panel_it)->mMinDim;
+				LLPanel::Params resize_bar_bg_panel_p;
+				resize_bar_bg_panel_p.name = "resize_handle_bg_panel";
+				resize_bar_bg_panel_p.rect = lp->mResizeBar->getLocalRect();
+				resize_bar_bg_panel_p.follows.flags = FOLLOWS_ALL;
+				resize_bar_bg_panel_p.tab_stop = false;
+				resize_bar_bg_panel_p.background_visible = true;
+				resize_bar_bg_panel_p.bg_alpha_color = LLUIColorTable::instance().getColor("ResizebarBody");
+				resize_bar_bg_panel_p.has_border = true;
+				resize_bar_bg_panel_p.border.border_thickness = 1;
+				resize_bar_bg_panel_p.border.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
+				resize_bar_bg_panel_p.border.shadow_dark_color = LLUIColorTable::instance().getColor("ResizebarBorderDark");
+
+				LLPanel* resize_bar_bg_panel = LLUICtrlFactory::create<LLPanel>(resize_bar_bg_panel_p);
+
+				LLIconCtrl::Params icon_p;
+				icon_p.name = "resize_handle_image";
+				icon_p.rect = lp->mResizeBar->getLocalRect();
+				icon_p.follows.flags = FOLLOWS_ALL;
+				icon_p.image = LLUI::getUIImage(mOrientation == HORIZONTAL ? "Vertical Drag Handle" : "Horizontal Drag Handle");
+				resize_bar_bg_panel->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_p));
+
+				lp->mResizeBar->addChild(resize_bar_bg_panel);
 			}
-			else //VERTICAL
+
+			/*if (mShowDragHandle)
 			{
-				shrink_headroom_available += (*panel_it)->getRect().getHeight() - (*panel_it)->mMinDim;
-				shrink_headroom_total += (*panel_it)->getRect().getHeight() - (*panel_it)->mMinDim;
-			}
+				LLViewBorder::Params border_params;
+				border_params.border_thickness = 1;
+				border_params.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
+				border_params.shadow_dark_color = LLUIColorTable::instance().getColor("ResizebarBorderDark");
+
+				addBorder(border_params);
+				setBorderVisible(TRUE);
+
+				LLImagePanel::Params image_panel;
+				mDragHandleImage = LLUI::getUIImage(LLResizeBar::RIGHT == mSide ? "Vertical Drag Handle" : "Horizontal Drag Handle");
+				image_panel.bg_alpha_image = mDragHandleImage;
+				image_panel.background_visible = true;
+				image_panel.horizontal = (LLResizeBar::BOTTOM == mSide);
+				mImagePanel = LLUICtrlFactory::create<LLImagePanel>(image_panel);
+				setImagePanel(mImagePanel);
+			}*/
+
+			//if (mShowDragHandle)
+			//{
+			//	setBackgroundVisible(TRUE);
+			//	setTransparentColor(LLUIColorTable::instance().getColor("ResizebarBody"));
+			//}
+
+			/*if (mShowDragHandle)
+			{
+			S32 image_width = mDragHandleImage->getTextureWidth();
+			S32 image_height = mDragHandleImage->getTextureHeight();
+			const LLRect& panel_rect = getRect();
+			S32 image_left = (panel_rect.getWidth() - image_width) / 2 - 1;
+			S32 image_bottom = (panel_rect.getHeight() - image_height) / 2;
+			mImagePanel->setRect(LLRect(image_left, image_bottom + image_height, image_left + image_width, image_bottom));
+			}*/
+			LLView::addChild(resize_bar, 0);
 		}
 	}
-
-	// calculate how many pixels need to be distributed among layout panels
-	// positive means panels need to grow, negative means shrink
-	S32 pixels_to_distribute;
-	if (mOrientation == HORIZONTAL)
+	// bring all resize bars to the front so that they are clickable even over the panels
+	// with a bit of overlap
+	for (e_panel_list_t::iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
 	{
-		pixels_to_distribute = getRect().getWidth() - total_width;
+		LLResizeBar* resize_barp = (*panel_it)->mResizeBar;
+		sendChildToFront(resize_barp);
 	}
-	else //VERTICAL
+}
+
+// update layout stack animations, etc. once per frame
+// NOTE: we use this to size world view based on animating UI, *before* we draw the UI
+// we might still need to call updateLayout during UI draw phase, in case UI elements
+// are resizing themselves dynamically
+//static 
+void LLLayoutStack::updateClass()
+{
+	for (instance_iter it = beginInstances(); it != endInstances(); ++it)
 	{
-		pixels_to_distribute = getRect().getHeight() - total_height;
+		it->updateLayout();
+		it->mAnimatedThisFrame = false;
 	}
+}
 
-	// now we distribute the pixels...
-	S32 cur_x = 0;
-	S32 cur_y = getRect().getHeight();
+void LLLayoutStack::updateFractionalSizes()
+{
+	F32 total_resizable_dim = 0.f;
+
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+	{
+		if (panelp->mAutoResize)
+		{
+			total_resizable_dim += llmax(MIN_FRACTIONAL_SIZE, (F32)(panelp->getLayoutDim() - panelp->getRelevantMinDim()));
+		}
+	}
 
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
 	{
-		LLPanel* panelp = (*panel_it);
+		if (panelp->mAutoResize)
+		{
+			F32 panel_resizable_dim = llmax(MIN_FRACTIONAL_SIZE, (F32)(panelp->getLayoutDim() - panelp->getRelevantMinDim()));
+			panelp->mFractionalSize = panel_resizable_dim > 0.f 
+				? llclamp(panel_resizable_dim / total_resizable_dim, MIN_FRACTIONAL_SIZE, MAX_FRACTIONAL_SIZE)
+				: MIN_FRACTIONAL_SIZE;
+			llassert(!llisnan(panelp->mFractionalSize));
+		}
+	}
 
-		S32 cur_width = panelp->getRect().getWidth();
-		S32 cur_height = panelp->getRect().getHeight();
-		S32 new_width = cur_width;
-		S32 new_height = cur_height; 
+	normalizeFractionalSizes();
+}
 
-		if (mOrientation == HORIZONTAL)
+
+void LLLayoutStack::normalizeFractionalSizes()
+{
+	S32 num_auto_resize_panels = 0;
+	F32 total_fractional_size = 0.f;
+	
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+	{
+		if (panelp->mAutoResize)
 		{
-			new_width = llmax((*panel_it)->mMinDim, new_width);
+			total_fractional_size += panelp->mFractionalSize;
+			num_auto_resize_panels++;
 		}
-		else
+	}
+
+	if (total_fractional_size == 0.f)
+	{ // equal distribution
+		BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+		{
+			if (panelp->mAutoResize)
+			{
+				panelp->mFractionalSize = MAX_FRACTIONAL_SIZE / (F32)num_auto_resize_panels;
+			}
+		}
+	}
+	else
+	{ // renormalize
+		BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
 		{
-			new_height = llmax((*panel_it)->mMinDim, new_height);
+			if (panelp->mAutoResize)
+			{
+				panelp->mFractionalSize /= total_fractional_size;
+			}
 		}
-		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()) 
+bool LLLayoutStack::animatePanels()
+{
+	bool continue_animating = false;
+	
+	//
+	// animate visibility
+	//
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+	{
+		if (panelp->getVisible())
 		{
-			if (mOrientation == HORIZONTAL)
+			if (mAnimate && panelp->mVisibleAmt < 1.f)
 			{
-				// if we're shrinking
-				if (pixels_to_distribute < 0)
-				{
-					// 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);
-				}
-				else
+				if (!mAnimatedThisFrame)
 				{
-					// grow all elements equally
-					delta_size = llround((F32)pixels_to_distribute / (F32)num_resizable_panels);
-					num_resizable_panels--;
+					panelp->mVisibleAmt = lerp(panelp->mVisibleAmt, 1.f, LLSmoothInterpolation::getInterpolant(mOpenTimeConstant));
+					if (panelp->mVisibleAmt > 0.99f)
+					{
+						panelp->mVisibleAmt = 1.f;
+					}
 				}
-				pixels_to_distribute -= delta_size;
-				new_width = llmax((*panel_it)->mMinDim, cur_width + delta_size);
+				
+				mAnimatedThisFrame = true;
+				continue_animating = true;
 			}
 			else
 			{
-				new_width = getDefaultWidth(new_width);
-			}
-
-			if (mOrientation == VERTICAL)
-			{
-				if (pixels_to_distribute < 0)
+				if (panelp->mVisibleAmt != 1.f)
 				{
-					// 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);
+					panelp->mVisibleAmt = 1.f;
+					mAnimatedThisFrame = true;
 				}
-				else
+			}
+		}
+		else // not visible
+		{
+			if (mAnimate && panelp->mVisibleAmt > 0.f)
+			{
+				if (!mAnimatedThisFrame)
 				{
-					delta_size = llround((F32)pixels_to_distribute / (F32)num_resizable_panels);
-					num_resizable_panels--;
+					panelp->mVisibleAmt = lerp(panelp->mVisibleAmt, 0.f, LLSmoothInterpolation::getInterpolant(mCloseTimeConstant));
+					if (panelp->mVisibleAmt < 0.001f)
+					{
+						panelp->mVisibleAmt = 0.f;
+					}
 				}
-				pixels_to_distribute -= delta_size;
-				new_height = llmax((*panel_it)->mMinDim, cur_height + delta_size);
+
+				continue_animating = true;
+				mAnimatedThisFrame = true;
 			}
 			else
 			{
-				new_height = getDefaultHeight(new_height);
+				if (panelp->mVisibleAmt != 0.f)
+				{
+					panelp->mVisibleAmt = 0.f;
+					mAnimatedThisFrame = true;
+				}
 			}
 		}
-		else
+
+		F32 collapse_state = panelp->mCollapsed ? 1.f : 0.f;
+		if (panelp->mCollapseAmt != collapse_state)
 		{
-			if (mOrientation == HORIZONTAL)
+			if (mAnimate)
 			{
-				new_height = getDefaultHeight(new_height);
+				if (!mAnimatedThisFrame)
+				{
+					panelp->mCollapseAmt = lerp(panelp->mCollapseAmt, collapse_state, LLSmoothInterpolation::getInterpolant(mCloseTimeConstant));
+				}
+			
+				if (llabs(panelp->mCollapseAmt - collapse_state) < 0.001f)
+				{
+					panelp->mCollapseAmt = collapse_state;
+				}
+
+				mAnimatedThisFrame = true;
+				continue_animating = true;
 			}
-			else // VERTICAL
+			else
 			{
-				new_width = getDefaultWidth(new_width);
+				panelp->mCollapseAmt = collapse_state;
+				mAnimatedThisFrame = true;
 			}
 		}
+	}
 
-		// adjust running headroom count based on new sizes
-		shrink_headroom_total += delta_size;
+	if (mAnimatedThisFrame) mNeedsLayout = true;
+	return continue_animating;
+}
 
-		LLRect panel_rect;
-		panel_rect.setLeftTopAndSize(cur_x, cur_y, new_width, new_height);
-		panelp->setShape(panel_rect);
+void LLLayoutStack::updatePanelRect( LLLayoutPanel* resized_panel, const LLRect& new_rect )
+{
+	S32 new_dim = (mOrientation == HORIZONTAL)
+					? new_rect.getWidth()
+					: new_rect.getHeight();
+	S32 delta_panel_dim = new_dim - resized_panel->getVisibleDim();
+	if (delta_panel_dim == 0) return;
 
-		LLRect resize_bar_rect = panel_rect;
-		if (mOrientation == HORIZONTAL)
-		{
-			resize_bar_rect.mLeft = panel_rect.mRight - resize_bar_overlap;
-			resize_bar_rect.mRight = panel_rect.mRight + mPanelSpacing + resize_bar_overlap;
-		}
-		else
-		{
-			resize_bar_rect.mTop = panel_rect.mBottom + resize_bar_overlap;
-			resize_bar_rect.mBottom = panel_rect.mBottom - mPanelSpacing - resize_bar_overlap;
-		}
-		(*panel_it)->mResizeBar->setRect(resize_bar_rect);
+	F32 total_visible_fraction = 0.f;
+	F32 delta_auto_resize_headroom = 0.f;
+	F32 old_auto_resize_headroom = 0.f;
 
-		if (mOrientation == HORIZONTAL)
-		{
-			cur_x += llround(new_width * (*panel_it)->getCollapseFactor(mOrientation)) + mPanelSpacing;
-		}
-		else //VERTICAL
-		{
-			cur_y -= llround(new_height * (*panel_it)->getCollapseFactor(mOrientation)) + mPanelSpacing;
-		}
-	}
+	LLLayoutPanel* other_resize_panel = NULL;
+	LLLayoutPanel* following_panel = NULL;
 
-	// update resize bars with new limits
-	LLResizeBar* last_resize_bar = NULL;
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	BOOST_REVERSE_FOREACH(LLLayoutPanel* panelp, mPanels)
 	{
-		LLPanel* panelp = (*panel_it);
-
-		if (mOrientation == HORIZONTAL)
+		if (panelp->mAutoResize)
 		{
-			(*panel_it)->mResizeBar->setResizeLimits(
-				(*panel_it)->mMinDim, 
-				(*panel_it)->mMinDim + shrink_headroom_total);
+			old_auto_resize_headroom += (F32)(panelp->mTargetDim - panelp->getRelevantMinDim());
+			if (panelp->getVisible() && !panelp->mCollapsed)
+			{
+				total_visible_fraction += panelp->mFractionalSize;
+			}
 		}
-		else //VERTICAL
+
+		if (panelp == resized_panel)
 		{
-			(*panel_it)->mResizeBar->setResizeLimits(
-				(*panel_it)->mMinDim, 
-				(*panel_it)->mMinDim + shrink_headroom_total);
+			other_resize_panel = following_panel;
 		}
 
-		// toggle resize bars based on panel visibility, resizability, etc
-		BOOL resize_bar_enabled = panelp->getVisible() && (*panel_it)->mUserResize;
-		(*panel_it)->mResizeBar->setVisible(resize_bar_enabled);
-
-		if (resize_bar_enabled)
+		if (panelp->getVisible() && !panelp->mCollapsed)
 		{
-			last_resize_bar = (*panel_it)->mResizeBar;
+			following_panel = panelp;
 		}
 	}
 
-	// hide last resize bar as there is nothing past it
-	// resize bars need to be in between two resizable panels
-	if (last_resize_bar)
-	{
-		last_resize_bar->setVisible(FALSE);
-	}
-
-	// not enough room to fit existing contents
-	if (force_resize == FALSE
-		// layout did not complete by reaching target position
-		&& ((mOrientation == VERTICAL && cur_y != -mPanelSpacing)
-			|| (mOrientation == HORIZONTAL && cur_x != getRect().getWidth() + mPanelSpacing)))
-	{
-		// do another layout pass with all stacked elements contributing
-		// even those that don't usually resize
-		llassert_always(force_resize == FALSE);
-		updateLayout(TRUE);
-	}
-
-	 mAnimatedThisFrame = true;
-} // end LLLayoutStack::updateLayout
-
-
-LLLayoutPanel* LLLayoutStack::findEmbeddedPanel(LLPanel* panelp) const
-{
-	if (!panelp) return NULL;
-
-	e_panel_list_t::const_iterator panel_it;
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	if (resized_panel->mAutoResize)
 	{
-		if ((*panel_it) == panelp)
+		if (!other_resize_panel || !other_resize_panel->mAutoResize)
 		{
-			return *panel_it;
+			delta_auto_resize_headroom += delta_panel_dim;	
 		}
 	}
-	return NULL;
-}
-
-LLLayoutPanel* LLLayoutStack::findEmbeddedPanelByName(const std::string& name) const
-{
-	LLLayoutPanel* result = NULL;
-
-	for (e_panel_list_t::const_iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	else 
 	{
-		LLLayoutPanel* p = *panel_it;
-
-		if (p->getName() == name)
+		if (!other_resize_panel || other_resize_panel->mAutoResize)
 		{
-			result = p;
-			break;
+			delta_auto_resize_headroom -= delta_panel_dim;
 		}
 	}
 
-	return result;
-}
+	F32 fraction_given_up = 0.f;
+	F32 fraction_remaining = 1.f;
+	F32 new_auto_resize_headroom = old_auto_resize_headroom + delta_auto_resize_headroom;
 
-// Compute sum of min_width or min_height of children
-void LLLayoutStack::calcMinExtents()
-{
-	mMinWidth = 0;
-	mMinHeight = 0;
+	enum
+	{
+		BEFORE_RESIZED_PANEL,
+		RESIZED_PANEL,
+		NEXT_PANEL,
+		AFTER_RESIZED_PANEL
+	} which_panel = BEFORE_RESIZED_PANEL;
 
-	e_panel_list_t::iterator panel_it;
-	for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+	BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
 	{
-		if (mOrientation == HORIZONTAL)
+		if (!panelp->getVisible() || panelp->mCollapsed) 
 		{
-            mMinWidth += (*panel_it)->mMinDim;
-			if (panel_it != mPanels.begin())
+			if (panelp->mAutoResize) 
 			{
-				mMinWidth += mPanelSpacing;
+				fraction_remaining -= panelp->mFractionalSize;
 			}
+			continue;
 		}
-		else //VERTICAL
+
+		if (panelp == resized_panel)
 		{
-			mMinHeight += (*panel_it)->mMinDim;
-			if (panel_it != mPanels.begin())
-			{
-				mMinHeight += mPanelSpacing;
-			}
+			which_panel = RESIZED_PANEL;
 		}
-	}
-}
 
-void LLLayoutStack::createResizeBars()
-{
-	for (e_panel_list_t::iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
-	{
-		LLLayoutPanel* lp = (*panel_it);
-		if (lp->mResizeBar == NULL)
+		switch(which_panel)
 		{
-			LLResizeBar::Side side = (mOrientation == HORIZONTAL) ? LLResizeBar::RIGHT : LLResizeBar::BOTTOM;
-			LLRect resize_bar_rect = getRect();
-
-			LLResizeBar::Params resize_params;
-			resize_params.name("resize");
-			resize_params.resizing_view(lp);
-			resize_params.min_size(lp->mMinDim);
-			resize_params.side(side);
-			resize_params.snapping_enabled(false);
-			LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
-			lp->mResizeBar = resize_bar;
-			LLView::addChild(resize_bar, 0);
+		case BEFORE_RESIZED_PANEL:
+			if (panelp->mAutoResize)
+			{	// freeze current size as fraction of overall auto_resize space
+				F32 fractional_adjustment_factor = new_auto_resize_headroom == 0.f
+													? 1.f
+													: old_auto_resize_headroom / new_auto_resize_headroom;
+				F32 new_fractional_size = llclamp(panelp->mFractionalSize * fractional_adjustment_factor,
+													MIN_FRACTIONAL_SIZE,
+													MAX_FRACTIONAL_SIZE);
+				fraction_given_up -= new_fractional_size - panelp->mFractionalSize;
+				fraction_remaining -= panelp->mFractionalSize;
+				panelp->mFractionalSize = new_fractional_size;
+				llassert(!llisnan(panelp->mFractionalSize));
+			}
+			else
+			{
+				// leave non auto-resize panels alone
+			}
+			break;
+		case RESIZED_PANEL:
+			if (panelp->mAutoResize)
+			{	// freeze new size as fraction
+				F32 new_fractional_size = (new_auto_resize_headroom == 0.f)
+					? MAX_FRACTIONAL_SIZE
+					: llclamp(total_visible_fraction * (F32)(new_dim - panelp->getRelevantMinDim()) / new_auto_resize_headroom, MIN_FRACTIONAL_SIZE, MAX_FRACTIONAL_SIZE);
+				fraction_given_up -= new_fractional_size - panelp->mFractionalSize;
+				fraction_remaining -= panelp->mFractionalSize;
+				panelp->mFractionalSize = new_fractional_size;
+				llassert(!llisnan(panelp->mFractionalSize));
+			}
+			else
+			{	// freeze new size as original size
+				panelp->mTargetDim = new_dim;
+			}
+			which_panel = NEXT_PANEL;
+			break;
+		case NEXT_PANEL:
+			if (panelp->mAutoResize)
+			{
+				fraction_remaining -= panelp->mFractionalSize;
+				if (resized_panel->mAutoResize)
+				{
+					panelp->mFractionalSize = llclamp(panelp->mFractionalSize + fraction_given_up, MIN_FRACTIONAL_SIZE, MAX_FRACTIONAL_SIZE);
+					fraction_given_up = 0.f;
+				}
+				else
+				{
+					if (new_auto_resize_headroom < 1.f)
+					{
+						new_auto_resize_headroom = 1.f;
+					}
 
-			// bring all resize bars to the front so that they are clickable even over the panels
-			// with a bit of overlap
-			for (e_panel_list_t::iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+					F32 new_fractional_size = llclamp(total_visible_fraction * (F32)(panelp->mTargetDim - panelp->getRelevantMinDim() + delta_auto_resize_headroom) 
+														/ new_auto_resize_headroom,
+													MIN_FRACTIONAL_SIZE,
+													MAX_FRACTIONAL_SIZE);
+					fraction_given_up -= new_fractional_size - panelp->mFractionalSize;
+					panelp->mFractionalSize = new_fractional_size;
+				}
+			}
+			else
+			{
+				panelp->mTargetDim -= delta_panel_dim;
+			}
+			which_panel = AFTER_RESIZED_PANEL;
+			break;
+		case AFTER_RESIZED_PANEL:
+			if (panelp->mAutoResize && fraction_given_up != 0.f)
 			{
-				LLResizeBar* resize_barp = (*panel_it)->mResizeBar;
-				sendChildToFront(resize_barp);
+				panelp->mFractionalSize = llclamp(panelp->mFractionalSize + (panelp->mFractionalSize / fraction_remaining) * fraction_given_up,
+												MIN_FRACTIONAL_SIZE,
+												MAX_FRACTIONAL_SIZE);
 			}
+		default:
+			break;
 		}
 	}
+	updateLayout();
+	//normalizeFractionalSizes();
 }
 
-// update layout stack animations, etc. once per frame
-// NOTE: we use this to size world view based on animating UI, *before* we draw the UI
-// we might still need to call updateLayout during UI draw phase, in case UI elements
-// are resizing themselves dynamically
-//static 
-void LLLayoutStack::updateClass()
+void LLLayoutStack::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	mNeedsLayout = true;
+	LLView::reshape(width, height, called_from_parent);
+}
+
+void LLLayoutStack::updateResizeBarLimits()
 {
-	LLInstanceTrackerScopedGuard guard;
-	for (LLLayoutStack::instance_iter it = guard.beginInstances();
-	     it != guard.endInstances();
-	     ++it)
+	LLLayoutPanel* previous_visible_panelp = NULL;
+	BOOST_REVERSE_FOREACH(LLLayoutPanel* visible_panelp, mPanels)
 	{
-		it->updateLayout();
+		if (!visible_panelp->getVisible() || visible_panelp->mCollapsed)
+		{
+			visible_panelp->mResizeBar->setVisible(FALSE);
+			continue;
+		}
+
+		// toggle resize bars based on panel visibility, resizability, etc
+		if (previous_visible_panelp
+			&& (visible_panelp->mUserResize || previous_visible_panelp->mUserResize)				// one of the pair is user resizable
+			&& (visible_panelp->mAutoResize || visible_panelp->mUserResize)							// current panel is resizable
+			&& (previous_visible_panelp->mAutoResize || previous_visible_panelp->mUserResize))		// previous panel is resizable
+		{
+			visible_panelp->mResizeBar->setVisible(TRUE);
+			S32 previous_panel_headroom = previous_visible_panelp->getVisibleDim() - previous_visible_panelp->getRelevantMinDim();
+			visible_panelp->mResizeBar->setResizeLimits(visible_panelp->getRelevantMinDim(), 
+														visible_panelp->getVisibleDim() + previous_panel_headroom);
+		}
+		else
+		{
+			visible_panelp->mResizeBar->setVisible(FALSE);
+		}
+
+		previous_visible_panelp = visible_panelp;
 	}
 }
+