From 94e406157d0b133d51b5dbb95aab296b46eae10e Mon Sep 17 00:00:00 2001
From: Richard Nelson <none@none>
Date: Mon, 16 Aug 2010 14:59:29 -0700
Subject: added ability to cancel all notifications with a given name

---
 indra/llui/llnotifications.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 7fa3c2cf65..2da8f1eb1b 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -1423,6 +1423,21 @@ void LLNotifications::cancel(LLNotificationPtr pNotif)
 	updateItem(LLSD().with("sigtype", "delete").with("id", pNotif->id()), pNotif);
 }
 
+void LLNotifications::cancelByName(const std::string& name)
+{
+	for (LLNotificationSet::iterator it=mItems.begin(), end_it = mItems.end(), next_it = it;
+		it != end_it;
+		it = next_it, ++next_it)
+	{
+		LLNotificationPtr pNotif = *it;
+		if (pNotif->getName() == name)
+		{
+			pNotif->cancel();
+			updateItem(LLSD().with("sigtype", "delete").with("id", pNotif->id()), pNotif);
+		}
+	}
+}
+
 void LLNotifications::update(const LLNotificationPtr pNotif)
 {
 	LLNotificationSet::iterator it=mItems.find(pNotif);
-- 
cgit v1.2.3


From 3aa8148ed94bcf495784efe51ad9d466d566868d Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Wed, 18 Aug 2010 12:16:29 -0700
Subject: fix for occasional crash when dismissing hint

---
 indra/llui/llnotifications.cpp | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 2da8f1eb1b..7cc6e8e8f6 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -1425,17 +1425,26 @@ void LLNotifications::cancel(LLNotificationPtr pNotif)
 
 void LLNotifications::cancelByName(const std::string& name)
 {
-	for (LLNotificationSet::iterator it=mItems.begin(), end_it = mItems.end(), next_it = it;
+	std::vector<LLNotificationPtr> notifs_to_cancel;
+	for (LLNotificationSet::iterator it=mItems.begin(), end_it = mItems.end();
 		it != end_it;
-		it = next_it, ++next_it)
+		++it)
 	{
 		LLNotificationPtr pNotif = *it;
 		if (pNotif->getName() == name)
 		{
-			pNotif->cancel();
-			updateItem(LLSD().with("sigtype", "delete").with("id", pNotif->id()), pNotif);
+			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)
-- 
cgit v1.2.3


From 1ad5663463721c4bca6ca8e91b9894226e999cca Mon Sep 17 00:00:00 2001
From: Richard Nelson <none@none>
Date: Tue, 14 Sep 2010 10:53:05 -0700
Subject: converted notifications.xml to paramblock parsing for easier reuse
 and extension

---
 indra/llui/llnotifications.cpp | 654 ++++++++++++++++++++++++++++-------------
 1 file changed, 446 insertions(+), 208 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 7dba53e746..3baf8d4f7b 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -44,6 +44,229 @@
 
 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);
+}
+
+
+namespace LLNotificationTemplateParams
+{
+	using namespace LLInitParam;
+
+	struct GlobalString : public Block<GlobalString>
+	{
+		Mandatory<std::string>	name,
+								value;
+
+		GlobalString()
+		:	name("name"),
+			value("value")
+		{}
+	};
+
+	struct UniquenessContext : public Block<UniquenessContext>
+	{
+		Mandatory<std::string>	key;
+
+		UniquenessContext()
+		:	key("key")
+		{}
+		
+	};
+
+	struct UniquenessConstraint : public Block<UniquenessConstraint>
+	{
+		Multiple<UniquenessContext>	contexts;
+
+		UniquenessConstraint()
+		:	contexts("context")
+		{}
+	};
+
+	struct FormElementBase : public Block<FormElementBase>
+	{
+		Mandatory<std::string>	name;
+		FormElementBase()
+		:	name("name")
+		{}
+	};
+
+	struct FormIgnore : public Block<FormIgnore, FormElementBase>
+	{
+		Optional<std::string>	text;
+		Optional<bool>			save_option;
+
+		FormIgnore()
+		:	text("text"),
+			save_option("save_option", false)
+		{}
+	};
+
+	struct FormButton : public Block<FormButton, FormElementBase>
+	{
+		Mandatory<S32>			index;
+		Mandatory<std::string>	text;
+		Optional<std::string>	ignore;
+		Optional<bool>			is_default;
+
+		FormButton()
+		:	index("index"),
+			text("text"),
+			ignore("ignore"),
+			is_default("default")
+		{}
+	};
+
+	struct FormInput : public Block<FormInput, FormElementBase>
+	{
+		Mandatory<std::string>	type;
+		Optional<S32>			width;
+
+		FormInput()
+		:	type("type"),
+			width("width", 0)
+		{}
+	};
+
+	struct FormElement : public Choice<FormElement>
+	{
+		Alternative<FormButton> button;
+		Alternative<FormInput>	input;
+
+		FormElement()
+		:	button("button"),
+			input("input")
+		{}
+	};
+
+	struct Form : public Block<Form>
+	{
+		Optional<std::string>	name;
+		Optional<FormIgnore>	ignore;
+		Multiple<FormElement>	form_elements;
+
+		Form()
+		:	name("form"),
+			ignore("ignore"),
+			form_elements("")
+		{}
+	};
+
+	// Templates are used to define common form types, such as OK/Cancel dialogs, etc.
+
+	struct Template : public Block<Template>
+	{
+		Mandatory<std::string>	name;
+		Mandatory<Form>			form;
+
+		Template()
+		:	name("name"),
+			form("form")
+		{}
+	};
+
+	// Reference a template to use its form elements
+	struct TemplateRef : public Block<TemplateRef>
+	{
+		Mandatory<std::string>	name;
+		Optional<std::string>	yes_text,
+								no_text,
+								cancel_text,
+								ignore_text;
+
+		TemplateRef()
+		:	name("name"),
+			yes_text("yestext"),
+			no_text("notext"),
+			cancel_text("canceltext"),
+			ignore_text("ignoretext")
+		{}
+	};
+
+	struct URL : public Block<URL>
+	{
+		Mandatory<S32>			option;
+		Mandatory<std::string>	value;
+		Optional<std::string>	target;
+		Ignored					name;
+
+		URL()
+		:	option("option", -1),
+			value("value"),
+			target("target", "_blank"),
+			name("name")
+		{}
+	};
+
+	struct FormRef : public Choice<FormRef>
+	{
+		Alternative<Form>			form;
+		Alternative<TemplateRef>	form_template;
+
+		FormRef()
+		:	form("form"),
+			form_template("use_template")
+		{}
+	};
+
+	struct Notification : public Block<Notification>
+	{
+		Mandatory<std::string>			name;
+		Optional<bool>					persist;
+		Optional<std::string>			functor,
+										icon,
+										label,
+										sound,
+										type,
+										value;
+		Optional<U32>					duration;
+		Optional<S32>					expire_option;
+		Optional<URL>					url;
+		Optional<TemplateRef>			use_template;
+		Optional<UniquenessConstraint>	unique;
+		Optional<FormRef>				form_ref;
+		Optional<ENotificationPriority, 
+			NotificationPriorityValues> priority;
+
+
+		Notification()
+		:	name("name"),
+			persist("persist", false),
+			functor("functor"),
+			icon("icon"),
+			label("label"),
+			priority("priority"),
+			sound("sound"),
+			type("type"),
+			value("value"),
+			duration("duration"),
+			expire_option("expireOption", -1),
+			url("url"),
+			use_template("usetemplate"),
+			unique("unique"),
+			form_ref("")
+		{}
+
+	};
+
+	struct Notifications : public Block<Notifications>
+	{
+		Multiple<GlobalString>	strings;
+		Multiple<Template>		templates;
+		Multiple<Notification>	notifications;
+
+		Notifications()
+		:	strings("global"),
+			notifications("notification"),
+			templates("template")
+		{}
+	};
+}
+
 // Local channel for persistent notifications
 // Stores only persistent notifications.
 // Class users can use connectChanged() to process persistent notifications
@@ -141,57 +364,31 @@ LLNotificationForm::LLNotificationForm()
 }
 
 
