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

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

游戏引擎

开发平台：

C++ Builder

llpanelgroup.cpp：源码内容
  1. /** 
  2.  * @file llpanelgroup.cpp
  3.  *
  4.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2006-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  32. #include "llviewerprecompiledheaders.h"
  34. #include "llpanelgroup.h"
  36. // Library includes
  37. #include "llbutton.h"
  38. #include "lltabcontainer.h"
  39. #include "lltextbox.h"
  40. #include "lluictrlfactory.h"
  42. // Viewer includes
  43. #include "llviewermessage.h"
  44. #include "llviewerwindow.h"
  45. #include "llappviewer.h"
  46. #include "llnotificationsutil.h"
  47. #include "llfloaterreg.h"
  48. #include "llfloater.h"
  49. #include "llgroupactions.h"
  51. #include "llagent.h" 
  53. #include "llsidetraypanelcontainer.h"
  55. #include "llpanelgroupnotices.h"
  56. #include "llpanelgroupgeneral.h"
  58. #include "llsidetray.h"
  59. #include "llaccordionctrltab.h"
  60. #include "llaccordionctrl.h"
  62. static LLRegisterPanelClassWrapper<LLPanelGroup> t_panel_group("panel_group_info_sidetray");
  66. LLPanelGroupTab::LLPanelGroupTab()
  67. : LLPanel(),
  68.   mAllowEdit(TRUE),
  69.   mHasModal(FALSE)
  70. {
  71. mGroupID = LLUUID::null;
  72. }
  74. LLPanelGroupTab::~LLPanelGroupTab()
  75. {
  76. }
  78. BOOL LLPanelGroupTab::isVisibleByAgent(LLAgent* agentp)
  79. {
  80. //default to being visible
  81. return TRUE;
  82. }
  84. BOOL LLPanelGroupTab::postBuild()
  85. {
  86. return TRUE;
  87. }
  89. LLPanelGroup::LLPanelGroup()
  90. : LLPanel(),
  91. LLGroupMgrObserver( LLUUID() ),
  92. mSkipRefresh(FALSE),
  93. mButtonJoin(NULL),
  94. mShowingNotifyDialog(false)
  95. {
  96. // Set up the factory callbacks.
  97. // Roles sub tabs
  98. LLGroupMgr::getInstance()->addObserver(this);
  99. }
  102. LLPanelGroup::~LLPanelGroup()
  103. {
  104. LLGroupMgr::getInstance()->removeObserver(this);
  105. if(LLVoiceClient::getInstance())
  106. LLVoiceClient::getInstance()->removeObserver(this);
  107. }
  109. void LLPanelGroup::onOpen(const LLSD& key)
  110. {
  111. if(!key.has("group_id"))
  112. return;
  114. LLUUID group_id = key["group_id"];
  115. if(!key.has("action"))
  116. {
  117. setGroupID(group_id);
  118. return;
  119. }
  121. std::string str_action = key["action"];
  123. if(str_action == "refresh")
  124. {
  125. if(mID == group_id || group_id == LLUUID::null)
  126. refreshData();
  127. }
  128. else if(str_action == "close")
  129. {
  130. onBackBtnClick();
  131. }
  132. else if(str_action == "create")
  133. {
  134. setGroupID(LLUUID::null);
  135. }
  136. else if(str_action == "refresh_notices")
  137. {
  138. LLPanelGroupNotices* panel_notices = findChild<LLPanelGroupNotices>("group_notices_tab_panel");
  139. if(panel_notices)
  140. panel_notices->refreshNotices();
  141. }
  143. }
  145. BOOL LLPanelGroup::postBuild()
  146. {
  147. mDefaultNeedsApplyMesg = getString("default_needs_apply_text");
  148. mWantApplyMesg = getString("want_apply_text");
  150. LLButton* button;
  152. button = getChild<LLButton>("btn_apply");
  153. button->setClickedCallback(onBtnApply, this);
  154. button->setVisible(true);
  155. button->setEnabled(false);
  157. button = getChild<LLButton>("btn_call");
  158. button->setClickedCallback(onBtnGroupCallClicked, this);
  160. button = getChild<LLButton>("btn_chat");
  161. button->setClickedCallback(onBtnGroupChatClicked, this);
  163. button = getChild<LLButton>("btn_cancel");
  164. button->setVisible(false); button->setEnabled(true);
  166. button = getChild<LLButton>("btn_refresh");
  167. button->setClickedCallback(onBtnRefresh, this);
  169. getChild<LLButton>("btn_create")->setVisible(false);
  171. childSetCommitCallback("back",boost::bind(&LLPanelGroup::onBackBtnClick,this),NULL);
  173. childSetCommitCallback("btn_create",boost::bind(&LLPanelGroup::onBtnCreate,this),NULL);
  175. childSetCommitCallback("btn_cancel",boost::bind(&LLPanelGroup::onBtnCancel,this),NULL);
  177. LLPanelGroupTab* panel_general = findChild<LLPanelGroupTab>("group_general_tab_panel");
  178. LLPanelGroupTab* panel_roles = findChild<LLPanelGroupTab>("group_roles_tab_panel");
  179. LLPanelGroupTab* panel_notices = findChild<LLPanelGroupTab>("group_notices_tab_panel");
  180. LLPanelGroupTab* panel_land = findChild<LLPanelGroupTab>("group_land_tab_panel");
  182. if(panel_general) mTabs.push_back(panel_general);
  183. if(panel_roles) mTabs.push_back(panel_roles);
  184. if(panel_notices) mTabs.push_back(panel_notices);
  185. if(panel_land) mTabs.push_back(panel_land);
  187. if(panel_general)
  188. {
  189. panel_general->setupCtrls(this);
  190. button = panel_general->getChild<LLButton>("btn_join");
  191. button->setVisible(false);
  192. button->setEnabled(true);
  194. mButtonJoin = button;
  195. mButtonJoin->setCommitCallback(boost::bind(&LLPanelGroup::onBtnJoin,this));
  197. mJoinText = panel_general->getChild<LLUICtrl>("join_cost_text");
  198. }
  200. gVoiceClient->addObserver(this);
  202. return TRUE;
  203. }
  205. void LLPanelGroup::reposButton(const std::string& name)
  206. {
  207. LLButton* button = findChild<LLButton>(name);
  208. if(!button)
  209. return;
  210. LLRect btn_rect = button->getRect();
  211. btn_rect.setLeftTopAndSize( btn_rect.mLeft, btn_rect.getHeight() + 2, btn_rect.getWidth(), btn_rect.getHeight());
  212. button->setRect(btn_rect);
  213. }
  215. void LLPanelGroup::reposButtons()
  216. {
  217. LLButton* button_refresh = findChild<LLButton>("btn_refresh");
  218. LLButton* button_cancel = findChild<LLButton>("btn_cancel");
  220. if(button_refresh && button_cancel && button_refresh->getVisible() && button_cancel->getVisible())
  221. {
  222. LLRect btn_refresh_rect = button_refresh->getRect();
  223. LLRect btn_cancel_rect = button_cancel->getRect();
  224. btn_refresh_rect.setLeftTopAndSize( btn_cancel_rect.mLeft + btn_cancel_rect.getWidth() + 2, 
  225. btn_refresh_rect.getHeight() + 2, btn_refresh_rect.getWidth(), btn_refresh_rect.getHeight());
  226. button_refresh->setRect(btn_refresh_rect);
  227. }
  229. reposButton("btn_apply");
  230. reposButton("btn_create");
  231. reposButton("btn_refresh");
  232. reposButton("btn_cancel");
  233. reposButton("btn_chat");
  234. reposButton("btn_call");
  235. }
  237. void LLPanelGroup::reshape(S32 width, S32 height, BOOL called_from_parent )
  238. {
  239. LLPanel::reshape(width, height, called_from_parent );
  241. reposButtons();
  242. }
  244. void LLPanelGroup::onBackBtnClick()
  245. {
  246. LLSideTrayPanelContainer* parent = dynamic_cast<LLSideTrayPanelContainer*>(getParent());
  247. if(parent)
  248. {
  249. parent->openPreviousPanel();
  250. }
  251. }
  254. void LLPanelGroup::onBtnCreate()
  255. {
  256. LLPanelGroupGeneral* panel_general = findChild<LLPanelGroupGeneral>("group_general_tab_panel");
  257. if(!panel_general)
  258. return;
  259. std::string apply_mesg;
  260. if(panel_general->apply(apply_mesg))//yes yes you need to call apply to create...
  261. return;
  262. if ( !apply_mesg.empty() )
  263. {
  264. LLSD args;
  265. args["MESSAGE"] = apply_mesg;
  266. LLNotificationsUtil::add("GenericAlert", args);
  267. }
  268. }
  270. void LLPanelGroup::onBtnRefresh(void* user_data)
  271. {
  272. LLPanelGroup* self = static_cast<LLPanelGroup*>(user_data);
  273. self->refreshData();
  274. }
  276. void LLPanelGroup::onBtnApply(void* user_data)
  277. {
  278. LLPanelGroup* self = static_cast<LLPanelGroup*>(user_data);
  279. self->apply();
  280. }
  282. void LLPanelGroup::onBtnGroupCallClicked(void* user_data)
  283. {
  284. LLPanelGroup* self = static_cast<LLPanelGroup*>(user_data);
  285. self->callGroup();
  286. }
  288. void LLPanelGroup::onBtnGroupChatClicked(void* user_data)
  289. {
  290. LLPanelGroup* self = static_cast<LLPanelGroup*>(user_data);
  291. self->chatGroup();
  292. }
  294. void LLPanelGroup::onBtnJoin()
  295. {
  296. lldebugs << "joining group: " << mID << llendl;
  297. LLGroupActions::join(mID);
  298. }
  300. void LLPanelGroup::onBtnCancel()
  301. {
  302. onBackBtnClick();
  303. }
  306. void LLPanelGroup::changed(LLGroupChange gc)
  307. {
  308. for(std::vector<LLPanelGroupTab* >::iterator it = mTabs.begin();it!=mTabs.end();++it)
  309. (*it)->update(gc);
  310. update(gc);
  311. }
  313. // virtual
  314. void LLPanelGroup::onChange(EStatusType status, const std::string &channelURI, bool proximal)
  315. {
  316. if(status == STATUS_JOINING || status == STATUS_LEFT_CHANNEL)
  317. {
  318. return;
  319. }
  321. childSetEnabled("btn_call", LLVoiceClient::voiceEnabled() && gVoiceClient->voiceWorking());
  322. }
  324. void LLPanelGroup::notifyObservers()
  325. {
  326. changed(GC_ALL);
  327. }
  329. void LLPanelGroup::update(LLGroupChange gc)
  330. {
  331. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mID);
  332. if(gdatap)
  333. {
  334. childSetValue("group_name", gdatap->mName);
  335. childSetToolTip("group_name",gdatap->mName);
  337. LLGroupData agent_gdatap;
  338. bool is_member = gAgent.getGroupData(mID,agent_gdatap);
  339. bool join_btn_visible = !is_member && gdatap->mOpenEnrollment;
  341. mButtonJoin->setVisible(join_btn_visible);
  342. mJoinText->setVisible(join_btn_visible);
  344. if(join_btn_visible)
  345. {
  346. LLStringUtil::format_map_t string_args;
  347. std::string fee_buff;
  348. if(gdatap->mMembershipFee)
  349. {
  350. string_args["[AMOUNT]"] = llformat("%d", gdatap->mMembershipFee);
  351. fee_buff = getString("group_join_btn", string_args);
  353. }
  354. else
  355. {
  356. fee_buff = getString("group_join_free", string_args);
  357. }
  358. mJoinText->setValue(fee_buff);
  359. }
  360. }
  361. }
  363. void LLPanelGroup::setGroupID(const LLUUID& group_id)
  364. {
  365. std::string str_group_id;
  366. group_id.toString(str_group_id);
  368. bool is_same_id = group_id == mID;
  370. LLGroupMgr::getInstance()->removeObserver(this);
  371. mID = group_id;
  372. LLGroupMgr::getInstance()->addObserver(this);
  374. for(std::vector<LLPanelGroupTab* >::iterator it = mTabs.begin();it!=mTabs.end();++it)
  375. (*it)->setGroupID(group_id);
  377. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mID);
  378. if(gdatap)
  379. {
  380. childSetValue("group_name", gdatap->mName);
  381. childSetToolTip("group_name",gdatap->mName);
  382. }
  384. LLButton* button_apply = findChild<LLButton>("btn_apply");
  385. LLButton* button_refresh = findChild<LLButton>("btn_refresh");
  386. LLButton* button_create = findChild<LLButton>("btn_create");
  388. LLButton* button_cancel = findChild<LLButton>("btn_cancel");
  389. LLButton* button_call = findChild<LLButton>("btn_call");
  390. LLButton* button_chat = findChild<LLButton>("btn_chat");
  393. bool is_null_group_id = group_id == LLUUID::null;
  394. if(button_apply)
  395. button_apply->setVisible(!is_null_group_id);
  396. if(button_refresh)
  397. button_refresh->setVisible(!is_null_group_id);
  399. if(button_create)
  400. button_create->setVisible(is_null_group_id);
  401. if(button_cancel)
  402. button_cancel->setVisible(!is_null_group_id);
  404. if(button_call)
  405. button_call->setVisible(!is_null_group_id);
  406. if(button_chat)
  407. button_chat->setVisible(!is_null_group_id);
  409. getChild<LLUICtrl>("prepend_founded_by")->setVisible(!is_null_group_id);
  411. LLAccordionCtrl* tab_ctrl = findChild<LLAccordionCtrl>("group_accordion");
  412. if(tab_ctrl)
  413. tab_ctrl->reset();
  415. LLAccordionCtrlTab* tab_general = findChild<LLAccordionCtrlTab>("group_general_tab");
  416. LLAccordionCtrlTab* tab_roles = findChild<LLAccordionCtrlTab>("group_roles_tab");
  417. LLAccordionCtrlTab* tab_notices = findChild<LLAccordionCtrlTab>("group_notices_tab");
  418. LLAccordionCtrlTab* tab_land = findChild<LLAccordionCtrlTab>("group_land_tab");
  421. if(!tab_general || !tab_roles || !tab_notices || !tab_land)
  422. return;
  424. if(mButtonJoin)
  425. mButtonJoin->setVisible(false);
  428. if(is_null_group_id)//creating new group
  429. {
  430. if(!tab_general->getDisplayChildren())
  431. tab_general->changeOpenClose(tab_general->getDisplayChildren());
  433. if(tab_roles->getDisplayChildren())
  434. tab_roles->changeOpenClose(tab_roles->getDisplayChildren());
  435. if(tab_notices->getDisplayChildren())
  436. tab_notices->changeOpenClose(tab_notices->getDisplayChildren());
  437. if(tab_land->getDisplayChildren())
  438. tab_land->changeOpenClose(tab_land->getDisplayChildren());
  440. tab_roles->setVisible(false);
  441. tab_notices->setVisible(false);
  442. tab_land->setVisible(false);
  444. getChild<LLUICtrl>("group_name")->setVisible(false);
  445. getChild<LLUICtrl>("group_name_editor")->setVisible(true);
  447. if(button_call)
  448. button_call->setVisible(false);
  449. if(button_chat)
  450. button_chat->setVisible(false);
  451. }
  452. else 
  453. {
  454. if(!is_same_id)
  455. {
  456. if(!tab_general->getDisplayChildren())
  457. tab_general->changeOpenClose(tab_general->getDisplayChildren());
  458. if(tab_roles->getDisplayChildren())
  459. tab_roles->changeOpenClose(tab_roles->getDisplayChildren());
  460. if(tab_notices->getDisplayChildren())
  461. tab_notices->changeOpenClose(tab_notices->getDisplayChildren());
  462. if(tab_land->getDisplayChildren())
  463. tab_land->changeOpenClose(tab_land->getDisplayChildren());
  464. }
  466. LLGroupData agent_gdatap;
  467. bool is_member = gAgent.getGroupData(mID,agent_gdatap);
  469. tab_roles->setVisible(is_member);
  470. tab_notices->setVisible(is_member);
  471. tab_land->setVisible(is_member);
  473. getChild<LLUICtrl>("group_name")->setVisible(true);
  474. getChild<LLUICtrl>("group_name_editor")->setVisible(false);
  476. if(button_apply)
  477. button_apply->setVisible(is_member);
  478. if(button_call)
  479. button_call->setVisible(is_member);
  480. if(button_chat)
  481. button_chat->setVisible(is_member);
  482. }
  484. reposButtons();
  485. update(GC_ALL);//show/hide "join" button if data is already ready
  486. }
  488. bool LLPanelGroup::apply(LLPanelGroupTab* tab)
  489. {
  490. if(!tab)
  491. return false;
  493. std::string mesg;
  494. if ( !tab->needsApply(mesg) )
  495. return true;
  497. std::string apply_mesg;
  498. if(tab->apply( apply_mesg ) )
  499. {
  500. //we skip refreshing group after ew manually apply changes since its very annoying
  501. //for those who are editing group
  502. mSkipRefresh = TRUE;
  503. return true;
  504. }
  506. if ( !apply_mesg.empty() )
  507. {
  508. LLSD args;
  509. args["MESSAGE"] = apply_mesg;
  510. LLNotificationsUtil::add("GenericAlert", args);
  511. }
  512. return false;
  513. }
  515. bool LLPanelGroup::apply()
  516. {
  517. return apply(findChild<LLPanelGroupTab>("group_general_tab_panel")) 
  518. && apply(findChild<LLPanelGroupTab>("group_roles_tab_panel"))
  519. && apply(findChild<LLPanelGroupTab>("group_notices_tab_panel"))
  520. && apply(findChild<LLPanelGroupTab>("group_land_tab_panel"))
  521. ;
  522. }
  525. // virtual
  526. void LLPanelGroup::draw()
  527. {
  528. LLPanel::draw();
  530. if (mRefreshTimer.hasExpired())
  531. {
  532. mRefreshTimer.stop();
  533. childEnable("btn_refresh");
  534. }
  536. LLButton* button_apply = findChild<LLButton>("btn_apply");
  538. if(button_apply && button_apply->getVisible())
  539. {
  540. bool enable = false;
  541. std::string mesg;
  542. for(std::vector<LLPanelGroupTab* >::iterator it = mTabs.begin();it!=mTabs.end();++it)
  543. enable = enable || (*it)->needsApply(mesg);
  545. childSetEnabled("btn_apply", enable);
  546. }
  547. }
  549. void LLPanelGroup::refreshData()
  550. {
  551. if(mSkipRefresh)
  552. {
  553. mSkipRefresh = FALSE;
  554. return;
  555. }
  556. LLGroupMgr::getInstance()->clearGroupData(getID());
  558. setGroupID(getID());
  560. // 5 second timeout
  561. childDisable("btn_refresh");
  562. mRefreshTimer.start();
  563. mRefreshTimer.setTimerExpirySec(5);
  564. }
  566. void LLPanelGroup::callGroup()
  567. {
  568. LLGroupActions::startCall(getID());
  569. }
  571. void LLPanelGroup::chatGroup()
  572. {
  573. LLGroupActions::startIM(getID());
  574. }
  576. void LLPanelGroup::showNotice(const std::string& subject,
  577.       const std::string& message,
  578.       const bool& has_inventory,
  579.       const std::string& inventory_name,
  580.       LLOfferInfo* inventory_offer)
  581. {
  582. LLPanelGroupNotices* panel_notices = findChild<LLPanelGroupNotices>("group_notices_tab_panel");
  583. if(!panel_notices)
  584. {
  585. // We need to clean up that inventory offer.
  586. if (inventory_offer)
  587. {
  588. inventory_offer->forceResponse(IOR_DECLINE);
  589. }
  590. return;
  591. }
  592. panel_notices->showNotice(subject,message,has_inventory,inventory_name,inventory_offer);
  593. }
  598. //static
  599. void LLPanelGroup::refreshCreatedGroup(const LLUUID& group_id)
  600. {
  601. LLPanelGroup* panel = LLSideTray::getInstance()->findChild<LLPanelGroup>("panel_group_info_sidetray");
  602. if(!panel)
  603. return;
  604. panel->setGroupID(group_id);
  605. }
  607. //static
  609. void LLPanelGroup::showNotice(const std::string& subject,
  610.    const std::string& message,
  611.    const LLUUID& group_id,
  612.    const bool& has_inventory,
  613.    const std::string& inventory_name,
  614.    LLOfferInfo* inventory_offer)
  615. {
  616. LLPanelGroup* panel = LLSideTray::getInstance()->findChild<LLPanelGroup>("panel_group_info_sidetray");
  617. if(!panel)
  618. return;
  620. if(panel->getID() != group_id)//???? only for current group_id or switch panels? FIXME
  621. return;
  622. panel->showNotice(subject,message,has_inventory,inventory_name,inventory_offer);
  624. }
  626. bool LLPanelGroup::canClose()
  627. {
  628. if(getVisible() == false)
  629. return true;
  631. bool need_save = false;
  632. std::string mesg;
  633. for(std::vector<LLPanelGroupTab* >::iterator it = mTabs.begin();it!=mTabs.end();++it)
  634. if(need_save|=(*it)->needsApply(mesg))
  635. break;
  636. if(!need_save)
  637. return false;
  638. // If no message was provided, give a generic one.
  639. if (mesg.empty())
  640. {
  641. mesg = mDefaultNeedsApplyMesg;
  642. }
  643. // Create a notify box, telling the user about the unapplied tab.
  644. LLSD args;
  645. args["NEEDS_APPLY_MESSAGE"] = mesg;
  646. args["WANT_APPLY_MESSAGE"] = mWantApplyMesg;
  648. LLNotificationsUtil::add("SaveChanges", args, LLSD(), boost::bind(&LLPanelGroup::handleNotifyCallback,this, _1, _2));
  650. mShowingNotifyDialog = true;
  652. return false;
  653. }
  655. bool LLPanelGroup::notifyChildren(const LLSD& info)
  656. {
  657. if(info.has("request") && mID.isNull() )
  658. {
  659. std::string str_action = info["request"];
  661. if (str_action == "quit" )
  662. {
  663. canClose();
  664. return true;
  665. }
  666. if(str_action == "wait_quit")
  667. return mShowingNotifyDialog;
  668. }
  669. return false;
  670. }
  671. bool LLPanelGroup::handleNotifyCallback(const LLSD& notification, const LLSD& response)
  672. {
  673. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  674. mShowingNotifyDialog = false;
  675. switch (option)
  676. {
  677. case 0: // "Apply Changes"
  678. apply();
  679. break;
  680. case 1: // "Ignore Changes"
  681. break;
  682. case 2: // "Cancel"
  683. default:
  684. // Do nothing.  The user is canceling the action.
  685. // If we were quitting, we didn't really mean it.
  686. LLAppViewer::instance()->abortQuit();
  687. break;
  688. }
  689. return false;
  690. }