Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 1133 insertions, 1132 deletions

diff --git a/indra/llui/llnotifications.h b/indra/llui/llnotifications.h
index ccc8a42a6c..c3796252c7 100644
--- a/indra/llui/llnotifications.h
+++ b/indra/llui/llnotifications.h
@@ -1,1132 +1,1133 @@
-/**
-* @file llnotifications.h
-* @brief Non-UI manager and support for keeping a prioritized list of notifications
-* @author Q (with assistance from Richard and Coco)
-*
-* $LicenseInfo:firstyear=2008&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_LLNOTIFICATIONS_H
-#define LL_LLNOTIFICATIONS_H
-
-/**
- * This system is intended to provide a singleton mechanism for adding
- * notifications to one of an arbitrary set of event channels.
- * 
- * Controlling JIRA: DEV-9061
- *
- * Every notification has (see code for full list):
- *  - a textual name, which is used to look up its template in the XML files
- *  - a payload, which is a block of LLSD
- *  - a channel, which is normally extracted from the XML files but
- *	  can be overridden.
- *  - a timestamp, used to order the notifications
- *  - expiration time -- if nonzero, specifies a time after which the
- *    notification will no longer be valid.
- *  - a callback name and a couple of status bits related to callbacks (see below)
- * 
- * There is a management class called LLNotifications, which is an LLSingleton.
- * The class maintains a collection of all of the notifications received
- * or processed during this session, and also manages the persistence
- * of those notifications that must be persisted.
- * 
- * We also have Channels. A channel is a view on a collection of notifications;
- * The collection is defined by a filter function that controls which
- * notifications are in the channel, and its ordering is controlled by 
- * a comparator. 
- *
- * There is a hierarchy of channels; notifications flow down from
- * the management class (LLNotifications, which itself inherits from
- * The channel base class) to the individual channels.
- * Any change to notifications (add, delete, modify) is 
- * automatically propagated through the channel hierarchy.
- * 
- * We provide methods for adding a new notification, for removing
- * one, and for managing channels. Channels are relatively cheap to construct
- * and maintain, so in general, human interfaces should use channels to
- * select and manage their lists of notifications.
- * 
- * We also maintain a collection of templates that are loaded from the 
- * XML file of template translations. The system supports substitution
- * of named variables from the payload into the XML file.
- * 
- * By default, only the "unknown message" template is built into the system.
- * It is not an error to add a notification that's not found in the 
- * template system, but it is logged.
- *
- */
-
-#include <string>
-#include <list>
-#include <vector>
-#include <map>
-#include <set>
-#include <iomanip>
-#include <sstream>
-
-#include <boost/utility.hpp>
-#include <boost/type_traits.hpp>
-#include <boost/signals2.hpp>
-#include <boost/range.hpp>
-
-#include "llevents.h"
-#include "llfunctorregistry.h"
-#include "llinitparam.h"
-#include "llinstancetracker.h"
-#include "llmortician.h"
-#include "llnotificationptr.h"
-#include "llpointer.h"
-#include "llrefcount.h"
-#include "llsdparam.h"
-
-#include "llnotificationslistener.h"
-
-class LLAvatarName;
-typedef enum e_notification_priority
-{
-	NOTIFICATION_PRIORITY_UNSPECIFIED,
-	NOTIFICATION_PRIORITY_LOW,
-	NOTIFICATION_PRIORITY_NORMAL,
-	NOTIFICATION_PRIORITY_HIGH,
-	NOTIFICATION_PRIORITY_CRITICAL
-} ENotificationPriority;
-
-struct NotificationPriorityValues : public LLInitParam::TypeValuesHelper<ENotificationPriority, NotificationPriorityValues>
-{
-	static void declareValues();
-};
-
-class LLNotificationResponderInterface
-{
-public:
-	LLNotificationResponderInterface(){};
-	virtual ~LLNotificationResponderInterface(){};
-
-	virtual void handleRespond(const LLSD& notification, const LLSD& response) = 0;
-
-	virtual LLSD asLLSD() = 0;
-
-	virtual void fromLLSD(const LLSD& params) = 0;
-};
-
-typedef boost::function<void (const LLSD&, const LLSD&)> LLNotificationResponder;
-
-typedef std::shared_ptr<LLNotificationResponderInterface> LLNotificationResponderPtr;
-
-typedef LLFunctorRegistry<LLNotificationResponder> LLNotificationFunctorRegistry;
-typedef LLFunctorRegistration<LLNotificationResponder> LLNotificationFunctorRegistration;
-
-// context data that can be looked up via a notification's payload by the display logic
-// derive from this class to implement specific contexts
-class LLNotificationContext : public LLInstanceTracker<LLNotificationContext, LLUUID>
-{
-public:
-
-	LLNotificationContext() : LLInstanceTracker<LLNotificationContext, LLUUID>(LLUUID::generateNewID())
-	{
-	}
-
-	virtual ~LLNotificationContext() {}
-
-	LLSD asLLSD() const
-	{
-		return getKey();
-	}
-
-private:
-
-};
-
-// Contains notification form data, such as buttons and text fields along with
-// manipulator functions
-class LLNotificationForm
-{
-	LOG_CLASS(LLNotificationForm);
-
-public:
-	struct FormElementBase : public LLInitParam::Block<FormElementBase>
-	{
-		Optional<std::string>	name;
-		Optional<bool>			enabled;
-
-		FormElementBase();
-	};
-
-	struct FormIgnore : public LLInitParam::Block<FormIgnore, FormElementBase>
-	{
-		Optional<std::string>	text;
-		Optional<bool>			save_option;
-		Optional<std::string>	control;
-		Optional<bool>			invert_control;
-		Optional<bool>			session_only;
-		Optional<bool>			checkbox_only;
-
-		FormIgnore();
-	};
-
-	struct FormButton : public LLInitParam::Block<FormButton, FormElementBase>
-	{
-		Mandatory<S32>			index;
-		Mandatory<std::string>	text;
-		Optional<std::string>	ignore;
-		Optional<bool>			is_default;
-		Optional<S32>			width;
-
-		Mandatory<std::string>	type;
-
-		FormButton();
-	};
-
-	struct FormInput : public LLInitParam::Block<FormInput, FormElementBase>
-	{
-		Mandatory<std::string>	type;
-		Optional<S32>			width;
-		Optional<S32>			max_length_chars;
-		Optional<std::string>	text;
-
-		Optional<std::string>	value;
-		FormInput();
-	};
-
-	struct FormElement : public LLInitParam::ChoiceBlock<FormElement>
-	{
-		Alternative<FormButton> button;
-		Alternative<FormInput>	input;
-
-		FormElement();
-	};
-
-	struct FormElements : public LLInitParam::Block<FormElements>
-	{
-		Multiple<FormElement> elements;
-		FormElements();
-	};
-
-	struct Params : public LLInitParam::Block<Params>
-	{
-		Optional<std::string>	name;
-		Optional<FormIgnore>	ignore;
-		Optional<FormElements>	form_elements;
-
-		Params();
-	};
-
-	typedef enum e_ignore_type
-	{ 
-		IGNORE_CHECKBOX_ONLY = -1, // ignore won't be handled, will set value/checkbox only
-		IGNORE_NO = 0,
-		IGNORE_WITH_DEFAULT_RESPONSE,
-		IGNORE_WITH_DEFAULT_RESPONSE_SESSION_ONLY,
-		IGNORE_WITH_LAST_RESPONSE, 
-		IGNORE_SHOW_AGAIN 
-	} EIgnoreType;
-
-	LLNotificationForm();
-	LLNotificationForm(const LLNotificationForm&);
-	LLNotificationForm(const LLSD& sd);
-	LLNotificationForm(const std::string& name, const Params& p);
-
-	void fromLLSD(const LLSD& sd);
-	LLSD asLLSD() const;
-
-	S32 getNumElements() { return mFormData.size(); }
-	LLSD getElement(S32 index) { return mFormData.get(index); }
-	LLSD getElement(const std::string& element_name);
-    void getElements(LLSD& elements, S32 offset = 0);
-	bool hasElement(const std::string& element_name) const;
-	bool getElementEnabled(const std::string& element_name) const;
-	void setElementEnabled(const std::string& element_name, bool enabled);
-	void addElement(const std::string& type, const std::string& name, const LLSD& value = LLSD(), bool enabled = true);
-	void formatElements(const LLSD& substitutions);
-	// appends form elements from another form serialized as LLSD
-	void append(const LLSD& sub_form);
-	std::string getDefaultOption();
-	LLPointer<class LLControlVariable> getIgnoreSetting();
-	bool getIgnored();
-	void setIgnored(bool ignored);
-
-	EIgnoreType getIgnoreType() { return mIgnore; }
-	std::string getIgnoreMessage() { return mIgnoreMsg; }
-
-private:
-	LLSD								mFormData;
-	EIgnoreType							mIgnore;
-	std::string							mIgnoreMsg;
-	LLPointer<class LLControlVariable>	mIgnoreSetting;
-	bool								mInvertSetting;
-};
-
-typedef std::shared_ptr<LLNotificationForm> LLNotificationFormPtr;
-
-
-struct LLNotificationTemplate;
-
-// we want to keep a map of these by name, and it's best to manage them
-// with smart pointers
-typedef std::shared_ptr<LLNotificationTemplate> LLNotificationTemplatePtr;
-
-
-struct LLNotificationVisibilityRule;
-
-typedef std::shared_ptr<LLNotificationVisibilityRule> LLNotificationVisibilityRulePtr;
-
-/**
- * @class LLNotification
- * @brief The object that expresses the details of a notification
- * 
- * We make this noncopyable because
- * we want to manage these through LLNotificationPtr, and only
- * ever create one instance of any given notification.
- * 
- * The enable_shared_from_this flag ensures that if we construct
- * a smart pointer from a notification, we'll always get the same
- * shared pointer.
- */
-class LLNotification  : 
-	boost::noncopyable,
-	public std::enable_shared_from_this<LLNotification>
-{
-LOG_CLASS(LLNotification);
-friend class LLNotifications;
-
-public:
-
-	// parameter object used to instantiate a new notification
-	struct Params : public LLInitParam::Block<Params>
-	{
-		friend class LLNotification;
-	
-		Mandatory<std::string>					name;
-		Optional<LLUUID>						id;
-		Optional<LLSD>							substitutions,
-												form_elements,
-												payload;
-		Optional<ENotificationPriority, NotificationPriorityValues>	priority;
-		Optional<LLDate>						time_stamp,
-												expiry;
-		Optional<LLNotificationContext*>		context;
-		Optional<void*>							responder;
-		Optional<bool>							offer_from_agent;
-        Optional<bool>							is_dnd;
-
-		struct Functor : public LLInitParam::ChoiceBlock<Functor>
-		{
-			Alternative<std::string>										name;
-			Alternative<LLNotificationFunctorRegistry::ResponseFunctor>	function;
-			Alternative<LLNotificationResponderPtr>						responder;
-            Alternative<LLSD>						                    responder_sd;
-
-			Functor()
-			:	name("responseFunctor"),
-				function("functor"),
-				responder("responder"),
-                responder_sd("responder_sd")
-			{}
-		};
-		Optional<Functor>						functor;
-
-		Params()
-		:	name("name"),
-			id("id"),
-			priority("priority", NOTIFICATION_PRIORITY_UNSPECIFIED),
-			time_stamp("time"),
-			payload("payload"),
-			form_elements("form"),
-			substitutions("substitutions"),
-			expiry("expiry"),
-			offer_from_agent("offer_from_agent", false),
-            is_dnd("is_dnd", false)
-		{
-			time_stamp = LLDate::now();
-			responder = NULL;
-		}
-
-		Params(const std::string& _name) 
-		:	name("name"),
-			priority("priority", NOTIFICATION_PRIORITY_UNSPECIFIED),
-			time_stamp("time"),
-			payload("payload"),
-			form_elements("form"),
-			substitutions("substitutions"),
-			expiry("expiry"),
-			offer_from_agent("offer_from_agent", false),
-            is_dnd("is_dnd", false)
-		{
-			functor.name = _name;
-			name = _name;
-			time_stamp = LLDate::now();
-			responder = NULL;
-		}
-	};
-
-	LLNotificationResponderPtr getResponderPtr() { return mResponder; }
-
-private:
-	
-	const LLUUID mId;
-	LLSD mPayload;
-	LLSD mSubstitutions;
-	LLDate mTimestamp;
-	LLDate mExpiresAt;
-	bool mCancelled;
-	bool mRespondedTo; 	// once the notification has been responded to, this becomes true
-	LLSD mResponse;
-	bool mIgnored;
-	ENotificationPriority mPriority;
-	LLNotificationFormPtr mForm;
-	void* mResponderObj; // TODO - refactor/remove this field
-	LLNotificationResponderPtr mResponder;
-	bool mOfferFromAgent;
-    bool mIsDND;
-
-	// a reference to the template
-	LLNotificationTemplatePtr mTemplatep;
-
-	/*
-	 We want to be able to store and reload notifications so that they can survive
-	 a shutdown/restart of the client. So we can't simply pass in callbacks;
-	 we have to specify a callback mechanism that can be used by name rather than 
-	 by some arbitrary pointer -- and then people have to initialize callbacks 
-	 in some useful location. So we use LLNotificationFunctorRegistry to manage them.
-	 */
-	 std::string mResponseFunctorName;
-	
-	/*
-	 In cases where we want to specify an explict, non-persisted callback, 
-	 we store that in the callback registry under a dynamically generated
-	 key, and store the key in the notification, so we can still look it up
-	 using the same mechanism.
-	 */
-	bool mTemporaryResponder;
-	
-	// keep track of other notifications combined with COMBINE_WITH_NEW
-	std::vector<LLNotificationPtr> mCombinedNotifications;
-
-	void init(const std::string& template_name, const LLSD& form_elements);
-
-	void cancel();
-
-public:
-	LLNotification(const LLSDParamAdapter<Params>& p);
-
-	void setResponseFunctor(std::string const &responseFunctorName);
-
-	void setResponseFunctor(const LLNotificationFunctorRegistry::ResponseFunctor& cb);
-
-	void setResponseFunctor(const LLNotificationResponderPtr& responder);
-
-	typedef enum e_response_template_type
-	{
-		WITHOUT_DEFAULT_BUTTON,
-		WITH_DEFAULT_BUTTON
-	} EResponseTemplateType;
-
-	// return response LLSD filled in with default form contents and (optionally) the default button selected
-	LLSD getResponseTemplate(EResponseTemplateType type = WITHOUT_DEFAULT_BUTTON);
-
-	// returns index of first button with value==true
-	// usually this the button the user clicked on
-	// returns -1 if no button clicked (e.g. form has not been displayed)
-	static S32 getSelectedOption(const LLSD& notification, const LLSD& response);
-	// returns name of first button with value==true
-	static std::string getSelectedOptionName(const LLSD& notification);
-
-	// after someone responds to a notification (usually by clicking a button,
-	// but sometimes by filling out a little form and THEN clicking a button),
-    // the result of the response (the name and value of the button clicked,
-	// plus any other data) should be packaged up as LLSD, then passed as a
-	// parameter to the notification's respond() method here. This will look up
-	// and call the appropriate responder.
-	//
-	// response is notification serialized as LLSD:
-	// ["name"] = notification name
-	// ["form"] = LLSD tree that includes form description and any prefilled form data
-	// ["response"] = form data filled in by user
-	// (including, but not limited to which button they clicked on)
-	// ["payload"] = transaction specific data, such as ["source_id"] (originator of notification),  
-	//				["item_id"] (attached inventory item), etc.
-	// ["substitutions"] = string substitutions used to generate notification message
-    // from the template
-	// ["time"] = time at which notification was generated;
-	// ["expiry"] = time at which notification expires;
-	// ["responseFunctor"] = name of registered functor that handles responses to notification;
-	LLSD asLLSD(bool excludeTemplateElements = false);
-
-	const LLNotificationFormPtr getForm();
-	void updateForm(const LLNotificationFormPtr& form);
-
-	void repost();
-
-	void respond(const LLSD& sd);
-	void respondWithDefault();
-
-	void* getResponder() { return mResponderObj; }
-
-	void setResponder(void* responder) { mResponderObj = responder; }
-
-	void setIgnored(bool ignore);
-
-	bool isCancelled() const
-	{
-		return mCancelled;
-	}
-
-	bool isRespondedTo() const
-	{
-		return mRespondedTo;
-	}
-
-	bool isActive() const
-	{
-		return !isRespondedTo()
-			&& !isCancelled()
-			&& !isExpired();
-	}
-
-	const LLSD& getResponse() { return mResponse; }
-
-	bool isIgnored() const
-	{
-		return mIgnored;
-	}
-
-	const std::string& getName() const;
-
-	const std::string& getIcon() const;
-
-	bool isPersistent() const;
-
-	const LLUUID& id() const
-	{
-		return mId;
-	}
-	
-	const LLSD& getPayload() const
-	{
-		return mPayload;
-	}
-
-	const LLSD& getSubstitutions() const
-	{
-		return mSubstitutions;
-	}
-
-	const LLDate& getDate() const
-	{
-		return mTimestamp;
-	}
-
-	bool getOfferFromAgent() const
-	{
-		return mOfferFromAgent;
-	}
-
-    bool isDND() const
-    {
-        return mIsDND;
-    }
-
-    void setDND(const bool flag)
-    {
-        mIsDND = flag;
-    }
-
-	std::string getType() const;
-	std::string getMessage() const;
-	std::string getFooter() const;
-	std::string getLabel() const;
-	std::string getURL() const;
-	S32 getURLOption() const;
-	S32 getURLOpenExternally() const; //for url responce option
-	bool getForceUrlsExternal() const;
-	bool canLogToChat() const;
-	bool canLogToIM() const;
-	bool canShowToast() const;
-	bool canFadeToast() const;
-	bool hasFormElements() const;
-    void playSound();
-
-	typedef enum e_combine_behavior
-	{
-		REPLACE_WITH_NEW,
-		COMBINE_WITH_NEW,
-		KEEP_OLD,
-		CANCEL_OLD
-
-	} ECombineBehavior;
-	
-	ECombineBehavior getCombineBehavior() const;
-
-	const LLDate getExpiration() const
-	{
-		return mExpiresAt;
-	}
-
-	ENotificationPriority getPriority() const
-	{
-		return mPriority;
-	}
-
-	const LLUUID getID() const
-	{
-		return mId;
-	}
-
-	// comparing two notifications normally means comparing them by UUID (so we can look them
-	// up quickly this way)
-	bool operator<(const LLNotification& rhs) const
-	{
-		return mId < rhs.mId;
-	}
-
-	bool operator==(const LLNotification& rhs) const
-	{
-		return mId == rhs.mId;
-	}
-
-	bool operator!=(const LLNotification& rhs) const
-	{
-		return !operator==(rhs);
-	}
-
-	bool isSameObjectAs(const LLNotification* rhs) const
-	{
-		return this == rhs;
-	}
-	
-	// this object has been updated, so tell all our clients
-	void update();
-
-	void updateFrom(LLNotificationPtr other);
-	
-	// A fuzzy equals comparator.
-	// true only if both notifications have the same template and 
-	//     1) flagged as unique (there can be only one of these) OR 
-	//     2) all required payload fields of each also exist in the other.
-	bool isEquivalentTo(LLNotificationPtr that) const;
-	
-	// if the current time is greater than the expiration, the notification is expired
-	bool isExpired() const
-	{
-		if (mExpiresAt.secondsSinceEpoch() == 0)
-		{
-			return false;
-		}
-		
-		LLDate rightnow = LLDate::now();
-		return rightnow > mExpiresAt;
-	}
-	
-	std::string summarize() const;
-
-	bool hasUniquenessConstraints() const;
-
-	bool matchesTag(const std::string& tag);
-
-	virtual ~LLNotification() {}
-};
-
-std::ostream& operator<<(std::ostream& s, const LLNotification& notification);
-
-namespace LLNotificationFilters
-{
-	// a sample filter
-	bool includeEverything(LLNotificationPtr p);
-
-	typedef enum e_comparison 
-	{ 
-		EQUAL, 
-		LESS, 
-		GREATER, 
-		LESS_EQUAL, 
-		GREATER_EQUAL 
-	} EComparison;
-
-	// generic filter functor that takes method or member variable reference
-	template<typename T>
-	struct filterBy
-	{
-		typedef boost::function<T (LLNotificationPtr)>	field_t;
-		typedef typename boost::remove_reference<T>::type		value_t;
-		
-		filterBy(field_t field, value_t value, EComparison comparison = EQUAL) 
-			:	mField(field), 
-				mFilterValue(value),
-				mComparison(comparison)
-		{
-		}		
-		
-		bool operator()(LLNotificationPtr p)
-		{
-			switch(mComparison)
-			{
-			case EQUAL:
-				return mField(p) == mFilterValue;
-			case LESS:
-				return mField(p) < mFilterValue;
-			case GREATER:
-				return mField(p) > mFilterValue;
-			case LESS_EQUAL:
-				return mField(p) <= mFilterValue;
-			case GREATER_EQUAL:
-				return mField(p) >= mFilterValue;
-			default:
-				return false;
-			}
-		}
-
-		field_t mField;
-		value_t	mFilterValue;
-		EComparison mComparison;
-	};
-};
-
-namespace LLNotificationComparators
-{
-	struct orderByUUID
-	{
-		bool operator()(LLNotificationPtr lhs, LLNotificationPtr rhs) const
-		{
-			return lhs->id() < rhs->id();
-		}
-	};
-};
-
-typedef boost::function<bool (LLNotificationPtr)> LLNotificationFilter;
-typedef std::set<LLNotificationPtr, LLNotificationComparators::orderByUUID> LLNotificationSet;
-typedef std::multimap<std::string, LLNotificationPtr> LLNotificationMap;
-
-// ========================================================
-// Abstract base class (interface) for a channel; also used for the master container.
-// This lets us arrange channels into a call hierarchy.
-
-// We maintain a hierarchy of notification channels; events are always started at the top
-// and propagated through the hierarchy only if they pass a filter.
-// Any channel can be created with a parent. A null parent (empty string) means it's
-// tied to the root of the tree (the LLNotifications class itself).
-// The default hierarchy looks like this:
-//
-// LLNotifications --+-- Expiration --+-- Mute --+-- Ignore --+-- Visible --+-- History
-//                                                                          +-- Alerts
-//                                                                          +-- Notifications
-//
-// In general, new channels that want to only see notifications that pass through 
-// all of the built-in tests should attach to the "Visible" channel
-//
-class LLNotificationChannelBase :
-	public LLEventTrackable,
-	public LLRefCount
-{
-	LOG_CLASS(LLNotificationChannelBase);
-public:
-    LLNotificationChannelBase(LLNotificationFilter filter) 
-    : mFilter(filter)
-    , mItems() 
-    , mItemsMutex()
-    {}
-
-    virtual ~LLNotificationChannelBase()
-    {
-        // explicit cleanup for easier issue detection
-        mChanged.disconnect_all_slots();
-        mPassedFilter.disconnect_all_slots();
-        mFailedFilter.disconnect_all_slots();
-        LLMutexLock lock(&mItemsMutex);
-        mItems.clear();
-    }
-	// you can also connect to a Channel, so you can be notified of
-	// changes to this channel
-    LLBoundListener connectChanged(const LLEventListener& slot)
-    {
-        // Call this->connectChangedImpl() to actually connect it.
-        return connectChangedImpl(slot);
-    }
-    LLBoundListener connectAtFrontChanged(const LLEventListener& slot)
-    {
-        return connectAtFrontChangedImpl(slot);
-    }
-    LLBoundListener connectPassedFilter(const LLEventListener& slot)
-    {
-        // see comments in connectChanged()
-        return connectPassedFilterImpl(slot);
-    }
-    LLBoundListener connectFailedFilter(const LLEventListener& slot)
-    {
-        // see comments in connectChanged()
-        return connectFailedFilterImpl(slot);
-    }
-
-	// use this when items change or to add a new one
-	bool updateItem(const LLSD& payload);
-	const LLNotificationFilter& getFilter() { return mFilter; }
-
-protected:
-    LLBoundListener connectChangedImpl(const LLEventListener& slot);
-    LLBoundListener connectAtFrontChangedImpl(const LLEventListener& slot);
-    LLBoundListener connectPassedFilterImpl(const LLEventListener& slot);
-    LLBoundListener connectFailedFilterImpl(const LLEventListener& slot);
-
-	LLNotificationSet mItems;
-	LLStandardSignal mChanged;
-	LLStandardSignal mPassedFilter;
-	LLStandardSignal mFailedFilter;
-    LLMutex mItemsMutex;
-	
-	// these are action methods that subclasses can override to take action 
-	// on specific types of changes; the management of the mItems list is
-	// still handled by the generic handler.
-	virtual void onLoad(LLNotificationPtr p) {}
-	virtual void onAdd(LLNotificationPtr p) {}
-	virtual void onDelete(LLNotificationPtr p) {}
-	virtual void onChange(LLNotificationPtr p) {}
-
-	virtual void onFilterPass(LLNotificationPtr p) {}
-	virtual void onFilterFail(LLNotificationPtr p) {}
-
-	bool updateItem(const LLSD& payload, LLNotificationPtr pNotification);
-	LLNotificationFilter mFilter;
-};
-
-// The type of the pointers that we're going to manage in the NotificationQueue system
-// Because LLNotifications is a singleton, we don't actually expect to ever 
-// destroy it, but if it becomes necessary to do so, the shared_ptr model
-// will ensure that we don't leak resources.
-class LLNotificationChannel;
-typedef boost::intrusive_ptr<LLNotificationChannel> LLNotificationChannelPtr;
-
-// manages a list of notifications
-// Note that if this is ever copied around, we might find ourselves with multiple copies
-// of a queue with notifications being added to different nonequivalent copies. So we 
-// make it inherit from boost::noncopyable, and then create a map of LLPointer to manage it.
-//
-class LLNotificationChannel : 
-	boost::noncopyable, 
-	public LLNotificationChannelBase,
-	public LLInstanceTracker<LLNotificationChannel, std::string>
-{
-	LOG_CLASS(LLNotificationChannel);
-
-public:  
-	// Notification Channels have a filter, which determines which notifications
-	// will be added to this channel. 
-	// Channel filters cannot change.
-	struct Params : public LLInitParam::Block<Params>
-	{
-		Mandatory<std::string>				name;
-		Optional<LLNotificationFilter>		filter;
-		Multiple<std::string>				sources;
-	};
-
-	LLNotificationChannel(const Params& p = Params());
-	LLNotificationChannel(const std::string& name, const std::string& parent, LLNotificationFilter filter);
-
-	virtual ~LLNotificationChannel();
-	typedef LLNotificationSet::iterator Iterator;
-    
-	std::string getName() const { return mName; }
-	typedef std::vector<std::string>::const_iterator parents_iter;
-	boost::iterator_range<parents_iter> getParents() const
-	{
-		return boost::iterator_range<parents_iter>(mParents);
-	}
-
-    bool isEmpty() const;
-    S32 size() const;
-    size_t size();
-
-    typedef boost::function<void(LLNotificationPtr)> NotificationProcess;
-    void forEachNotification(NotificationProcess process);
-
-	std::string summarize();
-
-protected:
-    void connectToChannel(const std::string& channel_name);
-
-private:
-	std::string mName;
-	std::vector<std::string> mParents;
-    std::vector<LLBoundListener> mListeners;
-};
-
-// An interface class to provide a clean linker seam to the LLNotifications class.
-// Extend this interface as needed for your use of LLNotifications.
-class LLNotificationsInterface
-{
-public:
-	virtual LLNotificationPtr add(const std::string& name, 
-						const LLSD& substitutions, 
-						const LLSD& payload, 
-						LLNotificationFunctorRegistry::ResponseFunctor functor) = 0;
-};
-
-class LLNotifications : 
-	public LLNotificationsInterface,
-	public LLSingleton<LLNotifications>, 
-	public LLNotificationChannelBase
-{
-	LLSINGLETON(LLNotifications);
-	LOG_CLASS(LLNotifications);
-	virtual ~LLNotifications() {}
-
-public:
-
-    // Needed to clear up RefCounted things prior to actual destruction
-    // as the singleton nature of the class makes them do "bad things"
-    // on at least Mac, if not all 3 platforms
-    //
-    void clear();
-
-	// load all notification descriptions from file
-	// calling more than once will overwrite existing templates
-	// but never delete a template
-	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);
-	
-	// *NOTE: To add simple notifications, #include "llnotificationsutil.h"
-	// and use LLNotificationsUtil::add("MyNote") or add("MyNote", args)
-	LLNotificationPtr add(const std::string& name, 
-						const LLSD& substitutions,
-						const LLSD& payload);
-	LLNotificationPtr add(const std::string& name, 
-						const LLSD& substitutions, 
-						const LLSD& payload, 
-						const std::string& functor_name);
-	/* virtual */ LLNotificationPtr add(const std::string& name, 
-						const LLSD& substitutions, 
-						const LLSD& payload, 
-						LLNotificationFunctorRegistry::ResponseFunctor functor) override;
-	LLNotificationPtr add(const LLNotification::Params& p);
-
-	void add(const LLNotificationPtr pNotif);
-	void load(const LLNotificationPtr pNotif);
-	void cancel(LLNotificationPtr pNotif);
-	void cancelByName(const std::string& name);
-	void cancelByOwner(const LLUUID ownerId);
-	void update(const LLNotificationPtr pNotif);
-
-	LLNotificationPtr find(LLUUID uuid);
-
-	// This is all stuff for managing the templates
-	// take your template out
-	LLNotificationTemplatePtr getTemplate(const std::string& name);
-	
-	// get the whole collection
-	typedef std::vector<std::string> TemplateNames;
-	TemplateNames getTemplateNames() const;  // returns a list of notification names
-	
-	typedef std::map<std::string, LLNotificationTemplatePtr> TemplateMap;
-
-	TemplateMap::const_iterator templatesBegin() { return mTemplates.begin(); }
-	TemplateMap::const_iterator templatesEnd() { return mTemplates.end(); }
-
-	// test for existence
-	bool templateExists(const std::string& name);
-
-	typedef std::list<LLNotificationVisibilityRulePtr> VisibilityRuleList;
-	
-	void forceResponse(const LLNotification::Params& params, S32 option);
-
-	void createDefaultChannels();
-
-	LLNotificationChannelPtr getChannel(const std::string& channelName);
-	
-	std::string getGlobalString(const std::string& key) const;
-
-	void setIgnoreAllNotifications(bool ignore);
-	bool getIgnoreAllNotifications();
-
-	void setIgnored(const std::string& name, bool ignored);
-	bool getIgnored(const std::string& name);
-
-	bool isVisibleByRules(LLNotificationPtr pNotification);
-	
-private:
-	/*virtual*/ void initSingleton() override;
-	/*virtual*/ void cleanupSingleton() override;
-	
-	void loadPersistentNotifications();
-
-	bool expirationFilter(LLNotificationPtr pNotification);
-	bool expirationHandler(const LLSD& payload);
-	bool uniqueFilter(LLNotificationPtr pNotification);
-	bool uniqueHandler(const LLSD& payload);
-	bool failedUniquenessTest(const LLSD& payload);
-	LLNotificationChannelPtr pHistoryChannel;
-	LLNotificationChannelPtr pExpirationChannel;
-	
-	TemplateMap mTemplates;
-
-	VisibilityRuleList mVisibilityRules;
-
-	std::string mFileName;
-	
-	LLNotificationMap mUniqueNotifications;
-	
-	typedef std::map<std::string, std::string> GlobalStringMap;
-	GlobalStringMap mGlobalStrings;
-
-	bool mIgnoreAllNotifications;
-
-	std::unique_ptr<LLNotificationsListener> mListener;
-
-	std::vector<LLNotificationChannelPtr> mDefaultChannels;
-};
-
-/**
- * Abstract class for postponed notifications.
- * Provides possibility to add notification after specified by id avatar or group will be
- * received from cache name. The object of this type automatically well be deleted
- * by cleanup method after respond will be received from cache name.
- *
- * To add custom postponed notification to the notification system client should:
- *  1 create class derived from LLPostponedNotification;
- *  2 call LLPostponedNotification::add method;
- */
-class LLPostponedNotification : public LLMortician
-{
-public:
-	/**
-	 * Performs hooking cache name callback which will add notification to notifications system.
-	 * Type of added notification should be specified by template parameter T
-	 * and non-private derived from LLPostponedNotification class,
-	 * otherwise compilation error will occur.
-	 */
-	template<class T>
-	static void add(const LLNotification::Params& params,
-			const LLUUID& id, bool is_group)
-	{
-		// upcast T to the base type to restrict T derivation from LLPostponedNotification
-		LLPostponedNotification* thiz = new T();
-		thiz->mParams = params;
-
-		// Avoid header file dependency on llcachename.h
-		thiz->lookupName(id, is_group);
-	}
-
-private:
-	void lookupName(const LLUUID& id, bool is_group);
-	// only used for groups
-	void onGroupNameCache(const LLUUID& id, const std::string& full_name, bool is_group);
-	// only used for avatars
-	void fetchAvatarName(const LLUUID& id);
-	void onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name);
-	// used for both group and avatar names
-	void finalizeName(const std::string& name);
-
-	void cleanup()
-	{
-		die();
-	}
-
-protected:
-	LLPostponedNotification()
-		: mParams(),
-		mName(),
-		mAvatarNameCacheConnection()
-	{}
-
-	virtual ~LLPostponedNotification()
-	{
-		if (mAvatarNameCacheConnection.connected())
-		{
-			mAvatarNameCacheConnection.disconnect();
-		}
-	}
-
-	/**
-	 * Abstract method provides possibility to modify notification parameters and
-	 * will be called after cache name retrieve information about avatar or group
-	 * and before notification will be added to the notification system.
-	 */
-	virtual void modifyNotificationParams() = 0;
-
-	LLNotification::Params mParams;
-	std::string mName;
-	boost::signals2::connection mAvatarNameCacheConnection;
-};
-
-// Stores only persistent notifications.
-// Class users can use connectChanged() to process persistent notifications
-// (see LLPersistentNotificationStorage for example).
-class LLPersistentNotificationChannel : public LLNotificationChannel
-{
-	LOG_CLASS(LLPersistentNotificationChannel);
-public:
-	LLPersistentNotificationChannel() 
-		:	LLNotificationChannel("Persistent", "Visible", &notificationFilter)
-	{}
-
-    virtual ~LLPersistentNotificationChannel()
-    {
-        mHistory.clear();
-    }
-
-	typedef std::vector<LLNotificationPtr> history_list_t;
-	history_list_t::iterator beginHistory() { sortHistory(); return mHistory.begin(); }
-	history_list_t::iterator endHistory() { return mHistory.end(); }
-
-private:
-	struct sortByTime
-	{
-		S32 operator ()(const LLNotificationPtr& a, const LLNotificationPtr& b)
-		{
-			return a->getDate() < b->getDate();
-		}
-	};
-
-	void sortHistory()
-	{
-		std::sort(mHistory.begin(), mHistory.end(), sortByTime());
-	}
-
-	// The channel gets all persistent notifications except those that have been canceled
-	static bool notificationFilter(LLNotificationPtr pNotification)
-	{
-		bool handle_notification = false;
-
-		handle_notification = pNotification->isPersistent()
-			&& !pNotification->isCancelled();
-
-		return handle_notification;
-	}
-
-	void onAdd(LLNotificationPtr p) 
-	{
-		mHistory.push_back(p);
-	}
-
-	void onLoad(LLNotificationPtr p) 
-	{
-		mHistory.push_back(p);
-	}
-
-	std::vector<LLNotificationPtr> mHistory;
-};
-
-#endif//LL_LLNOTIFICATIONS_H
-
+/**

+* @file llnotifications.h

+* @brief Non-UI manager and support for keeping a prioritized list of notifications

+* @author Q (with assistance from Richard and Coco)

+*

+* $LicenseInfo:firstyear=2008&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_LLNOTIFICATIONS_H

+#define LL_LLNOTIFICATIONS_H

+

+/**

+ * This system is intended to provide a singleton mechanism for adding

+ * notifications to one of an arbitrary set of event channels.

+ *

+ * Controlling JIRA: DEV-9061

+ *

+ * Every notification has (see code for full list):

+ *  - a textual name, which is used to look up its template in the XML files

+ *  - a payload, which is a block of LLSD

+ *  - a channel, which is normally extracted from the XML files but

+ *    can be overridden.

+ *  - a timestamp, used to order the notifications

+ *  - expiration time -- if nonzero, specifies a time after which the

+ *    notification will no longer be valid.

+ *  - a callback name and a couple of status bits related to callbacks (see below)

+ *

+ * There is a management class called LLNotifications, which is an LLSingleton.

+ * The class maintains a collection of all of the notifications received

+ * or processed during this session, and also manages the persistence

+ * of those notifications that must be persisted.

+ *

+ * We also have Channels. A channel is a view on a collection of notifications;

+ * The collection is defined by a filter function that controls which

+ * notifications are in the channel, and its ordering is controlled by

+ * a comparator.

+ *

+ * There is a hierarchy of channels; notifications flow down from

+ * the management class (LLNotifications, which itself inherits from

+ * The channel base class) to the individual channels.

+ * Any change to notifications (add, delete, modify) is

+ * automatically propagated through the channel hierarchy.

+ *

+ * We provide methods for adding a new notification, for removing

+ * one, and for managing channels. Channels are relatively cheap to construct

+ * and maintain, so in general, human interfaces should use channels to

+ * select and manage their lists of notifications.

+ *

+ * We also maintain a collection of templates that are loaded from the

+ * XML file of template translations. The system supports substitution

+ * of named variables from the payload into the XML file.

+ *

+ * By default, only the "unknown message" template is built into the system.

+ * It is not an error to add a notification that's not found in the

+ * template system, but it is logged.

+ *

+ */

