livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Automated merge with ssh://hg.lindenlab.com/richard/viewer-chui

master
Richard Linden 2012-07-23 19:34:10 -07:00
parent 3ae21b429e 176b7d82be
commit 310ebe90a9
7 changed files with 66 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
indra/llui/llnotifications.cpp
View File

@ -223,14 +223,6 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
LLParamSDParser parser;
parser.writeSD(mFormData, p.form_elements);
if (!mFormData.isArray() && !mFormData.isUndefined())
{
// change existing contents to a one element array
LLSD new_llsd_array = LLSD::emptyArray();
new_llsd_array.append(mFormData);
mFormData = new_llsd_array;
}
for (LLSD::array_iterator it = mFormData.beginArray(), end_it = mFormData.endArray();
it != end_it;
++it)
@ -516,7 +508,7 @@ LLSD LLNotification::asLLSD()
p.id = mId;
p.name = mTemplatep->mName;
p.form_elements = getForm()->asLLSD();
p.substitutions = mSubstitutions;
p.payload = mPayload;
p.time_stamp = mTimestamp;

33
indra/llui/llsdparam.cpp
View File

@ -223,10 +223,14 @@ LLSD& LLParamSDParserUtilities::getSDWriteNode(LLSD& input, LLInitParam::Parser:
{
bool new_traversal = it->second;
LLSD* child_sd = it->first.empty() ? sd_to_write : &(*sd_to_write)[it->first];
if (child_sd->isArray())
LLSD* child_sd;
if (it->first.empty())
{
child_sd = sd_to_write;
if (child_sd->isUndefined())
{
*child_sd = LLSD::emptyArray();
}
if (new_traversal)
{
// write to new element at end
@ -240,22 +244,7 @@ LLSD& LLParamSDParserUtilities::getSDWriteNode(LLSD& input, LLInitParam::Parser:
}
else
{
if (new_traversal
&& child_sd->isDefined()
&& !child_sd->isArray())
{
// copy child contents into first element of an array
LLSD new_array = LLSD::emptyArray();
new_array.append(*child_sd);
// assign array to slot that previously held the single value
*child_sd = new_array;
// return next element in that array
sd_to_write = &((*child_sd)[1]);
}
else
{
sd_to_write = child_sd;
}
sd_to_write = &(*sd_to_write)[it->first];
}
it->second = false;
}
@ -283,11 +272,9 @@ void LLParamSDParserUtilities::readSDValues(read_sd_cb_t cb, const LLSD& sd, LLI
it != sd.endArray();
++it)
{
if (!stack.empty())
{
stack.back().second = true;
}
stack.push_back(make_pair(std::string(), true));
readSDValues(cb, *it, stack);
stack.pop_back();
}
}
else if (sd.isUndefined())

87
indra/llxml/llxmlnode.cpp
View File

@ -259,7 +259,7 @@ BOOL LLXMLNode::removeChild(LLXMLNode *target_child)
return FALSE;
}
void LLXMLNode::addChild(LLXMLNodePtr new_child, LLXMLNodePtr after_child)
void LLXMLNode::addChild(LLXMLNodePtr& new_child)
{
if (new_child->mParent != NULL)
{
@ -273,6 +273,11 @@ void LLXMLNode::addChild(LLXMLNodePtr new_child, LLXMLNodePtr after_child)
new_child->mParent = this;
if (new_child->mIsAttribute)
{
LLXMLAttribList::iterator found_it = mAttributes.find(new_child->mName);
if (found_it != mAttributes.end())
{
removeChild(found_it->second);
}
mAttributes.insert(std::make_pair(new_child->mName, new_child));
}
else
@ -285,49 +290,11 @@ void LLXMLNode::addChild(LLXMLNodePtr new_child, LLXMLNodePtr after_child)
}
mChildren->map.insert(std::make_pair(new_child->mName, new_child));
// if after_child is specified, it damn well better be in the list of children
// for this node. I'm not going to assert that, because it would be expensive,
// but don't specify that parameter if you didn't get the value for it from the
// list of children of this node!
if (after_child.isNull())
if (mChildren->tail != new_child)
{
if (mChildren->tail != new_child)
{
mChildren->tail->mNext = new_child;
new_child->mPrev = mChildren->tail;
mChildren->tail = new_child;
}
}
// if after_child == parent, then put new_child at beginning
else if (after_child == this)
{
// add to front of list
new_child->mNext = mChildren->head;
if (mChildren->head)
{
mChildren->head->mPrev = new_child;
mChildren->head = new_child;
}
else // no children
{
mChildren->head = new_child;
mChildren->tail = new_child;
}
}
else
{
if (after_child->mNext.notNull())
{
// if after_child was not the last item, fix up some pointers
after_child->mNext->mPrev = new_child;
new_child->mNext = after_child->mNext;
}
new_child->mPrev = after_child;
after_child->mNext = new_child;
if (mChildren->tail == after_child)
{
mChildren->tail = new_child;
}
mChildren->tail->mNext = new_child;
new_child->mPrev = mChildren->tail;
mChildren->tail = new_child;
}
}
@ -343,8 +310,9 @@ LLXMLNodePtr LLXMLNode::createChild(const char* name, BOOL is_attribute)
// virtual
LLXMLNodePtr LLXMLNode::createChild(LLStringTableEntry* name, BOOL is_attribute)
{
LLXMLNode* ret = new LLXMLNode(name, is_attribute);
LLXMLNodePtr ret(new LLXMLNode(name, is_attribute));
ret->mID.clear();
addChild(ret);
return ret;
}
@ -358,11 +326,12 @@ BOOL LLXMLNode::deleteChild(LLXMLNode *child)
return FALSE;
}
void LLXMLNode::setParent(LLXMLNodePtr new_parent)
void LLXMLNode::setParent(LLXMLNodePtr& new_parent)
{
if (new_parent.notNull())
{
new_parent->addChild(this);
LLXMLNodePtr this_ptr(this);
new_parent->addChild(this_ptr);
}
else
{
@ -681,27 +650,6 @@ bool LLXMLNode::updateNode(
return TRUE;
}
// static
LLXMLNodePtr LLXMLNode::replaceNode(LLXMLNodePtr node, LLXMLNodePtr update_node)
{
if (!node || !update_node)
{
llwarns << "Node invalid" << llendl;
return node;
}
LLXMLNodePtr cloned_node = update_node->deepCopy();
node->mParent->addChild(cloned_node, node); // add after node
LLXMLNodePtr parent = node->mParent;
parent->removeChild(node);
parent->updateDefault();
return cloned_node;
}
// static
bool LLXMLNode::parseFile(const std::string& filename, LLXMLNodePtr& node, LLXMLNode* defaults_tree)
{
@ -1198,7 +1146,7 @@ void LLXMLNode::scrubToTree(LLXMLNode *tree)
std::vector<LLXMLNodePtr>::iterator itor3;
for (itor3=to_delete_list.begin(); itor3!=to_delete_list.end(); ++itor3)
{
(*itor3)->setParent(NULL);
(*itor3)->setParent(LLXMLNodePtr());
}
}
}
@ -2733,7 +2681,8 @@ void LLXMLNode::setName(LLStringTableEntry* name)
mName = name;
if (old_parent)
{
old_parent->addChild(this);
LLXMLNodePtr this_ptr(this);
old_parent->addChild(this_ptr);
}
}

