884 lines
30 KiB
C++
884 lines
30 KiB
C++
/**
|
|
* @file fsnearbychathub.cpp (was llnearbychat.cpp)
|
|
* @brief @brief Nearby chat central class for handling multiple chat input controls
|
|
*
|
|
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
* Copyright (C) 2012, Zi Ree @ Second Life
|
|
*
|
|
* 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 "fsnearbychathub.h"
|
|
|
|
#include "chatbar_as_cmdline.h"
|
|
#include "fscommon.h"
|
|
#include "fsfloaternearbychat.h"
|
|
#include "fsnearbychatcontrol.h"
|
|
#include "llagent.h" // gAgent
|
|
#include "llanimationstates.h" // ANIM_AGENT_WHISPER, ANIM_AGENT_TALK, ANIM_AGENT_SHOUT
|
|
#include "llavatarnamecache.h"
|
|
#include "llchatentry.h"
|
|
#include "llcommandhandler.h"
|
|
#include "llgesturemgr.h"
|
|
#include "lllineeditor.h"
|
|
#include "llspinctrl.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewerinput.h"
|
|
#include "llviewerstats.h"
|
|
#include "llworld.h"
|
|
#include "rlvactions.h"
|
|
#include "rlvhandler.h"
|
|
|
|
constexpr U32 NAME_PREDICTION_MINIMUM_LENGTH = 3;
|
|
|
|
// *HACK* chat bar cannot return its correct height for some reason
|
|
constexpr S32 MAGIC_CHAT_BAR_PAD = 5;
|
|
|
|
struct LLChatTypeTrigger {
|
|
std::string name;
|
|
EChatType type;
|
|
};
|
|
|
|
static LLChatTypeTrigger sChatTypeTriggers[] = {
|
|
{ "/whisper" , CHAT_TYPE_WHISPER},
|
|
{ "/shout" , CHAT_TYPE_SHOUT}
|
|
};
|
|
|
|
|
|
// This function just sends the message, with no other processing. Moved out
|
|
// of send_chat_from_viewer.
|
|
void really_send_chat_from_viewer(const std::string& utf8_out_text, EChatType type, S32 channel)
|
|
{
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
|
|
if (!msg)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (channel >= 0)
|
|
{
|
|
msg->newMessageFast(_PREHASH_ChatFromViewer);
|
|
msg->nextBlockFast(_PREHASH_AgentData);
|
|
msg->addUUIDFast(_PREHASH_AgentID, gAgentID);
|
|
msg->addUUIDFast(_PREHASH_SessionID, gAgentSessionID);
|
|
msg->nextBlockFast(_PREHASH_ChatData);
|
|
msg->addStringFast(_PREHASH_Message, utf8_out_text);
|
|
msg->addU8Fast(_PREHASH_Type, type);
|
|
msg->addS32("Channel", channel);
|
|
}
|
|
else
|
|
{
|
|
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();
|
|
}
|
|
|
|
void send_chat_from_viewer(std::string utf8_out_text, EChatType type, S32 channel)
|
|
{
|
|
// Only process chat messages (ie not CHAT_TYPE_START, CHAT_TYPE_STOP, etc)
|
|
if ( (rlv_handler_t::isEnabled()) && ( (CHAT_TYPE_WHISPER == type) || (CHAT_TYPE_NORMAL == type) || (CHAT_TYPE_SHOUT == type) ) )
|
|
{
|
|
if (0 == channel)
|
|
{
|
|
// (We already did this before, but LLChatHandler::handle() calls this directly)
|
|
if ( ((CHAT_TYPE_SHOUT == type) || (CHAT_TYPE_NORMAL == type)) && (gRlvHandler.hasBehaviour(RLV_BHVR_CHATNORMAL)) )
|
|
type = CHAT_TYPE_WHISPER;
|
|
else if ( (CHAT_TYPE_SHOUT == type) && (gRlvHandler.hasBehaviour(RLV_BHVR_CHATSHOUT)) )
|
|
type = CHAT_TYPE_NORMAL;
|
|
else if ( (CHAT_TYPE_WHISPER == type) && (gRlvHandler.hasBehaviour(RLV_BHVR_CHATWHISPER)) )
|
|
type = CHAT_TYPE_NORMAL;
|
|
|
|
// Redirect chat if needed
|
|
if ( ( (gRlvHandler.hasBehaviour(RLV_BHVR_REDIRCHAT) || (gRlvHandler.hasBehaviour(RLV_BHVR_REDIREMOTE)) ) &&
|
|
(gRlvHandler.redirectChatOrEmote(utf8_out_text)) ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Filter public chat if sendchat restricted
|
|
if (gRlvHandler.hasBehaviour(RLV_BHVR_SENDCHAT))
|
|
gRlvHandler.filterChat(utf8_out_text, true);
|
|
}
|
|
else
|
|
{
|
|
// Don't allow chat on a non-public channel if sendchannel restricted (unless the channel is an exception)
|
|
if (!RlvActions::canSendChannel(channel))
|
|
return;
|
|
|
|
// Don't allow chat on debug channel if @sendchat, @redirchat or @rediremote restricted (shows as public chat on viewers)
|
|
if (CHAT_CHANNEL_DEBUG == channel)
|
|
{
|
|
bool fIsEmote = RlvUtil::isEmote(utf8_out_text);
|
|
if ( (gRlvHandler.hasBehaviour(RLV_BHVR_SENDCHAT)) ||
|
|
((!fIsEmote) && (gRlvHandler.hasBehaviour(RLV_BHVR_REDIRCHAT))) ||
|
|
((fIsEmote) && (gRlvHandler.hasBehaviour(RLV_BHVR_REDIREMOTE))) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t split = MAX_MSG_BUF_SIZE - 1;
|
|
size_t pos = 0;
|
|
size_t total = utf8_out_text.length();
|
|
|
|
// Don't break null messages
|
|
if (total == 0)
|
|
{
|
|
really_send_chat_from_viewer(utf8_out_text, type, channel);
|
|
}
|
|
|
|
while (pos < total)
|
|
{
|
|
size_t next_split = split;
|
|
|
|
if (pos + next_split > total)
|
|
{
|
|
// just send the rest of the message
|
|
next_split = total - pos;
|
|
}
|
|
else
|
|
{
|
|
// first, try to split at a space
|
|
while((U8(utf8_out_text[pos + next_split]) != ' ')
|
|
&& (next_split > 0))
|
|
{
|
|
--next_split;
|
|
}
|
|
|
|
if (next_split == 0)
|
|
{
|
|
next_split = split;
|
|
// no space found, split somewhere not in the middle of UTF-8
|
|
while((U8(utf8_out_text[pos + next_split]) >= 0x80)
|
|
&& (U8(utf8_out_text[pos + next_split]) < 0xC0)
|
|
&& (next_split > 0))
|
|
{
|
|
--next_split;
|
|
}
|
|
}
|
|
|
|
if (next_split == 0)
|
|
{
|
|
next_split = split;
|
|
LL_WARNS("Splitting") << "utf-8 couldn't be split correctly" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
std::string send = utf8_out_text.substr(pos, next_split);
|
|
pos += next_split;
|
|
|
|
// *FIXME: Queue messages and wait for server
|
|
really_send_chat_from_viewer(send, type, channel);
|
|
}
|
|
|
|
// moved here so we don't bump the count for every message segment
|
|
add(LLStatViewer::CHAT_COUNT, 1);
|
|
}
|
|
|
|
bool matchChatTypeTrigger(const std::string& in_str, std::string* out_str)
|
|
{
|
|
size_t in_len = in_str.length();
|
|
S32 cnt = sizeof(sChatTypeTriggers) / sizeof(*sChatTypeTriggers);
|
|
|
|
for (S32 n = 0; n < cnt; n++)
|
|
{
|
|
if (in_len > sChatTypeTriggers[n].name.length())
|
|
continue;
|
|
|
|
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;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// FSNearbyChat
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
S32 FSNearbyChat::sLastSpecialChatChannel = 0;
|
|
|
|
FSNearbyChat::FSNearbyChat() :
|
|
mDefaultChatBar(nullptr),
|
|
mFocusedInputEditor(nullptr)
|
|
{
|
|
gSavedSettings.getControl("MainChatbarVisible")->getSignal()->connect(boost::bind(&FSNearbyChat::onDefaultChatBarButtonClicked, this));
|
|
}
|
|
|
|
FSNearbyChat::~FSNearbyChat()
|
|
{
|
|
}
|
|
|
|
void FSNearbyChat::sendChat(LLWString text, EChatType type)
|
|
{
|
|
LLWStringUtil::trim(text);
|
|
|
|
if (!text.empty())
|
|
{
|
|
FSCommon::updateUsedEmojis(text);
|
|
|
|
if (type == CHAT_TYPE_OOC)
|
|
{
|
|
text = utf8string_to_wstring(gSavedSettings.getString("FSOOCPrefix") + " ") + text + utf8string_to_wstring(" " + gSavedSettings.getString("FSOOCPostfix"));
|
|
}
|
|
|
|
// Check if this is destined for another channel
|
|
S32 channel = 0;
|
|
bool is_set = false;
|
|
stripChannelNumber(text, &channel, &sLastSpecialChatChannel, &is_set);
|
|
|
|
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)
|
|
{
|
|
// Convert OOC and MU* style poses
|
|
utf8text = FSCommon::applyAutoCloseOoc(utf8text);
|
|
utf8text = FSCommon::applyMuPose(utf8text);
|
|
|
|
// 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);
|
|
|
|
EChatType nType = (type == CHAT_TYPE_OOC ? CHAT_TYPE_NORMAL : type);
|
|
type = processChatTypeTriggers(nType, utf8_revised_text);
|
|
|
|
if (!utf8_revised_text.empty() && cmd_line_chat(utf8_revised_text, type))
|
|
{
|
|
// Chat with animation
|
|
sendChatFromViewer(utf8_revised_text, type, gSavedSettings.getBOOL("PlayChatAnim"));
|
|
}
|
|
}
|
|
|
|
gAgent.stopTyping();
|
|
}
|
|
|
|
void FSNearbyChat::sendChatFromViewer(const std::string& utf8text, EChatType type, bool animate)
|
|
{
|
|
sendChatFromViewer(utf8str_to_wstring(utf8text), type, animate);
|
|
}
|
|
|
|
void FSNearbyChat::sendChatFromViewer(const LLWString& wtext, EChatType type, bool animate)
|
|
{
|
|
// Look for "/20 foo" channel chats.
|
|
S32 channel = 0;
|
|
bool is_set = false;
|
|
LLWString out_text = stripChannelNumber(wtext, &channel, &sLastSpecialChatChannel, &is_set);
|
|
sendChatFromViewer(wtext, out_text, type, animate, channel);
|
|
}
|
|
|
|
// all chat bars call this function and we keep the first or one that's seen as the default
|
|
void FSNearbyChat::registerChatBar(FSNearbyChatControl* chatBar)
|
|
{
|
|
if (!mDefaultChatBar || chatBar->isDefault())
|
|
{
|
|
mDefaultChatBar = chatBar;
|
|
}
|
|
}
|
|
|
|
// unhide the default nearby chat bar on request (pressing Enter or a letter key)
|
|
void FSNearbyChat::showDefaultChatBar(bool visible, const char* text) const
|
|
{
|
|
if (!mDefaultChatBar)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// change settings control to signal button state
|
|
gSavedSettings.setBOOL("MainChatbarVisible", visible);
|
|
|
|
mDefaultChatBar->getParent()->setVisible(visible);
|
|
mDefaultChatBar->setVisible(visible);
|
|
mDefaultChatBar->setFocus(visible);
|
|
|
|
// <FS:KC> Fix for bad edge snapping
|
|
if (visible)
|
|
{
|
|
gFloaterView->setSnapOffsetChatBar(mDefaultChatBar->getRect().getHeight() + MAGIC_CHAT_BAR_PAD);
|
|
}
|
|
else
|
|
{
|
|
gFloaterView->setSnapOffsetChatBar(0);
|
|
}
|
|
|
|
if (!text)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (mDefaultChatBar->getText().empty())
|
|
{
|
|
mDefaultChatBar->setText(LLStringExplicit(text));
|
|
mDefaultChatBar->setCursorToEnd();
|
|
}
|
|
// </FS:KC> Fix for bad edge snapping
|
|
}
|
|
|
|
// We want to know which nearby chat editor (if any) currently has focus
|
|
void FSNearbyChat::setFocusedInputEditor(FSNearbyChatControl* inputEditor, bool focus)
|
|
{
|
|
if (focus)
|
|
{
|
|
mFocusedInputEditor = inputEditor;
|
|
}
|
|
else if (mFocusedInputEditor == inputEditor)
|
|
{
|
|
// only remove focus if the request came from the previously active input editor
|
|
// to avoid races
|
|
mFocusedInputEditor = NULL;
|
|
}
|
|
}
|
|
|
|
// for the "arrow key moves avatar when chat is empty" hack in llviewerwindow.cpp
|
|
// and the hide chat bar feature in mouselook in llagent.cpp
|
|
bool FSNearbyChat::defaultChatBarIsIdle() const
|
|
{
|
|
if (mFocusedInputEditor && mFocusedInputEditor->isDefault())
|
|
{
|
|
return mFocusedInputEditor->getText().empty();
|
|
}
|
|
|
|
// if any other chat bar has focus, report "idle", because they're not the default
|
|
return true;
|
|
}
|
|
|
|
// for the "arrow key moves avatar when chat is empty" hack in llviewerwindow.cpp
|
|
bool FSNearbyChat::defaultChatBarHasFocus() const
|
|
{
|
|
if (mFocusedInputEditor && mFocusedInputEditor->isDefault())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void FSNearbyChat::onDefaultChatBarButtonClicked()
|
|
{
|
|
showDefaultChatBar(gSavedSettings.getBOOL("MainChatbarVisible"));
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// General chat handling methods
|
|
|
|
void FSNearbyChat::sendChatFromViewer(const LLWString& wtext, const LLWString& out_text, EChatType type, bool animate, S32 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);
|
|
}
|
|
|
|
// [RLVa:KB] - Checked: 2010-03-27 (RLVa-1.2.0b) | Modified: RLVa-1.2.0b
|
|
if ( (0 == channel) && (rlv_handler_t::isEnabled()) )
|
|
{
|
|
// Adjust the (public) chat "volume" on chat and gestures (also takes care of playing the proper animation)
|
|
type = RlvActions::checkChatVolume(type);
|
|
animate &= !RlvActions::hasBehaviour( (!RlvUtil::isEmote(utf8_text)) ? RLV_BHVR_REDIRCHAT : RLV_BHVR_REDIREMOTE );
|
|
}
|
|
// [/RLVa:KB]
|
|
|
|
// Don't animate for chats people can't hear (chat to scripts)
|
|
if (animate && (channel == 0))
|
|
{
|
|
if (type == CHAT_TYPE_WHISPER)
|
|
{
|
|
LL_DEBUGS("FSNearbyChatHub") << "You whisper " << utf8_text << LL_ENDL;
|
|
gAgent.sendAnimationRequest(ANIM_AGENT_WHISPER, ANIM_REQUEST_START);
|
|
}
|
|
else if (type == CHAT_TYPE_NORMAL)
|
|
{
|
|
LL_DEBUGS("FSNearbyChatHub") << "You say " << utf8_text << LL_ENDL;
|
|
gAgent.sendAnimationRequest(ANIM_AGENT_TALK, ANIM_REQUEST_START);
|
|
}
|
|
else if (type == CHAT_TYPE_SHOUT)
|
|
{
|
|
LL_DEBUGS("FSNearbyChatHub") << "You shout " << utf8_text << LL_ENDL;
|
|
gAgent.sendAnimationRequest(ANIM_AGENT_SHOUT, ANIM_REQUEST_START);
|
|
}
|
|
else
|
|
{
|
|
LL_INFOS("FSNearbyChatHub") << "send_chat_from_viewer() - invalid volume" << LL_ENDL;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (type != CHAT_TYPE_START && type != CHAT_TYPE_STOP)
|
|
{
|
|
LL_DEBUGS("FSNearbyChatHub") << "Channel chat: " << utf8_text << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
send_chat_from_viewer(utf8_out_text, type, channel);
|
|
}
|
|
|
|
// static
|
|
EChatType FSNearbyChat::processChatTypeTriggers(EChatType type, std::string &str)
|
|
{
|
|
size_t 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))
|
|
{
|
|
size_t 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;
|
|
}
|
|
|
|
// If input of the form "/20foo" or "/20 foo", returns "foo" and channel 20.
|
|
// Otherwise returns input and channel 0.
|
|
LLWString FSNearbyChat::stripChannelNumber(const LLWString &mesg, S32* channel, S32* last_channel, bool* is_set)
|
|
{
|
|
*is_set = false;
|
|
|
|
if (mesg[0] == '/'
|
|
&& mesg[1] == '/')
|
|
{
|
|
// This is a "repeat channel send"
|
|
*is_set = true;
|
|
*channel = *last_channel;
|
|
return mesg.substr(2, mesg.length() - 2);
|
|
}
|
|
else if (mesg[0] == '/'
|
|
&& mesg[1]
|
|
//<FS:TS> FIRE-11412: Allow saying /-channel for negative numbers
|
|
// (this code was here; documenting for the future)
|
|
//&& LLStringOps::isDigit(mesg[1]))
|
|
&& (LLStringOps::isDigit(mesg[1])
|
|
|| (mesg[1] == '-'
|
|
&& mesg[2]
|
|
&& LLStringOps::isDigit(mesg[2]))))
|
|
//</FS:TS> FIRE-11412
|
|
{
|
|
// This a special "/20" speak on a channel
|
|
*is_set = true;
|
|
S32 pos = 0;
|
|
//<FS:TS> FIRE-11412: Allow saying /-channel for negative numbers
|
|
// (this code was here; documenting for the future)
|
|
if (mesg[1] == '-')
|
|
{
|
|
pos++;
|
|
}
|
|
//</FS:TS> FIRE-11412
|
|
|
|
// 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));
|
|
|
|
// 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++;
|
|
}
|
|
|
|
*last_channel = strtol(wstring_to_utf8str(channel_string).c_str(), NULL, 10);
|
|
//<FS:TS> FIRE-11412: Allow saying /-channel for negative numbers
|
|
// (this code was here; documenting for the future)
|
|
if (mesg[1] == '-')
|
|
{
|
|
*last_channel = -(*last_channel);
|
|
}
|
|
//</FS:TS> FIRE-11412
|
|
*channel = *last_channel;
|
|
return mesg.substr(pos, mesg.length() - pos);
|
|
}
|
|
else
|
|
{
|
|
// This is normal chat.
|
|
*channel = 0;
|
|
return mesg;
|
|
}
|
|
}
|
|
|
|
//static
|
|
void FSNearbyChat::handleChatBarKeystroke(LLUICtrl* source, S32 channel /* = 0 */)
|
|
{
|
|
LLChatEntry* chat_entry = dynamic_cast<LLChatEntry*>(source);
|
|
LLLineEditor* line_editor = dynamic_cast<LLLineEditor*>(source);
|
|
|
|
if (!chat_entry && !line_editor)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLWString raw_text;
|
|
if (chat_entry)
|
|
{
|
|
raw_text = chat_entry->getWText();
|
|
}
|
|
else
|
|
{
|
|
raw_text = line_editor->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);
|
|
size_t length = raw_text.length();
|
|
|
|
LLWString prefix;
|
|
if (length > 3)
|
|
{
|
|
prefix = raw_text.substr(0, 3);
|
|
LLWStringUtil::toLower(prefix);
|
|
}
|
|
|
|
static LLCachedControl<bool> type_during_emote(gSavedSettings, "FSTypeDuringEmote");
|
|
static LLCachedControl<bool> allow_mu_pose(gSavedSettings, "AllowMUpose");
|
|
if (length > 0 &&
|
|
((raw_text[0] != '/' || (type_during_emote && length > 3 && prefix == utf8string_to_wstring("/me") && (raw_text[3] == ' ' || raw_text[3] == '\'')))
|
|
&& (raw_text[0] != ':' || !allow_mu_pose || type_during_emote)))
|
|
{
|
|
// only start typing animation if we are chatting without / on channel 0 -Zi
|
|
if (channel == 0)
|
|
{
|
|
gAgent.startTyping();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gAgent.stopTyping();
|
|
}
|
|
|
|
KEY key = gKeyboard->currentKey();
|
|
MASK mask = gKeyboard->currentMask(false);
|
|
|
|
// Ignore "special" keys, like backspace, arrows, etc.
|
|
if (length > 1
|
|
&& raw_text[0] == '/'
|
|
&& key < KEY_SPECIAL
|
|
&& gSavedSettings.getBOOL("FSChatbarGestureAutoCompleteEnable"))
|
|
{
|
|
// 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())
|
|
{
|
|
if (chat_entry)
|
|
{
|
|
chat_entry->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.
|
|
chat_entry->selectByCursorPosition(static_cast<S32>(utf8_out_str.size() - rest_of_match.size()), static_cast<S32>(utf8_out_str.size()));
|
|
}
|
|
else
|
|
{
|
|
line_editor->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.
|
|
S32 outlength = line_editor->getLength(); // in characters
|
|
line_editor->setSelection(static_cast<S32>(length), outlength);
|
|
line_editor->setCursor(outlength);
|
|
}
|
|
}
|
|
}
|
|
else if (matchChatTypeTrigger(utf8_trigger, &utf8_out_str))
|
|
{
|
|
std::string rest_of_match = utf8_out_str.substr(utf8_trigger.size());
|
|
if (chat_entry)
|
|
{
|
|
chat_entry->setText(utf8_trigger + rest_of_match + " "); // keep original capitalization for user-entered part
|
|
chat_entry->endOfDoc();
|
|
}
|
|
else
|
|
{
|
|
line_editor->setText(utf8_trigger + rest_of_match + " "); // keep original capitalization for user-entered part
|
|
line_editor->setCursorToEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
// <FS:CR> FIRE-3192 - Predictive name completion, based on code by Satomi Ahn
|
|
static LLCachedControl<bool> sNameAutocomplete(gSavedSettings, "FSChatbarNamePrediction");
|
|
if (length > NAME_PREDICTION_MINIMUM_LENGTH && sNameAutocomplete && key < KEY_SPECIAL && mask != MASK_CONTROL)
|
|
{
|
|
S32 cur_pos;
|
|
if (chat_entry)
|
|
{
|
|
cur_pos = chat_entry->getCursorPos();
|
|
}
|
|
else
|
|
{
|
|
cur_pos = line_editor->getCursor();
|
|
}
|
|
if (cur_pos && (raw_text[cur_pos - 1] != ' '))
|
|
{
|
|
// Get a list of avatars within range
|
|
uuid_vec_t avatar_ids;
|
|
LLWorld::getInstance()->getAvatars(&avatar_ids, NULL, gAgent.getPositionGlobal(), gSavedSettings.getF32("NearMeRange"));
|
|
|
|
if (avatar_ids.empty())
|
|
{
|
|
return; // Nobody's in range!
|
|
}
|
|
|
|
// Parse text for a pattern to search
|
|
std::string prefix = wstring_to_utf8str(raw_text.substr(0, cur_pos)); // Text before search string
|
|
std::string suffix = "";
|
|
if (cur_pos <= raw_text.length()) // Is there anything after the cursor?
|
|
{
|
|
suffix = wstring_to_utf8str(raw_text.substr(cur_pos)); // Text after search string
|
|
}
|
|
size_t last_space = prefix.rfind(" ");
|
|
std::string pattern = prefix.substr(last_space + 1, prefix.length() - last_space - 1); // Search pattern
|
|
|
|
prefix = prefix.substr(0, last_space + 1);
|
|
std::string match_pattern = "";
|
|
|
|
if (pattern.size() < NAME_PREDICTION_MINIMUM_LENGTH)
|
|
{
|
|
return;
|
|
}
|
|
|
|
match_pattern = prefix.substr(last_space + 1, prefix.length() - last_space - 1);
|
|
prefix = prefix.substr(0, last_space + 1);
|
|
std::string match = pattern;
|
|
LLStringUtil::toLower(pattern);
|
|
|
|
std::string name;
|
|
bool found = false;
|
|
bool full_name = false;
|
|
uuid_vec_t::iterator iter = avatar_ids.begin();
|
|
|
|
if (last_space != std::string::npos && !prefix.empty())
|
|
{
|
|
last_space = prefix.substr(0, prefix.length() - 2).rfind(" ");
|
|
match_pattern = prefix.substr(last_space + 1, prefix.length() - last_space - 1);
|
|
prefix = prefix.substr(0, last_space + 1);
|
|
|
|
// prepare search pattern
|
|
std::string full_pattern(match_pattern + pattern);
|
|
LLStringUtil::toLower(full_pattern);
|
|
|
|
// Look for a match
|
|
while (iter != avatar_ids.end() && !found)
|
|
{
|
|
LLAvatarName av_name;
|
|
if (LLAvatarNameCache::get(*iter++, &av_name))
|
|
{
|
|
name = av_name.getUserName();
|
|
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
|
|
{
|
|
name = RlvStrings::getAnonym(av_name);
|
|
}
|
|
LLStringUtil::toLower(name);
|
|
found = (name.find(full_pattern) == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
full_name = true; // ignore OnlyFirstName in case we want to disambiguate
|
|
prefix += match_pattern;
|
|
}
|
|
else if (!pattern.empty()) // if first search did not work, try matching with last word before cursor only
|
|
{
|
|
prefix += match_pattern; // first part of the pattern wasn't a pattern, so keep it in prefix
|
|
LLStringUtil::toLower(pattern);
|
|
iter = avatar_ids.begin();
|
|
|
|
// Look for a match
|
|
while (iter != avatar_ids.end() && !found)
|
|
{
|
|
LLAvatarName av_name;
|
|
if (LLAvatarNameCache::get(*iter++, &av_name))
|
|
{
|
|
name = av_name.getUserName();
|
|
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
|
|
{
|
|
name = RlvStrings::getAnonym(av_name);
|
|
}
|
|
LLStringUtil::toLower(name);
|
|
found = (name.find(pattern) == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we found something by either method, replace the pattern by the avatar name
|
|
if (found)
|
|
{
|
|
std::string first_name, last_name;
|
|
LLAvatarName av_name;
|
|
LLAvatarNameCache::get(*(iter - 1), &av_name);
|
|
std::string username = av_name.getLegacyName();
|
|
size_t delim_pos = username.find(' ');
|
|
first_name = username.substr(0, delim_pos);
|
|
if (delim_pos + 1 < username.length())
|
|
{
|
|
last_name = username.substr(delim_pos + 1, std::string::npos);
|
|
}
|
|
|
|
std::string rest_of_match;
|
|
std::string replaced_text;
|
|
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
|
|
{
|
|
replaced_text += RlvStrings::getAnonym(av_name) + " ";
|
|
}
|
|
else
|
|
{
|
|
if (full_name)
|
|
{
|
|
rest_of_match = /*first_name + " " +*/ last_name.substr(pattern.size());
|
|
}
|
|
else
|
|
{
|
|
rest_of_match = first_name.substr(pattern.size());
|
|
}
|
|
replaced_text += match + rest_of_match + " ";
|
|
}
|
|
if (!rest_of_match.empty())
|
|
{
|
|
if (chat_entry)
|
|
{
|
|
chat_entry->setText(prefix + replaced_text + suffix);
|
|
chat_entry->selectByCursorPosition(static_cast<S32>(utf8string_to_wstring(prefix).size() + utf8string_to_wstring(match).size()), static_cast<S32>(utf8string_to_wstring(prefix).size() + utf8string_to_wstring(replaced_text).size()));
|
|
}
|
|
else
|
|
{
|
|
line_editor->setText(prefix + replaced_text + suffix);
|
|
line_editor->setSelection(static_cast<S32>(utf8str_to_wstring(prefix + replaced_text).length()), cur_pos);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// </FS:CR>
|
|
}
|
|
|
|
|
|
class LLChatCommandHandler : public LLCommandHandler
|
|
{
|
|
public:
|
|
// not allowed from outside the app
|
|
LLChatCommandHandler() : LLCommandHandler("chat", UNTRUSTED_THROTTLE) { }
|
|
|
|
// 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;
|