1 files changed, 335 insertions, 264 deletions

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 7b8f51ae3c..30cd85619e 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -2,38 +2,34 @@
 * @file llnotifications.cpp
 * @brief Non-UI queue manager for keeping a prioritized list of notifications
 *
-* $LicenseInfo:firstyear=2008&license=viewergpl$
-* 
-* Copyright (c) 2008-2009, Linden Research, Inc.
-* 
+* $LicenseInfo:firstyear=2008&license=viewerlgpl$
 * 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
+* Copyright (C) 2010, Linden Research, Inc.
+* 
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation;
+* version 2.1 of the License only.
 * 
-* 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
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
 * 
-* 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.
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
-* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
-* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
-* COMPLETENESS OR PERFORMANCE.
+* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */
 
 #include "linden_common.h"
 
 #include "llnotifications.h"
+#include "llnotificationtemplate.h"
 
+#include "llinstantmessage.h"
 #include "llxmlnode.h"
 #include "lluictrl.h"
 #include "lluictrlfactory.h"
@@ -41,6 +37,9 @@
 #include "llsdserialize.h"
 #include "lltrans.h"
 #include "llnotificationslistener.h"
+#include "llstring.h"
+#include "llsdparam.h"
+#include "llsdutil.h"
 
 #include <algorithm>
 #include <boost/regex.hpp>
@@ -48,6 +47,56 @@
 
 const std::string NOTIFICATION_PERSIST_VERSION = "0.93";
 
+void NotificationPriorityValues::declareValues()
+{
+	declare("low", NOTIFICATION_PRIORITY_LOW);
+	declare("normal", NOTIFICATION_PRIORITY_NORMAL);
+	declare("high", NOTIFICATION_PRIORITY_HIGH);
+	declare("critical", NOTIFICATION_PRIORITY_CRITICAL);
+}
+
+LLNotificationForm::FormElementBase::FormElementBase()
+:	name("name")
+{}
+
+LLNotificationForm::FormIgnore::FormIgnore()
+:	text("text"),
+	control("control"),
+	invert_control("invert_control", true),
+	save_option("save_option", false)
+{}
+
+LLNotificationForm::FormButton::FormButton()
+:	index("index"),
+	text("text"),
+	ignore("ignore"),
+	is_default("default"),
+	type("type")
+{
+	// set type here so it gets serialized
+	type = "button";
+}
+
+LLNotificationForm::FormInput::FormInput()
+:	type("type"),
+	width("width", 0)
+{}
+
+LLNotificationForm::FormElement::FormElement()
+:	button("button"),
+	input("input")
+{}
+
+LLNotificationForm::FormElements::FormElements()
+:	elements("")
+{}
+
+LLNotificationForm::Params::Params()
+:	name("name"),
+	ignore("ignore"),
+	form_elements("")
+{}
+
 // Local channel for persistent notifications
 // Stores only persistent notifications.
 // Class users can use connectChanged() to process persistent notifications
@@ -92,12 +141,7 @@ bool filterIgnoredNotifications(LLNotificationPtr notification)
 
 	LLNotificationFormPtr form = notification->getForm();
 	// Check to see if the user wants to ignore this alert
-	if (form->getIgnoreType() != LLNotificationForm::IGNORE_NO)
-	{
-		return LLUI::sSettingGroups["ignores"]->getBOOL(notification->getName());
-	}
-
-	return true;
+	return !notification->getForm()->getIgnored();
 }
 
 bool handleIgnoredNotification(const LLSD& payload)
@@ -139,63 +183,68 @@ namespace LLNotificationFilters
 };
 
 LLNotificationForm::LLNotificationForm()
-:	mFormData(LLSD::emptyArray()),
-	mIgnore(IGNORE_NO)
+:	mIgnore(IGNORE_NO)
 {
 }
 
 
