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

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

游戏引擎

开发平台：

C++ Builder

llimfloater.cpp：源码内容
  1. /** 
  2.  * @file llimfloater.cpp
  3.  * @brief LLIMFloater class definition
  4.  *
  5.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2009-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"
  35. #include "llimfloater.h"
  37. #include "llnotificationsutil.h"
  39. #include "llagent.h"
  40. #include "llappviewer.h"
  41. #include "llbutton.h"
  42. #include "llbottomtray.h"
  43. #include "llchannelmanager.h"
  44. #include "llchiclet.h"
  45. #include "llfloaterreg.h"
  46. #include "llimfloatercontainer.h" // to replace separate IM Floaters with multifloater container
  47. #include "lllayoutstack.h"
  48. #include "lllineeditor.h"
  49. #include "lllogchat.h"
  50. #include "llpanelimcontrolpanel.h"
  51. #include "llscreenchannel.h"
  52. #include "llsyswellwindow.h"
  53. #include "lltrans.h"
  54. #include "llchathistory.h"
  55. #include "llviewerwindow.h"
  56. #include "llvoicechannel.h"
  57. #include "lltransientfloatermgr.h"
  58. #include "llinventorymodel.h"
  59. #include "llrootview.h"
  61. #include "llspeakers.h"
  64. LLIMFloater::LLIMFloater(const LLUUID& session_id)
  65.   : LLTransientDockableFloater(NULL, true, session_id),
  66. mControlPanel(NULL),
  67. mSessionID(session_id),
  68. mLastMessageIndex(-1),
  69. mDialog(IM_NOTHING_SPECIAL),
  70. mChatHistory(NULL),
  71. mInputEditor(NULL),
  72. mSavedTitle(),
  73. mTypingStart(),
  74. mShouldSendTypingState(false),
  75. mMeTyping(false),
  76. mOtherTyping(false),
  77. mTypingTimer(),
  78. mTypingTimeoutTimer(),
  79. mPositioned(false),
  80. mSessionInitialized(false)
  81. {
  82. LLIMModel::LLIMSession* im_session = LLIMModel::getInstance()->findIMSession(mSessionID);
  83. if (im_session)
  84. {
  85. mSessionInitialized = im_session->mSessionInitialized;
  87. mDialog = im_session->mType;
  88. switch(mDialog){
  89. case IM_NOTHING_SPECIAL:
  90. case IM_SESSION_P2P_INVITE:
  91. mFactoryMap["panel_im_control_panel"] = LLCallbackMap(createPanelIMControl, this);
  92. break;
  93. case IM_SESSION_CONFERENCE_START:
  94. mFactoryMap["panel_im_control_panel"] = LLCallbackMap(createPanelAdHocControl, this);
  95. break;
  96. case IM_SESSION_GROUP_START:
  97. mFactoryMap["panel_im_control_panel"] = LLCallbackMap(createPanelGroupControl, this);
  98. break;
  99. case IM_SESSION_INVITE:
  100. if (gAgent.isInGroup(mSessionID))
  101. {
  102. mFactoryMap["panel_im_control_panel"] = LLCallbackMap(createPanelGroupControl, this);
  103. }
  104. else
  105. {
  106. mFactoryMap["panel_im_control_panel"] = LLCallbackMap(createPanelAdHocControl, this);
  107. }
  108. break;
  109. default: break;
  110. }
  111. }
  112. setOverlapsScreenChannel(true);
  114. LLTransientFloaterMgr::getInstance()->addControlView(LLTransientFloaterMgr::IM, this);
  115. }
  117. void LLIMFloater::onFocusLost()
  118. {
  119. LLIMModel::getInstance()->resetActiveSessionID();
  121. LLBottomTray::getInstance()->getChicletPanel()->setChicletToggleState(mSessionID, false);
  122. }
  124. void LLIMFloater::onFocusReceived()
  125. {
  126. LLIMModel::getInstance()->setActiveSessionID(mSessionID);
  128. // return focus to the input field when active tab in the multitab container is clicked.
  129. if (isChatMultiTab() && mInputEditor)
  130. {
  131. mInputEditor->setFocus(TRUE);
  132. }
  134. LLBottomTray::getInstance()->getChicletPanel()->setChicletToggleState(mSessionID, true);
  135. }
  137. // virtual
  138. void LLIMFloater::onClose(bool app_quitting)
  139. {
  140. setTyping(false);
  142. // The source of much argument and design thrashing
  143. // Should the window hide or the session close when the X is clicked?
  144. //
  145. // Last change:
  146. // EXT-3516 X Button should end IM session, _ button should hide
  147. gIMMgr->leaveSession(mSessionID);
  148. }
  150. /* static */
  151. void LLIMFloater::newIMCallback(const LLSD& data){
  153. if (data["num_unread"].asInteger() > 0 || data["from_id"].asUUID().isNull())
  154. {
  155. LLUUID session_id = data["session_id"].asUUID();
  157. LLIMFloater* floater = LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
  158. if (floater == NULL) return;
  160.         // update if visible, otherwise will be updated when opened
  161. if (floater->getVisible())
  162. {
  163. floater->updateMessages();
  164. }
  165. }
  166. }
  168. void LLIMFloater::onVisibilityChange(const LLSD& new_visibility)
  169. {
  170. bool visible = new_visibility.asBoolean();
  172. LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);
  174. if (visible && voice_channel &&
  175. voice_channel->getState() == LLVoiceChannel::STATE_CONNECTED)
  176. {
  177. LLFloaterReg::showInstance("voice_call", mSessionID);
  178. }
  179. else
  180. {
  181. LLFloaterReg::hideInstance("voice_call", mSessionID);
  182. }
  183. }
  185. void LLIMFloater::onSendMsg( LLUICtrl* ctrl, void* userdata )
  186. {
  187. LLIMFloater* self = (LLIMFloater*) userdata;
  188. self->sendMsg();
  189. self->setTyping(false);
  190. }
  192. void LLIMFloater::sendMsg()
  193. {
  194. if (!gAgent.isGodlike() 
  195. && (mDialog == IM_NOTHING_SPECIAL)
  196. && mOtherParticipantUUID.isNull())
  197. {
  198. llinfos << "Cannot send IM to everyone unless you're a god." << llendl;
  199. return;
  200. }
  202. if (mInputEditor)
  203. {
  204. LLWString text = mInputEditor->getConvertedText();
  205. if(!text.empty())
  206. {
  207. // Truncate and convert to UTF8 for transport
  208. std::string utf8_text = wstring_to_utf8str(text);
  209. utf8_text = utf8str_truncate(utf8_text, MAX_MSG_BUF_SIZE - 1);
  211. if (mSessionInitialized)
  212. {
  213. LLIMModel::sendMessage(utf8_text, mSessionID,
  214. mOtherParticipantUUID,mDialog);
  215. }
  216. else
  217. {
  218. //queue up the message to send once the session is initialized
  219. mQueuedMsgsForInit.append(utf8_text);
  220. }
  222. mInputEditor->setText(LLStringUtil::null);
  224. updateMessages();
  225. }
  226. }
  227. }
  231. LLIMFloater::~LLIMFloater()
  232. {
  233. LLTransientFloaterMgr::getInstance()->removeControlView(LLTransientFloaterMgr::IM, this);
  234. }
  236. //virtual
  237. BOOL LLIMFloater::postBuild()
  238. {
  239. // User-resizable control panels in P2P sessions look ugly (EXT-3470).
  240. if (mDialog == IM_NOTHING_SPECIAL || mDialog == IM_SESSION_P2P_INVITE)
  241. {
  242. getChild<LLLayoutStack>("im_panels")->setPanelUserResize("panel_im_control_panel", FALSE);
  243. }
  245. const LLUUID& other_party_id = LLIMModel::getInstance()->getOtherParticipantID(mSessionID);
  246. if (other_party_id.notNull())
  247. {
  248. mOtherParticipantUUID = other_party_id;
  249. }
  251. mControlPanel->setSessionId(mSessionID);
  252. mControlPanel->setVisible(gSavedSettings.getBOOL("IMShowControlPanel"));
  254. LLButton* slide_left = getChild<LLButton>("slide_left_btn");
  255. slide_left->setVisible(mControlPanel->getVisible());
  256. slide_left->setClickedCallback(boost::bind(&LLIMFloater::onSlide, this));
  258. LLButton* slide_right = getChild<LLButton>("slide_right_btn");
  259. slide_right->setVisible(!mControlPanel->getVisible());
  260. slide_right->setClickedCallback(boost::bind(&LLIMFloater::onSlide, this));
  262. mInputEditor = getChild<LLLineEditor>("chat_editor");
  263. mInputEditor->setMaxTextLength(1023);
  264. // enable line history support for instant message bar
  265. mInputEditor->setEnableLineHistory(TRUE);
  268. mInputEditor->setFocusReceivedCallback( boost::bind(onInputEditorFocusReceived, _1, this) );
  269. mInputEditor->setFocusLostCallback( boost::bind(onInputEditorFocusLost, _1, this) );
  270. mInputEditor->setKeystrokeCallback( onInputEditorKeystroke, this );
  271. mInputEditor->setCommitOnFocusLost( FALSE );
  272. mInputEditor->setRevertOnEsc( FALSE );
  273. mInputEditor->setReplaceNewlinesWithSpaces( FALSE );
  274. mInputEditor->setPassDelete( TRUE );
  276. std::string session_name(LLIMModel::instance().getName(mSessionID));
  278. mInputEditor->setLabel(LLTrans::getString("IM_to_label") + " " + session_name);
  280. setTitle(session_name);
  282. childSetCommitCallback("chat_editor", onSendMsg, this);
  284. mChatHistory = getChild<LLChatHistory>("chat_history");
  286. setDocked(true);
  288. mTypingStart = LLTrans::getString("IM_typing_start_string");
  290. // Disable input editor if session cannot accept text
  291. LLIMModel::LLIMSession* im_session =
  292. LLIMModel::instance().findIMSession(mSessionID);
  293. if( im_session && !im_session->mTextIMPossible )
  294. {
  295. mInputEditor->setEnabled(FALSE);
  296. mInputEditor->setLabel(LLTrans::getString("IM_unavailable_text_label"));
  297. }
  299. //*TODO if session is not initialized yet, add some sort of a warning message like "starting session...blablabla"
  300. //see LLFloaterIMPanel for how it is done (IB)
  302. if(isChatMultiTab())
  303. {
  304. return LLFloater::postBuild();
  305. }
  306. else
  307. {
  308. return LLDockableFloater::postBuild();
  309. }
  310. }
  312. // virtual
  313. void LLIMFloater::draw()
  314. {
  315. if ( mMeTyping )
  316. {
  317. // Time out if user hasn't typed for a while.
  318. if ( mTypingTimeoutTimer.getElapsedTimeF32() > LLAgent::TYPING_TIMEOUT_SECS )
  319. {
  320. setTyping(false);
  321. }
  322. }
  324. LLTransientDockableFloater::draw();
  325. }
  328. // static
  329. void* LLIMFloater::createPanelIMControl(void* userdata)
  330. {
  331. LLIMFloater *self = (LLIMFloater*)userdata;
  332. self->mControlPanel = new LLPanelIMControlPanel();
  333. self->mControlPanel->setXMLFilename("panel_im_control_panel.xml");
  334. return self->mControlPanel;
  335. }
  338. // static
  339. void* LLIMFloater::createPanelGroupControl(void* userdata)
  340. {
  341. LLIMFloater *self = (LLIMFloater*)userdata;
  342. self->mControlPanel = new LLPanelGroupControlPanel(self->mSessionID);
  343. self->mControlPanel->setXMLFilename("panel_group_control_panel.xml");
  344. return self->mControlPanel;
  345. }
  347. // static
  348. void* LLIMFloater::createPanelAdHocControl(void* userdata)
  349. {
  350. LLIMFloater *self = (LLIMFloater*)userdata;
  351. self->mControlPanel = new LLPanelAdHocControlPanel(self->mSessionID);
  352. self->mControlPanel->setXMLFilename("panel_adhoc_control_panel.xml");
  353. return self->mControlPanel;
  354. }
  356. void LLIMFloater::onSlide()
  357. {
  358. mControlPanel->setVisible(!mControlPanel->getVisible());
  360. gSavedSettings.setBOOL("IMShowControlPanel", mControlPanel->getVisible());
  362. getChild<LLButton>("slide_left_btn")->setVisible(mControlPanel->getVisible());
  363. getChild<LLButton>("slide_right_btn")->setVisible(!mControlPanel->getVisible());
  365. LLLayoutStack* stack = getChild<LLLayoutStack>("im_panels");
  366. if (stack) stack->setAnimate(true);
  367. }
  369. //static
  370. LLIMFloater* LLIMFloater::show(const LLUUID& session_id)
  371. {
  372. if (!gIMMgr->hasSession(session_id)) return NULL;
  374. if(!isChatMultiTab())
  375. {
  376. //hide all
  377. LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("impanel");
  378. for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin();
  379.  iter != inst_list.end(); ++iter)
  380. {
  381. LLIMFloater* floater = dynamic_cast<LLIMFloater*>(*iter);
  382. if (floater && floater->isDocked())
  383. {
  384. floater->setVisible(false);
  385. }
  386. }
  387. }
  389. bool exist = findInstance(session_id);
  391. LLIMFloater* floater = getInstance(session_id);
  392. if (!floater) return NULL;
  394. if(isChatMultiTab())
  395. {
  396. LLIMFloaterContainer* floater_container = LLIMFloaterContainer::getInstance();
  398. // do not add existed floaters to avoid adding torn off instances
  399. if (!exist)
  400. {
  401. // LLTabContainer::eInsertionPoint i_pt = user_initiated ? LLTabContainer::RIGHT_OF_CURRENT : LLTabContainer::END;
  402. // TODO: mantipov: use LLTabContainer::RIGHT_OF_CURRENT if it exists
  403. LLTabContainer::eInsertionPoint i_pt = LLTabContainer::END;
  405. if (floater_container)
  406. {
  407. floater_container->addFloater(floater, TRUE, i_pt);
  408. }
  409. }
  411. floater->openFloater(floater->getKey());
  412. }
  413. else
  414. {
  415. // Docking may move chat window, hide it before moving, or user will see how window "jumps"
  416. floater->setVisible(false);
  418. if (floater->getDockControl() == NULL)
  419. {
  420. LLChiclet* chiclet =
  421. LLBottomTray::getInstance()->getChicletPanel()->findChiclet<LLChiclet>(
  422. session_id);
  423. if (chiclet == NULL)
  424. {
  425. llerror("Dock chiclet for LLIMFloater doesn't exists", 0);
  426. }
  427. else
  428. {
  429. LLBottomTray::getInstance()->getChicletPanel()->scrollToChiclet(chiclet);
  430. }
  432. floater->setDockControl(new LLDockControl(chiclet, floater, floater->getDockTongue(),
  433. LLDockControl::TOP,  boost::bind(&LLIMFloater::getAllowedRect, floater, _1)));
  434. }
  436. // window is positioned, now we can show it.
  437. }
  438. floater->setVisible(TRUE);
  440. return floater;
  441. }
  443. void LLIMFloater::getAllowedRect(LLRect& rect)
  444. {
  445. rect = gViewerWindow->getWorldViewRectRaw();
  446. static S32 right_padding = 0;
  447. if (right_padding == 0)
  448. {
  449. LLPanel* side_bar_tabs =
  450. gViewerWindow->getRootView()->getChild<LLPanel> (
  451. "side_bar_tabs");
  452. right_padding = side_bar_tabs->getRect().getWidth();
  453. LLTransientFloaterMgr::getInstance()->addControlView(side_bar_tabs);
  454. }
  455. rect.mRight -= right_padding;
  456. }
  458. void LLIMFloater::setDocked(bool docked, bool pop_on_undock)
  459. {
  460. // update notification channel state
  461. LLNotificationsUI::LLScreenChannel* channel = dynamic_cast<LLNotificationsUI::LLScreenChannel*>
  462. (LLNotificationsUI::LLChannelManager::getInstance()->
  463. findChannelByID(LLUUID(gSavedSettings.getString("NotificationChannelUUID"))));
  465. if(!isChatMultiTab())
  466. {
  467. LLTransientDockableFloater::setDocked(docked, pop_on_undock);
  468. }
  470. // update notification channel state
  471. if(channel)
  472. {
  473. channel->updateShowToastsState();
  474. channel->redrawToasts();
  475. }
  476. }
  478. void LLIMFloater::setVisible(BOOL visible)
  479. {
  480. LLNotificationsUI::LLScreenChannel* channel = dynamic_cast<LLNotificationsUI::LLScreenChannel*>
  481. (LLNotificationsUI::LLChannelManager::getInstance()->
  482. findChannelByID(LLUUID(gSavedSettings.getString("NotificationChannelUUID"))));
  483. LLTransientDockableFloater::setVisible(visible);
  485. // update notification channel state
  486. if(channel)
  487. {
  488. channel->updateShowToastsState();
  489. channel->redrawToasts();
  490. }
  492. BOOL is_minimized = visible && isChatMultiTab()
  493. ? LLIMFloaterContainer::getInstance()->isMinimized()
  494. : !visible;
  496. if (!is_minimized && mChatHistory && mInputEditor)
  497. {
  498. //only if floater was construced and initialized from xml
  499. updateMessages();
  500. //prevent steal focus when IM opened in multitab mode
  501. if (!isChatMultiTab())
  502. {
  503. mInputEditor->setFocus(TRUE);
  504. }
  505. }
  507. if(!visible)
  508. {
  509. LLIMChiclet* chiclet = LLBottomTray::getInstance()->getChicletPanel()->findChiclet<LLIMChiclet>(mSessionID);
  510. if(chiclet)
  511. {
  512. chiclet->setToggleState(false);
  513. }
  514. }
  515. }
  517. BOOL LLIMFloater::getVisible()
  518. {
  519. if(isChatMultiTab())
  520. {
  521. LLIMFloaterContainer* im_container = LLIMFloaterContainer::getInstance();
  523. // Treat inactive floater as invisible.
  524. bool is_active = im_container->getActiveFloater() == this;
  526. //torn off floater is always inactive
  527. if (!is_active && getHost() != im_container)
  528. {
  529. return LLTransientDockableFloater::getVisible();
  530. }
  532. // getVisible() returns TRUE when Tabbed IM window is minimized.
  533. return is_active && !im_container->isMinimized() && im_container->getVisible();
  534. }
  535. else
  536. {
  537. return LLTransientDockableFloater::getVisible();
  538. }
  539. }
  541. //static
  542. bool LLIMFloater::toggle(const LLUUID& session_id)
  543. {
  544. if(!isChatMultiTab())
  545. {
  546. LLIMFloater* floater = LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
  547. if (floater && floater->getVisible() && floater->hasFocus())
  548. {
  549. // clicking on chiclet to close floater just hides it to maintain existing
  550. // scroll/text entry state
  551. floater->setVisible(false);
  552. return false;
  553. }
  554. else if(floater && (!floater->isDocked() || floater->getVisible() && !floater->hasFocus()))
  555. {
  556. floater->setVisible(TRUE);
  557. floater->setFocus(TRUE);
  558. return true;
  559. }
  560. }
  562. // ensure the list of messages is updated when floater is made visible
  563. show(session_id);
  564. return true;
  565. }
  567. //static
  568. LLIMFloater* LLIMFloater::findInstance(const LLUUID& session_id)
  569. {
  570. return LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
  571. }
  573. LLIMFloater* LLIMFloater::getInstance(const LLUUID& session_id)
  574. {
  575. return LLFloaterReg::getTypedInstance<LLIMFloater>("impanel", session_id);
  576. }
  578. void LLIMFloater::sessionInitReplyReceived(const LLUUID& im_session_id)
  579. {
  580. mSessionInitialized = true;
  582. //will be different only for an ad-hoc im session
  583. if (mSessionID != im_session_id)
  584. {
  585. mSessionID = im_session_id;
  586. setKey(im_session_id);
  587. mControlPanel->setSessionId(im_session_id);
  588. }
  590. // updating "Call" button from group control panel here to enable it without placing into draw() (EXT-4796)
  591. if(gAgent.isInGroup(im_session_id))
  592. {
  593. mControlPanel->updateCallButton();
  594. }
  596. //*TODO here we should remove "starting session..." warning message if we added it in postBuild() (IB)
  599. //need to send delayed messaged collected while waiting for session initialization
  600. if (!mQueuedMsgsForInit.size()) return;
  601. LLSD::array_iterator iter;
  602. for ( iter = mQueuedMsgsForInit.beginArray();
  603. iter != mQueuedMsgsForInit.endArray();
  604. ++iter)
  605. {
  606. LLIMModel::sendMessage(iter->asString(), mSessionID,
  607. mOtherParticipantUUID, mDialog);
  608. }
  609. }
  611. void LLIMFloater::updateMessages()
  612. {
  613. bool use_plain_text_chat_history = gSavedSettings.getBOOL("PlainTextChatHistory");
  615. std::list<LLSD> messages;
  616. LLIMModel::instance().getMessages(mSessionID, messages, mLastMessageIndex+1);
  618. if (messages.size())
  619. {
  620. // LLUIColor chat_color = LLUIColorTable::instance().getColor("IMChatColor");
  622. LLSD chat_args;
  623. chat_args["use_plain_text_chat_history"] = use_plain_text_chat_history;
  625. std::ostringstream message;
  626. std::list<LLSD>::const_reverse_iterator iter = messages.rbegin();
  627. std::list<LLSD>::const_reverse_iterator iter_end = messages.rend();
  628. for (; iter != iter_end; ++iter)
  629. {
  630. LLSD msg = *iter;
  632. std::string time = msg["time"].asString();
  633. LLUUID from_id = msg["from_id"].asUUID();
  634. std::string from = msg["from"].asString();
  635. std::string message = msg["message"].asString();
  637. LLChat chat;
  638. chat.mFromID = from_id;
  639. chat.mSessionID = mSessionID;
  640. chat.mFromName = from;
  641. chat.mTimeStr = time;
  643. // process offer notification
  644. if (msg.has("notification_id"))
  645. {
  646. chat.mNotifId = msg["notification_id"].asUUID();
  647. }
  648. //process text message
  649. else
  650. {
  651. chat.mText = message;
  652. }
  654. mChatHistory->appendMessage(chat, chat_args);
  655. mLastMessageIndex = msg["index"].asInteger();
  656. }
  657. }
  658. }
  660. void LLIMFloater::reloadMessages()
  661. {
  662. mChatHistory->clear();
  663. mLastMessageIndex = -1;
  664. updateMessages();
  665. }
  667. // static
  668. void LLIMFloater::onInputEditorFocusReceived( LLFocusableElement* caller, void* userdata )
  669. {
  670. LLIMFloater* self= (LLIMFloater*) userdata;
  672. // Allow enabling the LLIMFloater input editor only if session can accept text
  673. LLIMModel::LLIMSession* im_session =
  674. LLIMModel::instance().findIMSession(self->mSessionID);
  675. //TODO: While disabled lllineeditor can receive focus we need to check if it is enabled (EK)
  676. if( im_session && im_session->mTextIMPossible && self->mInputEditor->getEnabled())
  677. {
  678. //in disconnected state IM input editor should be disabled
  679. self->mInputEditor->setEnabled(!gDisconnected);
  680. }
  682. // when IM Floater is a part of the multitab container LLTabContainer set focus to the first
  683. // child on tab button's mouse up. This leads input field lost focus. See EXT-3852.
  684. if (isChatMultiTab())
  685. {
  686. // So, clear control captured mouse to prevent LLTabContainer set focus on the panel's first child.
  687. // do not pass self->mInputEditor, this leads to have "Edit Text" mouse pointer wherever it is.
  688. gFocusMgr.setMouseCapture(NULL);
  689. }
  690. }
  692. // static
  693. void LLIMFloater::onInputEditorFocusLost(LLFocusableElement* caller, void* userdata)
  694. {
  695. LLIMFloater* self = (LLIMFloater*) userdata;
  696. self->setTyping(false);
  697. }
  699. // static
  700. void LLIMFloater::onInputEditorKeystroke(LLLineEditor* caller, void* userdata)
  701. {
  702. LLIMFloater* self = (LLIMFloater*)userdata;
  703. std::string text = self->mInputEditor->getText();
  704. if (!text.empty())
  705. {
  706. self->setTyping(true);
  707. }
  708. else
  709. {
  710. // Deleting all text counts as stopping typing.
  711. self->setTyping(false);
  712. }
  713. }
  715. void LLIMFloater::setTyping(bool typing)
  716. {
  717. if ( typing )
  718. {
  719. // Started or proceeded typing, reset the typing timeout timer
  720. mTypingTimeoutTimer.reset();
  721. }
  723. if ( mMeTyping != typing )
  724. {
  725. // Typing state is changed
  726. mMeTyping = typing;
  727. // So, should send current state
  728. mShouldSendTypingState = true;
  729. // In case typing is started, send state after some delay
  730. mTypingTimer.reset();
  731. }
  733. // Don't want to send typing indicators to multiple people, potentially too
  734. // much network traffic. Only send in person-to-person IMs.
  735. if ( mShouldSendTypingState && mDialog == IM_NOTHING_SPECIAL )
  736. {
  737. if ( mMeTyping )
  738. {
  739. if ( mTypingTimer.getElapsedTimeF32() > 1.f )
  740. {
  741. // Still typing, send 'start typing' notification
  742. LLIMModel::instance().sendTypingState(mSessionID, mOtherParticipantUUID, TRUE);
  743. mShouldSendTypingState = false;
  744. }
  745. }
  746. else
  747. {
  748. // Send 'stop typing' notification immediately
  749. LLIMModel::instance().sendTypingState(mSessionID, mOtherParticipantUUID, FALSE);
  750. mShouldSendTypingState = false;
  751. }
  752. }
  754. LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
  755. if (speaker_mgr)
  756. speaker_mgr->setSpeakerTyping(gAgent.getID(), FALSE);
  758. }
  760. void LLIMFloater::processIMTyping(const LLIMInfo* im_info, BOOL typing)
  761. {
  762. if ( typing )
  763. {
  764. // other user started typing
  765. addTypingIndicator(im_info);
  766. }
  767. else
  768. {
  769. // other user stopped typing
  770. removeTypingIndicator(im_info);
  771. }
  772. }
  774. void LLIMFloater::processAgentListUpdates(const LLSD& body)
  775. {
  776. if ( !body.isMap() ) return;
  778. if ( body.has("agent_updates") && body["agent_updates"].isMap() )
  779. {
  780. LLSD agent_data = body["agent_updates"].get(gAgentID.asString());
  781. if (agent_data.isMap() && agent_data.has("info"))
  782. {
  783. LLSD agent_info = agent_data["info"];
  785. if (agent_info.has("mutes"))
  786. {
  787. BOOL moderator_muted_text = agent_info["mutes"]["text"].asBoolean(); 
  788. mInputEditor->setEnabled(!moderator_muted_text);
  789. std::string label;
  790. if (moderator_muted_text)
  791. label = LLTrans::getString("IM_muted_text_label");
  792. else
  793. label = LLTrans::getString("IM_to_label") + " " + LLIMModel::instance().getName(mSessionID);
  794. mInputEditor->setLabel(label);
  796. if (moderator_muted_text)
  797. LLNotificationsUtil::add("TextChatIsMutedByModerator");
  798. }
  799. }
  800. }
  801. }
  803. void LLIMFloater::updateChatHistoryStyle()
  804. {
  805. mChatHistory->clear();
  806. mLastMessageIndex = -1;
  807. updateMessages();
  808. }
  810. void LLIMFloater::processChatHistoryStyleUpdate(const LLSD& newvalue)
  811. {
  812. LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("impanel");
  813. for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin();
  814.  iter != inst_list.end(); ++iter)
  815. {
  816. LLIMFloater* floater = dynamic_cast<LLIMFloater*>(*iter);
  817. if (floater)
  818. {
  819. floater->updateChatHistoryStyle();
  820. }
  821. }
  823. }
  825. void LLIMFloater::processSessionUpdate(const LLSD& session_update)
  826. {
  827. // *TODO : verify following code when moderated mode will be implemented
  828. if ( false && session_update.has("moderated_mode") &&
  829.  session_update["moderated_mode"].has("voice") )
  830. {
  831. BOOL voice_moderated = session_update["moderated_mode"]["voice"];
  832. const std::string session_label = LLIMModel::instance().getName(mSessionID);
  834. if (voice_moderated)
  835. {
  836. setTitle(session_label + std::string(" ") + LLTrans::getString("IM_moderated_chat_label"));
  837. }
  838. else
  839. {
  840. setTitle(session_label);
  841. }
  843. // *TODO : uncomment this when/if LLPanelActiveSpeakers panel will be added
  844. //update the speakers dropdown too
  845. //mSpeakerPanel->setVoiceModerationCtrlMode(voice_moderated);
  846. }
  847. }
  849. BOOL LLIMFloater::handleDragAndDrop(S32 x, S32 y, MASK mask,
  850.    BOOL drop, EDragAndDropType cargo_type,
  851.    void *cargo_data, EAcceptance *accept,
  852.    std::string& tooltip_msg)
  853. {
  855. if (mDialog == IM_NOTHING_SPECIAL)
  856. {
  857. LLToolDragAndDrop::handleGiveDragAndDrop(mOtherParticipantUUID, mSessionID, drop,
  858.  cargo_type, cargo_data, accept);
  859. }
  861. // handle case for dropping calling cards (and folders of calling cards) onto invitation panel for invites
  862. else if (isInviteAllowed())
  863. {
  864. *accept = ACCEPT_NO;
  866. if (cargo_type == DAD_CALLINGCARD)
  867. {
  868. if (dropCallingCard((LLInventoryItem*)cargo_data, drop))
  869. {
  870. *accept = ACCEPT_YES_MULTI;
  871. }
  872. }
  873. else if (cargo_type == DAD_CATEGORY)
  874. {
  875. if (dropCategory((LLInventoryCategory*)cargo_data, drop))
  876. {
  877. *accept = ACCEPT_YES_MULTI;
  878. }
  879. }
  880. }
  881. return TRUE;
  882. }
  884. BOOL LLIMFloater::dropCallingCard(LLInventoryItem* item, BOOL drop)
  885. {
  886. BOOL rv = isInviteAllowed();
  887. if(rv && item && item->getCreatorUUID().notNull())
  888. {
  889. if(drop)
  890. {
  891. std::vector<LLUUID> ids;
  892. ids.push_back(item->getCreatorUUID());
  893. inviteToSession(ids);
  894. }
  895. }
  896. else
  897. {
  898. // set to false if creator uuid is null.
  899. rv = FALSE;
  900. }
  901. return rv;
  902. }
  904. BOOL LLIMFloater::dropCategory(LLInventoryCategory* category, BOOL drop)
  905. {
  906. BOOL rv = isInviteAllowed();
  907. if(rv && category)
  908. {
  909. LLInventoryModel::cat_array_t cats;
  910. LLInventoryModel::item_array_t items;
  911. LLUniqueBuddyCollector buddies;
  912. gInventory.collectDescendentsIf(category->getUUID(),
  913. cats,
  914. items,
  915. LLInventoryModel::EXCLUDE_TRASH,
  916. buddies);
  917. S32 count = items.count();
  918. if(count == 0)
  919. {
  920. rv = FALSE;
  921. }
  922. else if(drop)
  923. {
  924. std::vector<LLUUID> ids;
  925. ids.reserve(count);
  926. for(S32 i = 0; i < count; ++i)
  927. {
  928. ids.push_back(items.get(i)->getCreatorUUID());
  929. }
  930. inviteToSession(ids);
  931. }
  932. }
  933. return rv;
  934. }
  936. BOOL LLIMFloater::isInviteAllowed() const
  937. {
  939. return ( (IM_SESSION_CONFERENCE_START == mDialog)
  940.  || (IM_SESSION_INVITE == mDialog) );
  941. }
  943. class LLSessionInviteResponder : public LLHTTPClient::Responder
  944. {
  945. public:
  946. LLSessionInviteResponder(const LLUUID& session_id)
  947. {
  948. mSessionID = session_id;
  949. }
  951. void error(U32 statusNum, const std::string& reason)
  952. {
  953. llinfos << "Error inviting all agents to session" << llendl;
  954. //throw something back to the viewer here?
  955. }
  957. private:
  958. LLUUID mSessionID;
  959. };
  961. BOOL LLIMFloater::inviteToSession(const std::vector<LLUUID>& ids)
  962. {
  963. LLViewerRegion* region = gAgent.getRegion();
  964. if (!region)
  965. {
  966. return FALSE;
  967. }
  969. S32 count = ids.size();
  971. if( isInviteAllowed() && (count > 0) )
  972. {
  973. llinfos << "LLIMFloater::inviteToSession() - inviting participants" << llendl;
  975. std::string url = region->getCapability("ChatSessionRequest");
  977. LLSD data;
  979. data["params"] = LLSD::emptyArray();
  980. for (int i = 0; i < count; i++)
  981. {
  982. data["params"].append(ids[i]);
  983. }
  985. data["method"] = "invite";
  986. data["session-id"] = mSessionID;
  987. LLHTTPClient::post(
  988. url,
  989. data,
  990. new LLSessionInviteResponder(
  991. mSessionID));
  992. }
  993. else
  994. {
  995. llinfos << "LLIMFloater::inviteToSession -"
  996. << " no need to invite agents for "
  997. << mDialog << llendl;
  998. // successful add, because everyone that needed to get added
  999. // was added.
  1000. }
  1002. return TRUE;
  1003. }
  1005. void LLIMFloater::addTypingIndicator(const LLIMInfo* im_info)
  1006. {
  1007. // We may have lost a "stop-typing" packet, don't add it twice
  1008. if ( im_info && !mOtherTyping )
  1009. {
  1010. mOtherTyping = true;
  1012. // Create typing is started title string
  1013. LLUIString typing_start(mTypingStart);
  1014. typing_start.setArg("[NAME]", im_info->mName);
  1016. // Save and set new title
  1017. mSavedTitle = getTitle();
  1018. setTitle (typing_start);
  1020. // Update speaker
  1021. LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
  1022. if ( speaker_mgr )
  1023. {
  1024. speaker_mgr->setSpeakerTyping(im_info->mFromID, TRUE);
  1025. }
  1026. }
  1027. }
  1029. void LLIMFloater::removeTypingIndicator(const LLIMInfo* im_info)
  1030. {
  1031. if ( mOtherTyping )
  1032. {
  1033. mOtherTyping = false;
  1035. // Revert the title to saved one
  1036. setTitle(mSavedTitle);
  1038. if ( im_info )
  1039. {
  1040. // Update speaker
  1041. LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
  1042. if ( speaker_mgr )
  1043. {
  1044. speaker_mgr->setSpeakerTyping(im_info->mFromID, FALSE);
  1045. }
  1046. }
  1048. }
  1049. }
  1051. // static
  1052. bool LLIMFloater::isChatMultiTab()
  1053. {
  1054. // Restart is required in order to change chat window type.
  1055. static bool is_single_window = gSavedSettings.getS32("ChatWindow") == 1;
  1056. return is_single_window;
  1057. }
  1059. // static
  1060. void LLIMFloater::initIMFloater()
  1061. {
  1062. // This is called on viewer start up
  1063. // init chat window type before user changed it in preferences
  1064. isChatMultiTab();
  1065. }
  1067. //static
  1068. void LLIMFloater::sRemoveTypingIndicator(const LLSD& data)
  1069. {
  1070. LLUUID session_id = data["session_id"];
  1071. if (session_id.isNull()) return;
  1073. LLUUID from_id = data["from_id"];
  1074. if (gAgentID == from_id || LLUUID::null == from_id) return;
  1076. LLIMFloater* floater = LLIMFloater::findInstance(session_id);
  1077. if (!floater) return;
  1079. if (IM_NOTHING_SPECIAL != floater->mDialog) return;
  1081. floater->removeTypingIndicator();
  1082. }
  1084. void LLIMFloater::onIMChicletCreated( const LLUUID& session_id )
  1085. {
  1087. if (isChatMultiTab())
  1088. {
  1089. LLIMFloaterContainer* im_box = LLIMFloaterContainer::getInstance();
  1090. if (!im_box) return;
  1092. if (LLIMFloater::findInstance(session_id)) return;
  1094. LLIMFloater* new_tab = LLIMFloater::getInstance(session_id);
  1096. im_box->addFloater(new_tab, FALSE, LLTabContainer::END);
  1097. }
  1099. }