开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llnotifications.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：43k
源码类别：

游戏引擎

开发平台：

C++ Builder

llnotifications.cpp：源码内容
  1. /**
  2. * @file llnotifications.cpp
  3. * @brief Non-UI queue manager for keeping a prioritized list of notifications
  4. *
  5. * $LicenseInfo:firstyear=2008&license=viewergpl$
  6. * 
  7. * Copyright (c) 2008-2010, Linden Research, Inc.
  8. * 
  9. * Second Life Viewer Source Code
  10. * The source code in this file ("Source Code") is provided by Linden Lab
  11. * to you under the terms of the GNU General Public License, version 2.0
  12. * ("GPL"), unless you have obtained a separate licensing agreement
  13. * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14. * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15. * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16. * 
  17. * There are special exceptions to the terms and conditions of the GPL as
  18. * it is applied to this Source Code. View the full text of the exception
  19. * in the file doc/FLOSS-exception.txt in this software distribution, or
  20. * online at
  21. * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22. * 
  23. * By copying, modifying or distributing this software, you acknowledge
  24. * that you have read and understood your obligations described above,
  25. * and agree to abide by those obligations.
  26. * 
  27. * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28. * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29. * COMPLETENESS OR PERFORMANCE.
  30. * $/LicenseInfo$
  31. */
  33. #include "linden_common.h"
  35. #include "llnotifications.h"
  37. #include "llxmlnode.h"
  38. #include "lluictrl.h"
  39. #include "lluictrlfactory.h"
  40. #include "lldir.h"
  41. #include "llsdserialize.h"
  42. #include "lltrans.h"
  43. #include "llnotificationslistener.h"
  45. #include <algorithm>
  46. #include <boost/regex.hpp>
  49. const std::string NOTIFICATION_PERSIST_VERSION = "0.93";
  51. // local channel for notification history
  52. class LLNotificationHistoryChannel : public LLNotificationChannel
  53. {
  54. LOG_CLASS(LLNotificationHistoryChannel);
  55. public:
  56. LLNotificationHistoryChannel(const std::string& filename) : 
  57. LLNotificationChannel("History", "Visible", &historyFilter, LLNotificationComparators::orderByUUID()),
  58. mFileName(filename)
  59. {
  60. connectChanged(boost::bind(&LLNotificationHistoryChannel::historyHandler, this, _1));
  61. loadPersistentNotifications();
  62. }
  64. private:
  65. bool historyHandler(const LLSD& payload)
  66. {
  67. // we ignore "load" messages, but rewrite the persistence file on any other
  68. std::string sigtype = payload["sigtype"];
  69. if (sigtype != "load")
  70. {
  71. savePersistentNotifications();
  72. }
  73. return false;
  74. }
  76. // The history channel gets all notifications except those that have been cancelled
  77. static bool historyFilter(LLNotificationPtr pNotification)
  78. {
  79. return !pNotification->isCancelled();
  80. }
  82. void savePersistentNotifications()
  83. {
  84. /* NOTE: As of 2009-11-09 the reload of notifications on startup does not
  85. work, and has not worked for months.  Skip saving notifications until the
  86. read can be fixed, because this hits the disk once per notification and
  87. causes log spam.  James
  89. llinfos << "Saving open notifications to " << mFileName << llendl;
  91. llofstream notify_file(mFileName.c_str());
  92. if (!notify_file.is_open()) 
  93. {
  94. llwarns << "Failed to open " << mFileName << llendl;
  95. return;
  96. }
  98. LLSD output;
  99. output["version"] = NOTIFICATION_PERSIST_VERSION;
  100. LLSD& data = output["data"];
  102. for (LLNotificationSet::iterator it = mItems.begin(); it != mItems.end(); ++it)
  103. {
  104. if (!LLNotifications::instance().templateExists((*it)->getName())) continue;
  106. // only store notifications flagged as persisting
  107. LLNotificationTemplatePtr templatep = LLNotifications::instance().getTemplate((*it)->getName());
  108. if (!templatep->mPersist) continue;
  110. data.append((*it)->asLLSD());
  111. }
  113. LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
  114. formatter->format(output, notify_file, LLSDFormatter::OPTIONS_PRETTY);
  115. */
  116. }
  118. void loadPersistentNotifications()
  119. {
  120. llinfos << "Loading open notifications from " << mFileName << llendl;
  122. llifstream notify_file(mFileName.c_str());
  123. if (!notify_file.is_open()) 
  124. {
  125. llwarns << "Failed to open " << mFileName << llendl;
  126. return;
  127. }
  129. LLSD input;
  130. LLPointer<LLSDParser> parser = new LLSDXMLParser();
  131. if (parser->parse(notify_file, input, LLSDSerialize::SIZE_UNLIMITED) < 0)
  132. {
  133. llwarns << "Failed to parse open notifications" << llendl;
  134. return;
  135. }
  137. if (input.isUndefined()) return;
  138. std::string version = input["version"];
  139. if (version != NOTIFICATION_PERSIST_VERSION)
  140. {
  141. llwarns << "Bad open notifications version: " << version << llendl;
  142. return;
  143. }
  144. LLSD& data = input["data"];
  145. if (data.isUndefined()) return;
  147. LLNotifications& instance = LLNotifications::instance();
  148. for (LLSD::array_const_iterator notification_it = data.beginArray();
  149. notification_it != data.endArray();
  150. ++notification_it)
  151. {
  152. instance.add(LLNotificationPtr(new LLNotification(*notification_it)));
  153. }
  154. }
  156. //virtual
  157. void onDelete(LLNotificationPtr pNotification)
  158. {
  159. // we want to keep deleted notifications in our log
  160. mItems.insert(pNotification);
  162. return;
  163. }
  165. private:
  166. std::string mFileName;
  167. };
  169. bool filterIgnoredNotifications(LLNotificationPtr notification)
  170. {
  171. // filter everything if we are to ignore ALL
  172. if(LLNotifications::instance().getIgnoreAllNotifications())
  173. {
  174. return false;
  175. }
  177. LLNotificationFormPtr form = notification->getForm();
  178. // Check to see if the user wants to ignore this alert
  179. if (form->getIgnoreType() != LLNotificationForm::IGNORE_NO)
  180. {
  181. return LLUI::sSettingGroups["ignores"]->getBOOL(notification->getName());
  182. }
  184. return true;
  185. }
  187. bool handleIgnoredNotification(const LLSD& payload)
  188. {
  189. if (payload["sigtype"].asString() == "add")
  190. {
  191. LLNotificationPtr pNotif = LLNotifications::instance().find(payload["id"].asUUID());
  192. if (!pNotif) return false;
  194. LLNotificationFormPtr form = pNotif->getForm();
  195. LLSD response;
  196. switch(form->getIgnoreType())
  197. {
  198. case LLNotificationForm::IGNORE_WITH_DEFAULT_RESPONSE:
  199. response = pNotif->getResponseTemplate(LLNotification::WITH_DEFAULT_BUTTON);
  200. break;
  201. case LLNotificationForm::IGNORE_WITH_LAST_RESPONSE:
  202. response = LLUI::sSettingGroups["ignores"]->getLLSD("Default" + pNotif->getName());
  203. break;
  204. case LLNotificationForm::IGNORE_SHOW_AGAIN:
  205. break;
  206. default:
  207. return false;
  208. }
  209. pNotif->setIgnored(true);
  210. pNotif->respond(response);
  211. return true;  // don't process this item any further
  212. }
  213. return false;
  214. }
  216. namespace LLNotificationFilters
  217. {
  218. // a sample filter
  219. bool includeEverything(LLNotificationPtr p)
  220. {
  221. return true;
  222. }
  223. };
  225. LLNotificationForm::LLNotificationForm()
  226. : mFormData(LLSD::emptyArray()),
  227. mIgnore(IGNORE_NO)
  228. {
  229. }
  232. LLNotificationForm::LLNotificationForm(const std::string& name, const LLXMLNodePtr xml_node) 
  233. : mFormData(LLSD::emptyArray()),
  234. mIgnore(IGNORE_NO)
  235. {
  236. if (!xml_node->hasName("form"))
  237. {
  238. llwarns << "Bad xml node for form: " << xml_node->getName() << llendl;
  239. }
  240. LLXMLNodePtr child = xml_node->getFirstChild();
  241. while(child)
  242. {
  243. child = LLNotifications::instance().checkForXMLTemplate(child);
  245. LLSD item_entry;
  246. std::string element_name = child->getName()->mString;
  248. if (element_name == "ignore" )
  249. {
  250. bool save_option = false;
  251. child->getAttribute_bool("save_option", save_option);
  252. if (!save_option)
  253. {
  254. mIgnore = IGNORE_WITH_DEFAULT_RESPONSE;
  255. }
  256. else
  257. {
  258. // remember last option chosen by user and automatically respond with that in the future
  259. mIgnore = IGNORE_WITH_LAST_RESPONSE;
  260. LLUI::sSettingGroups["ignores"]->declareLLSD(std::string("Default") + name, "", std::string("Default response for notification " + name));
  261. }
  262. child->getAttributeString("text", mIgnoreMsg);
  263. BOOL show_notification = TRUE;
  264. LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Ignore notification with this name", TRUE);
  265. }
  266. else
  267. {
  268. // flatten xml form entry into single LLSD map with type==name
  269. item_entry["type"] = element_name;
  270. const LLXMLAttribList::iterator attrib_end = child->mAttributes.end();
  271. for(LLXMLAttribList::iterator attrib_it = child->mAttributes.begin();
  272. attrib_it != attrib_end;
  273. ++attrib_it)
  274. {
  275. item_entry[std::string(attrib_it->second->getName()->mString)] = attrib_it->second->getValue();
  276. }
  277. item_entry["value"] = child->getTextContents();
  278. mFormData.append(item_entry);
  279. }
  281. child = child->getNextSibling();
  282. }
  283. }
  285. LLNotificationForm::LLNotificationForm(const LLSD& sd)
  286. : mIgnore(IGNORE_NO)
  287. {
  288. if (sd.isArray())
  289. {
  290. mFormData = sd;
  291. }
  292. else
  293. {
  294. llwarns << "Invalid form data " << sd << llendl;
  295. mFormData = LLSD::emptyArray();
  296. }
  297. }
  299. LLSD LLNotificationForm::asLLSD() const
  300. { 
  301. return mFormData; 
  302. }
  304. LLSD LLNotificationForm::getElement(const std::string& element_name)
  305. {
  306. for (LLSD::array_const_iterator it = mFormData.beginArray();
  307. it != mFormData.endArray();
  308. ++it)
  309. {
  310. if ((*it)["name"].asString() == element_name) return (*it);
  311. }
  312. return LLSD();
  313. }
  316. bool LLNotificationForm::hasElement(const std::string& element_name)
  317. {
  318. for (LLSD::array_const_iterator it = mFormData.beginArray();
  319. it != mFormData.endArray();
  320. ++it)
  321. {
  322. if ((*it)["name"].asString() == element_name) return true;
  323. }
  324. return false;
  325. }
  327. void LLNotificationForm::addElement(const std::string& type, const std::string& name, const LLSD& value)
  328. {
  329. LLSD element;
  330. element["type"] = type;
  331. element["name"] = name;
  332. element["text"] = name;
  333. element["value"] = value;
  334. element["index"] = mFormData.size();
  335. mFormData.append(element);
  336. }
  338. void LLNotificationForm::append(const LLSD& sub_form)
  339. {
  340. if (sub_form.isArray())
  341. {
  342. for (LLSD::array_const_iterator it = sub_form.beginArray();
  343. it != sub_form.endArray();
  344. ++it)
  345. {
  346. mFormData.append(*it);
  347. }
  348. }
  349. }
  351. void LLNotificationForm::formatElements(const LLSD& substitutions)
  352. {
  353. for (LLSD::array_iterator it = mFormData.beginArray();
  354. it != mFormData.endArray();
  355. ++it)
  356. {
  357. // format "text" component of each form element
  358. if ((*it).has("text"))
  359. {
  360. std::string text = (*it)["text"].asString();
  361. LLStringUtil::format(text, substitutions);
  362. (*it)["text"] = text;
  363. }
  364. if ((*it)["type"].asString() == "text" && (*it).has("value"))
  365. {
  366. std::string value = (*it)["value"].asString();
  367. LLStringUtil::format(value, substitutions);
  368. (*it)["value"] = value;
  369. }
  370. }
  371. }
  373. std::string LLNotificationForm::getDefaultOption()
  374. {
  375. for (LLSD::array_const_iterator it = mFormData.beginArray();
  376. it != mFormData.endArray();
  377. ++it)
  378. {
  379. if ((*it)["default"]) return (*it)["name"].asString();
  380. }
  381. return "";
  382. }
  384. LLNotificationTemplate::LLNotificationTemplate() :
  385. mExpireSeconds(0),
  386. mExpireOption(-1),
  387. mURLOption(-1),
  388. mURLOpenExternally(-1),
  389. mPersist(false),
  390. mUnique(false),
  391. mPriority(NOTIFICATION_PRIORITY_NORMAL)
  392. {
  393. mForm = LLNotificationFormPtr(new LLNotificationForm()); 
  394. }
  396. LLNotification::LLNotification(const LLNotification::Params& p) : 
  397. mTimestamp(p.time_stamp), 
  398. mSubstitutions(p.substitutions),
  399. mPayload(p.payload),
  400. mExpiresAt(0),
  401. mTemporaryResponder(false),
  402. mRespondedTo(false),
  403. mPriority(p.priority),
  404. mCancelled(false),
  405. mIgnored(false)
  406. {
  407. if (p.functor.name.isChosen())
  408. {
  409. mResponseFunctorName = p.functor.name;
  410. }
  411. else if (p.functor.function.isChosen())
  412. {
  413. mResponseFunctorName = LLUUID::generateNewID().asString();
  414. LLNotificationFunctorRegistry::instance().registerFunctor(mResponseFunctorName, p.functor.function());
  416. mTemporaryResponder = true;
  417. }
  419. mId.generate();
  420. init(p.name, p.form_elements);
  421. }
  424. LLNotification::LLNotification(const LLSD& sd) :
  425. mTemporaryResponder(false),
  426. mRespondedTo(false),
  427. mCancelled(false),
  428. mIgnored(false)
  429. { 
  430. mId.generate();
  431. mSubstitutions = sd["substitutions"];
  432. mPayload = sd["payload"]; 
  433. mTimestamp = sd["time"]; 
  434. mExpiresAt = sd["expiry"];
  435. mPriority = (ENotificationPriority)sd["priority"].asInteger();
  436. mResponseFunctorName = sd["responseFunctor"].asString();
  437. std::string templatename = sd["name"].asString();
  438. init(templatename, LLSD());
  439. // replace form with serialized version
  440. mForm = LLNotificationFormPtr(new LLNotificationForm(sd["form"]));
  441. }
  444. LLSD LLNotification::asLLSD()
  445. {
  446. LLSD output;
  447. output["name"] = mTemplatep->mName;
  448. output["form"] = getForm()->asLLSD();
  449. output["substitutions"] = mSubstitutions;
  450. output["payload"] = mPayload;
  451. output["time"] = mTimestamp;
  452. output["expiry"] = mExpiresAt;
  453. output["priority"] = (S32)mPriority;
  454. output["responseFunctor"] = mResponseFunctorName;
  455. return output;
  456. }
  458. void LLNotification::update()
  459. {
  460. LLNotifications::instance().update(shared_from_this());
  461. }
  463. void LLNotification::updateFrom(LLNotificationPtr other)
  464. {
  465. // can only update from the same notification type
  466. if (mTemplatep != other->mTemplatep) return;
  468. // NOTE: do NOT change the ID, since it is the key to
  469. // this given instance, just update all the metadata
  470. //mId = other->mId;
  472. mPayload = other->mPayload;
  473. mSubstitutions = other->mSubstitutions;
  474. mTimestamp = other->mTimestamp;
  475. mExpiresAt = other->mExpiresAt;
  476. mCancelled = other->mCancelled;
  477. mIgnored = other->mIgnored;
  478. mPriority = other->mPriority;
  479. mForm = other->mForm;
  480. mResponseFunctorName = other->mResponseFunctorName;
  481. mRespondedTo = other->mRespondedTo;
  482. mTemporaryResponder = other->mTemporaryResponder;
  484. update();
  485. }
  487. const LLNotificationFormPtr LLNotification::getForm()
  488. {
  489. return mForm;
  490. }
  492. void LLNotification::cancel()
  493. {
  494. mCancelled = true;
  495. }
  497. LLSD LLNotification::getResponseTemplate(EResponseTemplateType type)
  498. {
  499. LLSD response = LLSD::emptyMap();
  500. for (S32 element_idx = 0;
  501. element_idx < mForm->getNumElements();
  502. ++element_idx)
  503. {
  504. LLSD element = mForm->getElement(element_idx);
  505. if (element.has("name"))
  506. {
  507. response[element["name"].asString()] = element["value"];
  508. }
  510. if ((type == WITH_DEFAULT_BUTTON) 
  511. && element["default"].asBoolean())
  512. {
  513. response[element["name"].asString()] = true;
  514. }
  515. }
  516. return response;
  517. }
  519. //static
  520. S32 LLNotification::getSelectedOption(const LLSD& notification, const LLSD& response)
  521. {
  522. LLNotificationForm form(notification["form"]);
  524. for (S32 element_idx = 0;
  525. element_idx < form.getNumElements();
  526. ++element_idx)
  527. {
  528. LLSD element = form.getElement(element_idx);
  530. // only look at buttons
  531. if (element["type"].asString() == "button" 
  532. && response[element["name"].asString()].asBoolean())
  533. {
  534. return element["index"].asInteger();
  535. }
  536. }
  538. return -1;
  539. }
  541. //static
  542. std::string LLNotification::getSelectedOptionName(const LLSD& response)
  543. {
  544. for (LLSD::map_const_iterator response_it = response.beginMap();
  545. response_it != response.endMap();
  546. ++response_it)
  547. {
  548. if (response_it->second.isBoolean() && response_it->second.asBoolean())
  549. {
  550. return response_it->first;
  551. }
  552. }
  553. return "";
  554. }
  557. void LLNotification::respond(const LLSD& response)
  558. {
  559. mRespondedTo = true;
  560. // look up the functor
  561. LLNotificationFunctorRegistry::ResponseFunctor functor = 
  562. LLNotificationFunctorRegistry::instance().getFunctor(mResponseFunctorName);
  563. // and then call it
  564. functor(asLLSD(), response);
  566. if (mTemporaryResponder)
  567. {
  568. LLNotificationFunctorRegistry::instance().unregisterFunctor(mResponseFunctorName);
  569. mResponseFunctorName = "";
  570. mTemporaryResponder = false;
  571. }
  573. if (mForm->getIgnoreType() != LLNotificationForm::IGNORE_NO)
  574. {
  575. BOOL show_notification = mIgnored ? FALSE : TRUE;
  576. LLUI::sSettingGroups["ignores"]->setBOOL(getName(), show_notification);
  577. if (mIgnored && mForm->getIgnoreType() == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
  578. {
  579. LLUI::sSettingGroups["ignores"]->setLLSD("Default" + getName(), response);
  580. }
  581. }
  583. update();
  584. }
  586. void LLNotification::setIgnored(bool ignore)
  587. {
  588. mIgnored = ignore;
  589. }
  591. void LLNotification::setResponseFunctor(std::string const &responseFunctorName)
  592. {
  593. if (mTemporaryResponder)
  594. // get rid of the old one
  595. LLNotificationFunctorRegistry::instance().unregisterFunctor(mResponseFunctorName);
  596. mResponseFunctorName = responseFunctorName;
  597. mTemporaryResponder = false;
  598. }
  600. bool LLNotification::payloadContainsAll(const std::vector<std::string>& required_fields) const
  601. {
  602. for(std::vector<std::string>::const_iterator required_fields_it = required_fields.begin(); 
  603. required_fields_it != required_fields.end();
  604. required_fields_it++)
  605. {
  606. std::string required_field_name = *required_fields_it;
  607. if( ! getPayload().has(required_field_name))
  608. {
  609. return false; // a required field was not found
  610. }
  611. }
  612. return true; // all required fields were found
  613. }
  615. bool LLNotification::isEquivalentTo(LLNotificationPtr that) const
  616. {
  617. if (this->mTemplatep->mName != that->mTemplatep->mName) 
  618. {
  619. return false; // must have the same template name or forget it
  620. }
  621. if (this->mTemplatep->mUnique)
  622. {
  623. // highlander bit sez there can only be one of these
  624. return
  625. this->payloadContainsAll(that->mTemplatep->mUniqueContext) &&
  626. that->payloadContainsAll(this->mTemplatep->mUniqueContext);
  627. }
  628. return false; 
  629. }
  631. void LLNotification::init(const std::string& template_name, const LLSD& form_elements)
  632. {
  633. mTemplatep = LLNotifications::instance().getTemplate(template_name);
  634. if (!mTemplatep) return;
  636. // add default substitutions
  637. const LLStringUtil::format_map_t& default_args = LLTrans::getDefaultArgs();
  638. for (LLStringUtil::format_map_t::const_iterator iter = default_args.begin();
  639.  iter != default_args.end(); ++iter)
  640. {
  641. mSubstitutions[iter->first] = iter->second;
  642. }
  643. mSubstitutions["_URL"] = getURL();
  644. mSubstitutions["_NAME"] = template_name;
  645. // TODO: something like this so that a missing alert is sensible:
  646. //mSubstitutions["_ARGS"] = get_all_arguments_as_text(mSubstitutions);
  648. mForm = LLNotificationFormPtr(new LLNotificationForm(*mTemplatep->mForm));
  649. mForm->append(form_elements);
  651. // apply substitution to form labels
  652. mForm->formatElements(mSubstitutions);
  654. LLDate rightnow = LLDate::now();
  655. if (mTemplatep->mExpireSeconds)
  656. {
  657. mExpiresAt = LLDate(rightnow.secondsSinceEpoch() + mTemplatep->mExpireSeconds);
  658. }
  660. if (mPriority == NOTIFICATION_PRIORITY_UNSPECIFIED)
  661. {
  662. mPriority = mTemplatep->mPriority;
  663. }
  664. }
  666. std::string LLNotification::summarize() const
  667. {
  668. std::string s = "Notification(";
  669. s += getName();
  670. s += ") : ";
  671. s += mTemplatep ? mTemplatep->mMessage : "";
  672. // should also include timestamp and expiration time (but probably not payload)
  673. return s;
  674. }
  676. std::string LLNotification::getMessage() const
  677. {
  678. // all our callers cache this result, so it gives us more flexibility
  679. // to do the substitution at call time rather than attempting to 
  680. // cache it in the notification
  681. if (!mTemplatep)
  682. return std::string();
  684. std::string message = mTemplatep->mMessage;
  685. LLStringUtil::format(message, mSubstitutions);
  686. return message;
  687. }
  689. std::string LLNotification::getLabel() const
  690. {
  691. std::string label = mTemplatep->mLabel;
  692. LLStringUtil::format(label, mSubstitutions);
  693. return (mTemplatep ? label : "");
  694. }
  696. std::string LLNotification::getURL() const
  697. {
  698. if (!mTemplatep)
  699. return std::string();
  700. std::string url = mTemplatep->mURL;
  701. LLStringUtil::format(url, mSubstitutions);
  702. return (mTemplatep ? url : "");
  703. }
  705. // =========================================================
  706. // LLNotificationChannel implementation
  707. // ---
  708. LLBoundListener LLNotificationChannelBase::connectChangedImpl(const LLEventListener& slot)
  709. {
  710. // when someone wants to connect to a channel, we first throw them
  711. // all of the notifications that are already in the channel
  712. // we use a special signal called "load" in case the channel wants to care
  713. // only about new notifications
  714. for (LLNotificationSet::iterator it = mItems.begin(); it != mItems.end(); ++it)
  715. {
  716. slot(LLSD().with("sigtype", "load").with("id", (*it)->id()));
  717. }
  718. // and then connect the signal so that all future notifications will also be
  719. // forwarded.
  720. return mChanged.connect(slot);
  721. }
  723. LLBoundListener LLNotificationChannelBase::connectAtFrontChangedImpl(const LLEventListener& slot)
  724. {
  725. for (LLNotificationSet::iterator it = mItems.begin(); it != mItems.end(); ++it)
  726. {
  727. slot(LLSD().with("sigtype", "load").with("id", (*it)->id()));
  728. }
  729. return mChanged.connect(slot, boost::signals2::at_front);
  730. }
  732. LLBoundListener LLNotificationChannelBase::connectPassedFilterImpl(const LLEventListener& slot)
  733. {
  734. // these two filters only fire for notifications added after the current one, because
  735. // they don't participate in the hierarchy.
  736. return mPassedFilter.connect(slot);
  737. }
  739. LLBoundListener LLNotificationChannelBase::connectFailedFilterImpl(const LLEventListener& slot)
  740. {
  741. return mFailedFilter.connect(slot);
  742. }
  744. // external call, conforms to our standard signature
  745. bool LLNotificationChannelBase::updateItem(const LLSD& payload)
  746. {
  747. // first check to see if it's in the master list
  748. LLNotificationPtr pNotification  = LLNotifications::instance().find(payload["id"]);
  749. if (!pNotification)
  750. return false; // not found
  752. return updateItem(payload, pNotification);
  753. }
  756. //FIX QUIT NOT WORKING
  759. // internal call, for use in avoiding lookup
  760. bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPtr pNotification)
  761. {
  762. std::string cmd = payload["sigtype"];
  763. LLNotificationSet::iterator foundItem = mItems.find(pNotification);
  764. bool wasFound = (foundItem != mItems.end());
  765. bool passesFilter = mFilter(pNotification);
  767. // first, we offer the result of the filter test to the simple
  768. // signals for pass/fail. One of these is guaranteed to be called.
  769. // If either signal returns true, the change processing is NOT performed
  770. // (so don't return true unless you know what you're doing!)
  771. bool abortProcessing = false;
  772. if (passesFilter)
  773. {
  774. abortProcessing = mPassedFilter(payload);
  775. }
  776. else
  777. {
  778. abortProcessing = mFailedFilter(payload);
  779. }
  781. if (abortProcessing)
  782. {
  783. return true;
  784. }
  786. if (cmd == "load")
  787. {
  788. // should be no reason we'd ever get a load if we already have it
  789. // if passes filter send a load message, else do nothing
  790. assert(!wasFound);
  791. if (passesFilter)
  792. {
  793. // not in our list, add it and say so
  794. mItems.insert(pNotification);
  795. abortProcessing = mChanged(payload);
  796. onLoad(pNotification);
  797. }
  798. }
  799. else if (cmd == "change")
  800. {
  801. // if it passes filter now and was found, we just send a change message
  802. // if it passes filter now and wasn't found, we have to add it
  803. // if it doesn't pass filter and wasn't found, we do nothing
  804. // if it doesn't pass filter and was found, we need to delete it
  805. if (passesFilter)
  806. {
  807. if (wasFound)
  808. {
  809. // it already existed, so this is a change
  810. // since it changed in place, all we have to do is resend the signal
  811. abortProcessing = mChanged(payload);
  812. onChange(pNotification);
  813. }
  814. else
  815. {
  816. // not in our list, add it and say so
  817. mItems.insert(pNotification);
  818. // our payload is const, so make a copy before changing it
  819. LLSD newpayload = payload;
  820. newpayload["sigtype"] = "add";
  821. abortProcessing = mChanged(newpayload);
  822. onChange(pNotification);
  823. }
  824. }
  825. else
  826. {
  827. if (wasFound)
  828. {
  829. // it already existed, so this is a delete
  830. mItems.erase(pNotification);
  831. // our payload is const, so make a copy before changing it
  832. LLSD newpayload = payload;
  833. newpayload["sigtype"] = "delete";
  834. abortProcessing = mChanged(newpayload);
  835. onChange(pNotification);
  836. }
  837. // didn't pass, not on our list, do nothing
  838. }
  839. }
  840. else if (cmd == "add")
  841. {
  842. // should be no reason we'd ever get an add if we already have it
  843. // if passes filter send an add message, else do nothing
  844. assert(!wasFound);
  845. if (passesFilter)
  846. {
  847. // not in our list, add it and say so
  848. mItems.insert(pNotification);
  849. abortProcessing = mChanged(payload);
  850. onAdd(pNotification);
  851. }
  852. }
  853. else if (cmd == "delete")
  854. {
  855. // if we have it in our list, pass on the delete, then delete it, else do nothing
  856. if (wasFound)
  857. {
  858. abortProcessing = mChanged(payload);
  859. mItems.erase(pNotification);
  860. onDelete(pNotification);
  861. }
  862. }
  863. return abortProcessing;
  864. }
  866. /* static */
  867. LLNotificationChannelPtr LLNotificationChannel::buildChannel(const std::string& name, 
  868.  const std::string& parent,
  869.  LLNotificationFilter filter, 
  870.  LLNotificationComparator comparator)
  871. {
  872. // note: this is not a leak; notifications are self-registering.
  873. // This factory helps to prevent excess deletions by making sure all smart
  874. // pointers to notification channels come from the same source
  875. new LLNotificationChannel(name, parent, filter, comparator);
  876. return LLNotifications::instance().getChannel(name);
  877. }
  880. LLNotificationChannel::LLNotificationChannel(const std::string& name, 
  881.  const std::string& parent,
  882.  LLNotificationFilter filter, 
  883.  LLNotificationComparator comparator) : 
  884. LLNotificationChannelBase(filter, comparator),
  885. mName(name),
  886. mParent(parent)
  887. {
  888. // store myself in the channel map
  889. LLNotifications::instance().addChannel(LLNotificationChannelPtr(this));
  890. // bind to notification broadcast
  891. if (parent.empty())
  892. {
  893. LLNotifications::instance().connectChanged(
  894. boost::bind(&LLNotificationChannelBase::updateItem, this, _1));
  895. }
  896. else
  897. {
  898. LLNotificationChannelPtr p = LLNotifications::instance().getChannel(parent);
  899. p->connectChanged(boost::bind(&LLNotificationChannelBase::updateItem, this, _1));
  900. }
  901. }
  904. void LLNotificationChannel::setComparator(LLNotificationComparator comparator) 
  905. { 
  906. mComparator = comparator; 
  907. LLNotificationSet s2(mComparator);
  908. s2.insert(mItems.begin(), mItems.end());
  909. mItems.swap(s2);
  911. // notify clients that we've been resorted
  912. mChanged(LLSD().with("sigtype", "sort")); 
  913. }
  915. bool LLNotificationChannel::isEmpty() const
  916. {
  917. return mItems.empty();
  918. }
  920. LLNotificationChannel::Iterator LLNotificationChannel::begin()
  921. {
  922. return mItems.begin();
  923. }
  925. LLNotificationChannel::Iterator LLNotificationChannel::end()
  926. {
  927. return mItems.end();
  928. }
  930. std::string LLNotificationChannel::summarize()
  931. {
  932. std::string s("Channel '");
  933. s += mName;
  934. s += "'n  ";
  935. for (LLNotificationChannel::Iterator it = begin(); it != end(); ++it)
  936. {
  937. s += (*it)->summarize();
  938. s += "n  ";
  939. }
  940. return s;
  941. }
  944. // ---
  945. // END OF LLNotificationChannel implementation
  946. // =========================================================
  949. // =========================================================
  950. // LLNotifications implementation
  951. // ---
  952. LLNotifications::LLNotifications() : LLNotificationChannelBase(LLNotificationFilters::includeEverything,
  953.    LLNotificationComparators::orderByUUID()),
  954. mIgnoreAllNotifications(false)
  955. {
  956. LLUICtrl::CommitCallbackRegistry::currentRegistrar().add("Notification.Show", boost::bind(&LLNotifications::addFromCallback, this, _2));
  958.     mListener.reset(new LLNotificationsListener(*this));
  959. }
  962. // The expiration channel gets all notifications that are cancelled
  963. bool LLNotifications::expirationFilter(LLNotificationPtr pNotification)
  964. {
  965. return pNotification->isCancelled() || pNotification->isRespondedTo();
  966. }
  968. bool LLNotifications::expirationHandler(const LLSD& payload)
  969. {
  970. if (payload["sigtype"].asString() != "delete")
  971. {
  972. // anything added to this channel actually should be deleted from the master
  973. cancel(find(payload["id"]));
  974. return true; // don't process this item any further
  975. }
  976. return false;
  977. }
  979. bool LLNotifications::uniqueFilter(LLNotificationPtr pNotif)
  980. {
  981. if (!pNotif->hasUniquenessConstraints())
  982. {
  983. return true;
  984. }
  986. // checks against existing unique notifications
  987. for (LLNotificationMap::iterator existing_it = mUniqueNotifications.find(pNotif->getName());
  988. existing_it != mUniqueNotifications.end();
  989. ++existing_it)
  990. {
  991. LLNotificationPtr existing_notification = existing_it->second;
  992. if (pNotif != existing_notification 
  993. && pNotif->isEquivalentTo(existing_notification))
  994. {
  995. return false;
  996. }
  997. }
  999. return true;
  1000. }
  1002. bool LLNotifications::uniqueHandler(const LLSD& payload)
  1003. {
  1004. LLNotificationPtr pNotif = LLNotifications::instance().find(payload["id"].asUUID());
  1005. if (pNotif && pNotif->hasUniquenessConstraints()) 
  1006. {
  1007. if (payload["sigtype"].asString() == "add")
  1008. {
  1009. // not a duplicate according to uniqueness criteria, so we keep it
  1010. // and store it for future uniqueness checks
  1011. mUniqueNotifications.insert(std::make_pair(pNotif->getName(), pNotif));
  1012. }
  1013. else if (payload["sigtype"].asString() == "delete")
  1014. {
  1015. mUniqueNotifications.erase(pNotif->getName());
  1016. }
  1017. }
  1019. return false;
  1020. }
  1022. bool LLNotifications::failedUniquenessTest(const LLSD& payload)
  1023. {
  1024. LLNotificationPtr pNotif = LLNotifications::instance().find(payload["id"].asUUID());
  1026. if (!pNotif || !pNotif->hasUniquenessConstraints())
  1027. {
  1028. return false;
  1029. }
  1031. // checks against existing unique notifications
  1032. for (LLNotificationMap::iterator existing_it = mUniqueNotifications.find(pNotif->getName());
  1033. existing_it != mUniqueNotifications.end();
  1034. ++existing_it)
  1035. {
  1036. LLNotificationPtr existing_notification = existing_it->second;
  1037. if (pNotif != existing_notification 
  1038. && pNotif->isEquivalentTo(existing_notification))
  1039. {
  1040. // copy notification instance data over to oldest instance
  1041. // of this unique notification and update it
  1042. existing_notification->updateFrom(pNotif);
  1043. // then delete the new one
  1044. pNotif->cancel();
  1045. }
  1046. }
  1048. return false;
  1049. }
  1052. void LLNotifications::addChannel(LLNotificationChannelPtr pChan)
  1053. {
  1054. mChannels[pChan->getName()] = pChan;
  1055. }
  1057. LLNotificationChannelPtr LLNotifications::getChannel(const std::string& channelName)
  1058. {
  1059. ChannelMap::iterator p = mChannels.find(channelName);
  1060. if(p == mChannels.end())
  1061. {
  1062. llerrs << "Did not find channel named " << channelName << llendl;
  1063. return LLNotificationChannelPtr();
  1064. }
  1065. return p->second;
  1066. }
  1069. // this function is called once at construction time, after the object is constructed.
  1070. void LLNotifications::initSingleton()
  1071. {
  1072. loadTemplates();
  1073. createDefaultChannels();
  1074. }
  1076. void LLNotifications::createDefaultChannels()
  1077. {
  1078. // now construct the various channels AFTER loading the notifications,
  1079. // because the history channel is going to rewrite the stored notifications file
  1080. LLNotificationChannel::buildChannel("Expiration", "",
  1081. boost::bind(&LLNotifications::expirationFilter, this, _1));
  1082. LLNotificationChannel::buildChannel("Unexpired", "",
  1083. !boost::bind(&LLNotifications::expirationFilter, this, _1)); // use negated bind
  1084. LLNotificationChannel::buildChannel("Unique", "Unexpired",
  1085. boost::bind(&LLNotifications::uniqueFilter, this, _1));
  1086. LLNotificationChannel::buildChannel("Ignore", "Unique",
  1087. filterIgnoredNotifications);
  1088. LLNotificationChannel::buildChannel("Visible", "Ignore",
  1089. &LLNotificationFilters::includeEverything);
  1091. // create special history channel
  1092. //std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_PER_SL_ACCOUNT, "open_notifications.xml" );
  1093. // use ^^^ when done debugging notifications serialization
  1094. std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_USER_SETTINGS, "open_notifications.xml" );
  1095. // this isn't a leak, don't worry about the empty "new"
  1096. new LLNotificationHistoryChannel(notifications_log_file);
  1098. // connect action methods to these channels
  1099. LLNotifications::instance().getChannel("Expiration")->
  1100.         connectChanged(boost::bind(&LLNotifications::expirationHandler, this, _1));
  1101. // uniqueHandler slot should be added as first slot of the signal due to
  1102. // usage LLStopWhenHandled combiner in LLStandardSignal
  1103. LLNotifications::instance().getChannel("Unique")->
  1104.         connectAtFrontChanged(boost::bind(&LLNotifications::uniqueHandler, this, _1));
  1105. // failedUniquenessTest slot isn't necessary
  1106. // LLNotifications::instance().getChannel("Unique")->
  1107. //        connectFailedFilter(boost::bind(&LLNotifications::failedUniquenessTest, this, _1));
  1108. LLNotifications::instance().getChannel("Ignore")->
  1109. connectFailedFilter(&handleIgnoredNotification);
  1110. }
  1112. bool LLNotifications::addTemplate(const std::string &name, 
  1113.   LLNotificationTemplatePtr theTemplate)
  1114. {
  1115. if (mTemplates.count(name))
  1116. {
  1117. llwarns << "LLNotifications -- attempted to add template '" << name << "' twice." << llendl;
  1118. return false;
  1119. }
  1120. mTemplates[name] = theTemplate;
  1121. return true;
  1122. }
  1124. LLNotificationTemplatePtr LLNotifications::getTemplate(const std::string& name)
  1125. {
  1126. if (mTemplates.count(name))
  1127. {
  1128. return mTemplates[name];
  1129. }
  1130. else
  1131. {
  1132. return mTemplates["MissingAlert"];
  1133. }
  1134. }
  1136. bool LLNotifications::templateExists(const std::string& name)
  1137. {
  1138. return (mTemplates.count(name) != 0);
  1139. }
  1141. void LLNotifications::clearTemplates()
  1142. {
  1143. mTemplates.clear();
  1144. }
  1146. void LLNotifications::forceResponse(const LLNotification::Params& params, S32 option)
  1147. {
  1148. LLNotificationPtr temp_notify(new LLNotification(params));
  1149. LLSD response = temp_notify->getResponseTemplate();
  1150. LLSD selected_item = temp_notify->getForm()->getElement(option);
  1152. if (selected_item.isUndefined())
  1153. {
  1154. llwarns << "Invalid option" << option << " for notification " << (std::string)params.name << llendl;
  1155. return;
  1156. }
  1157. response[selected_item["name"].asString()] = true;
  1159. temp_notify->respond(response);
  1160. }
  1162. LLNotifications::TemplateNames LLNotifications::getTemplateNames() const
  1163. {
  1164. TemplateNames names;
  1165. for (TemplateMap::const_iterator it = mTemplates.begin(); it != mTemplates.end(); ++it)
  1166. {
  1167. names.push_back(it->first);
  1168. }
  1169. return names;
  1170. }
  1172. typedef std::map<std::string, std::string> StringMap;
  1173. void replaceSubstitutionStrings(LLXMLNodePtr node, StringMap& replacements)
  1174. {
  1175. //llwarns << "replaceSubstitutionStrings" << llendl;
  1176. // walk the list of attributes looking for replacements
  1177. for (LLXMLAttribList::iterator it=node->mAttributes.begin();
  1178.  it != node->mAttributes.end(); ++it)
  1179. {
  1180. std::string value = it->second->getValue();
  1181. if (value[0] == '$')
  1182. {
  1183. value.erase(0, 1); // trim off the $
  1184. std::string replacement;
  1185. StringMap::const_iterator found = replacements.find(value);
  1186. if (found != replacements.end())
  1187. {
  1188. replacement = found->second;
  1189. //llwarns << "replaceSubstituionStrings: value: " << value << " repl: " << replacement << llendl;
  1191. it->second->setValue(replacement);
  1192. }
  1193. else
  1194. {
  1195. llwarns << "replaceSubstituionStrings FAILURE: value: " << value << " repl: " << replacement << llendl;
  1196. }
  1197. }
  1198. }
  1200. // now walk the list of children and call this recursively.
  1201. for (LLXMLNodePtr child = node->getFirstChild(); 
  1202.  child.notNull(); child = child->getNextSibling())
  1203. {
  1204. replaceSubstitutionStrings(child, replacements);
  1205. }
  1206. }
  1208. // private to this file
  1209. // returns true if the template request was invalid and there's nothing else we
  1210. // can do with this node, false if you should keep processing (it may have
  1211. // replaced the contents of the node referred to)
  1212. LLXMLNodePtr LLNotifications::checkForXMLTemplate(LLXMLNodePtr item)
  1213. {
  1214. if (item->hasName("usetemplate"))
  1215. {
  1216. std::string replacementName;
  1217. if (item->getAttributeString("name", replacementName))
  1218. {
  1219. StringMap replacements;
  1220. for (LLXMLAttribList::const_iterator it=item->mAttributes.begin(); 
  1221.  it != item->mAttributes.end(); ++it)
  1222. {
  1223. replacements[it->second->getName()->mString] = it->second->getValue();
  1224. }
  1225. if (mXmlTemplates.count(replacementName))
  1226. {
  1227. item=LLXMLNode::replaceNode(item, mXmlTemplates[replacementName]);
  1229. // walk the nodes looking for $(substitution) here and replace
  1230. replaceSubstitutionStrings(item, replacements);
  1231. }
  1232. else
  1233. {
  1234. llwarns << "XML template lookup failure on '" << replacementName << "' " << llendl;
  1235. }
  1236. }
  1237. }
  1238. return item;
  1239. }
  1241. bool LLNotifications::loadTemplates()
  1242. {
  1243. const std::string xml_filename = "notifications.xml";
  1244. LLXMLNodePtr root;
  1246. BOOL success  = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);
  1248. if (!success || root.isNull() || !root->hasName( "notifications" ))
  1249. {
  1250. llerrs << "Problem reading UI Notifications file: " << xml_filename << llendl;
  1251. return false;
  1252. }
  1254. clearTemplates();
  1256. for (LLXMLNodePtr item = root->getFirstChild();
  1257.  item.notNull(); item = item->getNextSibling())
  1258. {
  1259. // we do this FIRST so that item can be changed if we 
  1260. // encounter a usetemplate -- we just replace the
  1261. // current xml node and keep processing
  1262. item = checkForXMLTemplate(item);
  1264. if (item->hasName("global"))
  1265. {
  1266. std::string global_name;
  1267. if (item->getAttributeString("name", global_name))
  1268. {
  1269. mGlobalStrings[global_name] = item->getTextContents();
  1270. }
  1271. continue;
  1272. }
  1274. if (item->hasName("template"))
  1275. {
  1276. // store an xml template; templates must have a single node (can contain
  1277. // other nodes)
  1278. std::string name;
  1279. item->getAttributeString("name", name);
  1280. LLXMLNodePtr ptr = item->getFirstChild();
  1281. mXmlTemplates[name] = ptr;
  1282. continue;
  1283. }
  1285. if (!item->hasName("notification"))
  1286. {
  1287.             llwarns << "Unexpected entity " << item->getName()->mString << 
  1288.                        " found in " << xml_filename << llendl;
  1289. continue;
  1290. }
  1292. // now we know we have a notification entry, so let's build it
  1293. LLNotificationTemplatePtr pTemplate(new LLNotificationTemplate());
  1295. if (!item->getAttributeString("name", pTemplate->mName))
  1296. {
  1297. llwarns << "Unable to parse notification with no name" << llendl;
  1298. continue;
  1299. }
  1301. //llinfos << "Parsing " << pTemplate->mName << llendl;
  1303. pTemplate->mMessage = item->getTextContents();
  1304. pTemplate->mDefaultFunctor = pTemplate->mName;
  1305. item->getAttributeString("type", pTemplate->mType);
  1306. item->getAttributeString("icon", pTemplate->mIcon);
  1307. item->getAttributeString("label", pTemplate->mLabel);
  1308. item->getAttributeU32("duration", pTemplate->mExpireSeconds);
  1309. item->getAttributeU32("expireOption", pTemplate->mExpireOption);
  1311. std::string priority;
  1312. item->getAttributeString("priority", priority);
  1313. pTemplate->mPriority = NOTIFICATION_PRIORITY_NORMAL;
  1314. if (!priority.empty())
  1315. {
  1316. if (priority == "low")      pTemplate->mPriority = NOTIFICATION_PRIORITY_LOW;
  1317. if (priority == "normal")   pTemplate->mPriority = NOTIFICATION_PRIORITY_NORMAL;
  1318. if (priority == "high")     pTemplate->mPriority = NOTIFICATION_PRIORITY_HIGH;
  1319. if (priority == "critical") pTemplate->mPriority = NOTIFICATION_PRIORITY_CRITICAL;
  1320. }
  1322. item->getAttributeString("functor", pTemplate->mDefaultFunctor);
  1324. BOOL persist = false;
  1325. item->getAttributeBOOL("persist", persist);
  1326. pTemplate->mPersist = persist;
  1328. std::string sound;
  1329. item->getAttributeString("sound", sound);
  1330. if (!sound.empty())
  1331. {
  1332. // test for bad sound effect name / missing effect
  1333. if (LLUI::sSettingGroups["config"]->controlExists(sound))
  1334. {
  1335. pTemplate->mSoundEffect = 
  1336. LLUUID(LLUI::sSettingGroups["config"]->getString(sound));
  1337. }
  1338. else
  1339. {
  1340. llwarns << "Unknown sound effect control name " << sound
  1341. << llendl;
  1342. }
  1343. }
  1345. for (LLXMLNodePtr child = item->getFirstChild();
  1346.  !child.isNull(); child = child->getNextSibling())
  1347. {
  1348. child = checkForXMLTemplate(child);
  1350. // <url>
  1351. if (child->hasName("url"))
  1352. {
  1353. pTemplate->mURL = child->getTextContents();
  1354. child->getAttributeU32("option", pTemplate->mURLOption);
  1355. child->getAttributeU32("openexternally", pTemplate->mURLOpenExternally);
  1356. }
  1358.             if (child->hasName("unique"))
  1359.             {
  1360.                 pTemplate->mUnique = true;
  1361.                 for (LLXMLNodePtr formitem = child->getFirstChild();
  1362.                      !formitem.isNull(); formitem = formitem->getNextSibling())
  1363.                 {
  1364.                     if (formitem->hasName("context"))
  1365.                     {
  1366.                         std::string key;
  1367.                         formitem->getAttributeString("key", key);
  1368.                         pTemplate->mUniqueContext.push_back(key);
  1369.                         //llwarns << "adding " << key << " to unique context" << llendl;
  1370.                     }
  1371.                     else
  1372.                     {
  1373.                         llwarns << "'unique' has unrecognized subelement " 
  1374.                         << formitem->getName()->mString << llendl;
  1375.                     }
  1376.                 }
  1377.             }
  1378.             
  1379. // <form>
  1380. if (child->hasName("form"))
  1381. {
  1382.                 pTemplate->mForm = LLNotificationFormPtr(new LLNotificationForm(pTemplate->mName, child));
  1383. }
  1384. }
  1385. addTemplate(pTemplate->mName, pTemplate);
  1386. }
  1388. //std::ostringstream ostream;
  1389. //root->writeToOstream(ostream, "n  ");
  1390. //llwarns << ostream.str() << llendl;
  1392. return true;
  1393. }
  1395. // Add a simple notification (from XUI)
  1396. void LLNotifications::addFromCallback(const LLSD& name)
  1397. {
  1398. add(LLNotification::Params().name(name.asString()));
  1399. }
  1401. LLNotificationPtr LLNotifications::add(const std::string& name, 
  1402.    const LLSD& substitutions, 
  1403.    const LLSD& payload)
  1404. {
  1405. LLNotification::Params::Functor functor_p;
  1406. functor_p.name = name;
  1407. return add(LLNotification::Params().name(name).substitutions(substitutions).payload(payload).functor(functor_p));
  1408. }
  1410. LLNotificationPtr LLNotifications::add(const std::string& name, 
  1411.    const LLSD& substitutions, 
  1412.    const LLSD& payload, 
  1413.    const std::string& functor_name)
  1414. {
  1415. LLNotification::Params::Functor functor_p;
  1416. functor_p.name = functor_name;
  1417. return add(LLNotification::Params().name(name).substitutions(substitutions).payload(payload).functor(functor_p));
  1418. }
  1419.   
  1420. //virtual
  1421. LLNotificationPtr LLNotifications::add(const std::string& name, 
  1422. const LLSD& substitutions, 
  1423. const LLSD& payload, 
  1424. LLNotificationFunctorRegistry::ResponseFunctor functor)
  1425. {
  1426. LLNotification::Params::Functor functor_p;
  1427. functor_p.function = functor;
  1428. return add(LLNotification::Params().name(name).substitutions(substitutions).payload(payload).functor(functor_p));
  1429. }
  1431. // generalized add function that takes a parameter block object for more complex instantiations
  1432. LLNotificationPtr LLNotifications::add(const LLNotification::Params& p)
  1433. {
  1434. LLNotificationPtr pNotif(new LLNotification(p));
  1435. add(pNotif);
  1436. return pNotif;
  1437. }
  1440. void LLNotifications::add(const LLNotificationPtr pNotif)
  1441. {
  1442. // first see if we already have it -- if so, that's a problem
  1443. LLNotificationSet::iterator it=mItems.find(pNotif);
  1444. if (it != mItems.end())
  1445. {
  1446. llerrs << "Notification added a second time to the master notification channel." << llendl;
  1447. }
  1449. updateItem(LLSD().with("sigtype", "add").with("id", pNotif->id()), pNotif);
  1450. }
  1452. void LLNotifications::cancel(LLNotificationPtr pNotif)
  1453. {
  1454. LLNotificationSet::iterator it=mItems.find(pNotif);
  1455. if (it == mItems.end())
  1456. {
  1457. llerrs << "Attempted to delete nonexistent notification " << pNotif->getName() << llendl;
  1458. }
  1459. pNotif->cancel();
  1460. updateItem(LLSD().with("sigtype", "delete").with("id", pNotif->id()), pNotif);
  1461. }
  1463. void LLNotifications::update(const LLNotificationPtr pNotif)
  1464. {
  1465. LLNotificationSet::iterator it=mItems.find(pNotif);
  1466. if (it != mItems.end())
  1467. {
  1468. updateItem(LLSD().with("sigtype", "change").with("id", pNotif->id()), pNotif);
  1469. }
  1470. }
  1473. LLNotificationPtr LLNotifications::find(LLUUID uuid)
  1474. {
  1475. LLNotificationPtr target = LLNotificationPtr(new LLNotification(uuid));
  1476. LLNotificationSet::iterator it=mItems.find(target);
  1477. if (it == mItems.end())
  1478. {
  1479. llwarns << "Tried to dereference uuid '" << uuid << "' as a notification key but didn't find it." << llendl;
  1480. return LLNotificationPtr((LLNotification*)NULL);
  1481. }
  1482. else
  1483. {
  1484. return *it;
  1485. }
  1486. }
  1488. void LLNotifications::forEachNotification(NotificationProcess process)
  1489. {
  1490. std::for_each(mItems.begin(), mItems.end(), process);
  1491. }
  1493. std::string LLNotifications::getGlobalString(const std::string& key) const
  1494. {
  1495. GlobalStringMap::const_iterator it = mGlobalStrings.find(key);
  1496. if (it != mGlobalStrings.end())
  1497. {
  1498. return it->second;
  1499. }
  1500. else
  1501. {
  1502. // if we don't have the key as a global, return the key itself so that the error
  1503. // is self-diagnosing.
  1504. return key;
  1505. }
  1506. }
  1508. void LLNotifications::setIgnoreAllNotifications(bool setting)
  1509. {
  1510. mIgnoreAllNotifications = setting; 
  1511. }
  1512. bool LLNotifications::getIgnoreAllNotifications()
  1513. {
  1514. return mIgnoreAllNotifications; 
  1515. }
  1517. // ---
  1518. // END OF LLNotifications implementation
  1519. // =========================================================
  1521. std::ostream& operator<<(std::ostream& s, const LLNotification& notification)
  1522. {
  1523. s << notification.summarize();
  1524. return s;
  1525. }