-LLNotificationForm::LLNotificationForm(const std::string& name, const LLXMLNodePtr xml_node) 
+LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationTemplateParams::Form& p) 
 :	mFormData(LLSD::emptyArray()),
 	mIgnore(IGNORE_NO)
 {
-	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 (element_name == "ignore" )
+		if (!p.ignore.save_option)
 		{
-			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);
+			mIgnore = IGNORE_WITH_DEFAULT_RESPONSE;
 		}
 		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);
+			// 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 = child->getNextSibling();
+		BOOL show_notification = TRUE;
+		LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
 	}
+
+	// TODO: serialize params.form_elements to mFormData
+	//mFormData.append(item_entry);
 }
 
 LLNotificationForm::LLNotificationForm(const LLSD& sd)
@@ -293,16 +490,37 @@ std::string LLNotificationForm::getDefaultOption()
 	return "";
 }
 
-LLNotificationTemplate::LLNotificationTemplate() :
-	mExpireSeconds(0),
-	mExpireOption(-1),
-	mURLOption(-1),
-	mURLOpenExternally(-1),
-	mPersist(false),
-	mUnique(false),
-	mPriority(NOTIFICATION_PRIORITY_NORMAL)
+LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplateParams::Notification& 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())
 {
-	mForm = LLNotificationFormPtr(new LLNotificationForm()); 
+	if (p.sound.isProvided()
+		&& LLUI::sSettingGroups["config"]->controlExists(p.sound))
+	{
+		mSoundEffect = LLUUID(LLUI::sSettingGroups["config"]->getString(p.sound));
+	}
+
+	for(LLInitParam::ParamIterator<LLNotificationTemplateParams::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) : 
@@ -1095,11 +1313,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));
@@ -1162,185 +1375,210 @@ 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(LLNotificationTemplateParams::Form& 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<LLNotificationTemplateParams::FormElement>::iterator it = form.form_elements().begin(),
+			end_it = form.form_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";
-	LLXMLNodePtr root;
-	
-	BOOL success  = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);
-	
-	if (!success || root.isNull() || !root->hasName( "notifications" ))
+
+	std::string full_filename = gDirUtilp->findSkinnedFilename(LLUI::getXUIPaths().front(), xml_filename);
+	LLNotificationTemplateParams::Notifications params;
+	LLSimpleXUIParser parser;
+	parser.readXUI(full_filename, params);
+
+	mTemplates.clear();
+
+	for(LLInitParam::ParamIterator<LLNotificationTemplateParams::GlobalString>::const_iterator it = params.strings().begin(), end_it = params.strings().end();
+		it != end_it;
+		++it)
 	{
-		llerrs << "Problem reading UI Notifications file: " << xml_filename << llendl;
-		return false;
+		mGlobalStrings[it->name] = it->value;
 	}
-	
-	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);
+	std::map<std::string, LLNotificationTemplateParams::Form> form_templates;
 
-		BOOL persist = false;
-		item->getAttributeBOOL("persist", persist);
-		pTemplate->mPersist = persist;
-		
-		std::string sound;
-		item->getAttributeString("sound", sound);
-		if (!sound.empty())
+	for(LLInitParam::ParamIterator<LLNotificationTemplateParams::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<LLNotificationTemplateParams::Notification>::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, "$cancel_text", 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, "$ignore_text", it->form_ref.form_template.ignore_text);
 			}
 		}
-		addTemplate(pTemplate->mName, pTemplate);
-	}
+		addTemplate(it->name, LLNotificationTemplatePtr(new LLNotificationTemplate(*it)));
+	}
+
+	//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())
+	//	{
+	//		// test for bad sound effect name / missing effect
+	//		if (LLUI::sSettingGroups["config"]->controlExists(sound))
+	//		{
+	//			pTemplate->mSoundEffect = 
+	//				LLUUID(LLUI::sSettingGroups["config"]->getString(sound));
+	//		}
+	//		else
+	//		{
+	//			llwarns << "Unknown sound effect control name " << sound
+	//				<< llendl;
+	//		}
+	//	}
+
+	//	for (LLXMLNodePtr child = item->getFirstChild();
+	//		 !child.isNull(); child = child->getNextSibling())
+	//	{
+	//		child = checkForXMLTemplate(child);
+	//		
+	//		// <url>
+	//		if (child->hasName("url"))
+	//		{
+	//			pTemplate->mURL = child->getTextContents();
+	//			child->getAttributeU32("option", pTemplate->mURLOption);
+	//			child->getAttributeU32("openexternally", pTemplate->mURLOpenExternally);
+	//		}
+	//		
+ //           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"))
+	//		{
+ //               pTemplate->mForm = LLNotificationFormPtr(new LLNotificationForm(pTemplate->mName, child));
+	//		}
+	//	}
+	//	addTemplate(pTemplate->mName, pTemplate);
+	//}
 	
 	//std::ostringstream ostream;
 	//root->writeToOstream(ostream, "\n  ");
-- 
cgit v1.2.3


From e0548d4c6f66b8236b1026f840fea37367325d95 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Tue, 14 Sep 2010 20:11:58 -0700
Subject: finished notifications param block parsing logic

---
 indra/llui/llnotifications.cpp | 204 +++++++++++------------------------------
 1 file changed, 51 insertions(+), 153 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 3baf8d4f7b..cf93243eeb 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -37,6 +37,8 @@
 #include "lltrans.h"
 #include "llnotificationslistener.h"
 #include "llstring.h"
+#include "llsdparam.h"
+#include "llsdutil.h"
 
 #include <algorithm>
 #include <boost/regex.hpp>
@@ -90,6 +92,7 @@ namespace LLNotificationTemplateParams
 	struct FormElementBase : public Block<FormElementBase>
 	{
 		Mandatory<std::string>	name;
+
 		FormElementBase()
 		:	name("name")
 		{}
@@ -113,12 +116,18 @@ namespace LLNotificationTemplateParams
 		Optional<std::string>	ignore;
 		Optional<bool>			is_default;
 
+		Mandatory<std::string>	type;
+
 		FormButton()
 		:	index("index"),
 			text("text"),
 			ignore("ignore"),
-			is_default("default")
-		{}
+			is_default("default"),
+			type("type")
+		{
+			// set type here so it gets serialized
+			type = "button";
+		}
 	};
 
 	struct FormInput : public Block<FormInput, FormElementBase>
@@ -143,11 +152,19 @@ namespace LLNotificationTemplateParams
 		{}
 	};
 
+	struct FormElements : public Block<FormElements>
+	{
+		Multiple<FormElement> elements;
+		FormElements()
+		:	elements("")
+		{}
+	};
+
 	struct Form : public Block<Form>
 	{
 		Optional<std::string>	name;
 		Optional<FormIgnore>	ignore;
-		Multiple<FormElement>	form_elements;
+		Optional<FormElements>	form_elements;
 
 		Form()
 		:	name("form"),
@@ -209,7 +226,7 @@ namespace LLNotificationTemplateParams
 
 		FormRef()
 		:	form("form"),
-			form_template("use_template")
+			form_template("usetemplate")
 		{}
 	};
 
@@ -226,7 +243,6 @@ namespace LLNotificationTemplateParams
 		Optional<U32>					duration;
 		Optional<S32>					expire_option;
 		Optional<URL>					url;
-		Optional<TemplateRef>			use_template;
 		Optional<UniquenessConstraint>	unique;
 		Optional<FormRef>				form_ref;
 		Optional<ENotificationPriority, 
@@ -246,7 +262,6 @@ namespace LLNotificationTemplateParams
 			duration("duration"),
 			expire_option("expireOption", -1),
 			url("url"),
-			use_template("usetemplate"),
 			unique("unique"),
 			form_ref("")
 		{}
@@ -358,15 +373,13 @@ namespace LLNotificationFilters
 };
 
 LLNotificationForm::LLNotificationForm()
-:	mFormData(LLSD::emptyArray()),
-	mIgnore(IGNORE_NO)
+:	mIgnore(IGNORE_NO)
 {
 }
 
 
 LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationTemplateParams::Form& p) 
-:	mFormData(LLSD::emptyArray()),
-	mIgnore(IGNORE_NO)
+:	mIgnore(IGNORE_NO)
 {
 	if (p.ignore.isProvided())
 	{
@@ -387,8 +400,20 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
 		LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
 	}
 
-	// TODO: serialize params.form_elements to mFormData
-	//mFormData.append(item_entry);
+	LLParamSDParser parser;
+	parser.writeSD(mFormData, p.form_elements);
+
+	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;
+		}
+	}
+	//llinfos << ll_pretty_print_sd(mFormData) << llendl;
 }
 
 LLNotificationForm::LLNotificationForm(const LLSD& sd)
@@ -1381,8 +1406,8 @@ void replaceFormText(LLNotificationTemplateParams::Form& form, const std::string
 	{
 		form.ignore.text = replace;
 	}
-	for (LLInitParam::ParamIterator<LLNotificationTemplateParams::FormElement>::iterator it = form.form_elements().begin(),
-			end_it = form.form_elements().end();
+	for (LLInitParam::ParamIterator<LLNotificationTemplateParams::FormElement>::iterator it = form.form_elements.elements().begin(),
+			end_it = form.form_elements.elements().end();
 		it != end_it;
 		++it)
 	{
@@ -1396,11 +1421,20 @@ void replaceFormText(LLNotificationTemplateParams::Form& form, const std::string
 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: " << full_filename << llendl;
+		return false;
+	}
+
 	LLNotificationTemplateParams::Notifications params;
-	LLSimpleXUIParser parser;
-	parser.readXUI(full_filename, params);
+	LLXUIParser parser;
+	parser.readXUI(root, params, full_filename);
 
 	mTemplates.clear();
 
@@ -1448,142 +1482,6 @@ bool LLNotifications::loadTemplates()
 		addTemplate(it->name, LLNotificationTemplatePtr(new LLNotificationTemplate(*it)));
 	}
 
-	//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())
-	//	{
-	//		// test for bad sound effect name / missing effect
-	//		if (LLUI::sSettingGroups["config"]->controlExists(sound))
-	//		{
-	//			pTemplate->mSoundEffect = 
-	//				LLUUID(LLUI::sSettingGroups["config"]->getString(sound));
-	//		}
-	//		else
-	//		{
-	//			llwarns << "Unknown sound effect control name " << sound
-	//				<< llendl;
-	//		}
-	//	}
-
-	//	for (LLXMLNodePtr child = item->getFirstChild();
-	//		 !child.isNull(); child = child->getNextSibling())
-	//	{
-	//		child = checkForXMLTemplate(child);
-	//		
-	//		// <url>
-	//		if (child->hasName("url"))
-	//		{
-	//			pTemplate->mURL = child->getTextContents();
-	//			child->getAttributeU32("option", pTemplate->mURLOption);
-	//			child->getAttributeU32("openexternally", pTemplate->mURLOpenExternally);
-	//		}
-	//		
- //           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"))
-	//		{
- //               pTemplate->mForm = LLNotificationFormPtr(new LLNotificationForm(pTemplate->mName, child));
-	//		}
-	//	}
-	//	addTemplate(pTemplate->mName, pTemplate);
-	//}
-	
-	//std::ostringstream ostream;
-	//root->writeToOstream(ostream, "\n  ");
-	//llwarns << ostream.str() << llendl;
-	
 	return true;
 }
 
-- 
cgit v1.2.3


From f87a49991a0a96c8cf11cbc9461711794aae3a72 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Thu, 16 Sep 2010 00:39:21 -0700
Subject: refactored notification template into own header file

---
 indra/llui/llnotifications.cpp | 302 +++++++++--------------------------------
 1 file changed, 64 insertions(+), 238 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index cf93243eeb..bdc094bf47 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -27,6 +27,7 @@
 #include "linden_common.h"
 
 #include "llnotifications.h"
+#include "llnotificationtemplate.h"
 
 #include "llinstantmessage.h"
 #include "llxmlnode.h"
@@ -55,233 +56,6 @@ void NotificationPriorityValues::declareValues()
 }
 
 
