diff --git a/.hgtags b/.hgtags
index 75ece0c9b419ee269d0a124500fc33de41215f5a..b333b9384d9285b923658970f6719c8926ad9e23 100755
--- a/.hgtags
+++ b/.hgtags
@@ -554,3 +554,5 @@ ab2ec5c5423b277d23fd0511ce50c15123ff2e03 6.2.3-release
9777aec6dc4a30a24537297ac040861ce16b82ae 6.3.0-release
ece699718f163921717bb95a6131e94af4c4138f 6.3.1-release
07f5d5bc9faebb45695853d40a9549773db816c0 6.3.2-release
+d9a4bd15e2c852953d6c8e84d6f3b7ca442c0e7f 6.3.3-release
+4033b3f57e76f087235145a3016886ccdc87ffa3 6.3.4-release
diff --git a/autobuild.xml b/autobuild.xml
index 3983e123130cb07872635916f36b574be17adf40..88db33e3176a2767d77c08b4fbaa752049c27be8 100644
--- a/autobuild.xml
+++ b/autobuild.xml
@@ -2918,7 +2918,7 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>license</key>
<string>Mixed</string>
<key>license_file</key>
- <string>LICENSES/slvoice.txt</string>
+ <string>LICENSES/vivox_licenses.txt</string>
<key>name</key>
<string>slvoice</string>
<key>platforms</key>
@@ -2940,9 +2940,9 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>archive</key>
<map>
<key>hash</key>
- <string>a605ec940768c878527d3b8f2ff61288</string>
+ <string>f824d586ab5de6edd14ef6828e9e4b66</string>
<key>url</key>
- <string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/21421/157284/slvoice-4.9.0002.30313.517593-darwin64-517593.tar.bz2</string>
+ <string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/44719/395040/slvoice-4.10.0000.32327.5fc3fe7c.531581-darwin64-531581.tar.bz2</string>
</map>
<key>name</key>
<string>darwin64</string>
@@ -2976,9 +2976,9 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>archive</key>
<map>
<key>hash</key>
- <string>5a78539626b5f23522d0b466247f48b4</string>
+ <string>1941c17c81905f23b4928288bcf719fb</string>
<key>url</key>
- <string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/21422/157291/slvoice-4.9.0002.30313.517593-windows-517593.tar.bz2</string>
+ <string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/44720/395047/slvoice-4.10.0000.32327.5fc3fe7c.531581-windows-531581.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>
@@ -2988,16 +2988,16 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>archive</key>
<map>
<key>hash</key>
- <string>1f8e09c053c00d9dc44ea74568e63dc1</string>
+ <string>baa6cdc8e8762d5519996ed9faa0bf3f</string>
<key>url</key>
- <string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/21423/157298/slvoice-4.9.0002.30313.517593-windows64-517593.tar.bz2</string>
+ <string>http://automated-builds-secondlife-com.s3.amazonaws.com/ct2/44721/395056/slvoice-4.10.0000.32327.5fc3fe7c.531581-windows64-531581.tar.bz2</string>
</map>
<key>name</key>
<string>windows64</string>
</map>
</map>
<key>version</key>
- <string>4.9.0002.30313.517593</string>
+ <string>4.10.0000.32327.5fc3fe7c.531581</string>
</map>
<key>tut</key>
<map>
diff --git a/indra/cmake/Copy3rdPartyLibs.cmake b/indra/cmake/Copy3rdPartyLibs.cmake
index dde53835fb5d770ddd954fb0138e902197d28efd..c73a1fdb47b3e78f5de6bfe751d0d76a8b73eb06 100644
--- a/indra/cmake/Copy3rdPartyLibs.cmake
+++ b/indra/cmake/Copy3rdPartyLibs.cmake
@@ -17,17 +17,16 @@ if(WINDOWS)
#*******************************
# VIVOX - *NOTE: no debug version
- set(vivox_src_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
- set(vivox_files
- SLVoice.exe
- )
+ set(vivox_lib_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
+ set(slvoice_src_dir "${ARCH_PREBUILT_BIN_RELEASE}")
+ set(slvoice_files SLVoice.exe )
if (ADDRESS_SIZE EQUAL 64)
- list(APPEND vivox_files
+ list(APPEND vivox_libs
vivoxsdk_x64.dll
ortp_x64.dll
)
else (ADDRESS_SIZE EQUAL 64)
- list(APPEND vivox_files
+ list(APPEND vivox_libs
vivoxsdk.dll
ortp.dll
)
@@ -169,11 +168,10 @@ elseif(DARWIN)
set(SHARED_LIB_STAGING_DIR_RELWITHDEBINFO "${SHARED_LIB_STAGING_DIR}/RelWithDebInfo/Resources")
set(SHARED_LIB_STAGING_DIR_RELEASE "${SHARED_LIB_STAGING_DIR}/Release/Resources")
- set(vivox_src_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
- set(vivox_files
- SLVoice
+ set(vivox_lib_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
+ set(slvoice_files SLVoice)
+ set(vivox_libs
libortp.dylib
- libvivoxplatform.dylib
libvivoxsdk.dylib
)
set(debug_src_dir "${ARCH_PREBUILT_DIRS_DEBUG}")
@@ -206,15 +204,15 @@ elseif(LINUX)
set(SHARED_LIB_STAGING_DIR_RELWITHDEBINFO "${SHARED_LIB_STAGING_DIR}")
set(SHARED_LIB_STAGING_DIR_RELEASE "${SHARED_LIB_STAGING_DIR}")
- set(vivox_src_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
- set(vivox_files
+ set(vivox_lib_dir "${ARCH_PREBUILT_DIRS_RELEASE}")
+ set(vivox_libs
libsndfile.so.1
libortp.so
libvivoxoal.so.1
- libvivoxplatform.so
libvivoxsdk.so
- SLVoice
- )
+ )
+ set(slvoice_files SLVoice)
+
# *TODO - update this to use LIBS_PREBUILT_DIR and LL_ARCH_DIR variables
# or ARCH_PREBUILT_DIRS
set(debug_src_dir "${ARCH_PREBUILT_DIRS_DEBUG}")
@@ -251,8 +249,8 @@ elseif(LINUX)
else(WINDOWS)
message(STATUS "WARNING: unrecognized platform for staging 3rd party libs, skipping...")
- set(vivox_src_dir "${CMAKE_SOURCE_DIR}/newview/vivox-runtime/i686-linux")
- set(vivox_files "")
+ set(vivox_lib_dir "${CMAKE_SOURCE_DIR}/newview/vivox-runtime/i686-linux")
+ set(vivox_libs "")
# *TODO - update this to use LIBS_PREBUILT_DIR and LL_ARCH_DIR variables
# or ARCH_PREBUILT_DIRS
set(debug_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-linux/lib/debug")
@@ -275,39 +273,36 @@ endif(WINDOWS)
################################################################
copy_if_different(
- ${vivox_src_dir}
+ ${vivox_lib_dir}
"${SHARED_LIB_STAGING_DIR_DEBUG}"
out_targets
- ${vivox_files}
+ ${vivox_libs}
)
set(third_party_targets ${third_party_targets} ${out_targets})
copy_if_different(
- ${vivox_src_dir}
+ ${slvoice_src_dir}
+ "${SHARED_LIB_STAGING_DIR_RELEASE}"
+ out_targets
+ ${slvoice_files}
+ )
+copy_if_different(
+ ${vivox_lib_dir}
"${SHARED_LIB_STAGING_DIR_RELEASE}"
out_targets
- ${vivox_files}
+ ${vivox_libs}
)
+
set(third_party_targets ${third_party_targets} ${out_targets})
copy_if_different(
- ${vivox_src_dir}
+ ${vivox_lib_dir}
"${SHARED_LIB_STAGING_DIR_RELWITHDEBINFO}"
out_targets
- ${vivox_files}
+ ${vivox_libs}
)
set(third_party_targets ${third_party_targets} ${out_targets})
-
-
-#copy_if_different(
-# ${debug_src_dir}
-# "${SHARED_LIB_STAGING_DIR_DEBUG}"
-# out_targets
-# ${debug_files}
-# )
-#set(third_party_targets ${third_party_targets} ${out_targets})
-
copy_if_different(
${release_src_dir}
"${SHARED_LIB_STAGING_DIR_RELEASE}"
diff --git a/indra/lib/python/indra/util/llmanifest.py b/indra/lib/python/indra/util/llmanifest.py
index 2e6cf53912c2cd0e06440a4346aaaf03ba5c06da..4bc70b2ca4106c67fde86440317e9fa406dd45bc 100755
--- a/indra/lib/python/indra/util/llmanifest.py
+++ b/indra/lib/python/indra/util/llmanifest.py
@@ -27,6 +27,7 @@
$/LicenseInfo$
"""
+from collections import namedtuple, defaultdict
import commands
import errno
import filecmp
@@ -312,6 +313,8 @@ def __init__(cls, name, bases, dct):
if match:
cls.manifests[match.group(1).lower()] = cls
+MissingFile = namedtuple("MissingFile", ("pattern", "tried"))
+
class LLManifest(object):
__metaclass__ = LLManifestRegistry
manifests = {}
@@ -333,7 +336,8 @@ def __init__(self, args):
self.dst_prefix = [args['dest']]
self.created_paths = []
self.package_name = "Unknown"
-
+ self.missing = []
+
def default_channel(self):
return self.args.get('channel', None) == RELEASE_CHANNEL
@@ -592,6 +596,40 @@ def copy_action(self, src, dst):
def package_action(self, src, dst):
pass
+ def finish(self):
+ """
+ generic finish, always called before the ${action}_finish() methods
+ """
+ # Collecting MissingFile instances in self.missing, and checking that
+ # here, is intended to minimize the number of (potentially lengthy)
+ # build cycles a developer must run in order to fix missing-files
+ # errors. The manifest processing is necessarily the last step in a
+ # build, and if we only caught a single missing file error per run,
+ # the developer would need to run a build for each additional missing-
+ # file error until all were resolved. This way permits the developer
+ # to resolve them all at once.
+ if self.missing:
+ print '*' * 72
+ print "Missing files:"
+ # Instead of just dumping each missing file and all the places we
+ # looked for it, group by common sets of places we looked. Use a
+ # set to store the 'tried' directories, to avoid mismatches due to
+ # reordering -- but since we intend to use the set of 'tried'
+ # directories as a dict key, it must be a frozenset.
+ organize = defaultdict(set)
+ for missingfile in self.missing:
+ organize[frozenset(missingfile.tried)].add(missingfile.pattern)
+ # Now dump all the patterns sought in each group of 'tried'
+ # directories.
+ for tried, patterns in organize.items():
+ print " Could not find in:"
+ for dir in sorted(tried):
+ print " %s" % dir
+ for pattern in sorted(patterns):
+ print " %s" % pattern
+ print '*' * 72
+ raise MissingError('%s patterns could not be found' % len(self.missing))
+
def copy_finish(self):
pass
@@ -825,17 +863,23 @@ def try_path(src):
return count
try_prefixes = [self.get_src_prefix(), self.get_artwork_prefix(), self.get_build_prefix()]
- tried=[]
- count=0
- while not count and try_prefixes:
- pfx = try_prefixes.pop(0)
+ for pfx in try_prefixes:
try:
count = try_path(os.path.join(pfx, src))
except MissingError:
- tried.append(pfx)
- if not try_prefixes:
- # no more prefixes left to try
- print "unable to find '%s'; looked in:\n %s" % (src, '\n '.join(tried))
+ # if we produce MissingError, just try the next prefix
+ continue
+ # If we actually found nonzero files, stop looking
+ if count:
+ break
+ else:
+ # no more prefixes left to try
+ print("\nunable to find '%s'; looked in:\n %s" % (src, '\n '.join(try_prefixes)))
+ self.missing.append(MissingFile(pattern=src, tried=try_prefixes))
+ # At this point 'count' might never have been successfully
+ # assigned! Even if it was, though, we can be sure it is 0.
+ return 0
+
print "%d files" % count
# Let caller check whether we processed as many files as expected. In
@@ -846,6 +890,8 @@ def do(self, *actions):
self.actions = actions
self.construct()
# perform finish actions
+ # generic finish first
+ self.finish()
for action in self.actions:
methodname = action + "_finish"
method = getattr(self, methodname, None)
diff --git a/indra/llappearance/llwearabletype.cpp b/indra/llappearance/llwearabletype.cpp
index 0e29bbe783e08219000a94ec341fef76122f8d5e..6b7dc41ffdc10b0db17e1b0b4f3359ecdd8452f6 100644
--- a/indra/llappearance/llwearabletype.cpp
+++ b/indra/llappearance/llwearabletype.cpp
@@ -29,18 +29,6 @@
#include "llinventorytype.h"
#include "llinventorydefines.h"
-static LLTranslationBridge* sTrans = NULL;
-
-// static
-void LLWearableType::initClass(LLTranslationBridge* trans)
-{
- sTrans = trans;
-}
-
-void LLWearableType::cleanupClass()
-{
- delete sTrans;
-}
struct WearableEntry : public LLDictionaryEntry
{
@@ -53,7 +41,7 @@ struct WearableEntry : public LLDictionaryEntry
LLDictionaryEntry(name),
mAssetType(assetType),
mDefaultNewName(default_new_name),
- mLabel(sTrans->getString(name)),
+ mLabel(LLWearableType::getInstance()->mTrans->getString(name)),
mIconName(iconName),
mDisableCameraSwitch(disable_camera_switch),
mAllowMultiwear(allow_multiwear)
@@ -68,7 +56,7 @@ struct WearableEntry : public LLDictionaryEntry
BOOL mAllowMultiwear;
};
-class LLWearableDictionary : public LLSingleton<LLWearableDictionary>,
+class LLWearableDictionary : public LLParamSingleton<LLWearableDictionary>,
public LLDictionary<LLWearableType::EType, WearableEntry>
{
LLSINGLETON(LLWearableDictionary);
@@ -99,6 +87,27 @@ LLWearableDictionary::LLWearableDictionary()
addEntry(LLWearableType::WT_NONE, new WearableEntry("none", "Invalid Wearable", LLAssetType::AT_NONE, LLInventoryType::ICONNAME_NONE, FALSE, FALSE));
}
+
+// class LLWearableType
+
+LLWearableType::LLWearableType(LLTranslationBridge* trans)
+{
+ mTrans = trans;
+}
+
+LLWearableType::~LLWearableType()
+{
+ delete mTrans;
+}
+
+void LLWearableType::initSingleton()
+{
+ // To make sure all wrapping functions will crash without initing LLWearableType;
+ LLWearableDictionary::initParamSingleton();
+
+ // Todo: consider merging LLWearableType and LLWearableDictionary
+}
+
// static
LLWearableType::EType LLWearableType::typeNameToType(const std::string& type_name)
{
diff --git a/indra/llappearance/llwearabletype.h b/indra/llappearance/llwearabletype.h
index ac81376538ed1d2d94f33babf891ee980f2e34dc..80bb9a10b4a28bd04dc0694a7e4e75ef475157a2 100644
--- a/indra/llappearance/llwearabletype.h
+++ b/indra/llappearance/llwearabletype.h
@@ -42,8 +42,12 @@ class LLTranslationBridge
};
-class LLWearableType
+class LLWearableType : public LLParamSingleton<LLWearableType>
{
+ LLSINGLETON(LLWearableType, LLTranslationBridge* trans);
+ ~LLWearableType();
+ friend struct WearableEntry;
+ void initSingleton();
public:
enum EType
{
@@ -70,9 +74,8 @@ class LLWearableType
WT_NONE = -1,
};
- static void initClass(LLTranslationBridge* trans); // initializes static members
- static void cleanupClass(); // initializes static members
-
+ // Most methods are wrappers for dictionary, but if LLWearableType is not initialized,
+ // they will crash. Whole LLWearableType is just wrapper for convinient calls.
static const std::string& getTypeName(EType type);
static const std::string& getTypeDefaultNewName(EType type);
static const std::string& getTypeLabel(EType type);
@@ -81,11 +84,12 @@ class LLWearableType
static LLInventoryType::EIconName getIconName(EType type);
static BOOL getDisableCameraSwitch(EType type);
static BOOL getAllowMultiwear(EType type);
- static EType inventoryFlagsToWearableType(U32 flags);
+
+ static EType inventoryFlagsToWearableType(U32 flags);
protected:
- LLWearableType() {}
- ~LLWearableType() {}
+
+ LLTranslationBridge* mTrans;
};
#endif // LL_LLWEARABLETYPE_H
diff --git a/indra/llcommon/llsingleton.cpp b/indra/llcommon/llsingleton.cpp
index 9fbd78a0003e10067cc16234fdc86363a3cebbc0..c45c14457048ecc65da4fc5593f4a5d54972c211 100644
--- a/indra/llcommon/llsingleton.cpp
+++ b/indra/llcommon/llsingleton.cpp
@@ -134,12 +134,6 @@ LLSingletonBase::list_t& LLSingletonBase::get_initializing()
return LLSingletonBase::MasterList::instance().get_initializing_();
}
-//static
-LLSingletonBase::list_t& LLSingletonBase::get_initializing_from(MasterList* master)
-{
- return master->get_initializing_();
-}
-
LLSingletonBase::~LLSingletonBase() {}
void LLSingletonBase::push_initializing(const char* name)
@@ -156,7 +150,7 @@ void LLSingletonBase::pop_initializing()
if (list.empty())
{
logerrs("Underflow in stack of currently-initializing LLSingletons at ",
- demangle(typeid(*this).name()).c_str(), "::getInstance()");
+ classname(this).c_str(), "::getInstance()");
}
// Now we know list.back() exists: capture it
@@ -178,14 +172,39 @@ void LLSingletonBase::pop_initializing()
if (back != this)
{
logerrs("Push/pop mismatch in stack of currently-initializing LLSingletons: ",
- demangle(typeid(*this).name()).c_str(), "::getInstance() trying to pop ",
- demangle(typeid(*back).name()).c_str());
+ classname(this).c_str(), "::getInstance() trying to pop ",
+ classname(back).c_str());
}
// log AFTER popping so logging singletons don't cry circularity
log_initializing("Popping", typeid(*back).name());
}
+void LLSingletonBase::reset_initializing(list_t::size_type size)
+{
+ // called for cleanup in case the LLSingleton subclass constructor throws
+ // an exception
+
+ // The tricky thing about this, the reason we have a separate method
+ // instead of just calling pop_initializing(), is (hopefully remote)
+ // possibility that the exception happened *before* the
+ // push_initializing() call in LLSingletonBase's constructor. So only
+ // remove the stack top if in fact we've pushed something more than the
+ // previous size.
+ list_t& list(get_initializing());
+
+ while (list.size() > size)
+ {
+ list.pop_back();
+ }
+
+ // as in pop_initializing()
+ if (list.empty())
+ {
+ MasterList::instance().cleanup_initializing_();
+ }
+}
+
//static
void LLSingletonBase::log_initializing(const char* verb, const char* name)
{
@@ -197,7 +216,7 @@ void LLSingletonBase::log_initializing(const char* verb, const char* name)
ri != rend; ++ri)
{
LLSingletonBase* sb(*ri);
- LL_CONT << ' ' << demangle(typeid(*sb).name());
+ LL_CONT << ' ' << classname(sb);
}
LL_ENDL;
}
@@ -231,7 +250,7 @@ void LLSingletonBase::capture_dependency(list_t& initializing, EInitState initSt
// 'found' is an iterator; *found is an LLSingletonBase*; **found
// is the actual LLSingletonBase instance.
LLSingletonBase* foundp(*found);
- out << demangle(typeid(*foundp).name()) << " -> ";
+ out << classname(foundp) << " -> ";
}
// We promise to capture dependencies from both the constructor
// and the initSingleton() method, so an LLSingleton's instance
@@ -245,7 +264,7 @@ void LLSingletonBase::capture_dependency(list_t& initializing, EInitState initSt
if (initState == CONSTRUCTING)
{
logerrs("LLSingleton circularity in Constructor: ", out.str().c_str(),
- demangle(typeid(*this).name()).c_str(), "");
+ classname(this).c_str(), "");
}
else if (it_next == initializing.end())
{
@@ -256,14 +275,14 @@ void LLSingletonBase::capture_dependency(list_t& initializing, EInitState initSt
// Example: LLNotifications singleton initializes default channels.
// Channels register themselves with singleton once done.
logdebugs("LLSingleton circularity: ", out.str().c_str(),
- demangle(typeid(*this).name()).c_str(), "");
+ classname(this).c_str(), "");
}
else
{
// Actual circularity with other singleton (or single singleton is used extensively).
// Dependency can be unclear.
logwarns("LLSingleton circularity: ", out.str().c_str(),
- demangle(typeid(*this).name()).c_str(), "");
+ classname(this).c_str(), "");
}
}
else
@@ -276,8 +295,8 @@ void LLSingletonBase::capture_dependency(list_t& initializing, EInitState initSt
if (current->mDepends.insert(this).second)
{
// only log the FIRST time we hit this dependency!
- logdebugs(demangle(typeid(*current).name()).c_str(),
- " depends on ", demangle(typeid(*this).name()).c_str());
+ logdebugs(classname(current).c_str(),
+ " depends on ", classname(this).c_str());
}
}
}
@@ -336,19 +355,19 @@ void LLSingletonBase::cleanupAll()
sp->mCleaned = true;
logdebugs("calling ",
- demangle(typeid(*sp).name()).c_str(), "::cleanupSingleton()");
+ classname(sp).c_str(), "::cleanupSingleton()");
try
{
sp->cleanupSingleton();
}
catch (const std::exception& e)
{
- logwarns("Exception in ", demangle(typeid(*sp).name()).c_str(),
+ logwarns("Exception in ", classname(sp).c_str(),
"::cleanupSingleton(): ", e.what());
}
catch (...)
{
- logwarns("Unknown exception in ", demangle(typeid(*sp).name()).c_str(),
+ logwarns("Unknown exception in ", classname(sp).c_str(),
"::cleanupSingleton()");
}
}
@@ -363,7 +382,7 @@ void LLSingletonBase::deleteAll()
{
// Capture the class name first: in case of exception, don't count on
// being able to extract it later.
- const std::string name = demangle(typeid(*sp).name());
+ const std::string name = classname(sp);
try
{
// Call static method through instance function pointer.
@@ -440,7 +459,17 @@ void LLSingletonBase::logerrs(const char* p1, const char* p2, const char* p3, co
log(LLError::LEVEL_ERROR, p1, p2, p3, p4);
// The other important side effect of LL_ERRS() is
// https://www.youtube.com/watch?v=OMG7paGJqhQ (emphasis on OMG)
- LLError::crashAndLoop(std::string());
+ std::ostringstream out;
+ out << p1 << p2 << p3 << p4;
+ auto crash = LLError::getFatalFunction();
+ if (crash)
+ {
+ crash(out.str());
+ }
+ else
+ {
+ LLError::crashAndLoop(out.str());
+ }
}
std::string LLSingletonBase::demangle(const char* mangled)
diff --git a/indra/llcommon/llsingleton.h b/indra/llcommon/llsingleton.h
index 859e271e26c661a88a726456bcaf128d61f83672..0da6d548ab007aaf1719acba4a4093919d7f9b3b 100644
--- a/indra/llcommon/llsingleton.h
+++ b/indra/llcommon/llsingleton.h
@@ -31,6 +31,18 @@
#include <vector>
#include <typeinfo>
+#if LL_WINDOWS
+#pragma warning (push)
+#pragma warning (disable:4265)
+#endif
+// warning C4265: 'std::_Pad' : class has virtual functions, but destructor is not virtual
+
+#include <mutex>
+
+#if LL_WINDOWS
+#pragma warning (pop)
+#endif
+
class LLSingletonBase: private boost::noncopyable
{
public:
@@ -43,7 +55,6 @@ class LLSingletonBase: private boost::noncopyable
// This, on the other hand, is a stack whose top indicates the LLSingleton
// currently being initialized.
static list_t& get_initializing();
- static list_t& get_initializing_from(MasterList*);
// Produce a vector<LLSingletonBase*> of master list, in dependency order.
typedef std::vector<LLSingletonBase*> vec_t;
static vec_t dep_sort();
@@ -57,10 +68,11 @@ class LLSingletonBase: private boost::noncopyable
typedef enum e_init_state
{
UNINITIALIZED = 0, // must be default-initialized state
- CONSTRUCTING,
- INITIALIZING,
- INITIALIZED,
- DELETED
+ CONSTRUCTING, // within DERIVED_TYPE constructor
+ CONSTRUCTED, // finished DERIVED_TYPE constructor
+ INITIALIZING, // within DERIVED_TYPE::initSingleton()
+ INITIALIZED, // normal case
+ DELETED // deleteSingleton() or deleteAll() called
} EInitState;
// Define tag<T> to pass to our template constructor. You can't explicitly
@@ -100,6 +112,9 @@ class LLSingletonBase: private boost::noncopyable
// That being the case, we control exactly when it happens -- and we can
// pop the stack immediately thereafter.
void pop_initializing();
+ // Remove 'this' from the init stack in case of exception in the
+ // LLSingleton subclass constructor.
+ static void reset_initializing(list_t::size_type size);
private:
// logging
static void log_initializing(const char* verb, const char* name);
@@ -115,6 +130,10 @@ class LLSingletonBase: private boost::noncopyable
static void logwarns(const char* p1, const char* p2="",
const char* p3="", const char* p4="");
static std::string demangle(const char* mangled);
+ template <typename T>
+ static std::string classname() { return demangle(typeid(T).name()); }
+ template <typename T>
+ static std::string classname(T* ptr) { return demangle(typeid(*ptr).name()); }
// Default methods in case subclass doesn't declare them.
virtual void initSingleton() {}
@@ -178,7 +197,15 @@ struct LLSingleton_manage_master
void remove(LLSingletonBase* sb) { sb->remove_master(); }
void push_initializing(LLSingletonBase* sb) { sb->push_initializing(typeid(T).name()); }
void pop_initializing (LLSingletonBase* sb) { sb->pop_initializing(); }
- LLSingletonBase::list_t& get_initializing(T*) { return LLSingletonBase::get_initializing(); }
+ // used for init stack cleanup in case an LLSingleton subclass constructor
+ // throws an exception
+ void reset_initializing(LLSingletonBase::list_t::size_type size)
+ {
+ LLSingletonBase::reset_initializing(size);
+ }
+ // For any LLSingleton subclass except the MasterList, obtain the init
+ // stack from the MasterList singleton instance.
+ LLSingletonBase::list_t& get_initializing() { return LLSingletonBase::get_initializing(); }
};
// But for the specific case of LLSingletonBase::MasterList, don't.
@@ -189,9 +216,14 @@ struct LLSingleton_manage_master<LLSingletonBase::MasterList>
void remove(LLSingletonBase*) {}
void push_initializing(LLSingletonBase*) {}
void pop_initializing (LLSingletonBase*) {}
- LLSingletonBase::list_t& get_initializing(LLSingletonBase::MasterList* instance)
+ // since we never pushed, no need to clean up
+ void reset_initializing(LLSingletonBase::list_t::size_type size) {}
+ LLSingletonBase::list_t& get_initializing()
{
- return LLSingletonBase::get_initializing_from(instance);
+ // The MasterList shouldn't depend on any other LLSingletons. We'd
+ // get into trouble if we tried to recursively engage that machinery.
+ static LLSingletonBase::list_t sDummyList;
+ return sDummyList;
}
};
@@ -201,10 +233,19 @@ LLSingletonBase::LLSingletonBase(tag<DERIVED_TYPE>):
mCleaned(false),
mDeleteSingleton(NULL)
{
- // Make this the currently-initializing LLSingleton.
+ // This is the earliest possible point at which we can push this new
+ // instance onto the init stack. LLSingleton::constructSingleton() can't
+ // do it before calling the constructor, because it doesn't have an
+ // instance pointer until the constructor returns. Fortunately this
+ // constructor is guaranteed to be called before any subclass constructor.
+ // Make this new instance the currently-initializing LLSingleton.
LLSingleton_manage_master<DERIVED_TYPE>().push_initializing(this);
}
+// forward declare for friend directive within LLSingleton
+template <typename DERIVED_TYPE>
+class LLParamSingleton;
+
/**
* LLSingleton implements the getInstance() method part of the Singleton
* pattern. It can't make the derived class constructors protected, though, so
@@ -270,9 +311,94 @@ template <typename DERIVED_TYPE>
class LLSingleton : public LLSingletonBase
{
private:
- static DERIVED_TYPE* constructSingleton()
+ // Allow LLParamSingleton subclass -- but NOT DERIVED_TYPE itself -- to
+ // access our private members.
+ friend class LLParamSingleton<DERIVED_TYPE>;
+
+ // LLSingleton only supports a nullary constructor. However, the specific
+ // purpose for its subclass LLParamSingleton is to support Singletons
+ // requiring constructor arguments. constructSingleton() supports both use
+ // cases.
+ template <typename... Args>
+ static void constructSingleton(Args&&... args)
+ {
+ auto prev_size = LLSingleton_manage_master<DERIVED_TYPE>().get_initializing().size();
+ // getInstance() calls are from within constructor
+ sData.mInitState = CONSTRUCTING;
+ try
+ {
+ sData.mInstance = new DERIVED_TYPE(std::forward<Args>(args)...);
+ // we have called constructor, have not yet called initSingleton()
+ sData.mInitState = CONSTRUCTED;
+ }
+ catch (const std::exception& err)
+ {
+ // LLSingletonBase might -- or might not -- have pushed the new
+ // instance onto the init stack before the exception. Reset the
+ // init stack to its previous size BEFORE logging so log-machinery
+ // LLSingletons don't record a dependency on DERIVED_TYPE!
+ LLSingleton_manage_master<DERIVED_TYPE>().reset_initializing(prev_size);
+ logwarns("Error constructing ", classname<DERIVED_TYPE>().c_str(),
+ ": ", err.what());
+ // There isn't a separate EInitState value meaning "we attempted
+ // to construct this LLSingleton subclass but could not," so use
+ // DELETED. That seems slightly more appropriate than UNINITIALIZED.
+ sData.mInitState = DELETED;
+ // propagate the exception
+ throw;
+ }
+ }
+
+ static void finishInitializing()
+ {
+ // getInstance() calls are from within initSingleton()
+ sData.mInitState = INITIALIZING;
+ try
+ {
+ // initialize singleton after constructing it so that it can
+ // reference other singletons which in turn depend on it, thus
+ // breaking cyclic dependencies
+ sData.mInstance->initSingleton();
+ sData.mInitState = INITIALIZED;
+
+ // pop this off stack of initializing singletons
+ pop_initializing();
+ }
+ catch (const std::exception& err)
+ {
+ // pop this off stack of initializing singletons here, too --
+ // BEFORE logging, so log-machinery LLSingletons don't record a
+ // dependency on DERIVED_TYPE!
+ pop_initializing();
+ logwarns("Error in ", classname<DERIVED_TYPE>().c_str(),
+ "::initSingleton(): ", err.what());
+ // and get rid of the instance entirely
+ deleteSingleton();
+ // propagate the exception
+ throw;
+ }
+ }
+
+ static void pop_initializing()
{
- return new DERIVED_TYPE();
+ // route through LLSingleton_manage_master so we Do The Right Thing
+ // (namely, nothing) for MasterList
+ LLSingleton_manage_master<DERIVED_TYPE>().pop_initializing(sData.mInstance);
+ }
+
+ // Without this 'using' declaration, the static method we're declaring
+ // here would hide the base-class method we want it to call.
+ using LLSingletonBase::capture_dependency;
+ static void capture_dependency()
+ {
+ // By this point, if DERIVED_TYPE was pushed onto the initializing
+ // stack, it has been popped off. So the top of that stack, if any, is
+ // an LLSingleton that directly depends on DERIVED_TYPE. If
+ // getInstance() was called by another LLSingleton, rather than from
+ // vanilla application code, record the dependency.
+ sData.mInstance->capture_dependency(
+ LLSingleton_manage_master<DERIVED_TYPE>().get_initializing(),
+ sData.mInitState);
}
// We know of no way to instruct the compiler that every subclass
@@ -285,34 +411,17 @@ class LLSingleton : public LLSingletonBase
// subclass body.
virtual void you_must_use_LLSINGLETON_macro() = 0;
- // stores pointer to singleton instance
- struct SingletonLifetimeManager
+ // The purpose of this struct is to engage the C++11 guarantee that static
+ // variables declared in function scope are initialized exactly once, even
+ // if multiple threads concurrently reach the same declaration.
+ // https://en.cppreference.com/w/cpp/language/storage_duration#Static_local_variables
+ // Since getInstance() declares a static instance of SingletonInitializer,
+ // only the first call to getInstance() calls constructSingleton().
+ struct SingletonInitializer
{
- SingletonLifetimeManager()
- {
- construct();
- }
-
- static void construct()
- {
- sData.mInitState = CONSTRUCTING;
- sData.mInstance = constructSingleton();
- sData.mInitState = INITIALIZING;
- }
-
- ~SingletonLifetimeManager()
+ SingletonInitializer()
{
- // The dependencies between LLSingletons, and the arbitrary order
- // of static-object destruction, mean that we DO NOT WANT this
- // destructor to delete this LLSingleton. This destructor will run
- // without regard to any other LLSingleton whose cleanup might
- // depend on its existence. If you want to clean up LLSingletons,
- // call LLSingletonBase::deleteAll() sometime before static-object
- // destruction begins. That method will properly honor cross-
- // LLSingleton dependencies. Otherwise we simply leak LLSingleton
- // instances at shutdown. Since the whole process is terminating
- // anyway, that's not necessarily a bad thing; it depends on what
- // resources your LLSingleton instances are managing.
+ constructSingleton();
}
};
@@ -363,64 +472,59 @@ class LLSingleton : public LLSingletonBase
static void deleteSingleton()
{
delete sData.mInstance;
- sData.mInstance = NULL;
- sData.mInitState = DELETED;
+ // SingletonData state handled by destructor, above
}
static DERIVED_TYPE* getInstance()
{
- static SingletonLifetimeManager sLifeTimeMgr;
+ // call constructSingleton() only the first time we get here
+ static SingletonInitializer sInitializer;
switch (sData.mInitState)
{
case UNINITIALIZED:
// should never be uninitialized at this point
logerrs("Uninitialized singleton ",
- demangle(typeid(DERIVED_TYPE).name()).c_str());
+ classname<DERIVED_TYPE>().c_str());
return NULL;
case CONSTRUCTING:
+ // here if DERIVED_TYPE's constructor (directly or indirectly)
+ // calls DERIVED_TYPE::getInstance()
logerrs("Tried to access singleton ",
- demangle(typeid(DERIVED_TYPE).name()).c_str(),
+ classname<DERIVED_TYPE>().c_str(),
" from singleton constructor!");
return NULL;
- case INITIALIZING:
- // go ahead and flag ourselves as initialized so we can be
- // reentrant during initialization
- sData.mInitState = INITIALIZED;
- // initialize singleton after constructing it so that it can
- // reference other singletons which in turn depend on it, thus
- // breaking cyclic dependencies
- sData.mInstance->initSingleton();
- // pop this off stack of initializing singletons
- LLSingleton_manage_master<DERIVED_TYPE>().pop_initializing(sData.mInstance);
+ case CONSTRUCTED:
+ // first time through: set to CONSTRUCTED by
+ // constructSingleton(), called by sInitializer's constructor;
+ // still have to call initSingleton()
+ finishInitializing();
break;
+ case INITIALIZING:
+ // here if DERIVED_TYPE::initSingleton() (directly or indirectly)
+ // calls DERIVED_TYPE::getInstance(): go ahead and allow it
case INITIALIZED:
+ // normal subsequent calls
break;
case DELETED:
+ // called after deleteSingleton()
logwarns("Trying to access deleted singleton ",
- demangle(typeid(DERIVED_TYPE).name()).c_str(),
+ classname<DERIVED_TYPE>().c_str(),
" -- creating new instance");
- SingletonLifetimeManager::construct();
- // same as first time construction
- sData.mInitState = INITIALIZED;
- sData.mInstance->initSingleton();
- // pop this off stack of initializing singletons
- LLSingleton_manage_master<DERIVED_TYPE>().pop_initializing(sData.mInstance);
+ // This recovery sequence is NOT thread-safe! We would need a
+ // recursive_mutex a la LLParamSingleton.
+ constructSingleton();
+ finishInitializing();
break;
}
- // By this point, if DERIVED_TYPE was pushed onto the initializing
- // stack, it has been popped off. So the top of that stack, if any, is
- // an LLSingleton that directly depends on DERIVED_TYPE. If this call
- // came from another LLSingleton, rather than from vanilla application
- // code, record the dependency.
- sData.mInstance->capture_dependency(
- LLSingleton_manage_master<DERIVED_TYPE>().get_initializing(sData.mInstance),
- sData.mInitState);
+ // record the dependency, if any: check if we got here from another
+ // LLSingleton's constructor or initSingleton() method
+ capture_dependency();
return sData.mInstance;
}
@@ -460,6 +564,173 @@ class LLSingleton : public LLSingletonBase
template<typename T>
typename LLSingleton<T>::SingletonData LLSingleton<T>::sData;
+
+/**
+ * LLParamSingleton<T> is like LLSingleton<T>, except in the following ways:
+ *
+ * * It is NOT instantiated on demand (instance() or getInstance()). You must
+ * first call initParamSingleton(constructor args...).
+ * * Before initParamSingleton(), calling instance() or getInstance() dies with
+ * LL_ERRS.
+ * * initParamSingleton() may be called only once. A second call dies with
+ * LL_ERRS.
+ * * However, distinct initParamSingleton() calls can be used to engage
+ * different constructors, as long as only one such call is executed at
+ * runtime.
+ * * Unlike LLSingleton, an LLParamSingleton cannot be "revived" by an
+ * instance() or getInstance() call after deleteSingleton().
+ *
+ * Importantly, though, each LLParamSingleton subclass does participate in the
+ * dependency-ordered LLSingletonBase::deleteAll() processing.
+ */
+template <typename DERIVED_TYPE>
+class LLParamSingleton : public LLSingleton<DERIVED_TYPE>
+{
+private:
+ typedef LLSingleton<DERIVED_TYPE> super;
+ // Use a recursive_mutex in case of constructor circularity. With a
+ // non-recursive mutex, that would result in deadlock rather than the
+ // logerrs() call in getInstance().
+ typedef std::recursive_mutex mutex_t;
+
+public:
+ using super::deleteSingleton;
+ using super::instanceExists;
+ using super::wasDeleted;
+
+ // Passes arguments to DERIVED_TYPE's constructor and sets appropriate states
+ template <typename... Args>
+ static void initParamSingleton(Args&&... args)
+ {
+ // In case racing threads both call initParamSingleton() at the same
+ // time, serialize them. One should initialize; the other should see
+ // mInitState already set.
+ std::unique_lock<mutex_t> lk(getMutex());
+ // For organizational purposes this function shouldn't be called twice
+ if (super::sData.mInitState != super::UNINITIALIZED)
+ {
+ super::logerrs("Tried to initialize singleton ",
+ super::template classname<DERIVED_TYPE>().c_str(),
+ " twice!");
+ }
+ else
+ {
+ super::constructSingleton(std::forward<Args>(args)...);
+ super::finishInitializing();
+ }
+ }
+
+ static DERIVED_TYPE* getInstance()
+ {
+ // In case racing threads call getInstance() at the same moment as
+ // initParamSingleton(), serialize the calls.
+ std::unique_lock<mutex_t> lk(getMutex());
+
+ switch (super::sData.mInitState)
+ {
+ case super::UNINITIALIZED:
+ super::logerrs("Uninitialized param singleton ",
+ super::template classname<DERIVED_TYPE>().c_str());
+ break;
+
+ case super::CONSTRUCTING:
+ super::logerrs("Tried to access param singleton ",
+ super::template classname<DERIVED_TYPE>().c_str(),
+ " from singleton constructor!");
+ break;
+
+ case super::CONSTRUCTED:
+ // Should never happen!? The CONSTRUCTED state is specifically to
+ // navigate through LLSingleton::SingletonInitializer getting
+ // constructed (once) before LLSingleton::getInstance()'s switch
+ // on mInitState. But our initParamSingleton() method calls
+ // constructSingleton() and then calls finishInitializing(), which
+ // immediately sets INITIALIZING. Why are we here?
+ super::logerrs("Param singleton ",
+ super::template classname<DERIVED_TYPE>().c_str(),
+ "::initSingleton() not yet called");
+ break;
+
+ case super::INITIALIZING:
+ // As with LLSingleton, explicitly permit circular calls from
+ // within initSingleton()
+ case super::INITIALIZED:
+ // for any valid call, capture dependencies
+ super::capture_dependency();
+ return super::sData.mInstance;
+
+ case super::DELETED:
+ super::logerrs("Trying to access deleted param singleton ",
+ super::template classname<DERIVED_TYPE>().c_str());
+ break;
+ }
+
+ // should never actually get here; this is to pacify the compiler,
+ // which assumes control might return from logerrs()
+ return nullptr;
+ }
+
+ // instance() is replicated here so it calls
+ // LLParamSingleton::getInstance() rather than LLSingleton::getInstance()
+ // -- avoid making getInstance() virtual
+ static DERIVED_TYPE& instance()
+ {
+ return *getInstance();
+ }
+
+private:
+ // sMutex must be a function-local static rather than a static member. One
+ // of the essential features of LLSingleton and friends is that they must
+ // support getInstance() even when the containing module's static
+ // variables have not yet been runtime-initialized. A mutex requires
+ // construction. A static class member might not yet have been
+ // constructed.
+ //
+ // We could store a dumb mutex_t*, notice when it's NULL and allocate a
+ // heap mutex -- but that's vulnerable to race conditions. And we can't
+ // defend the dumb pointer with another mutex.
+ //
+ // We could store a std::atomic<mutex_t*> -- but a default-constructed
+ // std::atomic<T> does not contain a valid T, even a default-constructed
+ // T! Which means std::atomic, too, requires runtime initialization.
+ //
+ // But a function-local static is guaranteed to be initialized exactly
+ // once, the first time control reaches that declaration.
+ static mutex_t& getMutex()
+ {
+ static mutex_t sMutex;
+ return sMutex;
+ }
+};
+
+/**
+ * Initialization locked singleton, only derived class can decide when to initialize.
+ * Starts locked.
+ * For cases when singleton has a dependency onto something or.
+ *
+ * LLLockedSingleton is like an LLParamSingleton with a nullary constructor.
+ * It cannot be instantiated on demand (instance() or getInstance() call) --
+ * it must be instantiated by calling construct(). However, it does
+ * participate in dependency-ordered LLSingletonBase::deleteAll() processing.
+ */
+template <typename DT>
+class LLLockedSingleton : public LLParamSingleton<DT>
+{
+ typedef LLParamSingleton<DT> super;
+
+public:
+ using super::deleteSingleton;
+ using super::getInstance;
+ using super::instance;
+ using super::instanceExists;
+ using super::wasDeleted;
+
+ static void construct()
+ {
+ super::initParamSingleton();
+ }
+};
+
/**
* Use LLSINGLETON(Foo); at the start of an LLSingleton<Foo> subclass body
* when you want to declare an out-of-line constructor:
@@ -484,13 +755,13 @@ typename LLSingleton<T>::SingletonData LLSingleton<T>::sData;
* file, use 'inline' (unless it's a template class) to avoid duplicate-symbol
* errors at link time.
*/
-#define LLSINGLETON(DERIVED_CLASS) \
+#define LLSINGLETON(DERIVED_CLASS, ...) \
private: \
/* implement LLSingleton pure virtual method whose sole purpose */ \
/* is to remind people to use this macro */ \
virtual void you_must_use_LLSINGLETON_macro() {} \
friend class LLSingleton<DERIVED_CLASS>; \
- DERIVED_CLASS()
+ DERIVED_CLASS(__VA_ARGS__)
/**
* Use LLSINGLETON_EMPTY_CTOR(Foo); at the start of an LLSingleton<Foo>
diff --git a/indra/llcommon/tests/lleventcoro_test.cpp b/indra/llcommon/tests/lleventcoro_test.cpp
index a459d17fb8b58b2692bf731910eb204116ab8495..fa02d2bb1a0013e23baf4978c5842ec8e3eac73f 100644
--- a/indra/llcommon/tests/lleventcoro_test.cpp
+++ b/indra/llcommon/tests/lleventcoro_test.cpp
@@ -506,16 +506,10 @@ namespace tut
replyName = waiter.getName0();
errorName = waiter.getName1();
WrapLLErrs capture;
- try
- {
- result = waiter.suspendWithLog();
- debug("no exception");
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- debug(STRINGIZE("exception " << e.what()));
- threw = e.what();
- }
+ threw = capture.catch_llerrs([&waiter, &debug](){
+ result = waiter.suspendWithLog();
+ debug("no exception");
+ });
}
END
}
@@ -762,18 +756,13 @@ namespace tut
{
LLCoroEventPumps waiter;
WrapLLErrs capture;
- try
- {
- result = waiter.postAndSuspendWithLog(
- LLSDMap("value", 31)("fail", LLSD()),
- immediateAPI.getPump(), "reply", "error");
- debug("no exception");
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- debug(STRINGIZE("exception " << e.what()));
- threw = e.what();
- }
+ threw = capture.catch_llerrs(
+ [&waiter, &debug](){
+ result = waiter.postAndSuspendWithLog(
+ LLSDMap("value", 31)("fail", LLSD()),
+ immediateAPI.getPump(), "reply", "error");
+ debug("no exception");
+ });
}
END
}
diff --git a/indra/llcommon/tests/lleventdispatcher_test.cpp b/indra/llcommon/tests/lleventdispatcher_test.cpp
index 5a4df81bf1ecbc9e74a1bc9f54723cff38c04dfd..a181d5c941e09a5855eafe0d2bb8f76096bc7734 100644
--- a/indra/llcommon/tests/lleventdispatcher_test.cpp
+++ b/indra/llcommon/tests/lleventdispatcher_test.cpp
@@ -22,6 +22,7 @@
#include "llsdutil.h"
#include "stringize.h"
#include "tests/wrapllerrs.h"
+#include "../test/catch_and_store_what_in.h"
#include <map>
#include <string>
@@ -630,16 +631,9 @@ namespace tut
void call_exc(const std::string& func, const LLSD& args, const std::string& exc_frag)
{
- std::string threw;
- try
- {
- work(func, args);
- }
- catch (const std::runtime_error& e)
- {
- cout << "*** " << e.what() << '\n';
- threw = e.what();
- }
+ std::string threw = catch_what<std::runtime_error>([this, &func, &args](){
+ work(func, args);
+ });
ensure_has(threw, exc_frag);
}
@@ -717,15 +711,9 @@ namespace tut
LLSD attempts(LLSDArray(17)(LLSDMap("pi", 3.14)("two", 2)));
foreach(LLSD ae, inArray(attempts))
{
- std::string threw;
- try
- {
- work.add("freena_err", "freena", freena, ae);
- }
- catch (const std::exception& e)
- {
- threw = e.what();
- }
+ std::string threw = catch_what<std::exception>([this, &ae](){
+ work.add("freena_err", "freena", freena, ae);
+ });
ensure_has(threw, "must be an array");
}
}
@@ -734,15 +722,9 @@ namespace tut
void object::test<2>()
{
set_test_name("map-style registration with badly-formed defaults");
- std::string threw;
- try
- {
- work.add("freena_err", "freena", freena, LLSDArray("a")("b"), 17);
- }
- catch (const std::exception& e)
- {
- threw = e.what();
- }
+ std::string threw = catch_what<std::exception>([this](){
+ work.add("freena_err", "freena", freena, LLSDArray("a")("b"), 17);
+ });
ensure_has(threw, "must be a map or an array");
}
@@ -750,17 +732,11 @@ namespace tut
void object::test<3>()
{
set_test_name("map-style registration with too many array defaults");
- std::string threw;
- try
- {
- work.add("freena_err", "freena", freena,
- LLSDArray("a")("b"),
- LLSDArray(17)(0.9)("gack"));
- }
- catch (const std::exception& e)
- {
- threw = e.what();
- }
+ std::string threw = catch_what<std::exception>([this](){
+ work.add("freena_err", "freena", freena,
+ LLSDArray("a")("b"),
+ LLSDArray(17)(0.9)("gack"));
+ });
ensure_has(threw, "shorter than");
}
@@ -768,17 +744,11 @@ namespace tut
void object::test<4>()
{
set_test_name("map-style registration with too many map defaults");
- std::string threw;
- try
- {
- work.add("freena_err", "freena", freena,
- LLSDArray("a")("b"),
- LLSDMap("b", 17)("foo", 3.14)("bar", "sinister"));
- }
- catch (const std::exception& e)
- {
- threw = e.what();
- }
+ std::string threw = catch_what<std::exception>([this](){
+ work.add("freena_err", "freena", freena,
+ LLSDArray("a")("b"),
+ LLSDMap("b", 17)("foo", 3.14)("bar", "sinister"));
+ });
ensure_has(threw, "nonexistent params");
ensure_has(threw, "foo");
ensure_has(threw, "bar");
@@ -1039,16 +1009,9 @@ namespace tut
// We don't have a comparable helper function for the one-arg
// operator() method, and it's not worth building one just for this
// case. Write it out.
- std::string threw;
- try
- {
- work(LLSDMap("op", "freek"));
- }
- catch (const std::runtime_error& e)
- {
- cout << "*** " << e.what() << "\n";
- threw = e.what();
- }
+ std::string threw = catch_what<std::runtime_error>([this](){
+ work(LLSDMap("op", "freek"));
+ });
ensure_has(threw, "bad");
ensure_has(threw, "op");
ensure_has(threw, "freek");
diff --git a/indra/llcommon/tests/lleventfilter_test.cpp b/indra/llcommon/tests/lleventfilter_test.cpp
index eb98b12ef5260395b35e1c4fc429ce00cea847ec..1875013794fe1abd6c5703d6b322341211856c65 100644
--- a/indra/llcommon/tests/lleventfilter_test.cpp
+++ b/indra/llcommon/tests/lleventfilter_test.cpp
@@ -350,15 +350,9 @@ namespace tut
// Now let the timer expire.
filter.forceTimeout();
// Notice the timeout.
- std::string threw;
- try
- {
- mainloop.post(17);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([this](){
+ mainloop.post(17);
+ });
ensure_contains("errorAfter() timeout exception", threw, "timeout");
// Timing out cancels the timer. Verify that.
listener0.reset(0);
diff --git a/indra/llcommon/tests/llinstancetracker_test.cpp b/indra/llcommon/tests/llinstancetracker_test.cpp
index c7d4b8a06bdd879d364cf14395f70f38db20df24..d94fc0c56d0b2052bee78d39a47910f48acd0557 100644
--- a/indra/llcommon/tests/llinstancetracker_test.cpp
+++ b/indra/llcommon/tests/llinstancetracker_test.cpp
@@ -198,14 +198,9 @@ namespace tut
{
WrapLLErrs wrapper;
Keyed::instance_iter i(Keyed::beginInstances());
- try
- {
- delete keyed;
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- what = e.what();
- }
+ what = wrapper.catch_llerrs([&keyed](){
+ delete keyed;
+ });
}
ensure(! what.empty());
}
@@ -219,14 +214,9 @@ namespace tut
{
WrapLLErrs wrapper;
Keyed::key_iter i(Keyed::beginKeys());
- try
- {
- delete keyed;
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- what = e.what();
- }
+ what = wrapper.catch_llerrs([&keyed](){
+ delete keyed;
+ });
}
ensure(! what.empty());
}
@@ -240,14 +230,9 @@ namespace tut
{
WrapLLErrs wrapper;
Unkeyed::instance_iter i(Unkeyed::beginInstances());
- try
- {
- delete unkeyed;
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- what = e.what();
- }
+ what = wrapper.catch_llerrs([&unkeyed](){
+ delete unkeyed;
+ });
}
ensure(! what.empty());
}
diff --git a/indra/llcommon/tests/lllazy_test.cpp b/indra/llcommon/tests/lllazy_test.cpp
index 32a717f4fccffea7227d1801504dc331221f84dd..542306ee22a36805a70232c55fd4328aba79ac24 100644
--- a/indra/llcommon/tests/lllazy_test.cpp
+++ b/indra/llcommon/tests/lllazy_test.cpp
@@ -38,6 +38,7 @@
#include <boost/lambda/bind.hpp>
// other Linden headers
#include "../test/lltut.h"
+#include "../test/catch_and_store_what_in.h"
namespace bll = boost::lambda;
@@ -200,15 +201,9 @@ namespace tut
void lllazy_object::test<2>()
{
TestNeedsTesting tnt;
- std::string threw;
- try
- {
- tnt.toolate();
- }
- catch (const LLLazyCommon::InstanceChange& e)
- {
- threw = e.what();
- }
+ std::string threw = catch_what<LLLazyCommon::InstanceChange>([&tnt](){
+ tnt.toolate();
+ });
ensure_contains("InstanceChange exception", threw, "replace LLLazy instance");
}
diff --git a/indra/llcommon/tests/llleap_test.cpp b/indra/llcommon/tests/llleap_test.cpp
index 45648536c4db95fac6b382abc77d5e60a8fadf8e..bf0a74d10da2d9d1453f94fbb9b39788bf2b0258 100644
--- a/indra/llcommon/tests/llleap_test.cpp
+++ b/indra/llcommon/tests/llleap_test.cpp
@@ -23,7 +23,7 @@
#include "../test/lltut.h"
#include "../test/namedtempfile.h"
#include "../test/catch_and_store_what_in.h"
-#include "wrapllerrs.h"
+#include "wrapllerrs.h" // CaptureLog
#include "llevents.h"
#include "llprocess.h"
#include "llstring.h"
@@ -290,12 +290,9 @@ namespace tut
void object::test<6>()
{
set_test_name("empty plugin vector");
- std::string threw;
- try
- {
- LLLeap::create("empty", StringVec());
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLLeap::Error)
+ std::string threw = catch_what<LLLeap::Error>([](){
+ LLLeap::create("empty", StringVec());
+ });
ensure_contains("LLLeap::Error", threw, "no plugin");
// try the suppress-exception variant
ensure("bad launch returned non-NULL", ! LLLeap::create("empty", StringVec(), false));
@@ -308,12 +305,9 @@ namespace tut
// Synthesize bogus executable name
std::string BADPYTHON(PYTHON.substr(0, PYTHON.length()-1) + "x");
CaptureLog log;
- std::string threw;
- try
- {
- LLLeap::create("bad exe", BADPYTHON);
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLLeap::Error)
+ std::string threw = catch_what<LLLeap::Error>([&BADPYTHON](){
+ LLLeap::create("bad exe", BADPYTHON);
+ });
ensure_contains("LLLeap::create() didn't throw", threw, "failed");
log.messageWith("failed");
log.messageWith(BADPYTHON);
diff --git a/indra/llcommon/tests/llprocess_test.cpp b/indra/llcommon/tests/llprocess_test.cpp
index 5c87cdabd914600873d8d0b062735b4d899a7804..222d8320843de36a2d2db59b86d74f51a2ff689c 100644
--- a/indra/llcommon/tests/llprocess_test.cpp
+++ b/indra/llcommon/tests/llprocess_test.cpp
@@ -25,8 +25,6 @@
#include <boost/function.hpp>
#include <boost/algorithm/string/find_iterator.hpp>
#include <boost/algorithm/string/finder.hpp>
-//#include <boost/lambda/lambda.hpp>
-//#include <boost/lambda/bind.hpp>
// other Linden headers
#include "../test/lltut.h"
#include "../test/namedtempfile.h"
@@ -35,7 +33,7 @@
#include "llsdutil.h"
#include "llevents.h"
#include "llstring.h"
-#include "wrapllerrs.h"
+#include "wrapllerrs.h" // CaptureLog
#if defined(LL_WINDOWS)
#define sleep(secs) _sleep((secs) * 1000)
@@ -45,8 +43,7 @@
#include <sys/wait.h>
#endif
-//namespace lambda = boost::lambda;
- std::string apr_strerror_helper(apr_status_t rv)
+std::string apr_strerror_helper(apr_status_t rv)
{
char errbuf[256];
apr_strerror(rv, errbuf, sizeof(errbuf));
@@ -960,12 +957,9 @@ namespace tut
#define CATCH_IN(THREW, EXCEPTION, CODE) \
do \
{ \
- (THREW).clear(); \
- try \
- { \
- CODE; \
- } \
- CATCH_AND_STORE_WHAT_IN(THREW, EXCEPTION) \
+ (THREW) = catch_what<EXCEPTION>([&](){ \
+ CODE; \
+ }); \
ensure("failed to throw " #EXCEPTION ": " #CODE, ! (THREW).empty()); \
} while (0)
diff --git a/indra/llcommon/tests/llsingleton_test.cpp b/indra/llcommon/tests/llsingleton_test.cpp
index 56886bc73fd9185932f76c82d0d72232cc5c4e5c..75ddff9d7daa427472f3408b70f170331b5c2ddb 100644
--- a/indra/llcommon/tests/llsingleton_test.cpp
+++ b/indra/llcommon/tests/llsingleton_test.cpp
@@ -29,7 +29,8 @@
#include "llsingleton.h"
#include "../test/lltut.h"
-
+#include "wrapllerrs.h"
+#include "llsd.h"
// Capture execution sequence by appending to log string.
std::string sLog;
@@ -198,4 +199,134 @@ namespace tut
TESTS(A, B, 4, 5, 6, 7)
TESTS(B, A, 8, 9, 10, 11)
+
+#define PARAMSINGLETON(cls) \
+ class cls: public LLParamSingleton<cls> \
+ { \
+ LLSINGLETON(cls, const LLSD::String& str): mDesc(str) {} \
+ cls(LLSD::Integer i): mDesc(i) {} \
+ \
+ public: \
+ std::string desc() const { return mDesc.asString(); } \
+ \
+ private: \
+ LLSD mDesc; \
+ }
+
+ // Declare two otherwise-identical LLParamSingleton classes so we can
+ // validly initialize each using two different constructors. If we tried
+ // to test that with a single LLParamSingleton class within the same test
+ // program, we'd get 'trying to use deleted LLParamSingleton' errors.
+ PARAMSINGLETON(PSing1);
+ PARAMSINGLETON(PSing2);
+
+ template<> template<>
+ void singleton_object_t::test<12>()
+ {
+ set_test_name("LLParamSingleton");
+
+ WrapLLErrs catcherr;
+ // query methods
+ ensure("false positive on instanceExists()", ! PSing1::instanceExists());
+ ensure("false positive on wasDeleted()", ! PSing1::wasDeleted());
+ // try to reference before initializing
+ std::string threw = catcherr.catch_llerrs([](){
+ (void)PSing1::instance();
+ });
+ ensure_contains("too-early instance() didn't throw", threw, "Uninitialized");
+ // getInstance() behaves the same as instance()
+ threw = catcherr.catch_llerrs([](){
+ (void)PSing1::getInstance();
+ });
+ ensure_contains("too-early getInstance() didn't throw", threw, "Uninitialized");
+ // initialize using LLSD::String constructor
+ PSing1::initParamSingleton("string");
+ ensure_equals(PSing1::instance().desc(), "string");
+ ensure("false negative on instanceExists()", PSing1::instanceExists());
+ // try to initialize again
+ threw = catcherr.catch_llerrs([](){
+ PSing1::initParamSingleton("again");
+ });
+ ensure_contains("second ctor(string) didn't throw", threw, "twice");
+ // try to initialize using the other constructor -- should be
+ // well-formed, but illegal at runtime
+ threw = catcherr.catch_llerrs([](){
+ PSing1::initParamSingleton(17);
+ });
+ ensure_contains("other ctor(int) didn't throw", threw, "twice");
+ PSing1::deleteSingleton();
+ ensure("false negative on wasDeleted()", PSing1::wasDeleted());
+ threw = catcherr.catch_llerrs([](){
+ (void)PSing1::instance();
+ });
+ ensure_contains("accessed deleted LLParamSingleton", threw, "deleted");
+ }
+
+ template<> template<>
+ void singleton_object_t::test<13>()
+ {
+ set_test_name("LLParamSingleton alternate ctor");
+
+ WrapLLErrs catcherr;
+ // We don't have to restate all the tests for PSing1. Only test validly
+ // using the other constructor.
+ PSing2::initParamSingleton(17);
+ ensure_equals(PSing2::instance().desc(), "17");
+ // can't do it twice
+ std::string threw = catcherr.catch_llerrs([](){
+ PSing2::initParamSingleton(34);
+ });
+ ensure_contains("second ctor(int) didn't throw", threw, "twice");
+ // can't use the other constructor either
+ threw = catcherr.catch_llerrs([](){
+ PSing2::initParamSingleton("string");
+ });
+ ensure_contains("other ctor(string) didn't throw", threw, "twice");
+ }
+
+ class CircularPCtor: public LLParamSingleton<CircularPCtor>
+ {
+ LLSINGLETON(CircularPCtor)
+ {
+ // never mind indirection, just go straight for the circularity
+ (void)instance();
+ }
+ };
+
+ template<> template<>
+ void singleton_object_t::test<14>()
+ {
+ set_test_name("Circular LLParamSingleton constructor");
+ WrapLLErrs catcherr;
+ std::string threw = catcherr.catch_llerrs([](){
+ CircularPCtor::initParamSingleton();
+ });
+ ensure_contains("constructor circularity didn't throw", threw, "constructor");
+ }
+
+ class CircularPInit: public LLParamSingleton<CircularPInit>
+ {
+ LLSINGLETON_EMPTY_CTOR(CircularPInit);
+ public:
+ virtual void initSingleton()
+ {
+ // never mind indirection, just go straight for the circularity
+ CircularPInit *pt = getInstance();
+ if (!pt)
+ {
+ throw;
+ }
+ }
+ };
+
+ template<> template<>
+ void singleton_object_t::test<15>()
+ {
+ set_test_name("Circular LLParamSingleton initSingleton()");
+ WrapLLErrs catcherr;
+ std::string threw = catcherr.catch_llerrs([](){
+ CircularPInit::initParamSingleton();
+ });
+ ensure("initSingleton() circularity threw", threw.empty());
+ }
}
diff --git a/indra/llcommon/tests/wrapllerrs.h b/indra/llcommon/tests/wrapllerrs.h
index 08fbf19b1cdccec7323769b515246737368de2d0..b07d5afbd8fa7a7582356f670b6f9bee27896dd6 100644
--- a/indra/llcommon/tests/wrapllerrs.h
+++ b/indra/llcommon/tests/wrapllerrs.h
@@ -37,6 +37,7 @@
#include "llerrorcontrol.h"
#include "llexception.h"
#include "stringize.h"
+#include "../test/catch_and_store_what_in.h"
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
@@ -81,6 +82,31 @@ struct WrapLLErrs
LLTHROW(FatalException(message));
}
+ /// Convenience wrapper for catch_what<FatalException>()
+ //
+ // The implementation makes it clear that this function need not be a
+ // member; it could easily be a free function. It is a member because it
+ // makes no sense to attempt to catch FatalException unless there is a
+ // WrapLLErrs instance in scope. Without a live WrapLLErrs instance, any
+ // LL_ERRS() reached by code within 'func' would terminate the test
+ // program instead of throwing FatalException.
+ //
+ // We were tempted to introduce a free function, likewise accepting
+ // arbitrary 'func', that would instantiate WrapLLErrs and then call
+ // catch_llerrs() on that instance. We decided against it, for this
+ // reason: on extending a test function containing a single call to that
+ // free function, a maintainer would most likely make additional calls to
+ // that free function, instead of switching to an explicit WrapLLErrs
+ // declaration with several calls to its catch_llerrs() member function.
+ // Even a construct such as WrapLLErrs().catch_llerrs(...) would make the
+ // object declaration more visible; it's not unreasonable to expect a
+ // maintainer to extend that by naming and reusing the WrapLLErrs instance.
+ template <typename FUNC>
+ std::string catch_llerrs(FUNC func)
+ {
+ return catch_what<FatalException>(func);
+ }
+
std::string error;
LLError::SettingsStoragePtr mPriorErrorSettings;
LLError::FatalFunction mPriorFatal;
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 680fbf548f7ffd80ac819cda04957e027592088b..9dea87611423e5ccfdeac6ac7354cd1df4f4f230 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -583,39 +583,29 @@ static void bilinear_scale(const U8 *src, U32 srcW, U32 srcH, U32 srcCh, U32 src
// LLImage
//---------------------------------------------------------------------------
-//static
-std::string LLImage::sLastErrorMessage;
-LLMutex* LLImage::sMutex = NULL;
-bool LLImage::sUseNewByteRange = false;
-S32 LLImage::sMinimalReverseByteRangePercent = 75;
-
-//static
-void LLImage::initClass(bool use_new_byte_range, S32 minimal_reverse_byte_range_percent)
+LLImage::LLImage(bool use_new_byte_range, S32 minimal_reverse_byte_range_percent)
{
- sUseNewByteRange = use_new_byte_range;
- sMinimalReverseByteRangePercent = minimal_reverse_byte_range_percent;
- sMutex = new LLMutex();
+ mMutex = new LLMutex();
+ mUseNewByteRange = use_new_byte_range;
+ mMinimalReverseByteRangePercent = minimal_reverse_byte_range_percent;
}
-//static
-void LLImage::cleanupClass()
+LLImage::~LLImage()
{
- delete sMutex;
- sMutex = NULL;
+ delete mMutex;
+ mMutex = NULL;
}
-//static
-const std::string& LLImage::getLastError()
+const std::string& LLImage::getLastErrorMessage()
{
static const std::string noerr("No Error");
- return sLastErrorMessage.empty() ? noerr : sLastErrorMessage;
+ return mLastErrorMessage.empty() ? noerr : mLastErrorMessage;
}
-//static
-void LLImage::setLastError(const std::string& message)
+void LLImage::setLastErrorMessage(const std::string& message)
{
- LLMutexLock m(sMutex);
- sLastErrorMessage = message;
+ LLMutexLock m(mMutex);
+ mLastErrorMessage = message;
}
//---------------------------------------------------------------------------
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index 8ec49d3f0f96cb806b08440a212da8f91ee7818e..9f8d06129394faeb024f88fdcee7e95946d8f00b 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -30,6 +30,7 @@
#include "lluuid.h"
#include "llstring.h"
#include "llpointer.h"
+#include "llsingleton.h"
#include "lltrace.h"
const S32 MIN_IMAGE_MIP = 2; // 4x4, only used for expand/contract power of 2
@@ -88,23 +89,25 @@ typedef enum e_image_codec
//============================================================================
// library initialization class
-class LLImage
+class LLImage : public LLParamSingleton<LLImage>
{
+ LLSINGLETON(LLImage, bool use_new_byte_range = false, S32 minimal_reverse_byte_range_percent = 75);
+ ~LLImage();
public:
- static void initClass(bool use_new_byte_range = false, S32 minimal_reverse_byte_range_percent = 75);
- static void cleanupClass();
- static const std::string& getLastError();
- static void setLastError(const std::string& message);
-
- static bool useNewByteRange() { return sUseNewByteRange; }
- static S32 getReverseByteRangePercent() { return sMinimalReverseByteRangePercent; }
-
-protected:
- static LLMutex* sMutex;
- static std::string sLastErrorMessage;
- static bool sUseNewByteRange;
- static S32 sMinimalReverseByteRangePercent;
+ const std::string& getLastErrorMessage();
+ static const std::string& getLastError() { return getInstance()->getLastErrorMessage(); };
+ void setLastErrorMessage(const std::string& message);
+ static void setLastError(const std::string& message) { getInstance()->setLastErrorMessage(message); }
+
+ bool useNewByteRange() { return mUseNewByteRange; }
+ S32 getReverseByteRangePercent() { return mMinimalReverseByteRangePercent; }
+
+private:
+ LLMutex* mMutex;
+ std::string mLastErrorMessage;
+ bool mUseNewByteRange;
+ S32 mMinimalReverseByteRangePercent;
};
//============================================================================
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 4bff21610fc83c861fa301f6ce189823e0d1080b..71cab0554d78943faf8faf17a60f101c56c35ce6 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -281,7 +281,7 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
S32 bytes;
S32 new_bytes = (S32) (sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor);
S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
- bytes = (LLImage::useNewByteRange() && (new_bytes < old_bytes) ? new_bytes : old_bytes);
+ bytes = (LLImage::getInstance()->useNewByteRange() && (new_bytes < old_bytes) ? new_bytes : old_bytes);
bytes = llmax(bytes, calcHeaderSizeJ2C());
return bytes;
}
@@ -322,7 +322,7 @@ S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
{
S32 bytes_needed = calcDataSize(discard_level);
// Use TextureReverseByteRange percent (see settings.xml) of the optimal size to qualify as correct rendering for the given discard level
- if (bytes >= (bytes_needed*LLImage::getReverseByteRangePercent()/100))
+ if (bytes >= (bytes_needed*LLImage::getInstance()->getReverseByteRangePercent()/100))
{
break;
}
diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index ba1a2a035eac7ff0341e247f928a572dcd822a39..6a287f0cc5cf43b87145f482d3339a53f31aac60 100644
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -49,101 +49,22 @@
#include <map>
#include <set>
-namespace LLAvatarNameCache
-{
- use_display_name_signal_t mUseDisplayNamesSignal;
-
- // Cache starts in a paused state until we can determine if the
- // current region supports display names.
- bool sRunning = false;
-
- // Use the People API (modern) for fetching name if true. Use the old legacy protocol if false.
- // For testing, there's a UsePeopleAPI setting that can be flipped (must restart viewer).
- bool sUsePeopleAPI = true;
-
- // Base lookup URL for name service.
- // On simulator, loaded from indra.xml
- // On viewer, usually a simulator capability (at People API team's request)
- // Includes the trailing slash, like "http://pdp60.lindenlab.com:8000/agents/"
- std::string sNameLookupURL;
-
- // Accumulated agent IDs for next query against service
- typedef std::set<LLUUID> ask_queue_t;
- ask_queue_t sAskQueue;
-
- // Agent IDs that have been requested, but with no reply.
- // Maps agent ID to frame time request was made.
- typedef std::map<LLUUID, F64> pending_queue_t;
- pending_queue_t sPendingQueue;
-
- // Callbacks to fire when we received a name.
- // May have multiple callbacks for a single ID, which are
- // represented as multiple slots bound to the signal.
- // Avoid copying signals via pointers.
- typedef std::map<LLUUID, callback_signal_t*> signal_map_t;
- signal_map_t sSignalMap;
-
- // The cache at last, i.e. avatar names we know about.
- typedef std::map<LLUUID, LLAvatarName> cache_t;
- cache_t sCache;
-
- // Send bulk lookup requests a few times a second at most.
- // Only need per-frame timing resolution.
- LLFrameTimer sRequestTimer;
-
- // Maximum time an unrefreshed cache entry is allowed.
- const F64 MAX_UNREFRESHED_TIME = 20.0 * 60.0;
-
- // Time when unrefreshed cached names were checked last.
- static F64 sLastExpireCheck;
-
- // Time-to-live for a temp cache entry.
- const F64 TEMP_CACHE_ENTRY_LIFETIME = 60.0;
-
- LLCore::HttpRequest::ptr_t sHttpRequest;
- LLCore::HttpHeaders::ptr_t sHttpHeaders;
- LLCore::HttpOptions::ptr_t sHttpOptions;
- LLCore::HttpRequest::policy_t sHttpPolicy;
- LLCore::HttpRequest::priority_t sHttpPriority;
-
- //-----------------------------------------------------------------------
- // Internal methods
- //-----------------------------------------------------------------------
-
- // Handle name response off network.
- void processName(const LLUUID& agent_id,
- const LLAvatarName& av_name);
-
- void requestNamesViaCapability();
-
- // Legacy name system callbacks
- void legacyNameCallback(const LLUUID& agent_id,
- const std::string& full_name,
- bool is_group);
- void legacyNameFetch(const LLUUID& agent_id,
- const std::string& full_name,
- bool is_group);
-
- void requestNamesViaLegacy();
-
- // Do a single callback to a given slot
- void fireSignal(const LLUUID& agent_id,
- const callback_slot_t& slot,
- const LLAvatarName& av_name);
-
- // Is a request in-flight over the network?
- bool isRequestPending(const LLUUID& agent_id);
- // Erase expired names from cache
- void eraseUnrefreshed();
+// Time-to-live for a temp cache entry.
+const F64 TEMP_CACHE_ENTRY_LIFETIME = 60.0;
+// Maximum time an unrefreshed cache entry is allowed.
+const F64 MAX_UNREFRESHED_TIME = 20.0 * 60.0;
- bool expirationFromCacheControl(const LLSD& headers, F64 *expires);
+// Send bulk lookup requests a few times a second at most.
+// Only need per-frame timing resolution.
+static LLFrameTimer sRequestTimer;
- // This is a coroutine.
- void requestAvatarNameCache_(std::string url, std::vector<LLUUID> agentIds);
-
- void handleAvNameCacheSuccess(const LLSD &data, const LLSD &httpResult);
-}
+// static to avoid unnessesary dependencies
+LLCore::HttpRequest::ptr_t sHttpRequest;
+LLCore::HttpHeaders::ptr_t sHttpHeaders;
+LLCore::HttpOptions::ptr_t sHttpOptions;
+LLCore::HttpRequest::policy_t sHttpPolicy;
+LLCore::HttpRequest::priority_t sHttpPriority;
/* Sample response:
<?xml version="1.0"?>
@@ -187,6 +108,30 @@ namespace LLAvatarNameCache
// Coroutine for sending and processing avatar name cache requests.
// Do not call directly. See documentation in lleventcoro.h and llcoro.h for
// further explanation.
+
+LLAvatarNameCache::LLAvatarNameCache()
+{
+ // Will be set to running later
+ // For now fail immediate lookups and query async ones.
+ mRunning = false;
+
+ mUsePeopleAPI = true;
+
+ sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+ sHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
+ sHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions());
+ sHttpPolicy = LLCore::HttpRequest::DEFAULT_POLICY_ID;
+ sHttpPriority = 0;
+}
+
+LLAvatarNameCache::~LLAvatarNameCache()
+{
+ sHttpRequest.reset();
+ sHttpHeaders.reset();
+ sHttpOptions.reset();
+ mCache.clear();
+}
+
void LLAvatarNameCache::requestAvatarNameCache_(std::string url, std::vector<LLUUID> agentIds)
{
LL_DEBUGS("AvNameCache") << "Entering coroutine " << LLCoros::instance().getName()
@@ -205,7 +150,7 @@ void LLAvatarNameCache::requestAvatarNameCache_(std::string url, std::vector<LLU
{
bool success = true;
- LLCoreHttpUtil::HttpCoroutineAdapter httpAdapter("NameCache", LLAvatarNameCache::sHttpPolicy);
+ LLCoreHttpUtil::HttpCoroutineAdapter httpAdapter("NameCache", sHttpPolicy);
LLSD results = httpAdapter.getAndSuspend(sHttpRequest, url);
LL_DEBUGS() << results << LL_ENDL;
@@ -233,12 +178,12 @@ void LLAvatarNameCache::requestAvatarNameCache_(std::string url, std::vector<LLU
for ( ; it != agentIds.end(); ++it)
{
const LLUUID& agent_id = *it;
- LLAvatarNameCache::handleAgentError(agent_id);
+ LLAvatarNameCache::getInstance()->handleAgentError(agent_id);
}
return;
}
- LLAvatarNameCache::handleAvNameCacheSuccess(results, httpResults);
+ LLAvatarNameCache::getInstance()->handleAvNameCacheSuccess(results, httpResults);
}
catch (...)
@@ -300,15 +245,15 @@ void LLAvatarNameCache::handleAvNameCacheSuccess(const LLSD &data, const LLSD &h
}
}
LL_DEBUGS("AvNameCache") << "LLAvatarNameResponder::result "
- << LLAvatarNameCache::sCache.size() << " cached names"
+ << LLAvatarNameCache::mCache.size() << " cached names"
<< LL_ENDL;
}
// Provide some fallback for agents that return errors
void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
{
- std::map<LLUUID,LLAvatarName>::iterator existing = sCache.find(agent_id);
- if (existing == sCache.end())
+ std::map<LLUUID,LLAvatarName>::iterator existing = mCache.find(agent_id);
+ if (existing == mCache.end())
{
// there is no existing cache entry, so make a temporary name from legacy
LL_WARNS("AvNameCache") << "LLAvatarNameCache get legacy for agent "
@@ -322,7 +267,7 @@ void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
// been returned by the get method, there is no need to signal anyone
// Clear this agent from the pending list
- LLAvatarNameCache::sPendingQueue.erase(agent_id);
+ LLAvatarNameCache::mPendingQueue.erase(agent_id);
LLAvatarName& av_name = existing->second;
LL_DEBUGS("AvNameCache") << "LLAvatarNameCache use cache for agent " << agent_id << LL_ENDL;
@@ -341,19 +286,19 @@ void LLAvatarNameCache::processName(const LLUUID& agent_id, const LLAvatarName&
}
// Add to the cache
- sCache[agent_id] = av_name;
+ mCache[agent_id] = av_name;
// Suppress request from the queue
- sPendingQueue.erase(agent_id);
+ mPendingQueue.erase(agent_id);
// Signal everyone waiting on this name
- signal_map_t::iterator sig_it = sSignalMap.find(agent_id);
- if (sig_it != sSignalMap.end())
+ signal_map_t::iterator sig_it = mSignalMap.find(agent_id);
+ if (sig_it != mSignalMap.end())
{
callback_signal_t* signal = sig_it->second;
(*signal)(agent_id, av_name);
- sSignalMap.erase(agent_id);
+ mSignalMap.erase(agent_id);
delete signal;
signal = NULL;
@@ -379,16 +324,16 @@ void LLAvatarNameCache::requestNamesViaCapability()
U32 ids = 0;
ask_queue_t::const_iterator it;
- while(!sAskQueue.empty())
+ while(!mAskQueue.empty())
{
- it = sAskQueue.begin();
+ it = mAskQueue.begin();
LLUUID agent_id = *it;
- sAskQueue.erase(it);
+ mAskQueue.erase(it);
if (url.empty())
{
// ...starting new request
- url += sNameLookupURL;
+ url += mNameLookupURL;
url += "?ids=";
ids = 1;
}
@@ -402,7 +347,7 @@ void LLAvatarNameCache::requestNamesViaCapability()
agent_ids.push_back(agent_id);
// mark request as pending
- sPendingQueue[agent_id] = now;
+ mPendingQueue[agent_id] = now;
if (url.size() > NAME_URL_SEND_THRESHOLD)
{
@@ -432,7 +377,7 @@ void LLAvatarNameCache::legacyNameCallback(const LLUUID& agent_id,
// Retrieve the name and set it to never (or almost never...) expire: when we are using the legacy
// protocol, we do not get an expiration date for each name and there's no reason to ask the
// data again and again so we set the expiration time to the largest value admissible.
- std::map<LLUUID,LLAvatarName>::iterator av_record = sCache.find(agent_id);
+ std::map<LLUUID,LLAvatarName>::iterator av_record = LLAvatarNameCache::getInstance()->mCache.find(agent_id);
LLAvatarName& av_name = av_record->second;
av_name.setExpires(MAX_UNREFRESHED_TIME);
}
@@ -451,7 +396,7 @@ void LLAvatarNameCache::legacyNameFetch(const LLUUID& agent_id,
av_name.fromString(full_name);
// Add to cache: we're still using the new cache even if we're using the old (legacy) protocol.
- processName(agent_id, av_name);
+ LLAvatarNameCache::getInstance()->processName(agent_id, av_name);
}
void LLAvatarNameCache::requestNamesViaLegacy()
@@ -460,15 +405,15 @@ void LLAvatarNameCache::requestNamesViaLegacy()
F64 now = LLFrameTimer::getTotalSeconds();
std::string full_name;
ask_queue_t::const_iterator it;
- for (S32 requests = 0; !sAskQueue.empty() && requests < MAX_REQUESTS; ++requests)
+ for (S32 requests = 0; !mAskQueue.empty() && requests < MAX_REQUESTS; ++requests)
{
- it = sAskQueue.begin();
+ it = mAskQueue.begin();
LLUUID agent_id = *it;
- sAskQueue.erase(it);
+ mAskQueue.erase(it);
// Mark as pending first, just in case the callback is immediately
// invoked below. This should never happen in practice.
- sPendingQueue[agent_id] = now;
+ mPendingQueue[agent_id] = now;
LL_DEBUGS("AvNameCache") << "agent " << agent_id << LL_ENDL;
@@ -477,26 +422,6 @@ void LLAvatarNameCache::requestNamesViaLegacy()
}
}
-void LLAvatarNameCache::initClass(bool running, bool usePeopleAPI)
-{
- sRunning = running;
- sUsePeopleAPI = usePeopleAPI;
-
- sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
- sHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
- sHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions());
- sHttpPolicy = LLCore::HttpRequest::DEFAULT_POLICY_ID;
- sHttpPriority = 0;
-}
-
-void LLAvatarNameCache::cleanupClass()
-{
- sHttpRequest.reset();
- sHttpHeaders.reset();
- sHttpOptions.reset();
- sCache.clear();
-}
-
bool LLAvatarNameCache::importFile(std::istream& istr)
{
LLSD data;
@@ -517,9 +442,9 @@ bool LLAvatarNameCache::importFile(std::istream& istr)
{
agent_id.set(it->first);
av_name.fromLLSD( it->second );
- sCache[agent_id] = av_name;
+ mCache[agent_id] = av_name;
}
- LL_INFOS("AvNameCache") << "LLAvatarNameCache loaded " << sCache.size() << LL_ENDL;
+ LL_INFOS("AvNameCache") << "LLAvatarNameCache loaded " << mCache.size() << LL_ENDL;
// Some entries may have expired since the cache was stored,
// but they will be flushed in the first call to eraseUnrefreshed
// from LLAvatarNameResponder::idle
@@ -531,9 +456,9 @@ void LLAvatarNameCache::exportFile(std::ostream& ostr)
{
LLSD agents;
F64 max_unrefreshed = LLFrameTimer::getTotalSeconds() - MAX_UNREFRESHED_TIME;
- LL_INFOS("AvNameCache") << "LLAvatarNameCache at exit cache has " << sCache.size() << LL_ENDL;
- cache_t::const_iterator it = sCache.begin();
- for ( ; it != sCache.end(); ++it)
+ LL_INFOS("AvNameCache") << "LLAvatarNameCache at exit cache has " << mCache.size() << LL_ENDL;
+ cache_t::const_iterator it = mCache.begin();
+ for ( ; it != mCache.end(); ++it)
{
const LLUUID& agent_id = it->first;
const LLAvatarName& av_name = it->second;
@@ -552,23 +477,28 @@ void LLAvatarNameCache::exportFile(std::ostream& ostr)
void LLAvatarNameCache::setNameLookupURL(const std::string& name_lookup_url)
{
- sNameLookupURL = name_lookup_url;
+ mNameLookupURL = name_lookup_url;
}
bool LLAvatarNameCache::hasNameLookupURL()
{
- return !sNameLookupURL.empty();
+ return !mNameLookupURL.empty();
+}
+
+void LLAvatarNameCache::setUsePeopleAPI(bool use_api)
+{
+ mUsePeopleAPI = use_api;
}
bool LLAvatarNameCache::usePeopleAPI()
{
- return hasNameLookupURL() && sUsePeopleAPI;
+ return hasNameLookupURL() && mUsePeopleAPI;
}
void LLAvatarNameCache::idle()
{
// By convention, start running at first idle() call
- sRunning = true;
+ mRunning = true;
// *TODO: Possibly re-enabled this based on People API load measurements
// 100 ms is the threshold for "user speed" operations, so we can
@@ -579,7 +509,7 @@ void LLAvatarNameCache::idle()
return;
}
- if (!sAskQueue.empty())
+ if (!mAskQueue.empty())
{
if (usePeopleAPI())
{
@@ -592,7 +522,7 @@ void LLAvatarNameCache::idle()
}
}
- if (sAskQueue.empty())
+ if (mAskQueue.empty())
{
// cleared the list, reset the request timer.
sRequestTimer.resetWithExpiry(SECS_BETWEEN_REQUESTS);
@@ -607,8 +537,8 @@ bool LLAvatarNameCache::isRequestPending(const LLUUID& agent_id)
bool isPending = false;
const F64 PENDING_TIMEOUT_SECS = 5.0 * 60.0;
- pending_queue_t::const_iterator it = sPendingQueue.find(agent_id);
- if (it != sPendingQueue.end())
+ pending_queue_t::const_iterator it = mPendingQueue.find(agent_id);
+ if (it != mPendingQueue.end())
{
// in the list of requests in flight, retry if too old
F64 expire_time = LLFrameTimer::getTotalSeconds() - PENDING_TIMEOUT_SECS;
@@ -622,11 +552,11 @@ void LLAvatarNameCache::eraseUnrefreshed()
F64 now = LLFrameTimer::getTotalSeconds();
F64 max_unrefreshed = now - MAX_UNREFRESHED_TIME;
- if (!sLastExpireCheck || sLastExpireCheck < max_unrefreshed)
+ if (!mLastExpireCheck || mLastExpireCheck < max_unrefreshed)
{
- sLastExpireCheck = now;
+ mLastExpireCheck = now;
S32 expired = 0;
- for (cache_t::iterator it = sCache.begin(); it != sCache.end();)
+ for (cache_t::iterator it = mCache.begin(); it != mCache.end();)
{
const LLAvatarName& av_name = it->second;
if (av_name.mExpires < max_unrefreshed)
@@ -635,7 +565,7 @@ void LLAvatarNameCache::eraseUnrefreshed()
<< " user '" << av_name.getAccountName() << "' "
<< "expired " << now - av_name.mExpires << " secs ago"
<< LL_ENDL;
- sCache.erase(it++);
+ mCache.erase(it++);
expired++;
}
else
@@ -644,19 +574,24 @@ void LLAvatarNameCache::eraseUnrefreshed()
}
}
LL_INFOS("AvNameCache") << "LLAvatarNameCache expired " << expired << " cached avatar names, "
- << sCache.size() << " remaining" << LL_ENDL;
+ << mCache.size() << " remaining" << LL_ENDL;
}
}
+//static, wrapper
+bool LLAvatarNameCache::get(const LLUUID& agent_id, LLAvatarName *av_name)
+{
+ return LLAvatarNameCache::getInstance()->getName(agent_id, av_name);
+}
// fills in av_name if it has it in the cache, even if expired (can check expiry time)
// returns bool specifying if av_name was filled, false otherwise
-bool LLAvatarNameCache::get(const LLUUID& agent_id, LLAvatarName *av_name)
+bool LLAvatarNameCache::getName(const LLUUID& agent_id, LLAvatarName *av_name)
{
- if (sRunning)
+ if (mRunning)
{
// ...only do immediate lookups when cache is running
- std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
- if (it != sCache.end())
+ std::map<LLUUID,LLAvatarName>::iterator it = mCache.find(agent_id);
+ if (it != mCache.end())
{
*av_name = it->second;
@@ -667,7 +602,7 @@ bool LLAvatarNameCache::get(const LLUUID& agent_id, LLAvatarName *av_name)
{
LL_DEBUGS("AvNameCache") << "LLAvatarNameCache refresh agent " << agent_id
<< LL_ENDL;
- sAskQueue.insert(agent_id);
+ mAskQueue.insert(agent_id);
}
}
@@ -678,7 +613,7 @@ bool LLAvatarNameCache::get(const LLUUID& agent_id, LLAvatarName *av_name)
if (!isRequestPending(agent_id))
{
LL_DEBUGS("AvNameCache") << "LLAvatarNameCache queue request for agent " << agent_id << LL_ENDL;
- sAskQueue.insert(agent_id);
+ mAskQueue.insert(agent_id);
}
return false;
@@ -693,15 +628,21 @@ void LLAvatarNameCache::fireSignal(const LLUUID& agent_id,
signal(agent_id, av_name);
}
+// static, wrapper
LLAvatarNameCache::callback_connection_t LLAvatarNameCache::get(const LLUUID& agent_id, callback_slot_t slot)
+{
+ return LLAvatarNameCache::getInstance()->getNameCallback(agent_id, slot);
+}
+
+LLAvatarNameCache::callback_connection_t LLAvatarNameCache::getNameCallback(const LLUUID& agent_id, callback_slot_t slot)
{
callback_connection_t connection;
- if (sRunning)
+ if (mRunning)
{
// ...only do immediate lookups when cache is running
- std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
- if (it != sCache.end())
+ std::map<LLUUID,LLAvatarName>::iterator it = mCache.find(agent_id);
+ if (it != mCache.end())
{
const LLAvatarName& av_name = it->second;
@@ -717,17 +658,17 @@ LLAvatarNameCache::callback_connection_t LLAvatarNameCache::get(const LLUUID& ag
// schedule a request
if (!isRequestPending(agent_id))
{
- sAskQueue.insert(agent_id);
+ mAskQueue.insert(agent_id);
}
// always store additional callback, even if request is pending
- signal_map_t::iterator sig_it = sSignalMap.find(agent_id);
- if (sig_it == sSignalMap.end())
+ signal_map_t::iterator sig_it = mSignalMap.find(agent_id);
+ if (sig_it == mSignalMap.end())
{
// ...new callback for this id
callback_signal_t* signal = new callback_signal_t();
connection = signal->connect(slot);
- sSignalMap[agent_id] = signal;
+ mSignalMap[agent_id] = signal;
}
else
{
@@ -760,20 +701,20 @@ void LLAvatarNameCache::setUseUsernames(bool use)
void LLAvatarNameCache::erase(const LLUUID& agent_id)
{
- sCache.erase(agent_id);
+ mCache.erase(agent_id);
}
void LLAvatarNameCache::insert(const LLUUID& agent_id, const LLAvatarName& av_name)
{
// *TODO: update timestamp if zero?
- sCache[agent_id] = av_name;
+ mCache[agent_id] = av_name;
}
LLUUID LLAvatarNameCache::findIdByName(const std::string& name)
{
std::map<LLUUID, LLAvatarName>::iterator it;
- std::map<LLUUID, LLAvatarName>::iterator end = sCache.end();
- for (it = sCache.begin(); it != end; ++it)
+ std::map<LLUUID, LLAvatarName>::iterator end = mCache.end();
+ for (it = mCache.begin(); it != end; ++it)
{
if (it->second.getUserName() == name)
{
diff --git a/indra/llmessage/llavatarnamecache.h b/indra/llmessage/llavatarnamecache.h
index 63e067c939f502871dafece78e69dfaf8da002dc..ba89d569f3f6f9ce1315a151d070861df2db1f0d 100644
--- a/indra/llmessage/llavatarnamecache.h
+++ b/indra/llmessage/llavatarnamecache.h
@@ -29,21 +29,20 @@
#define LLAVATARNAMECACHE_H
#include "llavatarname.h" // for convenience
+#include "llsingleton.h"
#include <boost/signals2.hpp>
+#include <set>
class LLSD;
class LLUUID;
-namespace LLAvatarNameCache
+class LLAvatarNameCache : public LLSingleton<LLAvatarNameCache>
{
+ LLSINGLETON(LLAvatarNameCache);
+ ~LLAvatarNameCache();
+public:
typedef boost::signals2::signal<void (void)> use_display_name_signal_t;
- // Until the cache is set running, immediate lookups will fail and
- // async lookups will be queued. This allows us to block requests
- // until we know if the first region supports display names.
- void initClass(bool running, bool usePeopleAPI);
- void cleanupClass();
-
// Import/export the name cache to file.
bool importFile(std::istream& istr);
void exportFile(std::ostream& ostr);
@@ -55,6 +54,7 @@ namespace LLAvatarNameCache
// Do we have a valid lookup URL, i.e. are we trying to use the
// more recent display name lookup system?
bool hasNameLookupURL();
+ void setUsePeopleAPI(bool use_api);
bool usePeopleAPI();
// Periodically makes a batch request for display names not already in
@@ -63,7 +63,8 @@ namespace LLAvatarNameCache
// If name is in cache, returns true and fills in provided LLAvatarName
// otherwise returns false.
- bool get(const LLUUID& agent_id, LLAvatarName *av_name);
+ static bool get(const LLUUID& agent_id, LLAvatarName *av_name);
+ bool getName(const LLUUID& agent_id, LLAvatarName *av_name);
// Callback types for get() below
typedef boost::signals2::signal<
@@ -74,7 +75,8 @@ namespace LLAvatarNameCache
// Fetches name information and calls callbacks.
// If name information is in cache, callbacks will be called immediately.
- callback_connection_t get(const LLUUID& agent_id, callback_slot_t slot);
+ static callback_connection_t get(const LLUUID& agent_id, callback_slot_t slot);
+ callback_connection_t getNameCallback(const LLUUID& agent_id, callback_slot_t slot);
// Set display name: flips the switch and triggers the callbacks.
void setUseDisplayNames(bool use);
@@ -100,7 +102,83 @@ namespace LLAvatarNameCache
F64 nameExpirationFromHeaders(const LLSD& headers);
void addUseDisplayNamesCallback(const use_display_name_signal_t::slot_type& cb);
-}
+
+private:
+ // Handle name response off network.
+ void processName(const LLUUID& agent_id,
+ const LLAvatarName& av_name);
+
+ void requestNamesViaCapability();
+
+ // Legacy name system callbacks
+ static void legacyNameCallback(const LLUUID& agent_id,
+ const std::string& full_name,
+ bool is_group);
+ static void legacyNameFetch(const LLUUID& agent_id,
+ const std::string& full_name,
+ bool is_group);
+
+ void requestNamesViaLegacy();
+
+ // Do a single callback to a given slot
+ void fireSignal(const LLUUID& agent_id,
+ const callback_slot_t& slot,
+ const LLAvatarName& av_name);
+
+ // Is a request in-flight over the network?
+ bool isRequestPending(const LLUUID& agent_id);
+
+ // Erase expired names from cache
+ void eraseUnrefreshed();
+
+ bool expirationFromCacheControl(const LLSD& headers, F64 *expires);
+
+ // This is a coroutine.
+ static void requestAvatarNameCache_(std::string url, std::vector<LLUUID> agentIds);
+
+ void handleAvNameCacheSuccess(const LLSD &data, const LLSD &httpResult);
+
+private:
+
+ use_display_name_signal_t mUseDisplayNamesSignal;
+
+ // Cache starts in a paused state until we can determine if the
+ // current region supports display names.
+ bool mRunning;
+
+ // Use the People API (modern) for fetching name if true. Use the old legacy protocol if false.
+ // For testing, there's a UsePeopleAPI setting that can be flipped (must restart viewer).
+ bool mUsePeopleAPI;
+
+ // Base lookup URL for name service.
+ // On simulator, loaded from indra.xml
+ // On viewer, usually a simulator capability (at People API team's request)
+ // Includes the trailing slash, like "http://pdp60.lindenlab.com:8000/agents/"
+ std::string mNameLookupURL;
+
+ // Accumulated agent IDs for next query against service
+ typedef std::set<LLUUID> ask_queue_t;
+ ask_queue_t mAskQueue;
+
+ // Agent IDs that have been requested, but with no reply.
+ // Maps agent ID to frame time request was made.
+ typedef std::map<LLUUID, F64> pending_queue_t;
+ pending_queue_t mPendingQueue;
+
+ // Callbacks to fire when we received a name.
+ // May have multiple callbacks for a single ID, which are
+ // represented as multiple slots bound to the signal.
+ // Avoid copying signals via pointers.
+ typedef std::map<LLUUID, callback_signal_t*> signal_map_t;
+ signal_map_t mSignalMap;
+
+ // The cache at last, i.e. avatar names we know about.
+ typedef std::map<LLUUID, LLAvatarName> cache_t;
+ cache_t mCache;
+
+ // Time when unrefreshed cached names were checked last.
+ F64 mLastExpireCheck;
+};
// Parse a cache-control header to get the max-age delta-seconds.
// Returns true if header has max-age param and it parses correctly.
diff --git a/indra/llmessage/llproxy.cpp b/indra/llmessage/llproxy.cpp
index dea03aab853fe6267170ca7f8163c4425672bfb8..950599217f83195b1adb0ff4ed07a461030eafb0 100644
--- a/indra/llmessage/llproxy.cpp
+++ b/indra/llmessage/llproxy.cpp
@@ -403,8 +403,11 @@ LLSocks5AuthType LLProxy::getSelectedAuthMethod() const
//static
void LLProxy::cleanupClass()
{
- getInstance()->stopSOCKSProxy();
- deleteSingleton();
+ if (instanceExists())
+ {
+ getInstance()->stopSOCKSProxy();
+ deleteSingleton();
+ }
}
/**
diff --git a/indra/llmessage/tests/llareslistener_test.cpp b/indra/llmessage/tests/llareslistener_test.cpp
index c04696c86b721f5734214fc9ad369c3a9b44847c..254185cbd0981c9081cbd56e5966170b8370a610 100644
--- a/indra/llmessage/tests/llareslistener_test.cpp
+++ b/indra/llmessage/tests/llareslistener_test.cpp
@@ -138,15 +138,9 @@ namespace tut
WrapLLErrs capture;
LLSD request;
request["op"] = "foo";
- std::string threw;
- try
- {
- LLEventPumps::instance().obtain("LLAres").post(request);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([&request](){
+ LLEventPumps::instance().obtain("LLAres").post(request);
+ });
ensure_contains("LLAresListener bad op", threw, "bad");
}
@@ -157,15 +151,9 @@ namespace tut
WrapLLErrs capture;
LLSD request;
request["op"] = "rewriteURI";
- std::string threw;
- try
- {
- LLEventPumps::instance().obtain("LLAres").post(request);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([&request](){
+ LLEventPumps::instance().obtain("LLAres").post(request);
+ });
ensure_contains("LLAresListener bad req", threw, "missing");
ensure_contains("LLAresListener bad req", threw, "reply");
ensure_contains("LLAresListener bad req", threw, "uri");
@@ -179,15 +167,9 @@ namespace tut
LLSD request;
request["op"] = "rewriteURI";
request["reply"] = "nonexistent";
- std::string threw;
- try
- {
- LLEventPumps::instance().obtain("LLAres").post(request);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([&request](){
+ LLEventPumps::instance().obtain("LLAres").post(request);
+ });
ensure_contains("LLAresListener bad req", threw, "missing");
ensure_contains("LLAresListener bad req", threw, "uri");
ensure_does_not_contain("LLAresListener bad req", threw, "reply");
@@ -201,15 +183,9 @@ namespace tut
LLSD request;
request["op"] = "rewriteURI";
request["uri"] = "foo.bar.com";
- std::string threw;
- try
- {
- LLEventPumps::instance().obtain("LLAres").post(request);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([&request](){
+ LLEventPumps::instance().obtain("LLAres").post(request);
+ });
ensure_contains("LLAresListener bad req", threw, "missing");
ensure_contains("LLAresListener bad req", threw, "reply");
ensure_does_not_contain("LLAresListener bad req", threw, "uri");
diff --git a/indra/llrender/llrender2dutils.cpp b/indra/llrender/llrender2dutils.cpp
index 4e2ebfd51ef248fa599f1dd60108fa25a5483838..4eb0203245985f455a883bd6945387036cdd7b8b 100644
--- a/indra/llrender/llrender2dutils.cpp
+++ b/indra/llrender/llrender2dutils.cpp
@@ -46,8 +46,6 @@
// Globals
//
const LLColor4 UI_VERTEX_COLOR(1.f, 1.f, 1.f, 1.f);
-/*static*/ LLVector2 LLRender2D::sGLScaleFactor(1.f, 1.f);
-/*static*/ LLImageProviderInterface* LLRender2D::sImageProvider = NULL;
//
// Functions
@@ -108,10 +106,11 @@ void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixe
top += LLFontGL::sCurOrigin.mY;
gGL.loadUIIdentity();
- gl_rect_2d(llfloor((F32)left * LLRender2D::sGLScaleFactor.mV[VX]) - pixel_offset,
- llfloor((F32)top * LLRender2D::sGLScaleFactor.mV[VY]) + pixel_offset,
- llfloor((F32)right * LLRender2D::sGLScaleFactor.mV[VX]) + pixel_offset,
- llfloor((F32)bottom * LLRender2D::sGLScaleFactor.mV[VY]) - pixel_offset,
+ LLRender2D *r2d_inst = LLRender2D::getInstance();
+ gl_rect_2d(llfloor((F32)left * r2d_inst->mGLScaleFactor.mV[VX]) - pixel_offset,
+ llfloor((F32)top * r2d_inst->mGLScaleFactor.mV[VY]) + pixel_offset,
+ llfloor((F32)right * r2d_inst->mGLScaleFactor.mV[VX]) + pixel_offset,
+ llfloor((F32)bottom * r2d_inst->mGLScaleFactor.mV[VY]) - pixel_offset,
filled);
gGL.popUIMatrix();
}
@@ -800,7 +799,7 @@ void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LL
}
gGL.end();
- LLRender2D::setLineWidth(1.f);
+ LLRender2D::getInstance()->setLineWidth(1.f);
}
void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle)
@@ -967,7 +966,7 @@ void gl_rect_2d_checkerboard(const LLRect& rect, GLfloat alpha)
}
else
{ //polygon stipple is deprecated, use "Checker" texture
- LLPointer<LLUIImage> img = LLRender2D::getUIImage("Checker");
+ LLPointer<LLUIImage> img = LLRender2D::getInstance()->getUIImage("Checker");
gGL.getTexUnit(0)->bind(img->getImage());
gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_WRAP);
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
@@ -1567,25 +1566,26 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
}
-// static
-void LLRender2D::initClass(LLImageProviderInterface* image_provider,
- const LLVector2* scale_factor)
+LLRender2D::LLRender2D(LLImageProviderInterface* image_provider)
{
- sGLScaleFactor = (scale_factor == NULL) ? LLVector2(1.f, 1.f) : *scale_factor;
- sImageProvider = image_provider;
+ mGLScaleFactor = LLVector2(1.f, 1.f);
+ mImageProvider = image_provider;
+ if(mImageProvider)
+ {
+ mImageProvider->addOnRemovalCallback(resetProvider);
+ }
}
-// static
-void LLRender2D::cleanupClass()
+LLRender2D::~LLRender2D()
{
- if(sImageProvider)
+ if(mImageProvider)
{
- sImageProvider->cleanUp();
+ mImageProvider->cleanUp();
+ mImageProvider->deleteOnRemovalCallback(resetProvider);
}
}
-//static
void LLRender2D::translate(F32 x, F32 y, F32 z)
{
gGL.translateUI(x,y,z);
@@ -1594,14 +1594,12 @@ void LLRender2D::translate(F32 x, F32 y, F32 z)
LLFontGL::sCurDepth += z;
}
-//static
void LLRender2D::pushMatrix()
{
gGL.pushUIMatrix();
LLFontGL::sOriginStack.push_back(std::make_pair(LLFontGL::sCurOrigin, LLFontGL::sCurDepth));
}
-//static
void LLRender2D::popMatrix()
{
gGL.popUIMatrix();
@@ -1610,7 +1608,6 @@ void LLRender2D::popMatrix()
LLFontGL::sOriginStack.pop_back();
}
-//static
void LLRender2D::loadIdentity()
{
gGL.loadUIIdentity();
@@ -1619,25 +1616,22 @@ void LLRender2D::loadIdentity()
LLFontGL::sCurDepth = 0.f;
}
-//static
void LLRender2D::setScaleFactor(const LLVector2 &scale_factor)
{
- sGLScaleFactor = scale_factor;
+ mGLScaleFactor = scale_factor;
}
-//static
void LLRender2D::setLineWidth(F32 width)
{
gGL.flush();
- glLineWidth(width * lerp(sGLScaleFactor.mV[VX], sGLScaleFactor.mV[VY], 0.5f));
+ glLineWidth(width * lerp(mGLScaleFactor.mV[VX], mGLScaleFactor.mV[VY], 0.5f));
}
-//static
LLPointer<LLUIImage> LLRender2D::getUIImageByID(const LLUUID& image_id, S32 priority)
{
- if (sImageProvider)
+ if (mImageProvider)
{
- return sImageProvider->getUIImageByID(image_id, priority);
+ return mImageProvider->getUIImageByID(image_id, priority);
}
else
{
@@ -1645,12 +1639,49 @@ LLPointer<LLUIImage> LLRender2D::getUIImageByID(const LLUUID& image_id, S32 prio
}
}
-//static
LLPointer<LLUIImage> LLRender2D::getUIImage(const std::string& name, S32 priority)
{
- if (!name.empty() && sImageProvider)
- return sImageProvider->getUIImage(name, priority);
+ if (!name.empty() && mImageProvider)
+ return mImageProvider->getUIImage(name, priority);
else
return NULL;
}
+// static
+void LLRender2D::resetProvider()
+{
+ if (LLRender2D::instanceExists)
+ {
+ LLRender2D::getInstance()->mImageProvider = NULL;
+ }
+}
+
+// class LLImageProviderInterface
+
+LLImageProviderInterface::~LLImageProviderInterface()
+{
+ for (callback_list_t::iterator iter = mCallbackList.begin(); iter != mCallbackList.end();)
+ {
+ callback_list_t::iterator curiter = iter++;
+ (*curiter)();
+ }
+}
+
+void LLImageProviderInterface::addOnRemovalCallback(callback_t func)
+{
+ if (!func)
+ {
+ return;
+ }
+ mCallbackList.push_back(func);
+}
+
+void LLImageProviderInterface::deleteOnRemovalCallback(callback_t func)
+{
+ callback_list_t::iterator iter = std::find(mCallbackList.begin(), mCallbackList.end(), func);
+ if (iter != mCallbackList.end())
+ {
+ mCallbackList.erase(iter);
+ }
+}
+
diff --git a/indra/llrender/llrender2dutils.h b/indra/llrender/llrender2dutils.h
index cce3b4ed511154d3887ce44259836c1a42135289..70ab006fd6573490d0857cf90b588bd29cb569a4 100644
--- a/indra/llrender/llrender2dutils.h
+++ b/indra/llrender/llrender2dutils.h
@@ -121,39 +121,54 @@ inline void gl_rect_2d_offset_local( const LLRect& rect, S32 pixel_offset, BOOL
class LLImageProviderInterface;
-class LLRender2D
+class LLRender2D : public LLParamSingleton<LLRender2D>
{
+ LLSINGLETON(LLRender2D, LLImageProviderInterface* image_provider);
LOG_CLASS(LLRender2D);
+ ~LLRender2D();
public:
- static void initClass(LLImageProviderInterface* image_provider,
- const LLVector2* scale_factor);
- static void cleanupClass();
+ void pushMatrix();
+ void popMatrix();
+ void loadIdentity();
+ void translate(F32 x, F32 y, F32 z = 0.0f);
- static void pushMatrix();
- static void popMatrix();
- static void loadIdentity();
- static void translate(F32 x, F32 y, F32 z = 0.0f);
+ void setLineWidth(F32 width);
+ void setScaleFactor(const LLVector2& scale_factor);
- static void setLineWidth(F32 width);
- static void setScaleFactor(const LLVector2& scale_factor);
+ LLPointer<LLUIImage> getUIImageByID(const LLUUID& image_id, S32 priority = 0);
+ LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority = 0);
- static LLPointer<LLUIImage> getUIImageByID(const LLUUID& image_id, S32 priority = 0);
- static LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority = 0);
+ LLVector2 mGLScaleFactor;
+
+protected:
+ // since LLRender2D has no control of image provider's lifecycle
+ // we need a way to tell LLRender2D that provider died and
+ // LLRender2D needs to be updated.
+ static void resetProvider();
- static LLVector2 sGLScaleFactor;
private:
- static LLImageProviderInterface* sImageProvider;
+ LLImageProviderInterface* mImageProvider;
};
class LLImageProviderInterface
{
protected:
LLImageProviderInterface() {};
- virtual ~LLImageProviderInterface() {};
+ virtual ~LLImageProviderInterface();
public:
virtual LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority) = 0;
virtual LLPointer<LLUIImage> getUIImageByID(const LLUUID& id, S32 priority) = 0;
virtual void cleanUp() = 0;
+
+ // to notify holders when pointer gets deleted
+ typedef void(*callback_t)();
+ void addOnRemovalCallback(callback_t func);
+ void deleteOnRemovalCallback(callback_t func);
+
+private:
+
+ typedef std::list< callback_t > callback_list_t;
+ callback_list_t mCallbackList;
};
diff --git a/indra/llrender/lluiimage.cpp b/indra/llrender/lluiimage.cpp
index 5d8f92b2e6f87737a3612623fd0303385dcfbee8..c8337feabbc69e8fd985ebea177b0925c522104f 100644
--- a/indra/llrender/lluiimage.cpp
+++ b/indra/llrender/lluiimage.cpp
@@ -120,12 +120,12 @@ void LLUIImage::draw3D(const LLVector3& origin_agent, const LLVector3& x_axis, c
}
}
- LLRender2D::pushMatrix();
+ LLRender2D::getInstance()->pushMatrix();
{
LLVector3 rect_origin = origin_agent + (rect.mLeft * x_axis) + (rect.mBottom * y_axis);
- LLRender2D::translate(rect_origin.mV[VX],
- rect_origin.mV[VY],
- rect_origin.mV[VZ]);
+ LLRender2D::getInstance()->translate(rect_origin.mV[VX],
+ rect_origin.mV[VY],
+ rect_origin.mV[VZ]);
gGL.getTexUnit(0)->bind(getImage());
gGL.color4fv(color.mV);
@@ -142,7 +142,7 @@ void LLUIImage::draw3D(const LLVector3& origin_agent, const LLVector3& x_axis, c
rect.getWidth() * x_axis,
rect.getHeight() * y_axis);
- } LLRender2D::popMatrix();
+ } LLRender2D::getInstance()->popMatrix();
}
@@ -199,7 +199,7 @@ namespace LLInitParam
return;
}
- LLUIImage* imagep = LLRender2D::getUIImage(name());
+ LLUIImage* imagep = LLRender2D::getInstance()->getUIImage(name());
if (imagep)
{
updateValue(imagep);
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
index eaf128423731da22add5a012daaaea3dd4acfe71..1034a219052f29b45ba4be46885f837573ec7c5d 100644
--- a/indra/llui/llaccordionctrltab.cpp
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -977,7 +977,7 @@ void LLAccordionCtrlTab::drawChild(const LLRect& root_rect,LLView* child)
LLRect screen_rect;
localRectToScreen(child->getRect(),&screen_rect);
- if ( root_rect.overlaps(screen_rect) && LLUI::sDirtyRect.overlaps(screen_rect))
+ if ( root_rect.overlaps(screen_rect) && LLUI::getInstance()->mDirtyRect.overlaps(screen_rect))
{
gGL.matrixMode(LLRender::MM_MODELVIEW);
LLUI::pushMatrix();
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 6b7a8a8b860021a83a474a34944bb4aebf0ca257..27444b7f5b961c127558f9f124cd9c6de9689494 100644
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -90,8 +90,8 @@ LLButton::Params::Params()
image_overlay_disabled_color("image_overlay_disabled_color", LLColor4::white % 0.3f),
image_overlay_selected_color("image_overlay_selected_color", LLColor4::white),
flash_color("flash_color"),
- pad_right("pad_right", LLUI::sSettingGroups["config"]->getS32("ButtonHPad")),
- pad_left("pad_left", LLUI::sSettingGroups["config"]->getS32("ButtonHPad")),
+ pad_right("pad_right", LLUI::getInstance()->mSettingGroups["config"]->getS32("ButtonHPad")),
+ pad_left("pad_left", LLUI::getInstance()->mSettingGroups["config"]->getS32("ButtonHPad")),
pad_bottom("pad_bottom"),
click_callback("click_callback"),
mouse_down_callback("mouse_down_callback"),
@@ -614,7 +614,7 @@ void LLButton::getOverlayImageSize(S32& overlay_width, S32& overlay_height)
// virtual
void LLButton::draw()
{
- static LLCachedControl<bool> sEnableButtonFlashing(*LLUI::sSettingGroups["config"], "EnableButtonFlashing", true);
+ static LLCachedControl<bool> sEnableButtonFlashing(*LLUI::getInstance()->mSettingGroups["config"], "EnableButtonFlashing", true);
F32 alpha = mUseDrawContextAlpha ? getDrawContext().mAlpha : getCurrentTransparency();
bool pressed_by_keyboard = FALSE;
@@ -628,7 +628,7 @@ void LLButton::draw()
{
S32 local_mouse_x ;
S32 local_mouse_y;
- LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
mouse_pressed_and_over = pointInView(local_mouse_x, local_mouse_y);
}
@@ -1261,10 +1261,10 @@ void LLButton::showHelp(LLUICtrl* ctrl, const LLSD& sdname)
// search back through the button's parents for a panel
// with a help_topic string defined
std::string help_topic;
- if (LLUI::sHelpImpl &&
+ if (LLUI::getInstance()->mHelpImpl &&
ctrl->findHelpTopic(help_topic))
{
- LLUI::sHelpImpl->showTopic(help_topic);
+ LLUI::getInstance()->mHelpImpl->showTopic(help_topic);
return; // success
}
diff --git a/indra/llui/llchatentry.cpp b/indra/llui/llchatentry.cpp
index dac001afabcf757be529aa00b85cd4b0491f021e..c50657612621d16b94134f7c49e1315eb0b019ee 100644
--- a/indra/llui/llchatentry.cpp
+++ b/indra/llui/llchatentry.cpp
@@ -201,7 +201,7 @@ BOOL LLChatEntry::handleSpecialKey(const KEY key, const MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
handled = TRUE;
}
@@ -225,7 +225,7 @@ BOOL LLChatEntry::handleSpecialKey(const KEY key, const MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
handled = TRUE;
}
diff --git a/indra/llui/llcombobox.cpp b/indra/llui/llcombobox.cpp
index b2ad38bddfb8e278112e0aaa2798eb763b29660e..c7f0326ed49f324b6d95187a444c365df1fc4489 100644
--- a/indra/llui/llcombobox.cpp
+++ b/indra/llui/llcombobox.cpp
@@ -668,7 +668,7 @@ void LLComboBox::showList()
mButton->setToggleState(TRUE);
mList->setVisible(TRUE);
- LLUI::addPopup(this);
+ LLUI::getInstance()->addPopup(this);
setUseBoundingRect(TRUE);
// updateBoundingRect();
@@ -694,7 +694,7 @@ void LLComboBox::hideList()
mList->mouseOverHighlightNthItem(-1);
setUseBoundingRect(FALSE);
- LLUI::removePopup(this);
+ LLUI::getInstance()->removePopup(this);
// updateBoundingRect();
}
}
diff --git a/indra/llui/llconsole.cpp b/indra/llui/llconsole.cpp
index 26ae31cac660fbe4c0c1ef4909f2392bf00181a7..5f50e462336424cc88dfcf0473d9a09f01c3c7dc 100644
--- a/indra/llui/llconsole.cpp
+++ b/indra/llui/llconsole.cpp
@@ -68,7 +68,7 @@ LLConsole::LLConsole(const LLConsole::Params& p)
setFontSize(p.font_size_index);
}
mFadeTime = mLinePersistTime - FADE_DURATION;
- setMaxLines(LLUI::sSettingGroups["config"]->getS32("ConsoleMaxLines"));
+ setMaxLines(LLUI::getInstance()->mSettingGroups["config"]->getS32("ConsoleMaxLines"));
}
void LLConsole::setLinePersistTime(F32 seconds)
@@ -180,7 +180,7 @@ void LLConsole::draw()
LLUIImagePtr imagep = LLUI::getUIImage("transparent");
- F32 console_opacity = llclamp(LLUI::sSettingGroups["config"]->getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
+ F32 console_opacity = llclamp(LLUI::getInstance()->mSettingGroups["config"]->getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
LLColor4 color = LLUIColorTable::instance().getColor("ConsoleBackground");
color.mV[VALPHA] *= console_opacity;
diff --git a/indra/llui/llconsole.h b/indra/llui/llconsole.h
index 5ff05698b05b39cf5d95b463c56ef0071cae6e4f..04f5e716099335bf0495e1a0cf482116ef46f8ec 100644
--- a/indra/llui/llconsole.h
+++ b/indra/llui/llconsole.h
@@ -51,7 +51,7 @@ class LLConsole : public LLFixedBuffer, public LLUICtrl, public LLInstanceTracke
Optional<F32> persist_time;
Optional<S32> font_size_index;
Params()
- : max_lines("max_lines", LLUI::sSettingGroups["config"]->getS32("ConsoleMaxLines")),
+ : max_lines("max_lines", LLUI::getInstance()->mSettingGroups["config"]->getS32("ConsoleMaxLines")),
persist_time("persist_time", 0.f), // forever
font_size_index("font_size_index")
{
diff --git a/indra/llui/llflashtimer.cpp b/indra/llui/llflashtimer.cpp
index 6d9c429b083b0775a3a3bc8d0d8f01fb8f734a6b..39793316f438db32e90ebaf0fcd3fba7b982e4d3 100644
--- a/indra/llui/llflashtimer.cpp
+++ b/indra/llui/llflashtimer.cpp
@@ -40,10 +40,10 @@ LLFlashTimer::LLFlashTimer(callback_t cb, S32 count, F32 period)
// By default use settings from settings.xml to be able change them via Debug settings. See EXT-5973.
// Due to Timer is implemented as derived class from EventTimer it is impossible to change period
// in runtime. So, both settings are made as required restart.
- mFlashCount = 2 * ((count > 0) ? count : LLUI::sSettingGroups["config"]->getS32("FlashCount"));
+ mFlashCount = 2 * ((count > 0) ? count : LLUI::getInstance()->mSettingGroups["config"]->getS32("FlashCount"));
if (mPeriod <= 0)
{
- mPeriod = LLUI::sSettingGroups["config"]->getF32("FlashPeriod");
+ mPeriod = LLUI::getInstance()->mSettingGroups["config"]->getF32("FlashPeriod");
}
}
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index a245dd8f78b61aff032d15744d9496b237ccb92a..42802cd339cfece764cf1f62079919bcef0ebb86 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -215,14 +215,14 @@ void LLFloater::initClass()
sButtonToolTips[i] = LLTrans::getString( sButtonToolTipsIndex[i] );
}
- LLControlVariable* ctrl = LLUI::sSettingGroups["config"]->getControl("ActiveFloaterTransparency").get();
+ LLControlVariable* ctrl = LLUI::getInstance()->mSettingGroups["config"]->getControl("ActiveFloaterTransparency").get();
if (ctrl)
{
ctrl->getSignal()->connect(boost::bind(&LLFloater::updateActiveFloaterTransparency));
updateActiveFloaterTransparency();
}
- ctrl = LLUI::sSettingGroups["config"]->getControl("InactiveFloaterTransparency").get();
+ ctrl = LLUI::getInstance()->mSettingGroups["config"]->getControl("InactiveFloaterTransparency").get();
if (ctrl)
{
ctrl->getSignal()->connect(boost::bind(&LLFloater::updateInactiveFloaterTransparency));
@@ -374,13 +374,13 @@ void LLFloater::layoutDragHandle()
// static
void LLFloater::updateActiveFloaterTransparency()
{
- sActiveControlTransparency = LLUI::sSettingGroups["config"]->getF32("ActiveFloaterTransparency");
+ sActiveControlTransparency = LLUI::getInstance()->mSettingGroups["config"]->getF32("ActiveFloaterTransparency");
}
// static
void LLFloater::updateInactiveFloaterTransparency()
{
- sInactiveControlTransparency = LLUI::sSettingGroups["config"]->getF32("InactiveFloaterTransparency");
+ sInactiveControlTransparency = LLUI::getInstance()->mSettingGroups["config"]->getF32("InactiveFloaterTransparency");
}
void LLFloater::addResizeCtrls()
@@ -579,7 +579,7 @@ std::string LLFloater::getControlName(const std::string& name, const LLSD& key)
LLControlGroup* LLFloater::getControlGroup()
{
// Floater size, position, visibility, etc are saved in per-account settings.
- return LLUI::sSettingGroups["account"];
+ return LLUI::getInstance()->mSettingGroups["account"];
}
void LLFloater::setVisible( BOOL visible )
@@ -592,7 +592,7 @@ void LLFloater::setVisible( BOOL visible )
if( !visible )
{
- LLUI::removePopup(this);
+ LLUI::getInstance()->removePopup(this);
if( gFocusMgr.childHasMouseCapture( this ) )
{
@@ -818,7 +818,7 @@ void LLFloater::reshape(S32 width, S32 height, BOOL called_from_parent)
void LLFloater::releaseFocus()
{
- LLUI::removePopup(this);
+ LLUI::getInstance()->removePopup(this);
setFocus(FALSE);
@@ -1771,13 +1771,13 @@ void LLFloater::onClickDock(LLFloater* self)
// static
void LLFloater::onClickHelp( LLFloater* self )
{
- if (self && LLUI::sHelpImpl)
+ if (self && LLUI::getInstance()->mHelpImpl)
{
// find the current help context for this floater
std::string help_topic;
if (self->findHelpTopic(help_topic))
{
- LLUI::sHelpImpl->showTopic(help_topic);
+ LLUI::getInstance()->mHelpImpl->showTopic(help_topic);
}
}
}
@@ -2931,7 +2931,7 @@ void LLFloaterView::syncFloaterTabOrder()
if (modal_dialog)
{
// If we have a visible modal dialog, make sure that it has focus
- LLUI::addPopup(modal_dialog);
+ LLUI::getInstance()->addPopup(modal_dialog);
if( !gFocusMgr.childHasKeyboardFocus( modal_dialog ) )
{
diff --git a/indra/llui/llfloaterreg.cpp b/indra/llui/llfloaterreg.cpp
index 9ef290abc024cd6629c876d12bad94ad768611b2..85e07fc6a6a0f2a3dd2a41c61e4bae891db5422b 100644
--- a/indra/llui/llfloaterreg.cpp
+++ b/indra/llui/llfloaterreg.cpp
@@ -445,7 +445,7 @@ void LLFloaterReg::registerControlVariables()
}
}
- const LLSD& exclude_list = LLUI::sSettingGroups["config"]->getLLSD("always_showable_floaters");
+ const LLSD& exclude_list = LLUI::getInstance()->mSettingGroups["config"]->getLLSD("always_showable_floaters");
for (LLSD::array_const_iterator iter = exclude_list.beginArray();
iter != exclude_list.endArray();
iter++)
diff --git a/indra/llui/llfocusmgr.cpp b/indra/llui/llfocusmgr.cpp
index 1b213c34186e7ee4d08ba30d5a04a3eab24d1877..7b0a6cbdaeb4124a93c19a3d534dfbc428737b54 100644
--- a/indra/llui/llfocusmgr.cpp
+++ b/indra/llui/llfocusmgr.cpp
@@ -183,7 +183,7 @@ void LLFocusMgr::releaseFocusIfNeeded( LLView* view )
}
}
- LLUI::removePopup(view);
+ LLUI::getInstance()->removePopup(view);
}
void LLFocusMgr::setKeyboardFocus(LLFocusableElement* new_focus, BOOL lock, BOOL keystrokes_only)
@@ -481,7 +481,7 @@ void LLFocusMgr::setAppHasFocus(BOOL focus)
// release focus from "top ctrl"s, which generally hides them
if (!focus)
{
- LLUI::clearPopups();
+ LLUI::getInstance()->clearPopups();
}
mAppHasFocus = focus;
}
diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp
index 895753aeae6394edc6e1383db58065a2ae593873..b05a9807d0801f8af5747d14fe07ea1d39e5aa8e 100644
--- a/indra/llui/llfolderview.cpp
+++ b/indra/llui/llfolderview.cpp
@@ -338,7 +338,7 @@ static LLTrace::BlockTimerStatHandle FTM_FILTER("Filter Folder View");
void LLFolderView::filter( LLFolderViewFilter& filter )
{
LL_RECORD_BLOCK_TIME(FTM_FILTER);
- filter.resetTime(llclamp(LLUI::sSettingGroups["config"]->getS32(mParentPanel.get()->getVisible() ? "FilterItemsMaxTimePerFrameVisible" : "FilterItemsMaxTimePerFrameUnvisible"), 1, 100));
+ filter.resetTime(llclamp(LLUI::getInstance()->mSettingGroups["config"]->getS32(mParentPanel.get()->getVisible() ? "FilterItemsMaxTimePerFrameVisible" : "FilterItemsMaxTimePerFrameUnvisible"), 1, 100));
// Note: we filter the model, not the view
getViewModelItem()->filter(filter);
@@ -657,7 +657,7 @@ void LLFolderView::draw()
closeAutoOpenedFolders();
}
- if (mSearchTimer.getElapsedTimeF32() > LLUI::sSettingGroups["config"]->getF32("TypeAheadTimeout") || !mSearchString.size())
+ if (mSearchTimer.getElapsedTimeF32() > LLUI::getInstance()->mSettingGroups["config"]->getF32("TypeAheadTimeout") || !mSearchString.size())
{
mSearchString.clear();
}
@@ -733,7 +733,7 @@ void LLFolderView::closeRenamer( void )
if (mRenamer && mRenamer->getVisible())
{
// Triggers onRenamerLost() that actually closes the renamer.
- LLUI::removePopup(mRenamer);
+ LLUI::getInstance()->removePopup(mRenamer);
}
}
@@ -1064,7 +1064,7 @@ void LLFolderView::startRenamingSelectedItem( void )
// set focus will fail unless item is visible
mRenamer->setFocus( TRUE );
mRenamer->setTopLostCallback(boost::bind(&LLFolderView::onRenamerLost, this));
- LLUI::addPopup(mRenamer);
+ LLUI::getInstance()->addPopup(mRenamer);
}
}
@@ -1321,7 +1321,7 @@ BOOL LLFolderView::handleUnicodeCharHere(llwchar uni_char)
}
//do text search
- if (mSearchTimer.getElapsedTimeF32() > LLUI::sSettingGroups["config"]->getF32("TypeAheadTimeout"))
+ if (mSearchTimer.getElapsedTimeF32() > LLUI::getInstance()->mSettingGroups["config"]->getF32("TypeAheadTimeout"))
{
mSearchString.clear();
}
@@ -1803,7 +1803,7 @@ void LLFolderView::updateRenamerPosition()
screenPointToLocal( x, y, &x, &y );
mRenamer->setOrigin( x, y );
- LLRect scroller_rect(0, 0, (S32)LLUI::getWindowSize().mV[VX], 0);
+ LLRect scroller_rect(0, 0, (S32)LLUI::getInstance()->getWindowSize().mV[VX], 0);
if (mScrollContainer)
{
scroller_rect = mScrollContainer->getContentWindowRect();
diff --git a/indra/llui/llfolderviewitem.cpp b/indra/llui/llfolderviewitem.cpp
index 0510e472c53da52dc8101da82ce3ecea17e01618..2de47f1a19152f0417b4b35f4ab6713ccaca55ec 100644
--- a/indra/llui/llfolderviewitem.cpp
+++ b/indra/llui/llfolderviewitem.cpp
@@ -548,7 +548,7 @@ BOOL LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
{
- static LLCachedControl<S32> drag_and_drop_threshold(*LLUI::sSettingGroups["config"],"DragAndDropDistanceThreshold", 3);
+ static LLCachedControl<S32> drag_and_drop_threshold(*LLUI::getInstance()->mSettingGroups["config"],"DragAndDropDistanceThreshold", 3);
mIsMouseOverTitle = (y > (getRect().getHeight() - mItemHeight));
diff --git a/indra/llui/llfolderviewmodel.cpp b/indra/llui/llfolderviewmodel.cpp
index 3363dc531652b54c66fb332efea086d20f928450..3b45fb53a2183ebfa99ea982aeae816e929dbe8e 100644
--- a/indra/llui/llfolderviewmodel.cpp
+++ b/indra/llui/llfolderviewmodel.cpp
@@ -48,7 +48,7 @@ std::string LLFolderViewModelCommon::getStatusText()
void LLFolderViewModelCommon::filter()
{
- getFilter().resetTime(llclamp(LLUI::sSettingGroups["config"]->getS32("FilterItemsMaxTimePerFrameVisible"), 1, 100));
+ getFilter().resetTime(llclamp(LLUI::getInstance()->mSettingGroups["config"]->getS32("FilterItemsMaxTimePerFrameVisible"), 1, 100));
mFolderView->getViewModelItem()->filter(getFilter());
}
diff --git a/indra/llui/lllayoutstack.cpp b/indra/llui/lllayoutstack.cpp
index 955e7089f464d5b9ef43eab2dfcc9d58cb5e87d8..4a464b3507ccbd79c1b9cbf6099200ed5a7aa344 100644
--- a/indra/llui/lllayoutstack.cpp
+++ b/indra/llui/lllayoutstack.cpp
@@ -209,7 +209,7 @@ LLLayoutStack::Params::Params()
open_time_constant("open_time_constant", 0.02f),
close_time_constant("close_time_constant", 0.03f),
resize_bar_overlap("resize_bar_overlap", 1),
- border_size("border_size", LLCachedControl<S32>(*LLUI::sSettingGroups["config"], "UIResizeBarHeight", 0)),
+ border_size("border_size", LLCachedControl<S32>(*LLUI::getInstance()->mSettingGroups["config"], "UIResizeBarHeight", 0)),
show_drag_handle("show_drag_handle", false),
drag_handle_first_indent("drag_handle_first_indent", 0),
drag_handle_second_indent("drag_handle_second_indent", 0),
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
index ff8bf3031900bd5b646b4f2bfb9b68f1291b307c..3ad504d68da3b88647774489ca83a45b83fbaae0 100644
--- a/indra/llui/lllineeditor.cpp
+++ b/indra/llui/lllineeditor.cpp
@@ -941,7 +941,7 @@ void LLLineEditor::removeChar()
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
}
@@ -992,7 +992,7 @@ void LLLineEditor::addChar(const llwchar uni_char)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
getWindow()->hideCursorUntilMouseMove();
@@ -1088,7 +1088,7 @@ BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
break;
@@ -1104,7 +1104,7 @@ BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
break;
@@ -1184,7 +1184,7 @@ void LLLineEditor::cut()
if( need_to_rollback )
{
rollback.doRollback( this );
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
else
{
@@ -1288,7 +1288,7 @@ void LLLineEditor::pasteHelper(bool is_primary)
}
// Truncate the clean string at the limit of what will fit
clean_string = clean_string.substr(0, wchars_that_fit);
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
if (mMaxLengthChars)
@@ -1300,7 +1300,7 @@ void LLLineEditor::pasteHelper(bool is_primary)
clean_string = clean_string.substr(0, available_chars);
}
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
mText.insert(getCursor(), clean_string);
@@ -1312,7 +1312,7 @@ void LLLineEditor::pasteHelper(bool is_primary)
if( need_to_rollback )
{
rollback.doRollback( this );
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
else
{
@@ -1376,7 +1376,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
}
handled = TRUE;
@@ -1425,7 +1425,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
handled = TRUE;
}
@@ -1452,7 +1452,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
handled = TRUE;
}
@@ -1469,7 +1469,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
handled = TRUE;
}
@@ -1486,7 +1486,7 @@ BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
handled = TRUE;
}
@@ -1567,7 +1567,7 @@ BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask )
{
rollback.doRollback(this);
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
// Notify owner if requested
@@ -1623,7 +1623,7 @@ BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
{
rollback.doRollback( this );
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
// Notify owner if requested
@@ -1674,7 +1674,7 @@ void LLLineEditor::doDelete()
if( need_to_rollback )
{
rollback.doRollback( this );
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
else
{
@@ -2478,7 +2478,7 @@ BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
{
LLRect control_rect_screen;
localRectToScreen(getRect(), &control_rect_screen);
- LLUI::screenRectToGL(control_rect_screen, control);
+ LLUI::getInstance()->screenRectToGL(control_rect_screen, control);
}
S32 preedit_left_column, preedit_right_column;
@@ -2508,7 +2508,7 @@ BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
S32 query_local = findPixelNearestPos(query - getCursor());
S32 query_screen_x, query_screen_y;
localPointToScreen(query_local, getRect().getHeight() / 2, &query_screen_x, &query_screen_y);
- LLUI::screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
+ LLUI::getInstance()->screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
}
if (bounds)
@@ -2524,7 +2524,7 @@ BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
LLRect preedit_rect_local(preedit_left_local, getRect().getHeight(), preedit_right_local, 0);
LLRect preedit_rect_screen;
localRectToScreen(preedit_rect_local, &preedit_rect_screen);
- LLUI::screenRectToGL(preedit_rect_screen, bounds);
+ LLUI::getInstance()->screenRectToGL(preedit_rect_screen, bounds);
}
return TRUE;
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index 92543b952e8f7cfbaccb002595a3e1bb10ee2640..200dd2fdca6498230d441daad8aa5f1aa5ce1c6f 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -3263,7 +3263,7 @@ void LLMenuGL::showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y)
menu->needsArrange();
menu->arrangeAndClear();
- LLUI::getMousePositionLocal(menu->getParent(), &mouse_x, &mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(menu->getParent(), &mouse_x, &mouse_y);
LLMenuHolderGL::sContextMenuSpawnPos.set(mouse_x,mouse_y);
const LLRect menu_region_rect = LLMenuGL::sMenuContainer->getRect();
diff --git a/indra/llui/llmodaldialog.cpp b/indra/llui/llmodaldialog.cpp
index 8cf88ad5ebceba80d90c123bdb081925a4b7e2eb..5cfa8ea9738cbe7ac36678a57fd8edbca6946685 100644
--- a/indra/llui/llmodaldialog.cpp
+++ b/indra/llui/llmodaldialog.cpp
@@ -105,7 +105,7 @@ void LLModalDialog::onOpen(const LLSD& key)
// This is a modal dialog. It sucks up all mouse and keyboard operations.
gFocusMgr.setMouseCapture( this );
- LLUI::addPopup(this);
+ LLUI::getInstance()->addPopup(this);
setFocus(TRUE);
sModalStack.push_front( this );
@@ -147,7 +147,7 @@ void LLModalDialog::setVisible( BOOL visible )
gFocusMgr.setMouseCapture( this );
// The dialog view is a root view
- LLUI::addPopup(this);
+ LLUI::getInstance()->addPopup(this);
setFocus( TRUE );
}
else
@@ -165,7 +165,7 @@ BOOL LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
if (popup_menu != NULL)
{
S32 mx, my;
- LLUI::getMousePositionScreen(&mx, &my);
+ LLUI::getInstance()->getMousePositionScreen(&mx, &my);
LLRect menu_screen_rc = popup_menu->calcScreenRect();
if(!menu_screen_rc.pointInRect(mx, my))
{
@@ -202,7 +202,7 @@ BOOL LLModalDialog::handleHover(S32 x, S32 y, MASK mask)
if (popup_menu != NULL)
{
S32 mx, my;
- LLUI::getMousePositionScreen(&mx, &my);
+ LLUI::getInstance()->getMousePositionScreen(&mx, &my);
LLRect menu_screen_rc = popup_menu->calcScreenRect();
if(menu_screen_rc.pointInRect(mx, my))
{
@@ -286,7 +286,7 @@ void LLModalDialog::draw()
void LLModalDialog::centerOnScreen()
{
- LLVector2 window_size = LLUI::getWindowSize();
+ LLVector2 window_size = LLUI::getInstance()->getWindowSize();
centerWithin(LLRect(0, 0, ll_round(window_size.mV[VX]), ll_round(window_size.mV[VY])));
}
@@ -316,7 +316,7 @@ void LLModalDialog::onAppFocusGained()
// This is a modal dialog. It sucks up all mouse and keyboard operations.
gFocusMgr.setMouseCapture( instance );
instance->setFocus(TRUE);
- LLUI::addPopup(instance);
+ LLUI::getInstance()->addPopup(instance);
instance->centerOnScreen();
}
diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 7bafd711cb0223849f1936e823f092275c4ab2ec..9fc6c05ead9d5a70dcf1a52ff6c396432e2c1826 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -130,7 +130,7 @@ bool handleIgnoredNotification(const LLSD& payload)
response = pNotif->getResponseTemplate(LLNotification::WITH_DEFAULT_BUTTON);
break;
case LLNotificationForm::IGNORE_WITH_LAST_RESPONSE:
- response = LLUI::sSettingGroups["ignores"]->getLLSD("Default" + pNotif->getName());
+ response = LLUI::getInstance()->mSettingGroups["ignores"]->getLLSD("Default" + pNotif->getName());
break;
case LLNotificationForm::IGNORE_SHOW_AGAIN:
break;
@@ -197,6 +197,7 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
{
mIgnoreMsg = p.ignore.text;
+ LLUI *ui_inst = LLUI::getInstance();
if (!p.ignore.save_option)
{
mIgnore = p.ignore.session_only ? IGNORE_WITH_DEFAULT_RESPONSE_SESSION_ONLY : IGNORE_WITH_DEFAULT_RESPONSE;
@@ -205,19 +206,19 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLNotifica
{
// remember last option chosen by user and automatically respond with that in the future
mIgnore = IGNORE_WITH_LAST_RESPONSE;
- LLUI::sSettingGroups["ignores"]->declareLLSD(std::string("Default") + name, "", std::string("Default response for notification " + name));
+ ui_inst->mSettingGroups["ignores"]->declareLLSD(std::string("Default") + name, "", std::string("Default response for notification " + name));
}
BOOL show_notification = TRUE;
if (p.ignore.control.isProvided())
{
- mIgnoreSetting = LLUI::sSettingGroups["config"]->getControl(p.ignore.control);
+ mIgnoreSetting = ui_inst->mSettingGroups["config"]->getControl(p.ignore.control);
mInvertSetting = p.ignore.invert_control;
}
else
{
- LLUI::sSettingGroups["ignores"]->declareBOOL(name, show_notification, "Show notification with this name", LLControlVariable::PERSIST_NONDFT);
- mIgnoreSetting = LLUI::sSettingGroups["ignores"]->getControl(name);
+ ui_inst->mSettingGroups["ignores"]->declareBOOL(name, show_notification, "Show notification with this name", LLControlVariable::PERSIST_NONDFT);
+ mIgnoreSetting = ui_inst->mSettingGroups["ignores"]->getControl(name);
}
}
@@ -432,7 +433,7 @@ LLNotificationTemplate::LLNotificationTemplate(const LLNotificationTemplate::Par
mSoundName("")
{
if (p.sound.isProvided()
- && LLUI::sSettingGroups["config"]->controlExists(p.sound))
+ && LLUI::getInstance()->mSettingGroups["config"]->controlExists(p.sound))
{
mSoundName = p.sound;
}
@@ -700,7 +701,7 @@ void LLNotification::respond(const LLSD& response)
mForm->setIgnored(mIgnored);
if (mIgnored && mForm->getIgnoreType() == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
{
- LLUI::sSettingGroups["ignores"]->setLLSD("Default" + getName(), response);
+ LLUI::getInstance()->mSettingGroups["ignores"]->setLLSD("Default" + getName(), response);
}
}
diff --git a/indra/llui/llpanel.cpp b/indra/llui/llpanel.cpp
index ee905741617a9b7c95138b2971a97916e223664a..00da0f5fec5075786163aecff9bffa7b0066fdbc 100644
--- a/indra/llui/llpanel.cpp
+++ b/indra/llui/llpanel.cpp
@@ -609,7 +609,7 @@ std::string LLPanel::getString(const std::string& name, const LLStringUtil::form
return formatted_string.getString();
}
std::string err_str("Failed to find string " + name + " in panel " + getName()); //*TODO: Translate
- if(LLUI::sSettingGroups["config"]->getBOOL("QAMode"))
+ if(LLUI::getInstance()->mSettingGroups["config"]->getBOOL("QAMode"))
{
LL_ERRS() << err_str << LL_ENDL;
}
@@ -628,7 +628,7 @@ std::string LLPanel::getString(const std::string& name) const
return found_it->second;
}
std::string err_str("Failed to find string " + name + " in panel " + getName()); //*TODO: Translate
- if(LLUI::sSettingGroups["config"]->getBOOL("QAMode"))
+ if(LLUI::getInstance()->mSettingGroups["config"]->getBOOL("QAMode"))
{
LL_ERRS() << err_str << LL_ENDL;
}
diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp
index 76134144a0538f73ed8b384167dff0cc52532f21..b3a79bc1ebf4475549c522d1c26a92aaed4f2a2d 100644
--- a/indra/llui/llscrollbar.cpp
+++ b/indra/llui/llscrollbar.cpp
@@ -84,7 +84,7 @@ LLScrollbar::LLScrollbar(const Params & p)
mThumbImageH(p.thumb_image_horizontal),
mTrackImageV(p.track_image_vertical),
mTrackImageH(p.track_image_horizontal),
- mThickness(p.thickness.isProvided() ? p.thickness : LLUI::sSettingGroups["config"]->getS32("UIScrollbarSize")),
+ mThickness(p.thickness.isProvided() ? p.thickness : LLUI::getInstance()->mSettingGroups["config"]->getS32("UIScrollbarSize")),
mBGVisible(p.bg_visible),
mBGColor(p.bg_color)
{
@@ -488,7 +488,7 @@ void LLScrollbar::draw()
S32 local_mouse_x;
S32 local_mouse_y;
- LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
BOOL other_captor = gFocusMgr.getMouseCapture() && gFocusMgr.getMouseCapture() != this;
BOOL hovered = getEnabled() && !other_captor && (hasMouseCapture() || mThumbRect.pointInRect(local_mouse_x, local_mouse_y));
if (hovered)
@@ -645,5 +645,5 @@ void LLScrollbar::onLineDownBtnPressed( const LLSD& data )
void LLScrollbar::setThickness(S32 thickness)
{
- mThickness = thickness < 0 ? LLUI::sSettingGroups["config"]->getS32("UIScrollbarSize") : thickness;
+ mThickness = thickness < 0 ? LLUI::getInstance()->mSettingGroups["config"]->getS32("UIScrollbarSize") : thickness;
}
diff --git a/indra/llui/llspellcheck.cpp b/indra/llui/llspellcheck.cpp
index 7f64743e99070cd5d8f461d7b50ba4f6dffa96f1..296ea0907931d230e428c7e1355c578413855cc1 100644
--- a/indra/llui/llspellcheck.cpp
+++ b/indra/llui/llspellcheck.cpp
@@ -44,7 +44,6 @@ static const std::string DICT_FILE_IGNORE = "user_ignore.dic";
static const std::string DICT_FILE_MAIN = "dictionaries.xml";
static const std::string DICT_FILE_USER = "user_dictionaries.xml";
-LLSD LLSpellChecker::sDictMap;
LLSpellChecker::settings_change_signal_t LLSpellChecker::sSettingsChangeSignal;
LLSpellChecker::LLSpellChecker()
@@ -94,10 +93,9 @@ S32 LLSpellChecker::getSuggestions(const std::string& word, std::vector<std::str
return suggestions.size();
}
-// static
const LLSD LLSpellChecker::getDictionaryData(const std::string& dict_language)
{
- for (LLSD::array_const_iterator it = sDictMap.beginArray(); it != sDictMap.endArray(); ++it)
+ for (LLSD::array_const_iterator it = mDictMap.beginArray(); it != mDictMap.endArray(); ++it)
{
const LLSD& dict_entry = *it;
if (dict_language == dict_entry["language"].asString())
@@ -108,14 +106,12 @@ const LLSD LLSpellChecker::getDictionaryData(const std::string& dict_language)
return LLSD();
}
-// static
bool LLSpellChecker::hasDictionary(const std::string& dict_language, bool check_installed)
{
const LLSD dict_info = getDictionaryData(dict_language);
return dict_info.has("language") && ( (!check_installed) || (dict_info["installed"].asBoolean()) );
}
-// static
void LLSpellChecker::setDictionaryData(const LLSD& dict_info)
{
const std::string dict_language = dict_info["language"].asString();
@@ -124,7 +120,7 @@ void LLSpellChecker::setDictionaryData(const LLSD& dict_info)
return;
}
- for (LLSD::array_iterator it = sDictMap.beginArray(); it != sDictMap.endArray(); ++it)
+ for (LLSD::array_iterator it = mDictMap.beginArray(); it != mDictMap.endArray(); ++it)
{
LLSD& dict_entry = *it;
if (dict_language == dict_entry["language"].asString())
@@ -133,7 +129,7 @@ void LLSpellChecker::setDictionaryData(const LLSD& dict_info)
return;
}
}
- sDictMap.append(dict_info);
+ mDictMap.append(dict_info);
return;
}
@@ -147,14 +143,14 @@ void LLSpellChecker::refreshDictionaryMap()
std::string user_filename(user_path + DICT_FILE_MAIN);
llifstream user_file(user_filename.c_str(), std::ios::binary);
if ( (!user_file.is_open())
- || (LLSDParser::PARSE_FAILURE == LLSDSerialize::fromXMLDocument(sDictMap, user_file))
- || (0 == sDictMap.size()) )
+ || (LLSDParser::PARSE_FAILURE == LLSDSerialize::fromXMLDocument(mDictMap, user_file))
+ || (0 == mDictMap.size()) )
{
std::string app_filename(app_path + DICT_FILE_MAIN);
llifstream app_file(app_filename.c_str(), std::ios::binary);
if ( (!app_file.is_open())
- || (LLSDParser::PARSE_FAILURE == LLSDSerialize::fromXMLDocument(sDictMap, app_file))
- || (0 == sDictMap.size()) )
+ || (LLSDParser::PARSE_FAILURE == LLSDSerialize::fromXMLDocument(mDictMap, app_file))
+ || (0 == mDictMap.size()) )
{
return;
}
@@ -178,7 +174,7 @@ void LLSpellChecker::refreshDictionaryMap()
// Look for installed dictionaries
std::string tmp_app_path, tmp_user_path;
- for (LLSD::array_iterator it = sDictMap.beginArray(); it != sDictMap.endArray(); ++it)
+ for (LLSD::array_iterator it = mDictMap.beginArray(); it != mDictMap.endArray(); ++it)
{
LLSD& sdDict = *it;
tmp_app_path = (sdDict.has("name")) ? app_path + sdDict["name"].asString() : LLStringUtil::null;
@@ -416,7 +412,6 @@ bool LLSpellChecker::getUseSpellCheck()
return (LLSpellChecker::instanceExists()) && (LLSpellChecker::instance().mHunspell);
}
-// static
bool LLSpellChecker::canRemoveDictionary(const std::string& dict_language)
{
// Only user-installed inactive dictionaries can be removed
@@ -426,7 +421,6 @@ bool LLSpellChecker::canRemoveDictionary(const std::string& dict_language)
( (!getUseSpellCheck()) || (!LLSpellChecker::instance().isActiveDictionary(dict_language)) );
}
-// static
void LLSpellChecker::removeDictionary(const std::string& dict_language)
{
if (!canRemoveDictionary(dict_language))
@@ -499,12 +493,3 @@ void LLSpellChecker::setUseSpellCheck(const std::string& dict_language)
LLSpellChecker::instance().initHunspell(dict_language);
}
}
-
-// static
-void LLSpellChecker::initClass()
-{
- if (sDictMap.isUndefined())
- {
- refreshDictionaryMap();
- }
-}
diff --git a/indra/llui/llspellcheck.h b/indra/llui/llspellcheck.h
index acac589e433dd8d33c452641c1638bb751199559..f1964cc091940f6e03513f9143c79b22b5fc5e23 100644
--- a/indra/llui/llspellcheck.h
+++ b/indra/llui/llspellcheck.h
@@ -34,10 +34,9 @@
class Hunspell;
-class LLSpellChecker : public LLSingleton<LLSpellChecker>, public LLInitClass<LLSpellChecker>
+class LLSpellChecker : public LLSingleton<LLSpellChecker>
{
LLSINGLETON(LLSpellChecker);
- friend class LLInitClass<LLSpellChecker>;
~LLSpellChecker();
public:
@@ -57,26 +56,24 @@ class LLSpellChecker : public LLSingleton<LLSpellChecker>, public LLInitClass<LL
bool isActiveDictionary(const std::string& dict_language) const;
void setSecondaryDictionaries(dict_list_t dict_list);
- static bool canRemoveDictionary(const std::string& dict_language);
+ bool canRemoveDictionary(const std::string& dict_language);
static const std::string getDictionaryAppPath();
static const std::string getDictionaryUserPath();
- static const LLSD getDictionaryData(const std::string& dict_language);
- static const LLSD& getDictionaryMap() { return sDictMap; }
+ const LLSD getDictionaryData(const std::string& dict_language);
+ const LLSD& getDictionaryMap() { return mDictMap; }
static bool getUseSpellCheck();
- static bool hasDictionary(const std::string& dict_language, bool check_installed = false);
- static void refreshDictionaryMap();
- static void removeDictionary(const std::string& dict_language);
+ bool hasDictionary(const std::string& dict_language, bool check_installed = false);
+ void refreshDictionaryMap();
+ void removeDictionary(const std::string& dict_language);
static void setUseSpellCheck(const std::string& dict_language);
protected:
static LLSD loadUserDictionaryMap();
- static void setDictionaryData(const LLSD& dict_info);
+ void setDictionaryData(const LLSD& dict_info);
static void saveUserDictionaryMap(const LLSD& dict_map);
public:
typedef boost::signals2::signal<void()> settings_change_signal_t;
static boost::signals2::connection setSettingsChangeCallback(const settings_change_signal_t::slot_type& cb);
-protected:
- static void initClass();
protected:
Hunspell* mHunspell;
@@ -84,8 +81,8 @@ class LLSpellChecker : public LLSingleton<LLSpellChecker>, public LLInitClass<LL
std::string mDictFile;
dict_list_t mDictSecondary;
std::vector<std::string> mIgnoreList;
+ LLSD mDictMap;
- static LLSD sDictMap;
static settings_change_signal_t sSettingsChangeSignal;
};
diff --git a/indra/llui/llstatview.cpp b/indra/llui/llstatview.cpp
index eda2d6047f4c755686eaf954801692fd1a5bd35e..bb4969c81f1d74c2f86c206b909f6fc6872225d7 100644
--- a/indra/llui/llstatview.cpp
+++ b/indra/llui/llstatview.cpp
@@ -43,7 +43,7 @@ LLStatView::LLStatView(const LLStatView::Params& p)
BOOL isopen = getDisplayChildren();
if (mSetting.length() > 0)
{
- isopen = LLUI::sSettingGroups["config"]->getBOOL(mSetting);
+ isopen = LLUI::getInstance()->mSettingGroups["config"]->getBOOL(mSetting);
}
setDisplayChildren(isopen);
}
@@ -54,7 +54,7 @@ LLStatView::~LLStatView()
if (mSetting.length() > 0)
{
BOOL isopen = getDisplayChildren();
- LLUI::sSettingGroups["config"]->setBOOL(mSetting, isopen);
+ LLUI::getInstance()->mSettingGroups["config"]->setBOOL(mSetting, isopen);
}
}
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index a23741b6dd6d17f600579bce9f34285e98ea3c3c..22635f734e6fa213dd09751a672e7b802161a1ec 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -3246,7 +3246,7 @@ BOOL LLNormalTextSegment::handleHover(S32 x, S32 y, MASK mask)
// Only process the click if it's actually in this segment, not to the right of the end-of-line.
if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
{
- LLUI::getWindow()->setCursor(UI_CURSOR_HAND);
+ LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
return TRUE;
}
}
diff --git a/indra/llui/lltextbox.cpp b/indra/llui/lltextbox.cpp
index 9faff1278de8ffcfb3d1f3786b8d84f7034dbb73..0afd32f33279bde6fbbe67ea9d2e21e39951eaec 100644
--- a/indra/llui/lltextbox.cpp
+++ b/indra/llui/lltextbox.cpp
@@ -107,7 +107,7 @@ BOOL LLTextBox::handleHover(S32 x, S32 y, MASK mask)
if (!handled && mClickedCallback && mShowCursorHand)
{
// Clickable text boxes change the cursor to a hand
- LLUI::getWindow()->setCursor(UI_CURSOR_HAND);
+ LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
return TRUE;
}
return handled;
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index 137167db2adcdc75db2cf7a1f5b3f3cc769b5fe5..b1f8b00cab18a9f09d7b634239bc87f6111c73c2 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -1045,7 +1045,7 @@ void LLTextEditor::removeCharOrTab()
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
}
@@ -1068,7 +1068,7 @@ void LLTextEditor::removeChar()
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
}
@@ -1315,7 +1315,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
}
break;
@@ -1333,7 +1333,7 @@ BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
}
break;
@@ -1665,7 +1665,7 @@ BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask)
}
else
{
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
break;
@@ -2750,7 +2750,7 @@ BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
{
LLRect control_rect_screen;
localRectToScreen(mVisibleTextRect, &control_rect_screen);
- LLUI::screenRectToGL(control_rect_screen, control);
+ LLUI::getInstance()->screenRectToGL(control_rect_screen, control);
}
S32 preedit_left_position, preedit_right_position;
@@ -2804,7 +2804,7 @@ BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
const S32 query_y = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height - line_height / 2;
S32 query_screen_x, query_screen_y;
localPointToScreen(query_x, query_y, &query_screen_x, &query_screen_y);
- LLUI::screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
+ LLUI::getInstance()->screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
}
if (bounds)
@@ -2831,7 +2831,7 @@ BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
const LLRect preedit_rect_local(preedit_left, preedit_top, preedit_right, preedit_bottom);
LLRect preedit_rect_screen;
localRectToScreen(preedit_rect_local, &preedit_rect_screen);
- LLUI::screenRectToGL(preedit_rect_screen, bounds);
+ LLUI::getInstance()->screenRectToGL(preedit_rect_screen, bounds);
}
return TRUE;
diff --git a/indra/llui/lltextutil.cpp b/indra/llui/lltextutil.cpp
index f6b2ee1dc0942676a7aff18d3ca8037021f6913e..538508b856d98dcd29c7b8288d83f9935a117665 100644
--- a/indra/llui/lltextutil.cpp
+++ b/indra/llui/lltextutil.cpp
@@ -78,7 +78,7 @@ void LLTextUtil::textboxSetGreyedVal(LLTextBox *txtbox, const LLStyle::Params& n
const std::string& LLTextUtil::formatPhoneNumber(const std::string& phone_str)
{
- static const std::string PHONE_SEPARATOR = LLUI::sSettingGroups["config"]->getString("AvalinePhoneSeparator");
+ static const std::string PHONE_SEPARATOR = LLUI::getInstance()->mSettingGroups["config"]->getString("AvalinePhoneSeparator");
static const S32 PHONE_PART_LEN = 2;
static std::string formatted_phone_str;
diff --git a/indra/llui/lltoggleablemenu.cpp b/indra/llui/lltoggleablemenu.cpp
index ccb92ffbb2a6a944660b7cb8b52f0b949df25bba..3e56e0a589c7b7a27ae419e01ea820d2ff1080e3 100644
--- a/indra/llui/lltoggleablemenu.cpp
+++ b/indra/llui/lltoggleablemenu.cpp
@@ -55,7 +55,7 @@ boost::signals2::connection LLToggleableMenu::setVisibilityChangeCallback(const
void LLToggleableMenu::onVisibilityChange (BOOL curVisibilityIn)
{
S32 x,y;
- LLUI::getMousePositionLocal(LLUI::getRootView(), &x, &y);
+ LLUI::getInstance()->getMousePositionLocal(LLUI::getInstance()->getRootView(), &x, &y);
// STORM-1879: also check MouseCapture to see if the button was really
// clicked (otherwise the VisibilityChange was triggered via keyboard shortcut)
diff --git a/indra/llui/lltoolbar.cpp b/indra/llui/lltoolbar.cpp
index abc2b6e9cac2025efa9983566c81e7d9a81d99d1..e6f466ec784b9f1c5dbf90ede4a64d17dfd6f820 100644
--- a/indra/llui/lltoolbar.cpp
+++ b/indra/llui/lltoolbar.cpp
@@ -1125,7 +1125,7 @@ BOOL LLToolBarButton::handleHover(S32 x, S32 y, MASK mask)
BOOL handled = FALSE;
S32 mouse_distance_squared = (x - mMouseDownX) * (x - mMouseDownX) + (y - mMouseDownY) * (y - mMouseDownY);
- S32 drag_threshold = LLUI::sSettingGroups["config"]->getS32("DragAndDropDistanceThreshold");
+ S32 drag_threshold = LLUI::getInstance()->mSettingGroups["config"]->getS32("DragAndDropDistanceThreshold");
if (mouse_distance_squared > drag_threshold * drag_threshold
&& hasMouseCapture() &&
mStartDragItemCallback && mHandleDragItemCallback)
diff --git a/indra/llui/lltooltip.cpp b/indra/llui/lltooltip.cpp
index 698b128d45d079c8d7633bd38977c480000835a2..422534b781125bb4dbc0abd3b26e497c4d212476 100644
--- a/indra/llui/lltooltip.cpp
+++ b/indra/llui/lltooltip.cpp
@@ -145,10 +145,10 @@ LLToolTip::Params::Params()
wrap("wrap", true),
pos("pos"),
message("message"),
- delay_time("delay_time", LLUI::sSettingGroups["config"]->getF32( "ToolTipDelay" )),
- visible_time_over("visible_time_over", LLUI::sSettingGroups["config"]->getF32( "ToolTipVisibleTimeOver" )),
- visible_time_near("visible_time_near", LLUI::sSettingGroups["config"]->getF32( "ToolTipVisibleTimeNear" )),
- visible_time_far("visible_time_far", LLUI::sSettingGroups["config"]->getF32( "ToolTipVisibleTimeFar" )),
+ delay_time("delay_time", LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipDelay" )),
+ visible_time_over("visible_time_over", LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipVisibleTimeOver" )),
+ visible_time_near("visible_time_near", LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipVisibleTimeNear" )),
+ visible_time_far("visible_time_far", LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipVisibleTimeFar" )),
sticky_rect("sticky_rect"),
image("image"),
text_color("text_color"),
@@ -358,7 +358,7 @@ void LLToolTip::draw()
if (mFadeTimer.getStarted())
{
- F32 tool_tip_fade_time = LLUI::sSettingGroups["config"]->getF32("ToolTipFadeTime");
+ F32 tool_tip_fade_time = LLUI::getInstance()->mSettingGroups["config"]->getF32("ToolTipFadeTime");
alpha = clamp_rescale(mFadeTimer.getElapsedTimeF32(), 0.f, tool_tip_fade_time, 1.f, 0.f);
if (alpha == 0.f)
{
@@ -436,12 +436,12 @@ void LLToolTipMgr::createToolTip(const LLToolTip::Params& params)
{
LLCoordGL pos = params.pos;
// try to spawn at requested position
- LLUI::positionViewNearMouse(mToolTip, pos.mX, pos.mY);
+ LLUI::getInstance()->positionViewNearMouse(mToolTip, pos.mX, pos.mY);
}
else
{
// just spawn at mouse location
- LLUI::positionViewNearMouse(mToolTip);
+ LLUI::getInstance()->positionViewNearMouse(mToolTip);
}
//...update "sticky" rect and tooltip position
@@ -453,7 +453,7 @@ void LLToolTipMgr::createToolTip(const LLToolTip::Params& params)
{
S32 mouse_x;
S32 mouse_y;
- LLUI::getMousePositionLocal(gToolTipView->getParent(), &mouse_x, &mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(gToolTipView->getParent(), &mouse_x, &mouse_y);
// allow mouse a little bit of slop before changing tooltips
mMouseNearRect.setCenterAndSize(mouse_x, mouse_y, 3, 3);
@@ -491,7 +491,7 @@ void LLToolTipMgr::show(const LLToolTip::Params& params)
// are we ready to show the tooltip?
if (!mToolTipsBlocked // we haven't hit a key, moved the mouse, etc.
- && LLUI::getMouseIdleTime() > params_with_defaults.delay_time) // the mouse has been still long enough
+ && LLUI::getInstance()->getMouseIdleTime() > params_with_defaults.delay_time) // the mouse has been still long enough
{
bool tooltip_changed = mLastToolTipParams.message() != params_with_defaults.message()
|| mLastToolTipParams.pos() != params_with_defaults.pos()
@@ -563,7 +563,7 @@ void LLToolTipMgr::updateToolTipVisibility()
}
// hide tooltips when mouse cursor is hidden
- if (LLUI::getWindow()->isCursorHidden())
+ if (LLUI::getInstance()->getWindow()->isCursorHidden())
{
blockToolTips();
return;
@@ -574,7 +574,7 @@ void LLToolTipMgr::updateToolTipVisibility()
if (toolTipVisible())
{
S32 mouse_x, mouse_y;
- LLUI::getMousePositionLocal(gToolTipView, &mouse_x, &mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(gToolTipView, &mouse_x, &mouse_y);
// mouse far away from tooltip
tooltip_timeout = mLastToolTipParams.visible_time_far;
diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
index 52190a1473075551889137246b77aba583448583..656b69d3ed50ba0d3d9876a23afff9d3fbe94431 100644
--- a/indra/llui/llui.cpp
+++ b/indra/llui/llui.cpp
@@ -75,19 +75,6 @@
// Language for UI construction
std::map<std::string, std::string> gTranslation;
std::list<std::string> gUntranslated;
-/*static*/ LLUI::settings_map_t LLUI::sSettingGroups;
-/*static*/ LLUIAudioCallback LLUI::sAudioCallback = NULL;
-/*static*/ LLUIAudioCallback LLUI::sDeferredAudioCallback = NULL;
-/*static*/ LLWindow* LLUI::sWindow = NULL;
-/*static*/ LLView* LLUI::sRootView = NULL;
-/*static*/ BOOL LLUI::sDirty = FALSE;
-/*static*/ LLRect LLUI::sDirtyRect;
-/*static*/ LLHelp* LLUI::sHelpImpl = NULL;
-/*static*/ std::vector<std::string> LLUI::sXUIPaths;
-/*static*/ LLFrameTimer LLUI::sMouseIdleTimer;
-/*static*/ LLUI::add_popup_t LLUI::sAddPopupFunc;
-/*static*/ LLUI::remove_popup_t LLUI::sRemovePopupFunc;
-/*static*/ LLUI::clear_popups_t LLUI::sClearPopupsFunc;
// register filter editor here
static LLDefaultChildRegistry::Register<LLFilterEditor> register_filter_editor("filter_editor");
@@ -106,18 +93,19 @@ LLUUID find_ui_sound(const char * namep)
{
std::string name = ll_safe_string(namep);
LLUUID uuid = LLUUID(NULL);
- if (!LLUI::sSettingGroups["config"]->controlExists(name))
+ LLUI *ui_inst = LLUI::getInstance();
+ if (!ui_inst->mSettingGroups["config"]->controlExists(name))
{
LL_WARNS() << "tried to make UI sound for unknown sound name: " << name << LL_ENDL;
}
else
{
- uuid = LLUUID(LLUI::sSettingGroups["config"]->getString(name));
+ uuid = LLUUID(ui_inst->mSettingGroups["config"]->getString(name));
if (uuid.isNull())
{
- if (LLUI::sSettingGroups["config"]->getString(name) == LLUUID::null.asString())
+ if (ui_inst->mSettingGroups["config"]->getString(name) == LLUUID::null.asString())
{
- if (LLUI::sSettingGroups["config"]->getBOOL("UISndDebugSpamToggle"))
+ if (ui_inst->mSettingGroups["config"]->getBOOL("UISndDebugSpamToggle"))
{
LL_INFOS() << "UI sound name: " << name << " triggered but silent (null uuid)" << LL_ENDL;
}
@@ -127,9 +115,9 @@ LLUUID find_ui_sound(const char * namep)
LL_WARNS() << "UI sound named: " << name << " does not translate to a valid uuid" << LL_ENDL;
}
}
- else if (LLUI::sAudioCallback != NULL)
+ else if (ui_inst->mAudioCallback != NULL)
{
- if (LLUI::sSettingGroups["config"]->getBOOL("UISndDebugSpamToggle"))
+ if (ui_inst->mSettingGroups["config"]->getBOOL("UISndDebugSpamToggle"))
{
LL_INFOS() << "UI sound name: " << name << LL_ENDL;
}
@@ -144,7 +132,7 @@ void make_ui_sound(const char* namep)
LLUUID soundUUID = find_ui_sound(namep);
if(soundUUID.notNull())
{
- LLUI::sAudioCallback(soundUUID);
+ LLUI::getInstance()->mAudioCallback(soundUUID);
}
}
@@ -153,30 +141,31 @@ void make_ui_sound_deferred(const char* namep)
LLUUID soundUUID = find_ui_sound(namep);
if(soundUUID.notNull())
{
- LLUI::sDeferredAudioCallback(soundUUID);
+ LLUI::getInstance()->mDeferredAudioCallback(soundUUID);
}
}
-void LLUI::initClass(const settings_map_t& settings,
- LLImageProviderInterface* image_provider,
- LLUIAudioCallback audio_callback,
- LLUIAudioCallback deferred_audio_callback,
- const LLVector2* scale_factor,
- const std::string& language)
+LLUI::LLUI(const settings_map_t& settings,
+ LLImageProviderInterface* image_provider,
+ LLUIAudioCallback audio_callback,
+ LLUIAudioCallback deferred_audio_callback)
+: mSettingGroups(settings),
+mAudioCallback(audio_callback),
+mDeferredAudioCallback(deferred_audio_callback),
+mWindow(NULL), // set later in startup
+mRootView(NULL),
+mDirty(FALSE),
+mHelpImpl(NULL)
{
- LLRender2D::initClass(image_provider,scale_factor);
- sSettingGroups = settings;
+ LLRender2D::initParamSingleton(image_provider);
- if ((get_ptr_in_map(sSettingGroups, std::string("config")) == NULL) ||
- (get_ptr_in_map(sSettingGroups, std::string("floater")) == NULL) ||
- (get_ptr_in_map(sSettingGroups, std::string("ignores")) == NULL))
+ if ((get_ptr_in_map(mSettingGroups, std::string("config")) == NULL) ||
+ (get_ptr_in_map(mSettingGroups, std::string("floater")) == NULL) ||
+ (get_ptr_in_map(mSettingGroups, std::string("ignores")) == NULL))
{
LL_ERRS() << "Failure to initialize configuration groups" << LL_ENDL;
}
- sAudioCallback = audio_callback;
- sDeferredAudioCallback = deferred_audio_callback;
- sWindow = NULL; // set later in startup
LLFontGL::sShadowColor = LLUIColorTable::instance().getColor("ColorDropShadow");
LLUICtrl::CommitCallbackRegistry::Registrar& reg = LLUICtrl::CommitCallbackRegistry::defaultRegistrar();
@@ -207,33 +196,26 @@ void LLUI::initClass(const settings_map_t& settings,
LLCommandManager::load();
}
-void LLUI::cleanupClass()
-{
- SUBSYSTEM_CLEANUP(LLRender2D);
-}
-
void LLUI::setPopupFuncs(const add_popup_t& add_popup, const remove_popup_t& remove_popup, const clear_popups_t& clear_popups)
{
- sAddPopupFunc = add_popup;
- sRemovePopupFunc = remove_popup;
- sClearPopupsFunc = clear_popups;
+ mAddPopupFunc = add_popup;
+ mRemovePopupFunc = remove_popup;
+ mClearPopupsFunc = clear_popups;
}
-//static
void LLUI::dirtyRect(LLRect rect)
{
- if (!sDirty)
+ if (!mDirty)
{
- sDirtyRect = rect;
- sDirty = TRUE;
+ mDirtyRect = rect;
+ mDirty = TRUE;
}
else
{
- sDirtyRect.unionWith(rect);
- }
+ mDirtyRect.unionWith(rect);
+ }
}
-
-//static
+
void LLUI::setMousePositionScreen(S32 x, S32 y)
{
#if defined(LL_DARWIN)
@@ -247,7 +229,6 @@ void LLUI::setMousePositionScreen(S32 x, S32 y)
LLView::getWindow()->setCursorPosition(LLCoordGL(screen_x, screen_y).convert());
}
-//static
void LLUI::getMousePositionScreen(S32 *x, S32 *y)
{
LLCoordWindow cursor_pos_window;
@@ -257,7 +238,6 @@ void LLUI::getMousePositionScreen(S32 *x, S32 *y)
*y = ll_round((F32)cursor_pos_gl.mY / getScaleFactor().mV[VY]);
}
-//static
void LLUI::setMousePositionLocal(const LLView* viewp, S32 x, S32 y)
{
S32 screen_x, screen_y;
@@ -266,7 +246,6 @@ void LLUI::setMousePositionLocal(const LLView* viewp, S32 x, S32 y)
setMousePositionScreen(screen_x, screen_y);
}
-//static
void LLUI::getMousePositionLocal(const LLView* viewp, S32 *x, S32 *y)
{
S32 screen_x, screen_y;
@@ -280,20 +259,19 @@ void LLUI::getMousePositionLocal(const LLView* viewp, S32 *x, S32 *y)
// or on Windows if the SecondLife.exe executable is run directly, the
// language follows the OS language. In all cases the user can override
// the language manually in preferences. JC
-// static
-std::string LLUI::getLanguage()
+std::string LLUI::getUILanguage()
{
std::string language = "en";
- if (sSettingGroups["config"])
+ if (mSettingGroups["config"])
{
- language = sSettingGroups["config"]->getString("Language");
+ language = mSettingGroups["config"]->getString("Language");
if (language.empty() || language == "default")
{
- language = sSettingGroups["config"]->getString("InstallLanguage");
+ language = mSettingGroups["config"]->getString("InstallLanguage");
}
if (language.empty() || language == "default")
{
- language = sSettingGroups["config"]->getString("SystemLanguage");
+ language = mSettingGroups["config"]->getString("SystemLanguage");
}
if (language.empty() || language == "default")
{
@@ -303,6 +281,13 @@ std::string LLUI::getLanguage()
return language;
}
+// static
+std::string LLUI::getLanguage()
+{
+ // Note: lldateutil_test redefines this function
+ return LLUI::getInstance()->getUILanguage();
+}
+
struct SubDir : public LLInitParam::Block<SubDir>
{
Mandatory<std::string> value;
@@ -362,37 +347,32 @@ std::string LLUI::locateSkin(const std::string& filename)
return "";
}
-//static
LLVector2 LLUI::getWindowSize()
{
LLCoordWindow window_rect;
- sWindow->getSize(&window_rect);
+ mWindow->getSize(&window_rect);
return LLVector2(window_rect.mX / getScaleFactor().mV[VX], window_rect.mY / getScaleFactor().mV[VY]);
}
-//static
void LLUI::screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y)
{
*gl_x = ll_round((F32)screen_x * getScaleFactor().mV[VX]);
*gl_y = ll_round((F32)screen_y * getScaleFactor().mV[VY]);
}
-//static
void LLUI::glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y)
{
*screen_x = ll_round((F32)gl_x / getScaleFactor().mV[VX]);
*screen_y = ll_round((F32)gl_y / getScaleFactor().mV[VY]);
}
-//static
void LLUI::screenRectToGL(const LLRect& screen, LLRect *gl)
{
screenPointToGL(screen.mLeft, screen.mTop, &gl->mLeft, &gl->mTop);
screenPointToGL(screen.mRight, screen.mBottom, &gl->mRight, &gl->mBottom);
}
-//static
void LLUI::glRectToScreen(const LLRect& gl, LLRect *screen)
{
glPointToScreen(gl.mLeft, gl.mTop, &screen->mLeft, &screen->mTop);
@@ -402,8 +382,8 @@ void LLUI::glRectToScreen(const LLRect& gl, LLRect *screen)
LLControlGroup& LLUI::getControlControlGroup (const std::string& controlname)
{
- for (settings_map_t::iterator itor = sSettingGroups.begin();
- itor != sSettingGroups.end(); ++itor)
+ for (settings_map_t::iterator itor = mSettingGroups.begin();
+ itor != mSettingGroups.end(); ++itor)
{
LLControlGroup* control_group = itor->second;
if(control_group != NULL)
@@ -413,43 +393,38 @@ LLControlGroup& LLUI::getControlControlGroup (const std::string& controlname)
}
}
- return *sSettingGroups["config"]; // default group
+ return *mSettingGroups["config"]; // default group
}
-//static
void LLUI::addPopup(LLView* viewp)
{
- if (sAddPopupFunc)
+ if (mAddPopupFunc)
{
- sAddPopupFunc(viewp);
+ mAddPopupFunc(viewp);
}
}
-//static
void LLUI::removePopup(LLView* viewp)
{
- if (sRemovePopupFunc)
+ if (mRemovePopupFunc)
{
- sRemovePopupFunc(viewp);
+ mRemovePopupFunc(viewp);
}
}
-//static
void LLUI::clearPopups()
{
- if (sClearPopupsFunc)
+ if (mClearPopupsFunc)
{
- sClearPopupsFunc();
+ mClearPopupsFunc();
}
}
-//static
void LLUI::reportBadKeystroke()
{
make_ui_sound("UISndBadKeystroke");
}
-
-//static
+
// spawn_x and spawn_y are top left corner of view in screen GL coordinates
void LLUI::positionViewNearMouse(LLView* view, S32 spawn_x, S32 spawn_y)
{
@@ -460,7 +435,7 @@ void LLUI::positionViewNearMouse(LLView* view, S32 spawn_x, S32 spawn_y)
S32 mouse_x;
S32 mouse_y;
- LLUI::getMousePositionScreen(&mouse_x, &mouse_y);
+ getMousePositionScreen(&mouse_x, &mouse_y);
// If no spawn location provided, use mouse position
if (spawn_x == S32_MAX || spawn_y == S32_MAX)
diff --git a/indra/llui/llui.h b/indra/llui/llui.h
index d7151dbee9939fd0ecf9af5d65e5646394e00833..e1c51deba9aa0897afff8bc72dccd02c888ed1cf 100644
--- a/indra/llui/llui.h
+++ b/indra/llui/llui.h
@@ -109,8 +109,16 @@ class LLImageProviderInterface;
typedef void (*LLUIAudioCallback)(const LLUUID& uuid);
-class LLUI
+class LLUI : public LLParamSingleton<LLUI>
{
+public:
+ typedef std::map<std::string, LLControlGroup*> settings_map_t;
+
+private:
+ LLSINGLETON(LLUI , const settings_map_t &settings,
+ LLImageProviderInterface* image_provider,
+ LLUIAudioCallback audio_callback,
+ LLUIAudioCallback deferred_audio_callback);
LOG_CLASS(LLUI);
public:
//
@@ -232,36 +240,24 @@ class LLUI
//
// Methods
//
- typedef std::map<std::string, LLControlGroup*> settings_map_t;
typedef boost::function<void(LLView*)> add_popup_t;
typedef boost::function<void(LLView*)> remove_popup_t;
typedef boost::function<void(void)> clear_popups_t;
- static void initClass(const settings_map_t& settings,
- LLImageProviderInterface* image_provider,
- LLUIAudioCallback audio_callback = NULL,
- LLUIAudioCallback deferred_audio_callback = NULL,
- const LLVector2 *scale_factor = NULL,
- const std::string& language = LLStringUtil::null);
- static void cleanupClass();
- static void setPopupFuncs(const add_popup_t& add_popup, const remove_popup_t&, const clear_popups_t& );
-
- static void pushMatrix() { LLRender2D::pushMatrix(); }
- static void popMatrix() { LLRender2D::popMatrix(); }
- static void loadIdentity() { LLRender2D::loadIdentity(); }
- static void translate(F32 x, F32 y, F32 z = 0.0f) { LLRender2D::translate(x, y, z); }
+ void setPopupFuncs(const add_popup_t& add_popup, const remove_popup_t&, const clear_popups_t& );
- static LLRect sDirtyRect;
- static BOOL sDirty;
- static void dirtyRect(LLRect rect);
+ LLRect mDirtyRect;
+ BOOL mDirty;
+ void dirtyRect(LLRect rect);
// Return the ISO639 language name ("en", "ko", etc.) for the viewer UI.
// http://www.loc.gov/standards/iso639-2/php/code_list.php
- static std::string getLanguage();
+ std::string getUILanguage();
+ static std::string getLanguage(); // static for lldateutil_test compatibility
//helper functions (should probably move free standing rendering helper functions here)
- static LLView* getRootView() { return sRootView; }
- static void setRootView(LLView* view) { sRootView = view; }
+ LLView* getRootView() { return mRootView; }
+ void setRootView(LLView* view) { mRootView = view; }
/**
* Walk the LLView tree to resolve a path
* Paths can be discovered using Develop > XUI > Show XUI Paths
@@ -287,58 +283,65 @@ class LLUI
* tree, the first "bar" anywhere under it, and "baz"
* as a direct child of that
*/
- static const LLView* resolvePath(const LLView* context, const std::string& path);
- static LLView* resolvePath(LLView* context, const std::string& path);
+ const LLView* resolvePath(const LLView* context, const std::string& path);
+ LLView* resolvePath(LLView* context, const std::string& path);
static std::string locateSkin(const std::string& filename);
- static void setMousePositionScreen(S32 x, S32 y);
- static void getMousePositionScreen(S32 *x, S32 *y);
- static void setMousePositionLocal(const LLView* viewp, S32 x, S32 y);
- static void getMousePositionLocal(const LLView* viewp, S32 *x, S32 *y);
- static LLVector2& getScaleFactor() { return LLRender2D::sGLScaleFactor; }
- static void setScaleFactor(const LLVector2& scale_factor) { LLRender2D::setScaleFactor(scale_factor); }
- static void setLineWidth(F32 width) { LLRender2D::setLineWidth(width); }
- static LLPointer<LLUIImage> getUIImageByID(const LLUUID& image_id, S32 priority = 0)
- { return LLRender2D::getUIImageByID(image_id, priority); }
- static LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority = 0)
- { return LLRender2D::getUIImage(name, priority); }
- static LLVector2 getWindowSize();
- static void screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y);
- static void glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y);
- static void screenRectToGL(const LLRect& screen, LLRect *gl);
- static void glRectToScreen(const LLRect& gl, LLRect *screen);
+ void setMousePositionScreen(S32 x, S32 y);
+ void getMousePositionScreen(S32 *x, S32 *y);
+ void setMousePositionLocal(const LLView* viewp, S32 x, S32 y);
+ void getMousePositionLocal(const LLView* viewp, S32 *x, S32 *y);
+ LLVector2 getWindowSize();
+ void screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y);
+ void glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y);
+ void screenRectToGL(const LLRect& screen, LLRect *gl);
+ void glRectToScreen(const LLRect& gl, LLRect *screen);
// Returns the control group containing the control name, or the default group
- static LLControlGroup& getControlControlGroup (const std::string& controlname);
- static F32 getMouseIdleTime() { return sMouseIdleTimer.getElapsedTimeF32(); }
- static void resetMouseIdleTimer() { sMouseIdleTimer.reset(); }
- static LLWindow* getWindow() { return sWindow; }
+ LLControlGroup& getControlControlGroup (const std::string& controlname);
+ F32 getMouseIdleTime() { return mMouseIdleTimer.getElapsedTimeF32(); }
+ void resetMouseIdleTimer() { mMouseIdleTimer.reset(); }
+ LLWindow* getWindow() { return mWindow; }
- static void addPopup(LLView*);
- static void removePopup(LLView*);
- static void clearPopups();
+ void addPopup(LLView*);
+ void removePopup(LLView*);
+ void clearPopups();
- static void reportBadKeystroke();
+ void reportBadKeystroke();
// Ensures view does not overlap mouse cursor, but is inside
// the view's parent rectangle. Used for tooltips, inspectors.
// Optionally override the view's default X/Y, which are relative to the
// view's parent.
- static void positionViewNearMouse(LLView* view, S32 spawn_x = S32_MAX, S32 spawn_y = S32_MAX);
+ void positionViewNearMouse(LLView* view, S32 spawn_x = S32_MAX, S32 spawn_y = S32_MAX);
+
+ // LLRender2D wrappers
+ static void pushMatrix() { LLRender2D::getInstance()->pushMatrix(); }
+ static void popMatrix() { LLRender2D::getInstance()->popMatrix(); }
+ static void loadIdentity() { LLRender2D::getInstance()->loadIdentity(); }
+ static void translate(F32 x, F32 y, F32 z = 0.0f) { LLRender2D::getInstance()->translate(x, y, z); }
+
+ static LLVector2& getScaleFactor() { return LLRender2D::getInstance()->mGLScaleFactor; }
+ static void setScaleFactor(const LLVector2& scale_factor) { LLRender2D::getInstance()->setScaleFactor(scale_factor); }
+ static void setLineWidth(F32 width) { LLRender2D::getInstance()->setLineWidth(width); }
+ static LLPointer<LLUIImage> getUIImageByID(const LLUUID& image_id, S32 priority = 0)
+ { return LLRender2D::getInstance()->getUIImageByID(image_id, priority); }
+ static LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority = 0)
+ { return LLRender2D::getInstance()->getUIImage(name, priority); }
//
// Data
//
- static settings_map_t sSettingGroups;
- static LLUIAudioCallback sAudioCallback;
- static LLUIAudioCallback sDeferredAudioCallback;
- static LLWindow* sWindow;
- static LLView* sRootView;
- static LLHelp* sHelpImpl;
+ settings_map_t mSettingGroups;
+ LLUIAudioCallback mAudioCallback;
+ LLUIAudioCallback mDeferredAudioCallback;
+ LLWindow* mWindow;
+ LLView* mRootView;
+ LLHelp* mHelpImpl;
private:
- static std::vector<std::string> sXUIPaths;
- static LLFrameTimer sMouseIdleTimer;
- static add_popup_t sAddPopupFunc;
- static remove_popup_t sRemovePopupFunc;
- static clear_popups_t sClearPopupsFunc;
+ std::vector<std::string> mXUIPaths;
+ LLFrameTimer mMouseIdleTimer;
+ add_popup_t mAddPopupFunc;
+ remove_popup_t mRemovePopupFunc;
+ clear_popups_t mClearPopupsFunc;
};
@@ -363,7 +366,7 @@ class LLUICachedControl : public LLCachedControl<T>
LLUICachedControl(const std::string& name,
const T& default_value,
const std::string& comment = "Declared In Code")
- : LLCachedControl<T>(LLUI::getControlControlGroup(name), name, default_value, comment)
+ : LLCachedControl<T>(LLUI::getInstance()->getControlControlGroup(name), name, default_value, comment)
{}
};
diff --git a/indra/llui/llurlentry.cpp b/indra/llui/llurlentry.cpp
index cd9b52d1641380735c13e1093adebc749d3a0ac9..63ed427ab582334d7c8fe2f94c1466c6ec7f1179 100644
--- a/indra/llui/llurlentry.cpp
+++ b/indra/llui/llurlentry.cpp
@@ -176,7 +176,7 @@ void LLUrlEntryBase::callObservers(const std::string &id,
bool LLUrlEntryBase::isLinkDisabled() const
{
// this allows us to have a global setting to turn off text hyperlink highlighting/action
- bool globally_disabled = LLUI::sSettingGroups["config"]->getBOOL("DisableTextHyperlinkActions");
+ bool globally_disabled = LLUI::getInstance()->mSettingGroups["config"]->getBOOL("DisableTextHyperlinkActions");
return globally_disabled;
}
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 89ad8138d89749cdbee477ef540f98edf7f1ec57..2a190365b3e4d94a6230af95ba6a3ebe8aa31cf4 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -816,7 +816,7 @@ LLView* LLView::childrenHandleHover(S32 x, S32 y, MASK mask)
}
// This call differentiates this method from childrenHandleMouseEvent().
- LLUI::sWindow->setCursor(viewp->getHoverCursor());
+ LLUI::getInstance()->mWindow->setCursor(viewp->getHoverCursor());
if (viewp->handleHover(local_x, local_y, mask)
|| viewp->blockMouseEvent(local_x, local_y))
@@ -873,8 +873,8 @@ BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
// allow "scrubbing" over ui by showing next tooltip immediately
// if previous one was still visible
F32 timeout = LLToolTipMgr::instance().toolTipVisible()
- ? LLUI::sSettingGroups["config"]->getF32( "ToolTipFastDelay" )
- : LLUI::sSettingGroups["config"]->getF32( "ToolTipDelay" );
+ ? LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipFastDelay" )
+ : LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipDelay" );
LLToolTipMgr::instance().show(LLToolTip::Params()
.message(tooltip)
.sticky_rect(calcScreenRect())
@@ -1142,7 +1142,7 @@ void LLView::drawChildren()
{
if (!mChildList.empty())
{
- LLView* rootp = LLUI::getRootView();
+ LLView* rootp = LLUI::getInstance()->getRootView();
++sDepth;
for (child_list_reverse_iter_t child_iter = mChildList.rbegin(); child_iter != mChildList.rend();) // ++child_iter)
@@ -1158,7 +1158,7 @@ void LLView::drawChildren()
if (viewp->getVisible() && viewp->getRect().isValid())
{
LLRect screen_rect = viewp->calcScreenRect();
- if ( rootp->getLocalRect().overlaps(screen_rect) && LLUI::sDirtyRect.overlaps(screen_rect))
+ if ( rootp->getLocalRect().overlaps(screen_rect) && LLUI::getInstance()->mDirtyRect.overlaps(screen_rect))
{
LLUI::pushMatrix();
{
@@ -1200,7 +1200,7 @@ void LLView::dirtyRect()
parent = parent->getParent();
}
- LLUI::dirtyRect(cur->calcScreenRect());
+ LLUI::getInstance()->dirtyRect(cur->calcScreenRect());
}
//Draw a box for debugging.
@@ -2223,9 +2223,9 @@ LLControlVariable *LLView::findControl(const std::string& name)
std::string control_group_key = name.substr(0, key_pos);
LLControlVariable* control;
// check if it's in the control group that name indicated
- if(LLUI::sSettingGroups[control_group_key])
+ if(LLUI::getInstance()->mSettingGroups[control_group_key])
{
- control = LLUI::sSettingGroups[control_group_key]->getControl(name);
+ control = LLUI::getInstance()->mSettingGroups[control_group_key]->getControl(name);
if (control)
{
return control;
@@ -2233,7 +2233,7 @@ LLControlVariable *LLView::findControl(const std::string& name)
}
}
- LLControlGroup& control_group = LLUI::getControlControlGroup(name);
+ LLControlGroup& control_group = LLUI::getInstance()->getControlControlGroup(name);
return control_group.getControl(name);
}
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
index 8494bb338adfa4e9e2dbc19821177089280e11d0..e36ca7c8c691a4abb83d92677bc678d8e7012de7 100644
--- a/indra/llui/llview.h
+++ b/indra/llui/llview.h
@@ -498,7 +498,7 @@ class LLView
// return query for iterating over focus roots in tab order
static const LLViewQuery & getFocusRootsQuery();
- static LLWindow* getWindow(void) { return LLUI::sWindow; }
+ static LLWindow* getWindow(void) { return LLUI::getInstance()->mWindow; }
// Set up params after XML load before calling new(),
// usually to adjust layout.
diff --git a/indra/llui/llviewereventrecorder.cpp b/indra/llui/llviewereventrecorder.cpp
index 8754cfebbb466a7b193e956eb88417c87c908ad5..cb000aef74fd8166189431f35a18e0231c69e0bf 100644
--- a/indra/llui/llviewereventrecorder.cpp
+++ b/indra/llui/llviewereventrecorder.cpp
@@ -44,7 +44,7 @@ LLViewerEventRecorder::LLViewerEventRecorder() {
bool LLViewerEventRecorder::displayViewerEventRecorderMenuItems() {
- return LLUI::sSettingGroups["config"]->getBOOL("ShowEventRecorderMenuItems");
+ return LLUI::getInstance()->mSettingGroups["config"]->getBOOL("ShowEventRecorderMenuItems");
}
@@ -99,7 +99,7 @@ void LLViewerEventRecorder::setMouseGlobalCoords(S32 x, S32 y) {
void LLViewerEventRecorder::updateMouseEventInfo(S32 local_x, S32 local_y, S32 global_x, S32 global_y, std::string mName) {
- LLView * target_view = LLUI::resolvePath(LLUI::getRootView(), xui);
+ LLView * target_view = LLUI::getInstance()->resolvePath(LLUI::getInstance()->getRootView(), xui);
if (! target_view) {
LL_DEBUGS() << "LLViewerEventRecorder::updateMouseEventInfo - xui path on file at moment is NOT valid - so DO NOT record these local coords" << LL_ENDL;
return;
@@ -216,7 +216,7 @@ void LLViewerEventRecorder::playbackRecording() {
LLSD LeapCommand;
// ivita sets this on startup, it also sends commands to the viewer to make start, stop, and playback menu items visible in viewer
- LeapCommand =LLUI::sSettingGroups["config"]->getLLSD("LeapPlaybackEventsCommand");
+ LeapCommand =LLUI::getInstance()->mSettingGroups["config"]->getLLSD("LeapPlaybackEventsCommand");
LL_DEBUGS() << "[VITA] launching playback - leap command is: " << LLSDXMLStreamer(LeapCommand) << LL_ENDL;
LLLeap::create("", LeapCommand, false); // exception=false
diff --git a/indra/llui/llviewinject.h b/indra/llui/llviewinject.h
index 0de3d155c41ba819b491ac4d93e1ed894e587c04..7f18ec6fbe8fce6fbc9ecb2d92992f59bf3625fe 100644
--- a/indra/llui/llviewinject.h
+++ b/indra/llui/llviewinject.h
@@ -32,7 +32,7 @@ namespace llview
public:
/**
* Construct TargetEvent with the desired target LLView*. (See
- * LLUI::resolvePath() to obtain an LLView* given a string pathname.)
+ * LLUI::getInstance()->resolvePath() to obtain an LLView* given a string pathname.)
* This sets up for operator().
*/
TargetEvent(LLView* view);
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index b8789da66bc128912d7210daa873c3edbe4bcd9f..694e89ab99bfcfaa67222e341e74ff3f1186c0ed 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -1377,8 +1377,12 @@ if (DARWIN)
PROPERTIES
COMPILE_DEFINITIONS "${VIEWER_CHANNEL_VERSION_DEFINES}"
# BugsplatMac is a module, imported with @import. That language feature
- # demands these switches.
- COMPILE_FLAGS "-fmodules -fcxx-modules"
+ # demands these -f switches.
+ # Xcode 10.2 requires that Objective-C++ headers declare nullability of
+ # pointer variables. As of 2019-06-26, the BugsplatMac version we're using
+ # does not yet do so in its own header files. This -W flag prevents fatal
+ # warnings.
+ COMPILE_FLAGS "-fmodules -fcxx-modules -Wno-nullability-completeness"
)
find_library(AGL_LIBRARY AGL)
diff --git a/indra/newview/VIEWER_VERSION.txt b/indra/newview/VIEWER_VERSION.txt
index 7849b73dc743d35ec7fbe7b500244979ac719e04..b98d1d3fa746f67079f0a6fc24649c7aff21ddea 100644
--- a/indra/newview/VIEWER_VERSION.txt
+++ b/indra/newview/VIEWER_VERSION.txt
@@ -1 +1 @@
-6.3.3
+6.3.5
diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp
index 92a30260964a2fe8aeb7a63b83672106c3dadf72..0b4b848014e400fe14b882f4caa619f64c3e280f 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -1140,7 +1140,7 @@ void LLAgentCamera::updateCamera()
mCameraUpVector = mCameraUpVector * gAgentAvatarp->getRenderRotation();
}
- if (cameraThirdPerson() && (mFocusOnAvatar || mAllowChangeToFollow) && LLFollowCamMgr::getActiveFollowCamParams())
+ if (cameraThirdPerson() && (mFocusOnAvatar || mAllowChangeToFollow) && LLFollowCamMgr::getInstance()->getActiveFollowCamParams())
{
mAllowChangeToFollow = FALSE;
mFocusOnAvatar = TRUE;
@@ -1240,7 +1240,7 @@ void LLAgentCamera::updateCamera()
// *TODO: use combined rotation of frameagent and sit object
LLQuaternion avatarRotationForFollowCam = gAgentAvatarp->isSitting() ? gAgentAvatarp->getRenderRotation() : gAgent.getFrameAgent().getQuaternion();
- LLFollowCamParams* current_cam = LLFollowCamMgr::getActiveFollowCamParams();
+ LLFollowCamParams* current_cam = LLFollowCamMgr::getInstance()->getActiveFollowCamParams();
if (current_cam)
{
mFollowCam.copyParams(*current_cam);
@@ -2046,7 +2046,7 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
// Menus should not remain open on switching to mouselook...
LLMenuGL::sMenuContainer->hideMenus();
- LLUI::clearPopups();
+ LLUI::getInstance()->clearPopups();
// unpause avatar animation
gAgent.unpauseAnimation();
@@ -2100,7 +2100,7 @@ void LLAgentCamera::changeCameraToDefault()
return;
}
- if (LLFollowCamMgr::getActiveFollowCamParams())
+ if (LLFollowCamMgr::getInstance()->getActiveFollowCamParams())
{
changeCameraToFollow();
}
diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index 22bcbad7da211e8c054e6bcc17cf12bae798d023..7325ec598a17ed1977a8b49b8694c7056569da69 100644
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -148,7 +148,7 @@ class LLAppearanceHandler : public LLCommandHandler
{
// support secondlife:///app/appearance/show, but for now we just
// make all secondlife:///app/appearance SLapps behave this way
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableAppearance"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableAppearance"))
{
LLNotificationsUtil::add("NoAppearance", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index c8dcbb87c1aa9544bce6ebfed6fa3cf877c56b12..ff897ef9624739691e3550988c885aff3368d4ec 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -100,7 +100,6 @@
#include "llscenemonitor.h"
#include "llavatarrenderinfoaccountant.h"
#include "lllocalbitmaps.h"
-#include "llskinningutil.h"
// Linden library includes
#include "llavatarnamecache.h"
@@ -774,7 +773,7 @@ bool LLAppViewer::init()
// initialize LLWearableType translation bridge.
// Memory will be cleaned up in ::cleanupClass()
- LLWearableType::initClass(new LLUITranslationBridge());
+ LLWearableType::initParamSingleton(new LLUITranslationBridge());
// initialize SSE options
LLVector4a::initClass();
@@ -798,9 +797,6 @@ bool LLAppViewer::init()
LL_INFOS("InitInfo") << "Configuration initialized." << LL_ENDL ;
- // initialize skinning util
- LLSkinningUtil::initClass();
-
//set the max heap size.
initMaxHeapSize() ;
LLCoros::instance().setStackSize(gSavedSettings.getS32("CoroutineStackSize"));
@@ -848,11 +844,10 @@ bool LLAppViewer::init()
settings_map["floater"] = &gSavedSettings; // *TODO: New settings file
settings_map["account"] = &gSavedPerAccountSettings;
- LLUI::initClass(settings_map,
+ LLUI::initParamSingleton(settings_map,
LLUIImageList::getInstance(),
ui_audio_callback,
- deferred_ui_audio_callback,
- &LLUI::getScaleFactor());
+ deferred_ui_audio_callback);
LL_INFOS("InitInfo") << "UI initialized." << LL_ENDL ;
// NOW LLUI::getLanguage() should work. gDirUtilp must know the language
@@ -896,8 +891,6 @@ bool LLAppViewer::init()
// LLKeyboard relies on LLUI to know what some accelerator keys are called.
LLKeyboard::setStringTranslatorFunc( LLTrans::getKeyboardString );
- LLWeb::initClass(); // do this after LLUI
-
// Provide the text fields with callbacks for opening Urls
LLUrlAction::setOpenURLCallback(boost::bind(&LLWeb::loadURL, _1, LLStringUtil::null, LLStringUtil::null));
LLUrlAction::setOpenURLInternalCallback(boost::bind(&LLWeb::loadURLInternal, _1, LLStringUtil::null, LLStringUtil::null, false));
@@ -905,7 +898,7 @@ bool LLAppViewer::init()
LLUrlAction::setExecuteSLURLCallback(&LLURLDispatcher::dispatchFromTextEditor);
// Let code in llui access the viewer help floater
- LLUI::sHelpImpl = LLViewerHelp::getInstance();
+ LLUI::getInstance()->mHelpImpl = LLViewerHelp::getInstance();
LL_INFOS("InitInfo") << "UI initialization is done." << LL_ENDL ;
@@ -1211,9 +1204,6 @@ bool LLAppViewer::init()
<< LL_ENDL;
}
- LLViewerMedia::initClass();
- LL_INFOS("InitInfo") << "Viewer media initialized." << LL_ENDL ;
-
LLTextUtil::TextHelpers::iconCallbackCreationFunction = create_text_segment_icon_from_url_match;
//EXT-7013 - On windows for some locale (Japanese) standard
@@ -1253,7 +1243,7 @@ bool LLAppViewer::init()
// Note: this is where gLocalSpeakerMgr and gActiveSpeakerMgr used to be instantiated.
LLVoiceChannel::initClass();
- LLVoiceClient::getInstance()->init(gServicePump);
+ LLVoiceClient::initParamSingleton(gServicePump);
LLVoiceChannel::setCurrentVoiceChannelChangedCallback(boost::bind(&LLFloaterIMContainer::onCurrentChannelChanged, _1), true);
joystick = LLViewerJoystick::getInstance();
@@ -1750,8 +1740,6 @@ bool LLAppViewer::cleanup()
gTransferManager.cleanup();
#endif
- SUBSYSTEM_CLEANUP(LLLocalBitmapMgr);
-
// Note: this is where gWorldMap used to be deleted.
// Note: this is where gHUDManager used to be deleted.
@@ -1894,12 +1882,9 @@ bool LLAppViewer::cleanup()
//end_messaging_system();
- SUBSYSTEM_CLEANUP(LLFollowCamMgr);
- //SUBSYSTEM_CLEANUP(LLVolumeMgr);
LLPrimitive::cleanupVolumeManager();
SUBSYSTEM_CLEANUP(LLWorldMapView);
SUBSYSTEM_CLEANUP(LLFolderViewItem);
- SUBSYSTEM_CLEANUP(LLUI);
//
// Shut down the VFS's AFTER the decode manager cleans up (since it cleans up vfiles).
@@ -2049,13 +2034,10 @@ bool LLAppViewer::cleanup()
//Note:
//SUBSYSTEM_CLEANUP(LLViewerMedia) has to be put before gTextureList.shutdown()
//because some new image might be generated during cleaning up media. --bao
- SUBSYSTEM_CLEANUP(LLViewerMedia);
- SUBSYSTEM_CLEANUP(LLViewerParcelMedia);
gTextureList.shutdown(); // shutdown again in case a callback added something
LLUIImageList::getInstance()->cleanUp();
// This should eventually be done in LLAppViewer
- SUBSYSTEM_CLEANUP(LLImage);
SUBSYSTEM_CLEANUP(LLVFSThread);
SUBSYSTEM_CLEANUP(LLLFSThread);
@@ -2103,8 +2085,6 @@ bool LLAppViewer::cleanup()
SUBSYSTEM_CLEANUP(LLProxy);
LLCore::LLHttp::cleanup();
- SUBSYSTEM_CLEANUP(LLWearableType);
-
LLMainLoopRepeater::instance().stop();
ll_close_fail_log();
@@ -2163,7 +2143,7 @@ bool LLAppViewer::initThreads()
{
static const bool enable_threads = true;
- LLImage::initClass(gSavedSettings.getBOOL("TextureNewByteRange"),gSavedSettings.getS32("TextureReverseByteRange"));
+ LLImage::initParamSingleton(gSavedSettings.getBOOL("TextureNewByteRange"),gSavedSettings.getS32("TextureReverseByteRange"));
LLVFSThread::initClass(enable_threads && false);
LLLFSThread::initClass(enable_threads && false);
@@ -3047,7 +3027,7 @@ bool LLAppViewer::initWindow()
gViewerWindow->getWindow()->maximize();
}
- LLUI::sWindow = gViewerWindow->getWindow();
+ LLUI::getInstance()->mWindow = gViewerWindow->getWindow();
// Show watch cursor
gViewerWindow->setCursor(UI_CURSOR_WAIT);
@@ -4146,7 +4126,7 @@ bool LLAppViewer::initCache()
mPurgeCache = false;
BOOL read_only = mSecondInstance ? TRUE : FALSE;
LLAppViewer::getTextureCache()->setReadOnly(read_only) ;
- LLVOCache::getInstance()->setReadOnly(read_only);
+ LLVOCache::initParamSingleton(read_only);
bool texture_cache_mismatch = false;
if (gSavedSettings.getS32("LocalCacheVersion") != LLAppViewer::getTextureCacheVersion())
@@ -4218,7 +4198,8 @@ bool LLAppViewer::initCache()
S64 extra = LLAppViewer::getTextureCache()->initCache(LL_PATH_CACHE, texture_cache_size, texture_cache_mismatch);
texture_cache_size -= extra;
- LLVOCache::getInstance()->initCache(LL_PATH_CACHE, gSavedSettings.getU32("CacheNumberOfRegionsForObjects"), getObjectCacheVersion()) ;
+
+ LLVOCache::getInstance()->initCache(LL_PATH_CACHE, gSavedSettings.getU32("CacheNumberOfRegionsForObjects"), getObjectCacheVersion());
LLSplashScreen::update(LLTrans::getString("StartupInitializingVFS"));
@@ -4548,7 +4529,7 @@ void LLAppViewer::loadNameCache()
llifstream name_cache_stream(filename.c_str());
if(name_cache_stream.is_open())
{
- if ( ! LLAvatarNameCache::importFile(name_cache_stream))
+ if ( ! LLAvatarNameCache::getInstance()->importFile(name_cache_stream))
{
LL_WARNS("AppInit") << "removing invalid '" << filename << "'" << LL_ENDL;
name_cache_stream.close();
@@ -4575,7 +4556,7 @@ void LLAppViewer::saveNameCache()
llofstream name_cache_stream(filename.c_str());
if(name_cache_stream.is_open())
{
- LLAvatarNameCache::exportFile(name_cache_stream);
+ LLAvatarNameCache::getInstance()->exportFile(name_cache_stream);
}
// real names cache
@@ -5182,7 +5163,8 @@ void LLAppViewer::idleNameCache()
// granted to neighbor regions before the main agent gets there. Can't
// do it in the move-into-region code because cap not guaranteed to be
// granted yet, for example on teleport.
- bool had_capability = LLAvatarNameCache::hasNameLookupURL();
+ LLAvatarNameCache *name_cache = LLAvatarNameCache::getInstance();
+ bool had_capability = LLAvatarNameCache::getInstance()->hasNameLookupURL();
std::string name_lookup_url;
name_lookup_url.reserve(128); // avoid a memory allocation below
name_lookup_url = region->getCapability("GetDisplayNames");
@@ -5199,12 +5181,12 @@ void LLAppViewer::idleNameCache()
{
name_lookup_url += '/';
}
- LLAvatarNameCache::setNameLookupURL(name_lookup_url);
+ name_cache->setNameLookupURL(name_lookup_url);
}
else
{
// Display names not available on this region
- LLAvatarNameCache::setNameLookupURL( std::string() );
+ name_cache->setNameLookupURL( std::string() );
}
// Error recovery - did we change state?
@@ -5214,7 +5196,7 @@ void LLAppViewer::idleNameCache()
LLVOAvatar::invalidateNameTags();
}
- LLAvatarNameCache::idle();
+ name_cache->idle();
}
//
diff --git a/indra/newview/llavatarlist.cpp b/indra/newview/llavatarlist.cpp
index 513f25e3017cd2795ae16c1698fc7d63d325a7c3..b0715a3afd38e54e22a6905e6371a6d684d00fee 100644
--- a/indra/newview/llavatarlist.cpp
+++ b/indra/newview/llavatarlist.cpp
@@ -154,7 +154,7 @@ LLAvatarList::LLAvatarList(const Params& p)
mLITUpdateTimer->start();
}
- LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLAvatarList::handleDisplayNamesOptionChanged, this));
+ LLAvatarNameCache::getInstance()->addUseDisplayNamesCallback(boost::bind(&LLAvatarList::handleDisplayNamesOptionChanged, this));
}
diff --git a/indra/newview/llbrowsernotification.cpp b/indra/newview/llbrowsernotification.cpp
index 19747757dbcc13b4af68d5f039a5470d61764784..0460bff1b4859f923f7b8a584ee5a5318fcf1a9a 100644
--- a/indra/newview/llbrowsernotification.cpp
+++ b/indra/newview/llbrowsernotification.cpp
@@ -50,7 +50,7 @@ bool LLBrowserNotification::processNotification(const LLNotificationPtr& notific
}
else if (LLViewerMediaFocus::instance().getControlsMediaID() == media_id)
{
- LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(media_id);
+ LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(media_id);
if (impl)
{
impl->showNotification(notification);
diff --git a/indra/newview/llchannelmanager.cpp b/indra/newview/llchannelmanager.cpp
index d6240838b6eca6da33174638a3ff837580a14b70..0b7b9cbbc7aef373ff5a50e735dd34be8c922627 100644
--- a/indra/newview/llchannelmanager.cpp
+++ b/indra/newview/llchannelmanager.cpp
@@ -58,15 +58,22 @@ LLChannelManager::LLChannelManager()
//--------------------------------------------------------------------------
LLChannelManager::~LLChannelManager()
{
- for(std::vector<ChannelElem>::iterator it = mChannelList.begin(); it != mChannelList.end(); ++it)
- {
- LLScreenChannelBase* channel = it->channel.get();
- if (!channel) continue;
+}
- delete channel;
- }
+//--------------------------------------------------------------------------
+void LLChannelManager::cleanupSingleton()
+{
+ // Note: LLScreenChannelBase is a LLUICtrl and depends onto other singletions
+ // not captured by singleton-dependency, so cleanup it here instead of destructor
+ for (std::vector<ChannelElem>::iterator it = mChannelList.begin(); it != mChannelList.end(); ++it)
+ {
+ LLScreenChannelBase* channel = it->channel.get();
+ if (!channel) continue;
- mChannelList.clear();
+ delete channel;
+ }
+
+ mChannelList.clear();
}
//--------------------------------------------------------------------------
diff --git a/indra/newview/llchannelmanager.h b/indra/newview/llchannelmanager.h
index 8b9d0dda8b6ca2158b3e90bdec497039bc397fe6..8abe350196bd9630de2a4e6de8e3f4591d95f423 100644
--- a/indra/newview/llchannelmanager.h
+++ b/indra/newview/llchannelmanager.h
@@ -46,6 +46,7 @@ class LLChannelManager : public LLSingleton<LLChannelManager>
LLSINGLETON(LLChannelManager);
virtual ~LLChannelManager();
+ void cleanupSingleton();
public:
diff --git a/indra/newview/llconversationlog.cpp b/indra/newview/llconversationlog.cpp
index 9ccf9b98f734eabab2158fb41abca9b171ca4b6d..f7c61efce07dc93bf1c1fe76ccb62d5190467a10 100644
--- a/indra/newview/llconversationlog.cpp
+++ b/indra/newview/llconversationlog.cpp
@@ -189,16 +189,6 @@ LLConversationLog::LLConversationLog() :
mAvatarNameCacheConnection(),
mLoggingEnabled(false)
{
- if(gSavedPerAccountSettings.controlExists("KeepConversationLogTranscripts"))
- {
- LLControlVariable * keep_log_ctrlp = gSavedPerAccountSettings.getControl("KeepConversationLogTranscripts").get();
- S32 log_mode = keep_log_ctrlp->getValue();
- keep_log_ctrlp->getSignal()->connect(boost::bind(&LLConversationLog::enableLogging, this, _2));
- if (log_mode > 0)
- {
- enableLogging(log_mode);
- }
- }
}
void LLConversationLog::enableLogging(S32 log_mode)
@@ -443,6 +433,20 @@ bool LLConversationLog::moveLog(const std::string &originDirectory, const std::s
return true;
}
+void LLConversationLog::initLoggingState()
+{
+ if (gSavedPerAccountSettings.controlExists("KeepConversationLogTranscripts"))
+ {
+ LLControlVariable * keep_log_ctrlp = gSavedPerAccountSettings.getControl("KeepConversationLogTranscripts").get();
+ S32 log_mode = keep_log_ctrlp->getValue();
+ keep_log_ctrlp->getSignal()->connect(boost::bind(&LLConversationLog::enableLogging, this, _2));
+ if (log_mode > 0)
+ {
+ enableLogging(log_mode);
+ }
+ }
+}
+
std::string LLConversationLog::getFileName()
{
std::string filename = "conversation";
diff --git a/indra/newview/llconversationlog.h b/indra/newview/llconversationlog.h
index 035cbcb9451e7eb41be8747176b15ece750f84eb..46e46a3278b6c4c843b286054f56e21bf071bf3a 100644
--- a/indra/newview/llconversationlog.h
+++ b/indra/newview/llconversationlog.h
@@ -111,7 +111,6 @@ class LLConversationLog : public LLSingleton<LLConversationLog>, LLIMSessionObse
{
LLSINGLETON(LLConversationLog);
public:
-
void removeConversation(const LLConversation& conversation);
/**
@@ -148,6 +147,12 @@ class LLConversationLog : public LLSingleton<LLConversationLog>, LLIMSessionObse
bool getIsLoggingEnabled() { return mLoggingEnabled; }
bool isLogEmpty() { return mConversations.empty(); }
+ /**
+ * inits connection to per account settings,
+ * loads saved file and inits enabled state
+ */
+ void initLoggingState();
+
/**
* constructs file name in which conversations log will be saved
* file name is conversation.log
diff --git a/indra/newview/lldonotdisturbnotificationstorage.cpp b/indra/newview/lldonotdisturbnotificationstorage.cpp
index 7d2712eec708f611338e0bae252facb0a078f8a8..cb5f9c8a2c98cb0ce48e1212c4130db8dc7cc8f7 100644
--- a/indra/newview/lldonotdisturbnotificationstorage.cpp
+++ b/indra/newview/lldonotdisturbnotificationstorage.cpp
@@ -48,7 +48,6 @@ const char * LLDoNotDisturbNotificationStorage::offerName = "UserGiveItem";
LLDoNotDisturbNotificationStorageTimer::LLDoNotDisturbNotificationStorageTimer() : LLEventTimer(DND_TIMER)
{
-
}
LLDoNotDisturbNotificationStorageTimer::~LLDoNotDisturbNotificationStorageTimer()
@@ -74,6 +73,7 @@ LLDoNotDisturbNotificationStorage::LLDoNotDisturbNotificationStorage()
{
nameToPayloadParameterMap[toastName] = "SESSION_ID";
nameToPayloadParameterMap[offerName] = "object_id";
+ initialize();
}
LLDoNotDisturbNotificationStorage::~LLDoNotDisturbNotificationStorage()
diff --git a/indra/newview/lldonotdisturbnotificationstorage.h b/indra/newview/lldonotdisturbnotificationstorage.h
index e6cb7835e311b4277df3daf26c2363c3e8d29b62..c6f0bf1ab588ddd63fd52324bdf91f7dcd9d3516 100644
--- a/indra/newview/lldonotdisturbnotificationstorage.h
+++ b/indra/newview/lldonotdisturbnotificationstorage.h
@@ -45,7 +45,7 @@ class LLDoNotDisturbNotificationStorageTimer : public LLEventTimer
BOOL tick();
};
-class LLDoNotDisturbNotificationStorage : public LLSingleton<LLDoNotDisturbNotificationStorage>, public LLNotificationStorage
+class LLDoNotDisturbNotificationStorage : public LLParamSingleton<LLDoNotDisturbNotificationStorage>, public LLNotificationStorage
{
LLSINGLETON(LLDoNotDisturbNotificationStorage);
~LLDoNotDisturbNotificationStorage();
@@ -55,7 +55,6 @@ class LLDoNotDisturbNotificationStorage : public LLSingleton<LLDoNotDisturbNotif
static const char * toastName;
static const char * offerName;
- void initialize();
bool getDirty();
void resetDirty();
void saveNotifications();
@@ -66,6 +65,8 @@ class LLDoNotDisturbNotificationStorage : public LLSingleton<LLDoNotDisturbNotif
protected:
private:
+ void initialize();
+
bool mDirty;
LLDoNotDisturbNotificationStorageTimer mTimer;
diff --git a/indra/newview/llexpandabletextbox.cpp b/indra/newview/llexpandabletextbox.cpp
index d657f04457ab937c3070a1a41e703099d847af82..3395777aab42424db453fa9314140951e6814f46 100644
--- a/indra/newview/llexpandabletextbox.cpp
+++ b/indra/newview/llexpandabletextbox.cpp
@@ -97,7 +97,7 @@ class LLExpanderSegment : public LLTextSegment
/*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask) { mEditor.onCommit(); return TRUE; }
/*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask)
{
- LLUI::getWindow()->setCursor(UI_CURSOR_HAND);
+ LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
return TRUE;
}
private:
diff --git a/indra/newview/llexternaleditor.cpp b/indra/newview/llexternaleditor.cpp
index 776bbf78c2a8dd2ce28d27551c742df42e559207..b66eb754a48c684aea5279944b89106b18a0e326 100644
--- a/indra/newview/llexternaleditor.cpp
+++ b/indra/newview/llexternaleditor.cpp
@@ -184,9 +184,9 @@ std::string LLExternalEditor::findCommand(
cmd = override;
LL_INFOS() << "Using override" << LL_ENDL;
}
- else if (!LLUI::sSettingGroups["config"]->getString(sSetting).empty())
+ else if (!LLUI::getInstance()->mSettingGroups["config"]->getString(sSetting).empty())
{
- cmd = LLUI::sSettingGroups["config"]->getString(sSetting);
+ cmd = LLUI::getInstance()->mSettingGroups["config"]->getString(sSetting);
LL_INFOS() << "Using setting" << LL_ENDL;
}
else // otherwise use the path specified by the environment variable
diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp
index 912bde9986bf2363d3fc1a1f0f465aa7ae883eae..1587903a1517e6b9fd9fb60f167bda344fb0574e 100644
--- a/indra/newview/llface.cpp
+++ b/indra/newview/llface.cpp
@@ -228,12 +228,6 @@ void LLFace::destroy()
mVObjp = NULL;
}
-
-// static
-void LLFace::initClass()
-{
-}
-
void LLFace::setWorldMatrix(const LLMatrix4 &mat)
{
LL_ERRS() << "Faces on this drawable are not independently modifiable\n" << LL_ENDL;
diff --git a/indra/newview/llface.h b/indra/newview/llface.h
index a08e730e54c4beaf68ce059440a116db63f9af02..77861f7d2f9016b21e1f2e5e53b9236d6f5e836f 100644
--- a/indra/newview/llface.h
+++ b/indra/newview/llface.h
@@ -80,8 +80,6 @@ class LLFace : public LLTrace::MemTrackableNonVirtual<LLFace, 16>
PARTICLE = 0x0080,
};
- static void initClass();
-
static void cacheFaceInVRAM(const LLVolumeFace& vf);
public:
diff --git a/indra/newview/llfeaturemanager.cpp b/indra/newview/llfeaturemanager.cpp
index 8d07035b97d85dcc528472db0d2b2c42b04b0d8e..aa9cba0c188b650e1527e53e7f5d61cfd91d4815 100644
--- a/indra/newview/llfeaturemanager.cpp
+++ b/indra/newview/llfeaturemanager.cpp
@@ -522,7 +522,7 @@ void LLFeatureManager::cleanupFeatureTables()
mMaskList.clear();
}
-void LLFeatureManager::init()
+void LLFeatureManager::initSingleton()
{
// load the tables
loadFeatureTables();
diff --git a/indra/newview/llfeaturemanager.h b/indra/newview/llfeaturemanager.h
index f77861a1a754f4efa001027f946ac55897000d46..42a226cd18f843bdc40ed58e07f30543e58eedc4 100644
--- a/indra/newview/llfeaturemanager.h
+++ b/indra/newview/llfeaturemanager.h
@@ -100,9 +100,10 @@ class LLFeatureManager : public LLFeatureList, public LLSingleton<LLFeatureManag
LLSINGLETON(LLFeatureManager);
~LLFeatureManager() {cleanupFeatureTables();}
-public:
// initialize this by loading feature table and gpu table
- void init();
+ void initSingleton();
+
+public:
void maskCurrentList(const std::string& name); // Mask the current feature list with the named list
diff --git a/indra/newview/llfirstuse.cpp b/indra/newview/llfirstuse.cpp
index 2e1afc68b40427407430d97a731f5c37e508db0f..1ce9fe3a7ad0a27d47f5a024bf80ac98bae382a4 100644
--- a/indra/newview/llfirstuse.cpp
+++ b/indra/newview/llfirstuse.cpp
@@ -40,37 +40,6 @@
#include "lltracker.h"
-// static
-std::set<std::string> LLFirstUse::sConfigVariables;
-
-// static
-void LLFirstUse::addConfigVariable(const std::string& var)
-{
- sConfigVariables.insert(var);
-}
-
-// static
-void LLFirstUse::disableFirstUse()
-{
- // Set all first-use warnings to disabled
- for (std::set<std::string>::iterator iter = sConfigVariables.begin();
- iter != sConfigVariables.end(); ++iter)
- {
- gWarningSettings.setBOOL(*iter, FALSE);
- }
-}
-
-// static
-void LLFirstUse::resetFirstUse()
-{
- // Set all first-use warnings to disabled
- for (std::set<std::string>::iterator iter = sConfigVariables.begin();
- iter != sConfigVariables.end(); ++iter)
- {
- gWarningSettings.setBOOL(*iter, TRUE);
- }
-}
-
// static
void LLFirstUse::otherAvatarChatFirst(bool enable)
{
diff --git a/indra/newview/llfirstuse.h b/indra/newview/llfirstuse.h
index 4c8c9d3cde6b00fd622014652d3cedc13e45b95f..80b83580b389ebaa0bc8f3ff424771c9f6cf3433 100644
--- a/indra/newview/llfirstuse.h
+++ b/indra/newview/llfirstuse.h
@@ -78,14 +78,6 @@ class LLNotification;
class LLFirstUse
{
public:
-
- // Add a config variable to be reset on resetFirstUse()
- static void addConfigVariable(const std::string& var);
-
- // Sets all controls back to show the dialogs.
- static void disableFirstUse();
- static void resetFirstUse();
-
static void otherAvatarChatFirst(bool enable = true);
static void speak(bool enable = true);
static void sit(bool enable = true);
@@ -100,7 +92,6 @@ class LLFirstUse
protected:
static void firstUseNotification(const std::string& control_var, bool enable, const std::string& notification_name, LLSD args = LLSD(), LLSD payload = LLSD());
- static std::set<std::string> sConfigVariables;
static void init();
static bool processNotification(const LLSD& notify);
diff --git a/indra/newview/llfloaterbvhpreview.cpp b/indra/newview/llfloaterbvhpreview.cpp
index 080d0ed8ea914b30ee3697c176fc8a2eabad8338..ee7e6f85621d745265b972d1c41b0c4d6d582164 100644
--- a/indra/newview/llfloaterbvhpreview.cpp
+++ b/indra/newview/llfloaterbvhpreview.cpp
@@ -527,7 +527,7 @@ BOOL LLFloaterBvhPreview::handleHover(S32 x, S32 y, MASK mask)
mAnimPreview->requestUpdate();
- LLUI::setMousePositionLocal(this, mLastMouseX, mLastMouseY);
+ LLUI::getInstance()->setMousePositionLocal(this, mLastMouseX, mLastMouseY);
}
if (!mPreviewRect.pointInRect(x, y) || !mAnimPreview)
diff --git a/indra/newview/llfloatercamera.cpp b/indra/newview/llfloatercamera.cpp
index 20d650fa37187d3a97d98695e8402d2cef5a8bc8..f3406d93bb11ed388397ac50f1ad032d34d73a9b 100644
--- a/indra/newview/llfloatercamera.cpp
+++ b/indra/newview/llfloatercamera.cpp
@@ -351,7 +351,7 @@ LLFloaterCamera::LLFloaterCamera(const LLSD& val)
mCurrMode(CAMERA_CTRL_MODE_PAN),
mPrevMode(CAMERA_CTRL_MODE_PAN)
{
- LLHints::registerHintTarget("view_popup", getHandle());
+ LLHints::getInstance()->registerHintTarget("view_popup", getHandle());
mCommitCallbackRegistrar.add("CameraPresets.ChangeView", boost::bind(&LLFloaterCamera::onClickCameraItem, _2));
}
diff --git a/indra/newview/llfloaterchatvoicevolume.cpp b/indra/newview/llfloaterchatvoicevolume.cpp
index 3c76a3a43cdfc1627d748cbef99e5b78a99ec603..45aea00a49e3a31f5fe1ef65b836e0ece56e88f1 100644
--- a/indra/newview/llfloaterchatvoicevolume.cpp
+++ b/indra/newview/llfloaterchatvoicevolume.cpp
@@ -35,7 +35,7 @@ LLFloaterChatVoiceVolume::LLFloaterChatVoiceVolume(const LLSD& key)
void LLFloaterChatVoiceVolume::onOpen(const LLSD& key)
{
LLInspect::onOpen(key);
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
}
LLFloaterChatVoiceVolume::~LLFloaterChatVoiceVolume()
diff --git a/indra/newview/llfloaterconversationpreview.cpp b/indra/newview/llfloaterconversationpreview.cpp
index 66198b3bf68475fa989e448645d0b761b1afea69..55561fa1281c35bb39b9c2d93bfb874a979c1eb9 100644
--- a/indra/newview/llfloaterconversationpreview.cpp
+++ b/indra/newview/llfloaterconversationpreview.cpp
@@ -111,7 +111,7 @@ void LLFloaterConversationPreview::setPages(std::list<LLSD>* messages, const std
getChild<LLTextBox>("page_num_label")->setValue(total_page_num);
mShowHistory = true;
}
- LLLoadHistoryThread* loadThread = LLLogChat::getLoadHistoryThread(mSessionID);
+ LLLoadHistoryThread* loadThread = LLLogChat::getInstance()->getLoadHistoryThread(mSessionID);
if (loadThread)
{
loadThread->removeLoadEndSignal(boost::bind(&LLFloaterConversationPreview::setPages, this, _1, _2));
@@ -135,7 +135,7 @@ void LLFloaterConversationPreview::onOpen(const LLSD& key)
return;
}
mOpened = true;
- if (!LLLogChat::historyThreadsFinished(mSessionID))
+ if (!LLLogChat::getInstance()->historyThreadsFinished(mSessionID))
{
LLNotificationsUtil::add("ChatHistoryIsBusyAlert");
mHistoryThreadsBusy = true;
@@ -165,15 +165,16 @@ void LLFloaterConversationPreview::onOpen(const LLSD& key)
// LLDeleteHistoryThread is started in destructor
std::list<LLSD>* messages = new std::list<LLSD>();
- LLLogChat::cleanupHistoryThreads();
+ LLLogChat *log_chat_inst = LLLogChat::getInstance();
+ log_chat_inst->cleanupHistoryThreads();
LLLoadHistoryThread* loadThread = new LLLoadHistoryThread(mChatHistoryFileName, messages, load_params);
loadThread->setLoadEndSignal(boost::bind(&LLFloaterConversationPreview::setPages, this, _1, _2));
loadThread->start();
- LLLogChat::addLoadHistoryThread(mSessionID, loadThread);
+ log_chat_inst->addLoadHistoryThread(mSessionID, loadThread);
LLDeleteHistoryThread* deleteThread = new LLDeleteHistoryThread(messages, loadThread);
- LLLogChat::addDeleteHistoryThread(mSessionID, deleteThread);
+ log_chat_inst->addDeleteHistoryThread(mSessionID, deleteThread);
mShowHistory = true;
}
@@ -183,7 +184,7 @@ void LLFloaterConversationPreview::onClose(bool app_quitting)
mOpened = false;
if (!mHistoryThreadsBusy)
{
- LLDeleteHistoryThread* deleteThread = LLLogChat::getDeleteHistoryThread(mSessionID);
+ LLDeleteHistoryThread* deleteThread = LLLogChat::getInstance()->getDeleteHistoryThread(mSessionID);
if (deleteThread)
{
deleteThread->start();
@@ -221,7 +222,7 @@ void LLFloaterConversationPreview::showHistory()
else
{
std::string legacy_name = gCacheName->buildLegacyName(from);
- from_id = LLAvatarNameCache::findIdByName(legacy_name);
+ from_id = LLAvatarNameCache::getInstance()->findIdByName(legacy_name);
}
LLChat chat;
diff --git a/indra/newview/llfloaterimagepreview.cpp b/indra/newview/llfloaterimagepreview.cpp
index 3c428a70f30b86bdf5abaa6f7062ada259560005..d4b0fa85ab71162c9549f4777a98cdf9fa52f2ce 100644
--- a/indra/newview/llfloaterimagepreview.cpp
+++ b/indra/newview/llfloaterimagepreview.cpp
@@ -503,7 +503,7 @@ BOOL LLFloaterImagePreview::handleHover(S32 x, S32 y, MASK mask)
mSculptedPreview->refresh();
}
- LLUI::setMousePositionLocal(this, mLastMouseX, mLastMouseY);
+ LLUI::getInstance()->setMousePositionLocal(this, mLastMouseX, mLastMouseY);
}
if (!mPreviewRect.pointInRect(x, y) || !mAvatarPreview || !mSculptedPreview)
diff --git a/indra/newview/llfloaterimcontainer.cpp b/indra/newview/llfloaterimcontainer.cpp
index 30d05ae2875b3230055272d8ec851e413a352c46..21420b122b8ead0d1db60d868cef5b0b15d3b6c5 100644
--- a/indra/newview/llfloaterimcontainer.cpp
+++ b/indra/newview/llfloaterimcontainer.cpp
@@ -237,7 +237,7 @@ BOOL LLFloaterIMContainer::postBuild()
collapseMessagesPane(gSavedPerAccountSettings.getBOOL("ConversationsMessagePaneCollapsed"));
collapseConversationsPane(gSavedPerAccountSettings.getBOOL("ConversationsListPaneCollapsed"), false);
- LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLFloaterIMSessionTab::processChatHistoryStyleUpdate, false));
+ LLAvatarNameCache::getInstance()->addUseDisplayNamesCallback(boost::bind(&LLFloaterIMSessionTab::processChatHistoryStyleUpdate, false));
mMicroChangedSignal = LLVoiceClient::getInstance()->MicroChangedCallback(boost::bind(&LLFloaterIMContainer::updateSpeakBtnState, this));
if (! mMessagesPane->isCollapsed() && ! mConversationsPane->isCollapsed())
@@ -267,7 +267,7 @@ BOOL LLFloaterIMContainer::postBuild()
// We'll take care of view updates on idle
gIdleCallbacks.addFunction(idle, this);
// When display name option change, we need to reload all participant names
- LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLFloaterIMContainer::processParticipantsStyleUpdate, this));
+ LLAvatarNameCache::getInstance()->addUseDisplayNamesCallback(boost::bind(&LLFloaterIMContainer::processParticipantsStyleUpdate, this));
mParticipantRefreshTimer.setTimerExpirySec(0);
mParticipantRefreshTimer.start();
diff --git a/indra/newview/llfloaterimnearbychat.cpp b/indra/newview/llfloaterimnearbychat.cpp
index f9efd136088cdc67cfb4b6460229eabf3668f942..a6531ed7e1b9ae3acd7b1bb6597dd6d1bae59e79 100644
--- a/indra/newview/llfloaterimnearbychat.cpp
+++ b/indra/newview/llfloaterimnearbychat.cpp
@@ -228,7 +228,7 @@ void LLFloaterIMNearbyChat::loadHistory()
else
{
std::string legacy_name = gCacheName->buildLegacyName(from);
- from_id = LLAvatarNameCache::findIdByName(legacy_name);
+ from_id = LLAvatarNameCache::getInstance()->findIdByName(legacy_name);
}
LLChat chat;
diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp
index cb58cfdd0aafb30acc5d229fc3de9a2e14c0fd0c..b6efc1590ea3ec51d40fa3908510850b65df024c 100644
--- a/indra/newview/llfloatermodelpreview.cpp
+++ b/indra/newview/llfloatermodelpreview.cpp
@@ -806,7 +806,7 @@ BOOL LLFloaterModelPreview::handleHover (S32 x, S32 y, MASK mask)
mModelPreview->refresh();
- LLUI::setMousePositionLocal(this, mLastMouseX, mLastMouseY);
+ LLUI::getInstance()->setMousePositionLocal(this, mLastMouseX, mLastMouseY);
}
if (!mPreviewRect.pointInRect(x, y) || !mModelPreview)
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 64961fc99ca2c34d28b2286337b1d0df57ab1ea8..fe347a91a301e2f328c4f7cd22ef977840de035b 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -254,8 +254,8 @@ bool callback_clear_browser_cache(const LLSD& notification, const LLSD& response
if ( option == 0 ) // YES
{
// clean web
- LLViewerMedia::clearAllCaches();
- LLViewerMedia::clearAllCookies();
+ LLViewerMedia::getInstance()->clearAllCaches();
+ LLViewerMedia::getInstance()->clearAllCookies();
// clean nav bar history
LLNavigationBar::getInstance()->clearHistoryCache();
@@ -278,13 +278,13 @@ bool callback_clear_browser_cache(const LLSD& notification, const LLSD& response
void handleNameTagOptionChanged(const LLSD& newvalue)
{
- LLAvatarNameCache::setUseUsernames(gSavedSettings.getBOOL("NameTagShowUsernames"));
+ LLAvatarNameCache::getInstance()->setUseUsernames(gSavedSettings.getBOOL("NameTagShowUsernames"));
LLVOAvatar::invalidateNameTags();
}
void handleDisplayNamesOptionChanged(const LLSD& newvalue)
{
- LLAvatarNameCache::setUseDisplayNames(newvalue.asBoolean());
+ LLAvatarNameCache::getInstance()->setUseDisplayNames(newvalue.asBoolean());
LLVOAvatar::invalidateNameTags();
}
@@ -523,7 +523,7 @@ BOOL LLFloaterPreference::postBuild()
// set 'enable' property for 'Clear log...' button
changed();
- LLLogChat::setSaveHistorySignal(boost::bind(&LLFloaterPreference::onLogChatHistorySaved, this));
+ LLLogChat::getInstance()->setSaveHistorySignal(boost::bind(&LLFloaterPreference::onLogChatHistorySaved, this));
LLSliderCtrl* fov_slider = getChild<LLSliderCtrl>("camera_fov");
fov_slider->setMinValue(LLViewerCamera::getInstance()->getMinView());
@@ -635,14 +635,14 @@ void LLFloaterPreference::apply()
std::string cache_location = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "");
setCacheLocation(cache_location);
- LLViewerMedia::setCookiesEnabled(getChild<LLUICtrl>("cookies_enabled")->getValue());
+ LLViewerMedia::getInstance()->setCookiesEnabled(getChild<LLUICtrl>("cookies_enabled")->getValue());
if (hasChild("web_proxy_enabled", TRUE) &&hasChild("web_proxy_editor", TRUE) && hasChild("web_proxy_port", TRUE))
{
bool proxy_enable = getChild<LLUICtrl>("web_proxy_enabled")->getValue();
std::string proxy_address = getChild<LLUICtrl>("web_proxy_editor")->getValue();
int proxy_port = getChild<LLUICtrl>("web_proxy_port")->getValue();
- LLViewerMedia::setProxyConfig(proxy_enable, proxy_address, proxy_port);
+ LLViewerMedia::getInstance()->setProxyConfig(proxy_enable, proxy_address, proxy_port);
}
if (mGotPersonalInfo)
@@ -1234,7 +1234,7 @@ void LLFloaterPreference::buildPopupLists()
{
if (ignore == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
{
- LLSD last_response = LLUI::sSettingGroups["config"]->getLLSD("Default" + templatep->mName);
+ LLSD last_response = LLUI::getInstance()->mSettingGroups["config"]->getLLSD("Default" + templatep->mName);
if (!last_response.isUndefined())
{
for (LLSD::map_const_iterator it = last_response.beginMap();
@@ -1739,7 +1739,7 @@ void LLFloaterPreference::onClickEnablePopup()
LLNotificationTemplatePtr templatep = LLNotifications::instance().getTemplate(*(std::string*)((*itor)->getUserdata()));
//gSavedSettings.setWarning(templatep->mName, TRUE);
std::string notification_name = templatep->mName;
- LLUI::sSettingGroups["ignores"]->setBOOL(notification_name, TRUE);
+ LLUI::getInstance()->mSettingGroups["ignores"]->setBOOL(notification_name, TRUE);
}
buildPopupLists();
diff --git a/indra/newview/llfloatersearch.cpp b/indra/newview/llfloatersearch.cpp
index d1246dae4c8d230513b8793eade97921cf930eac..779542cfcc8821d83232b693f5f02ae7663f1b72 100644
--- a/indra/newview/llfloatersearch.cpp
+++ b/indra/newview/llfloatersearch.cpp
@@ -48,7 +48,7 @@ class LLSearchHandler : public LLCommandHandler
LLSearchHandler() : LLCommandHandler("search", UNTRUSTED_THROTTLE) { }
bool handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableSearch"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableSearch"))
{
LLNotificationsUtil::add("NoSearch", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llfloaterspellchecksettings.cpp b/indra/newview/llfloaterspellchecksettings.cpp
index b87044ef5a538967b8b02fcf65200a56daf5b756..de5d59f484552149c30d6effc0b5e8d7de21ff4b 100644
--- a/indra/newview/llfloaterspellchecksettings.cpp
+++ b/indra/newview/llfloaterspellchecksettings.cpp
@@ -56,7 +56,7 @@ void LLFloaterSpellCheckerSettings::draw()
bool enable_remove = !sel_items.empty();
for (std::vector<LLScrollListItem*>::const_iterator sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)
{
- enable_remove &= LLSpellChecker::canRemoveDictionary((*sel_it)->getValue().asString());
+ enable_remove &= LLSpellChecker::getInstance()->canRemoveDictionary((*sel_it)->getValue().asString());
}
getChild<LLUICtrl>("spellcheck_remove_btn")->setEnabled(enable_remove);
}
@@ -121,7 +121,7 @@ void LLFloaterSpellCheckerSettings::onClose(bool app_quitting)
for (std::vector<LLScrollListItem*>::const_iterator item_it = list_items.begin(); item_it != list_items.end(); ++item_it)
{
const std::string language = (*item_it)->getValue().asString();
- if (LLSpellChecker::hasDictionary(language, true))
+ if (LLSpellChecker::getInstance()->hasDictionary(language, true))
{
list_dict.push_back(language);
}
@@ -164,7 +164,7 @@ void LLFloaterSpellCheckerSettings::refreshDictionaries(bool from_settings)
}
dict_combo->clearRows();
- const LLSD& dict_map = LLSpellChecker::getDictionaryMap();
+ const LLSD& dict_map = LLSpellChecker::getInstance()->getDictionaryMap();
if (dict_map.size())
{
for (LLSD::array_const_iterator dict_it = dict_map.beginArray(); dict_it != dict_map.endArray(); ++dict_it)
@@ -216,7 +216,7 @@ void LLFloaterSpellCheckerSettings::refreshDictionaries(bool from_settings)
for (LLSpellChecker::dict_list_t::const_iterator it = active_list.begin(); it != active_list.end(); ++it)
{
const std::string language = *it;
- const LLSD dict = LLSpellChecker::getDictionaryData(language);
+ const LLSD dict = LLSpellChecker::getInstance()->getDictionaryData(language);
row["value"] = language;
row["columns"][0]["value"] = (!dict["user_installed"].asBoolean()) ? language : language + " " + LLTrans::getString("UserDictionary");
active_ctrl->addElement(row);
@@ -380,7 +380,7 @@ void LLFloaterSpellCheckerImport::onBtnOK()
custom_file_out.close();
}
- LLSpellChecker::refreshDictionaryMap();
+ LLSpellChecker::getInstance()->refreshDictionaryMap();
}
closeFloater(false);
diff --git a/indra/newview/llfloateruipreview.cpp b/indra/newview/llfloateruipreview.cpp
index db5a1922870c2768ecdc4cf214c36344451322ca..e67c79a3a0f54f33a27d767c8d78cff4ec5e5a5c 100644
--- a/indra/newview/llfloateruipreview.cpp
+++ b/indra/newview/llfloateruipreview.cpp
@@ -291,8 +291,8 @@ bool LLPreviewedFloater::sShowRectangles = false;
// Changes are made here
LLLocalizationResetForcer::LLLocalizationResetForcer(LLFloaterUIPreview* floater, S32 ID)
{
- mSavedLocalization = LLUI::sSettingGroups["config"]->getString("Language"); // save current localization setting
- LLUI::sSettingGroups["config"]->setString("Language", floater->getLocStr(ID));// hack language to be the one we want to preview floaters in
+ mSavedLocalization = LLUI::getInstance()->mSettingGroups["config"]->getString("Language"); // save current localization setting
+ LLUI::getInstance()->mSettingGroups["config"]->setString("Language", floater->getLocStr(ID));// hack language to be the one we want to preview floaters in
// forcibly reset XUI paths with this new language
gDirUtilp->setSkinFolder(gDirUtilp->getSkinFolder(), floater->getLocStr(ID));
}
@@ -301,7 +301,7 @@ LLLocalizationResetForcer::LLLocalizationResetForcer(LLFloaterUIPreview* floater
// Changes are reversed here
LLLocalizationResetForcer::~LLLocalizationResetForcer()
{
- LLUI::sSettingGroups["config"]->setString("Language", mSavedLocalization); // reset language to what it was before we changed it
+ LLUI::getInstance()->mSettingGroups["config"]->setString("Language", mSavedLocalization); // reset language to what it was before we changed it
// forcibly reset XUI paths with this new language
gDirUtilp->setSkinFolder(gDirUtilp->getSkinFolder(), mSavedLocalization);
}
diff --git a/indra/newview/llfloatervoicevolume.cpp b/indra/newview/llfloatervoicevolume.cpp
index 38446e46df8979e73f8ce826ce476f4fe37dfdb7..59e1f49f81d7895c4ab39813a350a5ffa1b81308 100644
--- a/indra/newview/llfloatervoicevolume.cpp
+++ b/indra/newview/llfloatervoicevolume.cpp
@@ -127,7 +127,7 @@ void LLFloaterVoiceVolume::onOpen(const LLSD& data)
// Extract appropriate avatar id
mAvatarID = data["avatar_id"];
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
getChild<LLUICtrl>("avatar_name")->setValue("");
updateVolumeControls();
diff --git a/indra/newview/llfloaterwebcontent.cpp b/indra/newview/llfloaterwebcontent.cpp
index 13953d6be5b77942ebb16d0527ba8abf11af1cf2..c591dfacaf310c61204a318e39ceeb8041026a00 100644
--- a/indra/newview/llfloaterwebcontent.cpp
+++ b/indra/newview/llfloaterwebcontent.cpp
@@ -234,7 +234,7 @@ void LLFloaterWebContent::preCreate(LLFloaterWebContent::Params& p)
void LLFloaterWebContent::open_media(const Params& p)
{
- LLViewerMedia::proxyWindowOpened(p.target(), p.id());
+ LLViewerMedia::getInstance()->proxyWindowOpened(p.target(), p.id());
mWebBrowser->setHomePageUrl(p.url);
mWebBrowser->setTarget(p.target);
mWebBrowser->navigateTo(p.url);
@@ -308,7 +308,7 @@ void LLFloaterWebContent::onClose(bool app_quitting)
LLTwitterConnect::instance().setConnectionState(LLTwitterConnect::TWITTER_CONNECTION_FAILED);
}
}
- LLViewerMedia::proxyWindowClosed(mUUID);
+ LLViewerMedia::getInstance()->proxyWindowClosed(mUUID);
destroy();
}
diff --git a/indra/newview/llfloaterworldmap.cpp b/indra/newview/llfloaterworldmap.cpp
index 1e9c9ce5e0407c1f33521064e664d2d4a05c3782..27197f0b065075055cef8c772c0a6f82247027a1 100644
--- a/indra/newview/llfloaterworldmap.cpp
+++ b/indra/newview/llfloaterworldmap.cpp
@@ -122,7 +122,7 @@ class LLWorldMapHandler : public LLCommandHandler
bool handle(const LLSD& params, const LLSD& query_map,
LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableWorldMap"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableWorldMap"))
{
LLNotificationsUtil::add("NoWorldMap", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
@@ -160,7 +160,7 @@ class LLMapTrackAvatarHandler : public LLCommandHandler
bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableWorldMap"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableWorldMap"))
{
LLNotificationsUtil::add("NoWorldMap", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llfollowcam.cpp b/indra/newview/llfollowcam.cpp
index 612afc0d18fdeb8142499f3155072aa3af394bfc..c2ea3b07c1a87ad706a17f2f7b83f1eec6e57353 100644
--- a/indra/newview/llfollowcam.cpp
+++ b/indra/newview/llfollowcam.cpp
@@ -29,12 +29,6 @@
#include "llfollowcam.h"
#include "llagent.h"
-//-------------------------------------------------------
-// class statics
-//-------------------------------------------------------
-std::map<LLUUID, LLFollowCamParams*> LLFollowCamMgr::sParamMap;
-std::vector<LLFollowCamParams*> LLFollowCamMgr::sParamStack;
-
//-------------------------------------------------------
// constants
//-------------------------------------------------------
@@ -668,18 +662,20 @@ LLFollowCam::~LLFollowCam()
//-------------------------------------------------------
// LLFollowCamMgr
//-------------------------------------------------------
-//static
-void LLFollowCamMgr::cleanupClass()
+LLFollowCamMgr::LLFollowCamMgr()
{
- for (param_map_t::iterator iter = sParamMap.begin(); iter != sParamMap.end(); ++iter)
- {
- LLFollowCamParams* params = iter->second;
- delete params;
- }
- sParamMap.clear();
}
-//static
+LLFollowCamMgr::~LLFollowCamMgr()
+{
+ for (param_map_t::iterator iter = mParamMap.begin(); iter != mParamMap.end(); ++iter)
+ {
+ LLFollowCamParams* params = iter->second;
+ delete params;
+ }
+ mParamMap.clear();
+}
+
void LLFollowCamMgr::setPositionLag( const LLUUID& source, F32 lag)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -689,7 +685,6 @@ void LLFollowCamMgr::setPositionLag( const LLUUID& source, F32 lag)
}
}
-//static
void LLFollowCamMgr::setFocusLag( const LLUUID& source, F32 lag)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -699,7 +694,6 @@ void LLFollowCamMgr::setFocusLag( const LLUUID& source, F32 lag)
}
}
-//static
void LLFollowCamMgr::setFocusThreshold( const LLUUID& source, F32 threshold)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -710,7 +704,6 @@ void LLFollowCamMgr::setFocusThreshold( const LLUUID& source, F32 threshold)
}
-//static
void LLFollowCamMgr::setPositionThreshold( const LLUUID& source, F32 threshold)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -720,7 +713,6 @@ void LLFollowCamMgr::setPositionThreshold( const LLUUID& source, F32 threshold)
}
}
-//static
void LLFollowCamMgr::setDistance( const LLUUID& source, F32 distance)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -730,7 +722,6 @@ void LLFollowCamMgr::setDistance( const LLUUID& source, F32 distance)
}
}
-//static
void LLFollowCamMgr::setPitch( const LLUUID& source, F32 pitch)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -740,7 +731,6 @@ void LLFollowCamMgr::setPitch( const LLUUID& source, F32 pitch)
}
}
-//static
void LLFollowCamMgr::setFocusOffset( const LLUUID& source, const LLVector3& offset)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -750,7 +740,6 @@ void LLFollowCamMgr::setFocusOffset( const LLUUID& source, const LLVector3& offs
}
}
-//static
void LLFollowCamMgr::setBehindnessAngle( const LLUUID& source, F32 angle)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -760,7 +749,6 @@ void LLFollowCamMgr::setBehindnessAngle( const LLUUID& source, F32 angle)
}
}
-//static
void LLFollowCamMgr::setBehindnessLag( const LLUUID& source, F32 force)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -770,7 +758,6 @@ void LLFollowCamMgr::setBehindnessLag( const LLUUID& source, F32 force)
}
}
-//static
void LLFollowCamMgr::setPosition( const LLUUID& source, const LLVector3 position)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -780,7 +767,6 @@ void LLFollowCamMgr::setPosition( const LLUUID& source, const LLVector3 position
}
}
-//static
void LLFollowCamMgr::setFocus( const LLUUID& source, const LLVector3 focus)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -790,7 +776,6 @@ void LLFollowCamMgr::setFocus( const LLUUID& source, const LLVector3 focus)
}
}
-//static
void LLFollowCamMgr::setPositionLocked( const LLUUID& source, bool locked)
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -800,7 +785,6 @@ void LLFollowCamMgr::setPositionLocked( const LLUUID& source, bool locked)
}
}
-//static
void LLFollowCamMgr::setFocusLocked( const LLUUID& source, bool locked )
{
LLFollowCamParams* paramsp = getParamsForID(source);
@@ -810,16 +794,15 @@ void LLFollowCamMgr::setFocusLocked( const LLUUID& source, bool locked )
}
}
-//static
LLFollowCamParams* LLFollowCamMgr::getParamsForID(const LLUUID& source)
{
LLFollowCamParams* params = NULL;
- param_map_t::iterator found_it = sParamMap.find(source);
- if (found_it == sParamMap.end()) // didn't find it?
+ param_map_t::iterator found_it = mParamMap.find(source);
+ if (found_it == mParamMap.end()) // didn't find it?
{
params = new LLFollowCamParams();
- sParamMap[source] = params;
+ mParamMap[source] = params;
}
else
{
@@ -829,56 +812,51 @@ LLFollowCamParams* LLFollowCamMgr::getParamsForID(const LLUUID& source)
return params;
}
-//static
LLFollowCamParams* LLFollowCamMgr::getActiveFollowCamParams()
{
- if (sParamStack.empty())
+ if (mParamStack.empty())
{
return NULL;
}
- return sParamStack.back();
+ return mParamStack.back();
}
-//static
void LLFollowCamMgr::setCameraActive( const LLUUID& source, bool active )
{
LLFollowCamParams* params = getParamsForID(source);
- param_stack_t::iterator found_it = std::find(sParamStack.begin(), sParamStack.end(), params);
- if (found_it != sParamStack.end())
+ param_stack_t::iterator found_it = std::find(mParamStack.begin(), mParamStack.end(), params);
+ if (found_it != mParamStack.end())
{
- sParamStack.erase(found_it);
+ mParamStack.erase(found_it);
}
// put on top of stack
if(active)
{
- sParamStack.push_back(params);
+ mParamStack.push_back(params);
}
}
-//static
void LLFollowCamMgr::removeFollowCamParams(const LLUUID& source)
{
setCameraActive(source, FALSE);
LLFollowCamParams* params = getParamsForID(source);
- sParamMap.erase(source);
+ mParamMap.erase(source);
delete params;
}
-//static
bool LLFollowCamMgr::isScriptedCameraSource(const LLUUID& source)
{
- param_map_t::iterator found_it = sParamMap.find(source);
- return (found_it != sParamMap.end());
+ param_map_t::iterator found_it = mParamMap.find(source);
+ return (found_it != mParamMap.end());
}
-//static
void LLFollowCamMgr::dump()
{
S32 param_count = 0;
LL_INFOS() << "Scripted camera active stack" << LL_ENDL;
- for (param_stack_t::iterator param_it = sParamStack.begin();
- param_it != sParamStack.end();
+ for (param_stack_t::iterator param_it = mParamStack.begin();
+ param_it != mParamStack.end();
++param_it)
{
LL_INFOS() << param_count++ <<
diff --git a/indra/newview/llfollowcam.h b/indra/newview/llfollowcam.h
index f4b7b2723a0091ffdd7560722a783060d5268381..799584816051b8741aacf9d9c689e43eff14781d 100644
--- a/indra/newview/llfollowcam.h
+++ b/indra/newview/llfollowcam.h
@@ -193,40 +193,40 @@ class LLFollowCam : public LLFollowCamParams
};// end of FollowCam class
-class LLFollowCamMgr
+class LLFollowCamMgr : public LLSingleton<LLFollowCamMgr>
{
-public:
- static void cleanupClass ( );
-
- static void setPositionLag ( const LLUUID& source, F32 lag);
- static void setFocusLag ( const LLUUID& source, F32 lag);
- static void setFocusThreshold ( const LLUUID& source, F32 threshold);
- static void setPositionThreshold ( const LLUUID& source, F32 threshold);
- static void setDistance ( const LLUUID& source, F32 distance);
- static void setPitch ( const LLUUID& source, F32 pitch);
- static void setFocusOffset ( const LLUUID& source, const LLVector3& offset);
- static void setBehindnessAngle ( const LLUUID& source, F32 angle);
- static void setBehindnessLag ( const LLUUID& source, F32 lag);
- static void setPosition ( const LLUUID& source, const LLVector3 position);
- static void setFocus ( const LLUUID& source, const LLVector3 focus);
- static void setPositionLocked ( const LLUUID& source, bool locked);
- static void setFocusLocked ( const LLUUID& source, bool locked );
-
- static void setCameraActive ( const LLUUID& source, bool active );
-
- static LLFollowCamParams* getActiveFollowCamParams();
- static LLFollowCamParams* getParamsForID(const LLUUID& source);
- static void removeFollowCamParams(const LLUUID& source);
- static bool isScriptedCameraSource(const LLUUID& source);
- static void dump();
+ LLSINGLETON(LLFollowCamMgr);
+ ~LLFollowCamMgr();
+public:
+ void setPositionLag ( const LLUUID& source, F32 lag);
+ void setFocusLag ( const LLUUID& source, F32 lag);
+ void setFocusThreshold ( const LLUUID& source, F32 threshold);
+ void setPositionThreshold ( const LLUUID& source, F32 threshold);
+ void setDistance ( const LLUUID& source, F32 distance);
+ void setPitch ( const LLUUID& source, F32 pitch);
+ void setFocusOffset ( const LLUUID& source, const LLVector3& offset);
+ void setBehindnessAngle ( const LLUUID& source, F32 angle);
+ void setBehindnessLag ( const LLUUID& source, F32 lag);
+ void setPosition ( const LLUUID& source, const LLVector3 position);
+ void setFocus ( const LLUUID& source, const LLVector3 focus);
+ void setPositionLocked ( const LLUUID& source, bool locked);
+ void setFocusLocked ( const LLUUID& source, bool locked );
+
+ void setCameraActive ( const LLUUID& source, bool active );
+
+ LLFollowCamParams* getActiveFollowCamParams();
+ LLFollowCamParams* getParamsForID(const LLUUID& source);
+ void removeFollowCamParams(const LLUUID& source);
+ bool isScriptedCameraSource(const LLUUID& source);
+ void dump();
protected:
typedef std::map<LLUUID, LLFollowCamParams*> param_map_t;
- static param_map_t sParamMap;
+ param_map_t mParamMap;
typedef std::vector<LLFollowCamParams*> param_stack_t;
- static param_stack_t sParamStack;
+ param_stack_t mParamStack;
};
#endif //LL_FOLLOWCAM_H
diff --git a/indra/newview/llgroupactions.cpp b/indra/newview/llgroupactions.cpp
index 913efd643426aa50e727377a6d9987095cd206ae..599790d2bb8e0d3591d488ddb0c6f8b71f21ec59 100644
--- a/indra/newview/llgroupactions.cpp
+++ b/indra/newview/llgroupactions.cpp
@@ -55,7 +55,7 @@ class LLGroupHandler : public LLCommandHandler
bool handle(const LLSD& tokens, const LLSD& query_map,
LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableGroupInfo"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableGroupInfo"))
{
LLNotificationsUtil::add("NoGroupInfo", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llhints.cpp b/indra/newview/llhints.cpp
index 197408b40e8e9fe167e3aa86d6dcf6ea134ae51f..7271376a3c18f8fac6238ea0aeb32975a1078dc2 100644
--- a/indra/newview/llhints.cpp
+++ b/indra/newview/llhints.cpp
@@ -240,7 +240,7 @@ void LLHintPopup::draw()
}
else
{
- LLView* targetp = LLHints::getHintTarget(mTarget).get();
+ LLView* targetp = LLHints::getInstance()->getHintTarget(mTarget).get();
if (!targetp)
{
// target widget is no longer valid, go away
@@ -349,10 +349,20 @@ void LLHintPopup::draw()
}
-LLRegistry<std::string, LLHandle<LLView> > LLHints::sTargetRegistry;
-std::map<LLNotificationPtr, class LLHintPopup*> LLHints::sHints;
+/// LLHints
+
+LLHints::LLHints()
+{
+ LLControlVariablePtr control = gSavedSettings.getControl("EnableUIHints");
+ mControlConnection = control->getSignal()->connect(boost::bind(&LLHints::showHints, this, _2));
+ gViewerWindow->getHintHolder()->setVisible(control->getValue().asBoolean());
+}
+
+LLHints::~LLHints()
+{
+ mControlConnection.disconnect();
+}
-//static
void LLHints::show(LLNotificationPtr hint)
{
LLHintPopup::Params p(LLUICtrlFactory::getDefaultParams<LLHintPopup>());
@@ -365,7 +375,7 @@ void LLHints::show(LLNotificationPtr hint)
{
LLHintPopup* popup = new LLHintPopup(p);
- sHints[hint] = popup;
+ mHints[hint] = popup;
LLView* hint_holder = gViewerWindow->getHintHolder();
if (hint_holder)
@@ -376,27 +386,24 @@ void LLHints::show(LLNotificationPtr hint)
}
}
-//static
void LLHints::hide(LLNotificationPtr hint)
{
- hint_map_t::iterator found_it = sHints.find(hint);
- if (found_it != sHints.end())
+ hint_map_t::iterator found_it = mHints.find(hint);
+ if (found_it != mHints.end())
{
found_it->second->hide();
- sHints.erase(found_it);
+ mHints.erase(found_it);
}
}
-//static
void LLHints::registerHintTarget(const std::string& name, LLHandle<LLView> target)
{
- sTargetRegistry.defaultRegistrar().replace(name, target);
+ mTargetRegistry.defaultRegistrar().replace(name, target);
}
-//static
LLHandle<LLView> LLHints::getHintTarget(const std::string& name)
{
- LLHandle<LLView>* handlep = sTargetRegistry.getValue(name);
+ LLHandle<LLView>* handlep = mTargetRegistry.getValue(name);
if (handlep)
{
return *handlep;
@@ -407,18 +414,6 @@ LLHandle<LLView> LLHints::getHintTarget(const std::string& name)
}
}
-//static
-void LLHints::initClass()
-{
- sRegister.reference();
-
- LLControlVariablePtr control = gSavedSettings.getControl("EnableUIHints");
- control->getSignal()->connect(boost::bind(&showHints, _2));
- gViewerWindow->getHintHolder()->setVisible(control->getValue().asBoolean());
-
-}
-
-//staic
void LLHints::showHints(const LLSD& show)
{
bool visible = show.asBoolean();
diff --git a/indra/newview/llhints.h b/indra/newview/llhints.h
index dd6195a9ce37e782287df50b334dd7e61a5f8be4..1f730734d0124e8d7d5c335b858fa4895b14d2ce 100644
--- a/indra/newview/llhints.h
+++ b/indra/newview/llhints.h
@@ -32,19 +32,22 @@
#include "llinitdestroyclass.h"
-class LLHints : public LLInitClass<LLHints>
+class LLHints : public LLSingleton<LLHints>
{
+ LLSINGLETON(LLHints);
+ ~LLHints();
public:
- static void show(LLNotificationPtr hint);
- static void hide(LLNotificationPtr hint);
- static void registerHintTarget(const std::string& name, LLHandle<LLView> target);
- static LLHandle<LLView> getHintTarget(const std::string& name);
- static void initClass();
+ void show(LLNotificationPtr hint);
+ void hide(LLNotificationPtr hint);
+ void registerHintTarget(const std::string& name, LLHandle<LLView> target);
+ LLHandle<LLView> getHintTarget(const std::string& name);
private:
- static LLRegistry<std::string, LLHandle<LLView> > sTargetRegistry;
+ LLRegistry<std::string, LLHandle<LLView> > mTargetRegistry;
typedef std::map<LLNotificationPtr, class LLHintPopup*> hint_map_t;
- static hint_map_t sHints;
- static void showHints(const LLSD& show);
+ hint_map_t mHints;
+ void showHints(const LLSD& show);
+
+ boost::signals2::connection mControlConnection;
};
diff --git a/indra/newview/llimagefiltersmanager.cpp b/indra/newview/llimagefiltersmanager.cpp
index ee6b39efaca6b650f5df139399a3f2b63ad1ede2..c23cdc8103e83bfa71b356d5258ea4305fff77a6 100644
--- a/indra/newview/llimagefiltersmanager.cpp
+++ b/indra/newview/llimagefiltersmanager.cpp
@@ -48,7 +48,7 @@ LLImageFiltersManager::~LLImageFiltersManager()
{
}
-// virtual static
+// virtual
void LLImageFiltersManager::initSingleton()
{
loadAllFilters();
diff --git a/indra/newview/llimprocessing.cpp b/indra/newview/llimprocessing.cpp
index d59c301210781965a77ff73f2754e08081168d05..3606a439a69fc2abdccda3a83e1dc5ce5fdf62b5 100644
--- a/indra/newview/llimprocessing.cpp
+++ b/indra/newview/llimprocessing.cpp
@@ -695,7 +695,7 @@ void LLIMProcessing::processNewMessage(LLUUID from_id,
// The group notice packet does not have an AgentID. Obtain one from the name cache.
// If last name is "Resident" strip it out so the cache name lookup works.
std::string legacy_name = gCacheName->buildLegacyName(original_name);
- agent_id = LLAvatarNameCache::findIdByName(legacy_name);
+ agent_id = LLAvatarNameCache::getInstance()->findIdByName(legacy_name);
if (agent_id.isNull())
{
diff --git a/indra/newview/llimview.cpp b/indra/newview/llimview.cpp
index 0f5d5146600a90d9b90b3d953dc1a6b73caa3ada..e331a51bda76220197e21dc08c9078fce942c966 100644
--- a/indra/newview/llimview.cpp
+++ b/indra/newview/llimview.cpp
@@ -83,11 +83,6 @@ void startConfrenceCoro(std::string url, LLUUID tempSessionId, LLUUID creatorId,
void chatterBoxInvitationCoro(std::string url, LLUUID sessionId, LLIMMgr::EInvitationType invitationType);
void start_deprecated_conference_chat(const LLUUID& temp_session_id, const LLUUID& creator_id, const LLUUID& other_participant_id, const LLSD& agents_to_invite);
-std::string LLCallDialogManager::sPreviousSessionlName = "";
-LLIMModel::LLIMSession::SType LLCallDialogManager::sPreviousSessionType = LLIMModel::LLIMSession::P2P_SESSION;
-std::string LLCallDialogManager::sCurrentSessionlName = "";
-LLIMModel::LLIMSession* LLCallDialogManager::sSession = NULL;
-LLVoiceChannel::EState LLCallDialogManager::sOldState = LLVoiceChannel::STATE_READY;
const LLUUID LLOutgoingCallDialog::OCD_KEY = LLUUID("7CF78E11-0CFE-498D-ADB9-1417BF03DDB4");
//
// Globals
@@ -811,7 +806,7 @@ void LLIMModel::LLIMSession::addMessagesFromHistory(const std::list<LLSD>& histo
{
// convert it to a legacy name if we have a complete name
std::string legacy_name = gCacheName->buildLegacyName(from);
- from_id = LLAvatarNameCache::findIdByName(legacy_name);
+ from_id = LLAvatarNameCache::getInstance()->findIdByName(legacy_name);
}
std::string timestamp = msg[LL_IM_TIME];
@@ -1786,7 +1781,12 @@ LLIMMgr::onConfirmForceCloseError(
// Class LLCallDialogManager
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-LLCallDialogManager::LLCallDialogManager()
+LLCallDialogManager::LLCallDialogManager():
+mPreviousSessionlName(""),
+mPreviousSessionType(LLIMModel::LLIMSession::P2P_SESSION),
+mCurrentSessionlName(""),
+mSession(NULL),
+mOldState(LLVoiceChannel::STATE_READY)
{
}
@@ -1794,39 +1794,45 @@ LLCallDialogManager::~LLCallDialogManager()
{
}
-void LLCallDialogManager::initClass()
+void LLCallDialogManager::initSingleton()
{
LLVoiceChannel::setCurrentVoiceChannelChangedCallback(LLCallDialogManager::onVoiceChannelChanged);
}
+// static
void LLCallDialogManager::onVoiceChannelChanged(const LLUUID &session_id)
+{
+ LLCallDialogManager::getInstance()->onVoiceChannelChangedInt(session_id);
+}
+
+void LLCallDialogManager::onVoiceChannelChangedInt(const LLUUID &session_id)
{
LLIMModel::LLIMSession* session = LLIMModel::getInstance()->findIMSession(session_id);
if(!session)
{
- sPreviousSessionlName = sCurrentSessionlName;
- sCurrentSessionlName = ""; // Empty string results in "Nearby Voice Chat" after substitution
+ mPreviousSessionlName = mCurrentSessionlName;
+ mCurrentSessionlName = ""; // Empty string results in "Nearby Voice Chat" after substitution
return;
}
- if (sSession)
+ if (mSession)
{
// store previous session type to process Avaline calls in dialogs
- sPreviousSessionType = sSession->mSessionType;
+ mPreviousSessionType = mSession->mSessionType;
}
- sSession = session;
+ mSession = session;
static boost::signals2::connection prev_channel_state_changed_connection;
// disconnect previously connected callback to avoid have invalid sSession in onVoiceChannelStateChanged()
prev_channel_state_changed_connection.disconnect();
prev_channel_state_changed_connection =
- sSession->mVoiceChannel->setStateChangedCallback(boost::bind(LLCallDialogManager::onVoiceChannelStateChanged, _1, _2, _3, _4));
+ mSession->mVoiceChannel->setStateChangedCallback(boost::bind(LLCallDialogManager::onVoiceChannelStateChanged, _1, _2, _3, _4));
- if(sCurrentSessionlName != session->mName)
+ if(mCurrentSessionlName != session->mName)
{
- sPreviousSessionlName = sCurrentSessionlName;
- sCurrentSessionlName = session->mName;
+ mPreviousSessionlName = mCurrentSessionlName;
+ mCurrentSessionlName = session->mName;
}
if (LLVoiceChannel::getCurrentVoiceChannel()->getState() == LLVoiceChannel::STATE_CALL_STARTED &&
@@ -1835,14 +1841,14 @@ void LLCallDialogManager::onVoiceChannelChanged(const LLUUID &session_id)
//*TODO get rid of duplicated code
LLSD mCallDialogPayload;
- mCallDialogPayload["session_id"] = sSession->mSessionID;
- mCallDialogPayload["session_name"] = sSession->mName;
- mCallDialogPayload["other_user_id"] = sSession->mOtherParticipantID;
- mCallDialogPayload["old_channel_name"] = sPreviousSessionlName;
- mCallDialogPayload["old_session_type"] = sPreviousSessionType;
+ mCallDialogPayload["session_id"] = mSession->mSessionID;
+ mCallDialogPayload["session_name"] = mSession->mName;
+ mCallDialogPayload["other_user_id"] = mSession->mOtherParticipantID;
+ mCallDialogPayload["old_channel_name"] = mPreviousSessionlName;
+ mCallDialogPayload["old_session_type"] = mPreviousSessionType;
mCallDialogPayload["state"] = LLVoiceChannel::STATE_CALL_STARTED;
- mCallDialogPayload["disconnected_channel_name"] = sSession->mName;
- mCallDialogPayload["session_type"] = sSession->mSessionType;
+ mCallDialogPayload["disconnected_channel_name"] = mSession->mName;
+ mCallDialogPayload["session_type"] = mSession->mSessionType;
LLOutgoingCallDialog* ocd = LLFloaterReg::getTypedInstance<LLOutgoingCallDialog>("outgoing_call", LLOutgoingCallDialog::OCD_KEY);
if(ocd)
@@ -1853,26 +1859,32 @@ void LLCallDialogManager::onVoiceChannelChanged(const LLUUID &session_id)
}
+// static
void LLCallDialogManager::onVoiceChannelStateChanged(const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state, const LLVoiceChannel::EDirection& direction, bool ended_by_agent)
+{
+ LLCallDialogManager::getInstance()->onVoiceChannelStateChangedInt(old_state, new_state, direction, ended_by_agent);
+}
+
+void LLCallDialogManager::onVoiceChannelStateChangedInt(const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state, const LLVoiceChannel::EDirection& direction, bool ended_by_agent)
{
LLSD mCallDialogPayload;
LLOutgoingCallDialog* ocd = NULL;
- if(sOldState == new_state)
+ if(mOldState == new_state)
{
return;
}
- sOldState = new_state;
+ mOldState = new_state;
- mCallDialogPayload["session_id"] = sSession->mSessionID;
- mCallDialogPayload["session_name"] = sSession->mName;
- mCallDialogPayload["other_user_id"] = sSession->mOtherParticipantID;
- mCallDialogPayload["old_channel_name"] = sPreviousSessionlName;
- mCallDialogPayload["old_session_type"] = sPreviousSessionType;
+ mCallDialogPayload["session_id"] = mSession->mSessionID;
+ mCallDialogPayload["session_name"] = mSession->mName;
+ mCallDialogPayload["other_user_id"] = mSession->mOtherParticipantID;
+ mCallDialogPayload["old_channel_name"] = mPreviousSessionlName;
+ mCallDialogPayload["old_session_type"] = mPreviousSessionType;
mCallDialogPayload["state"] = new_state;
- mCallDialogPayload["disconnected_channel_name"] = sSession->mName;
- mCallDialogPayload["session_type"] = sSession->mSessionType;
+ mCallDialogPayload["disconnected_channel_name"] = mSession->mName;
+ mCallDialogPayload["session_type"] = mSession->mSessionType;
mCallDialogPayload["ended_by_agent"] = ended_by_agent;
switch(new_state)
@@ -1887,7 +1899,7 @@ void LLCallDialogManager::onVoiceChannelStateChanged(const LLVoiceChannel::EStat
case LLVoiceChannel::STATE_HUNG_UP:
// this state is coming before session is changed, so, put it into payload map
- mCallDialogPayload["old_session_type"] = sSession->mSessionType;
+ mCallDialogPayload["old_session_type"] = mSession->mSessionType;
break;
case LLVoiceChannel::STATE_CONNECTED :
@@ -1925,7 +1937,7 @@ LLCallDialog::LLCallDialog(const LLSD& payload)
LLCallDialog::~LLCallDialog()
{
- LLUI::removePopup(this);
+ LLUI::getInstance()->removePopup(this);
}
BOOL LLCallDialog::postBuild()
@@ -2002,7 +2014,7 @@ void LLCallDialog::onOpen(const LLSD& key)
LLDockableFloater::onOpen(key);
// it should be over the all floaters. EXT-5116
- LLUI::addPopup(this);
+ LLUI::getInstance()->addPopup(this);
}
void LLCallDialog::setIcon(const LLSD& session_id, const LLSD& participant_id)
diff --git a/indra/newview/llimview.h b/indra/newview/llimview.h
index 81d3ffa1a6f6d63c0b9c99b1dff7ae221f4fc252..2a9e4679a8bd1dd8447ee8dbe42aab39f82edec3 100644
--- a/indra/newview/llimview.h
+++ b/indra/newview/llimview.h
@@ -499,22 +499,26 @@ class LLIMMgr : public LLSingleton<LLIMMgr>
LLSD mPendingAgentListUpdates;
};
-class LLCallDialogManager : public LLInitClass<LLCallDialogManager>
+class LLCallDialogManager : public LLSingleton<LLCallDialogManager>
{
-public:
- LLCallDialogManager();
+ LLSINGLETON(LLCallDialogManager);
~LLCallDialogManager();
-
- static void initClass();
+public:
+ // static for convinience
static void onVoiceChannelChanged(const LLUUID &session_id);
static void onVoiceChannelStateChanged(const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state, const LLVoiceChannel::EDirection& direction, bool ended_by_agent);
+private:
+ void initSingleton();
+ void onVoiceChannelChangedInt(const LLUUID &session_id);
+ void onVoiceChannelStateChangedInt(const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state, const LLVoiceChannel::EDirection& direction, bool ended_by_agent);
+
protected:
- static std::string sPreviousSessionlName;
- static LLIMModel::LLIMSession::SType sPreviousSessionType;
- static std::string sCurrentSessionlName;
- static LLIMModel::LLIMSession* sSession;
- static LLVoiceChannel::EState sOldState;
+ std::string mPreviousSessionlName;
+ LLIMModel::LLIMSession::SType mPreviousSessionType;
+ std::string mCurrentSessionlName;
+ LLIMModel::LLIMSession* mSession;
+ LLVoiceChannel::EState mOldState;
};
class LLCallDialog : public LLDockableFloater
diff --git a/indra/newview/llinspect.cpp b/indra/newview/llinspect.cpp
index e6cb068613c8bb1e1d6cd253d16e332fd39c0f81..479e8f9abf96bf65ffe9c3dec18e4e83786567a4 100644
--- a/indra/newview/llinspect.cpp
+++ b/indra/newview/llinspect.cpp
@@ -28,7 +28,7 @@
#include "lltooltip.h"
#include "llcontrol.h" // LLCachedControl
-#include "llui.h" // LLUI::sSettingsGroups
+#include "llui.h" // LLUI::getInstance()->mSettingsGroups
#include "llviewermenu.h"
LLInspect::LLInspect(const LLSD& key)
@@ -45,8 +45,8 @@ LLInspect::~LLInspect()
// virtual
void LLInspect::draw()
{
- static LLCachedControl<F32> FADE_TIME(*LLUI::sSettingGroups["config"], "InspectorFadeTime", 1.f);
- static LLCachedControl<F32> STAY_TIME(*LLUI::sSettingGroups["config"], "InspectorShowTime", 1.f);
+ static LLCachedControl<F32> FADE_TIME(*LLUI::getInstance()->mSettingGroups["config"], "InspectorFadeTime", 1.f);
+ static LLCachedControl<F32> STAY_TIME(*LLUI::getInstance()->mSettingGroups["config"], "InspectorShowTime", 1.f);
if (mOpenTimer.getStarted())
{
LLFloater::draw();
@@ -113,7 +113,7 @@ BOOL LLInspect::handleToolTip(S32 x, S32 y, MASK mask)
params.fillFrom(LLUICtrlFactory::instance().getDefaultParams<LLInspector>());
params.message = child_handler->getToolTip();
//set up delay if there is no visible tooltip at this moment
- params.delay_time = LLToolTipMgr::instance().toolTipVisible() ? 0.f : LLUI::sSettingGroups["config"]->getF32( "ToolTipDelay" );
+ params.delay_time = LLToolTipMgr::instance().toolTipVisible() ? 0.f : LLUI::getInstance()->mSettingGroups["config"]->getF32( "ToolTipDelay" );
LLToolTipMgr::instance().show(params);
handled = TRUE;
}
@@ -137,7 +137,7 @@ bool LLInspect::childHasVisiblePopupMenu()
LLRect floater_rc = calcScreenRect();
LLRect menu_screen_rc = child_menu->calcScreenRect();
S32 mx, my;
- LLUI::getMousePositionScreen(&mx, &my);
+ LLUI::getInstance()->getMousePositionScreen(&mx, &my);
// This works wrong if we spawn a menu near Inspector and menu overlaps Inspector.
if(floater_rc.overlaps(menu_screen_rc) && menu_screen_rc.pointInRect(mx, my))
diff --git a/indra/newview/llinspectavatar.cpp b/indra/newview/llinspectavatar.cpp
index 88e7ad1b71b7f99ef77c64dc48946b978b1e3cc0..10814ac0769db1f3675c36211e83774d3a9eb84f 100644
--- a/indra/newview/llinspectavatar.cpp
+++ b/indra/newview/llinspectavatar.cpp
@@ -207,11 +207,11 @@ void LLInspectAvatar::onOpen(const LLSD& data)
// See LLToolTipMgr::createToolTip
if (data.has("pos"))
{
- LLUI::positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
+ LLUI::getInstance()->positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
}
else
{
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
}
// Generate link to avatar profile.
diff --git a/indra/newview/llinspectgroup.cpp b/indra/newview/llinspectgroup.cpp
index 8332443162add399e0c24916f6cc70618a662e8d..fa8a53c5466db45f0bb051f6a2680db36b512f00 100644
--- a/indra/newview/llinspectgroup.cpp
+++ b/indra/newview/llinspectgroup.cpp
@@ -129,11 +129,11 @@ void LLInspectGroup::onOpen(const LLSD& data)
// See LLToolTipMgr::createToolTip
if (data.has("pos"))
{
- LLUI::positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
+ LLUI::getInstance()->positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
}
else
{
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
}
// can't call from constructor as widgets are not built yet
diff --git a/indra/newview/llinspectobject.cpp b/indra/newview/llinspectobject.cpp
index 46019557f85f91be6784dd5a4a169eaa15d3264f..f78a5cc64e0c2b9a3b65a39f6e9a5517c30403f8 100644
--- a/indra/newview/llinspectobject.cpp
+++ b/indra/newview/llinspectobject.cpp
@@ -202,11 +202,11 @@ void LLInspectObject::onOpen(const LLSD& data)
// See LLToolTipMgr::createToolTip
if (data.has("pos"))
{
- LLUI::positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
+ LLUI::getInstance()->positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
}
else
{
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
}
// Promote hovered object to a complete selection, which will also force
@@ -241,7 +241,7 @@ void LLInspectObject::onOpen(const LLSD& data)
if(!mMediaEntry)
return;
- mMediaImpl = LLViewerMedia::getMediaImplFromTextureID(mMediaEntry->getMediaID());
+ mMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaEntry->getMediaID());
}
}
@@ -300,7 +300,7 @@ void LLInspectObject::update()
if(!mMediaEntry)
return;
- mMediaImpl = LLViewerMedia::getMediaImplFromTextureID(mMediaEntry->getMediaID());
+ mMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaEntry->getMediaID());
updateMediaCurrentURL();
updateSecureBrowsing();
diff --git a/indra/newview/llinspectremoteobject.cpp b/indra/newview/llinspectremoteobject.cpp
index b64df2bd47176affd6fcfc24bb7de8f2f3c24d1f..272c8acbd5b8fc0d683b52d0af7bb00ea1c9f6cc 100644
--- a/indra/newview/llinspectremoteobject.cpp
+++ b/indra/newview/llinspectremoteobject.cpp
@@ -116,11 +116,11 @@ void LLInspectRemoteObject::onOpen(const LLSD& data)
// See LLToolTipMgr::createToolTip
if (data.has("pos"))
{
- LLUI::positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
+ LLUI::getInstance()->positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
}
else
{
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
}
}
diff --git a/indra/newview/llinspecttoast.cpp b/indra/newview/llinspecttoast.cpp
index 47560341e727c48312d96e4b63e9a0c22e013dec..d0034eff1346ea0bfdc34aef61576cc6251626ad 100644
--- a/indra/newview/llinspecttoast.cpp
+++ b/indra/newview/llinspecttoast.cpp
@@ -110,7 +110,7 @@ void LLInspectToast::onOpen(const LLSD& notification_id)
panel_rect = panel->getRect();
reshape(panel_rect.getWidth(), panel_rect.getHeight());
- LLUI::positionViewNearMouse(this);
+ LLUI::getInstance()->positionViewNearMouse(this);
}
// virtual
diff --git a/indra/newview/lllocalbitmaps.cpp b/indra/newview/lllocalbitmaps.cpp
index 0243e2183e6d4a328758e5c3d338dbae122a23e8..b8bde39bd105af0d6cf8991be35e821ba8250c5a 100644
--- a/indra/newview/lllocalbitmaps.cpp
+++ b/indra/newview/lllocalbitmaps.cpp
@@ -69,9 +69,6 @@
/*=======================================*/
/* Formal declarations, constants, etc. */
/*=======================================*/
-std::list<LLLocalBitmap*> LLLocalBitmapMgr::sBitmapList;
-LLLocalBitmapTimer LLLocalBitmapMgr::sTimer;
-bool LLLocalBitmapMgr::sNeedsRebake;
static const F32 LL_LOCAL_TIMER_HEARTBEAT = 3.0;
static const BOOL LL_LOCAL_USE_MIPMAPS = true;
@@ -131,7 +128,7 @@ LLLocalBitmap::~LLLocalBitmap()
if(LL_LOCAL_REPLACE_ON_DEL && mValid && gAgentAvatarp) // fix for STORM-1837
{
replaceIDs(mWorldID, IMG_DEFAULT);
- LLLocalBitmapMgr::doRebake();
+ LLLocalBitmapMgr::getInstance()->doRebake();
}
// delete self from gimagelist
@@ -571,7 +568,7 @@ void LLLocalBitmap::updateUserLayers(LLUUID old_id, LLUUID new_id, LLWearableTyp
gAgentAvatarp->setLocalTexture(reg_texind, gTextureList.getImage(new_id), FALSE, index);
gAgentAvatarp->wearableUpdated(type);
/* telling the manager to rebake once update cycle is fully done */
- LLLocalBitmapMgr::setNeedsRebake();
+ LLLocalBitmapMgr::getInstance()->setNeedsRebake();
}
}
@@ -905,7 +902,7 @@ bool LLLocalBitmapTimer::isRunning()
BOOL LLLocalBitmapTimer::tick()
{
- LLLocalBitmapMgr::doUpdates();
+ LLLocalBitmapMgr::getInstance()->doUpdates();
return FALSE;
}
@@ -914,17 +911,12 @@ BOOL LLLocalBitmapTimer::tick()
/*=======================================*/
LLLocalBitmapMgr::LLLocalBitmapMgr()
{
- // The class is all made of static members, should i even bother instantiating?
}
LLLocalBitmapMgr::~LLLocalBitmapMgr()
{
-}
-
-void LLLocalBitmapMgr::cleanupClass()
-{
- std::for_each(sBitmapList.begin(), sBitmapList.end(), DeletePointer());
- sBitmapList.clear();
+ std::for_each(mBitmapList.begin(), mBitmapList.end(), DeletePointer());
+ mBitmapList.clear();
}
bool LLLocalBitmapMgr::addUnit()
@@ -934,7 +926,7 @@ bool LLLocalBitmapMgr::addUnit()
LLFilePicker& picker = LLFilePicker::instance();
if (picker.getMultipleOpenFiles(LLFilePicker::FFLOAD_IMAGE))
{
- sTimer.stopTimer();
+ mTimer.stopTimer();
std::string filename = picker.getFirstFile();
while(!filename.empty())
@@ -949,7 +941,7 @@ bool LLLocalBitmapMgr::addUnit()
if (unit->getValid())
{
- sBitmapList.push_back(unit);
+ mBitmapList.push_back(unit);
add_successful = true;
}
else
@@ -968,7 +960,7 @@ bool LLLocalBitmapMgr::addUnit()
filename = picker.getNextFile();
}
- sTimer.startTimer();
+ mTimer.startTimer();
}
return add_successful;
@@ -1007,10 +999,10 @@ bool LLLocalBitmapMgr::checkTextureDimensions(std::string filename)
void LLLocalBitmapMgr::delUnit(LLUUID tracking_id)
{
- if (!sBitmapList.empty())
+ if (!mBitmapList.empty())
{
std::vector<LLLocalBitmap*> to_delete;
- for (local_list_iter iter = sBitmapList.begin(); iter != sBitmapList.end(); iter++)
+ for (local_list_iter iter = mBitmapList.begin(); iter != mBitmapList.end(); iter++)
{ /* finding which ones we want deleted and making a separate list */
LLLocalBitmap* unit = *iter;
if (unit->getTrackingID() == tracking_id)
@@ -1023,7 +1015,7 @@ void LLLocalBitmapMgr::delUnit(LLUUID tracking_id)
del_iter != to_delete.end(); del_iter++)
{ /* iterating over a temporary list, hence preserving the iterator validity while deleting. */
LLLocalBitmap* unit = *del_iter;
- sBitmapList.remove(unit);
+ mBitmapList.remove(unit);
delete unit;
unit = NULL;
}
@@ -1034,7 +1026,7 @@ LLUUID LLLocalBitmapMgr::getWorldID(LLUUID tracking_id)
{
LLUUID world_id = LLUUID::null;
- for (local_list_iter iter = sBitmapList.begin(); iter != sBitmapList.end(); iter++)
+ for (local_list_iter iter = mBitmapList.begin(); iter != mBitmapList.end(); iter++)
{
LLLocalBitmap* unit = *iter;
if (unit->getTrackingID() == tracking_id)
@@ -1050,7 +1042,7 @@ std::string LLLocalBitmapMgr::getFilename(LLUUID tracking_id)
{
std::string filename = "";
- for (local_list_iter iter = sBitmapList.begin(); iter != sBitmapList.end(); iter++)
+ for (local_list_iter iter = mBitmapList.begin(); iter != mBitmapList.end(); iter++)
{
LLLocalBitmap* unit = *iter;
if (unit->getTrackingID() == tracking_id)
@@ -1068,10 +1060,10 @@ void LLLocalBitmapMgr::feedScrollList(LLScrollListCtrl* ctrl)
{
ctrl->clearRows();
- if (!sBitmapList.empty())
+ if (!mBitmapList.empty())
{
- for (local_list_iter iter = sBitmapList.begin();
- iter != sBitmapList.end(); iter++)
+ for (local_list_iter iter = mBitmapList.begin();
+ iter != mBitmapList.end(); iter++)
{
LLSD element;
element["columns"][0]["column"] = "unit_name";
@@ -1092,29 +1084,29 @@ void LLLocalBitmapMgr::feedScrollList(LLScrollListCtrl* ctrl)
void LLLocalBitmapMgr::doUpdates()
{
// preventing theoretical overlap in cases with huge number of loaded images.
- sTimer.stopTimer();
- sNeedsRebake = false;
+ mTimer.stopTimer();
+ mNeedsRebake = false;
- for (local_list_iter iter = sBitmapList.begin(); iter != sBitmapList.end(); iter++)
+ for (local_list_iter iter = mBitmapList.begin(); iter != mBitmapList.end(); iter++)
{
(*iter)->updateSelf();
}
doRebake();
- sTimer.startTimer();
+ mTimer.startTimer();
}
void LLLocalBitmapMgr::setNeedsRebake()
{
- sNeedsRebake = true;
+ mNeedsRebake = true;
}
void LLLocalBitmapMgr::doRebake()
{ /* separated that from doUpdates to insure a rebake can be called separately during deletion */
- if (sNeedsRebake)
+ if (mNeedsRebake)
{
gAgentAvatarp->forceBakeAllTextures(LL_LOCAL_SLAM_FOR_DEBUG);
- sNeedsRebake = false;
+ mNeedsRebake = false;
}
}
diff --git a/indra/newview/lllocalbitmaps.h b/indra/newview/lllocalbitmaps.h
index ee4161fb45f8397b9640fc92ff925371387fb5a1..f6cc1e919e00cc8bdc82565de32c254786e3a5fa 100644
--- a/indra/newview/lllocalbitmaps.h
+++ b/indra/newview/lllocalbitmaps.h
@@ -110,31 +110,28 @@ class LLLocalBitmapTimer : public LLEventTimer
};
-class LLLocalBitmapMgr
+class LLLocalBitmapMgr : public LLSingleton<LLLocalBitmapMgr>
{
- public:
- LLLocalBitmapMgr();
- ~LLLocalBitmapMgr();
-
- public:
- static void cleanupClass();
- static bool addUnit();
- static void delUnit(LLUUID tracking_id);
- static bool checkTextureDimensions(std::string filename);
-
- static LLUUID getWorldID(LLUUID tracking_id);
- static std::string getFilename(LLUUID tracking_id);
-
- static void feedScrollList(LLScrollListCtrl* ctrl);
- static void doUpdates();
- static void setNeedsRebake();
- static void doRebake();
-
- private:
- static std::list<LLLocalBitmap*> sBitmapList;
- static LLLocalBitmapTimer sTimer;
- static bool sNeedsRebake;
- typedef std::list<LLLocalBitmap*>::iterator local_list_iter;
+ LLSINGLETON(LLLocalBitmapMgr);
+ ~LLLocalBitmapMgr();
+public:
+ bool addUnit();
+ void delUnit(LLUUID tracking_id);
+ bool checkTextureDimensions(std::string filename);
+
+ LLUUID getWorldID(LLUUID tracking_id);
+ std::string getFilename(LLUUID tracking_id);
+
+ void feedScrollList(LLScrollListCtrl* ctrl);
+ void doUpdates();
+ void setNeedsRebake();
+ void doRebake();
+
+private:
+ std::list<LLLocalBitmap*> mBitmapList;
+ LLLocalBitmapTimer mTimer;
+ bool mNeedsRebake;
+ typedef std::list<LLLocalBitmap*>::iterator local_list_iter;
};
#endif
diff --git a/indra/newview/lllocationinputctrl.cpp b/indra/newview/lllocationinputctrl.cpp
index 11bc1425f902566721a15e32ec5231fd1fe2d8de..42b5ff38907cced1436c0c22f186c946d8aa1629 100644
--- a/indra/newview/lllocationinputctrl.cpp
+++ b/indra/newview/lllocationinputctrl.cpp
@@ -666,7 +666,7 @@ void LLLocationInputCtrl::onAgentParcelChange()
void LLLocationInputCtrl::onMaturityButtonClicked()
{
- LLUI::sHelpImpl->showTopic(mMaturityHelpTopic);
+ LLUI::getInstance()->mHelpImpl->showTopic(mMaturityHelpTopic);
}
void LLLocationInputCtrl::onRegionBoundaryCrossed()
diff --git a/indra/newview/lllogchat.cpp b/indra/newview/lllogchat.cpp
index 1bdeddbcfeb6c0447a838ffa50f764e5bd455833..453bf17b119bf9fef9c8eff362a8272d498dd61e 100644
--- a/indra/newview/lllogchat.cpp
+++ b/indra/newview/lllogchat.cpp
@@ -209,11 +209,24 @@ LLLogChatTimeScanner::LLLogChatTimeScanner()
mTimeStream.imbue(std::locale(mTimeStream.getloc(), new time_input_facet(DATE_FORMAT)));
}
-LLLogChat::save_history_signal_t * LLLogChat::sSaveHistorySignal = NULL;
+LLLogChat::LLLogChat()
+: mSaveHistorySignal(NULL) // only needed in preferences
+{
+ mHistoryThreadsMutex = new LLMutex();
+}
-std::map<LLUUID,LLLoadHistoryThread *> LLLogChat::sLoadHistoryThreads;
-std::map<LLUUID,LLDeleteHistoryThread *> LLLogChat::sDeleteHistoryThreads;
-LLMutex* LLLogChat::sHistoryThreadsMutex = NULL;
+LLLogChat::~LLLogChat()
+{
+ delete mHistoryThreadsMutex;
+ mHistoryThreadsMutex = NULL;
+
+ if (mSaveHistorySignal)
+ {
+ mSaveHistorySignal->disconnect_all_slots();
+ delete mSaveHistorySignal;
+ mSaveHistorySignal = NULL;
+ }
+}
//static
@@ -338,10 +351,7 @@ void LLLogChat::saveHistory(const std::string& filename,
file.close();
- if (NULL != sSaveHistorySignal)
- {
- (*sSaveHistorySignal)();
- }
+ LLLogChat::getInstance()->triggerHistorySignal();
}
// static
@@ -416,13 +426,12 @@ void LLLogChat::loadChatHistory(const std::string& file_name, std::list<LLSD>& m
fclose(fptr);
}
-// static
bool LLLogChat::historyThreadsFinished(LLUUID session_id)
{
LLMutexLock lock(historyThreadsMutex());
bool finished = true;
- std::map<LLUUID,LLLoadHistoryThread *>::iterator it = sLoadHistoryThreads.find(session_id);
- if (it != sLoadHistoryThreads.end())
+ std::map<LLUUID,LLLoadHistoryThread *>::iterator it = mLoadHistoryThreads.find(session_id);
+ if (it != mLoadHistoryThreads.end())
{
finished = it->second->isFinished();
}
@@ -430,95 +439,93 @@ bool LLLogChat::historyThreadsFinished(LLUUID session_id)
{
return false;
}
- std::map<LLUUID,LLDeleteHistoryThread *>::iterator dit = sDeleteHistoryThreads.find(session_id);
- if (dit != sDeleteHistoryThreads.end())
+ std::map<LLUUID,LLDeleteHistoryThread *>::iterator dit = mDeleteHistoryThreads.find(session_id);
+ if (dit != mDeleteHistoryThreads.end())
{
finished = finished && dit->second->isFinished();
}
return finished;
}
-// static
LLLoadHistoryThread* LLLogChat::getLoadHistoryThread(LLUUID session_id)
{
LLMutexLock lock(historyThreadsMutex());
- std::map<LLUUID,LLLoadHistoryThread *>::iterator it = sLoadHistoryThreads.find(session_id);
- if (it != sLoadHistoryThreads.end())
+ std::map<LLUUID,LLLoadHistoryThread *>::iterator it = mLoadHistoryThreads.find(session_id);
+ if (it != mLoadHistoryThreads.end())
{
return it->second;
}
return NULL;
}
-// static
LLDeleteHistoryThread* LLLogChat::getDeleteHistoryThread(LLUUID session_id)
{
LLMutexLock lock(historyThreadsMutex());
- std::map<LLUUID,LLDeleteHistoryThread *>::iterator it = sDeleteHistoryThreads.find(session_id);
- if (it != sDeleteHistoryThreads.end())
+ std::map<LLUUID,LLDeleteHistoryThread *>::iterator it = mDeleteHistoryThreads.find(session_id);
+ if (it != mDeleteHistoryThreads.end())
{
return it->second;
}
return NULL;
}
-// static
bool LLLogChat::addLoadHistoryThread(LLUUID& session_id, LLLoadHistoryThread* lthread)
{
LLMutexLock lock(historyThreadsMutex());
- std::map<LLUUID,LLLoadHistoryThread *>::const_iterator it = sLoadHistoryThreads.find(session_id);
- if (it != sLoadHistoryThreads.end())
+ std::map<LLUUID,LLLoadHistoryThread *>::const_iterator it = mLoadHistoryThreads.find(session_id);
+ if (it != mLoadHistoryThreads.end())
{
return false;
}
- sLoadHistoryThreads[session_id] = lthread;
+ mLoadHistoryThreads[session_id] = lthread;
return true;
}
-// static
bool LLLogChat::addDeleteHistoryThread(LLUUID& session_id, LLDeleteHistoryThread* dthread)
{
LLMutexLock lock(historyThreadsMutex());
- std::map<LLUUID,LLDeleteHistoryThread *>::const_iterator it = sDeleteHistoryThreads.find(session_id);
- if (it != sDeleteHistoryThreads.end())
+ std::map<LLUUID,LLDeleteHistoryThread *>::const_iterator it = mDeleteHistoryThreads.find(session_id);
+ if (it != mDeleteHistoryThreads.end())
{
return false;
}
- sDeleteHistoryThreads[session_id] = dthread;
+ mDeleteHistoryThreads[session_id] = dthread;
return true;
}
-// static
void LLLogChat::cleanupHistoryThreads()
{
LLMutexLock lock(historyThreadsMutex());
std::vector<LLUUID> uuids;
- std::map<LLUUID,LLLoadHistoryThread *>::iterator lit = sLoadHistoryThreads.begin();
- for (; lit != sLoadHistoryThreads.end(); lit++)
+ std::map<LLUUID,LLLoadHistoryThread *>::iterator lit = mLoadHistoryThreads.begin();
+ for (; lit != mLoadHistoryThreads.end(); lit++)
{
- if (lit->second->isFinished() && sDeleteHistoryThreads[lit->first]->isFinished())
+ if (lit->second->isFinished() && mDeleteHistoryThreads[lit->first]->isFinished())
{
delete lit->second;
- delete sDeleteHistoryThreads[lit->first];
+ delete mDeleteHistoryThreads[lit->first];
uuids.push_back(lit->first);
}
}
std::vector<LLUUID>::iterator uuid_it = uuids.begin();
for ( ;uuid_it != uuids.end(); uuid_it++)
{
- sLoadHistoryThreads.erase(*uuid_it);
- sDeleteHistoryThreads.erase(*uuid_it);
+ mLoadHistoryThreads.erase(*uuid_it);
+ mDeleteHistoryThreads.erase(*uuid_it);
}
}
-//static
LLMutex* LLLogChat::historyThreadsMutex()
{
- if (sHistoryThreadsMutex == NULL)
- {
- sHistoryThreadsMutex = new LLMutex();
- }
- return sHistoryThreadsMutex;
+ return mHistoryThreadsMutex;
+}
+
+void LLLogChat::triggerHistorySignal()
+{
+ if (NULL != mSaveHistorySignal)
+ {
+ (*mSaveHistorySignal)();
+ }
}
// static
@@ -596,15 +603,14 @@ void LLLogChat::getListOfTranscriptBackupFiles(std::vector<std::string>& list_of
findTranscriptFiles(pattern, list_of_transcriptions);
}
-//static
boost::signals2::connection LLLogChat::setSaveHistorySignal(const save_history_signal_t::slot_type& cb)
{
- if (NULL == sSaveHistorySignal)
+ if (NULL == mSaveHistorySignal)
{
- sSaveHistorySignal = new save_history_signal_t();
+ mSaveHistorySignal = new save_history_signal_t();
}
- return sSaveHistorySignal->connect(cb);
+ return mSaveHistorySignal->connect(cb);
}
//static
diff --git a/indra/newview/lllogchat.h b/indra/newview/lllogchat.h
index fcbd38a044627099f0297306064bcc8563f29b07..b71a34ae0aaac1a7b6d3cc3c0b05637b8417e35f 100644
--- a/indra/newview/lllogchat.h
+++ b/indra/newview/lllogchat.h
@@ -79,8 +79,10 @@ class LLDeleteHistoryThread : public LLActionThread
static void deleteHistory();
};
-class LLLogChat
+class LLLogChat : public LLSingleton<LLLogChat>
{
+ LLSINGLETON(LLLogChat);
+ ~LLLogChat();
public:
// status values for callback function
enum ELogLineType {
@@ -107,7 +109,7 @@ class LLLogChat
static void loadChatHistory(const std::string& file_name, std::list<LLSD>& messages, const LLSD& load_params = LLSD());
typedef boost::signals2::signal<void ()> save_history_signal_t;
- static boost::signals2::connection setSaveHistorySignal(const save_history_signal_t::slot_type& cb);
+ boost::signals2::connection setSaveHistorySignal(const save_history_signal_t::slot_type& cb);
static bool moveTranscripts(const std::string currentDirectory,
const std::string newDirectory,
@@ -123,21 +125,23 @@ class LLLogChat
static bool isAdHocTranscriptExist(std::string file_name);
static bool isTranscriptFileFound(std::string fullname);
- static bool historyThreadsFinished(LLUUID session_id);
- static LLLoadHistoryThread* getLoadHistoryThread(LLUUID session_id);
- static LLDeleteHistoryThread* getDeleteHistoryThread(LLUUID session_id);
- static bool addLoadHistoryThread(LLUUID& session_id, LLLoadHistoryThread* lthread);
- static bool addDeleteHistoryThread(LLUUID& session_id, LLDeleteHistoryThread* dthread);
- static void cleanupHistoryThreads();
+ bool historyThreadsFinished(LLUUID session_id);
+ LLLoadHistoryThread* getLoadHistoryThread(LLUUID session_id);
+ LLDeleteHistoryThread* getDeleteHistoryThread(LLUUID session_id);
+ bool addLoadHistoryThread(LLUUID& session_id, LLLoadHistoryThread* lthread);
+ bool addDeleteHistoryThread(LLUUID& session_id, LLDeleteHistoryThread* dthread);
+ void cleanupHistoryThreads();
private:
static std::string cleanFileName(std::string filename);
- static save_history_signal_t * sSaveHistorySignal;
- static std::map<LLUUID,LLLoadHistoryThread *> sLoadHistoryThreads;
- static std::map<LLUUID,LLDeleteHistoryThread *> sDeleteHistoryThreads;
- static LLMutex* sHistoryThreadsMutex;
- static LLMutex* historyThreadsMutex();
+ LLMutex* historyThreadsMutex();
+ void triggerHistorySignal();
+
+ save_history_signal_t * mSaveHistorySignal;
+ std::map<LLUUID,LLLoadHistoryThread *> mLoadHistoryThreads;
+ std::map<LLUUID,LLDeleteHistoryThread *> mDeleteHistoryThreads;
+ LLMutex* mHistoryThreadsMutex;
};
/**
diff --git a/indra/newview/llmaniptranslate.cpp b/indra/newview/llmaniptranslate.cpp
index 92a09357c8fa5adc77405f2118df0aceb10915db..9248c160c66cca92b2b839a9b6ff31699537dbfe 100644
--- a/indra/newview/llmaniptranslate.cpp
+++ b/indra/newview/llmaniptranslate.cpp
@@ -386,7 +386,7 @@ BOOL LLManipTranslate::handleMouseDownOnPart( S32 x, S32 y, MASK mask )
}
else if (gSavedSettings.getBOOL("SnapToMouseCursor"))
{
- LLUI::setMousePositionScreen(mouse_pos.mX, mouse_pos.mY);
+ LLUI::getInstance()->setMousePositionScreen(mouse_pos.mX, mouse_pos.mY);
x = mouse_pos.mX;
y = mouse_pos.mY;
}
diff --git a/indra/newview/llmarketplacefunctions.cpp b/indra/newview/llmarketplacefunctions.cpp
index a0e19f2d1965f6d6f6a5b3cb895edc7d3ffa378f..805c25508fe4f5d5e9da0d6550846154b7cdc73d 100644
--- a/indra/newview/llmarketplacefunctions.cpp
+++ b/indra/newview/llmarketplacefunctions.cpp
@@ -219,7 +219,7 @@ namespace LLMarketplaceImport
httpHeaders->append(HTTP_OUT_HEADER_CONNECTION, "Keep-Alive");
httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sMarketplaceCookie);
httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_XML);
- httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getCurrentUserAgent());
+ httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getInstance()->getCurrentUserAgent());
LLSD result = httpAdapter->postAndSuspend(httpRequest, url, LLSD(), httpOpts, httpHeaders);
@@ -283,11 +283,11 @@ namespace LLMarketplaceImport
httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sMarketplaceCookie);
httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
- httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getCurrentUserAgent());
+ httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getInstance()->getCurrentUserAgent());
}
else
{
- httpHeaders = LLViewerMedia::getHttpHeaders();
+ httpHeaders = LLViewerMedia::getInstance()->getHttpHeaders();
}
LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts, httpHeaders);
diff --git a/indra/newview/llmediactrl.cpp b/indra/newview/llmediactrl.cpp
index 7f6955d08cccaff5953c418da15d45237de5e4da..b399ab9bc4f5d0dd11e7c36b834b6fae06ab3c78 100644
--- a/indra/newview/llmediactrl.cpp
+++ b/indra/newview/llmediactrl.cpp
@@ -691,7 +691,7 @@ bool LLMediaCtrl::ensureMediaSourceExists()
if(mMediaSource.isNull())
{
// If we don't already have a media source, try to create one.
- mMediaSource = LLViewerMedia::newMediaImpl(mMediaTextureID, mTextureWidth, mTextureHeight);
+ mMediaSource = LLViewerMedia::getInstance()->newMediaImpl(mMediaTextureID, mTextureWidth, mTextureHeight);
if ( mMediaSource )
{
mMediaSource->setUsedInUI(true);
@@ -1098,7 +1098,7 @@ void LLMediaCtrl::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
auth_request_params.substitutions = args;
auth_request_params.payload = LLSD().with("media_id", mMediaTextureID);
- auth_request_params.functor.function = boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2);
+ auth_request_params.functor.function = boost::bind(&LLViewerMedia::authSubmitCallback, _1, _2);
LLNotifications::instance().add(auth_request_params);
};
break;
@@ -1144,7 +1144,7 @@ void LLMediaCtrl::onPopup(const LLSD& notification, const LLSD& response)
else
{
// Make sure the opening instance knows its window open request was denied, so it can clean things up.
- LLViewerMedia::proxyWindowClosed(notification["payload"]["uuid"]);
+ LLViewerMedia::getInstance()->proxyWindowClosed(notification["payload"]["uuid"]);
}
}
diff --git a/indra/newview/llmoveview.cpp b/indra/newview/llmoveview.cpp
index 19f238d99a67aa3a717d927a1a0b50bae12ecd5c..8fc356c9282045bbe75dded7e944ac2c95aa083d 100644
--- a/indra/newview/llmoveview.cpp
+++ b/indra/newview/llmoveview.cpp
@@ -568,7 +568,7 @@ BOOL LLPanelStandStopFlying::postBuild()
mStandButton->setCommitCallback(boost::bind(&LLPanelStandStopFlying::onStandButtonClick, this));
mStandButton->setCommitCallback(boost::bind(&LLFloaterMove::enableInstance));
mStandButton->setVisible(FALSE);
- LLHints::registerHintTarget("stand_btn", mStandButton->getHandle());
+ LLHints::getInstance()->registerHintTarget("stand_btn", mStandButton->getHandle());
mStopFlyingButton = getChild<LLButton>("stop_fly_btn");
//mStopFlyingButton->setCommitCallback(boost::bind(&LLFloaterMove::setFlyingMode, FALSE));
@@ -670,7 +670,7 @@ LLPanelStandStopFlying* LLPanelStandStopFlying::getStandStopFlyingPanel()
panel->buildFromFile("panel_stand_stop_flying.xml");
panel->setVisible(FALSE);
- //LLUI::getRootView()->addChild(panel);
+ //LLUI::getInstance()->getRootView()->addChild(panel);
LL_INFOS() << "Build LLPanelStandStopFlying panel" << LL_ENDL;
diff --git a/indra/newview/llnamelistctrl.cpp b/indra/newview/llnamelistctrl.cpp
index d7c5364fba0e27ca162b2f542719e02e72ac5f10..3209d23e430b7f127165c19fcee7444301871561 100644
--- a/indra/newview/llnamelistctrl.cpp
+++ b/indra/newview/llnamelistctrl.cpp
@@ -154,7 +154,7 @@ void LLNameListCtrl::mouseOverHighlightNthItem( S32 target_index )
bool is_mouse_over_name_cell = false;
S32 mouse_x, mouse_y;
- LLUI::getMousePositionLocal(this, &mouse_x, &mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(this, &mouse_x, &mouse_y);
S32 column_index = getColumnIndexFromOffset(mouse_x);
LLScrollListItem* hit_item = hitItem(mouse_x, mouse_y);
diff --git a/indra/newview/llnavigationbar.cpp b/indra/newview/llnavigationbar.cpp
index cfe2e6bf6a7bc17e0c4a9488549af68a0ef99622..179c64b5c572d5882e499d7211340af28464f15d 100644
--- a/indra/newview/llnavigationbar.cpp
+++ b/indra/newview/llnavigationbar.cpp
@@ -320,7 +320,7 @@ BOOL LLNavigationBar::postBuild()
LLTeleportHistory::getInstance()->setHistoryChangedCallback(
boost::bind(&LLNavigationBar::onTeleportHistoryChanged, this));
- LLHints::registerHintTarget("nav_bar", getHandle());
+ LLHints::getInstance()->registerHintTarget("nav_bar", getHandle());
mNavigationPanel = getChild<LLLayoutPanel>("navigation_layout_panel");
mFavoritePanel = getChild<LLLayoutPanel>("favorites_layout_panel");
diff --git a/indra/newview/llnetmap.cpp b/indra/newview/llnetmap.cpp
index 248c361ca40eb084f039b0854c5eff292e9d525e..fc1039b37257467074a5dfb53eaf9f5dd6cfe843 100644
--- a/indra/newview/llnetmap.cpp
+++ b/indra/newview/llnetmap.cpp
@@ -329,7 +329,7 @@ void LLNetMap::draw()
S32 local_mouse_x;
S32 local_mouse_y;
//localMouse(&local_mouse_x, &local_mouse_y);
- LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
+ LLUI::getInstance()->getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
mClosestAgentToCursor.setNull();
F32 closest_dist_squared = F32_MAX; // value will be overridden in the loop
F32 min_pick_dist_squared = (mDotRadius * MIN_PICK_SCALE) * (mDotRadius * MIN_PICK_SCALE);
@@ -835,7 +835,7 @@ BOOL LLNetMap::handleMouseUp( S32 x, S32 y, MASK mask )
LLRect clip_rect = getRect();
clip_rect.stretch(-8);
clip_rect.clipPointToRect(mMouseDown.mX, mMouseDown.mY, local_x, local_y);
- LLUI::setMousePositionLocal(this, local_x, local_y);
+ LLUI::getInstance()->setMousePositionLocal(this, local_x, local_y);
// finish the pan
mPanning = false;
diff --git a/indra/newview/llnotificationhandlerutil.cpp b/indra/newview/llnotificationhandlerutil.cpp
index 6a5819676079934bd4afc6b76e410fb3cc83a9dd..9a3f1a853a9f3066ca11193c8d4b7fb9b855411b 100644
--- a/indra/newview/llnotificationhandlerutil.cpp
+++ b/indra/newview/llnotificationhandlerutil.cpp
@@ -177,7 +177,7 @@ void LLHandlerUtil::logGroupNoticeToIMGroup(
{
// Legacy support and fallback method
// if we can't retrieve sender id from group notice system message, try to lookup it from cache
- sender_id = LLAvatarNameCache::findIdByName(sender_name);
+ sender_id = LLAvatarNameCache::getInstance()->findIdByName(sender_name);
}
logToIM(IM_SESSION_GROUP_START, group_name, sender_name, payload["message"],
diff --git a/indra/newview/llnotificationhinthandler.cpp b/indra/newview/llnotificationhinthandler.cpp
index f40369a2e061735eaa67b9eff730addf3e9c3944..f1226c53ffe0b20c135f70d02e16a6d5bc858474 100644
--- a/indra/newview/llnotificationhinthandler.cpp
+++ b/indra/newview/llnotificationhinthandler.cpp
@@ -40,17 +40,17 @@ LLHintHandler::LLHintHandler()
void LLHintHandler::onAdd(LLNotificationPtr p)
{
- LLHints::show(p);
+ LLHints::getInstance()->show(p);
}
void LLHintHandler::onLoad(LLNotificationPtr p)
{
- LLHints::show(p);
+ LLHints::getInstance()->show(p);
}
void LLHintHandler::onDelete(LLNotificationPtr p)
{
- LLHints::hide(p);
+ LLHints::getInstance()->hide(p);
}
bool LLHintHandler::processNotification(const LLNotificationPtr& p)
diff --git a/indra/newview/llpanelface.cpp b/indra/newview/llpanelface.cpp
index 2ed6ec0b0dea88721ceee2a35079076b053709be..9c80d582d5da7dd1a81aaf3eff0e07384a977d7b 100644
--- a/indra/newview/llpanelface.cpp
+++ b/indra/newview/llpanelface.cpp
@@ -1008,7 +1008,7 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/)
break;
}
- if(LLViewerMedia::textureHasMedia(id))
+ if(LLViewerMedia::getInstance()->textureHasMedia(id))
{
getChildView("button align")->setEnabled(editable);
}
@@ -2550,13 +2550,13 @@ struct LLPanelFaceSetMediaFunctor : public LLSelectedTEFunctor
const LLMediaEntry* mep = tep->hasMedia() ? tep->getMediaData() : NULL;
if ( mep )
{
- pMediaImpl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ pMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
}
if ( pMediaImpl.isNull())
{
// If we didn't find face media for this face, check whether this face is showing parcel media.
- pMediaImpl = LLViewerMedia::getMediaImplFromTextureID(tep->getID());
+ pMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(tep->getID());
}
if ( pMediaImpl.notNull())
@@ -2724,7 +2724,7 @@ void LLPanelFace::LLSelectedTE::getTexId(LLUUID& id, bool& identical)
id = image->getID();
}
- if (!id.isNull() && LLViewerMedia::textureHasMedia(id))
+ if (!id.isNull() && LLViewerMedia::getInstance()->textureHasMedia(id))
{
if (te)
{
diff --git a/indra/newview/llpanelmediasettingsgeneral.cpp b/indra/newview/llpanelmediasettingsgeneral.cpp
index 352218984230d669a9e940e2156067efd4550084..9730f0f16d9df5f95b5a4815eb8ee42efaf28a5a 100644
--- a/indra/newview/llpanelmediasettingsgeneral.cpp
+++ b/indra/newview/llpanelmediasettingsgeneral.cpp
@@ -457,7 +457,7 @@ bool LLPanelMediaSettingsGeneral::navigateHomeSelectedFace(bool only_if_current_
if (!only_if_current_is_empty || (media_data->getCurrentURL().empty() && media_data->getAutoPlay()))
{
viewer_media_t media_impl =
- LLViewerMedia::getMediaImplFromTextureID(object->getTE(face)->getMediaData()->getMediaID());
+ LLViewerMedia::getInstance()->getMediaImplFromTextureID(object->getTE(face)->getMediaData()->getMediaID());
if(media_impl)
{
media_impl->navigateHome();
diff --git a/indra/newview/llpanelnearbymedia.cpp b/indra/newview/llpanelnearbymedia.cpp
index f3a2ed94085baa3d6aa31a5ce03052eeb5d81c04..2dca55514d2b39f3ed28dc6464a3ce478e7c4e25 100644
--- a/indra/newview/llpanelnearbymedia.cpp
+++ b/indra/newview/llpanelnearbymedia.cpp
@@ -543,9 +543,10 @@ void LLPanelNearByMedia::refreshParcelItems()
// Only show "special parcel items" if "All" or "Within" filter
// (and if media is "enabled")
bool should_include = (choice == MEDIA_CLASS_ALL || choice == MEDIA_CLASS_WITHIN_PARCEL);
-
+ LLViewerMedia* media_inst = LLViewerMedia::getInstance();
+
// First Parcel Media: add or remove it as necessary
- if (gSavedSettings.getBOOL("AudioStreamingMedia") &&should_include && LLViewerMedia::hasParcelMedia())
+ if (gSavedSettings.getBOOL("AudioStreamingMedia") && should_include && media_inst->hasParcelMedia())
{
// Yes, there is parcel media.
if (NULL == mParcelMediaItem)
@@ -566,7 +567,7 @@ void LLPanelNearByMedia::refreshParcelItems()
if (NULL != mParcelMediaItem)
{
std::string name, url, tooltip;
- getNameAndUrlHelper(LLViewerParcelMedia::getParcelMedia(), name, url, "");
+ getNameAndUrlHelper(LLViewerParcelMedia::getInstance()->getParcelMedia(), name, url, "");
if (name.empty() || name == url)
{
tooltip = url;
@@ -575,20 +576,20 @@ void LLPanelNearByMedia::refreshParcelItems()
{
tooltip = name + " : " + url;
}
- LLViewerMediaImpl *impl = LLViewerParcelMedia::getParcelMedia();
+ LLViewerMediaImpl *impl = LLViewerParcelMedia::getInstance()->getParcelMedia();
updateListItem(mParcelMediaItem,
mParcelMediaName,
tooltip,
-2, // Proximity closer than anything else, before Parcel Audio
impl == NULL || impl->isMediaDisabled(),
- impl != NULL && !LLViewerParcelMedia::getURL().empty(),
+ impl != NULL && !LLViewerParcelMedia::getInstance()->getURL().empty(),
impl != NULL && impl->isMediaTimeBased() && impl->isMediaPlaying(),
MEDIA_CLASS_ALL,
"parcel media");
}
// Next Parcel Audio: add or remove it as necessary (don't show if disabled in prefs)
- if (should_include && LLViewerMedia::hasParcelAudio() && gSavedSettings.getBOOL("AudioStreamingMusic"))
+ if (should_include && media_inst->hasParcelAudio() && gSavedSettings.getBOOL("AudioStreamingMusic"))
{
// Yes, there is parcel audio.
if (NULL == mParcelAudioItem)
@@ -608,10 +609,10 @@ void LLPanelNearByMedia::refreshParcelItems()
// ... then update it
if (NULL != mParcelAudioItem)
{
- bool is_playing = LLViewerMedia::isParcelAudioPlaying();
+ bool is_playing = media_inst->isParcelAudioPlaying();
std::string url;
- url = LLViewerMedia::getParcelAudioURL();
+ url = media_inst->getParcelAudioURL();
updateListItem(mParcelAudioItem,
mParcelAudioName,
@@ -653,7 +654,8 @@ void LLPanelNearByMedia::refreshList()
refreshParcelItems();
// Get the canonical list from LLViewerMedia
- LLViewerMedia::impl_list impls = LLViewerMedia::getPriorityList();
+ LLViewerMedia* media_inst = LLViewerMedia::getInstance();
+ LLViewerMedia::impl_list impls = media_inst->getPriorityList();
LLViewerMedia::impl_list::iterator priority_iter;
U32 enabled_count = 0;
@@ -706,17 +708,17 @@ void LLPanelNearByMedia::refreshList()
}
mDisableAllCtrl->setEnabled((gSavedSettings.getBOOL("AudioStreamingMusic") ||
gSavedSettings.getBOOL("AudioStreamingMedia")) &&
- (LLViewerMedia::isAnyMediaShowing() ||
- LLViewerMedia::isParcelMediaPlaying() ||
- LLViewerMedia::isParcelAudioPlaying()));
+ (media_inst->isAnyMediaShowing() ||
+ media_inst->isParcelMediaPlaying() ||
+ media_inst->isParcelAudioPlaying()));
mEnableAllCtrl->setEnabled( (gSavedSettings.getBOOL("AudioStreamingMusic") ||
gSavedSettings.getBOOL("AudioStreamingMedia")) &&
(disabled_count > 0 ||
// parcel media (if we have it, and it isn't playing, enable "start")
- (LLViewerMedia::hasParcelMedia() && ! LLViewerMedia::isParcelMediaPlaying()) ||
+ (media_inst->hasParcelMedia() && ! media_inst->isParcelMediaPlaying()) ||
// parcel audio (if we have it, and it isn't playing, enable "start")
- (LLViewerMedia::hasParcelAudio() && ! LLViewerMedia::isParcelAudioPlaying())));
+ (media_inst->hasParcelAudio() && ! media_inst->isParcelAudioPlaying())));
// Iterate over the rows in the control, updating ones whose impl exists, and deleting ones whose impl has gone away.
std::vector<LLScrollListItem*> items = mMediaList->getAllData();
@@ -731,7 +733,7 @@ void LLPanelNearByMedia::refreshList()
if (row_id != PARCEL_MEDIA_LIST_ITEM_UUID &&
row_id != PARCEL_AUDIO_LIST_ITEM_UUID)
{
- LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(row_id);
+ LLViewerMediaImpl* impl = media_inst->getMediaImplFromTextureID(row_id);
if(impl)
{
updateListItem(item, impl);
@@ -776,26 +778,26 @@ void LLPanelNearByMedia::updateColumns()
void LLPanelNearByMedia::onClickEnableAll()
{
- LLViewerMedia::setAllMediaEnabled(true);
+ LLViewerMedia::getInstance()->setAllMediaEnabled(true);
}
void LLPanelNearByMedia::onClickDisableAll()
{
- LLViewerMedia::setAllMediaEnabled(false);
+ LLViewerMedia::getInstance()->setAllMediaEnabled(false);
}
void LLPanelNearByMedia::onClickEnableParcelMedia()
{
- if ( ! LLViewerMedia::isParcelMediaPlaying() )
+ if ( ! LLViewerMedia::getInstance()->isParcelMediaPlaying() )
{
- LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
+ LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
}
}
void LLPanelNearByMedia::onClickDisableParcelMedia()
{
// This actually unloads the impl, as opposed to "stop"ping the media
- LLViewerParcelMedia::stop();
+ LLViewerParcelMedia::getInstance()->stop();
}
void LLPanelNearByMedia::onCheckItem(LLUICtrl* ctrl, const LLUUID &row_id)
@@ -832,7 +834,7 @@ bool LLPanelNearByMedia::setDisabled(const LLUUID &row_id, bool disabled)
return true;
}
else {
- LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(row_id);
+ LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(row_id);
if(impl)
{
impl->setDisabled(disabled, true);
@@ -853,22 +855,22 @@ void LLPanelNearByMedia::onZoomMedia(void* user_data)
void LLPanelNearByMedia::onClickParcelMediaPlay()
{
- LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
+ LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
}
void LLPanelNearByMedia::onClickParcelMediaStop()
{
- if (LLViewerParcelMedia::getParcelMedia())
+ if (LLViewerParcelMedia::getInstance()->getParcelMedia())
{
// This stops the media playing, as opposed to unloading it like
// LLViewerParcelMedia::stop() does
- LLViewerParcelMedia::getParcelMedia()->stop();
+ LLViewerParcelMedia::getInstance()->getParcelMedia()->stop();
}
}
void LLPanelNearByMedia::onClickParcelMediaPause()
{
- LLViewerParcelMedia::pause();
+ LLViewerParcelMedia::getInstance()->pause();
}
void LLPanelNearByMedia::onClickParcelAudioPlay()
@@ -889,7 +891,7 @@ void LLPanelNearByMedia::onClickParcelAudioPlay()
}
else
{
- LLViewerAudio::getInstance()->startInternetStreamWithAutoFade(LLViewerMedia::getParcelAudioURL());
+ LLViewerAudio::getInstance()->startInternetStreamWithAutoFade(LLViewerMedia::getInstance()->getParcelAudioURL());
}
}
@@ -981,16 +983,17 @@ void LLPanelNearByMedia::onMoreLess()
void LLPanelNearByMedia::updateControls()
{
LLUUID selected_media_id = mMediaList->getValue().asUUID();
+ LLViewerMedia* media_inst = LLViewerMedia::getInstance();
if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID)
{
- if (!LLViewerMedia::hasParcelAudio() || !gSavedSettings.getBOOL("AudioStreamingMusic"))
+ if (!media_inst->getInstance()->hasParcelAudio() || !gSavedSettings.getBOOL("AudioStreamingMusic"))
{
// disable controls if audio streaming music is disabled from preference
showDisabledControls();
}
else {
- showTimeBasedControls(LLViewerMedia::isParcelAudioPlaying(),
+ showTimeBasedControls(media_inst->isParcelAudioPlaying(),
false, // include_zoom
false, // is_zoomed
gSavedSettings.getBOOL("MuteMusic"),
@@ -999,13 +1002,13 @@ void LLPanelNearByMedia::updateControls()
}
else if (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID)
{
- if (!LLViewerMedia::hasParcelMedia() || !gSavedSettings.getBOOL("AudioStreamingMedia"))
+ if (!media_inst->hasParcelMedia() || !gSavedSettings.getBOOL("AudioStreamingMedia"))
{
// disable controls if audio streaming media is disabled from preference
showDisabledControls();
}
else {
- LLViewerMediaImpl* impl = LLViewerParcelMedia::getParcelMedia();
+ LLViewerMediaImpl* impl = LLViewerParcelMedia::getInstance()->getParcelMedia();
if (NULL == impl)
{
// Just means it hasn't started yet
@@ -1021,7 +1024,7 @@ void LLPanelNearByMedia::updateControls()
}
else {
// non-time-based parcel media
- showBasicControls(LLViewerMedia::isParcelMediaPlaying(),
+ showBasicControls(media_inst->isParcelMediaPlaying(),
false,
false,
impl->getVolume() == 0.0,
@@ -1030,7 +1033,7 @@ void LLPanelNearByMedia::updateControls()
}
}
else {
- LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
+ LLViewerMediaImpl* impl = media_inst->getMediaImplFromTextureID(selected_media_id);
if (NULL == impl || !gSavedSettings.getBOOL("AudioStreamingMedia"))
{
@@ -1116,7 +1119,7 @@ void LLPanelNearByMedia::onClickSelectedMediaPlay()
if (selected_media_id != PARCEL_AUDIO_LIST_ITEM_UUID)
{
LLViewerMediaImpl *impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
- ((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
+ ((LLViewerMediaImpl*)LLViewerParcelMedia::getInstance()->getParcelMedia()) : LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl)
{
if (impl->isMediaTimeBased() && impl->isMediaPaused())
@@ -1127,7 +1130,7 @@ void LLPanelNearByMedia::onClickSelectedMediaPlay()
}
else if (impl->isParcelMedia())
{
- LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
+ LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
}
}
}
@@ -1145,7 +1148,7 @@ void LLPanelNearByMedia::onClickSelectedMediaPause()
onClickParcelMediaPause();
}
else {
- LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
+ LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl && impl->isMediaTimeBased() && impl->isMediaPlaying())
{
impl->pause();
@@ -1162,7 +1165,7 @@ void LLPanelNearByMedia::onClickSelectedMediaMute()
}
else {
LLViewerMediaImpl* impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
- ((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
+ ((LLViewerMediaImpl*)LLViewerParcelMedia::getInstance()->getParcelMedia()) : LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl)
{
F32 volume = impl->getVolume();
@@ -1193,7 +1196,7 @@ void LLPanelNearByMedia::onCommitSelectedMediaVolume()
}
else {
LLViewerMediaImpl* impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
- ((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
+ ((LLViewerMediaImpl*)LLViewerParcelMedia::getInstance()->getParcelMedia()) : LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl)
{
impl->setVolume(mVolumeSlider->getValueF32());
diff --git a/indra/newview/llpanelpicks.cpp b/indra/newview/llpanelpicks.cpp
index 77bc99da832c181857448174524e8fae58f040bb..c39df3fe8bbe58a6ffd101afbe975fa883f29ef9 100644
--- a/indra/newview/llpanelpicks.cpp
+++ b/indra/newview/llpanelpicks.cpp
@@ -84,7 +84,7 @@ class LLPickHandler : public LLCommandHandler,
bool handle(const LLSD& params, const LLSD& query_map,
LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnablePicks"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnablePicks"))
{
LLNotificationsUtil::add("NoPicks", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
@@ -198,7 +198,7 @@ class LLClassifiedHandler :
bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableClassifieds"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableClassifieds"))
{
LLNotificationsUtil::add("NoClassifieds", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llpanelplaces.cpp b/indra/newview/llpanelplaces.cpp
index 48dd45480e8d9efa630f7548252fc482cd59e2f6..961e2599472ff47caf1c00aef286dbc41f916319 100644
--- a/indra/newview/llpanelplaces.cpp
+++ b/indra/newview/llpanelplaces.cpp
@@ -97,7 +97,7 @@ class LLParcelHandler : public LLCommandHandler
return false;
}
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnablePlaceProfile"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnablePlaceProfile"))
{
LLNotificationsUtil::add("NoPlaceInfo", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llpanelprimmediacontrols.cpp b/indra/newview/llpanelprimmediacontrols.cpp
index 5f413fc3c0d64c1f25c44ca7cbb0bb434bb9a145..8105beae1b971cf4c81c19dae7142c1d1b3e5571 100644
--- a/indra/newview/llpanelprimmediacontrols.cpp
+++ b/indra/newview/llpanelprimmediacontrols.cpp
@@ -267,7 +267,7 @@ void LLPanelPrimMediaControls::focusOnTarget()
LLViewerMediaImpl* LLPanelPrimMediaControls::getTargetMediaImpl()
{
- return LLViewerMedia::getMediaImplFromTextureID(mTargetImplID);
+ return LLViewerMedia::getInstance()->getMediaImplFromTextureID(mTargetImplID);
}
LLViewerObject* LLPanelPrimMediaControls::getTargetObject()
diff --git a/indra/newview/llpanelprofile.cpp b/indra/newview/llpanelprofile.cpp
index 8afa35efa0b4066ab1e10b58d8af234cf792106f..5f13b223fbbf097096a59ff12f4373a27dc1b094 100644
--- a/indra/newview/llpanelprofile.cpp
+++ b/indra/newview/llpanelprofile.cpp
@@ -110,7 +110,7 @@ class LLAgentHandler : public LLCommandHandler
if (verb == "pay")
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableAvatarPay"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableAvatarPay"))
{
LLNotificationsUtil::add("NoAvatarPay", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llpersistentnotificationstorage.cpp b/indra/newview/llpersistentnotificationstorage.cpp
index 264382ae8280be64506e877e961f2d57073d1ea3..f95ab9928d54737ca17b52b204568f2abdbbcc43 100644
--- a/indra/newview/llpersistentnotificationstorage.cpp
+++ b/indra/newview/llpersistentnotificationstorage.cpp
@@ -40,6 +40,7 @@ LLPersistentNotificationStorage::LLPersistentNotificationStorage():
LLNotificationStorage("")
, mLoaded(false)
{
+ initialize();
}
LLPersistentNotificationStorage::~LLPersistentNotificationStorage()
diff --git a/indra/newview/llpersistentnotificationstorage.h b/indra/newview/llpersistentnotificationstorage.h
index 40c9923c7412036cc0b26cf1cb5ab860e0cb4acc..1fb44872867d9c0b4e1c4801766297c1b463782d 100644
--- a/indra/newview/llpersistentnotificationstorage.h
+++ b/indra/newview/llpersistentnotificationstorage.h
@@ -43,7 +43,7 @@ class LLSD;
// be a) serializable(implement LLNotificationResponderInterface),
// b) registered with LLResponderRegistry (found in llpersistentnotificationstorage.cpp).
-class LLPersistentNotificationStorage : public LLSingleton<LLPersistentNotificationStorage>, public LLNotificationStorage
+class LLPersistentNotificationStorage : public LLParamSingleton<LLPersistentNotificationStorage>, public LLNotificationStorage
{
LLSINGLETON(LLPersistentNotificationStorage);
~LLPersistentNotificationStorage();
@@ -53,11 +53,11 @@ class LLPersistentNotificationStorage : public LLSingleton<LLPersistentNotificat
void saveNotifications();
void loadNotifications();
- void initialize();
-
protected:
private:
+ void initialize();
+
bool onPersistentChannelChanged(const LLSD& payload);
bool mLoaded;
};
diff --git a/indra/newview/llpopupview.cpp b/indra/newview/llpopupview.cpp
index 153f0930c27ab5ee3b9af6545e9f8ce1fb4307ca..d1a9ca229fdcd067859ede6ccc876000bc323ed6 100644
--- a/indra/newview/llpopupview.cpp
+++ b/indra/newview/llpopupview.cpp
@@ -44,13 +44,13 @@ LLPopupView::LLPopupView(const LLPopupView::Params& p)
: LLPanel(p)
{
// register ourself as handler of UI popups
- LLUI::setPopupFuncs(boost::bind(&LLPopupView::addPopup, this, _1), boost::bind(&LLPopupView::removePopup, this, _1), boost::bind(&LLPopupView::clearPopups, this));
+ LLUI::getInstance()->setPopupFuncs(boost::bind(&LLPopupView::addPopup, this, _1), boost::bind(&LLPopupView::removePopup, this, _1), boost::bind(&LLPopupView::clearPopups, this));
}
LLPopupView::~LLPopupView()
{
// set empty callback function so we can't handle popups anymore
- LLUI::setPopupFuncs(LLUI::add_popup_t(), LLUI::remove_popup_t(), LLUI::clear_popups_t());
+ LLUI::getInstance()->setPopupFuncs(LLUI::add_popup_t(), LLUI::remove_popup_t(), LLUI::clear_popups_t());
}
void LLPopupView::draw()
diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp
index f1bb0bc27d011329cff83e7874a82ab2d1177021..d177384b5ac8c602b19d64e0b0c919d06aabac0f 100644
--- a/indra/newview/llpreviewscript.cpp
+++ b/indra/newview/llpreviewscript.cpp
@@ -885,7 +885,7 @@ bool LLScriptEdCore::handleSaveChangesDialog(const LLSD& notification, const LLS
void LLScriptEdCore::onBtnHelp()
{
- LLUI::sHelpImpl->showTopic(HELP_LSL_PORTAL_TOPIC);
+ LLUI::getInstance()->mHelpImpl->showTopic(HELP_LSL_PORTAL_TOPIC);
}
void LLScriptEdCore::onBtnDynamicHelp()
diff --git a/indra/newview/llprogressview.cpp b/indra/newview/llprogressview.cpp
index c17b86783d139ab1ded51ab9ee76e013f55a34e5..083a913ef8bb1479d0ad248d0a2209eebeb2f367 100644
--- a/indra/newview/llprogressview.cpp
+++ b/indra/newview/llprogressview.cpp
@@ -86,7 +86,7 @@ BOOL LLProgressView::postBuild()
mMediaCtrl->setVisible( false ); // hidden initially
mMediaCtrl->addObserver( this ); // watch events
- LLViewerMedia::setOnlyAudibleMediaTextureID(mMediaCtrl->getTextureID());
+ LLViewerMedia::getInstance()->setOnlyAudibleMediaTextureID(mMediaCtrl->getTextureID());
mCancelBtn = getChild<LLButton>("cancel_btn");
mCancelBtn->setClickedCallback( LLProgressView::onCancelButtonClicked, NULL );
@@ -263,7 +263,7 @@ void LLProgressView::draw()
{
mFadeToWorldTimer.stop();
- LLViewerMedia::setOnlyAudibleMediaTextureID(LLUUID::null);
+ LLViewerMedia::getInstance()->setOnlyAudibleMediaTextureID(LLUUID::null);
// Fade is complete, release focus
gFocusMgr.releaseFocusIfNeeded( this );
diff --git a/indra/newview/llsaveoutfitcombobtn.cpp b/indra/newview/llsaveoutfitcombobtn.cpp
index 32295cd96f29b3c5acf352b8accb1e571b4579fa..b1cb6d08d023d4b17dbd00b5c33f7f140bfb1503 100644
--- a/indra/newview/llsaveoutfitcombobtn.cpp
+++ b/indra/newview/llsaveoutfitcombobtn.cpp
@@ -56,7 +56,7 @@ LLSaveOutfitComboBtn::LLSaveOutfitComboBtn(LLPanel* parent, bool saveAsDefaultAc
void LLSaveOutfitComboBtn::showSaveMenu()
{
S32 x, y;
- LLUI::getMousePositionLocal(mParent, &x, &y);
+ LLUI::getInstance()->getMousePositionLocal(mParent, &x, &y);
mSaveMenu->updateParent(LLMenuGL::sMenuContainer);
LLMenuGL::showPopup(mParent, mSaveMenu, x, y);
diff --git a/indra/newview/llshareavatarhandler.cpp b/indra/newview/llshareavatarhandler.cpp
index 6b4f1d3dc67859466c6f20cf82d1ad3c23bb293b..142e00c3f7e5203437cc1848cd51e5ccfd49edf7 100644
--- a/indra/newview/llshareavatarhandler.cpp
+++ b/indra/newview/llshareavatarhandler.cpp
@@ -40,7 +40,7 @@ class LLShareWithAvatarHandler : public LLCommandHandler
bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableAvatarShare"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableAvatarShare"))
{
LLNotificationsUtil::add("NoAvatarShare", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llskinningutil.cpp b/indra/newview/llskinningutil.cpp
index 0fa4c2b114fbc51a208d62f7a143ba0b0c932203..8e1f80abfc41a4c98ff6f4a73a40b9996279bcff 100644
--- a/indra/newview/llskinningutil.cpp
+++ b/indra/newview/llskinningutil.cpp
@@ -83,10 +83,6 @@ void dump_avatar_and_skin_state(const std::string& reason, LLVOAvatar *avatar, c
}
}
-void LLSkinningUtil::initClass()
-{
-}
-
U32 LLSkinningUtil::getMaxJointCount()
{
U32 result = LL_MAX_JOINTS_PER_MESH_OBJECT;
diff --git a/indra/newview/llskinningutil.h b/indra/newview/llskinningutil.h
index ccc501adc0d7ca9958a8a82e1f1f2037e5ab920f..2c77e030aa525fd682020fffcc77ffbda0c912b2 100644
--- a/indra/newview/llskinningutil.h
+++ b/indra/newview/llskinningutil.h
@@ -34,7 +34,6 @@ class LLVolumeFace;
namespace LLSkinningUtil
{
- void initClass();
U32 getMaxJointCount();
U32 getMeshJointCount(const LLMeshSkinInfo *skin);
void scrubInvalidJoints(LLVOAvatar *avatar, LLMeshSkinInfo* skin);
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 6e0a36be4902f474088b4b450d6a344f38f58a5d..c8c39ae00f57d6c464ed1a176a35a37a391e6c8b 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -902,8 +902,13 @@ bool idle_startup()
LLFile::mkdir(gDirUtilp->getLindenUserDir());
// As soon as directories are ready initialize notification storages
- LLPersistentNotificationStorage::getInstance()->initialize();
- LLDoNotDisturbNotificationStorage::getInstance()->initialize();
+ if (!LLPersistentNotificationStorage::instanceExists())
+ {
+ // check existance since this part of code can be reached
+ // twice due to login failures
+ LLPersistentNotificationStorage::initParamSingleton();
+ LLDoNotDisturbNotificationStorage::initParamSingleton();
+ }
// Set PerAccountSettingsFile to the default value.
gSavedSettings.setString("PerAccountSettingsFile",
@@ -1236,8 +1241,6 @@ bool idle_startup()
LLSurface::initClasses();
display_startup();
-
- LLFace::initClass();
display_startup();
LLDrawable::initClass();
@@ -1299,9 +1302,13 @@ bool idle_startup()
LLStartUp::initExperiences();
display_startup();
+
+ // If logging should be enebled, turns it on and loads history from disk
+ // Note: does not happen on init of singleton because preferences can use
+ // this instance without logging in
+ LLConversationLog::getInstance()->initLoggingState();
+
LLStartUp::setStartupState( STATE_MULTIMEDIA_INIT );
-
- LLConversationLog::getInstance();
return FALSE;
}
@@ -2857,9 +2864,6 @@ void LLStartUp::multimediaInit()
std::string msg = LLTrans::getString("LoginInitializingMultimedia");
set_startup_status(0.42f, msg.c_str(), gAgent.mMOTD.c_str());
display_startup();
-
- // LLViewerMedia::initClass();
- LLViewerParcelMedia::initClass();
}
void LLStartUp::fontInit()
@@ -2887,9 +2891,10 @@ void LLStartUp::initNameCache()
// Start cache in not-running state until we figure out if we have
// capabilities for display name lookup
- LLAvatarNameCache::initClass(false,gSavedSettings.getBOOL("UsePeopleAPI"));
- LLAvatarNameCache::setUseDisplayNames(gSavedSettings.getBOOL("UseDisplayNames"));
- LLAvatarNameCache::setUseUsernames(gSavedSettings.getBOOL("NameTagShowUsernames"));
+ LLAvatarNameCache* cache_inst = LLAvatarNameCache::getInstance();
+ cache_inst->setUsePeopleAPI(gSavedSettings.getBOOL("UsePeopleAPI"));
+ cache_inst->setUseDisplayNames(gSavedSettings.getBOOL("UseDisplayNames"));
+ cache_inst->setUseUsernames(gSavedSettings.getBOOL("NameTagShowUsernames"));
}
@@ -2904,8 +2909,6 @@ void LLStartUp::initExperiences()
void LLStartUp::cleanupNameCache()
{
- SUBSYSTEM_CLEANUP(LLAvatarNameCache);
-
delete gCacheName;
gCacheName = NULL;
}
@@ -3594,7 +3597,7 @@ bool process_login_success_response()
if(!openid_url.empty())
{
std::string openid_token = response["openid_token"];
- LLViewerMedia::openIDSetup(openid_url, openid_token);
+ LLViewerMedia::getInstance()->openIDSetup(openid_url, openid_token);
}
gMaxAgentGroups = DEFAULT_MAX_AGENT_GROUPS;
diff --git a/indra/newview/llstatusbar.cpp b/indra/newview/llstatusbar.cpp
index f3c270a97be9a69c51f64742d842025d75318bc4..9eda33d3d20f22dac2309ffed79e6b1648deb87b 100644
--- a/indra/newview/llstatusbar.cpp
+++ b/indra/newview/llstatusbar.cpp
@@ -183,7 +183,7 @@ BOOL LLStatusBar::postBuild()
mMediaToggle->setClickedCallback( &LLStatusBar::onClickMediaToggle, this );
mMediaToggle->setMouseEnterCallback(boost::bind(&LLStatusBar::onMouseEnterNearbyMedia, this));
- LLHints::registerHintTarget("linden_balance", getChild<LLView>("balance_bg")->getHandle());
+ LLHints::getInstance()->registerHintTarget("linden_balance", getChild<LLView>("balance_bg")->getHandle());
gSavedSettings.getControl("MuteAudio")->getSignal()->connect(boost::bind(&LLStatusBar::onVolumeChanged, this, _2));
@@ -310,16 +310,18 @@ void LLStatusBar::refresh()
// update the master volume button state
bool mute_audio = LLAppViewer::instance()->getMasterSystemAudioMute();
mBtnVolume->setToggleState(mute_audio);
-
+
+ LLViewerMedia* media_inst = LLViewerMedia::getInstance();
+
// Disable media toggle if there's no media, parcel media, and no parcel audio
// (or if media is disabled)
bool button_enabled = (gSavedSettings.getBOOL("AudioStreamingMusic")||gSavedSettings.getBOOL("AudioStreamingMedia")) &&
- (LLViewerMedia::hasInWorldMedia() || LLViewerMedia::hasParcelMedia() || LLViewerMedia::hasParcelAudio());
+ (media_inst->hasInWorldMedia() || media_inst->hasParcelMedia() || media_inst->hasParcelAudio());
mMediaToggle->setEnabled(button_enabled);
// Note the "sense" of the toggle is opposite whether media is playing or not
- bool any_media_playing = (LLViewerMedia::isAnyMediaPlaying() ||
- LLViewerMedia::isParcelMediaPlaying() ||
- LLViewerMedia::isParcelAudioPlaying());
+ bool any_media_playing = (media_inst->isAnyMediaPlaying() ||
+ media_inst->isParcelMediaPlaying() ||
+ media_inst->isParcelAudioPlaying());
mMediaToggle->setValue(!any_media_playing);
}
@@ -501,8 +503,8 @@ void LLStatusBar::onMouseEnterPresets()
mPanelPresetsPulldown->setShape(pulldown_rect);
// show the master presets pull-down
- LLUI::clearPopups();
- LLUI::addPopup(mPanelPresetsPulldown);
+ LLUI::getInstance()->clearPopups();
+ LLUI::getInstance()->addPopup(mPanelPresetsPulldown);
mPanelNearByMedia->setVisible(FALSE);
mPanelVolumePulldown->setVisible(FALSE);
mPanelPresetsPulldown->setVisible(TRUE);
@@ -525,8 +527,8 @@ void LLStatusBar::onMouseEnterVolume()
// show the master volume pull-down
- LLUI::clearPopups();
- LLUI::addPopup(mPanelVolumePulldown);
+ LLUI::getInstance()->clearPopups();
+ LLUI::getInstance()->addPopup(mPanelVolumePulldown);
mPanelPresetsPulldown->setVisible(FALSE);
mPanelNearByMedia->setVisible(FALSE);
mPanelVolumePulldown->setVisible(TRUE);
@@ -548,8 +550,8 @@ void LLStatusBar::onMouseEnterNearbyMedia()
// show the master volume pull-down
mPanelNearByMedia->setShape(nearby_media_rect);
- LLUI::clearPopups();
- LLUI::addPopup(mPanelNearByMedia);
+ LLUI::getInstance()->clearPopups();
+ LLUI::getInstance()->addPopup(mPanelNearByMedia);
mPanelPresetsPulldown->setVisible(FALSE);
mPanelVolumePulldown->setVisible(FALSE);
@@ -578,7 +580,7 @@ void LLStatusBar::onClickMediaToggle(void* data)
LLStatusBar *status_bar = (LLStatusBar*)data;
// "Selected" means it was showing the "play" icon (so media was playing), and now it shows "pause", so turn off media
bool pause = status_bar->mMediaToggle->getValue();
- LLViewerMedia::setAllMediaPaused(pause);
+ LLViewerMedia::getInstance()->setAllMediaPaused(pause);
}
BOOL can_afford_transaction(S32 cost)
diff --git a/indra/newview/lltexturectrl.cpp b/indra/newview/lltexturectrl.cpp
index 8a2fc881a94c05240624266ccfbbb7071df2a7e1..e2bb904eff0ffdd003fad4596ee8e94cfde648ec 100644
--- a/indra/newview/lltexturectrl.cpp
+++ b/indra/newview/lltexturectrl.cpp
@@ -410,7 +410,7 @@ BOOL LLFloaterTexturePicker::postBuild()
mLocalScrollCtrl = getChild<LLScrollListCtrl>("l_name_list");
mLocalScrollCtrl->setCommitCallback(onLocalScrollCommit, this);
- LLLocalBitmapMgr::feedScrollList(mLocalScrollCtrl);
+ LLLocalBitmapMgr::getInstance()->feedScrollList(mLocalScrollCtrl);
mNoCopyTextureSelected = FALSE;
@@ -743,7 +743,7 @@ void LLFloaterTexturePicker::onBtnSelect(void* userdata)
if (self->mLocalScrollCtrl->getVisible() && !self->mLocalScrollCtrl->getAllSelected().empty())
{
LLUUID temp_id = self->mLocalScrollCtrl->getFirstSelected()->getColumn(LOCAL_TRACKING_ID_COLUMN)->getValue().asUUID();
- local_id = LLLocalBitmapMgr::getWorldID(temp_id);
+ local_id = LLLocalBitmapMgr::getInstance()->getWorldID(temp_id);
}
}
@@ -890,10 +890,10 @@ void LLFloaterTexturePicker::onModeSelect(LLUICtrl* ctrl, void *userdata)
// static
void LLFloaterTexturePicker::onBtnAdd(void* userdata)
{
- if (LLLocalBitmapMgr::addUnit() == true)
+ if (LLLocalBitmapMgr::getInstance()->addUnit() == true)
{
LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
- LLLocalBitmapMgr::feedScrollList(self->mLocalScrollCtrl);
+ LLLocalBitmapMgr::getInstance()->feedScrollList(self->mLocalScrollCtrl);
}
}
@@ -912,13 +912,13 @@ void LLFloaterTexturePicker::onBtnRemove(void* userdata)
if (list_item)
{
LLUUID tracking_id = list_item->getColumn(LOCAL_TRACKING_ID_COLUMN)->getValue().asUUID();
- LLLocalBitmapMgr::delUnit(tracking_id);
+ LLLocalBitmapMgr::getInstance()->delUnit(tracking_id);
}
}
self->getChild<LLButton>("l_rem_btn")->setEnabled(false);
self->getChild<LLButton>("l_upl_btn")->setEnabled(false);
- LLLocalBitmapMgr::feedScrollList(self->mLocalScrollCtrl);
+ LLLocalBitmapMgr::getInstance()->feedScrollList(self->mLocalScrollCtrl);
}
}
@@ -938,7 +938,7 @@ void LLFloaterTexturePicker::onBtnUpload(void* userdata)
in the future, it might be a good idea to check the vector size and if more than one units is selected - opt for multi-image upload. */
LLUUID tracking_id = (LLUUID)self->mLocalScrollCtrl->getSelectedItemLabel(LOCAL_TRACKING_ID_COLUMN);
- std::string filename = LLLocalBitmapMgr::getFilename(tracking_id);
+ std::string filename = LLLocalBitmapMgr::getInstance()->getFilename(tracking_id);
if (!filename.empty())
{
@@ -961,7 +961,7 @@ void LLFloaterTexturePicker::onLocalScrollCommit(LLUICtrl* ctrl, void* userdata)
if (has_selection)
{
LLUUID tracking_id = (LLUUID)self->mLocalScrollCtrl->getSelectedItemLabel(LOCAL_TRACKING_ID_COLUMN);
- LLUUID inworld_id = LLLocalBitmapMgr::getWorldID(tracking_id);
+ LLUUID inworld_id = LLLocalBitmapMgr::getInstance()->getWorldID(tracking_id);
if (self->mSetImageAssetIDCallback)
{
self->mSetImageAssetIDCallback(inworld_id);
diff --git a/indra/newview/lltoast.cpp b/indra/newview/lltoast.cpp
index b9b05966bc9e1ced2babfa6b987963271002c2c9..870e0d94f0c03518b6dda3e5924ea5382afe378a 100644
--- a/indra/newview/lltoast.cpp
+++ b/indra/newview/lltoast.cpp
@@ -430,7 +430,7 @@ void LLToast::setVisible(BOOL show)
void LLToast::updateHoveredState()
{
S32 x, y;
- LLUI::getMousePositionScreen(&x, &y);
+ LLUI::getInstance()->getMousePositionScreen(&x, &y);
LLRect panel_rc = mWrapperPanel->calcScreenRect();
LLRect button_rc;
diff --git a/indra/newview/lltoastalertpanel.cpp b/indra/newview/lltoastalertpanel.cpp
index 495c9c1f449e052056780369a4ce54670fb5ac17..941cb410fcab88f227754ed9eccad010a8659af1 100644
--- a/indra/newview/lltoastalertpanel.cpp
+++ b/indra/newview/lltoastalertpanel.cpp
@@ -45,6 +45,7 @@
#include "llrootview.h"
#include "lltransientfloatermgr.h"
#include "llviewercontrol.h" // for gSavedSettings
+#include "llweb.h"
#include <boost/algorithm/string.hpp>
@@ -52,7 +53,6 @@ const S32 MAX_ALLOWED_MSG_WIDTH = 400;
const F32 DEFAULT_BUTTON_DELAY = 0.5f;
/*static*/ LLControlGroup* LLToastAlertPanel::sSettings = NULL;
-/*static*/ LLToastAlertPanel::URLLoader* LLToastAlertPanel::sURLLoader;
//-----------------------------------------------------------------------------
// Private methods
@@ -555,9 +555,16 @@ void LLToastAlertPanel::onButtonPressed( const LLSD& data, S32 button )
response[button_data->mButton->getName()] = true;
// If we declared a URL and chose the URL option, go to the url
- if (!button_data->mURL.empty() && sURLLoader != NULL)
+ if (!button_data->mURL.empty())
{
- sURLLoader->load(button_data->mURL, button_data->mURLExternal);
+ if (button_data->mURLExternal)
+ {
+ LLWeb::loadURLExternal(button_data->mURL);
+ }
+ else
+ {
+ LLWeb::loadURL(button_data->mURL);
+ }
}
mNotification->respond(response); // new notification reponse
diff --git a/indra/newview/lltoastalertpanel.h b/indra/newview/lltoastalertpanel.h
index d1be5e018ead9eae01a34701e18eaef821f7726d..15bf11d42c83ecb622b67f7be6932d29bffa935c 100644
--- a/indra/newview/lltoastalertpanel.h
+++ b/indra/newview/lltoastalertpanel.h
@@ -52,20 +52,6 @@ class LLToastAlertPanel
public:
typedef bool (*display_callback_t)(S32 modal);
- class URLLoader
- {
- public:
- virtual void load(const std::string& url, bool force_open_externally = 0) = 0;
- virtual ~URLLoader()
- {
- }
- };
-
- static void setURLLoader(URLLoader* loader)
- {
- sURLLoader = loader;
- }
-
public:
// User's responsibility to call show() after creating these.
LLToastAlertPanel( LLNotificationPtr notep, bool is_modal );
@@ -94,7 +80,6 @@ class LLToastAlertPanel
BOOL hasTitleBar() const;
private:
- static URLLoader* sURLLoader;
static LLControlGroup* sSettings;
struct ButtonData
diff --git a/indra/newview/lltoolfocus.cpp b/indra/newview/lltoolfocus.cpp
index 596951fdfb41d50053cbb0a9883c12fb247908e8..07f46c5fbe07e08669b25992412af8ab4d970162 100644
--- a/indra/newview/lltoolfocus.cpp
+++ b/indra/newview/lltoolfocus.cpp
@@ -293,12 +293,12 @@ BOOL LLToolCamera::handleMouseUp(S32 x, S32 y, MASK mask)
BOOL success = LLViewerCamera::getInstance()->projectPosAgentToScreen(focus_pos, mouse_pos);
if (success)
{
- LLUI::setMousePositionScreen(mouse_pos.mX, mouse_pos.mY);
+ LLUI::getInstance()->setMousePositionScreen(mouse_pos.mX, mouse_pos.mY);
}
}
else if (mMouseSteering)
{
- LLUI::setMousePositionScreen(mMouseDownX, mMouseDownY);
+ LLUI::getInstance()->setMousePositionScreen(mMouseDownX, mMouseDownY);
}
else
{
@@ -308,7 +308,7 @@ BOOL LLToolCamera::handleMouseUp(S32 x, S32 y, MASK mask)
else
{
// not a valid zoomable object
- LLUI::setMousePositionScreen(mMouseDownX, mMouseDownY);
+ LLUI::getInstance()->setMousePositionScreen(mMouseDownX, mMouseDownY);
}
// calls releaseMouse() internally
diff --git a/indra/newview/lltoolgrab.cpp b/indra/newview/lltoolgrab.cpp
index f3e661e71a3007f574e4cd8ed463ee073d91bca2..3831f7d67dae7ab81943e0bde176d5617853d0bc 100644
--- a/indra/newview/lltoolgrab.cpp
+++ b/indra/newview/lltoolgrab.cpp
@@ -1001,7 +1001,7 @@ void LLToolGrabBase::onMouseCaptureLost()
// ...move cursor "naturally", as if it had moved when hidden
S32 x = mGrabPick.mMousePt.mX + mAccumDeltaX;
S32 y = mGrabPick.mMousePt.mY + mAccumDeltaY;
- LLUI::setMousePositionScreen(x, y);
+ LLUI::getInstance()->setMousePositionScreen(x, y);
}
else if (mHasMoved)
{
@@ -1011,13 +1011,13 @@ void LLToolGrabBase::onMouseCaptureLost()
LLCoordGL gl_point;
if (LLViewerCamera::getInstance()->projectPosAgentToScreen(grab_point_agent, gl_point))
{
- LLUI::setMousePositionScreen(gl_point.mX, gl_point.mY);
+ LLUI::getInstance()->setMousePositionScreen(gl_point.mX, gl_point.mY);
}
}
else
{
// ...move cursor back to click position
- LLUI::setMousePositionScreen(mGrabPick.mMousePt.mX, mGrabPick.mMousePt.mY);
+ LLUI::getInstance()->setMousePositionScreen(mGrabPick.mMousePt.mX, mGrabPick.mMousePt.mY);
}
gViewerWindow->showCursor();
diff --git a/indra/newview/lltoolpie.cpp b/indra/newview/lltoolpie.cpp
index 2a87bce134c139eaa9c2d6d7cb0dee35b9b8d37a..54df5198c8c95a18d5e5e453a6c65486c6bfa98f 100644
--- a/indra/newview/lltoolpie.cpp
+++ b/indra/newview/lltoolpie.cpp
@@ -1185,7 +1185,7 @@ BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string l
const LLMediaEntry* mep = has_media ? tep->getMediaData() : NULL;
if (mep)
{
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
LLPluginClassMedia* media_plugin = NULL;
if (media_impl.notNull() && (media_impl->hasMedia()))
@@ -1255,7 +1255,7 @@ BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string l
BOOL LLToolPie::handleToolTip(S32 local_x, S32 local_y, MASK mask)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("ShowHoverTips")) return TRUE;
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("ShowHoverTips")) return TRUE;
if (!mHoverPick.isValid()) return TRUE;
LLViewerObject* hover_object = mHoverPick.getObject();
@@ -1360,7 +1360,7 @@ void LLToolPie::playCurrentMedia(const LLPickInfo& info)
LLPluginClassMedia* media_plugin = NULL;
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if(media_impl.notNull() && media_impl->hasMedia())
{
@@ -1412,7 +1412,7 @@ void LLToolPie::VisitHomePage(const LLPickInfo& info)
LLPluginClassMedia* media_plugin = NULL;
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if(media_impl.notNull() && media_impl->hasMedia())
{
@@ -1512,19 +1512,19 @@ static void handle_click_action_play()
LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
if (!parcel) return;
- LLViewerMediaImpl::EMediaStatus status = LLViewerParcelMedia::getStatus();
+ LLViewerMediaImpl::EMediaStatus status = LLViewerParcelMedia::getInstance()->getStatus();
switch(status)
{
case LLViewerMediaImpl::MEDIA_PLAYING:
- LLViewerParcelMedia::pause();
+ LLViewerParcelMedia::getInstance()->pause();
break;
case LLViewerMediaImpl::MEDIA_PAUSED:
- LLViewerParcelMedia::start();
+ LLViewerParcelMedia::getInstance()->start();
break;
default:
- LLViewerParcelMedia::play(parcel);
+ LLViewerParcelMedia::getInstance()->play(parcel);
break;
}
}
@@ -1555,7 +1555,7 @@ bool LLToolPie::handleMediaClick(const LLPickInfo& pick)
if (!mep)
return false;
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if (gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
@@ -1609,7 +1609,7 @@ bool LLToolPie::handleMediaDblClick(const LLPickInfo& pick)
if (!mep)
return false;
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if (gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
@@ -1664,7 +1664,7 @@ bool LLToolPie::handleMediaHover(const LLPickInfo& pick)
if (mep
&& gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if(media_impl.notNull())
{
@@ -1702,7 +1702,7 @@ bool LLToolPie::handleMediaMouseUp()
if(mMediaMouseCaptureID.notNull())
{
// Face media needs to know the mouse went up.
- viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mMediaMouseCaptureID);
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaMouseCaptureID);
if(media_impl)
{
// This will send a mouseUp event to the plugin using the last known mouse coordinate (from a mouseDown or mouseMove), which is what we want.
@@ -1731,7 +1731,7 @@ static void handle_click_action_open_media(LLPointer<LLViewerObject> objectp)
if( face < 0 || face >= objectp->getNumTEs() ) return;
// is media playing on this face?
- if (LLViewerMedia::getMediaImplFromTextureID(objectp->getTE(face)->getID()) != NULL)
+ if (LLViewerMedia::getInstance()->getMediaImplFromTextureID(objectp->getTE(face)->getID()) != NULL)
{
handle_click_action_play();
return;
@@ -1761,7 +1761,7 @@ static ECursorType cursor_from_parcel_media(U8 click_action)
open_cursor = UI_CURSOR_TOOLMEDIAOPEN;
- LLViewerMediaImpl::EMediaStatus status = LLViewerParcelMedia::getStatus();
+ LLViewerMediaImpl::EMediaStatus status = LLViewerParcelMedia::getInstance()->getStatus();
switch(status)
{
case LLViewerMediaImpl::MEDIA_PLAYING:
diff --git a/indra/newview/lluilistener.cpp b/indra/newview/lluilistener.cpp
index 6b2cd71d406ac4a493eb6de9dd66a6b9d2b2d2b5..956f5cf187acecbabdc369c56a9e253dc5f35d9e 100644
--- a/indra/newview/lluilistener.cpp
+++ b/indra/newview/lluilistener.cpp
@@ -84,8 +84,8 @@ void LLUIListener::getValue(const LLSD&event) const
{
LLSD reply = LLSD::emptyMap();
- const LLView* root = LLUI::getRootView();
- const LLView* view = LLUI::resolvePath(root, event["path"].asString());
+ const LLView* root = LLUI::getInstance()->getRootView();
+ const LLView* view = LLUI::getInstance()->resolvePath(root, event["path"].asString());
const LLUICtrl* ctrl(dynamic_cast<const LLUICtrl*>(view));
if (ctrl)
diff --git a/indra/newview/llurldispatcher.cpp b/indra/newview/llurldispatcher.cpp
index da31e4f54246beb9d90d9840fa26f96ed1875e40..a1670351f4005da600c0e90a9470dba1eadcd4b0 100644
--- a/indra/newview/llurldispatcher.cpp
+++ b/indra/newview/llurldispatcher.cpp
@@ -188,7 +188,7 @@ bool LLURLDispatcherImpl::dispatchRegion(const LLSLURL& slurl, const std::string
LLWorldMapMessage::getInstance()->sendNamedRegionRequest(slurl.getRegion(),
LLURLDispatcherImpl::regionNameCallback,
slurl.getSLURLString(),
- LLUI::sSettingGroups["config"]->getBOOL("SLURLTeleportDirectly")); // don't teleport
+ LLUI::getInstance()->mSettingGroups["config"]->getBOOL("SLURLTeleportDirectly")); // don't teleport
return true;
}
diff --git a/indra/newview/llurllineeditorctrl.cpp b/indra/newview/llurllineeditorctrl.cpp
index 8a6111485264b7ea297fab407f3c558365c5c2df..2b7e598a590cea853e8eb30d22efc0a635ac1f61 100644
--- a/indra/newview/llurllineeditorctrl.cpp
+++ b/indra/newview/llurllineeditorctrl.cpp
@@ -66,7 +66,7 @@ void LLURLLineEditor::cut()
if( need_to_rollback )
{
rollback.doRollback( this );
- LLUI::reportBadKeystroke();
+ LLUI::getInstance()->reportBadKeystroke();
}
else
if( mKeystrokeCallback )
diff --git a/indra/newview/llurlwhitelist.cpp b/indra/newview/llurlwhitelist.cpp
index 3a7285974e4041381b069b8edce0453308c17461..b4d38f5d1e7f9e948d21c94de35d5f4425b5dba5 100644
--- a/indra/newview/llurlwhitelist.cpp
+++ b/indra/newview/llurlwhitelist.cpp
@@ -31,8 +31,6 @@
#include <iostream>
#include <fstream>
-LLUrlWhiteList* LLUrlWhiteList::sInstance = 0;
-
///////////////////////////////////////////////////////////////////////////////
//
LLUrlWhiteList::LLUrlWhiteList () :
@@ -49,29 +47,6 @@ LLUrlWhiteList::~LLUrlWhiteList ()
{
}
-///////////////////////////////////////////////////////////////////////////////
-
-//static
-void LLUrlWhiteList::initClass ()
-{
- if ( ! sInstance )
- {
- sInstance = new LLUrlWhiteList ();
- }
-}
-
-//static
-void LLUrlWhiteList::cleanupClass ()
-{
- delete sInstance;
- sInstance = NULL;
-}
-
-LLUrlWhiteList* LLUrlWhiteList::getInstance ()
-{
- return sInstance;
-}
-
///////////////////////////////////////////////////////////////////////////////
//
bool LLUrlWhiteList::load ()
diff --git a/indra/newview/llurlwhitelist.h b/indra/newview/llurlwhitelist.h
index b0969051a76afcabdef7a16a9ce5b61ab6647803..c2511b08fd8da4a9fec2220c8d00197453d45907 100644
--- a/indra/newview/llurlwhitelist.h
+++ b/indra/newview/llurlwhitelist.h
@@ -30,15 +30,11 @@
#include <list>
-class LLUrlWhiteList
+class LLUrlWhiteList : public LLSingleton<LLUrlWhiteList>
{
+ LLSINGLETON(LLUrlWhiteList);
+ ~LLUrlWhiteList();
public:
- virtual ~LLUrlWhiteList ();
-
- static void initClass();
- static void cleanupClass();
- static LLUrlWhiteList* getInstance ();
-
bool load ();
bool save ();
@@ -51,9 +47,6 @@ class LLUrlWhiteList
bool getNext ( std::string& valueOut );
private:
- LLUrlWhiteList ();
- static LLUrlWhiteList* sInstance;
-
typedef std::vector < std::string > string_list_t ;
bool mLoaded;
diff --git a/indra/newview/llvieweraudio.cpp b/indra/newview/llvieweraudio.cpp
index 7ce9d858dd89ee068bcd51a77fcb529098a8df0e..cb20801756162acdc62b78f58a3382fee5a25d95 100644
--- a/indra/newview/llvieweraudio.cpp
+++ b/indra/newview/llvieweraudio.cpp
@@ -463,24 +463,25 @@ void audio_update_volume(bool force_update)
F32 media_volume = gSavedSettings.getF32("AudioLevelMedia");
BOOL media_muted = gSavedSettings.getBOOL("MuteMedia");
media_volume = mute_volume * master_volume * media_volume;
- LLViewerMedia::setVolume( media_muted ? 0.0f : media_volume );
+ LLViewerMedia::getInstance()->setVolume( media_muted ? 0.0f : media_volume );
- // Voice
- if (LLVoiceClient::getInstance())
+ // Voice, this is parametric singleton, it gets initialized when ready
+ if (LLVoiceClient::instanceExists())
{
F32 voice_volume = gSavedSettings.getF32("AudioLevelVoice");
voice_volume = mute_volume * master_volume * voice_volume;
BOOL voice_mute = gSavedSettings.getBOOL("MuteVoice");
- LLVoiceClient::getInstance()->setVoiceVolume(voice_mute ? 0.f : voice_volume);
- LLVoiceClient::getInstance()->setMicGain(voice_mute ? 0.f : gSavedSettings.getF32("AudioLevelMic"));
+ LLVoiceClient *voice_inst = LLVoiceClient::getInstance();
+ voice_inst->setVoiceVolume(voice_mute ? 0.f : voice_volume);
+ voice_inst->setMicGain(voice_mute ? 0.f : gSavedSettings.getF32("AudioLevelMic"));
if (!gViewerWindow->getActive() && (gSavedSettings.getBOOL("MuteWhenMinimized")))
{
- LLVoiceClient::getInstance()->setMuteMic(true);
+ voice_inst->setMuteMic(true);
}
else
{
- LLVoiceClient::getInstance()->setMuteMic(false);
+ voice_inst->setMuteMic(false);
}
}
}
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 5924dbc260ca8cdc5f612fb6dad09a8b03214d37..d8526e63caeed25370cb7cdcc339a74a2927d8ed 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -1508,9 +1508,10 @@ void render_ui_2d()
if (gSavedSettings.getBOOL("RenderUIBuffer"))
{
- if (LLUI::sDirty)
+ LLUI* ui_inst = LLUI::getInstance();
+ if (ui_inst->mDirty)
{
- LLUI::sDirty = FALSE;
+ ui_inst->mDirty = FALSE;
LLRect t_rect;
gPipeline.mUIScreen.bindTarget();
@@ -1518,25 +1519,25 @@ void render_ui_2d()
{
static const S32 pad = 8;
- LLUI::sDirtyRect.mLeft -= pad;
- LLUI::sDirtyRect.mRight += pad;
- LLUI::sDirtyRect.mBottom -= pad;
- LLUI::sDirtyRect.mTop += pad;
+ ui_inst->mDirtyRect.mLeft -= pad;
+ ui_inst->mDirtyRect.mRight += pad;
+ ui_inst->mDirtyRect.mBottom -= pad;
+ ui_inst->mDirtyRect.mTop += pad;
LLGLEnable scissor(GL_SCISSOR_TEST);
- static LLRect last_rect = LLUI::sDirtyRect;
+ static LLRect last_rect = ui_inst->mDirtyRect;
//union with last rect to avoid mouse poop
- last_rect.unionWith(LLUI::sDirtyRect);
+ last_rect.unionWith(ui_inst->mDirtyRect);
- t_rect = LLUI::sDirtyRect;
- LLUI::sDirtyRect = last_rect;
+ t_rect = ui_inst->mDirtyRect;
+ ui_inst->mDirtyRect = last_rect;
last_rect = t_rect;
- last_rect.mLeft = LLRect::tCoordType(last_rect.mLeft / LLUI::getScaleFactor().mV[0]);
- last_rect.mRight = LLRect::tCoordType(last_rect.mRight / LLUI::getScaleFactor().mV[0]);
- last_rect.mTop = LLRect::tCoordType(last_rect.mTop / LLUI::getScaleFactor().mV[1]);
- last_rect.mBottom = LLRect::tCoordType(last_rect.mBottom / LLUI::getScaleFactor().mV[1]);
+ last_rect.mLeft = LLRect::tCoordType(last_rect.mLeft / ui_inst->getScaleFactor().mV[0]);
+ last_rect.mRight = LLRect::tCoordType(last_rect.mRight / ui_inst->getScaleFactor().mV[0]);
+ last_rect.mTop = LLRect::tCoordType(last_rect.mTop / ui_inst->getScaleFactor().mV[1]);
+ last_rect.mBottom = LLRect::tCoordType(last_rect.mBottom / ui_inst->getScaleFactor().mV[1]);
LLRect clip_rect(last_rect);
@@ -1548,7 +1549,7 @@ void render_ui_2d()
gPipeline.mUIScreen.flush();
gGL.setColorMask(true, false);
- LLUI::sDirtyRect = t_rect;
+ ui_inst->mDirtyRect = t_rect;
}
LLGLDisable cull(GL_CULL_FACE);
diff --git a/indra/newview/llviewerinventory.cpp b/indra/newview/llviewerinventory.cpp
index 61857d6fb1afef1209f5db81a00e107c7672ecc0..9d7da115ac8b4afd9b74112b5983facf13602b41 100644
--- a/indra/newview/llviewerinventory.cpp
+++ b/indra/newview/llviewerinventory.cpp
@@ -238,7 +238,7 @@ class LLInventoryHandler : public LLCommandHandler
return false;
}
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableInventory"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableInventory"))
{
LLNotificationsUtil::add("NoInventory", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index a27a083a2acf89e553aafc4091d70430b94b044b..6cfc22a4e596d31141c5527f7f6541c04f8ef5d0 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -77,12 +77,6 @@
#include <boost/bind.hpp> // for SkinFolder listener
#include <boost/signals2.hpp>
-/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "ParcelMediaAutoPlayEnable";
-/*static*/ const char* LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING = "MediaShowOnOthers";
-/*static*/ const char* LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING = "MediaShowWithinParcel";
-/*static*/ const char* LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING = "MediaShowOutsideParcel";
-
-
class LLMediaFilePicker : public LLFilePickerThread // deletes itself when done
{
public:
@@ -191,9 +185,6 @@ LLViewerMediaObserver::~LLViewerMediaObserver()
}
-LLURL LLViewerMedia::sOpenIDURL;
-std::string LLViewerMedia::sOpenIDCookie;
-LLPluginClassMedia* LLViewerMedia::sSpareBrowserMediaSource = NULL;
static LLViewerMedia::impl_list sViewerMediaImplList;
static LLViewerMedia::impl_id_map sViewerMediaTextureIDMap;
static LLTimer sMediaCreateTimer;
@@ -203,8 +194,6 @@ static bool sForceUpdate = false;
static LLUUID sOnlyAudibleTextureID = LLUUID::null;
static F64 sLowestLoadableImplInterest = 0.0f;
static bool sAnyMediaShowing = false;
-static bool sAnyMediaPlaying = false;
-static boost::signals2::connection sTeleportFinishConnection;
//////////////////////////////////////////////////////////////////////////////////////////
static void add_media_impl(LLViewerMediaImpl* media)
@@ -230,7 +219,7 @@ static void remove_media_impl(LLViewerMediaImpl* media)
class LLViewerMediaMuteListObserver : public LLMuteListObserver
{
- /* virtual */ void onChange() { LLViewerMedia::muteListChanged();}
+ /* virtual */ void onChange() { LLViewerMedia::getInstance()->muteListChanged();}
};
static LLViewerMediaMuteListObserver sViewerMediaMuteListObserver;
@@ -239,9 +228,40 @@ static bool sViewerMediaMuteListObserverInitialized = false;
//////////////////////////////////////////////////////////////////////////////////////////
// LLViewerMedia
-
//////////////////////////////////////////////////////////////////////////////////////////
+
+/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "ParcelMediaAutoPlayEnable";
+/*static*/ const char* LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING = "MediaShowOnOthers";
+/*static*/ const char* LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING = "MediaShowWithinParcel";
+/*static*/ const char* LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING = "MediaShowOutsideParcel";
+
+LLViewerMedia::LLViewerMedia():
+mAnyMediaShowing(false),
+mAnyMediaPlaying(false),
+mSpareBrowserMediaSource(NULL)
+{
+}
+
+LLViewerMedia::~LLViewerMedia()
+{
+ gIdleCallbacks.deleteFunction(LLViewerMedia::onIdle, NULL);
+ mTeleportFinishConnection.disconnect();
+ if (mSpareBrowserMediaSource != NULL)
+ {
+ delete mSpareBrowserMediaSource;
+ mSpareBrowserMediaSource = NULL;
+ }
+}
+
// static
+void LLViewerMedia::initSingleton()
+{
+ gIdleCallbacks.addFunction(LLViewerMedia::onIdle, NULL);
+ mTeleportFinishConnection = LLViewerParcelMgr::getInstance()->
+ setTeleportFinishedCallback(boost::bind(&LLViewerMedia::onTeleportFinished, this));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
viewer_media_t LLViewerMedia::newMediaImpl(
const LLUUID& texture_id,
S32 media_width,
@@ -368,7 +388,6 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& texture_id)
{
LLViewerMediaImpl* result = NULL;
@@ -384,7 +403,6 @@ LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& textur
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
std::string LLViewerMedia::getCurrentUserAgent()
{
// Don't use user-visible string to avoid
@@ -411,7 +429,6 @@ std::string LLViewerMedia::getCurrentUserAgent()
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::updateBrowserUserAgent()
{
std::string user_agent = getCurrentUserAgent();
@@ -431,7 +448,6 @@ void LLViewerMedia::updateBrowserUserAgent()
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
{
// gSavedSettings is already updated when this function is called.
@@ -440,7 +456,6 @@ bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::textureHasMedia(const LLUUID& texture_id)
{
impl_list::iterator iter = sViewerMediaImplList.begin();
@@ -458,7 +473,6 @@ bool LLViewerMedia::textureHasMedia(const LLUUID& texture_id)
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setVolume(F32 volume)
{
if(volume != sGlobalVolume || sForceUpdate)
@@ -478,14 +492,12 @@ void LLViewerMedia::setVolume(F32 volume)
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
F32 LLViewerMedia::getVolume()
{
return sGlobalVolume;
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::muteListChanged()
{
// When the mute list changes, we need to check mute status on all impls.
@@ -500,7 +512,6 @@ void LLViewerMedia::muteListChanged()
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::isInterestingEnough(const LLVOVolume *object, const F64 &object_interest)
{
bool result = false;
@@ -535,6 +546,7 @@ LLViewerMedia::impl_list &LLViewerMedia::getPriorityList()
return sViewerMediaImplList;
}
+// static
// This is the predicate function used to sort sViewerMediaImplList by priority.
bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
{
@@ -629,7 +641,12 @@ static LLTrace::BlockTimerStatHandle FTM_MEDIA_MISC("Misc");
//////////////////////////////////////////////////////////////////////////////////////////
-// static
+void LLViewerMedia::onIdle(void *dummy_arg)
+{
+ LLViewerMedia::getInstance()->updateMedia(dummy_arg);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
void LLViewerMedia::updateMedia(void *dummy_arg)
{
LL_RECORD_BLOCK_TIME(FTM_MEDIA_UPDATE);
@@ -642,8 +659,8 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
// removing it for now.
//createSpareBrowserMediaSource();
- sAnyMediaShowing = false;
- sAnyMediaPlaying = false;
+ mAnyMediaShowing = false;
+ mAnyMediaPlaying = false;
impl_list::iterator iter = sViewerMediaImplList.begin();
impl_list::iterator end = sViewerMediaImplList.end();
@@ -659,10 +676,10 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
}
// Let the spare media source actually launch
- if(sSpareBrowserMediaSource)
+ if(mSpareBrowserMediaSource)
{
LL_RECORD_BLOCK_TIME(FTM_MEDIA_SPARE_IDLE);
- sSpareBrowserMediaSource->idle();
+ mSpareBrowserMediaSource->idle();
}
{
@@ -854,7 +871,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
if (!pimpl->getUsedInUI() && pimpl->hasMedia() && (pimpl->isMediaPlaying() || !pimpl->isMediaTimeBased()))
{
// consider visible non-timebased media as playing
- sAnyMediaPlaying = true;
+ mAnyMediaPlaying = true;
}
}
@@ -899,21 +916,18 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::isAnyMediaShowing()
{
- return sAnyMediaShowing;
+ return mAnyMediaShowing;
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::isAnyMediaPlaying()
{
- return sAnyMediaPlaying;
+ return mAnyMediaPlaying;
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setAllMediaEnabled(bool val)
{
// Set "tentative" autoplay first. We need to do this here or else
@@ -938,7 +952,7 @@ void LLViewerMedia::setAllMediaEnabled(bool val)
{
if (!LLViewerMedia::isParcelMediaPlaying() && LLViewerMedia::hasParcelMedia())
{
- LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
+ LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
}
static LLCachedControl<bool> audio_streaming_music(gSavedSettings, "AudioStreamingMusic", true);
@@ -960,7 +974,7 @@ void LLViewerMedia::setAllMediaEnabled(bool val)
}
else {
// This actually unloads the impl, as opposed to "stop"ping the media
- LLViewerParcelMedia::stop();
+ LLViewerParcelMedia::getInstance()->stop();
if (gAudiop)
{
LLViewerAudio::getInstance()->stopInternetStreamWithAutoFade();
@@ -969,7 +983,6 @@ void LLViewerMedia::setAllMediaEnabled(bool val)
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setAllMediaPaused(bool val)
{
// Set "tentative" autoplay first. We need to do this here or else
@@ -1010,7 +1023,7 @@ void LLViewerMedia::setAllMediaPaused(bool val)
{
if (!LLViewerMedia::isParcelMediaPlaying() && LLViewerMedia::hasParcelMedia())
{
- LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
+ LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
}
static LLCachedControl<bool> audio_streaming_music(gSavedSettings, "AudioStreamingMusic", true);
@@ -1032,7 +1045,7 @@ void LLViewerMedia::setAllMediaPaused(bool val)
}
else {
// This actually unloads the impl, as opposed to "stop"ping the media
- LLViewerParcelMedia::stop();
+ LLViewerParcelMedia::getInstance()->stop();
if (gAudiop)
{
LLViewerAudio::getInstance()->stopInternetStreamWithAutoFade();
@@ -1041,19 +1054,25 @@ void LLViewerMedia::setAllMediaPaused(bool val)
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::isParcelMediaPlaying()
{
- return (LLViewerMedia::hasParcelMedia() && LLViewerParcelMedia::getParcelMedia() && LLViewerParcelMedia::getParcelMedia()->hasMedia());
+ viewer_media_t media = LLViewerParcelMedia::getInstance()->getParcelMedia();
+ return (LLViewerMedia::hasParcelMedia() && media && media->hasMedia());
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::isParcelAudioPlaying()
{
return (LLViewerMedia::hasParcelAudio() && gAudiop && LLAudioEngine::AUDIO_PLAYING == gAudiop->isInternetStreamPlaying());
}
+/////////////////////////////////////////////////////////////////////////////////////////
+// static
+void LLViewerMedia::authSubmitCallback(const LLSD& notification, const LLSD& response)
+{
+ LLViewerMedia::getInstance()->onAuthSubmit(notification, response);
+}
+
void LLViewerMedia::onAuthSubmit(const LLSD& notification, const LLSD& response)
{
LLViewerMediaImpl *impl = LLViewerMedia::getMediaImplFromTextureID(notification["payload"]["media_id"]);
@@ -1075,7 +1094,6 @@ void LLViewerMedia::onAuthSubmit(const LLSD& notification, const LLSD& response)
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::clearAllCookies()
{
// Clear all cookies for all plugins
@@ -1092,7 +1110,6 @@ void LLViewerMedia::clearAllCookies()
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::clearAllCaches()
{
// Clear all plugins' caches
@@ -1106,7 +1123,6 @@ void LLViewerMedia::clearAllCaches()
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setCookiesEnabled(bool enabled)
{
// Set the "cookies enabled" flag for all loaded plugins
@@ -1123,7 +1139,6 @@ void LLViewerMedia::setCookiesEnabled(bool enabled)
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int port)
{
// Set the proxy config for all loaded plugins
@@ -1140,10 +1155,6 @@ void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int por
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
-/////////////////////////////////////////////////////////////////////////////////////////
-//// static
-
LLSD LLViewerMedia::getHeaders()
{
LLSD headers = LLSD::emptyMap();
@@ -1151,14 +1162,13 @@ LLSD LLViewerMedia::getHeaders()
// *TODO: Should this be 'application/llsd+xml' ?
// *TODO: Should this even be set at all? This header is only not overridden in 'GET' methods.
headers[HTTP_OUT_HEADER_CONTENT_TYPE] = HTTP_CONTENT_XML;
- headers[HTTP_OUT_HEADER_COOKIE] = sOpenIDCookie;
+ headers[HTTP_OUT_HEADER_COOKIE] = mOpenIDCookie;
headers[HTTP_OUT_HEADER_USER_AGENT] = getCurrentUserAgent();
return headers;
}
/////////////////////////////////////////////////////////////////////////////////////////
- // static
bool LLViewerMedia::parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure)
{
std::size_t name_pos = raw_cookie.find_first_of("=");
@@ -1181,13 +1191,14 @@ bool LLViewerMedia::parseRawCookie(const std::string raw_cookie, std::string& na
return false;
}
+/////////////////////////////////////////////////////////////////////////////////////////
LLCore::HttpHeaders::ptr_t LLViewerMedia::getHttpHeaders()
{
LLCore::HttpHeaders::ptr_t headers(new LLCore::HttpHeaders);
headers->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
headers->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_XML);
- headers->append(HTTP_OUT_HEADER_COOKIE, sOpenIDCookie);
+ headers->append(HTTP_OUT_HEADER_COOKIE, mOpenIDCookie);
headers->append(HTTP_OUT_HEADER_USER_AGENT, getCurrentUserAgent());
return headers;
@@ -1195,10 +1206,9 @@ LLCore::HttpHeaders::ptr_t LLViewerMedia::getHttpHeaders()
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setOpenIDCookie(const std::string& url)
{
- if(!sOpenIDCookie.empty())
+ if(!mOpenIDCookie.empty())
{
std::string profileUrl = getProfileURL("");
@@ -1207,7 +1217,7 @@ void LLViewerMedia::setOpenIDCookie(const std::string& url)
}
}
-/*static*/
+//static
void LLViewerMedia::getOpenIDCookieCoro(std::string url)
{
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
@@ -1229,7 +1239,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
// The LLURL can give me the 'authority', which is of the form: [username[:password]@]hostname[:port]
// We want just the hostname for the cookie code, but LLURL doesn't seem to have a way to extract that.
// We therefore do it here.
- std::string authority = sOpenIDURL.mAuthority;
+ std::string authority = getInstance()->mOpenIDURL.mAuthority;
std::string::size_type hostStart = authority.find('@');
if (hostStart == std::string::npos)
{ // no username/password
@@ -1246,7 +1256,8 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
{ // no port
hostEnd = authority.size();
}
-
+
+ LLViewerMedia* inst = getInstance();
if (url.length())
{
LLMediaCtrl* media_instance = LLFloaterReg::getInstance("destinations")->getChild<LLMediaCtrl>("destination_guide_contents");
@@ -1258,8 +1269,8 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
std::string cookie_path = "";
bool httponly = true;
bool secure = true;
- if (parseRawCookie(sOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure) &&
- media_instance->getMediaPlugin())
+ if (inst->parseRawCookie(inst->mOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure) &&
+ media_instance->getMediaPlugin())
{
// MAINT-5711 - inexplicably, the CEF setCookie function will no longer set the cookie if the
// url and domain are not the same. This used to be my.sl.com and id.sl.com respectively and worked.
@@ -1268,7 +1279,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
// (Feels like there must be a less dirty way to construct a URL from component LLURL parts)
// MAINT-6392 - Rider: Do not change, however, the original URI requested, since it is used further
// down.
- std::string cefUrl(std::string(sOpenIDURL.mURI) + "://" + std::string(sOpenIDURL.mAuthority));
+ std::string cefUrl(std::string(inst->mOpenIDURL.mURI) + "://" + std::string(inst->mOpenIDURL.mAuthority));
media_instance->getMediaPlugin()->setCookie(cefUrl, cookie_name, cookie_value, cookie_host, cookie_path, httponly, secure);
}
@@ -1281,11 +1292,11 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
// Do a web profile get so we can store the cookie
httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
- httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sOpenIDCookie);
- httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, getCurrentUserAgent());
+ httpHeaders->append(HTTP_OUT_HEADER_COOKIE, inst->mOpenIDCookie);
+ httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, inst->getCurrentUserAgent());
LL_DEBUGS("MediaAuth") << "Requesting " << url << LL_ENDL;
- LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << sOpenIDCookie << "]" << LL_ENDL;
+ LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << inst->mOpenIDCookie << "]" << LL_ENDL;
LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts, httpHeaders);
@@ -1314,7 +1325,6 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::openIDSetup(const std::string &openidUrl, const std::string &openidToken)
{
LL_DEBUGS("MediaAuth") << "url = \"" << openidUrl << "\", token = \"" << openidToken << "\"" << LL_ENDL;
@@ -1323,7 +1333,6 @@ void LLViewerMedia::openIDSetup(const std::string &openidUrl, const std::string
boost::bind(&LLViewerMedia::openIDSetupCoro, openidUrl, openidToken));
}
-/*static*/
void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidToken)
{
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
@@ -1338,10 +1347,10 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
// post the token to the url
// the responder will need to extract the cookie(s).
// Save the OpenID URL for later -- we may need the host when adding the cookie.
- sOpenIDURL.init(openidUrl.c_str());
+ getInstance()->mOpenIDURL.init(openidUrl.c_str());
// We shouldn't ever do this twice, but just in case this code gets repurposed later, clear existing cookies.
- sOpenIDCookie.clear();
+ getInstance()->mOpenIDCookie.clear();
httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, "application/x-www-form-urlencoded");
@@ -1373,24 +1382,22 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
const std::string& cookie = resultHeaders[HTTP_IN_HEADER_SET_COOKIE].asString();
// *TODO: What about bad status codes? Does this destroy previous cookies?
- LLViewerMedia::openIDCookieResponse(openidUrl, cookie);
+ LLViewerMedia::getInstance()->openIDCookieResponse(openidUrl, cookie);
LL_DEBUGS("MediaAuth") << "OpenID cookie set." << LL_ENDL;
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::openIDCookieResponse(const std::string& url, const std::string &cookie)
{
LL_DEBUGS("MediaAuth") << "Cookie received: \"" << cookie << "\"" << LL_ENDL;
- sOpenIDCookie += cookie;
+ mOpenIDCookie += cookie;
setOpenIDCookie(url);
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::string &uuid)
{
if(uuid.empty())
@@ -1406,7 +1413,6 @@ void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::stri
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::proxyWindowClosed(const std::string &uuid)
{
if(uuid.empty())
@@ -1422,28 +1428,26 @@ void LLViewerMedia::proxyWindowClosed(const std::string &uuid)
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::createSpareBrowserMediaSource()
{
// If we don't have a spare browser media source, create one.
// However, if PluginAttachDebuggerToPlugins is set then don't spawn a spare
// SLPlugin process in order to not be confused by an unrelated gdb terminal
// popping up at the moment we start a media plugin.
- if (!sSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
+ if (!mSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
{
// The null owner will keep the browser plugin from fully initializing
// (specifically, it keeps LLPluginClassMedia from negotiating a size change,
// which keeps MediaPluginWebkit::initBrowserWindow from doing anything until we have some necessary data, like the background color)
- sSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType(HTTP_CONTENT_TEXT_HTML, NULL, 0, 0, 1.0);
+ mSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType(HTTP_CONTENT_TEXT_HTML, NULL, 0, 0, 1.0);
}
}
/////////////////////////////////////////////////////////////////////////////////////////
-// static
LLPluginClassMedia* LLViewerMedia::getSpareBrowserMediaSource()
{
- LLPluginClassMedia* result = sSpareBrowserMediaSource;
- sSpareBrowserMediaSource = NULL;
+ LLPluginClassMedia* result = mSpareBrowserMediaSource;
+ mSpareBrowserMediaSource = NULL;
return result;
};
@@ -1465,50 +1469,24 @@ bool LLViewerMedia::hasInWorldMedia()
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::hasParcelMedia()
{
- return !LLViewerParcelMedia::getURL().empty();
+ return !LLViewerParcelMedia::getInstance()->getURL().empty();
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
bool LLViewerMedia::hasParcelAudio()
{
return !LLViewerMedia::getParcelAudioURL().empty();
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
std::string LLViewerMedia::getParcelAudioURL()
{
return LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL();
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::initClass()
-{
- gIdleCallbacks.addFunction(LLViewerMedia::updateMedia, NULL);
- sTeleportFinishConnection = LLViewerParcelMgr::getInstance()->
- setTeleportFinishedCallback(boost::bind(&LLViewerMedia::onTeleportFinished));
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::cleanupClass()
-{
- gIdleCallbacks.deleteFunction(LLViewerMedia::updateMedia, NULL);
- sTeleportFinishConnection.disconnect();
- if (sSpareBrowserMediaSource != NULL)
- {
- delete sSpareBrowserMediaSource;
- sSpareBrowserMediaSource = NULL;
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::onTeleportFinished()
{
// On teleport, clear this setting (i.e. set it to true)
@@ -1517,9 +1495,7 @@ void LLViewerMedia::onTeleportFinished()
LLViewerMediaImpl::sMimeTypesFailed.clear();
}
-
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerMedia::setOnlyAudibleMediaTextureID(const LLUUID& texture_id)
{
sOnlyAudibleTextureID = texture_id;
@@ -1711,7 +1687,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
if ((plugin_basename == "media_plugin_cef") &&
!gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins") && !clean_browser)
{
- media_source = LLViewerMedia::getSpareBrowserMediaSource();
+ media_source = LLViewerMedia::getInstance()->getSpareBrowserMediaSource();
if(media_source)
{
media_source->setOwner(owner);
@@ -1787,7 +1763,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
media_source->enableMediaPluginDebugging( media_plugin_debugging_enabled || clean_browser);
// need to set agent string here before instance created
- media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
+ media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
media_source->setTarget(target);
@@ -1858,7 +1834,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type)
media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout"));
media_source->setLoop(mMediaLoop);
media_source->setAutoScale(mMediaAutoScale);
- media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
+ media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
media_source->focus(mHasFocus);
media_source->setBackgroundColor(mBackgroundColor);
@@ -2091,7 +2067,7 @@ void LLViewerMediaImpl::updateVolume()
if(mMediaSource)
{
// always scale the volume by the global media volume
- F32 volume = mRequestedVolume * LLViewerMedia::getVolume();
+ F32 volume = mRequestedVolume * LLViewerMedia::getInstance()->getVolume();
if (mProximityCamera > 0)
{
@@ -3365,7 +3341,7 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla
auth_request_params.substitutions = args;
auth_request_params.payload = LLSD().with("media_id", mTextureId);
- auth_request_params.functor.function = boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2);
+ auth_request_params.functor.function = boost::bind(&LLViewerMedia::authSubmitCallback, _1, _2);
LLNotifications::instance().add(auth_request_params);
};
break;
diff --git a/indra/newview/llviewermedia.h b/indra/newview/llviewermedia.h
index e2e758befb6df2a59946f55cae1671100075c6b3..014f9048f0849559f17007dcb8f923f527495f00 100644
--- a/indra/newview/llviewermedia.h
+++ b/indra/newview/llviewermedia.h
@@ -70,11 +70,14 @@ class LLViewerMediaEventEmitter
class LLViewerMediaImpl;
-class LLViewerMedia
+class LLViewerMedia: public LLSingleton<LLViewerMedia>
{
+ LLSINGLETON(LLViewerMedia);
+ ~LLViewerMedia();
+ void initSingleton();
LOG_CLASS(LLViewerMedia);
+
public:
-
// String to get/set media autoplay in gSavedSettings
static const char* AUTO_PLAY_MEDIA_SETTING;
static const char* SHOW_MEDIA_ON_OTHERS_SETTING;
@@ -88,91 +91,93 @@ class LLViewerMedia
// Special case early init for just web browser component
// so we can show login screen. See .cpp file for details. JC
- static viewer_media_t newMediaImpl(const LLUUID& texture_id,
+ viewer_media_t newMediaImpl(const LLUUID& texture_id,
S32 media_width = 0,
S32 media_height = 0,
U8 media_auto_scale = false,
U8 media_loop = false);
- static viewer_media_t updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self);
- static LLViewerMediaImpl* getMediaImplFromTextureID(const LLUUID& texture_id);
- static std::string getCurrentUserAgent();
- static void updateBrowserUserAgent();
- static bool handleSkinCurrentChanged(const LLSD& /*newvalue*/);
- static bool textureHasMedia(const LLUUID& texture_id);
- static void setVolume(F32 volume);
+ viewer_media_t updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self);
+ LLViewerMediaImpl* getMediaImplFromTextureID(const LLUUID& texture_id);
+ std::string getCurrentUserAgent();
+ void updateBrowserUserAgent();
+ bool handleSkinCurrentChanged(const LLSD& /*newvalue*/);
+ bool textureHasMedia(const LLUUID& texture_id);
+ void setVolume(F32 volume);
// Is any media currently "showing"? Includes Parcel Media. Does not include media in the UI.
- static bool isAnyMediaShowing();
+ bool isAnyMediaShowing();
// Shows if any media is playing, counts visible non time based media as playing. Does not include media in the UI.
- static bool isAnyMediaPlaying();
+ bool isAnyMediaPlaying();
// Set all media enabled or disabled, depending on val. Does not include media in the UI.
- static void setAllMediaEnabled(bool val);
+ void setAllMediaEnabled(bool val);
// Set all media paused(stopped for non time based) or playing, depending on val. Does not include media in the UI.
- static void setAllMediaPaused(bool val);
+ void setAllMediaPaused(bool val);
- static void updateMedia(void* dummy_arg = NULL);
-
- static void initClass();
- static void cleanupClass();
-
- static F32 getVolume();
- static void muteListChanged();
- static bool isInterestingEnough(const LLVOVolume* object, const F64 &object_interest);
+ static void onIdle(void* dummy_arg = NULL); // updateMedia wrapper
+ void updateMedia(void* dummy_arg = NULL);
+
+ F32 getVolume();
+ void muteListChanged();
+ bool isInterestingEnough(const LLVOVolume* object, const F64 &object_interest);
// Returns the priority-sorted list of all media impls.
- static impl_list &getPriorityList();
+ impl_list &getPriorityList();
// This is the comparitor used to sort the list.
static bool priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2);
// These are just helper functions for the convenience of others working with media
- static bool hasInWorldMedia();
- static std::string getParcelAudioURL();
- static bool hasParcelMedia();
- static bool hasParcelAudio();
- static bool isParcelMediaPlaying();
- static bool isParcelAudioPlaying();
-
- static void onAuthSubmit(const LLSD& notification, const LLSD& response);
+ bool hasInWorldMedia();
+ std::string getParcelAudioURL();
+ bool hasParcelMedia();
+ bool hasParcelAudio();
+ bool isParcelMediaPlaying();
+ bool isParcelAudioPlaying();
+
+ static void authSubmitCallback(const LLSD& notification, const LLSD& response);
// Clear all cookies for all plugins
- static void clearAllCookies();
+ void clearAllCookies();
// Clear all plugins' caches
- static void clearAllCaches();
+ void clearAllCaches();
// Set the "cookies enabled" flag for all loaded plugins
- static void setCookiesEnabled(bool enabled);
+ void setCookiesEnabled(bool enabled);
// Set the proxy config for all loaded plugins
- static void setProxyConfig(bool enable, const std::string &host, int port);
+ void setProxyConfig(bool enable, const std::string &host, int port);
- static void openIDSetup(const std::string &openid_url, const std::string &openid_token);
- static void openIDCookieResponse(const std::string& url, const std::string &cookie);
+ void openIDSetup(const std::string &openid_url, const std::string &openid_token);
+ void openIDCookieResponse(const std::string& url, const std::string &cookie);
- static void proxyWindowOpened(const std::string &target, const std::string &uuid);
- static void proxyWindowClosed(const std::string &uuid);
+ void proxyWindowOpened(const std::string &target, const std::string &uuid);
+ void proxyWindowClosed(const std::string &uuid);
- static void createSpareBrowserMediaSource();
- static LLPluginClassMedia* getSpareBrowserMediaSource();
+ void createSpareBrowserMediaSource();
+ LLPluginClassMedia* getSpareBrowserMediaSource();
- static void setOnlyAudibleMediaTextureID(const LLUUID& texture_id);
+ void setOnlyAudibleMediaTextureID(const LLUUID& texture_id);
- static LLSD getHeaders();
- static LLCore::HttpHeaders::ptr_t getHttpHeaders();
+ LLSD getHeaders();
+ LLCore::HttpHeaders::ptr_t getHttpHeaders();
private:
- static bool parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure);
- static void setOpenIDCookie(const std::string& url);
- static void onTeleportFinished();
-
- static void openIDSetupCoro(std::string openidUrl, std::string openidToken);
- static void getOpenIDCookieCoro(std::string url);
-
- static LLURL sOpenIDURL;
- static std::string sOpenIDCookie;
- static LLPluginClassMedia* sSpareBrowserMediaSource;
+ void onAuthSubmit(const LLSD& notification, const LLSD& response);
+ bool parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure);
+ void setOpenIDCookie(const std::string& url);
+ void onTeleportFinished();
+
+ static void openIDSetupCoro(std::string openidUrl, std::string openidToken);
+ static void getOpenIDCookieCoro(std::string url);
+
+ bool mAnyMediaShowing;
+ bool mAnyMediaPlaying;
+ LLURL mOpenIDURL;
+ std::string mOpenIDCookie;
+ LLPluginClassMedia* mSpareBrowserMediaSource;
+ boost::signals2::connection mTeleportFinishConnection;
};
// Implementation functions not exported into header file
diff --git a/indra/newview/llviewermediafocus.cpp b/indra/newview/llviewermediafocus.cpp
index 59165c1d7144d2e005fa6a73337f2b52f7237905..f4a64a8e55c41ded10ad734cfd0df3ca5d8833e2 100644
--- a/indra/newview/llviewermediafocus.cpp
+++ b/indra/newview/llviewermediafocus.cpp
@@ -339,12 +339,12 @@ BOOL LLViewerMediaFocus::handleKey(KEY key, MASK mask, BOOL called_from_parent)
clearFocus();
}
- if ( KEY_F1 == key && LLUI::sHelpImpl && mMediaControls.get())
+ if ( KEY_F1 == key && LLUI::getInstance()->mHelpImpl && mMediaControls.get())
{
std::string help_topic;
if (mMediaControls.get()->findHelpTopic(help_topic))
{
- LLUI::sHelpImpl->showTopic(help_topic);
+ LLUI::getInstance()->mHelpImpl->showTopic(help_topic);
}
}
}
@@ -537,7 +537,7 @@ bool LLViewerMediaFocus::isHoveringOverFace(LLPointer<LLViewerObject> objectp, S
LLViewerMediaImpl* LLViewerMediaFocus::getFocusedMediaImpl()
{
- return LLViewerMedia::getMediaImplFromTextureID(mFocusedImplID);
+ return LLViewerMedia::getInstance()->getMediaImplFromTextureID(mFocusedImplID);
}
LLViewerObject* LLViewerMediaFocus::getFocusedObject()
@@ -547,7 +547,7 @@ LLViewerObject* LLViewerMediaFocus::getFocusedObject()
LLViewerMediaImpl* LLViewerMediaFocus::getHoverMediaImpl()
{
- return LLViewerMedia::getMediaImplFromTextureID(mHoverImplID);
+ return LLViewerMedia::getInstance()->getMediaImplFromTextureID(mHoverImplID);
}
LLViewerObject* LLViewerMediaFocus::getHoverObject()
@@ -557,7 +557,7 @@ LLViewerObject* LLViewerMediaFocus::getHoverObject()
void LLViewerMediaFocus::focusZoomOnMedia(LLUUID media_id)
{
- LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(media_id);
+ LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(media_id);
if(impl)
{
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 52b2c631fa4755fe88f0220e709ac2d5f0e709ef..dc82719109b91d3bee6f9c9c89c11c8d97c28ade 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -6278,7 +6278,7 @@ void dump_inventory(void*)
void handle_dump_followcam(void*)
{
- LLFollowCamMgr::dump();
+ LLFollowCamMgr::getInstance()->dump();
}
void handle_viewer_enable_message_log(void*)
@@ -8656,7 +8656,6 @@ class LLWorldPostProcess : public view_listener_t
void handle_flush_name_caches()
{
- SUBSYSTEM_CLEANUP(LLAvatarNameCache);
if (gCacheName) gCacheName->clear();
}
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index 6e5c77e4a9c2f1aba56b1587b8999a50abe4c076..b0ad81614a1c1c2fd5748f4a356616fc6d20a280 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -4271,7 +4271,7 @@ void process_clear_follow_cam_properties(LLMessageSystem *mesgsys, void **user_d
mesgsys->getUUIDFast(_PREHASH_ObjectData, _PREHASH_ObjectID, source_id);
- LLFollowCamMgr::removeFollowCamParams(source_id);
+ LLFollowCamMgr::getInstance()->removeFollowCamParams(source_id);
}
void process_set_follow_cam_properties(LLMessageSystem *mesgsys, void **user_data)
@@ -4303,7 +4303,7 @@ void process_set_follow_cam_properties(LLMessageSystem *mesgsys, void **user_dat
switch(type)
{
case FOLLOWCAM_PITCH:
- LLFollowCamMgr::setPitch(source_id, value);
+ LLFollowCamMgr::getInstance()->setPitch(source_id, value);
break;
case FOLLOWCAM_FOCUS_OFFSET_X:
focus_offset.mV[VX] = value;
@@ -4318,29 +4318,29 @@ void process_set_follow_cam_properties(LLMessageSystem *mesgsys, void **user_dat
settingFocusOffset = true;
break;
case FOLLOWCAM_POSITION_LAG:
- LLFollowCamMgr::setPositionLag(source_id, value);
+ LLFollowCamMgr::getInstance()->setPositionLag(source_id, value);
break;
case FOLLOWCAM_FOCUS_LAG:
- LLFollowCamMgr::setFocusLag(source_id, value);
+ LLFollowCamMgr::getInstance()->setFocusLag(source_id, value);
break;
case FOLLOWCAM_DISTANCE:
- LLFollowCamMgr::setDistance(source_id, value);
+ LLFollowCamMgr::getInstance()->setDistance(source_id, value);
break;
case FOLLOWCAM_BEHINDNESS_ANGLE:
- LLFollowCamMgr::setBehindnessAngle(source_id, value);
+ LLFollowCamMgr::getInstance()->setBehindnessAngle(source_id, value);
break;
case FOLLOWCAM_BEHINDNESS_LAG:
- LLFollowCamMgr::setBehindnessLag(source_id, value);
+ LLFollowCamMgr::getInstance()->setBehindnessLag(source_id, value);
break;
case FOLLOWCAM_POSITION_THRESHOLD:
- LLFollowCamMgr::setPositionThreshold(source_id, value);
+ LLFollowCamMgr::getInstance()->setPositionThreshold(source_id, value);
break;
case FOLLOWCAM_FOCUS_THRESHOLD:
- LLFollowCamMgr::setFocusThreshold(source_id, value);
+ LLFollowCamMgr::getInstance()->setFocusThreshold(source_id, value);
break;
case FOLLOWCAM_ACTIVE:
//if 1, set using followcam,.
- LLFollowCamMgr::setCameraActive(source_id, value != 0.f);
+ LLFollowCamMgr::getInstance()->setCameraActive(source_id, value != 0.f);
break;
case FOLLOWCAM_POSITION_X:
settingPosition = true;
@@ -4367,10 +4367,10 @@ void process_set_follow_cam_properties(LLMessageSystem *mesgsys, void **user_dat
focus.mV[ 2 ] = value;
break;
case FOLLOWCAM_POSITION_LOCKED:
- LLFollowCamMgr::setPositionLocked(source_id, value != 0.f);
+ LLFollowCamMgr::getInstance()->setPositionLocked(source_id, value != 0.f);
break;
case FOLLOWCAM_FOCUS_LOCKED:
- LLFollowCamMgr::setFocusLocked(source_id, value != 0.f);
+ LLFollowCamMgr::getInstance()->setFocusLocked(source_id, value != 0.f);
break;
default:
@@ -4380,15 +4380,15 @@ void process_set_follow_cam_properties(LLMessageSystem *mesgsys, void **user_dat
if ( settingPosition )
{
- LLFollowCamMgr::setPosition(source_id, position);
+ LLFollowCamMgr::getInstance()->setPosition(source_id, position);
}
if ( settingFocus )
{
- LLFollowCamMgr::setFocus(source_id, focus);
+ LLFollowCamMgr::getInstance()->setFocus(source_id, focus);
}
if ( settingFocusOffset )
{
- LLFollowCamMgr::setFocusOffset(source_id, focus_offset);
+ LLFollowCamMgr::getInstance()->setFocusOffset(source_id, focus_offset);
}
}
//end Ventrella
diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index 1353a27982337372ab8773a0511c78e608af297f..c7a77d4d2ab82c363f6ebf3ef963586aaa544d2a 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -482,7 +482,7 @@ void LLViewerObject::markDead()
if (flagCameraSource())
{
- LLFollowCamMgr::removeFollowCamParams(mID);
+ LLFollowCamMgr::getInstance()->removeFollowCamParams(mID);
}
sNumZombieObjects++;
diff --git a/indra/newview/llviewerparcelmedia.cpp b/indra/newview/llviewerparcelmedia.cpp
index d31fc0d6069c92b791e1c1f8fe93ca901a415420..b1b5275f826bcb510df5c3cf8f019e23468eb120 100644
--- a/indra/newview/llviewerparcelmedia.cpp
+++ b/indra/newview/llviewerparcelmedia.cpp
@@ -45,31 +45,22 @@
#include "llviewertexture.h"
#include "llcorehttputil.h"
-// Static Variables
-S32 LLViewerParcelMedia::sMediaParcelLocalID = 0;
-LLUUID LLViewerParcelMedia::sMediaRegionID;
-viewer_media_t LLViewerParcelMedia::sMediaImpl;
-
-
-// static
-void LLViewerParcelMedia::initClass()
+LLViewerParcelMedia::LLViewerParcelMedia():
+mMediaParcelLocalID(0)
{
LLMessageSystem* msg = gMessageSystem;
- msg->setHandlerFunc("ParcelMediaCommandMessage", processParcelMediaCommandMessage );
- msg->setHandlerFunc("ParcelMediaUpdate", processParcelMediaUpdate );
- LLViewerParcelMediaAutoPlay::initClass();
+ msg->setHandlerFunc("ParcelMediaCommandMessage", parcelMediaCommandMessageHandler );
+ msg->setHandlerFunc("ParcelMediaUpdate", parcelMediaUpdateHandler );
}
-//static
-void LLViewerParcelMedia::cleanupClass()
+LLViewerParcelMedia::~LLViewerParcelMedia()
{
// This needs to be destroyed before global destructor time.
- sMediaImpl = NULL;
+ mMediaImpl = NULL;
}
//////////////////////////////////////////////////////////////////////////////////////////
-// static
void LLViewerParcelMedia::update(LLParcel* parcel)
{
if (/*LLViewerMedia::hasMedia()*/ true)
@@ -79,7 +70,7 @@ void LLViewerParcelMedia::update(LLParcel* parcel)
{
if(!gAgent.getRegion())
{
- sMediaRegionID = LLUUID() ;
+ mMediaRegionID = LLUUID() ;
stop() ;
LL_DEBUGS("Media") << "no agent region, bailing out." << LL_ENDL;
return ;
@@ -89,11 +80,11 @@ void LLViewerParcelMedia::update(LLParcel* parcel)
S32 parcelid = parcel->getLocalID();
LLUUID regionid = gAgent.getRegion()->getRegionID();
- if (parcelid != sMediaParcelLocalID || regionid != sMediaRegionID)
+ if (parcelid != mMediaParcelLocalID || regionid != mMediaRegionID)
{
LL_DEBUGS("Media") << "New parcel, parcel id = " << parcelid << ", region id = " << regionid << LL_ENDL;
- sMediaParcelLocalID = parcelid;
- sMediaRegionID = regionid;
+ mMediaParcelLocalID = parcelid;
+ mMediaRegionID = regionid;
}
std::string mediaUrl = std::string ( parcel->getMediaURL () );
@@ -108,19 +99,19 @@ void LLViewerParcelMedia::update(LLParcel* parcel)
LLStringUtil::trim(mediaUrl);
// If no parcel media is playing, nothing left to do
- if(sMediaImpl.isNull())
+ if(mMediaImpl.isNull())
{
return;
}
// Media is playing...has something changed?
- else if (( sMediaImpl->getMediaURL() != mediaUrl )
- || ( sMediaImpl->getMediaTextureID() != parcel->getMediaID() )
- || ( sMediaImpl->getMimeType() != parcel->getMediaType() ))
+ else if (( mMediaImpl->getMediaURL() != mediaUrl )
+ || ( mMediaImpl->getMediaTextureID() != parcel->getMediaID() )
+ || ( mMediaImpl->getMimeType() != parcel->getMediaType() ))
{
// Only play if the media types are the same.
- if(sMediaImpl->getMimeType() == parcel->getMediaType())
+ if(mMediaImpl->getMimeType() == parcel->getMediaType())
{
play(parcel);
}
@@ -176,30 +167,30 @@ void LLViewerParcelMedia::play(LLParcel* parcel)
S32 media_width = parcel->getMediaWidth();
S32 media_height = parcel->getMediaHeight();
- if(sMediaImpl)
+ if(mMediaImpl)
{
// If the url and mime type are the same, call play again
- if(sMediaImpl->getMediaURL() == media_url
- && sMediaImpl->getMimeType() == mime_type
- && sMediaImpl->getMediaTextureID() == placeholder_texture_id)
+ if(mMediaImpl->getMediaURL() == media_url
+ && mMediaImpl->getMimeType() == mime_type
+ && mMediaImpl->getMediaTextureID() == placeholder_texture_id)
{
LL_DEBUGS("Media") << "playing with existing url " << media_url << LL_ENDL;
- sMediaImpl->play();
+ mMediaImpl->play();
}
// Else if the texture id's are the same, navigate and rediscover type
// MBW -- This causes other state from the previous parcel (texture size, autoscale, and looping) to get re-used incorrectly.
// It's also not really necessary -- just creating a new instance is fine.
-// else if(sMediaImpl->getMediaTextureID() == placeholder_texture_id)
+// else if(mMediaImpl->getMediaTextureID() == placeholder_texture_id)
// {
-// sMediaImpl->navigateTo(media_url, mime_type, true);
+// mMediaImpl->navigateTo(media_url, mime_type, true);
// }
else
{
// Since the texture id is different, we need to generate a new impl
// Delete the old one first so they don't fight over the texture.
- sMediaImpl = NULL;
+ mMediaImpl = NULL;
// A new impl will be created below.
}
@@ -208,19 +199,19 @@ void LLViewerParcelMedia::play(LLParcel* parcel)
// Don't ever try to play if the media type is set to "none/none"
if(stricmp(mime_type.c_str(), LLMIMETypes::getDefaultMimeType().c_str()) != 0)
{
- if(!sMediaImpl)
+ if(!mMediaImpl)
{
LL_DEBUGS("Media") << "new media impl with mime type " << mime_type << ", url " << media_url << LL_ENDL;
// There is no media impl, make a new one
- sMediaImpl = LLViewerMedia::newMediaImpl(
+ mMediaImpl = LLViewerMedia::getInstance()->newMediaImpl(
placeholder_texture_id,
media_width,
media_height,
media_auto_scale,
media_loop);
- sMediaImpl->setIsParcelMedia(true);
- sMediaImpl->navigateTo(media_url, mime_type, true);
+ mMediaImpl->setIsParcelMedia(true);
+ mMediaImpl->navigateTo(media_url, mime_type, true);
}
//LLFirstUse::useMedia();
@@ -232,7 +223,7 @@ void LLViewerParcelMedia::play(LLParcel* parcel)
// static
void LLViewerParcelMedia::stop()
{
- if(sMediaImpl.isNull())
+ if(mMediaImpl.isNull())
{
return;
}
@@ -241,27 +232,27 @@ void LLViewerParcelMedia::stop()
LLViewerMediaFocus::getInstance()->clearFocus();
// This will unload & kill the media instance.
- sMediaImpl = NULL;
+ mMediaImpl = NULL;
}
// static
void LLViewerParcelMedia::pause()
{
- if(sMediaImpl.isNull())
+ if(mMediaImpl.isNull())
{
return;
}
- sMediaImpl->pause();
+ mMediaImpl->pause();
}
// static
void LLViewerParcelMedia::start()
{
- if(sMediaImpl.isNull())
+ if(mMediaImpl.isNull())
{
return;
}
- sMediaImpl->start();
+ mMediaImpl->start();
//LLFirstUse::useMedia();
@@ -271,17 +262,17 @@ void LLViewerParcelMedia::start()
// static
void LLViewerParcelMedia::seek(F32 time)
{
- if(sMediaImpl.isNull())
+ if(mMediaImpl.isNull())
{
return;
}
- sMediaImpl->seek(time);
+ mMediaImpl->seek(time);
}
// static
void LLViewerParcelMedia::focus(bool focus)
{
- sMediaImpl->focus(focus);
+ mMediaImpl->focus(focus);
}
// static
@@ -289,9 +280,9 @@ LLPluginClassMediaOwner::EMediaStatus LLViewerParcelMedia::getStatus()
{
LLPluginClassMediaOwner::EMediaStatus result = LLPluginClassMediaOwner::MEDIA_NONE;
- if(sMediaImpl.notNull() && sMediaImpl->hasMedia())
+ if(mMediaImpl.notNull() && mMediaImpl->hasMedia())
{
- result = sMediaImpl->getMediaPlugin()->getStatus();
+ result = mMediaImpl->getMediaPlugin()->getStatus();
}
return result;
@@ -300,15 +291,15 @@ LLPluginClassMediaOwner::EMediaStatus LLViewerParcelMedia::getStatus()
// static
std::string LLViewerParcelMedia::getMimeType()
{
- return sMediaImpl.notNull() ? sMediaImpl->getMimeType() : LLMIMETypes::getDefaultMimeType();
+ return mMediaImpl.notNull() ? mMediaImpl->getMimeType() : LLMIMETypes::getDefaultMimeType();
}
//static
std::string LLViewerParcelMedia::getURL()
{
std::string url;
- if(sMediaImpl.notNull())
- url = sMediaImpl->getMediaURL();
+ if(mMediaImpl.notNull())
+ url = mMediaImpl->getMediaURL();
if(stricmp(LLViewerParcelMgr::getInstance()->getAgentParcel()->getMediaType().c_str(), LLMIMETypes::getDefaultMimeType().c_str()) != 0)
{
@@ -325,19 +316,24 @@ std::string LLViewerParcelMedia::getURL()
//static
std::string LLViewerParcelMedia::getName()
{
- if(sMediaImpl.notNull())
- return sMediaImpl->getName();
+ if(mMediaImpl.notNull())
+ return mMediaImpl->getName();
return "";
}
viewer_media_t LLViewerParcelMedia::getParcelMedia()
{
- return sMediaImpl;
+ return mMediaImpl;
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
-void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg, void ** )
+void LLViewerParcelMedia::parcelMediaCommandMessageHandler(LLMessageSystem *msg, void **)
+{
+ getInstance()->processParcelMediaCommandMessage(msg);
+}
+
+void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg)
{
// extract the agent id
// LLUUID agent_id;
@@ -392,7 +388,7 @@ void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg
if (flags & (1<<PARCEL_MEDIA_COMMAND_TIME))
{
- if(sMediaImpl.isNull())
+ if(mMediaImpl.isNull())
{
LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
play(parcel);
@@ -403,7 +399,12 @@ void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg
//////////////////////////////////////////////////////////////////////////////////////////
// static
-void LLViewerParcelMedia::processParcelMediaUpdate( LLMessageSystem *msg, void ** )
+void LLViewerParcelMedia::parcelMediaUpdateHandler(LLMessageSystem *msg, void **)
+{
+ getInstance()->processParcelMediaUpdate(msg);
+}
+
+void LLViewerParcelMedia::processParcelMediaUpdate( LLMessageSystem *msg)
{
LLUUID media_id;
std::string media_url;
diff --git a/indra/newview/llviewerparcelmedia.h b/indra/newview/llviewerparcelmedia.h
index 534f65b4193795f4f045e0eaffa73f7d6e31c04d..779a65bdf83a5cb239b485e2379bc21ec2675658 100644
--- a/indra/newview/llviewerparcelmedia.h
+++ b/indra/newview/llviewerparcelmedia.h
@@ -37,50 +37,53 @@ class LLViewerParcelMediaNavigationObserver;
// This class understands land parcels, network traffic, LSL media
// transport commands, and talks to the LLViewerMedia class to actually
// do playback. It allows us to remove code from LLViewerParcelMgr.
-class LLViewerParcelMedia : public LLViewerMediaObserver
+class LLViewerParcelMedia : public LLViewerMediaObserver, public LLSingleton<LLViewerParcelMedia>
{
+ LLSINGLETON(LLViewerParcelMedia);
+ ~LLViewerParcelMedia();
LOG_CLASS(LLViewerParcelMedia);
- public:
- static void initClass();
- static void cleanupClass();
-
- static void update(LLParcel* parcel);
- // called when the agent's parcel has a new URL, or the agent has
- // walked on to a new parcel with media
-
- static void play(LLParcel* parcel);
- // user clicked play button in media transport controls
-
- static void stop();
- // user clicked stop button in media transport controls
-
- static void pause();
- static void start();
- // restart after pause - no need for all the setup
-
- static void focus(bool focus);
-
- static void seek(F32 time);
- // jump to timecode time
-
- static LLPluginClassMediaOwner::EMediaStatus getStatus();
- static std::string getMimeType();
- static std::string getURL();
- static std::string getName();
- static viewer_media_t getParcelMedia();
-
- static void processParcelMediaCommandMessage( LLMessageSystem *msg, void ** );
- static void processParcelMediaUpdate( LLMessageSystem *msg, void ** );
- static void sendMediaNavigateMessage(const std::string& url);
-
- // inherited from LLViewerMediaObserver
- virtual void handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event);
-
- public:
- static S32 sMediaParcelLocalID;
- static LLUUID sMediaRegionID;
- // HACK: this will change with Media on a Prim
- static viewer_media_t sMediaImpl;
+public:
+ void update(LLParcel* parcel);
+ // called when the agent's parcel has a new URL, or the agent has
+ // walked on to a new parcel with media
+
+ void play(LLParcel* parcel);
+ // user clicked play button in media transport controls
+
+ void stop();
+ // user clicked stop button in media transport controls
+
+ void pause();
+ void start();
+ // restart after pause - no need for all the setup
+
+ void focus(bool focus);
+
+ void seek(F32 time);
+ // jump to timecode time
+
+ LLPluginClassMediaOwner::EMediaStatus getStatus();
+ std::string getMimeType();
+ std::string getURL();
+ std::string getName();
+ viewer_media_t getParcelMedia();
+ bool hasParcelMedia() { return mMediaImpl.notNull(); }
+
+ static void parcelMediaCommandMessageHandler( LLMessageSystem *msg, void ** );
+ static void parcelMediaUpdateHandler( LLMessageSystem *msg, void ** );
+ void sendMediaNavigateMessage(const std::string& url);
+
+ // inherited from LLViewerMediaObserver
+ virtual void handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event);
+
+private:
+ void processParcelMediaCommandMessage(LLMessageSystem *msg);
+ void processParcelMediaUpdate(LLMessageSystem *msg);
+
+ S32 mMediaParcelLocalID;
+ LLUUID mMediaRegionID;
+ // HACK: this will change with Media on a Prim
+ viewer_media_t mMediaImpl;
};
diff --git a/indra/newview/llviewerparcelmediaautoplay.cpp b/indra/newview/llviewerparcelmediaautoplay.cpp
index 57ee583eae66f49fbf10669aa5313579165517f9..b5a76ccba2a9c2d4fca938e9e417650da45951d0 100644
--- a/indra/newview/llviewerparcelmediaautoplay.cpp
+++ b/indra/newview/llviewerparcelmediaautoplay.cpp
@@ -51,29 +51,10 @@ LLViewerParcelMediaAutoPlay::LLViewerParcelMediaAutoPlay() :
{
}
-static LLViewerParcelMediaAutoPlay *sAutoPlay = NULL;
-
-// static
-void LLViewerParcelMediaAutoPlay::initClass()
-{
- if (!sAutoPlay)
- sAutoPlay = new LLViewerParcelMediaAutoPlay;
-}
-
-// static
-void LLViewerParcelMediaAutoPlay::cleanupClass()
-{
- if (sAutoPlay)
- delete sAutoPlay;
-}
-
// static
void LLViewerParcelMediaAutoPlay::playStarted()
{
- if (sAutoPlay)
- {
- sAutoPlay->mPlayed = TRUE;
- }
+ LLSingleton<LLViewerParcelMediaAutoPlay>::getInstance()->mPlayed = TRUE;
}
BOOL LLViewerParcelMediaAutoPlay::tick()
@@ -122,7 +103,7 @@ BOOL LLViewerParcelMediaAutoPlay::tick()
(mTimeInParcel > AUTOPLAY_TIME) && // and if we've been here for so many seconds
(!this_media_url.empty()) && // and if the parcel has media
(stricmp(this_media_type.c_str(), LLMIMETypes::getDefaultMimeType().c_str()) != 0) &&
- (LLViewerParcelMedia::sMediaImpl.isNull())) // and if the media is not already playing
+ (!LLViewerParcelMedia::getInstance()->hasParcelMedia())) // and if the media is not already playing
{
if (this_media_texture_id.notNull()) // and if the media texture is good
{
@@ -144,7 +125,7 @@ BOOL LLViewerParcelMediaAutoPlay::tick()
if (gSavedSettings.getBOOL("ParcelMediaAutoPlayEnable"))
{
// and last but not least, only play when autoplay is enabled
- LLViewerParcelMedia::play(this_parcel);
+ LLViewerParcelMedia::getInstance()->play(this_parcel);
}
}
diff --git a/indra/newview/llviewerparcelmediaautoplay.h b/indra/newview/llviewerparcelmediaautoplay.h
index a05236282931ce83b9233bc4884a3566f9e5a059..33565307f285e2c5ab84d5c79593c18edaccff4c 100644
--- a/indra/newview/llviewerparcelmediaautoplay.h
+++ b/indra/newview/llviewerparcelmediaautoplay.h
@@ -31,13 +31,11 @@
#include "lluuid.h"
// timer to automatically play media
-class LLViewerParcelMediaAutoPlay : LLEventTimer
+class LLViewerParcelMediaAutoPlay : LLEventTimer, public LLSingleton<LLViewerParcelMediaAutoPlay>
{
- public:
- LLViewerParcelMediaAutoPlay();
+ LLSINGLETON(LLViewerParcelMediaAutoPlay);
+public:
virtual BOOL tick();
- static void initClass();
- static void cleanupClass();
static void playStarted();
private:
diff --git a/indra/newview/llviewerparcelmgr.cpp b/indra/newview/llviewerparcelmgr.cpp
index 416d5d8e2ef1bbca6dfd6d489adff5b6d37d4040..6cc88d0c0be698ba7956a4469ed5c94d464b0cd8 100644
--- a/indra/newview/llviewerparcelmgr.cpp
+++ b/indra/newview/llviewerparcelmgr.cpp
@@ -1822,7 +1822,7 @@ void LLViewerParcelMgr::processParcelProperties(LLMessageSystem *msg, void **use
else
{
// Check for video
- LLViewerParcelMedia::update(parcel);
+ LLViewerParcelMedia::getInstance()->update(parcel);
// Then check for music
if (gAudiop)
diff --git a/indra/newview/llviewertexteditor.cpp b/indra/newview/llviewertexteditor.cpp
index 7d2d6e25c79ed08d8314408e49bfb49bae9c76a1..0e181bf53d838d8d35190e4a287e5ff4e4ec3594 100644
--- a/indra/newview/llviewertexteditor.cpp
+++ b/indra/newview/llviewertexteditor.cpp
@@ -239,7 +239,7 @@ class LLEmbeddedItemSegment : public LLTextSegment
/*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask)
{
- LLUI::getWindow()->setCursor(UI_CURSOR_HAND);
+ LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
return TRUE;
}
virtual BOOL handleToolTip(S32 x, S32 y, MASK mask )
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 93562cfab23b9d4becf9afbf5831328b4df14d91..305f891a86a2ee3c80dce32563f56462a0d38060 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -3459,7 +3459,7 @@ void LLViewerMediaTexture::setMediaImpl()
{
if(!mMediaImplp)
{
- mMediaImplp = LLViewerMedia::getMediaImplFromTextureID(mID);
+ mMediaImplp = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mID);
}
}
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index c3cf07e9c777971f71aa9cfc617c1a5f39bc4c08..61f4ee463dc70d95d222a6ec108255f6c46c7bc7 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -960,7 +960,7 @@ BOOL LLViewerWindow::handleAnyMouseClick(LLWindow *window, LLCoordGL pos, MASK
mWindow->releaseMouse();
// Indicate mouse was active
- LLUI::resetMouseIdleTimer();
+ LLUI::getInstance()->resetMouseIdleTimer();
// Don't let the user move the mouse out of the window until mouse up.
if( LLToolMgr::getInstance()->getCurrentTool()->clipMouseWhenDown() )
@@ -1295,7 +1295,7 @@ void LLViewerWindow::handleMouseMove(LLWindow *window, LLCoordGL pos, MASK mask
if (mouse_point != mCurrentMousePoint)
{
- LLUI::resetMouseIdleTimer();
+ LLUI::getInstance()->resetMouseIdleTimer();
}
saveLastMouse(mouse_point);
@@ -1796,8 +1796,6 @@ LLViewerWindow::LLViewerWindow(const Params& p)
//
LL_DEBUGS("Window") << "Loading feature tables." << LL_ENDL;
- LLFeatureManager::getInstance()->init();
-
// Initialize OpenGL Renderer
if (!LLFeatureManager::getInstance()->isFeatureAvailable("RenderVBOEnable") ||
!gGLManager.mHasVertexBufferObject)
@@ -1852,7 +1850,7 @@ LLViewerWindow::LLViewerWindow(const Params& p)
rvp.mouse_opaque(false);
rvp.follows.flags(FOLLOWS_NONE);
mRootView = LLUICtrlFactory::create<LLRootView>(rvp);
- LLUI::setRootView(mRootView);
+ LLUI::getInstance()->setRootView(mRootView);
// Make avatar head look forward at start
mCurrentMousePoint.mX = getWindowWidthScaled() / 2;
@@ -2410,7 +2408,7 @@ void LLViewerWindow::setNormalControlsVisible( BOOL visible )
gStatusBar->setEnabled( visible );
}
- LLNavigationBar* navbarp = LLUI::getRootView()->findChild<LLNavigationBar>("navigation_bar");
+ LLNavigationBar* navbarp = LLUI::getInstance()->getRootView()->findChild<LLNavigationBar>("navigation_bar");
if (navbarp)
{
// when it's time to show navigation bar we need to ensure that the user wants to see it
@@ -2520,7 +2518,7 @@ void LLViewerWindow::draw()
if (!gSavedSettings.getBOOL("RenderUIBuffer"))
{
- LLUI::sDirtyRect = getWindowRectScaled();
+ LLUI::getInstance()->mDirtyRect = getWindowRectScaled();
}
// HACK for timecode debugging
@@ -2920,7 +2918,7 @@ BOOL LLViewerWindow::handleUnicodeChar(llwchar uni_char, MASK mask)
void LLViewerWindow::handleScrollWheel(S32 clicks)
{
- LLUI::resetMouseIdleTimer();
+ LLUI::getInstance()->resetMouseIdleTimer();
LLMouseHandler* mouse_captor = gFocusMgr.getMouseCapture();
if( mouse_captor )
@@ -2999,7 +2997,7 @@ void LLViewerWindow::moveCursorToCenter()
S32 x = getWorldViewWidthScaled() / 2;
S32 y = getWorldViewHeightScaled() / 2;
- LLUI::setMousePositionScreen(x, y);
+ LLUI::getInstance()->setMousePositionScreen(x, y);
//on a forced move, all deltas get zeroed out to prevent jumping
mCurrentMousePoint.set(x,y);
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index b5db5d4a4802b22f9e429198b37ea0ec396cca69..ca1216b89db6790c1eae95f14f5404cc0be26f36 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -7363,7 +7363,7 @@ void LLVOAvatar::getOffObject()
if (sit_object)
{
stopMotionFromSource(sit_object->getID());
- LLFollowCamMgr::setCameraActive(sit_object->getID(), FALSE);
+ LLFollowCamMgr::getInstance()->setCameraActive(sit_object->getID(), FALSE);
LLViewerObject::const_child_list_t& child_list = sit_object->getChildren();
for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
@@ -7372,7 +7372,7 @@ void LLVOAvatar::getOffObject()
LLViewerObject* child_objectp = *iter;
stopMotionFromSource(child_objectp->getID());
- LLFollowCamMgr::setCameraActive(child_objectp->getID(), FALSE);
+ LLFollowCamMgr::getInstance()->setCameraActive(child_objectp->getID(), FALSE);
}
}
diff --git a/indra/newview/llvoavatarself.cpp b/indra/newview/llvoavatarself.cpp
index dcaade55a6894dc647bba23e4204ef83e4c2cd63..63ace4fe5298931dcd190779cc4673915ef77700 100644
--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@@ -1208,7 +1208,7 @@ BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object)
// the simulator should automatically handle permission revocation
stopMotionFromSource(attachment_id);
- LLFollowCamMgr::setCameraActive(viewer_object->getID(), FALSE);
+ LLFollowCamMgr::getInstance()->setCameraActive(viewer_object->getID(), FALSE);
LLViewerObject::const_child_list_t& child_list = viewer_object->getChildren();
for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
@@ -1220,7 +1220,7 @@ BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object)
// permissions revocation
stopMotionFromSource(child_objectp->getID());
- LLFollowCamMgr::setCameraActive(child_objectp->getID(), FALSE);
+ LLFollowCamMgr::getInstance()->setCameraActive(child_objectp->getID(), FALSE);
}
// Make sure the inventory is in sync with the avatar.
diff --git a/indra/newview/llvocache.cpp b/indra/newview/llvocache.cpp
index fb28d9bdb5ab31422705ab7c89c652aef1ae9273..07660ca6ac16efc94a662da152592ef40c066abf 100644
--- a/indra/newview/llvocache.cpp
+++ b/indra/newview/llvocache.cpp
@@ -1045,9 +1045,9 @@ const char* object_cache_dirname = "objectcache";
const char* header_filename = "object.cache";
-LLVOCache::LLVOCache():
+LLVOCache::LLVOCache(bool read_only) :
mInitialized(false),
- mReadOnly(true),
+ mReadOnly(read_only),
mNumEntries(0),
mCacheSize(1)
{
diff --git a/indra/newview/llvocache.h b/indra/newview/llvocache.h
index 594d38249bd07cdb5548414dd6ade6862aa2ab35..6c95541c1169469c092587cb76344539d1e54fe9 100644
--- a/indra/newview/llvocache.h
+++ b/indra/newview/llvocache.h
@@ -221,9 +221,9 @@ class LLVOCachePartition : public LLViewerOctreePartition, public LLTrace::MemTr
//
//Note: LLVOCache is not thread-safe
//
-class LLVOCache : public LLSingleton<LLVOCache>
+class LLVOCache : public LLParamSingleton<LLVOCache>
{
- LLSINGLETON(LLVOCache);
+ LLSINGLETON(LLVOCache, bool read_only);
~LLVOCache() ;
private:
@@ -259,15 +259,14 @@ class LLVOCache : public LLSingleton<LLVOCache>
typedef std::map<U64, HeaderEntryInfo*> handle_entry_map_t;
public:
- void initCache(ELLPath location, U32 size, U32 cache_version) ;
+ // We need this init to be separate from constructor, since we might construct cache, purge it, then init.
+ void initCache(ELLPath location, U32 size, U32 cache_version);
void removeCache(ELLPath location, bool started = false) ;
void readFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_entry_map_t& cache_entry_map) ;
void writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, BOOL dirty_cache, bool removal_enabled);
void removeEntry(U64 handle) ;
- void setReadOnly(bool read_only) {mReadOnly = read_only;}
-
U32 getCacheEntries() { return mNumEntries; }
U32 getCacheEntriesMax() { return mCacheSize; }
diff --git a/indra/newview/llvoicecallhandler.cpp b/indra/newview/llvoicecallhandler.cpp
index 2050dab689abd1d2c88cfa2f8a8222abeea04792..1e993d13843aaf3af2c93fa95ebd55508ee0f36b 100644
--- a/indra/newview/llvoicecallhandler.cpp
+++ b/indra/newview/llvoicecallhandler.cpp
@@ -40,7 +40,7 @@ class LLVoiceCallAvatarHandler : public LLCommandHandler
bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
{
- if (!LLUI::sSettingGroups["config"]->getBOOL("EnableVoiceCall"))
+ if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableVoiceCall"))
{
LLNotificationsUtil::add("NoVoiceCall", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
return true;
diff --git a/indra/newview/llvoiceclient.cpp b/indra/newview/llvoiceclient.cpp
index 5c107cc10bd2a6833cb1888e1f8cc58973d12202..d8c8cb04614f5d6e414f108435871484f9542890 100644
--- a/indra/newview/llvoiceclient.cpp
+++ b/indra/newview/llvoiceclient.cpp
@@ -116,7 +116,7 @@ std::string LLVoiceClientStatusObserver::status2string(LLVoiceClientStatusObserv
///////////////////////////////////////////////////////////////////////////////////////////////
-LLVoiceClient::LLVoiceClient()
+LLVoiceClient::LLVoiceClient(LLPumpIO *pump)
:
mVoiceModule(NULL),
m_servicePump(NULL),
@@ -133,6 +133,7 @@ LLVoiceClient::LLVoiceClient()
mDisableMic(false)
{
updateSettings();
+ init(pump);
}
//---------------------------------------------------
diff --git a/indra/newview/llvoiceclient.h b/indra/newview/llvoiceclient.h
index 758e9cecd76acd69cdafc782cca61bfd85096430..f95b853c31daf475ee8b2936e639189576e14cda 100644
--- a/indra/newview/llvoiceclient.h
+++ b/indra/newview/llvoiceclient.h
@@ -310,9 +310,9 @@ class LLVoiceEffectInterface
};
-class LLVoiceClient: public LLSingleton<LLVoiceClient>
+class LLVoiceClient: public LLParamSingleton<LLVoiceClient>
{
- LLSINGLETON(LLVoiceClient);
+ LLSINGLETON(LLVoiceClient, LLPumpIO *pump);
LOG_CLASS(LLVoiceClient);
~LLVoiceClient();
@@ -320,7 +320,6 @@ class LLVoiceClient: public LLSingleton<LLVoiceClient>
typedef boost::signals2::signal<void(void)> micro_changed_signal_t;
micro_changed_signal_t mMicroChangedSignal;
- void init(LLPumpIO *pump); // Call this once at application startup (creates connector)
void terminate(); // Call this to clean up during shutdown
const LLVoiceVersionInfo getVersion();
@@ -472,6 +471,8 @@ class LLVoiceClient: public LLSingleton<LLVoiceClient>
// Returns NULL if voice effects are not supported, or not enabled.
LLVoiceEffectInterface* getVoiceEffectInterface() const;
//@}
+private:
+ void init(LLPumpIO *pump);
protected:
LLVoiceModuleInterface* mVoiceModule;
diff --git a/indra/newview/llvoicevivox.cpp b/indra/newview/llvoicevivox.cpp
index e10ba77e16ba71883ffdb7ab8e6e95ef75d0ac49..739f7bd47cb340687760bc8a5937d746d14cce30 100644
--- a/indra/newview/llvoicevivox.cpp
+++ b/indra/newview/llvoicevivox.cpp
@@ -824,6 +824,20 @@ bool LLVivoxVoiceClient::startAndLaunchDaemon()
params.args.add("-lf");
params.args.add(log_folder);
+ // set log file basename and .log
+ params.args.add("-lp");
+ params.args.add("SLVoice");
+ params.args.add("-ls");
+ params.args.add(".log");
+
+ // rotate any existing log
+ std::string new_log = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "SLVoice.log");
+ std::string old_log = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "SLVoice.old");
+ if (gDirUtilp->fileExists(new_log))
+ {
+ LLFile::rename(new_log, old_log);
+ }
+
std::string shutdown_timeout = gSavedSettings.getString("VivoxShutdownTimeout");
if (!shutdown_timeout.empty())
{
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 33a9c771eab5c5e55c21df7ba60b8c7398804e2a..0a1efd564f6a7446c8eaebf58bcdc4b457996db5 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -189,7 +189,7 @@ class LLMediaDataClientObjectImpl : public LLMediaDataClientObject
virtual bool isInterestingEnough() const
{
- return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
+ return LLViewerMedia::getInstance()->isInterestingEnough(mObject, getMediaInterest());
}
virtual std::string getCapabilityUrl(const std::string &name) const
@@ -2705,7 +2705,7 @@ void LLVOVolume::syncMediaData(S32 texture_index, const LLSD &media_data, bool m
LLUUID updating_agent = LLTextureEntry::getAgentIDFromMediaVersionString(getMediaURL());
update_from_self = (updating_agent == gAgent.getID());
}
- viewer_media_t media_impl = LLViewerMedia::updateMediaImpl(mep, previous_url, update_from_self);
+ viewer_media_t media_impl = LLViewerMedia::getInstance()->updateMediaImpl(mep, previous_url, update_from_self);
addMediaImpl(media_impl, texture_index) ;
}
diff --git a/indra/newview/llweb.cpp b/indra/newview/llweb.cpp
index 61ec02957e2176ba4dea256d04f139725fc61333..a34c5826edcd55c34aa00bcb3929011bad563753 100644
--- a/indra/newview/llweb.cpp
+++ b/indra/newview/llweb.cpp
@@ -39,7 +39,6 @@
#include "lllogininstance.h"
#include "llparcel.h"
#include "llsd.h"
-#include "lltoastalertpanel.h"
#include "llui.h"
#include "lluri.h"
#include "llversioninfo.h"
@@ -57,32 +56,6 @@
bool on_load_url_external_response(const LLSD& notification, const LLSD& response, bool async );
-class URLLoader : public LLToastAlertPanel::URLLoader
-{
- virtual void load(const std::string& url , bool force_open_externally)
- {
- if (force_open_externally)
- {
- LLWeb::loadURLExternal(url);
- }
- else
- {
- LLWeb::loadURL(url);
- }
- }
-};
-static URLLoader sAlertURLLoader;
-
-
-// static
-void LLWeb::initClass()
-{
- LLToastAlertPanel::setURLLoader(&sAlertURLLoader);
-}
-
-
-
-
// static
void LLWeb::loadURL(const std::string& url, const std::string& target, const std::string& uuid)
{
@@ -121,7 +94,7 @@ void LLWeb::loadURLExternal(const std::string& url, const std::string& uuid)
void LLWeb::loadURLExternal(const std::string& url, bool async, const std::string& uuid)
{
// Act like the proxy window was closed, since we won't be able to track targeted windows in the external browser.
- LLViewerMedia::proxyWindowClosed(uuid);
+ LLViewerMedia::getInstance()->proxyWindowClosed(uuid);
if(gSavedSettings.getBOOL("DisableExternalBrowser"))
{
diff --git a/indra/newview/llweb.h b/indra/newview/llweb.h
index 7149ce9baf49b265f1de93ee560b40faa7e03296..0426f00f278efba7204830af86d1fba570046d66 100644
--- a/indra/newview/llweb.h
+++ b/indra/newview/llweb.h
@@ -46,8 +46,6 @@ class LLWeb
BROWSER_INT_LL_EXT_OTHERS = 1,
BROWSER_INTERNAL_ONLY = 2
};
-
- static void initClass();
/// Load the given url in the operating system's web browser, async if we want to return immediately
/// before browser has spawned
diff --git a/indra/newview/llwebprofile.cpp b/indra/newview/llwebprofile.cpp
index 8dcef2c7cdae9e393bb5beabd83cac1b1b798b2a..569f479a16cde785517c473b078fab3989f672ad 100644
--- a/indra/newview/llwebprofile.cpp
+++ b/indra/newview/llwebprofile.cpp
@@ -83,7 +83,7 @@ void LLWebProfile::setAuthCookie(const std::string& cookie)
LLCore::HttpHeaders::ptr_t LLWebProfile::buildDefaultHeaders()
{
LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
- LLSD headers = LLViewerMedia::getHeaders();
+ LLSD headers = LLViewerMedia::getInstance()->getHeaders();
for (LLSD::map_iterator it = headers.beginMap(); it != headers.endMap(); ++it)
{
diff --git a/indra/newview/llwindowlistener.cpp b/indra/newview/llwindowlistener.cpp
index 5367262bb6cfe3094187fffa8868c5393b1d8e52..9e4297baafc13a903d8ae97dc6436cd11d8aed51 100644
--- a/indra/newview/llwindowlistener.cpp
+++ b/indra/newview/llwindowlistener.cpp
@@ -69,7 +69,7 @@ LLWindowListener::LLWindowListener(LLViewerWindow *window, const KeyboardGetter&
std::string buttonExplain =
"(button values \"LEFT\", \"MIDDLE\", \"RIGHT\")\n";
std::string paramsExplain =
- "[\"path\"] is as for LLUI::resolvePath(), described in\n"
+ "[\"path\"] is as for LLUI::getInstance()->resolvePath(), described in\n"
"http://bitbucket.org/lindenlab/viewer-release/src/tip/indra/llui/llui.h\n"
"If you omit [\"path\"], you must specify both [\"x\"] and [\"y\"].\n"
"If you specify [\"path\"] without both [\"x\"] and [\"y\"], will synthesize (x, y)\n"
@@ -209,7 +209,7 @@ void LLWindowListener::getInfo(LLSD const & evt)
if (evt.has("path"))
{
std::string path(evt["path"]);
- LLView * target_view = LLUI::resolvePath(LLUI::getRootView(), path);
+ LLView * target_view = LLUI::getInstance()->resolvePath(LLUI::getInstance()->getRootView(), path);
if (target_view != 0)
{
response.setResponse(target_view->getInfo());
@@ -230,7 +230,7 @@ void LLWindowListener::getInfo(LLSD const & evt)
void LLWindowListener::getPaths(LLSD const & request)
{
Response response(LLSD(), request);
- LLView *root(LLUI::getRootView()), *base(NULL);
+ LLView *root(LLUI::getInstance()->getRootView()), *base(NULL);
// Capturing request["under"] as string means we conflate the case in
// which there is no ["under"] key with the case in which its value is the
// empty string. That seems to make sense to me.
@@ -243,7 +243,7 @@ void LLWindowListener::getPaths(LLSD const & request)
}
else
{
- base = LLUI::resolvePath(root, under);
+ base = LLUI::getInstance()->resolvePath(root, under);
if (! base)
{
return response.error(STRINGIZE(request["op"].asString() << " request "
@@ -268,7 +268,7 @@ void LLWindowListener::keyDown(LLSD const & evt)
if (evt.has("path"))
{
std::string path(evt["path"]);
- LLView * target_view = LLUI::resolvePath(LLUI::getRootView(), path);
+ LLView * target_view = LLUI::getInstance()->resolvePath(LLUI::getInstance()->getRootView(), path);
if (target_view == 0)
{
response.error(STRINGIZE(evt["op"].asString() << " request "
@@ -303,7 +303,7 @@ void LLWindowListener::keyUp(LLSD const & evt)
if (evt.has("path"))
{
std::string path(evt["path"]);
- LLView * target_view = LLUI::resolvePath(LLUI::getRootView(), path);
+ LLView * target_view = LLUI::getInstance()->resolvePath(LLUI::getInstance()->getRootView(), path);
if (target_view == 0 )
{
response.error(STRINGIZE(evt["op"].asString() << " request "
@@ -407,8 +407,8 @@ static void mouseEvent(const MouseFunc& func, const LLSD& request)
}
else // ! path.empty()
{
- LLView* root = LLUI::getRootView();
- LLView* target = LLUI::resolvePath(root, path);
+ LLView* root = LLUI::getInstance()->getRootView();
+ LLView* target = LLUI::getInstance()->resolvePath(root, path);
if (! target)
{
return response.error(STRINGIZE(request["op"].asString() << " request "
diff --git a/indra/newview/llworldmapview.cpp b/indra/newview/llworldmapview.cpp
index 86249badaa35e11323792464a3028faecaef1f19..9bc3a2a33bc59b3e838e64d53daf3b320afa5f0f 100644
--- a/indra/newview/llworldmapview.cpp
+++ b/indra/newview/llworldmapview.cpp
@@ -1622,7 +1622,7 @@ BOOL LLWorldMapView::handleMouseUp( S32 x, S32 y, MASK mask )
LLRect clip_rect = getRect();
clip_rect.stretch(-8);
clip_rect.clipPointToRect(mMouseDownX, mMouseDownY, local_x, local_y);
- LLUI::setMousePositionLocal(this, local_x, local_y);
+ LLUI::getInstance()->setMousePositionLocal(this, local_x, local_y);
// finish the pan
mPanning = FALSE;
diff --git a/indra/newview/tests/llxmlrpclistener_test.cpp b/indra/newview/tests/llxmlrpclistener_test.cpp
index 6e9756e7d5305f9b8fd3e0a4b9242ac8d4420ee6..dbaae7280c6f71080ab59ff2cc65c8fed41a94bb 100644
--- a/indra/newview/tests/llxmlrpclistener_test.cpp
+++ b/indra/newview/tests/llxmlrpclistener_test.cpp
@@ -88,15 +88,9 @@ namespace tut
WrapLLErrs capture;
LLSD request;
request["uri"] = uri;
- std::string threw;
- try
- {
- pumps.obtain("LLXMLRPCTransaction").post(request);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([&pumps, &request](){
+ pumps.obtain("LLXMLRPCTransaction").post(request);
+ });
ensure_contains("threw exception", threw, "missing params");
ensure_contains("identified missing", threw, "method");
ensure_contains("identified missing", threw, "reply");
@@ -113,15 +107,9 @@ namespace tut
request["reply"] = "reply";
LLSD& params(request["params"]);
params["who"]["specifically"] = "world"; // LLXMLRPCListener only handles scalar params
- std::string threw;
- try
- {
- pumps.obtain("LLXMLRPCTransaction").post(request);
- }
- catch (const WrapLLErrs::FatalException& e)
- {
- threw = e.what();
- }
+ std::string threw = capture.catch_llerrs([&pumps, &request](){
+ pumps.obtain("LLXMLRPCTransaction").post(request);
+ });
ensure_contains("threw exception", threw, "unknown type");
}
diff --git a/indra/newview/viewer_manifest.py b/indra/newview/viewer_manifest.py
index fcb97ded8ff46857ea6724b68c5d713dd410f2a5..a4cda0ba78cfe196acbc22fe004ec3fa6bd48453 100755
--- a/indra/newview/viewer_manifest.py
+++ b/indra/newview/viewer_manifest.py
@@ -46,7 +46,7 @@
# Put it FIRST because some of our build hosts have an ancient install of
# indra.util.llmanifest under their system Python!
sys.path.insert(0, os.path.join(viewer_dir, os.pardir, "lib", "python"))
-from indra.util.llmanifest import LLManifest, main, path_ancestors, CHANNEL_VENDOR_BASE, RELEASE_CHANNEL, ManifestError
+from indra.util.llmanifest import LLManifest, main, path_ancestors, CHANNEL_VENDOR_BASE, RELEASE_CHANNEL, ManifestError, MissingError
from llbase import llsd
class ViewerManifest(LLManifest):
@@ -145,13 +145,10 @@ def construct(self):
with self.prefix(src_dst="skins"):
# include the entire textures directory recursively
with self.prefix(src_dst="*/textures"):
- self.path("*/*.tga")
- self.path("*/*.j2c")
self.path("*/*.jpg")
self.path("*/*.png")
self.path("*.tga")
self.path("*.j2c")
- self.path("*.jpg")
self.path("*.png")
self.path("textures.xml")
self.path("*/xui/*/*.xml")
@@ -171,14 +168,6 @@ def construct(self):
self.path("*/*/*.gif")
- # local_assets dir (for pre-cached textures)
- with self.prefix(src_dst="local_assets"):
- self.path("*.j2c")
- self.path("*.tga")
-
- # File in the newview/ directory
- self.path("gpu_table.txt")
-
#build_data.json. Standard with exception handling is fine. If we can't open a new file for writing, we have worse problems
#platform is computed above with other arg parsing
build_data_dict = {"Type":"viewer","Version":'.'.join(self.args['version']),
@@ -517,17 +506,6 @@ def construct(self):
with self.prefix(src=os.path.join(self.args['build'], os.pardir,
'sharedlibs', self.args['configuration'])):
- # Get llcommon and deps. If missing assume static linkage and continue.
- try:
- self.path('llcommon.dll')
- self.path('libapr-1.dll')
- self.path('libaprutil-1.dll')
- self.path('libapriconv-1.dll')
-
- except RuntimeError as err:
- print err.message
- print "Skipping llcommon.dll (assuming llcommon was linked statically)"
-
# Mesh 3rd party libs needed for auto LOD and collada reading
try:
self.path("glod.dll")
@@ -552,24 +530,21 @@ def construct(self):
if self.args['configuration'].lower() == 'debug':
self.path("msvcr120d.dll")
self.path("msvcp120d.dll")
- self.path("msvcr100d.dll")
- self.path("msvcp100d.dll")
else:
self.path("msvcr120.dll")
self.path("msvcp120.dll")
- self.path("msvcr100.dll")
- self.path("msvcp100.dll")
- # Vivox runtimes
- self.path("SLVoice.exe")
+ # SLVoice executable
+ with self.prefix(src=os.path.join(pkgdir, 'bin', 'release')):
+ self.path("SLVoice.exe")
+
+ # Vivox libraries
if (self.address_size == 64):
self.path("vivoxsdk_x64.dll")
self.path("ortp_x64.dll")
else:
self.path("vivoxsdk.dll")
self.path("ortp.dll")
- self.path("libsndfile-1.dll")
- self.path("vivoxoal.dll")
# Security
self.path("ssleay32.dll")
@@ -592,15 +567,6 @@ def construct(self):
self.path("BugSplat.dll")
self.path("BugSplatRc.dll")
- # For google-perftools tcmalloc allocator.
- try:
- if self.args['configuration'].lower() == 'debug':
- self.path('libtcmalloc_minimal-debug.dll')
- else:
- self.path('libtcmalloc_minimal.dll')
- except:
- print "Skipping libtcmalloc_minimal.dll"
-
self.path(src="licenses-win32.txt", dst="licenses.txt")
self.path("featuretable.txt")
@@ -990,7 +956,7 @@ def construct(self):
with self.prefix(src=relpkgdir, dst=""):
self.path("libndofdev.dylib")
- self.path("libhunspell-1.3.0.dylib")
+ self.path("libhunspell-1.3.a")
with self.prefix(src_dst="cursors_mac"):
self.path("*.tif")
@@ -1037,11 +1003,15 @@ def path_optional(src, dst):
# (source, dest) pair to self.file_list for every expanded
# file processed. Remember its size before the call.
oldlen = len(self.file_list)
- self.path(src, dst)
- # The dest appended to self.file_list has been prepended
- # with self.get_dst_prefix(). Strip it off again.
- added = [os.path.relpath(d, self.get_dst_prefix())
- for s, d in self.file_list[oldlen:]]
+ try:
+ self.path(src, dst)
+ # The dest appended to self.file_list has been prepended
+ # with self.get_dst_prefix(). Strip it off again.
+ added = [os.path.relpath(d, self.get_dst_prefix())
+ for s, d in self.file_list[oldlen:]]
+ except MissingError as err:
+ print >> sys.stderr, "Warning: "+err.msg
+ added = []
if not added:
print "Skipping %s" % dst
return added
@@ -1051,18 +1021,10 @@ def path_optional(src, dst):
# symlink from sub-app/Contents/Resources to the real .dylib.
# Need to get the llcommon dll from any of the build directories as well.
libfile_parent = self.get_dst_prefix()
- libfile = "libllcommon.dylib"
- dylibs = path_optional(self.find_existing_file(os.path.join(os.pardir,
- "llcommon",
- self.args['configuration'],
- libfile),
- os.path.join(relpkgdir, libfile)),
- dst=libfile)
-
+ dylibs=[]
for libfile in (
"libapr-1.0.dylib",
"libaprutil-1.0.dylib",
- "libcollada14dom.dylib",
"libexpat.1.dylib",
"libexception_handler.dylib",
"libGLOD.dylib",
@@ -1073,14 +1035,14 @@ def path_optional(src, dst):
):
dylibs += path_optional(os.path.join(relpkgdir, libfile), libfile)
- # SLVoice and vivox lols, no symlinks needed
+ # SLVoice executable
+ with self.prefix(src=os.path.join(pkgdir, 'bin', 'release')):
+ self.path("SLVoice")
+
+ # Vivox libraries
for libfile in (
'libortp.dylib',
- 'libsndfile.dylib',
- 'libvivoxoal.dylib',
'libvivoxsdk.dylib',
- 'libvivoxplatform.dylib',
- 'SLVoice',
):
self.path2basename(relpkgdir, libfile)
@@ -1575,7 +1537,6 @@ def construct(self):
self.path("libsndfile.so.1")
#self.path("libvivoxoal.so.1") # no - we'll re-use the viewer's own OpenAL lib
self.path("libvivoxsdk.so")
- self.path("libvivoxplatform.so")
self.strip_binaries()
@@ -1596,4 +1557,9 @@ def construct(self):
dict(name='bugsplat', description="""BugSplat database to which to post crashes,
if BugSplat crash reporting is desired""", default=''),
]
- main(extra=extra_arguments)
+ try:
+ main(extra=extra_arguments)
+ except (ManifestError, MissingError) as err:
+ sys.exit("\nviewer_manifest.py failed: "+err.msg)
+ except:
+ raise
diff --git a/indra/test/catch_and_store_what_in.h b/indra/test/catch_and_store_what_in.h
index 59f8cc008585769dfe250e4c4ddde6059129cd43..5beba06024368dd878bd207484055c7600c3e7d3 100644
--- a/indra/test/catch_and_store_what_in.h
+++ b/indra/test/catch_and_store_what_in.h
@@ -2,7 +2,7 @@
* @file catch_and_store_what_in.h
* @author Nat Goodspeed
* @date 2012-02-15
- * @brief CATCH_AND_STORE_WHAT_IN() macro
+ * @brief catch_what() template function, CATCH_AND_STORE_WHAT_IN() macro
*
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
* Copyright (c) 2012, Linden Research, Inc.
@@ -12,6 +12,30 @@
#if ! defined(LL_CATCH_AND_STORE_WHAT_IN_H)
#define LL_CATCH_AND_STORE_WHAT_IN_H
+/**
+ * In the brave new world of lambdas, we can use a nicer C++ idiom for testing
+ * exceptions than CATCH_AND_STORE_WHAT_IN() below, e.g.:
+ *
+ * @code
+ * std::string threw = catch_what<std::runtime_error>(
+ * [](){ throw std::runtime_error("badness"); });
+ * ensure_equals(threw, "badness");
+ * @endcode
+ */
+template <typename EXCEPTION, typename FUNC>
+std::string catch_what(FUNC func)
+{
+ try
+ {
+ func();
+ return {};
+ }
+ catch (const EXCEPTION& err)
+ {
+ return err.what();
+ }
+}
+
/**
* Idiom useful for test programs: catch an expected exception, store its
* what() string in a specified std::string variable. From there the caller
diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
index 16edab628229e6afad61886f43947fa2af17a167..3abae3e43ef4802be2b52b9d719f79e9e95fbd11 100644
--- a/indra/test/llevents_tut.cpp
+++ b/indra/test/llevents_tut.cpp
@@ -134,17 +134,15 @@ void events_object::test<1>()
per_frame.post(4);
check_listener("re-blocked", listener0, 3);
} // unblock
- std::string threw;
- try
- {
- // NOTE: boost::bind() saves its arguments by VALUE! If you pass
- // an object instance rather than a pointer, you'll end up binding
- // to an internal copy of that instance! Use boost::ref() to
- // capture a reference instead.
- per_frame.listen(listener0.getName(), // note bug, dup name
- boost::bind(&Listener::call, boost::ref(listener1), _1));
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::DupListenerName)
+ std::string threw = catch_what<LLEventPump::DupListenerName>(
+ [&per_frame, this](){
+ // NOTE: boost::bind() saves its arguments by VALUE! If you pass
+ // an object instance rather than a pointer, you'll end up binding
+ // to an internal copy of that instance! Use boost::ref() to
+ // capture a reference instead.
+ per_frame.listen(listener0.getName(), // note bug, dup name
+ boost::bind(&Listener::call, boost::ref(listener1), _1));
+ });
ensure_equals(threw,
std::string("DupListenerName: "
"Attempt to register duplicate listener name '") +
@@ -341,15 +339,13 @@ void events_object::test<7>()
ensure_equals(collector.result, make<StringVec>(list_of("Mary")("spot")("checked")));
collector.clear();
button.stopListening("spot");
- std::string threw;
- try
- {
- button.listen("spot",
- boost::bind(&Collect::add, boost::ref(collector), "spot", _1),
- // after "Mary" and "checked" -- whoops!
- make<NameList>(list_of("Mary")("checked")));
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::Cycle)
+ std::string threw = catch_what<LLEventPump::Cycle>(
+ [&button, &collector](){
+ button.listen("spot",
+ boost::bind(&Collect::add, boost::ref(collector), "spot", _1),
+ // after "Mary" and "checked" -- whoops!
+ make<NameList>(list_of("Mary")("checked")));
+ });
// Obviously the specific wording of the exception text can
// change; go ahead and change the test to match.
// Establish that it contains:
@@ -374,15 +370,13 @@ void events_object::test<7>()
button.post(3);
ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
collector.clear();
- threw.clear();
- try
- {
- button.listen("of",
- boost::bind(&Collect::add, boost::ref(collector), "of", _1),
- make<NameList>(list_of("shoelaces")),
- make<NameList>(list_of("yellow")));
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::OrderChange)
+ threw = catch_what<LLEventPump::OrderChange>(
+ [&button, &collector](){
+ button.listen("of",
+ boost::bind(&Collect::add, boost::ref(collector), "of", _1),
+ make<NameList>(list_of("shoelaces")),
+ make<NameList>(list_of("yellow")));
+ });
// Same remarks about the specific wording of the exception. Just
// ensure that it contains enough information to clarify the
// problem and what must be done to resolve it.
@@ -404,13 +398,11 @@ void events_object::test<8>()
{ // nested scope
// Hand-instantiate an LLEventStream...
LLEventStream bob("bob");
- std::string threw;
- try
- {
- // then another with a duplicate name.
- LLEventStream bob2("bob");
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::DupPumpName)
+ std::string threw = catch_what<LLEventPump::DupPumpName>(
+ [](){
+ // then another with a duplicate name.
+ LLEventStream bob2("bob");
+ });
ensure("Caught DupPumpName", !threw.empty());
} // delete first 'bob'
LLEventStream bob("bob"); // should work, previous one unregistered
@@ -445,13 +437,11 @@ void events_object::test<9>()
listener0.listenTo(random);
eventSource("random");
check_listener("got by pump name", listener0, 17);
- std::string threw;
- try
- {
- LLListenerOrPumpName empty;
- empty(17);
- }
- CATCH_AND_STORE_WHAT_IN(threw, LLListenerOrPumpName::Empty)
+ std::string threw = catch_what<LLListenerOrPumpName::Empty>(
+ [](){
+ LLListenerOrPumpName empty;
+ empty(17);
+ });
ensure("threw Empty", !threw.empty());
}
diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index 861ec1d942fac8120aac7435dbf6fdbe5106ca7b..b14c2eb255a5a1ca657b426749315cb3602808f5 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -37,7 +37,6 @@
#include "linden_common.h"
#include "llerrorcontrol.h"
#include "lltut.h"
-#include "tests/wrapllerrs.h" // RecorderProxy
#include "stringize.h"
#include "namedtempfile.h"
#include "lltrace.h"
@@ -254,7 +253,7 @@ class LLTestCallback : public tut::callback
break;
case tut::test_result::ex:
++mFailedTests;
- out << "exception";
+ out << "exception: " << tr.exception_typeid;
break;
case tut::test_result::warn:
++mFailedTests;
@@ -265,7 +264,7 @@ class LLTestCallback : public tut::callback
out << "abnormal termination";
break;
case tut::test_result::skip:
- ++mSkippedTests;
+ ++mSkippedTests;
out << "skipped known failure";
break;
default: