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

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file llmimetypes.cpp
  3.  * @brief Translates a MIME type like "video/quicktime" into a
  4.  * localizable user-friendly string like "QuickTime Movie"
  5.  *
  6.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2007-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 "llviewerprecompiledheaders.h"
  34. #include "llmimetypes.h"
  35. #include "llxmlnode.h"
  36. #include "lluictrlfactory.h"
  37. LLMIMETypes::mime_info_map_t LLMIMETypes::sMap;
  38. LLMIMETypes::mime_widget_set_map_t LLMIMETypes::sWidgetMap;
  39. std::string sDefaultLabel;
  40. // Returned when we don't know what to do with the mime type
  41. std::string sDefaultWidgetType;
  42. // Returned when we don't know what widget set to use
  43. std::string sDefaultImpl;
  44. // Returned when we don't know what impl to use
  45. std::string sXMLFilename; 
  46.     // Squirrel away XML filename so we know how to reset
  47. /////////////////////////////////////////////////////////////////////////////
  48. // static
  49. bool LLMIMETypes::parseMIMETypes(const std::string& xml_filename)
  50. {
  51. LLXMLNodePtr root;
  52. bool success = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);
  53. if ( ! success || root.isNull() || ! root->hasName( "mimetypes" ) )
  54. {
  55. llwarns << "Unable to read MIME type file: "
  56. << xml_filename << llendl;
  57. return false;
  58. }
  59. for (LLXMLNode* node = root->getFirstChild();
  60.  node != NULL;
  61.  node = node->getNextSibling())
  62. {
  63. if (node->hasName("defaultlabel"))
  64. {
  65. sDefaultLabel = node->getTextContents();
  66. }
  67. else if (node->hasName("defaultwidget"))
  68. {
  69. sDefaultWidgetType = node->getTextContents();
  70. }
  71. else if (node->hasName("defaultimpl"))
  72. {
  73. sDefaultImpl = node->getTextContents();
  74. }
  75. else if (node->hasName("mimetype") || node->hasName("scheme"))
  76. {
  77. std::string mime_type;
  78. node->getAttributeString("name", mime_type);
  79. LLMIMEInfo info;
  80. for (LLXMLNode* child = node->getFirstChild();
  81.  child != NULL;
  82.  child = child->getNextSibling())
  83. {
  84. if (child->hasName("label"))
  85. {
  86. info.mLabel = child->getTextContents();
  87. }
  88. else if (child->hasName("widgettype"))
  89. {
  90. info.mWidgetType = child->getTextContents();
  91. }
  92. else if (child->hasName("impl"))
  93. {
  94. info.mImpl = child->getTextContents();
  95. }
  96. }
  97. sMap[mime_type] = info;
  98. }
  99. else if (node->hasName("widgetset"))
  100. {
  101. std::string set_name;
  102. node->getAttributeString("name", set_name);
  103. LLMIMEWidgetSet info;
  104. for (LLXMLNode* child = node->getFirstChild();
  105. child != NULL;
  106. child = child->getNextSibling())
  107. {
  108. if (child->hasName("label"))
  109. {
  110. info.mLabel = child->getTextContents();
  111. }
  112. if (child->hasName("icon"))
  113. {
  114. info.mIcon = child->getTextContents();
  115. }
  116. if (child->hasName("default_type"))
  117. {
  118. info.mDefaultMimeType = child->getTextContents();
  119. }
  120. if (child->hasName("tooltip"))
  121. {
  122. info.mToolTip = child->getTextContents();
  123. }
  124. if (child->hasName("playtip"))
  125. {
  126. info.mPlayTip = child->getTextContents();
  127. }
  128. if (child->hasName("allow_resize"))
  129. {
  130. BOOL allow_resize = FALSE;
  131. child->getBoolValue( 1, &allow_resize );
  132. info.mAllowResize = (bool)allow_resize;
  133. }
  134. if (child->hasName("allow_looping"))
  135. {
  136. BOOL allow_looping = FALSE;
  137. child->getBoolValue( 1, &allow_looping );
  138. info.mAllowLooping = (bool)allow_looping;
  139. }
  140. }
  141. sWidgetMap[set_name] = info;
  142. }
  143. }
  144. sXMLFilename = xml_filename;
  145. return true;
  146. }
  147. // static
  148. std::string LLMIMETypes::translate(const std::string& mime_type)
  149. {
  150. mime_info_map_t::const_iterator it = sMap.find(mime_type);
  151. if (it != sMap.end())
  152. {
  153. return it->second.mLabel;
  154. }
  155. else
  156. {
  157. return sDefaultLabel;
  158. }
  159. }
  160. // static
  161. std::string LLMIMETypes::widgetType(const std::string& mime_type)
  162. {
  163. mime_info_map_t::const_iterator it = sMap.find(mime_type);
  164. if (it != sMap.end())
  165. {
  166. return it->second.mWidgetType;
  167. }
  168. else
  169. {
  170. return sDefaultWidgetType;
  171. }
  172. }
  173. // static
  174. std::string LLMIMETypes::implType(const std::string& mime_type)
  175. {
  176. mime_info_map_t::const_iterator it = sMap.find(mime_type);
  177. if (it != sMap.end())
  178. {
  179. return it->second.mImpl;
  180. }
  181. else
  182. {
  183. return sDefaultImpl;
  184. }
  185. }
  186. // static
  187. std::string LLMIMETypes::findIcon(const std::string& mime_type)
  188. {
  189. std::string icon = "";
  190. std::string widget_type = LLMIMETypes::widgetType(mime_type);
  191. mime_widget_set_map_t::iterator it = sWidgetMap.find(widget_type);
  192. if(it != sWidgetMap.end())
  193. {
  194. icon = it->second.mIcon;
  195. }
  196. return icon;
  197. }
  198. // static
  199. std::string LLMIMETypes::findDefaultMimeType(const std::string& widget_type)
  200. {
  201. std::string mime_type = "none/none";
  202. mime_widget_set_map_t::iterator it = sWidgetMap.find(widget_type);
  203. if(it != sWidgetMap.end())
  204. {
  205. mime_type = it->second.mDefaultMimeType;
  206. }
  207. return mime_type;
  208. }
  209. // static
  210. std::string LLMIMETypes::findToolTip(const std::string& mime_type)
  211. {
  212. std::string tool_tip = "";
  213. std::string widget_type = LLMIMETypes::widgetType(mime_type);
  214. mime_widget_set_map_t::iterator it = sWidgetMap.find(widget_type);
  215. if(it != sWidgetMap.end())
  216. {
  217. tool_tip = it->second.mToolTip;
  218. }
  219. return tool_tip;
  220. }
  221. // static
  222. std::string LLMIMETypes::findPlayTip(const std::string& mime_type)
  223. {
  224. std::string play_tip = "";
  225. std::string widget_type = LLMIMETypes::widgetType(mime_type);
  226. mime_widget_set_map_t::iterator it = sWidgetMap.find(widget_type);
  227. if(it != sWidgetMap.end())
  228. {
  229. play_tip = it->second.mPlayTip;
  230. }
  231. return play_tip;
  232. }
  233. // static
  234. bool LLMIMETypes::findAllowResize(const std::string& mime_type)
  235. {
  236. bool allow_resize = false;
  237. std::string widget_type = LLMIMETypes::widgetType(mime_type);
  238. mime_widget_set_map_t::iterator it = sWidgetMap.find(widget_type);
  239. if(it != sWidgetMap.end())
  240. {
  241. allow_resize = it->second.mAllowResize;
  242. }
  243. return allow_resize;
  244. }
  245. // static
  246. bool LLMIMETypes::findAllowLooping(const std::string& mime_type)
  247. {
  248. bool allow_looping = false;
  249. std::string widget_type = LLMIMETypes::widgetType(mime_type);
  250. mime_widget_set_map_t::iterator it = sWidgetMap.find(widget_type);
  251. if(it != sWidgetMap.end())
  252. {
  253. allow_looping = it->second.mAllowLooping;
  254. }
  255. return allow_looping;
  256. }
  257. // static
  258. bool LLMIMETypes::isTypeHandled(const std::string& mime_type)
  259. {
  260. mime_info_map_t::const_iterator it = sMap.find(mime_type);
  261. if (it != sMap.end())
  262. {
  263. return true;
  264. }
  265. return false;
  266. }
  267. // static
  268. void LLMIMETypes::reload(void*)
  269. {
  270. sMap.clear();
  271. sWidgetMap.clear();
  272. (void)LLMIMETypes::parseMIMETypes(sXMLFilename);
  273. }