livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main' into DRTVWR-559

master
Brad Linden 2023-02-02 12:11:40 -08:00
parent 627e3d51c6 8d21d29bd7
commit 5fabfa50d7
169 changed files with 3325 additions and 2151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
autobuild.xml
View File

@ -52,9 +52,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>b6357ef3a0ec37877a5831820f25094e</string>
<string>178b16ee9ff67986c8c14413ee68218e</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/80557/759704/apr_suite-1.4.5.558565-darwin64-558565.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/107593/938535/apr_suite-1.4.5.576669-darwin64-576669.tar.bz2</string>
</map>
<key>name</key>
<string>darwin64</string>
@ -76,9 +76,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>cb48ac069440f6dcd564cfa9fd02a4c2</string>
<string>d2997cad03dbd0d70a060276b5671480</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/80556/759710/apr_suite-1.4.5.558565-windows-558565.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/107594/938548/apr_suite-1.4.5.576669-windows-576669.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>
@ -88,16 +88,16 @@
<key>archive</key>
<map>
<key>hash</key>
<string>646dc3828d9c39fb1e77c4eec44ed739</string>
<string>ec24f5945faa8f13807b83eeaeb994f8</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/80555/759709/apr_suite-1.4.5.558565-windows64-558565.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/107592/938547/apr_suite-1.4.5.576669-windows64-576669.tar.bz2</string>
</map>
<key>name</key>
<string>windows64</string>
</map>
</map>
<key>version</key>
<string>1.4.5.558565</string>
<string>1.4.5.576669</string>
</map>
<key>boost</key>
<map>
@ -1382,9 +1382,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>c1c9e32e21f3c34d91ed045b2ca91f24</string>
<string>7a0059748d0b8733f2f9ce434cf604b8</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/87781/805801/libpng-1.6.8.563850-darwin64-563850.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/107514/937867/libpng-1.6.38.576621-darwin64-576621.tar.bz2</string>
</map>
<key>name</key>
<string>darwin64</string>
@ -1406,9 +1406,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>642e9cf95c8ccd0eb34f6d7a40df585a</string>
<string>3112013186ad60b0fc270a398d4dd499</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/87782/805831/libpng-1.6.8.563850-windows-563850.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/107513/937823/libpng-1.6.38.576621-windows-576621.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>
@ -1418,16 +1418,16 @@
<key>archive</key>
<map>
<key>hash</key>
<string>ce46aa0f171d97626c4a3940347cecd7</string>
<string>7c6bfcdb0d6162587cdbc436f595dd02</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/87780/805832/libpng-1.6.8.563850-windows64-563850.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/107512/937822/libpng-1.6.38.576621-windows64-576621.tar.bz2</string>
</map>
<key>name</key>
<string>windows64</string>
</map>
</map>
<key>version</key>
<string>1.6.8.563850</string>
<string>1.6.38.576621</string>
</map>
<key>libuuid</key>
<map>
@ -2215,9 +2215,9 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>archive</key>
<map>
<key>hash</key>
<string>5abf2d9c0b250821c59cc60cd94fd8af</string>
<string>8114c6a7e499ea20d325db0de08ce30a</string>
<key>url</key>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/54840/510064/openjpeg-1.5.1.538970-darwin64-538970.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/105469/923024/openjpeg-2.5.0.575496-darwin64-575496.tar.bz2</string>
</map>
<key>name</key>
<string>darwin64</string>
@ -2239,9 +2239,9 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>archive</key>
<map>
<key>hash</key>
<string>222a406ecb4071a9cc9635353afa337e</string>
<string>edc9388870d951632a6d595792293e05</string>
<key>url</key>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/54977/511775/openjpeg-1.5.1.538970-windows-538970.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/105472/923036/openjpeg-2.5.0.575496-windows-575496.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>
@ -2251,16 +2251,16 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>archive</key>
<map>
<key>hash</key>
<string>5b5c80807fa8161f3480be3d89fe9516</string>
<string>b95f0732f2388ebb0ddf33d4a30e0ff1</string>
<key>url</key>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/54974/511767/openjpeg-1.5.1.538970-windows64-538970.tar.bz2</string>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/105471/923037/openjpeg-2.5.0.575496-windows64-575496.tar.bz2</string>
</map>
<key>name</key>
<string>windows64</string>
</map>
</map>
<key>version</key>
<string>1.5.1.538970</string>
<string>2.5.0.575496</string>
</map>
<key>openssl</key>
<map>

11
doc/contributions.txt
View File

@ -282,6 +282,7 @@ Beq Janus
SL-11300
SL-15709
SL-16021
SL-18592
SL-18637
Beth Walcher
Bezilon Kasei
@ -373,6 +374,7 @@ Charlie Sazaland
Chaser Zaks
BUG-225599
BUG-227485
SL-16874
Cherry Cheevers
ChickyBabes Zuzu
Chorazin Allen
@ -1383,6 +1385,7 @@ Sovereign Engineer
OPEN-343
SL-11625
BUG-229030
SL-14696
SL-14705
SL-14706
SL-14707
@ -1390,6 +1393,12 @@ Sovereign Engineer
SL-14732
SL-15096
SL-16127
SL-18249
SL-18394
SL-18412
SL-18497
SL-18525
SL-18534
SpacedOut Frye
VWR-34
VWR-45
@ -1652,6 +1661,8 @@ Zi Ree
VWR-25588
STORM-1790
STORM-1842
SL-18348
SL-18593
Zipherius Turas
VWR-76
VWR-77

4
indra/cmake/Copy3rdPartyLibs.cmake
View File

@ -52,7 +52,7 @@ if(WINDOWS)
set(release_src_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
set(release_files
openjpeg.dll
openjp2.dll
libapr-1.dll
libaprutil-1.dll
libapriconv-1.dll
@ -220,7 +220,7 @@ elseif(LINUX)
libgobject-2.0.so
libhunspell-1.3.so.0.0.0
libopenal.so
libopenjpeg.so
libopenjp2.so
libuuid.so.16
libuuid.so.16.0.22
libfontconfig.so.1.8.0

3
indra/cmake/FindOpenJPEG.cmake
View File

@ -14,9 +14,10 @@ FIND_PATH(OPENJPEG_INCLUDE_DIR openjpeg.h
/usr/local/include
/usr/include/openjpeg
/usr/include
include/openjpeg
)
SET(OPENJPEG_NAMES ${OPENJPEG_NAMES} openjpeg)
SET(OPENJPEG_NAMES ${OPENJPEG_NAMES} openjp2)
FIND_LIBRARY(OPENJPEG_LIBRARY
NAMES ${OPENJPEG_NAMES}
PATHS /usr/lib /usr/local/lib

14
indra/cmake/OpenJPEG.cmake
View File

@ -8,15 +8,7 @@ if (USESYSTEMLIBS)
include(FindOpenJPEG)
else (USESYSTEMLIBS)
use_prebuilt_binary(openjpeg)
if(WINDOWS)
# Windows has differently named release and debug openjpeg(d) libs.
set(OPENJPEG_LIBRARIES
debug openjpegd
optimized openjpeg)
else(WINDOWS)
set(OPENJPEG_LIBRARIES openjpeg)
endif(WINDOWS)
set(OPENJPEG_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/include/openjpeg)
set(OPENJPEG_LIBRARIES openjp2)
set(OPENJPEG_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/include/openjpeg)
endif (USESYSTEMLIBS)

4
indra/integration_tests/llui_libtest/CMakeLists.txt
View File

@ -99,14 +99,14 @@ if (WINDOWS)
# Copy over OpenJPEG.dll
# *NOTE: On Windows with VS2005, only the first comment prints
set(OPENJPEG_RELEASE
"${ARCH_PREBUILT_DIRS_RELEASE}/openjpeg.dll")
"${ARCH_PREBUILT_DIRS_RELEASE}/openjp2.dll")
add_custom_command( TARGET llui_libtest POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
${OPENJPEG_RELEASE} ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Copying OpenJPEG DLLs to binary directory"
)
set(OPENJPEG_DEBUG
"${ARCH_PREBUILT_DIRS_DEBUG}/openjpegd.dll")
"${ARCH_PREBUILT_DIRS_DEBUG}/openjp2.dll")
add_custom_command( TARGET llui_libtest POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
${OPENJPEG_DEBUG} ${CMAKE_CURRENT_BINARY_DIR}

7
indra/llappearance/llavatarappearance.cpp
View File

@ -305,7 +305,12 @@ LLAvatarAppearance::~LLAvatarAppearance()
}
}
if (mRoot) mRoot->removeAllChildren();
if (mRoot)
{
mRoot->removeAllChildren();
delete mRoot;
mRoot = nullptr;
}
mJointMap.clear();
clearSkeleton();

1
indra/llappearance/lllocaltextureobject.cpp
View File

@ -76,6 +76,7 @@ LLLocalTextureObject::LLLocalTextureObject(const LLLocalTextureObject& lto) :
LLLocalTextureObject::~LLLocalTextureObject()
{
delete_and_clear(mTexLayers);
}
LLGLTexture* LLLocalTextureObject::getImage() const

185
indra/llcharacter/llkeyframemotion.cpp
View File