+

+#include <string>

+#include <list>

+#include <vector>

+#include <map>

+#include <set>

+#include <iomanip>

+#include <sstream>

+

+#include <boost/utility.hpp>

+#include <boost/type_traits.hpp>

+#include <boost/signals2.hpp>

+#include <boost/range.hpp>

+

+#include "llevents.h"

+#include "llfunctorregistry.h"

+#include "llinitparam.h"

+#include "llinstancetracker.h"

+#include "llmortician.h"

+#include "llnotificationptr.h"

+#include "llpointer.h"

+#include "llrefcount.h"

+#include "llsdparam.h"

+

+#include "llnotificationslistener.h"

+

+class LLAvatarName;

+typedef enum e_notification_priority

+{

+    NOTIFICATION_PRIORITY_UNSPECIFIED,

+    NOTIFICATION_PRIORITY_LOW,

+    NOTIFICATION_PRIORITY_NORMAL,

+    NOTIFICATION_PRIORITY_HIGH,

+    NOTIFICATION_PRIORITY_CRITICAL

+} ENotificationPriority;

+

+struct NotificationPriorityValues : public LLInitParam::TypeValuesHelper<ENotificationPriority, NotificationPriorityValues>

+{

+    static void declareValues();

+};

+

+class LLNotificationResponderInterface

