automated merge viewer2.0->avp

--HG--
branch : avatar-pipeline

59 files changed, 1241 insertions, 416 deletions

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index eb0d180a4b..ac7cc2cdac 100644
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -167,6 +167,7 @@ set(llcommon_HEADER_FILES
     llinstancetracker.h
     llkeythrottle.h
     lllazy.h
+    lllistenerwrapper.h
     lllinkedqueue.h
     llliveappconfig.h
     lllivefile.h
@@ -224,6 +225,7 @@ set(llcommon_HEADER_FILES
     llversionserver.h
     llversionviewer.h
     llworkerthread.h
+    ll_template_cast.h
     metaclass.h
     metaclasst.h
     metaproperty.h
diff --git a/indra/llcommon/ll_template_cast.h b/indra/llcommon/ll_template_cast.h
new file mode 100644
index 0000000000..cff58ce00d
--- /dev/null
+++ b/indra/llcommon/ll_template_cast.h
@@ -0,0 +1,160 @@
+/**
+ * @file   ll_template_cast.h
+ * @author Nat Goodspeed
+ * @date   2009-11-21
+ * @brief  Define ll_template_cast function
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LL_TEMPLATE_CAST_H)
+#define LL_LL_TEMPLATE_CAST_H
+
+/**
+ * Implementation for ll_template_cast() (q.v.).
+ *
+ * Default implementation: trying to cast two completely unrelated types
+ * returns 0. Typically you'd specify T and U as pointer types, but in fact T
+ * can be any type that can be initialized with 0.
+ */
+template <typename T, typename U>
+struct ll_template_cast_impl
+{
+    T operator()(U)
+    {
+        return 0;
+    }
+};
+
+/**
+ * ll_template_cast<T>(some_value) is for use in a template function when
+ * some_value might be of arbitrary type, but you want to recognize type T
+ * specially.
+ *
+ * It's designed for use with pointer types. Example:
+ * @code
+ * struct SpecialClass
+ * {
+ *     void someMethod(const std::string&) const;
+ * };
+ *
+ * template <class REALCLASS>
+ * void somefunc(const REALCLASS& instance)
+ * {
+ *     const SpecialClass* ptr = ll_template_cast<const SpecialClass*>(&instance);
+ *     if (ptr)
+ *     {
+ *         ptr->someMethod("Call method only available on SpecialClass");
+ *     }
+ * }
+ * @endcode
+ *
+ * Why is this better than dynamic_cast<>? Because unless OtherClass is
+ * polymorphic, the following won't even compile (gcc 4.0.1):
+ * @code
+ * OtherClass other;
+ * SpecialClass* ptr = dynamic_cast<SpecialClass*>(&other);
+ * @endcode
+ * to say nothing of this:
+ * @code
+ * void function(int);
+ * SpecialClass* ptr = dynamic_cast<SpecialClass*>(&function);
+ * @endcode
+ * ll_template_cast handles these kinds of cases by returning 0.
+ */
+template <typename T, typename U>
+T ll_template_cast(U value)
+{
+    return ll_template_cast_impl<T, U>()(value);
+}
+
+/**
+ * Implementation for ll_template_cast() (q.v.).
+ *
+ * Implementation for identical types: return same value.
+ */
+template <typename T>
+struct ll_template_cast_impl<T, T>
+{
+    T operator()(T value)
+    {
+        return value;
+    }
+};
+
+/**
+ * LL_TEMPLATE_CONVERTIBLE(dest, source) asserts that, for a value @c s of
+ * type @c source, <tt>ll_template_cast<dest>(s)</tt> will return @c s --
+ * presuming that @c source can be converted to @c dest by the normal rules of
+ * C++.
+ *
+ * By default, <tt>ll_template_cast<dest>(s)</tt> will return 0 unless @c s's
+ * type is literally identical to @c dest. (This is because of the
+ * straightforward application of template specialization rules.) That can
+ * lead to surprising results, e.g.:
+ *
+ * @code
+ * Foo myFoo;
+ * const Foo* fooptr = ll_template_cast<const Foo*>(&myFoo);
+ * @endcode
+ *
+ * Here @c fooptr will be 0 because <tt>&myFoo</tt> is of type <tt>Foo*</tt>
+ * -- @em not <tt>const Foo*</tt>. (Declaring <tt>const Foo myFoo;</tt> would
+ * force the compiler to do the right thing.)
+ *
+ * More disappointingly:
+ * @code
+ * struct Base {};
+ * struct Subclass: public Base {};
+ * Subclass object;
+ * Base* ptr = ll_template_cast<Base*>(&object);
+ * @endcode
+ *
+ * Here @c ptr will be 0 because <tt>&object</tt> is of type
+ * <tt>Subclass*</tt> rather than <tt>Base*</tt>. We @em want this cast to
+ * succeed, but without our help ll_template_cast can't recognize it.
+ *
+ * The following would suffice:
+ * @code
+ * LL_TEMPLATE_CONVERTIBLE(Base*, Subclass*);
+ * ...
+ * Base* ptr = ll_template_cast<Base*>(&object);
+ * @endcode
+ *
+ * However, as noted earlier, this is easily fooled:
+ * @code
+ * const Base* ptr = ll_template_cast<const Base*>(&object);
+ * @endcode
+ * would still produce 0 because we haven't yet seen:
+ * @code
+ * LL_TEMPLATE_CONVERTIBLE(const Base*, Subclass*);
+ * @endcode
+ *
+ * @TODO
+ * This macro should use Boost type_traits facilities for stripping and
+ * re-adding @c const and @c volatile qualifiers so that invoking
+ * LL_TEMPLATE_CONVERTIBLE(dest, source) will automatically generate all
+ * permitted permutations. It's really not fair to the coder to require
+ * separate:
+ * @code
+ * LL_TEMPLATE_CONVERTIBLE(Base*, Subclass*);
+ * LL_TEMPLATE_CONVERTIBLE(const Base*, Subclass*);
+ * LL_TEMPLATE_CONVERTIBLE(const Base*, const Subclass*);
+ * @endcode
+ *
+ * (Naturally we omit <tt>LL_TEMPLATE_CONVERTIBLE(Base*, const Subclass*)</tt>
+ * because that's not permitted by normal C++ assignment anyway.)
+ */
+#define LL_TEMPLATE_CONVERTIBLE(DEST, SOURCE)   \
+template <>                                     \
+struct ll_template_cast_impl<DEST, SOURCE>      \
+{                                               \
+    DEST operator()(SOURCE wrapper)             \
+    {                                           \
+        return wrapper;                         \
+    }                                           \
+}
+
+#endif /* ! defined(LL_LL_TEMPLATE_CAST_H) */
diff --git a/indra/llcommon/llevents.cpp b/indra/llcommon/llevents.cpp
index 4bdfe5a867..31fdd9e60a 100644
--- a/indra/llcommon/llevents.cpp
+++ b/indra/llcommon/llevents.cpp
@@ -459,11 +459,25 @@ void LLEventPump::stopListening(const std::string& name)
 bool LLEventStream::post(const LLSD& event)
 {
     if (! mEnabled)
+    {
         return false;
+    }
+    // NOTE NOTE NOTE: Any new access to member data beyond this point should
+    // cause us to move our LLStandardSignal object to a pimpl class along
+    // with said member data. Then the local shared_ptr will preserve both.
+
+    // DEV-43463: capture a local copy of mSignal. We've turned up a
+    // cross-coroutine scenario (described in the Jira) in which this post()
+    // call could end up destroying 'this', the LLEventPump subclass instance
+    // containing mSignal, during the call through *mSignal. So -- capture a
+    // *stack* instance of the shared_ptr, ensuring that our heap
+    // LLStandardSignal object will live at least until post() returns, even
+    // if 'this' gets destroyed during the call.
+    boost::shared_ptr<LLStandardSignal> signal(mSignal);
     // Let caller know if any one listener handled the event. This is mostly
     // useful when using LLEventStream as a listener for an upstream
     // LLEventPump.
-    return (*mSignal)(event);
+    return (*signal)(event);
 }
 
 /*****************************************************************************
@@ -492,9 +506,16 @@ void LLEventQueue::flush()
     // be processed in the *next* flush() call.
     EventQueue queue(mEventQueue);
     mEventQueue.clear();
+    // NOTE NOTE NOTE: Any new access to member data beyond this point should
+    // cause us to move our LLStandardSignal object to a pimpl class along
+    // with said member data. Then the local shared_ptr will preserve both.
+
+    // DEV-43463: capture a local copy of mSignal. See LLEventStream::post()
+    // for detailed comments.
+    boost::shared_ptr<LLStandardSignal> signal(mSignal);
     for ( ; ! queue.empty(); queue.pop_front())
     {
-        (*mSignal)(queue.front());
+        (*signal)(queue.front());
     }
 }
 
diff --git a/indra/llcommon/llevents.h b/indra/llcommon/llevents.h
index f52cf33fd8..a73ada2931 100644
--- a/indra/llcommon/llevents.h
+++ b/indra/llcommon/llevents.h
@@ -44,6 +44,7 @@
 #include "llsd.h"
 #include "llsingleton.h"
 #include "lldependencies.h"
+#include "ll_template_cast.h"
 
 /*==========================================================================*|
 // override this to allow binding free functions with more parameters
@@ -256,6 +257,11 @@ namespace LLEventDetail
     /// signature.
     typedef boost::function<LLBoundListener(const LLEventListener&)> ConnectFunc;
 
+    /// overload of visit_and_connect() when we have a string identifier available
+    template <typename LISTENER>
+    LLBoundListener visit_and_connect(const std::string& name,
+                                      const LISTENER& listener,
+                                      const ConnectFunc& connect_func);
     /**
      * Utility template function to use Visitor appropriately
      *
@@ -266,7 +272,10 @@ namespace LLEventDetail
      */
     template <typename LISTENER>
     LLBoundListener visit_and_connect(const LISTENER& listener,
-                                      const ConnectFunc& connect_func);
+                                      const ConnectFunc& connect_func)
+    {
+        return visit_and_connect("", listener, connect_func);
+    }
 } // namespace LLEventDetail
 
 /*****************************************************************************
@@ -468,7 +477,8 @@ public:
         // This is why listen() is a template. Conversion from boost::bind()
         // to LLEventListener performs type erasure, so it's important to look
         // at the boost::bind object itself before that happens.
-        return LLEventDetail::visit_and_connect(listener,
+        return LLEventDetail::visit_and_connect(name,
+                                                listener,
                                                 boost::bind(&LLEventPump::listen_impl,
                                                             this,
                                                             name,
@@ -522,7 +532,7 @@ private:
 
 protected:
     /// implement the dispatching
-    boost::scoped_ptr<LLStandardSignal> mSignal;
+    boost::shared_ptr<LLStandardSignal> mSignal;
 
     /// valve open?
     bool mEnabled;
@@ -664,6 +674,62 @@ private:
     LLSD mReqid;
 };
 
+/**
+ * Base class for LLListenerWrapper. See visit_and_connect() and llwrap(). We
+ * provide virtual @c accept_xxx() methods, customization points allowing a
+ * subclass access to certain data visible at LLEventPump::listen() time.
+ * Example subclass usage:
+ *
+ * @code
+ * myEventPump.listen("somename",
+ *                    llwrap<MyListenerWrapper>(boost::bind(&MyClass::method, instance, _1)));
+ * @endcode
+ *
+ * Because of the anticipated usage (note the anonymous temporary
+ * MyListenerWrapper instance in the example above), the @c accept_xxx()
+ * methods must be @c const.
+ */
+class LL_COMMON_API LLListenerWrapperBase
+{
+public:
+    /// New instance. The accept_xxx() machinery makes it important to use
+    /// shared_ptrs for our data. Many copies of this object are made before
+    /// the instance that actually ends up in the signal, yet accept_xxx()
+    /// will later be called on the @em original instance. All copies of the
+    /// same original instance must share the same data.
+    LLListenerWrapperBase():
+        mName(new std::string),
+        mConnection(new LLBoundListener)
+    {
+    }
+	
+    /// Copy constructor. Copy shared_ptrs to original instance data.
+    LLListenerWrapperBase(const LLListenerWrapperBase& that):
+        mName(that.mName),
+        mConnection(that.mConnection)
+    {
+    }
+	virtual ~LLListenerWrapperBase() {}
+
+    /// Ask LLEventPump::listen() for the listener name
+    virtual void accept_name(const std::string& name) const
+    {
+        *mName = name;
+    }
+
+    /// Ask LLEventPump::listen() for the new connection
+    virtual void accept_connection(const LLBoundListener& connection) const
+    {
+        *mConnection = connection;
+    }
+
+protected:
+    /// Listener name.
+    boost::shared_ptr<std::string> mName;
+    /// Connection.
+    boost::shared_ptr<LLBoundListener> mConnection;
+};
+
 /*****************************************************************************
 *   Underpinnings
 *****************************************************************************/
@@ -898,7 +964,8 @@ namespace LLEventDetail
      * LLStandardSignal, returning LLBoundListener.
      */
     template <typename LISTENER>
-    LLBoundListener visit_and_connect(const LISTENER& raw_listener,
+    LLBoundListener visit_and_connect(const std::string& name,
+                                      const LISTENER& raw_listener,
                                       const ConnectFunc& connect_func)
     {
         // Capture the listener
@@ -913,14 +980,20 @@ namespace LLEventDetail
         // which type details have been erased. unwrap() comes from
         // Boost.Signals, in case we were passed a boost::ref().
         visit_each(visitor, LLEventDetail::unwrap(raw_listener));
-        // Make the connection using passed function. At present, wrapping
-        // this functionality into this function is a bit silly: we don't
-        // really need a visit_and_connect() function any more, just a visit()
-        // function. The definition of this function dates from when, after
-        // visit_each(), after establishing the connection, we had to
-        // postprocess the new connection with the visitor object. That's no
-        // longer necessary.
-        return connect_func(listener);
+        // Make the connection using passed function.
+        LLBoundListener connection(connect_func(listener));
+        // If the LISTENER is an LLListenerWrapperBase subclass, pass it the
+        // desired information. It's important that we pass the raw_listener
+        // so the compiler can make decisions based on its original type.
+        const LLListenerWrapperBase* lwb =
+            ll_template_cast<const LLListenerWrapperBase*>(&raw_listener);
+        if (lwb)
+        {
+            lwb->accept_name(name);
+            lwb->accept_connection(connection);
+        }
+        // In any case, show new connection to caller.
+        return connection;
     }
 } // namespace LLEventDetail
 
