Merged skinning-17 into viewer-2 for bug fixes. Commented out new IM window for now, not complete.

Merging revisions 127913-128319 of svn+ssh://svn.lindenlab.com/svn/linden/branches/skinning/skinning-17 into D:\viewer-2.0.0-3, respecting ancestry

1 files changed, 315 insertions, 0 deletions

diff --git a/indra/llui/llrngwriter.cpp b/indra/llui/llrngwriter.cpp
new file mode 100644
index 0000000000..cf23e3af15
--- /dev/null
+++ b/indra/llui/llrngwriter.cpp
@@ -0,0 +1,315 @@
+/** 
+ * @file llrngwriter.cpp
+ * @brief Generates Relax NG schema from param blocks
+ *
+ * $LicenseInfo:firstyear=2003&license=viewergpl$
+ * 
+ * Copyright (c) 2003-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llrngwriter.h"
+#include "lluicolor.h"
+#include "lluictrlfactory.h"
+
+//
+// LLRNGWriter - writes Relax NG schema files based on a param block
+//
+LLRNGWriter::LLRNGWriter()
+{
+	// register various callbacks for inspecting the contents of a param block
+	registerInspectFunc<bool>(boost::bind(&LLRNGWriter::writeAttribute, this, "boolean", _1, _2, _3, _4));
+	registerInspectFunc<std::string>(boost::bind(&LLRNGWriter::writeAttribute, this, "string", _1, _2, _3, _4));
+	registerInspectFunc<U8>(boost::bind(&LLRNGWriter::writeAttribute, this, "unsignedByte", _1, _2, _3, _4));
+	registerInspectFunc<S8>(boost::bind(&LLRNGWriter::writeAttribute, this, "signedByte", _1, _2, _3, _4));
+	registerInspectFunc<U16>(boost::bind(&LLRNGWriter::writeAttribute, this, "unsignedShort", _1, _2, _3, _4));
+	registerInspectFunc<S16>(boost::bind(&LLRNGWriter::writeAttribute, this, "signedShort", _1, _2, _3, _4));
+	registerInspectFunc<U32>(boost::bind(&LLRNGWriter::writeAttribute, this, "unsignedInt", _1, _2, _3, _4));
+	registerInspectFunc<S32>(boost::bind(&LLRNGWriter::writeAttribute, this, "integer", _1, _2, _3, _4));
+	registerInspectFunc<F32>(boost::bind(&LLRNGWriter::writeAttribute, this, "float", _1, _2, _3, _4));
+	registerInspectFunc<F64>(boost::bind(&LLRNGWriter::writeAttribute, this, "double", _1, _2, _3, _4));
+	registerInspectFunc<LLColor4>(boost::bind(&LLRNGWriter::writeAttribute, this, "string", _1, _2, _3, _4));
+	registerInspectFunc<LLUIColor>(boost::bind(&LLRNGWriter::writeAttribute, this, "string", _1, _2, _3, _4));
+	registerInspectFunc<LLUUID>(boost::bind(&LLRNGWriter::writeAttribute, this, "string", _1, _2, _3, _4));
+	registerInspectFunc<LLSD>(boost::bind(&LLRNGWriter::writeAttribute, this, "string", _1, _2, _3, _4));
+}
+
+void LLRNGWriter::writeRNG(const std::string& type_name, LLXMLNodePtr node, const LLInitParam::BaseBlock& block, const std::string& xml_namespace)
+{
+	mGrammarNode = node;
+	mGrammarNode->setName("grammar");
+	mGrammarNode->createChild("xmlns", true)->setStringValue("http://relaxng.org/ns/structure/1.0");
+	mGrammarNode->createChild("datatypeLibrary", true)->setStringValue("http://www.w3.org/2001/XMLSchema-datatypes");
+	mGrammarNode->createChild("ns", true)->setStringValue(xml_namespace);
+
+	node = mGrammarNode->createChild("start", false);
+	node = node->createChild("ref", false);
+	node->createChild("name", true)->setStringValue(type_name);
+
+	addDefinition(type_name, block);
+}
+
+void LLRNGWriter::addDefinition(const std::string& type_name, const LLInitParam::BaseBlock& block)
+{
+	if (mDefinedElements.find(type_name) != mDefinedElements.end()) return;
+	mDefinedElements.insert(type_name);
+
+	LLXMLNodePtr node = mGrammarNode->createChild("define", false);
+	node->createChild("name", true)->setStringValue(type_name);
+
+	mElementNode = node->createChild("element", false);
+	mElementNode->createChild("name", true)->setStringValue(type_name);
+	mChildrenNode = mElementNode->createChild("zeroOrMore", false)->createChild("choice", false);
+
+	mAttributesWritten.first = mElementNode;
+	mAttributesWritten.second.clear();
+	mElementsWritten.clear();
+
+	block.inspectBlock(*this);
+
+	// add includes for all possible children
+	const std::type_info* type = *LLWidgetTypeRegistry::instance().getValue(type_name);
+	const widget_registry_t* widget_registryp = LLChildRegistryRegistry::instance().getValue(type);
+	
+	// add include declarations for all valid children
+	for (widget_registry_t::Registrar::registry_map_t::const_iterator it = widget_registryp->currentRegistrar().beginItems();
+		it != widget_registryp->currentRegistrar().endItems();
+		++it)
+	{
+		std::string child_name = it->first;
+		if (child_name == type_name)
+		{
+			continue;
+		}
+		
+		LLXMLNodePtr old_element_node = mElementNode;
+		LLXMLNodePtr old_child_node = mChildrenNode;
+		addDefinition(child_name, (*LLDefaultParamBlockRegistry::instance().getValue(type))());
+		mElementNode = old_element_node;
+		mChildrenNode = old_child_node;
+
+		mChildrenNode->createChild("ref", false)->createChild("name", true)->setStringValue(child_name);
+	}
+
+	if (mChildrenNode->mChildren.isNull())
+	{
+		// remove unused children node
+		mChildrenNode->mParent->mParent->deleteChild(mChildrenNode->mParent);
+	}
+}
+
+void LLRNGWriter::writeAttribute(const std::string& type, const Parser::name_stack_t& stack, S32 min_count, S32 max_count, const std::vector<std::string>* possible_values)
+{
+	if (max_count == 0) return;
+
+	name_stack_t non_empty_names;
+	std::string attribute_name;
+	for (name_stack_t::const_iterator it = stack.begin();
+		it != stack.end();
+		++it)
+	{
+		const std::string& name = it->first;
+		if (!name.empty())
+		{
+			non_empty_names.push_back(*it);
+		}
+	}
+
+	if (non_empty_names.empty()) return;
+
+	for (name_stack_t::const_iterator it = non_empty_names.begin();
+		it != non_empty_names.end();
+		++it)
+	{
+		if (!attribute_name.empty())
+		{
+			attribute_name += ".";
+		}
+		attribute_name += it->first;
+	}
+
+	// singular attribute, e.g. <foo bar="1"/>
+	if (non_empty_names.size() == 1 && max_count == 1)
+	{
+		if (mAttributesWritten.second.find(attribute_name) == mAttributesWritten.second.end())
+		{
+			LLXMLNodePtr node = createCardinalityNode(mElementNode, min_count, max_count)->createChild("attribute", false);
+			node->createChild("name", true)->setStringValue(attribute_name);
+			node->createChild("data", false)->createChild("type", true)->setStringValue(type);
+
+			mAttributesWritten.second.insert(attribute_name);
+		}
+	}
+	// compound attribute
+	else
+	{
+		std::string element_name;
+
+		// traverse all but last element, leaving that as an attribute name
+		name_stack_t::const_iterator end_it = non_empty_names.end();
+		end_it--;
+
+		for (name_stack_t::const_iterator it = non_empty_names.begin();
+			it != end_it;
+			++it)
+		{
+			if (it != non_empty_names.begin())
+			{
+				element_name += ".";
+			}
+			element_name += it->first;
+		}
+
+		elements_map_t::iterator found_it = mElementsWritten.find(element_name);
+		// <choice>
+		//   <group>
+		//     <optional>
+		//	     <attribute name="foo.bar"><data type="string"/></attribute>
+		//     </optional>
+		//     <optional>
+		//       <attribute name="foo.baz"><data type="integer"/></attribute>
+		//     </optional>
+		//   </group>
+		//   <element name="foo">
+		//     <optional>
+		//       <attribute name="bar"><data type="string"/></attribute>
+		//     </optional>
+		//     <optional>
+		//       <attribute name="baz"><data type="string"/></attribute>
+		//     </optional>
+		//   </element>
+		//   <element name="outer.foo">
+		//     <ref name="foo"/>
+		//   </element>
+		// </choice>
+
+		if (found_it != mElementsWritten.end())
+		{
+			// reuse existing element
+			LLXMLNodePtr choice_node = found_it->second.first;
+
+			// attribute with this name not already written?
+			if (found_it->second.second.find(attribute_name) == found_it->second.second.end())
+			{
+				// append to <group>
+				LLXMLNodePtr node = choice_node->mChildren->head;
+				node = createCardinalityNode(node, min_count, max_count)->createChild("attribute", false);
+				node->createChild("name", true)->setStringValue(attribute_name);
+				addTypeNode(node, type, possible_values);
+
+				// append to <element>
+				node = choice_node->mChildren->head->mNext->mChildren->head;
+				node = createCardinalityNode(node, min_count, max_count)->createChild("attribute", false);
+				node->createChild("name", true)->setStringValue(non_empty_names.back().first);
+				addTypeNode(node, type, possible_values);
+
+				// append to <element>
+				//node = choice_node->mChildren->head->mNext->mNext->mChildren->head;
+				//node = createCardinalityNode(node, min_count, max_count)->createChild("attribute", false);
+				//node->createChild("name", true)->setStringValue(non_empty_names.back().first);
+				//addTypeNode(node, type, possible_values);
+
+				found_it->second.second.insert(attribute_name);
+			}
+		}
+		else
+		{
+			LLXMLNodePtr choice_node = mElementNode->createChild("choice", false);
+
+			LLXMLNodePtr node = choice_node->createChild("group", false);
+			node = createCardinalityNode(node, min_count, max_count)->createChild("attribute", false);
+			node->createChild("name", true)->setStringValue(attribute_name);
+			addTypeNode(node, type, possible_values);
+
+			node = choice_node->createChild("optional", false);
+			node = node->createChild("element", false);
+			node->createChild("name", true)->setStringValue(element_name);
+			node = createCardinalityNode(node, min_count, max_count)->createChild("attribute", false);
+			node->createChild("name", true)->setStringValue(non_empty_names.back().first);
+			addTypeNode(node, type, possible_values);
+			
+			//node = choice_node->createChild("optional", false);
+			//node = node->createChild("element", false);
+			//node->createChild("name", true)->setStringValue(mDefinitionName + "." + element_name);
+			//node = createCardinalityNode(node, min_count, max_count)->createChild("attribute", false);
+			//node->createChild("name", true)->setStringValue(non_empty_names.back().first);
+			//addTypeNode(node, type, possible_values);
+
+			attribute_data_t& attribute_data = mElementsWritten[element_name];
+			attribute_data.first = choice_node;
+			attribute_data.second.insert(attribute_name);
+		}
+	}
+}
+
+void LLRNGWriter::addTypeNode(LLXMLNodePtr parent_node, const std::string& type, const std::vector<std::string>* possible_values)
+{
+	if (possible_values)
+	{
+		LLXMLNodePtr enum_node = parent_node->createChild("choice", false);
+		for (std::vector<std::string>::const_iterator it = possible_values->begin();
+			it != possible_values->end();
+			++it)
+		{
+			enum_node->createChild("value", false)->setStringValue(*it);
+		}
+	}
+	else
+	{
+		parent_node->createChild("data", false)->createChild("type", true)->setStringValue(type);
+	}
+}
+
+LLXMLNodePtr LLRNGWriter::createCardinalityNode(LLXMLNodePtr parent_node, S32 min_count, S32 max_count)
+{
+	// unlinked by default, meaning this attribute is forbidden
+	LLXMLNodePtr count_node = new LLXMLNode();
+	if (min_count == 0)
+	{
+		if (max_count == 1)
+		{
+			count_node = parent_node->createChild("optional", false);
+		}
+		else if (max_count > 1)
+		{
+			count_node = parent_node->createChild("zeroOrMore", false);
+		}	
+	}
+	else if (min_count >= 1)
+	{
+		if (max_count == 1 && min_count == 1)
+		{
+			// just add raw element, will count as 1 and only 1
+			count_node = parent_node;
+		}
+		else
+		{
+			count_node = parent_node->createChild("oneOrMore", false);
+		}
+	}
+	return count_node;
+}