+{

+public:

+    LLNotificationResponderInterface(){};

+    virtual ~LLNotificationResponderInterface(){};

+

+    virtual void handleRespond(const LLSD& notification, const LLSD& response) = 0;

+

+    virtual LLSD asLLSD() = 0;

+

+    virtual void fromLLSD(const LLSD& params) = 0;

+};

+

+typedef boost::function<void (const LLSD&, const LLSD&)> LLNotificationResponder;

+

+typedef std::shared_ptr<LLNotificationResponderInterface> LLNotificationResponderPtr;

+

+typedef LLFunctorRegistry<LLNotificationResponder> LLNotificationFunctorRegistry;

+typedef LLFunctorRegistration<LLNotificationResponder> LLNotificationFunctorRegistration;

+

+// context data that can be looked up via a notification's payload by the display logic

+// derive from this class to implement specific contexts

+class LLNotificationContext : public LLInstanceTracker<LLNotificationContext, LLUUID>

+{

+public:

+

+    LLNotificationContext() : LLInstanceTracker<LLNotificationContext, LLUUID>(LLUUID::generateNewID())

+    {

+    }

+

+    virtual ~LLNotificationContext() {}

+

+    LLSD asLLSD() const

+    {

+        return getKey();

+    }

+

+private:

+

+};

