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

merge changes for storm-485

master
Oz Linden 2011-01-04 16:44:15 -05:00
parent 43659aac93 05810f063d
commit 562ed9c4d4
33 changed files with 509 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
doc/contributions.txt
View File

@ -364,11 +364,13 @@ JB Kraft
Joghert LeSabre
VWR-64
Jonathan Yap
VWR-17801
STORM-596
STORM-523
STORM-616
STORM-679
STORM-596
STORM-737
STORM-726
VWR-17801
STORM-785
Kage Pixel
VWR-11
@ -747,6 +749,7 @@ Tue Torok
CT-74
Twisted Laws
SNOW-352
STORM-466
Vadim Bigbear
VWR-2681
Vector Hastings

24
indra/lib/python/indra/util/test_win32_manifest.py
View File

@ -52,20 +52,22 @@ def get_HKLM_registry_value(key_str, value_str):
def find_vc_dir():
supported_versions = (r'8.0', r'9.0')
supported_products = (r'VisualStudio', r'VCExpress')
value_str = (r'ProductDir')
for version in supported_versions:
key_str = (r'SOFTWARE\Microsoft\VisualStudio\%s\Setup\VC' %
version)
try:
return get_HKLM_registry_value(key_str, value_str)
except WindowsError, err:
x64_key_str = (r'SOFTWARE\Wow6432Node\Microsoft\VisualStudio\%s\Setup\VS' %
version)
for product in supported_products:
for version in supported_versions:
key_str = (r'SOFTWARE\Microsoft\%s\%s\Setup\VC' %
(product, version))
try:
return get_HKLM_registry_value(x64_key_str, value_str)
except:
print >> sys.stderr, "Didn't find MS VC version %s " % version
return get_HKLM_registry_value(key_str, value_str)
except WindowsError, err:
x64_key_str = (r'SOFTWARE\Wow6432Node\Microsoft\VisualStudio\%s\Setup\VS' %
version)
try:
return get_HKLM_registry_value(x64_key_str, value_str)
except:
print >> sys.stderr, "Didn't find MS %s version %s " % (product,version)
raise

13
indra/llimage/CMakeLists.txt
View File

@ -3,12 +3,13 @@
project(llimage)
include(00-Common)
include(LLAddBuildTest)
include(LLCommon)
include(LLImage)
include(LLMath)
include(LLVFS)
include(ZLIB)
include(LLAddBuildTest)
include(Tut)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
@ -63,4 +64,12 @@ target_link_libraries(llimage
)
# Add tests
#ADD_BUILD_TEST(llimageworker llimage)
if (LL_TESTS)
SET(llimage_TEST_SOURCE_FILES
llimageworker.cpp
)
LL_ADD_PROJECT_UNIT_TESTS(llimage "${llimage_TEST_SOURCE_FILES}")
endif (LL_TESTS)

18
indra/llimage/tests/llimageworker_test.cpp
View File

@ -26,10 +26,8 @@
*/
// Precompiled header: almost always required for newview cpp files
#include <list>
#include <map>
#include <algorithm>
// Class to test
#include "linden_common.h"
// Class to test
#include "../llimageworker.h"
// For timer class
#include "../llcommon/lltimer.h"
@ -44,7 +42,17 @@
// * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
// * A simulator for a class can be implemented here. Please comment and document thoroughly.
LLImageBase::LLImageBase() {}
LLImageBase::LLImageBase()
: mData(NULL),
mDataSize(0),
mWidth(0),
mHeight(0),
mComponents(0),
mBadBufferAllocation(false),
mAllowOverSize(false),
mMemType(LLMemType::MTYPE_IMAGEBASE)
{
}
LLImageBase::~LLImageBase() {}
void LLImageBase::dump() { }
void LLImageBase::sanityCheck() { }

6
indra/llimagej2coj/llimagej2coj.cpp
View File

@ -90,6 +90,12 @@ void info_callback(const char* msg, void*)
lldebugs << "LLImageJ2COJ: " << chomp(msg) << llendl;
}
// Divide a by 2 to the power of b and round upwards
int ceildivpow2(int a, int b)
{
return (a + (1 << b) - 1) >> b;
}
LLImageJ2COJ::LLImageJ2COJ()
: LLImageJ2CImpl()

6
indra/llimagej2coj/llimagej2coj.h
View File

@ -34,17 +34,11 @@ class LLImageJ2COJ : public LLImageJ2CImpl
public:
LLImageJ2COJ();
virtual ~LLImageJ2COJ();
protected:
/*virtual*/ BOOL getMetadata(LLImageJ2C &base);
/*virtual*/ BOOL decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count);
/*virtual*/ BOOL encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
BOOL reversible = FALSE);
int ceildivpow2(int a, int b)
{
// Divide a by b to the power of 2 and round upwards.
return (a + (1 << b) - 1) >> b;
}
};
#endif

10
indra/llkdu/CMakeLists.txt
View File

@ -42,4 +42,14 @@ list(APPEND llkdu_SOURCE_FILES ${llkdu_HEADER_FILES})
if (USE_KDU)
add_library (${LLKDU_LIBRARIES} ${llkdu_SOURCE_FILES})
# Add tests
if (LL_TESTS)
include(LLAddBuildTest)
include(Tut)
SET(llkdu_TEST_SOURCE_FILES
llimagej2ckdu.cpp
)
LL_ADD_PROJECT_UNIT_TESTS(llkdu "${llkdu_TEST_SOURCE_FILES}")
endif (LL_TESTS)
endif (USE_KDU)

13
indra/llkdu/llimagej2ckdu.cpp
View File