diff --git a/indra/llcommon/lllistenerwrapper.h b/indra/llcommon/lllistenerwrapper.h
new file mode 100644
index 0000000000..2f747fb182
--- /dev/null
+++ b/indra/llcommon/lllistenerwrapper.h
@@ -0,0 +1,181 @@
+/**
+ * @file   lllistenerwrapper.h
+ * @author Nat Goodspeed
+ * @date   2009-11-30
+ * @brief  Introduce LLListenerWrapper template
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLLISTENERWRAPPER_H)
+#define LL_LLLISTENERWRAPPER_H
+
+#include "llevents.h"               // LLListenerWrapperBase
+#include <boost/visit_each.hpp>
+
+/**
+ * Template base class for coding wrappers for LLEventPump listeners.
+ *
+ * Derive your listener wrapper from LLListenerWrapper. You must use
+ * LLLISTENER_WRAPPER_SUBCLASS() so your subclass will play nicely with
+ * boost::visit_each (q.v.). That way boost::signals2 can still detect
+ * derivation from LLEventTrackable, and so forth.
+ */
+template <typename LISTENER>
+class LLListenerWrapper: public LLListenerWrapperBase
+{
+public:
+    /// Wrap an arbitrary listener object
+    LLListenerWrapper(const LISTENER& listener):
+        mListener(listener)
+    {}
+
+    /// call
+    virtual bool operator()(const LLSD& event)
+    {
+        return mListener(event);
+    }
+
+    /// Allow boost::visit_each() to peek at our mListener.
+    template <class V>
+    void accept_visitor(V& visitor) const
+    {
+        using boost::visit_each;
+        visit_each(visitor, mListener, 0);
+    }
+
+private:
+    LISTENER mListener;
+};
+
+/**
+ * Specialize boost::visit_each() (leveraging ADL) to peek inside an
+ * LLListenerWrapper<T> to traverse its LISTENER. We borrow the
+ * accept_visitor() pattern from boost::bind(), avoiding the need to make
+ * mListener public.
+ */
+template <class V, typename T>
+void visit_each(V& visitor, const LLListenerWrapper<T>& wrapper, int)
+{
+    wrapper.accept_visitor(visitor);
+}
+
+/// use this (sigh!) for each subclass of LLListenerWrapper<T> you write
+#define LLLISTENER_WRAPPER_SUBCLASS(CLASS)                              \
+template <class V, typename T>                                          \
+void visit_each(V& visitor, const CLASS<T>& wrapper, int)               \
+{                                                                       \
+    visit_each(visitor, static_cast<const LLListenerWrapper<T>&>(wrapper), 0); \
+}                                                                       \
+                                                                        \
+/* Have to state this explicitly, rather than using LL_TEMPLATE_CONVERTIBLE, */ \
+/* because the source type is itself a template. */                     \
+template <typename T>                                                   \
+struct ll_template_cast_impl<const LLListenerWrapperBase*, const CLASS<T>*> \
+{                                                                       \
+    const LLListenerWrapperBase* operator()(const CLASS<T>* wrapper)    \
+    {                                                                   \
+        return wrapper;                                                 \
+    }                                                                   \
+}
+
+/**
+ * Make an instance of a listener wrapper. Every wrapper class must be a
+ * template accepting a listener object of arbitrary type. In particular, the
+ * type of a boost::bind() expression is deliberately undocumented. So we
+ * can't just write Wrapper<CorrectType>(boost::bind(...)). Instead we must
+ * write llwrap<Wrapper>(boost::bind(...)).
+ */
+template <template<typename> class WRAPPER, typename T>
+WRAPPER<T> llwrap(const T& listener)
+{
+    return WRAPPER<T>(listener);
+}
+
+/**
+ * This LLListenerWrapper template subclass is used to report entry/exit to an
+ * event listener, by changing this:
+ * @code
+ * someEventPump.listen("MyClass",
+ *                      boost::bind(&MyClass::method, ptr, _1));
+ * @endcode
+ * to this:
+ * @code
+ * someEventPump.listen("MyClass",
+ *                      llwrap<LLCoutListener>(
+ *                      boost::bind(&MyClass::method, ptr, _1)));
+ * @endcode
+ */
+template <class LISTENER>
+class LLCoutListener: public LLListenerWrapper<LISTENER>
+{
+    typedef LLListenerWrapper<LISTENER> super;
+
+public:
+    /// Wrap an arbitrary listener object
+    LLCoutListener(const LISTENER& listener):
+        super(listener)
+    {}
+
+    /// call
+    virtual bool operator()(const LLSD& event)
+    {
+        std::cout << "Entering listener " << *super::mName << " with " << event << std::endl;
+        bool handled = super::operator()(event);
+        std::cout << "Leaving  listener " << *super::mName;
+        if (handled)
+        {
+            std::cout << " (handled)";
+        }
+        std::cout << std::endl;
+        return handled;
+    }
+};
+
+LLLISTENER_WRAPPER_SUBCLASS(LLCoutListener);
+
+/**
+ * This LLListenerWrapper template subclass is used to log entry/exit to an
+ * event listener, by changing this:
+ * @code
+ * someEventPump.listen("MyClass",
+ *                      boost::bind(&MyClass::method, ptr, _1));
+ * @endcode
+ * to this:
+ * @code
+ * someEventPump.listen("MyClass",
+ *                      llwrap<LLLogListener>(
+ *                      boost::bind(&MyClass::method, ptr, _1)));
+ * @endcode
+ */
+template <class LISTENER>
+class LLLogListener: public LLListenerWrapper<LISTENER>
+{
+    typedef LLListenerWrapper<LISTENER> super;
+
+public:
+    /// Wrap an arbitrary listener object
+    LLLogListener(const LISTENER& listener):
+        super(listener)
+    {}
+
+    /// call
+    virtual bool operator()(const LLSD& event)
+    {
+        LL_DEBUGS("LLLogListener") << "Entering listener " << *super::mName << " with " << event << LL_ENDL;
+        bool handled = super::operator()(event);
+        LL_DEBUGS("LLLogListener") << "Leaving  listener " << *super::mName;
+        if (handled)
+        {
+            LL_CONT << " (handled)";
+        }
+        LL_CONT << LL_ENDL;
+        return handled;
+    }
+};
+
+LLLISTENER_WRAPPER_SUBCLASS(LLLogListener);
+
+#endif /* ! defined(LL_LLLISTENERWRAPPER_H) */
diff --git a/indra/llcommon/tests/llerror_test.cpp b/indra/llcommon/tests/llerror_test.cpp
index 1558df231a..6785d0cf17 100644
--- a/indra/llcommon/tests/llerror_test.cpp
+++ b/indra/llcommon/tests/llerror_test.cpp
@@ -545,6 +545,15 @@ namespace tut
 		// output order
 	void ErrorTestObject::test<10>()
 	{
+#if LL_LINUX
+        skip("Fails on Linux, see comments");
+// on Linux:
+// [error, 10] fail: 'order is time type location function message: expected
+// '1947-07-08T03:04:05Z INFO: llcommon/tests/llerror_test.cpp(268) :
+// writeReturningLocationAndFunction: apple' actual
+// '1947-07-08T03:04:05Z INFO: llcommon/tests/llerror_test.cpp(268) :
+// LLError::NoClassInfo::writeReturningLocationAndFunction: apple''
+#endif
 		LLError::setPrintLocation(true);
 		LLError::setTimeFunction(roswell);
 		mRecorder.setWantsTime(true);
diff --git a/indra/llmessage/tests/llsdmessage_test.cpp b/indra/llmessage/tests/llsdmessage_test.cpp
index 9b018d685b..de2c7e00c8 100644
--- a/indra/llmessage/tests/llsdmessage_test.cpp
+++ b/indra/llmessage/tests/llsdmessage_test.cpp
@@ -21,6 +21,7 @@
 #include <iostream>
 // std headers
 #include <stdexcept>
+#include <typeinfo>
 // external library headers
 // other Linden headers
 #include "../test/lltut.h"
@@ -63,6 +64,32 @@ namespace tut
         {
             threw = true;
         }
+        catch (const std::runtime_error& ex)
+        {
+            // This clause is because on Linux, on the viewer side, for this
+            // one test program (though not others!), the
+            // LLEventPump::DupPumpName exception isn't caught by the clause
+            // above. Warn the user...
+            std::cerr << "Failed to catch " << typeid(ex).name() << std::endl;
+            // But if the expected exception was thrown, allow the test to
+            // succeed anyway. Not sure how else to handle this odd case.
+            if (std::string(typeid(ex).name()) == typeid(LLEventPump::DupPumpName).name())
+            {
+                threw = true;
+            }
+            else
+            {
+                // We don't even recognize this exception. Let it propagate
+                // out to TUT to fail the test.
+                throw;
+            }
+        }
+        catch (...)
+        {
+            std::cerr << "Utterly failed to catch expected exception!" << std::endl;
+            // This case is full of fail. We HAVE to address it.
+            throw;
+        }
         ensure("second LLSDMessage should throw", threw);
     }
 
diff --git a/indra/llplugin/llpluginmessage.cpp b/indra/llplugin/llpluginmessage.cpp
index 34e02c356e..d06f3cefa0 100644
--- a/indra/llplugin/llpluginmessage.cpp
+++ b/indra/llplugin/llpluginmessage.cpp
@@ -37,31 +37,57 @@
 #include "llsdserialize.h"
 #include "u64.h"
 
+/**
+ * Constructor.
+ */
 LLPluginMessage::LLPluginMessage()
 {
 }
 
+/**
+ * Constructor.
+ *
+ * @param[in] p Existing message
+ */
 LLPluginMessage::LLPluginMessage(const LLPluginMessage &p)
 {
 	mMessage = p.mMessage;
 }
 
+/**
+ * Constructor.
+ *
+ * @param[in] message_class Message class
+ * @param[in] message_name Message name
+ */
 LLPluginMessage::LLPluginMessage(const std::string &message_class, const std::string &message_name)
 {
 	setMessage(message_class, message_name);
 }
 
 
+/**
+ * Destructor.
+ */
 LLPluginMessage::~LLPluginMessage()
 {
 }
 
+/**
+ * Reset all internal state.
+ */
 void LLPluginMessage::clear()
 {
 	mMessage = LLSD::emptyMap();
 	mMessage["params"] = LLSD::emptyMap();
 }
 
