From 636c86782b9c8a37996aaf01868f713214c54584 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Wed, 22 Sep 2010 16:12:04 -0700 Subject: cleaned up notifications.xml and made global notifications toggle not use or modify saved responses --- indra/llui/llnotifications.cpp | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index ab9bd12b85..d86b0183fc 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -133,12 +133,6 @@ private: bool filterIgnoredNotifications(LLNotificationPtr notification) { - // filter everything if we are to ignore ALL - if(LLNotifications::instance().getIgnoreAllNotifications()) - { - return false; - } - LLNotificationFormPtr form = notification->getForm(); // Check to see if the user wants to ignore this alert return !notification->getForm()->getIgnored(); @@ -173,6 +167,20 @@ bool handleIgnoredNotification(const LLSD& payload) return false; } +bool defaultResponse(const LLSD& payload) +{ + if (payload["sigtype"].asString() == "add") + { + LLNotificationPtr pNotif = LLNotifications::instance().find(payload["id"].asUUID()); + if (pNotif) + { + // supply default response + pNotif->respond(pNotif->getResponseTemplate(LLNotification::WITH_DEFAULT_BUTTON)); + } + } + return false; +} + namespace LLNotificationFilters { // a sample filter @@ -1187,9 +1195,11 @@ void LLNotifications::createDefaultChannels() { // now construct the various channels AFTER loading the notifications, // because the history channel is going to rewrite the stored notifications file - LLNotificationChannel::buildChannel("Expiration", "", + LLNotificationChannel::buildChannel("Enabled", "", + !boost::bind(&LLNotifications::getIgnoreAllNotifications, this)); + LLNotificationChannel::buildChannel("Expiration", "Enabled", boost::bind(&LLNotifications::expirationFilter, this, _1)); - LLNotificationChannel::buildChannel("Unexpired", "", + LLNotificationChannel::buildChannel("Unexpired", "Enabled", !boost::bind(&LLNotifications::expirationFilter, this, _1)); // use negated bind LLNotificationChannel::buildChannel("Unique", "Unexpired", boost::bind(&LLNotifications::uniqueFilter, this, _1)); @@ -1203,6 +1213,8 @@ void LLNotifications::createDefaultChannels() new LLPersistentNotificationChannel(); // connect action methods to these channels + LLNotifications::instance().getChannel("Enabled")-> + connectFailedFilter(&defaultResponse); LLNotifications::instance().getChannel("Expiration")-> connectChanged(boost::bind(&LLNotifications::expirationHandler, this, _1)); // uniqueHandler slot should be added as first slot of the signal due to -- cgit v1.2.3 From ff071bbdce6478f8cd666ecf75658ca6e24f1140 Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Tue, 28 Sep 2010 16:49:22 -0700 Subject: Added a mechanism for preventing classes of notifications from being displayed, controlled by the notification_visibility.xml file in the viewer skin. Reviewed by Richard. --- indra/llui/llnotifications.cpp | 75 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 74 insertions(+), 1 deletion(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 9a3933093c..46af9323e1 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -28,6 +28,7 @@ #include "llnotifications.h" #include "llnotificationtemplate.h" +#include "llnotificationvisibilityrule.h" #include "llinstantmessage.h" #include "llxmlnode.h" @@ -414,6 +415,13 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par mForm = LLNotificationFormPtr(new LLNotificationForm(p.name, p.form_ref.form)); } +LLNotificationVisibilityRule::LLNotificationVisibilityRule(const LLNotificationVisibilityRule::Params &p) +: mVisible(p.visible), + mType(p.type), + mTag(p.tag) +{ +} + LLNotification::LLNotification(const LLNotification::Params& p) : mTimestamp(p.time_stamp), mSubstitutions(p.substitutions), @@ -1188,6 +1196,7 @@ LLNotificationChannelPtr LLNotifications::getChannel(const std::string& channelN void LLNotifications::initSingleton() { loadTemplates(); + loadVisibilityRules(); createDefaultChannels(); } @@ -1205,7 +1214,9 @@ void LLNotifications::createDefaultChannels() boost::bind(&LLNotifications::uniqueFilter, this, _1)); LLNotificationChannel::buildChannel("Ignore", "Unique", filterIgnoredNotifications); - LLNotificationChannel::buildChannel("Visible", "Ignore", + LLNotificationChannel::buildChannel("VisibilityRules", "Ignore", + boost::bind(&LLNotifications::isVisibleByRules, this, _1)); + LLNotificationChannel::buildChannel("Visible", "VisibilityRules", &LLNotificationFilters::includeEverything); // create special persistent notification channel @@ -1226,6 +1237,8 @@ void LLNotifications::createDefaultChannels() // connectFailedFilter(boost::bind(&LLNotifications::failedUniquenessTest, this, _1)); LLNotifications::instance().getChannel("Ignore")-> connectFailedFilter(&handleIgnoredNotification); + LLNotifications::instance().getChannel("VisibilityRules")-> + connectFailedFilter(&handleIgnoredNotification); } bool LLNotifications::addTemplate(const std::string &name, @@ -1404,6 +1417,36 @@ bool LLNotifications::loadTemplates() return true; } +bool LLNotifications::loadVisibilityRules() +{ + const std::string xml_filename = "notification_visibility.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( "notification_visibility" )) + { + llerrs << "Problem reading UI Notification Visibility Rules file: " << full_filename << llendl; + return false; + } + + LLNotificationVisibilityRule::Rules params; + LLXUIParser parser; + parser.readXUI(root, params, full_filename); + + mVisibilityRules.clear(); + + for(LLInitParam::ParamIterator::iterator it = params.rules.begin(), end_it = params.rules.end(); + it != end_it; + ++it) + { + mVisibilityRules.push_back(LLNotificationVisibilityRulePtr(new LLNotificationVisibilityRule(*it))); + } + + return true; +} + // Add a simple notification (from XUI) void LLNotifications::addFromCallback(const LLSD& name) { @@ -1553,6 +1596,36 @@ bool LLNotifications::getIgnoreAllNotifications() { return mIgnoreAllNotifications; } + +bool LLNotifications::isVisibleByRules(LLNotificationPtr n) +{ + VisibilityRuleList::iterator it; + + for(it = mVisibilityRules.begin(); it != mVisibilityRules.end(); it++) + { + // An empty type or tag string will match any notification, so only do the comparison when the string is non-empty in the rule. + + if(!(*it)->mType.empty()) + { + if((*it)->mType != n->getType()) + { + // Type doesn't match, so skip this rule. + continue; + } + } + + if(!(*it)->mTag.empty()) + { + // TODO: check this notification's tag(s) against it->mTag and continue if no match is found. + } + + // If we got here, the rule matches. Don't evaluate subsequent rules. + return (*it)->mVisible; + } + + // Default for cases with no rules or incomplete rules is to show all notifications. + return true; +} // --- // END OF LLNotifications implementation -- cgit v1.2.3 From b2ebf4c245fa4b5024c6c2bee46c426ad58cb14c Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Tue, 28 Sep 2010 17:10:40 -0700 Subject: Add XML validation in LLNotifications when loading notifications.xml and notification_visibility.xml. Reviewed by Richard. --- indra/llui/llnotifications.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 46af9323e1..6e1f574935 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -1367,6 +1367,12 @@ bool LLNotifications::loadTemplates() LLNotificationTemplate::Notifications params; LLXUIParser parser; parser.readXUI(root, params, full_filename); + + if(!params.validateBlock()) + { + llerrs << "Problem reading UI Notifications file: " << full_filename << llendl; + return false; + } mTemplates.clear(); @@ -1435,6 +1441,12 @@ bool LLNotifications::loadVisibilityRules() LLXUIParser parser; parser.readXUI(root, params, full_filename); + if(!params.validateBlock()) + { + llerrs << "Problem reading UI Notification Visibility Rules file: " << full_filename << llendl; + return false; + } + mVisibilityRules.clear(); for(LLInitParam::ParamIterator::iterator it = params.rules.begin(), end_it = params.rules.end(); -- cgit v1.2.3 From 27f6b2ea7d9339f9ecfd3f7bbbde356cfe007848 Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Wed, 29 Sep 2010 16:51:21 -0700 Subject: Change non-visible notifications to return empty response instead of default. This is part of EXP-111. Reviewed by Richard. --- indra/llui/llnotifications.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 6e1f574935..98718e4de7 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -182,6 +182,20 @@ bool defaultResponse(const LLSD& payload) return false; } +bool emptyResponse(const LLSD& payload) +{ + if (payload["sigtype"].asString() == "add") + { + LLNotificationPtr pNotif = LLNotifications::instance().find(payload["id"].asUUID()); + if (pNotif) + { + // supply empty response + pNotif->respond(pNotif->getResponseTemplate(LLNotification::WITHOUT_DEFAULT_BUTTON)); + } + } + return false; +} + namespace LLNotificationFilters { // a sample filter @@ -1238,7 +1252,7 @@ void LLNotifications::createDefaultChannels() LLNotifications::instance().getChannel("Ignore")-> connectFailedFilter(&handleIgnoredNotification); LLNotifications::instance().getChannel("VisibilityRules")-> - connectFailedFilter(&handleIgnoredNotification); + connectFailedFilter(&emptyResponse); } bool LLNotifications::addTemplate(const std::string &name, -- cgit v1.2.3 From cd2b9b45faa6dfd7a4c4e72fbe5395de8ad8f98d Mon Sep 17 00:00:00 2001 From: Monroe Williams Date: Thu, 30 Sep 2010 12:18:49 -0700 Subject: Cancel hidden notifications instead of using empty responses. This is more work on EXP-111. Reviewed by Richard. --- indra/llui/llnotifications.cpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 98718e4de7..dd56f03237 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -196,6 +196,17 @@ bool emptyResponse(const LLSD& payload) return false; } +bool cancelNotification(const LLSD& payload) +{ + if (payload["sigtype"].asString() == "add") + { + // cancel this notification + LLNotifications::instance().cancel(LLNotifications::instance().find(payload["id"].asUUID())); + } + return false; +} + + namespace LLNotificationFilters { // a sample filter @@ -1252,7 +1263,7 @@ void LLNotifications::createDefaultChannels() LLNotifications::instance().getChannel("Ignore")-> connectFailedFilter(&handleIgnoredNotification); LLNotifications::instance().getChannel("VisibilityRules")-> - connectFailedFilter(&emptyResponse); + connectFailedFilter(&cancelNotification); } bool LLNotifications::addTemplate(const std::string &name, -- cgit v1.2.3 From 2b6d3b851fc6210e7cf6272ac0bc9f8645ca5644 Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Thu, 30 Sep 2010 14:48:36 -0700 Subject: Adding tags mechanism to notification visibility rules. Also started adding the tag 'fail' to entries in notifications.xml that are failures the user should always be told about. Reviewed by Richard. --- indra/llui/llnotifications.cpp | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index dd56f03237..289020fa3f 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -437,6 +437,14 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par mUniqueContext.push_back(it->key); } + for(LLInitParam::ParamIterator::const_iterator it = p.tags.begin(), + end_it = p.tags.end(); + it != end_it; + ++it) + { + mTags.push_back(it->value); + } + mForm = LLNotificationFormPtr(new LLNotificationForm(p.name, p.form_ref.form)); } @@ -716,6 +724,25 @@ bool LLNotification::hasUniquenessConstraints() const return (mTemplatep ? mTemplatep->mUnique : false); } +bool LLNotification::matchesTag(const std::string& tag) +{ + bool result = false; + + if(mTemplatep) + { + std::list::iterator it; + for(it = mTemplatep->mTags.begin(); it != mTemplatep->mTags.end(); it++) + { + if((*it) == tag) + { + result = true; + break; + } + } + } + + return result; +} void LLNotification::setIgnored(bool ignore) { @@ -1653,7 +1680,12 @@ bool LLNotifications::isVisibleByRules(LLNotificationPtr n) if(!(*it)->mTag.empty()) { - // TODO: check this notification's tag(s) against it->mTag and continue if no match is found. + // check this notification's tag(s) against it->mTag and continue if no match is found. + if(!n->matchesTag((*it)->mTag)) + { + // This rule's non-empty tag didn't match one of the notification's tags. Skip this rule. + continue; + } } // If we got here, the rule matches. Don't evaluate subsequent rules. -- cgit v1.2.3 From a82a270b80a6bb9ed1a6bd1f70a42f4234197c36 Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Fri, 1 Oct 2010 17:43:27 -0700 Subject: More precise control of notifications using notification_visibility.xml. Added a "name" property that lets a rule match a specific notification. Added a "response" property that lets a rule specify a response when it matches. Reviewed by Richard. --- indra/llui/llnotifications.cpp | 84 +++++++++++++++++++++++++++++------------- 1 file changed, 58 insertions(+), 26 deletions(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 289020fa3f..5b2e7590b1 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -182,28 +182,11 @@ bool defaultResponse(const LLSD& payload) return false; } -bool emptyResponse(const LLSD& payload) +bool visibilityRuleMached(const LLSD& payload) { - if (payload["sigtype"].asString() == "add") - { - LLNotificationPtr pNotif = LLNotifications::instance().find(payload["id"].asUUID()); - if (pNotif) - { - // supply empty response - pNotif->respond(pNotif->getResponseTemplate(LLNotification::WITHOUT_DEFAULT_BUTTON)); - } - } - return false; -} - -bool cancelNotification(const LLSD& payload) -{ - if (payload["sigtype"].asString() == "add") - { - // cancel this notification - LLNotifications::instance().cancel(LLNotifications::instance().find(payload["id"].asUUID())); - } - return false; + // This is needed because LLNotifications::isVisibleByRules may have cancelled the notification. + // Returning true here makes LLNotificationChannelBase::updateItem do an early out, which prevents things from happening in the wrong order. + return true; } @@ -450,8 +433,10 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par LLNotificationVisibilityRule::LLNotificationVisibilityRule(const LLNotificationVisibilityRule::Params &p) : mVisible(p.visible), + mResponse(p.response), mType(p.type), - mTag(p.tag) + mTag(p.tag), + mName(p.name) { } @@ -1290,7 +1275,7 @@ void LLNotifications::createDefaultChannels() LLNotifications::instance().getChannel("Ignore")-> connectFailedFilter(&handleIgnoredNotification); LLNotifications::instance().getChannel("VisibilityRules")-> - connectFailedFilter(&cancelNotification); + connectFailedFilter(&visibilityRuleMached); } bool LLNotifications::addTemplate(const std::string &name, @@ -1663,6 +1648,12 @@ bool LLNotifications::getIgnoreAllNotifications() bool LLNotifications::isVisibleByRules(LLNotificationPtr n) { + if(n->isRespondedTo()) + { + // This avoids infinite recursion in the case where the filter calls respond() + return true; + } + VisibilityRuleList::iterator it; for(it = mVisibilityRules.begin(); it != mVisibilityRules.end(); it++) @@ -1687,15 +1678,56 @@ bool LLNotifications::isVisibleByRules(LLNotificationPtr n) continue; } } + + if(!(*it)->mName.empty()) + { + lldebugs << "rule name = " << (*it)->mName << ", notification name = " << n->getName() << llendl; + + // check this notification's name against the notification's name and continue if no match is found. + if((*it)->mName != n->getName()) + { + // This rule's non-empty name didn't match the notification. Skip this rule. + continue; + } + } // If we got here, the rule matches. Don't evaluate subsequent rules. - return (*it)->mVisible; + if(!(*it)->mVisible) + { + // This notification is being hidden. + + if((*it)->mResponse.empty()) + { + // Response property is empty. Cancel this notification. + lldebugs << "cancelling notification " << n->getName() << llendl; + + n->cancel(); + } + else + { + // Response property is not empty. Return the specified response. + LLSD response = n->getResponseTemplate(LLNotification::WITHOUT_DEFAULT_BUTTON); + // TODO: verify that the response template has an item with the correct name + response[(*it)->mResponse] = true; + + lldebugs << "responding to notification " << n->getName() << " with response = " << response << llendl; + + n->respond(response); + } + + return false; + } + + // If we got here, exit the loop and return true. + break; } - // Default for cases with no rules or incomplete rules is to show all notifications. + lldebugs << "allowing notification " << n->getName() << llendl; + return true; } - + + // --- // END OF LLNotifications implementation // ========================================================= -- cgit v1.2.3 From ff81c6c529ce2c7216ee2cd5aa60b7a232792fec Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 5 Oct 2010 14:31:07 -0700 Subject: changed format of notification_visibility rules to be cleaner --- indra/llui/llnotifications.cpp | 45 +++++++++++++++++++++++++----------------- 1 file changed, 27 insertions(+), 18 deletions(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 92fa6ada54..c41c19216c 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -431,13 +431,30 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par mForm = LLNotificationFormPtr(new LLNotificationForm(p.name, p.form_ref.form)); } -LLNotificationVisibilityRule::LLNotificationVisibilityRule(const LLNotificationVisibilityRule::Params &p) -: mVisible(p.visible), - mResponse(p.response), - mType(p.type), - mTag(p.tag), - mName(p.name) +LLNotificationVisibilityRule::LLNotificationVisibilityRule(const LLNotificationVisibilityRule::Rule &p) { + if (p.show.isChosen()) + { + mType = p.show.type; + mTag = p.show.tag; + mName = p.show.name; + mVisible = true; + } + else if (p.hide.isChosen()) + { + mType = p.hide.type; + mTag = p.hide.tag; + mName = p.hide.name; + mVisible = false; + } + else if (p.respond.isChosen()) + { + mType = p.respond.type; + mTag = p.respond.tag; + mName = p.respond.name; + mVisible = false; + mResponse = p.respond.response; + } } LLNotification::LLNotification(const LLNotification::Params& p) : @@ -1465,18 +1482,9 @@ bool LLNotifications::loadVisibilityRules() const std::string xml_filename = "notification_visibility.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( "notification_visibility" )) - { - llerrs << "Problem reading UI Notification Visibility Rules file: " << full_filename << llendl; - return false; - } - LLNotificationVisibilityRule::Rules params; - LLXUIParser parser; - parser.readXUI(root, params, full_filename); + LLSimpleXUIParser parser; + parser.readXUI(full_filename, params); if(!params.validateBlock()) { @@ -1486,7 +1494,8 @@ bool LLNotifications::loadVisibilityRules() mVisibilityRules.clear(); - for(LLInitParam::ParamIterator::iterator it = params.rules.begin(), end_it = params.rules.end(); + for(LLInitParam::ParamIterator::iterator it = params.rules.begin(), + end_it = params.rules.end(); it != end_it; ++it) { -- cgit v1.2.3 From 1ae67f66d1d0203069cec62421d1d71d67a3334f Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Thu, 7 Oct 2010 15:44:35 -0700 Subject: Fixed a problem that prevented notification tags from being parsed. Added some lldebugs to the LLNotificationTemplate constructor and LLNotifications::isVisibleByRules() that may be useful in debugging notification issues in the future. --- 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 c41c19216c..916ca24d13 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -419,12 +419,15 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par { mUniqueContext.push_back(it->key); } - + + lldebugs << "notification \"" << mName << "\": tag count is " << p.tags.size() << llendl; + for(LLInitParam::ParamIterator::const_iterator it = p.tags.begin(), end_it = p.tags.end(); it != end_it; ++it) { + lldebugs << " tag \"" << std::string(it->value) << "\"" << llendl; mTags.push_back(it->value); } @@ -1667,7 +1670,15 @@ bool LLNotifications::isVisibleByRules(LLNotificationPtr n) for(it = mVisibilityRules.begin(); it != mVisibilityRules.end(); it++) { - // An empty type or tag string will match any notification, so only do the comparison when the string is non-empty in the rule. + // An empty type/tag/name string will match any notification, so only do the comparison when the string is non-empty in the rule. + + lldebugs + << "notification \"" << n->getName() << "\" " + << "testing against " << ((*it)->mVisible?"show":"hide") << " rule, " + << "name = \"" << (*it)->mName << "\" " + << "tag = \"" << (*it)->mTag << "\" " + << "type = \"" << (*it)->mType << "\" " + << llendl; if(!(*it)->mType.empty()) { @@ -1690,8 +1701,6 @@ bool LLNotifications::isVisibleByRules(LLNotificationPtr n) if(!(*it)->mName.empty()) { - lldebugs << "rule name = " << (*it)->mName << ", notification name = " << n->getName() << llendl; - // check this notification's name against the notification's name and continue if no match is found. if((*it)->mName != n->getName()) { -- cgit v1.2.3 From b10744dbee7ffa64180f5558cac874e126045fc8 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Mon, 11 Oct 2010 16:33:23 -0700 Subject: fix for default notification form valus not appearing --- indra/llui/llnotifications.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp index 916ca24d13..133d12ff22 100644 --- a/indra/llui/llnotifications.cpp +++ b/indra/llui/llnotifications.cpp @@ -80,7 +80,8 @@ LLNotificationForm::FormButton::FormButton() LLNotificationForm::FormInput::FormInput() : type("type"), - width("width", 0) + width("width", 0), + value("value") {} LLNotificationForm::FormElement::FormElement() -- cgit v1.2.3