@ -229,16 +229,17 @@ void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECod
mCodeStreamp = NULL;
}
if (!mInputp)
if (!mInputp && base.getData())
{
llassert(base.getData());
// The compressed data has been loaded
// Setup the source for the codestrea
// Setup the source for the codestream
mInputp = new LLKDUMemSource(base.getData(), data_size);
}
llassert(mInputp);
mInputp->reset();
if (mInputp)
{
mInputp->reset();
}
mCodeStreamp = new kdu_codestream;
mCodeStreamp->create(mInputp);
@ -1017,7 +1018,7 @@ kdc_flow_control::kdc_flow_control (kdu_image_in_base *img_in, kdu_codestream co
comp->ratio_counter = 0;
comp->remaining_lines = comp->initial_lines = dims.size.y;
}
assert(num_components > 0);
assert(num_components >= 0);
tile.set_components_of_interest(num_components);
max_buffer_memory = engine.create(codestream,tile,false,NULL,false,1,NULL,NULL,false);

5
indra/llkdu/llimagej2ckdu.h
View File

@ -50,17 +50,16 @@ public:
MODE_RESILIENT = 1,
MODE_FUSSY = 2
};
public:
LLImageJ2CKDU();
virtual ~LLImageJ2CKDU();
protected:
/*virtual*/ BOOL getMetadata(LLImageJ2C &base);
/*virtual*/ BOOL decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count);
/*virtual*/ BOOL encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
BOOL reversible=FALSE);
private:
void setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECodeStreamMode mode);
void cleanupCodeStream();
BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, ECodeStreamMode mode, S32 first_channel, S32 max_channel_count );

248
indra/llkdu/tests/llimagej2ckdu_test.cpp Normal file
View File

