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

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

游戏引擎

开发平台：

C++ Builder

llchiclet.cpp：源码内容
  1. /** 
  2.  * @file llchiclet.cpp
  3.  * @brief LLChiclet class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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" // must be first include
  34. #include "llchiclet.h"
  36. #include "llagent.h"
  37. #include "llavataractions.h"
  38. #include "llbottomtray.h"
  39. #include "lleventtimer.h"
  40. #include "llgroupactions.h"
  41. #include "lliconctrl.h"
  42. #include "llimfloater.h"
  43. #include "llimview.h"
  44. #include "llfloaterreg.h"
  45. #include "lllocalcliprect.h"
  46. #include "llmenugl.h"
  47. #include "llnotifications.h"
  48. #include "llnotificationsutil.h"
  49. #include "lloutputmonitorctrl.h"
  50. #include "llscriptfloater.h"
  51. #include "llspeakers.h"
  52. #include "lltextbox.h"
  53. #include "llvoiceclient.h"
  54. #include "llgroupmgr.h"
  55. #include "llnotificationmanager.h"
  56. #include "lltransientfloatermgr.h"
  57. #include "llsyswellwindow.h"
  59. static LLDefaultChildRegistry::Register<LLChicletPanel> t1("chiclet_panel");
  60. static LLDefaultChildRegistry::Register<LLIMWellChiclet> t2_0("chiclet_im_well");
  61. static LLDefaultChildRegistry::Register<LLNotificationChiclet> t2("chiclet_notification");
  62. static LLDefaultChildRegistry::Register<LLIMP2PChiclet> t3("chiclet_im_p2p");
  63. static LLDefaultChildRegistry::Register<LLIMGroupChiclet> t4("chiclet_im_group");
  64. static LLDefaultChildRegistry::Register<LLAdHocChiclet> t5("chiclet_im_adhoc");
  65. static LLDefaultChildRegistry::Register<LLScriptChiclet> t6("chiclet_script");
  66. static LLDefaultChildRegistry::Register<LLInvOfferChiclet> t7("chiclet_offer");
  68. boost::signals2::signal<LLChiclet* (const LLUUID&),
  69. LLIMChiclet::CollectChicletCombiner<std::list<LLChiclet*> > >
  70. LLIMChiclet::sFindChicletsSignal;
  71. //////////////////////////////////////////////////////////////////////////
  72. //////////////////////////////////////////////////////////////////////////
  73. //////////////////////////////////////////////////////////////////////////
  75. /**
  76.  * Updates the Well's 'Lit' state to flash it when "new messages" are come.
  77.  *
  78.  * It gets callback which will be called 2*N times with passed period. See EXT-3147
  79.  */
  80. class LLSysWellChiclet::FlashToLitTimer : public LLEventTimer
  81. {
  82. public:
  83. typedef boost::function<void()> callback_t;
  85. /**
  86.  * Constructor.
  87.  *
  88.  * @param count - how many times callback should be called (twice to not change original state)
  89.  * @param period - how frequently callback should be called
  90.  * @param cb - callback to be called each tick
  91.  */
  92. FlashToLitTimer(S32 count, F32 period, callback_t cb)
  93. : LLEventTimer(period)
  94. , mCallback(cb)
  95. , mFlashCount(2 * count)
  96. , mCurrentFlashCount(0)
  97. {
  98. mEventTimer.stop();
  99. }
  101. BOOL tick()
  102. {
  103. mCallback();
  105. if (++mCurrentFlashCount == mFlashCount) mEventTimer.stop();
  106. return FALSE;
  107. }
  109. void flash()
  110. {
  111. mCurrentFlashCount = 0;
  112. mEventTimer.start();
  113. }
  115. void stopFlashing()
  116. {
  117. mEventTimer.stop();
  118. }
  120. private:
  121. callback_t mCallback;
  123. /**
  124.  * How many times Well will blink.
  125.  */
  126. S32 mFlashCount;
  127. S32 mCurrentFlashCount;
  128. };
  130. LLSysWellChiclet::Params::Params()
  131. : button("button")
  132. , unread_notifications("unread_notifications")
  133. , max_displayed_count("max_displayed_count", 99)
  134. , flash_to_lit_count("flash_to_lit_count", 3)
  135. , flash_period("flash_period", 0.5F)
  136. {
  137. button.name("button");
  138. button.tab_stop(FALSE);
  139. button.label(LLStringUtil::null);
  140. }
  142. LLSysWellChiclet::LLSysWellChiclet(const Params& p)
  143. : LLChiclet(p)
  144. , mButton(NULL)
  145. , mCounter(0)
  146. , mMaxDisplayedCount(p.max_displayed_count)
  147. , mIsNewMessagesState(false)
  148. , mFlashToLitTimer(NULL)
  149. , mContextMenu(NULL)
  150. {
  151. LLButton::Params button_params = p.button;
  152. mButton = LLUICtrlFactory::create<LLButton>(button_params);
  153. addChild(mButton);
  155. mFlashToLitTimer = new FlashToLitTimer(p.flash_to_lit_count, p.flash_period, boost::bind(&LLSysWellChiclet::changeLitState, this));
  156. }
  158. LLSysWellChiclet::~LLSysWellChiclet()
  159. {
  160. delete mFlashToLitTimer;
  161. }
  163. void LLSysWellChiclet::setCounter(S32 counter)
  164. {
  165. // do nothing if the same counter is coming. EXT-3678.
  166. if (counter == mCounter) return;
  168. // note same code in LLChicletNotificationCounterCtrl::setCounter(S32 counter)
  169. std::string s_count;
  170. if(counter != 0)
  171. {
  172. static std::string more_messages_exist("+");
  173. std::string more_messages(counter > mMaxDisplayedCount ? more_messages_exist : "");
  174. s_count = llformat("%d%s"
  175. , llmin(counter, mMaxDisplayedCount)
  176. , more_messages.c_str()
  177. );
  178. }
  180. mButton->setLabel(s_count);
  182. setNewMessagesState(counter > mCounter);
  184. // we have to flash to 'Lit' state each time new unread message is coming.
  185. if (counter > mCounter)
  186. {
  187. mFlashToLitTimer->flash();
  188. }
  189. else if (counter == 0)
  190. {
  191. // if notification is resolved while well is flashing it can leave in the 'Lit' state
  192. // when flashing finishes itself. Let break flashing here.
  193. mFlashToLitTimer->stopFlashing();
  194. }
  196. mCounter = counter;
  197. }
  199. boost::signals2::connection LLSysWellChiclet::setClickCallback(
  200. const commit_callback_t& cb)
  201. {
  202. return mButton->setClickedCallback(cb);
  203. }
  205. void LLSysWellChiclet::setToggleState(BOOL toggled) {
  206. mButton->setToggleState(toggled);
  207. }
  209. void LLSysWellChiclet::changeLitState()
  210. {
  211. setNewMessagesState(!mIsNewMessagesState);
  212. }
  214. void LLSysWellChiclet::setNewMessagesState(bool new_messages)
  215. {
  216. /*
  217. Emulate 4 states of button by background images, see detains in EXT-3147
  218. xml attribute           Description
  219. image_unselected        "Unlit" - there are no new messages
  220. image_selected          "Unlit" + "Selected" - there are no new messages and the Well is open
  221. image_pressed           "Lit" - there are new messages
  222. image_pressed_selected  "Lit" + "Selected" - there are new messages and the Well is open
  223. */
  224. mButton->setForcePressedState(new_messages);
  226. mIsNewMessagesState = new_messages;
  227. }
  229. void LLSysWellChiclet::updateWidget(bool is_window_empty)
  230. {
  231. mButton->setEnabled(!is_window_empty);
  232. }
  233. // virtual
  234. BOOL LLSysWellChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
  235. {
  236. if(!mContextMenu)
  237. {
  238. createMenu();
  239. }
  240. if (mContextMenu)
  241. {
  242. mContextMenu->show(x, y);
  243. LLMenuGL::showPopup(this, mContextMenu, x, y);
  244. }
  245. return TRUE;
  246. }
  248. /************************************************************************/
  249. /*               LLIMWellChiclet implementation                         */
  250. /************************************************************************/
  251. LLIMWellChiclet::LLIMWellChiclet(const Params& p)
  252. : LLSysWellChiclet(p)
  253. {
  254. LLIMModel::instance().addNewMsgCallback(boost::bind(&LLIMWellChiclet::messageCountChanged, this, _1));
  255. LLIMModel::instance().addNoUnreadMsgsCallback(boost::bind(&LLIMWellChiclet::messageCountChanged, this, _1));
  257. LLIMMgr::getInstance()->addSessionObserver(this);
  259. LLIMWellWindow::getInstance()->setSysWellChiclet(this);
  260. }
  262. LLIMWellChiclet::~LLIMWellChiclet()
  263. {
  264. LLIMMgr::getInstance()->removeSessionObserver(this);
  265. }
  267. void LLIMWellChiclet::onMenuItemClicked(const LLSD& user_data)
  268. {
  269. std::string action = user_data.asString();
  270. if("close all" == action)
  271. {
  272. LLIMWellWindow::getInstance()->closeAll();
  273. }
  274. }
  276. bool LLIMWellChiclet::enableMenuItem(const LLSD& user_data)
  277. {
  278. std::string item = user_data.asString();
  279. if (item == "can close all")
  280. {
  281. return !LLIMWellWindow::getInstance()->isWindowEmpty();
  282. }
  283. return true;
  284. }
  286. void LLIMWellChiclet::createMenu()
  287. {
  288. if(mContextMenu)
  289. {
  290. llwarns << "Menu already exists" << llendl;
  291. return;
  292. }
  294. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  295. registrar.add("IMWellChicletMenu.Action",
  296. boost::bind(&LLIMWellChiclet::onMenuItemClicked, this, _2));
  298. LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
  299. enable_registrar.add("IMWellChicletMenu.EnableItem",
  300. boost::bind(&LLIMWellChiclet::enableMenuItem, this, _2));
  302. mContextMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>
  303. ("menu_im_well_button.xml",
  304.  LLMenuGL::sMenuContainer,
  305.  LLViewerMenuHolderGL::child_registry_t::instance());
  306. }
  308. void LLIMWellChiclet::messageCountChanged(const LLSD& session_data)
  309. {
  310. setCounter(LLBottomTray::getInstance()->getTotalUnreadIMCount());
  311. }
  313. /************************************************************************/
  314. /*               LLNotificationChiclet implementation                   */
  315. /************************************************************************/
  316. LLNotificationChiclet::LLNotificationChiclet(const Params& p)
  317. : LLSysWellChiclet(p)
  318. , mUreadSystemNotifications(0)
  319. {
  320. // connect counter handlers to the signals
  321. connectCounterUpdatersToSignal("notify");
  322. connectCounterUpdatersToSignal("groupnotify");
  323. connectCounterUpdatersToSignal("offer");
  325. // ensure that notification well window exists, to synchronously
  326. // handle toast add/delete events.
  327. LLNotificationWellWindow::getInstance()->setSysWellChiclet(this);
  328. }
  330. void LLNotificationChiclet::connectCounterUpdatersToSignal(const std::string& notification_type)
  331. {
  332. LLNotificationsUI::LLNotificationManager* manager = LLNotificationsUI::LLNotificationManager::getInstance();
  333. LLNotificationsUI::LLEventHandler* n_handler = manager->getHandlerForNotification(notification_type);
  334. if(n_handler)
  335. {
  336. n_handler->setNewNotificationCallback(boost::bind(&LLNotificationChiclet::incUreadSystemNotifications, this));
  337. n_handler->setDelNotification(boost::bind(&LLNotificationChiclet::decUreadSystemNotifications, this));
  338. }
  339. }
  341. void LLNotificationChiclet::onMenuItemClicked(const LLSD& user_data)
  342. {
  343. std::string action = user_data.asString();
  344. if("close all" == action)
  345. {
  346. LLNotificationWellWindow::getInstance()->closeAll();
  347. }
  348. }
  350. bool LLNotificationChiclet::enableMenuItem(const LLSD& user_data)
  351. {
  352. std::string item = user_data.asString();
  353. if (item == "can close all")
  354. {
  355. return mUreadSystemNotifications != 0;
  356. }
  357. return true;
  358. }
  360. void LLNotificationChiclet::createMenu()
  361. {
  362. if(mContextMenu)
  363. {
  364. llwarns << "Menu already exists" << llendl;
  365. return;
  366. }
  368. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  369. registrar.add("NotificationWellChicletMenu.Action",
  370. boost::bind(&LLNotificationChiclet::onMenuItemClicked, this, _2));
  372. LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
  373. enable_registrar.add("NotificationWellChicletMenu.EnableItem",
  374. boost::bind(&LLNotificationChiclet::enableMenuItem, this, _2));
  376. mContextMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>
  377. ("menu_notification_well_button.xml",
  378.  LLMenuGL::sMenuContainer,
  379.  LLViewerMenuHolderGL::child_registry_t::instance());
  380. }
  382. /*virtual*/
  383. void LLNotificationChiclet::setCounter(S32 counter)
  384. {
  385. LLSysWellChiclet::setCounter(counter);
  386. updateWidget(getCounter() == 0);
  388. }
  389. //////////////////////////////////////////////////////////////////////////
  390. //////////////////////////////////////////////////////////////////////////
  391. //////////////////////////////////////////////////////////////////////////
  393. LLChiclet::Params::Params()
  394.  : show_counter("show_counter", true)
  395.  , enable_counter("enable_counter", false)
  396. {
  397. }
  399. LLChiclet::LLChiclet(const Params& p)
  400. : LLUICtrl(p)
  401. , mSessionId(LLUUID::null)
  402. , mShowCounter(p.show_counter)
  403. {
  405. }
  407. LLChiclet::~LLChiclet()
  408. {
  410. }
  412. boost::signals2::connection LLChiclet::setLeftButtonClickCallback(
  413. const commit_callback_t& cb)
  414. {
  415. return setCommitCallback(cb);
  416. }
  418. BOOL LLChiclet::handleMouseDown(S32 x, S32 y, MASK mask)
  419. {
  420. onCommit();
  421. childrenHandleMouseDown(x,y,mask);
  422. return TRUE;
  423. }
  425. boost::signals2::connection LLChiclet::setChicletSizeChangedCallback(
  426. const chiclet_size_changed_callback_t& cb)
  427. {
  428. return mChicletSizeChangedSignal.connect(cb);
  429. }
  431. void LLChiclet::onChicletSizeChanged()
  432. {
  433. mChicletSizeChangedSignal(this, getValue());
  434. }
  436. LLSD LLChiclet::getValue() const
  437. {
  438. return LLSD(getSessionId());
  439. }
  441. void LLChiclet::setValue(const LLSD& value)
  442. {
  443. if(value.isUUID())
  444. setSessionId(value.asUUID());
  445. }
  447. //////////////////////////////////////////////////////////////////////////
  448. //////////////////////////////////////////////////////////////////////////
  449. //////////////////////////////////////////////////////////////////////////
  451. LLIMChiclet::LLIMChiclet(const LLIMChiclet::Params& p)
  452. : LLChiclet(p)
  453. , mShowSpeaker(false)
  454. , mDefaultWidth(p.rect().getWidth())
  455. , mNewMessagesIcon(NULL)
  456. , mSpeakerCtrl(NULL)
  457. , mCounterCtrl(NULL)
  458. , mChicletButton(NULL)
  459. {
  460. enableCounterControl(p.enable_counter);
  461. }
  463. /* virtual*/
  464. BOOL LLIMChiclet::postBuild()
  465. {
  466. mChicletButton = getChild<LLButton>("chiclet_button");
  467. mChicletButton->setCommitCallback(boost::bind(&LLIMChiclet::onMouseDown, this));
  468. mChicletButton->setDoubleClickCallback(boost::bind(&LLIMChiclet::onMouseDown, this));
  469. return TRUE;
  470. }
  471. void LLIMChiclet::setShowSpeaker(bool show)
  472. {
  473. bool needs_resize = getShowSpeaker() != show;
  474. if(needs_resize)
  475. {
  476. mShowSpeaker = show;
  477. toggleSpeakerControl();
  478. }
  479. }
  481. void LLIMChiclet::enableCounterControl(bool enable) 
  482. {
  483. mCounterEnabled = enable;
  484. if(!enable)
  485. {
  486. LLChiclet::setShowCounter(false);
  487. }
  488. }
  490. void LLIMChiclet::setShowCounter(bool show)
  491. {
  492. if(!mCounterEnabled)
  493. {
  494. return;
  495. }
  497. bool needs_resize = getShowCounter() != show;
  498. if(needs_resize)
  499. {
  500. LLChiclet::setShowCounter(show);
  501. toggleCounterControl();
  502. }
  503. }
  505. void LLIMChiclet::initSpeakerControl()
  506. {
  507. // virtual
  508. }
  510. void LLIMChiclet::setRequiredWidth()
  511. {
  512. bool show_speaker = getShowSpeaker();
  513. bool show_counter = getShowCounter();
  514. S32 required_width = mDefaultWidth;
  516. if (show_counter)
  517. {
  518. required_width += mCounterCtrl->getRect().getWidth();
  519. }
  520. if (show_speaker)
  521. {
  522. required_width += mSpeakerCtrl->getRect().getWidth();
  523. } 
  525. reshape(required_width, getRect().getHeight());
  527. onChicletSizeChanged();
  528. }
  530. void LLIMChiclet::toggleSpeakerControl()
  531. {
  532. if(getShowSpeaker())
  533. {
  534. // move speaker to the right of chiclet icon
  535. LLRect speaker_rc = mSpeakerCtrl->getRect();
  536. speaker_rc.setLeftTopAndSize(mDefaultWidth, speaker_rc.mTop, speaker_rc.getWidth(), speaker_rc.getHeight());
  537. mSpeakerCtrl->setRect(speaker_rc);
  539. if(getShowCounter())
  540. {
  541. // move speaker to the right of counter
  542. mSpeakerCtrl->translate(mCounterCtrl->getRect().getWidth(), 0);
  543. }
  545. initSpeakerControl();
  546. }
  548. setRequiredWidth();
  549. mSpeakerCtrl->setSpeakerId(LLUUID::null);
  550. mSpeakerCtrl->setVisible(getShowSpeaker());
  551. }
  553. void LLIMChiclet::setCounter(S32 counter)
  554. {
  555. if (mCounterCtrl->getCounter() == counter)
  556. {
  557. return;
  558. }
  560. mCounterCtrl->setCounter(counter);
  561. setShowCounter(counter);
  562. setShowNewMessagesIcon(counter);
  563. }
  565. void LLIMChiclet::toggleCounterControl()
  566. {
  567. setRequiredWidth();
  568. mCounterCtrl->setVisible(getShowCounter());
  569. }
  571. void LLIMChiclet::setShowNewMessagesIcon(bool show)
  572. {
  573. if(mNewMessagesIcon)
  574. {
  575. mNewMessagesIcon->setVisible(show);
  576. }
  577. setRequiredWidth();
  578. }
  580. bool LLIMChiclet::getShowNewMessagesIcon()
  581. {
  582. return mNewMessagesIcon->getVisible();
  583. }
  585. void LLIMChiclet::onMouseDown()
  586. {
  587. LLIMFloater::toggle(getSessionId());
  588. setCounter(0);
  589. }
  591. void LLIMChiclet::setToggleState(bool toggle)
  592. {
  593. mChicletButton->setToggleState(toggle);
  594. }
  596. void LLIMChiclet::draw()
  597. {
  598. LLUICtrl::draw();
  599. }
  601. // static
  602. LLIMChiclet::EType LLIMChiclet::getIMSessionType(const LLUUID& session_id)
  603. {
  604. EType type = TYPE_UNKNOWN;
  606. if(session_id.isNull())
  607. return type;
  609. EInstantMessage im_type = LLIMModel::getInstance()->getType(session_id);
  610. if (IM_COUNT == im_type)
  611. {
  612. llassert_always(0 && "IM session not found"); // should never happen
  613. return type;
  614. }
  616. switch(im_type)
  617. {
  618. case IM_NOTHING_SPECIAL:
  619. case IM_SESSION_P2P_INVITE:
  620. type = TYPE_IM;
  621. break;
  622. case IM_SESSION_GROUP_START:
  623. case IM_SESSION_INVITE:
  624. if (gAgent.isInGroup(session_id))
  625. {
  626. type = TYPE_GROUP;
  627. }
  628. else
  629. {
  630. type = TYPE_AD_HOC;
  631. }
  632. break;
  633. case IM_SESSION_CONFERENCE_START:
  634. type = TYPE_AD_HOC;
  635. default:
  636. break;
  637. }
  639. return type;
  640. }
  642. //////////////////////////////////////////////////////////////////////////
  643. //////////////////////////////////////////////////////////////////////////
  644. //////////////////////////////////////////////////////////////////////////
  646. LLIMP2PChiclet::Params::Params()
  647. : avatar_icon("avatar_icon")
  648. , chiclet_button("chiclet_button")
  649. , unread_notifications("unread_notifications")
  650. , speaker("speaker")
  651. , new_message_icon("new_message_icon")
  652. , show_speaker("show_speaker")
  653. {
  654. }
  656. LLIMP2PChiclet::LLIMP2PChiclet(const Params& p)
  657. : LLIMChiclet(p)
  658. , mChicletIconCtrl(NULL)
  659. , mPopupMenu(NULL)
  660. {
  661. LLButton::Params button_params = p.chiclet_button;
  662. mChicletButton = LLUICtrlFactory::create<LLButton>(button_params);
  663. addChild(mChicletButton);
  665. LLIconCtrl::Params new_msg_params = p.new_message_icon;
  666. mNewMessagesIcon = LLUICtrlFactory::create<LLIconCtrl>(new_msg_params);
  667. addChild(mNewMessagesIcon);
  669. LLChicletAvatarIconCtrl::Params avatar_params = p.avatar_icon;
  670. mChicletIconCtrl = LLUICtrlFactory::create<LLChicletAvatarIconCtrl>(avatar_params);
  671. addChild(mChicletIconCtrl);
  673. LLChicletNotificationCounterCtrl::Params unread_params = p.unread_notifications;
  674. mCounterCtrl = LLUICtrlFactory::create<LLChicletNotificationCounterCtrl>(unread_params);
  675. addChild(mCounterCtrl);
  677. setCounter(getCounter());
  678. setShowCounter(getShowCounter());
  680. LLChicletSpeakerCtrl::Params speaker_params = p.speaker;
  681. mSpeakerCtrl = LLUICtrlFactory::create<LLChicletSpeakerCtrl>(speaker_params);
  682. addChild(mSpeakerCtrl);
  684. sendChildToFront(mNewMessagesIcon);
  685. setShowSpeaker(p.show_speaker);
  686. }
  688. void LLIMP2PChiclet::initSpeakerControl()
  689. {
  690. mSpeakerCtrl->setSpeakerId(getOtherParticipantId());
  691. }
  693. void LLIMP2PChiclet::setOtherParticipantId(const LLUUID& other_participant_id)
  694. {
  695. LLIMChiclet::setOtherParticipantId(other_participant_id);
  696. mChicletIconCtrl->setValue(getOtherParticipantId());
  697. }
  699. void LLIMP2PChiclet::updateMenuItems()
  700. {
  701. if(!mPopupMenu)
  702. return;
  703. if(getSessionId().isNull())
  704. return;
  706. LLIMFloater* open_im_floater = LLIMFloater::findInstance(getSessionId());
  707. bool open_window_exists = open_im_floater && open_im_floater->getVisible();
  708. mPopupMenu->getChild<LLUICtrl>("Send IM")->setEnabled(!open_window_exists);
  710. bool is_friend = LLAvatarActions::isFriend(getOtherParticipantId());
  711. mPopupMenu->getChild<LLUICtrl>("Add Friend")->setEnabled(!is_friend);
  712. }
  714. BOOL LLIMP2PChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
  715. {
  716. if(!mPopupMenu)
  717. {
  718. createPopupMenu();
  719. }
  721. if (mPopupMenu)
  722. {
  723. updateMenuItems();
  724. mPopupMenu->arrangeAndClear();
  725. LLMenuGL::showPopup(this, mPopupMenu, x, y);
  726. }
  728. return TRUE;
  729. }
  731. void LLIMP2PChiclet::createPopupMenu()
  732. {
  733. if(mPopupMenu)
  734. {
  735. llwarns << "Menu already exists" << llendl;
  736. return;
  737. }
  738. if(getSessionId().isNull())
  739. {
  740. return;
  741. }
  743. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  744. registrar.add("IMChicletMenu.Action", boost::bind(&LLIMP2PChiclet::onMenuItemClicked, this, _2));
  746. mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
  747. ("menu_imchiclet_p2p.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  748. }
  750. void LLIMP2PChiclet::onMenuItemClicked(const LLSD& user_data)
  751. {
  752. std::string level = user_data.asString();
  753. LLUUID other_participant_id = getOtherParticipantId();
  755. if("profile" == level)
  756. {
  757. LLAvatarActions::showProfile(other_participant_id);
  758. }
  759. else if("im" == level)
  760. {
  761. LLAvatarActions::startIM(other_participant_id);
  762. }
  763. else if("add" == level)
  764. {
  765. LLAvatarActions::requestFriendshipDialog(other_participant_id);
  766. }
  767. else if("end" == level)
  768. {
  769. LLAvatarActions::endIM(other_participant_id);
  770. }
  771. }
  773. //////////////////////////////////////////////////////////////////////////
  774. //////////////////////////////////////////////////////////////////////////
  775. //////////////////////////////////////////////////////////////////////////
  777. LLAdHocChiclet::Params::Params()
  778. : avatar_icon("avatar_icon")
  779. , chiclet_button("chiclet_button")
  780. , unread_notifications("unread_notifications")
  781. , speaker("speaker")
  782. , new_message_icon("new_message_icon")
  783. , show_speaker("show_speaker")
  784. , avatar_icon_color("avatar_icon_color", LLColor4::green)
  785. {
  786. }
  788. LLAdHocChiclet::LLAdHocChiclet(const Params& p)
  789. : LLIMChiclet(p)
  790. , mChicletIconCtrl(NULL)
  791. , mPopupMenu(NULL)
  792. {
  793. LLButton::Params button_params = p.chiclet_button;
  794. mChicletButton = LLUICtrlFactory::create<LLButton>(button_params);
  795. addChild(mChicletButton);
  797. LLIconCtrl::Params new_msg_params = p.new_message_icon;
  798. mNewMessagesIcon = LLUICtrlFactory::create<LLIconCtrl>(new_msg_params);
  799. addChild(mNewMessagesIcon);
  801. LLChicletAvatarIconCtrl::Params avatar_params = p.avatar_icon;
  802. mChicletIconCtrl = LLUICtrlFactory::create<LLChicletAvatarIconCtrl>(avatar_params);
  803. //Make the avatar modified
  804. mChicletIconCtrl->setColor(p.avatar_icon_color);
  805. addChild(mChicletIconCtrl);
  807. LLChicletNotificationCounterCtrl::Params unread_params = p.unread_notifications;
  808. mCounterCtrl = LLUICtrlFactory::create<LLChicletNotificationCounterCtrl>(unread_params);
  809. addChild(mCounterCtrl);
  811. setCounter(getCounter());
  812. setShowCounter(getShowCounter());
  814. LLChicletSpeakerCtrl::Params speaker_params = p.speaker;
  815. mSpeakerCtrl = LLUICtrlFactory::create<LLChicletSpeakerCtrl>(speaker_params);
  816. addChild(mSpeakerCtrl);
  818. sendChildToFront(mNewMessagesIcon);
  819. setShowSpeaker(p.show_speaker);
  820. }
  822. void LLAdHocChiclet::setSessionId(const LLUUID& session_id)
  823. {
  824. LLChiclet::setSessionId(session_id);
  825. LLIMModel::LLIMSession* im_session = LLIMModel::getInstance()->findIMSession(session_id);
  826. mChicletIconCtrl->setValue(im_session->mOtherParticipantID);
  827. }
  829. void LLAdHocChiclet::draw()
  830. {
  831. switchToCurrentSpeaker();
  832. LLIMChiclet::draw();
  833. }
  835. void LLAdHocChiclet::initSpeakerControl()
  836. {
  837. switchToCurrentSpeaker();
  838. }
  840. void LLAdHocChiclet::switchToCurrentSpeaker()
  841. {
  842. LLUUID speaker_id;
  843. LLSpeakerMgr::speaker_list_t speaker_list;
  845. LLIMModel::getInstance()->findIMSession(getSessionId())->mSpeakers->getSpeakerList(&speaker_list, FALSE);
  846. for (LLSpeakerMgr::speaker_list_t::iterator i = speaker_list.begin(); i != speaker_list.end(); ++i)
  847. {
  848. LLPointer<LLSpeaker> s = *i;
  849. if (s->mSpeechVolume > 0 || s->mStatus == LLSpeaker::STATUS_SPEAKING)
  850. {
  851. speaker_id = s->mID;
  852. break;
  853. }
  854. }
  856. mSpeakerCtrl->setSpeakerId(speaker_id);
  857. }
  859. void LLAdHocChiclet::createPopupMenu()
  860. {
  861. if(mPopupMenu)
  862. {
  863. llwarns << "Menu already exists" << llendl;
  864. return;
  865. }
  866. if(getSessionId().isNull())
  867. {
  868. return;
  869. }
  871. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  872. registrar.add("IMChicletMenu.Action", boost::bind(&LLAdHocChiclet::onMenuItemClicked, this, _2));
  874. mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
  875. ("menu_imchiclet_adhoc.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  876. }
  878. void LLAdHocChiclet::onMenuItemClicked(const LLSD& user_data)
  879. {
  880. std::string level = user_data.asString();
  881. LLUUID group_id = getSessionId();
  883. if("end" == level)
  884. {
  885. LLGroupActions::endIM(group_id);
  886. }
  887. }
  889. BOOL LLAdHocChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
  890. {
  891. if(!mPopupMenu)
  892. {
  893. createPopupMenu();
  894. }
  896. if (mPopupMenu)
  897. {
  898. mPopupMenu->arrangeAndClear();
  899. LLMenuGL::showPopup(this, mPopupMenu, x, y);
  900. }
  902. return TRUE;
  903. }
  905. //////////////////////////////////////////////////////////////////////////
  906. //////////////////////////////////////////////////////////////////////////
  907. //////////////////////////////////////////////////////////////////////////
  909. LLIMGroupChiclet::Params::Params()
  910. : group_icon("group_icon")
  911. , chiclet_button("chiclet_button")
  912. , unread_notifications("unread_notifications")
  913. , speaker("speaker")
  914. , new_message_icon("new_message_icon")
  915. , show_speaker("show_speaker")
  916. {
  917. }
  919. LLIMGroupChiclet::LLIMGroupChiclet(const Params& p)
  920. : LLIMChiclet(p)
  921. , LLGroupMgrObserver(LLUUID::null)
  922. , mChicletIconCtrl(NULL)
  923. , mPopupMenu(NULL)
  924. {
  925. LLButton::Params button_params = p.chiclet_button;
  926. mChicletButton = LLUICtrlFactory::create<LLButton>(button_params);
  927. addChild(mChicletButton);
  929. LLIconCtrl::Params new_msg_params = p.new_message_icon;
  930. mNewMessagesIcon = LLUICtrlFactory::create<LLIconCtrl>(new_msg_params);
  931. addChild(mNewMessagesIcon);
  933. LLChicletGroupIconCtrl::Params avatar_params = p.group_icon;
  934. mChicletIconCtrl = LLUICtrlFactory::create<LLChicletGroupIconCtrl>(avatar_params);
  935. addChild(mChicletIconCtrl);
  937. LLChicletNotificationCounterCtrl::Params unread_params = p.unread_notifications;
  938. mCounterCtrl = LLUICtrlFactory::create<LLChicletNotificationCounterCtrl>(unread_params);
  939. addChild(mCounterCtrl);
  941. setCounter(getCounter());
  942. setShowCounter(getShowCounter());
  944. LLChicletSpeakerCtrl::Params speaker_params = p.speaker;
  945. mSpeakerCtrl = LLUICtrlFactory::create<LLChicletSpeakerCtrl>(speaker_params);
  946. addChild(mSpeakerCtrl);
  948. sendChildToFront(mNewMessagesIcon);
  949. setShowSpeaker(p.show_speaker);
  950. }
  952. LLIMGroupChiclet::~LLIMGroupChiclet()
  953. {
  954. LLGroupMgr::getInstance()->removeObserver(this);
  955. }
  957. void LLIMGroupChiclet::draw()
  958. {
  959. if(getShowSpeaker())
  960. {
  961. switchToCurrentSpeaker();
  962. }
  963. LLIMChiclet::draw();
  964. }
  966. void LLIMGroupChiclet::initSpeakerControl()
  967. {
  968. switchToCurrentSpeaker();
  969. }
  971. void LLIMGroupChiclet::switchToCurrentSpeaker()
  972. {
  973. LLUUID speaker_id;
  974. LLSpeakerMgr::speaker_list_t speaker_list;
  976. LLIMModel::getInstance()->findIMSession(getSessionId())->mSpeakers->getSpeakerList(&speaker_list, FALSE);
  977. for (LLSpeakerMgr::speaker_list_t::iterator i = speaker_list.begin(); i != speaker_list.end(); ++i)
  978. {
  979. LLPointer<LLSpeaker> s = *i;
  980. if (s->mSpeechVolume > 0 || s->mStatus == LLSpeaker::STATUS_SPEAKING)
  981. {
  982. speaker_id = s->mID;
  983. break;
  984. }
  985. }
  987. mSpeakerCtrl->setSpeakerId(speaker_id);
  988. }
  990. void LLIMGroupChiclet::setSessionId(const LLUUID& session_id)
  991. {
  992. LLChiclet::setSessionId(session_id);
  994. LLGroupMgr* grp_mgr = LLGroupMgr::getInstance();
  995. LLGroupMgrGroupData* group_data = grp_mgr->getGroupData(session_id);
  996. if (group_data && group_data->mInsigniaID.notNull())
  997. {
  998. mChicletIconCtrl->setValue(group_data->mInsigniaID);
  999. }
  1000. else
  1001. {
  1002. if(getSessionId() != mID)
  1003. {
  1004. grp_mgr->removeObserver(this);
  1005. mID = getSessionId();
  1006. grp_mgr->addObserver(this);
  1007. }
  1008. grp_mgr->sendGroupPropertiesRequest(session_id);
  1009. }
  1010. }
  1012. void LLIMGroupChiclet::changed(LLGroupChange gc)
  1013. {
  1014. if (GC_PROPERTIES == gc)
  1015. {
  1016. LLGroupMgrGroupData* group_data = LLGroupMgr::getInstance()->getGroupData(getSessionId());
  1017. if (group_data)
  1018. {
  1019. mChicletIconCtrl->setValue(group_data->mInsigniaID);
  1020. }
  1021. }
  1022. }
  1024. void LLIMGroupChiclet::updateMenuItems()
  1025. {
  1026. if(!mPopupMenu)
  1027. return;
  1028. if(getSessionId().isNull())
  1029. return;
  1031. LLIMFloater* open_im_floater = LLIMFloater::findInstance(getSessionId());
  1032. bool open_window_exists = open_im_floater && open_im_floater->getVisible();
  1033. mPopupMenu->getChild<LLUICtrl>("Chat")->setEnabled(!open_window_exists);
  1034. }
  1036. BOOL LLIMGroupChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
  1037. {
  1038. if(!mPopupMenu)
  1039. {
  1040. createPopupMenu();
  1041. }
  1043. if (mPopupMenu)
  1044. {
  1045. updateMenuItems();
  1046. mPopupMenu->arrangeAndClear();
  1047. LLMenuGL::showPopup(this, mPopupMenu, x, y);
  1048. }
  1050. return TRUE;
  1051. }
  1053. void LLIMGroupChiclet::createPopupMenu()
  1054. {
  1055. if(mPopupMenu)
  1056. {
  1057. llwarns << "Menu already exists" << llendl;
  1058. return;
  1059. }
  1060. if(getSessionId().isNull())
  1061. {
  1062. return;
  1063. }
  1065. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  1066. registrar.add("IMChicletMenu.Action", boost::bind(&LLIMGroupChiclet::onMenuItemClicked, this, _2));
  1068. mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
  1069. ("menu_imchiclet_group.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  1070. }
  1072. void LLIMGroupChiclet::onMenuItemClicked(const LLSD& user_data)
  1073. {
  1074. std::string level = user_data.asString();
  1075. LLUUID group_id = getSessionId();
  1077. if("group chat" == level)
  1078. {
  1079. LLGroupActions::startIM(group_id);
  1080. }
  1081. else if("info" == level)
  1082. {
  1083. LLGroupActions::show(group_id);
  1084. }
  1085. else if("end" == level)
  1086. {
  1087. LLGroupActions::endIM(group_id);
  1088. }
  1089. }
  1092. //////////////////////////////////////////////////////////////////////////
  1093. //////////////////////////////////////////////////////////////////////////
  1094. //////////////////////////////////////////////////////////////////////////
  1096. LLChicletPanel::Params::Params()
  1097. : chiclet_padding("chiclet_padding")
  1098. , scrolling_offset("scrolling_offset")
  1099. , scroll_button_hpad("scroll_button_hpad")
  1100. , scroll_ratio("scroll_ratio")
  1101. , min_width("min_width")
  1102. {
  1103. };
  1105. LLChicletPanel::LLChicletPanel(const Params&p)
  1106. : LLPanel(p)
  1107. , mScrollArea(NULL)
  1108. , mLeftScrollButton(NULL)
  1109. , mRightScrollButton(NULL)
  1110. , mChicletPadding(p.chiclet_padding)
  1111. , mScrollingOffset(p.scrolling_offset)
  1112. , mScrollButtonHPad(p.scroll_button_hpad)
  1113. , mScrollRatio(p.scroll_ratio)
  1114. , mMinWidth(p.min_width)
  1115. , mShowControls(true)
  1116. {
  1117. LLPanel::Params panel_params;
  1118. panel_params.follows.flags(FOLLOWS_LEFT | FOLLOWS_RIGHT);
  1119. mScrollArea = LLUICtrlFactory::create<LLPanel>(panel_params,this);
  1121. // important for Show/Hide Camera and Move controls menu in bottom tray to work properly
  1122. mScrollArea->setMouseOpaque(false);
  1124. addChild(mScrollArea);
  1125. }
  1127. LLChicletPanel::~LLChicletPanel()
  1128. {
  1129. LLTransientFloaterMgr::getInstance()->removeControlView(mLeftScrollButton);
  1130. LLTransientFloaterMgr::getInstance()->removeControlView(mRightScrollButton);
  1132. }
  1134. void im_chiclet_callback(LLChicletPanel* panel, const LLSD& data){
  1136. LLUUID session_id = data["session_id"].asUUID();
  1137. S32 unread = data["participant_unread"].asInteger();
  1139. LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
  1140. if (im_floater && im_floater->getVisible())
  1141. {
  1142. unread = 0;
  1143. }
  1145. std::list<LLChiclet*> chiclets = LLIMChiclet::sFindChicletsSignal(session_id);
  1146. std::list<LLChiclet *>::iterator iter;
  1147. for (iter = chiclets.begin(); iter != chiclets.end(); iter++) {
  1148. LLChiclet* chiclet = *iter;
  1149. if (chiclet != NULL)
  1150. {
  1151. chiclet->setCounter(unread);
  1152. }
  1153.     else
  1154.     {
  1155.      llwarns << "Unable to set counter for chiclet " << session_id << llendl;
  1156.     }
  1157. }
  1158. }
  1160. void object_chiclet_callback(const LLSD& data)
  1161. {
  1162. LLUUID notification_id = data["notification_id"];
  1163. bool new_message = data["new_message"];
  1165. std::list<LLChiclet*> chiclets = LLIMChiclet::sFindChicletsSignal(notification_id);
  1166. std::list<LLChiclet *>::iterator iter;
  1167. for (iter = chiclets.begin(); iter != chiclets.end(); iter++)
  1168. {
  1169. LLIMChiclet* chiclet = dynamic_cast<LLIMChiclet*>(*iter);
  1170. if (chiclet != NULL)
  1171. {
  1172. if(data.has("unread"))
  1173. {
  1174. chiclet->setCounter(data["unread"]);
  1175. }
  1176. chiclet->setShowNewMessagesIcon(new_message);
  1177. }
  1178. }
  1179. }
  1181. BOOL LLChicletPanel::postBuild()
  1182. {
  1183. LLPanel::postBuild();
  1184. LLIMModel::instance().addNewMsgCallback(boost::bind(im_chiclet_callback, this, _1));
  1185. LLIMModel::instance().addNoUnreadMsgsCallback(boost::bind(im_chiclet_callback, this, _1));
  1186. LLScriptFloaterManager::getInstance()->addNewObjectCallback(boost::bind(object_chiclet_callback, _1));
  1187. LLScriptFloaterManager::getInstance()->addToggleObjectFloaterCallback(boost::bind(object_chiclet_callback, _1));
  1188. LLIMChiclet::sFindChicletsSignal.connect(boost::bind(&LLChicletPanel::findChiclet<LLChiclet>, this, _1));
  1189. LLVoiceChannel::setCurrentVoiceChannelChangedCallback(boost::bind(&LLChicletPanel::onCurrentVoiceChannelChanged, this, _1));
  1191. mLeftScrollButton=getChild<LLButton>("chicklet_left_scroll_button");
  1192. LLTransientFloaterMgr::getInstance()->addControlView(mLeftScrollButton);
  1193. mLeftScrollButton->setMouseDownCallback(boost::bind(&LLChicletPanel::onLeftScrollClick,this));
  1194. mLeftScrollButton->setHeldDownCallback(boost::bind(&LLChicletPanel::onLeftScrollHeldDown,this));
  1195. mLeftScrollButton->setEnabled(false);
  1197. mRightScrollButton=getChild<LLButton>("chicklet_right_scroll_button");
  1198. LLTransientFloaterMgr::getInstance()->addControlView(mRightScrollButton);
  1199. mRightScrollButton->setMouseDownCallback(boost::bind(&LLChicletPanel::onRightScrollClick,this));
  1200. mRightScrollButton->setHeldDownCallback(boost::bind(&LLChicletPanel::onRightScrollHeldDown,this));
  1201. mRightScrollButton->setEnabled(false);
  1203. return TRUE;
  1204. }
  1206. void LLChicletPanel::onCurrentVoiceChannelChanged(const LLUUID& session_id)
  1207. {
  1208. static LLUUID s_previous_active_voice_session_id;
  1210. std::list<LLChiclet*> chiclets = LLIMChiclet::sFindChicletsSignal(session_id);
  1212. for(std::list<LLChiclet *>::iterator it = chiclets.begin(); it != chiclets.end(); ++it)
  1213. {
  1214. LLIMChiclet* chiclet = dynamic_cast<LLIMChiclet*>(*it);
  1215. if(chiclet)
  1216. {
  1217. chiclet->setShowSpeaker(true);
  1218. }
  1219. }
  1221. if(!s_previous_active_voice_session_id.isNull() && s_previous_active_voice_session_id != session_id)
  1222. {
  1223. chiclets = LLIMChiclet::sFindChicletsSignal(s_previous_active_voice_session_id);
  1225. for(std::list<LLChiclet *>::iterator it = chiclets.begin(); it != chiclets.end(); ++it)
  1226. {
  1227. LLIMChiclet* chiclet = dynamic_cast<LLIMChiclet*>(*it);
  1228. if(chiclet)
  1229. {
  1230. chiclet->setShowSpeaker(false);
  1231. }
  1232. }
  1233. }
  1235. s_previous_active_voice_session_id = session_id;
  1236. }
  1238. bool LLChicletPanel::addChiclet(LLChiclet* chiclet, S32 index)
  1239. {
  1240. if(mScrollArea->addChild(chiclet))
  1241. {
  1242. // chiclets should be aligned to right edge of scroll panel
  1243. S32 left_shift = 0;
  1245. if (!canScrollLeft())
  1246. {
  1247. // init left shift for the first chiclet in the list...
  1248. if (mChicletList.empty())
  1249. {
  1250. // ...start from the right border of the scroll area for the first added chiclet 
  1251. left_shift = mScrollArea->getRect().getWidth();
  1252. }
  1253. else
  1254. {
  1255. // ... start from the left border of the first chiclet minus padding
  1256. left_shift = getChiclet(0)->getRect().mLeft - getChicletPadding();
  1257. }
  1259. // take into account width of the being added chiclet
  1260. left_shift -= chiclet->getRequiredRect().getWidth();
  1262. // if we overflow the scroll area we do not need to shift chiclets
  1263. if (left_shift < 0)
  1264. {
  1265. left_shift = 0;
  1266. }
  1267. }
  1269. mChicletList.insert(mChicletList.begin() + index, chiclet);
  1271. // shift first chiclet to place it in correct position. 
  1272. // rest ones will be placed in arrange()
  1273. if (!canScrollLeft())
  1274. {
  1275. getChiclet(0)->translate(left_shift - getChiclet(0)->getRect().mLeft, 0);
  1276. }
  1278. chiclet->setLeftButtonClickCallback(boost::bind(&LLChicletPanel::onChicletClick, this, _1, _2));
  1279. chiclet->setChicletSizeChangedCallback(boost::bind(&LLChicletPanel::onChicletSizeChanged, this, _1, index));
  1281. arrange();
  1282. LLTransientFloaterMgr::getInstance()->addControlView(LLTransientFloaterMgr::IM, chiclet);
  1284. return true;
  1285. }
  1287. return false;
  1288. }
  1290. void LLChicletPanel::onChicletSizeChanged(LLChiclet* ctrl, const LLSD& param)
  1291. {
  1292. arrange();
  1293. }
  1295. void LLChicletPanel::onChicletClick(LLUICtrl*ctrl,const LLSD&param)
  1296. {
  1297. if (mCommitSignal)
  1298. {
  1299. (*mCommitSignal)(ctrl,param);
  1300. }
  1301. }
  1303. void LLChicletPanel::removeChiclet(chiclet_list_t::iterator it)
  1304. {
  1305. LLChiclet* chiclet = *it;
  1306. mScrollArea->removeChild(chiclet);
  1307. mChicletList.erase(it);
  1309. arrange();
  1310. LLTransientFloaterMgr::getInstance()->removeControlView(LLTransientFloaterMgr::IM, chiclet);
  1311. chiclet->die();
  1312. }
  1314. void LLChicletPanel::removeChiclet(S32 index)
  1315. {
  1316. if(index >= 0 && index < getChicletCount())
  1317. {
  1318. removeChiclet(mChicletList.begin() + index);
  1319. }
  1320. }
  1322. S32 LLChicletPanel::getChicletIndex(const LLChiclet* chiclet)
  1323. {
  1324. if(mChicletList.empty())
  1325. return -1;
  1327. S32 size = getChicletCount();
  1328. for(int n = 0; n < size; ++n)
  1329. {
  1330. if(chiclet == mChicletList[n])
  1331. return n;
  1332. }
  1334. return -1;
  1335. }
  1337. void LLChicletPanel::removeChiclet(LLChiclet*chiclet)
  1338. {
  1339. chiclet_list_t::iterator it = mChicletList.begin();
  1340. for( ; mChicletList.end() != it; ++it)
  1341. {
  1342. LLChiclet* temp = *it;
  1343. if(temp == chiclet)
  1344. {
  1345. removeChiclet(it);
  1346. return;
  1347. }
  1348. }
  1349. }
  1351. void LLChicletPanel::removeChiclet(const LLUUID& im_session_id)
  1352. {
  1353. chiclet_list_t::iterator it = mChicletList.begin();
  1354. for( ; mChicletList.end() != it; ++it)
  1355. {
  1356. LLIMChiclet* chiclet = dynamic_cast<LLIMChiclet*>(*it);
  1358. if(chiclet->getSessionId() == im_session_id)
  1359. {
  1360. removeChiclet(it);
  1361. return;
  1362. }
  1363. }
  1364. }
  1366. void LLChicletPanel::removeAll()
  1367. {
  1368. S32 size = getChicletCount();
  1369. for(S32 n = 0; n < size; ++n)
  1370. {
  1371. mScrollArea->removeChild(mChicletList[n]);
  1372. }
  1374. mChicletList.erase(mChicletList.begin(), mChicletList.end());
  1376. showScrollButtonsIfNeeded();
  1377. }
  1379. void LLChicletPanel::scrollToChiclet(const LLChiclet* chiclet)
  1380. {
  1381. const LLRect& rect = chiclet->getRect();
  1383. if (rect.mLeft < 0)
  1384. {
  1385. scroll(llabs(rect.mLeft));
  1386. showScrollButtonsIfNeeded();
  1387. }
  1388. else
  1389. {
  1390. S32 scrollWidth = mScrollArea->getRect().getWidth();
  1392. if (rect.mRight > scrollWidth)
  1393. {
  1394. scroll(-llabs(rect.mRight - scrollWidth));
  1395. showScrollButtonsIfNeeded();
  1396. }
  1397. }
  1398. }
  1400. void LLChicletPanel::reshape(S32 width, S32 height, BOOL called_from_parent )
  1401. {
  1402. LLPanel::reshape(width,height,called_from_parent);
  1404. //Needed once- to avoid error at first call of reshape() before postBuild()
  1405. if(!mLeftScrollButton||!mRightScrollButton)
  1406. return;
  1408. LLRect scroll_button_rect = mLeftScrollButton->getRect();
  1409. mLeftScrollButton->setRect(LLRect(0,scroll_button_rect.mTop,scroll_button_rect.getWidth(),
  1410. scroll_button_rect.mBottom));
  1411. scroll_button_rect = mRightScrollButton->getRect();
  1412. mRightScrollButton->setRect(LLRect(width - scroll_button_rect.getWidth(),scroll_button_rect.mTop,
  1413. width, scroll_button_rect.mBottom));
  1416. bool need_show_scroll = needShowScroll();
  1417. if(need_show_scroll)
  1418. {
  1419. mScrollArea->setRect(LLRect(scroll_button_rect.getWidth() + mScrollButtonHPad,
  1420. height, width - scroll_button_rect.getWidth() - mScrollButtonHPad, 0));
  1421. }
  1422. else
  1423. {
  1424. mScrollArea->setRect(LLRect(0,height, width, 0));
  1425. }
  1427. mShowControls = width >= mMinWidth;
  1429. mScrollArea->setVisible(mShowControls);
  1431. trimChiclets();
  1432. showScrollButtonsIfNeeded();
  1434. }
  1436. S32 LLChicletPanel::notifyParent(const LLSD& info)
  1437. {
  1438. if(info.has("notification"))
  1439. {
  1440. std::string str_notification = info["notification"];
  1441. if(str_notification == "size_changes")
  1442. {
  1443. arrange();
  1444. return 1;
  1445. }
  1446. }
  1447. return LLPanel::notifyParent(info);
  1448. }
  1450. void LLChicletPanel::setChicletToggleState(const LLUUID& session_id, bool toggle)
  1451. {
  1452. if(session_id.isNull())
  1453. {
  1454. llwarns << "Null Session ID" << llendl;
  1455. }
  1457. // toggle off all chiclets, except specified
  1458. S32 size = getChicletCount();
  1459. for(int n = 0; n < size; ++n)
  1460. {
  1461. LLIMChiclet* chiclet = getChiclet<LLIMChiclet>(n);
  1462. if(chiclet && chiclet->getSessionId() != session_id)
  1463. {
  1464. chiclet->setToggleState(false);
  1465. }
  1466. }
  1468. // toggle specified chiclet
  1469. LLIMChiclet* chiclet = findChiclet<LLIMChiclet>(session_id);
  1470. if(chiclet)
  1471. {
  1472. chiclet->setToggleState(toggle);
  1473. }
  1474. }
  1476. void LLChicletPanel::arrange()
  1477. {
  1478. if(mChicletList.empty())
  1479. return;
  1481. //initial arrange of chicklets positions
  1482. S32 chiclet_left = getChiclet(0)->getRect().mLeft;
  1483. S32 size = getChicletCount();
  1484. for( int n = 0; n < size; ++n)
  1485. {
  1486. LLChiclet* chiclet = getChiclet(n);
  1488. S32 chiclet_width = chiclet->getRequiredRect().getWidth();
  1489. LLRect rect = chiclet->getRect();
  1490. rect.set(chiclet_left, rect.mTop, chiclet_left + chiclet_width, rect.mBottom);
  1492. chiclet->setRect(rect);
  1494. chiclet_left += chiclet_width + getChicletPadding();
  1495. }
  1497. //reset size and pos on mScrollArea
  1498. LLRect rect = getRect();
  1499. LLRect scroll_button_rect = mLeftScrollButton->getRect();
  1501. bool need_show_scroll = needShowScroll();
  1502. if(need_show_scroll)
  1503. {
  1504. mScrollArea->setRect(LLRect(scroll_button_rect.getWidth() + mScrollButtonHPad,
  1505. rect.getHeight(), rect.getWidth() - scroll_button_rect.getWidth() - mScrollButtonHPad, 0));
  1506. }
  1507. else
  1508. {
  1509. mScrollArea->setRect(LLRect(0,rect.getHeight(), rect.getWidth(), 0));
  1510. }
  1512. trimChiclets();
  1513. showScrollButtonsIfNeeded();
  1514. }
  1516. void LLChicletPanel::trimChiclets()
  1517. {
  1518. // trim right
  1519. if(!mChicletList.empty())
  1520. {
  1521. S32 last_chiclet_right = (*mChicletList.rbegin())->getRect().mRight;
  1522. S32 first_chiclet_left = getChiclet(0)->getRect().mLeft;
  1523. S32 scroll_width = mScrollArea->getRect().getWidth();
  1524. if(last_chiclet_right < scroll_width || first_chiclet_left > 0)
  1525. {
  1526. shiftChiclets(scroll_width - last_chiclet_right);
  1527. }
  1528. }
  1529. }
  1531. bool LLChicletPanel::needShowScroll()
  1532. {
  1533. if(mChicletList.empty())
  1534. return false;
  1536. S32 chicklet_width  = (*mChicletList.rbegin())->getRect().mRight - (*mChicletList.begin())->getRect().mLeft;
  1538. return chicklet_width>getRect().getWidth();
  1539. }
  1542. void LLChicletPanel::showScrollButtonsIfNeeded()
  1543. {
  1544. bool can_scroll_left = canScrollLeft();
  1545. bool can_scroll_right = canScrollRight();
  1547. mLeftScrollButton->setEnabled(can_scroll_left);
  1548. mRightScrollButton->setEnabled(can_scroll_right);
  1550. bool show_scroll_buttons = (can_scroll_left || can_scroll_right) && mShowControls;
  1552. mLeftScrollButton->setVisible(show_scroll_buttons);
  1553. mRightScrollButton->setVisible(show_scroll_buttons);
  1554. }
  1556. void LLChicletPanel::draw()
  1557. {
  1558. child_list_const_iter_t it = getChildList()->begin();
  1559. for( ; getChildList()->end() != it; ++it)
  1560. {
  1561. LLView* child = *it;
  1562. if(child == dynamic_cast<LLView*>(mScrollArea))
  1563. {
  1564. LLLocalClipRect clip(mScrollArea->getRect());
  1565. drawChild(mScrollArea);
  1566. }
  1567. else
  1568. {
  1569. drawChild(child);
  1570. }
  1571. }
  1572. }
  1574. bool LLChicletPanel::canScrollRight()
  1575. {
  1576. if(mChicletList.empty())
  1577. return false;
  1579. S32 scroll_width = mScrollArea->getRect().getWidth();
  1580. S32 last_chiclet_right = (*mChicletList.rbegin())->getRect().mRight;
  1582. if(last_chiclet_right > scroll_width)
  1583. return true;
  1585. return false;
  1586. }
  1588. bool LLChicletPanel::canScrollLeft()
  1589. {
  1590. if(mChicletList.empty())
  1591. return false;
  1593. return getChiclet(0)->getRect().mLeft < 0;
  1594. }
  1596. void LLChicletPanel::scroll(S32 offset)
  1597. {
  1598. shiftChiclets(offset);
  1599. }
  1601. void LLChicletPanel::shiftChiclets(S32 offset, S32 start_index /* = 0 */)
  1602. {
  1603. if(start_index < 0 || start_index >= getChicletCount())
  1604. {
  1605. return;
  1606. }
  1608. chiclet_list_t::const_iterator it = mChicletList.begin() + start_index;
  1609. for(;mChicletList.end() != it; ++it)
  1610. {
  1611. LLChiclet* chiclet = *it;
  1612. chiclet->translate(offset,0);
  1613. }
  1614. }
  1616. void LLChicletPanel::scrollLeft()
  1617. {
  1618. if(canScrollLeft())
  1619. {
  1620. S32 offset = getScrollingOffset();
  1621. LLRect first_chiclet_rect = getChiclet(0)->getRect();
  1623. // shift chiclets in case first chiclet is partially visible
  1624. if(first_chiclet_rect.mLeft < 0 && first_chiclet_rect.mRight > 0)
  1625. {
  1626. offset = llabs(first_chiclet_rect.mLeft);
  1627. }
  1629. scroll(offset);
  1631. showScrollButtonsIfNeeded();
  1632. }
  1633. }
  1635. void LLChicletPanel::scrollRight()
  1636. {
  1637. if(canScrollRight())
  1638. {
  1639. S32 offset = - getScrollingOffset();
  1641. S32 last_chiclet_right = (*mChicletList.rbegin())->getRect().mRight;
  1642. S32 scroll_rect_width = mScrollArea->getRect().getWidth();
  1643. // if after scrolling, the last chiclet will not be aligned to 
  1644. // scroll area right side - align it.
  1645. if( last_chiclet_right + offset < scroll_rect_width )
  1646. {
  1647. offset = scroll_rect_width - last_chiclet_right;
  1648. }
  1650. scroll(offset);
  1652. showScrollButtonsIfNeeded();
  1653. }
  1654. }
  1656. void LLChicletPanel::onLeftScrollClick()
  1657. {
  1658. scrollLeft();
  1659. }
  1661. void LLChicletPanel::onRightScrollClick()
  1662. {
  1663. scrollRight();
  1664. }
  1666. void LLChicletPanel::onLeftScrollHeldDown()
  1667. {
  1668. S32 offset = mScrollingOffset;
  1669. mScrollingOffset = mScrollingOffset / mScrollRatio;
  1670. scrollLeft();
  1671. mScrollingOffset = offset;
  1672. }
  1674. void LLChicletPanel::onRightScrollHeldDown()
  1675. {
  1676. S32 offset = mScrollingOffset;
  1677. mScrollingOffset = mScrollingOffset / mScrollRatio;
  1678. scrollRight();
  1679. mScrollingOffset = offset;
  1680. }
  1682. boost::signals2::connection LLChicletPanel::setChicletClickedCallback(
  1683. const commit_callback_t& cb)
  1684. {
  1685. return setCommitCallback(cb);
  1686. }
  1688. BOOL LLChicletPanel::handleScrollWheel(S32 x, S32 y, S32 clicks)
  1689. {
  1690. if(clicks > 0)
  1691. {
  1692. scrollRight();
  1693. }
  1694. else
  1695. {
  1696. scrollLeft();
  1697. }
  1698. return TRUE;
  1699. }
  1701. bool LLChicletPanel::isAnyIMFloaterDoked()
  1702. {
  1703. bool res = false;
  1704. for (chiclet_list_t::iterator it = mChicletList.begin(); it
  1705. != mChicletList.end(); it++)
  1706. {
  1707. LLIMFloater* im_floater = LLFloaterReg::findTypedInstance<LLIMFloater>(
  1708. "impanel", (*it)->getSessionId());
  1709. if (im_floater != NULL && im_floater->getVisible()
  1710. && !im_floater->isMinimized() && im_floater->isDocked())
  1711. {
  1712. res = true;
  1713. break;
  1714. }
  1715. }
  1717. return res;
  1718. }
  1720. S32 LLChicletPanel::getTotalUnreadIMCount()
  1721. {
  1722. S32 count = 0;
  1723. chiclet_list_t::const_iterator it = mChicletList.begin();
  1724. for( ; mChicletList.end() != it; ++it)
  1725. {
  1726. LLIMChiclet* chiclet = dynamic_cast<LLIMChiclet*>(*it);
  1727. if(chiclet)
  1728. {
  1729. count += chiclet->getCounter();
  1730. }
  1731. }
  1732. return count;
  1733. }
  1735. //////////////////////////////////////////////////////////////////////////
  1736. //////////////////////////////////////////////////////////////////////////
  1737. //////////////////////////////////////////////////////////////////////////
  1738. LLChicletNotificationCounterCtrl::Params::Params()
  1739. : max_displayed_count("max_displayed_count", 99)
  1740. {
  1741. }
  1743. LLChicletNotificationCounterCtrl::LLChicletNotificationCounterCtrl(const Params& p)
  1744.  : LLTextBox(p)
  1745.  , mCounter(0)
  1746.  , mInitialWidth(0)
  1747.  , mMaxDisplayedCount(p.max_displayed_count)
  1748. {
  1749. mInitialWidth = getRect().getWidth();
  1750. }
  1752. void LLChicletNotificationCounterCtrl::setCounter(S32 counter)
  1753. {
  1754. mCounter = counter;
  1756. // note same code in LLSysWellChiclet::setCounter(S32 counter)
  1757. std::string s_count;
  1758. if(counter != 0)
  1759. {
  1760. static std::string more_messages_exist("+");
  1761. std::string more_messages(counter > mMaxDisplayedCount ? more_messages_exist : "");
  1762. s_count = llformat("%d%s"
  1763. , llmin(counter, mMaxDisplayedCount)
  1764. , more_messages.c_str()
  1765. );
  1766. }
  1768. if(mCounter != 0)
  1769. {
  1770. setText(s_count);
  1771. }
  1772. else
  1773. {
  1774. setText(std::string(""));
  1775. }
  1776. }
  1778. LLRect LLChicletNotificationCounterCtrl::getRequiredRect()
  1779. {
  1780. LLRect rc;
  1781. S32 text_width = getTextPixelWidth();
  1783. rc.mRight = rc.mLeft + llmax(text_width, mInitialWidth);
  1785. return rc;
  1786. }
  1788. void LLChicletNotificationCounterCtrl::setValue(const LLSD& value)
  1789. {
  1790. if(value.isInteger())
  1791. setCounter(value.asInteger());
  1792. }
  1794. LLSD LLChicletNotificationCounterCtrl::getValue() const
  1795. {
  1796. return LLSD(getCounter());
  1797. }
  1799. //////////////////////////////////////////////////////////////////////////
  1800. //////////////////////////////////////////////////////////////////////////
  1801. //////////////////////////////////////////////////////////////////////////
  1803. LLChicletAvatarIconCtrl::LLChicletAvatarIconCtrl(const Params& p)
  1804.  : LLAvatarIconCtrl(p)
  1805. {
  1806. }
  1808. //////////////////////////////////////////////////////////////////////////
  1809. //////////////////////////////////////////////////////////////////////////
  1810. //////////////////////////////////////////////////////////////////////////
  1812. LLChicletGroupIconCtrl::LLChicletGroupIconCtrl(const Params& p)
  1813. : LLIconCtrl(p)
  1814. , mDefaultIcon(p.default_icon)
  1815. {
  1816. setValue(LLUUID::null);
  1817. }
  1819. void LLChicletGroupIconCtrl::setValue(const LLSD& value )
  1820. {
  1821. if(value.asUUID().isNull())
  1822. {
  1823. LLIconCtrl::setValue(mDefaultIcon);
  1824. }
  1825. else
  1826. {
  1827. LLIconCtrl::setValue(value);
  1828. }
  1829. }
  1831. //////////////////////////////////////////////////////////////////////////
  1832. //////////////////////////////////////////////////////////////////////////
  1833. //////////////////////////////////////////////////////////////////////////
  1835. LLChicletInvOfferIconCtrl::LLChicletInvOfferIconCtrl(const Params& p)
  1836. : LLChicletAvatarIconCtrl(p)
  1837.  , mDefaultIcon(p.default_icon)
  1838. {
  1839. }
  1841. void LLChicletInvOfferIconCtrl::setValue(const LLSD& value )
  1842. {
  1843. if(value.asUUID().isNull())
  1844. {
  1845. LLIconCtrl::setValue(mDefaultIcon);
  1846. }
  1847. else
  1848. {
  1849. LLChicletAvatarIconCtrl::setValue(value);
  1850. }
  1851. }
  1853. //////////////////////////////////////////////////////////////////////////
  1854. //////////////////////////////////////////////////////////////////////////
  1855. //////////////////////////////////////////////////////////////////////////
  1857. LLChicletSpeakerCtrl::LLChicletSpeakerCtrl(const Params&p)
  1858.  : LLOutputMonitorCtrl(p)
  1859. {
  1860. }
  1862. //////////////////////////////////////////////////////////////////////////
  1863. //////////////////////////////////////////////////////////////////////////
  1864. //////////////////////////////////////////////////////////////////////////
  1866. LLScriptChiclet::Params::Params()
  1867.  : icon("icon")
  1868.  , chiclet_button("chiclet_button")
  1869.  , new_message_icon("new_message_icon")
  1870. {
  1871. }
  1873. LLScriptChiclet::LLScriptChiclet(const Params&p)
  1874.  : LLIMChiclet(p)
  1875.  , mChicletIconCtrl(NULL)
  1876. {
  1877. LLButton::Params button_params = p.chiclet_button;
  1878. mChicletButton = LLUICtrlFactory::create<LLButton>(button_params);
  1879. addChild(mChicletButton);
  1881. LLIconCtrl::Params new_msg_params = p.new_message_icon;
  1882. mNewMessagesIcon = LLUICtrlFactory::create<LLIconCtrl>(new_msg_params);
  1883. addChild(mNewMessagesIcon);
  1885. LLIconCtrl::Params icon_params = p.icon;
  1886. mChicletIconCtrl = LLUICtrlFactory::create<LLIconCtrl>(icon_params);
  1887. addChild(mChicletIconCtrl);
  1889. sendChildToFront(mNewMessagesIcon);
  1890. }
  1892. void LLScriptChiclet::setSessionId(const LLUUID& session_id)
  1893. {
  1894. setShowNewMessagesIcon( getSessionId() != session_id );
  1896. LLIMChiclet::setSessionId(session_id);
  1898. setToolTip(LLScriptFloaterManager::getObjectName(session_id));
  1899. }
  1901. void LLScriptChiclet::setCounter(S32 counter)
  1902. {
  1903. setShowNewMessagesIcon( counter > 0 );
  1904. }
  1906. void LLScriptChiclet::onMouseDown()
  1907. {
  1908. LLScriptFloaterManager::getInstance()->toggleScriptFloater(getSessionId());
  1909. }
  1911. //////////////////////////////////////////////////////////////////////////
  1912. //////////////////////////////////////////////////////////////////////////
  1913. //////////////////////////////////////////////////////////////////////////
  1915. static const std::string INVENTORY_USER_OFFER ("UserGiveItem");
  1917. LLInvOfferChiclet::Params::Params()
  1918.  : icon("icon")
  1919.  , chiclet_button("chiclet_button")
  1920.  , new_message_icon("new_message_icon")
  1921. {
  1922. }
  1924. LLInvOfferChiclet::LLInvOfferChiclet(const Params&p)
  1925.  : LLIMChiclet(p)
  1926.  , mChicletIconCtrl(NULL)
  1927. {
  1928. LLButton::Params button_params = p.chiclet_button;
  1929. mChicletButton = LLUICtrlFactory::create<LLButton>(button_params);
  1930. addChild(mChicletButton);
  1932. LLIconCtrl::Params new_msg_params = p.new_message_icon;
  1933. mNewMessagesIcon = LLUICtrlFactory::create<LLIconCtrl>(new_msg_params);
  1934. addChild(mNewMessagesIcon);
  1936. LLChicletInvOfferIconCtrl::Params icon_params = p.icon;
  1937. mChicletIconCtrl = LLUICtrlFactory::create<LLChicletInvOfferIconCtrl>(icon_params);
  1938. addChild(mChicletIconCtrl);
  1940. sendChildToFront(mNewMessagesIcon);
  1941. }
  1943. void LLInvOfferChiclet::setSessionId(const LLUUID& session_id)
  1944. {
  1945. setShowNewMessagesIcon( getSessionId() != session_id );
  1947. setToolTip(LLScriptFloaterManager::getObjectName(session_id));
  1949. LLIMChiclet::setSessionId(session_id);
  1950. LLNotificationPtr notification = LLNotifications::getInstance()->find(session_id);
  1952. if ( notification && notification->getName() == INVENTORY_USER_OFFER )
  1953. {
  1954. mChicletIconCtrl->setValue(notification->getPayload()["from_id"]);
  1955. }
  1956. else
  1957. {
  1958. mChicletIconCtrl->setValue(LLUUID::null);
  1959. }
  1960. }
  1962. void LLInvOfferChiclet::setCounter(S32 counter)
  1963. {
  1964. setShowNewMessagesIcon( counter > 0 );
  1965. }
  1967. void LLInvOfferChiclet::onMouseDown()
  1968. {
  1969. LLScriptFloaterManager::instance().toggleScriptFloater(getSessionId());
  1970. }
  1972. // EOF