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

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

游戏引擎

开发平台：

C++ Builder

llfloatersettingsdebug.cpp：源码内容
  1. /** 
  2.  * @file llfloatersettingsdebug.cpp
  3.  * @brief floater for debugging internal viewer settings
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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 "llviewerprecompiledheaders.h"
  34. #include "llfloatersettingsdebug.h"
  35. #include "llfloater.h"
  36. #include "lluictrlfactory.h"
  37. //#include "llfirstuse.h"
  38. #include "llcombobox.h"
  39. #include "llspinctrl.h"
  40. #include "llcolorswatch.h"
  41. #include "llviewercontrol.h"
  42. #include "lltexteditor.h"
  45. LLFloaterSettingsDebug::LLFloaterSettingsDebug(const LLSD& key) 
  46. : LLFloater(key)
  47. {
  48. //LLUICtrlFactory::getInstance()->buildFloater(this, "floater_settings_debug.xml");
  49. mCommitCallbackRegistrar.add("SettingSelect", boost::bind(&LLFloaterSettingsDebug::onSettingSelect, this,_1));
  50. mCommitCallbackRegistrar.add("CommitSettings", boost::bind(&LLFloaterSettingsDebug::onCommitSettings, this));
  51. mCommitCallbackRegistrar.add("ClickDefault", boost::bind(&LLFloaterSettingsDebug::onClickDefault, this));
  53. }
  55. LLFloaterSettingsDebug::~LLFloaterSettingsDebug()
  56. {}
  58. BOOL LLFloaterSettingsDebug::postBuild()
  59. {
  60. LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
  62. struct f : public LLControlGroup::ApplyFunctor
  63. {
  64. LLComboBox* combo;
  65. f(LLComboBox* c) : combo(c) {}
  66. virtual void apply(const std::string& name, LLControlVariable* control)
  67. {
  68. if (!control->isHiddenFromSettingsEditor())
  69. {
  70. combo->add(name, (void*)control);
  71. }
  72. }
  73. } func(settings_combo);
  75. std::string key = getKey().asString();
  76. if (key == "all" || key == "base")
  77. {
  78. gSavedSettings.applyToAll(&func);
  79. }
  80. if (key == "all" || key == "account")
  81. {
  82. gSavedPerAccountSettings.applyToAll(&func);
  83. }
  85. settings_combo->sortByName();
  86. settings_combo->updateSelection();
  87. mComment = getChild<LLTextEditor>("comment_text");
  88. return TRUE;
  89. }
  91. void LLFloaterSettingsDebug::draw()
  92. {
  93. LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
  94. LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
  95. updateControl(controlp);
  97. LLFloater::draw();
  98. }
  100. //static 
  101. void LLFloaterSettingsDebug::onSettingSelect(LLUICtrl* ctrl)
  102. {
  103. LLComboBox* combo_box = (LLComboBox*)ctrl;
  104. LLControlVariable* controlp = (LLControlVariable*)combo_box->getCurrentUserdata();
  106. updateControl(controlp);
  107. }
  109. void LLFloaterSettingsDebug::onCommitSettings()
  110. {
  111. LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
  112. LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
  114. if (!controlp)
  115. {
  116. return;
  117. }
  119. LLVector3 vector;
  120. LLVector3d vectord;
  121. LLRect rect;
  122. LLColor4 col4;
  123. LLColor3 col3;
  124. LLColor4U col4U;
  125. LLColor4 color_with_alpha;
  127. switch(controlp->type())
  128. {
  129.   case TYPE_U32:
  130. controlp->set(childGetValue("val_spinner_1"));
  131. break;
  132.   case TYPE_S32:
  133. controlp->set(childGetValue("val_spinner_1"));
  134. break;
  135.   case TYPE_F32:
  136. controlp->set(LLSD(childGetValue("val_spinner_1").asReal()));
  137. break;
  138.   case TYPE_BOOLEAN:
  139. controlp->set(childGetValue("boolean_combo"));
  140. break;
  141.   case TYPE_STRING:
  142. controlp->set(LLSD(childGetValue("val_text").asString()));
  143. break;
  144.   case TYPE_VEC3:
  145. vector.mV[VX] = (F32)childGetValue("val_spinner_1").asReal();
  146. vector.mV[VY] = (F32)childGetValue("val_spinner_2").asReal();
  147. vector.mV[VZ] = (F32)childGetValue("val_spinner_3").asReal();
  148. controlp->set(vector.getValue());
  149. break;
  150.   case TYPE_VEC3D:
  151. vectord.mdV[VX] = childGetValue("val_spinner_1").asReal();
  152. vectord.mdV[VY] = childGetValue("val_spinner_2").asReal();
  153. vectord.mdV[VZ] = childGetValue("val_spinner_3").asReal();
  154. controlp->set(vectord.getValue());
  155. break;
  156.   case TYPE_RECT:
  157. rect.mLeft = childGetValue("val_spinner_1").asInteger();
  158. rect.mRight = childGetValue("val_spinner_2").asInteger();
  159. rect.mBottom = childGetValue("val_spinner_3").asInteger();
  160. rect.mTop = childGetValue("val_spinner_4").asInteger();
  161. controlp->set(rect.getValue());
  162. break;
  163.   case TYPE_COL4:
  164. col3.setValue(childGetValue("val_color_swatch"));
  165. col4 = LLColor4(col3, (F32)childGetValue("val_spinner_4").asReal());
  166. controlp->set(col4.getValue());
  167. break;
  168.   case TYPE_COL3:
  169. controlp->set(childGetValue("val_color_swatch"));
  170. //col3.mV[VRED] = (F32)floaterp->childGetValue("val_spinner_1").asC();
  171. //col3.mV[VGREEN] = (F32)floaterp->childGetValue("val_spinner_2").asReal();
  172. //col3.mV[VBLUE] = (F32)floaterp->childGetValue("val_spinner_3").asReal();
  173. //controlp->set(col3.getValue());
  174. break;
  175.   default:
  176. break;
  177. }
  178. }
  180. // static
  181. void LLFloaterSettingsDebug::onClickDefault()
  182. {
  183. LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
  184. LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
  186. if (controlp)
  187. {
  188. controlp->resetToDefault();
  189. updateControl(controlp);
  190. }
  191. }
  193. // we've switched controls, or doing per-frame update, so update spinners, etc.
  194. void LLFloaterSettingsDebug::updateControl(LLControlVariable* controlp)
  195. {
  196. LLSpinCtrl* spinner1 = getChild<LLSpinCtrl>("val_spinner_1");
  197. LLSpinCtrl* spinner2 = getChild<LLSpinCtrl>("val_spinner_2");
  198. LLSpinCtrl* spinner3 = getChild<LLSpinCtrl>("val_spinner_3");
  199. LLSpinCtrl* spinner4 = getChild<LLSpinCtrl>("val_spinner_4");
  200. LLColorSwatchCtrl* color_swatch = getChild<LLColorSwatchCtrl>("val_color_swatch");
  202. if (!spinner1 || !spinner2 || !spinner3 || !spinner4 || !color_swatch)
  203. {
  204. llwarns << "Could not find all desired controls by name"
  205. << llendl;
  206. return;
  207. }
  209. spinner1->setVisible(FALSE);
  210. spinner2->setVisible(FALSE);
  211. spinner3->setVisible(FALSE);
  212. spinner4->setVisible(FALSE);
  213. color_swatch->setVisible(FALSE);
  214. childSetVisible("val_text", FALSE);
  215. mComment->setText(LLStringUtil::null);
  217. if (controlp)
  218. {
  219. eControlType type = controlp->type();
  221. //hide combo box only for non booleans, otherwise this will result in the combo box closing every frame
  222. childSetVisible("boolean_combo", type == TYPE_BOOLEAN);
  225. mComment->setText(controlp->getComment());
  226. spinner1->setMaxValue(F32_MAX);
  227. spinner2->setMaxValue(F32_MAX);
  228. spinner3->setMaxValue(F32_MAX);
  229. spinner4->setMaxValue(F32_MAX);
  230. spinner1->setMinValue(-F32_MAX);
  231. spinner2->setMinValue(-F32_MAX);
  232. spinner3->setMinValue(-F32_MAX);
  233. spinner4->setMinValue(-F32_MAX);
  234. if (!spinner1->hasFocus())
  235. {
  236. spinner1->setIncrement(0.1f);
  237. }
  238. if (!spinner2->hasFocus())
  239. {
  240. spinner2->setIncrement(0.1f);
  241. }
  242. if (!spinner3->hasFocus())
  243. {
  244. spinner3->setIncrement(0.1f);
  245. }
  246. if (!spinner4->hasFocus())
  247. {
  248. spinner4->setIncrement(0.1f);
  249. }
  251. LLSD sd = controlp->get();
  252. switch(type)
  253. {
  254.   case TYPE_U32:
  255. spinner1->setVisible(TRUE);
  256. spinner1->setLabel(std::string("value")); // Debug, don't translate
  257. if (!spinner1->hasFocus())
  258. {
  259. spinner1->setValue(sd);
  260. spinner1->setMinValue((F32)U32_MIN);
  261. spinner1->setMaxValue((F32)U32_MAX);
  262. spinner1->setIncrement(1.f);
  263. spinner1->setPrecision(0);
  264. }
  265. break;
  266.   case TYPE_S32:
  267. spinner1->setVisible(TRUE);
  268. spinner1->setLabel(std::string("value")); // Debug, don't translate
  269. if (!spinner1->hasFocus())
  270. {
  271. spinner1->setValue(sd);
  272. spinner1->setMinValue((F32)S32_MIN);
  273. spinner1->setMaxValue((F32)S32_MAX);
  274. spinner1->setIncrement(1.f);
  275. spinner1->setPrecision(0);
  276. }
  277. break;
  278.   case TYPE_F32:
  279. spinner1->setVisible(TRUE);
  280. spinner1->setLabel(std::string("value")); // Debug, don't translate
  281. if (!spinner1->hasFocus())
  282. {
  283. spinner1->setPrecision(3);
  284. spinner1->setValue(sd);
  285. }
  286. break;
  287.   case TYPE_BOOLEAN:
  288. if (!childHasFocus("boolean_combo"))
  289. {
  290. if (sd.asBoolean())
  291. {
  292. childSetValue("boolean_combo", LLSD("true"));
  293. }
  294. else
  295. {
  296. childSetValue("boolean_combo", LLSD(""));
  297. }
  298. }
  299. break;
  300.   case TYPE_STRING:
  301. childSetVisible("val_text", TRUE);
  302. if (!childHasFocus("val_text"))
  303. {
  304. childSetValue("val_text", sd);
  305. }
  306. break;
  307.   case TYPE_VEC3:
  308.   {
  309. LLVector3 v;
  310. v.setValue(sd);
  311. spinner1->setVisible(TRUE);
  312. spinner1->setLabel(std::string("X"));
  313. spinner2->setVisible(TRUE);
  314. spinner2->setLabel(std::string("Y"));
  315. spinner3->setVisible(TRUE);
  316. spinner3->setLabel(std::string("Z"));
  317. if (!spinner1->hasFocus())
  318. {
  319. spinner1->setPrecision(3);
  320. spinner1->setValue(v[VX]);
  321. }
  322. if (!spinner2->hasFocus())
  323. {
  324. spinner2->setPrecision(3);
  325. spinner2->setValue(v[VY]);
  326. }
  327. if (!spinner3->hasFocus())
  328. {
  329. spinner3->setPrecision(3);
  330. spinner3->setValue(v[VZ]);
  331. }
  332. break;
  333.   }
  334.   case TYPE_VEC3D:
  335.   {
  336. LLVector3d v;
  337. v.setValue(sd);
  338. spinner1->setVisible(TRUE);
  339. spinner1->setLabel(std::string("X"));
  340. spinner2->setVisible(TRUE);
  341. spinner2->setLabel(std::string("Y"));
  342. spinner3->setVisible(TRUE);
  343. spinner3->setLabel(std::string("Z"));
  344. if (!spinner1->hasFocus())
  345. {
  346. spinner1->setPrecision(3);
  347. spinner1->setValue(v[VX]);
  348. }
  349. if (!spinner2->hasFocus())
  350. {
  351. spinner2->setPrecision(3);
  352. spinner2->setValue(v[VY]);
  353. }
  354. if (!spinner3->hasFocus())
  355. {
  356. spinner3->setPrecision(3);
  357. spinner3->setValue(v[VZ]);
  358. }
  359. break;
  360.   }
  361.   case TYPE_RECT:
  362.   {
  363. LLRect r;
  364. r.setValue(sd);
  365. spinner1->setVisible(TRUE);
  366. spinner1->setLabel(std::string("Left"));
  367. spinner2->setVisible(TRUE);
  368. spinner2->setLabel(std::string("Right"));
  369. spinner3->setVisible(TRUE);
  370. spinner3->setLabel(std::string("Bottom"));
  371. spinner4->setVisible(TRUE);
  372. spinner4->setLabel(std::string("Top"));
  373. if (!spinner1->hasFocus())
  374. {
  375. spinner1->setPrecision(0);
  376. spinner1->setValue(r.mLeft);
  377. }
  378. if (!spinner2->hasFocus())
  379. {
  380. spinner2->setPrecision(0);
  381. spinner2->setValue(r.mRight);
  382. }
  383. if (!spinner3->hasFocus())
  384. {
  385. spinner3->setPrecision(0);
  386. spinner3->setValue(r.mBottom);
  387. }
  388. if (!spinner4->hasFocus())
  389. {
  390. spinner4->setPrecision(0);
  391. spinner4->setValue(r.mTop);
  392. }
  394. spinner1->setMinValue((F32)S32_MIN);
  395. spinner1->setMaxValue((F32)S32_MAX);
  396. spinner1->setIncrement(1.f);
  398. spinner2->setMinValue((F32)S32_MIN);
  399. spinner2->setMaxValue((F32)S32_MAX);
  400. spinner2->setIncrement(1.f);
  402. spinner3->setMinValue((F32)S32_MIN);
  403. spinner3->setMaxValue((F32)S32_MAX);
  404. spinner3->setIncrement(1.f);
  406. spinner4->setMinValue((F32)S32_MIN);
  407. spinner4->setMaxValue((F32)S32_MAX);
  408. spinner4->setIncrement(1.f);
  409. break;
  410.   }
  411.   case TYPE_COL4:
  412.   {
  413. LLColor4 clr;
  414. clr.setValue(sd);
  415. color_swatch->setVisible(TRUE);
  416. // only set if changed so color picker doesn't update
  417. if(clr != LLColor4(color_swatch->getValue()))
  418. {
  419. color_swatch->set(LLColor4(sd), TRUE, FALSE);
  420. }
  421. spinner4->setVisible(TRUE);
  422. spinner4->setLabel(std::string("Alpha"));
  423. if (!spinner4->hasFocus())
  424. {
  425. spinner4->setPrecision(3);
  426. spinner4->setMinValue(0.0);
  427. spinner4->setMaxValue(1.f);
  428. spinner4->setValue(clr.mV[VALPHA]);
  429. }
  430. break;
  431.   }
  432.   case TYPE_COL3:
  433.   {
  434. LLColor3 clr;
  435. clr.setValue(sd);
  436. color_swatch->setVisible(TRUE);
  437. color_swatch->setValue(sd);
  438. break;
  439.   }
  440.   default:
  441. mComment->setText(std::string("unknown"));
  442. break;
  443. }
  444. }
  446. }