+

+// Contains notification form data, such as buttons and text fields along with

+// manipulator functions

+class LLNotificationForm

+{

+    LOG_CLASS(LLNotificationForm);

+

+public:

+    struct FormElementBase : public LLInitParam::Block<FormElementBase>

+    {

+        Optional<std::string>   name;

+        Optional<bool>          enabled;

+

+        FormElementBase();

+    };

+

+    struct FormIgnore : public LLInitParam::Block<FormIgnore, FormElementBase>

+    {

+        Optional<std::string>   text;

+        Optional<bool>          save_option;

+        Optional<std::string>   control;

+        Optional<bool>          invert_control;

+        Optional<bool>          session_only;

+        Optional<bool>          checkbox_only;

+

+        FormIgnore();

+    };

+

+    struct FormButton : public LLInitParam::Block<FormButton, FormElementBase>

+    {

+        Mandatory<S32>          index;

+        Mandatory<std::string>  text;

+        Optional<std::string>   ignore;

+        Optional<bool>          is_default;

+        Optional<S32>           width;

+

+        Mandatory<std::string>  type;

+

+        FormButton();

+    };

+

+    struct FormInput : public LLInitParam::Block<FormInput, FormElementBase>

+    {

+        Mandatory<std::string>  type;

+        Optional<S32>           width;

+        Optional<S32>           max_length_chars;

+        Optional<bool>          allow_emoji;

+        Optional<std::string>   text;

+

+        Optional<std::string>   value;

+        FormInput();

+    };

+

+    struct FormElement : public LLInitParam::ChoiceBlock<FormElement>

+    {

+        Alternative<FormButton> button;

+        Alternative<FormInput>  input;

+

+        FormElement();

+    };

+

+    struct FormElements : public LLInitParam::Block<FormElements>

+    {

+        Multiple<FormElement> elements;

+        FormElements();

+    };

+

+    struct Params : public LLInitParam::Block<Params>

+    {

+        Optional<std::string>   name;

+        Optional<FormIgnore>    ignore;

+        Optional<FormElements>  form_elements;

+

+        Params();

+    };

+

+    typedef enum e_ignore_type

+    {

+        IGNORE_CHECKBOX_ONLY = -1, // ignore won't be handled, will set value/checkbox only

+        IGNORE_NO = 0,

+        IGNORE_WITH_DEFAULT_RESPONSE,

+        IGNORE_WITH_DEFAULT_RESPONSE_SESSION_ONLY,

+        IGNORE_WITH_LAST_RESPONSE,

+        IGNORE_SHOW_AGAIN

+    } EIgnoreType;

+

+    LLNotificationForm();

+    LLNotificationForm(const LLNotificationForm&);

+    LLNotificationForm(const LLSD& sd);

+    LLNotificationForm(const std::string& name, const Params& p);

+

+    void fromLLSD(const LLSD& sd);

+    LLSD asLLSD() const;

+

+    S32 getNumElements() { return mFormData.size(); }

+    LLSD getElement(S32 index) { return mFormData.get(index); }

+    LLSD getElement(const std::string& element_name);

+    void getElements(LLSD& elements, S32 offset = 0);

+    bool hasElement(const std::string& element_name) const;

+    bool getElementEnabled(const std::string& element_name) const;

+    void setElementEnabled(const std::string& element_name, bool enabled);

+    void addElement(const std::string& type, const std::string& name, const LLSD& value = LLSD(), bool enabled = true);

+    void formatElements(const LLSD& substitutions);

+    // appends form elements from another form serialized as LLSD

+    void append(const LLSD& sub_form);

+    std::string getDefaultOption();

+    LLPointer<class LLControlVariable> getIgnoreSetting();

+    bool getIgnored();

+    void setIgnored(bool ignored);

+

+    EIgnoreType getIgnoreType() { return mIgnore; }

+    std::string getIgnoreMessage() { return mIgnoreMsg; }

+

+private:

+    LLSD                                mFormData;

+    EIgnoreType                         mIgnore;

+    std::string                         mIgnoreMsg;

+    LLPointer<class LLControlVariable>  mIgnoreSetting;

+    bool                                mInvertSetting;

+};

