param block cleanup

added Flag as value type
moved Batch to BatchBlock
renamed Choice to ChoiceBlock
made merging of parameters for ValueParams consistent (fillFrom and overwriteFrom are inverses of each other now)
made iteration over Multiple<T> type params easier
initial schema param blocks

25 files changed, 377 insertions, 298 deletions

diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
index 583bde360a..2518dbe3c7 100644
--- a/indra/llui/lllineeditor.h
+++ b/indra/llui/lllineeditor.h
@@ -60,7 +60,7 @@ public:
 
 	typedef boost::function<void (LLLineEditor* caller)> keystroke_callback_t;
 	
-	struct MaxLength : public LLInitParam::Choice<MaxLength>
+	struct MaxLength : public LLInitParam::ChoiceBlock<MaxLength>
 	{
 		Alternative<S32> bytes, chars;
 		
diff --git a/indra/llui/llloadingindicator.cpp b/indra/llui/llloadingindicator.cpp
index c4eec1835c..6ac38f5ad4 100644
--- a/indra/llui/llloadingindicator.cpp
+++ b/indra/llui/llloadingindicator.cpp
@@ -34,6 +34,7 @@
 // Project includes
 #include "lluictrlfactory.h"
 #include "lluiimage.h"
+#include "boost/foreach.hpp"
 
 // registered in llui.cpp to avoid being left out by MS linker
 //static LLDefaultChildRegistry::Register<LLLoadingIndicator> r("loading_indicator");
@@ -51,11 +52,9 @@ LLLoadingIndicator::LLLoadingIndicator(const Params& p)
 
 void LLLoadingIndicator::initFromParams(const Params& p)
 {
-	for (LLInitParam::ParamIterator<LLUIImage*>::const_iterator it = p.images().image.begin(), end_it = p.images().image.end();
-		it != end_it;
-		++it)
+	BOOST_FOREACH(LLUIImage* image, p.images.image)
 	{
-		mImages.push_back(it->getValue());
+		mImages.push_back(image);
 	}
 
 	// Start timer for switching images.
diff --git a/indra/llui/llloadingindicator.h b/indra/llui/llloadingindicator.h
index 7c44478848..c1f979c111 100644
--- a/indra/llui/llloadingindicator.h
+++ b/indra/llui/llloadingindicator.h
@@ -51,7 +51,7 @@ class LLLoadingIndicator
 	LOG_CLASS(LLLoadingIndicator);
 public:
 
-	struct Images : public LLInitParam::Block<Images>
+	struct Images : public LLInitParam::BatchBlock<Images>
 	{
 		Multiple<LLUIImage*>	image;
 
@@ -63,7 +63,7 @@ public:
 	struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
 	{
 		Optional<F32>			images_per_sec;
-		Batch<Images>			images;
+		Optional<Images>		images;
 
 		Params()
 		:	images_per_sec("images_per_sec", 1.0f),
diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h
index 0c4d4fc897..462d69be2e 100644
--- a/indra/llui/llnotifications.h
+++ b/indra/llui/llnotifications.h
@@ -201,7 +201,7 @@ public:
 		FormInput();
 	};
 
-	struct FormElement : public LLInitParam::Choice<FormElement>
+	struct FormElement : public LLInitParam::ChoiceBlock<FormElement>
 	{
 		Alternative<FormButton> button;
 		Alternative<FormInput>	input;
@@ -312,7 +312,7 @@ public:
 		Optional<LLNotificationContext*>		context;
 		Optional<void*>							responder;
 
-		struct Functor : public LLInitParam::Choice<Functor>
+		struct Functor : public LLInitParam::ChoiceBlock<Functor>
 		{
 			Alternative<std::string>										name;
 			Alternative<LLNotificationFunctorRegistry::ResponseFunctor>	function;
diff --git a/indra/llui/llnotificationtemplate.h b/indra/llui/llnotificationtemplate.h
index ab777d37a5..fb50c9c123 100644
--- a/indra/llui/llnotificationtemplate.h
+++ b/indra/llui/llnotificationtemplate.h
@@ -91,7 +91,7 @@ struct LLNotificationTemplate
 		// <notification> <unique/> </notification>
 		// as well as
 		// <notification> <unique> <context></context> </unique>...
-		Flag			dummy_val;
+		Optional<LLInitParam::Flag>	dummy_val;
 	public:
 		Multiple<UniquenessContext>	contexts;
 
@@ -147,7 +147,7 @@ struct LLNotificationTemplate
 		{}
 	};
 
-	struct FormRef : public LLInitParam::Choice<FormRef>
+	struct FormRef : public LLInitParam::ChoiceBlock<FormRef>
 	{
 		Alternative<LLNotificationForm::Params>		form;
 		Alternative<TemplateRef>					form_template;
diff --git a/indra/llui/llnotificationvisibilityrule.h b/indra/llui/llnotificationvisibilityrule.h
index 78bdec2a8f..78788a275c 100644
--- a/indra/llui/llnotificationvisibilityrule.h
+++ b/indra/llui/llnotificationvisibilityrule.h
@@ -59,7 +59,7 @@ struct LLNotificationVisibilityRule
 		{}
 	};
 
-	struct Rule : public LLInitParam::Choice<Rule>
+	struct Rule : public LLInitParam::ChoiceBlock<Rule>
 	{
 		Alternative<Filter>		show;
 		Alternative<Filter>		hide;
diff --git a/indra/llui/llscrolllistcolumn.h b/indra/llui/llscrolllistcolumn.h
index 12baea8e0c..b4d4a6d05e 100644
--- a/indra/llui/llscrolllistcolumn.h
+++ b/indra/llui/llscrolllistcolumn.h
@@ -95,7 +95,7 @@ public:
 		Optional<ESortDirection, SortNames>	sort_direction;
 		Optional<bool>						sort_ascending;
 
-		struct Width : public LLInitParam::Choice<Width>
+		struct Width : public LLInitParam::ChoiceBlock<Width>
 		{
 			Alternative<bool>	dynamic_width;
 			Alternative<S32>		pixel_width;
@@ -112,7 +112,7 @@ public:
 		Optional<Width>						width;
 
 		// either an image or label is used in column header
-		struct Header : public LLInitParam::Choice<Header>
+		struct Header : public LLInitParam::ChoiceBlock<Header>
 		{
 			Alternative<std::string>			label;
 			Alternative<LLUIImage*>			image;
diff --git a/indra/llui/llsdparam.cpp b/indra/llui/llsdparam.cpp
index 04919e6991..4b69360e33 100644
--- a/indra/llui/llsdparam.cpp
+++ b/indra/llui/llsdparam.cpp
@@ -45,7 +45,7 @@ LLParamSDParser::LLParamSDParser()
 
 	if (sReadFuncs.empty())
 	{
-		registerParserFuncs<LLInitParam::NoParamValue>(readNoValue, &LLParamSDParser::writeNoValue);
+		registerParserFuncs<LLInitParam::Flag>(readFlag, &LLParamSDParser::writeFlag);
 		registerParserFuncs<S32>(readS32, &LLParamSDParser::writeTypedValue<S32>);
 		registerParserFuncs<U32>(readU32, &LLParamSDParser::writeU32Param);
 		registerParserFuncs<F32>(readF32, &LLParamSDParser::writeTypedValue<F32>);
@@ -72,7 +72,7 @@ bool LLParamSDParser::writeU32Param(LLParamSDParser::parser_t& parser, const voi
 	return true;
 }
 
-bool LLParamSDParser::writeNoValue(LLParamSDParser::parser_t& parser, const void* val_ptr, const parser_t::name_stack_t& name_stack)
+bool LLParamSDParser::writeFlag(LLParamSDParser::parser_t& parser, const void* val_ptr, const parser_t::name_stack_t& name_stack)
 {
 	LLParamSDParser& sdparser = static_cast<LLParamSDParser&>(parser);
 	if (!sdparser.mWriteRootSD) return false;
@@ -226,7 +226,7 @@ LLSD* LLParamSDParser::getSDWriteNode(const parser_t::name_stack_t& name_stack)
 	return sd_to_write;
 }
 
-bool LLParamSDParser::readNoValue(Parser& parser, void* val_ptr)
+bool LLParamSDParser::readFlag(Parser& parser, void* val_ptr)
 {
 	LLParamSDParser& self = static_cast<LLParamSDParser&>(parser);
 	return self.mCurReadSD == &NO_VALUE_MARKER;
diff --git a/indra/llui/llsdparam.h b/indra/llui/llsdparam.h
index f776c781b3..a371c28f68 100644
--- a/indra/llui/llsdparam.h
+++ b/indra/llui/llsdparam.h
@@ -63,9 +63,9 @@ private:
 	LLSD* getSDWriteNode(const parser_t::name_stack_t& name_stack);
 
 	static bool writeU32Param(Parser& parser, const void* value_ptr, const parser_t::name_stack_t& name_stack);
-	static bool writeNoValue(Parser& parser, const void* value_ptr, const parser_t::name_stack_t& name_stack);
+	static bool writeFlag(Parser& parser, const void* value_ptr, const parser_t::name_stack_t& name_stack);
 
-	static bool readNoValue(Parser& parser, void* val_ptr);
+	static bool readFlag(Parser& parser, void* val_ptr);
 	static bool readS32(Parser& parser, void* val_ptr);
 	static bool readU32(Parser& parser, void* val_ptr);
 	static bool readF32(Parser& parser, void* val_ptr);
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index 7d545a1ba6..384d9116fc 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -237,7 +237,7 @@ public:
 	friend class LLNormalTextSegment;
 	friend class LLUICtrlFactory;
 
-	struct LineSpacingParams : public LLInitParam::Choice<LineSpacingParams>
+	struct LineSpacingParams : public LLInitParam::ChoiceBlock<LineSpacingParams>
 	{
 		Alternative<F32>	multiple;
 		Alternative<S32>	pixels;
diff --git a/indra/llui/lltoolbar.cpp b/indra/llui/lltoolbar.cpp
index caad896a06..d940bed905 100644
--- a/indra/llui/lltoolbar.cpp
+++ b/indra/llui/lltoolbar.cpp
@@ -185,7 +185,7 @@ void LLToolBar::initFromParams(const LLToolBar::Params& p)
 
 	LLPanel::Params button_panel_p(p.button_panel);
 	button_panel_p.rect = center_panel->getLocalRect();
-		button_panel_p.follows.flags = FOLLOWS_BOTTOM|FOLLOWS_LEFT;
+	button_panel_p.follows.flags = FOLLOWS_BOTTOM|FOLLOWS_LEFT;
 	mButtonPanel = LLUICtrlFactory::create<LLPanel>(button_panel_p);
 	center_panel->addChild(mButtonPanel);
 	
@@ -558,8 +558,8 @@ BOOL LLToolBarButton::handleHover(S32 x, S32 y, MASK mask)
 			LLToolBar* bar = getParentByType<LLToolBar>();
 			if (view)
 			{
-				view->startDrag(bar->createButton(mId));
-				setVisible(FALSE);
+				//view->startDrag(bar->createButton(mId));
+				//setVisible(FALSE);
 			}
 		}
 	}
diff --git a/indra/llui/lltoolbarview.h b/indra/llui/lltoolbarview.h
index ea3422f04e..dd2bbf0e49 100644
--- a/indra/llui/lltoolbarview.h
+++ b/indra/llui/lltoolbarview.h
@@ -65,10 +65,6 @@ public:
 	virtual ~LLToolBarView();
 	virtual BOOL postBuild();
 	virtual void draw();
-	virtual BOOL handleHover(S32 x, S32 y, MASK mask);
-	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
-	virtual void onMouseCaptureLost();
-	void startDrag(LLToolBarButton*);
 	// Toolbar view interface with the rest of the world
 	// Checks if the commandId is being used somewhere in one of the toolbars
 	bool hasCommand(const LLCommandId& commandId) const;
diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
index 4f129ccfba..76a12e649b 100644
--- a/indra/llui/llui.cpp
+++ b/indra/llui/llui.cpp
@@ -2107,7 +2107,7 @@ namespace LLInitParam
 
 	void ParamValue<LLUIColor, TypeValues<LLUIColor> >::updateValueFromBlock()
 	{
-		if (control.isProvided())
+		if (control.isProvided() && !control().empty())
 		{
 			updateValue(LLUIColorTable::instance().getColor(control));
 		}
@@ -2264,9 +2264,11 @@ namespace LLInitParam
 		// in this case, that is left+width and bottom+height
 		LLRect& value = getValue();
 
+		right.set(value.mRight, false);
 		left.set(value.mLeft, make_block_authoritative);
 		width.set(value.getWidth(), make_block_authoritative);
 
+		top.set(value.mTop, false);
 		bottom.set(value.mBottom, make_block_authoritative);
 		height.set(value.getHeight(), make_block_authoritative);
 	}
diff --git a/indra/llui/llui.h b/indra/llui/llui.h
index 7801a01ace..3afb7c65a9 100644
--- a/indra/llui/llui.h
+++ b/indra/llui/llui.h
@@ -365,7 +365,7 @@ template <typename T> LLRegisterWith<LLInitClassList> LLInitClass<T>::sRegister(
 template <typename T> LLRegisterWith<LLDestroyClassList> LLDestroyClass<T>::sRegister(&T::destroyClass);
 
 // useful parameter blocks
-struct TimeIntervalParam : public LLInitParam::Choice<TimeIntervalParam>
+struct TimeIntervalParam : public LLInitParam::ChoiceBlock<TimeIntervalParam>
 {
 	Alternative<F32>		seconds;
 	Alternative<S32>		frames;
diff --git a/indra/llui/lluicolortable.h b/indra/llui/lluicolortable.h
index 76518789ec..6a7a681d57 100644
--- a/indra/llui/lluicolortable.h
+++ b/indra/llui/lluicolortable.h
@@ -44,7 +44,7 @@ LOG_CLASS(LLUIColorTable);
 	typedef std::map<std::string, LLUIColor>  string_color_map_t;
 
 public:
-	struct ColorParams : LLInitParam::Choice<ColorParams>
+	struct ColorParams : LLInitParam::ChoiceBlock<ColorParams>
 	{
 		Alternative<LLColor4>    value;
 		Alternative<std::string> reference;
diff --git a/indra/llui/lluictrl.h b/indra/llui/lluictrl.h
index fc56e5fc35..a8a4e3191d 100644
--- a/indra/llui/lluictrl.h
+++ b/indra/llui/lluictrl.h
@@ -76,14 +76,14 @@ public:
 		Optional<enable_callback_t> function;
 	};
 		
-	struct EnableControls : public LLInitParam::Choice<EnableControls>
+	struct EnableControls : public LLInitParam::ChoiceBlock<EnableControls>
 	{
 		Alternative<std::string> enabled;
 		Alternative<std::string> disabled;
 		
 		EnableControls();
 	};	
-	struct ControlVisibility : public LLInitParam::Choice<ControlVisibility>
+	struct ControlVisibility : public LLInitParam::ChoiceBlock<ControlVisibility>
 	{
 		Alternative<std::string> visible;
 		Alternative<std::string> invisible;
diff --git a/indra/llui/lluictrlfactory.h b/indra/llui/lluictrlfactory.h
index 71c38237c1..d612ad5005 100644
--- a/indra/llui/lluictrlfactory.h
+++ b/indra/llui/lluictrlfactory.h
@@ -125,12 +125,12 @@ private:
 
 	// base case for recursion, there are NO base classes of LLInitParam::BaseBlock
 	template<int DUMMY>
-	class ParamDefaults<LLInitParam::BaseBlockWithFlags, DUMMY> : public LLSingleton<ParamDefaults<LLInitParam::BaseBlockWithFlags, DUMMY> >
+	class ParamDefaults<LLInitParam::BaseBlock, DUMMY> : public LLSingleton<ParamDefaults<LLInitParam::BaseBlock, DUMMY> >
 	{
 	public:
-		const LLInitParam::BaseBlockWithFlags& get() { return mBaseBlock; }
+		const LLInitParam::BaseBlock& get() { return mBaseBlock; }
 	private:
-		LLInitParam::BaseBlockWithFlags mBaseBlock;
+		LLInitParam::BaseBlock mBaseBlock;
 	};
 
 public:
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
index f4e31b109a..a1c46f3bf3 100644
--- a/indra/llui/llview.h
+++ b/indra/llui/llview.h
@@ -98,7 +98,7 @@ private:
 class LLView : public LLMouseHandler, public LLMortician, public LLFocusableElement
 {
 public:
-	struct Follows : public LLInitParam::Choice<Follows>
+	struct Follows : public LLInitParam::ChoiceBlock<Follows>
 	{
 		Alternative<std::string>	string;
 		Alternative<U32>			flags;
diff --git a/indra/llxuixml/llinitparam.cpp b/indra/llxuixml/llinitparam.cpp
index c024fd405e..99016205c8 100644
--- a/indra/llxuixml/llinitparam.cpp
+++ b/indra/llxuixml/llinitparam.cpp
@@ -365,7 +365,7 @@ namespace LLInitParam
 		// verify by calling readValue with NoParamValue type, an inherently unparseable type
 		if (!names_left)
 		{
-			NoParamValue no_value;
+			Flag no_value;
 			return p.readValue(no_value);
 		}
 
diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h
index 69dcd474f7..9a6ded47ff 100644
--- a/indra/llxuixml/llinitparam.h
+++ b/indra/llxuixml/llinitparam.h
@@ -38,6 +38,9 @@
 
 namespace LLInitParam
 {
+	// used to indicate no matching value to a given name when parsing
+	struct Flag{};
+
 	template<typename T> const T& defaultValue() { static T value; return value; }
 
 	template <typename T, bool IS_BOOST_FUNCTION = boost::is_convertible<T, boost::function_base>::value >
@@ -65,6 +68,12 @@ namespace LLInitParam
 		static bool equals(const LLSD &a, const LLSD &b) { return false; }
 	};
 
+	template<>
+	struct ParamCompare<Flag, false>
+	{
+		static bool equals(const Flag& a, const Flag& b) { return false; }
+	};
+
 	// helper functions and classes
 	typedef ptrdiff_t param_handle_t;
 
@@ -275,9 +284,6 @@ namespace LLInitParam
 		static S32					sNextParseGeneration;
 	};
 
-	// used to indicate no matching value to a given name when parsing
-	struct NoParamValue{};
-
 	class BaseBlock;
 
 	class Param
@@ -385,36 +391,36 @@ namespace LLInitParam
 		// "Multiple" constraint types, put here in root class to avoid ambiguity during use
 		struct AnyAmount
 		{
-			static U32 minCount() { return 0; }
-			static U32 maxCount() { return U32_MAX; }
+			enum { minCount = 0 };
+			enum { maxCount = U32_MAX };
 		};
 
 		template<U32 MIN_AMOUNT>
 		struct AtLeast
 		{
-			static U32 minCount() { return MIN_AMOUNT; }
-			static U32 maxCount() { return U32_MAX; }
+			enum { minCount = MIN_AMOUNT };
+			enum { maxCount = U32_MAX };
 		};
 
 		template<U32 MAX_AMOUNT>
 		struct AtMost
 		{
-			static U32 minCount() { return 0; }
-			static U32 maxCount() { return MAX_AMOUNT; }
+			enum { minCount = 0 };
+			enum { maxCount = MAX_AMOUNT };
 		};
 
 		template<U32 MIN_AMOUNT, U32 MAX_AMOUNT>
 		struct Between
 		{
-			static U32 minCount() { return MIN_AMOUNT; }
-			static U32 maxCount() { return MAX_AMOUNT; }
+			enum { minCount = MIN_AMOUNT };
+			enum { maxCount = MAX_AMOUNT };
 		};
 
 		template<U32 EXACT_COUNT>
 		struct Exactly
 		{
-			static U32 minCount() { return EXACT_COUNT; }
-			static U32 maxCount() { return EXACT_COUNT; }
+			enum { minCount = EXACT_COUNT };
+			enum { maxCount = EXACT_COUNT };
 		};
 
 		// this typedef identifies derived classes as being blocks
@@ -477,9 +483,9 @@ namespace LLInitParam
 		void init(BlockDescriptor& descriptor, BlockDescriptor& base_descriptor, size_t block_size);
 
 
-		bool mergeBlockParam(bool param_provided, BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
+		bool mergeBlockParam(bool source_provided, bool dst_provided, BlockDescriptor& block_data, const BaseBlock& source, bool overwrite)
 		{
-			return mergeBlock(block_data, other, overwrite);
+			return mergeBlock(block_data, source, overwrite);
 		}
 		// take all provided params from other and apply to self
 		bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite);
@@ -497,92 +503,6 @@ namespace LLInitParam
 		const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const;
 	};
 
-	class BaseBlockWithFlags : public BaseBlock
-	{
-	public:
-		class FlagBase : public Param
-		{
-		public:
-			typedef FlagBase self_t;
-
-			FlagBase(const char* name, BaseBlock* enclosing_block) : Param(enclosing_block) 
-			{
-				if (LL_UNLIKELY(enclosing_block->mostDerivedBlockDescriptor().mInitializationState == BlockDescriptor::INITIALIZING))
-				{
-					ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor(
-						enclosing_block->getHandleFromParam(this),
-						&mergeWith,
-						&deserializeParam,
-						&serializeParam,
-						NULL,
-						&inspectParam,
-						0, 1));
-					BaseBlock::addParam(enclosing_block->mostDerivedBlockDescriptor(), param_descriptor, name);
-				}
-			}
-
-			bool isProvided() const { return anyProvided(); }
-
-		private:
-			static bool mergeWith(Param& dst, const Param& src, bool overwrite)
-			{
-				const self_t& src_typed_param = static_cast<const self_t&>(src);
-				self_t& dst_typed_param = static_cast<self_t&>(dst);
-
-				if (src_typed_param.isProvided()
-					&& (overwrite || !dst_typed_param.isProvided()))
-				{
-					dst.setProvided(true);
-					return true;
-				}
-				return false;
-			}
-
-			static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation)
-			{
-				self_t& typed_param = static_cast<self_t&>(param);
-
-				// no further names in stack, parse value now
-				if (name_stack.first == name_stack.second)
-				{
-					typed_param.setProvided(true);
-					typed_param.enclosingBlock().paramChanged(param, true);
-					return true;
-				}
-
-				return false;
-			}
-
-			static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param)
-			{
-				const self_t& typed_param = static_cast<const self_t&>(param);
-				const self_t* typed_diff_param = static_cast<const self_t*>(diff_param);
-
-				if (!typed_param.isProvided()) return;
-
-				if (!name_stack.empty())
-				{
-					name_stack.back().second = parser.newParseGeneration();
-				}
-
-				// then try to serialize value directly
-				if (!typed_diff_param || !typed_diff_param->isProvided())
-				{
-					if (!parser.writeValue(NoParamValue(), name_stack)) 
-					{
-						return;
-					}
-				}
-			}
-
-			static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count)
-			{
-				// tell parser about our actual type
-				parser.inspectValue<NoParamValue>(name_stack, min_count, max_count, NULL);
-			}
-		};
-	};
-
 	// these templates allow us to distinguish between template parameters
 	// that derive from BaseBlock and those that don't
 	template<typename T, typename Void = void>
@@ -604,7 +524,7 @@ namespace LLInitParam
 		typedef const T&							value_assignment_t;
 
 		ParamValue(): mValue() {}
-		ParamValue(const T& other) : mValue(other) {}
+		ParamValue(value_assignment_t other) : mValue(other) {}
 
 		void setValue(value_assignment_t val)
 		{
@@ -621,6 +541,17 @@ namespace LLInitParam
 			return mValue;
 		}
 
+		operator value_assignment_t() const
+		{
+			return mValue;
+		}
+
+		value_assignment_t operator()() const
+		{
+			return mValue;
+		}
+
+
 	private:
 		T mValue;
 	};
@@ -644,7 +575,7 @@ namespace LLInitParam
 			mValidated(false)
 		{}
 
-		ParamValue(const T& other)
+		ParamValue(value_assignment_t other)
 		:	T(other),
 			mKeyVersion(0),
 			mValidatedVersion(-1),
@@ -666,6 +597,16 @@ namespace LLInitParam
 		{
 			return *this;
 		}
+
+		operator value_assignment_t() const
+		{
+			return *this;
+		}
+		
+		value_assignment_t operator()() const
+		{
+			return *this;
+		}
 	};
 
 	template<typename T, typename NAME_VALUE_LOOKUP = TypeValues<T> >
@@ -801,11 +742,6 @@ namespace LLInitParam
 			Param::enclosingBlock().paramChanged(*this, flag_as_provided);
 		}
 
-		// implicit conversion
-		operator value_assignment_t() const { return param_value_t::getValue(); } 
-		// explicit conversion
-		value_assignment_t operator()() const { return param_value_t::getValue(); } 
-
 	protected:
 
 		static bool mergeWith(Param& dst, const Param& src, bool overwrite)
@@ -958,11 +894,6 @@ namespace LLInitParam
 			}
 		}
 
-		// implicit conversion
-		operator value_assignment_t() const { return param_value_t::getValue(); } 
-		// explicit conversion
-		value_assignment_t operator()() const { return param_value_t::getValue(); } 
-
 	protected:
 
 		static bool mergeWith(Param& dst, const Param& src, bool overwrite)
@@ -972,8 +903,7 @@ namespace LLInitParam
 
 			if (src_typed_param.anyProvided())
 			{
-				bool param_provided = src_typed_param.isProvided() && (overwrite || !dst_typed_param.isProvided());
-				if (dst_typed_param.mergeBlockParam(param_provided, param_value_t::selfBlockDescriptor(), src_typed_param, overwrite))
+				if (dst_typed_param.mergeBlockParam(src_typed_param.isProvided(), dst_typed_param.isProvided(), param_value_t::selfBlockDescriptor(), src_typed_param, overwrite))
 				{
 					dst_typed_param.clearValueName();
 					dst_typed_param.setProvided(true);
@@ -992,8 +922,8 @@ namespace LLInitParam
 	{
 	public:
 		typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, false>		self_t;
-		typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP>			param_value_t;
-		typedef typename std::vector<param_value_t>							container_t;
+		typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP>					param_value_t;
+		typedef typename std::vector<param_value_t>					container_t;
 		typedef const container_t&											value_assignment_t;
 
 		typedef VALUE_TYPE													value_t;
@@ -1118,6 +1048,8 @@ namespace LLInitParam
 
 		// implicit conversion
 		operator value_assignment_t() const { return mValues; } 
+		// explicit conversion		
+		value_assignment_t operator()() const { return mValues; }
 
 		typedef typename container_t::iterator iterator;
 		typedef typename container_t::const_iterator const_iterator;
@@ -1169,7 +1101,7 @@ namespace LLInitParam
 	public:
 		typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, true>	self_t;
 		typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP>				param_value_t;
-		typedef typename std::vector<param_value_t>						container_t;
+		typedef typename std::vector<param_value_t>				container_t;
 		typedef const container_t&										value_assignment_t;
 		typedef VALUE_TYPE												value_t;
 		typedef NAME_VALUE_LOOKUP										name_value_lookup_t;
@@ -1308,6 +1240,8 @@ namespace LLInitParam
 
 		// implicit conversion
 		operator value_assignment_t() const { return mValues; } 
+		// explicit conversion
+		value_assignment_t operator()() const { return mValues; }
 
 		typedef typename container_t::iterator iterator;
 		typedef typename container_t::const_iterator const_iterator;
@@ -1363,10 +1297,10 @@ namespace LLInitParam
 	};
 
 	template <typename DERIVED_BLOCK>
-	class Choice : public BaseBlock
+	class ChoiceBlock : public BaseBlock
 	{
-		typedef Choice<DERIVED_BLOCK>	self_t;
-		typedef Choice<DERIVED_BLOCK>	enclosing_block_t;
+		typedef ChoiceBlock<DERIVED_BLOCK>	self_t;
+		typedef ChoiceBlock<DERIVED_BLOCK>	enclosing_block_t;
 		
 		LOG_CLASS(self_t);
 	public:
@@ -1382,11 +1316,13 @@ namespace LLInitParam
 			return mergeBlock(selfBlockDescriptor(), other, false);
 		}
 
-		bool mergeBlockParam(bool param_provided, BlockDescriptor& block_data, const self_t& other, bool overwrite)
+		bool mergeBlockParam(bool source_provided, bool dest_provided, BlockDescriptor& block_data, const self_t& source, bool overwrite)
 		{
-			if (param_provided)
+			bool source_override = source_provided && (overwrite || !dest_provided);
+
+			if (source_override || source.mCurChoice == mCurChoice)
 			{
-				return mergeBlock(block_data, other, overwrite);
+				return mergeBlock(block_data, source, overwrite);
 			}
 			return false;
 		}
@@ -1420,7 +1356,7 @@ namespace LLInitParam
 		virtual BlockDescriptor& mostDerivedBlockDescriptor() { return selfBlockDescriptor(); }
 
 	protected:
-		Choice()
+		ChoiceBlock()
 		:	mCurChoice(0)
 		{
 			BaseBlock::init(selfBlockDescriptor(), BaseBlock::selfBlockDescriptor(), sizeof(DERIVED_BLOCK));
@@ -1433,13 +1369,13 @@ namespace LLInitParam
 		class Alternative : public TypedParam<T, NAME_VALUE_LOOKUP, false>
 		{
 		public:
-			friend class Choice<DERIVED_BLOCK>;
+			friend class ChoiceBlock<DERIVED_BLOCK>;
 
 			typedef Alternative<T, NAME_VALUE_LOOKUP>									self_t;
 			typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value>		super_t;
 			typedef typename super_t::value_assignment_t								value_assignment_t;
 
-			explicit Alternative(const char* name, value_assignment_t val = defaultValue<T>())
+			explicit Alternative(const char* name = "", value_assignment_t val = defaultValue<T>())
 			:	super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1),
 				mOriginalValue(val)
 			{
@@ -1454,10 +1390,19 @@ namespace LLInitParam
 				}
 			}
 
-			Alternative& operator=(value_assignment_t val)
+			void choose()
+			{
+				static_cast<enclosing_block_t&>(Param::enclosingBlock()).paramChanged(*this, true);
+			}
+
+			void chooseAs(value_assignment_t val)
+			{
+				super_t::set(val);
+			}
+
+			void operator=(value_assignment_t val)
 			{
 				super_t::set(val);
-				return *this;
 			}
 
 			void operator()(typename super_t::value_assignment_t val) 
@@ -1466,12 +1411,8 @@ namespace LLInitParam
 			}
 
 			operator value_assignment_t() const 
-			{ 
-				if (static_cast<enclosing_block_t&>(Param::enclosingBlock()).getCurrentChoice() == this)
-				{
-					return super_t::getValue(); 
-				}
-				return mOriginalValue;
+			{
+				return (*this)();
 			} 
 
 			value_assignment_t operator()() const 
@@ -1508,7 +1449,7 @@ namespace LLInitParam
 		}
 	};
 
-	template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlockWithFlags>
+	template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock>
 	class Block 
 	:	public BASE_BLOCK
 	{
@@ -1604,13 +1545,6 @@ namespace LLInitParam
 
 		};
 
-		class Flag : public BaseBlockWithFlags::FlagBase
-		{
-		public:
-			Flag(const char* name) : FlagBase(name, DERIVED_BLOCK::selfBlockDescriptor().mCurrentBlockPtr)
-			{}
-		};
-
 		template <typename T, typename RANGE = BaseBlock::AnyAmount, typename NAME_VALUE_LOOKUP = TypeValues<T> >
 		class Multiple : public TypedParam<T, NAME_VALUE_LOOKUP, true>
 		{
@@ -1623,7 +1557,7 @@ namespace LLInitParam
 			typedef typename super_t::const_iterator								const_iterator;
 
 			explicit Multiple(const char* name = "")
-			:	super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, container_t(), &validate, RANGE::minCount(), RANGE::maxCount())
+			:	super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, container_t(), &validate, RANGE::minCount, RANGE::maxCount)
 			{}
 
 			Multiple& operator=(value_assignment_t val)
@@ -1641,100 +1575,10 @@ namespace LLInitParam
 			static bool validate(const Param* paramp) 
 			{
 				U32 num_valid = ((super_t*)paramp)->numValidElements();
-				return RANGE::minCount() <= num_valid && num_valid <= RANGE::maxCount();
+				return RANGE::minCount <= num_valid && num_valid <= RANGE::maxCount;
 			}
 		};
 
