/** * @file LLFloaterIMNearbyChat.cpp * @brief LLFloaterIMNearbyChat class implementation * * $LicenseInfo:firstyear=2002&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "message.h" #include "lliconctrl.h" #include "llappviewer.h" #include "llchatentry.h" #include "llfloaterreg.h" #include "lltrans.h" #include "llfloaterimcontainer.h" #include "llfloatersidepanelcontainer.h" #include "llfocusmgr.h" #include "lllogchat.h" #include "llresizebar.h" #include "llresizehandle.h" #include "lldraghandle.h" #include "llmenugl.h" #include "llviewermenu.h" // for gMenuHolder #include "llfloaterimnearbychathandler.h" #include "llchannelmanager.h" #include "llchathistory.h" #include "llstylemap.h" #include "llavatarnamecache.h" #include "llfloaterreg.h" #include "lltrans.h" #include "llfirstuse.h" #include "llfloaterimnearbychat.h" #include "llagent.h" // gAgent #include "llgesturemgr.h" #include "llmultigesture.h" #include "llkeyboard.h" #include "llanimationstates.h" #include "llviewerstats.h" #include "llcommandhandler.h" #include "llviewercontrol.h" #include "llnavigationbar.h" #include "llwindow.h" #include "llviewerwindow.h" #include "llrootview.h" #include "llviewerchat.h" #include "lltranslate.h" #include "llautoreplace.h" #include "lluiusage.h" S32 LLFloaterIMNearbyChat::sLastSpecialChatChannel = 0; const S32 EXPANDED_HEIGHT = 266; const S32 COLLAPSED_HEIGHT = 60; const S32 EXPANDED_MIN_HEIGHT = 150; // legacy callback glue void send_chat_from_viewer(const std::string& utf8_out_text, EChatType type, S32 channel); struct LLChatTypeTrigger { std::string name; EChatType type; }; static LLChatTypeTrigger sChatTypeTriggers[] = { { "/whisper" , CHAT_TYPE_WHISPER}, { "/shout" , CHAT_TYPE_SHOUT} }; bool cb_do_nothing() { return false; } LLFloaterIMNearbyChat::LLFloaterIMNearbyChat(const LLSD& llsd) : LLFloaterIMSessionTab(LLSD(LLUUID::null)), //mOutputMonitor(NULL), mSpeakerMgr(NULL), mExpandedHeight(COLLAPSED_HEIGHT + EXPANDED_HEIGHT) { mIsP2PChat = false; mIsNearbyChat = true; mSpeakerMgr = LLLocalSpeakerMgr::getInstance(); // Required by LLFloaterIMSessionTab::mGearBtn // But nearby floater has no 'per agent' menu items, mEnableCallbackRegistrar.add("Avatar.EnableGearItem", boost::bind(&cb_do_nothing)); mCommitCallbackRegistrar.add("Avatar.GearDoToSelected", boost::bind(&cb_do_nothing)); mEnableCallbackRegistrar.add("Avatar.CheckGearItem", boost::bind(&cb_do_nothing)); mMinFloaterHeight = EXPANDED_MIN_HEIGHT; } //static LLFloaterIMNearbyChat* LLFloaterIMNearbyChat::buildFloater(const LLSD& key) { LLFloaterReg::getInstance("im_container"); return new LLFloaterIMNearbyChat(key); } //virtual BOOL LLFloaterIMNearbyChat::postBuild() { setIsSingleInstance(TRUE); BOOL result = LLFloaterIMSessionTab::postBuild(); mInputEditor->setAutoreplaceCallback(boost::bind(&LLAutoReplace::autoreplaceCallback, LLAutoReplace::getInstance(), _1, _2, _3, _4, _5)); mInputEditor->setCommitCallback(boost::bind(&LLFloaterIMNearbyChat::onChatBoxCommit, this)); mInputEditor->setKeystrokeCallback(boost::bind(&LLFloaterIMNearbyChat::onChatBoxKeystroke, this)); mInputEditor->setFocusLostCallback(boost::bind(&LLFloaterIMNearbyChat::onChatBoxFocusLost, this)); mInputEditor->setFocusReceivedCallback(boost::bind(&LLFloaterIMNearbyChat::onChatBoxFocusReceived, this)); mInputEditor->setLabel(LLTrans::getString("NearbyChatTitle")); // Title must be defined BEFORE call to addConversationListItem() because // it is used to show the item's name in the conversations list setTitle(LLTrans::getString("NearbyChatTitle")); // obsolete, but may be needed for backward compatibility? gSavedSettings.declareS32("nearbychat_showicons_and_names", 2, "NearByChat header settings", LLControlVariable::PERSIST_NONDFT); if (gSavedPerAccountSettings.getBOOL("LogShowHistory")) { loadHistory(); } return result; } // virtual void LLFloaterIMNearbyChat::closeHostedFloater() { // If detached from conversations window close anyway if (!getHost()) { setVisible(FALSE); } // Should check how many conversations are ongoing. Select next to "Nearby Chat" in case there are some other besides. // Close conversations window in case "Nearby Chat" is attached and the only conversation LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance(); if (floater_container->getConversationListItemSize() == 1) { if (getHost()) { floater_container->closeFloater(); } } else { if (!getHost()) { floater_container->selectNextConversationByID(LLUUID()); } } } // virtual void LLFloaterIMNearbyChat::refresh() { displaySpeakingIndicator(); updateCallBtnState(LLVoiceClient::getInstance()->getUserPTTState()); // *HACK: Update transparency type depending on whether our children have focus. // This is needed because this floater is chrome and thus cannot accept focus, so // the transparency type setting code from LLFloater::setFocus() isn't reached. if (getTransparencyType() != TT_DEFAULT) { setTransparencyType(hasFocus() ? TT_ACTIVE : TT_INACTIVE); } } void LLFloaterIMNearbyChat::reloadMessages(bool clean_messages/* = false*/) { if (clean_messages) { mMessageArchive.clear(); loadHistory(); } mChatHistory->clear(); LLSD do_not_log; do_not_log["do_not_log"] = true; for(std::vector<LLChat>::iterator it = mMessageArchive.begin();it!=mMessageArchive.end();++it) { // Update the messages without re-writing them to a log file. addMessage(*it,false, do_not_log); } } void LLFloaterIMNearbyChat::loadHistory() { LLSD do_not_log; do_not_log["do_not_log"] = true; std::list<LLSD> history; LLLogChat::loadChatHistory("chat", history); std::list<LLSD>::const_iterator it = history.begin(); while (it != history.end()) { const LLSD& msg = *it; std::string from = msg[LL_IM_FROM]; LLUUID from_id; if (msg[LL_IM_FROM_ID].isDefined()) { from_id = msg[LL_IM_FROM_ID].asUUID(); } else { std::string legacy_name = gCacheName->buildLegacyName(from); from_id = LLAvatarNameCache::getInstance()->findIdByName(legacy_name); } LLChat chat; chat.mFromName = from; chat.mFromID = from_id; chat.mText = msg[LL_IM_TEXT].asString(); chat.mTimeStr = msg[LL_IM_TIME].asString(); chat.mChatStyle = CHAT_STYLE_HISTORY; chat.mSourceType = CHAT_SOURCE_AGENT; if (from_id.isNull() && SYSTEM_FROM == from) { chat.mSourceType = CHAT_SOURCE_SYSTEM; } else if (from_id.isNull()) { chat.mSourceType = isWordsName(from) ? CHAT_SOURCE_UNKNOWN : CHAT_SOURCE_OBJECT; } addMessage(chat, true, do_not_log); it++; } } void LLFloaterIMNearbyChat::removeScreenChat() { LLNotificationsUI::LLScreenChannelBase* chat_channel = LLNotificationsUI::LLChannelManager::getInstance()->findChannelByID( LLNotificationsUI::NEARBY_CHAT_CHANNEL_UUID); if(chat_channel) { chat_channel->removeToastsFromChannel(); } } void LLFloaterIMNearbyChat::setVisible(BOOL visible) { LLFloaterIMSessionTab::setVisible(visible); if(visible) { removeScreenChat(); } } void LLFloaterIMNearbyChat::setVisibleAndFrontmost(BOOL take_focus, const LLSD& key) { LLFloaterIMSessionTab::setVisibleAndFrontmost(take_focus, key); if(matchesKey(key)) { LLFloaterIMContainer::getInstance()->selectConversationPair(mSessionID, true, take_focus); } } // virtual void LLFloaterIMNearbyChat::onTearOffClicked() { LLFloaterIMSessionTab::onTearOffClicked(); // see CHUI-170: Save torn-off state of the nearby chat between sessions bool in_the_multifloater(getHost()); gSavedPerAccountSettings.setBOOL("NearbyChatIsNotTornOff", in_the_multifloater); } // virtual void LLFloaterIMNearbyChat::onOpen(const LLSD& key) { LLFloaterIMSessionTab::onOpen(key); if(!isMessagePaneExpanded()) { restoreFloater(); onCollapseToLine(this); } } // virtual void LLFloaterIMNearbyChat::onClose(bool app_quitting) { // Override LLFloaterIMSessionTab::onClose() so that Nearby Chat is not removed from the conversation floater LLFloaterIMSessionTab::restoreFloater(); if (app_quitting) { // We are starting and closing floater in "expanded" state // Update expanded (restored) rect and position for use in next session forceReshape(); storeRectControl(); } } // virtual void LLFloaterIMNearbyChat::onClickCloseBtn(bool) { if (!isTornOff()) { return; } closeHostedFloater(); } void LLFloaterIMNearbyChat::onChatFontChange(LLFontGL* fontp) { // Update things with the new font whohoo if (mInputEditor) { mInputEditor->setFont(fontp); } } void LLFloaterIMNearbyChat::show() { openFloater(getKey()); } bool LLFloaterIMNearbyChat::isChatVisible() const { bool isVisible = false; LLFloaterIMContainer* im_box = LLFloaterIMContainer::getInstance(); // Is the IM floater container ever null? llassert(im_box != NULL); if (im_box != NULL) { isVisible = isChatMultiTab() && gSavedPerAccountSettings.getBOOL("NearbyChatIsNotTornOff")? im_box->getVisible() && !im_box->isMinimized() : getVisible() && !isMinimized(); } return isVisible; } void LLFloaterIMNearbyChat::showHistory() { openFloater(); LLFloaterIMContainer::getInstance()->selectConversation(LLUUID(NULL)); if(!isMessagePaneExpanded()) { restoreFloater(); setFocus(true); } else { LLFloaterIMContainer::getInstance()->setFocus(TRUE); } setResizeLimits(getMinWidth(), EXPANDED_MIN_HEIGHT); } std::string LLFloaterIMNearbyChat::getCurrentChat() { return mInputEditor ? mInputEditor->getText() : LLStringUtil::null; } // virtual BOOL LLFloaterIMNearbyChat::handleKeyHere( KEY key, MASK mask ) { BOOL handled = FALSE; if( KEY_RETURN == key && mask == MASK_CONTROL) { // shout sendChat(CHAT_TYPE_SHOUT); handled = TRUE; } else if (KEY_RETURN == key && mask == MASK_SHIFT) { // whisper sendChat(CHAT_TYPE_WHISPER); handled = TRUE; } if((mask == MASK_ALT) && isTornOff()) { LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance(); if ((KEY_UP == key) || (KEY_LEFT == key)) { floater_container->selectNextorPreviousConversation(false); handled = TRUE; } if ((KEY_DOWN == key ) || (KEY_RIGHT == key)) { floater_container->selectNextorPreviousConversation(true); handled = TRUE; } } return handled; } BOOL LLFloaterIMNearbyChat::matchChatTypeTrigger(const std::string& in_str, std::string* out_str) { U32 in_len = in_str.length(); S32 cnt = sizeof(sChatTypeTriggers) / sizeof(*sChatTypeTriggers); bool string_was_found = false; for (S32 n = 0; n < cnt && !string_was_found; n++) { if (in_len <= sChatTypeTriggers[n].name.length()) { std::string trigger_trunc = sChatTypeTriggers[n].name; LLStringUtil::truncate(trigger_trunc, in_len); if (!LLStringUtil::compareInsensitive(in_str, trigger_trunc)) { *out_str = sChatTypeTriggers[n].name; string_was_found = true; } } } return string_was_found; } void LLFloaterIMNearbyChat::onChatBoxKeystroke() { LLFloaterIMContainer* im_box = LLFloaterIMContainer::findInstance(); if (im_box) { im_box->flashConversationItemWidget(mSessionID,false); } LLFirstUse::otherAvatarChatFirst(false); LLWString raw_text = mInputEditor->getWText(); // Can't trim the end, because that will cause autocompletion // to eat trailing spaces that might be part of a gesture. LLWStringUtil::trimHead(raw_text); S32 length = raw_text.length(); if( (length > 0) && (raw_text[0] != '/') ) // forward slash is used for escape (eg. emote) sequences { gAgent.startTyping(); } else { gAgent.stopTyping(); } /* Doesn't work -- can't tell the difference between a backspace that killed the selection vs. backspace at the end of line. if (length > 1 && text[0] == '/' && key == KEY_BACKSPACE) { // the selection will already be deleted, but we need to trim // off the character before std::string new_text = raw_text.substr(0, length-1); mInputEditor->setText( new_text ); mInputEditor->setCursorToEnd(); length = length - 1; } */ KEY key = gKeyboard->currentKey(); // Ignore "special" keys, like backspace, arrows, etc. if (gSavedSettings.getBOOL("ChatAutocompleteGestures") && length > 1 && raw_text[0] == '/' && key < KEY_SPECIAL) { // we're starting a gesture, attempt to autocomplete std::string utf8_trigger = wstring_to_utf8str(raw_text); std::string utf8_out_str(utf8_trigger); if (LLGestureMgr::instance().matchPrefix(utf8_trigger, &utf8_out_str)) { std::string rest_of_match = utf8_out_str.substr(utf8_trigger.size()); if (!rest_of_match.empty()) { mInputEditor->setText(utf8_trigger + rest_of_match); // keep original capitalization for user-entered part // Select to end of line, starting from the character // after the last one the user typed. mInputEditor->selectByCursorPosition(utf8_out_str.size()-rest_of_match.size(),utf8_out_str.size()); } } else if (matchChatTypeTrigger(utf8_trigger, &utf8_out_str)) { std::string rest_of_match = utf8_out_str.substr(utf8_trigger.size()); mInputEditor->setText(utf8_trigger + rest_of_match + " "); // keep original capitalization for user-entered part mInputEditor->endOfDoc(); } //LL_INFOS() << "GESTUREDEBUG " << trigger // << " len " << length // << " outlen " << out_str.getLength() // << LL_ENDL; } } // static void LLFloaterIMNearbyChat::onChatBoxFocusLost() { // stop typing animation gAgent.stopTyping(); } void LLFloaterIMNearbyChat::onChatBoxFocusReceived() { mInputEditor->setEnabled(!gDisconnected); } EChatType LLFloaterIMNearbyChat::processChatTypeTriggers(EChatType type, std::string &str) { U32 length = str.length(); S32 cnt = sizeof(sChatTypeTriggers) / sizeof(*sChatTypeTriggers); for (S32 n = 0; n < cnt; n++) { if (length >= sChatTypeTriggers[n].name.length()) { std::string trigger = str.substr(0, sChatTypeTriggers[n].name.length()); if (!LLStringUtil::compareInsensitive(trigger, sChatTypeTriggers[n].name)) { U32 trigger_length = sChatTypeTriggers[n].name.length(); // It's to remove space after trigger name if (length > trigger_length && str[trigger_length] == ' ') trigger_length++; str = str.substr(trigger_length, length); if (CHAT_TYPE_NORMAL == type) return sChatTypeTriggers[n].type; else break; } } } return type; } void LLFloaterIMNearbyChat::sendChat( EChatType type ) { if (mInputEditor) { LLWString text = mInputEditor->getWText(); LLWStringUtil::trim(text); LLWStringUtil::replaceChar(text,182,'\n'); // Convert paragraph symbols back into newlines. if (!text.empty()) { // Check if this is destined for another channel S32 channel = 0; stripChannelNumber(text, &channel); std::string utf8text = wstring_to_utf8str(text); // Try to trigger a gesture, if not chat to a script. std::string utf8_revised_text; if (0 == channel) { // discard returned "found" boolean if(!LLGestureMgr::instance().triggerAndReviseString(utf8text, &utf8_revised_text)) { utf8_revised_text = utf8text; } } else { utf8_revised_text = utf8text; } utf8_revised_text = utf8str_trim(utf8_revised_text); type = processChatTypeTriggers(type, utf8_revised_text); if (!utf8_revised_text.empty()) { // Chat with animation sendChatFromViewer(utf8_revised_text, type, gSavedSettings.getBOOL("PlayChatAnim")); } } mInputEditor->setText(LLStringExplicit("")); } gAgent.stopTyping(); // If the user wants to stop chatting on hitting return, lose focus // and go out of chat mode. if (gSavedSettings.getBOOL("CloseChatOnReturn")) { stopChat(); } } void LLFloaterIMNearbyChat::addMessage(const LLChat& chat,bool archive,const LLSD &args) { appendMessage(chat, args); if(archive) { mMessageArchive.push_back(chat); if(mMessageArchive.size() > 200) { mMessageArchive.erase(mMessageArchive.begin()); } } // logging if (!args["do_not_log"].asBoolean() && gSavedPerAccountSettings.getS32("KeepConversationLogTranscripts") > 1) { std::string from_name = chat.mFromName; if (chat.mSourceType == CHAT_SOURCE_AGENT) { // if the chat is coming from an agent, log the complete name LLAvatarName av_name; LLAvatarNameCache::get(chat.mFromID, &av_name); if (!av_name.isDisplayNameDefault()) { from_name = av_name.getCompleteName(); } } LLLogChat::saveHistory("chat", from_name, chat.mFromID, chat.mText); } } void LLFloaterIMNearbyChat::onChatBoxCommit() { sendChat(CHAT_TYPE_NORMAL); gAgent.stopTyping(); } void LLFloaterIMNearbyChat::displaySpeakingIndicator() { LLSpeakerMgr::speaker_list_t speaker_list; LLUUID id; id.setNull(); mSpeakerMgr->update(FALSE); mSpeakerMgr->getSpeakerList(&speaker_list, FALSE); for (LLSpeakerMgr::speaker_list_t::iterator i = speaker_list.begin(); i != speaker_list.end(); ++i) { LLPointer<LLSpeaker> s = *i; if (s->mSpeechVolume > 0 || s->mStatus == LLSpeaker::STATUS_SPEAKING) { id = s->mID; break; } } } void LLFloaterIMNearbyChat::sendChatFromViewer(const std::string &utf8text, EChatType type, BOOL animate) { sendChatFromViewer(utf8str_to_wstring(utf8text), type, animate); } void LLFloaterIMNearbyChat::sendChatFromViewer(const LLWString &wtext, EChatType type, BOOL animate) { // Look for "/20 foo" channel chats. S32 channel = 0; LLWString out_text = stripChannelNumber(wtext, &channel); std::string utf8_out_text = wstring_to_utf8str(out_text); std::string utf8_text = wstring_to_utf8str(wtext); utf8_text = utf8str_trim(utf8_text); if (!utf8_text.empty()) { utf8_text = utf8str_truncate(utf8_text, MAX_STRING - 1); } // Don't animate for chats people can't hear (chat to scripts) if (animate && (channel == 0)) { if (type == CHAT_TYPE_WHISPER) { LL_DEBUGS() << "You whisper " << utf8_text << LL_ENDL; gAgent.sendAnimationRequest(ANIM_AGENT_WHISPER, ANIM_REQUEST_START); } else if (type == CHAT_TYPE_NORMAL) { LL_DEBUGS() << "You say " << utf8_text << LL_ENDL; gAgent.sendAnimationRequest(ANIM_AGENT_TALK, ANIM_REQUEST_START); } else if (type == CHAT_TYPE_SHOUT) { LL_DEBUGS() << "You shout " << utf8_text << LL_ENDL; gAgent.sendAnimationRequest(ANIM_AGENT_SHOUT, ANIM_REQUEST_START); } else { LL_INFOS() << "send_chat_from_viewer() - invalid volume" << LL_ENDL; return; } } else { if (type != CHAT_TYPE_START && type != CHAT_TYPE_STOP) { LL_DEBUGS() << "Channel chat: " << utf8_text << LL_ENDL; } } send_chat_from_viewer(utf8_out_text, type, channel); } // static bool LLFloaterIMNearbyChat::isWordsName(const std::string& name) { // checking to see if it's display name plus username in parentheses S32 open_paren = name.find(" (", 0); S32 close_paren = name.find(')', 0); if (open_paren != std::string::npos && close_paren == name.length()-1) { return true; } else { //checking for a single space S32 pos = name.find(' ', 0); return std::string::npos != pos && name.rfind(' ', name.length()) == pos && 0 != pos && name.length()-1 != pos; } } // static void LLFloaterIMNearbyChat::startChat(const char* line) { LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"); if (nearby_chat) { if(!nearby_chat->isTornOff()) { LLFloaterIMContainer::getInstance()->selectConversation(LLUUID(NULL)); } if(nearby_chat->isMinimized()) { nearby_chat->setMinimized(false); } nearby_chat->show(); nearby_chat->setFocus(TRUE); if (line) { std::string line_string(line); nearby_chat->mInputEditor->setText(line_string); } nearby_chat->mInputEditor->endOfDoc(); } } // Exit "chat mode" and do the appropriate focus changes // static void LLFloaterIMNearbyChat::stopChat() { LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"); if (nearby_chat) { nearby_chat->mInputEditor->setFocus(FALSE); gAgent.stopTyping(); } } // If input of the form "/20foo" or "/20 foo", returns "foo" and channel 20. // Otherwise returns input and channel 0. LLWString LLFloaterIMNearbyChat::stripChannelNumber(const LLWString &mesg, S32* channel) { if (mesg[0] == '/' && mesg[1] == '/') { // This is a "repeat channel send" *channel = sLastSpecialChatChannel; return mesg.substr(2, mesg.length() - 2); } else if (mesg[0] == '/' && mesg[1] && (LLStringOps::isDigit(mesg[1]) || (mesg[1] == '-' && mesg[2] && LLStringOps::isDigit(mesg[2])))) { // This a special "/20" speak on a channel S32 pos = 0; // Copy the channel number into a string LLWString channel_string; llwchar c; do { c = mesg[pos+1]; channel_string.push_back(c); pos++; } while(c && pos < 64 && (LLStringOps::isDigit(c) || (pos==1 && c =='-'))); // Move the pointer forward to the first non-whitespace char // Check isspace before looping, so we can handle "/33foo" // as well as "/33 foo" while(c && iswspace(c)) { c = mesg[pos+1]; pos++; } sLastSpecialChatChannel = strtol(wstring_to_utf8str(channel_string).c_str(), NULL, 10); *channel = sLastSpecialChatChannel; return mesg.substr(pos, mesg.length() - pos); } else { // This is normal chat. *channel = 0; return mesg; } } void send_chat_from_viewer(const std::string& utf8_out_text, EChatType type, S32 channel) { LL_DEBUGS("UIUsage") << "Nearby chat, text " << utf8_out_text << " type " << type << " channel " << channel << LL_ENDL; if (type != CHAT_TYPE_START && type != CHAT_TYPE_STOP) // prune back some redundant logging { LLUIUsage::instance().logCommand("Chat.SendNearby"); // pseuo-command } LLMessageSystem* msg = gMessageSystem; if (channel >= 0) { msg->newMessageFast(_PREHASH_ChatFromViewer); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->nextBlockFast(_PREHASH_ChatData); msg->addStringFast(_PREHASH_Message, utf8_out_text); msg->addU8Fast(_PREHASH_Type, type); msg->addS32("Channel", channel); } else { // Hack: ChatFromViewer doesn't allow negative channels msg->newMessage("ScriptDialogReply"); msg->nextBlock("AgentData"); msg->addUUID("AgentID", gAgentID); msg->addUUID("SessionID", gAgentSessionID); msg->nextBlock("Data"); msg->addUUID("ObjectID", gAgentID); msg->addS32("ChatChannel", channel); msg->addS32("ButtonIndex", 0); msg->addString("ButtonLabel", utf8_out_text); } gAgent.sendReliableMessage(); add(LLStatViewer::CHAT_COUNT, 1); } class LLChatCommandHandler : public LLCommandHandler { public: // not allowed from outside the app LLChatCommandHandler() : LLCommandHandler("chat", UNTRUSTED_BLOCK) { } // Your code here bool handle(const LLSD& tokens, const LLSD& query_map, const std::string& grid, LLMediaCtrl* web) { bool retval = false; // Need at least 2 tokens to have a valid message. if (tokens.size() < 2) { retval = false; } else { S32 channel = tokens[0].asInteger(); // VWR-19499 Restrict function to chat channels greater than 0. if ((channel > 0) && (channel < CHAT_CHANNEL_DEBUG)) { retval = true; // Send unescaped message, see EXT-6353. std::string unescaped_mesg (LLURI::unescape(tokens[1].asString())); send_chat_from_viewer(unescaped_mesg, CHAT_TYPE_NORMAL, channel); } else { retval = false; // Tell us this is an unsupported SLurl. } } return retval; } }; // Creating the object registers with the dispatcher. LLChatCommandHandler gChatHandler;