+

+typedef std::shared_ptr<LLNotificationForm> LLNotificationFormPtr;

+

+

+struct LLNotificationTemplate;

+

+// we want to keep a map of these by name, and it's best to manage them

+// with smart pointers

+typedef std::shared_ptr<LLNotificationTemplate> LLNotificationTemplatePtr;

+

+

+struct LLNotificationVisibilityRule;

+

+typedef std::shared_ptr<LLNotificationVisibilityRule> LLNotificationVisibilityRulePtr;

+

+/**

+ * @class LLNotification

+ * @brief The object that expresses the details of a notification

+ *

+ * We make this noncopyable because

+ * we want to manage these through LLNotificationPtr, and only

+ * ever create one instance of any given notification.

+ *

+ * The enable_shared_from_this flag ensures that if we construct

+ * a smart pointer from a notification, we'll always get the same

+ * shared pointer.

+ */

+class LLNotification  :

+    boost::noncopyable,

+    public std::enable_shared_from_this<LLNotification>

+{

+LOG_CLASS(LLNotification);

+friend class LLNotifications;

+

+public:

+

+    // parameter object used to instantiate a new notification

+    struct Params : public LLInitParam::Block<Params>

+    {

+        friend class LLNotification;

+

+        Mandatory<std::string>                  name;

+        Optional<LLUUID>                        id;

+        Optional<LLSD>                          substitutions,

+                                                form_elements,

+                                                payload;

+        Optional<ENotificationPriority, NotificationPriorityValues> priority;

+        Optional<LLDate>                        time_stamp,

+                                                expiry;

+        Optional<LLNotificationContext*>        context;

+        Optional<void*>                         responder;

+        Optional<bool>                          offer_from_agent;

+        Optional<bool>                          is_dnd;

+

+        struct Functor : public LLInitParam::ChoiceBlock<Functor>

+        {

+            Alternative<std::string>                                        name;

+            Alternative<LLNotificationFunctorRegistry::ResponseFunctor> function;

+            Alternative<LLNotificationResponderPtr>                     responder;

+            Alternative<LLSD>                                           responder_sd;

+

+            Functor()

+            :   name("responseFunctor"),

+                function("functor"),

+                responder("responder"),

+                responder_sd("responder_sd")

+            {}

+        };

+        Optional<Functor>                       functor;

+

+        Params()

+        :   name("name"),

+            id("id"),

+            priority("priority", NOTIFICATION_PRIORITY_UNSPECIFIED),

+            time_stamp("time"),

+            payload("payload"),

+            form_elements("form"),

+            substitutions("substitutions"),

+            expiry("expiry"),

+            offer_from_agent("offer_from_agent", false),

+            is_dnd("is_dnd", false)

+        {

+            time_stamp = LLDate::now();

+            responder = NULL;

+        }

+

+        Params(const std::string& _name)

+        :   name("name"),

+            priority("priority", NOTIFICATION_PRIORITY_UNSPECIFIED),

+            time_stamp("time"),

+            payload("payload"),

+            form_elements("form"),

+            substitutions("substitutions"),

+            expiry("expiry"),

+            offer_from_agent("offer_from_agent", false),

+            is_dnd("is_dnd", false)

+        {

+            functor.name = _name;

+            name = _name;

+            time_stamp = LLDate::now();

+            responder = NULL;

+        }

+    };

+

+    LLNotificationResponderPtr getResponderPtr() { return mResponder; }

+

+private:

+

+    const LLUUID mId;

+    LLSD mPayload;

+    LLSD mSubstitutions;

+    LLDate mTimestamp;

+    LLDate mExpiresAt;

+    bool mCancelled;

+    bool mRespondedTo;  // once the notification has been responded to, this becomes true

+    LLSD mResponse;

+    bool mIgnored;

+    ENotificationPriority mPriority;

+    LLNotificationFormPtr mForm;

+    void* mResponderObj; // TODO - refactor/remove this field

+    LLNotificationResponderPtr mResponder;

+    bool mOfferFromAgent;

+    bool mIsDND;

+

+    // a reference to the template

+    LLNotificationTemplatePtr mTemplatep;

+

+    /*

+     We want to be able to store and reload notifications so that they can survive

+     a shutdown/restart of the client. So we can't simply pass in callbacks;

+     we have to specify a callback mechanism that can be used by name rather than

+     by some arbitrary pointer -- and then people have to initialize callbacks

+     in some useful location. So we use LLNotificationFunctorRegistry to manage them.

+     */

+     std::string mResponseFunctorName;

+

+    /*

+     In cases where we want to specify an explict, non-persisted callback,

+     we store that in the callback registry under a dynamically generated

+     key, and store the key in the notification, so we can still look it up

+     using the same mechanism.

+     */

+    bool mTemporaryResponder;

+

+    // keep track of other notifications combined with COMBINE_WITH_NEW

+    std::vector<LLNotificationPtr> mCombinedNotifications;

+

+    void init(const std::string& template_name, const LLSD& form_elements);

+

+    void cancel();

+

+public:

+    LLNotification(const LLSDParamAdapter<Params>& p);

+

+    void setResponseFunctor(std::string const &responseFunctorName);

+

+    void setResponseFunctor(const LLNotificationFunctorRegistry::ResponseFunctor& cb);

+

+    void setResponseFunctor(const LLNotificationResponderPtr& responder);

+

+    typedef enum e_response_template_type

+    {

+        WITHOUT_DEFAULT_BUTTON,

+        WITH_DEFAULT_BUTTON

+    } EResponseTemplateType;

+

+    // return response LLSD filled in with default form contents and (optionally) the default button selected

+    LLSD getResponseTemplate(EResponseTemplateType type = WITHOUT_DEFAULT_BUTTON);

+

+    // returns index of first button with value==true

+    // usually this the button the user clicked on

+    // returns -1 if no button clicked (e.g. form has not been displayed)

+    static S32 getSelectedOption(const LLSD& notification, const LLSD& response);

+    // returns name of first button with value==true

+    static std::string getSelectedOptionName(const LLSD& notification);

+

+    // after someone responds to a notification (usually by clicking a button,

+    // but sometimes by filling out a little form and THEN clicking a button),

+    // the result of the response (the name and value of the button clicked,

+    // plus any other data) should be packaged up as LLSD, then passed as a

+    // parameter to the notification's respond() method here. This will look up

+    // and call the appropriate responder.

+    //

+    // response is notification serialized as LLSD:

+    // ["name"] = notification name

+    // ["form"] = LLSD tree that includes form description and any prefilled form data

+    // ["response"] = form data filled in by user

+    // (including, but not limited to which button they clicked on)

+    // ["payload"] = transaction specific data, such as ["source_id"] (originator of notification),

+    //              ["item_id"] (attached inventory item), etc.

+    // ["substitutions"] = string substitutions used to generate notification message

+    // from the template

+    // ["time"] = time at which notification was generated;

+    // ["expiry"] = time at which notification expires;

+    // ["responseFunctor"] = name of registered functor that handles responses to notification;

+    LLSD asLLSD(bool excludeTemplateElements = false);

+

+    const LLNotificationFormPtr getForm();

+    void updateForm(const LLNotificationFormPtr& form);

+

+    void repost();

+

+    void respond(const LLSD& sd);

+    void respondWithDefault();

+

+    void* getResponder() { return mResponderObj; }

+

+    void setResponder(void* responder) { mResponderObj = responder; }

+

+    void setIgnored(bool ignore);

+

+    bool isCancelled() const

+    {

+        return mCancelled;

+    }

+

+    bool isRespondedTo() const

+    {

+        return mRespondedTo;

+    }

+

+    bool isActive() const

+    {

+        return !isRespondedTo()

+            && !isCancelled()

+            && !isExpired();

+    }

+

+    const LLSD& getResponse() { return mResponse; }

+

+    bool isIgnored() const

+    {

+        return mIgnored;

+    }

+

+    const std::string& getName() const;

+

+    const std::string& getIcon() const;

+

+    bool isPersistent() const;

+

+    const LLUUID& id() const

+    {

+        return mId;

+    }

+

+    const LLSD& getPayload() const

+    {

+        return mPayload;

+    }

+

+    const LLSD& getSubstitutions() const

+    {

+        return mSubstitutions;

+    }

+

+    const LLDate& getDate() const

+    {

+        return mTimestamp;

+    }

+

+    bool getOfferFromAgent() const

+    {

+        return mOfferFromAgent;

+    }

+

+    bool isDND() const

+    {

+        return mIsDND;

+    }

+

+    void setDND(const bool flag)

+    {

+        mIsDND = flag;

+    }

+

+    std::string getType() const;

+    std::string getMessage() const;

+    std::string getFooter() const;

+    std::string getLabel() const;

+    std::string getURL() const;

+    S32 getURLOption() const;

+    S32 getURLOpenExternally() const; //for url responce option

+    bool getForceUrlsExternal() const;

+    bool canLogToChat() const;

+    bool canLogToIM() const;

+    bool canShowToast() const;

+    bool canFadeToast() const;

+    bool hasFormElements() const;

+    void playSound();

+

+    typedef enum e_combine_behavior

+    {

+        REPLACE_WITH_NEW,

+        COMBINE_WITH_NEW,

+        KEEP_OLD,

+        CANCEL_OLD

+

+    } ECombineBehavior;

+

+    ECombineBehavior getCombineBehavior() const;

+

+    const LLDate getExpiration() const

+    {

+        return mExpiresAt;

+    }

+

+    ENotificationPriority getPriority() const

+    {

+        return mPriority;

+    }

+

+    const LLUUID getID() const

+    {

+        return mId;

+    }

+

+    // comparing two notifications normally means comparing them by UUID (so we can look them

+    // up quickly this way)

+    bool operator<(const LLNotification& rhs) const

+    {

+        return mId < rhs.mId;

+    }

+

+    bool operator==(const LLNotification& rhs) const

+    {

+        return mId == rhs.mId;

+    }

+

+    bool operator!=(const LLNotification& rhs) const

+    {

+        return !operator==(rhs);

+    }

+

+    bool isSameObjectAs(const LLNotification* rhs) const

+    {

+        return this == rhs;

+    }

+

+    // this object has been updated, so tell all our clients

+    void update();

+

+    void updateFrom(LLNotificationPtr other);

+

+    // A fuzzy equals comparator.

+    // true only if both notifications have the same template and

+    //     1) flagged as unique (there can be only one of these) OR

+    //     2) all required payload fields of each also exist in the other.

+    bool isEquivalentTo(LLNotificationPtr that) const;

+

+    // if the current time is greater than the expiration, the notification is expired

+    bool isExpired() const

+    {

+        if (mExpiresAt.secondsSinceEpoch() == 0)

+        {

+            return false;

+        }

+

+        LLDate rightnow = LLDate::now();

+        return rightnow > mExpiresAt;

+    }

+

+    std::string summarize() const;

+

+    bool hasUniquenessConstraints() const;

+

+    bool matchesTag(const std::string& tag);

+

+    virtual ~LLNotification() {}

+};