-		template <typename T, typename RANGE = BaseBlock::AnyAmount, typename NAME_VALUE_LOOKUP = TypeValues<T> >
-		class Batch : private TypedParam<T, NAME_VALUE_LOOKUP, false>
-		{
-		public:
-			typedef ParamValue<T, NAME_VALUE_LOOKUP>										param_value_t;
-			typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<param_value_t>::value>	super_t;
-			typedef Batch<T, RANGE, NAME_VALUE_LOOKUP>										self_t;
-			typedef typename super_t::value_assignment_t									value_assignment_t;
-			typedef typename super_t::value_t												value_t;
-
-			struct BatchDefaultValue : public ParamDescriptor::UserData
-			{
-				BatchDefaultValue(const T& value)
-				:	mValue(value)
-				{}
-
-				T mValue;
-			};
-
-			explicit Batch(const char* name, value_assignment_t val)
-			:	super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1),
-				mLastParseGeneration(-1)
-			{
-				BlockDescriptor& block_descriptor = DERIVED_BLOCK::selfBlockDescriptor();
-				if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING))
-				{
-					ParamDescriptorPtr param_descriptorp = block_descriptor.mCurrentBlockPtr->findParamDescriptor(*this);
-
-					if (param_descriptorp)
-					{
-						param_descriptorp->mDeserializeFunc = &deserializeParam;
-						param_descriptorp->mUserData = new BatchDefaultValue(new param_value_t(val));
-					}
-				}
-			}
-
-			explicit Batch(const char* name = "")
-			:	super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, defaultValue<T>(), NULL, 0, 1),
-				mLastParseGeneration(-1)
-			{
-				BlockDescriptor& block_descriptor = DERIVED_BLOCK::selfBlockDescriptor();
-				if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING))
-				{
-					ParamDescriptorPtr param_descriptorp = block_descriptor.mCurrentBlockPtr->findParamDescriptor(*this);
-
-					if (param_descriptorp)
-					{
-						param_descriptorp->mDeserializeFunc = &deserializeParam;
-					}
-				}
-			}
-
-			Batch& operator=(value_assignment_t val)
-			{
-				set(val);
-				return *this;
-			}
-
-			DERIVED_BLOCK& operator()(value_assignment_t val)
-			{
-				super_t::set(val);
-				return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock());
-			}
-
-			using super_t::operator();
-
-		private:
-			static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) 
-			{
-				self_t& typed_param = static_cast<self_t&>(param);
-
-				if (generation != typed_param.mLastParseGeneration)
-				{
-					ParamDescriptorPtr descriptor = typed_param.enclosingBlock().findParamDescriptor(param);
-					if (descriptor && static_cast<BatchDefaultValue*>(descriptor->mUserData))
-					{
-						static_cast<param_value_t&>(typed_param) = (static_cast<BatchDefaultValue*>(descriptor->mUserData))->mValue;
-					}
-					else
-					{
-						static_cast<param_value_t&>(typed_param) = param_value_t(value_t());
-					}
-					typed_param.mLastParseGeneration = generation;
-				}
-				return super_t::deserializeParam(param, parser, name_stack, generation);
-			}
-
-			S32 mLastParseGeneration;
-		};
-
 		class Deprecated : public Param
 		{
 		public:
@@ -1769,6 +1613,7 @@ namespace LLInitParam
 			}
 		};
 
