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.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/CMakeLists.txt | 1 + indra/llui/llnotifications.cpp | 75 ++++++++++++++++++++- indra/llui/llnotifications.h | 17 ++++- indra/llui/llnotificationvisibilityrule.h | 76 ++++++++++++++++++++++ indra/newview/llfloaternotificationsconsole.cpp | 1 + .../default/xui/en/notification_visibility.xml | 5 ++ 6 files changed, 173 insertions(+), 2 deletions(-) create mode 100644 indra/llui/llnotificationvisibilityrule.h create mode 100644 indra/newview/skins/default/xui/en/notification_visibility.xml (limited to 'indra/llui/llnotifications.cpp') diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt index e98201ea63..864f3f699e 100644 --- a/indra/llui/CMakeLists.txt +++ b/indra/llui/CMakeLists.txt @@ -159,6 +159,7 @@ set(llui_HEADER_FILES llnotificationslistener.h llnotificationsutil.h llnotificationtemplate.h + llnotificationvisibilityrule.h llpanel.h llprogressbar.h llradiogroup.h 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 diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h index 4fe1687f0e..75c67151ca 100644 --- a/indra/llui/llnotifications.h +++ b/indra/llui/llnotifications.h @@ -268,6 +268,11 @@ struct LLNotificationTemplate; // with smart pointers typedef boost::shared_ptr LLNotificationTemplatePtr; + +struct LLNotificationVisibilityRule; + +typedef boost::shared_ptr LLNotificationVisibilityRulePtr; + /** * @class LLNotification * @brief The object that expresses the details of a notification @@ -856,6 +861,10 @@ public: // load notification descriptions from file; // OK to call more than once because it will reload bool loadTemplates(); + + // load visibility rules from file; + // OK to call more than once because it will reload + bool loadVisibilityRules(); // Add a simple notification (from XUI) void addFromCallback(const LLSD& name); @@ -902,6 +911,8 @@ public: // test for existence bool templateExists(const std::string& name); + typedef std::list VisibilityRuleList; + void forceResponse(const LLNotification::Params& params, S32 option); void createDefaultChannels(); @@ -916,7 +927,9 @@ public: void setIgnoreAllNotifications(bool ignore); bool getIgnoreAllNotifications(); - + + bool isVisibleByRules(LLNotificationPtr pNotification); + private: // we're a singleton, so we don't have a public constructor LLNotifications(); @@ -935,6 +948,8 @@ private: // put your template in bool addTemplate(const std::string& name, LLNotificationTemplatePtr theTemplate); TemplateMap mTemplates; + + VisibilityRuleList mVisibilityRules; std::string mFileName; diff --git a/indra/llui/llnotificationvisibilityrule.h b/indra/llui/llnotificationvisibilityrule.h new file mode 100644 index 0000000000..a98591c9d6 --- /dev/null +++ b/indra/llui/llnotificationvisibilityrule.h @@ -0,0 +1,76 @@ +/** +* @file llnotificationvisibility.h +* @brief Rules for +* @author Monroe +* +* $LicenseInfo:firstyear=2010&license=viewerlgpl$ +* Second Life Viewer Source Code +* 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. +* +* 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. +* +* 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 +* +* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA +* $/LicenseInfo$ +*/ + +#ifndef LL_LLNOTIFICATION_VISIBILITY_RULE_H +#define LL_LLNOTIFICATION_VISIBILITY_RULE_H + +#include "llinitparam.h" +//#include "llnotifications.h" + + + +// This is the class of object read from the XML file (notification_visibility.xml, +// from the appropriate local language directory). +struct LLNotificationVisibilityRule +{ + struct Params : public LLInitParam::Block + { + Mandatory visible; + Optional type; + Optional tag; + + Params() + : visible("visible"), + type("type"), + tag("tag") + {} + }; + + + struct Rules : public LLInitParam::Block + { + Multiple rules; + + Rules() + : rules("rule") + {} + }; + + LLNotificationVisibilityRule(const Params& p); + + // If true, this rule makes matching notifications visible. Otherwise, it makes them invisible. + bool mVisible; + + // String to match against the notification's "type". An empty string matches all notifications. + std::string mType; + + // String to match against the notification's tag(s). An empty string matches all notifications. + std::string mTag; +}; + +#endif //LL_LLNOTIFICATION_VISIBILITY_RULE_H + diff --git a/indra/newview/llfloaternotificationsconsole.cpp b/indra/newview/llfloaternotificationsconsole.cpp index 42dc60f9e0..29af81d64c 100644 --- a/indra/newview/llfloaternotificationsconsole.cpp +++ b/indra/newview/llfloaternotificationsconsole.cpp @@ -174,6 +174,7 @@ BOOL LLFloaterNotificationConsole::postBuild() // these are in the order of processing addChannel("Unexpired"); addChannel("Ignore"); + addChannel("VisibilityRules"); addChannel("Visible", true); // all the ones below attach to the Visible channel addChannel("Persistent"); diff --git a/indra/newview/skins/default/xui/en/notification_visibility.xml b/indra/newview/skins/default/xui/en/notification_visibility.xml new file mode 100644 index 0000000000..cb36890fe6 --- /dev/null +++ b/indra/newview/skins/default/xui/en/notification_visibility.xml @@ -0,0 +1,5 @@ + + + + + -- cgit v1.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.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.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.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 +++++++++++++++++++++- indra/llui/llnotifications.h | 2 ++ indra/llui/llnotificationtemplate.h | 12 ++++++++ .../newview/skins/default/xui/en/notifications.xml | 23 +++++++++++++++ 4 files changed, 70 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. diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h index 75c67151ca..98ff035170 100644 --- a/indra/llui/llnotifications.h +++ b/indra/llui/llnotifications.h @@ -580,6 +580,8 @@ public: std::string summarize() const; bool hasUniquenessConstraints() const; + + bool matchesTag(const std::string& tag); virtual ~LLNotification() {} }; diff --git a/indra/llui/llnotificationtemplate.h b/indra/llui/llnotificationtemplate.h index 6bc0d2aaff..dfc2b10eb5 100644 --- a/indra/llui/llnotificationtemplate.h +++ b/indra/llui/llnotificationtemplate.h @@ -156,6 +156,15 @@ struct LLNotificationTemplate {} }; + struct Tag : public LLInitParam::Block + { + Mandatory value; + + Tag() + : value("value") + {} + }; + struct Params : public LLInitParam::Block { Mandatory name; @@ -173,6 +182,7 @@ struct LLNotificationTemplate Optional form_ref; Optional priority; + Multiple tags; Params() @@ -276,6 +286,8 @@ struct LLNotificationTemplate // this is loaded as a name, but looked up to get the UUID upon template load. // If null, it wasn't specified. LLUUID mSoundEffect; + // List of tags that rules can match against. + std::list mTags; }; #endif //LL_LLNOTIFICATION_TEMPLATE_H diff --git a/indra/newview/skins/default/xui/en/notifications.xml b/indra/newview/skins/default/xui/en/notifications.xml index 5966db9d51..e36109caed 100644 --- a/indra/newview/skins/default/xui/en/notifications.xml +++ b/indra/newview/skins/default/xui/en/notifications.xml @@ -5046,6 +5046,7 @@ You can only claim public land in the Region you're in. name="RegionTPAccessBlocked" persist="true" type="notify"> + fail You aren't allowed in that Region due to your maturity Rating. You may need to validate your age and/or install the latest Viewer. Please go to the Knowledge Base for details on accessing areas with this maturity Rating. @@ -5056,6 +5057,7 @@ Please go to the Knowledge Base for details on accessing areas with this maturit name="URBannedFromRegion" persist="true" type="notify"> + fail You are banned from the region. @@ -5064,6 +5066,7 @@ You are banned from the region. name="NoTeenGridAccess" persist="true" type="notify"> + fail Your account cannot connect to this teen grid region. @@ -5072,6 +5075,7 @@ Your account cannot connect to this teen grid region. name="ImproperPaymentStatus" persist="true" type="notify"> + fail You do not have proper payment status to enter this region. @@ -5080,6 +5084,7 @@ You do not have proper payment status to enter this region. name="MustGetAgeRgion" persist="true" type="notify"> + fail You must be age-verified to enter this region. @@ -5088,6 +5093,7 @@ You must be age-verified to enter this region. name="MustGetAgeParcel" persist="true" type="notify"> + fail You must be age-verified to enter this parcel. @@ -5096,6 +5102,7 @@ You must be age-verified to enter this parcel. name="NoDestRegion" persist="true" type="notify"> + fail No destination region found. @@ -5104,6 +5111,7 @@ No destination region found. name="NotAllowedInDest" persist="true" type="notify"> + fail You are not allowed into the destination. @@ -5112,6 +5120,7 @@ You are not allowed into the destination. name="RegionParcelBan" persist="true" type="notify"> + fail Cannot region cross into banned parcel. Try another way. @@ -5128,6 +5137,7 @@ You have been redirected to a telehub. name="CouldntTPCloser" persist="true" type="notify"> + fail Could not teleport closer to destination. @@ -5144,6 +5154,7 @@ Teleport cancelled. name="FullRegionTryAgain" persist="true" type="notify"> + fail The region you are attempting to enter is currently full. Please try again in a few moments. @@ -5153,6 +5164,7 @@ Please try again in a few moments. name="GeneralFailure" persist="true" type="notify"> + fail General failure. @@ -5161,6 +5173,7 @@ General failure. name="RoutedWrongRegion" persist="true" type="notify"> + fail Routed to wrong region. Please try again. @@ -5169,6 +5182,7 @@ Routed to wrong region. Please try again. name="NoValidAgentID" persist="true" type="notify"> + fail No valid agent id. @@ -5177,6 +5191,7 @@ No valid agent id. name="NoValidSession" persist="true" type="notify"> + fail No valid session id. @@ -5185,6 +5200,7 @@ No valid session id. name="NoValidCircuit" persist="true" type="notify"> + fail No valid circuit code. @@ -5193,6 +5209,7 @@ No valid circuit code. name="NoValidTimestamp" persist="true" type="notify"> + fail No valid timestamp. @@ -5201,6 +5218,7 @@ No valid timestamp. name="NoPendingConnection" persist="true" type="notify"> + fail Unable to create pending connection. @@ -5209,6 +5227,7 @@ Unable to create pending connection. name="InternalUsherError" persist="true" type="notify"> + fail Internal error attempting to connect agent usher. @@ -5217,6 +5236,7 @@ Internal error attempting to connect agent usher. name="NoGoodTPDestination" persist="true" type="notify"> + fail Unable to find a good teleport destination in this region. @@ -5225,6 +5245,7 @@ Unable to find a good teleport destination in this region. name="InternalErrorRegionResolver" persist="true" type="notify"> + fail Internal error attempting to activate region resolver. @@ -5233,6 +5254,7 @@ Internal error attempting to activate region resolver. name="NoValidLanding" persist="true" type="notify"> + fail A valid landing point could not be found. @@ -5241,6 +5263,7 @@ A valid landing point could not be found. name="NoValidParcel" persist="true" type="notify"> + fail No valid parcel could be found. -- cgit v1.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 +++++++++++++++++++++---------- indra/llui/llnotificationvisibilityrule.h | 13 ++++- 2 files changed, 70 insertions(+), 27 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 // ========================================================= diff --git a/indra/llui/llnotificationvisibilityrule.h b/indra/llui/llnotificationvisibilityrule.h index a98591c9d6..58a7eb6176 100644 --- a/indra/llui/llnotificationvisibilityrule.h +++ b/indra/llui/llnotificationvisibilityrule.h @@ -40,13 +40,17 @@ struct LLNotificationVisibilityRule struct Params : public LLInitParam::Block { Mandatory visible; + Optional response; Optional type; Optional tag; + Optional name; Params() : visible("visible"), + response("response"), type("type"), - tag("tag") + tag("tag"), + name("name") {} }; @@ -65,11 +69,18 @@ struct LLNotificationVisibilityRule // If true, this rule makes matching notifications visible. Otherwise, it makes them invisible. bool mVisible; + // Which response to give when making a notification invisible. An empty string means the notification should be cancelled instead of responded to. + std::string mResponse; + // String to match against the notification's "type". An empty string matches all notifications. std::string mType; // String to match against the notification's tag(s). An empty string matches all notifications. std::string mTag; + + // String to match against the notification's name. An empty string matches all notifications. + std::string mName; + }; #endif //LL_LLNOTIFICATION_VISIBILITY_RULE_H -- cgit v1.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 +++++++++++++--------- indra/llui/llnotificationvisibilityrule.h | 45 +++++++++++++++------- .../default/xui/en/notification_visibility.xml | 2 +- 3 files changed, 59 insertions(+), 33 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) { diff --git a/indra/llui/llnotificationvisibilityrule.h b/indra/llui/llnotificationvisibilityrule.h index 58a7eb6176..78bdec2a8f 100644 --- a/indra/llui/llnotificationvisibilityrule.h +++ b/indra/llui/llnotificationvisibilityrule.h @@ -37,34 +37,51 @@ // from the appropriate local language directory). struct LLNotificationVisibilityRule { - struct Params : public LLInitParam::Block + struct Filter : public LLInitParam::Block { - Mandatory visible; - Optional response; - Optional type; - Optional tag; - Optional name; - - Params() - : visible("visible"), - response("response"), - type("type"), + Optional type, + tag, + name; + + Filter() + : type("type"), tag("tag"), name("name") {} }; + struct Respond : public LLInitParam::Block + { + Mandatory response; + + Respond() + : response("response") + {} + }; + + struct Rule : public LLInitParam::Choice + { + Alternative show; + Alternative hide; + Alternative respond; + + Rule() + : show("show"), + hide("hide"), + respond("respond") + {} + }; struct Rules : public LLInitParam::Block { - Multiple rules; + Multiple rules; Rules() - : rules("rule") + : rules("") {} }; - LLNotificationVisibilityRule(const Params& p); + LLNotificationVisibilityRule(const Rule& p); // If true, this rule makes matching notifications visible. Otherwise, it makes them invisible. bool mVisible; diff --git a/indra/newview/skins/default/xui/en/notification_visibility.xml b/indra/newview/skins/default/xui/en/notification_visibility.xml index cb36890fe6..ea32a83b83 100644 --- a/indra/newview/skins/default/xui/en/notification_visibility.xml +++ b/indra/newview/skins/default/xui/en/notification_visibility.xml @@ -1,5 +1,5 @@ - + -- cgit v1.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 +++++++++++++---- indra/llui/llnotificationtemplate.h | 3 ++- 2 files changed, 15 insertions(+), 5 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()) { diff --git a/indra/llui/llnotificationtemplate.h b/indra/llui/llnotificationtemplate.h index dfc2b10eb5..5a6ab40a2e 100644 --- a/indra/llui/llnotificationtemplate.h +++ b/indra/llui/llnotificationtemplate.h @@ -199,7 +199,8 @@ struct LLNotificationTemplate expire_option("expireOption", -1), url("url"), unique("unique"), - form_ref("") + form_ref(""), + tags("tag") {} }; -- cgit v1.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 ++- indra/llui/llnotifications.h | 1 + 2 files changed, 3 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() diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h index 5298549b58..3b50d0b2b6 100644 --- a/indra/llui/llnotifications.h +++ b/indra/llui/llnotifications.h @@ -194,6 +194,7 @@ public: { Mandatory type; Optional width; + Optional value; FormInput(); }; -- cgit v1.3