+

+std::ostream& operator<<(std::ostream& s, const LLNotification& notification);

+

+namespace LLNotificationFilters

+{

+    // a sample filter

+    bool includeEverything(LLNotificationPtr p);

+

+    typedef enum e_comparison

+    {

+        EQUAL,

+        LESS,

+        GREATER,

+        LESS_EQUAL,

+        GREATER_EQUAL

+    } EComparison;

+

+    // generic filter functor that takes method or member variable reference

+    template<typename T>

+    struct filterBy

+    {

+        typedef boost::function<T (LLNotificationPtr)>  field_t;

+        typedef typename boost::remove_reference<T>::type       value_t;

+

+        filterBy(field_t field, value_t value, EComparison comparison = EQUAL)

+            :   mField(field),

+                mFilterValue(value),

+                mComparison(comparison)

+        {

+        }

+

+        bool operator()(LLNotificationPtr p)

+        {

+            switch(mComparison)

+            {

+            case EQUAL:

+                return mField(p) == mFilterValue;

+            case LESS:

+                return mField(p) < mFilterValue;

+            case GREATER:

+                return mField(p) > mFilterValue;

+            case LESS_EQUAL:

+                return mField(p) <= mFilterValue;

+            case GREATER_EQUAL:

+                return mField(p) >= mFilterValue;

+            default:

+                return false;

+            }

+        }

+

+        field_t mField;

+        value_t mFilterValue;

+        EComparison mComparison;

+    };

+};