+		// different semantics for documentation purposes, but functionally identical
 		typedef Deprecated Ignored;
 
 	protected:
@@ -1790,6 +1635,106 @@ namespace LLInitParam
 
 	};
 	
+	template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock>
+	class BatchBlock
+	:	public Block<DERIVED_BLOCK, BASE_BLOCK>
+	{
+	public:
+		typedef BatchBlock<DERIVED_BLOCK, BASE_BLOCK> self_t;
+		typedef Block<DERIVED_BLOCK, BASE_BLOCK> super_t;
+
+		BatchBlock()
+		:	mLastParseGeneration(-1)
+		{}
+
+		bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack, S32 generation)
+		{
+			if (generation != mLastParseGeneration)
+			{
+				// reset block
+				*static_cast<DERIVED_BLOCK*>(this) = defaultBatchValue();
+				mLastParseGeneration = generation;
+			}
+			return super_t::deserializeBlock(p, name_stack, generation);
+		}
+
+		bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
+		{
+			if (overwrite)
+			{
+				*static_cast<DERIVED_BLOCK*>(this) = defaultBatchValue();
+				mLastParseGeneration = -1;
+				// merge individual parameters into destination
+				return super_t::mergeBlock(super_t::selfBlockDescriptor(), src_typed_param, overwrite);
+			}
+			return false;
+		}
+	protected:
+		static const DERIVED_BLOCK& defaultBatchValue()
+		{
+			static DERIVED_BLOCK default_value;
+			return default_value;
+		}
+
+		S32 mLastParseGeneration;
+	};
+
+	
+
+	template<typename DERIVED_BLOCK,
+			typename BASE_BLOCK,
+			typename NAME_VALUE_LOOKUP>
+	class ParamValue <BatchBlock<DERIVED_BLOCK, BASE_BLOCK>,
+					NAME_VALUE_LOOKUP,
+					true>
+	:	public Param,
+		protected BatchBlock<DERIVED_BLOCK, BASE_BLOCK>
+	{
+		typedef const BatchBlock<DERIVED_BLOCK, BASE_BLOCK>&	value_assignment_t;
+
+		ParamValue()
+		:	T(),
+			mKeyVersion(0),
+			mValidatedVersion(-1),
+			mValidated(false)
+		{}
+
+		ParamValue(value_assignment_t other)
+		:	T(other),
+			mKeyVersion(0),
+			mValidatedVersion(-1),
+			mValidated(false)
+		{
+		}
+
+		void setValue(value_assignment_t val)
+		{
+			*this = val;
+			mLastParseGeneration = -1;
+		}
+
+		value_assignment_t getValue() const
+		{
+			return *this;
+		}
+
+		BatchBlock<DERIVED_BLOCK, BASE_BLOCK>& getValue()
+		{
+			return *this;
+		}
+
+		operator value_assignment_t() const
+		{
+			return *this;
+		}
+
+		value_assignment_t operator()() const
+		{
+			return *this;
+		}
+
+	};
+
 	template<typename T>
 	class CustomParamValue
 	:	public Block<ParamValue<T, TypeValues<T> > >,