-LLNotificationForm::LLNotificationForm(const std::string& name, const LLXMLNodePtr xml_node) 
-:	mFormData(LLSD::emptyArray()),
-	mIgnore(IGNORE_NO)
+LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationForm::Params& p) 
+:	mIgnore(IGNORE_NO),
+	mInvertSetting(true) // ignore settings by default mean true=show, false=ignore
 {
-	if (!xml_node->hasName("form"))
-	{
-		llwarns << "Bad xml node for form: " << xml_node->getName() << llendl;
-	}
-	LLXMLNodePtr child = xml_node->getFirstChild();
-	while(child)
+	if (p.ignore.isProvided())
 	{
-		child = LLNotifications::instance().checkForXMLTemplate(child);
+		mIgnoreMsg = p.ignore.text;
 
-		LLSD item_entry;
-		std::string element_name = child->getName()->mString;
+		if (!p.ignore.save_option)
+		{
+			mIgnore = IGNORE_WITH_DEFAULT_RESPONSE;
+		}
+		else
+		{
+			// remember last option chosen by user and automatically respond with that in the future
+			mIgnore = IGNORE_WITH_LAST_RESPONSE;
+			LLUI::sSettingGroups["ignores"]->declareLLSD(std::string("Default") + name, "", std::string("Default response for notification " + name));
+		}
 
-		if (element_name == "ignore" )
+		BOOL show_notification = TRUE;
+		if (p.ignore.control.isProvided())
 		{
-			bool save_option = false;
-			child->getAttribute_bool("save_option", save_option);
-			if (!save_option)
-			{
-				mIgnore = IGNORE_WITH_DEFAULT_RESPONSE;
-			}
-			else
-			{
-				// remember last option chosen by user and automatically respond with that in the future
-				mIgnore = IGNORE_WITH_LAST_RESPONSE;
-				LLUI::sSettingGroups["ignores"]->declareLLSD(std::string("Default") + name, "", std::string("Default response for notification " + name));
-			}
-			child->getAttributeString("text", mIgnoreMsg);
-			BOOL show_notification = TRUE;
-			LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
+			mIgnoreSetting = LLUI::sSettingGroups["config"]->getControl(p.ignore.control);
+			mInvertSetting = p.ignore.invert_control;
 		}
 		else
 		{
-			// flatten xml form entry into single LLSD map with type==name
-			item_entry["type"] = element_name;
-			const LLXMLAttribList::iterator attrib_end = child->mAttributes.end();
-			for(LLXMLAttribList::iterator attrib_it = child->mAttributes.begin();
-				attrib_it != attrib_end;
-				++attrib_it)
-			{
-				item_entry[std::string(attrib_it->second->getName()->mString)] = attrib_it->second->getValue();
-			}
-			item_entry["value"] = child->getTextContents();
-			mFormData.append(item_entry);
+			LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
+			mIgnoreSetting = LLUI::sSettingGroups["ignores"]->getControl(name);
 		}
+	}
 
-		child = child->getNextSibling();
+	LLParamSDParser parser;
+	parser.writeSD(mFormData, p.form_elements);
+
+	mFormData = mFormData[""];
+	if (!mFormData.isArray())
+	{
+		// 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)
+	{
+		// lift contents of form element up a level, since element type is already encoded in "type" param
+		if (it->isMap() && it->beginMap() != it->endMap())
+		{
+			*it = it->beginMap()->second;
+		}
+	}
+
+	LL_DEBUGS("Notifications") << name << LL_ENDL;
+	LL_DEBUGS("Notifications") << ll_pretty_print_sd(mFormData) << LL_ENDL;
 }
 
 LLNotificationForm::LLNotificationForm(const LLSD& sd)
@@ -297,16 +346,64 @@ std::string LLNotificationForm::getDefaultOption()
 	return "";
 }
 