@ -1229,7 +1229,7 @@ void LLKeyframeMotion::applyConstraint(JointConstraint* constraint, F32 time, U8
BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, bool allow_invalid_joints)
{
BOOL old_version = FALSE;
mJointMotionList = new LLKeyframeMotion::JointMotionList;
std::unique_ptr<LLKeyframeMotion::JointMotionList> joint_motion_list(new LLKeyframeMotion::JointMotionList);
//-------------------------------------------------------------------------
// get base priority
@ -1272,16 +1272,16 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
mJointMotionList->mBasePriority = (LLJoint::JointPriority) temp_priority;
joint_motion_list->mBasePriority = (LLJoint::JointPriority) temp_priority;
if (mJointMotionList->mBasePriority >= LLJoint::ADDITIVE_PRIORITY)
if (joint_motion_list->mBasePriority >= LLJoint::ADDITIVE_PRIORITY)
{
mJointMotionList->mBasePriority = (LLJoint::JointPriority)((S32)LLJoint::ADDITIVE_PRIORITY-1);
mJointMotionList->mMaxPriority = mJointMotionList->mBasePriority;
joint_motion_list->mBasePriority = (LLJoint::JointPriority)((S32)LLJoint::ADDITIVE_PRIORITY-1);
joint_motion_list->mMaxPriority = joint_motion_list->mBasePriority;
}
else if (mJointMotionList->mBasePriority < LLJoint::USE_MOTION_PRIORITY)
else if (joint_motion_list->mBasePriority < LLJoint::USE_MOTION_PRIORITY)
{
LL_WARNS() << "bad animation base_priority " << mJointMotionList->mBasePriority
LL_WARNS() << "bad animation base_priority " << joint_motion_list->mBasePriority
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
@ -1289,15 +1289,15 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
//-------------------------------------------------------------------------
// get duration
//-------------------------------------------------------------------------
if (!dp.unpackF32(mJointMotionList->mDuration, "duration"))
if (!dp.unpackF32(joint_motion_list->mDuration, "duration"))
{
LL_WARNS() << "can't read duration"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
if (mJointMotionList->mDuration > MAX_ANIM_DURATION ||
!llfinite(mJointMotionList->mDuration))
if (joint_motion_list->mDuration > MAX_ANIM_DURATION ||
!llfinite(joint_motion_list->mDuration))
{
LL_WARNS() << "invalid animation duration"
<< " for animation " << asset_id << LL_ENDL;
@ -1307,14 +1307,14 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
//-------------------------------------------------------------------------
// get emote (optional)
//-------------------------------------------------------------------------
if (!dp.unpackString(mJointMotionList->mEmoteName, "emote_name"))
if (!dp.unpackString(joint_motion_list->mEmoteName, "emote_name"))
{
LL_WARNS() << "can't read optional_emote_animation"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
if(mJointMotionList->mEmoteName==mID.asString())
if(joint_motion_list->mEmoteName==mID.asString())
{
LL_WARNS() << "Malformed animation mEmoteName==mID"
<< " for animation " << asset_id << LL_ENDL;
@ -1324,23 +1324,23 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
//-------------------------------------------------------------------------
// get loop
//-------------------------------------------------------------------------
if (!dp.unpackF32(mJointMotionList->mLoopInPoint, "loop_in_point") ||
!llfinite(mJointMotionList->mLoopInPoint))
if (!dp.unpackF32(joint_motion_list->mLoopInPoint, "loop_in_point") ||
!llfinite(joint_motion_list->mLoopInPoint))
{
LL_WARNS() << "can't read loop point"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
if (!dp.unpackF32(mJointMotionList->mLoopOutPoint, "loop_out_point") ||
!llfinite(mJointMotionList->mLoopOutPoint))
if (!dp.unpackF32(joint_motion_list->mLoopOutPoint, "loop_out_point") ||
!llfinite(joint_motion_list->mLoopOutPoint))
{
LL_WARNS() << "can't read loop point"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
if (!dp.unpackS32(mJointMotionList->mLoop, "loop"))
if (!dp.unpackS32(joint_motion_list->mLoop, "loop"))
{
LL_WARNS() << "can't read loop"
<< " for animation " << asset_id << LL_ENDL;
@ -1353,22 +1353,22 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
if (female_land_anim == asset_id || formal_female_land_anim == asset_id)
{
LL_WARNS() << "Animation(" << asset_id << ") won't be looped." << LL_ENDL;
mJointMotionList->mLoop = FALSE;
joint_motion_list->mLoop = FALSE;
}
//-------------------------------------------------------------------------
// get easeIn and easeOut
//-------------------------------------------------------------------------
if (!dp.unpackF32(mJointMotionList->mEaseInDuration, "ease_in_duration") ||
!llfinite(mJointMotionList->mEaseInDuration))
if (!dp.unpackF32(joint_motion_list->mEaseInDuration, "ease_in_duration") ||
!llfinite(joint_motion_list->mEaseInDuration))
{
LL_WARNS() << "can't read easeIn"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
if (!dp.unpackF32(mJointMotionList->mEaseOutDuration, "ease_out_duration") ||
!llfinite(mJointMotionList->mEaseOutDuration))
if (!dp.unpackF32(joint_motion_list->mEaseOutDuration, "ease_out_duration") ||
!llfinite(joint_motion_list->mEaseOutDuration))
{
LL_WARNS() << "can't read easeOut"
<< " for animation " << asset_id << LL_ENDL;
@ -1393,7 +1393,7 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
return FALSE;
}
mJointMotionList->mHandPose = (LLHandMotion::eHandPose)word;
joint_motion_list->mHandPose = (LLHandMotion::eHandPose)word;
//-------------------------------------------------------------------------
// get number of joint motions
@ -1419,8 +1419,8 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
return FALSE;
}
mJointMotionList->mJointMotionArray.clear();
mJointMotionList->mJointMotionArray.reserve(num_motions);
joint_motion_list->mJointMotionArray.clear();
joint_motion_list->mJointMotionArray.reserve(num_motions);
mJointStates.clear();
mJointStates.reserve(num_motions);
@ -1431,7 +1431,7 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
for(U32 i=0; i<num_motions; ++i)
{
JointMotion* joint_motion = new JointMotion;
mJointMotionList->mJointMotionArray.push_back(joint_motion);
joint_motion_list->mJointMotionArray.push_back(joint_motion);
std::string joint_name;
if (!dp.unpackString(joint_name, "joint_name"))
@ -1503,9 +1503,9 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
joint_motion->mPriority = (LLJoint::JointPriority)joint_priority;
if (joint_priority != LLJoint::USE_MOTION_PRIORITY &&
joint_priority > mJointMotionList->mMaxPriority)
joint_priority > joint_motion_list->mMaxPriority)
{
mJointMotionList->mMaxPriority = (LLJoint::JointPriority)joint_priority;
joint_motion_list->mMaxPriority = (LLJoint::JointPriority)joint_priority;
}
joint_state->setPriority((LLJoint::JointPriority)joint_priority);
@ -1556,9 +1556,9 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
return FALSE;
}
time = U16_to_F32(time_short, 0.f, mJointMotionList->mDuration);
time = U16_to_F32(time_short, 0.f, joint_motion_list->mDuration);
if (time < 0 || time > mJointMotionList->mDuration)
if (time < 0 || time > joint_motion_list->mDuration)
{
LL_WARNS() << "invalid frame time"
<< " for animation " << asset_id << LL_ENDL;
@ -1571,38 +1571,57 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
LLVector3 rot_angles;
U16 x, y, z;
BOOL success = TRUE;
if (old_version)
{
success = dp.unpackVector3(rot_angles, "rot_angles") && rot_angles.isFinite();
if (!dp.unpackVector3(rot_angles, "rot_angles"))
{
LL_WARNS() << "can't read rot_angles in rotation key (" << k << ")" << LL_ENDL;
return FALSE;
}
if (!rot_angles.isFinite())
{
LL_WARNS() << "non-finite angle in rotation key (" << k << ")" << LL_ENDL;
return FALSE;
}
LLQuaternion::Order ro = StringToOrder("ZYX");
rot_key.mRotation = mayaQ(rot_angles.mV[VX], rot_angles.mV[VY], rot_angles.mV[VZ], ro);
}
else
{
success &= dp.unpackU16(x, "rot_angle_x");
success &= dp.unpackU16(y, "rot_angle_y");
success &= dp.unpackU16(z, "rot_angle_z");
if (!dp.unpackU16(x, "rot_angle_x"))
{
LL_WARNS() << "can't read rot_angle_x in rotation key (" << k << ")" << LL_ENDL;
return FALSE;
}
if (!dp.unpackU16(y, "rot_angle_y"))
{
LL_WARNS() << "can't read rot_angle_y in rotation key (" << k << ")" << LL_ENDL;
return FALSE;
}
if (!dp.unpackU16(z, "rot_angle_z"))
{
LL_WARNS() << "can't read rot_angle_z in rotation key (" << k << ")" << LL_ENDL;
return FALSE;
}
LLVector3 rot_vec;
rot_vec.mV[VX] = U16_to_F32(x, -1.f, 1.f);
rot_vec.mV[VY] = U16_to_F32(y, -1.f, 1.f);
rot_vec.mV[VZ] = U16_to_F32(z, -1.f, 1.f);
if(!rot_vec.isFinite())
{
LL_WARNS() << "non-finite angle in rotation key (" << k << ")"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
rot_key.mRotation.unpackFromVector3(rot_vec);
}
if( !(rot_key.mRotation.isFinite()) )
if(!rot_key.mRotation.isFinite())
{
LL_WARNS() << "non-finite angle in rotation key"
<< " for animation " << asset_id << LL_ENDL;
success = FALSE;
}
if (!success)
{
LL_WARNS() << "can't read rotation key (" << k << ")"
LL_WARNS() << "non-finite angle in rotation key (" << k << ")"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
@ -1655,14 +1674,16 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
return FALSE;
}
pos_key.mTime = U16_to_F32(time_short, 0.f, mJointMotionList->mDuration);
pos_key.mTime = U16_to_F32(time_short, 0.f, joint_motion_list->mDuration);
}
BOOL success = TRUE;
if (old_version)
{
success = dp.unpackVector3(pos_key.mPosition, "pos");
if (!dp.unpackVector3(pos_key.mPosition, "pos"))
{
LL_WARNS() << "can't read pos in position key (" << k << ")" << LL_ENDL;
return FALSE;
}
//MAINT-6162
pos_key.mPosition.mV[VX] = llclamp( pos_key.mPosition.mV[VX], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
@ -1674,25 +1695,30 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
U16 x, y, z;
success &= dp.unpackU16(x, "pos_x");
success &= dp.unpackU16(y, "pos_y");
success &= dp.unpackU16(z, "pos_z");
if (!dp.unpackU16(x, "pos_x"))
{
LL_WARNS() << "can't read pos_x in position key (" << k << ")" << LL_ENDL;
return FALSE;
}
if (!dp.unpackU16(y, "pos_y"))
{
LL_WARNS() << "can't read pos_y in position key (" << k << ")" << LL_ENDL;
return FALSE;
}
if (!dp.unpackU16(z, "pos_z"))
{
LL_WARNS() << "can't read pos_z in position key (" << k << ")" << LL_ENDL;
return FALSE;
}
pos_key.mPosition.mV[VX] = U16_to_F32(x, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
pos_key.mPosition.mV[VY] = U16_to_F32(y, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
pos_key.mPosition.mV[VZ] = U16_to_F32(z, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
}
if( !(pos_key.mPosition.isFinite()) )
if(!pos_key.mPosition.isFinite())
{
LL_WARNS() << "non-finite position in key"
<< " for animation " << asset_id << LL_ENDL;
success = FALSE;
}
if (!success)
{
LL_WARNS() << "can't read position key (" << k << ")"
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
@ -1701,7 +1727,7 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
if (is_pelvis)
{
mJointMotionList->mPelvisBBox.addPoint(pos_key.mPosition);
joint_motion_list->mPelvisBBox.addPoint(pos_key.mPosition);
}
}
@ -1733,23 +1759,21 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
for(S32 i = 0; i < num_constraints; ++i)
{
// read in constraint data
JointConstraintSharedData* constraintp = new JointConstraintSharedData;
std::unique_ptr<JointConstraintSharedData> constraintp(new JointConstraintSharedData);
U8 byte = 0;
if (!dp.unpackU8(byte, "chain_length"))
{
LL_WARNS() << "can't read constraint chain length"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
constraintp->mChainLength = (S32) byte;
if((U32)constraintp->mChainLength > mJointMotionList->getNumJointMotions())
if((U32)constraintp->mChainLength > joint_motion_list->getNumJointMotions())
{
LL_WARNS() << "invalid constraint chain length"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1757,7 +1781,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint type"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1765,7 +1788,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "invalid constraint type"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
constraintp->mConstraintType = (EConstraintType)byte;
@ -1776,7 +1798,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read source volume name"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1787,7 +1808,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "not a valid source constraint volume " << str
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1795,7 +1815,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint source offset"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1803,7 +1822,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "non-finite constraint source offset"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1811,7 +1829,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read target volume name"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1830,7 +1847,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "not a valid target constraint volume " << str
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
}
@ -1839,7 +1855,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint target offset"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1847,7 +1862,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "non-finite constraint target offset"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1855,7 +1869,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint target direction"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1863,7 +1876,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "non-finite constraint target direction"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1877,7 +1889,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint ease in start time"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1885,7 +1896,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint ease in stop time"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1893,7 +1903,6 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint ease out start time"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
@ -1901,33 +1910,31 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "can't read constraint ease out stop time"
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
mJointMotionList->mConstraints.push_front(constraintp);
constraintp->mJointStateIndices = new S32[constraintp->mChainLength + 1]; // note: mChainLength is size-limited - comes from a byte
LLJoint* joint = mCharacter->findCollisionVolume(constraintp->mSourceConstraintVolume);
// get joint to which this collision volume is attached
if (!joint)
{
return FALSE;
}
constraintp->mJointStateIndices = new S32[constraintp->mChainLength + 1]; // note: mChainLength is size-limited - comes from a byte
for (S32 i = 0; i < constraintp->mChainLength + 1; i++)
{
LLJoint* parent = joint->getParent();
if (!parent)
{
LL_WARNS() << "Joint with no parent: " << joint->getName()
<< " Emote: " << mJointMotionList->mEmoteName
<< " Emote: " << joint_motion_list->mEmoteName
<< " for animation " << asset_id << LL_ENDL;
return FALSE;
}
joint = parent;
constraintp->mJointStateIndices[i] = -1;
for (U32 j = 0; j < mJointMotionList->getNumJointMotions(); j++)
for (U32 j = 0; j < joint_motion_list->getNumJointMotions(); j++)
{
LLJoint* constraint_joint = getJoint(j);
@ -1948,14 +1955,16 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp, const LLUUID& asset_id, boo
{
LL_WARNS() << "No joint index for constraint " << i
<< " for animation " << asset_id << LL_ENDL;
delete constraintp;
return FALSE;
}
}
joint_motion_list->mConstraints.push_front(constraintp.release());
}
}
// *FIX: support cleanup of old keyframe data
mJointMotionList = joint_motion_list.release(); // release from unique_ptr to member;
LLKeyframeDataCache::addKeyframeData(getID(), mJointMotionList);
mAssetStatus = ASSET_LOADED;

74
indra/llcommon/llcoros.cpp
View File

@ -288,25 +288,15 @@ std::string LLCoros::launch(const std::string& prefix, const callable_t& callabl
return name;
}
namespace
{
#if LL_WINDOWS
static const U32 STATUS_MSC_EXCEPTION = 0xE06D7363; // compiler specific
U32 cpp_exception_filter(U32 code, struct _EXCEPTION_POINTERS *exception_infop, const std::string& name)
U32 exception_filter(U32 code, struct _EXCEPTION_POINTERS *exception_infop)
{
// C++ exceptions were logged in toplevelTryWrapper, but not SEH
// log SEH exceptions here, to make sure it gets into bugsplat's
// report and because __try won't allow std::string operations
if (code != STATUS_MSC_EXCEPTION)
{
LL_WARNS() << "SEH crash in " << name << ", code: " << code << LL_ENDL;
}
// Handle bugsplat here, since GetExceptionInformation() can only be
// called from within filter for __except(filter), not from __except's {}
// Bugsplat should get all exceptions, C++ and SEH
LLApp::instance()->reportCrashToBugsplat(exception_infop);
// Only convert non C++ exceptions.
if (code == STATUS_MSC_EXCEPTION)
{
// C++ exception, go on
@ -319,28 +309,38 @@ U32 cpp_exception_filter(U32 code, struct _EXCEPTION_POINTERS *exception_infop,
}
}
void LLCoros::sehHandle(const std::string& name, const LLCoros::callable_t& callable)
void sehandle(const LLCoros::callable_t& callable)
{
__try
{
LLCoros::toplevelTryWrapper(name, callable);
callable();
}
__except (cpp_exception_filter(GetExceptionCode(), GetExceptionInformation(), name))
__except (exception_filter(GetExceptionCode(), GetExceptionInformation()))
{
// convert to C++ styled exception for handlers other than bugsplat
// convert to C++ styled exception
// Note: it might be better to use _se_set_translator
// if you want exception to inherit full callstack
//
// in case of bugsplat this will get to exceptionTerminateHandler and
// looks like fiber will terminate application after that
char integer_string[512];
sprintf(integer_string, "SEH crash in %s, code: %lu\n", name.c_str(), GetExceptionCode());
sprintf(integer_string, "SEH, code: %lu\n", GetExceptionCode());
throw std::exception(integer_string);
}
}
#endif
void LLCoros::toplevelTryWrapper(const std::string& name, const callable_t& callable)
#else // ! LL_WINDOWS
inline void sehandle(const LLCoros::callable_t& callable)
{
callable();
}
#endif // ! LL_WINDOWS
} // anonymous namespace
// Top-level wrapper around caller's coroutine callable.
// Normally we like to pass strings and such by const reference -- but in this
// case, we WANT to copy both the name and the callable to our local stack!
void LLCoros::toplevel(std::string name, callable_t callable)
{
// keep the CoroData on this top-level function's stack frame
CoroData corodata(name);
@ -350,12 +350,12 @@ void LLCoros::toplevelTryWrapper(const std::string& name, const callable_t& call
// run the code the caller actually wants in the coroutine
try
{
callable();
sehandle(callable);
}
catch (const Stop& exc)
{
LL_INFOS("LLCoros") << "coroutine " << name << " terminating because "
<< exc.what() << LL_ENDL;
<< exc.what() << LL_ENDL;
}
catch (const LLContinueError&)
{
@ -366,36 +366,14 @@ void LLCoros::toplevelTryWrapper(const std::string& name, const callable_t& call
}
catch (...)
{
#if LL_WINDOWS
// Any OTHER kind of uncaught exception will cause the viewer to
// crash, SEH handling should catch it and report to bugsplat.
LOG_UNHANDLED_EXCEPTION(STRINGIZE("coroutine " << name));
// to not modify callstack
throw;
#else
// Stash any OTHER kind of uncaught exception in the rethrow() queue
// to be rethrown by the main fiber.
LL_WARNS("LLCoros") << "Capturing uncaught exception in coroutine "
<< name << LL_ENDL;
LLCoros::instance().saveException(name, std::current_exception());
#endif
}
}
// Top-level wrapper around caller's coroutine callable.
// Normally we like to pass strings and such by const reference -- but in this
// case, we WANT to copy both the name and the callable to our local stack!
void LLCoros::toplevel(std::string name, callable_t callable)
{
#if LL_WINDOWS
// Because SEH can's have unwinding, need to call a wrapper
// 'try' is inside SEH handling to not catch LLContinue
sehHandle(name, callable);
#else
toplevelTryWrapper(name, callable);
#endif
}
//static
void LLCoros::checkStop()
{

6
indra/llcommon/llcoros.h
View File

@ -307,11 +307,7 @@ public:
private:
std::string generateDistinctName(const std::string& prefix) const;
void toplevelTryWrapper(const std::string& name, const callable_t& callable);
#if LL_WINDOWS
void sehHandle(const std::string& name, const callable_t& callable); // calls toplevelTryWrapper
#endif
void toplevel(std::string name, callable_t callable); // calls sehHandle or toplevelTryWrapper
void toplevel(std::string name, callable_t callable);
struct CoroData;
static CoroData& get_CoroData(const std::string& caller);
void saveException(const std::string& name, std::exception_ptr exc);

2
indra/llcommon/llerror.cpp
View File

@ -943,7 +943,7 @@ namespace LLError
for (a = sets.beginArray(), end = sets.endArray(); a != end; ++a)
{
const LLSD& entry = *a;
if (entry.isMap() && !entry.emptyMap())
if (entry.isMap() && entry.size() != 0)
{
ELevel level = decodeLevel(entry["level"]);

131
indra/llcommon/llsdserialize.cpp
View File

@ -34,6 +34,9 @@
#include <iostream>
#include "apr_base64.h"
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>
#ifdef LL_USESYSTEMLIBS
# include <zlib.h>
#else
@ -2128,7 +2131,9 @@ std::string zip_llsd(LLSD& data)
{ //copy result into output
if (strm.avail_out >= CHUNK)
{
free(output);
deflateEnd(&strm);
if(output)
free(output);
LL_WARNS() << "Failed to compress LLSD block." << LL_ENDL;
return std::string();
}
@ -2151,7 +2156,9 @@ std::string zip_llsd(LLSD& data)
}
else
{
free(output);
deflateEnd(&strm);
if(output)
free(output);
LL_WARNS() << "Failed to compress LLSD block." << LL_ENDL;
return std::string();
}
@ -2162,7 +2169,8 @@ std::string zip_llsd(LLSD& data)
std::string result((char*) output, size);
deflateEnd(&strm);
free(output);
if(output)
free(output);
return result;
}
@ -2172,53 +2180,66 @@ std::string zip_llsd(LLSD& data)
// and deserializes from that copy using LLSDSerialize
LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, std::istream& is, S32 size)
{
U8* result = NULL;
U32 cur_size = 0;
z_stream strm;
const U32 CHUNK = 65536;
U8 *in = new(std::nothrow) U8[size];
std::unique_ptr<U8[]> in = std::unique_ptr<U8[]>(new(std::nothrow) U8[size]);
if (!in)
{
return ZR_MEM_ERROR;
}
is.read((char*) in, size);
is.read((char*) in.get(), size);
U8 out[CHUNK];
return unzip_llsd(data, in.get(), size);
}
LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, const U8* in, S32 size)
{
U8* result = NULL;
U32 cur_size = 0;
z_stream strm;
constexpr U32 CHUNK = 1024 * 512;
static thread_local std::unique_ptr<U8[]> out;
if (!out)
{
out = std::unique_ptr<U8[]>(new(std::nothrow) U8[CHUNK]);
}
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = size;
strm.next_in = in;
strm.next_in = const_cast<U8*>(in);
S32 ret = inflateInit(&strm);
do
{
strm.avail_out = CHUNK;
strm.next_out = out;
strm.next_out = out.get();
ret = inflate(&strm, Z_NO_FLUSH);
if (ret == Z_STREAM_ERROR)
{
inflateEnd(&strm);
free(result);
delete [] in;
return ZR_DATA_ERROR;
}
switch (ret)
{
case Z_NEED_DICT:
ret = Z_DATA_ERROR;
case Z_DATA_ERROR:
case Z_MEM_ERROR:
{
inflateEnd(&strm);
free(result);
return ZR_DATA_ERROR;
}
case Z_STREAM_ERROR:
case Z_BUF_ERROR:
{
inflateEnd(&strm);
free(result);
return ZR_BUFFER_ERROR;
}
case Z_MEM_ERROR:
{
inflateEnd(&strm);
free(result);
delete [] in;
return ZR_MEM_ERROR;
break;
}
}
U32 have = CHUNK-strm.avail_out;
@ -2231,17 +2252,15 @@ LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, std::istream& is,
{
free(result);
}
delete[] in;
return ZR_MEM_ERROR;
}
result = new_result;
memcpy(result+cur_size, out, have);
memcpy(result+cur_size, out.get(), have);
cur_size += have;
} while (ret == Z_OK);
} while (ret == Z_OK && ret != Z_STREAM_END);
inflateEnd(&strm);
delete [] in;
if (ret != Z_STREAM_END)
{
@ -2251,37 +2270,11 @@ LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, std::istream& is,
//result now points to the decompressed LLSD block
{
std::istringstream istr;
// Since we are using this for meshes, data we are dealing with tend to be large.
// So string can potentially fail to allocate, make sure this won't cause problems
try
{
std::string res_str((char*)result, cur_size);
char* result_ptr = strip_deprecated_header((char*)result, cur_size);
std::string deprecated_header("<? LLSD/Binary ?>");
if (res_str.substr(0, deprecated_header.size()) == deprecated_header)
{
res_str = res_str.substr(deprecated_header.size() + 1, cur_size);
}
cur_size = res_str.size();
istr.str(res_str);
}
#ifdef LL_WINDOWS
catch (std::length_error)
{
free(result);
return ZR_SIZE_ERROR;
}
#endif
catch (std::bad_alloc&)
{
free(result);
return ZR_MEM_ERROR;
}
if (!LLSDSerialize::fromBinary(data, istr, cur_size, UNZIP_LLSD_MAX_DEPTH))
boost::iostreams::stream<boost::iostreams::array_source> istrm(result_ptr, cur_size);
if (!LLSDSerialize::fromBinary(data, istrm, cur_size, UNZIP_LLSD_MAX_DEPTH))
{
free(result);
return ZR_PARSE_ERROR;
@ -2395,4 +2388,22 @@ U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32
return result;
}
char* strip_deprecated_header(char* in, U32& cur_size, U32* header_size)
{
const char* deprecated_header = "<? LLSD/Binary ?>";
constexpr size_t deprecated_header_size = 17;
if (cur_size > deprecated_header_size
&& memcmp(in, deprecated_header, deprecated_header_size) == 0)
{
in = in + deprecated_header_size;
cur_size = cur_size - deprecated_header_size;
if (header_size)
{
*header_size = deprecated_header_size + 1;
}
}
return in;
}

6
indra/llcommon/llsdserialize.h
View File

@ -858,9 +858,12 @@ public:
ZR_SIZE_ERROR,
ZR_DATA_ERROR,
ZR_PARSE_ERROR,
ZR_BUFFER_ERROR,
ZR_VERSION_ERROR
} EZipRresult;
// return OK or reason for failure
static EZipRresult unzip_llsd(LLSD& data, std::istream& is, S32 size);
static EZipRresult unzip_llsd(LLSD& data, const U8* in, S32 size);
};
//dirty little zip functions -- yell at davep
@ -868,4 +871,7 @@ LL_COMMON_API std::string zip_llsd(LLSD& data);
LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize,std::istream& is, S32 size);
// returns a pointer to the array or past the array if the deprecated header exists
LL_COMMON_API char* strip_deprecated_header(char* in, U32& cur_size, U32* header_size = nullptr);
#endif // LL_LLSDSERIALIZE_H

30
indra/llcommon/lluuid.cpp
View File

@ -997,36 +997,6 @@ LLUUID::LLUUID()
return !(word[0] | word[1] | word[2] | word[3]);
}
// Copy constructor
LLUUID::LLUUID(const LLUUID& rhs)
{
U32 *tmp = (U32 *)mData;
U32 *rhstmp = (U32 *)rhs.mData;
tmp[0] = rhstmp[0];
tmp[1] = rhstmp[1];
tmp[2] = rhstmp[2];
tmp[3] = rhstmp[3];
}
LLUUID::~LLUUID()
{
}
// Assignment
LLUUID& LLUUID::operator=(const LLUUID& rhs)
{
// No need to check the case where this==&rhs. The branch is slower than the write.
U32 *tmp = (U32 *)mData;
U32 *rhstmp = (U32 *)rhs.mData;
tmp[0] = rhstmp[0];
tmp[1] = rhstmp[1];
tmp[2] = rhstmp[2];
tmp[3] = rhstmp[3];
return *this;
}
LLUUID::LLUUID(const char *in_string)
{
if (!in_string || in_string[0] == 0)

8
indra/llcommon/lluuid.h
View File

@ -55,10 +55,7 @@ public:
LLUUID();
explicit LLUUID(const char *in_string); // Convert from string.
explicit LLUUID(const std::string& in_string); // Convert from string.
LLUUID(const LLUUID &in);
LLUUID &operator=(const LLUUID &rhs);
~LLUUID();
~LLUUID() = default;
//
// MANIPULATORS
@ -131,6 +128,9 @@ public:
U8 mData[UUID_BYTES];
};
static_assert(std::is_trivially_copyable<LLUUID>::value, "LLUUID must be trivial copy");
static_assert(std::is_trivially_move_assignable<LLUUID>::value, "LLUUID must be trivial move");
static_assert(std::is_standard_layout<LLUUID>::value, "LLUUID must be a standard layout type");
typedef std::vector<LLUUID> uuid_vec_t;
typedef std::set<LLUUID> uuid_set_t;

2
indra/llcommon/threadsafeschedule.h
View File

@ -248,7 +248,7 @@ namespace LL
TimePoint until = TimePoint::clock::now() + std::chrono::hours(24);
pop_result popped = tryPopUntil_(lock, until, tt);
if (popped == POPPED)
return std::move(tt);
return tt;
// DONE: throw, just as super::pop() does
if (popped == DONE)

32
indra/llfilesystem/lldir_mac.cpp
View File

@ -66,16 +66,16 @@ LLDir_Mac::LLDir_Mac()
const std::string secondLifeString = "SecondLife";
std::string *executablepathstr = getSystemExecutableFolder();
std::string executablepathstr = getSystemExecutableFolder();
//NOTE: LLINFOS/LLERRS will not output to log here. The streams are not initialized.
if (executablepathstr)
if (!executablepathstr.empty())
{
// mExecutablePathAndName
mExecutablePathAndName = *executablepathstr;
mExecutablePathAndName = executablepathstr;
boost::filesystem::path executablepath(*executablepathstr);
boost::filesystem::path executablepath(executablepathstr);
# ifndef BOOST_SYSTEM_NO_DEPRECATED
#endif
@ -83,8 +83,8 @@ LLDir_Mac::LLDir_Mac()
mExecutableDir = executablepath.parent_path().string();
// mAppRODataDir
std::string *resourcepath = getSystemResourceFolder();
mAppRODataDir = *resourcepath;
std::string resourcepath = getSystemResourceFolder();
mAppRODataDir = resourcepath;
// *NOTE: When running in a dev tree, use the copy of
// skins in indra/newview/ rather than in the application bundle. This
@ -110,11 +110,11 @@ LLDir_Mac::LLDir_Mac()
}
// mOSUserDir
std::string *appdir = getSystemApplicationSupportFolder();
std::string appdir = getSystemApplicationSupportFolder();
std::string rootdir;
//Create root directory
if (CreateDirectory(*appdir, secondLifeString, &rootdir))
if (CreateDirectory(appdir, secondLifeString, &rootdir))
{
// Save the full path to the folder
@ -128,12 +128,10 @@ LLDir_Mac::LLDir_Mac()
}
//mOSCacheDir
std::string *cachedir = getSystemCacheFolder();
if (cachedir)
std::string cachedir = getSystemCacheFolder();
if (!cachedir.empty())
{
mOSCacheDir = *cachedir;
mOSCacheDir = cachedir;
//TODO: This changes from ~/Library/Cache/Secondlife to ~/Library/Cache/com.app.secondlife/Secondlife. Last dir level could go away.
CreateDirectory(mOSCacheDir, secondLifeString, NULL);
}
@ -143,12 +141,10 @@ LLDir_Mac::LLDir_Mac()
// mTempDir
//Aura 120920 boost::filesystem::temp_directory_path() not yet implemented on mac. :(
std::string *tmpdir = getSystemTempFolder();
if (tmpdir)
std::string tmpdir = getSystemTempFolder();
if (!tmpdir.empty())
{
CreateDirectory(*tmpdir, secondLifeString, &mTempDir);
if (tmpdir) delete tmpdir;
CreateDirectory(tmpdir, secondLifeString, &mTempDir);
}
mWorkingDir = getCurPath();

10
indra/llfilesystem/lldir_utils_objc.h
View File

@ -33,11 +33,11 @@
#include <iostream>
std::string* getSystemTempFolder();
std::string* getSystemCacheFolder();
std::string* getSystemApplicationSupportFolder();
std::string* getSystemResourceFolder();
std::string* getSystemExecutableFolder();
std::string getSystemTempFolder();
std::string getSystemCacheFolder();
std::string getSystemApplicationSupportFolder();
std::string getSystemResourceFolder();
std::string getSystemExecutableFolder();
#endif // LL_LLDIR_UTILS_OBJC_H

82
indra/llfilesystem/lldir_utils_objc.mm
View File

@ -30,75 +30,75 @@
#include "lldir_utils_objc.h"
#import <Cocoa/Cocoa.h>
std::string* getSystemTempFolder()
std::string getSystemTempFolder()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString * tempDir = NSTemporaryDirectory();
if (tempDir == nil)
tempDir = @"/tmp";
std::string *result = ( new std::string([tempDir UTF8String]) );
[pool release];
std::string result;
@autoreleasepool {
NSString * tempDir = NSTemporaryDirectory();
if (tempDir == nil)
tempDir = @"/tmp";
result = std::string([tempDir UTF8String]);
}
return result;
}
//findSystemDirectory scoped exclusively to this file.
std::string* findSystemDirectory(NSSearchPathDirectory searchPathDirectory,
std::string findSystemDirectory(NSSearchPathDirectory searchPathDirectory,
NSSearchPathDomainMask domainMask)
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
std::string *result = nil;
NSString *path = nil;
// Search for the path
NSArray* paths = NSSearchPathForDirectoriesInDomains(searchPathDirectory,
domainMask,
YES);
if ([paths count])
{
path = [paths objectAtIndex:0];
//HACK: Always attempt to create directory, ignore errors.
NSError *error = nil;
[[NSFileManager defaultManager] createDirectoryAtPath:path withIntermediateDirectories:YES attributes:nil error:&error];
std::string result;
@autoreleasepool {
NSString *path = nil;
result = new std::string([path UTF8String]);
// Search for the path
NSArray* paths = NSSearchPathForDirectoriesInDomains(searchPathDirectory,
domainMask,
YES);
if ([paths count])
{
path = [paths objectAtIndex:0];
//HACK: Always attempt to create directory, ignore errors.
NSError *error = nil;
[[NSFileManager defaultManager] createDirectoryAtPath:path withIntermediateDirectories:YES attributes:nil error:&error];
result = std::string([path UTF8String]);
}
}
[pool release];
return result;
}
std::string* getSystemExecutableFolder()
std::string getSystemExecutableFolder()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString *bundlePath = [[NSBundle mainBundle] executablePath];
std::string *result = (new std::string([bundlePath UTF8String]));
[pool release];
std::string result;
@autoreleasepool {
NSString *bundlePath = [[NSBundle mainBundle] executablePath];
result = std::string([bundlePath UTF8String]);
}
return result;
}
std::string* getSystemResourceFolder()
std::string getSystemResourceFolder()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString *bundlePath = [[NSBundle mainBundle] resourcePath];
std::string *result = (new std::string([bundlePath UTF8String]));
[pool release];
std::string result;
@autoreleasepool {
NSString *bundlePath = [[NSBundle mainBundle] resourcePath];
result = std::string([bundlePath UTF8String]);
}
return result;
}
std::string* getSystemCacheFolder()
std::string getSystemCacheFolder()
{
return findSystemDirectory (NSCachesDirectory,
NSUserDomainMask);
}
std::string* getSystemApplicationSupportFolder()
std::string getSystemApplicationSupportFolder()
{
return findSystemDirectory (NSApplicationSupportDirectory,
NSUserDomainMask);

5
indra/llimage/llpngwrapper.cpp
View File

@ -257,12 +257,7 @@ void LLPngWrapper::normalizeImage()
png_set_strip_16(mReadPngPtr);
}
#if LL_DARWIN
const F64 SCREEN_GAMMA = 1.8;
#else
const F64 SCREEN_GAMMA = 2.2;
#endif
if (png_get_gAMA(mReadPngPtr, mReadInfoPtr, &mGamma))
{
png_set_gamma(mReadPngPtr, SCREEN_GAMMA, mGamma);

1084
indra/llimagej2coj/llimagej2coj.cpp
View File

File diff suppressed because it is too large Load Diff

20
indra/llmath/llvolume.cpp
View File

@ -2394,7 +2394,25 @@ bool LLVolume::unpackVolumeFaces(std::istream& is, S32 size)
LL_DEBUGS("MeshStreaming") << "Failed to unzip LLSD blob for LoD with code " << uzip_result << " , will probably fetch from sim again." << LL_ENDL;
return false;
}
return unpackVolumeFacesInternal(mdl);
}
bool LLVolume::unpackVolumeFaces(U8* in_data, S32 size)
{
//input data is now pointing at a zlib compressed block of LLSD
//decompress block
LLSD mdl;
U32 uzip_result = LLUZipHelper::unzip_llsd(mdl, in_data, size);
if (uzip_result != LLUZipHelper::ZR_OK)
{
LL_DEBUGS("MeshStreaming") << "Failed to unzip LLSD blob for LoD with code " << uzip_result << " , will probably fetch from sim again." << LL_ENDL;
return false;
}
return unpackVolumeFacesInternal(mdl);
}
bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
{
{
U32 face_count = mdl.size();

6
indra/llmath/llvolume.h
View File

@ -1105,8 +1105,12 @@ protected:
BOOL generate();
void createVolumeFaces();
public:
virtual bool unpackVolumeFaces(std::istream& is, S32 size);
bool unpackVolumeFaces(std::istream& is, S32 size);
bool unpackVolumeFaces(U8* in_data, S32 size);
private:
bool unpackVolumeFacesInternal(const LLSD& mdl);
public:
virtual void setMeshAssetLoaded(BOOL loaded);
virtual BOOL isMeshAssetLoaded();

262
indra/llmessage/lldatapacker.cpp
View File

@ -116,9 +116,8 @@ BOOL LLDataPacker::packFixed(const F32 value, const char *name,
BOOL LLDataPacker::unpackFixed(F32 &value, const char *name,
const BOOL is_signed, const U32 int_bits, const U32 frac_bits)
{
//BOOL success = TRUE;
BOOL success = TRUE;
//LL_INFOS() << "unpackFixed:" << name << " int:" << int_bits << " frac:" << frac_bits << LL_ENDL;
BOOL ok = FALSE;
S32 unsigned_bits = int_bits + frac_bits;
S32 total_bits = unsigned_bits;
@ -134,19 +133,19 @@ BOOL LLDataPacker::unpackFixed(F32 &value, const char *name,
if (total_bits <= 8)
{
U8 fixed_8;
ok = unpackU8(fixed_8, name);
success = unpackU8(fixed_8, name);
fixed_val = (F32)fixed_8;
}
else if (total_bits <= 16)
{
U16 fixed_16;
ok = unpackU16(fixed_16, name);
success = unpackU16(fixed_16, name);
fixed_val = (F32)fixed_16;
}
else if (total_bits <= 31)
{
U32 fixed_32;
ok = unpackU32(fixed_32, name);
success = unpackU32(fixed_32, name);
fixed_val = (F32)fixed_32;
}
else
@ -164,7 +163,7 @@ BOOL LLDataPacker::unpackFixed(F32 &value, const char *name,
}
value = fixed_val;
//LL_INFOS() << "Value: " << value << LL_ENDL;
return ok;
return success;
}
BOOL LLDataPacker::unpackU16s(U16 *values, S32 count, const char *name)
@ -238,37 +237,43 @@ BOOL LLDataPacker::unpackUUIDs(LLUUID *values, S32 count, const char *name)
BOOL LLDataPackerBinaryBuffer::packString(const std::string& value, const char *name)
{
BOOL success = TRUE;
S32 length = value.length()+1;
success &= verifyLength(length, name);
if (!verifyLength(length, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value.c_str(), MVT_VARIABLE, length);
}
mCurBufferp += length;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackString(std::string& value, const char *name)
{
BOOL success = TRUE;
S32 length = (S32)strlen((char *)mCurBufferp) + 1; /*Flawfinder: ignore*/
success &= verifyLength(length, name);
if (!verifyLength(length, name))
{
return FALSE;
}
value = std::string((char*)mCurBufferp); // We already assume NULL termination calling strlen()
mCurBufferp += length;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packBinaryData(const U8 *value, S32 size, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(size + 4, name);
if (!verifyLength(size + 4, name))
{
return FALSE;
}
if (mWriteEnabled)
{
@ -280,102 +285,117 @@ BOOL LLDataPackerBinaryBuffer::packBinaryData(const U8 *value, S32 size, const c
htolememcpy(mCurBufferp, value, MVT_VARIABLE, size);
}
mCurBufferp += size;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackBinaryData(U8 *value, S32 &size, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(4, name);
htolememcpy(&size, mCurBufferp, MVT_S32, 4);
mCurBufferp += 4;
success &= verifyLength(size, name);
if (success)
{
htolememcpy(value, mCurBufferp, MVT_VARIABLE, size);
mCurBufferp += size;
}
else
if (!verifyLength(4, name))
{
LL_WARNS() << "LLDataPackerBinaryBuffer::unpackBinaryData would unpack invalid data, aborting!" << LL_ENDL;
success = FALSE;
return FALSE;
}
return success;
htolememcpy(&size, mCurBufferp, MVT_S32, 4);
mCurBufferp += 4;
if (!verifyLength(size, name))
{
LL_WARNS() << "LLDataPackerBinaryBuffer::unpackBinaryData would unpack invalid data, aborting!" << LL_ENDL;
return FALSE;
}
htolememcpy(value, mCurBufferp, MVT_VARIABLE, size);
mCurBufferp += size;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packBinaryDataFixed(const U8 *value, S32 size, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(size, name);
if (!verifyLength(size, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value, MVT_VARIABLE, size);
}
mCurBufferp += size;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackBinaryDataFixed(U8 *value, S32 size, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(size, name);
if (!verifyLength(size, name))
{
return FALSE;
}
htolememcpy(value, mCurBufferp, MVT_VARIABLE, size);
mCurBufferp += size;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packU8(const U8 value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(U8), name);
if (!verifyLength(sizeof(U8), name))
{
return FALSE;
}
if (mWriteEnabled)
{
*mCurBufferp = value;
}
mCurBufferp++;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackU8(U8 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(U8), name);
if (!verifyLength(sizeof(U8), name))
{
return FALSE;
}
value = *mCurBufferp;
mCurBufferp++;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packU16(const U16 value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(U16), name);
if (!verifyLength(sizeof(U16), name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, &value, MVT_U16, 2);
}
mCurBufferp += 2;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackU16(U16 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(U16), name);
if (!verifyLength(sizeof(U16), name))
{
return FALSE;
}
htolememcpy(&value, mCurBufferp, MVT_U16, 2);
mCurBufferp += 2;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packS16(const S16 value, const char *name)
@ -404,134 +424,156 @@ BOOL LLDataPackerBinaryBuffer::unpackS16(S16 &value, const char *name)
BOOL LLDataPackerBinaryBuffer::packU32(const U32 value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(U32), name);
if (!verifyLength(sizeof(U32), name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, &value, MVT_U32, 4);
}
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackU32(U32 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(U32), name);
if (!verifyLength(sizeof(U32), name))
{
return FALSE;
}
htolememcpy(&value, mCurBufferp, MVT_U32, 4);
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packS32(const S32 value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(S32), name);
if (!verifyLength(sizeof(S32), name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, &value, MVT_S32, 4);
}
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackS32(S32 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(S32), name);
if(!verifyLength(sizeof(S32), name))
{
return FALSE;
}
htolememcpy(&value, mCurBufferp, MVT_S32, 4);
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packF32(const F32 value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(F32), name);
if (!verifyLength(sizeof(F32), name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, &value, MVT_F32, 4);
}
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackF32(F32 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(sizeof(F32), name);
if (!verifyLength(sizeof(F32), name))
{
return FALSE;
}
htolememcpy(&value, mCurBufferp, MVT_F32, 4);
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packColor4(const LLColor4 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(16, name);
if (!verifyLength(16, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value.mV, MVT_LLVector4, 16);
}
mCurBufferp += 16;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackColor4(LLColor4 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(16, name);
if (!verifyLength(16, name))
{
return FALSE;
}
htolememcpy(value.mV, mCurBufferp, MVT_LLVector4, 16);
mCurBufferp += 16;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packColor4U(const LLColor4U &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(4, name);
if (!verifyLength(4, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value.mV, MVT_VARIABLE, 4);
}
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackColor4U(LLColor4U &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(4, name);
if (!verifyLength(4, name))
{
return FALSE;
}
htolememcpy(value.mV, mCurBufferp, MVT_VARIABLE, 4);
mCurBufferp += 4;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packVector2(const LLVector2 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(8, name);
if (!verifyLength(8, name))
{
return FALSE;
}
if (mWriteEnabled)
{
@ -539,92 +581,106 @@ BOOL LLDataPackerBinaryBuffer::packVector2(const LLVector2 &value, const char *n
htolememcpy(mCurBufferp+4, &value.mV[1], MVT_F32, 4);
}
mCurBufferp += 8;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackVector2(LLVector2 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(8, name);
if (!verifyLength(8, name))
{
return FALSE;
}
htolememcpy(&value.mV[0], mCurBufferp, MVT_F32, 4);
htolememcpy(&value.mV[1], mCurBufferp+4, MVT_F32, 4);
mCurBufferp += 8;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packVector3(const LLVector3 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(12, name);
if (!verifyLength(12, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value.mV, MVT_LLVector3, 12);
}
mCurBufferp += 12;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackVector3(LLVector3 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(12, name);
if (!verifyLength(12, name))
{
return FALSE;
}
htolememcpy(value.mV, mCurBufferp, MVT_LLVector3, 12);
mCurBufferp += 12;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packVector4(const LLVector4 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(16, name);
if (!verifyLength(16, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value.mV, MVT_LLVector4, 16);
}
mCurBufferp += 16;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackVector4(LLVector4 &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(16, name);
if (!verifyLength(16, name))
{
return FALSE;
}
htolememcpy(value.mV, mCurBufferp, MVT_LLVector4, 16);
mCurBufferp += 16;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::packUUID(const LLUUID &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(16, name);
if (!verifyLength(16, name))
{
return FALSE;
}
if (mWriteEnabled)
{
htolememcpy(mCurBufferp, value.mData, MVT_LLUUID, 16);
}
mCurBufferp += 16;
return success;
return TRUE;
}
BOOL LLDataPackerBinaryBuffer::unpackUUID(LLUUID &value, const char *name)
{
BOOL success = TRUE;
success &= verifyLength(16, name);
if (!verifyLength(16, name))
{
return FALSE;
}
htolememcpy(value.mData, mCurBufferp, MVT_LLUUID, 16);
mCurBufferp += 16;
return success;
return TRUE;
}
const LLDataPackerBinaryBuffer& LLDataPackerBinaryBuffer::operator=(const LLDataPackerBinaryBuffer &a)
@ -698,15 +754,13 @@ BOOL LLDataPackerAsciiBuffer::packString(const std::string& value, const char *n
BOOL LLDataPackerAsciiBuffer::unpackString(std::string& value, const char *name)
{
BOOL success = TRUE;
char valuestr[DP_BUFSIZE]; /*Flawfinder: ignore*/
BOOL res = getValueStr(name, valuestr, DP_BUFSIZE); // NULL terminated
if (!res) //
if (!getValueStr(name, valuestr, DP_BUFSIZE)) // NULL terminated
{
return FALSE;
}
value = valuestr;
return success;
return TRUE;
}

2
indra/llmessage/tests/llcoproceduremanager_test.cpp
View File

@ -92,7 +92,7 @@ namespace tut
Sync sync;
int foo = 0;
LLCoprocedureManager::instance().initializePool("PoolName");
LLUUID queueId = LLCoprocedureManager::instance().enqueueCoprocedure("PoolName", "ProcName",
LLCoprocedureManager::instance().enqueueCoprocedure("PoolName", "ProcName",
[&foo, &sync] (LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t & ptr, const LLUUID & id) {
sync.bump();
foo = 1;

10
indra/llprimitive/llmodel.cpp
View File

@ -1429,6 +1429,16 @@ LLMeshSkinInfo::LLMeshSkinInfo(LLSD& skin):
fromLLSD(skin);
}
LLMeshSkinInfo::LLMeshSkinInfo(const LLUUID& mesh_id, LLSD& skin) :
mMeshID(mesh_id),
mPelvisOffset(0.0),
mLockScaleIfJointPosition(false),
mInvalidJointsScrubbed(false),
mJointNumsInitialized(false)
{
fromLLSD(skin);
}
void LLMeshSkinInfo::fromLLSD(LLSD& skin)
{
if (skin.has("joint_names"))

3
indra/llprimitive/llmodel.h
View File

@ -41,12 +41,13 @@ class domMesh;
#define MAX_MODEL_FACES 8
LL_ALIGN_PREFIX(16)
class LLMeshSkinInfo
class LLMeshSkinInfo : public LLRefCount
{
LL_ALIGN_NEW
public:
LLMeshSkinInfo();
LLMeshSkinInfo(LLSD& data);
LLMeshSkinInfo(const LLUUID& mesh_id, LLSD& data);
void fromLLSD(LLSD& data);
LLSD asLLSD(bool include_joints, bool lock_scale_if_joint_position) const;
void updateHash();

11
indra/llui/llflatlistview.cpp
View File

@ -505,6 +505,17 @@ LLFlatListView::LLFlatListView(const LLFlatListView::Params& p)
}
};
LLFlatListView::~LLFlatListView()
{
for (pairs_iterator_t it = mItemPairs.begin(); it != mItemPairs.end(); ++it)
{
mItemsPanel->removeChild((*it)->first);
(*it)->first->die();
delete *it;
}
mItemPairs.clear();
}
// virtual
void LLFlatListView::draw()
{

1
indra/llui/llflatlistview.h
View File

@ -299,6 +299,7 @@ public:
virtual S32 notify(const LLSD& info) ;
virtual ~LLFlatListView();
protected:
/** Pairs LLpanel representing a single item LLPanel and LLSD associated with it */

58
indra/llui/llfolderview.cpp
View File

@ -163,6 +163,7 @@ LLFolderView::LLFolderView(const Params& p)
: LLFolderViewFolder(p),
mScrollContainer( NULL ),
mPopupMenuHandle(),
mMenuFileName(p.options_menu),
mAllowMultiSelect(p.allow_multiselect),
mAllowDrag(p.allow_drag),
mShowEmptyMessage(p.show_empty_message),
@ -182,6 +183,7 @@ LLFolderView::LLFolderView(const Params& p)
mMinWidth(0),
mDragAndDropThisFrame(FALSE),
mCallbackRegistrar(NULL),
mEnableRegistrar(NULL),
mUseEllipses(p.use_ellipses),
mDraggingOverItem(NULL),
mStatusTextBox(NULL),
@ -244,17 +246,6 @@ LLFolderView::LLFolderView(const Params& p)
mStatusTextBox->setFollowsTop();
addChild(mStatusTextBox);
// make the popup menu available
llassert(LLMenuGL::sMenuContainer != NULL);
LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>(p.options_menu, LLMenuGL::sMenuContainer, LLMenuHolderGL::child_registry_t::instance());
if (!menu)
{
menu = LLUICtrlFactory::getDefaultWidget<LLMenuGL>("inventory_menu");
}
menu->setBackgroundColor(LLUIColorTable::instance().getColor("MenuPopupBgColor"));
mPopupMenuHandle = menu->getHandle();
mViewModelItem->openItem();
mAreChildrenInited = true; // root folder is a special case due to not being loaded normally, assume that it's inited.
@ -276,6 +267,7 @@ LLFolderView::~LLFolderView( void )
mStatusTextBox = NULL;
if (mPopupMenuHandle.get()) mPopupMenuHandle.get()->die();
mPopupMenuHandle.markDead();
mAutoOpenItems.removeAllNodes();
clearSelection();
@ -1438,22 +1430,56 @@ BOOL LLFolderView::handleRightMouseDown( S32 x, S32 y, MASK mask )
BOOL handled = childrenHandleRightMouseDown(x, y, mask) != NULL;
S32 count = mSelectedItems.size();
LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
LLMenuGL* menu = static_cast<LLMenuGL*>(mPopupMenuHandle.get());
if (!menu)
{
if (mCallbackRegistrar)
{
mCallbackRegistrar->pushScope();
}
if (mEnableRegistrar)
{
mEnableRegistrar->pushScope();
}
llassert(LLMenuGL::sMenuContainer != NULL);
menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>(mMenuFileName, LLMenuGL::sMenuContainer, LLMenuHolderGL::child_registry_t::instance());
if (!menu)
{
menu = LLUICtrlFactory::getDefaultWidget<LLMenuGL>("inventory_menu");
}
menu->setBackgroundColor(LLUIColorTable::instance().getColor("MenuPopupBgColor"));
mPopupMenuHandle = menu->getHandle();
if (mEnableRegistrar)
{
mEnableRegistrar->popScope();
}
if (mCallbackRegistrar)
{
mCallbackRegistrar->popScope();
}
}
bool hide_folder_menu = mSuppressFolderMenu && isFolderSelected();
if ((handled
&& ( count > 0 && (hasVisibleChildren()) ) // show menu only if selected items are visible
&& menu ) &&
if (menu && (handled
&& ( count > 0 && (hasVisibleChildren()) )) && // show menu only if selected items are visible
!hide_folder_menu)
{
if (mCallbackRegistrar)
{
mCallbackRegistrar->pushScope();
}
if (mEnableRegistrar)
{
mEnableRegistrar->pushScope();
}
updateMenuOptions(menu);
menu->updateParent(LLMenuGL::sMenuContainer);
LLMenuGL::showPopup(this, menu, x, y);
if (mEnableRegistrar)
{
mEnableRegistrar->popScope();
}
if (mCallbackRegistrar)
{
mCallbackRegistrar->popScope();
@ -1531,7 +1557,7 @@ void LLFolderView::deleteAllChildren()
{
closeRenamer();
if (mPopupMenuHandle.get()) mPopupMenuHandle.get()->die();
mPopupMenuHandle = LLHandle<LLView>();
mPopupMenuHandle.markDead();
mScrollContainer = NULL;
mRenameItem = NULL;
mRenamer = NULL;

3
indra/llui/llfolderview.h
View File

@ -235,6 +235,7 @@ public:
bool showItemLinkOverlays() { return mShowItemLinkOverlays; }
void setCallbackRegistrar(LLUICtrl::CommitCallbackRegistry::ScopedRegistrar* registrar) { mCallbackRegistrar = registrar; }
void setEnableRegistrar(LLUICtrl::EnableCallbackRegistry::ScopedRegistrar* registrar) { mEnableRegistrar = registrar; }
LLPanel* getParentPanel() { return mParentPanel.get(); }
// DEBUG only
@ -272,6 +273,7 @@ protected:
protected:
LLHandle<LLView> mPopupMenuHandle;
std::string mMenuFileName;
selected_items_t mSelectedItems;
bool mKeyboardSelection,
@ -327,6 +329,7 @@ protected:
LLFolderViewItem* mDraggingOverItem; // See EXT-719
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar* mCallbackRegistrar;
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar* mEnableRegistrar;
public:
static F32 sAutoOpenTime;

16
indra/llui/llfolderviewmodel.h
View File

@ -419,21 +419,15 @@ public:
mFilter(filter)
{}
virtual ~LLFolderViewModel()
{
delete mSorter;
mSorter = NULL;
delete mFilter;
mFilter = NULL;
}
virtual ~LLFolderViewModel() {}
virtual SortType& getSorter() { return *mSorter; }
virtual const SortType& getSorter() const { return *mSorter; }
virtual void setSorter(const SortType& sorter) { mSorter = new SortType(sorter); requestSortAll(); }
virtual void setSorter(const SortType& sorter) { mSorter.reset(new SortType(sorter)); requestSortAll(); }
virtual FilterType& getFilter() { return *mFilter; }
virtual const FilterType& getFilter() const { return *mFilter; }
virtual void setFilter(const FilterType& filter) { mFilter = new FilterType(filter); }
virtual void setFilter(const FilterType& filter) { mFilter.reset(new FilterType(filter)); }
// By default, we assume the content is available. If a network fetch mechanism is implemented for the model,
// this method needs to be overloaded and return the relevant fetch status.
@ -471,8 +465,8 @@ public:
}
protected:
SortType* mSorter;
FilterType* mFilter;
std::unique_ptr<SortType> mSorter;
std::unique_ptr<FilterType> mFilter;
};
#endif // LLFOLDERVIEWMODEL_H

18
indra/llui/lllineeditor.cpp
View File

@ -209,13 +209,6 @@ LLLineEditor::LLLineEditor(const LLLineEditor::Params& p)
setPrevalidateInput(p.prevalidate_input_callback());
setPrevalidate(p.prevalidate_callback());
llassert(LLMenuGL::sMenuContainer != NULL);
LLContextMenu* menu = LLUICtrlFactory::instance().createFromFile<LLContextMenu>
("menu_text_editor.xml",
LLMenuGL::sMenuContainer,
LLMenuHolderGL::child_registry_t::instance());
setContextMenu(menu);
}
LLLineEditor::~LLLineEditor()
@ -1567,7 +1560,7 @@ BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask )
KEY_SHIFT != key &&
KEY_CONTROL != key &&
KEY_ALT != key &&
KEY_CAPSLOCK )
KEY_CAPSLOCK != key)
{
deselect();
}
@ -2637,6 +2630,15 @@ LLWString LLLineEditor::getConvertedText() const
void LLLineEditor::showContextMenu(S32 x, S32 y)
{
LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
if (!menu)
{
llassert(LLMenuGL::sMenuContainer != NULL);
menu = LLUICtrlFactory::createFromFile<LLContextMenu>
("menu_text_editor.xml",
LLMenuGL::sMenuContainer,
LLMenuHolderGL::child_registry_t::instance());
setContextMenu(menu);
}
if (menu)
{

58
indra/llui/llmenugl.cpp
View File

@ -4087,25 +4087,39 @@ void LLTearOffMenu::closeTearOff()
}
LLContextMenuBranch::LLContextMenuBranch(const LLContextMenuBranch::Params& p)
: LLMenuItemGL(p),
mBranch( p.branch()->getHandle() )
: LLMenuItemGL(p)
{
mBranch.get()->hide();
mBranch.get()->setParentMenuItem(this);
LLContextMenu* branch = static_cast<LLContextMenu*>(p.branch);
if (branch)
{
mBranch = branch->getHandle();
branch->hide();
branch->setParentMenuItem(this);
}
}
LLContextMenuBranch::~LLContextMenuBranch()
{
if (mBranch.get())
{
mBranch.get()->die();
}
}
// called to rebuild the draw label
void LLContextMenuBranch::buildDrawLabel( void )
{
auto menu = getBranch();
if (menu)
{
// default enablement is this -- if any of the subitems are
// enabled, this item is enabled. JC
U32 sub_count = mBranch.get()->getItemCount();
U32 sub_count = menu->getItemCount();
U32 i;
BOOL any_enabled = FALSE;
for (i = 0; i < sub_count; i++)
{
LLMenuItemGL* item = mBranch.get()->getItem(i);
LLMenuItemGL* item = menu->getItem(i);
item->buildDrawLabel();
if (item->getEnabled() && !item->getDrawTextDisabled() )
{
@ -4127,13 +4141,17 @@ void LLContextMenuBranch::buildDrawLabel( void )
void LLContextMenuBranch::showSubMenu()
{
LLMenuItemGL* menu_item = mBranch.get()->getParentMenuItem();
if (menu_item != NULL && menu_item->getVisible())
auto menu = getBranch();
if(menu)
{
S32 center_x;
S32 center_y;
localPointToScreen(getRect().getWidth(), getRect().getHeight() , &center_x, &center_y);
mBranch.get()->show(center_x, center_y);
LLMenuItemGL* menu_item = menu->getParentMenuItem();
if (menu_item != NULL && menu_item->getVisible())
{
S32 center_x;
S32 center_y;
localPointToScreen(getRect().getWidth(), getRect().getHeight(), &center_x, &center_y);
menu->show(center_x, center_y);
}
}
}
@ -4147,13 +4165,17 @@ void LLContextMenuBranch::setHighlight( BOOL highlight )
{
if (highlight == getHighlight()) return;
LLMenuItemGL::setHighlight(highlight);
if( highlight )
auto menu = getBranch();
if (menu)
{
showSubMenu();
}
else
{
mBranch.get()->hide();
if (highlight)
{
showSubMenu();
}
else
{
menu->hide();
}
}
}

3
indra/llui/llmenugl.h
View File

@ -745,8 +745,7 @@ public:
LLContextMenuBranch(const Params&);
virtual ~LLContextMenuBranch()
{}
virtual ~LLContextMenuBranch();
// called to rebuild the draw label
virtual void buildDrawLabel( void );

2
indra/llui/llmultislider.cpp
View File

@ -92,7 +92,7 @@ LLMultiSlider::LLMultiSlider(const LLMultiSlider::Params& p)
mMouseDownSignal(NULL),
mMouseUpSignal(NULL)
{
mValue.emptyMap();
mValue = LLSD::emptyMap();
mCurSlider = LLStringUtil::null;
if (mOrientation == HORIZONTAL)

42
indra/llui/llscrolllistctrl.cpp
View File

@ -196,7 +196,6 @@ LLScrollListCtrl::LLScrollListCtrl(const LLScrollListCtrl::Params& p)
mHighlightedItem(-1),
mBorder(NULL),
mSortCallback(NULL),
mPopupMenu(NULL),
mCommentTextView(NULL),
mNumDynamicWidthColumns(0),
mTotalStaticColumnWidth(0),
@ -348,6 +347,13 @@ LLScrollListCtrl::~LLScrollListCtrl()
mItemList.clear();
clearColumns(); //clears columns and deletes headers
delete mIsFriendSignal;
auto menu = mPopupMenuHandle.get();
if (menu)
{
menu->die();
mPopupMenuHandle.markDead();
}
}
@ -1307,14 +1313,14 @@ LLScrollListItem* LLScrollListCtrl::getItemByLabel(const std::string& label, BOO
}
BOOL LLScrollListCtrl::selectItemByPrefix(const std::string& target, BOOL case_sensitive)
BOOL LLScrollListCtrl::selectItemByPrefix(const std::string& target, BOOL case_sensitive, S32 column)
{
return selectItemByPrefix(utf8str_to_wstring(target), case_sensitive);
return selectItemByPrefix(utf8str_to_wstring(target), case_sensitive, column);
}
// Selects first enabled item that has a name where the name's first part matched the target string.
// Returns false if item not found.
BOOL LLScrollListCtrl::selectItemByPrefix(const LLWString& target, BOOL case_sensitive)
BOOL LLScrollListCtrl::selectItemByPrefix(const LLWString& target, BOOL case_sensitive, S32 column)
{
BOOL found = FALSE;
@ -1329,7 +1335,7 @@ BOOL LLScrollListCtrl::selectItemByPrefix(const LLWString& target, BOOL case_sen
{
LLScrollListItem* item = *iter;
// Only select enabled items with matching names
LLScrollListCell* cellp = item->getColumn(getSearchColumn());
LLScrollListCell* cellp = item->getColumn(column == -1 ? getSearchColumn() : column);
BOOL select = cellp ? item->getEnabled() && ('\0' == cellp->getValue().asString()[0]) : FALSE;
if (select)
{
@ -1352,7 +1358,7 @@ BOOL LLScrollListCtrl::selectItemByPrefix(const LLWString& target, BOOL case_sen
LLScrollListItem* item = *iter;
// Only select enabled items with matching names
LLScrollListCell* cellp = item->getColumn(getSearchColumn());
LLScrollListCell* cellp = item->getColumn(column == -1 ? getSearchColumn() : column);
if (!cellp)
{
continue;
@ -1997,17 +2003,23 @@ BOOL LLScrollListCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
// create the context menu from the XUI file and display it
std::string menu_name = is_group ? "menu_url_group.xml" : "menu_url_agent.xml";
delete mPopupMenu;
llassert(LLMenuGL::sMenuContainer != NULL);
mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>(
menu_name, LLMenuGL::sMenuContainer, LLMenuHolderGL::child_registry_t::instance());
if (mPopupMenu)
auto menu = mPopupMenuHandle.get();
if (menu)
{
menu->die();
mPopupMenuHandle.markDead();
}
llassert(LLMenuGL::sMenuContainer != NULL);
menu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>(
menu_name, LLMenuGL::sMenuContainer, LLMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandle = menu->getHandle();
if (mIsFriendSignal)
{
bool isFriend = *(*mIsFriendSignal)(uuid);
LLView* addFriendButton = mPopupMenu->getChild<LLView>("add_friend");
LLView* removeFriendButton = mPopupMenu->getChild<LLView>("remove_friend");
LLView* addFriendButton = menu->getChild<LLView>("add_friend");
LLView* removeFriendButton = menu->getChild<LLView>("remove_friend");
if (addFriendButton && removeFriendButton)
{
@ -2016,8 +2028,8 @@ BOOL LLScrollListCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
}
}
mPopupMenu->show(x, y);
LLMenuGL::showPopup(this, mPopupMenu, x, y);
menu->show(x, y);
LLMenuGL::showPopup(this, menu, x, y);
return TRUE;
}
}

6
indra/llui/llscrolllistctrl.h
View File

@ -261,8 +261,8 @@ public:
virtual LLScrollListItem* addSimpleElement(const std::string& value, EAddPosition pos = ADD_BOTTOM, const LLSD& id = LLSD());
BOOL selectItemByLabel( const std::string& item, BOOL case_sensitive = TRUE, S32 column = 0 ); // FALSE if item not found
BOOL selectItemByPrefix(const std::string& target, BOOL case_sensitive = TRUE);
BOOL selectItemByPrefix(const LLWString& target, BOOL case_sensitive = TRUE);
BOOL selectItemByPrefix(const std::string& target, BOOL case_sensitive = TRUE, S32 column = -1);
BOOL selectItemByPrefix(const LLWString& target, BOOL case_sensitive = TRUE, S32 column = -1);
LLScrollListItem* getItemByLabel( const std::string& item, BOOL case_sensitive = TRUE, S32 column = 0 );
const std::string getSelectedItemLabel(S32 column = 0) const;
LLSD getSelectedValue();
@ -528,7 +528,7 @@ private:
S32 mHighlightedItem;
class LLViewBorder* mBorder;
LLContextMenu *mPopupMenu;
LLHandle<LLContextMenu> mPopupMenuHandle;
LLView *mCommentTextView;

5
indra/llui/lltabcontainer.cpp
View File

@ -1442,6 +1442,11 @@ void LLTabContainer::selectLastTab()
void LLTabContainer::selectNextTab()
{
if (mTabList.size() == 0)
{
return;
}
BOOL tab_has_focus = FALSE;
if (mCurrentTabIdx >= 0 && mTabList[mCurrentTabIdx]->mButton->hasFocus())
{

6
indra/llui/lltextbase.cpp
View File

@ -273,6 +273,12 @@ LLTextBase::LLTextBase(const LLTextBase::Params &p)
LLTextBase::~LLTextBase()
{
mSegments.clear();
LLContextMenu* menu = static_cast<LLContextMenu*>(mPopupMenuHandle.get());
if (menu)
{
menu->die();
mPopupMenuHandle.markDead();
}
delete mURLClickSignal;
delete mIsFriendSignal;
delete mIsObjectBlockedSignal;

31
indra/llui/lltexteditor.cpp
View File

@ -257,7 +257,6 @@ LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
mMouseDownY(0),
mTabsToNextField(p.ignore_tab),
mPrevalidateFunc(p.prevalidate_callback()),
mContextMenu(NULL),
mShowContextMenu(p.show_context_menu),
mEnableTooltipPaste(p.enable_tooltip_paste),
mPassDelete(FALSE),
@ -301,8 +300,13 @@ LLTextEditor::~LLTextEditor()
// Scrollbar is deleted by LLView
std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
mUndoStack.clear();
// context menu is owned by menu holder, not us
//delete mContextMenu;
// Mark the menu as dead or its retained in memory till shutdown.
LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
if(menu)
{
menu->die();
mContextMenuHandle.markDead();
}
}
////////////////////////////////////////////////////////////
@ -2051,12 +2055,19 @@ void LLTextEditor::setEnabled(BOOL enabled)
void LLTextEditor::showContextMenu(S32 x, S32 y)
{
if (!mContextMenu)
LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
if (!menu)
{
llassert(LLMenuGL::sMenuContainer != NULL);
mContextMenu = LLUICtrlFactory::instance().createFromFile<LLContextMenu>("menu_text_editor.xml",
menu = LLUICtrlFactory::createFromFile<LLContextMenu>("menu_text_editor.xml",
LLMenuGL::sMenuContainer,
LLMenuHolderGL::child_registry_t::instance());
if(!menu)
{
LL_WARNS() << "Failed to create menu for LLTextEditor: " << getName() << LL_ENDL;
return;
}
mContextMenuHandle = menu->getHandle();
}
// Route menu to this class
@ -2102,11 +2113,11 @@ void LLTextEditor::showContextMenu(S32 x, S32 y)
}
}
mContextMenu->setItemVisible("Suggestion Separator", (use_spellcheck) && (!mSuggestionList.empty()));
mContextMenu->setItemVisible("Add to Dictionary", (use_spellcheck) && (is_misspelled));
mContextMenu->setItemVisible("Add to Ignore", (use_spellcheck) && (is_misspelled));
mContextMenu->setItemVisible("Spellcheck Separator", (use_spellcheck) && (is_misspelled));
mContextMenu->show(screen_x, screen_y, this);
menu->setItemVisible("Suggestion Separator", (use_spellcheck) && (!mSuggestionList.empty()));
menu->setItemVisible("Add to Dictionary", (use_spellcheck) && (is_misspelled));
menu->setItemVisible("Add to Ignore", (use_spellcheck) && (is_misspelled));
menu->setItemVisible("Spellcheck Separator", (use_spellcheck) && (is_misspelled));
menu->show(screen_x, screen_y, this);
}

2
indra/llui/lltexteditor.h
View File

@ -329,7 +329,7 @@ private:
keystroke_signal_t mKeystrokeSignal;
LLTextValidate::validate_func_t mPrevalidateFunc;
LLContextMenu* mContextMenu;
LLHandle<LLContextMenu> mContextMenuHandle;
}; // end class LLTextEditor
// Build time optimization, generate once in .cpp file

7
indra/llui/lltoolbar.cpp
View File

@ -127,7 +127,12 @@ LLToolBar::LLToolBar(const LLToolBar::Params& p)
LLToolBar::~LLToolBar()
{
delete mPopupMenuHandle.get();
auto menu = mPopupMenuHandle.get();
if (menu)
{
menu->die();
mPopupMenuHandle.markDead();
}
delete mButtonAddSignal;
delete mButtonEnterSignal;
delete mButtonLeaveSignal;

2
indra/llwindow/lldxhardware.cpp
View File

@ -1098,7 +1098,7 @@ LLSD LLDXHardware::getDisplayInfo()
}
LCleanup:
if (ret.emptyMap())
if (!ret.isMap() || (ret.size() == 0))
{
LL_INFOS() << "Failed to get data, cleaning up" << LL_ENDL;
}

7
indra/llwindow/llopenglview-objc.mm
View File

@ -501,7 +501,12 @@ attributedStringInfo getSegments(NSAttributedString *str)
// e.g. OS Window for upload something or Input Window...
// mModifiers instance variable is for insertText: or insertText:replacementRange: (by Pell Smit)
mModifiers = [theEvent modifierFlags];
unichar ch = [[theEvent charactersIgnoringModifiers] characterAtIndex:0];
NSString *str_no_modifiers = [theEvent charactersIgnoringModifiers];
unichar ch = 0;
if (str_no_modifiers.length)
{
ch = [str_no_modifiers characterAtIndex:0];
}
bool acceptsText = mHasMarkedText ? false : callKeyDown(&eventData, keycode, mModifiers, ch);
if (acceptsText &&

2
indra/llwindow/llwindowmacosx-objc.h
View File

@ -83,7 +83,7 @@ int createNSApp(int argc, const char **argv);
void setupCocoa();
bool pasteBoardAvailable();
bool copyToPBoard(const unsigned short *str, unsigned int len);
const unsigned short *copyFromPBoard();
unsigned short *copyFromPBoard();
CursorRef createImageCursor(const char *fullpath, int hotspotX, int hotspotY);
short releaseImageCursor(CursorRef ref);
short setImageCursor(CursorRef ref);

136
indra/llwindow/llwindowmacosx-objc.mm
View File

@ -49,14 +49,12 @@ void setupCocoa()
if(!inited)
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// The following prevents the Cocoa command line parser from trying to open 'unknown' arguements as documents.
// ie. running './secondlife -set Language fr' would cause a pop-up saying can't open document 'fr'
// when init'ing the Cocoa App window.
[[NSUserDefaults standardUserDefaults] setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
[pool release];
@autoreleasepool {
// The following prevents the Cocoa command line parser from trying to open 'unknown' arguements as documents.
// ie. running './secondlife -set Language fr' would cause a pop-up saying can't open document 'fr'
// when init'ing the Cocoa App window.
[[NSUserDefaults standardUserDefaults] setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
}
inited = true;
}
@ -64,13 +62,13 @@ void setupCocoa()
bool copyToPBoard(const unsigned short *str, unsigned int len)
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];
NSPasteboard *pboard = [NSPasteboard generalPasteboard];
[pboard clearContents];
NSArray *contentsToPaste = [[NSArray alloc] initWithObjects:[NSString stringWithCharacters:str length:len], nil];
[pool release];
return [pboard writeObjects:contentsToPaste];
@autoreleasepool {
NSPasteboard *pboard = [NSPasteboard generalPasteboard];
[pboard clearContents];
NSArray *contentsToPaste = [[[NSArray alloc] initWithObjects:[NSString stringWithCharacters:str length:len], nil] autorelease];
return [pboard writeObjects:contentsToPaste];
}
}
bool pasteBoardAvailable()
@ -79,39 +77,39 @@ bool pasteBoardAvailable()
return [[NSPasteboard generalPasteboard] canReadObjectForClasses:classArray options:[NSDictionary dictionary]];
}
const unsigned short *copyFromPBoard()
unsigned short *copyFromPBoard()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];
NSPasteboard *pboard = [NSPasteboard generalPasteboard];
NSArray *classArray = [NSArray arrayWithObject:[NSString class]];
NSString *str = NULL;
BOOL ok = [pboard canReadObjectForClasses:classArray options:[NSDictionary dictionary]];
if (ok)
{
NSArray *objToPaste = [pboard readObjectsForClasses:classArray options:[NSDictionary dictionary]];
str = [objToPaste objectAtIndex:0];
}
unichar* temp = (unichar*)calloc([str length]+1, sizeof(unichar));
[str getCharacters:temp];
[pool release];
return temp;
@autoreleasepool {
NSPasteboard *pboard = [NSPasteboard generalPasteboard];
NSArray *classArray = [NSArray arrayWithObject:[NSString class]];
NSString *str = NULL;
BOOL ok = [pboard canReadObjectForClasses:classArray options:[NSDictionary dictionary]];
if (ok)
{
NSArray *objToPaste = [pboard readObjectsForClasses:classArray options:[NSDictionary dictionary]];
str = [objToPaste objectAtIndex:0];
}
NSUInteger str_len = [str length];
unichar* temp = (unichar*)calloc(str_len+1, sizeof(unichar));
[str getCharacters:temp range:NSMakeRange(0, str_len)];
return temp;
}
}
CursorRef createImageCursor(const char *fullpath, int hotspotX, int hotspotY)
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// extra retain on the NSCursor since we want it to live for the lifetime of the app.
NSCursor *cursor =
[[[NSCursor alloc]
initWithImage:
[[[NSImage alloc] initWithContentsOfFile:
[NSString stringWithUTF8String:fullpath]
]autorelease]
hotSpot:NSMakePoint(hotspotX, hotspotY)
]retain];
[pool release];
NSCursor *cursor = nil;
@autoreleasepool {
// extra retain on the NSCursor since we want it to live for the lifetime of the app.
cursor =
[[[NSCursor alloc]
initWithImage:
[[[NSImage alloc] initWithContentsOfFile:
[NSString stringWithUTF8String:fullpath]
] autorelease]
hotSpot:NSMakePoint(hotspotX, hotspotY)
] retain];
}
return (CursorRef)cursor;
}
@ -178,10 +176,10 @@ OSErr releaseImageCursor(CursorRef ref)
{
if( ref != NULL )
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSCursor *cursor = (NSCursor*)ref;
[cursor release];
[pool release];
@autoreleasepool {
NSCursor *cursor = (NSCursor*)ref;
[cursor autorelease];
}
}
else
{
@ -195,10 +193,10 @@ OSErr setImageCursor(CursorRef ref)
{
if( ref != NULL )
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSCursor *cursor = (NSCursor*)ref;
[cursor set];
[pool release];
@autoreleasepool {
NSCursor *cursor = (NSCursor*)ref;
[cursor set];
}
}
else
{
@ -419,24 +417,26 @@ void requestUserAttention()
long showAlert(std::string text, std::string title, int type)
{
NSAlert *alert = [[NSAlert alloc] init];
[alert setMessageText:[NSString stringWithCString:title.c_str() encoding:[NSString defaultCStringEncoding]]];
[alert setInformativeText:[NSString stringWithCString:text.c_str() encoding:[NSString defaultCStringEncoding]]];
if (type == 0)
{
[alert addButtonWithTitle:@"Okay"];
} else if (type == 1)
{
[alert addButtonWithTitle:@"Okay"];
[alert addButtonWithTitle:@"Cancel"];
} else if (type == 2)
{
[alert addButtonWithTitle:@"Yes"];
[alert addButtonWithTitle:@"No"];
long ret = 0;
@autoreleasepool {
NSAlert *alert = [[[NSAlert alloc] init] autorelease];
[alert setMessageText:[NSString stringWithCString:title.c_str() encoding:[NSString defaultCStringEncoding]]];
[alert setInformativeText:[NSString stringWithCString:text.c_str() encoding:[NSString defaultCStringEncoding]]];
if (type == 0)
{
[alert addButtonWithTitle:@"Okay"];
} else if (type == 1)
{
[alert addButtonWithTitle:@"Okay"];
[alert addButtonWithTitle:@"Cancel"];
} else if (type == 2)
{
[alert addButtonWithTitle:@"Yes"];
[alert addButtonWithTitle:@"No"];
}
ret = [alert runModal];
}
long ret = [alert runModal];
[alert dealloc];
if (ret == NSAlertFirstButtonReturn)
{

14
indra/llwindow/llwindowmacosx.cpp
View File

@ -668,11 +668,11 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
if (cgl_err != kCGLNoError )
{
LL_DEBUGS("GLInit") << "Multi-threaded OpenGL not available." << LL_ENDL;
LL_INFOS("GLInit") << "Multi-threaded OpenGL not available." << LL_ENDL;
}
else
{
LL_DEBUGS("GLInit") << "Multi-threaded OpenGL enabled." << LL_ENDL;
LL_INFOS("GLInit") << "Multi-threaded OpenGL enabled." << LL_ENDL;
}
}
makeFirstResponder(mWindow, mGLView);
@ -1256,8 +1256,11 @@ BOOL LLWindowMacOSX::isClipboardTextAvailable()
}
BOOL LLWindowMacOSX::pasteTextFromClipboard(LLWString &dst)
{
llutf16string str(copyFromPBoard());
{
unsigned short* pboard_data = copyFromPBoard(); // must free returned data
llutf16string str(pboard_data);
free(pboard_data);
dst = utf16str_to_wstring(str);
if (dst != L"")
{
@ -1290,7 +1293,7 @@ LLWindow::LLWindowResolution* LLWindowMacOSX::getSupportedResolutions(S32 &num_r
{
if (!mSupportedResolutions)
{
CFArrayRef modes = CGDisplayAvailableModes(mDisplay);
CFArrayRef modes = CGDisplayCopyAllDisplayModes(mDisplay, nullptr);
if(modes != NULL)
{
@ -1329,6 +1332,7 @@ LLWindow::LLWindowResolution* LLWindowMacOSX::getSupportedResolutions(S32 &num_r
}
}
}
CFRelease(modes);
}
}

1
indra/llwindow/llwindowmacosx.h
View File

@ -231,6 +231,7 @@ protected:
BOOL mLanguageTextInputAllowed;
LLPreeditor* mPreeditor;
public:
static BOOL sUseMultGL;
friend class LLWindowManager;

6
indra/newview/CMakeLists.txt
View File

@ -1844,9 +1844,9 @@ if (WINDOWS)
${SHARED_LIB_STAGING_DIR}/Release/libcollada14dom22.dll
${SHARED_LIB_STAGING_DIR}/RelWithDebInfo/libcollada14dom22.dll
${SHARED_LIB_STAGING_DIR}/Debug/libcollada14dom22-d.dll
${SHARED_LIB_STAGING_DIR}/Release/openjpeg.dll
${SHARED_LIB_STAGING_DIR}/RelWithDebInfo/openjpeg.dll
${SHARED_LIB_STAGING_DIR}/Debug/openjpegd.dll
${SHARED_LIB_STAGING_DIR}/Release/openjp2.dll
${SHARED_LIB_STAGING_DIR}/RelWithDebInfo/openjp2.dll
${SHARED_LIB_STAGING_DIR}/Debug/openjp2.dll
${SHARED_LIB_STAGING_DIR}/Release/libhunspell.dll
${SHARED_LIB_STAGING_DIR}/RelWithDebInfo/libhunspell.dll
${SHARED_LIB_STAGING_DIR}/Debug/libhunspell.dll

11
indra/newview/app_settings/settings.xml
View File

@ -16978,5 +16978,16 @@
<key>Value</key>
<integer>0</integer>
</map>
<key>DebugSettingsHideDefault</key>
<map>
<key>Comment</key>
<string>Show non-default settings only in Debug Settings list</string>
<key>Persist</key>
<integer>0</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>0</integer>
</map>
</map>
</llsd>

50
indra/newview/app_settings/shaders/class1/deferred/skyF.glsl
View File

@ -25,6 +25,17 @@
/*[EXTRA_CODE_HERE]*/
// Inputs
VARYING vec4 vary_HazeColor;
VARYING float vary_LightNormPosDot;
uniform sampler2D rainbow_map;
uniform sampler2D halo_map;
uniform float moisture_level;
uniform float droplet_radius;
uniform float ice_level;
#ifdef DEFINE_GL_FRAGCOLOR
out vec4 frag_data[3];
#else
@ -37,9 +48,34 @@ out vec4 frag_data[3];
VARYING vec3 vary_HazeColor;
vec3 rainbow(float d)
{
// 'Interesting' values of d are -0.75 .. -0.825, i.e. when view vec nearly opposite of sun vec
// Rainbox tex is mapped with REPEAT, so -.75 as tex coord is same as 0.25. -0.825 -> 0.175. etc.
// SL-13629
// Unfortunately the texture is inverted, so we need to invert the y coord, but keep the 'interesting'
// part within the same 0.175..0.250 range, i.e. d = (1 - d) - 1.575
d = clamp(-0.575 - d, 0.0, 1.0);
// With the colors in the lower 1/4 of the texture, inverting the coords leaves most of it inaccessible.
// So, we can stretch the texcoord above the colors (ie > 0.25) to fill the entire remaining coordinate
// space. This improves gradation, reduces banding within the rainbow interior. (1-0.25) / (0.425/0.25) = 4.2857
float interior_coord = max(0.0, d - 0.25) * 4.2857;
d = clamp(d, 0.0, 0.25) + interior_coord;
float rad = (droplet_radius - 5.0f) / 1024.0f;
return pow(texture2D(rainbow_map, vec2(rad+0.5, d)).rgb, vec3(1.8)) * moisture_level;
}
vec3 halo22(float d)
{
d = clamp(d, 0.1, 1.0);
float v = sqrt(clamp(1 - (d * d), 0, 1));
return texture2D(halo_map, vec2(0, v)).rgb * ice_level;
}
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light);
vec3 srgb_to_linear(vec3 c);
void main()
{
@ -48,14 +84,18 @@ void main()
// the fragment) if the sky wouldn't show up because the clouds
// are fully opaque.
vec3 color;
color = vary_HazeColor;
vec3 color = vary_HazeColor;
float rel_pos_lightnorm = vary_LightNormPosDot;
float optic_d = rel_pos_lightnorm;
vec3 halo_22 = halo22(optic_d);
color.rgb += rainbow(optic_d);
color.rgb += halo_22;
color.rgb *= 2.;
color.rgb = scaleSoftClip(color.rgb);
/// Gamma correct for WL (soft clip effect).
frag_data[0] = vec4(color.rgb, 0.0);
// Gamma correct for WL (soft clip effect).
frag_data[0] = vec4(color.rgb, 1.0);
frag_data[1] = vec4(0.0,0.0,0.0,0.0);
frag_data[2] = vec4(0.0,0.0,0.0,GBUFFER_FLAG_SKIP_ATMOS); //1.0 in norm.w masks off fog

35
indra/newview/app_settings/shaders/class1/deferred/skyV.glsl
View File

@ -33,6 +33,7 @@ ATTRIBUTE vec3 position;
// Output parameters
VARYING vec3 vary_HazeColor;
VARYING float vary_LightNormPosDot;
// Inputs
uniform vec3 camPosLocal;
@ -70,27 +71,29 @@ void main()
vec3 rel_pos = position.xyz - camPosLocal.xyz + vec3(0, 50, 0);
// Adj position vector to clamp altitude
if (rel_pos.y > 0)
if (rel_pos.y > 0.)
{
rel_pos *= (max_y / rel_pos.y);
}
if (rel_pos.y < 0)
if (rel_pos.y < 0.)
{
rel_pos *= (-32000. / rel_pos.y);
}
// Can normalize then
vec3 rel_pos_norm = normalize(rel_pos);
// Normalized
vec3 rel_pos_norm = normalize(rel_pos);
float rel_pos_len = length(rel_pos);
float rel_pos_len = length(rel_pos);
// Grab this value and pass to frag shader for rainbows
float rel_pos_lightnorm_dot = dot(rel_pos_norm, lightnorm.xyz);
vary_LightNormPosDot = rel_pos_lightnorm_dot;
// Initialize temp variables
vec3 sunlight = (sun_up_factor == 1) ? sunlight_color : moonlight_color;
vec3 light_atten;
// Sunlight attenuation effect (hue and brightness) due to atmosphere
// this is used later for sunlight modulation at various altitudes
light_atten = (blue_density + vec3(haze_density * 0.25)) * (density_multiplier * max_y);
vec3 light_atten = (blue_density + vec3(haze_density * 0.25)) * (density_multiplier * max_y);
// Calculate relative weights
vec3 combined_haze = abs(blue_density) + vec4(abs(haze_density));
@ -110,7 +113,7 @@ void main()
combined_haze = exp(-combined_haze * density_dist);
// Compute haze glow
float haze_glow = 1.0 - dot(rel_pos_norm, lightnorm.xyz);
float haze_glow = 1.0 - rel_pos_lightnorm_dot;
// haze_glow is 0 at the sun and increases away from sun
haze_glow = max(haze_glow, .001);
// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
@ -121,30 +124,30 @@ void main()
// Add "minimum anti-solar illumination"
// For sun, add to glow. For moon, remove glow entirely. SL-13768
haze_glow = (sun_moon_glow_factor < 1.0) ? 0.0 : (haze_glow + 0.25);
haze_glow = (sun_moon_glow_factor < 1.0) ? 0.0 : (sun_moon_glow_factor * (haze_glow + 0.25));
vec3 color =
(blue_horizon * blue_weight * (sunlight + ambient_color) + (haze_horizon * haze_weight) * (sunlight * haze_glow + ambient_color));
// Haze color above cloud
vec3 color = (blue_horizon * blue_weight * (sunlight + ambient_color)
+ (haze_horizon * haze_weight) * (sunlight * haze_glow + ambient_color));
// Final atmosphere additive
color *= (1. - combined_haze);
// Increase ambient when there are more clouds
vec3 tmpAmbient = ambient_color;
tmpAmbient += max(vec3(0), (1. - ambient_color)) * cloud_shadow * 0.5;
vec3 ambient = ambient_color + max(vec3(0), (1. - ambient_color)) * cloud_shadow * 0.5;
// Dim sunlight by cloud shadow percentage
sunlight *= max(0.0, (1. - cloud_shadow));
// Haze color below cloud
vec3 additiveColorBelowCloud =
(blue_horizon * blue_weight * (sunlight + tmpAmbient) + (haze_horizon * haze_weight) * (sunlight * haze_glow + tmpAmbient));
vec3 add_below_cloud = (blue_horizon * blue_weight * (sunlight + ambient)
+ (haze_horizon * haze_weight) * (sunlight * haze_glow + ambient));
// Attenuate cloud color by atmosphere
combined_haze = sqrt(combined_haze); // less atmos opacity (more transparency) below clouds
// At horizon, blend high altitude sky color towards the darker color below the clouds
color += (additiveColorBelowCloud - color) * (1. - sqrt(combined_haze));
color += (add_below_cloud - color) * (1. - sqrt(combined_haze));
// Haze color above cloud
vary_HazeColor = color;

199
indra/newview/app_settings/shaders/class2/deferred/skyF.glsl
View File

@ -1,199 +0,0 @@
/**
* @file class2/deferred/skyF.glsl
*
* $LicenseInfo:firstyear=2005&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2005, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
uniform mat4 modelview_projection_matrix;
// SKY ////////////////////////////////////////////////////////////////////////
// The vertex shader for creating the atmospheric sky
///////////////////////////////////////////////////////////////////////////////
// Inputs
uniform vec3 camPosLocal;
uniform vec3 lightnorm;
uniform vec3 sunlight_color;
uniform vec3 moonlight_color;
uniform int sun_up_factor;
uniform vec3 ambient_color;
uniform vec3 blue_horizon;
uniform vec3 blue_density;
uniform float haze_horizon;
uniform float haze_density;
uniform float cloud_shadow;
uniform float density_multiplier;
uniform float distance_multiplier;
uniform float max_y;
uniform vec3 glow;
uniform float sun_moon_glow_factor;
uniform vec3 cloud_color;
#ifdef DEFINE_GL_FRAGCOLOR
out vec4 frag_data[3];
#else
#define frag_data gl_FragData
#endif
VARYING vec3 pos;
/////////////////////////////////////////////////////////////////////////
// The fragment shader for the sky
/////////////////////////////////////////////////////////////////////////
uniform sampler2D rainbow_map;
uniform sampler2D halo_map;
uniform float moisture_level;
uniform float droplet_radius;
uniform float ice_level;
vec3 rainbow(float d)
{
// d is the dot product of view and sun directions, so ranging -1.0..1.0
// 'interesting' values of d are the range -0.75..-0.825, when view is nearly opposite of sun vec
// Rainbox texture mode is GL_REPEAT, so tc of -.75 is equiv to 0.25, -0.825 equiv to 0.175.
// SL-13629 Rainbow texture has colors within the correct .175...250 range, but order is inverted.
// Rather than replace the texture, we mirror and translate the y tc to keep the colors within the
// interesting range, but in reversed order: i.e. d = (1 - d) - 1.575
d = clamp(-0.575 - d, 0.0, 1.0);
// With the colors in the lower 1/4 of the texture, inverting the coords leaves most of it inaccessible.
// So, we can stretch the texcoord above the colors (ie > 0.25) to fill the entire remaining coordinate
// space. This improves gradation, reduces banding within the rainbow interior. (1-0.25) / (0.425/0.25) = 4.2857
float interior_coord = max(0.0, d - 0.25) * 4.2857;
d = clamp(d, 0.0, 0.25) + interior_coord;
float rad = (droplet_radius - 5.0f) / 1024.0f;
return pow(texture2D(rainbow_map, vec2(rad, d)).rgb, vec3(1.8)) * moisture_level;
}
vec3 halo22(float d)
{
d = clamp(d, 0.1, 1.0);
float v = sqrt(clamp(1 - (d * d), 0, 1));
return texture2D(halo_map, vec2(0, v)).rgb * ice_level;
}
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light);
void main()
{
// World / view / projection
// Get relative position (offset why?)
vec3 rel_pos = pos.xyz - camPosLocal.xyz + vec3(0, 50, 0);
// Adj position vector to clamp altitude
if (rel_pos.y > 0.)
{
rel_pos *= (max_y / rel_pos.y);
}
if (rel_pos.y < 0.)
{
rel_pos *= (-32000. / rel_pos.y);
}
// Normalized
vec3 rel_pos_norm = normalize(rel_pos);
float rel_pos_len = length(rel_pos);
// Initialize temp variables
vec3 sunlight = (sun_up_factor == 1) ? sunlight_color : moonlight_color;
// Sunlight attenuation effect (hue and brightness) due to atmosphere
// this is used later for sunlight modulation at various altitudes
vec3 light_atten = (blue_density + vec3(haze_density * 0.25)) * (density_multiplier * max_y);
// Calculate relative weights
vec3 combined_haze = abs(blue_density) + vec3(abs(haze_density));
vec3 blue_weight = blue_density / combined_haze;
vec3 haze_weight = haze_density / combined_haze;
// Compute sunlight from rel_pos & lightnorm (for long rays like sky)
float off_axis = 1.0 / max(1e-6, max(0, rel_pos_norm.y) + lightnorm.y);
sunlight *= exp(-light_atten * off_axis);
// Distance
float density_dist = rel_pos_len * density_multiplier;
// Transparency (-> combined_haze)
// ATI Bugfix -- can't store combined_haze*density_dist in a variable because the ati
// compiler gets confused.
combined_haze = exp(-combined_haze * density_dist);
// Compute haze glow
float haze_glow = dot(rel_pos_norm, lightnorm.xyz);
haze_glow = 1. - haze_glow;
// haze_glow is 0 at the sun and increases away from sun
haze_glow = max(haze_glow, .001);
// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
haze_glow *= glow.x;
// Higher glow.x gives dimmer glow (because next step is 1 / "angle")
haze_glow = pow(haze_glow, glow.z);
// glow.z should be negative, so we're doing a sort of (1 / "angle") function
// Add "minimum anti-solar illumination"
// For sun, add to glow. For moon, remove glow entirely. SL-13768
haze_glow = (sun_moon_glow_factor < 1.0) ? 0.0 : (sun_moon_glow_factor * (haze_glow + 0.25));
// Haze color above cloud
vec3 color = blue_horizon * blue_weight * (sunlight + ambient_color)
+ haze_horizon * haze_weight * (sunlight * haze_glow + ambient_color);
// Final atmosphere additive
color *= (1. - combined_haze);
// Increase ambient when there are more clouds
// TODO 9/20: DJH what does this do? max(0,(1-ambient)) will change the color
vec3 ambient = ambient_color + max(vec3(0), (1. - ambient_color)) * cloud_shadow * 0.5;
// Dim sunlight by cloud shadow percentage
sunlight *= max(0.0, (1. - cloud_shadow));
// Haze color below cloud
vec3 add_below_cloud = blue_horizon * blue_weight * (sunlight + ambient)
+ haze_horizon * haze_weight * (sunlight * haze_glow + ambient);
// Attenuate cloud color by atmosphere
combined_haze = sqrt(combined_haze); // less atmos opacity (more transparency) below clouds
// At horizon, blend high altitude sky color towards the darker color below the clouds
color += (add_below_cloud - color) * (1. - sqrt(combined_haze));
float optic_d = dot(rel_pos_norm, lightnorm.xyz);
vec3 halo_22 = halo22(optic_d);
color.rgb += rainbow(optic_d);
color.rgb += halo_22;
color.rgb *= 2.;
color.rgb = scaleSoftClip(color.rgb);
// Gamma correct for WL (soft clip effect).
frag_data[0] = vec4(color.rgb, 1.0);
frag_data[1] = vec4(0.0, 0.0, 0.0, 0.0);
frag_data[2] = vec4(0.0, 0.0, 0.0, GBUFFER_FLAG_SKIP_ATMOS); // 1.0 in norm.w masks off fog
}

42
indra/newview/app_settings/shaders/class2/deferred/skyV.glsl
View File

@ -1,42 +0,0 @@
/**
* @file WLSkyV.glsl
*
* $LicenseInfo:firstyear=2005&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2005, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
uniform mat4 modelview_projection_matrix;
ATTRIBUTE vec3 position;
// SKY ////////////////////////////////////////////////////////////////////////
// The vertex shader for creating the atmospheric sky
///////////////////////////////////////////////////////////////////////////////
VARYING vec3 pos;
void main()
{
// World / view / projection
pos = position.xyz;
gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
}

6
indra/newview/llaccountingcostmanager.cpp
View File

@ -96,11 +96,7 @@ void LLAccountingCostManager::accountingCostCoro(std::string url,
LLSD dataToPost = LLSD::emptyMap();
dataToPost[keystr.c_str()] = objectList;
LLAccountingCostObserver* observer = observerHandle.get();
LLUUID transactionId = observer->getTransactionID();
observer = NULL;
LLAccountingCostObserver* observer = NULL;
LLSD results = httpAdapter->postAndSuspend(httpRequest, url, dataToPost);

15
indra/newview/llappdelegate-objc.mm
View File

@ -46,6 +46,7 @@
- (void)dealloc
{
[currentInputLanguage release];
[super dealloc];
}
@ -199,12 +200,14 @@
- (bool) romanScript
{
// How to add support for new languages with the input window:
// Simply append this array with the language code (ja for japanese, ko for korean, zh for chinese, etc.)
NSArray *nonRomanScript = [[NSArray alloc] initWithObjects:@"ja", @"ko", @"zh-Hant", @"zh-Hans", nil];
if ([nonRomanScript containsObject:currentInputLanguage])
{
return false;
@autoreleasepool {
// How to add support for new languages with the input window:
// Simply append this array with the language code (ja for japanese, ko for korean, zh for chinese, etc.)
NSArray* nonRomanScript = @[@"ja", @"ko", @"zh-Hant", @"zh-Hans"];
if ([nonRomanScript containsObject:currentInputLanguage])
{
return false;
}
}
return true;

2
indra/newview/llappearancemgr.cpp
View File

@ -3987,7 +3987,7 @@ void LLAppearanceMgr::makeNewOutfitLinks(const std::string& new_folder_name, boo
// existence of AIS as an indicator the fix is present. Does
// not actually use AIS to create the category.
inventory_func_type func = boost::bind(&LLAppearanceMgr::onOutfitFolderCreated,this,_1,show_panel);
LLUUID folder_id = gInventory.createNewCategory(
gInventory.createNewCategory(
parent_id,
LLFolderType::FT_OUTFIT,
new_folder_name,

8
indra/newview/llappviewer.cpp
View File

@ -135,6 +135,10 @@
#include "vlc/libvlc_version.h"
#endif // LL_LINUX
#if LL_DARWIN
#include "llwindowmacosx.h"
#endif
// Third party library includes
#include <boost/bind.hpp>
#include <boost/foreach.hpp>
@ -560,6 +564,7 @@ static void settings_to_globals()
LLWorldMapView::setScaleSetting(gSavedSettings.getF32("MapScale"));
#if LL_DARWIN
LLWindowMacOSX::sUseMultGL = gSavedSettings.getBOOL("RenderAppleUseMultGL");
gHiDPISupport = gSavedSettings.getBOOL("RenderHiDPI");
#endif
}
@ -1697,7 +1702,8 @@ bool LLAppViewer::cleanup()
{
if (!isSecondInstance())
{
LLSceneMonitor::instance().dumpToFile(gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "scene_monitor_results.csv"));
std::string dump_path = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "scene_monitor_results.csv");
LLSceneMonitor::instance().dumpToFile(dump_path);
}
LLSceneMonitor::deleteSingleton();
}

3
indra/newview/llavatarrenderinfoaccountant.cpp
View File

@ -364,11 +364,10 @@ void LLAvatarRenderInfoAccountant::getRenderInfoFromRegion(LLViewerRegion * regi
}
}
// static
// Called every frame - send render weight requests to every region
void LLAvatarRenderInfoAccountant::idle()
{
if (mRenderInfoScanTimer.hasExpired())
if (mRenderInfoScanTimer.hasExpired() && !LLApp::isExiting())
{
LL_DEBUGS("AvatarRenderInfo") << "Scanning regions for render info updates"
<< LL_ENDL;

2
indra/newview/llbuycurrencyhtml.cpp
View File

@ -41,7 +41,7 @@ class LLBuyCurrencyHTMLHandler :
{
public:
// requests will be throttled from a non-trusted browser
LLBuyCurrencyHTMLHandler() : LLCommandHandler( "buycurrencyhtml", UNTRUSTED_ALLOW ) {}
LLBuyCurrencyHTMLHandler() : LLCommandHandler( "buycurrencyhtml", UNTRUSTED_THROTTLE) {}
bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
{

14
indra/newview/llcallingcard.cpp
View File

@ -650,8 +650,7 @@ void LLAvatarTracker::processChange(LLMessageSystem* msg)
{
if(mBuddyInfo.find(agent_id) != mBuddyInfo.end())
{
if (((mBuddyInfo[agent_id]->getRightsGrantedFrom() ^ new_rights) & LLRelationship::GRANT_MODIFY_OBJECTS)
&& !gAgent.isDoNotDisturb())
if (((mBuddyInfo[agent_id]->getRightsGrantedFrom() ^ new_rights) & LLRelationship::GRANT_MODIFY_OBJECTS))
{
LLSD args;
args["NAME"] = LLSLURL("agent", agent_id, "displayname").getSLURLString();
@ -719,11 +718,12 @@ void LLAvatarTracker::processNotify(LLMessageSystem* msg, bool online)
// we were tracking someone who went offline
deleteTrackingData();
}
}
if(chat_notify)
{
// Look up the name of this agent for the notification
LLAvatarNameCache::get(agent_id,boost::bind(&on_avatar_name_cache_notify,_1, _2, online, payload));
if(chat_notify)
{
// Look up the name of this agent for the notification
LLAvatarNameCache::get(agent_id,boost::bind(&on_avatar_name_cache_notify,_1, _2, online, payload));
}
}
mModifyMask |= LLFriendObserver::ONLINE;

89
indra/newview/llchathistory.cpp
View File

@ -141,6 +141,18 @@ public:
{
mAvatarNameCacheConnection.disconnect();
}
auto menu = mPopupMenuHandleAvatar.get();
if (menu)
{
menu->die();
mPopupMenuHandleAvatar.markDead();
}
menu = mPopupMenuHandleObject.get();
if (menu)
{
menu->die();
mPopupMenuHandleObject.markDead();
}
}
BOOL handleMouseUp(S32 x, S32 y, MASK mask)
@ -567,36 +579,6 @@ public:
BOOL postBuild()
{
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar registrar_enable;
registrar.add("AvatarIcon.Action", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemClicked, this, _2));
registrar_enable.add("AvatarIcon.Check", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemChecked, this, _2));
registrar_enable.add("AvatarIcon.Enable", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemEnabled, this, _2));
registrar_enable.add("AvatarIcon.Visible", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemVisible, this, _2));
registrar.add("ObjectIcon.Action", boost::bind(&LLChatHistoryHeader::onObjectIconContextMenuItemClicked, this, _2));
registrar_enable.add("ObjectIcon.Visible", boost::bind(&LLChatHistoryHeader::onObjectIconContextMenuItemVisible, this, _2));
LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_avatar_icon.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandleAvatar = menu->getHandle();
}
else
{
LL_WARNS() << " Failed to create menu_avatar_icon.xml" << LL_ENDL;
}
menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_object_icon.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandleObject = menu->getHandle();
}
else
{
LL_WARNS() << " Failed to create menu_object_icon.xml" << LL_ENDL;
}
setDoubleClickCallback(boost::bind(&LLChatHistoryHeader::showInspector, this));
setMouseEnterCallback(boost::bind(&LLChatHistoryHeader::showInfoCtrl, this));
@ -884,13 +866,53 @@ protected:
void showObjectContextMenu(S32 x,S32 y)
{
LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandleObject.get();
if(menu)
if (!menu)
{
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar registrar_enable;
registrar.add("ObjectIcon.Action", boost::bind(&LLChatHistoryHeader::onObjectIconContextMenuItemClicked, this, _2));
registrar_enable.add("ObjectIcon.Visible", boost::bind(&LLChatHistoryHeader::onObjectIconContextMenuItemVisible, this, _2));
menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_object_icon.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandleObject = menu->getHandle();
menu->updateParent(LLMenuGL::sMenuContainer);
LLMenuGL::showPopup(this, menu, x, y);
}
else
{
LL_WARNS() << " Failed to create menu_object_icon.xml" << LL_ENDL;
}
}
else
{
LLMenuGL::showPopup(this, menu, x, y);
}
}
void showAvatarContextMenu(S32 x,S32 y)
{
LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandleAvatar.get();
if (!menu)
{
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar registrar_enable;
registrar.add("AvatarIcon.Action", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemClicked, this, _2));
registrar_enable.add("AvatarIcon.Check", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemChecked, this, _2));
registrar_enable.add("AvatarIcon.Enable", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemEnabled, this, _2));
registrar_enable.add("AvatarIcon.Visible", boost::bind(&LLChatHistoryHeader::onAvatarIconContextMenuItemVisible, this, _2));
menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_avatar_icon.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandleAvatar = menu->getHandle();
}
else
{
LL_WARNS() << " Failed to create menu_avatar_icon.xml" << LL_ENDL;
}
}
if(menu)
{
@ -1082,10 +1104,7 @@ LLChatHistory::LLChatHistory(const LLChatHistory::Params& p)
LLSD LLChatHistory::getValue() const
{
LLSD* text=new LLSD();
text->assign(mEditor->getText());
return *text;
return LLSD(mEditor->getText());
}
LLChatHistory::~LLChatHistory()

66
indra/newview/llchiclet.cpp
View File

@ -67,7 +67,6 @@ LLSysWellChiclet::LLSysWellChiclet(const Params& p)
, mMaxDisplayedCount(p.max_displayed_count)
, mIsNewMessagesState(false)
, mFlashToLitTimer(NULL)
, mContextMenu(NULL)
{
LLButton::Params button_params = p.button;
mButton = LLUICtrlFactory::create<LLButton>(button_params);
@ -79,6 +78,12 @@ LLSysWellChiclet::LLSysWellChiclet(const Params& p)
LLSysWellChiclet::~LLSysWellChiclet()
{
mFlashToLitTimer->unset();
LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
if (menu)
{
menu->die();
mContextMenuHandle.markDead();
}
}
void LLSysWellChiclet::setCounter(S32 counter)
@ -145,14 +150,16 @@ void LLSysWellChiclet::updateWidget(bool is_window_empty)
// virtual
BOOL LLSysWellChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
if(!mContextMenu)
LLContextMenu* menu_avatar = mContextMenuHandle.get();
if(!menu_avatar)
{
createMenu();
menu_avatar = mContextMenuHandle.get();
}
if (mContextMenu)
if (menu_avatar)
{
mContextMenu->show(x, y);
LLMenuGL::showPopup(this, mContextMenu, x, y);
menu_avatar->show(x, y);
LLMenuGL::showPopup(this, menu_avatar, x, y);
}
return TRUE;
}
@ -192,7 +199,7 @@ bool LLNotificationChiclet::enableMenuItem(const LLSD& user_data)
void LLNotificationChiclet::createMenu()
{
if(mContextMenu)
if(mContextMenuHandle.get())
{
LL_WARNS() << "Menu already exists" << LL_ENDL;
return;
@ -207,10 +214,14 @@ void LLNotificationChiclet::createMenu()
boost::bind(&LLNotificationChiclet::enableMenuItem, this, _2));
llassert(LLMenuGL::sMenuContainer != NULL);
mContextMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>
LLContextMenu* menu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>
("menu_notification_well_button.xml",
LLMenuGL::sMenuContainer,
LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mContextMenuHandle = menu->getHandle();
}
}
/*virtual*/
@ -309,10 +320,19 @@ LLIMChiclet::LLIMChiclet(const LLIMChiclet::Params& p)
, mDefaultWidth(p.rect().getWidth())
, mNewMessagesIcon(NULL)
, mChicletButton(NULL)
, mPopupMenu(NULL)
{
}
LLIMChiclet::~LLIMChiclet()
{
auto menu = mPopupMenuHandle.get();
if (menu)
{
menu->die();
mPopupMenuHandle.markDead();
}
}
/* virtual*/
BOOL LLIMChiclet::postBuild()
{
@ -364,16 +384,18 @@ void LLIMChiclet::setToggleState(bool toggle)
BOOL LLIMChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
if(!mPopupMenu)
auto menu = static_cast<LLMenuGL*>(mPopupMenuHandle.get());
if(!menu)
{
createPopupMenu();
menu = static_cast<LLMenuGL*>(mPopupMenuHandle.get());
}
if (mPopupMenu)
if (menu)
{
updateMenuItems();
mPopupMenu->arrangeAndClear();
LLMenuGL::showPopup(this, mPopupMenu, x, y);
menu->arrangeAndClear();
LLMenuGL::showPopup(this, menu, x, y);
}
return TRUE;
@ -381,15 +403,16 @@ BOOL LLIMChiclet::handleRightMouseDown(S32 x, S32 y, MASK mask)
void LLIMChiclet::hidePopupMenu()
{
if (mPopupMenu)
auto menu = mPopupMenuHandle.get();
if (menu)
{
mPopupMenu->setVisible(FALSE);
menu->setVisible(FALSE);
}
}
bool LLIMChiclet::canCreateMenu()
{
if(mPopupMenu)
if(mPopupMenuHandle.get())
{
LL_WARNS() << "Menu already exists" << LL_ENDL;
return false;
@ -1107,8 +1130,13 @@ void LLScriptChiclet::createPopupMenu()
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
registrar.add("ScriptChiclet.Action", boost::bind(&LLScriptChiclet::onMenuItemClicked, this, _2));
mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
("menu_script_chiclet.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandle = menu->getHandle();
}
}
//////////////////////////////////////////////////////////////////////////
@ -1185,8 +1213,12 @@ void LLInvOfferChiclet::createPopupMenu()
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
registrar.add("InvOfferChiclet.Action", boost::bind(&LLInvOfferChiclet::onMenuItemClicked, this, _2));
mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>
("menu_inv_offer_chiclet.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandle = menu->getHandle();
}
}
// EOF

6
indra/newview/llchiclet.h
View File

@ -252,7 +252,7 @@ public:
{};
virtual ~LLIMChiclet() {};
virtual ~LLIMChiclet();
/**
* It is used for default setting up of chicklet:click handler, etc.
@ -325,7 +325,7 @@ protected:
bool canCreateMenu();
LLMenuGL* mPopupMenu;
LLHandle<LLUICtrl> mPopupMenuHandle;
bool mShowSpeaker;
bool mCounterEnabled;
@ -519,7 +519,7 @@ protected:
bool mIsNewMessagesState;
LLFlashTimer* mFlashToLitTimer;
LLContextMenu* mContextMenu;
LLHandle<LLContextMenu> mContextMenuHandle;
};
class LLNotificationChiclet : public LLSysWellChiclet

84
indra/newview/llcommandhandler.cpp
View File

@ -39,6 +39,7 @@
#define THROTTLE_PERIOD 5 // required seconds between throttled commands
static LLCommandDispatcherListener sCommandDispatcherListener;
const std::string LLCommandHandler::NAV_TYPE_CLICKED = "clicked";
//---------------------------------------------------------------------------
// Underlying registry for command handlers, not directly accessible.
@ -64,6 +65,9 @@ public:
bool trusted_browser);
private:
void notifySlurlBlocked();
void notifySlurlThrottled();
friend LLSD LLCommandDispatcher::enumerate();
std::map<std::string, LLCommandHandlerInfo> mMap;
};
@ -96,8 +100,6 @@ bool LLCommandHandlerRegistry::dispatch(const std::string& cmd,
const std::string& nav_type,
bool trusted_browser)
{
static bool slurl_blocked = false;
static bool slurl_throttled = false;
static F64 last_throttle_time = 0.0;
F64 cur_time = 0.0;
std::map<std::string, LLCommandHandlerInfo>::iterator it = mMap.find(cmd);
@ -115,44 +117,45 @@ bool LLCommandHandlerRegistry::dispatch(const std::string& cmd,
// block request from external browser, but report as
// "handled" because it was well formatted.
LL_WARNS_ONCE("SLURL") << "Blocked SLURL command from untrusted browser" << LL_ENDL;
if (! slurl_blocked)
{
if (LLStartUp::getStartupState() >= STATE_BROWSER_INIT)
{
// Note: commands can arrive before we initialize everything we need for Notification.
LLNotificationsUtil::add("BlockedSLURL");
}
slurl_blocked = true;
}
notifySlurlBlocked();
return true;
case LLCommandHandler::UNTRUSTED_CLICK_ONLY:
if (nav_type == LLCommandHandler::NAV_TYPE_CLICKED
&& info.mHandler->canHandleUntrusted(params, query_map, web, nav_type))
{
break;
}
LL_WARNS_ONCE("SLURL") << "Blocked SLURL click-only command " << cmd << " from untrusted browser" << LL_ENDL;
notifySlurlBlocked();
return true;
case LLCommandHandler::UNTRUSTED_THROTTLE:
// if users actually click on a link, we don't need to throttle it
// (throttling mechanism is used to prevent an avalanche of clicks via
// javascript
if ( nav_type == "clicked" )
{
break;
}
//skip initial request from external browser before STATE_BROWSER_INIT
if (LLStartUp::getStartupState() == STATE_FIRST)
{
return true;
}
if (!info.mHandler->canHandleUntrusted(params, query_map, web, nav_type))
{
LL_WARNS_ONCE("SLURL") << "Blocked SLURL command from untrusted browser" << LL_ENDL;
notifySlurlBlocked();
return true;
}
// if users actually click on a link, we don't need to throttle it
// (throttling mechanism is used to prevent an avalanche of clicks via
// javascript
if (nav_type == LLCommandHandler::NAV_TYPE_CLICKED)
{
break;
}
cur_time = LLTimer::getElapsedSeconds();
if (cur_time < last_throttle_time + THROTTLE_PERIOD)
{
// block request from external browser if it happened
// within THROTTLE_PERIOD seconds of the last command
LL_WARNS_ONCE("SLURL") << "Throttled SLURL command from untrusted browser" << LL_ENDL;
if (! slurl_throttled)
{
if (LLStartUp::getStartupState() >= STATE_BROWSER_INIT)
{
LLNotificationsUtil::add("ThrottledSLURL");
}
slurl_throttled = true;
}
notifySlurlThrottled();
return true;
}
last_throttle_time = cur_time;
@ -163,6 +166,34 @@ bool LLCommandHandlerRegistry::dispatch(const std::string& cmd,
return info.mHandler->handle(params, query_map, web);
}
void LLCommandHandlerRegistry::notifySlurlBlocked()
{
static bool slurl_blocked = false;
if (!slurl_blocked)
{
if (LLStartUp::getStartupState() >= STATE_BROWSER_INIT)
{
// Note: commands can arrive before we initialize everything we need for Notification.
LLNotificationsUtil::add("BlockedSLURL");
}
slurl_blocked = true;
}
}
void LLCommandHandlerRegistry::notifySlurlThrottled()
{
static bool slurl_throttled = false;
if (!slurl_throttled)
{
if (LLStartUp::getStartupState() >= STATE_BROWSER_INIT)
{
// Note: commands can arrive before we initialize everything we need for Notification.
LLNotificationsUtil::add("ThrottledSLURL");
}
slurl_throttled = true;
}
}
//---------------------------------------------------------------------------
// Automatic registration of commands, runs before main()
//---------------------------------------------------------------------------
@ -230,6 +261,7 @@ symbol_info symbols[] =
{
ent(LLCommandHandler::UNTRUSTED_ALLOW), // allow commands from untrusted browsers
ent(LLCommandHandler::UNTRUSTED_BLOCK), // ignore commands from untrusted browsers
ent(LLCommandHandler::UNTRUSTED_CLICK_ONLY), // allow untrusted, but only if clicked
ent(LLCommandHandler::UNTRUSTED_THROTTLE) // allow untrusted, but only a few per min.
};

10
indra/newview/llcommandhandler.h
View File

@ -65,9 +65,12 @@ public:
{
UNTRUSTED_ALLOW, // allow commands from untrusted browsers
UNTRUSTED_BLOCK, // ignore commands from untrusted browsers
UNTRUSTED_CLICK_ONLY, // allow untrusted, but only if clicked
UNTRUSTED_THROTTLE // allow untrusted, but only a few per min.
};
static const std::string NAV_TYPE_CLICKED;
LLCommandHandler(const char* command, EUntrustedAccess untrusted_access);
// Automatically registers object to get called when
// command is executed. All commands can be processed
@ -76,6 +79,13 @@ public:
virtual ~LLCommandHandler();
virtual bool canHandleUntrusted(
const LLSD& params,
const LLSD& query_map,
LLMediaCtrl* web,
const std::string& nav_type)
{ return true; }
virtual bool handle(const LLSD& params,
const LLSD& query_map,
LLMediaCtrl* web) = 0;

3
indra/newview/llenvironment.cpp
View File

@ -684,7 +684,6 @@ namespace
if (!injection->mBlendIn)
mix = 1.0 - mix;
stringset_t dummy;
LLUUID cloud_noise_id = getCloudNoiseTextureId();
F64 value = this->mSettings[injection->mKeyName].asReal();
if (this->getCloudNoiseTextureId().isNull())
{
@ -3129,7 +3128,7 @@ bool LLEnvironment::loadFromSettings()
LL_INFOS("ENVIRONMENT") << "Unable to open previous session environment file " << user_filepath << LL_ENDL;
}
if (!env_data.isMap() || env_data.emptyMap())
if (!env_data.isMap() || (env_data.size() == 0))
{
LL_DEBUGS("ENVIRONMENT") << "Empty map loaded from: " << user_filepath << LL_ENDL;
return false;

10
indra/newview/llfilepicker.cpp
View File

@ -593,9 +593,9 @@ BOOL LLFilePicker::getSaveFile(ESaveFilter filter, const std::string& filename,
#elif LL_DARWIN
std::vector<std::string>* LLFilePicker::navOpenFilterProc(ELoadFilter filter) //(AEDesc *theItem, void *info, void *callBackUD, NavFilterModes filterMode)
std::unique_ptr<std::vector<std::string>> LLFilePicker::navOpenFilterProc(ELoadFilter filter) //(AEDesc *theItem, void *info, void *callBackUD, NavFilterModes filterMode)
{
std::vector<std::string> *allowedv = new std::vector< std::string >;
std::unique_ptr<std::vector<std::string>> allowedv(new std::vector< std::string >);
switch(filter)
{
case FFLOAD_ALL:
@ -669,9 +669,9 @@ bool LLFilePicker::doNavChooseDialog(ELoadFilter filter)
gViewerWindow->getWindow()->beforeDialog();
std::vector<std::string> *allowed_types=navOpenFilterProc(filter);
std::unique_ptr<std::vector<std::string>> allowed_types = navOpenFilterProc(filter);
std::vector<std::string> *filev = doLoadDialog(allowed_types,
std::unique_ptr<std::vector<std::string>> filev = doLoadDialog(allowed_types.get(),
mPickOptions);
gViewerWindow->getWindow()->afterDialog();
@ -786,7 +786,7 @@ bool LLFilePicker::doNavSaveDialog(ESaveFilter filter, const std::string& filena
gViewerWindow->getWindow()->beforeDialog();
// Run the dialog
std::string* filev = doSaveDialog(&namestring,
std::unique_ptr<std::string> filev = doSaveDialog(&namestring,
&type,
&creator,
&extension,

2
indra/newview/llfilepicker.h
View File

@ -165,7 +165,7 @@ private:
bool doNavChooseDialog(ELoadFilter filter);
bool doNavSaveDialog(ESaveFilter filter, const std::string& filename);
std::vector<std::string>* navOpenFilterProc(ELoadFilter filter);
std::unique_ptr<std::vector<std::string>> navOpenFilterProc(ELoadFilter filter);
#endif
#if LL_GTK

4
indra/newview/llfilepicker_mac.h
View File

@ -39,9 +39,9 @@
#include <vector>
//void modelessPicker();
std::vector<std::string>* doLoadDialog(const std::vector<std::string>* allowed_types,
std::unique_ptr<std::vector<std::string>> doLoadDialog(const std::vector<std::string>* allowed_types,
unsigned int flags);
std::string* doSaveDialog(const std::string* file,
std::unique_ptr<std::string> doSaveDialog(const std::string* file,
const std::string* type,
const std::string* creator,
const std::string* extension,

157
indra/newview/llfilepicker_mac.mm
View File

@ -29,104 +29,107 @@
#include <iostream>
#include "llfilepicker_mac.h"
std::vector<std::string>* doLoadDialog(const std::vector<std::string>* allowed_types,
std::unique_ptr<std::vector<std::string>> doLoadDialog(const std::vector<std::string>* allowed_types,
unsigned int flags)
{
int i, result;
//Aura TODO: We could init a small window and release it at the end of this routine
//for a modeless interface.
NSOpenPanel *panel = [NSOpenPanel openPanel];
//NSString *fileName = nil;
NSMutableArray *fileTypes = nil;
if ( allowed_types && !allowed_types->empty())
{
fileTypes = [[NSMutableArray alloc] init];
std::unique_ptr<std::vector<std::string>> outfiles;
@autoreleasepool {
int i, result;
//Aura TODO: We could init a small window and release it at the end of this routine
//for a modeless interface.
for (i=0;i<allowed_types->size();++i)
NSOpenPanel *panel = [NSOpenPanel openPanel];
//NSString *fileName = nil;
NSMutableArray *fileTypes = nil;
if ( allowed_types && !allowed_types->empty())
{
[fileTypes addObject:
[NSString stringWithCString:(*allowed_types)[i].c_str()
encoding:[NSString defaultCStringEncoding]]];
fileTypes = [[[NSMutableArray alloc] init] autorelease];
for (i=0;i<allowed_types->size();++i)
{
[fileTypes addObject:
[NSString stringWithCString:(*allowed_types)[i].c_str()
encoding:[NSString defaultCStringEncoding]]];
}
}
}
//[panel setMessage:@"Import one or more files or directories."];
[panel setAllowsMultipleSelection: ( (flags & F_MULTIPLE)?true:false ) ];
[panel setCanChooseDirectories: ( (flags & F_DIRECTORY)?true:false ) ];
[panel setCanCreateDirectories: true];
[panel setResolvesAliases: true];
[panel setCanChooseFiles: ( (flags & F_FILE)?true:false )];
[panel setTreatsFilePackagesAsDirectories: ( flags & F_NAV_SUPPORT ) ];
std::vector<std::string>* outfiles = NULL;
if (fileTypes)
{
[panel setAllowedFileTypes:fileTypes];
result = [panel runModal];
}
else
{
// I suggest it's better to open the last path and let this default to home dir as necessary
// for consistency with other OS X apps
//
//[panel setDirectoryURL: fileURLWithPath(NSHomeDirectory()) ];
result = [panel runModal];
}
if (result == NSOKButton)
{
NSArray *filesToOpen = [panel URLs];
int i, count = [filesToOpen count];
//[panel setMessage:@"Import one or more files or directories."];
[panel setAllowsMultipleSelection: ( (flags & F_MULTIPLE)?true:false ) ];
[panel setCanChooseDirectories: ( (flags & F_DIRECTORY)?true:false ) ];
[panel setCanCreateDirectories: true];
[panel setResolvesAliases: true];
[panel setCanChooseFiles: ( (flags & F_FILE)?true:false )];
[panel setTreatsFilePackagesAsDirectories: ( flags & F_NAV_SUPPORT ) ];
if (count > 0)
if (fileTypes)
{
outfiles = new std::vector<std::string>;
[panel setAllowedFileTypes:fileTypes];
result = [panel runModal];
}
else
{
// I suggest it's better to open the last path and let this default to home dir as necessary
// for consistency with other OS X apps
//
//[panel setDirectoryURL: fileURLWithPath(NSHomeDirectory()) ];
result = [panel runModal];
}
for (i=0; i<count; i++) {
NSString *aFile = [[filesToOpen objectAtIndex:i] path];
std::string *afilestr = new std::string([aFile UTF8String]);
outfiles->push_back(*afilestr);
if (result == NSOKButton)
{
NSArray *filesToOpen = [panel URLs];
int i, count = [filesToOpen count];
if (count > 0)
{
outfiles.reset(new std::vector<std::string>);
}
for (i=0; i<count; i++) {
NSString *aFile = [[filesToOpen objectAtIndex:i] path];
std::string afilestr = std::string([aFile UTF8String]);
outfiles->push_back(afilestr);
}
}
}
return outfiles;
}
std::string* doSaveDialog(const std::string* file,
std::unique_ptr<std::string> doSaveDialog(const std::string* file,
const std::string* type,
const std::string* creator,
const std::string* extension,
unsigned int flags)
{
NSSavePanel *panel = [NSSavePanel savePanel];
NSString *extensionns = [NSString stringWithCString:extension->c_str() encoding:[NSString defaultCStringEncoding]];
NSArray *fileType = [extensionns componentsSeparatedByString:@","];
//[panel setMessage:@"Save Image File"];
[panel setTreatsFilePackagesAsDirectories: ( flags & F_NAV_SUPPORT ) ];
[panel setCanSelectHiddenExtension:true];
[panel setAllowedFileTypes:fileType];
NSString *fileName = [NSString stringWithCString:file->c_str() encoding:[NSString defaultCStringEncoding]];
std::string *outfile = NULL;
NSURL* url = [NSURL fileURLWithPath:fileName];
[panel setNameFieldStringValue: fileName];
[panel setDirectoryURL: url];
if([panel runModal] ==
NSFileHandlingPanelOKButton)
{
NSURL* url = [panel URL];
NSString* p = [url path];
outfile = new std::string( [p UTF8String] );
// write the file
}
std::unique_ptr<std::string> outfile;
@autoreleasepool {
NSSavePanel *panel = [NSSavePanel savePanel];
NSString *extensionns = [NSString stringWithCString:extension->c_str() encoding:[NSString defaultCStringEncoding]];
NSArray *fileType = [extensionns componentsSeparatedByString:@","];
//[panel setMessage:@"Save Image File"];
[panel setTreatsFilePackagesAsDirectories: ( flags & F_NAV_SUPPORT ) ];
[panel setCanSelectHiddenExtension:true];
[panel setAllowedFileTypes:fileType];
NSString *fileName = [NSString stringWithCString:file->c_str() encoding:[NSString defaultCStringEncoding]];
NSURL* url = [NSURL fileURLWithPath:fileName];
[panel setNameFieldStringValue: fileName];
[panel setDirectoryURL: url];
if([panel runModal] ==
NSFileHandlingPanelOKButton)
{
NSURL* url = [panel URL];
NSString* p = [url path];
outfile.reset(new std::string([p UTF8String]));
// write the file
}
}
return outfile;
}

12
indra/newview/llfloater360capture.cpp
View File

@ -537,7 +537,8 @@ void LLFloater360Capture::capture360Images()
// We need to convert from the angle getYaw() gives us into something
// the XMP data field wants (N=0, E=90, S=180, W= 270 etc.)
mInitialHeadingDeg = (360 + 90 - (int)(camera->getYaw() * RAD_TO_DEG)) % 360;
LL_INFOS("360Capture") << "Recording a heading of " << (int)(mInitialHeadingDeg) << LL_ENDL;
LL_INFOS("360Capture") << "Recording a heading of " << (int)(mInitialHeadingDeg)
<< " Image size: " << (S32)mSourceImageSize << LL_ENDL;
// camera constants for the square, cube map capture image
camera->setAspect(1.0); // must set aspect ratio first to avoid undesirable clamping of vertical FoV
@ -587,6 +588,9 @@ void LLFloater360Capture::capture360Images()
// for each of the 6 directions we shoot...
for (int i = 0; i < 6; i++)
{
LLAppViewer::instance()->pauseMainloopTimeout();
LLViewerStats::instance().getRecording().stop();
// these buffers are where the raw, captured pixels are stored and
// the first time we use them, we have to make a new one
if (mRawImages[i] == nullptr)
@ -624,8 +628,10 @@ void LLFloater360Capture::capture360Images()
auto duration = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start);
encode_time_total += duration.count();
// ping the main loop in case the snapshot process takes a really long
// time and we get disconnected
LLViewerStats::instance().getRecording().resume();
LLAppViewer::instance()->resumeMainloopTimeout();
// update main loop timeout state
LLAppViewer::instance()->pingMainloopTimeout("LLFloater360Capture::capture360Images");
}

14
indra/newview/llfloateravatar.cpp
View File

@ -44,17 +44,21 @@ LLFloaterAvatar::LLFloaterAvatar(const LLSD& key)
LLFloaterAvatar::~LLFloaterAvatar()
{
LLMediaCtrl* avatar_picker = findChild<LLMediaCtrl>("avatar_picker_contents");
if (avatar_picker)
if (mAvatarPicker)
{
avatar_picker->navigateStop();
avatar_picker->clearCache(); //images are reloading each time already
avatar_picker->unloadMediaSource();
mAvatarPicker->navigateStop();
mAvatarPicker->clearCache(); //images are reloading each time already
mAvatarPicker->unloadMediaSource();
}
}
BOOL LLFloaterAvatar::postBuild()
{
mAvatarPicker = findChild<LLMediaCtrl>("avatar_picker_contents");
if (mAvatarPicker)
{
mAvatarPicker->clearCache();
}
enableResizeCtrls(true, true, false);
return TRUE;
}

3
indra/newview/llfloateravatar.h
View File

@ -29,6 +29,7 @@
#define LL_FLOATER_AVATAR_H
#include "llfloater.h"
class LLMediaCtrl;
class LLFloaterAvatar:
public LLFloater
@ -38,6 +39,8 @@ private:
LLFloaterAvatar(const LLSD& key);
/*virtual*/ ~LLFloaterAvatar();
/*virtual*/ BOOL postBuild();
LLMediaCtrl* mAvatarPicker;
};
#endif

35
indra/newview/llfloaterbump.cpp
View File

@ -69,6 +69,12 @@ LLFloaterBump::LLFloaterBump(const LLSD& key)
// Destroys the object
LLFloaterBump::~LLFloaterBump()
{
auto menu = mPopupMenuHandle.get();
if (menu)
{
menu->die();
mPopupMenuHandle.markDead();
}
}
BOOL LLFloaterBump::postBuild()
@ -77,11 +83,15 @@ BOOL LLFloaterBump::postBuild()
mList->setAllowMultipleSelection(false);
mList->setRightMouseDownCallback(boost::bind(&LLFloaterBump::onScrollListRightClicked, this, _1, _2, _3));
mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>("menu_avatar_other.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
mPopupMenu->setItemVisible(std::string("Normal"), false);
mPopupMenu->setItemVisible(std::string("Always use impostor"), false);
mPopupMenu->setItemVisible(std::string("Never use impostor"), false);
mPopupMenu->setItemVisible(std::string("Impostor seperator"), false);
LLContextMenu* menu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>("menu_avatar_other.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if (menu)
{
mPopupMenuHandle = menu->getHandle();
menu->setItemVisible(std::string("Normal"), false);
menu->setItemVisible(std::string("Always use impostor"), false);
menu->setItemVisible(std::string("Never use impostor"), false);
menu->setItemVisible(std::string("Impostor seperator"), false);
}
return TRUE;
}
@ -176,18 +186,19 @@ void LLFloaterBump::onScrollListRightClicked(LLUICtrl* ctrl, S32 x, S32 y)
if (!gMeanCollisionList.empty())
{
LLScrollListItem* item = mList->hitItem(x, y);
if (item && mPopupMenu)
auto menu = mPopupMenuHandle.get();
if (item && menu)
{
mItemUUID = item->getUUID();
mPopupMenu->buildDrawLabels();
mPopupMenu->updateParent(LLMenuGL::sMenuContainer);
menu->buildDrawLabels();
menu->updateParent(LLMenuGL::sMenuContainer);
std::string mute_msg = (LLMuteList::getInstance()->isMuted(mItemUUID, mNames[mItemUUID])) ? "UnmuteAvatar" : "MuteAvatar";
mPopupMenu->getChild<LLUICtrl>("Avatar Mute")->setValue(LLTrans::getString(mute_msg));
mPopupMenu->setItemEnabled(std::string("Zoom In"), bool(gObjectList.findObject(mItemUUID)));
menu->getChild<LLUICtrl>("Avatar Mute")->setValue(LLTrans::getString(mute_msg));
menu->setItemEnabled(std::string("Zoom In"), bool(gObjectList.findObject(mItemUUID)));
((LLContextMenu*)mPopupMenu)->show(x, y);
LLMenuGL::showPopup(ctrl, mPopupMenu, x, y);
menu->show(x, y);
LLMenuGL::showPopup(ctrl, menu, x, y);
}
}
}

2
indra/newview/llfloaterbump.h
View File

@ -68,7 +68,7 @@ private:
virtual ~LLFloaterBump();
LLScrollListCtrl* mList;
LLMenuGL* mPopupMenu;
LLHandle<LLContextMenu> mPopupMenuHandle;
LLUUID mItemUUID;
typedef std::map<LLUUID, std::string> uuid_map_t;

1
indra/newview/llfloatercreatelandmark.cpp
View File

@ -316,7 +316,6 @@ void LLFloaterCreateLandmark::onSaveClicked()
LLStringUtil::trim(current_title_value);
LLStringUtil::trim(current_notes_value);
LLUUID item_id = mItem->getUUID();
LLUUID folder_id = mFolderCombo->getValue().asUUID();
bool change_parent = folder_id != mItem->getParentUUID();

1
indra/newview/llfloaterimcontainer.cpp
View File

@ -211,6 +211,7 @@ BOOL LLFloaterIMContainer::postBuild()
p.options_menu = "menu_conversation.xml";
mConversationsRoot = LLUICtrlFactory::create<LLFolderView>(p);
mConversationsRoot->setCallbackRegistrar(&mCommitCallbackRegistrar);
mConversationsRoot->setEnableRegistrar(&mEnableCallbackRegistrar);
// Add listener to conversation model events
mConversationsEventStream.listen("ConversationsRefresh", boost::bind(&LLFloaterIMContainer::onConversationModelEvent, this, _1));

1
indra/newview/llfloaterimsessiontab.cpp
View File

@ -316,6 +316,7 @@ BOOL LLFloaterIMSessionTab::postBuild()
p.name = "root";
mConversationsRoot = LLUICtrlFactory::create<LLFolderView>(p);
mConversationsRoot->setCallbackRegistrar(&mCommitCallbackRegistrar);
mConversationsRoot->setEnableRegistrar(&mEnableCallbackRegistrar);
// Attach that root to the scroller
mScroller->addChild(mConversationsRoot);
mConversationsRoot->setScrollContainer(mScroller);

2
indra/newview/llfloatermodelpreview.cpp
View File

@ -1740,7 +1740,7 @@ void LLFloaterModelPreview::toggleCalculateButton(bool visible)
childSetTextArg("download_weight", "[ST]", tbd);
childSetTextArg("server_weight", "[SIM]", tbd);
childSetTextArg("physics_weight", "[PH]", tbd);
if (!mModelPhysicsFee.isMap() || mModelPhysicsFee.emptyMap())
if (!mModelPhysicsFee.isMap() || (mModelPhysicsFee.size() == 0))
{
childSetTextArg("upload_fee", "[FEE]", tbd);
}

14
indra/newview/llfloateropenobject.cpp
View File

@ -56,8 +56,6 @@ LLFloaterOpenObject::LLFloaterOpenObject(const LLSD& key)
mDirty(TRUE)
{
mCommitCallbackRegistrar.add("OpenObject.MoveToInventory", boost::bind(&LLFloaterOpenObject::onClickMoveToInventory, this));
mCommitCallbackRegistrar.add("OpenObject.MoveAndWear", boost::bind(&LLFloaterOpenObject::onClickMoveAndWear, this));
mCommitCallbackRegistrar.add("OpenObject.ReplaceOutfit", boost::bind(&LLFloaterOpenObject::onClickReplace, this));
mCommitCallbackRegistrar.add("OpenObject.Cancel", boost::bind(&LLFloaterOpenObject::onClickCancel, this));
}
@ -243,18 +241,6 @@ void LLFloaterOpenObject::onClickMoveToInventory()
closeFloater();
}
void LLFloaterOpenObject::onClickMoveAndWear()
{
moveToInventory(true, false);
closeFloater();
}
void LLFloaterOpenObject::onClickReplace()
{
moveToInventory(true, true);
closeFloater();
}
void LLFloaterOpenObject::onClickCancel()
{
closeFloater();

2
indra/newview/llfloateropenobject.h
View File

@ -63,8 +63,6 @@ protected:
void moveToInventory(bool wear, bool replace = false);
void onClickMoveToInventory();
void onClickMoveAndWear();
void onClickReplace();
void onClickCancel();
static void callbackCreateInventoryCategory(const LLUUID& category_id, LLUUID object_id, bool wear, bool replace = false);
static void callbackMoveInventory(S32 result, void* data);

1
indra/newview/llfloateroutfitphotopreview.cpp
View File

@ -234,7 +234,6 @@ void LLFloaterOutfitPhotoPreview::updateImageID()
if(item)
{
mImageID = item->getAssetUUID();
LLPermissions perm(item->getPermissions());
}
else
{

17
indra/newview/llfloaterpathfindinglinksets.cpp
View File

@ -44,6 +44,7 @@
#include "llpathfindinglinkset.h"
#include "llpathfindinglinksetlist.h"
#include "llpathfindingmanager.h"
#include "llsearcheditor.h"
#include "llscrolllistitem.h"
#include "llsd.h"
#include "lltextbase.h"
@ -114,17 +115,13 @@ BOOL LLFloaterPathfindingLinksets::postBuild()
{
mBeaconColor = LLUIColorTable::getInstance()->getColor("PathfindingLinksetBeaconColor");
mFilterByName = findChild<LLLineEditor>("filter_by_name");
llassert(mFilterByName != NULL);
mFilterByName->setCommitCallback(boost::bind(&LLFloaterPathfindingLinksets::onApplyAllFilters, this));
mFilterByName->setSelectAllonFocusReceived(true);
mFilterByName->setCommitOnFocusLost(true);
mFilterByName = getChild<LLSearchEditor>("filter_by_name");
mFilterByName->setCommitCallback(boost::bind(&LLFloaterPathfindingLinksets::onApplyAllFilters, this));
mFilterByName->setCommitOnFocusLost(true);
mFilterByDescription = findChild<LLLineEditor>("filter_by_description");
llassert(mFilterByDescription != NULL);
mFilterByDescription->setCommitCallback(boost::bind(&LLFloaterPathfindingLinksets::onApplyAllFilters, this));
mFilterByDescription->setSelectAllonFocusReceived(true);
mFilterByDescription->setCommitOnFocusLost(true);
mFilterByDescription = getChild<LLSearchEditor>("filter_by_description");
mFilterByDescription->setCommitCallback(boost::bind(&LLFloaterPathfindingLinksets::onApplyAllFilters, this));
mFilterByDescription->setCommitOnFocusLost(true);
mFilterByLinksetUse = findChild<LLComboBox>("filter_by_linkset_use");
llassert(mFilterByLinksetUse != NULL);

5
indra/newview/llfloaterpathfindinglinksets.h
View File

@ -42,6 +42,7 @@ class LLSD;
class LLTextBase;
class LLUICtrl;
class LLVector3;
class LLSearchEditor;
class LLFloaterPathfindingLinksets : public LLFloaterPathfindingObjects
{
@ -105,8 +106,8 @@ private:
LLPathfindingLinkset::ELinksetUse convertToLinksetUse(LLSD pXuiValue) const;
LLSD convertToXuiValue(LLPathfindingLinkset::ELinksetUse pLinksetUse) const;
LLLineEditor *mFilterByName;
LLLineEditor *mFilterByDescription;
LLSearchEditor *mFilterByName;
LLSearchEditor *mFilterByDescription;
LLComboBox *mFilterByLinksetUse;
LLComboBox *mEditLinksetUse;
LLScrollListItem *mEditLinksetUseUnset;

1
indra/newview/llfloaterscriptlimits.cpp
View File

@ -421,7 +421,6 @@ void LLPanelScriptLimitsRegionMemory::setRegionDetails(LLSD content)
for(S32 i = 0; i < number_parcels; i++)
{
std::string parcel_name = content["parcels"][i]["name"].asString();
LLUUID parcel_id = content["parcels"][i]["id"].asUUID();
S32 number_objects = content["parcels"][i]["objects"].size();
S32 local_id = 0;

2
indra/newview/llfloatersearch.cpp
View File

@ -45,7 +45,7 @@ class LLSearchHandler : public LLCommandHandler
{
public:
// requires trusted browser to trigger
LLSearchHandler() : LLCommandHandler("search", UNTRUSTED_THROTTLE) { }
LLSearchHandler() : LLCommandHandler("search", UNTRUSTED_CLICK_ONLY) { }
bool handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web)
{
if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableSearch"))

283
indra/newview/llfloatersettingsdebug.cpp
View File

@ -2,9 +2,9 @@
* @file llfloatersettingsdebug.cpp
* @brief floater for debugging internal viewer settings
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* $LicenseInfo:firstyear=2022&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
* Copyright (C) 2022, 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
@ -27,8 +27,8 @@
#include "llviewerprecompiledheaders.h"
#include "llfloatersettingsdebug.h"
#include "llfloater.h"
#include "llfiltereditor.h"
#include "lluictrlfactory.h"
//#include "llfirstuse.h"
#include "llcombobox.h"
#include "llspinctrl.h"
#include "llcolorswatch.h"
@ -37,12 +37,11 @@
LLFloaterSettingsDebug::LLFloaterSettingsDebug(const LLSD& key)
: LLFloater(key)
: LLFloater(key),
mSettingList(NULL)
{
mCommitCallbackRegistrar.add("SettingSelect", boost::bind(&LLFloaterSettingsDebug::onSettingSelect, this,_1));
mCommitCallbackRegistrar.add("CommitSettings", boost::bind(&LLFloaterSettingsDebug::onCommitSettings, this));
mCommitCallbackRegistrar.add("ClickDefault", boost::bind(&LLFloaterSettingsDebug::onClickDefault, this));
}
LLFloaterSettingsDebug::~LLFloaterSettingsDebug()
@ -50,59 +49,43 @@ LLFloaterSettingsDebug::~LLFloaterSettingsDebug()
BOOL LLFloaterSettingsDebug::postBuild()
{
LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
enableResizeCtrls(true, false, true);
struct f : public LLControlGroup::ApplyFunctor
{
LLComboBox* combo;
f(LLComboBox* c) : combo(c) {}
virtual void apply(const std::string& name, LLControlVariable* control)
{
if (!control->isHiddenFromSettingsEditor())
{
combo->add(name, (void*)control);
}
}
} func(settings_combo);
mComment = getChild<LLTextEditor>("comment_text");
std::string key = getKey().asString();
if (key == "all" || key == "base")
{
gSavedSettings.applyToAll(&func);
}
if (key == "all" || key == "account")
{
gSavedPerAccountSettings.applyToAll(&func);
}
getChild<LLFilterEditor>("filter_input")->setCommitCallback(boost::bind(&LLFloaterSettingsDebug::setSearchFilter, this, _2));
mSettingList = getChild<LLScrollListCtrl>("setting_list");
mSettingList->setCommitOnSelectionChange(TRUE);
mSettingList->setCommitCallback(boost::bind(&LLFloaterSettingsDebug::onSettingSelect, this));
updateList();
gSavedSettings.getControl("DebugSettingsHideDefault")->getCommitSignal()->connect(boost::bind(&LLFloaterSettingsDebug::updateList, this, false));
settings_combo->sortByName();
settings_combo->updateSelection();
mComment = getChild<LLTextEditor>("comment_text");
return TRUE;
}
void LLFloaterSettingsDebug::draw()
{
LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
updateControl(controlp);
LLScrollListItem* first_selected = mSettingList->getFirstSelected();
if (first_selected)
{
LLControlVariable* controlp = (LLControlVariable*)first_selected->getUserdata();
updateControl(controlp);
}
LLFloater::draw();
}
//static
void LLFloaterSettingsDebug::onSettingSelect(LLUICtrl* ctrl)
{
LLComboBox* combo_box = (LLComboBox*)ctrl;
LLControlVariable* controlp = (LLControlVariable*)combo_box->getCurrentUserdata();
updateControl(controlp);
}
void LLFloaterSettingsDebug::onCommitSettings()
{
LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
LLScrollListItem* first_selected = mSettingList->getFirstSelected();
if (!first_selected)
{
return;
}
LLControlVariable* controlp = (LLControlVariable*)first_selected->getUserdata();
if (!controlp)
{
@ -176,19 +159,23 @@ void LLFloaterSettingsDebug::onCommitSettings()
default:
break;
}
updateDefaultColumn(controlp);
}
// static
void LLFloaterSettingsDebug::onClickDefault()
{
LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
if (controlp)
{
controlp->resetToDefault(true);
updateControl(controlp);
}
LLScrollListItem* first_selected = mSettingList->getFirstSelected();
if (first_selected)
{
LLControlVariable* controlp = (LLControlVariable*)first_selected->getUserdata();
if (controlp)
{
controlp->resetToDefault(true);
updateDefaultColumn(controlp);
updateControl(controlp);
}
}
}
// we've switched controls, or doing per-frame update, so update spinners, etc.
@ -207,23 +194,30 @@ void LLFloaterSettingsDebug::updateControl(LLControlVariable* controlp)
return;
}
spinner1->setVisible(FALSE);
spinner2->setVisible(FALSE);
spinner3->setVisible(FALSE);
spinner4->setVisible(FALSE);
color_swatch->setVisible(FALSE);
getChildView("val_text")->setVisible( FALSE);
mComment->setText(LLStringUtil::null);
hideUIControls();
if (controlp)
if (controlp && !isSettingHidden(controlp))
{
eControlType type = controlp->type();
//hide combo box only for non booleans, otherwise this will result in the combo box closing every frame
getChildView("boolean_combo")->setVisible( type == TYPE_BOOLEAN);
getChildView("default_btn")->setVisible(true);
getChildView("setting_name_txt")->setVisible(true);
getChild<LLTextBox>("setting_name_txt")->setText(controlp->getName());
getChild<LLTextBox>("setting_name_txt")->setToolTip(controlp->getName());
mComment->setVisible(true);
std::string old_text = mComment->getText();
std::string new_text = controlp->getComment();
// Don't setText if not nessesary, it will reset scroll
// This is a debug UI that reads from xml, there might
// be use cases where comment changes, but not the name
if (old_text != new_text)
{
mComment->setText(controlp->getComment());
}
mComment->setText(controlp->getComment());
spinner1->setMaxValue(F32_MAX);
spinner2->setMaxValue(F32_MAX);
spinner3->setMaxValue(F32_MAX);
@ -479,3 +473,166 @@ void LLFloaterSettingsDebug::updateControl(LLControlVariable* controlp)
}
}
void LLFloaterSettingsDebug::updateList(bool skip_selection)
{
std::string last_selected;
LLScrollListItem* item = mSettingList->getFirstSelected();
if (item)
{
LLScrollListCell* cell = item->getColumn(1);
if (cell)
{
last_selected = cell->getValue().asString();
}
}
mSettingList->deleteAllItems();
struct f : public LLControlGroup::ApplyFunctor
{
LLScrollListCtrl* setting_list;
LLFloaterSettingsDebug* floater;
std::string selected_setting;
bool skip_selection;
f(LLScrollListCtrl* list, LLFloaterSettingsDebug* floater, std::string setting, bool skip_selection)
: setting_list(list), floater(floater), selected_setting(setting), skip_selection(skip_selection) {}
virtual void apply(const std::string& name, LLControlVariable* control)
{
if (!control->isHiddenFromSettingsEditor() && floater->matchesSearchFilter(name) && !floater->isSettingHidden(control))
{
LLSD row;
row["columns"][0]["column"] = "changed_setting";
row["columns"][0]["value"] = control->isDefault() ? "" : "*";
row["columns"][1]["column"] = "setting";
row["columns"][1]["value"] = name;
LLScrollListItem* item = setting_list->addElement(row, ADD_BOTTOM, (void*)control);
if (!floater->mSearchFilter.empty() && (selected_setting == name) && !skip_selection)
{
std::string lower_name(name);
LLStringUtil::toLower(lower_name);
if (LLStringUtil::startsWith(lower_name, floater->mSearchFilter))
{
item->setSelected(true);
}
}
}
}
} func(mSettingList, this, last_selected, skip_selection);
std::string key = getKey().asString();
if (key == "all" || key == "base")
{
gSavedSettings.applyToAll(&func);
}
if (key == "all" || key == "account")
{
gSavedPerAccountSettings.applyToAll(&func);
}
if (!mSettingList->isEmpty())
{
if (mSettingList->hasSelectedItem())
{
mSettingList->scrollToShowSelected();
}
else if (!mSettingList->hasSelectedItem() && !mSearchFilter.empty() && !skip_selection)
{
if (!mSettingList->selectItemByPrefix(mSearchFilter, false, 1))
{
mSettingList->selectFirstItem();
}
mSettingList->scrollToShowSelected();
}
}
else
{
LLSD row;
row["columns"][0]["column"] = "changed_setting";
row["columns"][0]["value"] = "";
row["columns"][1]["column"] = "setting";
row["columns"][1]["value"] = "No matching settings.";
mSettingList->addElement(row);
hideUIControls();
}
}
void LLFloaterSettingsDebug::onSettingSelect()
{
LLScrollListItem* first_selected = mSettingList->getFirstSelected();
if (first_selected)
{
LLControlVariable* controlp = (LLControlVariable*)first_selected->getUserdata();
if (controlp)
{
updateControl(controlp);
}
}
}
void LLFloaterSettingsDebug::setSearchFilter(const std::string& filter)
{
if(mSearchFilter == filter)
return;
mSearchFilter = filter;
LLStringUtil::toLower(mSearchFilter);
updateList();
}
bool LLFloaterSettingsDebug::matchesSearchFilter(std::string setting_name)
{
// If the search filter is empty, everything passes.
if (mSearchFilter.empty()) return true;
LLStringUtil::toLower(setting_name);
std::string::size_type match_name = setting_name.find(mSearchFilter);
return (std::string::npos != match_name);
}
bool LLFloaterSettingsDebug::isSettingHidden(LLControlVariable* control)
{
static LLCachedControl<bool> hide_default(gSavedSettings, "DebugSettingsHideDefault", false);
return hide_default && control->isDefault();
}
void LLFloaterSettingsDebug::updateDefaultColumn(LLControlVariable* control)
{
if (isSettingHidden(control))
{
hideUIControls();
updateList(true);
return;
}
LLScrollListItem* item = mSettingList->getFirstSelected();
if (item)
{
LLScrollListCell* cell = item->getColumn(0);
if (cell)
{
std::string is_default = control->isDefault() ? "" : "*";
cell->setValue(is_default);
}
}
}
void LLFloaterSettingsDebug::hideUIControls()
{
getChildView("val_spinner_1")->setVisible(false);
getChildView("val_spinner_2")->setVisible(false);
getChildView("val_spinner_3")->setVisible(false);
getChildView("val_spinner_4")->setVisible(false);
getChildView("val_color_swatch")->setVisible(false);
getChildView("val_text")->setVisible(false);
getChildView("default_btn")->setVisible(false);
getChildView("boolean_combo")->setVisible(false);
getChildView("setting_name_txt")->setVisible(false);
mComment->setVisible(false);
}

21
indra/newview/llfloatersettingsdebug.h
View File

@ -2,9 +2,9 @@
* @file llfloatersettingsdebug.h
* @brief floater for debugging internal viewer settings
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* $LicenseInfo:firstyear=2022&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
* Copyright (C) 2022, 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
@ -30,6 +30,8 @@
#include "llcontrol.h"
#include "llfloater.h"
class LLScrollListCtrl;
class LLFloaterSettingsDebug
: public LLFloater
{
@ -42,18 +44,31 @@ public:
void updateControl(LLControlVariable* control);
void onSettingSelect(LLUICtrl* ctrl);
void onCommitSettings();
void onClickDefault();
bool matchesSearchFilter(std::string setting_name);
bool isSettingHidden(LLControlVariable* control);
private:
// key - selects which settings to show, one of:
// "all", "base", "account", "skin"
LLFloaterSettingsDebug(const LLSD& key);
virtual ~LLFloaterSettingsDebug();
void updateList(bool skip_selection = false);
void onSettingSelect();
void setSearchFilter(const std::string& filter);
void updateDefaultColumn(LLControlVariable* control);
void hideUIControls();
LLScrollListCtrl* mSettingList;
protected:
class LLTextEditor* mComment;
std::string mSearchFilter;
};
#endif //LLFLOATERDEBUGSETTINGS_H

4
indra/newview/llfloaterworldmap.cpp
View File

@ -122,7 +122,7 @@ class LLWorldMapHandler : public LLCommandHandler
{
public:
// requires trusted browser to trigger
LLWorldMapHandler() : LLCommandHandler("worldmap", UNTRUSTED_THROTTLE ) { }
LLWorldMapHandler() : LLCommandHandler("worldmap", UNTRUSTED_CLICK_ONLY ) { }
bool handle(const LLSD& params, const LLSD& query_map,
LLMediaCtrl* web)
@ -159,7 +159,7 @@ class LLMapTrackAvatarHandler : public LLCommandHandler
{
public:
// requires trusted browser to trigger
LLMapTrackAvatarHandler() : LLCommandHandler("maptrackavatar", UNTRUSTED_THROTTLE)
LLMapTrackAvatarHandler() : LLCommandHandler("maptrackavatar", UNTRUSTED_CLICK_ONLY)
{
}

27
indra/newview/llgroupactions.cpp
View File

@ -52,7 +52,32 @@ class LLGroupHandler : public LLCommandHandler
{
public:
// requires trusted browser to trigger
LLGroupHandler() : LLCommandHandler("group", UNTRUSTED_THROTTLE) { }
LLGroupHandler() : LLCommandHandler("group", UNTRUSTED_CLICK_ONLY) { }
virtual bool canHandleUntrusted(
const LLSD& params,
const LLSD& query_map,
LLMediaCtrl* web,
const std::string& nav_type)
{
if (params.size() < 1)
{
return true; // don't block, will fail later
}
if (nav_type == NAV_TYPE_CLICKED)
{
return true;
}
const std::string verb = params[0].asString();
if (verb == "create")
{
return false;
}
return true;
}
bool handle(const LLSD& tokens, const LLSD& query_map,
LLMediaCtrl* web)
{

2
indra/newview/llimprocessing.cpp
View File

@ -1568,7 +1568,7 @@ void LLIMProcessing::requestOfflineMessagesCoro(std::string url)
return;
}
if (messages.emptyArray())
if (messages.size() == 0)
{
// Nothing to process
return;

6
indra/newview/llimview.cpp
View File

@ -2115,8 +2115,6 @@ void LLOutgoingCallDialog::show(const LLSD& key)
std::string callee_name = mPayload["session_name"].asString();
LLUUID session_id = mPayload["session_id"].asUUID();
if (callee_name == "anonymous") // obsolete? Likely was part of avaline support
{
callee_name = getString("anonymous");
@ -2500,7 +2498,7 @@ void LLIncomingCallDialog::processCallResponse(S32 response, const LLSD &payload
}
}
LLUUID new_session_id = gIMMgr->addSession(correct_session_name, type, session_id, true);
gIMMgr->addSession(correct_session_name, type, session_id, true);
std::string url = gAgent.getRegion()->getCapability(
"ChatSessionRequest");
@ -2586,7 +2584,7 @@ bool inviteUserResponse(const LLSD& notification, const LLSD& response)
}
else
{
LLUUID new_session_id = gIMMgr->addSession(
gIMMgr->addSession(
payload["session_name"].asString(),
type,
session_id, true);

13
indra/newview/llinventorybridge.cpp
View File

@ -834,6 +834,12 @@ void LLInvFVBridge::getClipboardEntries(bool show_asset_id,
{
disabled_items.push_back(std::string("Find Original"));
}
items.push_back(std::string("Cut"));
if (!isItemMovable() || !isItemRemovable())
{
disabled_items.push_back(std::string("Cut"));
}
}
else
{
@ -2154,6 +2160,7 @@ bool LLItemBridge::isItemCopyable(bool can_copy_as_link) const
static LLCachedControl<bool> inventory_linking(gSavedSettings, "InventoryLinking", true);
return (can_copy_as_link && inventory_linking)
|| (mIsLink && inventory_linking)
|| item->getPermissions().allowCopyBy(gAgent.getID());
}
@ -2360,6 +2367,12 @@ BOOL LLFolderBridge::isUpToDate() const
bool LLFolderBridge::isItemCopyable(bool can_copy_as_link) const
{
if (can_copy_as_link && !LLFolderType::lookupIsProtectedType(getPreferredType()))
{
// Can copy and paste unprotected folders as links
return true;
}
// Folders are copyable if items in them are, recursively, copyable.
// Get the content of the folder

1
indra/newview/llinventoryfilter.cpp
View File

@ -437,7 +437,6 @@ bool LLInventoryFilter::checkAgainstFilterType(const LLFolderViewModelItemInvent
bool LLInventoryFilter::checkAgainstFilterType(const LLInventoryItem* item) const
{
LLInventoryType::EType object_type = item->getInventoryType();
const LLUUID object_id = item->getUUID();
const U32 filterTypes = mFilterOps.mFilterTypes;

3
indra/newview/llinventoryfunctions.cpp
View File

@ -1406,9 +1406,6 @@ bool move_item_to_marketplacelistings(LLInventoryItem* inv_item, LLUUID dest_fol
LLNotificationsUtil::add("MerchantPasteFailed", subs);
return false;
}
// Get the parent folder of the moved item : we may have to update it
LLUUID src_folder = viewer_inv_item->getParentUUID();
if (copy)
{

2
indra/newview/llinventorylistitem.h
View File

@ -197,6 +197,7 @@ protected:
virtual BOOL handleToolTip( S32 x, S32 y, MASK mask);
const LLUUID mInventoryItemUUID;
bool mHovered;
private:
@ -221,7 +222,6 @@ private:
LLUIImagePtr mSelectedImage;
LLUIImagePtr mSeparatorImage;
bool mHovered;
bool mSelected;
bool mSeparatorVisible;

3
indra/newview/llinventorymodel.cpp
View File

@ -1694,11 +1694,11 @@ void LLInventoryModel::deleteObject(const LLUUID& id, bool fix_broken_links, boo
// Can't have links to links, so there's no need for this update
// if the item removed is a link. Can also skip if source of the
// update is getting broken link info separately.
obj = NULL; // delete obj
if (fix_broken_links && !is_link_type)
{
updateLinkedObjectsFromPurge(id);
}
obj = nullptr; // delete obj
if (do_notify_observers)
{
notifyObservers();
@ -2718,7 +2718,6 @@ void LLInventoryModel::buildParentChildMap()
// some accounts has pbroken inventory root folders
std::string name = "My Inventory";
LLUUID prev_root_id = mRootFolderID;
for (parent_cat_map_t::const_iterator it = mParentChildCategoryTree.begin(),
it_end = mParentChildCategoryTree.end(); it != it_end; ++it)
{

Some files were not shown because too many files have changed in this diff Show More