375 lines
9.0 KiB
C++
375 lines
9.0 KiB
C++
/**
|
|
* @file llgesture.cpp
|
|
*
|
|
* $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 "linden_common.h"
|
|
|
|
#include "indra_constants.h"
|
|
|
|
#include "llgesture.h"
|
|
#include "llendianswizzle.h"
|
|
#include "message.h"
|
|
#include <boost/tokenizer.hpp>
|
|
|
|
// for allocating serialization buffers - these need to be updated when members change
|
|
const S32 LLGestureList::SERIAL_HEADER_SIZE = sizeof(S32);
|
|
const S32 LLGesture::MAX_SERIAL_SIZE = sizeof(KEY) + sizeof(MASK) + 16 + 26 + 41 + 41;
|
|
|
|
LLGesture::LLGesture()
|
|
: mKey(KEY_NONE),
|
|
mMask(MASK_NONE),
|
|
mTrigger(),
|
|
mTriggerLower(),
|
|
mSoundItemID(),
|
|
mAnimation(),
|
|
mOutputString()
|
|
{ }
|
|
|
|
LLGesture::LLGesture(KEY key, MASK mask, const std::string &trigger,
|
|
const LLUUID &sound_item_id,
|
|
const std::string &animation,
|
|
const std::string &output_string)
|
|
:
|
|
mKey(key),
|
|
mMask(mask),
|
|
mTrigger(trigger),
|
|
mTriggerLower(trigger),
|
|
mSoundItemID(sound_item_id),
|
|
mAnimation(animation),
|
|
mOutputString(output_string)
|
|
{
|
|
mTriggerLower = utf8str_tolower(mTriggerLower);
|
|
}
|
|
|
|
LLGesture::LLGesture(U8 **buffer, S32 max_size)
|
|
{
|
|
*buffer = deserialize(*buffer, max_size);
|
|
}
|
|
|
|
LLGesture::LLGesture(const LLGesture &rhs)
|
|
{
|
|
mKey = rhs.mKey;
|
|
mMask = rhs.mMask;
|
|
mTrigger = rhs.mTrigger;
|
|
mTriggerLower = rhs.mTriggerLower;
|
|
mSoundItemID = rhs.mSoundItemID;
|
|
mAnimation = rhs.mAnimation;
|
|
mOutputString = rhs.mOutputString;
|
|
}
|
|
|
|
const LLGesture &LLGesture::operator =(const LLGesture &rhs)
|
|
{
|
|
mKey = rhs.mKey;
|
|
mMask = rhs.mMask;
|
|
mTrigger = rhs.mTrigger;
|
|
mTriggerLower = rhs.mTriggerLower;
|
|
mSoundItemID = rhs.mSoundItemID;
|
|
mAnimation = rhs.mAnimation;
|
|
mOutputString = rhs.mOutputString;
|
|
return (*this);
|
|
}
|
|
|
|
|
|
BOOL LLGesture::trigger(KEY key, MASK mask)
|
|
{
|
|
llwarns << "Parent class trigger called: you probably didn't mean this." << llendl;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL LLGesture::trigger(const std::string& trigger_string)
|
|
{
|
|
llwarns << "Parent class trigger called: you probably didn't mean this." << llendl;
|
|
return FALSE;
|
|
}
|
|
|
|
// NOT endian-neutral
|
|
U8 *LLGesture::serialize(U8 *buffer) const
|
|
{
|
|
htonmemcpy(buffer, &mKey, MVT_S8, 1);
|
|
buffer += sizeof(mKey);
|
|
htonmemcpy(buffer, &mMask, MVT_U32, 4);
|
|
buffer += sizeof(mMask);
|
|
htonmemcpy(buffer, mSoundItemID.mData, MVT_LLUUID, 16);
|
|
buffer += 16;
|
|
|
|
memcpy(buffer, mTrigger.c_str(), mTrigger.length() + 1); /* Flawfinder: ignore */
|
|
buffer += mTrigger.length() + 1;
|
|
memcpy(buffer, mAnimation.c_str(), mAnimation.length() + 1); /* Flawfinder: ignore */
|
|
buffer += mAnimation.length() + 1;
|
|
memcpy(buffer, mOutputString.c_str(), mOutputString.length() + 1); /* Flawfinder: ignore */
|
|
buffer += mOutputString.length() + 1;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
U8 *LLGesture::deserialize(U8 *buffer, S32 max_size)
|
|
{
|
|
U8 *tmp = buffer;
|
|
|
|
if (tmp + sizeof(mKey) + sizeof(mMask) + 16 > buffer + max_size)
|
|
{
|
|
llwarns << "Attempt to read past end of buffer, bad data!!!!" << llendl;
|
|
return buffer;
|
|
}
|
|
|
|
htonmemcpy(&mKey, tmp, MVT_S8, 1);
|
|
tmp += sizeof(mKey);
|
|
htonmemcpy(&mMask, tmp, MVT_U32, 4);
|
|
tmp += sizeof(mMask);
|
|
htonmemcpy(mSoundItemID.mData, tmp, MVT_LLUUID, 16);
|
|
tmp += 16;
|
|
|
|
mTrigger.assign((char *)tmp);
|
|
mTriggerLower = mTrigger;
|
|
mTriggerLower = utf8str_tolower(mTriggerLower);
|
|
tmp += mTrigger.length() + 1;
|
|
mAnimation.assign((char *)tmp);
|
|
//RN: force animation names to lower case
|
|
// must do this for backwards compatibility
|
|
mAnimation = utf8str_tolower(mAnimation);
|
|
tmp += mAnimation.length() + 1;
|
|
mOutputString.assign((char *)tmp);
|
|
tmp += mOutputString.length() + 1;
|
|
|
|
if (tmp > buffer + max_size)
|
|
{
|
|
llwarns << "Read past end of buffer, bad data!!!!" << llendl;
|
|
return tmp;
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
S32 LLGesture::getMaxSerialSize()
|
|
{
|
|
return MAX_SERIAL_SIZE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// LLGestureList
|
|
//---------------------------------------------------------------------
|
|
|
|
LLGestureList::LLGestureList()
|
|
: mList(0)
|
|
{
|
|
// add some gestures for debugging
|
|
// LLGesture *gesture = NULL;
|
|
/*
|
|
gesture = new LLGesture(KEY_F2, MASK_NONE, ":-)",
|
|
SND_CHIRP, "dance2", ":-)" );
|
|
mList.put(gesture);
|
|
|
|
gesture = new LLGesture(KEY_F3, MASK_NONE, "/dance",
|
|
SND_OBJECT_CREATE, "dance3", "(dances)" );
|
|
mList.put(gesture);
|
|
|
|
gesture = new LLGesture(KEY_F4, MASK_NONE, "/boogie",
|
|
LLUUID::null, "dance4", LLStringUtil::null );
|
|
mList.put(gesture);
|
|
|
|
gesture = new LLGesture(KEY_F5, MASK_SHIFT, "/tongue",
|
|
LLUUID::null, "Express_Tongue_Out", LLStringUtil::null );
|
|
mList.put(gesture);
|
|
*/
|
|
}
|
|
|
|
LLGestureList::~LLGestureList()
|
|
{
|
|
deleteAll();
|
|
}
|
|
|
|
|
|
void LLGestureList::deleteAll()
|
|
{
|
|
S32 count = mList.count();
|
|
for (S32 i = 0; i < count; i++)
|
|
{
|
|
delete mList.get(i);
|
|
}
|
|
mList.reset();
|
|
}
|
|
|
|
// Iterates through space delimited tokens in string, triggering any gestures found.
|
|
// Generates a revised string that has the found tokens replaced by their replacement strings
|
|
// and (as a minor side effect) has multiple spaces in a row replaced by single spaces.
|
|
BOOL LLGestureList::triggerAndReviseString(const std::string &string, std::string* revised_string)
|
|
{
|
|
std::string tokenized = string;
|
|
|
|
BOOL found_gestures = FALSE;
|
|
BOOL first_token = TRUE;
|
|
|
|
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
|
|
boost::char_separator<char> sep(" ");
|
|
tokenizer tokens(string, sep);
|
|
tokenizer::iterator token_iter;
|
|
|
|
for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
|
|
{
|
|
LLGesture* gesture = NULL;
|
|
|
|
if( !found_gestures ) // Only pay attention to the first gesture in the string.
|
|
{
|
|
std::string cur_token_lower = *token_iter;
|
|
LLStringUtil::toLower(cur_token_lower);
|
|
|
|
for (S32 i = 0; i < mList.count(); i++)
|
|
{
|
|
gesture = mList.get(i);
|
|
if (gesture->trigger(cur_token_lower))
|
|
{
|
|
if( !gesture->getOutputString().empty() )
|
|
{
|
|
if( !first_token )
|
|
{
|
|
revised_string->append( " " );
|
|
}
|
|
|
|
// Don't muck with the user's capitalization if we don't have to.
|
|
const std::string& output = gesture->getOutputString();
|
|
std::string output_lower = std::string(output.c_str());
|
|
LLStringUtil::toLower(output_lower);
|
|
if( cur_token_lower == output_lower )
|
|
{
|
|
revised_string->append(*token_iter);
|
|
}
|
|
else
|
|
{
|
|
revised_string->append(output);
|
|
}
|
|
|
|
}
|
|
found_gestures = TRUE;
|
|
break;
|
|
}
|
|
gesture = NULL;
|
|
}
|
|
}
|
|
|
|
if( !gesture )
|
|
{
|
|
if( !first_token )
|
|
{
|
|
revised_string->append( " " );
|
|
}
|
|
revised_string->append( *token_iter );
|
|
}
|
|
|
|
first_token = FALSE;
|
|
}
|
|
return found_gestures;
|
|
}
|
|
|
|
|
|
|
|
BOOL LLGestureList::trigger(KEY key, MASK mask)
|
|
{
|
|
for (S32 i = 0; i < mList.count(); i++)
|
|
{
|
|
LLGesture* gesture = mList.get(i);
|
|
if( gesture )
|
|
{
|
|
if (gesture->trigger(key, mask))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
llwarns << "NULL gesture in gesture list (" << i << ")" << llendl;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// NOT endian-neutral
|
|
U8 *LLGestureList::serialize(U8 *buffer) const
|
|
{
|
|
// a single S32 serves as the header that tells us how many to read
|
|
S32 count = mList.count();
|
|
htonmemcpy(buffer, &count, MVT_S32, 4);
|
|
buffer += sizeof(count);
|
|
|
|
for (S32 i = 0; i < count; i++)
|
|
{
|
|
buffer = mList[i]->serialize(buffer);
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
const S32 MAX_GESTURES = 4096;
|
|
|
|
U8 *LLGestureList::deserialize(U8 *buffer, S32 max_size)
|
|
{
|
|
deleteAll();
|
|
|
|
S32 count;
|
|
U8 *tmp = buffer;
|
|
|
|
if (tmp + sizeof(count) > buffer + max_size)
|
|
{
|
|
llwarns << "Invalid max_size" << llendl;
|
|
return buffer;
|
|
}
|
|
|
|
htonmemcpy(&count, tmp, MVT_S32, 4);
|
|
|
|
if (count > MAX_GESTURES)
|
|
{
|
|
llwarns << "Unreasonably large gesture list count in deserialize: " << count << llendl;
|
|
return tmp;
|
|
}
|
|
|
|
tmp += sizeof(count);
|
|
|
|
mList.reserve_block(count);
|
|
|
|
for (S32 i = 0; i < count; i++)
|
|
{
|
|
mList[i] = create_gesture(&tmp, max_size - (S32)(tmp - buffer));
|
|
if (tmp - buffer > max_size)
|
|
{
|
|
llwarns << "Deserialization read past end of buffer, bad data!!!!" << llendl;
|
|
return tmp;
|
|
}
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
// this is a helper for deserialize
|
|
// it gets overridden by LLViewerGestureList to create LLViewerGestures
|
|
// overridden by child class to use local LLGesture implementation
|
|
LLGesture *LLGestureList::create_gesture(U8 **buffer, S32 max_size)
|
|
{
|
|
return new LLGesture(buffer, max_size);
|
|
}
|
|
|
|
S32 LLGestureList::getMaxSerialSize()
|
|
{
|
|
return SERIAL_HEADER_SIZE + (count() * LLGesture::getMaxSerialSize());
|
|
}
|