-LLNotificationTemplate::LLNotificationTemplate() :
-	mExpireSeconds(0),
-	mExpireOption(-1),
-	mURLOption(-1),
-	mURLOpenExternally(-1),
-	mPersist(false),
-	mUnique(false),
-	mPriority(NOTIFICATION_PRIORITY_NORMAL)
+LLControlVariablePtr LLNotificationForm::getIgnoreSetting() 
+{ 
+	return mIgnoreSetting; 
+}
+
+bool LLNotificationForm::getIgnored()
+{
+	bool ignored = false;
+	if (mIgnore != LLNotificationForm::IGNORE_NO
+		&& mIgnoreSetting) 
+	{
+		ignored = mIgnoreSetting->getValue().asBoolean();
+		if (mInvertSetting) ignored = !ignored;
+	}
+
+	return ignored;
+}
+
+void LLNotificationForm::setIgnored(bool ignored)
 {
-	mForm = LLNotificationFormPtr(new LLNotificationForm()); 
+	if (mIgnoreSetting)
+	{
+		if (mInvertSetting) ignored = !ignored;
+		mIgnoreSetting->setValue(ignored);
+	}
+}
+
+LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Params& p)
+:	mName(p.name),
+	mType(p.type),
+	mMessage(p.value),
+	mLabel(p.label),
+	mIcon(p.icon),
+	mURL(p.url.value),
+	mExpireSeconds(p.duration),
+	mExpireOption(p.expire_option),
+	mURLOption(p.url.option),
+	mURLTarget(p.url.target),
+	mUnique(p.unique.isProvided()),
+	mPriority(p.priority),
+	mPersist(p.persist),
+	mDefaultFunctor(p.functor.isProvided() ? p.functor() : p.name())
+{
+	if (p.sound.isProvided()
+		&& LLUI::sSettingGroups["config"]->controlExists(p.sound))
+	{
+		mSoundEffect = LLUUID(LLUI::sSettingGroups["config"]->getString(p.sound));
+	}
+
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::UniquenessContext>::const_iterator it = p.unique.contexts.begin(),
+			end_it = p.unique.contexts.end();
+		it != end_it;
+		++it)
+	{
+		mUniqueContext.push_back(it->key);
+	}
+
+	mForm = LLNotificationFormPtr(new LLNotificationForm(p.name, p.form_ref.form));
 }
 
 LLNotification::LLNotification(const LLNotification::Params& p) : 