-namespace LLNotificationTemplateParams
-{
-	using namespace LLInitParam;
-
-	struct GlobalString : public Block<GlobalString>
-	{
-		Mandatory<std::string>	name,
-								value;
-
-		GlobalString()
-		:	name("name"),
-			value("value")
-		{}
-	};
-
-	struct UniquenessContext : public Block<UniquenessContext>
-	{
-		Mandatory<std::string>	key;
-
-		UniquenessContext()
-		:	key("key")
-		{}
-		
-	};
-
-	struct UniquenessConstraint : public Block<UniquenessConstraint>
-	{
-		Multiple<UniquenessContext>	contexts;
-
-		UniquenessConstraint()
-		:	contexts("context")
-		{}
-	};
-
-	struct FormElementBase : public Block<FormElementBase>
-	{
-		Mandatory<std::string>	name;
-
-		FormElementBase()
-		:	name("name")
-		{}
-	};
-
-	struct FormIgnore : public Block<FormIgnore, FormElementBase>
-	{
-		Optional<std::string>	text;
-		Optional<bool>			save_option;
-
-		FormIgnore()
-		:	text("text"),
-			save_option("save_option", false)
-		{}
-	};
-
-	struct FormButton : public Block<FormButton, FormElementBase>
-	{
-		Mandatory<S32>			index;
-		Mandatory<std::string>	text;
-		Optional<std::string>	ignore;
-		Optional<bool>			is_default;
-
-		Mandatory<std::string>	type;
-
-		FormButton()
-		:	index("index"),
-			text("text"),
-			ignore("ignore"),
-			is_default("default"),
-			type("type")
-		{
-			// set type here so it gets serialized
-			type = "button";
-		}
-	};
-
-	struct FormInput : public Block<FormInput, FormElementBase>
-	{
-		Mandatory<std::string>	type;
-		Optional<S32>			width;
-
-		FormInput()
-		:	type("type"),
-			width("width", 0)
-		{}
-	};
-
-	struct FormElement : public Choice<FormElement>
-	{
-		Alternative<FormButton> button;
-		Alternative<FormInput>	input;
-
-		FormElement()
-		:	button("button"),
-			input("input")
-		{}
-	};
-
-	struct FormElements : public Block<FormElements>
-	{
-		Multiple<FormElement> elements;
-		FormElements()
-		:	elements("")
-		{}
-	};
-
-	struct Form : public Block<Form>
-	{
-		Optional<std::string>	name;
-		Optional<FormIgnore>	ignore;
-		Optional<FormElements>	form_elements;
-
-		Form()
-		:	name("form"),
-			ignore("ignore"),
-			form_elements("")
-		{}
-	};
-
-	// Templates are used to define common form types, such as OK/Cancel dialogs, etc.
-
-	struct Template : public Block<Template>
-	{
-		Mandatory<std::string>	name;
-		Mandatory<Form>			form;
-
-		Template()
-		:	name("name"),
-			form("form")
-		{}
-	};
-
-	// Reference a template to use its form elements
-	struct TemplateRef : public Block<TemplateRef>
-	{
-		Mandatory<std::string>	name;
-		Optional<std::string>	yes_text,
-								no_text,
-								cancel_text,
-								ignore_text;
-
-		TemplateRef()
-		:	name("name"),
-			yes_text("yestext"),
-			no_text("notext"),
-			cancel_text("canceltext"),
-			ignore_text("ignoretext")
-		{}
-	};
-
-	struct URL : public Block<URL>
-	{
-		Mandatory<S32>			option;
-		Mandatory<std::string>	value;
-		Optional<std::string>	target;
-		Ignored					name;
-
-		URL()
-		:	option("option", -1),
-			value("value"),
-			target("target", "_blank"),
-			name("name")
-		{}
-	};
-
-	struct FormRef : public Choice<FormRef>
-	{
-		Alternative<Form>			form;
-		Alternative<TemplateRef>	form_template;
-
-		FormRef()
-		:	form("form"),
-			form_template("usetemplate")
-		{}
-	};
-
-	struct Notification : public Block<Notification>
-	{
-		Mandatory<std::string>			name;
-		Optional<bool>					persist;
-		Optional<std::string>			functor,
-										icon,
-										label,
-										sound,
-										type,
-										value;
-		Optional<U32>					duration;
-		Optional<S32>					expire_option;
-		Optional<URL>					url;
-		Optional<UniquenessConstraint>	unique;
-		Optional<FormRef>				form_ref;
-		Optional<ENotificationPriority, 
-			NotificationPriorityValues> priority;
-
-
-		Notification()
-		:	name("name"),
-			persist("persist", false),
-			functor("functor"),
-			icon("icon"),
-			label("label"),
-			priority("priority"),
-			sound("sound"),
-			type("type"),
-			value("value"),
-			duration("duration"),
-			expire_option("expireOption", -1),
-			url("url"),
-			unique("unique"),
-			form_ref("")
-		{}
-
-	};
-
-	struct Notifications : public Block<Notifications>
-	{
-		Multiple<GlobalString>	strings;
-		Multiple<Template>		templates;
-		Multiple<Notification>	notifications;
-
-		Notifications()
-		:	strings("global"),
-			notifications("notification"),
-			templates("template")
-		{}
-	};
-}
-
 // Local channel for persistent notifications
 // Stores only persistent notifications.
 // Class users can use connectChanged() to process persistent notifications
