llurlentry.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:19k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llurlentry.cpp
  3.  * @author Martin Reddy
  4.  * @brief Describes the Url types that can be registered in LLUrlRegistry
  5.  *
  6.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2009-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  33. #include "linden_common.h"
  34. #include "llurlentry.h"
  35. #include "lluri.h"
  36. #include "llcachename.h"
  37. #include "lltrans.h"
  38. #include "lluicolortable.h"
  39. LLUrlEntryBase::LLUrlEntryBase() :
  40. mColor(LLUIColorTable::instance().getColor("HTMLLinkColor")),
  41. mDisabledLink(false)
  42. {
  43. }
  44. LLUrlEntryBase::~LLUrlEntryBase()
  45. {
  46. }
  47. std::string LLUrlEntryBase::getUrl(const std::string &string) const
  48. {
  49. return escapeUrl(string);
  50. }
  51. std::string LLUrlEntryBase::getIDStringFromUrl(const std::string &url) const
  52. {
  53. // return the id from a SLURL in the format /app/{cmd}/{id}/about
  54. LLURI uri(url);
  55. LLSD path_array = uri.pathArray();
  56. if (path_array.size() == 4) 
  57. {
  58. return path_array.get(2).asString();
  59. }
  60. return "";
  61. }
  62. std::string LLUrlEntryBase::unescapeUrl(const std::string &url) const
  63. {
  64. return LLURI::unescape(url);
  65. }
  66. std::string LLUrlEntryBase::escapeUrl(const std::string &url) const
  67. {
  68. static std::string no_escape_chars;
  69. static bool initialized = false;
  70. if (!initialized)
  71. {
  72. no_escape_chars = 
  73. "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  74. "abcdefghijklmnopqrstuvwxyz"
  75. "0123456789"
  76. "-._~!$?&()*+,@:;=/%#";
  77. std::sort(no_escape_chars.begin(), no_escape_chars.end());
  78. initialized = true;
  79. }
  80. return LLURI::escape(url, no_escape_chars, true);
  81. }
  82. std::string LLUrlEntryBase::getLabelFromWikiLink(const std::string &url) const
  83. {
  84. // return the label part from [http://www.example.org Label]
  85. const char *text = url.c_str();
  86. S32 start = 0;
  87. while (! isspace(text[start]))
  88. {
  89. start++;
  90. }
  91. while (text[start] == ' ' || text[start] == 't')
  92. {
  93. start++;
  94. }
  95. return unescapeUrl(url.substr(start, url.size()-start-1));
  96. }
  97. std::string LLUrlEntryBase::getUrlFromWikiLink(const std::string &string) const
  98. {
  99. // return the url part from [http://www.example.org Label]
  100. const char *text = string.c_str();
  101. S32 end = 0;
  102. while (! isspace(text[end]))
  103. {
  104. end++;
  105. }
  106. return escapeUrl(string.substr(1, end-1));
  107. }
  108. void LLUrlEntryBase::addObserver(const std::string &id,
  109.  const std::string &url,
  110.  const LLUrlLabelCallback &cb)
  111. {
  112. // add a callback to be notified when we have a label for the uuid
  113. LLUrlEntryObserver observer;
  114. observer.url = url;
  115. observer.signal = new LLUrlLabelSignal();
  116. if (observer.signal)
  117. {
  118. observer.signal->connect(cb);
  119. mObservers.insert(std::pair<std::string, LLUrlEntryObserver>(id, observer));
  120. }
  121. }
  122.  
  123. void LLUrlEntryBase::callObservers(const std::string &id, const std::string &label)
  124. {
  125. // notify all callbacks waiting on the given uuid
  126. std::multimap<std::string, LLUrlEntryObserver>::iterator it;
  127. for (it = mObservers.find(id); it != mObservers.end();)
  128. {
  129. // call the callback - give it the new label
  130. LLUrlEntryObserver &observer = it->second;
  131. (*observer.signal)(it->second.url, label);
  132. // then remove the signal - we only need to call it once
  133. delete observer.signal;
  134. mObservers.erase(it++);
  135. }
  136. }
  137. static std::string getStringAfterToken(const std::string str, const std::string token)
  138. {
  139. size_t pos = str.find(token);
  140. if (pos == std::string::npos)
  141. {
  142. return "";
  143. }
  144. pos += token.size();
  145. return str.substr(pos, str.size() - pos);
  146. }
  147. //
  148. // LLUrlEntryHTTP Describes generic http: and https: Urls
  149. //
  150. LLUrlEntryHTTP::LLUrlEntryHTTP()
  151. {
  152. mPattern = boost::regex("https?://([-\w\.]+)+(:\d+)?(:\w+)?(@\d+)?(@\w+)?/?\S*",
  153. boost::regex::perl|boost::regex::icase);
  154. mMenuName = "menu_url_http.xml";
  155. mTooltip = LLTrans::getString("TooltipHttpUrl");
  156. }
  157. std::string LLUrlEntryHTTP::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  158. {
  159. return unescapeUrl(url);
  160. }
  161. //
  162. // LLUrlEntryHTTP Describes generic http: and https: Urls with custom label
  163. // We use the wikipedia syntax of [http://www.example.org Text]
  164. //
  165. LLUrlEntryHTTPLabel::LLUrlEntryHTTPLabel()
  166. {
  167. mPattern = boost::regex("\[https?://\S+[ t]+[^\]]+\]",
  168. boost::regex::perl|boost::regex::icase);
  169. mMenuName = "menu_url_http.xml";
  170. mTooltip = LLTrans::getString("TooltipHttpUrl");
  171. }
  172. std::string LLUrlEntryHTTPLabel::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  173. {
  174. return getLabelFromWikiLink(url);
  175. }
  176. std::string LLUrlEntryHTTPLabel::getUrl(const std::string &string) const
  177. {
  178. return getUrlFromWikiLink(string);
  179. }
  180. //
  181. // LLUrlEntryHTTPNoProtocol Describes generic Urls like www.google.com
  182. //
  183. LLUrlEntryHTTPNoProtocol::LLUrlEntryHTTPNoProtocol()
  184. {
  185. mPattern = boost::regex("("
  186. "\bwww\.\S+\.\S+" // i.e. www.FOO.BAR
  187. "|" // or
  188. "(?<!@)\b[^[:space:]:@/>]+\.(?:com|net|edu|org)([/:][^[:space:]<]*)?\b" // i.e. FOO.net
  189. ")",
  190. boost::regex::perl|boost::regex::icase);
  191. mMenuName = "menu_url_http.xml";
  192. mTooltip = LLTrans::getString("TooltipHttpUrl");
  193. }
  194. std::string LLUrlEntryHTTPNoProtocol::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  195. {
  196. return unescapeUrl(url);
  197. }
  198. std::string LLUrlEntryHTTPNoProtocol::getUrl(const std::string &string) const
  199. {
  200. if (string.find("://") == std::string::npos)
  201. {
  202. return "http://" + escapeUrl(string);
  203. }
  204. return escapeUrl(string);
  205. }
  206. //
  207. // LLUrlEntrySLURL Describes generic http: and https: Urls
  208. //
  209. LLUrlEntrySLURL::LLUrlEntrySLURL()
  210. {
  211. // see http://slurl.com/about.php for details on the SLURL format
  212. mPattern = boost::regex("http://(maps.secondlife.com|slurl.com)/secondlife/\S+/?(\d+)?/?(\d+)?/?(\d+)?/?\S*",
  213. boost::regex::perl|boost::regex::icase);
  214. mMenuName = "menu_url_slurl.xml";
  215. mTooltip = LLTrans::getString("TooltipSLURL");
  216. }
  217. std::string LLUrlEntrySLURL::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  218. {
  219. //
  220. // we handle SLURLs in the following formats:
  221. //   - http://slurl.com/secondlife/Place/X/Y/Z
  222. //   - http://slurl.com/secondlife/Place/X/Y
  223. //   - http://slurl.com/secondlife/Place/X
  224. //   - http://slurl.com/secondlife/Place
  225. //
  226. LLURI uri(url);
  227. LLSD path_array = uri.pathArray();
  228. S32 path_parts = path_array.size();
  229. if (path_parts == 5)
  230. {
  231. // handle slurl with (X,Y,Z) coordinates
  232. std::string location = unescapeUrl(path_array[path_parts-4]);
  233. std::string x = path_array[path_parts-3];
  234. std::string y = path_array[path_parts-2];
  235. std::string z = path_array[path_parts-1];
  236. return location + " (" + x + "," + y + "," + z + ")";
  237. }
  238. else if (path_parts == 4)
  239. {
  240. // handle slurl with (X,Y) coordinates
  241. std::string location = unescapeUrl(path_array[path_parts-3]);
  242. std::string x = path_array[path_parts-2];
  243. std::string y = path_array[path_parts-1];
  244. return location + " (" + x + "," + y + ")";
  245. }
  246. else if (path_parts == 3)
  247. {
  248. // handle slurl with (X) coordinate
  249. std::string location = unescapeUrl(path_array[path_parts-2]);
  250. std::string x = path_array[path_parts-1];
  251. return location + " (" + x + ")";
  252. }
  253. else if (path_parts == 2)
  254. {
  255. // handle slurl with no coordinates
  256. std::string location = unescapeUrl(path_array[path_parts-1]);
  257. return location;
  258. }
  259. return url;
  260. }
  261. std::string LLUrlEntrySLURL::getLocation(const std::string &url) const
  262. {
  263. // return the part of the Url after slurl.com/secondlife/
  264. const std::string search_string = "/secondlife";
  265. size_t pos = url.find(search_string);
  266. if (pos == std::string::npos)
  267. {
  268. return "";
  269. }
  270. pos += search_string.size() + 1;
  271. return url.substr(pos, url.size() - pos);
  272. }
  273. //
  274. // LLUrlEntryAgent Describes a Second Life agent Url, e.g.,
  275. // secondlife:///app/agent/0e346d8b-4433-4d66-a6b0-fd37083abc4c/about
  276. //
  277. LLUrlEntryAgent::LLUrlEntryAgent()
  278. {
  279. mPattern = boost::regex("secondlife:///app/agent/[\da-f-]+/\w+",
  280. boost::regex::perl|boost::regex::icase);
  281. mMenuName = "menu_url_agent.xml";
  282. mIcon = "Generic_Person";
  283. mColor = LLUIColorTable::instance().getColor("AgentLinkColor");
  284. }
  285. void LLUrlEntryAgent::onAgentNameReceived(const LLUUID& id,
  286.   const std::string& first,
  287.   const std::string& last,
  288.   BOOL is_group)
  289. {
  290. // received the agent name from the server - tell our observers
  291. callObservers(id.asString(), first + " " + last);
  292. }
  293. std::string LLUrlEntryAgent::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  294. {
  295. if (!gCacheName)
  296. {
  297. // probably at the login screen, use short string for layout
  298. return LLTrans::getString("LoadingData");
  299. }
  300. std::string agent_id_string = getIDStringFromUrl(url);
  301. if (agent_id_string.empty())
  302. {
  303. // something went wrong, just give raw url
  304. return unescapeUrl(url);
  305. }
  306. LLUUID agent_id(agent_id_string);
  307. std::string full_name;
  308. if (agent_id.isNull())
  309. {
  310. return LLTrans::getString("AvatarNameNobody");
  311. }
  312. else if (gCacheName->getFullName(agent_id, full_name))
  313. {
  314. return full_name;
  315. }
  316. else
  317. {
  318. gCacheName->get(agent_id, FALSE,
  319. boost::bind(&LLUrlEntryAgent::onAgentNameReceived,
  320. this, _1, _2, _3, _4));
  321. addObserver(agent_id_string, url, cb);
  322. return LLTrans::getString("LoadingData");
  323. }
  324. }
  325. //
  326. // LLUrlEntryGroup Describes a Second Life group Url, e.g.,
  327. // secondlife:///app/group/00005ff3-4044-c79f-9de8-fb28ae0df991/about
  328. // secondlife:///app/group/00005ff3-4044-c79f-9de8-fb28ae0df991/inspect
  329. //
  330. LLUrlEntryGroup::LLUrlEntryGroup()
  331. {
  332. mPattern = boost::regex("secondlife:///app/group/[\da-f-]+/\w+",
  333. boost::regex::perl|boost::regex::icase);
  334. mMenuName = "menu_url_group.xml";
  335. mIcon = "Generic_Group";
  336. mTooltip = LLTrans::getString("TooltipGroupUrl");
  337. mColor = LLUIColorTable::instance().getColor("GroupLinkColor");
  338. }
  339. void LLUrlEntryGroup::onGroupNameReceived(const LLUUID& id,
  340.   const std::string& first,
  341.   const std::string& last,
  342.   BOOL is_group)
  343. {
  344. // received the group name from the server - tell our observers
  345. callObservers(id.asString(), first);
  346. }
  347. std::string LLUrlEntryGroup::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  348. {
  349. if (!gCacheName)
  350. {
  351. // probably at login screen, give something short for layout
  352. return LLTrans::getString("LoadingData");
  353. }
  354. std::string group_id_string = getIDStringFromUrl(url);
  355. if (group_id_string.empty())
  356. {
  357. // something went wrong, give raw url
  358. return unescapeUrl(url);
  359. }
  360. LLUUID group_id(group_id_string);
  361. std::string group_name;
  362. if (group_id.isNull())
  363. {
  364. return LLTrans::getString("GroupNameNone");
  365. }
  366. else if (gCacheName->getGroupName(group_id, group_name))
  367. {
  368. return group_name;
  369. }
  370. else
  371. {
  372. gCacheName->get(group_id, TRUE,
  373. boost::bind(&LLUrlEntryGroup::onGroupNameReceived,
  374. this, _1, _2, _3, _4));
  375. addObserver(group_id_string, url, cb);
  376. return LLTrans::getString("LoadingData");
  377. }
  378. }
  379. //
  380. // LLUrlEntryInventory Describes a Second Life inventory Url, e.g.,
  381. // secondlife:///app/inventory/0e346d8b-4433-4d66-a6b0-fd37083abc4c/select
  382. //
  383. LLUrlEntryInventory::LLUrlEntryInventory()
  384. {
  385. //*TODO: add supporting of inventory item names with whitespaces
  386. //this pattern cann't parse for example 
  387. //secondlife:///app/inventory/0e346d8b-4433-4d66-a6b0-fd37083abc4c/select?name=name with spaces&param2=value
  388. mPattern = boost::regex("secondlife:///app/inventory/[\da-f-]+/\w+\S*",
  389. boost::regex::perl|boost::regex::icase);
  390. mMenuName = "menu_url_inventory.xml";
  391. }
  392. std::string LLUrlEntryInventory::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  393. {
  394. std::string label = getStringAfterToken(url, "name=");
  395. return LLURI::unescape(label.empty() ? url : label);
  396. }
  397. ///
  398. /// LLUrlEntryParcel Describes a Second Life parcel Url, e.g.,
  399. /// secondlife:///app/parcel/0000060e-4b39-e00b-d0c3-d98b1934e3a8/about
  400. ///
  401. LLUrlEntryParcel::LLUrlEntryParcel()
  402. {
  403. mPattern = boost::regex("secondlife:///app/parcel/[\da-f-]+/about",
  404. boost::regex::perl|boost::regex::icase);
  405. mMenuName = "menu_url_parcel.xml";
  406. mTooltip = LLTrans::getString("TooltipParcelUrl");
  407. }
  408. std::string LLUrlEntryParcel::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  409. {
  410. return unescapeUrl(url);
  411. }
  412. //
  413. // LLUrlEntryPlace Describes secondlife://<location> URLs
  414. //
  415. LLUrlEntryPlace::LLUrlEntryPlace()
  416. {
  417. mPattern = boost::regex("secondlife://\S+/?(\d+/\d+/\d+|\d+/\d+)/?",
  418. boost::regex::perl|boost::regex::icase);
  419. mMenuName = "menu_url_slurl.xml";
  420. mTooltip = LLTrans::getString("TooltipSLURL");
  421. }
  422. std::string LLUrlEntryPlace::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  423. {
  424. //
  425. // we handle SLURLs in the following formats:
  426. //   - secondlife://Place/X/Y/Z
  427. //   - secondlife://Place/X/Y
  428. //
  429. LLURI uri(url);
  430. std::string location = unescapeUrl(uri.hostName());
  431. LLSD path_array = uri.pathArray();
  432. S32 path_parts = path_array.size();
  433. if (path_parts == 3)
  434. {
  435. // handle slurl with (X,Y,Z) coordinates
  436. std::string x = path_array[0];
  437. std::string y = path_array[1];
  438. std::string z = path_array[2];
  439. return location + " (" + x + "," + y + "," + z + ")";
  440. }
  441. else if (path_parts == 2)
  442. {
  443. // handle slurl with (X,Y) coordinates
  444. std::string x = path_array[0];
  445. std::string y = path_array[1];
  446. return location + " (" + x + "," + y + ")";
  447. }
  448. return url;
  449. }
  450. std::string LLUrlEntryPlace::getLocation(const std::string &url) const
  451. {
  452. // return the part of the Url after secondlife:// part
  453. return ::getStringAfterToken(url, "://");
  454. }
  455. //
  456. // LLUrlEntryTeleport Describes a Second Life teleport Url, e.g.,
  457. // secondlife:///app/teleport/Ahern/50/50/50/
  458. //
  459. LLUrlEntryTeleport::LLUrlEntryTeleport()
  460. {
  461. mPattern = boost::regex("secondlife:///app/teleport/\S+(/\d+)?(/\d+)?(/\d+)?/?\S*",
  462. boost::regex::perl|boost::regex::icase);
  463. mMenuName = "menu_url_teleport.xml";
  464. mTooltip = LLTrans::getString("TooltipTeleportUrl");
  465. }
  466. std::string LLUrlEntryTeleport::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  467. {
  468. //
  469. // we handle teleport SLURLs in the following formats:
  470. //   - secondlife:///app/teleport/Place/X/Y/Z
  471. //   - secondlife:///app/teleport/Place/X/Y
  472. //   - secondlife:///app/teleport/Place/X
  473. //   - secondlife:///app/teleport/Place
  474. //
  475. LLURI uri(url);
  476. LLSD path_array = uri.pathArray();
  477. S32 path_parts = path_array.size();
  478. const std::string label = LLTrans::getString("SLurlLabelTeleport");
  479. if (path_parts == 6)
  480. {
  481. // handle teleport url with (X,Y,Z) coordinates
  482. std::string location = unescapeUrl(path_array[path_parts-4]);
  483. std::string x = path_array[path_parts-3];
  484. std::string y = path_array[path_parts-2];
  485. std::string z = path_array[path_parts-1];
  486. return label + " " + location + " (" + x + "," + y + "," + z + ")";
  487. }
  488. else if (path_parts == 5)
  489. {
  490. // handle teleport url with (X,Y) coordinates
  491. std::string location = unescapeUrl(path_array[path_parts-3]);
  492. std::string x = path_array[path_parts-2];
  493. std::string y = path_array[path_parts-1];
  494. return label + " " + location + " (" + x + "," + y + ")";
  495. }
  496. else if (path_parts == 4)
  497. {
  498. // handle teleport url with (X) coordinate only
  499. std::string location = unescapeUrl(path_array[path_parts-2]);
  500. std::string x = path_array[path_parts-1];
  501. return label + " " + location + " (" + x + ")";
  502. }
  503. else if (path_parts == 3)
  504. {
  505. // handle teleport url with no coordinates
  506. std::string location = unescapeUrl(path_array[path_parts-1]);
  507. return label + " " + location;
  508. }
  509. return url;
  510. }
  511. std::string LLUrlEntryTeleport::getLocation(const std::string &url) const
  512. {
  513. // return the part of the Url after ///app/teleport
  514. return ::getStringAfterToken(url, "app/teleport/");
  515. }
  516. //
  517. // LLUrlEntrySL Describes a generic SLURL, e.g., a Url that starts
  518. // with secondlife:// (used as a catch-all for cases not matched above)
  519. //
  520. LLUrlEntrySL::LLUrlEntrySL()
  521. {
  522. mPattern = boost::regex("secondlife://(\w+)?(:\d+)?/\S+",
  523. boost::regex::perl|boost::regex::icase);
  524. mMenuName = "menu_url_slapp.xml";
  525. mTooltip = LLTrans::getString("TooltipSLAPP");
  526. }
  527. std::string LLUrlEntrySL::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  528. {
  529. return unescapeUrl(url);
  530. }
  531. //
  532. // LLUrlEntrySLLabel Describes a generic SLURL, e.g., a Url that starts
  533. /// with secondlife:// with the ability to specify a custom label.
  534. //
  535. LLUrlEntrySLLabel::LLUrlEntrySLLabel()
  536. {
  537. mPattern = boost::regex("\[secondlife://\S+[ t]+[^\]]+\]",
  538. boost::regex::perl|boost::regex::icase);
  539. mMenuName = "menu_url_slapp.xml";
  540. mTooltip = LLTrans::getString("TooltipSLAPP");
  541. }
  542. std::string LLUrlEntrySLLabel::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  543. {
  544. return getLabelFromWikiLink(url);
  545. }
  546. std::string LLUrlEntrySLLabel::getUrl(const std::string &string) const
  547. {
  548. return getUrlFromWikiLink(string);
  549. }
  550. //
  551. // LLUrlEntryWorldMap Describes secondlife:///<location> URLs
  552. //
  553. LLUrlEntryWorldMap::LLUrlEntryWorldMap()
  554. {
  555. mPattern = boost::regex("secondlife:///app/worldmap/\S+/?(\d+)?/?(\d+)?/?(\d+)?/?\S*",
  556. boost::regex::perl|boost::regex::icase);
  557. mMenuName = "menu_url_map.xml";
  558. mTooltip = LLTrans::getString("TooltipMapUrl");
  559. }
  560. std::string LLUrlEntryWorldMap::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  561. {
  562. //
  563. // we handle SLURLs in the following formats:
  564. //   - secondlife:///app/worldmap/PLACE/X/Y/Z
  565. //   - secondlife:///app/worldmap/PLACE/X/Y
  566. //   - secondlife:///app/worldmap/PLACE/X
  567. //
  568. LLURI uri(url);
  569. LLSD path_array = uri.pathArray();
  570. S32 path_parts = path_array.size();
  571. if (path_parts < 3)
  572. {
  573. return url;
  574. }
  575. const std::string label = LLTrans::getString("SLurlLabelShowOnMap");
  576. std::string location = path_array[2];
  577. std::string x = (path_parts > 3) ? path_array[3] : "128";
  578. std::string y = (path_parts > 4) ? path_array[4] : "128";
  579. std::string z = (path_parts > 5) ? path_array[5] : "0";
  580. return label + " " + location + " (" + x + "," + y + "," + z + ")";
  581. }
  582. std::string LLUrlEntryWorldMap::getLocation(const std::string &url) const
  583. {
  584. // return the part of the Url after secondlife:///app/worldmap/ part
  585. return ::getStringAfterToken(url, "app/worldmap/");
  586. }
  587. //
  588. // LLUrlEntryNoLink lets us turn of URL detection with <nolink>...</nolink> tags
  589. //
  590. LLUrlEntryNoLink::LLUrlEntryNoLink()
  591. {
  592. mPattern = boost::regex("<nolink>[^<]*</nolink>",
  593. boost::regex::perl|boost::regex::icase);
  594. mDisabledLink = true;
  595. }
  596. std::string LLUrlEntryNoLink::getUrl(const std::string &url) const
  597. {
  598. // return the text between the <nolink> and </nolink> tags
  599. return url.substr(8, url.size()-8-9);
  600. }
  601. std::string LLUrlEntryNoLink::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
  602. {
  603. return getUrl(url);
  604. }