@ -0,0 +1,248 @@
/**
* @file llimagej2ckdu_test.cpp
* @author Merov Linden
* @date 2010-12-17
*
* $LicenseInfo:firstyear=2006&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "linden_common.h"
// Class to test
#include "../llimagej2ckdu.h"
#include "../llkdumem.h"
// Tut header
#include "../test/lltut.h"
// -------------------------------------------------------------------------------------------
// Stubbing: Declarations required to link and run the class being tested
// Notes:
// * Add here stubbed implementation of the few classes and methods used in the class to be tested
// * Add as little as possible (let the link errors guide you)
// * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
// * A simulator for a class can be implemented here. Please comment and document thoroughly.
// End Stubbing
// -------------------------------------------------------------------------------------------
// Stubb the LL Image Classes
LLImageRaw::LLImageRaw() { }
LLImageRaw::~LLImageRaw() { }
U8* LLImageRaw::allocateData(S32 ) { return NULL; }
void LLImageRaw::deleteData() { }
U8* LLImageRaw::reallocateData(S32 ) { return NULL; }
BOOL LLImageRaw::resize(U16, U16, S8) { return TRUE; } // this method always returns TRUE...
LLImageBase::LLImageBase()
: mData(NULL),
mDataSize(0),
mWidth(0),
mHeight(0),
mComponents(0),
mBadBufferAllocation(false),
mAllowOverSize(false),
mMemType(LLMemType::MTYPE_IMAGEBASE)
{ }
LLImageBase::~LLImageBase() { }
U8* LLImageBase::allocateData(S32 ) { return NULL; }
void LLImageBase::deleteData() { }
void LLImageBase::dump() { }
const U8* LLImageBase::getData() const { return NULL; }
U8* LLImageBase::getData() { return NULL; }
U8* LLImageBase::reallocateData(S32 ) { return NULL; }
void LLImageBase::sanityCheck() { }
void LLImageBase::setSize(S32 , S32 , S32 ) { }
LLImageJ2CImpl::~LLImageJ2CImpl() { }
LLImageFormatted::LLImageFormatted(S8 ) { }
LLImageFormatted::~LLImageFormatted() { }
U8* LLImageFormatted::allocateData(S32 ) { return NULL; }
S32 LLImageFormatted::calcDataSize(S32 ) { return 0; }
S32 LLImageFormatted::calcDiscardLevelBytes(S32 ) { return 0; }
BOOL LLImageFormatted::decodeChannels(LLImageRaw*, F32, S32, S32) { return FALSE; }
BOOL LLImageFormatted::copyData(U8 *, S32) { return TRUE; } // this method always returns TRUE...
void LLImageFormatted::deleteData() { }
void LLImageFormatted::dump() { }
U8* LLImageFormatted::reallocateData(S32 ) { return NULL; }
void LLImageFormatted::resetLastError() { }
void LLImageFormatted::sanityCheck() { }
void LLImageFormatted::setLastError(const std::string& , const std::string& ) { }
LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C) { }
LLImageJ2C::~LLImageJ2C() { }
S32 LLImageJ2C::calcDataSize(S32 ) { return 0; }
S32 LLImageJ2C::calcDiscardLevelBytes(S32 ) { return 0; }
S32 LLImageJ2C::calcHeaderSize() { return 0; }
BOOL LLImageJ2C::decode(LLImageRaw*, F32) { return FALSE; }
BOOL LLImageJ2C::decodeChannels(LLImageRaw*, F32, S32, S32 ) { return FALSE; }
void LLImageJ2C::decodeFailed() { }
BOOL LLImageJ2C::encode(const LLImageRaw*, F32) { return FALSE; }
S8 LLImageJ2C::getRawDiscardLevel() { return 0; }
void LLImageJ2C::resetLastError() { }
void LLImageJ2C::setLastError(const std::string&, const std::string&) { }
BOOL LLImageJ2C::updateData() { return FALSE; }
void LLImageJ2C::updateRawDiscardLevel() { }
LLKDUMemIn::LLKDUMemIn(const U8*, const U32, const U16, const U16, const U8, siz_params*) { }
LLKDUMemIn::~LLKDUMemIn() { }
bool LLKDUMemIn::get(int, kdu_line_buf&, int) { return false; }
// Stub Kakadu Library calls
kdu_tile_comp kdu_tile::access_component(int ) { kdu_tile_comp a; return a; }
void kdu_tile::close(kdu_thread_env* ) { }
int kdu_tile::get_num_components() { return 0; }
bool kdu_tile::get_ycc() { return false; }
void kdu_tile::set_components_of_interest(int , const int* ) { }
kdu_resolution kdu_tile_comp::access_resolution() { kdu_resolution a; return a; }
int kdu_tile_comp::get_bit_depth(bool ) { return 8; }
bool kdu_tile_comp::get_reversible() { return false; }
kdu_subband kdu_resolution::access_subband(int ) { kdu_subband a; return a; }
void kdu_resolution::get_dims(kdu_dims& ) { }
int kdu_resolution::which() { return 0; }
kdu_decoder::kdu_decoder(kdu_subband , kdu_sample_allocator*, bool , float, int, kdu_thread_env*, kdu_thread_queue*) { }
kdu_synthesis::kdu_synthesis(kdu_resolution, kdu_sample_allocator*, bool, float, kdu_thread_env*, kdu_thread_queue*) { }
kdu_params::kdu_params(const char*, bool, bool, bool, bool, bool) { }
kdu_params::~kdu_params() { }
void kdu_params::set(const char* , int , int , bool ) { }
void kdu_params::set(const char* , int , int , int ) { }
void kdu_params::finalize_all(bool ) { }
void kdu_params::copy_from(kdu_params*, int, int, int, int, int, bool, bool, bool) { }
bool kdu_params::parse_string(const char*) { return false; }
bool kdu_params::get(const char*, int, int, bool&, bool, bool, bool) { return false; }
bool kdu_params::get(const char*, int, int, float&, bool, bool, bool) { return false; }
bool kdu_params::get(const char*, int, int, int&, bool, bool, bool) { return false; }
kdu_params* kdu_params::access_relation(int, int, int, bool) { return NULL; }
kdu_params* kdu_params::access_cluster(const char*) { return NULL; }
void kdu_codestream::set_fast() { }
void kdu_codestream::set_fussy() { }
void kdu_codestream::get_dims(int, kdu_dims&, bool ) { }
void kdu_codestream::change_appearance(bool, bool, bool) { }
void kdu_codestream::get_tile_dims(kdu_coords, int, kdu_dims&, bool ) { }
void kdu_codestream::destroy() { }
void kdu_codestream::collect_timing_stats(int ) { }
void kdu_codestream::set_max_bytes(kdu_long, bool, bool ) { }
void kdu_codestream::get_valid_tiles(kdu_dims& ) { }
void kdu_codestream::create(siz_params*, kdu_compressed_target*, kdu_dims*, int, kdu_long ) { }
void kdu_codestream::create(kdu_compressed_source*, kdu_thread_env*) { }
void kdu_codestream::apply_input_restrictions( int, int, int, int, kdu_dims*, kdu_component_access_mode ) { }
void kdu_codestream::get_subsampling(int , kdu_coords&, bool ) { }
void kdu_codestream::flush(kdu_long *, int , kdu_uint16 *, bool, bool, double, kdu_thread_env*) { }
void kdu_codestream::set_resilient(bool ) { }
int kdu_codestream::get_num_components(bool ) { return 0; }
siz_params* kdu_codestream::access_siz() { return NULL; }
kdu_tile kdu_codestream::open_tile(kdu_coords , kdu_thread_env* ) { kdu_tile a; return a; }
kdu_codestream_comment kdu_codestream::add_comment() { kdu_codestream_comment a; return a; }
bool kdu_codestream_comment::put_text(const char*) { return false; }
void kdu_customize_warnings(kdu_message*) { }
void kdu_customize_errors(kdu_message*) { }
void kdu_convert_ycc_to_rgb(kdu_line_buf&, kdu_line_buf&, kdu_line_buf&, int) { }
kdu_long kdu_multi_analysis::create(kdu_codestream, kdu_tile, bool, kdu_roi_image*, bool, int, kdu_thread_env*, kdu_thread_queue*, bool ) { kdu_long a = 0; return a; }
siz_params::siz_params() : kdu_params(NULL, false, false, false, false, false) { }
void siz_params::finalize(bool ) { }
void siz_params::copy_with_xforms(kdu_params*, int, int, bool, bool, bool) { }
int siz_params::write_marker_segment(kdu_output*, kdu_params*, int) { return 0; }
bool siz_params::check_marker_segment(kdu_uint16, int, kdu_byte a[], int&) { return false; }
bool siz_params::read_marker_segment(kdu_uint16, int, kdu_byte a[], int) { return false; }
// -------------------------------------------------------------------------------------------
// TUT
// -------------------------------------------------------------------------------------------
namespace tut
{
// Test wrapper declarations
struct llimagej2ckdu_test
{
// Derived test class
class LLTestImageJ2CKDU : public LLImageJ2CKDU
{
public:
// Provides public access to some protected methods for testing
BOOL callGetMetadata(LLImageJ2C &base) { return getMetadata(base); }
BOOL callDecodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
{
return decodeImpl(base, raw_image, decode_time, first_channel, max_channel_count);
}
BOOL callEncodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text)
{
return encodeImpl(base, raw_image, comment_text);
}
};
// Instance to be tested
LLTestImageJ2CKDU* mImage;
// Constructor and destructor of the test wrapper
llimagej2ckdu_test()
{
mImage = new LLTestImageJ2CKDU;
}
~llimagej2ckdu_test()
{
delete mImage;
}
};
// Tut templating thingamagic: test group, object and test instance
typedef test_group<llimagej2ckdu_test> llimagej2ckdu_t;
typedef llimagej2ckdu_t::object llimagej2ckdu_object_t;
tut::llimagej2ckdu_t tut_llimagej2ckdu("LLImageJ2CKDU");
// ---------------------------------------------------------------------------------------
// Test functions
// Notes:
// * Test as many as you possibly can without requiring a full blown simulation of everything
// * The tests are executed in sequence so the test instance state may change between calls
// * Remember that you cannot test private methods with tut
// ---------------------------------------------------------------------------------------
// Test 1 : test getMetadata()
template<> template<>
void llimagej2ckdu_object_t::test<1>()
{
LLImageJ2C* image = new LLImageJ2C();
BOOL res = mImage->callGetMetadata(*image);
// Trying to set up a data stream with all NIL values and stubbed KDU will "work" and return TRUE
// Note that is linking with KDU, that call will throw an exception and fail, returning FALSE
ensure("getMetadata() test failed", res == TRUE);
}
// Test 2 : test decodeImpl()
template<> template<>
void llimagej2ckdu_object_t::test<2>()
{
LLImageJ2C* image = new LLImageJ2C();
LLImageRaw* raw = new LLImageRaw();
BOOL res = mImage->callDecodeImpl(*image, *raw, 0.0, 0, 0);
// Decoding returns TRUE whenever there's nothing else to do, including if decoding failed, so we'll get TRUE here
ensure("decodeImpl() test failed", res == TRUE);
}
// Test 3 : test encodeImpl()
template<> template<>
void llimagej2ckdu_object_t::test<3>()
{
LLImageJ2C* image = new LLImageJ2C();
LLImageRaw* raw = new LLImageRaw();
BOOL res = mImage->callEncodeImpl(*image, *raw, NULL);
// Encoding returns TRUE unless an exception was raised, so we'll get TRUE here though nothing really was done
ensure("encodeImpl() test failed", res == TRUE);
}
}

4
indra/llui/llfloater.cpp
View File

@ -2910,7 +2910,9 @@ bool LLFloater::initFloaterXML(LLXMLNodePtr node, LLView *parent, const std::str
params.from_xui = true;
applyXUILayout(params, parent);
initFromParams(params);
// chrome floaters don't take focus at all
setFocusRoot(!getIsChrome());
initFloater(params);
LLMultiFloater* last_host = LLFloater::getFloaterHost();

4
indra/newview/CMakeLists.txt
View File

@ -1891,6 +1891,8 @@ if (LL_TESTS)
llremoteparcelrequest.cpp
llviewerhelputil.cpp
llversioninfo.cpp
llworldmap.cpp
llworldmipmap.cpp
)
##################################################
@ -1978,8 +1980,6 @@ if (LL_TESTS)
#ADD_VIEWER_BUILD_TEST(llmemoryview viewer)
#ADD_VIEWER_BUILD_TEST(llagentaccess viewer)
#ADD_VIEWER_BUILD_TEST(llworldmap viewer)
#ADD_VIEWER_BUILD_TEST(llworldmipmap viewer)
#ADD_VIEWER_BUILD_TEST(lltextureinfo viewer)
#ADD_VIEWER_BUILD_TEST(lltextureinfodetails viewer)
#ADD_VIEWER_BUILD_TEST(lltexturestatsuploader viewer)

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

@ -4780,6 +4780,17 @@
<key>Value</key>
<string>http://map.secondlife.com.s3.amazonaws.com/</string>
</map>
<key>CurrentMapServerURL</key>
<map>
<key>Comment</key>
<string>Current Session World map URL</string>
<key>Persist</key>
<integer>0</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string></string>
</map>
<key>MapShowEvents</key>
<map>
<key>Comment</key>
@ -12423,5 +12434,16 @@
<key>Value</key>
<string>name</string>
</map>
<key>ReleaseNotesURL</key>
<map>
<key>Comment</key>
<string>Release notes URL template</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string>http://secondlife.com/app/releasenotes/?channel=[CHANNEL]&amp;version=[VERSION]</string>
</map>
</map>
</llsd>

0
indra/newview/app_settings/shaders/shader_heirarchy.txt → indra/newview/app_settings/shaders/shader_hierarchy.txt
View File

11
indra/newview/llfloatermap.cpp
View File

@ -288,7 +288,16 @@ void LLFloaterMap::handleZoom(const LLSD& userdata)
std::string level = userdata.asString();
F32 scale = 0.0f;
if (level == std::string("close"))
if (level == std::string("default"))
{
LLControlVariable *pvar = gSavedSettings.getControl("MiniMapScale");
if(pvar)
{
pvar->resetToDefault();
scale = gSavedSettings.getF32("MiniMapScale");
}
}
else if (level == std::string("close"))
scale = LLNetMap::MAP_SCALE_MAX;
else if (level == std::string("medium"))
scale = LLNetMap::MAP_SCALE_MID;

11
indra/newview/llimfloater.cpp
View File

@ -470,7 +470,7 @@ LLIMFloater* LLIMFloater::show(const LLUUID& session_id)
}
//static
bool LLIMFloater::resetAllowedRectPadding(const LLSD& newvalue)
bool LLIMFloater::resetAllowedRectPadding()
{
//reset allowed rect right padding if "SidebarCameraMovement" option
//or sidebar state changed
@ -482,10 +482,10 @@ void LLIMFloater::getAllowedRect(LLRect& rect)
{
if (sAllowedRectRightPadding == RECT_PADDING_NOT_INIT) //wasn't initialized
{
gSavedSettings.getControl("SidebarCameraMovement")->getSignal()->connect(boost::bind(&LLIMFloater::resetAllowedRectPadding, _2));
gSavedSettings.getControl("SidebarCameraMovement")->getSignal()->connect(boost::bind(&LLIMFloater::resetAllowedRectPadding));
LLSideTray* side_bar = LLSideTray::getInstance();
side_bar->getCollapseSignal().connect(boost::bind(&LLIMFloater::resetAllowedRectPadding, _2));
side_bar->setVisibleWidthChangeCallback(boost::bind(&LLIMFloater::resetAllowedRectPadding));
sAllowedRectRightPadding = RECT_PADDING_NEED_RECALC;
}
@ -500,10 +500,7 @@ void LLIMFloater::getAllowedRect(LLRect& rect)
if (gSavedSettings.getBOOL("SidebarCameraMovement") == FALSE)
{
LLSideTray* side_bar = LLSideTray::getInstance();
if (side_bar->getVisible() && !side_bar->getCollapsed())
sAllowedRectRightPadding += side_bar->getRect().getWidth();
sAllowedRectRightPadding += LLSideTray::getInstance()->getVisibleWidth();
}
}
rect.mRight -= sAllowedRectRightPadding;

2
indra/newview/llimfloater.h
View File

@ -156,7 +156,7 @@ private:
static void closeHiddenIMToasts();
static bool resetAllowedRectPadding(const LLSD& newvalue);
static bool resetAllowedRectPadding();
//need to keep this static for performance issues
static S32 sAllowedRectRightPadding;

5
indra/newview/llinventorybridge.cpp
View File

@ -5344,11 +5344,6 @@ void LLRecentItemsFolderBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
menuentry_vec_t disabled_items, items = getMenuItems();
items.erase(std::remove(items.begin(), items.end(), std::string("New Body Parts")), items.end());
items.erase(std::remove(items.begin(), items.end(), std::string("New Clothes")), items.end());
items.erase(std::remove(items.begin(), items.end(), std::string("New Note")), items.end());
items.erase(std::remove(items.begin(), items.end(), std::string("New Gesture")), items.end());
items.erase(std::remove(items.begin(), items.end(), std::string("New Script")), items.end());
items.erase(std::remove(items.begin(), items.end(), std::string("New Folder")), items.end());
hide_context_entries(menu, items, disabled_items);

8
indra/newview/llpanelmaininventory.cpp
View File

@ -506,9 +506,6 @@ void LLPanelMainInventory::onFilterSelected()
return;
}
BOOL recent_active = ("Recent Items" == mActivePanel->getName());
getChildView("add_btn_panel")->setVisible( !recent_active);
setFilterSubString(mFilterSubString);
LLInventoryFilter* filter = mActivePanel->getFilter();
LLFloaterInventoryFinder *finder = getFinder();
@ -944,6 +941,11 @@ void LLPanelMainInventory::updateListCommands()
void LLPanelMainInventory::onAddButtonClick()
{
// Gray out the "New Folder" option when the Recent tab is active as new folders will not be displayed
// unless "Always show folders" is checked in the filter options.
bool recent_active = ("Recent Items" == mActivePanel->getName());
mMenuAdd->getChild<LLMenuItemGL>("New Folder")->setEnabled(!recent_active);
setUploadCostIfNeeded();
showActionMenu(mMenuAdd,"add_btn");

20
indra/newview/llscreenchannel.cpp
View File

@ -83,11 +83,10 @@ bool LLScreenChannelBase::isHovering()
return mHoveredToast->isHovered();
}
bool LLScreenChannelBase::resetPositionAndSize(const LLSD& newvalue)
void LLScreenChannelBase::resetPositionAndSize()
{
LLRect rc = gViewerWindow->getWorldViewRectScaled();
updatePositionAndSize(rc, rc);
return true;
}
void LLScreenChannelBase::updatePositionAndSize(LLRect old_world_rect, LLRect new_world_rect)
@ -99,10 +98,7 @@ void LLScreenChannelBase::updatePositionAndSize(LLRect old_world_rect, LLRect ne
if (gSavedSettings.getBOOL("SidebarCameraMovement") == FALSE
&& LLSideTray::instanceCreated ())
{
LLSideTray* side_bar = LLSideTray::getInstance();
if (side_bar->getVisible() && !side_bar->getCollapsed())
world_rect_padding += side_bar->getRect().getWidth();
world_rect_padding += LLSideTray::getInstance()->getVisibleWidth();
}
@ -133,7 +129,7 @@ void LLScreenChannelBase::init(S32 channel_left, S32 channel_right)
if(LLSideTray::instanceCreated())
{
LLSideTray* side_bar = LLSideTray::getInstance();
side_bar->getCollapseSignal().connect(boost::bind(&LLScreenChannelBase::resetPositionAndSize, this, _2));
side_bar->setVisibleWidthChangeCallback(boost::bind(&LLScreenChannelBase::resetPositionAndSize, this));
}
// top and bottom set by updateBottom()
@ -214,10 +210,7 @@ void LLScreenChannel::updatePositionAndSize(LLRect old_world_rect, LLRect new_wo
if (gSavedSettings.getBOOL("SidebarCameraMovement") == FALSE
&& LLSideTray::instanceCreated ())
{
LLSideTray* side_bar = LLSideTray::getInstance();
if (side_bar->getVisible() && !side_bar->getCollapsed())
world_rect_padding += side_bar->getRect().getWidth();
world_rect_padding += LLSideTray::getInstance()->getVisibleWidth();
}
@ -495,7 +488,7 @@ void LLScreenChannel::modifyToastByNotificationID(LLUUID id, LLPanel* panel)
//--------------------------------------------------------------------------
void LLScreenChannel::redrawToasts()
{
if(mToastList.size() == 0 || isHovering())
if(mToastList.size() == 0)
return;
switch(mToastAlignment)
@ -841,8 +834,7 @@ void LLScreenChannel::onToastHover(LLToast* toast, bool mouse_enter)
}
}
if(!isHovering())
redrawToasts();
redrawToasts();
}
//--------------------------------------------------------------------------

2
indra/newview/llscreenchannel.h
View File

@ -59,8 +59,8 @@ public:
// Channel's outfit-functions
// update channel's size and position in the World View
virtual void updatePositionAndSize(LLRect old_world_rect, LLRect new_world_rect);
void resetPositionAndSize();
bool resetPositionAndSize(const LLSD& newvalue);
// initialization of channel's shape and position
virtual void init(S32 channel_left, S32 channel_right);

29
indra/newview/llsidetray.cpp
View File

@ -561,7 +561,7 @@ BOOL LLSideTray::postBuild()
{
if ((*it).channel)
{
getCollapseSignal().connect(boost::bind(&LLScreenChannelBase::resetPositionAndSize, (*it).channel, _2));
setVisibleWidthChangeCallback(boost::bind(&LLScreenChannelBase::resetPositionAndSize, (*it).channel));
}
}
@ -980,9 +980,6 @@ void LLSideTray::reflectCollapseChange()
}
gFloaterView->refresh();
LLSD new_value = mCollapsed;
mCollapseSignal(this,new_value);
}
void LLSideTray::arrange()
@ -1262,9 +1259,29 @@ bool LLSideTray::isPanelActive(const std::string& panel_name)
void LLSideTray::updateSidetrayVisibility()
{
// set visibility of parent container based on collapsed state
if (getParent())
LLView* parent = getParent();
if (parent)
{
getParent()->setVisible(!mCollapsed && !gAgentCamera.cameraMouselook());
bool old_visibility = parent->getVisible();
bool new_visibility = !mCollapsed && !gAgentCamera.cameraMouselook();
if (old_visibility != new_visibility)
{
parent->setVisible(new_visibility);
// Signal change of visible width.
llinfos << "Visible: " << new_visibility << llendl;
mVisibleWidthChangeSignal(this, new_visibility);
}
}
}
S32 LLSideTray::getVisibleWidth()
{
return (isInVisibleChain() && !mCollapsed) ? getRect().getWidth() : 0;
}
void LLSideTray::setVisibleWidthChangeCallback(const commit_signal_t::slot_type& cb)
{
mVisibleWidthChangeSignal.connect(cb);
}

15
indra/newview/llsidetray.h
View File

@ -165,9 +165,18 @@ public:
void reshape (S32 width, S32 height, BOOL called_from_parent = TRUE);
void updateSidetrayVisibility();
/**
* @return side tray width if it's visible and expanded, 0 otherwise.
*
* Not that width of the tab buttons is not included.
*
* @see setVisibleWidthChangeCallback()
*/
S32 getVisibleWidth();
commit_signal_t& getCollapseSignal() { return mCollapseSignal; }
void setVisibleWidthChangeCallback(const commit_signal_t::slot_type& cb);
void updateSidetrayVisibility();
void handleLoginComplete();
@ -216,7 +225,7 @@ private:
tab_order_vector_t mOriginalTabOrder;
LLSideTrayTab* mActiveTab;
commit_signal_t mCollapseSignal;
commit_signal_t mVisibleWidthChangeSignal;
LLButton* mCollapseButton;
bool mCollapsed;