@@ -378,7 +152,7 @@ LLNotificationForm::LLNotificationForm()
 }
 
 
-LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationTemplateParams::Form& p) 
+LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationForm::Params& p) 
 :	mIgnore(IGNORE_NO)
 {
 	if (p.ignore.isProvided())
@@ -403,6 +177,15 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
 	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)
@@ -413,7 +196,9 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
 			*it = it->beginMap()->second;
 		}
 	}
-	//llinfos << ll_pretty_print_sd(mFormData) << llendl;
+
+	LL_DEBUGS("Notifications") << name << LL_ENDL;
+	LL_DEBUGS("Notifications") << ll_pretty_print_sd(mFormData) << LL_ENDL;
 }
 
 LLNotificationForm::LLNotificationForm(const LLSD& sd)
@@ -515,7 +300,7 @@ std::string LLNotificationForm::getDefaultOption()
 	return "";
 }
 
-LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplateParams::Notification& p)
+LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Params& p)
 :	mName(p.name),
 	mType(p.type),
 	mMessage(p.value),
@@ -537,7 +322,7 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplateParam
 		mSoundEffect = LLUUID(LLUI::sSettingGroups["config"]->getString(p.sound));
 	}
 
-	for(LLInitParam::ParamIterator<LLNotificationTemplateParams::UniquenessContext>::const_iterator it = p.unique.contexts().begin(),
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::UniquenessContext>::const_iterator it = p.unique.contexts().begin(),
 			end_it = p.unique.contexts().end();
 		it != end_it;
 		++it)
@@ -771,6 +556,43 @@ void LLNotification::respond(const LLSD& response)
 	update();
 }
 
+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;
@@ -1400,13 +1222,13 @@ void replaceSubstitutionStrings(LLXMLNodePtr node, StringMap& replacements)
 	}
 }
 
-void replaceFormText(LLNotificationTemplateParams::Form& form, const std::string& pattern, const std::string& replace)
+void replaceFormText(LLNotificationForm::Params& form, const std::string& pattern, const std::string& replace)
 {
 	if (form.ignore.isProvided() && form.ignore.text() == pattern)
 	{
 		form.ignore.text = replace;
 	}
-	for (LLInitParam::ParamIterator<LLNotificationTemplateParams::FormElement>::iterator it = form.form_elements.elements().begin(),
+	for (LLInitParam::ParamIterator<LLNotificationForm::FormElement>::iterator it = form.form_elements.elements().begin(),
 			end_it = form.form_elements.elements().end();
 		it != end_it;
 		++it)
@@ -1432,29 +1254,29 @@ bool LLNotifications::loadTemplates()
 		return false;
 	}
 
-	LLNotificationTemplateParams::Notifications params;
+	LLNotificationTemplate::Notifications params;
 	LLXUIParser parser;
 	parser.readXUI(root, params, full_filename);
 
 	mTemplates.clear();
 
-	for(LLInitParam::ParamIterator<LLNotificationTemplateParams::GlobalString>::const_iterator it = params.strings().begin(), end_it = params.strings().end();
+	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, LLNotificationTemplateParams::Form> form_templates;
+	std::map<std::string, LLNotificationForm::Params> form_templates;
 
-	for(LLInitParam::ParamIterator<LLNotificationTemplateParams::Template>::const_iterator it = params.templates().begin(), end_it = params.templates().end();
+	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<LLNotificationTemplateParams::Notification>::iterator it = params.notifications().begin(), end_it = params.notifications().end();
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::Params>::iterator it = params.notifications().begin(), end_it = params.notifications().end();
 		it != end_it;
 		++it)
 	{
@@ -1532,6 +1354,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())
@@ -1544,6 +1368,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())
 	{
-- 
cgit v1.2.3


From b24071ca8936035ff42cb361e42cac63593f695e Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Thu, 16 Sep 2010 16:28:57 -0700
Subject: added ability to have notification ignore variable point to
 settings.xml variables

---
 indra/llui/llnotifications.cpp | 91 ++++++++++++++++++++++++++++++++++++------
 1 file changed, 79 insertions(+), 12 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index bdc094bf47..bd58fe2637 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -55,6 +55,47 @@ void NotificationPriorityValues::declareValues()
 	declare("critical", NOTIFICATION_PRIORITY_CRITICAL);
 }
 
+LLNotificationForm::FormElementBase::FormElementBase()
+:	name("name")
+{}
+
+LLNotificationForm::FormIgnore::FormIgnore()
+:	text("text"),
+	control("control"),
+	invert_control("invert_control", false),
+	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.
@@ -100,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)
@@ -153,7 +189,8 @@ LLNotificationForm::LLNotificationForm()
 
 
 LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationForm::Params& p) 