5
indra/llxml/llxmlnode.h
View File

@ -127,8 +127,8 @@ public:
BOOL isNull();
BOOL deleteChild(LLXMLNode* child);
void addChild(LLXMLNodePtr new_child, LLXMLNodePtr after_child = LLXMLNodePtr(NULL));
void setParent(LLXMLNodePtr new_parent); // reparent if necessary
void addChild(LLXMLNodePtr& new_child);
void setParent(LLXMLNodePtr& new_parent); // reparent if necessary
// Serialization
static bool parseFile(
@ -147,7 +147,6 @@ public:
static bool updateNode(
LLXMLNodePtr& node,
LLXMLNodePtr& update_node);
static LLXMLNodePtr replaceNode(LLXMLNodePtr node, LLXMLNodePtr replacement_node);
static bool getLayeredXMLNode(LLXMLNodePtr& root, const std::vector<std::string>& paths);

5
indra/llxuixml/llinitparam.cpp
View File

@ -227,12 +227,7 @@ namespace LLInitParam
if (serialize_func)
{
const Param* diff_param = diff_block ? diff_block->getParamFromHandle(param_handle) : NULL;
// each param descriptor remembers its serial number
// so we can inspect the same param under different names
// and see that it has the same number
name_stack.push_back(std::make_pair("", true));
serialize_func(*param, parser, name_stack, diff_param);
name_stack.pop_back();
}
}