@@ -1955,6 +1900,16 @@ namespace LLInitParam
 			return mValue;
 		}
 
+		operator value_assignment_t() const
+		{
+			return getValue();
+		}
+
+		value_assignment_t operator()() const
+		{
+			return getValue();
+		}
+
 		S32 				mKeyVersion;
 
 	protected:
@@ -1965,30 +1920,29 @@ namespace LLInitParam
 			mValue = value;
 		}
 
-		bool mergeBlockParam(bool param_provided, BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
+		bool mergeBlockParam(bool source_provided, bool dst_provided, BlockDescriptor& block_data, const BaseBlock& source, bool overwrite)
 		{
-			if (param_provided)
-			{
-				return mergeBlock(block_data, other, overwrite);
-			}
-			return false;
-		}
+			bool source_override = source_provided && (overwrite || !dst_provided);
 
-		bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
-		{
-			const derived_t& src_typed_param = static_cast<const derived_t&>(other);
+			const derived_t& src_typed_param = static_cast<const derived_t&>(source);
 
-			if (src_typed_param.mValueAge == VALUE_AUTHORITATIVE)
+			if (source_override && src_typed_param.mValueAge == VALUE_AUTHORITATIVE)
 			{
 				// copy value over
 				setValue(src_typed_param.getValue());
 				return true;
 			}
-			else
+			// merge individual parameters into destination
+			if (mValueAge == VALUE_AUTHORITATIVE)
 			{
-				// merge individual parameters into destination
-				return block_t::mergeBlock(block_t::selfBlockDescriptor(), src_typed_param, overwrite);
+				static_cast<derived_t*>(this)->updateBlockFromValue(dst_provided);
 			}
+			return mergeBlock(block_data, source, overwrite);
+		}
+
+		bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& source, bool overwrite)
+		{
+			return block_t::mergeBlock(block_data, source, overwrite);
 		}
 
 		mutable S32			mValidatedVersion;