+

+namespace LLNotificationComparators

+{

+    struct orderByUUID

+    {

+        bool operator()(LLNotificationPtr lhs, LLNotificationPtr rhs) const

+        {

+            return lhs->id() < rhs->id();

+        }

+    };

+};

+

+typedef boost::function<bool (LLNotificationPtr)> LLNotificationFilter;

+typedef std::set<LLNotificationPtr, LLNotificationComparators::orderByUUID> LLNotificationSet;

+typedef std::multimap<std::string, LLNotificationPtr> LLNotificationMap;

+

+// ========================================================

+// Abstract base class (interface) for a channel; also used for the master container.

+// This lets us arrange channels into a call hierarchy.

+

+// We maintain a hierarchy of notification channels; events are always started at the top

+// and propagated through the hierarchy only if they pass a filter.

+// Any channel can be created with a parent. A null parent (empty string) means it's

+// tied to the root of the tree (the LLNotifications class itself).

+// The default hierarchy looks like this:

+//

+// LLNotifications --+-- Expiration --+-- Mute --+-- Ignore --+-- Visible --+-- History

+//                                                                          +-- Alerts

+//                                                                          +-- Notifications

+//

+// In general, new channels that want to only see notifications that pass through

+// all of the built-in tests should attach to the "Visible" channel

+//

+class LLNotificationChannelBase :

+    public LLEventTrackable,

+    public LLRefCount

+{

+    LOG_CLASS(LLNotificationChannelBase);

+public:

+    LLNotificationChannelBase(LLNotificationFilter filter)

+    : mFilter(filter)

+    , mItems()

+    , mItemsMutex()

+    {}

+

+    virtual ~LLNotificationChannelBase()

+    {

+        // explicit cleanup for easier issue detection

+        mChanged.disconnect_all_slots();

+        mPassedFilter.disconnect_all_slots();

+        mFailedFilter.disconnect_all_slots();

+        LLMutexLock lock(&mItemsMutex);

+        mItems.clear();

+    }

+    // you can also connect to a Channel, so you can be notified of

+    // changes to this channel

+    LLBoundListener connectChanged(const LLEventListener& slot)

+    {

+        // Call this->connectChangedImpl() to actually connect it.

+        return connectChangedImpl(slot);

+    }

+    LLBoundListener connectAtFrontChanged(const LLEventListener& slot)

+    {

+        return connectAtFrontChangedImpl(slot);

+    }

+    LLBoundListener connectPassedFilter(const LLEventListener& slot)

+    {

+        // see comments in connectChanged()

+        return connectPassedFilterImpl(slot);

+    }

+    LLBoundListener connectFailedFilter(const LLEventListener& slot)

+    {

+        // see comments in connectChanged()

+        return connectFailedFilterImpl(slot);

+    }

+

+    // use this when items change or to add a new one

+    bool updateItem(const LLSD& payload);

+    const LLNotificationFilter& getFilter() { return mFilter; }

+

+protected:

+    LLBoundListener connectChangedImpl(const LLEventListener& slot);

+    LLBoundListener connectAtFrontChangedImpl(const LLEventListener& slot);

+    LLBoundListener connectPassedFilterImpl(const LLEventListener& slot);

+    LLBoundListener connectFailedFilterImpl(const LLEventListener& slot);

+

+    LLNotificationSet mItems;

+    LLStandardSignal mChanged;

+    LLStandardSignal mPassedFilter;

+    LLStandardSignal mFailedFilter;

+    LLMutex mItemsMutex;

+

+    // these are action methods that subclasses can override to take action

+    // on specific types of changes; the management of the mItems list is

+    // still handled by the generic handler.

+    virtual void onLoad(LLNotificationPtr p) {}

+    virtual void onAdd(LLNotificationPtr p) {}

+    virtual void onDelete(LLNotificationPtr p) {}

+    virtual void onChange(LLNotificationPtr p) {}

+

+    virtual void onFilterPass(LLNotificationPtr p) {}

+    virtual void onFilterFail(LLNotificationPtr p) {}

+

+    bool updateItem(const LLSD& payload, LLNotificationPtr pNotification);

+    LLNotificationFilter mFilter;

+};

+

+// The type of the pointers that we're going to manage in the NotificationQueue system

+// Because LLNotifications is a singleton, we don't actually expect to ever

+// destroy it, but if it becomes necessary to do so, the shared_ptr model

+// will ensure that we don't leak resources.

+class LLNotificationChannel;

+typedef boost::intrusive_ptr<LLNotificationChannel> LLNotificationChannelPtr;

+

+// manages a list of notifications

+// Note that if this is ever copied around, we might find ourselves with multiple copies

+// of a queue with notifications being added to different nonequivalent copies. So we

+// make it inherit from boost::noncopyable, and then create a map of LLPointer to manage it.

+//

+class LLNotificationChannel :

+    boost::noncopyable,

+    public LLNotificationChannelBase,

+    public LLInstanceTracker<LLNotificationChannel, std::string>

+{

+    LOG_CLASS(LLNotificationChannel);

+

+public:

+    // Notification Channels have a filter, which determines which notifications

+    // will be added to this channel.

+    // Channel filters cannot change.

+    struct Params : public LLInitParam::Block<Params>

+    {

+        Mandatory<std::string>              name;

+        Optional<LLNotificationFilter>      filter;

+        Multiple<std::string>               sources;

+    };

+

+    LLNotificationChannel(const Params& p = Params());

+    LLNotificationChannel(const std::string& name, const std::string& parent, LLNotificationFilter filter);

+

+    virtual ~LLNotificationChannel();

+    typedef LLNotificationSet::iterator Iterator;

+

+    std::string getName() const { return mName; }

+    typedef std::vector<std::string>::const_iterator parents_iter;

+    boost::iterator_range<parents_iter> getParents() const

+    {

+        return boost::iterator_range<parents_iter>(mParents);

+    }

+

+    bool isEmpty() const;

+    S32 size() const;

+    size_t size();

+

+    typedef boost::function<void(LLNotificationPtr)> NotificationProcess;

+    void forEachNotification(NotificationProcess process);

+

+    std::string summarize();

+

+protected:

+    void connectToChannel(const std::string& channel_name);

+

+private:

+    std::string mName;

+    std::vector<std::string> mParents;

+    std::vector<LLBoundListener> mListeners;

+};