+/**
+ * Sets the message class and name. Also has the side-effect of clearing any key-value pairs in the message.
+ *
+ * @param[in] message_class Message class
+ * @param[in] message_name Message name
+ */
 void LLPluginMessage::setMessage(const std::string &message_class, const std::string &message_name)
 {
 	clear();
@@ -69,21 +95,45 @@ void LLPluginMessage::setMessage(const std::string &message_class, const std::st
 	mMessage["name"] = message_name;
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is a string.
+ *
+ * @param[in] key Key
+ * @param[in] value String value
+ */
 void LLPluginMessage::setValue(const std::string &key, const std::string &value)
 {
 	mMessage["params"][key] = value;
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is LLSD.
+ *
+ * @param[in] key Key
+ * @param[in] value LLSD value
+ */
 void LLPluginMessage::setValueLLSD(const std::string &key, const LLSD &value)
 {
 	mMessage["params"][key] = value;
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is signed 32-bit.
+ *
+ * @param[in] key Key
+ * @param[in] value 32-bit signed value
+ */
 void LLPluginMessage::setValueS32(const std::string &key, S32 value)
 {
 	mMessage["params"][key] = value;
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is unsigned 32-bit. The value is stored as a string beginning with "0x".
+ *
+ * @param[in] key Key
+ * @param[in] value 32-bit unsigned value
+ */
 void LLPluginMessage::setValueU32(const std::string &key, U32 value)
 {
 	std::stringstream temp;
@@ -91,16 +141,34 @@ void LLPluginMessage::setValueU32(const std::string &key, U32 value)
 	setValue(key, temp.str());
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is a bool.
+ *
+ * @param[in] key Key
+ * @param[in] value Boolean value
+ */
 void LLPluginMessage::setValueBoolean(const std::string &key, bool value)
 {
 	mMessage["params"][key] = value;
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is a double.
+ *
+ * @param[in] key Key
+ * @param[in] value Boolean value
+ */
 void LLPluginMessage::setValueReal(const std::string &key, F64 value)
 {
 	mMessage["params"][key] = value;
 }
 
+/**
+ * Sets a key/value pair in the message, where the value is a pointer. The pointer is stored as a string.
+ *
+ * @param[in] key Key
+ * @param[in] value Pointer value
+ */
 void LLPluginMessage::setValuePointer(const std::string &key, void* value)
 {
 	std::stringstream temp;
@@ -109,16 +177,33 @@ void LLPluginMessage::setValuePointer(const std::string &key, void* value)
 	setValue(key, temp.str());
 }
 
+/**
+ * Gets the message class.
+ *
+ * @return Message class
+ */
 std::string LLPluginMessage::getClass(void) const
 {
 	return mMessage["class"];
 }
 
+/**
+ * Gets the message name.
+ *
+ * @return Message name
+ */
 std::string LLPluginMessage::getName(void) const
 {
 	return mMessage["name"];
 }
 
+/**
+ *	Returns true if the specified key exists in this message (useful for optional parameters).
+ *
+ * @param[in] key Key
+ *
+ * @return True if key exists, false otherwise.
+ */
 bool LLPluginMessage::hasValue(const std::string &key) const
 {
 	bool result = false;
@@ -131,6 +216,13 @@ bool LLPluginMessage::hasValue(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as a string. If the key does not exist, an empty string will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return String value of key if key exists, empty string if key does not exist.
+ */
 std::string LLPluginMessage::getValue(const std::string &key) const
 {
 	std::string result;
@@ -143,6 +235,13 @@ std::string LLPluginMessage::getValue(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as LLSD. If the key does not exist, a null LLSD will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return LLSD value of key if key exists, null LLSD if key does not exist.
+ */
 LLSD LLPluginMessage::getValueLLSD(const std::string &key) const
 {
 	LLSD result;
@@ -155,6 +254,13 @@ LLSD LLPluginMessage::getValueLLSD(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as signed 32-bit int. If the key does not exist, 0 will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Signed 32-bit int value of key if key exists, 0 if key does not exist.
+ */
 S32 LLPluginMessage::getValueS32(const std::string &key) const
 {
 	S32 result = 0;
@@ -167,6 +273,13 @@ S32 LLPluginMessage::getValueS32(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as unsigned 32-bit int. If the key does not exist, 0 will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Unsigned 32-bit int value of key if key exists, 0 if key does not exist.
+ */
 U32 LLPluginMessage::getValueU32(const std::string &key) const
 {
 	U32 result = 0;
@@ -181,6 +294,13 @@ U32 LLPluginMessage::getValueU32(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as a bool. If the key does not exist, false will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Boolean value of key if it exists, false otherwise.
+ */
 bool LLPluginMessage::getValueBoolean(const std::string &key) const
 {
 	bool result = false;
@@ -193,6 +313,13 @@ bool LLPluginMessage::getValueBoolean(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as a double. If the key does not exist, 0 will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Value as a double if key exists, 0 otherwise.
+ */
 F64 LLPluginMessage::getValueReal(const std::string &key) const
 {
 	F64 result = 0.0f;
@@ -205,6 +332,13 @@ F64 LLPluginMessage::getValueReal(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Gets the value of a key as a pointer. If the key does not exist, NULL will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Pointer value if key exists, NULL otherwise.
+ */
 void* LLPluginMessage::getValuePointer(const std::string &key) const
 {
 	void* result = NULL;
@@ -219,6 +353,11 @@ void* LLPluginMessage::getValuePointer(const std::string &key) const
 	return result;
 }
 
+/**
+ *	Flatten the message into a string.
+ *
+ * @return Message as a string.
+ */
 std::string LLPluginMessage::generate(void) const
 {
 	std::ostringstream result;
@@ -230,7 +369,11 @@ std::string LLPluginMessage::generate(void) const
 	return result.str();
 }
 
-
+/**
+ *	Parse an incoming message into component parts. Clears all existing state before starting the parse.
+ *
+ * @return Returns -1 on failure, otherwise returns the number of key/value pairs in the incoming message.
+ */
 int LLPluginMessage::parse(const std::string &message)
 {
 	// clear any previous state
@@ -255,16 +398,31 @@ LLPluginMessageDispatcher::~LLPluginMessageDispatcher()
 	
 }
 	
+/**
+ * Add a message listener. TODO:DOC need more info on what uses this. when are multiple listeners needed?
+ *
+ * @param[in] listener Message listener
+ */
 void LLPluginMessageDispatcher::addPluginMessageListener(LLPluginMessageListener *listener)
 {
 	mListeners.insert(listener);
 }
 
+/**
+ * Remove a message listener.
+ *
+ * @param[in] listener Message listener
+ */
 void LLPluginMessageDispatcher::removePluginMessageListener(LLPluginMessageListener *listener)
 {
 	mListeners.erase(listener);
 }
 
+/**
+ * Distribute a message to all message listeners.
+ *
+ * @param[in] message Message
+ */
 void LLPluginMessageDispatcher::dispatchPluginMessage(const LLPluginMessage &message)
 {
 	for (listener_set_t::iterator it = mListeners.begin();
diff --git a/indra/llplugin/llpluginmessage.h b/indra/llplugin/llpluginmessage.h
index 99f8d1194f..e00022a245 100644
--- a/indra/llplugin/llpluginmessage.h
+++ b/indra/llplugin/llpluginmessage.h
@@ -104,6 +104,9 @@ private:
 
 };
 
+/**
+ * @brief Listens for plugin messages.
+ */
 class LLPluginMessageListener
 {
 public:
@@ -112,6 +115,11 @@ public:
 	
 };
 
+/**
+ * @brief Dispatcher for plugin messages.
+ *
+ * Manages the set of plugin message listeners and distributes messages to plugin message listeners.
+ */
 class LLPluginMessageDispatcher
 {
 public:
@@ -122,7 +130,9 @@ public:
 protected:
 	void dispatchPluginMessage(const LLPluginMessage &message);
 
+   /** A set of message listeners. */
 	typedef std::set<LLPluginMessageListener*> listener_set_t;
+   /** The set of message listeners. */
 	listener_set_t mListeners;
 };
 
diff --git a/indra/llui/llflatlistview.cpp b/indra/llui/llflatlistview.cpp
index f4a5f1c990..d4c3cfb7b6 100644
--- a/indra/llui/llflatlistview.cpp
+++ b/indra/llui/llflatlistview.cpp
@@ -689,6 +689,17 @@ LLRect LLFlatListView::getSelectedItemsRect()
 	return rc;
 }
 
+void LLFlatListView::selectFirstItem	()
+{
+	selectItemPair(mItemPairs.front(), true);
+}
+
+void LLFlatListView::selectLastItem		()
+{
+	selectItemPair(mItemPairs.back(), true);
+}
+
+
 // virtual
 bool LLFlatListView::selectNextItemPair(bool is_up_direction, bool reset_selection)
 {
@@ -696,53 +707,53 @@ bool LLFlatListView::selectNextItemPair(bool is_up_direction, bool reset_selecti
 	if ( !mItemPairs.size() )
 		return false;
 
-	item_pair_t* cur_sel_pair = NULL;
+	
 	item_pair_t* to_sel_pair = NULL;
-
+	item_pair_t* cur_sel_pair = NULL;
 	if ( mSelectedItemPairs.size() )
 	{
 		// Take the last selected pair
 		cur_sel_pair = mSelectedItemPairs.back();
-	}
-	else
-	{
-		// If there weren't selected items then choose the first one bases on given direction
-		cur_sel_pair = (is_up_direction) ? mItemPairs.back() : mItemPairs.front();
-		// Force selection to first item
-		to_sel_pair = cur_sel_pair;
-	}
-
-	// Bases on given direction choose next item to select
-	if ( is_up_direction )
-	{
-		// Find current selected item position in mItemPairs list
-		pairs_list_t::reverse_iterator sel_it = std::find(mItemPairs.rbegin(), mItemPairs.rend(), cur_sel_pair);
-
-		for (;++sel_it != mItemPairs.rend();)
+		// Bases on given direction choose next item to select
+		if ( is_up_direction )
 		{
-			// skip invisible items
-			if ( (*sel_it)->first->getVisible() )
+			// Find current selected item position in mItemPairs list
+			pairs_list_t::reverse_iterator sel_it = std::find(mItemPairs.rbegin(), mItemPairs.rend(), cur_sel_pair);
+
+			for (;++sel_it != mItemPairs.rend();)
 			{
-				to_sel_pair = *sel_it;
-				break;
+				// skip invisible items
+				if ( (*sel_it)->first->getVisible() )
+				{
+					to_sel_pair = *sel_it;
+					break;
+				}
 			}
 		}
-	}
-	else
-	{
-		// Find current selected item position in mItemPairs list
-		pairs_list_t::iterator sel_it = std::find(mItemPairs.begin(), mItemPairs.end(), cur_sel_pair);
-
-		for (;++sel_it != mItemPairs.end();)
+		else
 		{
-			// skip invisible items
-			if ( (*sel_it)->first->getVisible() )
+			// Find current selected item position in mItemPairs list
+			pairs_list_t::iterator sel_it = std::find(mItemPairs.begin(), mItemPairs.end(), cur_sel_pair);
+
+			for (;++sel_it != mItemPairs.end();)
 			{
-				to_sel_pair = *sel_it;
-				break;
+				// skip invisible items
+				if ( (*sel_it)->first->getVisible() )
+				{
+					to_sel_pair = *sel_it;
+					break;
+				}
 			}
 		}
 	}
+	else
+	{
+		// If there weren't selected items then choose the first one bases on given direction
+		cur_sel_pair = (is_up_direction) ? mItemPairs.back() : mItemPairs.front();
+		// Force selection to first item
+		to_sel_pair = cur_sel_pair;
+	}
+
 
 	if ( to_sel_pair )
 	{
@@ -920,4 +931,23 @@ void LLFlatListView::onFocusLost()
 	mSelectedItemsBorder->setVisible(FALSE);
 }
 
+//virtual 
+void LLFlatListView::notify(const LLSD& info)
+{
+	if(info.has("action"))
+	{
+		std::string str_action = info["action"];
+		if(str_action == "select_first")
+		{
+			setFocus(true);
+			selectFirstItem();
+		}
+		else if(str_action == "select_last")
+		{
+			setFocus(true);
+			selectLastItem();
+		}
+	}
+}
+
 //EOF
diff --git a/indra/llui/llflatlistview.h b/indra/llui/llflatlistview.h
index 3867e910c0..9e1e0f90fc 100644
--- a/indra/llui/llflatlistview.h
+++ b/indra/llui/llflatlistview.h
@@ -279,6 +279,12 @@ public:
 
 	bool updateValue(const LLSD& old_value, const LLSD& new_value);
 
+
+	void selectFirstItem	();
+	void selectLastItem		();
+
+	virtual void	notify(const LLSD& info) ;
+
 protected:
 
 	/** Pairs LLpanel representing a single item LLPanel and LLSD associated with it */
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
index d485244a05..c611e4c85f 100644
--- a/indra/llui/llview.h
+++ b/indra/llui/llview.h
@@ -514,6 +514,8 @@ public:
 	virtual void	notifyParent(const LLSD& info);
 	virtual void	notifyChildren(const LLSD& info);
 
+	virtual void	notify(const LLSD& info) {};
+
 	static const LLViewDrawContext& getDrawContext();
 
 protected:
diff --git a/indra/media_plugins/base/media_plugin_base.cpp b/indra/media_plugins/base/media_plugin_base.cpp
index 8c8fa24a65..658783e064 100644
--- a/indra/media_plugins/base/media_plugin_base.cpp
+++ b/indra/media_plugins/base/media_plugin_base.cpp
@@ -2,6 +2,8 @@
  * @file media_plugin_base.cpp
  * @brief Media plugin base class for LLMedia API plugin system
  *
+ * All plugins should be a subclass of MediaPluginBase. 
+ *
  * @cond
  * $LicenseInfo:firstyear=2008&license=viewergpl$
  *
@@ -37,7 +39,10 @@
 
 // TODO: Make sure that the only symbol exported from this library is LLPluginInitEntryPoint
 ////////////////////////////////////////////////////////////////////////////////
-//
+/// Media plugin constructor.
+///
+/// @param[in] host_send_func Function for sending messages from plugin to plugin loader shell
+/// @param[in] host_user_data Message data for messages from plugin to plugin loader shell
 
 MediaPluginBase::MediaPluginBase(
 	LLPluginInstance::sendMessageFunction host_send_func,
@@ -55,6 +60,12 @@ MediaPluginBase::MediaPluginBase(
 	mStatus = STATUS_NONE;
 }
 
+/**
+ * Converts current media status enum value into string (STATUS_LOADING into "loading", etc.)
+ * 
+ * @return Media status string ("loading", "playing", "paused", etc)
+ *
+ */
 std::string MediaPluginBase::statusString()
 {
 	std::string result;
@@ -75,6 +86,12 @@ std::string MediaPluginBase::statusString()
 	return result;
 }
 	
+/**
+ * Set media status.
+ * 
+ * @param[in] status Media status (STATUS_LOADING, STATUS_PLAYING, STATUS_PAUSED, etc)
+ *
+ */
 void MediaPluginBase::setStatus(EStatus status)
 {
 	if(mStatus != status)
@@ -85,6 +102,13 @@ void MediaPluginBase::setStatus(EStatus status)
 }
 
 
+/**
+ * Receive message from plugin loader shell.
+ * 
+ * @param[in] message_string Message string
+ * @param[in] user_data Message data
+ *
+ */
 void MediaPluginBase::staticReceiveMessage(const char *message_string, void **user_data)
 {
 	MediaPluginBase *self = (MediaPluginBase*)*user_data;
@@ -102,12 +126,27 @@ void MediaPluginBase::staticReceiveMessage(const char *message_string, void **us
 	}
 }
 
+/**
+ * Send message to plugin loader shell.
+ * 
+ * @param[in] message Message data being sent to plugin loader shell
+ *
+ */
 void MediaPluginBase::sendMessage(const LLPluginMessage &message)
 {
 	std::string output = message.generate();
 	mHostSendFunction(output.c_str(), &mHostUserData);
 }
 
+/**
+ * Notifies plugin loader shell that part of display area needs to be redrawn.
+ * 
+ * @param[in] left Left X coordinate of area to redraw (0,0 is at top left corner)
+ * @param[in] top Top Y coordinate of area to redraw (0,0 is at top left corner)
+ * @param[in] right Right X-coordinate of area to redraw (0,0 is at top left corner)
+ * @param[in] bottom Bottom Y-coordinate of area to redraw (0,0 is at top left corner)
+ *
+ */
 void MediaPluginBase::setDirty(int left, int top, int right, int bottom)
 {
 	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "updated");
@@ -120,6 +159,10 @@ void MediaPluginBase::setDirty(int left, int top, int right, int bottom)
 	sendMessage(message);
 }
 
+/**
+ * Sends "media_status" message to plugin loader shell ("loading", "playing", "paused", etc.)
+ * 
+ */
 void MediaPluginBase::sendStatus()
 {
 	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "media_status");
@@ -143,6 +186,17 @@ extern "C"
 	LLSYMEXPORT int LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data);
 }
 
+/**
+ * Plugin initialization and entry point. Establishes communication channel for messages between plugin and plugin loader shell.  TODO:DOC - Please check!
+ * 
+ * @param[in] host_send_func Function for sending messages from plugin to plugin loader shell
+ * @param[in] host_user_data Message data for messages from plugin to plugin loader shell
+ * @param[out] plugin_send_func Function for plugin to receive messages from plugin loader shell
+ * @param[out] plugin_user_data Pointer to plugin instance
+ *
+ * @return int, where 0=success
+ *
+ */
 LLSYMEXPORT int
 LLPluginInitEntryPoint(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
 {
diff --git a/indra/media_plugins/base/media_plugin_base.h b/indra/media_plugins/base/media_plugin_base.h
index 4dd157a07c..ed4dc0cfa9 100644
--- a/indra/media_plugins/base/media_plugin_base.h
+++ b/indra/media_plugins/base/media_plugin_base.h
@@ -42,14 +42,17 @@ class MediaPluginBase
 {
 public:
 	MediaPluginBase(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+   /** Media plugin destructor. */
 	virtual ~MediaPluginBase() {}
 
+   /** Handle received message from plugin loader shell. */
 	virtual void receiveMessage(const char *message_string) = 0;
 	
 	static void staticReceiveMessage(const char *message_string, void **user_data);
 
 protected:
 
+   /** Plugin status. */
 	typedef enum 
 	{
 		STATUS_NONE,
@@ -61,10 +64,13 @@ protected:
 		STATUS_DONE
 	} EStatus;
 
+   /** Plugin shared memory. */
 	class SharedSegmentInfo
 	{
 	public:
+      /** Shared memory address. */
 		void *mAddress;
+      /** Shared memory size. */
 		size_t mSize;
 	};
 
@@ -73,42 +79,56 @@ protected:
 	std::string statusString();
 	void setStatus(EStatus status);		
 	
-	// The quicktime plugin overrides this to add current time and duration to the message...
+	/// Note: The quicktime plugin overrides this to add current time and duration to the message.
 	virtual void setDirty(int left, int top, int right, int bottom);
 
+   /** Map of shared memory names to shared memory. */
 	typedef std::map<std::string, SharedSegmentInfo> SharedSegmentMap;
 
 	
+   /** Function to send message from plugin to plugin loader shell. */
 	LLPluginInstance::sendMessageFunction mHostSendFunction;
+   /** Message data being sent to plugin loader shell by mHostSendFunction. */
 	void *mHostUserData;
+   /** Flag to delete plugin instance (self). */
 	bool mDeleteMe;
+   /** Pixel array to display. TODO:DOC are pixels always 24-bit RGB format, aligned on 32-bit boundary? Also: calling this a pixel array may be misleading since 1 pixel > 1 char. */
 	unsigned char* mPixels;
+   /** TODO:DOC what's this for -- does a texture have its own piece of shared memory? updated on size_change_request, cleared on shm_remove */
 	std::string mTextureSegmentName;
+   /** Width of plugin display in pixels. */
 	int mWidth;
+   /** Height of plugin display in pixels. */
 	int mHeight;
+   /** Width of plugin texture. */
 	int mTextureWidth;
+   /** Height of plugin texture. */
 	int mTextureHeight;
+   /** Pixel depth (pixel size in bytes). */
 	int mDepth;
+   /** Current status of plugin. */
 	EStatus mStatus;
+   /** Map of shared memory segments. */
 	SharedSegmentMap mSharedSegments;
 
 };
 
-// The plugin must define this function to create its instance.
+/** The plugin <b>must</b> define this function to create its instance.
+ * It should look something like this: 
+ * @code
+ * {  
+ *    MediaPluginFoo *self = new MediaPluginFoo(host_send_func, host_user_data); 
+ *    *plugin_send_func = MediaPluginFoo::staticReceiveMessage; 
+ *    *plugin_user_data = (void*)self; 
+ *    
+ *    return 0; 
+ * }  
+ * @endcode
+ */
 int init_media_plugin(
 	LLPluginInstance::sendMessageFunction host_send_func, 
 	void *host_user_data, 
 	LLPluginInstance::sendMessageFunction *plugin_send_func, 
 	void **plugin_user_data);
 
-// It should look something like this:
-/*
-{
-	MediaPluginFoo *self = new MediaPluginFoo(host_send_func, host_user_data);
-	*plugin_send_func = MediaPluginFoo::staticReceiveMessage;
-	*plugin_user_data = (void*)self;
-
-	return 0;
-}
-*/
 
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index fa4dfe767b..6252bd002e 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -386,17 +386,6 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
-    <key>AutoPlayMedia</key>
-    <map>
-      <key>Comment</key>
-      <string>Allow media objects to automatically play or navigate?</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>Boolean</string>
-      <key>Value</key>
-      <integer>1</integer>
-    </map>
     <key>AutoSnapshot</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index eb08707b61..ddc818172d 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -899,6 +899,8 @@ bool LLAppViewer::init()
 		loadEventHostModule(gSavedSettings.getS32("QAModeEventHostPort"));
 	}
 	
+	LLViewerMedia::initClass();
+	
 	return true;
 }
 
@@ -1666,7 +1668,7 @@ bool LLAppViewer::initThreads()
 	// Image decoding
 	LLAppViewer::sImageDecodeThread = new LLImageDecodeThread(enable_threads && true);
 	LLAppViewer::sTextureCache = new LLTextureCache(enable_threads && true);
-	LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), sImageDecodeThread, enable_threads && true);
+	LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), sImageDecodeThread, enable_threads && false);
 	LLImage::initClass();
 
 	if (LLFastTimer::sLog || LLFastTimer::sMetricLog)
diff --git a/indra/newview/llbottomtray.cpp b/indra/newview/llbottomtray.cpp
index 96c06b1665..6d3d61d4fe 100644
--- a/indra/newview/llbottomtray.cpp
+++ b/indra/newview/llbottomtray.cpp
@@ -391,7 +391,7 @@ bool LLBottomTray::onContextMenuItemEnabled(const LLSD& userdata)
 	}
 	else if (item == "can_select_all")
 	{
-		return edit_box->canSelectAll();
+		return edit_box->canSelectAll() && (edit_box->getLength()>0);
 	}
 	return true;
 }
diff --git a/indra/newview/llchathistory.cpp b/indra/newview/llchathistory.cpp
index 5e17770314..96b5ae5908 100644
--- a/indra/newview/llchathistory.cpp
+++ b/indra/newview/llchathistory.cpp
@@ -43,6 +43,7 @@
 #include "lltrans.h"
 #include "llfloaterreg.h"
 #include "llmutelist.h"
+#include "llstylemap.h"
 
 #include "llsidetray.h"//for blocked objects panel
 
@@ -355,6 +356,7 @@ void LLChatHistory::clear()
 {
 	mLastFromName.clear();
 	LLTextEditor::clear();
+	mLastFromID = LLUUID::null;
 }
 
 void LLChatHistory::appendMessage(const LLChat& chat, const bool use_plain_text_chat_history, const LLStyle::Params& input_append_params)
@@ -371,13 +373,25 @@ void LLChatHistory::appendMessage(const LLChat& chat, const bool use_plain_text_
 	style_params.font.size(font_size);	
 	style_params.font.style(input_append_params.font.style);
 	
-	std::string header_text = "[" + chat.mTimeStr + "] ";
-	if (utf8str_trim(chat.mFromName).size() != 0 && chat.mFromName != SYSTEM_FROM)
-		header_text += chat.mFromName + ": ";
-	
 	if (use_plain_text_chat_history)
 	{
-		appendText(header_text, getText().size() != 0, style_params);
+		appendText("[" + chat.mTimeStr + "] ", getText().size() != 0, style_params);
+
+		if (utf8str_trim(chat.mFromName).size() != 0)
+		{
+			// Don't hotlink any messages from the system (e.g. "Second Life:"), so just add those in plain text.
+			if ( chat.mFromName != SYSTEM_FROM && chat.mFromID.notNull() )
+			{
+				LLStyle::Params link_params(style_params);
+				link_params.fillFrom(LLStyleMap::instance().lookupAgent(chat.mFromID));
+				// Convert the name to a hotlink and add to message.
+				appendText(chat.mFromName + ": ", false, link_params);
+			}
+			else
+			{
+				appendText(chat.mFromName + ": ", false, style_params);
+			}
+		}
 	}
 	else
 	{
@@ -389,9 +403,11 @@ void LLChatHistory::appendMessage(const LLChat& chat, const bool use_plain_text_
 
 		LLDate new_message_time = LLDate::now();
 
-		if (mLastFromName == chat.mFromName && 
-			mLastMessageTime.notNull() &&
-			(new_message_time.secondsSinceEpoch() - mLastMessageTime.secondsSinceEpoch()) < 60.0 )
+		if (mLastFromName == chat.mFromName 
+			&& mLastFromID == chat.mFromID
+			&& mLastMessageTime.notNull() 
+			&& (new_message_time.secondsSinceEpoch() - mLastMessageTime.secondsSinceEpoch()) < 60.0 
+			)
 		{
 			view = getSeparator();
 			p.top_pad = mTopSeparatorPad;
@@ -417,8 +433,13 @@ void LLChatHistory::appendMessage(const LLChat& chat, const bool use_plain_text_
 		view->reshape(target_rect.getWidth(), view->getRect().getHeight());
 		view->setOrigin(target_rect.mLeft, view->getRect().mBottom);
 
+		std::string header_text = "[" + chat.mTimeStr + "] ";
+		if (utf8str_trim(chat.mFromName).size() != 0 && chat.mFromName != SYSTEM_FROM)
+			header_text += chat.mFromName + ": ";
+
 		appendWidget(p, header_text, false);
 		mLastFromName = chat.mFromName;
+		mLastFromID = chat.mFromID;
 		mLastMessageTime = new_message_time;
 	}
 	//Handle IRC styled /me messages.
diff --git a/indra/newview/llchathistory.h b/indra/newview/llchathistory.h
index d2cfa53d8b..8ca7dd1d58 100644
--- a/indra/newview/llchathistory.h
+++ b/indra/newview/llchathistory.h
@@ -114,6 +114,7 @@ class LLChatHistory : public LLTextEditor
 
 	private:
 		std::string mLastFromName;
+		LLUUID mLastFromID;
 		LLDate mLastMessageTime;
 		std::string mMessageHeaderFilename;
 		std::string mMessageSeparatorFilename;
diff --git a/indra/newview/llchatitemscontainerctrl.cpp b/indra/newview/llchatitemscontainerctrl.cpp
index efdaff3f6a..92df281307 100644
--- a/indra/newview/llchatitemscontainerctrl.cpp
+++ b/indra/newview/llchatitemscontainerctrl.cpp
@@ -122,7 +122,6 @@ void LLNearbyChatToastPanel::addMessage(LLSD& notification)
 
 		if(notification["chat_style"].asInteger()== CHAT_STYLE_IRC)
 		{
-			messageText = messageText.substr(3);
 			style_params.font.style = "ITALIC";
 		}
 		else if( chat_type == CHAT_TYPE_SHOUT)
@@ -208,7 +207,6 @@ void LLNearbyChatToastPanel::init(LLSD& notification)
 
 		if(notification["chat_style"].asInteger()== CHAT_STYLE_IRC)
 		{
-			messageText = messageText.substr(3);
 			style_params.font.style = "ITALIC";
 		}
 		else if( chat_type == CHAT_TYPE_SHOUT)
diff --git a/indra/newview/llimview.cpp b/indra/newview/llimview.cpp
index 5481ca97cd..d3058e67af 100644
--- a/indra/newview/llimview.cpp
+++ b/indra/newview/llimview.cpp
@@ -165,7 +165,7 @@ LLIMModel::LLIMSession::LLIMSession(const LLUUID& session_id, const std::string&
 
 	if(mVoiceChannel)
 	{
-		mVoiceChannel->setStateChangedCallback(boost::bind(&LLIMSession::onVoiceChannelStateChanged, this, _1, _2));
+		mVoiceChannelStateChangeConnection = mVoiceChannel->setStateChangedCallback(boost::bind(&LLIMSession::onVoiceChannelStateChanged, this, _1, _2));
 	}
 	mSpeakers = new LLIMSpeakerMgr(mVoiceChannel);
 
@@ -270,9 +270,11 @@ LLIMModel::LLIMSession::~LLIMSession()
 		}
 	}
 
+	mVoiceChannelStateChangeConnection.disconnect();
+
 	// HAVE to do this here -- if it happens in the LLVoiceChannel destructor it will call the wrong version (since the object's partially deconstructed at that point).
 	mVoiceChannel->deactivate();
-	
+
 	delete mVoiceChannel;
 	mVoiceChannel = NULL;
 }
@@ -1392,13 +1394,13 @@ void LLIncomingCallDialog::processCallResponse(S32 response)
 		}
 		else
 		{
-			LLUUID session_id = gIMMgr->addSession(
+			LLUUID new_session_id = gIMMgr->addSession(
 				mPayload["session_name"].asString(),
 				type,
 				session_id);
-			if (session_id != LLUUID::null)
+			if (new_session_id != LLUUID::null)
 			{
-				LLIMFloater::show(session_id);
+				LLIMFloater::show(new_session_id);
 			}
 
 			std::string url = gAgent.getRegion()->getCapability(
@@ -1486,13 +1488,13 @@ bool inviteUserResponse(const LLSD& notification, const LLSD& response)
 			}
 			else
 			{
-				LLUUID session_id = gIMMgr->addSession(
+				LLUUID new_session_id = gIMMgr->addSession(
 					payload["session_name"].asString(),
 					type,
 					session_id);
-				if (session_id != LLUUID::null)
+				if (new_session_id != LLUUID::null)
 				{
-					LLIMFloater::show(session_id);
+					LLIMFloater::show(new_session_id);
 				}
 
 				std::string url = gAgent.getRegion()->getCapability(
diff --git a/indra/newview/llimview.h b/indra/newview/llimview.h
index 66f92c83a5..8a0f57deb0 100644
--- a/indra/newview/llimview.h
+++ b/indra/newview/llimview.h
@@ -72,6 +72,9 @@ public:
 		LLUUID mOtherParticipantID;
 		std::vector<LLUUID> mInitialTargetIDs;
 
+		// connection to voice channel state change signal
+		boost::signals2::connection mVoiceChannelStateChangeConnection;
+
 		//does NOT include system messages
 		S32 mNumUnread;
 
diff --git a/indra/newview/lllocationinputctrl.cpp b/indra/newview/lllocationinputctrl.cpp
index d97f1d4d18..09c215e660 100644
--- a/indra/newview/lllocationinputctrl.cpp
+++ b/indra/newview/lllocationinputctrl.cpp
@@ -896,7 +896,7 @@ bool LLLocationInputCtrl::onLocationContextMenuItemEnabled(const LLSD& userdata)
 	}
 	else if (item == "can_select_all")
 	{
-		return mTextEntry->canSelectAll();
+		return mTextEntry->canSelectAll() && (mTextEntry->getLength() > 0);
 	}
 	else if(item == "show_coordinates")
 	{
diff --git a/indra/newview/llnearbychat.cpp b/indra/newview/llnearbychat.cpp
index ee3be0a5e3..18e5169930 100644
--- a/indra/newview/llnearbychat.cpp
+++ b/indra/newview/llnearbychat.cpp
@@ -54,10 +54,11 @@
 #include "llstylemap.h"
 
 #include "lldraghandle.h"
-#include "lltrans.h"
+
 #include "llbottomtray.h"
 #include "llnearbychatbar.h"
 #include "llfloaterreg.h"
+#include "lltrans.h"
 
 static const S32 RESIZE_BAR_THICKNESS = 3;
 
@@ -146,6 +147,7 @@ std::string appendTime()
 	return timeStr;
 }
 
+
 void	LLNearbyChat::addMessage(const LLChat& chat,bool archive)
 {
 	if (chat.mChatType == CHAT_TYPE_DEBUG_MSG)
@@ -167,18 +169,15 @@ void	LLNearbyChat::addMessage(const LLChat& chat,bool archive)
 		}
 	}
 
+	LLChat& tmp_chat = const_cast<LLChat&>(chat);
+
+	if(tmp_chat.mTimeStr.empty())
+		tmp_chat.mTimeStr = appendTime();
+
 	bool use_plain_text_chat_history = gSavedSettings.getBOOL("PlainTextChatHistory");
 	
 	if (!chat.mMuted)
 	{
-		std::string message = chat.mText;
-
-
-		LLChat& tmp_chat = const_cast<LLChat&>(chat);
-
-		if(tmp_chat.mTimeStr.empty())
-			tmp_chat.mTimeStr = appendTime();
-		
 		if (chat.mChatStyle == CHAT_STYLE_IRC)
 		{
 			LLColor4 txt_color = LLUIColorTable::instance().getColor("White");
@@ -191,17 +190,9 @@ void	LLNearbyChat::addMessage(const LLChat& chat,bool archive)
 			append_style_params.readonly_color(txt_color);
 			append_style_params.font.name(font_name);
 			append_style_params.font.size(font_size);
-			if (chat.mFromName.size() > 0)
-			{
-				append_style_params.font.style = "ITALIC";
-				LLChat add_chat=chat;
-				add_chat.mText = chat.mFromName + " ";
-				mChatHistory->appendMessage(add_chat, use_plain_text_chat_history, append_style_params);
-			}
-			
-			message = message.substr(3);
 			append_style_params.font.style = "ITALIC";
-			mChatHistory->appendText(message, FALSE, append_style_params);
+
+			mChatHistory->appendMessage(chat, use_plain_text_chat_history, append_style_params);
 		}
 		else
 		{
diff --git a/indra/newview/llnearbychathandler.cpp b/indra/newview/llnearbychathandler.cpp
index b0b6db682c..169560f688 100644
--- a/indra/newview/llnearbychathandler.cpp
+++ b/indra/newview/llnearbychathandler.cpp
@@ -318,6 +318,8 @@ void LLNearbyChatHandler::initChannel()
 	mChannel->init(channel_right_bound - channel_width, channel_right_bound);
 }
 
+
+
 void LLNearbyChatHandler::processChat(const LLChat& chat_msg)
 {
 	if(chat_msg.mMuted == TRUE)
@@ -327,6 +329,22 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg)
 
 	if(chat_msg.mText.empty())
 		return;//don't process empty messages
+
+	LLChat& tmp_chat = const_cast<LLChat&>(chat_msg);
+
+	if (tmp_chat.mChatStyle == CHAT_STYLE_IRC)
+	{
+		if(!tmp_chat.mFromName.empty())
+			tmp_chat.mText = tmp_chat.mFromName + " " + tmp_chat.mText.substr(3);
+		else
+			tmp_chat.mText = tmp_chat.mText.substr(3);
+	}
+	
+	{
+		//sometimes its usefull to have no name at all...
+		//if(tmp_chat.mFromName.empty() && tmp_chat.mFromID!= LLUUID::null)
+		//	tmp_chat.mFromName = tmp_chat.mFromID.asString();
+	}
 	
 	LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat", LLSD());
 	nearby_chat->addMessage(chat_msg);
diff --git a/indra/newview/llpanelgroupnotices.cpp b/indra/newview/llpanelgroupnotices.cpp
index 5834c50fbb..6210973dae 100644
--- a/indra/newview/llpanelgroupnotices.cpp
+++ b/indra/newview/llpanelgroupnotices.cpp
@@ -304,6 +304,9 @@ BOOL LLPanelGroupNotices::postBuild()
 
 void LLPanelGroupNotices::activate()
 {
+	if(mNoticesList)
+		mNoticesList->deleteAllItems();
+	
 	BOOL can_send = gAgent.hasPowerInGroup(mGroupID,GP_NOTICES_SEND);
 	BOOL can_receive = gAgent.hasPowerInGroup(mGroupID,GP_NOTICES_RECEIVE);
 
diff --git a/indra/newview/llpanelimcontrolpanel.cpp b/indra/newview/llpanelimcontrolpanel.cpp
index 405c95fc22..8c19865550 100644
--- a/indra/newview/llpanelimcontrolpanel.cpp
+++ b/indra/newview/llpanelimcontrolpanel.cpp
@@ -71,6 +71,11 @@ void LLPanelChatControlPanel::onVoiceChannelStateChanged(const LLVoiceChannel::E
 	childSetVisible("call_btn", ! is_call_started);
 }
 
+LLPanelChatControlPanel::~LLPanelChatControlPanel()
+{
+	mVoiceChannelStateChangeConnection.disconnect();
+}
+
 BOOL LLPanelChatControlPanel::postBuild()
 {
 	childSetAction("call_btn", boost::bind(&LLPanelChatControlPanel::onCallButtonClicked, this));
@@ -113,7 +118,9 @@ void LLPanelChatControlPanel::setSessionId(const LLUUID& session_id)
 	mSessionId = session_id;
 	LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionId);
 	if(voice_channel)
-		voice_channel->setStateChangedCallback(boost::bind(&LLPanelChatControlPanel::onVoiceChannelStateChanged, this, _1, _2));
+	{
+		mVoiceChannelStateChangeConnection = voice_channel->setStateChangedCallback(boost::bind(&LLPanelChatControlPanel::onVoiceChannelStateChanged, this, _1, _2));
+	}
 }
 
 LLPanelIMControlPanel::LLPanelIMControlPanel()
diff --git a/indra/newview/llpanelimcontrolpanel.h b/indra/newview/llpanelimcontrolpanel.h
index a590232a0b..871779b273 100644
--- a/indra/newview/llpanelimcontrolpanel.h
+++ b/indra/newview/llpanelimcontrolpanel.h
@@ -47,7 +47,7 @@ public:
 	LLPanelChatControlPanel() :
 		mSessionId(LLUUID()),
 		mInitialized(false) {};
-	~LLPanelChatControlPanel() {};
+	~LLPanelChatControlPanel();
 
 	virtual BOOL postBuild();
 	virtual void draw();
@@ -64,6 +64,9 @@ public:
 private:
 	LLUUID mSessionId;
 	bool   mInitialized;
+
+	// connection to voice channel state change signal
+	boost::signals2::connection mVoiceChannelStateChangeConnection;
 };
 
 
diff --git a/indra/newview/llpanellandmarks.cpp b/indra/newview/llpanellandmarks.cpp
index 4ce6d14faa..d731da0ec7 100644
--- a/indra/newview/llpanellandmarks.cpp
+++ b/indra/newview/llpanellandmarks.cpp
@@ -122,8 +122,7 @@ void LLLandmarksPanel::onSearchEdit(const std::string& string)
 	for (accordion_tabs_t::const_iterator iter = mAccordionTabs.begin(); iter != mAccordionTabs.end(); ++iter)
 	{
 		LLAccordionCtrlTab* tab = *iter;
-		if (tab && !tab->getVisible())
-			tab->setVisible(TRUE);
+		tab->setVisible(TRUE);
 
 		// expand accordion to see matched items in each one. See EXT-2014.
 		tab->changeOpenClose(false);
@@ -132,7 +131,9 @@ void LLLandmarksPanel::onSearchEdit(const std::string& string)
 		if (NULL == inventory_list) continue;
 
 		if (inventory_list->getFilter())
+		{
 			filter_list(inventory_list, string);
+		}
 	}
 
 	if (sFilterSubString != string)
@@ -333,8 +334,12 @@ void LLLandmarksPanel::initLandmarksInventoryPanel()
 
 	initLandmarksPanel(mLandmarksInventoryPanel);
 
+	// Check if mLandmarksInventoryPanel is properly initialized and has a Filter created.
+	// In case of a dummy widget getFilter() will return NULL.
 	if (mLandmarksInventoryPanel->getFilter())
+	{
 		mLandmarksInventoryPanel->setShowFolderState(LLInventoryFilter::SHOW_ALL_FOLDERS);
+	}
 
 	// subscribe to have auto-rename functionality while creating New Folder
 	mLandmarksInventoryPanel->setSelectCallback(boost::bind(&LLInventoryPanel::onSelectionChange, mLandmarksInventoryPanel, _1, _2));
@@ -362,6 +367,8 @@ void LLLandmarksPanel::initLibraryInventoryPanel()
 
 void LLLandmarksPanel::initLandmarksPanel(LLInventorySubTreePanel* inventory_list)
 {
+	// In case of a dummy widget further we have no Folder View widget and no Filter,
+	// so further initialization leads to crash.
 	if (!inventory_list->getFilter())
 		return;
 
@@ -388,8 +395,6 @@ void LLLandmarksPanel::initLandmarksPanel(LLInventorySubTreePanel* inventory_lis
 void LLLandmarksPanel::initAccordion(const std::string& accordion_tab_name, LLInventorySubTreePanel* inventory_list)
 {
 	LLAccordionCtrlTab* accordion_tab = getChild<LLAccordionCtrlTab>(accordion_tab_name);
-	if (!accordion_tab)
-		return;
 
 	mAccordionTabs.push_back(accordion_tab);
 	accordion_tab->setDropDownStateChangedCallback(
@@ -744,8 +749,8 @@ void LLLandmarksPanel::updateFilteredAccordions()
 	for (accordion_tabs_t::const_iterator iter = mAccordionTabs.begin(); iter != mAccordionTabs.end(); ++iter)
 	{
 		accordion_tab = *iter;
-		if (accordion_tab && !accordion_tab->getVisible())
-			accordion_tab->setVisible(TRUE);
+
+		accordion_tab->setVisible(TRUE);
 
 		inventory_list = dynamic_cast<LLInventorySubTreePanel*> (accordion_tab->getAccordionView());
 		if (NULL == inventory_list) continue;
diff --git a/indra/newview/llpanelpeoplemenus.cpp b/indra/newview/llpanelpeoplemenus.cpp
index 7dea5eaf67..57f3d86d53 100644
--- a/indra/newview/llpanelpeoplemenus.cpp
+++ b/indra/newview/llpanelpeoplemenus.cpp
@@ -97,7 +97,7 @@ LLContextMenu* NearbyMenu::createMenu()
 		registrar.add("Avatar.Profile",			boost::bind(&LLAvatarActions::showProfile,				id));
 		registrar.add("Avatar.AddFriend",		boost::bind(&LLAvatarActions::requestFriendshipDialog,	id));
 		registrar.add("Avatar.IM",				boost::bind(&LLAvatarActions::startIM,					id));
-		registrar.add("Avatar.Call",			boost::bind(&LLAvatarActions::startIM,					id));	// *TODO: unimplemented
+		registrar.add("Avatar.Call",			boost::bind(&LLAvatarActions::startCall,				id));
 		registrar.add("Avatar.OfferTeleport",	boost::bind(&NearbyMenu::offerTeleport,					this));
 		registrar.add("Avatar.ShowOnMap",		boost::bind(&LLAvatarActions::startIM,					id));	// *TODO: unimplemented
 		registrar.add("Avatar.Share",			boost::bind(&LLAvatarActions::startIM,					id));	// *TODO: unimplemented
@@ -117,7 +117,7 @@ LLContextMenu* NearbyMenu::createMenu()
 
 		// registrar.add("Avatar.AddFriend",	boost::bind(&LLAvatarActions::requestFriendshipDialog,	mUUIDs)); // *TODO: unimplemented
 		registrar.add("Avatar.IM",			boost::bind(&LLAvatarActions::startConference,			mUUIDs));
-		// registrar.add("Avatar.Call",		boost::bind(&LLAvatarActions::startConference,			mUUIDs)); // *TODO: unimplemented
+		registrar.add("Avatar.Call",		boost::bind(&LLAvatarActions::startAdhocCall,			mUUIDs));
 		// registrar.add("Avatar.Share",		boost::bind(&LLAvatarActions::startIM,					mUUIDs)); // *TODO: unimplemented
 		// registrar.add("Avatar.Pay",		boost::bind(&LLAvatarActions::pay,						mUUIDs)); // *TODO: unimplemented
 		enable_registrar.add("Avatar.EnableItem",	boost::bind(&NearbyMenu::enableContextMenuItem,	this, _2));
diff --git a/indra/newview/llpanelplaces.cpp b/indra/newview/llpanelplaces.cpp
index cd4bcb6c0a..f7f3c5830d 100644
--- a/indra/newview/llpanelplaces.cpp
+++ b/indra/newview/llpanelplaces.cpp
@@ -261,6 +261,10 @@ void LLPanelPlaces::onOpen(const LLSD& key)
 		}
 
 		mLandmarkInfo->displayParcelInfo(LLUUID(), mPosGlobal);
+
+		// Disable Save button because there is no item to save yet.
+		// The button will be enabled in onLandmarkLoaded callback.
+		mSaveBtn->setEnabled(FALSE);
 	}
 	else if (mPlaceInfoType == LANDMARK_INFO_TYPE)
 	{
@@ -380,11 +384,16 @@ void LLPanelPlaces::onLandmarkLoaded(LLLandmark* landmark)
 	landmark->getRegionID(region_id);
 	landmark->getGlobalPos(mPosGlobal);
 	mLandmarkInfo->displayParcelInfo(region_id, mPosGlobal);
+
+	mSaveBtn->setEnabled(TRUE);
 }
 
 void LLPanelPlaces::onFilterEdit(const std::string& search_string, bool force_filter)
 {
-	if (force_filter || LLPanelPlacesTab::sFilterSubString != search_string)
+	if (!mActivePanel)
+		return;
+
+	if (force_filter || mActivePanel->getFilterSubString() != search_string)
 	{
 		std::string string = search_string;
 
@@ -392,8 +401,7 @@ void LLPanelPlaces::onFilterEdit(const std::string& search_string, bool force_fi
 		LLStringUtil::toUpper(string);
 		LLStringUtil::trimHead(string);
 
-		if (mActivePanel)
-			mActivePanel->onSearchEdit(string);
+		mActivePanel->onSearchEdit(string);
 	}
 }
 
@@ -403,7 +411,7 @@ void LLPanelPlaces::onTabSelected()
 	if (!mActivePanel)
 		return;
 
-	onFilterEdit(LLPanelPlacesTab::sFilterSubString, true);
+	onFilterEdit(mActivePanel->getFilterSubString(), true);
 	mActivePanel->updateVerbs();
 }
 
@@ -814,7 +822,7 @@ void LLPanelPlaces::changedInventory(U32 mask)
 
 	// Filter applied to show all items.
 	if (mActivePanel)
-		mActivePanel->onSearchEdit(LLPanelPlacesTab::sFilterSubString);
+		mActivePanel->onSearchEdit(mActivePanel->getFilterSubString());
 
 	// we don't need to monitor inventory changes anymore,
 	// so remove the observer
diff --git a/indra/newview/llpanelplacestab.h b/indra/newview/llpanelplacestab.h
index b4d839452e..ce77a42259 100644
--- a/indra/newview/llpanelplacestab.h
+++ b/indra/newview/llpanelplacestab.h
@@ -56,13 +56,15 @@ public:
 										const LLUUID& snapshot_id,
 										bool teleport);
 
-public:
-	// Search string for filtering landmarks and teleport history locations
-	static std::string		sFilterSubString;
+	const std::string& getFilterSubString() { return sFilterSubString; }
+	void setFilterSubString(const std::string& string) { sFilterSubString = string; }
 
 protected:
 	LLButton*				mTeleportBtn;
 	LLButton*				mShowOnMapBtn;
+
+	// Search string for filtering landmarks and teleport history locations
+	static std::string		sFilterSubString;
 };
 
 #endif //LL_LLPANELPLACESTAB_H
diff --git a/indra/newview/llpanelprimmediacontrols.cpp b/indra/newview/llpanelprimmediacontrols.cpp
index e86123d565..aa2b7d4554 100644
--- a/indra/newview/llpanelprimmediacontrols.cpp
+++ b/indra/newview/llpanelprimmediacontrols.cpp
@@ -54,6 +54,7 @@
 #include "llpanelprimmediacontrols.h"
 #include "llpluginclassmedia.h"
 #include "llprogressbar.h"
+#include "llsliderctrl.h"
 #include "llstring.h"
 #include "llviewercontrol.h"
 #include "llviewerparcelmgr.h"
@@ -63,6 +64,8 @@
 #include "llweb.h"
 #include "llwindow.h"
 
+#include "llfloatertools.h"  // to enable hide if build tools are up
+
 glh::matrix4f glh_get_current_modelview();
 glh::matrix4f glh_get_current_projection();
 
@@ -88,7 +91,8 @@ LLPanelPrimMediaControls::LLPanelPrimMediaControls() :
 	mTargetImplID(LLUUID::null),
 	mTargetObjectNormal(LLVector3::zero),
 	mZoomObjectID(LLUUID::null),
-	mZoomObjectFace(0)
+	mZoomObjectFace(0),
+	mVolumeSliderVisible(false)
 {
 	mCommitCallbackRegistrar.add("MediaCtrl.Close",		boost::bind(&LLPanelPrimMediaControls::onClickClose, this));
 	mCommitCallbackRegistrar.add("MediaCtrl.Back",		boost::bind(&LLPanelPrimMediaControls::onClickBack, this));
@@ -105,7 +109,9 @@ LLPanelPrimMediaControls::LLPanelPrimMediaControls() :
 	mCommitCallbackRegistrar.add("MediaCtrl.JumpProgress",		boost::bind(&LLPanelPrimMediaControls::onCommitSlider, this));
 	mCommitCallbackRegistrar.add("MediaCtrl.CommitVolumeUp",	boost::bind(&LLPanelPrimMediaControls::onCommitVolumeUp, this));
 	mCommitCallbackRegistrar.add("MediaCtrl.CommitVolumeDown",	boost::bind(&LLPanelPrimMediaControls::onCommitVolumeDown, this));
+	mCommitCallbackRegistrar.add("MediaCtrl.Volume",	boost::bind(&LLPanelPrimMediaControls::onCommitVolumeSlider, this));
 	mCommitCallbackRegistrar.add("MediaCtrl.ToggleMute",		boost::bind(&LLPanelPrimMediaControls::onToggleMute, this));
+	mCommitCallbackRegistrar.add("MediaCtrl.ShowVolumeSlider",		boost::bind(&LLPanelPrimMediaControls::showVolumeSlider, this));
 	mCommitCallbackRegistrar.add("MediaCtrl.SkipBack",		boost::bind(&LLPanelPrimMediaControls::onClickSkipBack, this));
 	mCommitCallbackRegistrar.add("MediaCtrl.SkipForward",	boost::bind(&LLPanelPrimMediaControls::onClickSkipForward, this));
 	
@@ -147,12 +153,14 @@ BOOL LLPanelPrimMediaControls::postBuild()
 	mVolumeBtn				= getChild<LLButton>("media_volume_button");
 	mVolumeUpCtrl			= getChild<LLUICtrl>("volume_up");
 	mVolumeDownCtrl			= getChild<LLUICtrl>("volume_down");
+	mVolumeSliderCtrl       = getChild<LLSliderCtrl>("volume_slider");
 	mWhitelistIcon			= getChild<LLIconCtrl>("media_whitelist_flag");
 	mSecureLockIcon			= getChild<LLIconCtrl>("media_secure_lock_flag");
 	mMediaControlsStack		= getChild<LLLayoutStack>("media_controls");
 	mLeftBookend			= getChild<LLUICtrl>("left_bookend");
 	mRightBookend			= getChild<LLUICtrl>("right_bookend");
 	mBackgroundImage		= LLUI::getUIImage(getString("control_background_image_name"));
+	mVolumeSliderBackgroundImage		= LLUI::getUIImage(getString("control_background_image_name"));
 	LLStringUtil::convertToF32(getString("skip_step"), mSkipStep);
 	LLStringUtil::convertToS32(getString("min_width"), mMinWidth);
 	LLStringUtil::convertToS32(getString("min_height"), mMinHeight);
@@ -267,7 +275,7 @@ void LLPanelPrimMediaControls::updateShape()
 	LLViewerMediaImpl* media_impl = getTargetMediaImpl();
 	LLViewerObject* objectp = getTargetObject();
 	
-	if(!media_impl)
+	if(!media_impl || gFloaterTools->getVisible())
 	{
 		setVisible(FALSE);
 		return;
@@ -296,11 +304,13 @@ void LLPanelPrimMediaControls::updateShape()
 		LLMediaEntry *media_data = objectp->getTE(mTargetObjectFace)->getMediaData();
 		if (media_data && NULL != dynamic_cast<LLVOVolume*>(objectp))
 		{
-			// Don't show the media HUD if we do not have permissions
+			// Don't show the media controls if we do not have permissions
 			enabled = dynamic_cast<LLVOVolume*>(objectp)->hasMediaPermission(media_data, LLVOVolume::MEDIA_PERM_CONTROL);
 			mini_controls = (LLMediaEntry::MINI == media_data->getControls());
 		}
 		
+		const bool is_hud = objectp->isHUDAttachment();
+		
 		//
 		// Set the state of the buttons
 		//
@@ -323,8 +333,8 @@ void LLPanelPrimMediaControls::updateShape()
 		
 		mWhitelistIcon->setVisible(!mini_controls && (media_data)?media_data->getWhiteListEnable():false);
 		// Disable zoom if HUD
-		mZoomCtrl->setEnabled(!objectp->isHUDAttachment());
-		mUnzoomCtrl->setEnabled(!objectp->isHUDAttachment());
+		mZoomCtrl->setEnabled(!is_hud);
+		mUnzoomCtrl->setEnabled(!is_hud);
 		mSecureLockIcon->setVisible(false);
 		mCurrentURL = media_impl->getCurrentMediaURL();
 		
@@ -355,6 +365,8 @@ void LLPanelPrimMediaControls::updateShape()
 			mVolumeUpCtrl->setVisible(has_focus);
 			mVolumeDownCtrl->setVisible(has_focus);
 			mVolumeCtrl->setEnabled(has_focus);
+			mVolumeSliderCtrl->setEnabled(has_focus && mVolumeSliderVisible);
+			mVolumeSliderCtrl->setVisible(has_focus && mVolumeSliderVisible);
 
 			mWhitelistIcon->setVisible(false);
 			mSecureLockIcon->setVisible(false);
@@ -411,6 +423,7 @@ void LLPanelPrimMediaControls::updateShape()
 				mVolumeUpCtrl->setEnabled(TRUE);
 				mVolumeDownCtrl->setEnabled(TRUE);
 			}
+			mVolumeSliderCtrl->setValue(volume);
 				
 			switch(result)
 			{
@@ -456,9 +469,11 @@ void LLPanelPrimMediaControls::updateShape()
 			mVolumeCtrl->setVisible(FALSE);
 			mVolumeUpCtrl->setVisible(FALSE);
 			mVolumeDownCtrl->setVisible(FALSE);
+			mVolumeSliderCtrl->setVisible(FALSE);
 			mVolumeCtrl->setEnabled(FALSE);
 			mVolumeUpCtrl->setEnabled(FALSE);
 			mVolumeDownCtrl->setEnabled(FALSE);
+			mVolumeSliderCtrl->setEnabled(FALSE);
 			
 			if (mMediaPanelScroll)
 			{
@@ -548,56 +563,58 @@ void LLPanelPrimMediaControls::updateShape()
 		//
 		// Calculate position and shape of the controls
 		//
+		LLVector3 min, max;
+
 		glh::matrix4f mat = glh_get_current_projection()*glh_get_current_modelview();
 		std::vector<LLVector3>::iterator vert_it;
 		std::vector<LLVector3>::iterator vert_end;
 		std::vector<LLVector3> vect_face;
-
+			
 		LLVolume* volume = objectp->getVolume();
-
+			
 		if (volume)
 		{
 			const LLVolumeFace& vf = volume->getVolumeFace(mTargetObjectFace);
-
+				
 			const LLVector3* ext = vf.mExtents;
-
+				
 			LLVector3 center = (ext[0]+ext[1])*0.5f;
 			LLVector3 size = (ext[1]-ext[0])*0.5f;
 			LLVector3 vert[] =
-			{
-				center + size.scaledVec(LLVector3(1,1,1)),
-				center + size.scaledVec(LLVector3(-1,1,1)),
-				center + size.scaledVec(LLVector3(1,-1,1)),
-				center + size.scaledVec(LLVector3(-1,-1,1)),
-				center + size.scaledVec(LLVector3(1,1,-1)),
-				center + size.scaledVec(LLVector3(-1,1,-1)),
-				center + size.scaledVec(LLVector3(1,-1,-1)),
-				center + size.scaledVec(LLVector3(-1,-1,-1)),
-			};
-
+				{
+					center + size.scaledVec(LLVector3(1,1,1)),
+					center + size.scaledVec(LLVector3(-1,1,1)),
+					center + size.scaledVec(LLVector3(1,-1,1)),
+					center + size.scaledVec(LLVector3(-1,-1,1)),
+					center + size.scaledVec(LLVector3(1,1,-1)),
+					center + size.scaledVec(LLVector3(-1,1,-1)),
+					center + size.scaledVec(LLVector3(1,-1,-1)),
+					center + size.scaledVec(LLVector3(-1,-1,-1)),
+				};
+				
 			LLVOVolume* vo = (LLVOVolume*) objectp;
-
+				
 			for (U32 i = 0; i < 8; i++)
 			{
-				vect_face.push_back(vo->volumePositionToAgent(vert[i]));	
+				vect_face.push_back(vo->volumePositionToAgent(vert[i]));
 			}
 		}
 		vert_it = vect_face.begin();
 		vert_end = vect_face.end();
-
-		LLVector3 min = LLVector3(1,1,1);
-		LLVector3 max = LLVector3(-1,-1,-1);
+			
+		min = LLVector3(1,1,1);
+		max = LLVector3(-1,-1,-1);
 		for(; vert_it != vert_end; ++vert_it)
 		{
 			// project silhouette vertices into screen space
 			glh::vec3f screen_vert = glh::vec3f(vert_it->mV); 
 			mat.mult_matrix_vec(screen_vert);
-
+				
 			// add to screenspace bounding box
 			update_min_max(min, max, LLVector3(screen_vert.v));
 		}
-
-        LLCoordGL screen_min;
+			
+		LLCoordGL screen_min;
 		screen_min.mX = llround((F32)gViewerWindow->getWorldViewWidthScaled() * (min.mV[VX] + 1.f) * 0.5f);
 		screen_min.mY = llround((F32)gViewerWindow->getWorldViewHeightScaled() * (min.mV[VY] + 1.f) * 0.5f);
 
@@ -607,17 +624,16 @@ void LLPanelPrimMediaControls::updateShape()
 
 		// grow panel so that screenspace bounding box fits inside "media_region" element of HUD
 		LLRect media_controls_rect;
+		S32 volume_slider_height = mVolumeSliderCtrl->getRect().getHeight() - /*fudge*/ 2;
 		getParent()->screenRectToLocal(LLRect(screen_min.mX, screen_max.mY, screen_max.mX, screen_min.mY), &media_controls_rect);
 		media_controls_rect.mLeft -= mMediaRegion->getRect().mLeft;
-		media_controls_rect.mBottom -= mMediaRegion->getRect().mBottom;
+		media_controls_rect.mBottom -= mMediaRegion->getRect().mBottom - volume_slider_height;
 		media_controls_rect.mTop += getRect().getHeight() - mMediaRegion->getRect().mTop;
 		media_controls_rect.mRight += getRect().getWidth() - mMediaRegion->getRect().mRight;
 		
 		// keep all parts of HUD on-screen
 		media_controls_rect.intersectWith(getParent()->getLocalRect());
-		if (mCurrentZoom != ZOOM_NONE)
-			media_controls_rect.mBottom -= mMediaControlsStack->getRect().getHeight() + mMediaProgressPanel->getRect().getHeight();
-
+		
 		// clamp to minimum size, keeping centered
 		media_controls_rect.setCenterAndSize(media_controls_rect.getCenterX(), media_controls_rect.getCenterY(),
 			llmax(mMinWidth, media_controls_rect.getWidth()), llmax(mMinHeight, media_controls_rect.getHeight()));
@@ -681,6 +697,7 @@ void LLPanelPrimMediaControls::draw()
 				setVisible(FALSE);
 
 				mClearFaceOnFade = false;
+				mVolumeSliderVisible = false;
 				mTargetImplID = LLUUID::null;
 				mTargetObjectID = LLUUID::null;
 				mTargetObjectFace = 0;
@@ -692,16 +709,29 @@ void LLPanelPrimMediaControls::draw()
 	// Assumes layout_stack is a direct child of this panel
 	mMediaControlsStack->updateLayout();
 	LLRect icon_area = mMediaControlsStack->getRect();
+
+	// adjust to ignore space from volume slider
+	icon_area.mTop -= mVolumeSliderCtrl->getRect().getHeight();
 	
 	// adjust to ignore space from left bookend padding
 	icon_area.mLeft += mLeftBookend->getRect().getWidth();
 	
 	// ignore space from right bookend padding
 	icon_area.mRight -= mRightBookend->getRect().getWidth();
-	
-	// get UI image
+		
+	// draw control background UI image
 	mBackgroundImage->draw( icon_area, UI_VERTEX_COLOR % alpha);
 	
+	// draw volume slider background UI image
+	if (mVolumeSliderCtrl->getVisible())
+	{
+		LLRect volume_slider_rect = mVolumeSliderCtrl->getRect();
+		// For some reason the rect is not in the right place (??)
+		// This translates the bg to under the slider
+		volume_slider_rect.translate(mVolumeSliderCtrl->getParent()->getRect().mLeft, icon_area.getHeight());
+		mVolumeSliderBackgroundImage->draw(volume_slider_rect, UI_VERTEX_COLOR % alpha);
+	}
+	
 	{
 		LLViewDrawContext context(alpha);
 		LLPanel::draw();
@@ -1187,6 +1217,16 @@ void LLPanelPrimMediaControls::onCommitVolumeDown()
 	}
 }		
 
+void LLPanelPrimMediaControls::onCommitVolumeSlider()
+{
+	focusOnTarget();
+
+	LLViewerMediaImpl* media_impl = getTargetMediaImpl();
+	if (media_impl) 
+	{
+		media_impl->setVolume(mVolumeSliderCtrl->getValueF32());
+	}
+}
 
 void LLPanelPrimMediaControls::onToggleMute()
 {
@@ -1208,3 +1248,7 @@ void LLPanelPrimMediaControls::onToggleMute()
 	}
 }
 
+void LLPanelPrimMediaControls::showVolumeSlider()
+{
+	mVolumeSliderVisible = true;
+}
diff --git a/indra/newview/llpanelprimmediacontrols.h b/indra/newview/llpanelprimmediacontrols.h
index fe8f100abe..06163051a5 100644
--- a/indra/newview/llpanelprimmediacontrols.h
+++ b/indra/newview/llpanelprimmediacontrols.h
@@ -40,6 +40,7 @@ class LLCoordWindow;
 class LLIconCtrl;
 class LLLayoutStack;
 class LLProgressBar;
+class LLSliderCtrl;
 class LLViewerMediaImpl;
 
 class LLPanelPrimMediaControls : public LLPanel
@@ -106,7 +107,9 @@ private:
 	
 	void onCommitVolumeUp();
 	void onCommitVolumeDown();
+	void onCommitVolumeSlider();
 	void onToggleMute();
+	void showVolumeSlider();
 	
 	static void onScrollUp(void* user_data);
 	static void onScrollUpHeld(void* user_data);
@@ -153,12 +156,14 @@ private:
 	LLButton *mVolumeBtn;
 	LLUICtrl *mVolumeUpCtrl;
 	LLUICtrl *mVolumeDownCtrl;
+	LLSliderCtrl *mVolumeSliderCtrl;
 	LLIconCtrl *mWhitelistIcon;
 	LLIconCtrl *mSecureLockIcon;
 	LLLayoutStack *mMediaControlsStack;
 	LLUICtrl *mLeftBookend;
 	LLUICtrl *mRightBookend;
 	LLUIImage* mBackgroundImage;
+	LLUIImage* mVolumeSliderBackgroundImage;
 	F32 mSkipStep;
 	S32 mMinWidth;
 	S32 mMinHeight;
@@ -198,6 +203,8 @@ private:
 	
 	LLUUID mZoomObjectID;
 	S32 mZoomObjectFace;
+	
+	bool mVolumeSliderVisible;
 };
 
 #endif // LL_PANELPRIMMEDIACONTROLS_H
diff --git a/indra/newview/llscriptfloater.cpp b/indra/newview/llscriptfloater.cpp
index 155172128b..088884178b 100644
--- a/indra/newview/llscriptfloater.cpp
+++ b/indra/newview/llscriptfloater.cpp
@@ -62,15 +62,15 @@ LLUUID notification_id_to_object_id(const LLUUID& notification_id)
 //////////////////////////////////////////////////////////////////////////
 
 LLScriptFloater::LLScriptFloater(const LLSD& key)
-: LLTransientDockableFloater(NULL, true, key)
+: LLDockableFloater(NULL, true, key)
 , mScriptForm(NULL)
-, mObjectId(key.asUUID())
 {
 }
 
 bool LLScriptFloater::toggle(const LLUUID& object_id)
 {
-	LLScriptFloater* floater = LLFloaterReg::findTypedInstance<LLScriptFloater>("script_floater", object_id);
+	LLUUID notification_id = LLScriptFloaterManager::getInstance()->findNotificationId(object_id);
+	LLScriptFloater* floater = LLFloaterReg::findTypedInstance<LLScriptFloater>("script_floater", notification_id);
 
 	// show existing floater
 	if(floater)
@@ -97,7 +97,10 @@ bool LLScriptFloater::toggle(const LLUUID& object_id)
 
 LLScriptFloater* LLScriptFloater::show(const LLUUID& object_id)
 {
-	LLScriptFloater* floater = LLFloaterReg::showTypedInstance<LLScriptFloater>("script_floater", object_id);
+	LLUUID notification_id = LLScriptFloaterManager::getInstance()->findNotificationId(object_id);
+	
+	LLScriptFloater* floater = LLFloaterReg::showTypedInstance<LLScriptFloater>("script_floater", notification_id);
+	floater->setObjectId(object_id);
 	floater->createForm(object_id);
 
 	if (floater->getDockControl() == NULL)
@@ -156,19 +159,22 @@ void LLScriptFloater::createForm(const LLUUID& object_id)
 
 void LLScriptFloater::onClose(bool app_quitting)
 {
-	LLScriptFloaterManager::getInstance()->removeNotificationByObjectId(getObjectId());
+	if(getObjectId().notNull())
+	{
+		LLScriptFloaterManager::getInstance()->removeNotificationByObjectId(getObjectId());
+	}
 }
 
 void LLScriptFloater::setDocked(bool docked, bool pop_on_undock /* = true */)
 {
-	LLTransientDockableFloater::setDocked(docked, pop_on_undock);
+	LLDockableFloater::setDocked(docked, pop_on_undock);
 
 	hideToastsIfNeeded();
 }
 
 void LLScriptFloater::setVisible(BOOL visible)
 {
-	LLTransientDockableFloater::setVisible(visible);
+	LLDockableFloater::setVisible(visible);
 
 	hideToastsIfNeeded();
 }
@@ -206,7 +212,7 @@ void LLScriptFloaterManager::onAddNotification(const LLUUID& notification_id)
 	script_notification_map_t::iterator it = mNotifications.find(object_id);
 	if(it != mNotifications.end())
 	{
-		onRemoveNotification(notification_id);
+		onRemoveNotification(it->second.notification_id);
 	}
 
 	LLNotificationData nd = {notification_id};
@@ -228,7 +234,7 @@ void LLScriptFloaterManager::onAddNotification(const LLUUID& notification_id)
 
 void LLScriptFloaterManager::onRemoveNotification(const LLUUID& notification_id)
 {
-	LLUUID object_id = notification_id_to_object_id(notification_id);
+	LLUUID object_id = findObjectId(notification_id);
 	if(object_id.isNull())
 	{
 		llwarns << "Invalid notification, no object id" << llendl;
@@ -241,22 +247,24 @@ void LLScriptFloaterManager::onRemoveNotification(const LLUUID& notification_id)
 	LLUUID channel_id(gSavedSettings.getString("NotificationChannelUUID"));
 	LLScreenChannel* channel = dynamic_cast<LLScreenChannel*>
 		(LLChannelManager::getInstance()->findChannelByID(channel_id));
-	if(channel)
+	LLUUID n_toast_id = findNotificationToastId(object_id);
+	if(channel && n_toast_id.notNull())
 	{
-		channel->killToastByNotificationID(findNotificationToastId(object_id));
+		channel->killToastByNotificationID(n_toast_id);
 	}
 
-	mNotifications.erase(object_id);
-
 	// remove related chiclet
 	LLBottomTray::getInstance()->getChicletPanel()->removeChiclet(object_id);
 
 	// close floater
-	LLScriptFloater* floater = LLFloaterReg::findTypedInstance<LLScriptFloater>("script_floater", object_id);
+	LLScriptFloater* floater = LLFloaterReg::findTypedInstance<LLScriptFloater>("script_floater", notification_id);
 	if(floater)
 	{
+		floater->setObjectId(LLUUID::null);
 		floater->closeFloater();
 	}
+
+	mNotifications.erase(object_id);
 }
 
 void LLScriptFloaterManager::removeNotificationByObjectId(const LLUUID& object_id)
@@ -301,6 +309,22 @@ void LLScriptFloaterManager::setNotificationToastId(const LLUUID& object_id, con
 	}
 }
 
+LLUUID LLScriptFloaterManager::findObjectId(const LLUUID& notification_id)
+{
+	if(notification_id.notNull())
+	{
+		script_notification_map_t::const_iterator it = mNotifications.begin();
+		for(; mNotifications.end() != it; ++it)
+		{
+			if(notification_id == it->second.notification_id)
+			{
+				return it->first;
+			}
+		}
+	}
+	return LLUUID::null;
+}
+
 LLUUID LLScriptFloaterManager::findNotificationId(const LLUUID& object_id)
 {
 	script_notification_map_t::const_iterator it = mNotifications.find(object_id);
diff --git a/indra/newview/llscriptfloater.h b/indra/newview/llscriptfloater.h
index 0e1a7f36b7..8b5a266691 100644
--- a/indra/newview/llscriptfloater.h
+++ b/indra/newview/llscriptfloater.h
@@ -43,6 +43,9 @@ class LLToastNotifyPanel;
  */
 class LLScriptFloaterManager : public LLSingleton<LLScriptFloaterManager>
 {
+	// *TODO
+	// LLScriptFloaterManager and LLScriptFloater will need some refactoring after we 
+	// know how script notifications should look like.
 public:
 
 	/**
@@ -69,6 +72,8 @@ public:
 	 */
 	void toggleScriptFloater(const LLUUID& object_id);
 
+	LLUUID findObjectId(const LLUUID& notification_id);
+
 	LLUUID findNotificationId(const LLUUID& object_id);
 
 	LLUUID findNotificationToastId(const LLUUID& object_id);
@@ -102,7 +107,7 @@ private:
  * LLScriptFloater will create script form based on notification data and 
  * will auto fit the form.
  */
-class LLScriptFloater : public LLTransientDockableFloater
+class LLScriptFloater : public LLDockableFloater
 {
 public:
 
@@ -125,6 +130,8 @@ public:
 
 	const LLUUID& getObjectId() { return mObjectId; }
 
+	void setObjectId(const LLUUID& id) { mObjectId = id; }
+
 	/**
 	 * Close notification if script floater is closed.
 	 */
@@ -154,8 +161,6 @@ protected:
 	 */
 	static void hideToastsIfNeeded();
 
-	void setObjectId(const LLUUID& id) { mObjectId = id; }
-
 private:
 	LLToastNotifyPanel* mScriptForm;
 	LLUUID mObjectId;
diff --git a/indra/newview/llteleporthistory.cpp b/indra/newview/llteleporthistory.cpp
index cc4689062e..1315887c37 100644
--- a/indra/newview/llteleporthistory.cpp
+++ b/indra/newview/llteleporthistory.cpp
@@ -167,7 +167,10 @@ void LLTeleportHistory::onHistoryChanged()
 
 void LLTeleportHistory::purgeItems()
 {
-	mItems.erase(mItems.begin(), mItems.end()-1);
+	if (mItems.size() > 0)
+	{
+		mItems.erase(mItems.begin(), mItems.end()-1);
+	}
 	// reset the count
 	mRequestedItem = -1;
 	mCurrentItem = 0;
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 9bb2a4ad0a..ef49d7f057 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -736,7 +736,8 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			}
 			else
 			{
-				llwarns << "Region not found for host: " << mHost << llendl;
+				// This will happen if not logged in or if a region deoes not have HTTP Texture enabled
+				//llwarns << "Region not found for host: " << mHost << llendl;
 			}
 		}
 		if (!mUrl.empty())
@@ -943,11 +944,14 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		{
 			llerrs << "Decode entered with invalid mFormattedImage. ID = " << mID << llendl;
 		}
+		if (mLoadedDiscard < 0)
+		{
+			llerrs << "Decode entered with invalid mLoadedDiscard. ID = " << mID << llendl;
+		}
 		setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it
 		mRawImage = NULL;
 		mAuxImage = NULL;
 		llassert_always(mFormattedImage.notNull());
-		llassert_always(mLoadedDiscard >= 0);
 		S32 discard = mHaveAllData ? 0 : mLoadedDiscard;
 		U32 image_priority = LLWorkerThread::PRIORITY_NORMAL | mWorkPriority;
 		mDecoded  = FALSE;
diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp
index b5454e7298..7c9bd582dd 100644
--- a/indra/newview/llviewerfloaterreg.cpp
+++ b/indra/newview/llviewerfloaterreg.cpp
@@ -250,7 +250,6 @@ void LLViewerFloaterReg::registerFloaters()
 	LLFloaterReg::add("upload_sound", "floater_sound_preview.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterSoundPreview>, "upload");
 	
 	LLFloaterReg::add("volume_pulldown", "floater_volume_pulldown.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterVolumePulldown>);
-	LLFloaterReg::add("voice_call", "floater_call.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterCall>);
 	LLFloaterReg::add("voice_controls", "floater_voice_controls.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLCallFloater>);
 	
 	LLFloaterReg::add("whitelist_entry", "floater_whitelist_entry.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterWhiteListEntry>);	
diff --git a/indra/newview/llviewerkeyboard.cpp b/indra/newview/llviewerkeyboard.cpp
index 8fd646ee93..f757155b94 100644
--- a/indra/newview/llviewerkeyboard.cpp
+++ b/indra/newview/llviewerkeyboard.cpp
@@ -538,8 +538,9 @@ void start_chat( EKeystate s )
 
 void start_gesture( EKeystate s )
 {
+	LLUICtrl* focus_ctrlp = dynamic_cast<LLUICtrl*>(gFocusMgr.getKeyboardFocus());
 	if (KEYSTATE_UP == s &&
-		!(gFocusMgr.getKeyboardFocus() && dynamic_cast<LLUICtrl*>(gFocusMgr.getKeyboardFocus())->acceptsTextInput()))
+		! (focus_ctrlp && focus_ctrlp->acceptsTextInput()))
 	{
  		if (LLNearbyChatBar::getInstance()->getCurrentChat().empty())
  		{
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index d5fd23ac51..f6db661489 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -45,6 +45,9 @@
 #include "llviewertexturelist.h"
 #include "llvovolume.h"
 #include "llpluginclassmedia.h"
+#include "llviewerwindow.h"
+#include "llfocusmgr.h"
+#include "llcallbacklist.h"
 
 #include "llevent.h"		// LLSimpleListener
 #include "llnotificationsutil.h"
@@ -55,7 +58,7 @@
 #include <boost/bind.hpp>	// for SkinFolder listener
 #include <boost/signals2.hpp>
 
-/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "AutoPlayMedia";
+/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "ParcelMediaAutoPlayEnable";
 
 // Move this to its own file.
 
@@ -327,6 +330,8 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 		media_impl->mMediaLoop = media_entry->getAutoLoop();
 		media_impl->mMediaWidth = media_entry->getWidthPixels();
 		media_impl->mMediaHeight = media_entry->getHeightPixels();
+		media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
+		media_impl->mMediaEntryURL = media_entry->getCurrentURL();
 		if (media_impl->mMediaSource)
 		{
 			media_impl->mMediaSource->setAutoScale(media_impl->mMediaAutoScale);
@@ -334,8 +339,8 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 			media_impl->mMediaSource->setSize(media_entry->getWidthPixels(), media_entry->getHeightPixels());
 		}
 		
-		bool url_changed = (media_entry->getCurrentURL() != previous_url);
-		if(media_entry->getCurrentURL().empty())
+		bool url_changed = (media_impl->mMediaEntryURL != previous_url);
+		if(media_impl->mMediaEntryURL.empty())
 		{
 			if(url_changed)
 			{
@@ -350,7 +355,7 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 			// The current media URL is not empty.
 			// If (the media was already loaded OR the media was set to autoplay) AND this update didn't come from this agent,
 			// do a navigate.
-			bool auto_play = (media_entry->getAutoPlay() && gSavedSettings.getBOOL(AUTO_PLAY_MEDIA_SETTING));
+			bool auto_play = (media_impl->mMediaAutoPlay && gSavedSettings.getBOOL(AUTO_PLAY_MEDIA_SETTING));
 			
 			if((was_loaded || auto_play) && !update_from_self)
 			{
@@ -372,8 +377,10 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 			media_entry->getAutoLoop());
 		
 		media_impl->setHomeURL(media_entry->getHomeURL());
+		media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
+		media_impl->mMediaEntryURL = media_entry->getCurrentURL();
 		
-		if(media_entry->getAutoPlay() && gSavedSettings.getBOOL(AUTO_PLAY_MEDIA_SETTING))
+		if(media_impl->mMediaAutoPlay && gSavedSettings.getBOOL(AUTO_PLAY_MEDIA_SETTING))
 		{
 			needs_navigate = true;
 		}
@@ -381,21 +388,20 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 	
 	if(media_impl)
 	{
-		std::string url = media_entry->getCurrentURL();
 		if(needs_navigate)
 		{
-			media_impl->navigateTo(url, "", true, true);
-			lldebugs << "navigating to URL " << url << llendl;
+			media_impl->navigateTo(media_impl->mMediaEntryURL, "", true, true);
+			lldebugs << "navigating to URL " << media_impl->mMediaEntryURL << llendl;
 		}
-		else if(!media_impl->mMediaURL.empty() && (media_impl->mMediaURL != url))
+		else if(!media_impl->mMediaURL.empty() && (media_impl->mMediaURL != media_impl->mMediaEntryURL))
 		{
 			// If we already have a non-empty media URL set and we aren't doing a navigate, update the media URL to match the media entry.
-			media_impl->mMediaURL = url;
+			media_impl->mMediaURL = media_impl->mMediaEntryURL;
 
 			// If this causes a navigate at some point (such as after a reload), it should be considered server-driven so it isn't broadcast.
 			media_impl->mNavigateServerRequest = true;
 
-			lldebugs << "updating URL in the media impl to " << url << llendl;
+			lldebugs << "updating URL in the media impl to " << media_impl->mMediaEntryURL << llendl;
 		}
 	}
 	
@@ -625,7 +631,7 @@ static bool proximity_comparitor(const LLViewerMediaImpl* i1, const LLViewerMedi
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // static
-void LLViewerMedia::updateMedia()
+void LLViewerMedia::updateMedia(void *dummy_arg)
 {
 	impl_list::iterator iter = sViewerMediaImplList.begin();
 	impl_list::iterator end = sViewerMediaImplList.end();
@@ -668,7 +674,7 @@ void LLViewerMedia::updateMedia()
 		
 		LLPluginClassMedia::EPriority new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
 
-		if(pimpl->isForcedUnloaded() || (impl_count_total > (int)max_instances))
+		if(pimpl->isForcedUnloaded() || (impl_count_total >= (int)max_instances))
 		{
 			// Never load muted or failed impls.
 			// Hard limit on the number of instances that will be loaded at one time
@@ -747,6 +753,19 @@ void LLViewerMedia::updateMedia()
 			impl_count_total++;
 		}
 		
+		// Overrides if the window is minimized or we lost focus (taking care
+		// not to accidentally "raise" the priority either)
+		if (!gViewerWindow->getActive() /* viewer window minimized? */ 
+			&& new_priority > LLPluginClassMedia::PRIORITY_HIDDEN)
+		{
+			new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
+		}
+		else if (!gFocusMgr.getAppHasFocus() /* viewer window lost focus? */
+				 && new_priority > LLPluginClassMedia::PRIORITY_LOW)
+		{
+			new_priority = LLPluginClassMedia::PRIORITY_LOW;
+		}
+		
 		pimpl->setPriority(new_priority);
 		
 		if(pimpl->getUsedInUI())
@@ -785,9 +804,16 @@ void LLViewerMedia::updateMedia()
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // static
+void LLViewerMedia::initClass()
+{
+	gIdleCallbacks.addFunction(LLViewerMedia::updateMedia, NULL);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
 void LLViewerMedia::cleanupClass()
 {
-	// This is no longer necessary, since sViewerMediaImplList is no longer smart pointers.
+	gIdleCallbacks.deleteFunction(LLViewerMedia::updateMedia, NULL);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -830,6 +856,7 @@ LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
 	mProximity(-1),
 	mProximityDistance(0.0f),
 	mMimeTypeProbe(NULL),
+	mMediaAutoPlay(false),
 	mIsUpdated(false)
 { 
 
@@ -1911,6 +1938,33 @@ void LLViewerMediaImpl::resetPreviousMediaState()
 	mPreviousMediaTime = 0.0f;
 }
 
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//
+void LLViewerMediaImpl::setDisabled(bool disabled)
+{
+	if(mIsDisabled != disabled)
+	{
+		// Only do this on actual state transitions.
+		mIsDisabled = disabled;
+		
+		if(mIsDisabled)
+		{
+			// We just disabled this media.  Clear all state.
+			unload();
+		}
+		else
+		{
+			// We just (re)enabled this media.  Do a navigate if auto-play is in order.
+			if(mMediaAutoPlay && gSavedSettings.getBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING))
+			{
+				navigateTo(mMediaEntryURL, "", true, true);
+			}
+		}
+
+	}
+};
+
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::isForcedUnloaded() const
diff --git a/indra/newview/llviewermedia.h b/indra/newview/llviewermedia.h
index e2d159304f..713eb2710b 100644
--- a/indra/newview/llviewermedia.h
+++ b/indra/newview/llviewermedia.h
@@ -96,9 +96,10 @@ class LLViewerMedia
 		static bool textureHasMedia(const LLUUID& texture_id);
 		static void setVolume(F32 volume);
 
-		static void updateMedia();
+		static void updateMedia(void* dummy_arg = NULL);
 		static bool isMusicPlaying();
 
+		static void initClass();
 		static void cleanupClass();
 
 		static void toggleMusicPlay(void*);
@@ -201,7 +202,7 @@ public:
 	bool isMediaFailed() const { return mMediaSourceFailed; };
 	void resetPreviousMediaState();
 	
-	void setDisabled(bool disabled) { mIsDisabled = disabled; };
+	void setDisabled(bool disabled);
 	bool isMediaDisabled() const { return mIsDisabled; };
 
 	// returns true if this instance should not be loaded (disabled, muted object, crashed, etc.)
@@ -345,6 +346,8 @@ public:
 	S32 mProximity;
 	F64 mProximityDistance;
 	LLMimeDiscoveryResponder *mMimeTypeProbe;
+	bool mMediaAutoPlay;
+	std::string mMediaEntryURL;
 	
 private:
 	BOOL mIsUpdated ;
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index 65ad2f6fa6..507e34348b 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -5506,17 +5506,6 @@ void process_script_dialog(LLMessageSystem* msg, void**)
 		notification = LLNotifications::instance().add(
 			LLNotification::Params("ScriptDialogGroup").substitutions(args).payload(payload).form_elements(form.asLLSD()));
 	}
-
-	// "ScriptDialog" and "ScriptDialogGroup" are handles by LLScriptFloaterManager.
-	// We want to inform user that there is a script floater, lets add "ScriptToast"
-	LLNotification::Params p("ScriptToast");
-	p.substitutions(args).payload(payload).functor.function(boost::bind(
-		LLScriptFloaterManager::onToastButtonClick, _1, _2));
-
-	notification = LLNotifications::instance().add(p);
-
-	LLScriptFloaterManager::getInstance()->setNotificationToastId(
-		object_id, notification->getID());
 }
 
 //---------------------------------------------------------------------------
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index dbcf563010..5be7f2945f 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -614,10 +614,6 @@ void LLViewerTextureList::updateImages(F32 max_time)
 			didone = image->doLoadedCallbacks();
 		}
 	}
-	if (!gNoRender && !gGLManager.mIsDisabled)
-	{
-		LLViewerMedia::updateMedia();
-	}
 	updateImagesUpdateStats();
 }
 
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 9ba056a17c..8529a93527 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1011,6 +1011,7 @@ BOOL LLViewerWindow::handleActivate(LLWindow *window, BOOL activated)
 	else
 	{
 		mActive = FALSE;
+				
 		if (gSavedSettings.getBOOL("AllowIdleAFK"))
 		{
 			gAgent.setAFK();
@@ -3244,8 +3245,7 @@ LLPickInfo LLViewerWindow::pickImmediate(S32 x, S32 y_from_bot,  BOOL pick_trans
 	}
 	else
 	{
-		llwarns << "List of last picks is empty" << llendl;
-		llwarns << "Using stub pick" << llendl;
+		lldebugs << "List of last picks is empty: Using stub pick" << llendl;
 		mLastPick = LLPickInfo();
 	}
 
diff --git a/indra/newview/llvoicechannel.cpp b/indra/newview/llvoicechannel.cpp
index a0396bc790..608060174a 100644
--- a/indra/newview/llvoicechannel.cpp
+++ b/indra/newview/llvoicechannel.cpp
@@ -408,28 +408,6 @@ void LLVoiceChannel::doSetState(const EState& new_state)
 		mStateChangedCallback(old_state, mState);
 }
 
-void LLVoiceChannel::toggleCallWindowIfNeeded(EState state)
-{
-	LLFloaterCall* floater = dynamic_cast<LLFloaterCall*>(LLFloaterReg::getInstance("voice_call", mSessionID));
-	if (!floater)
-		return;
-
-	if (state == STATE_CONNECTED)
-	{
-		floater->init(mSessionID);
-		floater->openFloater(mSessionID);
-	}
-	// By checking that current state is CONNECTED we make sure that the call window
-	// has been shown, hence there's something to hide. This helps when user presses
-	// the "End call" button right after initiating the call.
-	// *TODO: move this check to LLFloaterCall?
-	else if (state == STATE_HUNG_UP && mState == STATE_CONNECTED)
-	{
-		floater->reset();
-		floater->closeFloater();
-	}
-}
-
 //static
 void LLVoiceChannel::initClass()
 {
@@ -630,9 +608,6 @@ void LLVoiceChannelGroup::handleError(EStatusType status)
 
 void LLVoiceChannelGroup::setState(EState state)
 {
-	// HACK: Open/close the call window if needed.
-	toggleCallWindowIfNeeded(state);
-
 	switch(state)
 	{
 	case STATE_RINGING:
@@ -886,9 +861,6 @@ void LLVoiceChannelP2P::setSessionHandle(const std::string& handle, const std::s
 
 void LLVoiceChannelP2P::setState(EState state)
 {
-	// *HACK: Open/close the call window if needed.
-	toggleCallWindowIfNeeded(state);
-	
 	llinfos << "P2P CALL STATE CHANGE: incoming=" << int(mReceivedCall) << " oldstate=" << mState << " newstate=" << state << llendl;
 
 	if (mReceivedCall) // incoming call
diff --git a/indra/newview/llvoicechannel.h b/indra/newview/llvoicechannel.h
index fe0114d687..1bed329ba2 100644
--- a/indra/newview/llvoicechannel.h
+++ b/indra/newview/llvoicechannel.h
@@ -101,7 +101,6 @@ protected:
 	 * Use this method if you want mStateChangedCallback to be executed while state is changed
 	 */
 	void doSetState(const EState& state);
-	void toggleCallWindowIfNeeded(EState state);
 	void setURI(std::string uri);
 
 	std::string	mURI;
diff --git a/indra/newview/skins/default/xui/en/floater_aaa.xml b/indra/newview/skins/default/xui/en/floater_aaa.xml
index 6ecdd76573..f89ad2f997 100644
--- a/indra/newview/skins/default/xui/en/floater_aaa.xml
+++ b/indra/newview/skins/default/xui/en/floater_aaa.xml
@@ -17,6 +17,7 @@
  save_visibility="true"
  single_instance="true"
  width="320">
+  <string name="nudge_parabuild">Nudge 1</string>
   <chat_history
    allow_html="true"
    bg_readonly_color="ChatHistoryBgColor"
diff --git a/indra/newview/skins/default/xui/en/menu_people_nearby.xml b/indra/newview/skins/default/xui/en/menu_people_nearby.xml
index 643336cf6c..c3a2540b2e 100644
--- a/indra/newview/skins/default/xui/en/menu_people_nearby.xml
+++ b/indra/newview/skins/default/xui/en/menu_people_nearby.xml
@@ -27,7 +27,6 @@
          function="Avatar.IM" />
     </menu_item_call>
     <menu_item_call
-     enabled="false"
      label="Call"
      layout="topleft"
      name="Call">
diff --git a/indra/newview/skins/default/xui/en/menu_viewer.xml b/indra/newview/skins/default/xui/en/menu_viewer.xml
index ae8a1599a9..37136af680 100644
--- a/indra/newview/skins/default/xui/en/menu_viewer.xml
+++ b/indra/newview/skins/default/xui/en/menu_viewer.xml
@@ -3268,6 +3268,17 @@
         </menu>
         <menu_item_separator
          layout="topleft" />
+        <menu_item_check
+         label="HTTP Textures"
+         layout="topleft"
+         name="HTTP Textures">
+            <menu_item_check.on_check
+             function="CheckControl"
+             parameter="ImagePipelineUseHTTP" />
+            <menu_item_check.on_click
+             function="ToggleControl"
+             parameter="ImagePipelineUseHTTP" />
+        </menu_item_check>
         <menu_item_call
          label="Compress Images"
          layout="topleft"
diff --git a/indra/newview/skins/default/xui/en/panel_my_profile.xml b/indra/newview/skins/default/xui/en/panel_my_profile.xml
index fe3e010cf9..3c87331199 100644
--- a/indra/newview/skins/default/xui/en/panel_my_profile.xml
+++ b/indra/newview/skins/default/xui/en/panel_my_profile.xml
@@ -416,6 +416,7 @@
          left="10"
          label="Edit Profile"
          name="edit_profile_btn"
+         tool_tip="Edit your personal information"
          width="130" />
         <button
          follows="bottom|right"
@@ -423,6 +424,7 @@
          label="Edit Appearance"
          left_pad="10"
          name="edit_appearance_btn"
+         tool_tip="Create/edit your appearance: physical data, clothes and etc."
          right="-10"
          width="130" />
  </panel>
diff --git a/indra/newview/skins/default/xui/en/panel_picks.xml b/indra/newview/skins/default/xui/en/panel_picks.xml
index 4c2bd67337..52bc72fe86 100644
--- a/indra/newview/skins/default/xui/en/panel_picks.xml
+++ b/indra/newview/skins/default/xui/en/panel_picks.xml
@@ -106,7 +106,7 @@
              layout="topleft"
              left_pad="15"
              name="new_btn"
-             tool_tip="Create new pick at current location"
+             tool_tip="Create new pick or classified at current location"
              top="5"
              width="18" />
             <button
@@ -138,6 +138,7 @@
          left="5"
          name="info_btn"
          tab_stop="false"
+         tool_tip="Show pic information"
          top="0"
          width="55" />
         <button
@@ -149,6 +150,7 @@
          left_pad="5"
          name="teleport_btn"
          tab_stop="false"
+         tool_tip="Teleport to the corresponding area"
          top="0"
          width="77" />
         <button
@@ -160,6 +162,7 @@
          left_pad="5"
          name="show_on_map_btn"
          tab_stop="false"
+         tool_tip="Show corresponding area on the world map"
          top="0"
          width="50" />
         </panel>
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml b/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml
index 23832ba120..29e9b476eb 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_privacy.xml
@@ -78,7 +78,7 @@
      top_pad="10"
      width="350" />
     <check_box
-     control_name="AutoPlayMedia"
+     control_name="ParcelMediaAutoPlayEnable"
      height="16"
      label="Allow Media Autoplay"
      layout="topleft"
@@ -86,15 +86,6 @@
      name="autoplay_enabled"
      top_pad="10"
      width="350" />
-    <check_box
-     control_name="ParcelMediaAutoPlayEnable"
-     height="16"
-     label="Automatically Play Parcel Media"
-     layout="topleft"
-     left="30"
-     name="parcel_autoplay_enabled"
-     top_pad="10"
-     width="350" />
    <text
       type="string"
     length="1"
diff --git a/indra/newview/skins/default/xui/en/panel_prim_media_controls.xml b/indra/newview/skins/default/xui/en/panel_prim_media_controls.xml
index 8b86067b03..e21de31498 100644
--- a/indra/newview/skins/default/xui/en/panel_prim_media_controls.xml
+++ b/indra/newview/skins/default/xui/en/panel_prim_media_controls.xml
@@ -3,7 +3,7 @@
 	follows="left|right|top|bottom"
 	name="MediaControls"
 	background_visible="false"
-	height="192"
+	height="200"
 	layout="topleft"
 	mouse_opaque="false"
 	width="800">
@@ -16,20 +16,20 @@
   <string name="zoom_far_padding">1.5</string>
   <panel
 	  name="media_region"
-	  bottom="125"
+	  height="100"
 	  follows="left|right|top|bottom"
 	  layout="topleft"
 	  mouse_opaque="false"
-	  top="20" />
+	  top="0" />
   <layout_stack
 	  name="media_controls"
 	  follows="left|right"
 	  animate="false"
-	  height="26"
+	  height="75"
 	  layout="topleft"
 	  left="0"
 	  orientation="horizontal"
-	  top="128">
+	  top="100">
 	<!-- outer layout_panels center the inner one -->
 	<layout_panel
 		name="left_bookend"
@@ -239,19 +239,6 @@
 		layout="topleft"
 		width="190"
 		min_width="90">
-	  <!--
-	  RE-ENABLE THIS WHEN WE HAVE A HISTORY DROP-DOWN AGAIN
-	  <combo_box
-		  name="media_address_url"
-		  allow_text_entry="true"
-		  height="22"
-		  layout="topleft"
-		  max_chars="1024"
-		  tool_tip = "Media URL">
-		<combo_box.commit_callback
-			function="MediaCtrl.CommitURL" />
-	  </combo_box>
-	  -->
 	  <line_editor 
 		  name="media_address_url"
 		  follows="left|right" 
@@ -314,8 +301,9 @@
 	  <slider_bar
 		  name="media_play_slider"
 		  follows="left|right|top"
-		  height="16"
-		  increment="0.05"
+		  height="20"
+		  bottom="88"
+		  increment="0.01"
 		  initial_value="0.5"
 		  layout="topleft"
 		  tool_tip="Movie play progress"
@@ -379,7 +367,8 @@
 		auto_resize="false"
 		user_resize="false"
 		layout="topleft"
-		height="22"
+		top="-50"
+		height="72"
 		min_width="22"
 		width="22">
 	  <!-- Note: this is not quite right either...the mute button is not the -->
@@ -397,138 +386,30 @@
 		  layout="topleft"
 		  scale_image="false" 
 		  tool_tip="Mute This Media"
-		  top_delta="18"
+		  top="118"
 		  min_width="22"
 		  width="22" >
 		<button.commit_callback
 			function="MediaCtrl.ToggleMute" />
+		<button.mouseenter_callback
+			function="MediaCtrl.ShowVolumeSlider" />
 	  </button>
-	</layout_panel>
-	<!-- We do not have a design yet for "volume", so this is a temporary -->
-	<!-- solution.  See DEV-42827. -->
-	<layout_panel
-		name="volume_up"
-		auto_resize="false"
-		user_resize="false"
-		layout="topleft"
-		min_width="14"
-		height="14"
-		width="14">
-	  <button
-		  image_overlay="media_btn_scrollup.png"
-		  image_disabled="PushButton_Disabled"
-		  image_disabled_selected="PushButton_Disabled"
-		  image_selected="PushButton_Selected"
-		  image_unselected="PushButton_Off"
-		  hover_glow_amount="0.15"
-		  top="-5"
-		  height="14"
-		  layout="topleft"
-		  tool_tip="Volume up"
-		  scale_image="true"
-		  min_width="14"
-		  width="14" >
-		<button.commit_callback
-			function="MediaCtrl.CommitVolumeUp" />
-	  </button>
-	</layout_panel>
-	<layout_panel
-		name="volume_down"
-		auto_resize="false"
-		user_resize="false"
-		layout="topleft"
-		min_width="14"
-		height="14"
-		width="14">
-	  <button
-		  image_overlay="media_btn_scrolldown.png"
-		  image_disabled="PushButton_Disabled"
-		  image_disabled_selected="PushButton_Disabled"
-		  image_selected="PushButton_Selected"
-		  image_unselected="PushButton_Off"
-		  hover_glow_amount="0.15"
-		  layout="topleft"
-		  tool_tip="Volume down"
-		  scale_image="true"
-		  top="-5"
-		  height="14"
-		  min_width="14"
-		  width="14">
-		<button.commit_callback
-			function="MediaCtrl.CommitVolumeDown" />
-	  </button>
-	</layout_panel>
-	<!-- Scroll pad -->
-	<!-- This was removed from the design, but is still here because it is --> 
-	<!-- complex, and recreating it would be hard.  In case the design -->
-	<!-- changes, here it lies: --> 
-	<!--
-	<layout_panel
-		name="media_panel_scroll"
-		auto_resize="false"
-		user_resize="false"
-		height="32"
-		follows="left|right|top|bottom"
-		layout="topleft"
-		min_width="32"
-		width="32">
-	  <icon
-		  height="32"
-		  image_name="media_panel_scrollbg.png"
-		  layout="topleft"
-		  top="0"
-		  min_width="32"
-		  width="32" />
-	  <button
-		  name="scrollup"
-		  height="8"
-		  image_selected="media_btn_scrollup.png"
-		  image_unselected="media_btn_scrollup.png"
-		  layout="topleft"
-		  tool_tip="Scroll up"
-		  scale_image="false"
-		  left="12"
-		  top_delta="4"
-		  min_width="8"
-		  width="8" />
-	  <button
-		  name="scrollleft"
-		  height="8"
-		  image_selected="media_btn_scrollleft.png"
-		  image_unselected="media_btn_scrollleft.png"
-		  layout="topleft"
-		  left="3"
-		  tool_tip="Scroll left"
-		  scale_image="false"
-		  top="12"
-		  min_width="8"
-		  width="8" />
-	  <button
-		  name="scrollright"
-		  height="8"
-		  image_selected="media_btn_scrollright.png"
-		  image_unselected="media_btn_scrollright.png"
-		  layout="topleft"
-		  left_pad="9"
-		  tool_tip="Scroll right"
-		  scale_image="false"
-		  top_delta="0"
-		  min_width="8"
-		  width="8" />
-	  <button
-		  name="scrolldown"
-		  height="8"
-		  image_selected="media_btn_scrolldown.png"
-		  image_unselected="media_btn_scrolldown.png"
+	  <slider
+		  orientation="vertical"
+		  left="0"
+		  top="-2"
+		  height="50"
 		  layout="topleft"
-		  left="12"
-		  tool_tip="Scroll down"
-		  scale_image="false"
-		  top="20"
-		  min_width="8"
-		  width="8" />
+		  increment="0.01"
+		  initial_value="0.5"
+		  name="volume_slider"
+		  tool_tip="Media Volume"
+		  show_text="false"
+		  volume="true">
+		<slider.commit_callback
+			function="MediaCtrl.Volume"/>
+	  </slider>
 	</layout_panel>
-	-->
 	<panel
 		height="28"
 		layout="topleft"
@@ -628,7 +509,7 @@
 	  animate="false"
 	  left="0"
 	  orientation="horizontal"
-	  top="150">
+	  top="170">
 	<!-- outer layout_panels center the inner one -->
 	<layout_panel
 		width="0"
diff --git a/indra/newview/skins/default/xui/en/panel_profile.xml b/indra/newview/skins/default/xui/en/panel_profile.xml
index 947bb67152..6be203ef9c 100644
--- a/indra/newview/skins/default/xui/en/panel_profile.xml
+++ b/indra/newview/skins/default/xui/en/panel_profile.xml
@@ -287,7 +287,7 @@
          mouse_opaque="false"
          name="add_friend"
          top="5"
-         width="76" />
+         width="77" />
         <button
          follows="bottom|left"
          height="19"
@@ -296,7 +296,7 @@
          name="im"
          top="5"
          left_pad="5"
-         width="31" />
+         width="33" />
         <button
          follows="bottom|left"
          height="19"
@@ -315,7 +315,7 @@
          name="show_on_map_btn"
          top="5"
          left_pad="5"
-         width="42" />
+         width="44" />
         <button
          follows="bottom|left"
          height="19"
@@ -324,7 +324,7 @@
          name="teleport"
          left_pad="5"
          top="5"
-         width="64" />
+         width="67" />
         <button
          follows="bottom|right"
          height="19"
diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
index cc9fa598f2..c1360987a5 100644
--- a/indra/test/CMakeLists.txt
+++ b/indra/test/CMakeLists.txt
@@ -119,8 +119,10 @@ get_target_property(TEST_EXE test LOCATION)
 
 IF(WINDOWS)
   set(LD_LIBRARY_PATH ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR})
+ELSEIF(DARWIN)
+  set(LD_LIBRARY_PATH ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources:/usr/lib)
 ELSE(WINDOWS)
-  set(LD_LIBRARY_PATH ${ARCH_PREBUILT_DIRS}:${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}:/usr/lib)
+  set(LD_LIBRARY_PATH ${SHARED_LIB_STAGING_DIR}:/usr/lib)
 ENDIF(WINDOWS)
 
 LL_TEST_COMMAND("${LD_LIBRARY_PATH}"
diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
index 31130c3c79..e58b10ce07 100644
--- a/indra/test/llevents_tut.cpp
+++ b/indra/test/llevents_tut.cpp
@@ -21,6 +21,7 @@
 #define testable public
 #include "llevents.h"
 #undef testable
+#include "lllistenerwrapper.h"
 // STL headers
 // std headers
 #include <iostream>
@@ -639,6 +640,33 @@ namespace tut
         heaptest.post(2);
     }
 
+    template<> template<>
+    void events_object::test<15>()
+    {
+        // This test ensures that using an LLListenerWrapper subclass doesn't
+        // block Boost.Signals2 from recognizing a bound LLEventTrackable
+        // subclass.
+        set_test_name("listen(llwrap<LLLogListener>(boost::bind(...TempTrackableListener ref...)))");
+        bool live = false;
+        LLEventPump& heaptest(pumps.obtain("heaptest"));
+        LLBoundListener connection;
+        {
+            TempTrackableListener tempListener("temp", live);
+            ensure("TempTrackableListener constructed", live);
+            connection = heaptest.listen(tempListener.getName(),
+                                         llwrap<LLLogListener>(
+                                         boost::bind(&TempTrackableListener::call,
+                                                     boost::ref(tempListener), _1)));
+            heaptest.post(1);
+            check_listener("received", tempListener, 1);
+        } // presumably this will make tempListener go away?
+        // verify that
+        ensure("TempTrackableListener destroyed", ! live);
+        ensure("implicit disconnect", ! connection.connected());
+        // now just make sure we don't blow up trying to access a freed object!
+        heaptest.post(2);
+    }
+
     class TempSharedListener: public TempListener,
                               public boost::enable_shared_from_this<TempSharedListener>
     {
@@ -649,7 +677,7 @@ namespace tut
     };
 
     template<> template<>
-    void events_object::test<15>()
+    void events_object::test<16>()
     {
         set_test_name("listen(boost::bind(...TempSharedListener ref...))");
 #if 0
diff --git a/indra/test/llsdutil_tut.cpp b/indra/test/llsdutil_tut.cpp
index d125bb0005..aebb1f9770 100644
--- a/indra/test/llsdutil_tut.cpp
+++ b/indra/test/llsdutil_tut.cpp
@@ -207,7 +207,7 @@ namespace tut
         map.insert("Date",      LLSD::Date());
         map.insert("URI",       LLSD::URI());
         map.insert("Binary",    LLSD::Binary());
-        map.insert("Map",       LLSD().insert("foo", LLSD()));
+        map.insert("Map",       LLSD().with("foo", LLSD()));
         // Only an empty array can be constructed on the fly
         LLSD array;
         array.append(LLSD());
diff --git a/indra/viewer_components/login/tests/lllogin_test.cpp b/indra/viewer_components/login/tests/lllogin_test.cpp
index 99ea796ad0..6255f7ed15 100644
--- a/indra/viewer_components/login/tests/lllogin_test.cpp
+++ b/indra/viewer_components/login/tests/lllogin_test.cpp
@@ -231,6 +231,7 @@ namespace tut
 		ensure_equals("Online state", listener.lastEvent()["state"].asString(), "online");
 	}
 
+	/*
     template<> template<>
     void llviewerlogin_object::test<2>()
     {
@@ -416,8 +417,8 @@ namespace tut
 		ensure_equals("Failed to offline", listener.lastEvent()["state"].asString(), "offline");
 	}
 
-/*
-    template<> template<>
+ *FIX:Mani Disabled unit boost::coro is patched 
+	template<> template<>
     void llviewerlogin_object::test<5>()
     {
         DEBUG;