diff --git a/indra/llxuixml/llxuiparser.cpp b/indra/llxuixml/llxuiparser.cpp
index 4af077b22c..c60f656c2c 100644
--- a/indra/llxuixml/llxuiparser.cpp
+++ b/indra/llxuixml/llxuiparser.cpp
@@ -51,6 +51,136 @@ static 	LLInitParam::Parser::parser_read_func_map_t sXSDReadFuncs;
 static 	LLInitParam::Parser::parser_write_func_map_t sXSDWriteFuncs;
 static 	LLInitParam::Parser::parser_inspect_func_map_t sXSDInspectFuncs;
 
+struct MaxOccur : public LLInitParam::ChoiceBlock<MaxOccur>
+{
+	Alternative<int> count;
+	Alternative<std::string> unbounded;
+
+	MaxOccur()
+	:	unbounded("", "unbounded")
+	{}
+};
+
+struct Occurs : public LLInitParam::Block<Occurs>
+{
+	Optional<S32>	minOccurs;
+	Optional<MaxOccur>	maxOccurs;
+
+	Occurs()
+	:	minOccurs("minOccurs"),
+		maxOccurs("maxOccurs")
+	{
+		minOccurs = 0;
+		maxOccurs.unbounded.choose();
+	}
+};
+
+
+typedef enum
+{
+	USE_REQUIRED,
+	USE_OPTIONAL
+} EUse;
+
+namespace LLInitParam
+{
+	template<>
+	struct TypeValues<EUse> : public TypeValuesHelper<EUse>
+	{
+		static void declareValues()
+		{
+			declare("required", USE_REQUIRED);
+			declare("optional", USE_OPTIONAL);
+		}
+	};
+}
+
+struct Name : public LLInitParam::Block<Name>
+{
+	Mandatory<std::string> name;
+
+	Name()
+	:	name("name")
+	{}
+};
+
+struct Attribute : public LLInitParam::Block<Attribute>
+{
+	Mandatory<Name>			name;
+	Mandatory<std::string>	type;
+	Mandatory<EUse>			use;
+	
+	Attribute()
+	:	name("name"),
+		type("type"),
+		use("use")
+	{
+	}
+};
+
+struct ComplexType : public LLInitParam::Block<ComplexType>
+{
+	Multiple<Attribute>			attribute;
+	//Multiple<struct Element>	elements;
+	Optional<bool>				mixed;
+
+	ComplexType()
+	:	attribute("xs:attribute"),
+		//elements("xs:element"),
+		mixed("mixed")
+	{
+		mixed = true;
+	}
+};
+
+struct Element : public LLInitParam::Block<Element, Occurs>
+{
+	Mandatory<ComplexType>	complexType;
+	Mandatory<Name>			name;
+
+	Element()
+	:	complexType("xs:complexType")
+	{}
+};
+
+struct Elements : public LLInitParam::Block<Elements, Occurs>
+{
+	Multiple<Element> elements;
+
+	Elements()
+	:	elements("xs:element")
+	{}
+};
+
+struct Schema : public LLInitParam::Block<Schema>
+{
+private:
+	Mandatory<std::string>	targetNamespace,
+							xmlns;
+
+public:
+	Optional<std::string>	attributeFormDefault,
+							elementFormDefault,
+							xs;
+
+	Optional<Elements>		elements;
+	
+	void setNameSpace(const std::string& ns) {targetNamespace = ns; xmlns = ns;}
+
+	Schema()
+	:	attributeFormDefault("attributeFormDefault"),
+		elementFormDefault("elementFormDefault"),
+		xs("xmlns:xs"),
+		targetNamespace("targetNamespace"),
+		xmlns("xmlns"),
+		elements("xs:choice")
+	{
+		attributeFormDefault = "unqualified";
+		elementFormDefault = "qualified";
+		xs = "http://www.w3.org/2001/XMLSchema";
+	}
+
+};
 
 //
 // LLXSDWriter
