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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llpanel.cpp
  3.  * @brief LLPanel base class
  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.  */
  32. // Opaque view with a background and a border.  Can contain LLUICtrls.
  33. #include "linden_common.h"
  34. #define LLPANEL_CPP
  35. #include "llpanel.h"
  36. #include "llfocusmgr.h"
  37. #include "llfontgl.h"
  38. #include "llrect.h"
  39. #include "llerror.h"
  40. #include "lltimer.h"
  41. #include "llaccordionctrltab.h"
  42. #include "llbutton.h"
  43. #include "llmenugl.h"
  44. //#include "llstatusbar.h"
  45. #include "llui.h"
  46. #include "llkeyboard.h"
  47. #include "lllineeditor.h"
  48. #include "llcontrol.h"
  49. #include "lltextbox.h"
  50. #include "lluictrl.h"
  51. #include "lluictrlfactory.h"
  52. #include "llviewborder.h"
  53. #include "lltabcontainer.h"
  54. static LLDefaultChildRegistry::Register<LLPanel> r1("panel", &LLPanel::fromXML);
  55. // Compiler optimization, generate extern template
  56. template class LLPanel* LLView::getChild<class LLPanel>(
  57. const std::string& name, BOOL recurse) const;
  58. LLPanel::LocalizedString::LocalizedString()
  59. : name("name"),
  60. value("value")
  61. {}
  62. const LLPanel::Params& LLPanel::getDefaultParams() 
  63. return LLUICtrlFactory::getDefaultParams<LLPanel>(); 
  64. }
  65. LLPanel::Params::Params()
  66. : has_border("border", false),
  67. border(""),
  68. background_visible("background_visible", false),
  69. background_opaque("background_opaque", false),
  70. bg_opaque_color("bg_opaque_color"),
  71. bg_alpha_color("bg_alpha_color"),
  72. bg_opaque_image("bg_opaque_image"),
  73. bg_alpha_image("bg_alpha_image"),
  74. min_width("min_width", 100),
  75. min_height("min_height", 100),
  76. strings("string"),
  77. filename("filename"),
  78. class_name("class"),
  79. help_topic("help_topic"),
  80. visible_callback("visible_callback")
  81. {
  82. name = "panel";
  83. addSynonym(background_visible, "bg_visible");
  84. addSynonym(has_border, "border_visible");
  85. addSynonym(label, "title");
  86. }
  87. LLPanel::LLPanel(const LLPanel::Params& p)
  88. : LLUICtrl(p),
  89. mBgVisible(p.background_visible),
  90. mBgOpaque(p.background_opaque),
  91. mBgOpaqueColor(p.bg_opaque_color()),
  92. mBgAlphaColor(p.bg_alpha_color()),
  93. mBgOpaqueImage(p.bg_opaque_image()),
  94. mBgAlphaImage(p.bg_alpha_image()),
  95. mDefaultBtn(NULL),
  96. mBorder(NULL),
  97. mLabel(p.label),
  98. mHelpTopic(p.help_topic),
  99. mCommitCallbackRegistrar(false),
  100. mEnableCallbackRegistrar(false),
  101. mXMLFilename(p.filename),
  102. mVisibleSignal(NULL)
  103. // *NOTE: Be sure to also change LLPanel::initFromParams().  We have too
  104. // many classes derived from LLPanel to retrofit them all to pass in params.
  105. {
  106. if (p.has_border)
  107. {
  108. addBorder(p.border);
  109. }
  110. mPanelHandle.bind(this);
  111. }
  112. LLPanel::~LLPanel()
  113. {
  114. delete mVisibleSignal;
  115. }
  116. // virtual
  117. BOOL LLPanel::isPanel() const
  118. {
  119. return TRUE;
  120. }
  121. void LLPanel::addBorder(LLViewBorder::Params p)
  122. {
  123. removeBorder();
  124. p.rect = getLocalRect();
  125. mBorder = LLUICtrlFactory::create<LLViewBorder>(p);
  126. addChild( mBorder );
  127. }
  128. void LLPanel::addBorder() 
  129. {  
  130. LLViewBorder::Params p; 
  131. p.border_thickness(LLPANEL_BORDER_WIDTH); 
  132. addBorder(p); 
  133. }
  134. void LLPanel::removeBorder()
  135. {
  136. if (mBorder)
  137. {
  138. removeChild(mBorder);
  139. delete mBorder;
  140. mBorder = NULL;
  141. }
  142. }
  143. // virtual
  144. void LLPanel::clearCtrls()
  145. {
  146. LLView::ctrl_list_t ctrls = getCtrlList();
  147. for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
  148. {
  149. LLUICtrl* ctrl = *ctrl_it;
  150. ctrl->setFocus( FALSE );
  151. ctrl->setEnabled( FALSE );
  152. ctrl->clear();
  153. }
  154. }
  155. void LLPanel::setCtrlsEnabled( BOOL b )
  156. {
  157. LLView::ctrl_list_t ctrls = getCtrlList();
  158. for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
  159. {
  160. LLUICtrl* ctrl = *ctrl_it;
  161. ctrl->setEnabled( b );
  162. }
  163. }
  164. void LLPanel::draw()
  165. {
  166. F32 alpha = getDrawContext().mAlpha;
  167. // draw background
  168. if( mBgVisible )
  169. {
  170. LLRect local_rect = getLocalRect();
  171. if (mBgOpaque )
  172. {
  173. // opaque, in-front look
  174. if (mBgOpaqueImage.notNull())
  175. {
  176. mBgOpaqueImage->draw( local_rect, UI_VERTEX_COLOR % alpha );
  177. }
  178. else
  179. {
  180. // fallback to flat colors when there are no images
  181. gl_rect_2d( local_rect, mBgOpaqueColor.get() % alpha);
  182. }
  183. }
  184. else
  185. {
  186. // transparent, in-back look
  187. if (mBgAlphaImage.notNull())
  188. {
  189. mBgAlphaImage->draw( local_rect, UI_VERTEX_COLOR % alpha );
  190. }
  191. else
  192. {
  193. gl_rect_2d( local_rect, mBgAlphaColor.get() % alpha );
  194. }
  195. }
  196. }
  197. updateDefaultBtn();
  198. LLView::draw();
  199. }
  200. void LLPanel::updateDefaultBtn()
  201. {
  202. if( mDefaultBtn)
  203. {
  204. if (gFocusMgr.childHasKeyboardFocus( this ) && mDefaultBtn->getEnabled())
  205. {
  206. LLButton* buttonp = dynamic_cast<LLButton*>(gFocusMgr.getKeyboardFocus());
  207. BOOL focus_is_child_button = buttonp && buttonp->getCommitOnReturn();
  208. // only enable default button when current focus is not a return-capturing button
  209. mDefaultBtn->setBorderEnabled(!focus_is_child_button);
  210. }
  211. else
  212. {
  213. mDefaultBtn->setBorderEnabled(FALSE);
  214. }
  215. }
  216. }
  217. void LLPanel::refresh()
  218. {
  219. // do nothing by default
  220. // but is automatically called in setFocus(TRUE)
  221. }
  222. void LLPanel::setDefaultBtn(LLButton* btn)
  223. {
  224. if (mDefaultBtn && mDefaultBtn->getEnabled())
  225. {
  226. mDefaultBtn->setBorderEnabled(FALSE);
  227. }
  228. mDefaultBtn = btn; 
  229. if (mDefaultBtn)
  230. {
  231. mDefaultBtn->setBorderEnabled(TRUE);
  232. }
  233. }
  234. void LLPanel::setDefaultBtn(const std::string& id)
  235. {
  236. LLButton *button = getChild<LLButton>(id);
  237. if (button)
  238. {
  239. setDefaultBtn(button);
  240. }
  241. else
  242. {
  243. setDefaultBtn(NULL);
  244. }
  245. }
  246. BOOL LLPanel::handleKeyHere( KEY key, MASK mask )
  247. {
  248. BOOL handled = FALSE;
  249. LLUICtrl* cur_focus = dynamic_cast<LLUICtrl*>(gFocusMgr.getKeyboardFocus());
  250. // handle user hitting ESC to defocus
  251. if (key == KEY_ESCAPE)
  252. {
  253. setFocus(FALSE);
  254. return TRUE;
  255. }
  256. else if( (mask == MASK_SHIFT) && (KEY_TAB == key))
  257. {
  258. //SHIFT-TAB
  259. if (cur_focus)
  260. {
  261. LLUICtrl* focus_root = cur_focus->findRootMostFocusRoot();
  262. if (focus_root)
  263. {
  264. handled = focus_root->focusPrevItem(FALSE);
  265. }
  266. }
  267. }
  268. else if( (mask == MASK_NONE ) && (KEY_TAB == key))
  269. {
  270. //TAB
  271. if (cur_focus)
  272. {
  273. LLUICtrl* focus_root = cur_focus->findRootMostFocusRoot();
  274. if (focus_root)
  275. {
  276. handled = focus_root->focusNextItem(FALSE);
  277. }
  278. }
  279. }
  280. // If RETURN was pressed and something has focus, call onCommit()
  281. if (!handled && cur_focus && key == KEY_RETURN && mask == MASK_NONE)
  282. {
  283. LLButton* focused_button = dynamic_cast<LLButton*>(cur_focus);
  284. if (focused_button && focused_button->getCommitOnReturn())
  285. {
  286. // current focus is a return-capturing button,
  287. // let *that* button handle the return key
  288. handled = FALSE; 
  289. }
  290. else if (mDefaultBtn && mDefaultBtn->getVisible() && mDefaultBtn->getEnabled())
  291. {
  292. // If we have a default button, click it when return is pressed
  293. mDefaultBtn->onCommit();
  294. handled = TRUE;
  295. }
  296. else if (cur_focus->acceptsTextInput())
  297. {
  298. // call onCommit for text input handling control
  299. cur_focus->onCommit();
  300. handled = TRUE;
  301. }
  302. }
  303. return handled;
  304. }
  305. void LLPanel::handleVisibilityChange ( BOOL new_visibility )
  306. {
  307. LLUICtrl::handleVisibilityChange ( new_visibility );
  308. if (mVisibleSignal)
  309. (*mVisibleSignal)(this, LLSD(new_visibility) ); // Pass BOOL as LLSD
  310. }
  311. void LLPanel::setFocus(BOOL b)
  312. {
  313. if( b && !hasFocus())
  314. {
  315. // give ourselves focus preemptively, to avoid infinite loop
  316. LLUICtrl::setFocus(TRUE);
  317. // then try to pass to first valid child
  318. focusFirstItem();
  319. }
  320. else
  321. {
  322. LLUICtrl::setFocus(b);
  323. }
  324. }
  325. void LLPanel::setBorderVisible(BOOL b)
  326. {
  327. if (mBorder)
  328. {
  329. mBorder->setVisible( b );
  330. }
  331. }
  332. LLFastTimer::DeclareTimer FTM_PANEL_CONSTRUCTION("Panel Construction");
  333. LLView* LLPanel::fromXML(LLXMLNodePtr node, LLView* parent, LLXMLNodePtr output_node)
  334. {
  335. std::string name("panel");
  336. node->getAttributeString("name", name);
  337. std::string class_attr;
  338. node->getAttributeString("class", class_attr);
  339. LLPanel* panelp = NULL;
  340. {
  341. LLFastTimer timer(FTM_PANEL_CONSTRUCTION);
  342. if(!class_attr.empty())
  343. {
  344. panelp = LLRegisterPanelClass::instance().createPanelClass(class_attr);
  345. if (!panelp)
  346. {
  347. llwarns << "Panel class "" << class_attr << "" not registered." << llendl;
  348. }
  349. }
  350. if (!panelp)
  351. {
  352. panelp = LLUICtrlFactory::getInstance()->createFactoryPanel(name);
  353. llassert(panelp);
  354. if (!panelp)
  355. {
  356. return NULL; // :(
  357. }
  358. }
  359. }
  360. // factory panels may have registered their own factory maps
  361. if (!panelp->getFactoryMap().empty())
  362. {
  363. LLUICtrlFactory::instance().pushFactoryFunctions(&panelp->getFactoryMap());
  364. }
  365. // for local registry callbacks; define in constructor, referenced in XUI or postBuild
  366. panelp->mCommitCallbackRegistrar.pushScope(); 
  367. panelp->mEnableCallbackRegistrar.pushScope();
  368. panelp->initPanelXML(node, parent, output_node);
  369. panelp->mCommitCallbackRegistrar.popScope();
  370. panelp->mEnableCallbackRegistrar.popScope();
  371. if (!panelp->getFactoryMap().empty())
  372. {
  373. LLUICtrlFactory::instance().popFactoryFunctions();
  374. }
  375. return panelp;
  376. }
  377. void LLPanel::initFromParams(const LLPanel::Params& p)
  378. {
  379.     //setting these here since panel constructor not called with params
  380.     //and LLView::initFromParams will use them to set visible and enabled  
  381. setVisible(p.visible);
  382. setEnabled(p.enabled);
  383. setSoundFlags(p.sound_flags);
  384.  // control_name, tab_stop, focus_lost_callback, initial_value, rect, enabled, visible
  385. LLUICtrl::initFromParams(p);
  386. // visible callback 
  387. if (p.visible_callback.isProvided())
  388. {
  389. setVisibleCallback(initCommitCallback(p.visible_callback));
  390. }
  391. for (LLInitParam::ParamIterator<LocalizedString>::const_iterator it = p.strings().begin();
  392. it != p.strings().end();
  393. ++it)
  394. {
  395. mUIStrings[it->name] = it->value;
  396. }
  397. setLabel(p.label());
  398. setHelpTopic(p.help_topic);
  399. setShape(p.rect);
  400. parseFollowsFlags(p);
  401. setToolTip(p.tool_tip());
  402. setFromXUI(p.from_xui);
  403. mHoverCursor = getCursorFromString(p.hover_cursor);
  404. if (p.has_border)
  405. {
  406. addBorder(p.border);
  407. }
  408. // let constructors set this value if not provided
  409. if (p.use_bounding_rect.isProvided())
  410. {
  411. setUseBoundingRect(p.use_bounding_rect);
  412. }
  413. setDefaultTabGroup(p.default_tab_group);
  414. setMouseOpaque(p.mouse_opaque);
  415. setBackgroundVisible(p.background_visible);
  416. setBackgroundOpaque(p.background_opaque);
  417. setBackgroundColor(p.bg_opaque_color().get());
  418. setTransparentColor(p.bg_alpha_color().get());
  419. mBgOpaqueImage = p.bg_opaque_image();
  420. mBgAlphaImage = p.bg_alpha_image();
  421. }
  422. static LLFastTimer::DeclareTimer FTM_PANEL_SETUP("Panel Setup");
  423. static LLFastTimer::DeclareTimer FTM_EXTERNAL_PANEL_LOAD("Load Extern Panel Reference");
  424. static LLFastTimer::DeclareTimer FTM_PANEL_POSTBUILD("Panel PostBuild");
  425. BOOL LLPanel::initPanelXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node)
  426. {
  427. const LLPanel::Params& default_params(LLUICtrlFactory::getDefaultParams<LLPanel>());
  428. Params params(default_params);
  429. {
  430. LLFastTimer timer(FTM_PANEL_SETUP);
  431. LLXMLNodePtr referenced_xml;
  432. std::string xml_filename = mXMLFilename;
  433. // if the panel didn't provide a filename, check the node
  434. if (xml_filename.empty())
  435. {
  436. node->getAttributeString("filename", xml_filename);
  437. }
  438. if (!xml_filename.empty())
  439. {
  440. LLFastTimer timer(FTM_EXTERNAL_PANEL_LOAD);
  441. if (output_node)
  442. {
  443. //if we are exporting, we want to export the current xml
  444. //not the referenced xml
  445. LLXUIParser::instance().readXUI(node, params, xml_filename);
  446. Params output_params(params);
  447. setupParamsForExport(output_params, parent);
  448. output_node->setName(node->getName()->mString);
  449. LLXUIParser::instance().writeXUI(
  450. output_node, output_params, &default_params);
  451. return TRUE;
  452. }
  453. if (!LLUICtrlFactory::getLayeredXMLNode(xml_filename, referenced_xml))
  454. {
  455. llwarns << "Couldn't parse panel from: " << xml_filename << llendl;
  456. return FALSE;
  457. }
  458. LLXUIParser::instance().readXUI(referenced_xml, params, xml_filename);
  459. // add children using dimensions from referenced xml for consistent layout
  460. setShape(params.rect);
  461. LLUICtrlFactory::createChildren(this, referenced_xml, child_registry_t::instance());
  462. setXMLFilename(xml_filename);
  463. }
  464. // ask LLUICtrlFactory for filename, since xml_filename might be empty
  465. LLXUIParser::instance().readXUI(node, params, LLUICtrlFactory::getInstance()->getCurFileName());
  466. if (output_node)
  467. {
  468. Params output_params(params);
  469. setupParamsForExport(output_params, parent);
  470. output_node->setName(node->getName()->mString);
  471. LLXUIParser::instance().writeXUI(
  472. output_node, output_params, &default_params);
  473. }
  474. params.from_xui = true;
  475. applyXUILayout(params, parent);
  476. {
  477. LLFastTimer timer(FTM_PANEL_CONSTRUCTION);
  478. initFromParams(params);
  479. }
  480. // add children
  481. LLUICtrlFactory::createChildren(this, node, child_registry_t::instance(), output_node);
  482. // Connect to parent after children are built, because tab containers
  483. // do a reshape() on their child panels, which requires that the children
  484. // be built/added. JC
  485. if (parent)
  486. {
  487. S32 tab_group = params.tab_group.isProvided() ? params.tab_group() : parent->getLastTabGroup();
  488. parent->addChild(this, tab_group);
  489. }
  490. {
  491. LLFastTimer timer(FTM_PANEL_POSTBUILD);
  492. postBuild();
  493. }
  494. }
  495. return TRUE;
  496. }
  497. bool LLPanel::hasString(const std::string& name)
  498. {
  499. return mUIStrings.find(name) != mUIStrings.end();
  500. }
  501. std::string LLPanel::getString(const std::string& name, const LLStringUtil::format_map_t& args) const
  502. {
  503. ui_string_map_t::const_iterator found_it = mUIStrings.find(name);
  504. if (found_it != mUIStrings.end())
  505. {
  506. // make a copy as format works in place
  507. LLUIString formatted_string = LLUIString(found_it->second);
  508. formatted_string.setArgList(args);
  509. return formatted_string.getString();
  510. }
  511. std::string err_str("Failed to find string " + name + " in panel " + getName()); //*TODO: Translate
  512. if(LLUI::sSettingGroups["config"]->getBOOL("QAMode"))
  513. {
  514. llerrs << err_str << llendl;
  515. }
  516. else
  517. {
  518. llwarns << err_str << llendl;
  519. }
  520. return LLStringUtil::null;
  521. }
  522. std::string LLPanel::getString(const std::string& name) const
  523. {
  524. ui_string_map_t::const_iterator found_it = mUIStrings.find(name);
  525. if (found_it != mUIStrings.end())
  526. {
  527. return found_it->second;
  528. }
  529. std::string err_str("Failed to find string " + name + " in panel " + getName()); //*TODO: Translate
  530. if(LLUI::sSettingGroups["config"]->getBOOL("QAMode"))
  531. {
  532. llerrs << err_str << llendl;
  533. }
  534. else
  535. {
  536. llwarns << err_str << llendl;
  537. }
  538. return LLStringUtil::null;
  539. }
  540. void LLPanel::childSetVisible(const std::string& id, bool visible)
  541. {
  542. LLView* child = findChild<LLView>(id);
  543. if (child)
  544. {
  545. child->setVisible(visible);
  546. }
  547. }
  548. bool LLPanel::childIsVisible(const std::string& id) const
  549. {
  550. LLView* child = findChild<LLView>(id);
  551. if (child)
  552. {
  553. return (bool)child->getVisible();
  554. }
  555. return false;
  556. }
  557. void LLPanel::childSetEnabled(const std::string& id, bool enabled)
  558. {
  559. LLView* child = findChild<LLView>(id);
  560. if (child)
  561. {
  562. child->setEnabled(enabled);
  563. }
  564. }
  565. void LLPanel::childSetTentative(const std::string& id, bool tentative)
  566. {
  567. LLView* child = findChild<LLView>(id);
  568. if (child)
  569. {
  570. child->setTentative(tentative);
  571. }
  572. }
  573. bool LLPanel::childIsEnabled(const std::string& id) const
  574. {
  575. LLView* child = findChild<LLView>(id);
  576. if (child)
  577. {
  578. return (bool)child->getEnabled();
  579. }
  580. return false;
  581. }
  582. void LLPanel::childSetToolTip(const std::string& id, const std::string& msg)
  583. {
  584. LLView* child = findChild<LLView>(id);
  585. if (child)
  586. {
  587. child->setToolTip(msg);
  588. }
  589. }
  590. void LLPanel::childSetRect(const std::string& id, const LLRect& rect)
  591. {
  592. LLView* child = findChild<LLView>(id);
  593. if (child)
  594. {
  595. child->setRect(rect);
  596. }
  597. }
  598. bool LLPanel::childGetRect(const std::string& id, LLRect& rect) const
  599. {
  600. LLView* child = findChild<LLView>(id);
  601. if (child)
  602. {
  603. rect = child->getRect();
  604. return true;
  605. }
  606. return false;
  607. }
  608. void LLPanel::childSetFocus(const std::string& id, BOOL focus)
  609. {
  610. LLUICtrl* child = findChild<LLUICtrl>(id);
  611. if (child)
  612. {
  613. child->setFocus(focus);
  614. }
  615. }
  616. BOOL LLPanel::childHasFocus(const std::string& id)
  617. {
  618. LLUICtrl* child = findChild<LLUICtrl>(id);
  619. if (child)
  620. {
  621. return child->hasFocus();
  622. }
  623. else
  624. {
  625. return FALSE;
  626. }
  627. }
  628. // *TODO: Deprecate; for backwards compatability only:
  629. // Prefer getChild<LLUICtrl>("foo")->setCommitCallback(boost:bind(...)),
  630. // which takes a generic slot.  Or use mCommitCallbackRegistrar.add() with
  631. // a named callback and reference it in XML.
  632. void LLPanel::childSetCommitCallback(const std::string& id, boost::function<void (LLUICtrl*,void*)> cb, void* data)
  633. {
  634. LLUICtrl* child = findChild<LLUICtrl>(id);
  635. if (child)
  636. {
  637. child->setCommitCallback(boost::bind(cb, child, data));
  638. }
  639. }
  640. void LLPanel::childSetValidate(const std::string& id, boost::function<bool (const LLSD& data)> cb)
  641. {
  642. LLUICtrl* child = findChild<LLUICtrl>(id);
  643. if (child)
  644. {
  645. child->setValidateBeforeCommit(cb);
  646. }
  647. }
  648. void LLPanel::childSetColor(const std::string& id, const LLColor4& color)
  649. {
  650. LLUICtrl* child = findChild<LLUICtrl>(id);
  651. if (child)
  652. {
  653. child->setColor(color);
  654. }
  655. }
  656. LLCtrlSelectionInterface* LLPanel::childGetSelectionInterface(const std::string& id) const
  657. {
  658. LLUICtrl* child = findChild<LLUICtrl>(id);
  659. if (child)
  660. {
  661. return child->getSelectionInterface();
  662. }
  663. return NULL;
  664. }
  665. LLCtrlListInterface* LLPanel::childGetListInterface(const std::string& id) const
  666. {
  667. LLUICtrl* child = findChild<LLUICtrl>(id);
  668. if (child)
  669. {
  670. return child->getListInterface();
  671. }
  672. return NULL;
  673. }
  674. LLCtrlScrollInterface* LLPanel::childGetScrollInterface(const std::string& id) const
  675. {
  676. LLUICtrl* child = findChild<LLUICtrl>(id);
  677. if (child)
  678. {
  679. return child->getScrollInterface();
  680. }
  681. return NULL;
  682. }
  683. void LLPanel::childSetValue(const std::string& id, LLSD value)
  684. {
  685. LLUICtrl* child = findChild<LLUICtrl>(id);
  686. if (child)
  687. {
  688. child->setValue(value);
  689. }
  690. }
  691. LLSD LLPanel::childGetValue(const std::string& id) const
  692. {
  693. LLUICtrl* child = findChild<LLUICtrl>(id);
  694. if (child)
  695. {
  696. return child->getValue();
  697. }
  698. // Not found => return undefined
  699. return LLSD();
  700. }
  701. BOOL LLPanel::childSetTextArg(const std::string& id, const std::string& key, const LLStringExplicit& text)
  702. {
  703. LLUICtrl* child = findChild<LLUICtrl>(id);
  704. if (child)
  705. {
  706. return child->setTextArg(key, text);
  707. }
  708. return FALSE;
  709. }
  710. BOOL LLPanel::childSetLabelArg(const std::string& id, const std::string& key, const LLStringExplicit& text)
  711. {
  712. LLView* child = findChild<LLView>(id);
  713. if (child)
  714. {
  715. return child->setLabelArg(key, text);
  716. }
  717. return FALSE;
  718. }
  719. BOOL LLPanel::childSetToolTipArg(const std::string& id, const std::string& key, const LLStringExplicit& text)
  720. {
  721. LLView* child = findChild<LLView>(id);
  722. if (child)
  723. {
  724. return child->setToolTipArg(key, text);
  725. }
  726. return FALSE;
  727. }
  728. void LLPanel::childShowTab(const std::string& id, const std::string& tabname, bool visible)
  729. {
  730. LLTabContainer* child = findChild<LLTabContainer>(id);
  731. if (child)
  732. {
  733. child->selectTabByName(tabname);
  734. }
  735. }
  736. LLPanel *LLPanel::childGetVisibleTab(const std::string& id) const
  737. {
  738. LLTabContainer* child = findChild<LLTabContainer>(id);
  739. if (child)
  740. {
  741. return child->getCurrentPanel();
  742. }
  743. return NULL;
  744. }
  745. static LLPanel *childGetVisibleTabWithHelp(LLView *parent)
  746. {
  747. LLView *child;
  748. // look through immediate children first for an active tab with help
  749. for (child = parent->getFirstChild(); child; child = parent->findNextSibling(child))
  750. {
  751. LLPanel *curTabPanel = NULL;
  752. // do we have a tab container?
  753. LLTabContainer *tab = dynamic_cast<LLTabContainer *>(child);
  754. if (tab && tab->getVisible())
  755. {
  756. curTabPanel = tab->getCurrentPanel();
  757. }
  758. // do we have an accordion tab?
  759. LLAccordionCtrlTab* accordion = dynamic_cast<LLAccordionCtrlTab *>(child);
  760. if (accordion && accordion->getDisplayChildren())
  761. {
  762. curTabPanel = dynamic_cast<LLPanel *>(accordion->getAccordionView());
  763. }
  764. // if we found a valid tab, does it have a help topic?
  765. if (curTabPanel && !curTabPanel->getHelpTopic().empty())
  766. {
  767. return curTabPanel;
  768. }
  769. }
  770. // then try a bit harder and recurse through all children
  771. for (child = parent->getFirstChild(); child; child = parent->findNextSibling(child))
  772. {
  773. if (child->getVisible())
  774. {
  775. LLPanel* tab = ::childGetVisibleTabWithHelp(child);
  776. if (tab)
  777. {
  778. return tab;
  779. }
  780. }
  781. }
  782. // couldn't find any active tabs with a help topic string
  783. return NULL;
  784. }
  785. LLPanel *LLPanel::childGetVisibleTabWithHelp()
  786. {
  787. // find a visible tab with a help topic (to determine help context)
  788. return ::childGetVisibleTabWithHelp(this);
  789. }
  790. static LLPanel *childGetVisiblePanelWithHelp(LLView *parent)
  791. {
  792. LLView *child;
  793. // look through immediate children first for an active panel with help
  794. for (child = parent->getFirstChild(); child; child = parent->findNextSibling(child))
  795. {
  796. // do we have a panel with a help topic?
  797. LLPanel *panel = dynamic_cast<LLPanel *>(child);
  798. if (panel && panel->getVisible() && !panel->getHelpTopic().empty())
  799. {
  800. return panel;
  801. }
  802. }
  803. // then try a bit harder and recurse through all children
  804. for (child = parent->getFirstChild(); child; child = parent->findNextSibling(child))
  805. {
  806. if (child->getVisible())
  807. {
  808. LLPanel* panel = ::childGetVisiblePanelWithHelp(child);
  809. if (panel)
  810. {
  811. return panel;
  812. }
  813. }
  814. }
  815. // couldn't find any active panels with a help topic string
  816. return NULL;
  817. }
  818. LLPanel *LLPanel::childGetVisiblePanelWithHelp()
  819. {
  820. // find a visible tab with a help topic (to determine help context)
  821. return ::childGetVisiblePanelWithHelp(this);
  822. }
  823. void LLPanel::childSetPrevalidate(const std::string& id, bool (*func)(const LLWString &) )
  824. {
  825. LLLineEditor* child = findChild<LLLineEditor>(id);
  826. if (child)
  827. {
  828. child->setPrevalidate(func);
  829. }
  830. }
  831. void LLPanel::childSetAction(const std::string& id, boost::function<void(void*)> function, void* value)
  832. {
  833. LLButton* button = findChild<LLButton>(id);
  834. if (button)
  835. {
  836. button->setClickedCallback(boost::bind(function, value));
  837. }
  838. }
  839. void LLPanel::childSetActionTextbox(const std::string& id, boost::function<void(void*)> function, void* value)
  840. {
  841. LLTextBox* textbox = findChild<LLTextBox>(id);
  842. if (textbox)
  843. {
  844. textbox->setClickedCallback(boost::bind(function, value));
  845. }
  846. }
  847. void LLPanel::childSetControlName(const std::string& id, const std::string& control_name)
  848. {
  849. LLUICtrl* view = findChild<LLUICtrl>(id);
  850. if (view)
  851. {
  852. view->setControlName(control_name, NULL);
  853. }
  854. }
  855. boost::signals2::connection LLPanel::setVisibleCallback( const commit_signal_t::slot_type& cb )
  856. {
  857. if (!mVisibleSignal)
  858. {
  859. mVisibleSignal = new commit_signal_t();
  860. }
  861. return mVisibleSignal->connect(cb);
  862. }