1 files changed, 100 insertions, 52 deletions

diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
index c300fe55d9..8020ca802b 100644
--- a/indra/llui/llui.cpp
+++ b/indra/llui/llui.cpp
@@ -61,6 +61,8 @@
 // for XUIParse
 #include "llquaternion.h"
 #include <boost/tokenizer.hpp>
+#include <boost/algorithm/string/find_iterator.hpp>
+#include <boost/algorithm/string/finder.hpp>
 
 //
 // Globals
@@ -1624,8 +1626,8 @@ void LLUI::cleanupClass()
 {
 	if(sImageProvider)
 	{
-		sImageProvider->cleanUp();
-	}
+	sImageProvider->cleanUp();
+}
 }
 
 void LLUI::setPopupFuncs(const add_popup_t& add_popup, const remove_popup_t& remove_popup,  const clear_popups_t& clear_popups)
@@ -2020,37 +2022,84 @@ void LLUI::positionViewNearMouse(LLView* view, S32 spawn_x, S32 spawn_y)
 	view->translateIntoRectWithExclusion( virtual_window_rect, mouse_rect, FALSE );
 }
 
+LLView* LLUI::resolvePath(LLView* context, const std::string& path)
+{
+	// Nothing about resolvePath() should require non-const LLView*. If caller
+	// wants non-const, call the const flavor and then cast away const-ness.
+	return const_cast<LLView*>(resolvePath(const_cast<const LLView*>(context), path));
+}
+
+const LLView* LLUI::resolvePath(const LLView* context, const std::string& path)
+{
+	// Create an iterator over slash-separated parts of 'path'. Dereferencing
+	// this iterator returns an iterator_range over the substring. Unlike
+	// LLStringUtil::getTokens(), this split_iterator doesn't combine adjacent
+	// delimiters: leading/trailing slash produces an empty substring, double
+	// slash produces an empty substring. That's what we need.
+	boost::split_iterator<std::string::const_iterator> ti(path, boost::first_finder("/")), tend;
+
+	if (ti == tend)
+	{
+		// 'path' is completely empty, no navigation
+		return context;
+	}
+
+	// leading / means "start at root"
+	if (ti->empty())
+	{
+		context = getRootView();
+		++ti;
+	}
+
+	bool recurse = false;
+	for (; ti != tend && context; ++ti)
+	{
+		if (ti->empty()) 
+		{
+			recurse = true;
+		}
+		else
+		{
+			std::string part(ti->begin(), ti->end());
+			context = context->findChildView(part, recurse);
+			recurse = false;
+		}
+	}
+
+	return context;
+}
+
 
 // LLLocalClipRect and LLScreenClipRect moved to lllocalcliprect.h/cpp
 
 namespace LLInitParam
 {
-	TypedParam<LLUIColor >::TypedParam(BlockDescriptor& descriptor, const char* name, const LLUIColor& value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
-	:	super_t(descriptor, name, value, func, min_count, max_count),
+	ParamValue<LLUIColor, TypeValues<LLUIColor> >::ParamValue(const LLUIColor& color)
+	:	super_t(color),
 		red("red"),
 		green("green"),
 		blue("blue"),
 		alpha("alpha"),
 		control("")
 	{
-		setBlockFromValue();
+		updateBlockFromValue();
 	}
 
-	void TypedParam<LLUIColor>::setValueFromBlock() const
+	void ParamValue<LLUIColor, TypeValues<LLUIColor> >::updateValueFromBlock()
 	{
 		if (control.isProvided())
 		{
-			mData.mValue = LLUIColorTable::instance().getColor(control);
+			updateValue(LLUIColorTable::instance().getColor(control));
 		}
 		else
 		{
-			mData.mValue = LLColor4(red, green, blue, alpha);
+			updateValue(LLColor4(red, green, blue, alpha));
 		}
 	}
 	
-	void TypedParam<LLUIColor>::setBlockFromValue()
+	void ParamValue<LLUIColor, TypeValues<LLUIColor> >::updateBlockFromValue()
 	{
-		LLColor4 color = mData.mValue.get();
+		LLColor4 color = getValue();
 		red.set(color.mV[VRED], false);
 		green.set(color.mV[VGREEN], false);
 		blue.set(color.mV[VBLUE], false);
@@ -2058,38 +2107,32 @@ namespace LLInitParam
 		control.set("", false);
 	}
 
-	void TypeValues<LLUIColor>::declareValues()
-	{
-		declare("white", LLColor4::white);
-		declare("black", LLColor4::black);
-		declare("red", LLColor4::red);
-		declare("green", LLColor4::green);
-		declare("blue", LLColor4::blue);
-	}
-
 	bool ParamCompare<const LLFontGL*, false>::equals(const LLFontGL* a, const LLFontGL* b)
 	{
 		return !(a->getFontDesc() < b->getFontDesc())
 			&& !(b->getFontDesc() < a->getFontDesc());
 	}
 
-	TypedParam<const LLFontGL*>::TypedParam(BlockDescriptor& descriptor, const char* _name, const LLFontGL*const value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
-	:	super_t(descriptor, _name, value, func, min_count, max_count),
+	ParamValue<const LLFontGL*, TypeValues<const LLFontGL*> >::ParamValue(const LLFontGL* fontp)
+	:	super_t(fontp),
 		name("name"),
 		size("size"),
 		style("style")
 	{
-		setBlockFromValue();
+		if (!fontp)
+		{
+			updateValue(LLFontGL::getFontDefault());
+		}
 		addSynonym(name, "");
-		setBlockFromValue();
+		updateBlockFromValue();
 	}
 
-	void TypedParam<const LLFontGL*>::setValueFromBlock() const
+	void ParamValue<const LLFontGL*, TypeValues<const LLFontGL*> >::updateValueFromBlock()
 	{
 		const LLFontGL* res_fontp = LLFontGL::getFontByName(name);
 		if (res_fontp)
 		{
-			mData.mValue = res_fontp;
+			updateValue(res_fontp);
 			return;
 		}
 
@@ -2099,22 +2142,26 @@ namespace LLInitParam
 		const LLFontGL* fontp = LLFontGL::getFont(desc);
 		if (fontp)
 		{
-			mData.mValue = fontp;
-		}		
+			updateValue(fontp);
+		}
+		else
+		{
+			updateValue(LLFontGL::getFontDefault());
+		}
 	}
 	
-	void TypedParam<const LLFontGL*>::setBlockFromValue()
+	void ParamValue<const LLFontGL*, TypeValues<const LLFontGL*> >::updateBlockFromValue()
 	{
-		if (mData.mValue)
+		if (getValue())
 		{
-			name.set(LLFontGL::nameFromFont(mData.mValue), false);
-			size.set(LLFontGL::sizeFromFont(mData.mValue), false);
-			style.set(LLFontGL::getStringFromStyle(mData.mValue->getFontDesc().getStyle()), false);
+			name.set(LLFontGL::nameFromFont(getValue()), false);
+			size.set(LLFontGL::sizeFromFont(getValue()), false);
+			style.set(LLFontGL::getStringFromStyle(getValue()->getFontDesc().getStyle()), false);
 		}
 	}
 
-	TypedParam<LLRect>::TypedParam(BlockDescriptor& descriptor, const char* name, const LLRect& value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
-	:	super_t(descriptor, name, value, func, min_count, max_count),
+	ParamValue<LLRect, TypeValues<LLRect> >::ParamValue(const LLRect& rect)
+	:	super_t(rect),
 		left("left"),
 		top("top"),
 		right("right"),
@@ -2122,10 +2169,10 @@ namespace LLInitParam
 		width("width"),
 		height("height")
 	{
-		setBlockFromValue();
+		updateBlockFromValue();
 	}
 
-	void TypedParam<LLRect>::setValueFromBlock() const
+	void ParamValue<LLRect, TypeValues<LLRect> >::updateValueFromBlock()
 	{
 		LLRect rect;
 
@@ -2186,40 +2233,41 @@ namespace LLInitParam
 			rect.mBottom = bottom;
 			rect.mTop = top;
 		}
-		mData.mValue = rect;
+		updateValue(rect);
 	}
 	
-	void TypedParam<LLRect>::setBlockFromValue()
+	void ParamValue<LLRect, TypeValues<LLRect> >::updateBlockFromValue()
 	{
 		// because of the ambiguity in specifying a rect by position and/or dimensions
 		// we clear the "provided" flag so that values from xui/etc have priority
 		// over those calculated from the rect object
 
-		left.set(mData.mValue.mLeft, false);
-		right.set(mData.mValue.mRight, false);
-		bottom.set(mData.mValue.mBottom, false);
-		top.set(mData.mValue.mTop, false);
-		width.set(mData.mValue.getWidth(), false);
-		height.set(mData.mValue.getHeight(), false);
+		LLRect& value = getValue();
+		left.set(value.mLeft, false);
+		right.set(value.mRight, false);
+		bottom.set(value.mBottom, false);
+		top.set(value.mTop, false);
+		width.set(value.getWidth(), false);
+		height.set(value.getHeight(), false);
 	}
 
-	TypedParam<LLCoordGL>::TypedParam(BlockDescriptor& descriptor, const char* name, LLCoordGL value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
-	:	super_t(descriptor, name, value, func, min_count, max_count),
+	ParamValue<LLCoordGL, TypeValues<LLCoordGL> >::ParamValue(const LLCoordGL& coord)
+	:	super_t(coord),
 		x("x"),
 		y("y")
 	{
-		setBlockFromValue();
+		updateBlockFromValue();
 	}
 
-	void TypedParam<LLCoordGL>::setValueFromBlock() const
+	void ParamValue<LLCoordGL, TypeValues<LLCoordGL> >::updateValueFromBlock()
 	{
-		mData.mValue.set(x, y);
+		updateValue(LLCoordGL(x, y));
 	}
 	
-	void TypedParam<LLCoordGL>::setBlockFromValue()
+	void ParamValue<LLCoordGL, TypeValues<LLCoordGL> >::updateBlockFromValue()
 	{
-		x.set(mData.mValue.mX, false);
-		y.set(mData.mValue.mY, false);
+		x.set(getValue().mX, false);
+		y.set(getValue().mY, false);
 	}