@@ -373,6 +470,7 @@ LLNotification::LLNotification(const LLSD& sd) :
 LLSD LLNotification::asLLSD()
 {
 	LLSD output;
+	output["id"] = mId;
 	output["name"] = mTemplatep->mName;
 	output["form"] = getForm()->asLLSD();
 	output["substitutions"] = mSubstitutions;
@@ -502,7 +600,7 @@ void LLNotification::respond(const LLSD& response)
 	{
 		mResponder->handleRespond(asLLSD(), response);
 	}
-	else
+	else if (!mResponseFunctorName.empty())
 	{
 		// look up the functor
 		LLNotificationFunctorRegistry::ResponseFunctor functor =
@@ -510,6 +608,11 @@ void LLNotification::respond(const LLSD& response)
 		// and then call it
 		functor(asLLSD(), response);
 	}
+	else
+	{
+		// no registered responder
+		return;
+	}
 
 	if (mTemporaryResponder && !isReusable())
 	{
@@ -520,8 +623,7 @@ void LLNotification::respond(const LLSD& response)
 
 	if (mForm->getIgnoreType() != LLNotificationForm::IGNORE_NO)
 	{
-		BOOL show_notification = mIgnored ? FALSE : TRUE;
-		LLUI::sSettingGroups["ignores"]->setBOOL(getName(), show_notification);
+		mForm->setIgnored(mIgnored);
 		if (mIgnored && mForm->getIgnoreType() == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
 		{
 			LLUI::sSettingGroups["ignores"]->setLLSD("Default" + getName(), response);
@@ -531,6 +633,49 @@ void LLNotification::respond(const LLSD& response)
 	update();
 }
 
+void LLNotification::respondWithDefault()
+{
+	respond(getResponseTemplate(WITH_DEFAULT_BUTTON));
+}
+
+
+const std::string& LLNotification::getName() const
+{
+	return mTemplatep->mName;
+}
+
+const std::string& LLNotification::getIcon() const
+{
+	return mTemplatep->mIcon;
+}
+
+
+bool LLNotification::isPersistent() const
+{
+	return mTemplatep->mPersist;
+}
+
+std::string LLNotification::getType() const
+{
+	return (mTemplatep ? mTemplatep->mType : "");
+}
+
+S32 LLNotification::getURLOption() const
+{
+	return (mTemplatep ? mTemplatep->mURLOption : -1);
+}
+
+S32 LLNotification::getURLOpenExternally() const
+{
+	return(mTemplatep? mTemplatep->mURLTarget == "_external": -1);
+}
+
+bool LLNotification::hasUniquenessConstraints() const 
+{ 
+	return (mTemplatep ? mTemplatep->mUnique : false);
+}
+
+
 void LLNotification::setIgnored(bool ignore)
 {
 	mIgnored = ignore;
@@ -560,21 +705,6 @@ void LLNotification::setResponseFunctor(const LLNotificationResponderPtr& respon
 	mResponder = responder;
 }
 
-bool LLNotification::payloadContainsAll(const std::vector<std::string>& required_fields) const
-{
-	for(std::vector<std::string>::const_iterator required_fields_it = required_fields.begin(); 
-		required_fields_it != required_fields.end();
-		required_fields_it++)
-	{
-		std::string required_field_name = *required_fields_it;
-		if( ! getPayload().has(required_field_name))
-		{
-			return false; // a required field was not found
-		}
-	}
-	return true; // all required fields were found
-}
-
 bool LLNotification::isEquivalentTo(LLNotificationPtr that) const
 {
 	if (this->mTemplatep->mName != that->mTemplatep->mName) 
@@ -583,11 +713,22 @@ bool LLNotification::isEquivalentTo(LLNotificationPtr that) const
 	}
 	if (this->mTemplatep->mUnique)
 	{
+		const LLSD& these_substitutions = this->getSubstitutions();
+		const LLSD& those_substitutions = that->getSubstitutions();
+
 		// highlander bit sez there can only be one of these
-		return
-			this->payloadContainsAll(that->mTemplatep->mUniqueContext) &&
-			that->payloadContainsAll(this->mTemplatep->mUniqueContext);
+		for (std::vector<std::string>::const_iterator it = mTemplatep->mUniqueContext.begin(), end_it = mTemplatep->mUniqueContext.end();
+			it != end_it;
+			++it)
+		{
+			if (these_substitutions.get(*it).asString() != those_substitutions.get(*it).asString())
+			{
+				return false;
+			}
+		}
+		return true;
 	}
+
 	return false; 
 }
 
@@ -614,6 +755,8 @@ void LLNotification::init(const std::string& template_name, const LLSD& form_ele
 	// apply substitution to form labels
 	mForm->formatElements(mSubstitutions);
 
+	mIgnored = mForm->getIgnored();
+
 	LLDate rightnow = LLDate::now();
 	if (mTemplatep->mExpireSeconds)
 	{
@@ -917,12 +1060,12 @@ std::string LLNotificationChannel::summarize()
 // LLNotifications implementation
 // ---
 LLNotifications::LLNotifications() : LLNotificationChannelBase(LLNotificationFilters::includeEverything,
-															   LLNotificationComparators::orderByUUID()),
-									mIgnoreAllNotifications(false)
+							       LLNotificationComparators::orderByUUID()),
+				     mIgnoreAllNotifications(false)
 {
 	LLUICtrl::CommitCallbackRegistry::currentRegistrar().add("Notification.Show", boost::bind(&LLNotifications::addFromCallback, this, _2));
-
-    mListener.reset(new LLNotificationsListener(*this));
+	
+	mListener.reset(new LLNotificationsListener(*this));
 }
 
 
@@ -1102,11 +1245,6 @@ bool LLNotifications::templateExists(const std::string& name)
 	return (mTemplates.count(name) != 0);
 }
 
-void LLNotifications::clearTemplates()
-{
-	mTemplates.clear();
-}
-
 void LLNotifications::forceResponse(const LLNotification::Params& params, S32 option)
 {
 	LLNotificationPtr temp_notify(new LLNotification(params));
@@ -1169,190 +1307,88 @@ void replaceSubstitutionStrings(LLXMLNodePtr node, StringMap& replacements)
 	}
 }
 
-// private to this file
-// returns true if the template request was invalid and there's nothing else we
-// can do with this node, false if you should keep processing (it may have
-// replaced the contents of the node referred to)
-LLXMLNodePtr LLNotifications::checkForXMLTemplate(LLXMLNodePtr item)
+void replaceFormText(LLNotificationForm::Params& form, const std::string& pattern, const std::string& replace)
 {
-	if (item->hasName("usetemplate"))
+	if (form.ignore.isProvided() && form.ignore.text() == pattern)
+	{
+		form.ignore.text = replace;
+	}
+	for (LLInitParam::ParamIterator<LLNotificationForm::FormElement>::iterator it = form.form_elements.elements.begin(),
+			end_it = form.form_elements.elements.end();
+		it != end_it;
+		++it)
 	{
-		std::string replacementName;
-		if (item->getAttributeString("name", replacementName))
+		if (it->button.isChosen() && it->button.text() == pattern)
 		{
-			StringMap replacements;
-			for (LLXMLAttribList::const_iterator it=item->mAttributes.begin(); 
-				 it != item->mAttributes.end(); ++it)
-			{
-				replacements[it->second->getName()->mString] = it->second->getValue();
-			}
-			if (mXmlTemplates.count(replacementName))
-			{
-				item=LLXMLNode::replaceNode(item, mXmlTemplates[replacementName]);
-				
-				// walk the nodes looking for $(substitution) here and replace
-				replaceSubstitutionStrings(item, replacements);
-			}
-			else
-			{
-				llwarns << "XML template lookup failure on '" << replacementName << "' " << llendl;
-			}
+			it->button.text = replace;
 		}
 	}
-	return item;
 }
 
 bool LLNotifications::loadTemplates()
 {
 	const std::string xml_filename = "notifications.xml";
+	std::string full_filename = gDirUtilp->findSkinnedFilename(LLUI::getXUIPaths().front(), xml_filename);
+
 	LLXMLNodePtr root;
-	
 	BOOL success  = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);
 	
 	if (!success || root.isNull() || !root->hasName( "notifications" ))
 	{
-		llerrs << "Problem reading UI Notifications file: " << xml_filename << llendl;
+		llerrs << "Problem reading UI Notifications file: " << full_filename << llendl;
 		return false;
 	}
-	
-	clearTemplates();
-	
-	for (LLXMLNodePtr item = root->getFirstChild();
-		 item.notNull(); item = item->getNextSibling())
-	{
-		// we do this FIRST so that item can be changed if we 
-		// encounter a usetemplate -- we just replace the
-		// current xml node and keep processing
-		item = checkForXMLTemplate(item);
-		
-		if (item->hasName("global"))
-		{
-			std::string global_name;
-			if (item->getAttributeString("name", global_name))
-			{
-				mGlobalStrings[global_name] = item->getTextContents();
-			}
-			continue;
-		}
-		
-		if (item->hasName("template"))
-		{
-			// store an xml template; templates must have a single node (can contain
-			// other nodes)
-			std::string name;
-			item->getAttributeString("name", name);
-			LLXMLNodePtr ptr = item->getFirstChild();
-			mXmlTemplates[name] = ptr;
-			continue;
-		}
-		
-		if (!item->hasName("notification"))
-		{
-            llwarns << "Unexpected entity " << item->getName()->mString << 
-                       " found in " << xml_filename << llendl;
-			continue;
-		}
-		
-		// now we know we have a notification entry, so let's build it
-		LLNotificationTemplatePtr pTemplate(new LLNotificationTemplate());
 
-		if (!item->getAttributeString("name", pTemplate->mName))
-		{
-			llwarns << "Unable to parse notification with no name" << llendl;
-			continue;
-		}
-		
-		//llinfos << "Parsing " << pTemplate->mName << llendl;
-		
-		pTemplate->mMessage = item->getTextContents();
-		pTemplate->mDefaultFunctor = pTemplate->mName;
-		item->getAttributeString("type", pTemplate->mType);
-		item->getAttributeString("icon", pTemplate->mIcon);
-		item->getAttributeString("label", pTemplate->mLabel);
-		item->getAttributeU32("duration", pTemplate->mExpireSeconds);
-		item->getAttributeU32("expireOption", pTemplate->mExpireOption);
-
-		std::string priority;
-		item->getAttributeString("priority", priority);
-		pTemplate->mPriority = NOTIFICATION_PRIORITY_NORMAL;
-		if (!priority.empty())
-		{
-			if (priority == "low")      pTemplate->mPriority = NOTIFICATION_PRIORITY_LOW;
-			if (priority == "normal")   pTemplate->mPriority = NOTIFICATION_PRIORITY_NORMAL;
-			if (priority == "high")     pTemplate->mPriority = NOTIFICATION_PRIORITY_HIGH;
-			if (priority == "critical") pTemplate->mPriority = NOTIFICATION_PRIORITY_CRITICAL;
-		}
-		
-		item->getAttributeString("functor", pTemplate->mDefaultFunctor);
-
-		BOOL persist = false;
-		item->getAttributeBOOL("persist", persist);
-		pTemplate->mPersist = persist;
-		
-		std::string sound;
-		item->getAttributeString("sound", sound);
-		if (!sound.empty())
+	LLNotificationTemplate::Notifications params;
+	LLXUIParser parser;
+	parser.readXUI(root, params, full_filename);
+
+	mTemplates.clear();
+
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::GlobalString>::const_iterator it = params.strings.begin(), end_it = params.strings.end();
+		it != end_it;
+		++it)
+	{
+		mGlobalStrings[it->name] = it->value;
+	}
+
+	std::map<std::string, LLNotificationForm::Params> form_templates;
+
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::Template>::const_iterator it = params.templates.begin(), end_it = params.templates.end();
+		it != end_it;
+		++it)
+	{
+		form_templates[it->name] = it->form;
+	}
+
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::Params>::iterator it = params.notifications.begin(), end_it = params.notifications.end();
+		it != end_it;
+		++it)
+	{
+		if (it->form_ref.form_template.isChosen())
 		{
-			// test for bad sound effect name / missing effect
-			if (LLUI::sSettingGroups["config"]->controlExists(sound))
+			// replace form contents from template
+			it->form_ref.form = form_templates[it->form_ref.form_template.name];
+			if(it->form_ref.form_template.yes_text.isProvided())
 			{
-				pTemplate->mSoundEffect = 
-					LLUUID(LLUI::sSettingGroups["config"]->getString(sound));
+				replaceFormText(it->form_ref.form, "$yestext", it->form_ref.form_template.yes_text);
 			}
-			else
+			if(it->form_ref.form_template.no_text.isProvided())
 			{
-				llwarns << "Unknown sound effect control name " << sound
-					<< llendl;
+				replaceFormText(it->form_ref.form, "$notext", it->form_ref.form_template.no_text);
 			}
-		}
-
-		for (LLXMLNodePtr child = item->getFirstChild();
-			 !child.isNull(); child = child->getNextSibling())
-		{
-			child = checkForXMLTemplate(child);
-			
-			// <url>
-			if (child->hasName("url"))
+			if(it->form_ref.form_template.cancel_text.isProvided())
 			{
-				pTemplate->mURL = child->getTextContents();
-				child->getAttributeU32("option", pTemplate->mURLOption);
-				child->getAttributeU32("openexternally", pTemplate->mURLOpenExternally);
+				replaceFormText(it->form_ref.form, "$canceltext", it->form_ref.form_template.cancel_text);
 			}
-			
-            if (child->hasName("unique"))
-            {
-                pTemplate->mUnique = true;
-                for (LLXMLNodePtr formitem = child->getFirstChild();
-                     !formitem.isNull(); formitem = formitem->getNextSibling())
-                {
-                    if (formitem->hasName("context"))
-                    {
-                        std::string key;
-                        formitem->getAttributeString("key", key);
-                        pTemplate->mUniqueContext.push_back(key);
-                        //llwarns << "adding " << key << " to unique context" << llendl;
-                    }
-                    else
-                    {
-                        llwarns << "'unique' has unrecognized subelement " 
-                        << formitem->getName()->mString << llendl;
-                    }
-                }
-            }
-            
-			// <form>
-			if (child->hasName("form"))
+			if(it->form_ref.form_template.ignore_text.isProvided())
 			{
-                pTemplate->mForm = LLNotificationFormPtr(new LLNotificationForm(pTemplate->mName, child));
+				replaceFormText(it->form_ref.form, "$ignoretext", it->form_ref.form_template.ignore_text);
 			}
 		}
-		addTemplate(pTemplate->mName, pTemplate);
+		addTemplate(it->name, LLNotificationTemplatePtr(new LLNotificationTemplate(*it)));
 	}
-	
-	//std::ostringstream ostream;
-	//root->writeToOstream(ostream, "\n  ");
-	//llwarns << ostream.str() << llendl;
-	
+
 	return true;
 }
 