@@ -388,7 +518,7 @@ LLXUIParser::LLXUIParser()
 {
 	if (sXUIReadFuncs.empty())
 	{
-		registerParserFuncs<LLInitParam::NoParamValue>(readNoValue, writeNoValue);
+		registerParserFuncs<LLInitParam::Flag>(readFlag, writeFlag);
 		registerParserFuncs<bool>(readBoolValue, writeBoolValue);
 		registerParserFuncs<std::string>(readStringValue, writeStringValue);
 		registerParserFuncs<U8>(readU8Value, writeU8Value);
@@ -645,13 +775,13 @@ LLXMLNodePtr LLXUIParser::getNode(const name_stack_t& stack)
 	return (out_node == mWriteRootNode ? LLXMLNodePtr(NULL) : out_node);
 }
 
-bool LLXUIParser::readNoValue(Parser& parser, void* val_ptr)
+bool LLXUIParser::readFlag(Parser& parser, void* val_ptr)
 {
 	LLXUIParser& self = static_cast<LLXUIParser&>(parser);
 	return self.mCurReadNode == DUMMY_NODE;
 }
 
-bool LLXUIParser::writeNoValue(Parser& parser, const void* val_ptr, const name_stack_t& stack)
+bool LLXUIParser::writeFlag(Parser& parser, const void* val_ptr, const name_stack_t& stack)
 {
 	// just create node
 	LLXUIParser& self = static_cast<LLXUIParser&>(parser);
@@ -1083,7 +1213,7 @@ LLSimpleXUIParser::LLSimpleXUIParser(LLSimpleXUIParser::element_start_callback_t
 {
 	if (sSimpleXUIReadFuncs.empty())
 	{
-		registerParserFuncs<LLInitParam::NoParamValue>(readNoValue);
+		registerParserFuncs<LLInitParam::Flag>(readFlag);
 		registerParserFuncs<bool>(readBoolValue);
 		registerParserFuncs<std::string>(readStringValue);
 		registerParserFuncs<U8>(readU8Value);
@@ -1376,7 +1506,7 @@ void LLSimpleXUIParser::parserError(const std::string& message)
 #endif
 }
 
-bool LLSimpleXUIParser::readNoValue(Parser& parser, void* val_ptr)
+bool LLSimpleXUIParser::readFlag(Parser& parser, void* val_ptr)
 {
 	LLSimpleXUIParser& self = static_cast<LLSimpleXUIParser&>(parser);
 	return self.mCurAttributeValueBegin == NO_VALUE_MARKER;
diff --git a/indra/llxuixml/llxuiparser.h b/indra/llxuixml/llxuiparser.h
index 0c38c4da93..42a79b4100 100644
--- a/indra/llxuixml/llxuiparser.h
+++ b/indra/llxuixml/llxuiparser.h
@@ -116,7 +116,7 @@ private:
 	bool readAttributes(LLXMLNodePtr nodep, LLInitParam::BaseBlock& block);
 
 	//reader helper functions
-	static bool readNoValue(Parser& parser, void* val_ptr);
+	static bool readFlag(Parser& parser, void* val_ptr);
 	static bool readBoolValue(Parser& parser, void* val_ptr);
 	static bool readStringValue(Parser& parser, void* val_ptr);
 	static bool readU8Value(Parser& parser, void* val_ptr);
@@ -133,7 +133,7 @@ private:
 	static bool readSDValue(Parser& parser, void* val_ptr);
 
 	//writer helper functions
-	static bool writeNoValue(Parser& parser, const void* val_ptr, const name_stack_t&);
+	static bool writeFlag(Parser& parser, const void* val_ptr, const name_stack_t&);
 	static bool writeBoolValue(Parser& parser, const void* val_ptr, const name_stack_t&);
 	static bool writeStringValue(Parser& parser, const void* val_ptr, const name_stack_t&);
 	static bool writeU8Value(Parser& parser, const void* val_ptr, const name_stack_t&);
@@ -197,7 +197,7 @@ public:
 
 private:
 	//reader helper functions
-	static bool readNoValue(Parser&, void* val_ptr);
+	static bool readFlag(Parser&, void* val_ptr);
 	static bool readBoolValue(Parser&, void* val_ptr);
 	static bool readStringValue(Parser&, void* val_ptr);
 	static bool readU8Value(Parser&, void* val_ptr);
diff --git a/indra/newview/llnamelistctrl.h b/indra/newview/llnamelistctrl.h
index d64fdbe6a5..ca9956dc53 100644
--- a/indra/newview/llnamelistctrl.h
+++ b/indra/newview/llnamelistctrl.h
@@ -61,7 +61,7 @@ public:
 		{}
 	};
 
-	struct NameColumn : public LLInitParam::Choice<NameColumn>
+	struct NameColumn : public LLInitParam::ChoiceBlock<NameColumn>
 	{
 		Alternative<S32>				column_index;
 		Alternative<std::string>		column_name;
diff --git a/indra/newview/skins/default/xui/en/panel_toolbar_view.xml b/indra/newview/skins/default/xui/en/panel_toolbar_view.xml
index fa7632920b..7bbacc0152 100644
--- a/indra/newview/skins/default/xui/en/panel_toolbar_view.xml
+++ b/indra/newview/skins/default/xui/en/panel_toolbar_view.xml
@@ -33,7 +33,6 @@
                   follows="all"
                   mouse_opaque="false">
       <layout_panel name="left_toolbar_panel"
-                    fit_content="true"
                     auto_resize="false"
                     user_resize="false"
                     height="500"
@@ -54,7 +53,6 @@
                     user_resize="false"
                     mouse_opaque="false"/>
       <layout_panel name="right_toolbar_panel"
-                    fit_content="true"
                     auto_resize="false"
                     user_resize="false"
                     height="500"
@@ -74,7 +72,6 @@
     </layout_stack>
   </layout_panel>
   <layout_panel name="bottom_toolbar_panel"
-                fit_content="true"
                 auto_resize="false"
                 user_resize="false"
                 height="30"
diff --git a/indra/newview/skins/default/xui/en/widgets/toolbar.xml b/indra/newview/skins/default/xui/en/widgets/toolbar.xml
index 32bc88cc9a..d16d70cb43 100644
--- a/indra/newview/skins/default/xui/en/widgets/toolbar.xml
+++ b/indra/newview/skins/default/xui/en/widgets/toolbar.xml
@@ -10,6 +10,7 @@
   <button_panel name="button_panel"
                 bg_opaque_image="Rounded_Rect"
                 background_visible="true"
+                bg_opaque_color="MouseGray"
                 background_opaque="true"/>
   <button_icon_and_text follows="left|top"
                         chrome="true"