diff --git a/indra/cmake/00-Common.cmake b/indra/cmake/00-Common.cmake index 6a6f7c222..0c4386784 100644 --- a/indra/cmake/00-Common.cmake +++ b/indra/cmake/00-Common.cmake @@ -246,44 +246,39 @@ endif (LINUX) if (DARWIN) - add_definitions(-DLL_DARWIN=1 -D_XOPEN_SOURCE) - set(CMAKE_CXX_LINK_FLAGS "-Wl,-headerpad_max_install_names,-search_paths_first") + add_definitions(-DLL_DARWIN=1) + set(CMAKE_CXX_LINK_FLAGS "-Wl,-no_compact_unwind -Wl,-headerpad_max_install_names,-search_paths_first") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_CXX_LINK_FLAGS}") - - if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mlong-branch") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mlong-branch") - # NOTE: it's critical that the optimization flag is put in front. - # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered. - set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}") - set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}") - set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}") - set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}") - elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - # NOTE: it's critical that the optimization flag is put in front. - # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered. - set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -msse3") - set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3") - set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3") - set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3") - endif() + set(DARWIN_extra_cstar_flags "-g") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DARWIN_extra_cstar_flags} -ftemplate-depth=256") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DARWIN_extra_cstar_flags}") + # NOTE: it's critical that the optimization flag is put in front. + # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered. + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O0 ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O0 ${CMAKE_C_FLAGS_RELWITHDEBINFO}") + set(CMAKE_XCODE_ATTRIBUTE_CLANG_X86_VECTOR_INSTRUCTIONS SSE3) + set(CMAKE_XCODE_ATTRIBUTE_GCC_OPTIMIZATION_LEVEL -O3) + set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse3 ${CMAKE_CXX_FLAGS_RELEASE}") + set(CMAKE_C_FLAGS_RELEASE "-O3 -msse3 ${CMAKE_C_FLAGS_RELEASE}") + if (XCODE_VERSION GREATER 4.2) + set(ENABLE_SIGNING TRUE) + set(SIGNING_IDENTITY "Developer ID Application: Linden Research, Inc.") + endif (XCODE_VERSION GREATER 4.2) endif (DARWIN) + if (LINUX OR DARWIN) + set(GCC_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs") + if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") add_definitions(-DLL_GNUC=1) - set(UNIX_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs") - set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS} -Wno-reorder -Wno-non-virtual-dtor -Woverloaded-virtual") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") add_definitions(-DLL_CLANG=1) - set(UNIX_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs -Wno-tautological-compare -Wno-char-subscripts -Wno-gnu -Wno-logical-op-parentheses -Wno-non-virtual-dtor") - set(UNIX_WARNINGS "${UNIX_WARNINGS} -Woverloaded-virtual -Wno-parentheses-equality -Wno-reorder -Wno-unused-function -Wno-unused-value -Wno-unused-variable") - set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS}") + set(UNIX_WARNINGS "${UNIX_WARNINGS} -Wno-deprecated") + set(UNIX_CXX_WARNINGS "${UNIX_CXX_WARNINGS} -Wno-deprecated -Wno-reorder -Wno-tautological-compare") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") add_definitions(-DLL_ICC=1) - set(UNIX_WARNINGS "-wd327 -wd597 -wd858") - set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS}") endif () if (NOT DISABLE_FATAL_WARNINGS) diff --git a/indra/cmake/Variables.cmake b/indra/cmake/Variables.cmake index 5848b8934..a8df1d307 100644 --- a/indra/cmake/Variables.cmake +++ b/indra/cmake/Variables.cmake @@ -97,24 +97,54 @@ endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux") if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") set(DARWIN 1) - if(${CMAKE_GENERATOR} MATCHES "Xcode") - #SDK Compiler and Deployment targets for XCode - if (${XCODE_VERSION} VERSION_LESS 4.0.0) - set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.5.sdk) - set(CMAKE_OSX_DEPLOYMENT_TARGET 10.5) - else (${XCODE_VERSION} VERSION_LESS 4.0.0) - set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.6.sdk) - set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6) - endif (${XCODE_VERSION} VERSION_LESS 4.0.0) - else(${CMAKE_GENERATOR} MATCHES "Xcode") - set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.6.sdk) - set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6) - endif(${CMAKE_GENERATOR} MATCHES "Xcode") + execute_process( + COMMAND sh -c "xcodebuild -version | grep Xcode | cut -d ' ' -f2 | cut -d'.' -f1-2" + OUTPUT_VARIABLE XCODE_VERSION ) + string(REGEX REPLACE "(\r?\n)+$" "" XCODE_VERSION "${XCODE_VERSION}") + +# # To support a different SDK update these Xcode settings: +# if (XCODE_VERSION GREATER 4.9) # (Which would be 5.0+) +# set(CMAKE_OSX_DEPLOYMENT_TARGET 10.8) +# set(CMAKE_OSX_SYSROOT macosx10.9) +# else (XCODE_VERION GREATER 4.9) +# if (XCODE_VERSION GREATER 4.5) +# set(CMAKE_OSX_DEPLOYMENT_TARGET 10.7) +# set(CMAKE_OSX_SYSROOT macosx10.8) +# else (XCODE_VERSION GREATER 4.5) +# if (XCODE_VERSION GREATER 4.2) +# set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6) +# set(CMAKE_OSX_SYSROOT macosx10.7) +# else (XCODE_VERSION GREATER 4.2) +# set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6) +# set(CMAKE_OSX_SYSROOT macosx10.7) +# endif (XCODE_VERSION GREATER 4.2) +# endif (XCODE_VERSION GREATER 4.5) +# endif (XCODE_VERSION GREATER 4.9) - set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42") + # Hardcode SDK we build against until we can test and allow newer ones + # as autodetected in the code above + set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6) + set(CMAKE_OSX_SYSROOT macosx10.6) + + # Support for Unix Makefiles generator + if (CMAKE_GENERATOR STREQUAL "Unix Makefiles") + execute_process(COMMAND xcodebuild -version -sdk "${CMAKE_OSX_SYSROOT}" Path | head -n 1 OUTPUT_VARIABLE CMAKE_OSX_SYSROOT) + string(REGEX REPLACE "(\r?\n)+$" "" CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT}") + endif (CMAKE_GENERATOR STREQUAL "Unix Makefiles") + + # LLVM-GCC has been removed in Xcode5 + if (XCODE_VERSION GREATER 4.9) + set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvm.clang.1_0") + else (XCODE_VERSION GREATER 4.9) + set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42") + endif (XCODE_VERSION GREATER 4.9) set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT dwarf-with-dsym) + message(STATUS "Xcode version: ${XCODE_VERSION}") + message(STATUS "OSX sysroot: ${CMAKE_OSX_SYSROOT}") + message(STATUS "OSX deployment target: ${CMAKE_OSX_DEPLOYMENT_TARGET}") + # Build only for i386 by default, system default on MacOSX 10.6 is x86_64 set(CMAKE_OSX_ARCHITECTURES i386) set(ARCH i386) diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index fd0e8208c..121268ad6 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -60,7 +60,6 @@ set(llcommon_SOURCE_FILES llformat.cpp llframetimer.cpp llheartbeat.cpp - llindraconfigfile.cpp llinitparam.cpp llinstancetracker.cpp llliveappconfig.cpp @@ -186,7 +185,6 @@ set(llcommon_HEADER_FILES llheartbeat.h llhttpstatuscodes.h llindexedqueue.h - llindraconfigfile.h llinitparam.h llinstancetracker.h llkeythrottle.h diff --git a/indra/llcommon/llindraconfigfile.cpp b/indra/llcommon/llindraconfigfile.cpp deleted file mode 100644 index f0873450f..000000000 --- a/indra/llcommon/llindraconfigfile.cpp +++ /dev/null @@ -1,119 +0,0 @@ -/** - * @file llindraconfigfile.cpp - * - * - * This class is an LLLiveFile that has config info for indra - * Currently only whether it's blacklisted - * - * $LicenseInfo:firstyear=2007&license=viewergpl$ - * - * Copyright (c) 2007-2009, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at - * http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ - -#include "llindraconfigfile.h" - -#include "llfile.h" -#include "llsd.h" -#include "llsdserialize.h" -#include "llframetimer.h" - -static std::string sConfigDir = ""; -static const char indraConfigFileName[] = "indra.xml"; - - -LLIndraConfigFile::LLIndraConfigFile() - : LLLiveFile(filename()), - mConfig(LLSD()) -{ -} - -//static -void LLIndraConfigFile::initClass(const std::string& config_dir) -{ - sConfigDir = config_dir; - llinfos << "LLIndraConfigFile::initClass config dir " - << config_dir << "/" << indraConfigFileName << llendl; -} - -LLSD LLIndraConfigFile::getConfig(const std::string& config_name) -{ - if (sConfigDir.empty()) - { - llerrs << "LLIndraConfigFile::initClass() not called" << llendl; - } - - LLFrameTimer::updateFrameTime(); - - static LLIndraConfigFile the_file; - the_file.checkAndReload(); - - return the_file.mConfig[config_name]; -} - -std::string LLIndraConfigFile::filename() -{ - std::ostringstream ostr; - - ostr << sConfigDir - << "/" << indraConfigFileName; - - return ostr.str(); -} - -/* virtual */ -bool LLIndraConfigFile::loadFile() -{ - llinfos << "LLIndraConfigFile::loadFile: reading from " - << filename() << llendl; - - LLSD config; - - { - llifstream file(filename()); - if (file.is_open()) - { - LLSDSerialize::fromXML(config, file); - } - - if (config.isUndefined()) - { - llinfos << "LLIndraConfigFile::loadFile: file missing, ill-formed," - " or simply undefined; not changing the blacklist" << llendl; - return false; - } - } - - if (config.isMap()) - { - mConfig = config; - return true; - } - else - { - llwarns << "LLIndraConfigFile: " << indraConfigFileName << " expects a map; wrong format" << llendl; - return false; - } -} diff --git a/indra/llcommon/llindraconfigfile.h b/indra/llcommon/llindraconfigfile.h deleted file mode 100644 index 17eda906e..000000000 --- a/indra/llcommon/llindraconfigfile.h +++ /dev/null @@ -1,61 +0,0 @@ -/** - * @file llindraconfigfile.h - * @brief manages configuration file for indra.xml - * - * $LicenseInfo:firstyear=2007&license=viewergpl$ - * - * Copyright (c) 2007-2009, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at - * http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ - -#ifndef LL_LLINDRACONFIGFILE_H -#define LL_LLINDRACONFIGFILE_H - -#include "linden_common.h" -#include - -#include "lllivefile.h" -#include "llsd.h" - - -// To use, call LLIndraConfigFile::initClass(config_dir); -// Then whenever getConfig is called, it will check and reload automatically - -class LLIndraConfigFile : public LLLiveFile -{ -public: - LLIndraConfigFile(); - static void initClass(const std::string& config_dir); - static LLSD getConfig(const std::string& config_name); - -private: - static std::string filename(); - -protected: - /* virtual */ bool loadFile(); - LLSD mConfig; -}; - -#endif //LL_LLINDRACONFIGFILE_H diff --git a/indra/llmessage/aihttptimeoutpolicy.cpp b/indra/llmessage/aihttptimeoutpolicy.cpp index 019750efc..b9052f12f 100644 --- a/indra/llmessage/aihttptimeoutpolicy.cpp +++ b/indra/llmessage/aihttptimeoutpolicy.cpp @@ -965,7 +965,6 @@ P(newAgentInventoryVariablePriceResponder); P(objectCostResponder); P(objectLinksetsResponder); P(physicsFlagsResponder); -P(placeAvatarTeleportResponder); P(productInfoRequestResponder); P(regionResponder); P(remoteParcelRequestResponder); diff --git a/indra/llprimitive/llmodel.cpp b/indra/llprimitive/llmodel.cpp index 7312209da..b722660bf 100644 --- a/indra/llprimitive/llmodel.cpp +++ b/indra/llprimitive/llmodel.cpp @@ -168,6 +168,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector& fa if ( !get_dom_sources(inputs, pos_offset, tc_offset, norm_offset, idx_stride, pos_source, tc_source, norm_source) || !pos_source ) { + llwarns << "Could not find dom sources for basic geo data; invalid model." << llendl; return LLModel::BAD_ELEMENT; } @@ -188,27 +189,78 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector& fa LLVolumeFace::VertexMapData::PointMap point_map; - for (U32 i = 0; i < idx.getCount(); i += idx_stride) + U32 index_count = idx.getCount(); + U32 vertex_count = pos_source ? v.getCount() : 0; + U32 tc_count = tc_source ? tc.getCount() : 0; + U32 norm_count = norm_source ? n.getCount() : 0; + + for (U32 i = 0; i < index_count; i += idx_stride) { LLVolumeFace::VertexData cv; if (pos_source) { + // guard against model data specifiying out of range indices or verts + // + if (((i + pos_offset) > index_count) + || ((idx[i+pos_offset]*3+2) > vertex_count)) + { + llwarns << "Out of range index data; invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } + cv.setPosition(LLVector4a(v[idx[i+pos_offset]*3+0], v[idx[i+pos_offset]*3+1], v[idx[i+pos_offset]*3+2])); + + if (!cv.getPosition().isFinite3()) + { + llwarns << "Nan positional data, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } if (tc_source) { + // guard against model data specifiying out of range indices or tcs + // + + if (((i + tc_offset) > index_count) + || ((idx[i+tc_offset]*2+1) > tc_count)) + { + llwarns << "Out of range TC indices." << llendl; + return LLModel::BAD_ELEMENT; + } + cv.mTexCoord.setVec(tc[idx[i+tc_offset]*2+0], tc[idx[i+tc_offset]*2+1]); + + if (!cv.mTexCoord.isFinite()) + { + llwarns << "Found NaN while loading tex coords from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } if (norm_source) { + // guard against model data specifiying out of range indices or norms + // + if (((i + norm_offset) > index_count) + || ((idx[i+norm_offset]*3+2) > norm_count)) + { + llwarns << "Found out of range norm indices, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } + cv.setNormal(LLVector4a(n[idx[i+norm_offset]*3+0], n[idx[i+norm_offset]*3+1], n[idx[i+norm_offset]*3+2])); + + if (!cv.getNormal().isFinite3()) + { + llwarns << "Found NaN while loading normals from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } BOOL found = FALSE; @@ -263,7 +315,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector& fa LLVolumeFace& new_face = *face_list.rbegin(); if (!norm_source) { - //l_aligned_free_16(new_face.mNormals); + //ll_aligned_free_16(new_face.mNormals); new_face.mNormals = NULL; } @@ -335,6 +387,7 @@ LLModel::EModelStatus load_face_from_dom_polylist(std::vector& fac if (!get_dom_sources(inputs, pos_offset, tc_offset, norm_offset, idx_stride, pos_source, tc_source, norm_source)) { + llwarns << "Could not get DOM sources for basic geo data, invalid model." << llendl; return LLModel::BAD_ELEMENT; } @@ -366,6 +419,11 @@ LLModel::EModelStatus load_face_from_dom_polylist(std::vector& fac LLVolumeFace::VertexMapData::PointMap point_map; + U32 index_count = idx.getCount(); + U32 vertex_count = pos_source ? v.getCount() : 0; + U32 tc_count = tc_source ? tc.getCount() : 0; + U32 norm_count = norm_source ? n.getCount() : 0; + U32 cur_idx = 0; for (U32 i = 0; i < vcount.getCount(); ++i) { //for each polygon @@ -378,22 +436,68 @@ LLModel::EModelStatus load_face_from_dom_polylist(std::vector& fac if (pos_source) { + // guard against model data specifiying out of range indices or verts + // + if (((cur_idx + pos_offset) > index_count) + || ((idx[cur_idx+pos_offset]*3+2) > vertex_count)) + { + llwarns << "Out of range position indices, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } + cv.getPosition().set(v[idx[cur_idx+pos_offset]*3+0], v[idx[cur_idx+pos_offset]*3+1], v[idx[cur_idx+pos_offset]*3+2]); + + if (!cv.getPosition().isFinite3()) + { + llwarns << "Found NaN while loading positions from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } + } if (tc_source) { + // guard against model data specifiying out of range indices or tcs + // + if (((cur_idx + tc_offset) > index_count) + || ((idx[cur_idx+tc_offset]*2+1) > tc_count)) + { + llwarns << "Out of range TC indices, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } + cv.mTexCoord.setVec(tc[idx[cur_idx+tc_offset]*2+0], tc[idx[cur_idx+tc_offset]*2+1]); + + if (!cv.mTexCoord.isFinite()) + { + llwarns << "Found NaN while loading tex coords from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } if (norm_source) { + // guard against model data specifiying out of range indices or norms + // + if (((cur_idx + norm_offset) > index_count) + || ((idx[cur_idx+norm_offset]*3+2) > norm_count)) + { + llwarns << "Out of range norm indices, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } + cv.getNormal().set(n[idx[cur_idx+norm_offset]*3+0], n[idx[cur_idx+norm_offset]*3+1], n[idx[cur_idx+norm_offset]*3+2]); + + if (!cv.getNormal().isFinite3()) + { + llwarns << "Found NaN while loading normals from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } cur_idx += idx_stride; @@ -560,6 +664,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac domVertices* vertices = (domVertices*) elem.cast(); if (!vertices) { + llwarns << "Could not find vertex source, invalid model." << llendl; return LLModel::BAD_ELEMENT; } domInputLocal_Array& v_inp = vertices->getInput_array(); @@ -573,6 +678,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac domSource* src = (domSource*) elem.cast(); if (!src) { + llwarns << "Could not find DOM source, invalid model." << llendl; return LLModel::BAD_ELEMENT; } v = &(src->getFloat_array()->getValue()); @@ -588,6 +694,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac domSource* src = (domSource*) elem.cast(); if (!src) { + llwarns << "Could not find DOM source, invalid model." << llendl; return LLModel::BAD_ELEMENT; } n = &(src->getFloat_array()->getValue()); @@ -600,6 +707,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac domSource* src = (domSource*) elem.cast(); if (!src) { + llwarns << "Could not find DOM source, invalid model." << llendl; return LLModel::BAD_ELEMENT; } t = &(src->getFloat_array()->getValue()); @@ -634,6 +742,12 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac vert.getPosition().set(v->get(v_idx), v->get(v_idx+1), v->get(v_idx+2)); + + if (!vert.getPosition().isFinite3()) + { + llwarns << "Found NaN while loading position data from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } //bounds check n and t lookups because some FBX to DAE converters @@ -646,6 +760,12 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac vert.getNormal().set(n->get(n_idx), n->get(n_idx+1), n->get(n_idx+2)); + + if (!vert.getNormal().isFinite3()) + { + llwarns << "Found NaN while loading normals from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } else { @@ -659,6 +779,12 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector& fac t_idx = llclamp(t_idx, (U32) 0, (U32) t->getCount()); vert.mTexCoord.setVec(t->get(t_idx), t->get(t_idx+1)); + + if (!vert.mTexCoord.isFinite()) + { + llwarns << "Found NaN while loading tex coords from DAE-Model, invalid model." << llendl; + return LLModel::BAD_ELEMENT; + } } else { @@ -1591,6 +1717,7 @@ LLSD LLModel::writeModel( mdl[model_names[idx]][i]["TexCoord0Domain"]["Max"] = max_tc.getValue(); mdl[model_names[idx]][i]["TexCoord0"] = tc; } + mdl[model_names[idx]][i]["TriangleList"] = indices; if (skinning) diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp index fb1673245..6276c0f50 100644 --- a/indra/llui/lllineeditor.cpp +++ b/indra/llui/lllineeditor.cpp @@ -921,6 +921,23 @@ void LLLineEditor::addChar(const llwchar uni_char) mText.insert(getCursor(), w_buf); setCursor(getCursor() + 1); + + if (!mReadOnly && mAutoreplaceCallback != NULL) + { + // autoreplace the text, if necessary + S32 replacement_start; + S32 replacement_length; + LLWString replacement_string; + S32 new_cursor_pos = getCursor(); + mAutoreplaceCallback(replacement_start, replacement_length, replacement_string, new_cursor_pos, mText); + + if (replacement_length > 0 || !replacement_string.empty()) + { + mText.erase(replacement_start, replacement_length); + mText.insert(replacement_start, replacement_string); + setCursor(new_cursor_pos); + } + } } else { diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h index bc6df16f3..91a7983f4 100644 --- a/indra/llui/lllineeditor.h +++ b/indra/llui/lllineeditor.h @@ -167,6 +167,10 @@ public: virtual BOOL isSpellDirty() const { return mText.getString() != mPrevSpelledText; } // Returns TRUE if user changed value at all virtual void resetSpellDirty() { mPrevSpelledText = mText.getString(); } // Clear dirty state + typedef boost::function autoreplace_callback_t; + autoreplace_callback_t mAutoreplaceCallback; + void setAutoreplaceCallback(autoreplace_callback_t cb) { mAutoreplaceCallback = cb; } + // assumes UTF8 text virtual void setValue(const LLSD& value ) { setText(value.asString()); } virtual LLSD getValue() const { return LLSD(getText()); } diff --git a/indra/llvfs/lldir_win32.cpp b/indra/llvfs/lldir_win32.cpp index 1289085b7..f611c6594 100644 --- a/indra/llvfs/lldir_win32.cpp +++ b/indra/llvfs/lldir_win32.cpp @@ -156,8 +156,6 @@ LLDir_Win32::LLDir_Win32() mAppRODataDir = mWorkingDir; -// if (mExecutableDir.find("indra") == std::string::npos) - // *NOTE:Mani - It is a mistake to put viewer specific code in // the LLDir implementation. The references to 'skins' and // 'llplugin' need to go somewhere else. @@ -172,7 +170,18 @@ LLDir_Win32::LLDir_Win32() llinfos << "mAppRODataDir = " << mAppRODataDir << llendl; - mSkinBaseDir = mAppRODataDir + mDirDelimiter + "skins"; + std::string::size_type build_dir_pos = mExecutableDir.rfind("indra" + mDirDelimiter); + if (build_dir_pos != std::string::npos) + { + // ...we're in a dev checkout + mSkinBaseDir = mExecutableDir.substr(0, build_dir_pos) + "indra" + mDirDelimiter + "newview" + mDirDelimiter + "skins"; + llinfos << "Running in dev checkout with mSkinBaseDir " << mSkinBaseDir << llendl; + } + else + { + // ...normal installation running + mSkinBaseDir = mAppRODataDir + mDirDelimiter + "skins"; + } // Build the default cache directory mDefaultCacheDir = buildSLOSCacheDir(); diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 7cdff9888..8b55d30a3 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -126,6 +126,7 @@ set(viewer_SOURCE_FILES llassetuploadresponders.cpp llattachmentsmgr.cpp llaudiosourcevo.cpp + llautoreplace.cpp llavataractions.cpp llavatarpropertiesprocessor.cpp llbox.cpp @@ -181,6 +182,7 @@ set(viewer_SOURCE_FILES llfloaterabout.cpp llfloateractivespeakers.cpp llfloaterauction.cpp + llfloaterautoreplacesettings.cpp llfloateravatarinfo.cpp llfloateravatarlist.cpp llfloateravatarpicker.cpp @@ -244,7 +246,6 @@ set(viewer_SOURCE_FILES llfloaterpathfindingcharacters.cpp llfloaterpathfindinglinksets.cpp llfloaterpathfindingobjects.cpp - llfloaterpermissionsmgr.cpp llfloaterperms.cpp llfloaterpostcard.cpp llfloaterpostprocess.cpp @@ -646,6 +647,7 @@ set(viewer_HEADER_FILES llassetuploadresponders.h llattachmentsmgr.h llaudiosourcevo.h + llautoreplace.h llavataractions.h llavatarpropertiesprocessor.h llbox.h @@ -701,6 +703,7 @@ set(viewer_HEADER_FILES llfloaterabout.h llfloateractivespeakers.h llfloaterauction.h + llfloaterautoreplacesettings.h llfloateravatarinfo.h llfloateravatarlist.h llfloateravatarpicker.h @@ -764,7 +767,6 @@ set(viewer_HEADER_FILES llfloaterpathfindingcharacters.h llfloaterpathfindinglinksets.h llfloaterpathfindingobjects.h - llfloaterpermissionsmgr.h llfloaterperms.h llfloaterpostcard.h llfloaterpostprocess.h diff --git a/indra/newview/app_settings/autoreplace.xml b/indra/newview/app_settings/autoreplace.xml new file mode 100644 index 000000000..09d19f7b0 --- /dev/null +++ b/indra/newview/app_settings/autoreplace.xml @@ -0,0 +1,8330 @@ + + + + name + Abbreviations + replacements + + afaic + As far as I am concerned + afaik + As far as I know + afk + away from keyboard + atm + at the moment + bbiab + be back in a bit + bbl + be back later + brb + be right back + btw + by the way + fyi + For your information + fwiw + For what its worth + gtg + got to go + idk + I don't know + iirc + if I recall correctly + imho + in my humble opinion + imo + in my opinion + irl + in real life + np + no problem + nsfw + not safe for work + nvm + nevermind + tc + take care + thx + thanks + ttfn + ta-ta for now + ttyl + talk to you later + ty + thank you + tyvm + thank you very much + wb + welcome back + yw + you're welcome + yvw + you're very welcome + + + + name + Spelling Corrections + replacements + + Amercia + America + Bernouilli + Bernoulli + Blitzkreig + Blitzkrieg + Bonnano + Bonanno + Brasillian + Brazilian + Britian + Britain + Brittish + British + Buddah + Buddha + Buddist + Buddhist + Cambrige + Cambridge + Capetown + Cape Town + Carmalite + Carmelite + Carnagie + Carnegie + Carnagie-Mellon + Carnegie-Mellon + Carnigie + Carnegie + Carnigie-Mellon + Carnegie-Mellon + Carribbean + Caribbean + Carribean + Caribbean + Carthagian + Carthaginian + Cataline + Catiline + Ceasar + Caesar + Celcius + Celsius + Champange + Champagne + Cincinatti + Cincinnati + Cincinnatti + Cincinnati + Conneticut + Connecticut + Dardenelles + Dardanelles + Dravadian + Dravidian + Enlish + English + Europian + European + Europians + Europeans + Eurpean + European + Eurpoean + European + Farenheit + Fahrenheit + Febuary + February + Feburary + February + Flemmish + Flemish + Formalhaut + Fomalhaut + Foundland + Newfoundland + Fransiscan + Franciscan + Fransiscans + Franciscans + Galations + Galatians + Gameboy + Game Boy + Ghandi + Gandhi + Godounov + Godunov + Gothenberg + Gothenburg + Gottleib + Gottlieb + Guaduloupe + Guadalupe + Guadulupe + Guadalupe + Guatamala + Guatemala + Guatamalan + Guatemalan + Guilia + Giulia + Guilio + Giulio + Guiness + Guinness + Guiseppe + Giuseppe + Habsbourg + Habsburg + Hallowean + Halloween + Heidelburg + Heidelberg + Ihaca + Ithaca + Israelies + Israelis + Janurary + January + Januray + January + Japanes + Japanese + Johanine + Johannine + Jospeh + Joseph + Juadaism + Judaism + Juadism + Judaism + Lybia + Libya + Malcom + Malcolm + Massachussets + Massachusetts + Massachussetts + Massachusetts + Mediteranean + Mediterranean + Michagan + Michigan + Misouri + Missouri + Missisipi + Mississippi + Missisippi + Mississippi + Monserrat + Montserrat + Montnana + Montana + Morisette + Morissette + Morrisette + Morissette + Mythraic + Mithraic + Naploeon + Napoleon + Napolean + Napoleon + Napoleonian + Napoleonic + Nazereth + Nazareth + Newyorker + New Yorker + Novermber + November + Nullabour + Nullarbor + Nuremburg + Nuremberg + Palistian + Palestinian + Palistinian + Palestinian + Palistinians + Palestinians + Papanicalou + Papanicolaou + Peloponnes + Peloponnesus + Pennyslvania + Pennsylvania + Pharoah + Pharaoh + Philipines + Philippines + Phillipine + Philippine + Phillipines + Philippines + Phillippines + Philippines + Phonecian + Phoenecian + Portugese + Portuguese + Postdam + Potsdam + Premonasterians + Premonstratensians + Pucini + Puccini + Puertorrican + Puerto Rican + Puertorricans + Puerto Ricans + Queenland + Queensland + Rockerfeller + Rockefeller + Russion + Russian + Sanhedrim + Sanhedrin + Saterday + Saturday + Saterdays + Saturdays + Sionist + Zionist + Sionists + Zionists + Sixtin + Sistine + Skagerak + Skagerrak + Tolkein + Tolkien + Tuscon + Tucson + Ukranian + Ukrainian + UnitesStates + UnitedStates + Yementite + Yemenite + abandonned + abandoned + aberation + aberration + abilties + abilities + abilty + ability + abondon + abandon + abondoned + abandoned + abondoning + abandoning + abondons + abandons + aborigene + aborigine + abortificant + abortifacient + abreviate + abbreviate + abreviated + abbreviated + abreviation + abbreviation + abritrary + arbitrary + absail + abseil + absailing + abseiling + absense + absence + absolutly + absolutely + absorbsion + absorption + absorbtion + absorption + abundacies + abundances + abundancies + abundances + abundunt + abundant + abutts + abuts + acadamy + academy + acadmic + academic + accademic + academic + accademy + academy + acccused + accused + accelleration + acceleration + accension + ascension + acceptence + acceptance + acceptible + acceptable + accessable + accessible + accidentaly + accidentally + accidently + accidentally + acclimitization + acclimatization + accomadate + accommodate + accomadated + accommodated + accomadates + accommodates + accomadating + accommodating + accomadation + accommodation + accomadations + accommodations + accomdate + accommodate + accomodate + accommodate + accomodated + accommodated + accomodates + accommodates + accomodating + accommodating + accomodation + accommodation + accomodations + accommodations + accompanyed + accompanied + accordeon + accordion + accordian + accordion + accoring + according + accoustic + acoustic + accquainted + acquainted + accrediation + accreditation + accredidation + accreditation + accross + across + accussed + accused + acedemic + academic + acheive + achieve + acheived + achieved + acheivement + achievement + acheivements + achievements + acheives + achieves + acheiving + achieving + acheivment + achievement + acheivments + achievements + achievment + achievement + achievments + achievements + achivement + achievement + achivements + achievements + acknowldeged + acknowledged + acknowledgeing + acknowledging + ackward + awkward + acommodate + accommodate + acomplish + accomplish + acomplished + accomplished + acomplishment + accomplishment + acomplishments + accomplishments + acording + according + acordingly + accordingly + acquaintence + acquaintance + acquaintences + acquaintances + acquiantence + acquaintance + acquiantences + acquaintances + acquited + acquitted + activites + activities + activly + actively + actualy + actually + acuracy + accuracy + acused + accused + acustom + accustom + acustommed + accustomed + adavanced + advanced + adbandon + abandon + additinally + additionally + additionaly + additionally + additonal + additional + additonally + additionally + addmission + admission + addopt + adopt + addopted + adopted + addoptive + adoptive + addres + address + addresable + addressable + addresed + addressed + addresing + addressing + addressess + addresses + addtion + addition + addtional + additional + adecuate + adequate + adequit + adequate + adhearing + adhering + adherance + adherence + admendment + amendment + admininistrative + administrative + adminstered + administered + adminstrate + administrate + adminstration + administration + adminstrative + administrative + adminstrator + administrator + admissability + admissibility + admissable + admissible + admited + admitted + admitedly + admittedly + adn + and + adolecent + adolescent + adquire + acquire + adquired + acquired + adquires + acquires + adquiring + acquiring + adres + address + adresable + addressable + adresing + addressing + adress + address + adressable + addressable + adressed + addressed + adressing + addressing + adventrous + adventurous + advertisment + advertisement + advertisments + advertisements + advesary + adversary + adviced + advised + aeriel + aerial + aeriels + aerials + afair + affair + afficianados + aficionados + afficionado + aficionado + afficionados + aficionados + affilate + affiliate + affilliate + affiliate + affort + afford + aforememtioned + aforementioned + againnst + against + agains + against + agaisnt + against + aganist + against + aggaravates + aggravates + aggreed + agreed + aggreement + agreement + aggregious + egregious + aggresive + aggressive + agian + again + agianst + against + agin + again + agina + again + aginst + against + agravate + aggravate + agre + agree + agred + agreed + agreeement + agreement + agreemnt + agreement + agregate + aggregate + agregates + aggregates + agreing + agreeing + agression + aggression + agressive + aggressive + agressively + aggressively + agressor + aggressor + agricuture + agriculture + agrieved + aggrieved + ahev + have + ahppen + happen + ahve + have + aicraft + aircraft + aiport + airport + airbourne + airborne + aircaft + aircraft + aircrafts + aircraft + airporta + airports + airrcraft + aircraft + aisian + asian + albiet + albeit + alchohol + alcohol + alchoholic + alcoholic + alchol + alcohol + alcholic + alcoholic + alcohal + alcohol + alcoholical + alcoholic + aledge + allege + aledged + alleged + aledges + alleges + alege + allege + aleged + alleged + alegience + allegiance + algebraical + algebraic + algorhitms + algorithms + algoritm + algorithm + algoritms + algorithms + alientating + alienating + alledge + allege + alledged + alleged + alledgedly + allegedly + alledges + alleges + allegedely + allegedly + allegedy + allegedly + allegely + allegedly + allegence + allegiance + allegience + allegiance + allign + align + alligned + aligned + alliviate + alleviate + allopone + allophone + allopones + allophones + allready + already + allthough + although + alltime + all-time + alltogether + altogether + almsot + almost + alochol + alcohol + alomst + almost + alot + a lot + alotted + allotted + alowed + allowed + alowing + allowing + alreayd + already + alse + else + alsot + also + alternitives + alternatives + altho + although + althought + although + altough + although + alusion + allusion + alwasy + always + alwyas + always + amalgomated + amalgamated + amatuer + amateur + amature + armature + amendmant + amendment + amerliorate + ameliorate + amke + make + amking + making + ammend + amend + ammended + amended + ammendment + amendment + ammendments + amendments + ammount + amount + ammused + amused + amoung + among + amoungst + amongst + amung + among + amunition + ammunition + analagous + analogous + analitic + analytic + analogeous + analogous + anarchim + anarchism + anarchistm + anarchism + anbd + and + ancestory + ancestry + ancilliary + ancillary + androgenous + androgynous + androgeny + androgyny + anihilation + annihilation + aniversary + anniversary + annoint + anoint + annointed + anointed + annointing + anointing + annoints + anoints + annouced + announced + annualy + annually + annuled + annulled + anohter + another + anomolies + anomalies + anomolous + anomalous + anomoly + anomaly + anonimity + anonymity + anounced + announced + anouncement + announcement + ansalisation + nasalisation + ansalization + nasalization + ansestors + ancestors + antartic + antarctic + anthromorphization + anthropomorphization + anthropolgist + anthropologist + anthropolgy + anthropology + anual + annual + anulled + annulled + anwsered + answered + anyhwere + anywhere + anyother + any other + anytying + anything + aparent + apparent + aparment + apartment + apenines + apennines + aplication + application + aplied + applied + apolegetics + apologetics + apon + apron + apparant + apparent + apparantly + apparently + appart + apart + appartment + apartment + appartments + apartments + appealling + appealing + appeareance + appearance + appearence + appearance + appearences + appearances + apperance + appearance + apperances + appearances + appereance + appearance + appereances + appearances + applicaiton + application + applicaitons + applications + appologies + apologies + appology + apology + apprearance + appearance + apprieciate + appreciate + approachs + approaches + appropiate + appropriate + appropraite + appropriate + appropropiate + appropriate + approproximate + approximate + approxamately + approximately + approxiately + approximately + approximitely + approximately + aprehensive + apprehensive + apropriate + appropriate + aproximate + approximate + aproximately + approximately + aquaduct + aqueduct + aquaintance + acquaintance + aquainted + acquainted + aquiantance + acquaintance + aquire + acquire + aquired + acquired + aquiring + acquiring + aquisition + acquisition + aquitted + acquitted + aranged + arranged + arangement + arrangement + arbitarily + arbitrarily + arbitary + arbitrary + archaelogists + archaeologists + archaelogy + archaeology + archaoelogy + archaeology + archaology + archaeology + archeaologist + archaeologist + archeaologists + archaeologists + archetect + architect + archetects + architects + archetectural + architectural + archetecturally + architecturally + archetecture + architecture + archiac + archaic + archictect + architect + archimedian + archimedean + architecht + architect + architechturally + architecturally + architechture + architecture + architechtures + architectures + architectual + architectural + archtype + archetype + archtypes + archetypes + aready + already + areodynamics + aerodynamics + argubly + arguably + arguement + argument + arguements + arguments + arised + arose + arival + arrival + armamant + armament + armistace + armistice + arogant + arrogant + arogent + arrogant + aroud + around + arrangment + arrangement + arrangments + arrangements + arround + around + artical + article + artice + article + articel + article + artifical + artificial + artifically + artificially + artillary + artillery + arund + around + asetic + ascetic + asfar + as far + asign + assign + aslo + also + asociated + associated + asorbed + absorbed + asphyxation + asphyxiation + assasin + assassin + assasinate + assassinate + assasinated + assassinated + assasinates + assassinates + assasination + assassination + assasinations + assassinations + assasined + assassinated + assasins + assassins + assassintation + assassination + assemple + assemble + assertation + assertion + asside + aside + assisnate + assassinate + assit + assist + assitant + assistant + assocation + association + assoicate + associate + assoicated + associated + assoicates + associates + assosication + assassination + asssassans + assassins + assualt + assault + assualted + assaulted + assymetric + asymmetric + assymetrical + asymmetrical + asteriod + asteroid + asthetic + aesthetic + asthetical + aesthetical + asthetically + aesthetically + asume + assume + aswell + as well + atain + attain + atempting + attempting + atheistical + atheistic + athenean + athenian + atheneans + athenians + athiesm + atheism + athiest + atheist + atorney + attorney + atribute + attribute + atributed + attributed + atributes + attributes + attaindre + attainder + attemp + attempt + attemped + attempted + attemt + attempt + attemted + attempted + attemting + attempting + attemts + attempts + attendence + attendance + attendent + attendant + attendents + attendants + attened + attended + attension + attention + attitide + attitude + attributred + attributed + attrocities + atrocities + audeince + audience + auromated + automated + austrailia + Australia + austrailian + Australian + auther + author + authobiographic + autobiographic + authobiography + autobiography + authorative + authoritative + authorites + authorities + authorithy + authority + authoritiers + authorities + authoritive + authoritative + authrorities + authorities + autochtonous + autochthonous + autoctonous + autochthonous + automaticly + automatically + automibile + automobile + automonomous + autonomous + autor + author + autority + authority + auxilary + auxiliary + auxillaries + auxiliaries + auxillary + auxiliary + auxilliaries + auxiliaries + auxilliary + auxiliary + availabe + available + availablity + availability + availaible + available + availble + available + availiable + available + availible + available + avalable + available + avalance + avalanche + avaliable + available + avation + aviation + avengence + a vengeance + averageed + averaged + avilable + available + awared + awarded + awya + away + baceause + because + backgorund + background + backrounds + backgrounds + bakc + back + banannas + bananas + bandwith + bandwidth + bankrupcy + bankruptcy + banruptcy + bankruptcy + baout + about + basicaly + basically + basicly + basically + bcak + back + beachead + beachhead + beacuse + because + beastiality + bestiality + beatiful + beautiful + beaurocracy + bureaucracy + beaurocratic + bureaucratic + beautyfull + beautiful + becamae + became + becames + becomes + becasue + because + beccause + because + becomeing + becoming + becomming + becoming + becouse + because + becuase + because + bedore + before + befoer + before + beggin + begin + begginer + beginner + begginers + beginners + beggining + beginning + begginings + beginnings + beggins + begins + begining + beginning + beginnig + beginning + behavour + behavior + beleagured + beleaguered + beleif + belief + beleive + believe + beleived + believed + beleives + believes + beleiving + believing + beligum + belgium + belive + believe + belived + believed + belives + believes + belligerant + belligerent + bellweather + bellwether + bemusemnt + bemusement + beneficary + beneficiary + beng + being + benificial + beneficial + benifit + benefit + benifits + benefits + bergamont + bergamot + beseige + besiege + beseiged + besieged + beseiging + besieging + betwen + between + beween + between + bewteen + between + bilateraly + bilaterally + billingualism + bilingualism + binominal + binomial + bizzare + bizarre + blaim + blame + blaimed + blamed + blessure + blessing + bodydbuilder + bodybuilder + bombardement + bombardment + bombarment + bombardment + bondary + boundary + borke + broke + boundry + boundary + bouyancy + buoyancy + bouyant + buoyant + boyant + buoyant + breakthough + breakthrough + breakthroughts + breakthroughs + breif + brief + breifly + briefly + brethen + brethren + bretheren + brethren + briliant + brilliant + brillant + brilliant + brimestone + brimstone + broacasted + broadcast + broadacasting + broadcasting + broady + broadly + buisness + business + buisnessman + businessman + buoancy + buoyancy + burried + buried + busineses + businesses + busness + business + bussiness + business + caculater + calculator + cacuses + caucuses + cahracters + characters + calaber + caliber + calculater + calculator + calculs + calculus + calenders + calendars + caligraphy + calligraphy + caluclate + calculate + caluclated + calculated + caluculate + calculate + caluculated + calculated + calulate + calculate + calulated + calculated + calulater + calculator + camoflage + camouflage + campain + campaign + campains + campaigns + candadate + candidate + candiate + candidate + candidiate + candidate + cannister + canister + cannisters + canisters + cannnot + cannot + cannonical + canonical + cannotation + connotation + cannotations + connotations + cant + can't + caost + coast + caperbility + capability + capible + capable + captial + capital + captued + captured + capturd + captured + carachter + character + caracterized + characterized + carcas + carcass + carefull + careful + careing + caring + carismatic + charismatic + carnege + carnage + carnige + carnage + carniverous + carnivorous + carreer + career + carrers + careers + cartdridge + cartridge + carthographer + cartographer + cartilege + cartilage + cartilidge + cartilage + cartrige + cartridge + casette + cassette + casion + caisson + cassawory + cassowary + cassowarry + cassowary + casulaties + casualties + casulaty + casualty + catagories + categories + catagorized + categorized + catagory + category + catapillar + caterpillar + catapillars + caterpillars + catapiller + caterpillar + catapillers + caterpillars + catepillar + caterpillar + catepillars + caterpillars + catergorize + categorize + catergorized + categorized + caterpilar + caterpillar + caterpilars + caterpillars + caterpiller + caterpillar + caterpillers + caterpillars + cathlic + catholic + catholocism + catholicism + catterpilar + caterpillar + catterpilars + caterpillars + catterpillar + caterpillar + catterpillars + caterpillars + cattleship + battleship + causalities + casualties + cellpading + cellpadding + cementary + cemetery + cemetarey + cemetery + cemetaries + cemeteries + cemetary + cemetery + cencus + census + censur + censor + cententenial + centennial + centruies + centuries + centruy + century + ceratin + certain + cerimonial + ceremonial + cerimonies + ceremonies + cerimonious + ceremonious + cerimony + ceremony + ceromony + ceremony + certainity + certainty + certian + certain + chalenging + challenging + challange + challenge + challanged + challenged + challege + challenge + changable + changeable + charachter + character + charachters + characters + charactersistic + characteristic + charactor + character + charactors + characters + charasmatic + charismatic + charaterized + characterized + chariman + chairman + charistics + characteristics + cheif + chief + cheifs + chiefs + chemcial + chemical + chemcially + chemically + chemestry + chemistry + chemicaly + chemically + childbird + childbirth + childen + children + choosen + chosen + chracter + character + chuch + church + churchs + churches + circulaton + circulation + circumsicion + circumcision + circut + circuit + ciricuit + circuit + ciriculum + curriculum + civillian + civilian + claer + clear + claerer + clearer + claerly + clearly + claimes + claims + clas + class + clasic + classic + clasical + classical + clasically + classically + cleareance + clearance + clera + clear + clincial + clinical + clinicaly + clinically + cmo + com + cmoputer + computer + co-incided + coincided + coctail + cocktail + coform + conform + cognizent + cognizant + coincedentally + coincidentally + colaborations + collaborations + colateral + collateral + colelctive + collective + collaberative + collaborative + collecton + collection + collegue + colleague + collegues + colleagues + collonade + colonnade + collonies + colonies + collony + colony + collosal + colossal + colonizators + colonizers + comander + commander + comando + commando + comandos + commandos + comany + company + comapany + company + comback + comeback + combanations + combinations + combinatins + combinations + combusion + combustion + comdemnation + condemnation + comemmorates + commemorates + comemoretion + commemoration + comision + commission + comisioned + commissioned + comisioner + commissioner + comisioning + commissioning + comisions + commissions + comission + commission + comissioned + commissioned + comissioner + commissioner + comissioning + commissioning + comissions + commissions + comited + committed + comiting + committing + comitted + committed + comittee + committee + comitting + committing + commandoes + commandos + commedic + comedic + commemerative + commemorative + commemmorate + commemorate + commemmorating + commemorating + commerical + commercial + commerically + commercially + commericial + commercial + commericially + commercially + commerorative + commemorative + comming + coming + comminication + communication + commision + commission + commisioned + commissioned + commisioner + commissioner + commisioning + commissioning + commisions + commissions + commited + committed + commitee + committee + commiting + committing + committe + committee + committment + commitment + committments + commitments + commmemorated + commemorated + commongly + commonly + commonweath + commonwealth + commuications + communications + commuinications + communications + communciation + communication + communiation + communication + communites + communities + compability + compatibility + comparision + comparison + comparisions + comparisons + comparitive + comparative + comparitively + comparatively + compatabilities + compatibilities + compatability + compatibility + compatable + compatible + compatablities + compatibilities + compatablity + compatibility + compatiable + compatible + compatiblities + compatibilities + compatiblity + compatibility + compeitions + competitions + compensantion + compensation + competance + competence + competant + competent + competative + competitive + competion + competition + competitiion + competition + competive + competitive + competiveness + competitiveness + comphrehensive + comprehensive + compitent + competent + completedthe + completed the + completelyl + completely + completetion + completion + complier + compiler + componant + component + comprable + comparable + comprimise + compromise + compulsary + compulsory + compulsery + compulsory + computarized + computerized + concensus + consensus + concider + consider + concidered + considered + concidering + considering + conciders + considers + concieted + conceited + concieved + conceived + concious + conscious + conciously + consciously + conciousness + consciousness + condamned + condemned + condemmed + condemned + condidtion + condition + condidtions + conditions + conditionsof + conditions of + conected + connected + conection + connection + conesencus + consensus + confidental + confidential + confidentally + confidentially + confids + confides + configureable + configurable + confortable + comfortable + congradulations + congratulations + congresional + congressional + conived + connived + conjecutre + conjecture + conjuction + conjunction + conotations + connotations + conquerd + conquered + conquerer + conqueror + conquerers + conquerors + conqured + conquered + conscent + consent + consciouness + consciousness + consdider + consider + consdidered + considered + consdiered + considered + consectutive + consecutive + consenquently + consequently + consentrate + concentrate + consentrated + concentrated + consentrates + concentrates + consept + concept + consequentually + consequently + consequeseces + consequences + consern + concern + conserned + concerned + conserning + concerning + conservitive + conservative + consiciousness + consciousness + consicousness + consciousness + considerd + considered + consideres + considered + consious + conscious + consistant + consistent + consistantly + consistently + consituencies + constituencies + consituency + constituency + consituted + constituted + consitution + constitution + consitutional + constitutional + consolodate + consolidate + consolodated + consolidated + consonent + consonant + consonents + consonants + consorcium + consortium + conspiracys + conspiracies + conspiriator + conspirator + constaints + constraints + constanly + constantly + constarnation + consternation + constatn + constant + constinually + continually + constituant + constituent + constituants + constituents + constituion + constitution + constituional + constitutional + consttruction + construction + constuction + construction + consulant + consultant + consumate + consummate + consumated + consummated + contaiminate + contaminate + containes + contains + contamporaries + contemporaries + contamporary + contemporary + contempoary + contemporary + contemporaneus + contemporaneous + contempory + contemporary + contendor + contender + contibute + contribute + contibuted + contributed + contibutes + contributes + contigent + contingent + contined + continued + continous + continuous + continously + continuously + continueing + continuing + contravercial + controversial + contraversy + controversy + contributer + contributor + contributers + contributors + contritutions + contributions + controled + controlled + controling + controlling + controll + control + controlls + controls + controvercial + controversial + controvercy + controversy + controveries + controversies + controversal + controversial + controversey + controversy + controvertial + controversial + controvery + controversy + contruction + construction + conveinent + convenient + convenant + covenant + convential + conventional + convertables + convertibles + convertion + conversion + conveyer + conveyor + conviced + convinced + convienient + convenient + coordiantion + coordination + coorperations + corporations + copmetitors + competitors + coputer + computer + copywrite + copyright + coridal + cordial + cornmitted + committed + corosion + corrosion + corparate + corporate + corperations + corporations + correcters + correctors + correponding + corresponding + correposding + corresponding + correspondant + correspondent + correspondants + correspondents + corridoors + corridors + corrispond + correspond + corrispondant + correspondent + corrispondants + correspondents + corrisponded + corresponded + corrisponding + corresponding + corrisponds + corresponds + costitution + constitution + coucil + council + counries + countries + countains + contains + countires + countries + coururier + courier + coverted + converted + cpoy + copy + creaeted + created + creedence + credence + critereon + criterion + criterias + criteria + criticists + critics + critising + criticising + critisising + criticising + critisism + criticism + critisisms + criticisms + critisize + criticise + critisized + criticised + critisizes + criticises + critisizing + criticising + critized + criticized + critizing + criticizing + crockodiles + crocodiles + crowm + crown + crtical + critical + crticised + criticised + crucifiction + crucifixion + crusies + cruises + crystalisation + crystallisation + culiminating + culminating + cumulatative + cumulative + curch + church + curcuit + circuit + currenly + currently + curriculem + curriculum + cxan + cyan + cyclinder + cylinder + dacquiri + daiquiri + dael + deal + dalmation + dalmatian + damenor + demeanor + dammage + damage + daugher + daughter + debateable + debatable + decendant + descendant + decendants + descendants + decendent + descendant + decendents + descendants + decideable + decidable + decidely + decidedly + decieved + deceived + decison + decision + decomissioned + decommissioned + decomposit + decompose + decomposited + decomposed + decompositing + decomposing + decomposits + decomposes + decress + decrees + decribe + describe + decribed + described + decribes + describes + decribing + describing + dectect + detect + defendent + defendant + defendents + defendants + deffensively + defensively + deffine + define + deffined + defined + definance + defiance + definate + definite + definately + definitely + definatly + definitely + definetly + definitely + definining + defining + definit + definite + definitly + definitely + definiton + definition + defintion + definition + degrate + degrade + delagates + delegates + delapidated + dilapidated + delerious + delirious + delevopment + development + deliberatly + deliberately + delusionally + delusively + demenor + demeanor + demographical + demographic + demolision + demolition + demorcracy + democracy + demostration + demonstration + denegrating + denigrating + densly + densely + deparment + department + deparmental + departmental + deparments + departments + dependance + dependence + dependancy + dependency + dependant + dependent + deram + dream + deriviated + derived + derivitive + derivative + derogitory + derogatory + descendands + descendants + descibed + described + descision + decision + descisions + decisions + descriibes + describes + descripters + descriptors + descripton + description + desctruction + destruction + descuss + discuss + desgined + designed + deside + decide + desigining + designing + desinations + destinations + desintegrated + disintegrated + desintegration + disintegration + desireable + desirable + desitned + destined + desktiop + desktop + desorder + disorder + desoriented + disoriented + desparate + desperate + despict + depict + despiration + desperation + dessicated + desiccated + dessigned + designed + destablized + destabilized + destory + destroy + detailled + detailed + detatched + detached + deteoriated + deteriorated + deteriate + deteriorate + deterioriating + deteriorating + determinining + determining + detremental + detrimental + devasted + devastated + develope + develop + developement + development + developped + developed + develpment + development + devels + delves + devestated + devastated + devestating + devastating + devide + divide + devided + divided + devistating + devastating + devolopement + development + diablical + diabolical + diamons + diamonds + diaster + disaster + dichtomy + dichotomy + diconnects + disconnects + dicover + discover + dicovered + discovered + dicovering + discovering + dicovers + discovers + dicovery + discovery + dicussed + discussed + didnt + didn't + diea + idea + dieing + dying + dieties + deities + diety + deity + diferent + different + diferrent + different + differentiatiations + differentiations + differnt + different + difficulity + difficulty + diffrent + different + dificulties + difficulties + dificulty + difficulty + dimenions + dimensions + dimention + dimension + dimentional + dimensional + dimentions + dimensions + dimesnional + dimensional + diminuitive + diminutive + dimunitive + diminutive + diosese + diocese + diphtong + diphthong + diphtongs + diphthongs + diplomancy + diplomacy + dipthong + diphthong + dipthongs + diphthongs + dirived + derived + disagreeed + disagreed + disapeared + disappeared + disapointing + disappointing + disappearred + disappeared + disaproval + disapproval + disasterous + disastrous + disatisfaction + dissatisfaction + disatisfied + dissatisfied + disatrous + disastrous + discontentment + discontent + discribe + describe + discribed + described + discribes + describes + discribing + describing + disctinction + distinction + disctinctive + distinctive + disemination + dissemination + disenchanged + disenchanted + disiplined + disciplined + disobediance + disobedience + disobediant + disobedient + disolved + dissolved + disover + discover + dispair + despair + disparingly + disparagingly + dispence + dispense + dispenced + dispensed + dispencing + dispensing + dispicable + despicable + dispite + despite + dispostion + disposition + disproportiate + disproportionate + disputandem + disputandum + disricts + districts + dissagreement + disagreement + dissapear + disappear + dissapearance + disappearance + dissapeared + disappeared + dissapearing + disappearing + dissapears + disappears + dissappear + disappear + dissappears + disappears + dissappointed + disappointed + dissarray + disarray + dissobediance + disobedience + dissobediant + disobedient + dissobedience + disobedience + dissobedient + disobedient + distiction + distinction + distingish + distinguish + distingished + distinguished + distingishes + distinguishes + distingishing + distinguishing + distingquished + distinguished + distrubution + distribution + distruction + destruction + distructive + destructive + ditributed + distributed + diversed + diverged + divice + device + divison + division + divisons + divisions + doccument + document + doccumented + documented + doccuments + documents + docrines + doctrines + doctines + doctrines + documenatry + documentary + doens + does + doesnt + doesn't + doign + doing + dominaton + domination + dominent + dominant + dominiant + dominant + donig + doing + dont + don't + dosen't + doesn't + doub + doubt + doulbe + double + dowloads + downloads + dramtic + dramatic + draughtman + draughtsman + dreasm + dreams + driectly + directly + drnik + drink + druming + drumming + drummless + drumless + dupicate + duplicate + durig + during + durring + during + duting + during + dyas + dryas + eahc + each + ealier + earlier + earlies + earliest + earnt + earned + ecclectic + eclectic + eceonomy + economy + ecidious + deciduous + eclispe + eclipse + ecomonic + economic + ect + etc + eearly + early + efel + evil + effeciency + efficiency + effecient + efficient + effeciently + efficiently + efficency + efficiency + efficent + efficient + efficently + efficiently + efford + effort + effords + efforts + effulence + effluence + eigth + eight + eiter + either + elction + election + electic + electric + electon + electron + electrial + electrical + electricly + electrically + electricty + electricity + elementay + elementary + eleminated + eliminated + eleminating + eliminating + eles + eels + eletricity + electricity + elicided + elicited + eligable + eligible + elimentary + elementary + ellected + elected + elphant + elephant + embarass + embarrass + embarassed + embarrassed + embarassing + embarrassing + embarassment + embarrassment + embargos + embargoes + embarras + embarrass + embarrased + embarrassed + embarrasing + embarrassing + embarrasment + embarrassment + embezelled + embezzled + emblamatic + emblematic + eminate + emanate + eminated + emanated + emision + emission + emited + emitted + emiting + emitting + emition + emission + emmediately + immediately + emmigrated + immigrated + emminently + eminently + emmisaries + emissaries + emmisarries + emissaries + emmisarry + emissary + emmisary + emissary + emmision + emission + emmisions + emissions + emmited + emitted + emmiting + emitting + emmitted + emitted + emmitting + emitting + emnity + enmity + emperical + empirical + emphaised + emphasised + emphsis + emphasis + emphysyma + emphysema + emprisoned + imprisoned + enameld + enameled + enchancement + enhancement + encouraing + encouraging + encryptiion + encryption + encylopedia + encyclopedia + endevors + endeavors + endevour + endeavour + endig + ending + endolithes + endoliths + enduce + induce + ened + need + enflamed + inflamed + enforceing + enforcing + engagment + engagement + engeneer + engineer + engeneering + engineering + engieneer + engineer + engieneers + engineers + enlargment + enlargement + enlargments + enlargements + enourmous + enormous + enourmously + enormously + ensconsed + ensconced + entaglements + entanglements + enteratinment + entertainment + enthusiatic + enthusiastic + entitity + entity + entitlied + entitled + entrepeneur + entrepreneur + entrepeneurs + entrepreneurs + enviorment + environment + enviormental + environmental + enviormentally + environmentally + enviorments + environments + enviornment + environment + enviornmental + environmental + enviornmentalist + environmentalist + enviornmentally + environmentally + enviornments + environments + enviroment + environment + enviromental + environmental + enviromentalist + environmentalist + enviromentally + environmentally + enviroments + environments + envolutionary + evolutionary + envrionments + environments + enxt + next + epidsodes + episodes + epsiode + episode + equialent + equivalent + equilibium + equilibrium + equilibrum + equilibrium + equiped + equipped + equippment + equipment + equitorial + equatorial + equivelant + equivalent + equivelent + equivalent + equivilant + equivalent + equivilent + equivalent + equivlalent + equivalent + erally + really + eratic + erratic + eratically + erratically + eraticly + erratically + errupted + erupted + esential + essential + esitmated + estimated + esle + else + especialy + especially + essencial + essential + essense + essence + essentail + essential + essentialy + essentially + essentual + essential + essesital + essential + estabishes + establishes + establising + establishing + ethnocentricm + ethnocentrism + ethose + those + evenhtually + eventually + eventally + eventually + eventhough + even though + eventially + eventually + eventualy + eventually + everthing + everything + everytime + every time + everyting + everything + eveyr + every + evidentally + evidently + exagerate + exaggerate + exagerated + exaggerated + exagerates + exaggerates + exagerating + exaggerating + exagerrate + exaggerate + exagerrated + exaggerated + exagerrates + exaggerates + exagerrating + exaggerating + examinated + examined + exampt + exempt + exapansion + expansion + excact + exact + excange + exchange + excecute + execute + excecuted + executed + excecutes + executes + excecuting + executing + excecution + execution + excedded + exceeded + excelent + excellent + excell + excel + excellance + excellence + excellant + excellent + excells + excels + excercise + exercise + exchanching + exchanging + excisted + existed + exculsivly + exclusively + execising + exercising + exection + execution + exectued + executed + exeedingly + exceedingly + exelent + excellent + exellent + excellent + exemple + example + exept + except + exeptional + exceptional + exerbate + exacerbate + exerbated + exacerbated + exerciese + exercises + exerpt + excerpt + exerpts + excerpts + exersize + exercise + exerternal + external + exhalted + exalted + exhibtion + exhibition + exibition + exhibition + exibitions + exhibitions + exicting + exciting + exinct + extinct + existance + existence + existant + existent + existince + existence + exliled + exiled + exludes + excludes + exmaple + example + exonorate + exonerate + exoskelaton + exoskeleton + expalin + explain + expatriot + expatriate + expeced + expected + expecially + especially + expeditonary + expeditionary + expeiments + experiments + expell + expel + expells + expels + experiance + experience + experianced + experienced + expiditions + expeditions + expierence + experience + explaination + explanation + explaning + explaining + explictly + explicitly + exploititive + exploitative + explotation + exploitation + expropiated + expropriated + expropiation + expropriation + exressed + expressed + extemely + extremely + extention + extension + extentions + extensions + extered + exerted + extermist + extremist + extint + extinct + extradiction + extradition + extraterrestial + extraterrestrial + extraterrestials + extraterrestrials + extravagent + extravagant + extrememly + extremely + extremeophile + extremophile + extremly + extremely + extrordinarily + extraordinarily + extrordinary + extraordinary + eyar + year + eyars + years + eyasr + years + faciliate + facilitate + faciliated + facilitated + faciliates + facilitates + facilites + facilities + facillitate + facilitate + facinated + fascinated + facist + fascist + familes + families + familliar + familiar + famoust + famous + fanatism + fanaticism + fatc + fact + faught + fought + favoutrable + favourable + feasable + feasible + fedreally + federally + feromone + pheromone + fertily + fertility + fianite + finite + fianlly + finally + ficticious + fictitious + fictious + fictitious + fidn + find + fiercly + fiercely + fightings + fighting + filiament + filament + fimilies + families + finacial + financial + finaly + finally + financialy + financially + firends + friends + firts + first + fisionable + fissionable + flamable + flammable + flawess + flawless + fleed + fled + florescent + fluorescent + flourescent + fluorescent + flourine + fluorine + fluorish + flourish + follwoing + following + folowing + following + fomed + formed + fomr + from + fonetic + phonetic + fontrier + fontier + foootball + football + forbad + forbade + forbiden + forbidden + foreward + foreword + forfiet + forfeit + forhead + forehead + foriegn + foreign + formallize + formalize + formallized + formalized + formaly + formally + formelly + formerly + formidible + formidable + formost + foremost + forsaw + foresaw + forseeable + foreseeable + fortelling + foretelling + forunner + forerunner + foucs + focus + foudn + found + fougth + fought + foundaries + foundries + foundary + foundry + fourties + forties + fourty + forty + fouth + fourth + foward + forward + freind + friend + freindly + friendly + frequentily + frequently + frome + from + fromed + formed + froniter + frontier + fucntion + function + fucntioning + functioning + fufill + fulfill + fufilled + fulfilled + fulfiled + fulfilled + fullfill + fulfill + fullfilled + fulfilled + fundametal + fundamental + fundametals + fundamentals + funguses + fungi + funtion + function + furuther + further + futher + further + futhermore + furthermore + galatic + galactic + gallaxies + galaxies + galvinized + galvanized + ganerate + generate + ganes + games + ganster + gangster + garantee + guarantee + garanteed + guaranteed + garantees + guarantees + garnison + garrison + gaurantee + guarantee + gauranteed + guaranteed + gaurantees + guarantees + gaurd + guard + gaurentee + guarantee + gaurenteed + guaranteed + gaurentees + guarantees + geneological + genealogical + geneologies + genealogies + geneology + genealogy + generaly + generally + generatting + generating + genialia + genitalia + geographicial + geographical + geometrician + geometer + geometricians + geometers + gerat + great + glight + flight + gnawwed + gnawed + godess + goddess + godesses + goddesses + gogin + going + goign + going + gonig + going + gouvener + governor + govement + government + govenment + government + govenrment + government + goverance + governance + goverment + government + govermental + governmental + governer + governor + governmnet + government + govorment + government + govormental + governmental + govornment + government + gracefull + graceful + graet + great + grafitti + graffiti + gramatically + grammatically + grammaticaly + grammatically + grammer + grammar + grat + great + gratuitious + gratuitous + greatful + grateful + greatfully + gratefully + greif + grief + gridles + griddles + gropu + group + grwo + grow + guage + gauge + guarentee + guarantee + guarenteed + guaranteed + guarentees + guarantees + guerilla + guerrilla + guerillas + guerrillas + guerrila + guerrilla + guerrilas + guerrillas + guidence + guidance + gunanine + guanine + gurantee + guarantee + guranteed + guaranteed + gurantees + guarantees + guttaral + guttural + gutteral + guttural + habaeus + habeas + habeus + habeas + haemorrage + haemorrhage + haev + have + halp + help + hapen + happen + hapened + happened + hapening + happening + happend + happened + happended + happened + happenned + happened + harased + harassed + harases + harasses + harasment + harassment + harasments + harassments + harassement + harassment + harras + harass + harrased + harassed + harrases + harasses + harrasing + harassing + harrasment + harassment + harrasments + harassments + harrassed + harassed + harrasses + harassed + harrassing + harassing + harrassment + harassment + harrassments + harassments + hasnt + hasn't + haviest + heaviest + headquarer + headquarter + headquater + headquarter + headquatered + headquartered + headquaters + headquarters + healthercare + healthcare + heared + heard + heathy + healthy + heigher + higher + heirarchy + hierarchy + heiroglyphics + hieroglyphics + helment + helmet + helpfull + helpful + helpped + helped + hemmorhage + hemorrhage + herad + heard + heridity + heredity + heroe + hero + heros + heroes + hertiage + heritage + hertzs + hertz + hesistant + hesitant + heterogenous + heterogeneous + hieght + height + hierachical + hierarchical + hierachies + hierarchies + hierachy + hierarchy + hierarcical + hierarchical + hierarcy + hierarchy + hieroglph + hieroglyph + hieroglphs + hieroglyphs + higer + higher + higest + highest + higway + highway + hillarious + hilarious + himselv + himself + hinderance + hindrance + hinderence + hindrance + hindrence + hindrance + hipopotamus + hippopotamus + hismelf + himself + histocompatability + histocompatibility + historicians + historians + hitsingles + hit singles + holliday + holiday + homestate + home state + homogeneize + homogenize + homogeneized + homogenized + honory + honorary + horrifing + horrifying + hosited + hoisted + hospitible + hospitable + hounour + honour + housr + hours + howver + however + hsitorians + historians + hstory + history + hten + then + htere + there + htey + they + htikn + think + hting + thing + htink + think + htis + this + humer + humor + humerous + humorous + huminoid + humanoid + humoural + humoral + humurous + humorous + husban + husband + hvae + have + hvaing + having + hvea + have + hwihc + which + hwile + while + hwole + whole + hydogen + hydrogen + hydropile + hydrophile + hydropilic + hydrophilic + hydropobe + hydrophobe + hydropobic + hydrophobic + hygeine + hygiene + hypocracy + hypocrisy + hypocrasy + hypocrisy + hypocricy + hypocrisy + hypocrit + hypocrite + hypocrits + hypocrites + i + I + iconclastic + iconoclastic + idaeidae + idea + idaes + ideas + idealogies + ideologies + idealogy + ideology + identicial + identical + identifers + identifiers + ideosyncratic + idiosyncratic + idesa + ideas + idiosyncracy + idiosyncrasy + illegimacy + illegitimacy + illegitmate + illegitimate + illess + illness + illiegal + illegal + illution + illusion + ilness + illness + ilogical + illogical + imagenary + imaginary + imagin + imagine + imaginery + imaginary + imcomplete + incomplete + imediately + immediately + imense + immense + immediatley + immediately + immediatly + immediately + immidately + immediately + immidiately + immediately + immitate + imitate + immitated + imitated + immitating + imitating + immitator + imitator + immunosupressant + immunosuppressant + impecabbly + impeccably + impedence + impedance + implamenting + implementing + impliment + implement + implimented + implemented + imploys + employs + importamt + important + imprioned + imprisoned + imprisonned + imprisoned + improvision + improvisation + improvments + improvements + inablility + inability + inaccessable + inaccessible + inadiquate + inadequate + inadquate + inadequate + inadvertant + inadvertent + inadvertantly + inadvertently + inagurated + inaugurated + inaguration + inauguration + inappropiate + inappropriate + inaugures + inaugurates + inbalance + imbalance + inbalanced + imbalanced + inbetween + between + incarcirated + incarcerated + incidentially + incidentally + incidently + incidentally + inclreased + increased + includ + include + includng + including + incompatabilities + incompatibilities + incompatability + incompatibility + incompatable + incompatible + incompatablities + incompatibilities + incompatablity + incompatibility + incompatiblities + incompatibilities + incompatiblity + incompatibility + incompetance + incompetence + incompetant + incompetent + incomptable + incompatible + incomptetent + incompetent + inconsistant + inconsistent + incoroporated + incorporated + incorperation + incorporation + incorportaed + incorporated + incorprates + incorporates + incorruptable + incorruptible + incramentally + incrementally + increadible + incredible + incredable + incredible + inctroduce + introduce + inctroduced + introduced + incuding + including + incunabla + incunabula + indefinately + indefinitely + indefineable + undefinable + indefinitly + indefinitely + indentical + identical + indepedantly + independently + indepedence + independence + independance + independence + independant + independent + independantly + independently + independece + independence + independendet + independent + indespensable + indispensable + indespensible + indispensable + indictement + indictment + indigineous + indigenous + indipendence + independence + indipendent + independent + indipendently + independently + indispensible + indispensable + indisputible + indisputable + indisputibly + indisputably + indite + indict + individualy + individually + indpendent + independent + indpendently + independently + indulgue + indulge + indutrial + industrial + indviduals + individuals + inefficienty + inefficiently + inevatible + inevitable + inevitible + inevitable + inevititably + inevitably + infalability + infallibility + infallable + infallible + infectuous + infectious + infered + inferred + infilitrate + infiltrate + infilitrated + infiltrated + infilitration + infiltration + infinit + infinite + inflamation + inflammation + influencial + influential + influented + influenced + infomation + information + informtion + information + infrantryman + infantryman + infrigement + infringement + ingenius + ingenious + ingreediants + ingredients + inhabitans + inhabitants + inherantly + inherently + inheritence + inheritance + inital + initial + initally + initially + initation + initiation + initiaitive + initiative + inlcuding + including + inmigrant + immigrant + inmigrants + immigrants + innoculated + inoculated + inocence + innocence + inofficial + unofficial + inot + into + inpeach + impeach + inpolite + impolite + inprisonment + imprisonment + inproving + improving + insectiverous + insectivorous + insensative + insensitive + inseperable + inseparable + insistance + insistence + insitution + institution + insitutions + institutions + inspite + in spite + instade + instead + instatance + instance + institue + institute + instuction + instruction + instuments + instruments + instutionalized + institutionalized + instutions + intuitions + insurence + insurance + intelectual + intellectual + inteligence + intelligence + inteligent + intelligent + intenational + international + intented + intended + intepretation + interpretation + intepretator + interpretor + interational + international + interbread + interbreed + interchangable + interchangeable + interchangably + interchangeably + intercontinetal + intercontinental + intered + interred + interelated + interrelated + interferance + interference + interfereing + interfering + intergrated + integrated + intergration + integration + interm + interim + internation + international + interpet + interpret + interrim + interim + interrugum + interregnum + intertaining + entertaining + interupt + interrupt + intervines + intervenes + intevene + intervene + intial + initial + intially + initially + intrduced + introduced + intrest + interest + introdued + introduced + intruduced + introduced + intrument + instrument + intrumental + instrumental + intruments + instruments + intrusted + entrusted + intutive + intuitive + intutively + intuitively + inudstry + industry + inventer + inventor + invertibrates + invertebrates + investingate + investigate + involvment + involvement + irelevent + irrelevant + iresistable + irresistible + iresistably + irresistibly + iresistible + irresistible + iresistibly + irresistibly + iritable + irritable + iritated + irritated + ironicly + ironically + irregardless + regardless + irrelevent + irrelevant + irreplacable + irreplaceable + irresistable + irresistible + irresistably + irresistibly + isnt + isn't + issueing + issuing + itnroduced + introduced + iunior + junior + iwll + will + iwth + with + jaques + jacques + jeapardy + jeopardy + jewllery + jewellery + jouney + journey + journied + journeyed + journies + journeys + jstu + just + jsut + just + judical + judicial + judisuary + judiciary + juducial + judicial + juristiction + jurisdiction + juristictions + jurisdictions + kindergarden + kindergarten + klenex + kleenex + knifes + knives + knive + knife + knowlege + knowledge + knowlegeable + knowledgeable + knwo + know + knwos + knows + konw + know + konws + knows + kwno + know + labatory + laboratory + labratory + laboratory + laguage + language + laguages + languages + larg + large + largst + largest + larrry + larry + lastr + last + lattitude + latitude + launhed + launched + lavae + larvae + layed + laid + lazyness + laziness + leage + league + leanr + learn + leathal + lethal + lefted + left + legitamate + legitimate + legitmate + legitimate + leibnitz + leibniz + lenght + length + leran + learn + lerans + learns + leutenant + lieutenant + levetate + levitate + levetated + levitated + levetates + levitates + levetating + levitating + levle + level + liasion + liaison + liason + liaison + liasons + liaisons + libary + library + libell + libel + libguistic + linguistic + libguistics + linguistics + libitarianisn + libertarianism + lieing + lying + liek + like + liekd + liked + liesure + leisure + lieuenant + lieutenant + lieved + lived + liftime + lifetime + lightyear + light year + lightyears + light years + likelyhood + likelihood + linnaena + linnaean + lippizaner + lipizzaner + liquify + liquefy + liscense + license + lisence + license + lisense + license + listners + listeners + litature + literature + literaly + literally + literture + literature + littel + little + litterally + literally + liuke + like + livley + lively + lmits + limits + loev + love + lonelyness + loneliness + longitudonal + longitudinal + lonley + lonely + lonly + lonely + loosing + losing + lotharingen + lothringen + lsat + last + lukid + likud + lveo + love + lvoe + love + maching + machine + mackeral + mackerel + magasine + magazine + magincian + magician + magnificient + magnificent + magolia + magnolia + mailny + mainly + maintainance + maintenance + maintainence + maintenance + maintance + maintenance + maintenence + maintenance + maintinaing + maintaining + maintioned + mentioned + majoroty + majority + maked + marked + makse + makes + maltesian + Maltese + mamal + mammal + mamalian + mammalian + managable + manageable + managment + management + maneouvre + manoeuvre + maneouvred + manoeuvred + maneouvres + manoeuvres + maneouvring + manoeuvring + manisfestations + manifestations + manoeuverability + maneuverability + manouver + maneuver + manouverability + maneuverability + manouverable + maneuverable + manouvers + maneuvers + mantained + maintained + manuever + maneuver + manuevers + maneuvers + manufacturedd + manufactured + manufature + manufacture + manufatured + manufactured + manufaturing + manufacturing + manuver + maneuver + mariage + marriage + marjority + majority + markes + marks + marketting + marketing + marmelade + marmalade + marrage + marriage + marraige + marriage + marrtyred + martyred + marryied + married + massmedia + mass media + masterbation + masturbation + mataphysical + metaphysical + materalists + materialist + mathamatics + mathematics + mathematican + mathematician + mathematicas + mathematics + matheticians + mathematicians + mathmatically + mathematically + mathmatician + mathematician + mathmaticians + mathematicians + mccarthyst + mccarthyist + mchanics + mechanics + meaninng + meaning + mear + wear + mechandise + merchandise + medacine + medicine + medeival + medieval + medevial + medieval + mediciney + mediciny + medievel + medieval + mediterainnean + mediterranean + meerkrat + meerkat + melieux + milieux + membranaphone + membranophone + memeber + member + menally + mentally + meranda + Miranda + mercentile + mercantile + messanger + messenger + messenging + messaging + metalic + metallic + metalurgic + metallurgic + metalurgical + metallurgical + metalurgy + metallurgy + metamorphysis + metamorphosis + metaphoricial + metaphorical + meterologist + meteorologist + meterology + meteorology + methaphor + metaphor + methaphors + metaphors + micoscopy + microscopy + midwifes + midwives + mileau + milieu + milennia + millennia + milennium + millennium + mileu + milieu + miliary + military + milion + million + miliraty + military + millenia + millennia + millenial + millennial + millenialism + millennialism + millenium + millennium + millepede + millipede + millioniare + millionaire + millitary + military + millon + million + miltary + military + minature + miniature + minerial + mineral + miniscule + minuscule + ministery + ministry + minstries + ministries + minstry + ministry + minumum + minimum + mirrorred + mirrored + miscelaneous + miscellaneous + miscellanious + miscellaneous + miscellanous + miscellaneous + mischeivous + mischievous + mischevious + mischievous + mischievious + mischievous + misdameanor + misdemeanor + misdameanors + misdemeanors + misdemenor + misdemeanor + misdemenors + misdemeanors + misfourtunes + misfortunes + misile + missile + mispell + misspell + mispelled + misspelled + mispelling + misspelling + missen + mizzen + missle + missile + missonary + missionary + misterious + mysterious + mistery + mystery + misteryous + mysterious + mkae + make + mkaes + makes + mkaing + making + mkea + make + moderm + modem + modle + model + moent + moment + moeny + money + mohammedans + muslims + moil + soil + moleclues + molecules + momento + memento + monestaries + monasteries + monestary + monastery + monickers + monikers + monolite + monolithic + montains + mountains + montanous + mountainous + monts + months + montypic + monotypic + moreso + more so + morgage + mortgage + morroccan + moroccan + morrocco + morocco + morroco + morocco + mortage + mortgage + mosture + moisture + motiviated + motivated + mounth + month + movei + movie + movment + movement + mroe + more + mucuous + mucous + muder + murder + mudering + murdering + muhammadan + muslim + multicultralism + multiculturalism + multipled + multiplied + multiplers + multipliers + munbers + numbers + muncipalities + municipalities + muncipality + municipality + munnicipality + municipality + muscels + muscles + muscial + musical + muscician + musician + muscicians + musicians + mutiliated + mutilated + myraid + myriad + mysef + myself + mysogynist + misogynist + mysogyny + misogyny + mysterous + mysterious + naieve + naive + naturaly + naturally + naturely + naturally + naturual + natural + naturually + naturally + neccesarily + necessarily + neccesary + necessary + neccessarily + necessarily + neccessary + necessary + neccessities + necessities + necesarily + necessarily + necesary + necessary + necessiate + necessitate + neglible + negligible + negligable + negligible + negociate + negotiate + negociation + negotiation + negociations + negotiations + negotation + negotiation + neice + niece + neigborhood + neighborhood + neigbour + neighbour + neigbourhood + neighbourhood + neolitic + neolithic + nessasarily + necessarily + nessecary + necessary + nestin + nesting + neverthless + nevertheless + newletters + newsletters + nickle + nickel + nightfa;; + nightfall + nightime + nighttime + nineth + ninth + ninteenth + nineteenth + ninties + 1990s + ninty + ninety + nkow + know + nkwo + know + nmae + name + noncombatents + noncombatants + nonsence + nonsense + nontheless + nonetheless + noone + no one + norhern + northern + northen + northern + northereastern + northeastern + notabley + notably + noteable + notable + noteably + notably + noteriety + notoriety + noth + north + nothern + northern + noticable + noticeable + noticably + noticeably + noticeing + noticing + noticible + noticeable + notwhithstanding + notwithstanding + noveau + nouveau + nowdays + nowadays + nowe + now + nto + not + nucular + nuclear + nuculear + nuclear + nuisanse + nuisance + numberous + numerous + nusance + nuisance + nutritent + nutrient + nutritents + nutrients + nuturing + nurturing + obediance + obedience + obediant + obedient + obession + obsession + obssessed + obsessed + obstacal + obstacle + obstancles + obstacles + obstruced + obstructed + ocasion + occasion + ocasional + occasional + ocasionally + occasionally + ocasionaly + occasionally + ocasioned + occasioned + ocasions + occasions + ocassion + occasion + ocassional + occasional + ocassionally + occasionally + ocassionaly + occasionally + ocassioned + occasioned + ocassions + occasions + occaison + occasion + occassion + occasion + occassional + occasional + occassionally + occasionally + occassionaly + occasionally + occassioned + occasioned + occassions + occasions + occationally + occasionally + occour + occur + occurance + occurrence + occurances + occurrences + occured + occurred + occurence + occurrence + occurences + occurrences + occuring + occurring + occurr + occur + occurrance + occurrence + occurrances + occurrences + octohedra + octahedra + octohedral + octahedral + octohedron + octahedron + ocuntries + countries + ocuntry + country + ocurr + occur + ocurrance + occurrence + ocurred + occurred + ocurrence + occurrence + offcers + officers + offcially + officially + offereings + offerings + offical + official + offically + officially + officals + officials + officaly + officially + officialy + officially + offred + offered + oftenly + often + oging + going + omision + omission + omited + omitted + omiting + omitting + omlette + omelette + ommision + omission + ommited + omitted + ommiting + omitting + ommitted + omitted + ommitting + omitting + omniverous + omnivorous + omniverously + omnivorously + omre + more + onot + note + onxy + onyx + onyl + only + openess + openness + oponent + opponent + oportunity + opportunity + opose + oppose + oposite + opposite + oposition + opposition + oppenly + openly + oppinion + opinion + opponant + opponent + oppononent + opponent + oppositition + opposition + oppossed + opposed + opprotunity + opportunity + opression + oppression + opressive + oppressive + opthalmic + ophthalmic + opthalmologist + ophthalmologist + opthalmology + ophthalmology + opthamologist + ophthalmologist + optmizations + optimizations + optomism + optimism + orded + ordered + organim + organism + organistion + organisation + organiztion + organization + orgin + origin + orginal + original + orginally + originally + orginize + organise + oridinarily + ordinarily + origanaly + originally + originall + original + originaly + originally + originially + originally + originnally + originally + origional + original + orignally + originally + orignially + originally + otehr + other + oublisher + publisher + ouevre + oeuvre + oustanding + outstanding + overshaddowed + overshadowed + overthere + over there + overwelming + overwhelming + overwheliming + overwhelming + owrk + work + owudl + would + oxigen + oxygen + oximoron + oxymoron + p0enis + penis + paide + paid + paitience + patience + palce + place + paleolitic + paleolithic + paliamentarian + parliamentarian + pallete + palette + pamflet + pamphlet + pamplet + pamphlet + pantomine + pantomime + paralel + parallel + paralell + parallel + paralelly + parallelly + paralely + parallelly + parallely + parallelly + paranthesis + parenthesis + paraphenalia + paraphernalia + parellels + parallels + parituclar + particular + parliment + parliament + parrakeets + parakeets + parralel + parallel + parrallel + parallel + parrallell + parallel + parrallelly + parallelly + parrallely + parallelly + partialy + partially + particually + particularly + particualr + particular + particuarly + particularly + particularily + particularly + particulary + particularly + pary + party + pased + passed + pasengers + passengers + passerbys + passersby + pasttime + pastime + pastural + pastoral + paticular + particular + pattented + patented + pavillion + pavilion + payed + paid + pblisher + publisher + pbulisher + publisher + peacefuland + peaceful and + peageant + pageant + peculure + peculiar + pedestrain + pedestrian + peformed + performed + peice + piece + penatly + penalty + penerator + penetrator + penisula + peninsula + penisular + peninsular + penninsula + peninsula + penninsular + peninsular + pennisula + peninsula + pensinula + peninsula + peom + poem + peoms + poems + peopel + people + peotry + poetry + perade + parade + percepted + perceived + percieve + perceive + percieved + perceived + perenially + perennially + perfomance + performance + perfomers + performers + performence + performance + performes + performed + perhasp + perhaps + perheaps + perhaps + perhpas + perhaps + peripathetic + peripatetic + peristent + persistent + perjery + perjury + perjorative + pejorative + permanant + permanent + permenant + permanent + permenantly + permanently + permissable + permissible + perogative + prerogative + peronal + personal + perosnality + personality + perphas + perhaps + perpindicular + perpendicular + perseverence + perseverance + persistance + persistence + persistant + persistent + personel + personnel + personell + personnel + personnell + personnel + persuded + persuaded + persue + pursue + persued + pursued + persuing + pursuing + persuit + pursuit + persuits + pursuits + pertubation + perturbation + pertubations + perturbations + pessiary + pessary + petetion + petition + phenomenom + phenomenon + phenomenonal + phenomenal + phenomenonly + phenomenally + phenomonenon + phenomenon + phenomonon + phenomenon + phenonmena + phenomena + philisopher + philosopher + philisophical + philosophical + philisophy + philosophy + phillosophically + philosophically + philospher + philosopher + philosphies + philosophies + philosphy + philosophy + phongraph + phonograph + phylosophical + philosophical + physicaly + physically + piblisher + publisher + pich + pitch + pilgrimmage + pilgrimage + pilgrimmages + pilgrimages + pinapple + pineapple + pinnaple + pineapple + pinoneered + pioneered + plagarism + plagiarism + planation + plantation + planed + planned + plantiff + plaintiff + plateu + plateau + plausable + plausible + playright + playwright + playwrite + playwright + playwrites + playwrights + pleasent + pleasant + plebicite + plebiscite + plesant + pleasant + poenis + penis + poeoples + peoples + poety + poetry + poisin + poison + polical + political + polinator + pollinator + polinators + pollinators + politican + politician + politicans + politicians + poltical + political + polute + pollute + poluted + polluted + polutes + pollutes + poluting + polluting + polution + pollution + polyphonyic + polyphonic + polysaccaride + polysaccharide + polysaccharid + polysaccharide + pomegranite + pomegranate + pomotion + promotion + poportional + proportional + popoulation + population + popularaty + popularity + populare + popular + populer + popular + portait + portrait + portayed + portrayed + portraing + portraying + portuguease + portuguese + portugues + Portuguese + posess + possess + posessed + possessed + posesses + possesses + posessing + possessing + posession + possession + posessions + possessions + posion + poison + positon + position + possable + possible + possably + possibly + posseses + possesses + possesing + possessing + possesion + possession + possessess + possesses + possibile + possible + possibilty + possibility + possiblility + possibility + possiblilty + possibility + possiblities + possibilities + possiblity + possibility + possition + position + posthomous + posthumous + postion + position + postive + positive + potatos + potatoes + potrait + portrait + potrayed + portrayed + poulations + populations + poverful + powerful + poweful + powerful + powerfull + powerful + ppublisher + publisher + practial + practical + practially + practically + practicaly + practically + practicioner + practitioner + practicioners + practitioners + practicly + practically + practioner + practitioner + practioners + practitioners + prairy + prairie + prarie + prairie + praries + prairies + pratice + practice + preample + preamble + precedessor + predecessor + preceed + precede + preceeded + preceded + preceeding + preceding + preceeds + precedes + precentage + percentage + precice + precise + precisly + precisely + precurser + precursor + predecesors + predecessors + predicatble + predictable + predicitons + predictions + predomiantly + predominately + prefered + preferred + prefering + preferring + preferrably + preferably + pregancies + pregnancies + preiod + period + preliferation + proliferation + premeire + premiere + premeired + premiered + premillenial + premillennial + preminence + preeminence + premission + permission + preocupation + preoccupation + prepair + prepare + prepartion + preparation + prepatory + preparatory + preperation + preparation + preperations + preparations + preriod + period + presedential + presidential + presense + presence + presidenital + presidential + presidental + presidential + presitgious + prestigious + prespective + perspective + prestigeous + prestigious + prestigous + prestigious + presumabely + presumably + presumibly + presumably + pretection + protection + prevelant + prevalent + preverse + perverse + previvous + previous + pricipal + principal + priciple + principle + priestood + priesthood + primarly + primarily + primative + primitive + primatively + primitively + primatives + primitives + primordal + primordial + priveledges + privileges + privelege + privilege + priveleged + privileged + priveleges + privileges + privelige + privilege + priveliged + privileged + priveliges + privileges + privelleges + privileges + privilage + privilege + priviledge + privilege + priviledges + privileges + privledge + privilege + privte + private + probabilaty + probability + probablistic + probabilistic + probablly + probably + probalibity + probability + probaly + probably + probelm + problem + proccess + process + proccessing + processing + procede + proceed + proceded + proceeded + procedes + proceeds + procedger + procedure + proceding + proceeding + procedings + proceedings + proceedure + procedure + proces + process + processer + processor + proclaimation + proclamation + proclamed + proclaimed + proclaming + proclaiming + proclomation + proclamation + profesion + profession + profesor + professor + professer + professor + proffesed + professed + proffesion + profession + proffesional + professional + proffesor + professor + profilic + prolific + progessed + progressed + programable + programmable + progrom + program + progroms + programs + prohabition + prohibition + prologomena + prolegomena + prominance + prominence + prominant + prominent + prominantly + prominently + prominately + prominently + promiscous + promiscuous + promotted + promoted + pronomial + pronominal + pronouced + pronounced + pronounched + pronounced + pronounciation + pronunciation + proove + prove + prooved + proved + prophacy + prophecy + propietary + proprietary + propmted + prompted + propoganda + propaganda + propogate + propagate + propogates + propagates + propogation + propagation + propostion + proposition + propotions + proportions + propper + proper + propperly + properly + proprietory + proprietary + proseletyzing + proselytizing + protaganist + protagonist + protaganists + protagonists + protocal + protocol + protoganist + protagonist + protrayed + portrayed + protruberance + protuberance + protruberances + protuberances + prouncements + pronouncements + provacative + provocative + provded + provided + provicial + provincial + provinicial + provincial + provisiosn + provision + provisonal + provisional + proximty + proximity + pseudononymous + pseudonymous + pseudonyn + pseudonym + psuedo + pseudo + psycology + psychology + psyhic + psychic + pubilsher + publisher + pubisher + publisher + publiaher + publisher + publically + publicly + publicaly + publicly + publicher + publisher + publihser + publisher + publisehr + publisher + publiser + publisher + publisger + publisher + publisheed + published + publisherr + publisher + publishher + publisher + publishor + publisher + publishre + publisher + publissher + publisher + publlisher + publisher + publsiher + publisher + publusher + publisher + puchasing + purchasing + pulisher + publisher + pumkin + pumpkin + puplisher + publisher + puritannical + puritanical + purposedly + purposely + purpotedly + purportedly + pursuade + persuade + pursuaded + persuaded + pursuades + persuades + pususading + persuading + puting + putting + pwoer + power + pyscic + psychic + qtuie + quiet + quantaty + quantity + quantitiy + quantity + quarantaine + quarantine + questonable + questionable + quicklyu + quickly + quinessential + quintessential + quitted + quit + quizes + quizzes + qutie + quiet + rabinnical + rabbinical + racaus + raucous + radiactive + radioactive + radify + ratify + raelly + really + rarified + rarefied + reaccurring + recurring + reacing + reaching + reacll + recall + readmition + readmission + realitvely + relatively + realsitic + realistic + realtions + relations + realy + really + realyl + really + reasearch + research + rebiulding + rebuilding + rebllions + rebellions + rebounce + rebound + reccomend + recommend + reccomendations + recommendations + reccomended + recommended + reccomending + recommending + reccommend + recommend + reccommended + recommended + reccommending + recommending + reccuring + recurring + receeded + receded + receeding + receding + receivedfrom + received from + recepient + recipient + recepients + recipients + receving + receiving + rechargable + rechargeable + reched + reached + recide + reside + recided + resided + recident + resident + recidents + residents + reciding + residing + reciepents + recipients + reciept + receipt + recieve + receive + recieved + received + reciever + receiver + recievers + receivers + recieves + receives + recieving + receiving + recipiant + recipient + recipiants + recipients + recived + received + recivership + receivership + recogise + recognise + recogize + recognize + recomend + recommend + recomended + recommended + recomending + recommending + recomends + recommends + recommedations + recommendations + reconaissance + reconnaissance + reconcilation + reconciliation + reconized + recognized + reconnaisance + reconnaissance + reconnaissence + reconnaissance + recontructed + reconstructed + recordproducer + record producer + recquired + required + recrational + recreational + recrod + record + recuiting + recruiting + recuring + recurring + recurrance + recurrence + rediculous + ridiculous + reedeming + redeeming + reenforced + reinforced + refect + reflect + refedendum + referendum + referal + referral + referece + reference + refereces + references + refered + referred + referemce + reference + referemces + references + referencs + references + referenece + reference + refereneced + referenced + refereneces + references + referiang + referring + refering + referring + refernce + references + refernces + references + referrence + reference + referrences + references + referrs + refers + reffered + referred + refference + reference + reffering + referring + refrence + reference + refrences + references + refrers + refers + refridgeration + refrigeration + refridgerator + refrigerator + refromist + reformist + refusla + refusal + regardes + regards + regluar + regular + reguarly + regularly + regulaion + regulation + regulaotrs + regulators + regularily + regularly + rehersal + rehearsal + reicarnation + reincarnation + reigining + reigning + reknown + renown + reknowned + renowned + rela + real + relaly + really + relatiopnship + relationship + relativly + relatively + relected + reelected + releive + relieve + releived + relieved + releiver + reliever + releses + releases + relevence + relevance + relevent + relevant + reliablity + reliability + relient + reliant + religeous + religious + religous + religious + religously + religiously + relinqushment + relinquishment + relitavely + relatively + relized + realized + relpacement + replacement + remaing + remaining + remeber + remember + rememberable + memorable + rememberance + remembrance + remembrence + remembrance + remenant + remnant + remenicent + reminiscent + reminent + remnant + reminescent + reminiscent + reminscent + reminiscent + reminsicent + reminiscent + rendevous + rendezvous + rendezous + rendezvous + renedered + rende + renewl + renewal + rennovate + renovate + rennovated + renovated + rennovating + renovating + rennovation + renovation + rentors + renters + reoccurrence + recurrence + reorganision + reorganisation + repatition + repetition + repectively + respectively + repeition + repetition + repentence + repentance + repentent + repentant + repeteadly + repeatedly + repetion + repetition + repid + rapid + reponse + response + reponsible + responsible + reportadly + reportedly + represantative + representative + representive + representative + representives + representatives + reproducable + reproducible + reprtoire + repertoire + repsectively + respectively + reptition + repetition + requirment + requirement + requred + required + resaurant + restaurant + resembelance + resemblance + resembes + resembles + resemblence + resemblance + resevoir + reservoir + residental + residential + resignement + resignment + resistable + resistible + resistence + resistance + resistent + resistant + respectivly + respectively + responce + response + responibilities + responsibilities + responisble + responsible + responnsibilty + responsibility + responsability + responsibility + responsibile + responsible + responsibilites + responsibilities + responsiblities + responsibilities + responsiblity + responsibility + ressemblance + resemblance + ressemble + resemble + ressembled + resembled + ressemblence + resemblance + ressembling + resembling + resssurecting + resurrecting + ressurect + resurrect + ressurected + resurrected + ressurection + resurrection + ressurrection + resurrection + restarant + restaurant + restarants + restaurants + restaraunt + restaurant + restaraunteur + restaurateur + restaraunteurs + restaurateurs + restaraunts + restaurants + restauranteurs + restaurateurs + restauration + restoration + restauraunt + restaurant + resteraunt + restaurant + resteraunts + restaurants + resticted + restricted + restraunt + restraint + resturant + restaurant + resturants + restaurants + resturaunt + restaurant + resturaunts + restaurants + resurecting + resurrecting + retalitated + retaliated + retalitation + retaliation + retreive + retrieve + returnd + returned + revaluated + reevaluated + reveiw + review + reveral + reversal + reversable + reversible + revolutionar + revolutionary + rewitten + rewritten + rewriet + rewrite + rference + reference + rferences + references + rhymme + rhyme + rhythem + rhythm + rhythim + rhythm + rhytmic + rhythmic + rigourous + rigorous + rininging + ringing + rised + rose + rococco + rococo + rocord + record + roomate + roommate + rougly + roughly + rucuperate + recuperate + rudimentatry + rudimentary + rulle + rule + runing + running + runnung + running + russina + Russian + rwite + write + rythem + rhythm + rythim + rhythm + rythm + rhythm + rythmic + rhythmic + rythyms + rhythms + sacrafice + sacrifice + sacreligious + sacrilegious + sacrifical + sacrificial + saftey + safety + safty + safety + salery + salary + sanctionning + sanctioning + sandwhich + sandwich + santioned + sanctioned + sargant + sergeant + sargeant + sergeant + satelite + satellite + satelites + satellites + satisfactority + satisfactorily + satric + satiric + satrical + satirical + satrically + satirically + sattelite + satellite + sattelites + satellites + saught + sought + saveing + saving + saxaphone + saxophone + scaleable + scalable + scandanavia + Scandinavia + scaricity + scarcity + scavanged + scavenged + schedual + schedule + scholarhip + scholarship + scholarstic + scholastic + scientfic + scientific + scientifc + scientific + scientis + scientist + scince + science + scinece + science + scirpt + script + scoll + scroll + screenwrighter + screenwriter + scrutinity + scrutiny + scuptures + sculptures + seach + search + seached + searched + seaches + searches + secratary + secretary + secretery + secretary + sedereal + sidereal + seeked + sought + segementation + segmentation + seguoys + segues + seige + siege + seing + seeing + seinor + senior + seldomly + seldom + senarios + scenarios + senstive + sensitive + sensure + censure + seperate + separate + seperated + separated + seperately + separately + seperates + separates + seperating + separating + seperation + separation + seperatism + separatism + seperatist + separatist + sepina + subpoena + sergent + sergeant + settelement + settlement + settlment + settlement + severeal + several + severley + severely + severly + severely + sevice + service + shadasloo + shadaloo + shaddow + shadow + shadoloo + shadaloo + shamen + shaman + sheat + sheath + sheild + shield + sherif + sheriff + shineing + shining + shiped + shipped + shiping + shipping + shopkeeepers + shopkeepers + shorly + shortly + shortwhile + short while + shoudl + should + shoudln + shouldn't + shouldnt + shouldn't + shreak + shriek + shrinked + shrunk + sicne + since + sideral + sidereal + siezure + seizure + siezures + seizures + siginificant + significant + signficant + significant + signficiant + significant + signfies + signifies + signifantly + significantly + significently + significantly + signifigant + significant + signifigantly + significantly + signitories + signatories + signitory + signatory + similarily + similarly + similiar + similar + similiarity + similarity + similiarly + similarly + simmilar + similar + simpley + simply + simplier + simpler + simultanous + simultaneous + simultanously + simultaneously + sincerley + sincerely + singsog + singsong + sinse + since + skateing + skating + slaugterhouses + slaughterhouses + slighly + slightly + slowy + slowly + smae + same + smealting + smelting + smoe + some + sneeks + sneaks + snese + sneeze + socalism + socialism + socities + societies + soem + some + sofware + software + sohw + show + soilders + soldiers + solatary + solitary + soley + solely + soliders + soldiers + soliliquy + soliloquy + soluable + soluble + somene + someone + somtimes + sometimes + somwhere + somewhere + sophicated + sophisticated + sophmore + sophomore + sorceror + sorcerer + sorrounding + surrounding + sotry + story + sotyr + story + soudn + sound + soudns + sounds + sould + could + sountrack + soundtrack + sourth + south + sourthern + southern + souvenier + souvenir + souveniers + souvenirs + soveits + soviets + sovereignity + sovereignty + soverign + sovereign + soverignity + sovereignty + soverignty + sovereignty + spainish + Spanish + speach + speech + specfic + specific + speciallized + specialized + specifiying + specifying + speciman + specimen + spectauclar + spectacular + spectaulars + spectaculars + spectum + spectrum + speices + species + spendour + splendour + spermatozoan + spermatozoon + spoace + space + sponser + sponsor + sponsered + sponsored + spontanous + spontaneous + sponzored + sponsored + spoonfulls + spoonfuls + sppeches + speeches + spreaded + spread + sprech + speech + spred + spread + spriritual + spiritual + spritual + spiritual + sqaure + square + stablility + stability + stainlees + stainless + staion + station + standars + standards + stange + strange + startegic + strategic + startegies + strategies + startegy + strategy + stateman + statesman + statememts + statements + statment + statement + steriods + steroids + sterotypes + stereotypes + stilus + stylus + stingent + stringent + stiring + stirring + stirrs + stirs + stlye + style + stomache + stomach + stong + strong + stopry + story + storeis + stories + storise + stories + stornegst + strongest + stoyr + story + stpo + stop + stradegies + strategies + stradegy + strategy + strat + start + stratagically + strategically + streemlining + streamlining + stregth + strength + strenghen + strengthen + strenghened + strengthened + strenghening + strengthening + strenght + strength + strenghten + strengthen + strenghtened + strengthened + strenghtening + strengthening + strengtened + strengthened + strenous + strenuous + strictist + strictest + strikely + strikingly + strnad + strand + stroy + story + structual + structural + stubborness + stubbornness + stucture + structure + stuctured + structured + studdy + study + studing + studying + stuggling + struggling + sturcture + structure + subcatagories + subcategories + subcatagory + subcategory + subconsiously + subconsciously + subjudgation + subjugation + submachne + submachine + subpecies + subspecies + subsidary + subsidiary + subsiduary + subsidiary + subsquent + subsequent + subsquently + subsequently + substace + substance + substancial + substantial + substatial + substantial + substituded + substituted + substract + subtract + substracted + subtracted + substracting + subtracting + substraction + subtraction + substracts + subtracts + subtances + substances + subterranian + subterranean + suburburban + suburban + succceeded + succeeded + succcesses + successes + succedded + succeeded + succeded + succeeded + succeds + succeeds + succesful + successful + succesfully + successfully + succesfuly + successfully + succesion + succession + succesive + successive + successfull + successful + successully + successfully + succsess + success + succsessfull + successful + suceed + succeed + suceeded + succeeded + suceeding + succeeding + suceeds + succeeds + sucesful + successful + sucesfully + successfully + sucesfuly + successfully + sucesion + succession + sucess + success + sucesses + successes + sucessful + successful + sucessfull + successful + sucessfully + successfully + sucessfuly + successfully + sucession + succession + sucessive + successive + sucessor + successor + sucessot + successor + sucide + suicide + sucidial + suicidal + sufferage + suffrage + sufferred + suffered + sufferring + suffering + sufficent + sufficient + sufficently + sufficiently + sumary + summary + sunglases + sunglasses + suop + soup + superceeded + superseded + superintendant + superintendent + suphisticated + sophisticated + suplimented + supplemented + supose + suppose + suposed + supposed + suposedly + supposedly + suposes + supposes + suposing + supposing + supplamented + supplemented + suppliementing + supplementing + suppoed + supposed + supposingly + supposedly + suppy + supply + supress + suppress + supressed + suppressed + supresses + suppresses + supressing + suppressing + suprise + surprise + suprised + surprised + suprising + surprising + suprisingly + surprisingly + suprize + surprise + suprized + surprised + suprizing + surprising + suprizingly + surprisingly + surfce + surface + surley + surely + suround + surround + surounded + surrounded + surounding + surrounding + suroundings + surroundings + surounds + surrounds + surplanted + supplanted + surpress + suppress + surpressed + suppressed + surprize + surprise + surprized + surprised + surprizing + surprising + surprizingly + surprisingly + surrended + surrendered + surrepetitious + surreptitious + surrepetitiously + surreptitiously + surreptious + surreptitious + surreptiously + surreptitiously + surronded + surrounded + surrouded + surrounded + surrouding + surrounding + surrundering + surrendering + surveilence + surveillance + surveill + surveil + surveyer + surveyor + surviver + survivor + survivers + survivors + survivied + survived + suseptable + susceptible + suseptible + susceptible + suspention + suspension + swaer + swear + swaers + swears + swepth + swept + swiming + swimming + syas + says + symetrical + symmetrical + symetrically + symmetrically + symetry + symmetry + symettric + symmetric + symmetral + symmetric + symmetricaly + symmetrically + synagouge + synagogue + syncronization + synchronization + synonomous + synonymous + synonymns + synonyms + synphony + symphony + syphyllis + syphilis + sypmtoms + symptoms + syrap + syrup + sysmatically + systematically + sytem + system + sytle + style + tabacco + tobacco + tahn + than + taht + that + talekd + talked + targetted + targeted + targetting + targeting + tast + taste + tath + that + tattooes + tattoos + taxanomic + taxonomic + taxanomy + taxonomy + teached + taught + techician + technician + techicians + technicians + techiniques + techniques + technitian + technician + technnology + technology + technolgy + technology + teh + the + tehy + they + telelevision + television + televsion + television + telphony + telephony + temerature + temperature + tempalte + template + tempaltes + templates + temparate + temperate + temperarily + temporarily + temperment + temperament + tempertaure + temperature + temperture + temperature + temprary + temporary + tenacle + tentacle + tenacles + tentacles + tendacy + tendency + tendancies + tendencies + tendancy + tendency + tennisplayer + tennis player + tepmorarily + temporarily + terrestial + terrestrial + terriories + territories + terriory + territory + territorist + terrorist + territoy + territory + terroist + terrorist + testiclular + testicular + tghe + the + thast + that's + theather + theater + theese + these + theif + thief + theives + thieves + themselfs + themselves + themslves + themselves + ther + there + therafter + thereafter + therby + thereby + theri + their + theyre + they're + thgat + that + thge + the + thier + their + thign + thing + thigns + things + thigsn + things + thikn + think + thikning + thinking + thikns + thinks + thiunk + think + thn + then + thna + than + thne + then + thnig + thing + thnigs + things + thoughout + throughout + threatend + threatened + threatning + threatening + threee + three + threshhold + threshold + thrid + third + throrough + thorough + throughly + thoroughly + throught + throat + througout + throughout + thru + through + thsi + this + thsoe + those + thta + that + thyat + that + tiem + time + tihkn + think + tihs + this + timne + time + tiome + time + tje + the + tjhe + the + tjpanishad + upanishad + tkae + take + tkaes + takes + tkaing + taking + tlaking + talking + tobbaco + tobacco + todays + today's + todya + today + toghether + together + toke + took + tolerence + tolerance + tomatos + tomatoes + tommorow + tomorrow + tommorrow + tomorrow + tongiht + tonight + toriodal + toroidal + tormenters + tormentors + tornadoe + tornado + torpeados + torpedoes + torpedos + torpedoes + tothe + to the + toubles + troubles + tounge + tongue + tourch + torch + towords + towards + towrad + toward + tradionally + traditionally + traditionaly + traditionally + traditionnal + traditional + traditition + tradition + tradtionally + traditionally + trafficed + trafficked + trafficing + trafficking + trafic + traffic + trancendent + transcendent + trancending + transcending + tranform + transform + tranformed + transformed + transcendance + transcendence + transcendant + transcendent + transcendentational + transcendental + transcripting + transcribing + transending + transcending + transesxuals + transsexuals + transfered + transferred + transfering + transferring + transformaton + transformation + transistion + transition + translater + translator + translaters + translators + transmissable + transmissible + transporation + transportation + tremelo + tremolo + tremelos + tremolos + triguered + triggered + triology + trilogy + troling + trolling + troup + troupe + troups + troops + truely + truly + trustworthyness + trustworthiness + turnk + trunk + tust + trust + twelth + twelfth + twon + town + twpo + two + tyhat + that + tyhe + they + typcial + typical + typicaly + typically + tyranies + tyrannies + tyrany + tyranny + tyrranies + tyrannies + tyrrany + tyranny + ubiquitious + ubiquitous + ublisher + publisher + uise + use + ultimely + ultimately + unacompanied + unaccompanied + unahppy + unhappy + unanymous + unanimous + unathorised + unauthorised + unavailible + unavailable + unballance + unbalance + unbeknowst + unbeknownst + unbeleivable + unbelievable + uncertainity + uncertainty + unchallengable + unchallengeable + unchangable + unchangeable + uncompetive + uncompetitive + unconcious + unconscious + unconciousness + unconsciousness + unconfortability + discomfort + uncontitutional + unconstitutional + unconvential + unconventional + undecideable + undecidable + understoon + understood + undesireable + undesirable + undetecable + undetectable + undoubtely + undoubtedly + undreground + underground + uneccesary + unnecessary + unecessary + unnecessary + unequalities + inequalities + unforetunately + unfortunately + unforgetable + unforgettable + unforgiveable + unforgivable + unfortunatley + unfortunately + unfortunatly + unfortunately + unfourtunately + unfortunately + unihabited + uninhabited + unilateraly + unilaterally + unilatreal + unilateral + unilatreally + unilaterally + uninterruped + uninterrupted + uninterupted + uninterrupted + univeral + universal + univeristies + universities + univeristy + university + univerity + university + universtiy + university + univesities + universities + univesity + university + unkown + unknown + unlikey + unlikely + unmanouverable + unmaneuverable + unmistakeably + unmistakably + unneccesarily + unnecessarily + unneccesary + unnecessary + unneccessarily + unnecessarily + unneccessary + unnecessary + unnecesarily + unnecessarily + unnecesary + unnecessary + unoffical + unofficial + unoperational + nonoperational + unoticeable + unnoticeable + unplease + displease + unplesant + unpleasant + unprecendented + unprecedented + unprecidented + unprecedented + unrepentent + unrepentant + unrepetant + unrepentant + unrepetent + unrepentant + unsed + unused + unsubstanciated + unsubstantiated + unsuccesful + unsuccessful + unsuccesfully + unsuccessfully + unsuccessfull + unsuccessful + unsucesful + unsuccessful + unsucesfuly + unsuccessfully + unsucessful + unsuccessful + unsucessfull + unsuccessful + unsucessfully + unsuccessfully + unsuprised + unsurprised + unsuprising + unsurprising + unsuprisingly + unsurprisingly + unsuprized + unsurprised + unsuprizing + unsurprising + unsuprizingly + unsurprisingly + unsurprized + unsurprised + unsurprizing + unsurprising + unsurprizingly + unsurprisingly + untill + until + untranslateable + untranslatable + unuseable + unusable + unusuable + unusable + unviersity + university + unwarrented + unwarranted + unweildly + unwieldy + unwieldly + unwieldy + upcomming + upcoming + upgradded + upgraded + upto + up to + usally + usually + useage + usage + usefull + useful + usefuly + usefully + useing + using + usualy + usually + ususally + usually + vaccum + vacuum + vaccume + vacuum + vacinity + vicinity + vaguaries + vagaries + vaieties + varieties + vailidty + validity + valetta + valletta + valuble + valuable + valueable + valuable + varations + variations + varient + variant + variey + variety + varing + varying + varities + varieties + varity + variety + vasall + vassal + vasalls + vassals + vegatarian + vegetarian + vegitable + vegetable + vegitables + vegetables + vegtable + vegetable + vehicule + vehicle + vell + well + venemous + venomous + vengance + vengeance + vengence + vengeance + verfication + verification + verison + version + verisons + versions + vermillion + vermilion + versitilaty + versatility + versitlity + versatility + vetween + between + veyr + very + vigeur + vigor + vigilence + vigilance + vigourous + vigorous + villian + villain + villification + vilification + villify + vilify + villin + villain + vincinity + vicinity + violentce + violence + virtualy + virtually + virutal + virtual + virutally + virtually + visable + visible + visably + visibly + visting + visiting + vistors + visitors + vitories + victories + volcanoe + volcano + voleyball + volleyball + volontary + voluntary + volonteer + volunteer + volonteered + volunteered + volonteering + volunteering + volonteers + volunteers + volounteer + volunteer + volounteered + volunteered + volounteering + volunteering + volounteers + volunteers + volumne + volume + vreity + variety + vrey + very + vriety + variety + vulnerablility + vulnerability + vyer + very + vyre + very + waht + what + wanna + want to + warantee + warranty + wardobe + wardrobe + warrent + warrant + warrriors + warriors + wasnt + wasn't + wass + was + watn + want + wayword + wayward + weaponary + weaponry + weas + was + wehn + when + weild + wield + weilded + wielded + wendsay + Wednesday + wensday + Wednesday + wereabouts + whereabouts + whant + want + whants + wants + whcih + which + wheras + whereas + wherease + whereas + whereever + wherever + whic + which + whihc + which + whith + with + whlch + which + whn + when + wholey + wholly + wholy + holy + whta + what + whther + whether + wich + which + widesread + widespread + wief + wife + wierd + weird + wiew + view + wih + with + wiht + with + wille + will + willingless + willingness + wirting + writing + withdrawl + withdrawal + witheld + withheld + withh + with + withing + within + withold + withhold + witht + with + witn + with + wiull + will + wnat + want + wnated + wanted + wnats + wants + wohle + whole + wokr + work + wokring + working + wonderfull + wonderful + wont + won't + wordlwide + worldwide + workststion + workstation + worls + world + worstened + worsened + woudl + would + wresters + wrestlers + wriet + write + writen + written + wroet + wrote + wrok + work + wroking + working + wtih + with + wupport + support + xenophoby + xenophobia + yaching + yachting + yaer + year + yaerly + yearly + yaers + years + yatch + yacht + yearm + year + yeasr + years + yeild + yield + yeilding + yielding + yera + year + yeras + years + yersa + years + yotube + YouTube + youre + you're + youseff + yousef + youself + yourself + ytou + you + yuo + you + zeebra + zebra + + + + diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index db797127e..8fd80896c 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -834,6 +834,17 @@ Value 0 + LiruMouselookHidesToolbar + + Comment + Whether or not the toolbar will be hidden in mouselook + Persist + 1 + Type + Boolean + Value + 1 + LiruMouselookMenu Comment @@ -2693,6 +2704,17 @@ This should be as low as possible, but too low may break functionality Value 0 + AutoReplace + + Comment + Replaces keywords with a configured word or phrase + Persist + 1 + Type + Boolean + Value + 0 + AutoAcceptAllNewInventory Comment @@ -7277,6 +7299,17 @@ This should be as low as possible, but too low may break functionality Value 24 + RadarColumnVoiceWidth + + Comment + Width for radar's voice status column + Persist + 1 + Type + S32 + Value + 24 + RadarColumnAgeWidth Comment @@ -7354,6 +7387,17 @@ This should be as low as possible, but too low may break functionality Value 0 + RadarColumnVoiceHidden + + Comment + Hide radar's voice status column + Persist + 1 + Type + Boolean + Value + 0 + RadarColumnAgeHidden Comment @@ -11123,22 +11167,6 @@ This should be as low as possible, but too low may break functionality Value 0 - PermissionsManagerRect - - Comment - Rectangle for permissions manager window - Persist - 1 - Type - Rect - Value - - 0 - 85 - 300 - 0 - - PickerContextOpacity Comment diff --git a/indra/newview/app_settings/settings_ascent.xml b/indra/newview/app_settings/settings_ascent.xml index caab652cf..1e4a735df 100644 --- a/indra/newview/app_settings/settings_ascent.xml +++ b/indra/newview/app_settings/settings_ascent.xml @@ -908,6 +908,17 @@ Value 0 + ToolbarVisibleAutoReplace + + Comment + Whether or not the button for autoreplace is on the toolbar + Persist + 1 + Type + Boolean + Value + 0 + ToolbarVisibleBeacons Comment @@ -1672,7 +1683,7 @@ ToolbarVisibleToolbarPrefs Comment - Whether or not the button for the floater to change buttons on the toolbar is on the toolbar (Nonfunctional, yet. Poke Liru.) + Whether or not the button for the floater to change buttons on the toolbar is on the toolbar Persist 1 Type diff --git a/indra/newview/ascentprefschat.cpp b/indra/newview/ascentprefschat.cpp index 57a5dd60e..660be832d 100644 --- a/indra/newview/ascentprefschat.cpp +++ b/indra/newview/ascentprefschat.cpp @@ -37,6 +37,7 @@ #include "llagent.h" #include "llcolorswatch.h" #include "llcombobox.h" +#include "llfloaterautoreplacesettings.h" #include "llradiogroup.h" #include "lluictrlfactory.h" #include "llviewercontrol.h" @@ -92,6 +93,7 @@ LLPrefsAscentChat::LLPrefsAscentChat() getChild("antispam_checkbox")->setCommitCallback(boost::bind(&LLPrefsAscentChat::onCommitDialogBlock, this, _1, _2)); getChild("Group Invites")->setCommitCallback(boost::bind(&LLPrefsAscentChat::onCommitDialogBlock, this, _1, _2)); + getChild("autoreplace")->setCommitCallback(boost::bind(LLFloaterAutoReplaceSettings::showInstance, LLSD())); getChild("KeywordsOn")->setCommitCallback(boost::bind(&LLPrefsAscentChat::onCommitKeywords, this, _1)); getChild("KeywordsList")->setCommitCallback(boost::bind(&LLPrefsAscentChat::onCommitKeywords, this, _1)); getChild("KeywordsSound")->setCommitCallback(boost::bind(&LLPrefsAscentChat::onCommitKeywords, this, _1)); diff --git a/indra/newview/chatbar_as_cmdline.h b/indra/newview/chatbar_as_cmdline.h index 3e1d37532..3a7de8140 100644 --- a/indra/newview/chatbar_as_cmdline.h +++ b/indra/newview/chatbar_as_cmdline.h @@ -29,8 +29,11 @@ * THE POSSIBILITY OF SUCH DAMAGE. */ -#include "llviewerprecompiledheaders.h" +#ifndef MS_CHATBARCMDLINE_H +#define MS_CHATBARCMDLINE_H #include "llchatbar.h" bool cmd_line_chat(std::string revised_text, EChatType type); + +#endif \ No newline at end of file diff --git a/indra/newview/generichandlers.h b/indra/newview/generichandlers.h index 2a1210b57..456d9aa53 100644 --- a/indra/newview/generichandlers.h +++ b/indra/newview/generichandlers.h @@ -22,6 +22,9 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#ifndef SG_GENERICHANDLERS_H +#define SG_GENERICHANDLERS_H + class GenericHandlers { public: @@ -29,3 +32,5 @@ public: }; extern GenericHandlers *gGenericHandlers; + +#endif // SG_GENERIC_HANDLERS \ No newline at end of file diff --git a/indra/newview/jcfloaterareasearch.h b/indra/newview/jcfloaterareasearch.h index abf2bd592..71cd1c7af 100644 --- a/indra/newview/jcfloaterareasearch.h +++ b/indra/newview/jcfloaterareasearch.h @@ -31,6 +31,9 @@ * Modified, debugged, optimized and improved by Henri Beauchamp Feb 2010. */ +#ifndef JC_FLOATERAREASEARCH_H +#define JC_FLOATERAREASEARCH_H + #include "llfloater.h" #include "lluuid.h" #include "llstring.h" @@ -90,3 +93,5 @@ private: std::string mFilterStrings[LIST_OBJECT_COUNT]; }; + +#endif \ No newline at end of file diff --git a/indra/newview/lggdicdownload.h b/indra/newview/lggdicdownload.h index 75f3053e9..d9edb8deb 100644 --- a/indra/newview/lggdicdownload.h +++ b/indra/newview/lggdicdownload.h @@ -28,6 +28,8 @@ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ +#ifndef LGG_DICDOWNLOAD_H +#define LGG_DICDOWNLOAD_H class LggDicDownload { @@ -35,3 +37,4 @@ class LggDicDownload static void show( BOOL showw , std::vector shortNames, std::vector longNames, void * data); }; +#endif \ No newline at end of file diff --git a/indra/newview/llautoreplace.cpp b/indra/newview/llautoreplace.cpp new file mode 100644 index 000000000..2e8926f45 --- /dev/null +++ b/indra/newview/llautoreplace.cpp @@ -0,0 +1,802 @@ +/** + * @file llautoreplace.cpp + * @brief Auto Replace Manager + * + * $LicenseInfo:firstyear=2012&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, 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; either + * version 2.1 of the License, or (at your option) any later version. + * + * 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 + * $/LicenseInfo$ + */ + +#include "llviewerprecompiledheaders.h" +#include "llautoreplace.h" +#include "llsdserialize.h" +#include "llboost.h" +#include "llcontrol.h" +#include "llviewercontrol.h" +#include "llnotificationsutil.h" + +const char* LLAutoReplace::SETTINGS_FILE_NAME = "autoreplace.xml"; + +void LLAutoReplace::autoreplaceCallback(S32& replacement_start, S32& replacement_length, LLWString& replacement_string, S32& cursor_pos, const LLWString& input_text) +{ + // make sure these returned values are cleared in case there is no replacement + replacement_start = 0; + replacement_length = 0; + replacement_string.clear(); + + static LLCachedControl perform_autoreplace(gSavedSettings, "AutoReplace", 0); + if (perform_autoreplace) + { + S32 word_end = cursor_pos - 1; + + bool at_space = (input_text[word_end] == ' '); + bool have_word = (LLWStringUtil::isPartOfWord(input_text[word_end])); + + if (at_space || have_word) + { + if (at_space && word_end > 0) + { + // find out if this space immediately follows a word + word_end--; + have_word = (LLWStringUtil::isPartOfWord(input_text[word_end])); + } + if (have_word) + { + // word_end points to the end of a word, now find the start of the word + std::string word; + S32 word_start = word_end; + for (S32 back_one = word_start - 1; + back_one >= 0 && LLWStringUtil::isPartOfWord(input_text[back_one]); + back_one-- + ) + { + word_start--; // walk word_start back to the beginning of the word + } + LL_DEBUGS("AutoReplace") << "word_start: " << word_start << " word_end: " << word_end << LL_ENDL; + std::string str_text = std::string(input_text.begin(), input_text.end()); + std::string last_word = str_text.substr(word_start, word_end - word_start + 1); + std::string replacement_word(mSettings.replaceWord(last_word)); + + if (replacement_word != last_word) + { + // The last word is one for which we have a replacement + if (at_space) + { + // return the replacement string + replacement_start = word_start; + replacement_length = last_word.length(); + replacement_string = utf8str_to_wstring(replacement_word); + LLWString old_string = utf8str_to_wstring(last_word); + S32 size_change = replacement_string.size() - old_string.size(); + cursor_pos += size_change; + } + } + } + } + } +} + +std::string LLAutoReplace::getUserSettingsFileName() +{ + std::string path=gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, ""); + + if (!path.empty()) + { + path = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, SETTINGS_FILE_NAME); + } + return path; +} + +std::string LLAutoReplace::getAppSettingsFileName() +{ + std::string path=gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""); + + if (!path.empty()) + { + path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, SETTINGS_FILE_NAME); + } + else + { + LL_ERRS("AutoReplace") << "Failed to get app settings directory name" << LL_ENDL; + } + return path; +} + +LLAutoReplaceSettings LLAutoReplace::getSettings() +{ + return mSettings; +} + +void LLAutoReplace::setSettings(const LLAutoReplaceSettings& newSettings) +{ + mSettings.set(newSettings); + /// Make the newSettings active and write them to user storage + saveToUserSettings(); +} + +LLAutoReplace::LLAutoReplace() +{ +} + +void LLAutoReplace::initSingleton() +{ + loadFromSettings(); +} + +void LLAutoReplace::loadFromSettings() +{ + std::string filename=getUserSettingsFileName(); + if (filename.empty()) + { + LL_INFOS("AutoReplace") << "no valid user settings directory." << LL_ENDL; + } + if(gDirUtilp->fileExists(filename)) + { + LLSD userSettings; + llifstream file; + file.open(filename.c_str()); + if (file.is_open()) + { + LLSDSerialize::fromXML(userSettings, file); + } + file.close(); + if ( mSettings.setFromLLSD(userSettings) ) + { + LL_INFOS("AutoReplace") << "settings loaded from '" << filename << "'" << LL_ENDL; + } + else + { + LL_WARNS("AutoReplace") << "invalid settings found in '" << filename << "'" << LL_ENDL; + } + } + else // no user settings found, try application settings + { + std::string defaultName = getAppSettingsFileName(); + LL_INFOS("AutoReplace") << " user settings file '" << filename << "' not found"<< LL_ENDL; + + bool gotSettings = false; + if(gDirUtilp->fileExists(defaultName)) + { + LLSD appDefault; + llifstream file; + file.open(defaultName.c_str()); + if (file.is_open()) + { + LLSDSerialize::fromXMLDocument(appDefault, file); + } + file.close(); + + if ( mSettings.setFromLLSD(appDefault) ) + { + LL_INFOS("AutoReplace") << "settings loaded from '" << defaultName.c_str() << "'" << LL_ENDL; + gotSettings = true; + } + else + { + LL_WARNS("AutoReplace") << "invalid settings found in '" << defaultName.c_str() << "'" << LL_ENDL; + } + } + + if ( ! gotSettings ) + { + if (mSettings.setFromLLSD(mSettings.getExampleLLSD())) + { + LL_WARNS("AutoReplace") << "no settings found; loaded example." << LL_ENDL; + } + else + { + LL_WARNS("AutoReplace") << "no settings found and example invalid!" << LL_ENDL; + } + } + } +} + +void LLAutoReplace::saveToUserSettings() +{ + std::string filename=getUserSettingsFileName(); + llofstream file; + file.open(filename.c_str()); + LLSDSerialize::toPrettyXML(mSettings.asLLSD(), file); + file.close(); + LL_INFOS("AutoReplace") << "settings saved to '" << filename << "'" << LL_ENDL; +} + +// ================================================================ +// LLAutoReplaceSettings +// ================================================================ + +const std::string LLAutoReplaceSettings::AUTOREPLACE_LIST_NAME = "name"; ///< key for looking up list names +const std::string LLAutoReplaceSettings::AUTOREPLACE_LIST_REPLACEMENTS = "replacements"; ///< key for looking up replacement map + +LLAutoReplaceSettings::LLAutoReplaceSettings() +{ +} + +LLAutoReplaceSettings::LLAutoReplaceSettings(const LLAutoReplaceSettings& settings) +{ + // copy all values through fundamental type intermediates for thread safety + mLists = LLSD::emptyArray(); + + for ( LLSD::array_const_iterator list = settings.mLists.beginArray(), listEnd = settings.mLists.endArray(); + list != listEnd; + list++ + ) + { + if ( (*list).isMap() ) // can fail due to LLSD-30: ignore it + { + LLSD listMap = LLSD::emptyMap(); + std::string listName = (*list)[AUTOREPLACE_LIST_NAME]; + listMap[AUTOREPLACE_LIST_NAME] = listName; + listMap[AUTOREPLACE_LIST_REPLACEMENTS] = LLSD::emptyMap(); + + for ( LLSD::map_const_iterator + entry = (*list)[AUTOREPLACE_LIST_REPLACEMENTS].beginMap(), + entriesEnd = (*list)[AUTOREPLACE_LIST_REPLACEMENTS].endMap(); + entry != entriesEnd; + entry++ + ) + { + std::string keyword = entry->first; + std::string replacement = entry->second.asString(); + listMap[AUTOREPLACE_LIST_REPLACEMENTS].insert(keyword, LLSD(replacement)); + } + + mLists.append(listMap); + } + } +} + +void LLAutoReplaceSettings::set(const LLAutoReplaceSettings& newSettings) +{ + mLists = newSettings.mLists; +} + +bool LLAutoReplaceSettings::setFromLLSD(const LLSD& settingsFromLLSD) +{ + bool settingsValid = true; + + if ( settingsFromLLSD.isArray() ) + { + for ( LLSD::array_const_iterator + list = settingsFromLLSD.beginArray(), + listEnd = settingsFromLLSD.endArray(); + settingsValid && list != listEnd; + list++ + ) + { + if ( (*list).isDefined() ) // can be undef due to LLSD-30: ignore it + { + settingsValid = listIsValid(*list); + } + } + } + else + { + settingsValid = false; + LL_WARNS("AutoReplace") << "settings are not an array" << LL_ENDL; + } + + if ( settingsValid ) + { + mLists = settingsFromLLSD; + } + else + { + LL_WARNS("AutoReplace") << "invalid settings discarded; using hard coded example" << LL_ENDL; + } + + return settingsValid; +} + +bool LLAutoReplaceSettings::listNameMatches( const LLSD& list, const std::string name ) +{ + return list.isMap() + && list.has(AUTOREPLACE_LIST_NAME) + && list[AUTOREPLACE_LIST_NAME].asString() == name; +} + +const LLSD* LLAutoReplaceSettings::getListEntries(std::string listName) +{ + const LLSD* returnedEntries = NULL; + for( LLSD::array_const_iterator list = mLists.beginArray(), endList = mLists.endArray(); + returnedEntries == NULL && list != endList; + list++ + ) + { + const LLSD& thisList = *list; + if ( listNameMatches(thisList, listName) ) + { + returnedEntries = &thisList[AUTOREPLACE_LIST_REPLACEMENTS]; + } + } + return returnedEntries; +} + +std::string LLAutoReplaceSettings::replacementFor(std::string keyword, std::string listName) +{ + std::string replacement; + bool foundList = false; + for( LLSD::array_const_iterator list = mLists.beginArray(), endList = mLists.endArray(); + ! foundList && list != endList; + list++ + ) + { + const LLSD& thisList = *list; + if ( listNameMatches(thisList, listName) ) + { + foundList = true; // whether there is a replacement or not, we're done + if ( thisList.isMap() + && thisList.has(AUTOREPLACE_LIST_REPLACEMENTS) + && thisList[AUTOREPLACE_LIST_REPLACEMENTS].has(keyword) + ) + { + replacement = thisList[AUTOREPLACE_LIST_REPLACEMENTS][keyword].asString(); + LL_DEBUGS("AutoReplace")<<"'"< '"<second.isString() ) + { + listValid = false; + LL_WARNS("AutoReplace") + << "non-string replacement value found in list '" + << list[AUTOREPLACE_LIST_NAME].asString() << "'" + << LL_ENDL; + } + } + } + + return listValid; +} + +const LLSD* LLAutoReplaceSettings::exportList(std::string listName) +{ + const LLSD* exportedList = NULL; + for ( LLSD::array_const_iterator list = mLists.beginArray(), listEnd = mLists.endArray(); + exportedList == NULL && list != listEnd; + list++ + ) + { + if ( listNameMatches(*list, listName) ) + { + const LLSD& namedList = (*list); + exportedList = &namedList; + } + } + return exportedList; +} + +bool LLAutoReplaceSettings::listNameIsUnique(const LLSD& newList) +{ + bool nameIsUnique = true; + // this must always be called with a valid list, so it is safe to assume it has a name + std::string newListName = newList[AUTOREPLACE_LIST_NAME].asString(); + for ( LLSD::array_const_iterator list = mLists.beginArray(), listEnd = mLists.endArray(); + nameIsUnique && list != listEnd; + list++ + ) + { + if ( listNameMatches(*list, newListName) ) + { + LL_WARNS("AutoReplace")<<"duplicate list name '"<= 0) + { + LL_DEBUGS("AutoReplace") << "erase "< autoreplace_enabled(gSavedSettings, "AutoReplace", false); + if ( autoreplace_enabled ) + { + LL_DEBUGS("AutoReplace")<<"checking '"< '" << replacements[currentWord].asString() << "'" + << LL_ENDL; + returnedWord = replacements[currentWord].asString(); + } + } + } + return returnedWord; +} + +bool LLAutoReplaceSettings::addEntryToList(LLWString keyword, LLWString replacement, std::string listName) +{ + bool added = false; + + if ( ! keyword.empty() && ! replacement.empty() ) + { + bool isOneWord = true; + for (size_t character = 0; isOneWord && character < keyword.size(); character++ ) + { + if ( ! LLWStringUtil::isPartOfWord(keyword[character]) ) + { + LL_WARNS("AutoReplace") << "keyword '" << wstring_to_utf8str(keyword) << "' not a single word (len "< replacement test pairs + + /// Get the replacement for the keyword from the specified list + std::string replacementFor(std::string keyword, std::string listName); + + /// Adds a keywword/replacement pair to the named list + bool addEntryToList(LLWString keyword, LLWString replacement, std::string listName); + + /// Removes the keywword and its replacement from the named list + bool removeEntryFromList(std::string keyword, std::string listName); + + /** + * Look for currentWord in the lists in order, returning any substitution found + * If no configured substitution is found, returns currentWord + */ + std::string replaceWord(const std::string currentWord /**< word to search for */ ); + + /// Provides a hard-coded example of settings + LLSD getExampleLLSD(); + + /// Get the actual settings as LLSD + const LLSD& asLLSD(); + ///< @note for use only in AutoReplace::saveToUserSettings + + private: + /// Efficiently and safely compare list names + bool listNameMatches( const LLSD& list, const std::string name ); + + /// The actual llsd data structure + LLSD mLists; + + static const std::string AUTOREPLACE_LIST_NAME; ///< key for looking up list names + static const std::string AUTOREPLACE_LIST_REPLACEMENTS; ///< key for looking up replacement map + + /**< + * LLSD structure of the lists + * - The configuration is an array (mLists), + * - Each entry in the array is a replacement list + * - Each replacement list is a map with three keys: + * @verbatim + * "name" String the name of the list + * "replacements" Map keyword -> replacement pairs + * + * + * + * + * name List 1 + * data + * + * keyword1 replacement1 + * keyword2 replacement2 + * + * + * + * name List 2 + * data + * + * keyword1 replacement1 + * keyword2 replacement2 + * + * + * + * + * @endverbatim + */ +}; + +/** Provides a facility to auto-replace text dynamically as it is entered. + * + * When the end of a word is detected (defined as any punctuation character, + * or any whitespace except newline or return), the preceding word is used + * as a lookup key in an ordered list of maps. If a match is found in any + * map, the replacement start index and length are returned along with the + * new replacement string. + * + * See the autoreplaceCallback method for how to add autoreplace functionality + * to a text entry tool. + */ +class LLAutoReplace : public LLSingleton +{ +public: + /// Callback that provides the hook for use in text entry methods + void autoreplaceCallback(S32& replacement_start, S32& replacement_length, LLWString& replacement_string, S32& cursor_pos, const LLWString& input_text); + + /// Get a copy of the current settings + LLAutoReplaceSettings getSettings(); + + /// Commit new settings after making changes + void setSettings(const LLAutoReplaceSettings& settings); + +private: + friend class LLSingleton; + LLAutoReplace(); + /*virtual*/ void initSingleton(); + + LLAutoReplaceSettings mSettings; ///< configuration information + + /// Read settings from persistent storage + void loadFromSettings(); + + /// Make the newSettings active and write them to user storage + void saveToUserSettings(); + + /// Compute the user settings file name + std::string getUserSettingsFileName(); + + /// Compute the (read-ony) application settings file name + std::string getAppSettingsFileName(); + + /// basename for the settings files + static const char* SETTINGS_FILE_NAME; +}; + +#endif /* LLAUTOREPLACE_H */ diff --git a/indra/newview/llchatbar.cpp b/indra/newview/llchatbar.cpp index 9a31e0d6f..8c38b0597 100644 --- a/indra/newview/llchatbar.cpp +++ b/indra/newview/llchatbar.cpp @@ -44,6 +44,7 @@ #include "llfocusmgr.h" #include "llagent.h" +#include "llautoreplace.h" #include "llbutton.h" #include "llcombobox.h" #include "llcommandhandler.h" // secondlife:///app/chat/ support @@ -149,6 +150,7 @@ BOOL LLChatBar::postBuild() mInputEditor = findChild("Chat Editor"); if (mInputEditor) { + mInputEditor->setAutoreplaceCallback(boost::bind(&LLAutoReplace::autoreplaceCallback, LLAutoReplace::getInstance(), _1, _2, _3, _4, _5)); mInputEditor->setKeystrokeCallback(boost::bind(&LLChatBar::onInputEditorKeystroke,this)); mInputEditor->setFocusLostCallback(boost::bind(&LLChatBar::onInputEditorFocusLost)); mInputEditor->setFocusReceivedCallback(boost::bind(&LLChatBar::onInputEditorGainFocus)); diff --git a/indra/newview/llfloaterabout.cpp b/indra/newview/llfloaterabout.cpp index 27b0ded9e..f02fece9c 100644 --- a/indra/newview/llfloaterabout.cpp +++ b/indra/newview/llfloaterabout.cpp @@ -50,7 +50,6 @@ #include "llviewerstats.h" #include "llviewerregion.h" #include "sgversion.h" -#include "llviewerbuild.h" #include "lluictrlfactory.h" #include "lluri.h" #include "llweb.h" @@ -141,7 +140,7 @@ LLFloaterAbout::LLFloaterAbout() + " (64 bit)" #endif + llformat(" %d.%d.%d (%d) %s %s (%s)\n", - gVersionMajor, gVersionMinor, gVersionPatch, LL_VIEWER_BUILD, + gVersionMajor, gVersionMinor, gVersionPatch, gVersionBuild, __DATE__, __TIME__, gVersionChannel)); support_widget->appendColoredText(version, FALSE, FALSE, gColors.getColor("TextFgReadOnlyColor")); diff --git a/indra/newview/llfloaterautoreplacesettings.cpp b/indra/newview/llfloaterautoreplacesettings.cpp new file mode 100644 index 000000000..eabd8c13e --- /dev/null +++ b/indra/newview/llfloaterautoreplacesettings.cpp @@ -0,0 +1,632 @@ +/** + * @file llfloaterautoreplacesettings.cpp + * @brief Auto Replace List floater + * + * $LicenseInfo:firstyear=2012&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, 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; either + * version 2.1 of the License, or (at your option) any later version. + * + * 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 + * $/LicenseInfo$ + */ + +#include "llviewerprecompiledheaders.h" + +#include "llfloaterautoreplacesettings.h" + +#include "statemachine/aifilepicker.h" +#include "llscrolllistctrl.h" +#include "lluictrlfactory.h" + +#include "llautoreplace.h" +#include "llsdserialize.h" +#include "llsdutil.h" + +#include + +#include "llnotificationsutil.h" + + +LLFloaterAutoReplaceSettings::LLFloaterAutoReplaceSettings(const LLSD& key) + : LLFloater(/*key*/) + , mSelectedListName("") + , mListNames(NULL) + , mReplacementsList(NULL) + , mKeyword(NULL) + , mPreviousKeyword("") + , mReplacement(NULL) +{ + LLUICtrlFactory::getInstance()->buildFloater(this, "floater_autoreplace.xml"); +} + +BOOL LLFloaterAutoReplaceSettings::postBuild(void) +{ + // get copies of the current settings that we will operate on + mEnabled = gSavedSettings.getBOOL("AutoReplace"); + LL_DEBUGS("AutoReplace") << ( mEnabled ? "enabled" : "disabled") << LL_ENDL; + + mSettings = LLAutoReplace::getInstance()->getSettings(); + + // global checkbox for whether or not autoreplace is active + LLUICtrl* enabledCheckbox = getChild("autoreplace_enable"); + enabledCheckbox->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onAutoReplaceToggled, this)); + enabledCheckbox->setValue(LLSD(mEnabled)); + + // top row list creation and deletion + getChild("autoreplace_import_list")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onImportList,this)); + getChild("autoreplace_export_list")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onExportList,this)); + getChild("autoreplace_new_list")->setCommitCallback( boost::bind(&LLFloaterAutoReplaceSettings::onNewList,this)); + getChild("autoreplace_delete_list")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onDeleteList,this)); + + // the list of keyword->replacement lists + mListNames = getChild("autoreplace_list_name"); + mListNames->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onSelectList, this)); + mListNames->setCommitOnSelectionChange(true); + + // list ordering + getChild("autoreplace_list_up")->setCommitCallback( boost::bind(&LLFloaterAutoReplaceSettings::onListUp,this)); + getChild("autoreplace_list_down")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onListDown,this)); + + // keyword->replacement entry add / delete + getChild("autoreplace_add_entry")->setCommitCallback( boost::bind(&LLFloaterAutoReplaceSettings::onAddEntry,this)); + getChild("autoreplace_delete_entry")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onDeleteEntry,this)); + + // entry edits + mKeyword = getChild("autoreplace_keyword"); + mReplacement = getChild("autoreplace_replacement"); + getChild("autoreplace_save_entry")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onSaveEntry, this)); + + // dialog termination ( Save Changes / Cancel ) + getChild("autoreplace_save_changes")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onSaveChanges, this)); + getChild("autoreplace_cancel")->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::close, this, false)); + + // the list of keyword->replacement pairs + mReplacementsList = getChild("autoreplace_list_replacements"); + mReplacementsList->setCommitCallback(boost::bind(&LLFloaterAutoReplaceSettings::onSelectEntry, this)); + mReplacementsList->setCommitOnSelectionChange(true); + + center(); + + mSelectedListName.clear(); + updateListNames(); + updateListNamesControls(); + updateReplacementsList(); + + return true; +} + + +void LLFloaterAutoReplaceSettings::updateListNames() +{ + mListNames->deleteAllItems(); // start from scratch + + LLSD listNames = mSettings.getListNames(); // Array of Strings + + for ( LLSD::array_const_iterator entry = listNames.beginArray(), end = listNames.endArray(); + entry != end; + ++entry + ) + { + const std::string& listName = entry->asString(); + mListNames->addSimpleElement(listName); + } + + if (!mSelectedListName.empty()) + { + mListNames->setSelectedByValue( LLSD(mSelectedListName), true ); + } +} + +void LLFloaterAutoReplaceSettings::updateListNamesControls() +{ + if ( mSelectedListName.empty() ) + { + // There is no selected list + + // Disable all controls that operate on the selected list + getChild("autoreplace_export_list")->setEnabled(false); + getChild("autoreplace_delete_list")->setEnabled(false); + getChild("autoreplace_list_up")->setEnabled(false); + getChild("autoreplace_list_down")->setEnabled(false); + + mReplacementsList->deleteAllItems(); + } + else + { + // Enable the controls that operate on the selected list + getChild("autoreplace_export_list")->setEnabled(true); + getChild("autoreplace_delete_list")->setEnabled(true); + getChild("autoreplace_list_up")->setEnabled(!selectedListIsFirst()); + getChild("autoreplace_list_down")->setEnabled(!selectedListIsLast()); + } +} + +void LLFloaterAutoReplaceSettings::onSelectList() +{ + std::string previousSelectedListName = mSelectedListName; + // only one selection allowed + LLSD selected = mListNames->getSelectedValue(); + if (selected.isDefined()) + { + mSelectedListName = selected.asString(); + LL_DEBUGS("AutoReplace")<<"selected list '"<getSelectedValue(); + if (selectedRow.isDefined()) + { + mPreviousKeyword = selectedRow.asString(); + LL_DEBUGS("AutoReplace")<<"selected entry '"<setValue(selectedRow); + std::string replacement = mSettings.replacementFor(mPreviousKeyword, mSelectedListName ); + mReplacement->setValue(replacement); + enableReplacementEntry(); + mReplacement->setFocus(true); + } + else + { + // no entry selection, so the entry panel should be off + disableReplacementEntry(); + LL_DEBUGS("AutoReplace")<<"no row selected"<deleteAllItems(); + + if ( mSelectedListName.empty() ) + { + mReplacementsList->setEnabled(false); + getChild("autoreplace_add_entry")->setEnabled(false); + disableReplacementEntry(); + } + else + { + // Populate the keyword->replacement list from the selected list + const LLSD* mappings = mSettings.getListEntries(mSelectedListName); + for ( LLSD::map_const_iterator entry = mappings->beginMap(), end = mappings->endMap(); + entry != end; + entry++ + ) + { + LLSD row; + row["id"] = entry->first; + row["columns"][0]["column"] = "Keyword"; + row["columns"][0]["value"] = entry->first; + row["columns"][1]["column"] = "Replacement"; + row["columns"][1]["value"] = entry->second; + + mReplacementsList->addElement(row, ADD_BOTTOM); + } + + mReplacementsList->deselectAllItems(false /* don't call commit */); + mReplacementsList->setEnabled(true); + + getChild("autoreplace_add_entry")->setEnabled(true); + disableReplacementEntry(); + } +} + +void LLFloaterAutoReplaceSettings::enableReplacementEntry() +{ + LL_DEBUGS("AutoReplace")<setEnabled(true); + mReplacement->setEnabled(true); + getChild("autoreplace_save_entry")->setEnabled(true); + getChild("autoreplace_delete_entry")->setEnabled(true); +} + +void LLFloaterAutoReplaceSettings::disableReplacementEntry() +{ + LL_DEBUGS("AutoReplace")<clear(); + mKeyword->setEnabled(false); + mReplacement->clear(); + mReplacement->setEnabled(false); + getChild("autoreplace_save_entry")->setEnabled(false); + getChild("autoreplace_delete_entry")->setEnabled(false); +} + +// called when the global settings checkbox is changed +void LLFloaterAutoReplaceSettings::onAutoReplaceToggled() +{ + // set our local copy of the flag, copied to the global preference in onOk + mEnabled = childGetValue("autoreplace_enable").asBoolean(); + LL_DEBUGS("AutoReplace")<< "autoreplace_enable " << ( mEnabled ? "on" : "off" ) << LL_ENDL; +} + +// called when the List Up button is pressed +void LLFloaterAutoReplaceSettings::onListUp() +{ + S32 selectedRow = mListNames->getFirstSelectedIndex(); + LLSD selectedName = mListNames->getSelectedValue().asString(); + + if ( mSettings.increaseListPriority(selectedName) ) + { + updateListNames(); + updateListNamesControls(); + } + else + { + LL_WARNS("AutoReplace") + << "invalid row ("<getFirstSelectedIndex(); + std::string selectedName = mListNames->getSelectedValue().asString(); + + if ( mSettings.decreaseListPriority(selectedName) ) + { + updateListNames(); + updateListNamesControls(); + } + else + { + LL_WARNS("AutoReplace") + << "invalid row ("<getSelectedValue(); + if (selectedRow.isDefined()) + { + std::string keyword = selectedRow.asString(); + mReplacementsList->deleteSelectedItems(); // delete from the control + mSettings.removeEntryFromList(keyword, mSelectedListName); // delete from the local settings copy + disableReplacementEntry(); // no selection active, so turn off the buttons + } +} + +// called when the Import List button is pressed +void LLFloaterAutoReplaceSettings::onImportList() +{ + AIFilePicker* picker = AIFilePicker::create(); + picker->open(FFLOAD_XML, "", "autoreplace"); + picker->run(boost::bind(&LLFloaterAutoReplaceSettings::onImportList_continued, this, picker)); +} + +void LLFloaterAutoReplaceSettings::onImportList_continued(AIFilePicker* picker) +{ + if (picker->hasFilename()) + { + llifstream file; + file.open(picker->getFilename()); + LLSD newList; + if (file.is_open()) + { + LLSDSerialize::fromXMLDocument(newList, file); + } + file.close(); + + switch ( mSettings.addList(newList) ) + { + case LLAutoReplaceSettings::AddListOk: + mSelectedListName = LLAutoReplaceSettings::getListName(newList); + + updateListNames(); + updateListNamesControls(); + updateReplacementsList(); + break; + + case LLAutoReplaceSettings::AddListDuplicateName: + { + std::string newName = LLAutoReplaceSettings::getListName(newList); + LL_WARNS("AutoReplace")<<"name '"<getSelectedValue().asString(); + if ( ! listName.empty() ) + { + if ( mSettings.removeReplacementList(listName) ) + { + LL_INFOS("AutoReplace")<<"deleted list '"<deleteSelectedItems(); // remove from the scrolling list + mSelectedListName.clear(); + updateListNames(); + updateListNamesControls(); + updateReplacementsList(); + } + else + { + LL_WARNS("AutoReplace")<<"failed to delete list '"<getFirstSelected()->getColumn(0)->getValue().asString(); + std::string listFileName = listName + ".xml"; + AIFilePicker* picker = AIFilePicker::create(); + picker->open(listFileName, FFSAVE_XML, "", "autoreplace"); + picker->run(boost::bind(&LLFloaterAutoReplaceSettings::onExportList_continued, this, picker, mSettings.exportList(listName))); +} +void LLFloaterAutoReplaceSettings::onExportList_continued(AIFilePicker* picker, const LLSD* list) +{ + if (picker->hasFilename()) + { + llofstream file; + file.open(picker->getFilename()); + LLSDSerialize::toPrettyXML(*list, file); + file.close(); + } +} + +void LLFloaterAutoReplaceSettings::onAddEntry() +{ + mPreviousKeyword.clear(); + mReplacementsList->deselectAllItems(false /* don't call commit */); + mKeyword->clear(); + mReplacement->clear(); + enableReplacementEntry(); + mKeyword->setFocus(true); +} + +void LLFloaterAutoReplaceSettings::onSaveEntry() +{ + LL_DEBUGS("AutoReplace")<<"called"<getWText(); + LLWString replacement = mReplacement->getWText(); + if ( mSettings.addEntryToList(keyword, replacement, mSelectedListName) ) + { + // insert the new keyword->replacement pair + LL_INFOS("AutoReplace") + << "list '" << mSelectedListName << "' " + << "added '" << wstring_to_utf8str(keyword) + << "' -> '" << wstring_to_utf8str(replacement) + << "'" << LL_ENDL; + + updateReplacementsList(); + } + else + { + LLNotificationsUtil::add("InvalidAutoReplaceEntry"); + LL_WARNS("AutoReplace")<<"invalid entry " + << "keyword '" << wstring_to_utf8str(keyword) + << "' replacement '" << wstring_to_utf8str(replacement) + << "'" << LL_ENDL; + } +} + +void LLFloaterAutoReplaceSettings::onSaveChanges() +{ + // put our local copy of the settings into the active copy + LLAutoReplace::getInstance()->setSettings( mSettings ); + // save our local copy of the global feature enable/disable value + gSavedSettings.setBOOL("AutoReplace", mEnabled); + close(); +} + +bool LLFloaterAutoReplaceSettings::selectedListIsFirst() +{ + bool isFirst = false; + + if (!mSelectedListName.empty()) + { + LLSD lists = mSettings.getListNames(); // an Array of Strings + LLSD first = lists.get(0); + if ( first.isString() && first.asString() == mSelectedListName ) + { + isFirst = true; + } + } + return isFirst; +} + +bool LLFloaterAutoReplaceSettings::selectedListIsLast() +{ + bool isLast = false; + + if (!mSelectedListName.empty()) + { + LLSD last; + LLSD lists = mSettings.getListNames(); // an Array of Strings + for ( LLSD::array_const_iterator list = lists.beginArray(), listEnd = lists.endArray(); + list != listEnd; + list++ + ) + { + last = *list; + } + if ( last.isString() && last.asString() == mSelectedListName ) + { + isLast = true; + } + } + return isLast; +} + +/* TBD +mOldText = getChild("autoreplace_old_text"); +mNewText = getChild("autoreplace_new_text"); +*/ diff --git a/indra/newview/llfloaterautoreplacesettings.h b/indra/newview/llfloaterautoreplacesettings.h new file mode 100644 index 000000000..c9cc98d9f --- /dev/null +++ b/indra/newview/llfloaterautoreplacesettings.h @@ -0,0 +1,111 @@ +/** + * @file llfloaterautoreplacesettings.h + * @brief Auto Replace List floater + * @copyright Copyright (c) 2011 LordGregGreg Back + * + * $LicenseInfo:firstyear=2012&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, 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; either + * version 2.1 of the License, or (at your option) any later version. + * + * 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 + * $/LicenseInfo$ + */ + +#ifndef LLFLOATERAUTOREPLACESETTINGS_H +#define LLFLOATERAUTOREPLACESETTINGS_H + +#include "llfloater.h" +#include "llautoreplace.h" + +class AIFilePicker; +class LLLineEditor; +class LLScrollListCtrl; + +class LLFloaterAutoReplaceSettings : public LLFloater, public LLFloaterSingleton +{ +public: + LLFloaterAutoReplaceSettings(const LLSD& key = LLSD()); + + /*virtual*/ BOOL postBuild(); + +private: + + /** @{ @name Local Copies of Settings + * These are populated in the postBuild method with the values + * current when the floater is instantiated, and then either + * discarded when Cancel is pressed, or copied back to the active + * settings if Ok is pressed. + */ + bool mEnabled; ///< the global preference for AutoReplace + LLAutoReplaceSettings mSettings; ///< settings being modified + /** @} */ + + /// convenience variable - the name of the currently selected list (if any) + std::string mSelectedListName; + /// the scrolling list of list names (one column, no headings, order manually controlled) + LLScrollListCtrl* mListNames; + /// the scroling list of keyword->replacement pairs + LLScrollListCtrl* mReplacementsList; + + /// the keyword for the entry editing pane + LLLineEditor* mKeyword; + /// saved keyword value + std::string mPreviousKeyword; + /// the replacement for the entry editing pane + LLLineEditor* mReplacement; + + /// callback for when the feature enable/disable checkbox changes + void onAutoReplaceToggled(); + /// callback for when an entry in the list of list names is selected + void onSelectList(); + + void onImportList(); + void onImportList_continued(AIFilePicker* picker); + void onExportList(); + void onExportList_continued(AIFilePicker* picker, const LLSD* list); + void onNewList(); + void onDeleteList(); + + void onListUp(); + void onListDown(); + + void onSelectEntry(); + void onAddEntry(); + void onDeleteEntry(); + void onSaveEntry(); + + void onSaveChanges(); + + /// updates the contents of the mListNames + void updateListNames(); + /// updates the controls associated with mListNames (depends on whether a name is selected or not) + void updateListNamesControls(); + /// updates the contents of the mReplacementsList + void updateReplacementsList(); + /// enables the components that should only be active when a keyword is selected + void enableReplacementEntry(); + /// disables the components that should only be active when a keyword is selected + void disableReplacementEntry(); + + /// called from the AddAutoReplaceList notification dialog + bool callbackNewListName(const LLSD& notification, const LLSD& response); + /// called from the RenameAutoReplaceList notification dialog + bool callbackListNameConflict(const LLSD& notification, const LLSD& response); + + bool selectedListIsFirst(); + bool selectedListIsLast(); +}; + +#endif // LLFLOATERAUTOREPLACESETTINGS_H diff --git a/indra/newview/llfloateravatarlist.cpp b/indra/newview/llfloateravatarlist.cpp index 86d87d049..95902a762 100644 --- a/indra/newview/llfloateravatarlist.cpp +++ b/indra/newview/llfloateravatarlist.cpp @@ -16,52 +16,44 @@ #include "llviewerprecompiledheaders.h" +#include "llfloateravatarlist.h" +#include "llaudioengine.h" #include "llavatarconstants.h" #include "llavatarnamecache.h" -#include "llfloateravatarlist.h" #include "llnotificationsutil.h" #include "llradiogroup.h" #include "llscrolllistcolumn.h" #include "llscrolllistctrl.h" #include "llscrolllistitem.h" -#include "lluictrlfactory.h" -#include "llviewerwindow.h" -#include "llwindow.h" - -#include "llvoavatar.h" -#include "llimview.h" -#include "llfloaterreporter.h" -#include "llagent.h" -#include "llagentcamera.h" -#include "llavataractions.h" -#include "llfloaterregioninfo.h" -#include "llviewerregion.h" -#include "lltracker.h" -#include "llchat.h" -#include "llfloaterchat.h" -#include "llviewermessage.h" -#include "llweb.h" -#include "llviewerobjectlist.h" -#include "llmutelist.h" -#include "llcallbacklist.h" - -#include -#include - -#include -#include -#include -#include - -#include "llworld.h" #include "llsdutil.h" -#include "llaudioengine.h" -#include "llstartup.h" -#include "llviewermenu.h" +#include "lluictrlfactory.h" +#include "llwindow.h" #include "hippogridmanager.h" #include "lfsimfeaturehandler.h" +#include "llagent.h" +#include "llagentcamera.h" +#include "llavataractions.h" +#include "llcallbacklist.h" +#include "llfloaterchat.h" +#include "llfloaterregioninfo.h" +#include "llfloaterreporter.h" +#include "llmutelist.h" +#include "llspeakers.h" +#include "lltracker.h" +#include "llviewermenu.h" +#include "llviewermessage.h" +#include "llviewerobjectlist.h" +#include "llviewerregion.h" +#include "llviewerwindow.h" +#include "llvoavatar.h" +#include "llvoiceclient.h" +#include "llworld.h" + +#include +#include +#include // [RLVa:KB] #include "rlvhandler.h" @@ -76,85 +68,48 @@ extern U32 gFrameCount; namespace { -void chat_avatar_status(std::string name, LLUUID key, ERadarStatType type, bool entering) -{ - if(gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) return; //RLVa:LF Don't announce people are around when blind, that cheats the system. - static LLCachedControl radar_chat_alerts(gSavedSettings, "RadarChatAlerts"); - if (!radar_chat_alerts) return; - static LLCachedControl radar_alert_sim(gSavedSettings, "RadarAlertSim"); - static LLCachedControl radar_alert_draw(gSavedSettings, "RadarAlertDraw"); - static LLCachedControl radar_alert_shout_range(gSavedSettings, "RadarAlertShoutRange"); - static LLCachedControl radar_alert_chat_range(gSavedSettings, "RadarAlertChatRange"); - static LLCachedControl radar_alert_age(gSavedSettings, "RadarAlertAge"); - - LLFloaterAvatarList* self = LLFloaterAvatarList::getInstance(); - LLStringUtil::format_map_t args; - args["[NAME]"] = name; - switch(type) + void chat_avatar_status(const std::string& name, const LLUUID& key, ERadarStatType type, bool entering) { - case STAT_TYPE_SIM: - if (radar_alert_sim) - { - args["[RANGE]"] = self->getString("the_sim"); - } - break; + if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) return; // RLVa:LF Don't announce people are around when blind, that cheats the system. + static LLCachedControl radar_chat_alerts(gSavedSettings, "RadarChatAlerts"); + if (!radar_chat_alerts) return; + static LLCachedControl radar_alert_sim(gSavedSettings, "RadarAlertSim"); + static LLCachedControl radar_alert_draw(gSavedSettings, "RadarAlertDraw"); + static LLCachedControl radar_alert_shout_range(gSavedSettings, "RadarAlertShoutRange"); + static LLCachedControl radar_alert_chat_range(gSavedSettings, "RadarAlertChatRange"); + static LLCachedControl radar_alert_age(gSavedSettings, "RadarAlertAge"); - case STAT_TYPE_DRAW: - if (radar_alert_draw) - { - args["[RANGE]"] = self->getString("draw_distance"); - } - break; - - case STAT_TYPE_SHOUTRANGE: - if (radar_alert_shout_range) - { - args["[RANGE]"] = self->getString("shout_range"); - } - break; - - case STAT_TYPE_CHATRANGE: - if (radar_alert_chat_range) - { - args["[RANGE]"] = self->getString("chat_range"); - } - break; - - case STAT_TYPE_AGE: - if (radar_alert_age) - { - LLChat chat; - chat.mFromName = name; - chat.mText = name + " " + self->getString("has_triggered_your_avatar_age_alert") + "."; - chat.mURL = llformat("secondlife:///app/agent/%s/about",key.asString().c_str()); - chat.mSourceType = CHAT_SOURCE_SYSTEM; - LLFloaterChat::addChat(chat); - } - break; - default: - llassert(type); - break; - } - if (args.find("[RANGE]") != args.end()) - { - args["[ACTION]"] = self->getString(entering ? "has_entered" : "has_left"); + LLFloaterAvatarList* self = LLFloaterAvatarList::getInstance(); + LLStringUtil::format_map_t args; LLChat chat; - chat.mText = self->getString("template", args); + switch(type) + { + case STAT_TYPE_SIM: if (radar_alert_sim) args["[RANGE]"] = self->getString("the_sim"); break; + case STAT_TYPE_DRAW: if (radar_alert_draw) args["[RANGE]"] = self->getString("draw_distance"); break; + case STAT_TYPE_SHOUTRANGE: if (radar_alert_shout_range) args["[RANGE]"] = self->getString("shout_range"); break; + case STAT_TYPE_CHATRANGE: if (radar_alert_chat_range) args["[RANGE]"] = self->getString("chat_range"); break; + case STAT_TYPE_AGE: if (radar_alert_age) chat.mText = name + " " + self->getString("has_triggered_your_avatar_age_alert") + "."; break; + default: llassert(type); break; + } + args["[NAME]"] = name; + args["[ACTION]"] = self->getString(entering ? "has_entered" : "has_left"); + if (args.find("[RANGE]") != args.end()) + chat.mText = self->getString("template", args); + else if (chat.mText.empty()) return; chat.mFromName = name; chat.mURL = llformat("secondlife:///app/agent/%s/about",key.asString().c_str()); chat.mSourceType = CHAT_SOURCE_SYSTEM; LLFloaterChat::addChat(chat); } -} - void send_keys_message(const int transact_num, const int num_ids, const std::string ids) + void send_keys_message(const int transact_num, const int num_ids, const std::string& ids) { gMessageSystem->newMessage("ScriptDialogReply"); gMessageSystem->nextBlock("AgentData"); - gMessageSystem->addUUID("AgentID", gAgent.getID()); - gMessageSystem->addUUID("SessionID", gAgent.getSessionID()); + gMessageSystem->addUUID("AgentID", gAgentID); + gMessageSystem->addUUID("SessionID", gAgentSessionID); gMessageSystem->nextBlock("Data"); - gMessageSystem->addUUID("ObjectID", gAgent.getID()); + gMessageSystem->addUUID("ObjectID", gAgentID); gMessageSystem->addS32("ChatChannel", -777777777); gMessageSystem->addS32("ButtonIndex", 1); gMessageSystem->addString("ButtonLabel", llformat("%d,%d", transact_num, num_ids) + ids); @@ -162,7 +117,7 @@ void chat_avatar_status(std::string name, LLUUID key, ERadarStatType type, bool } } //namespace -LLAvatarListEntry::LLAvatarListEntry(const LLUUID& id, const std::string &name, const LLVector3d &position) : +LLAvatarListEntry::LLAvatarListEntry(const LLUUID& id, const std::string& name, const LLVector3d& position) : mID(id), mName(name), mPosition(position), mMarked(false), mFocused(false), mUpdateTimer(), mFrame(gFrameCount), mStats(), mActivityType(ACTIVITY_NEW), mActivityTimer(), @@ -180,7 +135,7 @@ LLAvatarListEntry::~LLAvatarListEntry() // virtual void LLAvatarListEntry::processProperties(void* data, EAvatarProcessorType type) { - if(type == APT_PROPERTIES) + if (type == APT_PROPERTIES) { LLAvatarPropertiesProcessor::getInstance()->removeObserver(mID, this); const LLAvatarData* pAvatarData = static_cast(data); @@ -213,36 +168,20 @@ void LLAvatarListEntry::processProperties(void* data, EAvatarProcessorType type) } } -void LLAvatarListEntry::setPosition(LLVector3d position, bool this_sim, bool drawn, bool chatrange, bool shoutrange) +void LLAvatarListEntry::setPosition(const LLVector3d& position, bool this_sim, bool drawn, bool chatrange, bool shoutrange) { mPosition = position; - mFrame = gFrameCount; - - if (this_sim != mStats[STAT_TYPE_SIM]) - { - chat_avatar_status(mName, mID, STAT_TYPE_SIM, mStats[STAT_TYPE_SIM] = this_sim); - } - if (drawn != mStats[STAT_TYPE_DRAW]) - { - chat_avatar_status(mName, mID, STAT_TYPE_DRAW, mStats[STAT_TYPE_DRAW] = drawn); - } - if (shoutrange != mStats[STAT_TYPE_SHOUTRANGE]) - { - chat_avatar_status(mName, mID, STAT_TYPE_SHOUTRANGE, mStats[STAT_TYPE_SHOUTRANGE] = shoutrange); - } - if (chatrange != mStats[STAT_TYPE_CHATRANGE]) - { - chat_avatar_status(mName, mID, STAT_TYPE_CHATRANGE, mStats[STAT_TYPE_CHATRANGE] = chatrange); - } - + if (this_sim != mStats[STAT_TYPE_SIM]) chat_avatar_status(mName, mID, STAT_TYPE_SIM, mStats[STAT_TYPE_SIM] = this_sim); + if (drawn != mStats[STAT_TYPE_DRAW]) chat_avatar_status(mName, mID, STAT_TYPE_DRAW, mStats[STAT_TYPE_DRAW] = drawn); + if (shoutrange != mStats[STAT_TYPE_SHOUTRANGE]) chat_avatar_status(mName, mID, STAT_TYPE_SHOUTRANGE, mStats[STAT_TYPE_SHOUTRANGE] = shoutrange); + if (chatrange != mStats[STAT_TYPE_CHATRANGE]) chat_avatar_status(mName, mID, STAT_TYPE_CHATRANGE, mStats[STAT_TYPE_CHATRANGE] = chatrange); mUpdateTimer.start(); } -bool LLAvatarListEntry::getAlive() +bool LLAvatarListEntry::getAlive() const { - U32 current = gFrameCount; - return ((current - mFrame) <= 2); + return ((gFrameCount - mFrame) <= 2); } F32 LLAvatarListEntry::getEntryAgeSeconds() const @@ -266,11 +205,11 @@ void LLAvatarListEntry::setActivity(ACTIVITY_TYPE activity) const LLAvatarListEntry::ACTIVITY_TYPE LLAvatarListEntry::getActivity() { - if ( mActivityTimer.getElapsedTimeF32() > ACTIVITY_TIMEOUT ) + if (mActivityTimer.getElapsedTimeF32() > ACTIVITY_TIMEOUT) { mActivityType = ACTIVITY_NONE; } - if(isDead())return ACTIVITY_DEAD; + if (isDead()) return ACTIVITY_DEAD; return mActivityType; } @@ -328,15 +267,15 @@ void LLFloaterAvatarList::draw() void LLFloaterAvatarList::onOpen() { - gSavedSettings.setBOOL("ShowRadar", TRUE); + gSavedSettings.setBOOL("ShowRadar", true); } void LLFloaterAvatarList::onClose(bool app_quitting) { - setVisible(FALSE); + setVisible(false); if (!app_quitting) { - gSavedSettings.setBOOL("ShowRadar", FALSE); + gSavedSettings.setBOOL("ShowRadar", false); } if (!gSavedSettings.getBOOL("RadarKeepOpen") || app_quitting) { @@ -438,10 +377,10 @@ BOOL LLFloaterAvatarList::postBuild() childSetAction("track_btn", boost::bind(&LLFloaterAvatarList::onClickTrack, this)); childSetAction("mark_btn", boost::bind(&LLFloaterAvatarList::doCommand, this, &cmd_toggle_mark, false)); childSetAction("focus_btn", boost::bind(&LLFloaterAvatarList::onClickFocus, this)); - childSetAction("prev_in_list_btn", boost::bind(&LLFloaterAvatarList::focusOnPrev, this, FALSE)); - childSetAction("next_in_list_btn", boost::bind(&LLFloaterAvatarList::focusOnNext, this, FALSE)); - childSetAction("prev_marked_btn", boost::bind(&LLFloaterAvatarList::focusOnPrev, this, TRUE)); - childSetAction("next_marked_btn", boost::bind(&LLFloaterAvatarList::focusOnNext, this, TRUE)); + childSetAction("prev_in_list_btn", boost::bind(&LLFloaterAvatarList::focusOnPrev, this, false)); + childSetAction("next_in_list_btn", boost::bind(&LLFloaterAvatarList::focusOnNext, this, false)); + childSetAction("prev_marked_btn", boost::bind(&LLFloaterAvatarList::focusOnPrev, this, true)); + childSetAction("next_marked_btn", boost::bind(&LLFloaterAvatarList::focusOnNext, this, true)); childSetAction("get_key_btn", boost::bind(&LLFloaterAvatarList::onClickGetKey, this)); @@ -462,13 +401,14 @@ BOOL LLFloaterAvatarList::postBuild() gSavedSettings.getControl("RadarColumnPositionHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); gSavedSettings.getControl("RadarColumnAltitudeHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); gSavedSettings.getControl("RadarColumnActivityHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); + gSavedSettings.getControl("RadarColumnVoiceHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); gSavedSettings.getControl("RadarColumnAgeHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); gSavedSettings.getControl("RadarColumnTimeHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); // Get a pointer to the scroll list from the interface mAvatarList = getChild("avatar_list"); - mAvatarList->sortByColumn("distance", TRUE); - mAvatarList->setCommitOnSelectionChange(TRUE); + mAvatarList->sortByColumn("distance", true); + mAvatarList->setCommitOnSelectionChange(true); mAvatarList->setCommitCallback(boost::bind(&LLFloaterAvatarList::onSelectName,this)); mAvatarList->setDoubleClickCallback(boost::bind(&LLFloaterAvatarList::onClickFocus,this)); mAvatarList->setSortChangedCallback(boost::bind(&LLFloaterAvatarList::onAvatarSortingChanged,this)); @@ -483,7 +423,7 @@ BOOL LLFloaterAvatarList::postBuild() else gSavedSettings.getControl("RadarColumnClientHidden")->getSignal()->connect(boost::bind(&LLFloaterAvatarList::assessColumns, this)); - return TRUE; + return true; } void col_helper(const bool hide, LLCachedControl &setting, LLScrollListColumn* col) @@ -518,6 +458,7 @@ void LLFloaterAvatarList::assessColumns() BIND_COLUMN_TO_SETTINGS(LIST_POSITION,Position); BIND_COLUMN_TO_SETTINGS(LIST_ALTITUDE,Altitude); BIND_COLUMN_TO_SETTINGS(LIST_ACTIVITY,Activity); + BIND_COLUMN_TO_SETTINGS(LIST_VOICE,Voice); BIND_COLUMN_TO_SETTINGS(LIST_AGE,Age); BIND_COLUMN_TO_SETTINGS(LIST_TIME,Time); @@ -578,11 +519,6 @@ void LLFloaterAvatarList::updateAvatarList() refreshTracker(); return; } - //moved to pipeline to prevent a crash - //gPipeline.forAllVisibleDrawables(updateParticleActivity); - - - //todo: make this less of a hacked up copypasta from dales 1.18. { std::vector avatar_ids; @@ -593,42 +529,31 @@ void LLFloaterAvatarList::updateAvatarList() static const LLCachedControl radar_range_radius("RadarRangeRadius", 0); LLWorld::instance().getAvatars(&avatar_ids, &positions, mypos, radar_range_radius ? radar_range_radius : F32_MAX); - size_t i; - size_t count = avatar_ids.size(); - static LLCachedControl announce(gSavedSettings, "RadarChatKeys"); std::queue announce_keys; - for (i = 0; i < count; ++i) + for (size_t i = 0, count = avatar_ids.size(); i < count; ++i) { - const LLUUID &avid = avatar_ids[i]; - - static const LLCachedControl namesystem("RadarNameSystem"); + const LLUUID& avid = avatar_ids[i]; std::string name; - if (!LLAvatarNameCache::getPNSName(avid, name, namesystem)) - continue; //prevent (Loading...) - - LLAvatarListEntry* entry = getAvatarEntry(avid); + static const LLCachedControl namesystem("RadarNameSystem"); + if (!LLAvatarNameCache::getPNSName(avid, name, namesystem)) continue; //prevent (Loading...) LLVector3d position = positions[i]; LLVOAvatar* avatarp = gObjectList.findAvatar(avid); - if (avatarp) - { - // Get avatar data - position = gAgent.getPosGlobalFromAgent(avatarp->getCharacterPosition()); - } + if (avatarp) position = gAgent.getPosGlobalFromAgent(avatarp->getCharacterPosition()); + LLAvatarListEntry* entry = getAvatarEntry(avid); if (!entry) { // Avatar not there yet, add it - if(announce && gAgent.getRegion()->pointInRegionGlobal(position)) - announce_keys.push(avid); + if (announce && gAgent.getRegion()->pointInRegionGlobal(position)) announce_keys.push(avid); mAvatars.push_back(LLAvatarListEntryPtr(entry = new LLAvatarListEntry(avid, name, position))); } // Announce position - F32 dist = (F32)(position - mypos).magVec(); + F32 dist((position - mypos).magVec()); entry->setPosition(position, gAgent.getRegion()->pointInRegionGlobal(position), avatarp, dist < LFSimFeatureHandler::getInstance()->sayRange(), dist < LFSimFeatureHandler::getInstance()->shoutRange()); // Mark as typing if they are typing @@ -637,43 +562,30 @@ void LLFloaterAvatarList::updateAvatarList() // Set activity for anyone making sounds if (gAudiop) - { - for (LLAudioEngine::source_map::iterator iter = gAudiop->mAllSources.begin(); iter != gAudiop->mAllSources.end(); ++iter) - { - LLAudioSource* sourcep = iter->second; - if (LLAvatarListEntry* entry = getAvatarEntry(sourcep->getOwnerID())) - { + for (LLAudioEngine::source_map::iterator i = gAudiop->mAllSources.begin(); i != gAudiop->mAllSources.end(); ++i) + if (LLAvatarListEntry* entry = getAvatarEntry((i->second)->getOwnerID())) entry->setActivity(LLAvatarListEntry::ACTIVITY_SOUND); - } - } - } //let us send the keys in a more timely fashion if (announce && !announce_keys.empty()) { // NOTE: This fragment is repeated in sendKey std::ostringstream ids; - int transact_num = (int)gFrameCount; - int num_ids = 0; + U32 transact_num = gFrameCount; + U32 num_ids = 0; while(!announce_keys.empty()) { - LLUUID id = announce_keys.front(); - announce_keys.pop(); - - ids << "," << id.asString(); + ids << "," << announce_keys.front().asString(); ++num_ids; - if (ids.tellp() > 200) { send_keys_message(transact_num, num_ids, ids.str()); - - num_ids = 0; - ids.seekp(0); + ids.seekp(num_ids = 0); ids.str(""); } + announce_keys.pop(); } - if (num_ids > 0) - send_keys_message(transact_num, num_ids, ids.str()); + if (num_ids) send_keys_message(transact_num, num_ids, ids.str()); } } @@ -702,7 +614,7 @@ void LLFloaterAvatarList::expireAvatarList() for(av_list_t::iterator it = mAvatars.begin(); it != mAvatars.end();) { LLAvatarListEntry* entry = it->get(); - if(!entry->isDead()) + if (!entry->isDead()) { entry->getAlive(); ++it; @@ -717,22 +629,19 @@ void LLFloaterAvatarList::expireAvatarList() void LLFloaterAvatarList::updateAvatarSorting() { - if(mDirtyAvatarSorting) + if (mDirtyAvatarSorting) { mDirtyAvatarSorting = false; - if(mAvatars.size() <= 1) //Nothing to sort. - return; + if (mAvatars.size() <= 1) return; // Nothing to sort. + const std::vector list = mAvatarList->getAllData(); av_list_t::iterator insert_it = mAvatars.begin(); - for(std::vector::const_iterator it=list.begin();it!=list.end();++it) + for(std::vector::const_iterator it = list.begin(); it != list.end(); ++it) { av_list_t::iterator av_it = std::find_if(mAvatars.begin(),mAvatars.end(),LLAvatarListEntry::uuidMatch((*it)->getUUID())); - if(av_it!=mAvatars.end()) - { - std::iter_swap(insert_it++,av_it); - if(insert_it+1 == mAvatars.end()) //We've ran out of elements to sort - return; - } + if (av_it == mAvatars.end()) continue; + std::iter_swap(insert_it++, av_it); + if (insert_it+1 == mAvatars.end()) return; // We've run out of elements to sort } } } @@ -760,38 +669,21 @@ void LLFloaterAvatarList::refreshAvatarList() posagent.setVec(gAgent.getPositionAgent()); LLVector3d simpos = mypos - posagent; const S32 width(gAgent.getRegion() ? gAgent.getRegion()->getWidth() : 256); + LLSpeakerMgr& speakermgr = LLActiveSpeakerMgr::instance(); + LLRect screen_rect; + localRectToScreen(getLocalRect(), &screen_rect); + speakermgr.update(!(screen_rect.pointInRect(gViewerWindow->getCurrentMouseX(), gViewerWindow->getCurrentMouseY()) && gMouseIdleTimer.getElapsedTimeF32() < 5.f)); BOOST_FOREACH(av_list_t::value_type& entry, mAvatars) { - LLScrollListItem::Params element; - LLUUID av_id; - std::string av_name; - // Skip if avatar hasn't been around - if (entry->isDead()) - { - continue; - } - - entry->setInList(); - - av_id = entry->getID(); - av_name = entry->getName().c_str(); + if (entry->isDead()) continue; LLVector3d position = entry->getPosition(); - BOOL UnknownAltitude = false; - LLVector3d delta = position - mypos; - F32 distance = (F32)delta.magVec(); - F32 unknownAlt = (gHippoGridManager->getConnectedGrid()->isSecondLife()) ? 1020.f : 0.f; - if (position.mdV[VZ] == unknownAlt) - { - UnknownAltitude = true; - distance = 9000.0; - } + bool UnknownAltitude = position.mdV[VZ] == (gHippoGridManager->getConnectedGrid()->isSecondLife() ? 1020.f : 0.f); + F32 distance = UnknownAltitude ? 9000.0f : (F32)delta.magVec(); delta.mdV[2] = 0.0f; - F32 side_distance = (F32)delta.magVec(); - // HACK: Workaround for an apparent bug: // sometimes avatar entries get stuck, and are registered // by the client as perpetually moving in the same direction. @@ -799,11 +691,11 @@ void LLFloaterAvatarList::refreshAvatarList() //jcool410 -- this fucks up seeing dueds thru minimap data > 1024m away, so, lets just say > 2048m to the side is bad //aka 8 sims - if (side_distance > 2048.0f) - { - continue; - } + if (delta.magVec() > 2048.0) continue; + entry->setInList(); + const LLUUID& av_id = entry->getID(); + LLScrollListItem::Params element; element.value = av_id; LLScrollListCell::Params mark; @@ -819,7 +711,7 @@ void LLFloaterAvatarList::refreshAvatarList() LLScrollListCell::Params name; name.column = "avatar_name"; name.type = "text"; - name.value = av_name; + name.value = entry->getName(); if (entry->isFocused()) { name.font_style = "BOLD"; @@ -830,51 +722,48 @@ void LLFloaterAvatarList::refreshAvatarList() //name.color = gColors.getColor( "MapAvatar" ); LLViewerRegion* parent_estate = LLWorld::getInstance()->getRegionFromPosGlobal(entry->getPosition()); LLUUID estate_owner = LLUUID::null; - if(parent_estate && parent_estate->isAlive()) + if (parent_estate && parent_estate->isAlive()) { estate_owner = parent_estate->getOwner(); } - static const LLCachedControl unselected_color(gColors, "ScrollUnselectedColor",LLColor4(0.f, 0.f, 0.f, 0.8f)); + static const LLCachedControl unselected_color(gColors, "ScrollUnselectedColor", LLColor4(0.f, 0.f, 0.f, 0.8f)); static LLCachedControl sDefaultListText(gColors, "DefaultListText"); static LLCachedControl sRadarTextChatRange(gColors, "RadarTextChatRange"); static LLCachedControl sRadarTextShoutRange(gColors, "RadarTextShoutRange"); static LLCachedControl sRadarTextDrawDist(gColors, "RadarTextDrawDist"); static LLCachedControl sRadarTextYoung(gColors, "RadarTextYoung"); - LLColor4 name_color = sDefaultListText; + static const LLCachedControl ascent_muted_color("AscentMutedColor", LLColor4(0.7f,0.7f,0.7f,1.f)); + LLColor4 color = sDefaultListText; //Lindens are always more Linden than your friend, make that take precedence - if(LLMuteList::getInstance()->isLinden(av_id)) + if (LLMuteList::getInstance()->isLinden(av_id)) { - static const LLCachedControl ascent_linden_color("AscentLindenColor",LLColor4(0.f,0.f,1.f,1.f)); - name_color = ascent_linden_color; + static const LLCachedControl ascent_linden_color("AscentLindenColor", LLColor4(0.f,0.f,1.f,1.f)); + color = ascent_linden_color; } //check if they are an estate owner at their current position - else if(estate_owner.notNull() && av_id == estate_owner) + else if (estate_owner.notNull() && av_id == estate_owner) { - static const LLCachedControl ascent_estate_owner_color("AscentEstateOwnerColor",LLColor4(1.f,0.6f,1.f,1.f)); - name_color = ascent_estate_owner_color; + static const LLCachedControl ascent_estate_owner_color("AscentEstateOwnerColor", LLColor4(1.f,0.6f,1.f,1.f)); + color = ascent_estate_owner_color; } //without these dots, SL would suck. - else if(LLAvatarActions::isFriend(av_id)) + else if (LLAvatarActions::isFriend(av_id)) { - static const LLCachedControl ascent_friend_color("AscentFriendColor",LLColor4(1.f,1.f,0.f,1.f)); - name_color = ascent_friend_color; + static const LLCachedControl ascent_friend_color("AscentFriendColor", LLColor4(1.f,1.f,0.f,1.f)); + color = ascent_friend_color; } //big fat jerkface who is probably a jerk, display them as such. - else if(LLMuteList::getInstance()->isMuted(av_id)) + else if (LLMuteList::getInstance()->isMuted(av_id)) { - static const LLCachedControl ascent_muted_color("AscentMutedColor",LLColor4(0.7f,0.7f,0.7f,1.f)); - name_color = ascent_muted_color; + color = ascent_muted_color; } - - name_color = name_color*0.5f + unselected_color*0.5f; - - name.color = name_color; + name.color = color*0.5f + unselected_color*0.5f; char temp[32]; - LLColor4 color = sDefaultListText; + color = sDefaultListText; LLScrollListCell::Params dist; dist.column = "distance"; dist.type = "text"; @@ -891,32 +780,23 @@ void LLFloaterAvatarList::refreshAvatarList() if (distance <= LFSimFeatureHandler::getInstance()->shoutRange()) { snprintf(temp, sizeof(temp), "%.1f", distance); - if (distance > LFSimFeatureHandler::getInstance()->sayRange()) - { - color = sRadarTextShoutRange; - } - else - { - color = sRadarTextChatRange; - } + color = (distance > LFSimFeatureHandler::getInstance()->sayRange()) ? sRadarTextShoutRange : sRadarTextChatRange; } else { - if (entry->mStats[STAT_TYPE_DRAW]) - { - color = sRadarTextDrawDist; - } + if (entry->mStats[STAT_TYPE_DRAW]) color = sRadarTextDrawDist; snprintf(temp, sizeof(temp), "%d", (S32)distance); } } dist.value = temp; - dist.color = color; + dist.color = color * 0.7f + unselected_color * 0.3f; // Liru: Blend testing! + //dist.color = color; LLScrollListCell::Params pos; - position = position - simpos; + position -= simpos; - S32 x = (S32)position.mdV[VX]; - S32 y = (S32)position.mdV[VY]; + S32 x(position.mdV[VX]); + S32 y(position.mdV[VY]); if (x >= 0 && x <= width && y >= 0 && y <= width) { snprintf(temp, sizeof(temp), "%d, %d", x, y); @@ -959,62 +839,79 @@ void LLFloaterAvatarList::refreshAvatarList() alt.value = temp; LLScrollListCell::Params act; - act.column = "activity"; - act.type = "icon"; - - std::string activity_icon = ""; - std::string activity_tip = ""; - switch(entry->getActivity()) + static const LLCachedControl hide_act("RadarColumnActivityHidden"); + if (!hide_act) { - case LLAvatarListEntry::ACTIVITY_MOVING: + act.column = "activity"; + act.type = "icon"; + switch(entry->getActivity()) { - activity_icon = "inv_item_animation.tga"; - activity_tip = getString("Moving"); + case LLAvatarListEntry::ACTIVITY_MOVING: + act.value = "inv_item_animation.tga"; + act.tool_tip = getString("Moving"); + break; + case LLAvatarListEntry::ACTIVITY_GESTURING: + act.value = "inv_item_gesture.tga"; + act.tool_tip = getString("Playing a gesture"); + break; + case LLAvatarListEntry::ACTIVITY_SOUND: + act.value = "inv_item_sound.tga"; + act.tool_tip = getString("Playing a sound"); + break; + case LLAvatarListEntry::ACTIVITY_REZZING: + act.value = "ff_edit_theirs.tga"; + act.tool_tip = getString("Rezzing objects"); + break; + case LLAvatarListEntry::ACTIVITY_PARTICLES: + act.value = "particles_scan.tga"; + act.tool_tip = getString("Creating particles"); + break; + case LLAvatarListEntry::ACTIVITY_NEW: + act.value = "avatar_new.tga"; + act.tool_tip = getString("Just arrived"); + break; + case LLAvatarListEntry::ACTIVITY_TYPING: + act.value = "avatar_typing.tga"; + act.tool_tip = getString("Typing"); + break; + default: + break; } - break; - case LLAvatarListEntry::ACTIVITY_GESTURING: - { - activity_icon = "inv_item_gesture.tga"; - activity_tip = getString("Playing a gesture"); - } - break; - case LLAvatarListEntry::ACTIVITY_SOUND: - { - activity_icon = "inv_item_sound.tga"; - activity_tip = getString("Playing a sound"); - } - break; - case LLAvatarListEntry::ACTIVITY_REZZING: - { - activity_icon = "ff_edit_theirs.tga"; - activity_tip = getString("Rezzing objects"); - } - break; - case LLAvatarListEntry::ACTIVITY_PARTICLES: - { - activity_icon = "particles_scan.tga"; - activity_tip = getString("Creating particles"); - } - break; - case LLAvatarListEntry::ACTIVITY_NEW: - { - activity_icon = "avatar_new.tga"; - activity_tip = getString("Just arrived"); - } - break; - case LLAvatarListEntry::ACTIVITY_TYPING: - { - activity_icon = "avatar_typing.tga"; - activity_tip = getString("Typing"); - } - break; - default: - break; } - act.value = activity_icon;//icon_image_id; //"icn_active-speakers-dot-lvl0.tga"; - //act.color = icon_color; - act.tool_tip = activity_tip; + LLScrollListCell::Params voice; + static const LLCachedControl hide_voice("RadarColumnVoiceHidden"); + if (!hide_voice) + { + voice.column("voice"); + voice.type("icon"); + // transplant from llparticipantlist.cpp, update accordingly. + if (LLPointer speakerp = speakermgr.findSpeaker(av_id)) + { + if (speakerp->mStatus == LLSpeaker::STATUS_MUTED) + { + voice.value("mute_icon.tga"); + voice.color(speakerp->mModeratorMutedVoice ? ascent_muted_color : LLColor4(1.f, 71.f / 255.f, 71.f / 255.f, 1.f)); + } + else + { + switch(llmin(2, llfloor((speakerp->mSpeechVolume / LLVoiceClient::OVERDRIVEN_POWER_LEVEL) * 3.f))) + { + case 0: + voice.value("icn_active-speakers-dot-lvl0.tga"); + break; + case 1: + voice.value("icn_active-speakers-dot-lvl1.tga"); + break; + case 2: + voice.value("icn_active-speakers-dot-lvl2.tga"); + break; + } + // non voice speakers have hidden icons, render as transparent + voice.color(speakerp->mStatus > LLSpeaker::STATUS_VOICE_ACTIVE ? LLColor4::transparent : speakerp->mDotColor); + } + } + } LLScrollListCell::Params agep; agep.column = "age"; @@ -1049,17 +946,16 @@ void LLFloaterAvatarList::refreshAvatarList() viewer.type = "text"; static const LLCachedControl avatar_name_color(gColors, "AvatarNameColor",LLColor4(0.98f, 0.69f, 0.36f, 1.f)); - LLColor4 client_color(avatar_name_color); - LLVOAvatar* avatarp = gObjectList.findAvatar(av_id); - if(avatarp) + color = avatar_name_color; + if (LLVOAvatar* avatarp = gObjectList.findAvatar(av_id)) { std::string client = SHClientTagMgr::instance().getClientName(avatarp, false); - SHClientTagMgr::instance().getClientColor(avatarp, false, client_color); - if(client == "") + if (client.empty()) { - client_color = unselected_color; + color = unselected_color; client = "?"; } + else SHClientTagMgr::instance().getClientColor(avatarp, false, color); viewer.value = client.c_str(); } else @@ -1067,9 +963,7 @@ void LLFloaterAvatarList::refreshAvatarList() viewer.value = getString("Out Of Range"); } //Blend to make the color show up better - client_color = client_color *.5f + unselected_color * .5f; - - viewer.color = client_color; + viewer.color = color *.5f + unselected_color * .5f; // Add individual column cell params to the item param element.columns.add(mark); @@ -1077,7 +971,8 @@ void LLFloaterAvatarList::refreshAvatarList() element.columns.add(dist); element.columns.add(pos); element.columns.add(alt); - element.columns.add(act); + if (!hide_act) element.columns.add(act); + if (!hide_voice) element.columns.add(voice); element.columns.add(agep); element.columns.add(time); element.columns.add(viewer); @@ -1135,11 +1030,11 @@ void LLFloaterAvatarList::onClickTrack() if (mTracking && mTrackedAvatar == agent_id) { LLTracker::stopTracking(false); - mTracking = FALSE; + mTracking = false; } else { - mTracking = TRUE; + mTracking = true; mTrackedAvatar = agent_id; // trackAvatar only works for friends allowing you to see them on map... // LLTracker::trackAvatar(agent_id, self->mAvatars[agent_id].getName()); @@ -1164,70 +1059,60 @@ void LLFloaterAvatarList::refreshTracker() else { // Tracker stopped. LLTracker::stopTracking(false); - mTracking = FALSE; + mTracking = false; // llinfos << "Tracking stopped." << llendl; } } -void LLFloaterAvatarList::trackAvatar(const LLAvatarListEntry* entry) +void LLFloaterAvatarList::trackAvatar(const LLAvatarListEntry* entry) const { - if(!entry) return; + if (!entry) return; std::string name = entry->getName(); - if (!mUpdate) - { - name += "\n(last known position)"; - } + if (!mUpdate) name += "\n(last known position)"; LLTracker::trackLocation(entry->getPosition(), name, name); } -LLAvatarListEntry * LLFloaterAvatarList::getAvatarEntry(LLUUID avatar) +LLAvatarListEntry* LLFloaterAvatarList::getAvatarEntry(const LLUUID& avatar) const { - if (avatar.isNull()) - { - return NULL; - } - - av_list_t::iterator iter = std::find_if(mAvatars.begin(),mAvatars.end(),LLAvatarListEntry::uuidMatch(avatar)); - if(iter != mAvatars.end()) - return iter->get(); - else - return NULL; + if (avatar.isNull()) return NULL; + av_list_t::const_iterator iter = std::find_if(mAvatars.begin(),mAvatars.end(),LLAvatarListEntry::uuidMatch(avatar)); + return (iter != mAvatars.end()) ? iter->get() : NULL; } BOOL LLFloaterAvatarList::handleKeyHere(KEY key, MASK mask) { - LLScrollListItem* item = mAvatarList->getFirstSelected(); - if(item) + if (const LLScrollListItem* item = mAvatarList->getFirstSelected()) { LLUUID agent_id = item->getUUID(); - if (( KEY_RETURN == key ) && (MASK_NONE == mask)) + if (KEY_RETURN == key) { - setFocusAvatar(agent_id); - return TRUE; - } - else if (( KEY_RETURN == key ) && (MASK_CONTROL == mask)) - { - const LLAvatarListEntry* entry = getAvatarEntry(agent_id); - if (entry) + if (MASK_NONE == mask) { -// llinfos << "Trying to teleport to " << entry->getName() << " at " << entry->getPosition() << llendl; - gAgent.teleportViaLocation(entry->getPosition()); + setFocusAvatar(agent_id); + return true; + } + if (MASK_CONTROL == mask) + { + if (const LLAvatarListEntry* entry = getAvatarEntry(agent_id)) + { +// llinfos << "Trying to teleport to " << entry->getName() << " at " << entry->getPosition() << llendl; + gAgent.teleportViaLocation(entry->getPosition()); + } + return true; + } + if (MASK_SHIFT == mask) + { + onClickIM(); + return true; } - return TRUE; } } - - if (( KEY_RETURN == key ) && (MASK_SHIFT == mask)) - { - onClickIM(); - } return LLPanel::handleKeyHere(key, mask); } void LLFloaterAvatarList::onClickFocus() { - LLScrollListItem* item = mAvatarList->getFirstSelected(); - if (item) + if (LLScrollListItem* item = mAvatarList->getFirstSelected()) { setFocusAvatar(item->getUUID()); } @@ -1237,20 +1122,17 @@ void LLFloaterAvatarList::removeFocusFromAll() { BOOST_FOREACH(av_list_t::value_type& entry, mAvatars) { - entry->setFocus(FALSE); + entry->setFocus(false); } } void LLFloaterAvatarList::setFocusAvatar(const LLUUID& id) { + if (!gAgentCamera.lookAtObject(id, false) && !lookAtAvatar(id)) return; av_list_t::iterator iter = std::find_if(mAvatars.begin(),mAvatars.end(),LLAvatarListEntry::uuidMatch(id)); - if(iter != mAvatars.end()) - { - if(!gAgentCamera.lookAtObject(id, false)) - return; - removeFocusFromAll(); - (*iter)->setFocus(TRUE); - } + if (iter == mAvatars.end()) return; + removeFocusFromAll(); + (*iter)->setFocus(true); } // Simple function to decrement iterators, wrapping back if needed @@ -1261,7 +1143,7 @@ T prev_iter(const T& cur, const T& begin, const T& end) } template -void decrement_focus_target(T begin, T end, BOOL marked_only) +void decrement_focus_target(T begin, const T& end, bool marked_only) { for (T iter = begin; iter != end; ++iter) { @@ -1284,54 +1166,55 @@ void decrement_focus_target(T begin, T end, BOOL marked_only) } } -void LLFloaterAvatarList::focusOnPrev(BOOL marked_only) +void LLFloaterAvatarList::focusOnPrev(bool marked_only) { updateAvatarSorting(); decrement_focus_target(mAvatars.begin(), mAvatars.end(), marked_only); } -void LLFloaterAvatarList::focusOnNext(BOOL marked_only) +void LLFloaterAvatarList::focusOnNext(bool marked_only) { updateAvatarSorting(); decrement_focus_target(mAvatars.rbegin(), mAvatars.rend(), marked_only); } /*static*/ -void LLFloaterAvatarList::lookAtAvatar(LLUUID &uuid) +bool LLFloaterAvatarList::lookAtAvatar(const LLUUID& uuid) { // twisted laws LLVOAvatar* voavatar = gObjectList.findAvatar(uuid); - if(voavatar && voavatar->isAvatar()) + if (voavatar && voavatar->isAvatar()) { - gAgentCamera.setFocusOnAvatar(FALSE, FALSE); + gAgentCamera.setFocusOnAvatar(false, false); gAgentCamera.changeCameraToThirdPerson(); gAgentCamera.setFocusGlobal(voavatar->getPositionGlobal(),uuid); gAgentCamera.setCameraPosAndFocusGlobal(voavatar->getPositionGlobal() - + LLVector3d(3.5,1.35,0.75) * voavatar->getRotation(), + + LLVector3d(3.5, 1.35, 0.75) * voavatar->getRotation(), voavatar->getPositionGlobal(), - uuid ); + uuid); + return true; } + return false; } void LLFloaterAvatarList::onClickGetKey() { - LLScrollListItem* item = mAvatarList->getFirstSelected(); - - if (NULL == item) return; - - gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(item->getUUID().asString())); + if (LLScrollListItem* item = mAvatarList->getFirstSelected()) + { + gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(item->getUUID().asString())); + } } -void LLFloaterAvatarList::sendKeys() +void LLFloaterAvatarList::sendKeys() const { // This would break for send_keys_btn callback, check this beforehand, if it matters. //static LLCachedControl radar_chat_keys(gSavedSettings, "RadarChatKeys"); //if (radar_chat_keys) return; LLViewerRegion* regionp = gAgent.getRegion(); - if (!regionp) return;//ALWAYS VALIDATE DATA + if (!regionp) return; - static int last_transact_num = 0; - int transact_num = (int)gFrameCount; + static U32 last_transact_num = 0; + U32 transact_num(gFrameCount); if (transact_num > last_transact_num) { @@ -1345,37 +1228,32 @@ void LLFloaterAvatarList::sendKeys() } std::ostringstream ids; - int num_ids = 0; + U32 num_ids = 0; - for (int i = 0; i < regionp->mMapAvatarIDs.count(); ++i) + for (S32 i = 0; i < regionp->mMapAvatarIDs.count(); ++i) { - const LLUUID &id = regionp->mMapAvatarIDs.get(i); - - ids << "," << id; + ids << "," << regionp->mMapAvatarIDs.get(i); ++num_ids; - - if (ids.tellp() > 200) { send_keys_message(transact_num, num_ids, ids.str()); - - num_ids = 0; - ids.seekp(0); + ids.seekp(num_ids = 0); ids.str(""); } } - if (num_ids > 0) - send_keys_message(transact_num, num_ids, ids.str()); + if (num_ids > 0) send_keys_message(transact_num, num_ids, ids.str()); } //static void LLFloaterAvatarList::sound_trigger_hook(LLMessageSystem* msg,void **) { if (!LLFloaterAvatarList::instanceExists()) return; // Don't bother if we're closed. - LLUUID sound_id,owner_id; - msg->getUUIDFast(_PREHASH_SoundData, _PREHASH_SoundID, sound_id); + LLUUID owner_id; msg->getUUIDFast(_PREHASH_SoundData, _PREHASH_OwnerID, owner_id); - if (owner_id == gAgent.getID() && sound_id == LLUUID("76c78607-93f9-f55a-5238-e19b1a181389")) + if (owner_id != gAgentID) return; + LLUUID sound_id; + msg->getUUIDFast(_PREHASH_SoundData, _PREHASH_SoundID, sound_id); + if (sound_id == LLUUID("76c78607-93f9-f55a-5238-e19b1a181389")) { static LLCachedControl on("RadarChatKeys"); static LLCachedControl do_not_ask("RadarChatKeysStopAsking"); @@ -1386,7 +1264,7 @@ void LLFloaterAvatarList::sound_trigger_hook(LLMessageSystem* msg,void **) } } // static -bool LLFloaterAvatarList::onConfirmRadarChatKeys(const LLSD& notification, const LLSD& response ) +bool LLFloaterAvatarList::onConfirmRadarChatKeys(const LLSD& notification, const LLSD& response) { S32 option = LLNotification::getSelectedOption(notification, response); if (option == 1) // no @@ -1408,51 +1286,49 @@ bool LLFloaterAvatarList::onConfirmRadarChatKeys(const LLSD& notification, const void send_freeze(const LLUUID& avatar_id, bool freeze) { - U32 flags = 0x0; - if (!freeze) - { - // unfreeze - flags |= 0x1; - } - - LLMessageSystem* msg = gMessageSystem; LLVOAvatar* avatarp = gObjectList.findAvatar(avatar_id); - - if (avatarp && avatarp->getRegion()) + if (!avatarp) return; + if (LLViewerRegion* region = avatarp->getRegion()) { + LLMessageSystem* msg = gMessageSystem; msg->newMessage("FreezeUser"); msg->nextBlock("AgentData"); - msg->addUUID("AgentID", gAgent.getID()); - msg->addUUID("SessionID", gAgent.getSessionID()); + msg->addUUID("AgentID", gAgentID); + msg->addUUID("SessionID", gAgentSessionID); msg->nextBlock("Data"); msg->addUUID("TargetID", avatar_id); + U32 flags = 0x0; + if (!freeze) + { + // unfreeze + flags |= 0x1; + } msg->addU32("Flags", flags); - msg->sendReliable( avatarp->getRegion()->getHost()); + msg->sendReliable(region->getHost()); } } void send_eject(const LLUUID& avatar_id, bool ban) -{ - LLMessageSystem* msg = gMessageSystem; +{ LLVOAvatar* avatarp = gObjectList.findAvatar(avatar_id); - - if (avatarp && avatarp->getRegion()) + if (!avatarp) return; + if (LLViewerRegion* region = avatarp->getRegion()) { + LLMessageSystem* msg = gMessageSystem; + msg->newMessage("EjectUser"); + msg->nextBlock("AgentData"); + msg->addUUID("AgentID", gAgentID); + msg->addUUID("SessionID", gAgentSessionID); + msg->nextBlock("Data"); + msg->addUUID("TargetID", avatar_id); U32 flags = 0x0; if (ban) { // eject and add to ban list flags |= 0x1; } - - msg->newMessage("EjectUser"); - msg->nextBlock("AgentData"); - msg->addUUID("AgentID", gAgent.getID()); - msg->addUUID("SessionID", gAgent.getSessionID()); - msg->nextBlock("Data"); - msg->addUUID("TargetID", avatar_id); msg->addU32("Flags", flags); - msg->sendReliable(avatarp->getRegion()->getHost()); + msg->sendReliable(region->getHost()); } } @@ -1471,8 +1347,8 @@ static void send_estate_message( llinfos << "Sending estate request '" << request << "'" << llendl; msg->newMessage("EstateOwnerMessage"); msg->nextBlockFast(_PREHASH_AgentData); - msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); - msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); + msg->addUUIDFast(_PREHASH_AgentID, gAgentID); + msg->addUUIDFast(_PREHASH_SessionID, gAgentSessionID); msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null); //not used msg->nextBlock("MethodData"); msg->addString("Method", request); @@ -1480,7 +1356,7 @@ static void send_estate_message( // Agent id msg->nextBlock("ParamList"); - msg->addString("Parameter", gAgent.getID().asString().c_str()); + msg->addString("Parameter", gAgentID.asString().c_str()); // Target msg->nextBlock("ParamList"); @@ -1502,20 +1378,18 @@ static void cmd_ban(const LLAvatarListEntry* entry) { send_eject(entry->getID( static void cmd_estate_eject(const LLAvatarListEntry* entry){ send_estate_message("teleporthomeuser", entry->getID()); } static void cmd_estate_ban(const LLAvatarListEntry* entry) { LLPanelEstateInfo::sendEstateAccessDelta(ESTATE_ACCESS_BANNED_AGENT_ADD | ESTATE_ACCESS_ALLOWED_AGENT_REMOVE | ESTATE_ACCESS_NO_REPLY, entry->getID()); } -void LLFloaterAvatarList::doCommand(avlist_command_t func, bool single/*=false*/) +void LLFloaterAvatarList::doCommand(avlist_command_t func, bool single/*=false*/) const { uuid_vec_t ids; - if(!single) + if (!single) ids = mAvatarList->getSelectedIDs(); else ids.push_back(getSelectedID()); - for (uuid_vec_t::iterator itr = ids.begin(); itr != ids.end(); ++itr) + for (uuid_vec_t::const_iterator itr = ids.begin(); itr != ids.end(); ++itr) { - LLUUID& avid = *itr; - if(avid.isNull()) - continue; - LLAvatarListEntry* entry = getAvatarEntry(avid); - if (entry != NULL) + const LLUUID& avid = *itr; + if (avid.isNull()) continue; + if (LLAvatarListEntry* entry = getAvatarEntry(avid)) { llinfos << "Executing command on " << entry->getName() << llendl; func(entry); @@ -1523,32 +1397,26 @@ void LLFloaterAvatarList::doCommand(avlist_command_t func, bool single/*=false*/ } } -std::string LLFloaterAvatarList::getSelectedNames(const std::string& separator) +std::string LLFloaterAvatarList::getSelectedNames(const std::string& separator) const { std::string ret; doCommand(boost::bind(&cmd_append_names,_1,boost::ref(ret),separator)); return ret; } -std::string LLFloaterAvatarList::getSelectedName() +std::string LLFloaterAvatarList::getSelectedName() const { - LLUUID id = getSelectedID(); - LLAvatarListEntry* entry = getAvatarEntry(id); - if (entry) - { - return entry->getName(); - } - return ""; + LLAvatarListEntry* entry = getAvatarEntry(getSelectedID()); + return entry ? entry->getName() : ""; } -LLUUID LLFloaterAvatarList::getSelectedID() +LLUUID LLFloaterAvatarList::getSelectedID() const { LLScrollListItem* item = mAvatarList->getFirstSelected(); - if (item) return item->getUUID(); - return LLUUID::null; + return item ? item->getUUID() : LLUUID::null; } -uuid_vec_t LLFloaterAvatarList::getSelectedIDs() +uuid_vec_t LLFloaterAvatarList::getSelectedIDs() const { return mAvatarList->getSelectedIDs(); } @@ -1556,120 +1424,82 @@ uuid_vec_t LLFloaterAvatarList::getSelectedIDs() //static void LLFloaterAvatarList::callbackFreeze(const LLSD& notification, const LLSD& response) { - if(!instanceExists()) - return; - + if (!instanceExists()) return; + LLFloaterAvatarList& inst(instance()); S32 option = LLNotification::getSelectedOption(notification, response); - - if (option == 0) - { - getInstance()->doCommand(cmd_freeze); - } - else if (option == 1) - { - getInstance()->doCommand(cmd_unfreeze); - } + if (option == 0) inst.doCommand(cmd_freeze); + else if (option == 1) inst.doCommand(cmd_unfreeze); } //static void LLFloaterAvatarList::callbackEject(const LLSD& notification, const LLSD& response) { - if(!instanceExists()) - return; - + if (!instanceExists()) return; + LLFloaterAvatarList& inst(instance()); S32 option = LLNotification::getSelectedOption(notification, response); - - if (option == 0) - { - getInstance()->doCommand(cmd_eject); - } - else if (option == 1) - { - getInstance()->doCommand(cmd_ban); - } + if (option == 0) inst.doCommand(cmd_eject); + else if (option == 1) inst.doCommand(cmd_ban); } //static void LLFloaterAvatarList::callbackEjectFromEstate(const LLSD& notification, const LLSD& response) { - if(!instanceExists()) - return; - - S32 option = LLNotification::getSelectedOption(notification, response); - - if (option == 0) - { - getInstance()->doCommand(cmd_estate_eject); - } + if (!instanceExists()) return; + LLFloaterAvatarList& inst(instance()); + if (!LLNotification::getSelectedOption(notification, response)) // if == 0 + inst.doCommand(cmd_estate_eject); } //static void LLFloaterAvatarList::callbackBanFromEstate(const LLSD& notification, const LLSD& response) { - if(!instanceExists()) - return; - - S32 option = LLNotification::getSelectedOption(notification, response); - - if (option == 0) + if (!instanceExists()) return; + LLFloaterAvatarList& inst(instance()); + if (!LLNotification::getSelectedOption(notification, response)) // if == 0 { - getInstance()->doCommand(cmd_estate_eject); //Eject first, just in case. - getInstance()->doCommand(cmd_estate_ban); + inst.doCommand(cmd_estate_eject); //Eject first, just in case. + inst.doCommand(cmd_estate_ban); } } //static -void LLFloaterAvatarList::callbackIdle(void* userdata) +void LLFloaterAvatarList::callbackIdle(void*) { if (instanceExists()) { + LLFloaterAvatarList& inst(instance()); + const U32& rate = inst.mUpdateRate; // Do not update at every frame: this would be insane! - if (gFrameCount % getInstance()->mUpdateRate == 0) - { - getInstance()->updateAvatarList(); - } + if (rate == 0 || (gFrameCount % rate == 0)) + inst.updateAvatarList(); } } void LLFloaterAvatarList::onClickFreeze() { LLSD args; - LLSD payload; args["AVATAR_NAME"] = getSelectedNames(); - LLNotificationsUtil::add("FreezeAvatarFullname", args, payload, callbackFreeze); + LLNotificationsUtil::add("FreezeAvatarFullname", args, LLSD(), callbackFreeze); } void LLFloaterAvatarList::onClickEject() { LLSD args; - LLSD payload; args["AVATAR_NAME"] = getSelectedNames(); - LLNotificationsUtil::add("EjectAvatarFullname", args, payload, callbackEject); + LLNotificationsUtil::add("EjectAvatarFullname", args, LLSD(), callbackEject); } void LLFloaterAvatarList::onClickMute() { uuid_vec_t ids = mAvatarList->getSelectedIDs(); - if (ids.size() > 0) + for (uuid_vec_t::const_iterator itr = ids.begin(); itr != ids.end(); ++itr) { - for (uuid_vec_t::iterator itr = ids.begin(); itr != ids.end(); ++itr) + const LLUUID& agent_id = *itr; + std::string agent_name; + if (gCacheName->getFullName(agent_id, agent_name)) { - LLUUID agent_id = *itr; - - std::string agent_name; - if (gCacheName->getFullName(agent_id, agent_name)) - { - if (LLMuteList::getInstance()->isMuted(agent_id)) - { - LLMute mute(agent_id, agent_name, LLMute::AGENT); - LLMuteList::getInstance()->remove(mute); - } - else - { - LLMute mute(agent_id, agent_name, LLMute::AGENT); - LLMuteList::getInstance()->add(mute); - } - } + LLMute mute(agent_id, agent_name, LLMute::AGENT); + LLMuteList::getInstance()->isMuted(agent_id) ? LLMuteList::getInstance()->remove(mute) : LLMuteList::getInstance()->add(mute); } } } @@ -1677,9 +1507,8 @@ void LLFloaterAvatarList::onClickMute() void LLFloaterAvatarList::onClickEjectFromEstate() { LLSD args; - LLSD payload; args["EVIL_USER"] = getSelectedNames(); - LLNotificationsUtil::add("EstateKickUser", args, payload, callbackEjectFromEstate); + LLNotificationsUtil::add("EstateKickUser", args, LLSD(), callbackEjectFromEstate); } void LLFloaterAvatarList::onClickBanFromEstate() @@ -1687,24 +1516,16 @@ void LLFloaterAvatarList::onClickBanFromEstate() LLSD args; LLSD payload; args["EVIL_USER"] = getSelectedNames(); - LLNotificationsUtil::add("EstateBanUser", args, payload, callbackBanFromEstate); -} - -void LLFloaterAvatarList::onAvatarSortingChanged() -{ - mDirtyAvatarSorting = true; + LLNotificationsUtil::add("EstateBanUser", args, LLSD(), callbackBanFromEstate); } void LLFloaterAvatarList::onSelectName() { - LLScrollListItem* item = mAvatarList->getFirstSelected(); - if (item) + if (LLScrollListItem* item = mAvatarList->getFirstSelected()) { - LLUUID agent_id = item->getUUID(); - LLAvatarListEntry* entry = getAvatarEntry(agent_id); - if (entry) + if (LLAvatarListEntry* entry = getAvatarEntry(item->getUUID())) { - BOOL enabled = entry->mStats[STAT_TYPE_DRAW]; + bool enabled = entry->mStats[STAT_TYPE_DRAW]; childSetEnabled("focus_btn", enabled); childSetEnabled("prev_in_list_btn", enabled); childSetEnabled("next_in_list_btn", enabled); diff --git a/indra/newview/llfloateravatarlist.h b/indra/newview/llfloateravatarlist.h index a18b4f9cb..222107c12 100644 --- a/indra/newview/llfloateravatarlist.h +++ b/indra/newview/llfloateravatarlist.h @@ -10,6 +10,10 @@ // Copyright: See COPYING file that comes with this distribution // // + +#ifndef LL_LLFLOATERAVATARLIST_H +#define LL_LLFLOATERAVATARLIST_H + #include "llavatarname.h" #include "llavatarpropertiesprocessor.h" #include "llfloater.h" @@ -76,7 +80,7 @@ enum ACTIVITY_TYPE * Update world position. * Affects age. */ - void setPosition(LLVector3d position, bool this_sim, bool drawn, bool chatrange, bool shoutrange); + void setPosition(const LLVector3d& position, bool this_sim, bool drawn, bool chatrange, bool shoutrange); const LLVector3d& getPosition() const { return mPosition; } @@ -86,7 +90,7 @@ enum ACTIVITY_TYPE * This is only used for determining whether the avatar is still around. * @see getEntryAgeSeconds */ - bool getAlive(); + bool getAlive() const; /** * @brief Returns the age of this entry in seconds @@ -107,14 +111,14 @@ enum ACTIVITY_TYPE void setActivity(ACTIVITY_TYPE activity); /** - * @brief Returns the activity type + * @brief Returns the activity type, updates mActivityType if necessary */ const ACTIVITY_TYPE getActivity(); /** * @brief Sets the 'focus' status on this entry (camera focused on this avatar) */ - void setFocus(BOOL value) { mFocused = value; } + void setFocus(bool value) { mFocused = value; } bool isFocused() const { return mFocused; } @@ -130,7 +134,7 @@ enum ACTIVITY_TYPE bool isInList() const { return mIsInList; } /** * @brief Returns whether the item is dead and shouldn't appear in the list - * @returns TRUE if dead + * @returns true if dead */ bool isDead() const; @@ -207,7 +211,6 @@ public: /*virtual*/ void onOpen(); /*virtual*/ BOOL postBuild(); /*virtual*/ void draw(); - static void createInstance(bool visible); /** * @brief Toggles interface visibility * There is only one instance of the avatar scanner at any time. @@ -234,20 +237,20 @@ public: * @brief Returns the entry for an avatar, if preset * @returns Pointer to avatar entry, NULL if not found. */ - LLAvatarListEntry* getAvatarEntry(LLUUID avatar); + LLAvatarListEntry* getAvatarEntry(const LLUUID& avatar) const; /** * @brief Returns a string with the selected names in the list */ - std::string getSelectedNames(const std::string& separator = ", "); - std::string getSelectedName(); - LLUUID getSelectedID(); - uuid_vec_t getSelectedIDs(); + std::string getSelectedNames(const std::string& separator = ", ") const; + std::string getSelectedName() const; + LLUUID getSelectedID() const; + uuid_vec_t getSelectedIDs() const; - static void lookAtAvatar(LLUUID &uuid); + static bool lookAtAvatar(const LLUUID& uuid); static void sound_trigger_hook(LLMessageSystem* msg,void **); - void sendKeys(); + void sendKeys() const; typedef boost::shared_ptr LLAvatarListEntryPtr; typedef std::vector< LLAvatarListEntryPtr > av_list_t; @@ -264,6 +267,7 @@ public: LIST_POSITION, LIST_ALTITUDE, LIST_ACTIVITY, + LIST_VOICE, LIST_AGE, LIST_TIME, LIST_CLIENT, @@ -285,16 +289,16 @@ public: * @brief Focus camera on previous avatar * @param marked_only Whether to choose only marked avatars */ - void focusOnPrev(BOOL marked_only); + void focusOnPrev(bool marked_only); /** * @brief Focus camera on next avatar * @param marked_only Whether to choose only marked avatars */ - void focusOnNext(BOOL marked_only); + void focusOnNext(bool marked_only); void refreshTracker(); - void trackAvatar(const LLAvatarListEntry* entry); + void trackAvatar(const LLAvatarListEntry* entry) const; /** * @brief Handler for the "refresh" button click. @@ -321,7 +325,8 @@ public: void onClickEject(); void onClickEjectFromEstate(); void onClickBanFromEstate(); - void onAvatarSortingChanged(); + + void onAvatarSortingChanged() { mDirtyAvatarSorting = true; } /** * @brief Called via notification feedback. @@ -335,7 +340,7 @@ public: static void callbackIdle(void *userdata); - void doCommand(avlist_command_t cmd, bool single = false); + void doCommand(avlist_command_t cmd, bool single = false) const; /** * @brief Cleanup avatar list, removing dead entries from it. @@ -355,7 +360,7 @@ private: bool mDirtyAvatarSorting; /** - * @brief TRUE when Updating + * @brief true when Updating */ const LLCachedControl mUpdate; @@ -373,3 +378,5 @@ private: */ LLUUID mFocusedAvatar; }; + +#endif diff --git a/indra/newview/llfloatermessagelog.h b/indra/newview/llfloatermessagelog.h index 1fa01c5af..a17026233 100644 --- a/indra/newview/llfloatermessagelog.h +++ b/indra/newview/llfloatermessagelog.h @@ -1,3 +1,6 @@ +#ifndef LL_LLFLOATERMESSAGELOG_H +#define LL_LLFLOATERMESSAGELOG_H + // #include "llfloater.h" #include "llmessagelog.h" @@ -94,3 +97,5 @@ public: static void onClickFilterMenu(void* user_data); }; // + +#endif \ No newline at end of file diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp index 16c33c6b5..6e50ed2a4 100644 --- a/indra/newview/llfloatermodelpreview.cpp +++ b/indra/newview/llfloatermodelpreview.cpp @@ -241,6 +241,22 @@ bool ll_is_degenerate(const LLVector4a& a, const LLVector4a& b, const LLVector4a bool validate_face(const LLVolumeFace& face) { + + for (S32 v = 0; v < face.mNumVertices; v++) + { + if(face.mPositions && !face.mPositions[v].isFinite3()) + { + llwarns << "NaN position data in face found!" << llendl; + return false; + } + + if(face.mNormals && !face.mNormals[v].isFinite3()) + { + llwarns << "NaN normal data in face found!" << llendl; + return false; + } + } + for (S32 i = 0; i < face.mNumIndices; ++i) { if (face.mIndices[i] >= face.mNumVertices) @@ -3807,15 +3823,30 @@ void LLModelPreview::genLODs(S32 which_lod, U32 decimation, bool enforce_tri_lim U32 triangle_count = 0; - for (LLModelLoader::model_list::iterator iter = mBaseModel.begin(); iter != mBaseModel.end(); ++iter) + U32 instanced_triangle_count = 0; + + //get the triangle count for the whole scene + for (LLModelLoader::scene::iterator iter = mBaseScene.begin(), endIter = mBaseScene.end(); iter != endIter; ++iter) { - LLModel* mdl = *iter; - for (S32 i = 0; i < mdl->getNumVolumeFaces(); ++i) + for (LLModelLoader::model_instance_list::iterator instance = iter->second.begin(), end_instance = iter->second.end(); instance != end_instance; ++instance) { - triangle_count += mdl->getVolumeFace(i).mNumIndices/3; + LLModel* mdl = instance->mModel; + if (mdl) + { + instanced_triangle_count += mdl->getNumTriangles(); + } } } + //get the triangle count for the non-instanced set of models + for (U32 i = 0; i < mBaseModel.size(); ++i) + { + triangle_count += mBaseModel[i]->getNumTriangles(); + } + + //get ratio of uninstanced triangles to instanced triangles + F32 triangle_ratio = (F32) triangle_count / (F32) instanced_triangle_count; + U32 base_triangle_count = triangle_count; U32 type_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_TEXCOORD0; @@ -3849,6 +3880,8 @@ void LLModelPreview::genLODs(S32 which_lod, U32 decimation, bool enforce_tri_lim if (which_lod > -1 && which_lod < NUM_LOD) { limit = mFMP->childGetValue("lod_triangle_limit_" + lod_name[which_lod]).asInteger(); + //convert from "scene wide" to "non-instanced" triangle limit + limit = (S32) ( (F32) limit*triangle_ratio ); } } else @@ -3953,7 +3986,7 @@ void LLModelPreview::genLODs(S32 which_lod, U32 decimation, bool enforce_tri_lim U32 actual_verts = 0; U32 submeshes = 0; - mRequestedTriangleCount[lod] = triangle_count; + mRequestedTriangleCount[lod] = (S32) ( (F32) triangle_count / triangle_ratio ); mRequestedErrorThreshold[lod] = lod_error_threshold; glodGroupParameteri(mGroup, GLOD_ADAPT_MODE, lod_mode); @@ -4135,28 +4168,36 @@ void LLModelPreview::updateStatusMessages() //initialize total for this lod to 0 total_tris[lod] = total_verts[lod] = total_submeshes[lod] = 0; - for (U32 i = 0; i < mModel[lod].size(); ++i) - { //for each model in the lod - S32 cur_tris = 0; - S32 cur_verts = 0; - S32 cur_submeshes = mModel[lod][i]->getNumVolumeFaces(); + for (LLModelLoader::scene::iterator iter = mScene[lod].begin(), endIter = mScene[lod].end(); iter != endIter; ++iter) + { + for (LLModelLoader::model_instance_list::iterator instance = iter->second.begin(), end_instance = iter->second.end(); instance != end_instance; ++instance) + { + LLModel* model = instance->mModel; + if (model) + { + //for each model in the lod + S32 cur_tris = 0; + S32 cur_verts = 0; + S32 cur_submeshes = model->getNumVolumeFaces(); - for (S32 j = 0; j < cur_submeshes; ++j) - { //for each submesh (face), add triangles and vertices to current total - const LLVolumeFace& face = mModel[lod][i]->getVolumeFace(j); - cur_tris += face.mNumIndices/3; - cur_verts += face.mNumVertices; + for (S32 j = 0; j < cur_submeshes; ++j) + { //for each submesh (face), add triangles and vertices to current total + const LLVolumeFace& face = model->getVolumeFace(j); + cur_tris += face.mNumIndices/3; + cur_verts += face.mNumVertices; + } + + //add this model to the lod total + total_tris[lod] += cur_tris; + total_verts[lod] += cur_verts; + total_submeshes[lod] += cur_submeshes; + + //store this model's counts to asset data + tris[lod].push_back(cur_tris); + verts[lod].push_back(cur_verts); + submeshes[lod].push_back(cur_submeshes); + } } - - //add this model to the lod total - total_tris[lod] += cur_tris; - total_verts[lod] += cur_verts; - total_submeshes[lod] += cur_submeshes; - - //store this model's counts to asset data - tris[lod].push_back(cur_tris); - verts[lod].push_back(cur_verts); - submeshes[lod].push_back(cur_submeshes); } } @@ -4334,34 +4375,38 @@ void LLModelPreview::updateStatusMessages() } //add up physics triangles etc - S32 start = 0; - S32 end = mModel[LLModel::LOD_PHYSICS].size(); - S32 phys_tris = 0; S32 phys_hulls = 0; S32 phys_points = 0; - for (S32 i = start; i < end; ++i) - { //add up hulls and points and triangles for selected mesh(es) - LLModel* model = mModel[LLModel::LOD_PHYSICS][i]; - S32 cur_submeshes = model->getNumVolumeFaces(); - - LLModel::convex_hull_decomposition& decomp = model->mPhysics.mHull; - - if (!decomp.empty()) + //get the triangle count for the whole scene + for (LLModelLoader::scene::iterator iter = mScene[LLModel::LOD_PHYSICS].begin(), endIter = mScene[LLModel::LOD_PHYSICS].end(); iter != endIter; ++iter) + { + for (LLModelLoader::model_instance_list::iterator instance = iter->second.begin(), end_instance = iter->second.end(); instance != end_instance; ++instance) { - phys_hulls += decomp.size(); - for (U32 i = 0; i < decomp.size(); ++i) + LLModel* model = instance->mModel; + if (model) { - phys_points += decomp[i].size(); - } - } - else - { //choose physics shape OR decomposition, can't use both - for (S32 j = 0; j < cur_submeshes; ++j) - { //for each submesh (face), add triangles and vertices to current total - const LLVolumeFace& face = model->getVolumeFace(j); - phys_tris += face.mNumIndices/3; + S32 cur_submeshes = model->getNumVolumeFaces(); + + LLModel::convex_hull_decomposition& decomp = model->mPhysics.mHull; + + if (!decomp.empty()) + { + phys_hulls += decomp.size(); + for (U32 i = 0; i < decomp.size(); ++i) + { + phys_points += decomp[i].size(); + } + } + else + { //choose physics shape OR decomposition, can't use both + for (S32 j = 0; j < cur_submeshes; ++j) + { //for each submesh (face), add triangles and vertices to current total + const LLVolumeFace& face = model->getVolumeFace(j); + phys_tris += face.mNumIndices/3; + } + } } } } @@ -4523,7 +4568,7 @@ void LLModelPreview::updateLodControls(S32 lod) if (!lod_combo) return; S32 lod_mode = lod_combo->getCurrentIndex(); - if (lod_mode == 0) // LoD from file + if (lod_mode == LOD_FROM_FILE) // LoD from file { fmp->mLODMode[lod] = 0; for (U32 i = 0; i < num_file_controls; ++i) @@ -4536,7 +4581,7 @@ void LLModelPreview::updateLodControls(S32 lod) mFMP->childHide(lod_controls[i] + lod_name[lod]); } } - else if (lod_mode == 2) // use LoD above + else if (lod_mode == USE_LOD_ABOVE) // use LoD above { fmp->mLODMode[lod] = 2; for (U32 i = 0; i < num_file_controls; ++i) diff --git a/indra/newview/llfloatermodelpreview.h b/indra/newview/llfloatermodelpreview.h index 6ca55bb81..8ac80d41a 100644 --- a/indra/newview/llfloatermodelpreview.h +++ b/indra/newview/llfloatermodelpreview.h @@ -298,6 +298,15 @@ class LLModelPreview : public LLViewerDynamicTexture, public LLMutex typedef boost::signals2::signal model_loaded_signal_t; typedef boost::signals2::signal model_updated_signal_t; +public: + + typedef enum + { + LOD_FROM_FILE = 0, + GENERATE, + USE_LOD_ABOVE, + } eLoDMode; + public: LLModelPreview(S32 width, S32 height, LLFloater* fmp); virtual ~LLModelPreview(); diff --git a/indra/newview/llfloaterpermissionsmgr.cpp b/indra/newview/llfloaterpermissionsmgr.cpp deleted file mode 100644 index 750cd8bfd..000000000 --- a/indra/newview/llfloaterpermissionsmgr.cpp +++ /dev/null @@ -1,154 +0,0 @@ -/** - * @file llfloaterpermissionsmgr.cpp - * @brief for user control of script permissions - * - * $LicenseInfo:firstyear=2003&license=viewergpl$ - * - * Copyright (c) 2003-2009, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at - * http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ - -#include "llviewerprecompiledheaders.h" - -#include "llfloaterpermissionsmgr.h" - -#include "llscrollcontainer.h" -#include "lltextbox.h" -#include "llbutton.h" -#include "llagent.h" -#include "llviewerobjectlist.h" -#include "llviewerregion.h" -#include "llstl.h" - -// constants -const S32 MIN_PERM_MGR_WIDTH = 100; -const S32 MIN_PERM_MGR_HEIGHT = 100; -const S32 VPAD = 8; -const S32 HPAD = 8; -const S32 LINE = 16; - -// statics -LLFloaterPermissionsMgr* LLFloaterPermissionsMgr::sInstance = NULL; - -LLFloaterPermissionsMgr* LLFloaterPermissionsMgr::show() -{ - if (!sInstance) - { - sInstance = new LLFloaterPermissionsMgr(); - - sInstance->open(); /* Flawfinder: ignore */ - gFloaterView->adjustToFitScreen(sInstance, TRUE); - } - else - { - sInstance->open(); /* Flawfinder: ignore */ - } - - return sInstance; -} - -void LLFloaterPermissionsMgr::processPermissionsList(LLMessageSystem* msg, void**) -{ -} - -LLFloaterPermissionsMgr::LLFloaterPermissionsMgr() : - LLFloater(std::string("floater_perm_mgr"), std::string("PermissionsManagerRect"), std::string("Permissions Manager"), - TRUE, MIN_PERM_MGR_WIDTH, MIN_PERM_MGR_HEIGHT) -{ - S32 y = getRect().getHeight() - VPAD - LINE; - LLRect scrollable_container_rect(0, y, getRect().getWidth(), 0); - LLRect permissions_rect(0, 0, getRect().getWidth() - HPAD - HPAD, 0); - mPermissions = new LLPermissionsView(permissions_rect); - mScroller = new LLScrollContainer( - std::string("permissions container"), - scrollable_container_rect, - mPermissions - ); - mScroller->setFollowsAll(); - mScroller->setReserveScrollCorner(TRUE); - addChild(mScroller); -} - -LLFloaterPermissionsMgr::~LLFloaterPermissionsMgr() -{ -} - - -// -// LLPermissionsView -// - -LLPermissionsView::LLPermissionsView(const LLRect &rect) : LLView(std::string("permissions_view"), rect, TRUE, FOLLOWS_NONE) -{ -} - -void LLPermissionsView::clearPermissionsData() -{ - deleteAllChildren(); -} - -void LLPermissionsView::addPermissionsData(const std::string& object_name, const LLUUID& object_id, U32 permissions_flags) -{ - // grow to make room for new element - reshape(getRect().getWidth(), getRect().getHeight() + LINE + VPAD + BTN_HEIGHT + VPAD); - S32 y = getRect().getHeight() - LINE - VPAD; - LLRect label_rect(HPAD, y + LINE, getRect().getWidth(), y); - LLTextBox* text = new LLTextBox(std::string("perm_label"), label_rect, object_name); - text->setFollows(FOLLOWS_LEFT | FOLLOWS_RIGHT | FOLLOWS_BOTTOM); - addChild(text); - - y -= LINE + VPAD; - - LLRect btn_rect(HPAD, y + BTN_HEIGHT, 120, y); - LLButton* button = new LLButton(std::string("Revoke permissions"), btn_rect, LLStringUtil::null, boost::bind(&LLPermissionsView::revokePermissions, object_id, permissions_flags)); - button->setFollows(FOLLOWS_LEFT | FOLLOWS_BOTTOM); - addChild(button); - - /*btn_rect.set(HPAD + 120 + HPAD, y + BTN_HEIGHT, HPAD + 120 + HPAD + 120, y); - button = new LLButton(std::string("Find in world"), btn_rect, LLStringUtil::null, boost::bind(&LLPermissionsView::findObject, object_id, permissions_flags)); - button->setFollows(FOLLOWS_LEFT | FOLLOWS_BOTTOM); - addChild(button);*/ -} - -void LLPermissionsView::revokePermissions(const LLUUID& object_id, U32 permission_flags) -{ - LLViewerObject* objectp = gObjectList.findObject(object_id); - if (objectp) - { - LLMessageSystem* msg = gMessageSystem; - msg->newMessageFast(_PREHASH_RevokePermissions); - msg->nextBlockFast(_PREHASH_AgentData); - msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); - msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); - msg->nextBlockFast(_PREHASH_Data); - msg->addUUIDFast(_PREHASH_ObjectID, object_id); - msg->addU32Fast(_PREHASH_ObjectPermissions, permission_flags); - msg->sendReliable(objectp->getRegion()->getHost()); - } -} - -/*void LLPermissionsView::findObject(const LLUUID& object_id, U32 permission_flags) -{ -}*/ diff --git a/indra/newview/llfloaterpermissionsmgr.h b/indra/newview/llfloaterpermissionsmgr.h deleted file mode 100644 index ac933e3f1..000000000 --- a/indra/newview/llfloaterpermissionsmgr.h +++ /dev/null @@ -1,82 +0,0 @@ -/** - * @file llfloaterpermissionsmgr.h - * @brief for user control of script permissions - * - * $LicenseInfo:firstyear=2003&license=viewergpl$ - * - * Copyright (c) 2003-2009, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at - * http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ - -#ifndef LL_LLFLOATERPERMISSIONSMGR_H -#define LL_LLFLOATERPERMISSIONSMGR_H - -#include "llfloater.h" -#include - -class LLScrollContainer; -class LLPermissionsView; - -class LLFloaterPermissionsMgr -: public LLFloater -{ -public: - static LLFloaterPermissionsMgr* show(); - - // Message system callbacks - static void processPermissionsList(LLMessageSystem* msg, void**); - - virtual void onClose(bool app_quitting) { setVisible(FALSE); } - -private: - // Must construct by calling show(). - LLFloaterPermissionsMgr(); - virtual ~LLFloaterPermissionsMgr(); - -public: - LLPermissionsView* mPermissions; - -protected: - LLScrollContainer* mScroller; - - static LLFloaterPermissionsMgr* sInstance; -}; - -class LLPermissionsView : public LLView -{ -public: - LLPermissionsView(const LLRect& rect); - virtual ~LLPermissionsView() {}; - -public: - void clearPermissionsData(); - void addPermissionsData(const std::string& object_name, const LLUUID& object_id, U32 permissions_flags); - - static void revokePermissions(const LLUUID& object_id, U32 permission_flags); - //static void findObject(const LLUUID& object_id, U32 permission_flags); -}; - - -#endif diff --git a/indra/newview/llfloaterteleport.cpp b/indra/newview/llfloaterteleport.cpp deleted file mode 100644 index dd546c5b0..000000000 --- a/indra/newview/llfloaterteleport.cpp +++ /dev/null @@ -1,332 +0,0 @@ -/** - * @file llfloaterteleport.cpp - * @brief floater code for agentd teleports. - * - * $LicenseInfo:firstyear=2008&license=viewergpl$ - * - * Copyright (c) 2008, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ -//Teleport floater used for agent domain TP. URI text floater. -//Copyright International Business Machines Corporation 2008-9 -//Contributed to Linden Research, Inc. under the Second Life Viewer Contribution -//Agreement and licensed as above. -#include "llviewerprecompiledheaders.h" // must be first include - -#include "llfloaterteleport.h" - -#include "llagent.h" //for hack in teleport start -#include "llchat.h" -#include "llcombobox.h" -#include "llfloaterchat.h" -#include "llsdserialize.h" -#include "llsdutil.h" -#include "llsdutil_math.h" -#include "lluictrlfactory.h" // builds floaters from XML -#include "llurlhistory.h" -#include "lluserauth.h" // for saving placeavatarresponder result -#include "llviewercontrol.h" // for gSavedSettings -#include "llviewerdisplay.h" // for gTeleportDisplay -#include "llviewermessage.h" // for send_agent_movement_complete attempt -#include "llviewerregion.h" -#include "llviewerwindow.h" // for hack in teleport start -#include "llvoavatar.h" -#include "llworld.h" -#include "pipeline.h" // for gPipeline - -class AIHTTPTimeoutPolicy; -extern AIHTTPTimeoutPolicy placeAvatarTeleportResponder_timeout; - -// OGPX HTTP responder for PlaceAvatar cap used for Teleport -// very similar to the responder in Login, but not as many fields are returned in the TP version -// OGPX TODO: should this be combined with the Login responder for rez_avatar/place? -// OGPX TODO: mResult should not get replaced in result(), instead -// should replace individual LLSD fields in mResult. -class LLPlaceAvatarTeleportResponder : public LLHTTPClient::ResponderWithResult -{ -public: - LLPlaceAvatarTeleportResponder() - { - } - - ~LLPlaceAvatarTeleportResponder() - { - } - - /*virtual*/ void error(U32 statusNum, const std::string& reason) - { - LL_INFOS("OGPX") << "LLPlaceAvatarTeleportResponder error in TP " - << statusNum << " " << reason << LL_ENDL; - - LLSD args; - args["REASON"] = reason; - - - LLNotificationsUtil::add("CouldNotTeleportReason", args); - - gAgent.setTeleportState( LLAgent::TELEPORT_NONE ); - - } - - /*virtual*/ void result(const LLSD& content) - { - - LLSD result; - result["agent_id"] = content["agent_id"]; // need this for send_complete_agent_movement - result["region_x"] = content["region_x"]; // need these for making the first region - result["region_y"] = content["region_y"]; - result["login"] = "true"; // this gets checked in idle_startup() - result["session_id"] = content["session_id"]; - result["secure_session_id"] = content["secure_session_id"]; - result["circuit_code"] = content["circuit_code"]; - result["sim_port"] = content["sim_port"]; - result["sim_host"] = content["sim_host"]; - result["look_at"] = content["look_at"]; - // maintaining result seed_capability name for compatibility with legacy login - result["seed_capability"] = content["region_seed_capability"]; - result["position"] = content["position"]; // save this for agentmovementcomplete type processing - - // Even though we have the pretty print of the complete content returned, we still find it handy - // when scanning SecondLife.log to have these laid out in this way. So they are still here. - LL_DEBUGS("OGPX") << " Teleport placeAvatar responder " << LL_ENDL; - LL_DEBUGS("OGPX") << "agent_id: " << content["agent_id"] << LL_ENDL; - LL_DEBUGS("OGPX") << "region_x: " << content["region_x"] << LL_ENDL; - LL_DEBUGS("OGPX") << "session_id: " << content["session_id"] << LL_ENDL; - LL_DEBUGS("OGPX") << "sim_port: " << content["sim_port"] << LL_ENDL; - LL_DEBUGS("OGPX") << "sim_host: " << content["sim_host"] << LL_ENDL; - LL_DEBUGS("OGPX") << "look_at: " << content["look_at"] << LL_ENDL; - LL_DEBUGS("OGPX") << "position: " << content["position"] << LL_ENDL; - LL_DEBUGS("OGPX") << "seed_capability: " << content["region_seed_capability"] << LL_ENDL; - - LL_INFOS("OGPX") << " All the LLSD PlaceAvatarTeleportResponder content: \n " << ll_pretty_print_sd(content) << LL_ENDL; // OGPX - - - // check "connect" to make sure place_avatar fully successful - if (!content["connect"].asBoolean()) - { - // place_avatar failed somewhere - LL_INFOS("OGPX") << "TP failed, connect false in TP PlaceAvatarResponder " << LL_ENDL; - - LLSD args; - args["REASON"] = "Place Avatar Failed"; - - //gViewerWindow->alertXml("CouldNotTeleportReason", args); - LLNotificationsUtil::add("CouldNotTeleportReason",args); - - gAgent.setTeleportState( LLAgent::TELEPORT_NONE ); - - return; - } - - - U64 region_handle; - region_handle = to_region_handle_global(content["region_x"].asInteger(), content["region_y"].asInteger()); - - LLHost sim_host; - U32 sim_port = strtoul(result["sim_port"].asString().c_str(), NULL, 10); - sim_host.setHostByName(result["sim_host"].asString().c_str()); - sim_host.setPort(sim_port); - - if (sim_host.isOk()) - { - LLMessageSystem* msg = gMessageSystem; - gMessageSystem->enableCircuit(sim_host, TRUE); - msg->newMessageFast(_PREHASH_UseCircuitCode); - msg->nextBlockFast(_PREHASH_CircuitCode); - msg->addU32Fast(_PREHASH_Code, msg->getOurCircuitCode()); - msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); - msg->addUUIDFast(_PREHASH_ID, gAgent.getID()); - msg->sendReliable(sim_host); - } - else - { - LL_INFOS("OGPX") << "TP failed, could not resolve hostname for UDP messages." << LL_ENDL; - LLSD args; - args["REASON"] = "Failed to resolve host."; - //gViewerWindow->alertXml("CouldNotTeleportReason", args); - LLNotificationsUtil::add("CouldNotTeleportReason", args); - gAgent.setTeleportState( LLAgent::TELEPORT_NONE ); - return; - } - - - - - // Viewer trusts the simulator. - LLViewerRegion* regionp = LLWorld::getInstance()->addRegion(region_handle, sim_host); - regionp->setSeedCapability(content["seed_capability"].asString().c_str()); - // process_agent_movement_complete needs the region to still be the old region gAgent.setRegion(regionp); - - // placing these in result so they can be set properly in LLUserAuth result - // ...they are only passed in on login, and not on TP - result["session_id"] = gAgent.getSessionID(); - result["agent_id"] = gAgent.getID(); - result["circuit_code"].asString() = gMessageSystem->mOurCircuitCode; // this is what startup sets, is this proper to do? - - // grab the skeleton and root. - result["inventory-skeleton"] = LLUserAuth::getInstance()->mResult["inventory-skeleton"]; - result["inventory-root"] = LLUserAuth::getInstance()->mResult["inventory-root"]; - - LL_DEBUGS("OGPX") << "session_id: " << result["session_id"] << LL_ENDL; - - - - // results need to be stored so process_agent_movement_complete() can pull them - LLUserAuth::getInstance()->mAuthResponse = LLUserAuth::E_OK; - - // OGPX TODO: This just reeks of causing problems, because we are using - // ... mResult to store things that we get from other caps....So slamming a - // ... completely new result in on teleport is going to cause issues. - // ... It makes changing the things we save in mResult error prone. - // ... Question is, how should we really be storing the seemingly random things - // ... that we get back from (now) various different caps that used to all come back - // ... in the result of XMLRPC authenticate? - LLUserAuth::getInstance()->mResult = result; - - - - // ... new sim not sending me much without sending it CompleteAgentMovement msg. - //gAgent.setTeleportState( LLAgent::TELEPORT_MOVING ); // process_agent_mv_complete looks for TELEPORT_MOVING - LLVector3 position = ll_vector3_from_sd(result["position"]); - gAgent.setHomePosRegion(region_handle, position); // taken from teleport_finish (not sure regular code path gets this) - - send_complete_agent_movement(sim_host); - - // Turn off progress msg (also need to do this in all the possible failure places) - // I think we leave this, as the scene is still changing during the - // processing of agentmovementcomeplete message. TELEPORT_NONE resets it anyway - // gViewerWindow->setShowProgress(FALSE); - - } - - /*virtual*/ AIHTTPTimeoutPolicy const& getHTTPTimeoutPolicy(void) const { return placeAvatarTeleportResponder_timeout; } - /*virtual*/ char const* getName(void) const { return "LLPlaceAvatarTeleportResponder"; } -}; - -// Statics -LLFloaterTeleport* LLFloaterTeleport::sInstance = NULL; - -LLFloaterTeleport::LLFloaterTeleport() -: LLFloater("floater_teleport") -{ - if(!sInstance) - { - LLUICtrlFactory::getInstance()->buildFloater(this, "floater_teleport.xml"); - - LLComboBox* regioncombo = getChild("teleport_edit"); - regioncombo->setAllowTextEntry(TRUE, 256, FALSE); // URL bar needs to allow user text input - - // iterate on uri list adding to combobox (couldn't figure out how to add them all in one call) - LLSD regionuri_history = LLURLHistory::getURLHistory("regionuri"); - LLSD::array_iterator iter_history = regionuri_history.beginArray(); - LLSD::array_iterator iter_end = regionuri_history.endArray(); - for(; iter_history != iter_end; ++iter_history) - { - regioncombo->addSimpleElement((*iter_history).asString()); - } - - // select which is displayed if we have a current URL. - regioncombo->setSelectedByValue(LLSD(gSavedSettings.getString("CmdLineRegionURI")),TRUE); - - // TODO : decide if 'enter' when selecting something from the combox box should *not* be sent - // to the floater (p.s. and figure out how to change it) - - childSetAction("teleport_btn", onClickTeleport, this); - childSetAction("cancel_btn", onClickCancel, this); - - setDefaultBtn("teleport_btn"); - } - else - { - sInstance->show(NULL); - } -} - -// static -void LLFloaterTeleport::show(void*) -{ - if (!sInstance) - { - sInstance = new LLFloaterTeleport(); - } - - sInstance->open(); -} - -LLFloaterTeleport::~LLFloaterTeleport() -{ - sInstance=NULL; -} - - - -// static -void LLFloaterTeleport::onClickTeleport(void* userdata) -{ - std::string placeAvatarCap = LLAppViewer::instance()->getPlaceAvatarCap(); - LLSD args; - - LLFloaterTeleport* self = (LLFloaterTeleport*)userdata; - std::string text = self->childGetText("teleport_edit"); - if (text.find("://",0) == std::string::npos) - { - // if there is no uri, prepend it with http:// - text = "http://"+text; - LL_DEBUGS("OGPX") << "Teleport URI was prepended, now " << text << LL_ENDL; - } - - LL_DEBUGS("OGPX") << "onClickTeleport! from using place_avatar cap "<< placeAvatarCap << " contains "<< text << LL_ENDL; - LLStringUtil::trim(text); // trim extra spacing - gAgent.setTeleportSourceURL(gSavedSettings.getString("CmdLineRegionURI")); // grab src region name - gSavedSettings.setString("CmdLineRegionURI",text); // save the dst region - args["public_region_seed_capability"] = text; - args["position"] = ll_sd_from_vector3(LLVector3(128, 128, 50)); // default to middle of region above base terrain - LL_INFOS("OGPX") << " args to placeavatar cap " << placeAvatarCap << " on teleport: " << LLSDOStreamer(args) << LL_ENDL; - LLHTTPClient::post(placeAvatarCap, args, new LLPlaceAvatarTeleportResponder()); - gAgent.setTeleportMessage( - LLAgent::sTeleportProgressMessages["requesting"]); - gViewerWindow->setShowProgress(TRUE); - gAgent.teleportCore(); - gAgent.setTeleportState( LLAgent::TELEPORT_PLACE_AVATAR ); // teleportcore() sets tp state to legacy path, so reset. ick! - gTeleportDisplayTimer.reset(); - - - - self->setVisible(FALSE); - if ( LLURLHistory::appendToURLCollection("regionuri",text)) - { - // since URL history only populated on create of sInstance, add to combo list directly - LLComboBox* regioncombo = self->getChild("teleport_edit"); - // BUG : this should add the new item to the combo box, but doesn't - regioncombo->addSimpleElement(text); - } - -} - -void LLFloaterTeleport::onClickCancel(void *userdata) -{ - LLFloaterTeleport* self = (LLFloaterTeleport*)userdata; - LL_INFOS("OGPX") << "Teleport Cancel " << self->getName() << LL_ENDL; - self->setVisible(FALSE); -} diff --git a/indra/newview/llfloaterteleport.h b/indra/newview/llfloaterteleport.h deleted file mode 100644 index 58e907a68..000000000 --- a/indra/newview/llfloaterteleport.h +++ /dev/null @@ -1,65 +0,0 @@ -/** - * @file llfloaterteleport.h - * @brief floater header for agentd teleports. - * - * $LicenseInfo:firstyear=2008&license=viewergpl$ - * - * Copyright (c) 2008, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ -// Teleport floater for agent domain TPs using URIs. -//Copyright International Business Machines Corporation 2008-9 -//Contributed to Linden Research, Inc. under the Second Life Viewer Contribution -//Agreement and licensed as above. -#ifndef LL_FLOATER_TELEPORT_H -#define LL_FLOATER_TELEPORT_H -#include "llfloater.h" - -class LLFloaterTeleport : public LLFloater -{ -public: - LLFloaterTeleport(); - - virtual ~LLFloaterTeleport(); - - // by convention, this shows the floater and does instance management - static void show(void*); - -private: - // when a line editor loses keyboard focus, it is committed. - // commit callbacks are named onCommitWidgetName by convention. - static void onCommitTeleport(LLUICtrl* ctrl, void *userdata); - - // by convention, button callbacks are named onClickButtonLabel - static void onClickTeleport(void* userdata); - static void onClickCancel(void *userdata); - - // no pointers to widgets here - they are referenced by name - - // assuming we just need one, which is typical - static LLFloaterTeleport* sInstance; - -}; -#endif - diff --git a/indra/newview/llimpanel.cpp b/indra/newview/llimpanel.cpp index aaf79dbfc..9603208c7 100644 --- a/indra/newview/llimpanel.cpp +++ b/indra/newview/llimpanel.cpp @@ -35,6 +35,7 @@ #include "ascentkeyword.h" #include "llagent.h" +#include "llautoreplace.h" #include "llavataractions.h" #include "llavatarnamecache.h" #include "llbutton.h" @@ -466,6 +467,7 @@ BOOL LLFloaterIMPanel::postBuild() LLAvatarNameCache::get(mOtherParticipantUUID, boost::bind(&LLFloaterIMPanel::onAvatarNameLookup, this, _2)); mInputEditor = getChild("chat_editor"); + mInputEditor->setAutoreplaceCallback(boost::bind(&LLAutoReplace::autoreplaceCallback, LLAutoReplace::getInstance(), _1, _2, _3, _4, _5)); mInputEditor->setFocusReceivedCallback( boost::bind(&LLFloaterIMPanel::onInputEditorFocusReceived, this) ); mFocusLostSignal = mInputEditor->setFocusLostCallback(boost::bind(&LLFloaterIMPanel::setTyping, this, false)); mInputEditor->setKeystrokeCallback( boost::bind(&LLFloaterIMPanel::onInputEditorKeystroke, this, _1) ); @@ -969,7 +971,7 @@ void copy_profile_uri(const LLUUID& id, bool group = false); void LLFloaterIMPanel::onFlyoutCommit(LLComboBox* flyout, const LLSD& value) { - if (value.isUndefined()) + if (value.isUndefined() || value.asInteger() == 0) { LLAvatarActions::showProfile(mOtherParticipantUUID); return; diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp index 4d4e7ce8f..4b2466f89 100644 --- a/indra/newview/llinventorymodel.cpp +++ b/indra/newview/llinventorymodel.cpp @@ -2112,25 +2112,6 @@ bool LLInventoryModel::loadSkeleton( return rv; } -//OGPX crap. Since this function is actually functionally the same as its LLSD variant.. -// just convert options_t to LLSD and route to the LLSD version. Yuck. -bool LLInventoryModel::loadSkeleton( - const LLInventoryModel::options_t& options, - const LLUUID& owner_id) -{ - LLSD options_list; - for(options_t::const_iterator it = options.begin(); it < options.end(); ++it) - { - LLSD entry; - for(response_t::const_iterator it2 = it->begin(); it2 != it->end(); ++it2) - { - entry[it2->first]=it2->second; - } - options_list.append(entry); - } - return loadSkeleton(options_list,owner_id); -} - // This is a brute force method to rebuild the entire parent-child // relations. The overall operation has O(NlogN) performance, which // should be sufficient for our needs. diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h index 09a85ba5d..259b08f87 100644 --- a/indra/newview/llinventorymodel.h +++ b/indra/newview/llinventorymodel.h @@ -409,14 +409,6 @@ public: void addCategory(LLViewerInventoryCategory* category); void addItem(LLViewerInventoryItem* item); - // methods to load up inventory skeleton & meat. These are used - // during authentication. return true if everything parsed. - typedef std::map response_t; - typedef std::vector options_t; - - - //OGPX really screwed with the login process. This is needed until it's all sorted out. - bool loadSkeleton(const options_t& options, const LLUUID& owner_id); /** Mutators ** ** *******************************************************************************/ diff --git a/indra/newview/llmenucommands.cpp b/indra/newview/llmenucommands.cpp index a8eca6107..f00089379 100644 --- a/indra/newview/llmenucommands.cpp +++ b/indra/newview/llmenucommands.cpp @@ -46,6 +46,7 @@ #include "llfasttimerview.h" #include "llfloaterabout.h" #include "llfloateractivespeakers.h" +#include "llfloaterautoreplacesettings.h" #include "llfloateravatarlist.h" #include "llfloaterbeacons.h" #include "llfloaterblacklist.h" @@ -219,6 +220,7 @@ struct MenuFloaterDict : public LLSingleton registerFloater ("about region"); registerFloater ("active speakers"); registerFloater ("areasearch"); + registerFloater ("autoreplace"); registerFloater ("beacons"); registerFloater ("camera controls"); registerFloater ("chat history"); diff --git a/indra/newview/llpanellogin.cpp b/indra/newview/llpanellogin.cpp index a219868d3..addf34a04 100644 --- a/indra/newview/llpanellogin.cpp +++ b/indra/newview/llpanellogin.cpp @@ -62,7 +62,6 @@ #include "llui.h" #include "lluiconstants.h" #include "llurlhistory.h" // OGPX : regionuri text box has a history of region uris (if FN/LN are loaded at startup) -#include "llviewerbuild.h" #include "llviewertexturelist.h" #include "llviewermenu.h" // for handle_preferences() #include "llviewernetwork.h" @@ -254,7 +253,7 @@ LLPanelLogin::LLPanelLogin(const LLRect& rect) gVersionMajor, gVersionMinor, gVersionPatch, - LL_VIEWER_BUILD ); + gVersionBuild ); LLTextBox* channel_text = getChild("channel_text"); channel_text->setTextArg("[CHANNEL]", channel); // though not displayed channel_text->setTextArg("[VERSION]", version); diff --git a/indra/newview/lltoolbar.cpp b/indra/newview/lltoolbar.cpp index f924b93c2..5612088d8 100644 --- a/indra/newview/lltoolbar.cpp +++ b/indra/newview/lltoolbar.cpp @@ -58,24 +58,30 @@ #if LL_DARWIN - #include "llresizehandle.h" - #include "llviewerwindow.h" +#include "llresizehandle.h" +#include "llviewerwindow.h" - // This class draws like an LLResizeHandle but has no interactivity. - // It's just there to provide a cue to the user that the lower right corner of the window functions as a resize handle. - class LLFakeResizeHandle : public LLResizeHandle +// This class draws like an LLResizeHandle but has no interactivity. +// It's just there to provide a cue to the user that the lower right corner of the window functions as a resize handle. +class LLFakeResizeHandle : public LLResizeHandle +{ +public: + LLFakeResizeHandle(const LLResizeHandle::Params& p) : LLResizeHandle(p) {} + + virtual BOOL handleHover(S32 x, S32 y, MASK mask) { return false; } + virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask) { return false; } + virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask) { return false; } + virtual void reshape(S32 width, S32 height, BOOL called_from_parent) { - public: - LLFakeResizeHandle(const LLResizeHandle::Params& p) - : LLResizeHandle(p) - { - } + // Only when running in windowed mode on the Mac, leave room for a resize widget on the right edge of the bar. + if (gViewerWindow->getWindow()->getFullscreen()) + return setVisible(false); - virtual BOOL handleHover(S32 x, S32 y, MASK mask) { return FALSE; }; - virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask) { return FALSE; }; - virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask) { return FALSE; }; - - }; + setVisible(true); + const F32 wide(gViewerWindow->getWindowWidth() + 2); + setRect(LLRect(wide - RESIZE_HANDLE_WIDTH, RESIZE_HANDLE_HEIGHT, wide, 0)); + } +}; #endif // LL_DARWIN @@ -98,9 +104,6 @@ void show_floater(const std::string& floater_name); LLToolBar::LLToolBar() : LLLayoutPanel() -#if LL_DARWIN - , mResizeHandle(NULL) -#endif // LL_DARWIN { setIsChrome(TRUE); setFocusRoot(TRUE); @@ -130,22 +133,16 @@ BOOL LLToolBar::postBuild() } #if LL_DARWIN - if(mResizeHandle == NULL) - { - LLResizeHandle::Params p; - p.rect(LLRect(0, 0, RESIZE_HANDLE_WIDTH, RESIZE_HANDLE_HEIGHT)); - p.name(std::string("")); - p.min_width(RESIZE_HANDLE_WIDTH); - p.min_height(RESIZE_HANDLE_HEIGHT); - p.corner(LLResizeHandle::RIGHT_BOTTOM); - mResizeHandle = new LLFakeResizeHandle(p); this->addChildInBack(mResizeHandle); - LLLayoutStack* toolbar_stack = getChild("toolbar_stack"); - toolbar_stack->reshape(toolbar_stack->getRect().getWidth() - RESIZE_HANDLE_WIDTH, toolbar_stack->getRect().getHeight()); - } + LLResizeHandle::Params p; + p.rect(LLRect(0, 0, RESIZE_HANDLE_WIDTH, RESIZE_HANDLE_HEIGHT)); + p.name(std::string("")); + p.min_width(RESIZE_HANDLE_WIDTH); + p.min_height(RESIZE_HANDLE_HEIGHT); + p.corner(LLResizeHandle::RIGHT_BOTTOM); + addChildInBack(new LLFakeResizeHandle(p)); + reshape(getRect().getWidth(), getRect().getHeight()); #endif // LL_DARWIN - layoutButtons(); - return TRUE; } @@ -161,18 +158,18 @@ BOOL LLToolBar::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, EAcceptance* accept, std::string& tooltip_msg) { - LLButton* inventory_btn = getChild("inventory_btn"); + LLButton* inventory_btn = mInventoryBtn; if (!inventory_btn || !inventory_btn->getVisible()) return FALSE; LLInventoryView* active_inventory = LLInventoryView::getActiveInventory(); if (active_inventory && active_inventory->getVisible()) { - mInventoryAutoOpen = FALSE; + mInventoryAutoOpenTimer.stop(); } else if (inventory_btn->getRect().pointInRect(x, y)) { - if (mInventoryAutoOpen) + if (mInventoryAutoOpenTimer.getStarted()) { if (!(active_inventory && active_inventory->getVisible()) && mInventoryAutoOpenTimer.getElapsedTimeF32() > sInventoryAutoOpenTime) @@ -182,71 +179,35 @@ BOOL LLToolBar::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, } else { - mInventoryAutoOpen = TRUE; - mInventoryAutoOpenTimer.reset(); + mInventoryAutoOpenTimer.start(); } } return LLPanel::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg); } -void LLToolBar::layoutButtons() -{ -#if LL_DARWIN - const S32 FUDGE_WIDTH_OF_SCREEN = 4; - S32 width = gViewerWindow->getWindowWidth() + FUDGE_WIDTH_OF_SCREEN; - S32 pad = 2; - - // this function may be called before postBuild(), in which case mResizeHandle won't have been set up yet. - if(mResizeHandle != NULL) - { - if(!gViewerWindow->getWindow()->getFullscreen()) - { - // Only when running in windowed mode on the Mac, leave room for a resize widget on the right edge of the bar. - width -= RESIZE_HANDLE_WIDTH; - - LLRect r; - r.mLeft = width - pad; - r.mBottom = 0; - r.mRight = r.mLeft + RESIZE_HANDLE_WIDTH; - r.mTop = r.mBottom + RESIZE_HANDLE_HEIGHT; - mResizeHandle->setRect(r); - mResizeHandle->setVisible(TRUE); - } - else - { - mResizeHandle->setVisible(FALSE); - } - } -#endif // LL_DARWIN -} - - -// virtual -void LLToolBar::reshape(S32 width, S32 height, BOOL called_from_parent) -{ - LLPanel::reshape(width, height, called_from_parent); - - layoutButtons(); -} - // Per-frame updates of visibility void LLToolBar::refresh() { - if(!isAgentAvatarValid()) - return; + static const LLCachedControl show_toolbar("ShowToolBar", true); + bool show = show_toolbar; + if (show && gAgentCamera.cameraMouselook()) + { + static const LLCachedControl hidden("LiruMouselookHidesToolbar"); + show = !hidden; + } + setVisible(show); + if (!show) return; // Everything below this point manipulates visible UI, anyway - static LLCachedControl show("ShowToolBar", true); - BOOL mouselook = gAgentCamera.cameraMouselook(); - setVisible(show && !mouselook); + updateCommunicateList(); - static LLCachedControl continue_flying_on_unsit("LiruContinueFlyingOnUnsit"); - bool sitting = !continue_flying_on_unsit && gAgentAvatarp && gAgentAvatarp->isSitting(); + if (!isAgentAvatarValid()) return; - mFlyBtn->setEnabled((gAgent.canFly() || gAgent.getFlying()) && !sitting ); - static LLCachedControl ascent_build_always_enabled("AscentBuildAlwaysEnabled", true); - mBuildBtn->setEnabled((LLViewerParcelMgr::getInstance()->allowAgentBuild() || ascent_build_always_enabled)); + static const LLCachedControl continue_flying_on_unsit("LiruContinueFlyingOnUnsit"); + mFlyBtn->setEnabled((gAgent.canFly() || gAgent.getFlying()) && (continue_flying_on_unsit || !gAgentAvatarp->isSitting())); + static const LLCachedControl ascent_build_always_enabled("AscentBuildAlwaysEnabled", true); + mBuildBtn->setEnabled(ascent_build_always_enabled || LLViewerParcelMgr::getInstance()->allowAgentBuild()); // Check to see if we're in build mode // And not just clicking on a scripted object @@ -268,11 +229,6 @@ void LLToolBar::refresh() mInventoryBtn->setEnabled(!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWINV)); } // [/RLVa:KB] - - if (isInVisibleChain() && mCommunicateBtn->getVisible()) - { - updateCommunicateList(); - } } void bold_if_equal(const LLFloater* f1, const LLFloater* f2, LLScrollListItem* itemp) @@ -283,11 +239,13 @@ void bold_if_equal(const LLFloater* f1, const LLFloater* f2, LLScrollListItem* i void LLToolBar::updateCommunicateList() { + if (!mCommunicateBtn->getVisible()) return; + LLSD selected = mCommunicateBtn->getValue(); mCommunicateBtn->removeall(); - LLFloater* frontmost_floater = LLFloaterChatterBox::getInstance()->getActiveFloater(); + const LLFloater* frontmost_floater = LLFloaterChatterBox::getInstance()->getActiveFloater(); bold_if_equal(LLFloaterMyFriends::getInstance(), frontmost_floater, mCommunicateBtn->add(LLFloaterMyFriends::getInstance()->getShortTitle(), LLSD("contacts"), ADD_TOP)); bold_if_equal(LLFloaterChat::getInstance(), frontmost_floater, mCommunicateBtn->add(LLFloaterChat::getInstance()->getShortTitle(), LLSD("local chat"), ADD_TOP)); mCommunicateBtn->addSeparator(ADD_TOP); @@ -300,11 +258,11 @@ void LLToolBar::updateCommunicateList() { if (LLFloaterIMPanel* im_floaterp = (LLFloaterIMPanel*)floater_handle_it->get()) { - S32 count = im_floaterp->getNumUnreadMessages(); + const S32 count = im_floaterp->getNumUnreadMessages(); std::string floater_title; if (count > 0) floater_title = "*"; floater_title.append(im_floaterp->getShortTitle()); - static LLCachedControl show_counts("ShowUnreadIMsCounts", true); + static const LLCachedControl show_counts("ShowUnreadIMsCounts", true); if (show_counts && count > 0) { floater_title += " - "; @@ -323,7 +281,8 @@ void LLToolBar::updateCommunicateList() } } - mCommunicateBtn->setToggleState(gSavedSettings.getBOOL("ShowCommunicate")); + static const LLCachedControl show_comm("ShowCommunicate", true); + mCommunicateBtn->setToggleState(show_comm); if (!selected.isUndefined()) mCommunicateBtn->setValue(selected); } diff --git a/indra/newview/lltoolbar.h b/indra/newview/lltoolbar.h index 23307a78b..958c0b4bc 100644 --- a/indra/newview/lltoolbar.h +++ b/indra/newview/lltoolbar.h @@ -41,10 +41,6 @@ // "Constants" loaded from settings.xml at start time extern S32 TOOL_BAR_HEIGHT; -#if LL_DARWIN - class LLFakeResizeHandle; -#endif // LL_DARWIN - class LLFlyoutButton; class LLToolBar @@ -62,11 +58,6 @@ public: EAcceptance* accept, std::string& tooltip_msg); - /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE); - - // Move buttons to appropriate locations based on rect. - void layoutButtons(); - // Per-frame refresh call void refresh(); @@ -79,12 +70,8 @@ private: void updateCommunicateList(); private: - BOOL mInventoryAutoOpen; LLFrameTimer mInventoryAutoOpenTimer; S32 mNumUnreadIMs; -#if LL_DARWIN - LLFakeResizeHandle *mResizeHandle; -#endif // LL_DARWIN CachedUICtrl mCommunicateBtn; CachedUICtrl mFlyBtn; diff --git a/indra/newview/llurlhistory.cpp b/indra/newview/llurlhistory.cpp index 876ce02d4..57fc7e3f8 100644 --- a/indra/newview/llurlhistory.cpp +++ b/indra/newview/llurlhistory.cpp @@ -106,39 +106,6 @@ LLSD LLURLHistory::getURLHistory(const std::string& collection) return LLSD(); } -// OGPX : static function that appends unique values to existing collection. -// returns true if appended, else false. -BOOL LLURLHistory::appendToURLCollection(const std::string& collection, const std::string& url) -{ - if (!url.empty()) - { - BOOL found_current_url = FALSE; - // make room for the new url if needed - // always append to the end and remove from the front so you have the most recent. - if (sHistorySD[collection].size() >= MAX_URL_COUNT) - { - sHistorySD[collection].erase(0); - } - - LLSD::array_iterator iter_history = sHistorySD[collection].beginArray(); - LLSD::array_iterator iter_end = sHistorySD[collection].endArray(); - for (; iter_history != iter_end; ++iter_history) - { - if ((*iter_history).asString() == url) - { - found_current_url = TRUE; - } - } - if (!found_current_url ) - { - sHistorySD[collection].append(LLSD(url)); - LLURLHistory::limitSize(collection); - //llinfos << " appending XX" << url << "XX urlcollection: " << LLSDOStreamer(sHistorySD) << llendl; - return TRUE; // value was unique, needed to be inserted - } - } - return FALSE; // value was empty or already in the collection -} // static void LLURLHistory::addURL(const std::string& collection, const std::string& url) { diff --git a/indra/newview/llurlhistory.h b/indra/newview/llurlhistory.h index 1c7e6637c..2b9d41429 100644 --- a/indra/newview/llurlhistory.h +++ b/indra/newview/llurlhistory.h @@ -49,9 +49,6 @@ public: static LLSD getURLHistory(const std::string& collection); static void addURL(const std::string& collection, const std::string& url); - // OGPX appends url to a collection if it doesn't already exist in the collection. - // this is used in the collection of region URIs that are saved per region - static BOOL appendToURLCollection(const std::string& collection, const std::string& url); static void removeURL(const std::string& collection, const std::string& url); static void clear(const std::string& collection); diff --git a/indra/newview/lluserauth.cpp b/indra/newview/lluserauth.cpp index c2f00bb68..21e9835ea 100644 --- a/indra/newview/lluserauth.cpp +++ b/indra/newview/lluserauth.cpp @@ -40,7 +40,6 @@ #include "lldir.h" #include "sgversion.h" #include "llappviewer.h" -#include "llviewerbuild.h" #include "llviewercontrol.h" #include "llxmlrpcresponder.h" #include "llsdutil.h" diff --git a/indra/newview/llviewerbuild.h b/indra/newview/llviewerbuild.h deleted file mode 100644 index b02bdece5..000000000 --- a/indra/newview/llviewerbuild.h +++ /dev/null @@ -1,37 +0,0 @@ -/** - * @file llviewerbuild.h - * @brief Sets viewer build number - * - * $LicenseInfo:firstyear=2001&license=viewergpl$ - * - * Copyright (c) 2001-2009, Linden Research, Inc. - * - * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 - * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at - * http://secondlifegrid.net/programs/open_source/licensing/flossexception - * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. - * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. - * $/LicenseInfo$ - */ - -#include "sgversion.h" - -// Set the build number in indra/llcommon/llversionviewer.h! - -const S32 LL_VIEWER_BUILD = gVersionBuild; diff --git a/indra/newview/llviewerobject.h b/indra/newview/llviewerobject.h index 2aa0e3869..21003bcb1 100644 --- a/indra/newview/llviewerobject.h +++ b/indra/newview/llviewerobject.h @@ -514,6 +514,7 @@ public: inline BOOL flagCameraSource() const { return ((mFlags & FLAGS_CAMERA_SOURCE) != 0); } inline BOOL flagCameraDecoupled() const { return ((mFlags & FLAGS_CAMERA_DECOUPLED) != 0); } + inline bool getPhysicsShapeUnknown() const { return mPhysicsShapeUnknown; } U8 getPhysicsShapeType() const; inline F32 getPhysicsGravity() const { return mPhysicsGravity; } inline F32 getPhysicsFriction() const { return mPhysicsFriction; } diff --git a/indra/newview/llviewerobjectbackup.cpp b/indra/newview/llviewerobjectbackup.cpp index b93cd6b2c..2a426c3ee 100644 --- a/indra/newview/llviewerobjectbackup.cpp +++ b/indra/newview/llviewerobjectbackup.cpp @@ -641,14 +641,30 @@ LLSD LLObjectBackup::primsToLLSD(LLViewerObject::child_list_t child_list, bool i prim_llsd["scale"] = object->getScale().getValue(); // Flags - prim_llsd["shadows"] = FALSE; - prim_llsd["phantom"] = object->flagPhantom(); - prim_llsd["physical"] = object->flagUsePhysics(); + prim_llsd["flags"] = (S32)object->getFlags(); // Volume params LLVolumeParams params = object->getVolume()->getParams(); prim_llsd["volume"] = params.asLLSD(); + // Material + prim_llsd["material"] = object->getMaterial(); + + // Click Action + if (S32 action = object->getClickAction()) // Non-zero + prim_llsd["clickaction"] = action; + + // Physics + if (!object->getPhysicsShapeUnknown()) + { + LLSD& physics = prim_llsd["ExtraPhysics"]; + physics["PhysicsShapeType"] = object->getPhysicsShapeType(); + physics["Density"] = object->getPhysicsDensity(); + physics["Friction"] = object->getPhysicsFriction(); + physics["GravityMultiplier"] = object->getPhysicsGravity(); + physics["Restitution"] = object->getPhysicsRestitution(); + } + // Extra paramsb6fab961-af18-77f8-cf08-f021377a7244 if (object->isFlexible()) { @@ -662,6 +678,12 @@ LLSD LLObjectBackup::primsToLLSD(LLViewerObject::child_list_t child_list, bool i LLLightParams* light = (LLLightParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT); prim_llsd["light"] = light->asLLSD(); } + if (object->getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE)) + { + // Light Texture + LLLightImageParams* light_texture = (LLLightImageParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE); + prim_llsd["light_texture"] = light_texture->asLLSD(); + } if (object->getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT)) { // Sculpt @@ -714,7 +736,10 @@ LLSD LLObjectBackup::primsToLLSD(LLViewerObject::child_list_t child_list, bool i for (iter = mTexturesList.begin(); iter != mTexturesList.end(); iter++) { if ((*iter) == t_id) + { alreadyseen = true; + break; + } } if (alreadyseen == false) mTexturesList.push_back(t_id); @@ -871,7 +896,7 @@ void LLObjectBackup::importObject_continued(AIFilePicker* filepicker) } } - LLSD te_llsd = prim_llsd["textures"]; + LLSD& te_llsd = prim_llsd.has("textures") ? prim_llsd["textures"] : prim_llsd["texture"]; // Firestorm's format uses singular "texture" for (text_it = te_llsd.beginArray(); text_it != te_llsd.endArray(); text_it++) { @@ -968,6 +993,16 @@ void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object) LLSelectMgr::getInstance()->selectionSetObjectDescription(prim_llsd["description"]); } + if (prim_llsd.has("material")) + { + LLSelectMgr::getInstance()->selectionSetMaterial(prim_llsd["material"].asInteger()); + } + + if (prim_llsd.has("clickaction")) + { + LLSelectMgr::getInstance()->selectionSetClickAction(prim_llsd["clickaction"].asInteger()); + } + if (prim_llsd.has("parent")) { //we are not the root node. @@ -985,6 +1020,13 @@ void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object) object->setScale(prim_llsd["scale"]); + if (prim_llsd.has("flags")) + { + U32 flags(prim_llsd["flags"].asInteger()); + object->setFlags(flags, true); + } + else // Legacy + { /*if (prim_llsd.has("shadows")) if (prim_llsd["shadows"].asInteger() == 1) object->setFlags(FLAGS_CAST_SHADOWS, true);*/ @@ -996,6 +1038,18 @@ void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object) if (prim_llsd.has("physical")) if (prim_llsd["physical"].asInteger() == 1) object->setFlags(FLAGS_USE_PHYSICS, true); + } + + if (prim_llsd.has("ExtraPhysics")) + { + const LLSD& physics = prim_llsd["ExtraPhysics"]; + object->setPhysicsShapeType(physics["PhysicsShapeType"].asInteger()); + object->setPhysicsDensity(physics["Density"].asFloat()); + object->setPhysicsFriction(physics["Friction"].asFloat()); + object->setPhysicsGravity(physics["GravityMultiplier"].asFloat()); + object->setPhysicsRestitution(physics["Restitution"].asFloat()); + object->updateFlags(true); + } // Volume params LLVolumeParams volume_params = object->getVolume()->getParams(); @@ -1025,6 +1079,14 @@ void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object) object->setParameterEntry(LLNetworkData::PARAMS_LIGHT, light, true); } + if (prim_llsd.has("light_texture")) + { + // Light Texture + LLLightImageParams light_texture; + light_texture.fromLLSD(prim_llsd["light_texture"]); + object->setParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE, light_texture, true); + } + if (prim_llsd.has("flexible")) { LLFlexibleObjectData flex; @@ -1034,7 +1096,7 @@ void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object) // Textures LL_INFOS("ObjectBackup") << "Processing textures for prim" << LL_ENDL; - LLSD te_llsd = prim_llsd["textures"]; + LLSD& te_llsd = prim_llsd.has("textures") ? prim_llsd["textures"] : prim_llsd["texture"]; // Firestorm's format uses singular "texture" LLSD::array_iterator text_it; U8 i = 0; diff --git a/indra/newview/llviewerobjectbackup.h b/indra/newview/llviewerobjectbackup.h index 27ae4f2f9..ddf4f021f 100644 --- a/indra/newview/llviewerobjectbackup.h +++ b/indra/newview/llviewerobjectbackup.h @@ -27,6 +27,9 @@ * $/LicenseInfo$ */ +#ifndef LL_LLVIEWEROBJECTBACKUP_H +#define LL_LLVIEWEROBJECTBACKUP_H + #include "llviewerinventory.h" enum export_states { @@ -179,3 +182,4 @@ private: LLQuaternion mAgentRot; }; +#endif \ No newline at end of file diff --git a/indra/newview/llwlhandlers.h b/indra/newview/llwlhandlers.h index 969e188b6..cba1088f2 100644 --- a/indra/newview/llwlhandlers.h +++ b/indra/newview/llwlhandlers.h @@ -33,7 +33,6 @@ #ifndef LL_LLWLHANDLERS_H #define LL_LLWLHANDLERS_H -#include "llviewerprecompiledheaders.h" #include "llhttpclient.h" class AIHTTPTimeoutPolicy; diff --git a/indra/newview/shfloatermediaticker.h b/indra/newview/shfloatermediaticker.h index 4668f33bd..e5d1b968a 100644 --- a/indra/newview/shfloatermediaticker.h +++ b/indra/newview/shfloatermediaticker.h @@ -1,3 +1,6 @@ +#ifndef SH_SHFLOATERMEDIATICKER_H +#define SH_SHFLOATERMEDIATICKER_H + #include "llfloater.h" class LLIconCtrl; @@ -56,3 +59,4 @@ private: BOOL handle_ticker_enabled(void *); void handle_ticker_toggle(void *); +#endif diff --git a/indra/newview/skins/default/textures/icn_toolbar_auto_replace.tga b/indra/newview/skins/default/textures/icn_toolbar_auto_replace.tga new file mode 100644 index 000000000..0a1a235f3 Binary files /dev/null and b/indra/newview/skins/default/textures/icn_toolbar_auto_replace.tga differ diff --git a/indra/newview/skins/default/xui/de/floater_autoreplace.xml b/indra/newview/skins/default/xui/de/floater_autoreplace.xml new file mode 100644 index 000000000..a9b6aaabb --- /dev/null +++ b/indra/newview/skins/default/xui/de/floater_autoreplace.xml @@ -0,0 +1,32 @@ + + + + + + +