+

+// An interface class to provide a clean linker seam to the LLNotifications class.

+// Extend this interface as needed for your use of LLNotifications.

+class LLNotificationsInterface

+{

+public:

+    virtual LLNotificationPtr add(const std::string& name,

+                        const LLSD& substitutions,

+                        const LLSD& payload,

+                        LLNotificationFunctorRegistry::ResponseFunctor functor) = 0;

+};

+

+class LLNotifications :

+    public LLNotificationsInterface,

+    public LLSingleton<LLNotifications>,

+    public LLNotificationChannelBase

+{

+    LLSINGLETON(LLNotifications);

+    LOG_CLASS(LLNotifications);

+    virtual ~LLNotifications() {}

+

+public:

+

+    // Needed to clear up RefCounted things prior to actual destruction

+    // as the singleton nature of the class makes them do "bad things"

+    // on at least Mac, if not all 3 platforms

+    //

+    void clear();

+

+    // load all notification descriptions from file

+    // calling more than once will overwrite existing templates

+    // but never delete a template

+    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);

+

+    // *NOTE: To add simple notifications, #include "llnotificationsutil.h"

+    // and use LLNotificationsUtil::add("MyNote") or add("MyNote", args)

+    LLNotificationPtr add(const std::string& name,

+                        const LLSD& substitutions,

+                        const LLSD& payload);

+    LLNotificationPtr add(const std::string& name,

+                        const LLSD& substitutions,

+                        const LLSD& payload,

+                        const std::string& functor_name);

+    /* virtual */ LLNotificationPtr add(const std::string& name,

+                        const LLSD& substitutions,

+                        const LLSD& payload,

+                        LLNotificationFunctorRegistry::ResponseFunctor functor) override;

+    LLNotificationPtr add(const LLNotification::Params& p);

+

+    void add(const LLNotificationPtr pNotif);

+    void load(const LLNotificationPtr pNotif);

+    void cancel(LLNotificationPtr pNotif);

+    void cancelByName(const std::string& name);

+    void cancelByOwner(const LLUUID ownerId);

+    void update(const LLNotificationPtr pNotif);

+

+    LLNotificationPtr find(LLUUID uuid);

+

+    // This is all stuff for managing the templates

+    // take your template out

+    LLNotificationTemplatePtr getTemplate(const std::string& name);

+

+    // get the whole collection

+    typedef std::vector<std::string> TemplateNames;

+    TemplateNames getTemplateNames() const;  // returns a list of notification names

+

+    typedef std::map<std::string, LLNotificationTemplatePtr> TemplateMap;

+

+    TemplateMap::const_iterator templatesBegin() { return mTemplates.begin(); }

+    TemplateMap::const_iterator templatesEnd() { return mTemplates.end(); }

+

+    // test for existence

+    bool templateExists(const std::string& name);

+

+    typedef std::list<LLNotificationVisibilityRulePtr> VisibilityRuleList;

+

+    void forceResponse(const LLNotification::Params& params, S32 option);

+

+    void createDefaultChannels();

+

+    LLNotificationChannelPtr getChannel(const std::string& channelName);

+

+    std::string getGlobalString(const std::string& key) const;

+

+    void setIgnoreAllNotifications(bool ignore);

+    bool getIgnoreAllNotifications();

+

+    void setIgnored(const std::string& name, bool ignored);

+    bool getIgnored(const std::string& name);

+

+    bool isVisibleByRules(LLNotificationPtr pNotification);

+

+private:

+    /*virtual*/ void initSingleton() override;

+    /*virtual*/ void cleanupSingleton() override;

+

+    void loadPersistentNotifications();

+

+    bool expirationFilter(LLNotificationPtr pNotification);

+    bool expirationHandler(const LLSD& payload);

+    bool uniqueFilter(LLNotificationPtr pNotification);

+    bool uniqueHandler(const LLSD& payload);

+    bool failedUniquenessTest(const LLSD& payload);

+    LLNotificationChannelPtr pHistoryChannel;

+    LLNotificationChannelPtr pExpirationChannel;

+

+    TemplateMap mTemplates;

+

+    VisibilityRuleList mVisibilityRules;

+

+    std::string mFileName;

+

+    LLNotificationMap mUniqueNotifications;

+

+    typedef std::map<std::string, std::string> GlobalStringMap;

+    GlobalStringMap mGlobalStrings;

+

+    bool mIgnoreAllNotifications;

+

+    std::unique_ptr<LLNotificationsListener> mListener;

+

+    std::vector<LLNotificationChannelPtr> mDefaultChannels;

+};

+

+/**

+ * Abstract class for postponed notifications.

+ * Provides possibility to add notification after specified by id avatar or group will be

+ * received from cache name. The object of this type automatically well be deleted

+ * by cleanup method after respond will be received from cache name.

+ *

+ * To add custom postponed notification to the notification system client should:

+ *  1 create class derived from LLPostponedNotification;

+ *  2 call LLPostponedNotification::add method;

+ */

+class LLPostponedNotification : public LLMortician

+{

+public:

+    /**

+     * Performs hooking cache name callback which will add notification to notifications system.

+     * Type of added notification should be specified by template parameter T

+     * and non-private derived from LLPostponedNotification class,

+     * otherwise compilation error will occur.

+     */

+    template<class T>

+    static void add(const LLNotification::Params& params,

+            const LLUUID& id, bool is_group)

+    {

+        // upcast T to the base type to restrict T derivation from LLPostponedNotification

+        LLPostponedNotification* thiz = new T();

+        thiz->mParams = params;

+

+        // Avoid header file dependency on llcachename.h

+        thiz->lookupName(id, is_group);

+    }

+

+private:

+    void lookupName(const LLUUID& id, bool is_group);

+    // only used for groups

+    void onGroupNameCache(const LLUUID& id, const std::string& full_name, bool is_group);

+    // only used for avatars

+    void fetchAvatarName(const LLUUID& id);

+    void onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name);

+    // used for both group and avatar names

+    void finalizeName(const std::string& name);

+

+    void cleanup()

+    {

+        die();

+    }

+

+protected:

+    LLPostponedNotification()

+        : mParams(),

+        mName(),

+        mAvatarNameCacheConnection()

+    {}

+

+    virtual ~LLPostponedNotification()

+    {

+        if (mAvatarNameCacheConnection.connected())

+        {

+            mAvatarNameCacheConnection.disconnect();

+        }

+    }

+

+    /**

+     * Abstract method provides possibility to modify notification parameters and

+     * will be called after cache name retrieve information about avatar or group

+     * and before notification will be added to the notification system.

+     */

+    virtual void modifyNotificationParams() = 0;

+

+    LLNotification::Params mParams;

+    std::string mName;

+    boost::signals2::connection mAvatarNameCacheConnection;

+};

+

+// Stores only persistent notifications.

+// Class users can use connectChanged() to process persistent notifications

+// (see LLPersistentNotificationStorage for example).

+class LLPersistentNotificationChannel : public LLNotificationChannel

+{

+    LOG_CLASS(LLPersistentNotificationChannel);

+public:

+    LLPersistentNotificationChannel()

+        :   LLNotificationChannel("Persistent", "Visible", &notificationFilter)

+    {}

+

+    virtual ~LLPersistentNotificationChannel()

+    {

+        mHistory.clear();

+    }

+

+    typedef std::vector<LLNotificationPtr> history_list_t;

+    history_list_t::iterator beginHistory() { sortHistory(); return mHistory.begin(); }

+    history_list_t::iterator endHistory() { return mHistory.end(); }

+

+private:

+    struct sortByTime

+    {

+        S32 operator ()(const LLNotificationPtr& a, const LLNotificationPtr& b)

+        {

+            return a->getDate() < b->getDate();

+        }

+    };

+

+    void sortHistory()

+    {

+        std::sort(mHistory.begin(), mHistory.end(), sortByTime());

+    }

+

+    // The channel gets all persistent notifications except those that have been canceled

+    static bool notificationFilter(LLNotificationPtr pNotification)

+    {

+        bool handle_notification = false;

+

+        handle_notification = pNotification->isPersistent()

+            && !pNotification->isCancelled();

+

+        return handle_notification;

+    }

+

+    void onAdd(LLNotificationPtr p)

+    {

+        mHistory.push_back(p);

+    }

+

+    void onLoad(LLNotificationPtr p)

+    {

+        mHistory.push_back(p);

+    }

+

+    std::vector<LLNotificationPtr> mHistory;

+};

+

+#endif//LL_LLNOTIFICATIONS_H

+