@@ -1403,6 +1439,8 @@ LLNotificationPtr LLNotifications::add(const LLNotification::Params& p)
 
 void LLNotifications::add(const LLNotificationPtr pNotif)
 {
+	if (pNotif == NULL) return;
+
 	// first see if we already have it -- if so, that's a problem
 	LLNotificationSet::iterator it=mItems.find(pNotif);
 	if (it != mItems.end())
@@ -1415,6 +1453,8 @@ void LLNotifications::add(const LLNotificationPtr pNotif)
 
 void LLNotifications::cancel(LLNotificationPtr pNotif)
 {
+	if (pNotif == NULL) return;
+
 	LLNotificationSet::iterator it=mItems.find(pNotif);
 	if (it == mItems.end())
 	{
@@ -1424,6 +1464,30 @@ void LLNotifications::cancel(LLNotificationPtr pNotif)
 	updateItem(LLSD().with("sigtype", "delete").with("id", pNotif->id()), pNotif);
 }
 
+void LLNotifications::cancelByName(const std::string& name)
+{
+	std::vector<LLNotificationPtr> notifs_to_cancel;
+	for (LLNotificationSet::iterator it=mItems.begin(), end_it = mItems.end();
+		it != end_it;
+		++it)
+	{
+		LLNotificationPtr pNotif = *it;
+		if (pNotif->getName() == name)
+		{
+			notifs_to_cancel.push_back(pNotif);
+		}
+	}
+
+	for (std::vector<LLNotificationPtr>::iterator it = notifs_to_cancel.begin(), end_it = notifs_to_cancel.end();
+		it != end_it;
+		++it)
+	{
+		LLNotificationPtr pNotif = *it;
+		pNotif->cancel();
+		updateItem(LLSD().with("sigtype", "delete").with("id", pNotif->id()), pNotif);
+	}
+}
+
 void LLNotifications::update(const LLNotificationPtr pNotif)
 {
 	LLNotificationSet::iterator it=mItems.find(pNotif);
@@ -1491,7 +1555,14 @@ std::ostream& operator<<(std::ostream& s, const LLNotification& notification)
 void LLPostponedNotification::onCachedNameReceived(const LLUUID& id, const std::string& first,
 		const std::string& last, bool is_group)
 {
-	gCacheName->getFullName(id, mName);
+	mName = first + " " + last;
+
+	LLStringUtil::trim(mName);
+	if (mName.empty())
+	{
+		llwarns << "Empty name received for Id: " << id << llendl;
+		mName = SYSTEM_FROM;
+	}
 	modifyNotificationParams();
 	LLNotifications::instance().add(mParams);
 	cleanup();