31
indra/llxuixml/llinitparam.h
View File

@ -1317,10 +1317,18 @@ namespace LLInitParam
static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name)
{
Parser::name_stack_range_t new_name_stack_range(name_stack_range);
self_t& typed_param = static_cast<self_t&>(param);
value_t value;
// pop first element if empty string
if (new_name_stack_range.first != new_name_stack_range.second && new_name_stack_range.first->first.empty())
{
++new_name_stack_range.first;
}
// no further names in stack, attempt to parse value now
if (name_stack_range.first == name_stack_range.second)
if (new_name_stack_range.first == new_name_stack_range.second)
{
// attempt to read value directly
if (parser.readValue(value))
@ -1353,14 +1361,14 @@ namespace LLInitParam
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);
if (!typed_param.isProvided() || name_stack.empty()) return;
if (!typed_param.isProvided()) return;
for (const_iterator it = typed_param.mValues.begin(), end_it = typed_param.mValues.end();
it != end_it;
++it)
{
std::string key = it->getValueName();
name_stack.back().second = true;
name_stack.push_back(std::make_pair(std::string(), true));
if(key.empty())
// not parsed via name values, write out value directly
@ -1382,6 +1390,8 @@ namespace LLInitParam
break;
}
}
name_stack.pop_back();
}
}
@ -1519,9 +1529,16 @@ namespace LLInitParam
static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name)
{
Parser::name_stack_range_t new_name_stack_range(name_stack_range);
self_t& typed_param = static_cast<self_t&>(param);
bool new_value = false;
// pop first element if empty string
if (new_name_stack_range.first != new_name_stack_range.second && new_name_stack_range.first->first.empty())
{
new_value |= new_name_stack_range.first->second;
++new_name_stack_range.first;
}
if (new_name || typed_param.mValues.empty())
{
new_value = true;
@ -1531,7 +1548,7 @@ namespace LLInitParam
param_value_t& value = typed_param.mValues.back();
// attempt to parse block...
if(value.deserializeBlock(parser, name_stack_range, new_name))
if(value.deserializeBlock(parser, new_name_stack_range, new_name))
{
typed_param.setProvided();
return true;
@ -1564,13 +1581,13 @@ namespace LLInitParam
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);
if (!typed_param.isProvided() || name_stack.empty()) return;
if (!typed_param.isProvided()) return;
for (const_iterator it = typed_param.mValues.begin(), end_it = typed_param.mValues.end();
it != end_it;
++it)
{
name_stack.back().second = true;
name_stack.push_back(std::make_pair(std::string(), true));
std::string key = it->getValueName();
if (!key.empty())
@ -1583,6 +1600,8 @@ namespace LLInitParam
{
it->serializeBlock(parser, name_stack, NULL);
}
name_stack.pop_back();
}
}

12
indra/llxuixml/llxuiparser.cpp
View File

@ -621,7 +621,7 @@ void LLXUIXSDWriter::writeXSD(const std::string& type_name, const std::string& p
nodep->createChild("schemaLocation", true)->setStringValue(widget_name + ".xsd");
// add to front of schema
mSchemaNode->addChild(nodep, mSchemaNode);
mSchemaNode->addChild(nodep);
}
for (widget_registry_t::Registrar::registry_map_t::const_iterator it = widget_registryp->currentRegistrar().beginItems();
@ -877,16 +877,24 @@ LLXMLNodePtr LLXUIParser::getNode(name_stack_t& stack)
it = next_it)
{
++next_it;
bool force_new_node = false;
if (it->first.empty())
{
it->second = false;
continue;
}
if (next_it != stack.end() && next_it->first.empty() && next_it->second)
{
force_new_node = true;
}
out_nodes_t::iterator found_it = mOutNodes.find(it->first);
// node with this name not yet written
if (found_it == mOutNodes.end() || it->second)
if (found_it == mOutNodes.end() || it->second || force_new_node)
{
// make an attribute if we are the last element on the name stack
bool is_attribute = next_it == stack.end();