-:	mIgnore(IGNORE_NO)
+:	mIgnore(IGNORE_NO),
+	mInvertSetting(false)
 {
 	if (p.ignore.isProvided())
 	{
@@ -171,7 +208,16 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
 		}
 
 		BOOL show_notification = TRUE;
-		LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
+		if (p.ignore.control.isProvided())
+		{
+			mIgnoreSetting = LLUI::sSettingGroups["config"]->getControl(p.ignore.control);
+			mInvertSetting = p.ignore.invert_control;
+		}
+		else
+		{
+			LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
+			mIgnoreSetting = LLUI::sSettingGroups["ignores"]->getControl(name);
+		}
 	}
 
 	LLParamSDParser parser;
@@ -300,6 +346,27 @@ std::string LLNotificationForm::getDefaultOption()
 	return "";
 }
 
+LLControlVariablePtr LLNotificationForm::getIgnoreSetting() 
+{ 
+	return mIgnoreSetting; 
+}
+
+bool LLNotificationForm::getIgnored()
+{
+	if (mIgnore != LLNotificationForm::IGNORE_NO
+		&& mIgnoreSetting) 
+	{
+		return mIgnoreSetting->getValue().asBoolean() != mInvertSetting;
+	}
+
+	return false;
+}
+
+void LLNotificationForm::setIgnored(bool ignored)
+{
+	if (mIgnoreSetting) mIgnoreSetting->setValue(ignored != mInvertSetting);
+}
+
 LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Params& p)
 :	mName(p.name),
 	mType(p.type),
@@ -545,8 +612,8 @@ 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);
+		bool show_notification = !mIgnored;
+		mForm->setIgnored(!show_notification);
 		if (mIgnored && mForm->getIgnoreType() == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
 		{
 			LLUI::sSettingGroups["ignores"]->setLLSD("Default" + getName(), response);
@@ -1294,11 +1361,11 @@ bool LLNotifications::loadTemplates()
 			}
 			if(it->form_ref.form_template.cancel_text.isProvided())
 			{
-				replaceFormText(it->form_ref.form, "$cancel_text", it->form_ref.form_template.cancel_text);
+				replaceFormText(it->form_ref.form, "$canceltext", it->form_ref.form_template.cancel_text);
 			}
 			if(it->form_ref.form_template.ignore_text.isProvided())
 			{
-				replaceFormText(it->form_ref.form, "$ignore_text", it->form_ref.form_template.ignore_text);
+				replaceFormText(it->form_ref.form, "$ignoretext", it->form_ref.form_template.ignore_text);
 			}
 		}
 		addTemplate(it->name, LLNotificationTemplatePtr(new LLNotificationTemplate(*it)));
-- 
cgit v1.2.3


From 2dc14c66d4f50dfe4d140b5630cadf2febcee09d Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Thu, 16 Sep 2010 17:55:28 -0700
Subject: fix for all notifications being ignored by default

---
 indra/llui/llnotifications.cpp | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index bd58fe2637..6a0d64e876 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -62,7 +62,7 @@ LLNotificationForm::FormElementBase::FormElementBase()
 LLNotificationForm::FormIgnore::FormIgnore()
 :	text("text"),
 	control("control"),
-	invert_control("invert_control", false),
+	invert_control("invert_control", true),
 	save_option("save_option", false)
 {}
 
@@ -190,7 +190,7 @@ LLNotificationForm::LLNotificationForm()
 
 LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotificationForm::Params& p) 
 :	mIgnore(IGNORE_NO),
-	mInvertSetting(false)
+	mInvertSetting(true) // ignore settings by default mean true=show, false=ignore
 {
 	if (p.ignore.isProvided())
 	{
@@ -353,18 +353,24 @@ LLControlVariablePtr LLNotificationForm::getIgnoreSetting()
 
 bool LLNotificationForm::getIgnored()
 {
+	bool ignored = false;
 	if (mIgnore != LLNotificationForm::IGNORE_NO
 		&& mIgnoreSetting) 
 	{
-		return mIgnoreSetting->getValue().asBoolean() != mInvertSetting;
+		ignored = mIgnoreSetting->getValue().asBoolean();
+		if (mInvertSetting) ignored = !ignored;
 	}
 
-	return false;
+	return ignored;
 }
 
 void LLNotificationForm::setIgnored(bool ignored)
 {
-	if (mIgnoreSetting) mIgnoreSetting->setValue(ignored != mInvertSetting);
+	if (mIgnoreSetting)
+	{
+		if (mInvertSetting) ignored = !ignored;
+		mIgnoreSetting->setValue(ignored);
+	}
 }
 
 LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Params& p)
-- 
cgit v1.2.3


From 8e09bcd703a81bfb114df53e620e758a358149a2 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Fri, 17 Sep 2010 17:28:22 -0700
Subject: fix for clicking on Invite Friends resulting in disabling popups

---
 indra/llui/llnotifications.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 6a0d64e876..2a7ca4c321 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -618,8 +618,7 @@ void LLNotification::respond(const LLSD& response)
 
 	if (mForm->getIgnoreType() != LLNotificationForm::IGNORE_NO)
 	{
-		bool show_notification = !mIgnored;
-		mForm->setIgnored(!show_notification);
+		mForm->setIgnored(mIgnored);
 		if (mIgnored && mForm->getIgnoreType() == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
 		{
 			LLUI::sSettingGroups["ignores"]->setLLSD("Default" + getName(), response);
@@ -745,6 +744,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)
 	{
-- 
cgit v1.2.3


From a748466377982f376d4901e3450e6b927cf96a4d Mon Sep 17 00:00:00 2001
From: Richard Nelson <none@none>
Date: Mon, 20 Sep 2010 19:16:17 -0700
Subject: EXP-82 FIX MOTD open in external browser notification not given until
 fully logged in reviewed by Monroe

---
 indra/llui/llnotifications.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 2a7ca4c321..9d14c4149c 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -628,6 +628,12 @@ void LLNotification::respond(const LLSD& response)
 	update();
 }
 
+void LLNotification::respondWithDefault()
+{
+	respond(getResponseTemplate(WITH_DEFAULT_BUTTON));
+}
+
+
 const std::string& LLNotification::getName() const
 {
 	return mTemplatep->mName;
-- 
cgit v1.2.3


From 325f16d0b4c8fc9de694121d770a4931a7b98529 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Tue, 21 Sep 2010 14:28:03 -0700
Subject: fix for mac build and possible crash when responding to notification
 twice

---
 indra/llui/llnotifications.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 9d14c4149c..ab9bd12b85 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -600,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 =
@@ -608,6 +608,11 @@ void LLNotification::respond(const LLSD& response)
 		// and then call it
 		functor(asLLSD(), response);
 	}
+	else
+	{
+		// no registered responder
+		return;
+	}
 
 	if (mTemporaryResponder && !isReusable())
 	{
-- 
cgit v1.2.3


From 0edb695ea86d7997ae3952e155ed5b4922c799f8 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Wed, 22 Sep 2010 14:48:18 -0700
Subject: instead of exposing mutable container in LLInitParam::Multiple, just
 expose access functions, begin(), end(), etc. this allows mutation of param
 block contents, without being able to change number of elements

---
 indra/llui/llnotifications.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'indra/llui/llnotifications.cpp')

diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index ab9bd12b85..67b3c5cfce 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -395,8 +395,8 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par
 		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();
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::UniquenessContext>::const_iterator it = p.unique.contexts.begin(),
+			end_it = p.unique.contexts.end();
 		it != end_it;
 		++it)
 	{
@@ -1313,8 +1313,8 @@ void replaceFormText(LLNotificationForm::Params& form, const std::string& patter
 	{
 		form.ignore.text = replace;
 	}
-	for (LLInitParam::ParamIterator<LLNotificationForm::FormElement>::iterator it = form.form_elements.elements().begin(),
-			end_it = form.form_elements.elements().end();
+	for (LLInitParam::ParamIterator<LLNotificationForm::FormElement>::iterator it = form.form_elements.elements.begin(),
+			end_it = form.form_elements.elements.end();
 		it != end_it;
 		++it)
 	{
@@ -1345,7 +1345,7 @@ bool LLNotifications::loadTemplates()
 
 	mTemplates.clear();
 
-	for(LLInitParam::ParamIterator<LLNotificationTemplate::GlobalString>::const_iterator it = params.strings().begin(), end_it = params.strings().end();
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::GlobalString>::const_iterator it = params.strings.begin(), end_it = params.strings.end();
 		it != end_it;
 		++it)
 	{
@@ -1354,14 +1354,14 @@ bool LLNotifications::loadTemplates()
 
 	std::map<std::string, LLNotificationForm::Params> form_templates;
 
-	for(LLInitParam::ParamIterator<LLNotificationTemplate::Template>::const_iterator it = params.templates().begin(), end_it = params.templates().end();
+	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();
+	for(LLInitParam::ParamIterator<LLNotificationTemplate::Params>::iterator it = params.notifications.begin(), end_it = params.notifications.end();
 		it != end_it;
 		++it)
 	{
-- 
cgit v1.2.3