11
indra/newview/llstartup.cpp
View File

@ -3095,7 +3095,16 @@ bool process_login_success_response()
std::string map_server_url = response["map-server-url"];
if(!map_server_url.empty())
{
gSavedSettings.setString("MapServerURL", map_server_url);
// We got an answer from the grid -> use that for map for the current session
gSavedSettings.setString("CurrentMapServerURL", map_server_url);
LL_INFOS("LLStartup") << "map-server-url : we got an answer from the grid : " << map_server_url << LL_ENDL;
}
else
{
// No answer from the grid -> use the default setting for current session
map_server_url = gSavedSettings.getString("MapServerURL");
gSavedSettings.setString("CurrentMapServerURL", map_server_url);
LL_INFOS("LLStartup") << "map-server-url : no map-server-url answer, we use the default setting for the map : " << map_server_url << LL_ENDL;
}
// Default male and female avatars allowing the user to choose their avatar on first login.

57
indra/newview/llviewermessage.cpp
View File

@ -171,6 +171,31 @@ const BOOL SCRIPT_QUESTION_IS_CAUTION[SCRIPT_PERMISSION_EOF] =
FALSE // ControlYourCamera
};
// Extract channel and version from a string like "SL Web Viewer Beta 10.11.29.215604".
// (channel: "SL Web Viewer Beta", version: "10.11.29.215604")
static bool parse_version_info(const std::string& version_info, std::string& channel, std::string& ver)
{
size_t last_space = version_info.rfind(" ");
channel = version_info;
if (last_space != std::string::npos)
{
try
{
ver = version_info.substr(last_space + 1);
channel.replace(last_space, ver.length() + 1, ""); // strip version
}
catch (std::out_of_range)
{
return false;
}
return true;
}
return false;
}
bool friendship_offer_callback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
@ -3825,28 +3850,22 @@ void process_agent_movement_complete(LLMessageSystem* msg, void**)
if (!gLastVersionChannel.empty())
{
// work out the URL for this server's Release Notes
std::string url ="http://wiki.secondlife.com/wiki/Release_Notes/";
std::string server_version = version_channel;
std::vector<std::string> s_vect;
boost::algorithm::split(s_vect, server_version, isspace);
for(U32 i = 0; i < s_vect.size(); i++)
std::string url = regionp->getCapability("ServerReleaseNotes");
if (url.empty())
{
if (i != (s_vect.size() - 1))
// The capability hasn't arrived yet or is not supported,
// fall back to parsing server version channel.
std::string channel, ver;
if (!parse_version_info(version_channel, channel, ver))
{
if(i != (s_vect.size() - 2))
{
url += s_vect[i] + "_";
}
else
{
url += s_vect[i] + "/";
}
}
else
{
url += s_vect[i].substr(0,4);
llwarns << "Failed to parse server version channel (" << version_channel << ")" << llendl;
}
url = gSavedSettings.getString("ReleaseNotesURL");
LLSD args;
args["CHANNEL"] = LLWeb::escapeURL(channel);
args["VERSION"] = LLWeb::escapeURL(ver);
LLStringUtil::format(url, args);
}
LLSD args;

5
indra/newview/llviewerwindow.h
View File

@ -186,11 +186,6 @@ public:
/*virtual*/ std::string translateString(const char* tag,
const std::map<std::string, std::string>& args);
// signal on bottom tray width changed
typedef boost::function<void (void)> bottom_tray_callback_t;
typedef boost::signals2::signal<void (void)> bottom_tray_signal_t;
bottom_tray_signal_t mOnBottomTrayWidthChanged;
boost::signals2::connection setOnBottomTrayWidthChanged(bottom_tray_callback_t cb) { return mOnBottomTrayWidthChanged.connect(cb); }
// signal on update of WorldView rect
typedef boost::function<void (LLRect old_world_rect, LLRect new_world_rect)> world_rect_callback_t;
typedef boost::signals2::signal<void (LLRect old_world_rect, LLRect new_world_rect)> world_rect_signal_t;

3
indra/newview/llworldmipmap.cpp
View File

@ -181,8 +181,7 @@ LLPointer<LLViewerFetchedTexture> LLWorldMipmap::getObjectsTile(U32 grid_x, U32
LLPointer<LLViewerFetchedTexture> LLWorldMipmap::loadObjectsTile(U32 grid_x, U32 grid_y, S32 level)
{
// Get the grid coordinates
std::string imageurl = gSavedSettings.getString("MapServerURL") + llformat("map-%d-%d-%d-objects.jpg", level, grid_x, grid_y);
std::string imageurl = gSavedSettings.getString("CurrentMapServerURL") + llformat("map-%d-%d-%d-objects.jpg", level, grid_x, grid_y);
// DO NOT COMMIT!! DEBUG ONLY!!!
// Use a local jpeg for every tile to test map speed without S3 access

27
indra/newview/skins/default/xui/en/inspect_object.xml
View File

@ -76,13 +76,24 @@ L$30,000
</text>
<!-- Overlapping buttons for all default actions. Show "Buy" if
for sale, "Sit" if can sit, etc. -->
<icon
name="secure_browsing"
image_name="Lock"
left="0"
visible="false"
width="18"
height="18"
top="103"
tool_tip="Secure Browsing"
follows="left|top" />
<text
follows="all"
font="SansSerifSmall"
height="13"
name="object_media_url"
width="220"
top_pad="0"
width="207"
left_pad="2"
top_delta="0"
max_length = "50"
use_ellipses="true">
http://www.superdupertest.com
@ -135,16 +146,6 @@ L$30,000
name="open_btn"
top_delta="0"
width="80" />
<icon
name="secure_browsing"
image_name="Lock"
left_delta="80"
visible="false"
width="18"
height="18"
top_delta="0"
tool_tip="Secure Browsing"
follows="left|top" />
<!-- non-overlapping buttons here -->
<button
@ -153,7 +154,7 @@ L$30,000
label="More"
layout="topleft"
name="more_info_btn"
left_delta="10"
left_pad="10"
top_delta="0"
tab_stop="false"
width="80" />

11
indra/newview/skins/default/xui/en/menu_mini_map.xml
View File

@ -8,7 +8,7 @@
top="724"
visible="false"
width="128">
<menu_item_call
<menu_item_call
label="Zoom Close"
name="Zoom Close">
<menu_item_call.on_click
@ -29,7 +29,14 @@
function="Minimap.Zoom"
parameter="far" />
</menu_item_call>
<menu_item_separator />
<menu_item_call
label="Zoom Default"
name="Zoom Default">
<menu_item_call.on_click
function="Minimap.Zoom"
parameter="default" />
</menu_item_call>
<menu_item_separator />
<menu_item_check
label="Rotate Map"
name="Rotate Map">

2
indra/newview/skins/default/xui/en/panel_group_land_money.xml
View File

@ -117,7 +117,7 @@
name="map_button"
top_delta="-4"
left_pad="0"
width="60"
width="57"
enabled="false" />
<text
type="string"

1
indra/newview/skins/default/xui/en/panel_preferences_sound.xml
View File

@ -296,6 +296,7 @@
<check_box
name="media_auto_play_btn"
control_name="ParcelMediaAutoPlayEnable"
enabled_control="AudioStreamingMedia"
value="true"
follows="left|bottom|right"
height="15"

42
indra/newview/tests/llworldmap_test.cpp
View File

@ -25,13 +25,16 @@
* $/LicenseInfo$
*/
// Precompiled header: almost always required for newview cpp files
#include "../llviewerprecompiledheaders.h"
// Dependencies
#include "linden_common.h"
#include "llapr.h"
#include "llsingleton.h"
#include "lltrans.h"
#include "lluistring.h"
#include "../llviewertexture.h"
#include "../llworldmapmessage.h"
// Class to test
#include "../llworldmap.h"
// Dependencies
#include "../llviewerimagelist.h"
#include "../llworldmapmessage.h"
// Tut header
#include "../test/lltut.h"
@ -44,34 +47,29 @@
// * A simulator for a class can be implemented here. Please comment and document thoroughly.
// Stub image calls
LLViewerImageList::LLViewerImageList() { }
LLViewerImageList::~LLViewerImageList() { }
LLViewerImageList gImageList;
LLViewerImage* LLViewerImageList::getImage(const LLUUID &image_id,
BOOL usemipmaps,
BOOL level_immediate,
LLGLint internal_format,
LLGLenum primary_format,
LLHost request_from_host)
{ return NULL; }
void LLViewerImage::setBoostLevel(S32 level) { }
void LLImageGL::setAddressMode(LLTexUnit::eTextureAddressMode mode) { }
void LLViewerTexture::setBoostLevel(S32 ) { }
void LLViewerTexture::setAddressMode(LLTexUnit::eTextureAddressMode ) { }
LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTexture(const LLUUID&, BOOL, LLViewerTexture::EBoostLevel, S8,
LLGLint, LLGLenum, LLHost ) { return NULL; }
// Stub related map calls
LLWorldMapMessage::LLWorldMapMessage() { }
LLWorldMapMessage::~LLWorldMapMessage() { }
void LLWorldMapMessage::sendItemRequest(U32 type, U64 handle) { }
void LLWorldMapMessage::sendMapBlockRequest(U16 min_x, U16 min_y, U16 max_x, U16 max_y, bool return_nonexistent) { }
LLWorldMipmap::LLWorldMipmap() { }
LLWorldMipmap::~LLWorldMipmap() { }
void LLWorldMipmap::reset() { }
void LLWorldMipmap::dropBoostLevels() { }
void LLWorldMipmap::equalizeBoostLevels() { }
LLPointer<LLViewerImage> LLWorldMipmap::getObjectsTile(U32 grid_x, U32 grid_y, S32 level, bool load)
{ return NULL; }
LLPointer<LLViewerFetchedTexture> LLWorldMipmap::getObjectsTile(U32 grid_x, U32 grid_y, S32 level, bool load) { return NULL; }
// Stub other stuff
BOOL gPacificDaylightTime;
std::string LLTrans::getString(const std::string &, const LLStringUtil::format_map_t& ) { return std::string("test_trans"); }
void LLUIString::updateResult() const { }
void LLUIString::setArg(const std::string& , const std::string& ) { }
void LLUIString::assign(const std::string& ) { }
// End Stubbing
// -------------------------------------------------------------------------------------------
@ -237,7 +235,7 @@ namespace tut
// Test 9 : setLandForSaleImage() / getLandForSaleImage()
LLUUID id;
mSim->setLandForSaleImage(id);
LLPointer<LLViewerImage> image = mSim->getLandForSaleImage();
LLPointer<LLViewerFetchedTexture> image = mSim->getLandForSaleImage();
ensure("LLSimInfo::getLandForSaleImage() test failed", image.isNull());
// Test 10 : isPG()
mSim->setAccess(SIM_ACCESS_PG);
@ -370,7 +368,7 @@ namespace tut
}
// Test 7 : getObjectsTile()
try {
LLPointer<LLViewerImage> image = mWorld->getObjectsTile((U32)(X_WORLD_TEST/REGION_WIDTH_METERS), (U32)(Y_WORLD_TEST/REGION_WIDTH_METERS), 1);
LLPointer<LLViewerFetchedTexture> image = mWorld->getObjectsTile((U32)(X_WORLD_TEST/REGION_WIDTH_METERS), (U32)(Y_WORLD_TEST/REGION_WIDTH_METERS), 1);
ensure("LLWorldMap::getObjectsTile() failed", image.isNull());
} catch (...) {
fail("LLWorldMap::getObjectsTile() test failed with exception");

27
indra/newview/tests/llworldmipmap_test.cpp
View File

@ -25,12 +25,12 @@
* $/LicenseInfo$
*/
// Precompiled header: almost always required for newview cpp files
#include "../llviewerprecompiledheaders.h"
// Dependencies
#include "linden_common.h"
#include "../llviewertexture.h"
#include "../llviewercontrol.h"
// Class to test
#include "../llworldmipmap.h"
// Dependencies
#include "../llviewerimagelist.h"
// Tut header
#include "../test/lltut.h"
@ -42,19 +42,14 @@
// * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
// * A simulator for a class can be implemented here. Please comment and document thoroughly.
LLViewerImageList::LLViewerImageList() { }
LLViewerImageList::~LLViewerImageList() { }
void LLViewerTexture::setBoostLevel(S32 ) { }
LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromUrl(const std::string&, BOOL, LLViewerTexture::EBoostLevel, S8,
LLGLint, LLGLenum, const LLUUID& ) { return NULL; }
LLViewerImageList gImageList;
LLViewerImage* LLViewerImageList::getImageFromUrl(const std::string& url,
BOOL usemipmaps,
BOOL level_immediate,
LLGLint internal_format,
LLGLenum primary_format,
const LLUUID& force_id)
{ return NULL; }
void LLViewerImage::setBoostLevel(S32 level) { }
LLControlGroup::LLControlGroup(const std::string& name) : LLInstanceTracker<LLControlGroup, std::string>(name) { }
LLControlGroup::~LLControlGroup() { }
std::string LLControlGroup::getString(const std::string& ) { return std::string("test_url"); }
LLControlGroup gSavedSettings("test_settings");
// End Stubbing
// -------------------------------------------------------------------------------------------