Second Life viewer sources 1.18.1.2

1 files changed, 954 insertions, 66 deletions

diff --git a/linden/indra/newview/llimpanel.cpp b/linden/indra/newview/llimpanel.cpp
index b74fff0..2529d04 100644
--- a/linden/indra/newview/llimpanel.cpp
+++ b/linden/indra/newview/llimpanel.cpp
@@ -33,7 +33,6 @@
 #include "indra_constants.h"
 #include "llfocusmgr.h"
 #include "llfontgl.h"
-#include "llhttpclient.h"
 #include "llrect.h"
 #include "llerror.h"
 #include "llstring.h"
@@ -43,12 +42,14 @@
 #include "llagent.h"
 #include "llbutton.h"
 #include "llcallingcard.h"
+#include "llchat.h"
 #include "llconsole.h"
 #include "llfloater.h"
 #include "llinventory.h"
 #include "llinventorymodel.h"
 #include "llinventoryview.h"
 #include "llfloateravatarinfo.h"
+#include "llfloaterchat.h"
 #include "llkeyboard.h"
 #include "lllineeditor.h"
 #include "llresmgr.h"
@@ -61,8 +62,13 @@
 #include "llvieweruictrlfactory.h"
 #include "lllogchat.h"
 #include "llfloaterhtml.h"
-#include "llviewerregion.h"
 #include "llweb.h"
+#include "llhttpclient.h"
+#include "llfloateractivespeakers.h" // LLSpeakerMgr
+#include "llfloatergroupinfo.h"
+#include "llsdutil.h"
+#include "llnotify.h"
+#include "llmutelist.h"
 
 //
 // Constants
@@ -79,6 +85,10 @@ static LLString sTitleString = "Instant Message with [NAME]";
 static LLString sTypingStartString = "[NAME]: ...";
 static LLString sSessionStartString = "Starting session with [NAME] please wait.";
 
+LLVoiceChannel::voice_channel_map_t LLVoiceChannel::sVoiceChannelMap;
+LLVoiceChannel::voice_channel_map_uri_t LLVoiceChannel::sVoiceChannelURIMap;
+LLVoiceChannel* LLVoiceChannel::sCurrentVoiceChannel = NULL;
+
 void session_starter_helper(const LLUUID& temp_session_id,
                                                         const LLUUID& other_participant_id,
                                                         EInstantMessage im_type)
@@ -161,45 +171,669 @@ bool send_start_session_messages(const LLUUID& temp_session_id,
         return false;
 }
 
-// Member Functions
+class LLVoiceCallCapResponder : public LLHTTPClient::Responder
+{
+public:
+        LLVoiceCallCapResponder(const LLUUID& session_id) : mSessionID(session_id) {};
+
+        virtual void error(U32 status, const std::string& reason);      // called with bad status codes
+        virtual void result(const LLSD& content);
+
+private:
+        LLUUID mSessionID;
+};
+
+
+void LLVoiceCallCapResponder::error(U32 status, const std::string& reason)
+{
+        llwarns << "LLVoiceCallCapResponder::error("
+                << status << ": " << reason << ")"
+                << llendl;
+        LLVoiceChannel* channelp = LLVoiceChannel::getChannelByID(mSessionID);
+        if (channelp)
+        {
+                channelp->deactivate();
+        }
+}
+
+void LLVoiceCallCapResponder::result(const LLSD& content)
+{
+        LLVoiceChannel* channelp = LLVoiceChannel::getChannelByID(mSessionID);
+        if (channelp)
+        {
+                //*TODO: DEBUG SPAM
+                LLSD::map_const_iterator iter;
+                for(iter = content.beginMap(); iter != content.endMap(); ++iter)
+                {
+                        llinfos << "LLVoiceCallCapResponder::result got " 
+                                << iter->first << llendl;
+                }
+
+                channelp->setChannelInfo(
+                        content["voice_credentials"]["channel_uri"].asString(),
+                        content["voice_credentials"]["channel_credentials"].asString());
+        }
+}
+
+//
+// LLVoiceChannel
+//
+LLVoiceChannel::LLVoiceChannel(const LLUUID& session_id, const LLString& session_name) : 
+        mSessionID(session_id), 
+        mState(STATE_NO_CHANNEL_INFO), 
+        mSessionName(session_name),
+        mIgnoreNextSessionLeave(FALSE)
+{
+        mNotifyArgs["[VOICE_CHANNEL_NAME]"] = mSessionName;
+
+        if (!sVoiceChannelMap.insert(std::make_pair(session_id, this)).second)
+        {
+                // a voice channel already exists for this session id, so this instance will be orphaned
+                // the end result should simply be the failure to make voice calls
+                llwarns << "Duplicate voice channels registered for session_id " << session_id << llendl;
+        }
+
+        LLVoiceClient::getInstance()->addStatusObserver(this);
+}
+
+LLVoiceChannel::~LLVoiceChannel()
+{
+        // CANNOT do this here, since it will crash on quit in the LLVoiceChannelProximal singleton destructor.
+        // Do it in all other subclass destructors instead.
+        // deactivate();
+        
+        // Don't use LLVoiceClient::getInstance() here -- this can get called during atexit() time and that singleton MAY have already been destroyed.
+        if(gVoiceClient)
+        {
+                gVoiceClient->removeStatusObserver(this);
+        }
+        
+        sVoiceChannelMap.erase(mSessionID);
+        sVoiceChannelURIMap.erase(mURI);
+}
+
+void LLVoiceChannel::setChannelInfo(
+        const LLString& uri,
+        const LLString& credentials)
+{
+        setURI(uri);
+
+        mCredentials = credentials;
+
+        if (mState == STATE_NO_CHANNEL_INFO)
+        {
+                if(!mURI.empty() && !mCredentials.empty())
+                {
+                        setState(STATE_READY);
+
+                        // if we are supposed to be active, reconnect
+                        // this will happen on initial connect, as we request credentials on first use
+                        if (sCurrentVoiceChannel == this)
+                        {
+                                // just in case we got new channel info while active
+                                // should move over to new channel
+                                activate();
+                        }
+                }
+                else
+                {
+                        //*TODO: notify user
+                        llwarns << "Received invalid credentials for channel " << mSessionName << llendl;
+                        deactivate();
+                }
+        }
+}
+
+void LLVoiceChannel::onChange(EStatusType type, const std::string &channelURI, bool proximal)
+{
+        if (channelURI != mURI)
+        {
+                return;
+        }
+
+        if (type < BEGIN_ERROR_STATUS)
+        {
+                handleStatusChange(type);
+        }
+        else
+        {
+                handleError(type);
+        }
+}
+
+void LLVoiceChannel::handleStatusChange(EStatusType type)
+{
+        // status updates
+        switch(type)
+        {
+        case STATUS_LOGIN_RETRY:
+                mLoginNotificationHandle = LLNotifyBox::showXml("VoiceLoginRetry")->getHandle();
+                break;
+        case STATUS_LOGGED_IN:
+                if (!mLoginNotificationHandle.isDead())
+                {
+                        LLNotifyBox* notifyp = (LLNotifyBox*)LLPanel::getPanelByHandle(mLoginNotificationHandle);
+                        if (notifyp)
+                        {
+                                notifyp->close();
+                        }
+                        mLoginNotificationHandle.markDead();
+                }
+                break;
+        case STATUS_LEFT_CHANNEL:
+                if (callStarted() && !mIgnoreNextSessionLeave)
+                {
+                        // if forceably removed from channel
+                        // update the UI and revert to default channel
+                        LLNotifyBox::showXml("VoiceChannelDisconnected", mNotifyArgs);
+                        deactivate();
+                }
+                mIgnoreNextSessionLeave = FALSE;
+                break;
+        case STATUS_JOINING:
+                if (callStarted())
+                {
+                        setState(STATE_RINGING);
+                }
+                break;
+        case STATUS_JOINED:
+                if (callStarted())
+                {
+                        setState(STATE_CONNECTED);
+                }
+        default:
+                break;
+        }
+}
+
+// default behavior is to just deactivate channel
+// derived classes provide specific error messages
+void LLVoiceChannel::handleError(EStatusType type)
+{
+        deactivate();
+        setState(STATE_ERROR);
+}
+
+BOOL LLVoiceChannel::isActive()
+{ 
+        // only considered active when currently bound channel matches what our channel
+        return callStarted() && LLVoiceClient::getInstance()->getCurrentChannel() == mURI; 
+}
+
+BOOL LLVoiceChannel::callStarted()
+{
+        return mState >= STATE_CALL_STARTED;
+}
+
+void LLVoiceChannel::deactivate()
+{
+        if (mState >= STATE_RINGING)
+        {
+                // ignore session leave event
+                mIgnoreNextSessionLeave = TRUE;
+        }
+
+        if (callStarted())
+        {
+                setState(STATE_HUNG_UP);
+        }
+        if (sCurrentVoiceChannel == this)
+        {
+                // default channel is proximal channel
+                sCurrentVoiceChannel = LLVoiceChannelProximal::getInstance();
+                sCurrentVoiceChannel->activate();
+        }
+}
+
+void LLVoiceChannel::activate()
+{
+        if (callStarted())
+        {
+                return;
+        }
+
+        // deactivate old channel and mark ourselves as the active one
+        if (sCurrentVoiceChannel != this)
+        {
+                if (sCurrentVoiceChannel)
+                {
+                        sCurrentVoiceChannel->deactivate();
+                }
+                sCurrentVoiceChannel = this;
+        }
+
+        if (mState == STATE_NO_CHANNEL_INFO)
+        {
+                // responsible for setting status to active
+                getChannelInfo();
+        }
+        else
+        {
+                setState(STATE_CALL_STARTED);
+        }
+}
+
+void LLVoiceChannel::getChannelInfo()
+{
+        // pretend we have everything we need
+        if (sCurrentVoiceChannel == this)
+        {
+                setState(STATE_CALL_STARTED);
+        }
+}
+
+//static 
+LLVoiceChannel* LLVoiceChannel::getChannelByID(const LLUUID& session_id)
+{
+        voice_channel_map_t::iterator found_it = sVoiceChannelMap.find(session_id);
+        if (found_it == sVoiceChannelMap.end())
+        {
+                return NULL;
+        }
+        else
+        {
+                return found_it->second;
+        }
+}
+
+//static 
+LLVoiceChannel* LLVoiceChannel::getChannelByURI(LLString uri)
+{
+        voice_channel_map_uri_t::iterator found_it = sVoiceChannelURIMap.find(uri);
+        if (found_it == sVoiceChannelURIMap.end())
+        {
+                return NULL;
+        }
+        else
+        {
+                return found_it->second;
+        }
+}
+
+
+void LLVoiceChannel::updateSessionID(const LLUUID& new_session_id)
+{
+        sVoiceChannelMap.erase(sVoiceChannelMap.find(mSessionID));
+        mSessionID = new_session_id;
+        sVoiceChannelMap.insert(std::make_pair(mSessionID, this));
+}
+
+void LLVoiceChannel::setURI(LLString uri)
+{
+        sVoiceChannelURIMap.erase(mURI);
+        mURI = uri;
+        sVoiceChannelURIMap.insert(std::make_pair(mURI, this));
+}
+
+void LLVoiceChannel::setState(EState state)
+{
+        switch(state)
+        {
+        case STATE_RINGING:
+                gIMMgr->addSystemMessage(mSessionID, "ringing", mNotifyArgs);
+                break;
+        case STATE_CONNECTED:
+                gIMMgr->addSystemMessage(mSessionID, "connected", mNotifyArgs);
+                break;
+        case STATE_HUNG_UP:
+                gIMMgr->addSystemMessage(mSessionID, "hang_up", mNotifyArgs);
+                break;
+        default:
+                break;
+        }
+
+        mState = state;
+}
+
+
+//static
+void LLVoiceChannel::initClass()
+{
+        sCurrentVoiceChannel = LLVoiceChannelProximal::getInstance();
+}
+
+//
+// LLVoiceChannelGroup
+//
+
+LLVoiceChannelGroup::LLVoiceChannelGroup(const LLUUID& session_id, const LLString& session_name) : 
+        LLVoiceChannel(session_id, session_name)
+{
+}
+
+LLVoiceChannelGroup::~LLVoiceChannelGroup()
+{
+        deactivate();
+}
+
+void LLVoiceChannelGroup::deactivate()
+{
+        if (callStarted())
+        {
+                LLVoiceClient::getInstance()->leaveNonSpatialChannel();
+        }
+        LLVoiceChannel::deactivate();
+}
+
+void LLVoiceChannelGroup::activate()
+{
+        if (callStarted()) return;
+
+        LLVoiceChannel::activate();
+
+        if (callStarted())
+        {
+                // we have the channel info, just need to use it now
+                LLVoiceClient::getInstance()->setNonSpatialChannel(
+                        mURI,
+                        mCredentials);
+        }
+}
+
+void LLVoiceChannelGroup::getChannelInfo()
+{
+        LLViewerRegion* region = gAgent.getRegion();
+        if (region)
+        {
+                std::string url = region->getCapability("ChatSessionRequest");
+                LLSD data;
+                data["method"] = "call";
+                data["session-id"] = mSessionID;
+                LLHTTPClient::post(url,
+                                                   data,
+                                                   new LLVoiceCallCapResponder(mSessionID));
+        }
+}
+
+void LLVoiceChannelGroup::handleError(EStatusType status)
+{
+        std::string notify;
+        switch(status)
+        {
+          case ERROR_CHANNEL_LOCKED:
+          case ERROR_CHANNEL_FULL:
+                notify = "VoiceChannelFull";
+                break;
+          case ERROR_UNKNOWN:
+                break;
+          default:
+                break;
+        }
+
+        // notification
+        if (!notify.empty())
+        {
+                LLNotifyBox::showXml(notify, mNotifyArgs);
+                // echo to im window
+                gIMMgr->addMessage(mSessionID, LLUUID::null, SYSTEM_FROM, LLNotifyBox::getTemplateMessage(notify, mNotifyArgs).c_str());
+        }
+        
+        LLVoiceChannel::handleError(status);
+}
+
+//
+// LLVoiceChannelProximal
+//
+LLVoiceChannelProximal::LLVoiceChannelProximal() : 
+        LLVoiceChannel(LLUUID::null, LLString::null)
+{
+        activate();
+}
+
+LLVoiceChannelProximal::~LLVoiceChannelProximal()
+{
+        // DO NOT call deactivate() here, since this will only happen at atexit() time. 
+}
+
+BOOL LLVoiceChannelProximal::isActive()
+{
+        return callStarted() && LLVoiceClient::getInstance()->inProximalChannel(); 
+}
+
+void LLVoiceChannelProximal::activate()
+{
+        if (callStarted()) return;
+
+        LLVoiceChannel::activate();
+
+        if (callStarted())
+        {
+                // this implicitly puts you back in the spatial channel
+                LLVoiceClient::getInstance()->leaveNonSpatialChannel();
+        }
+}
+
+void LLVoiceChannelProximal::onChange(EStatusType type, const std::string &channelURI, bool proximal)
+{
+        if (!proximal)
+        {
+                return;
+        }
+
+        if (type < BEGIN_ERROR_STATUS)
+        {
+                handleStatusChange(type);
+        }
+        else
+        {
+                handleError(type);
+        }
+}
+
+void LLVoiceChannelProximal::handleStatusChange(EStatusType status)
+{
+        // status updates
+        switch(status)
+        {
+        case STATUS_LEFT_CHANNEL:
+                // do not notify user when leaving proximal channel
+                return;
+        default:
+                break;
+        }
+        LLVoiceChannel::handleStatusChange(status);
+}
+
+
+void LLVoiceChannelProximal::handleError(EStatusType status)
+{
+        std::string notify;
+        switch(status)
+        {
+          case ERROR_CHANNEL_LOCKED:
+          case ERROR_CHANNEL_FULL:
+                notify = "ProximalVoiceChannelFull";
+                break;
+          default:
+                 break;
+        }
+
+        // notification
+        if (!notify.empty())
+        {
+                LLNotifyBox::showXml(notify, mNotifyArgs);
+        }
+
+        LLVoiceChannel::handleError(status);
+}
+
+void LLVoiceChannelProximal::deactivate()
+{
+        if (callStarted())
+        {
+                setState(STATE_HUNG_UP);
+        }
+}
+
 //
+// LLVoiceChannelP2P
+//
+LLVoiceChannelP2P::LLVoiceChannelP2P(const LLUUID& session_id, const LLString& session_name, const LLUUID& other_user_id) : 
+                LLVoiceChannelGroup(session_id, session_name), 
+                mOtherUserID(other_user_id)
+{
+        // make sure URI reflects encoded version of other user's agent id
+        setURI(LLVoiceClient::getInstance()->sipURIFromID(other_user_id));
+}
+
+LLVoiceChannelP2P::~LLVoiceChannelP2P() 
+{
+        deactivate();
+}
+
+void LLVoiceChannelP2P::handleStatusChange(EStatusType type)
+{
+        // status updates
+        switch(type)
+        {
+        case STATUS_LEFT_CHANNEL:
+                if (callStarted() && !mIgnoreNextSessionLeave)
+                {
+                        if (mState == STATE_RINGING)
+                        {
+                                // other user declined call
+                                LLNotifyBox::showXml("P2PCallDeclined", mNotifyArgs);
+                        }
+                        else
+                        {
+                                // other user hung up
+                                LLNotifyBox::showXml("VoiceChannelDisconnectedP2P", mNotifyArgs);
+                        }
+                        deactivate();
+                }
+                mIgnoreNextSessionLeave = FALSE;
+                return;
+        default:
+                break;
+        }
+
+        LLVoiceChannelGroup::handleStatusChange(type);
+}
+
+void LLVoiceChannelP2P::handleError(EStatusType type)
+{
+        switch(type)
+        {
+        case ERROR_NOT_AVAILABLE:
+                LLNotifyBox::showXml("P2PCallNoAnswer", mNotifyArgs);
+                break;
+        default:
+                break;
+        }
+
+        LLVoiceChannelGroup::handleError(type);
+}
+
+void LLVoiceChannelP2P::activate()
+{
+        if (callStarted()) return;
 
-LLFloaterIMPanel::LLFloaterIMPanel(const std::string& name,
-                                                                   const LLRect& rect,
-                                                                   const std::string& session_label,
-                                                                   const LLUUID& session_id,
-                                                                   const LLUUID& other_participant_id,
-                                                                   EInstantMessage dialog) :
+        LLVoiceChannel::activate();
+
+        if (callStarted())
+        {
+                // no session handle yet, we're starting the call
+                if (mSessionHandle.empty())
+                {
+                        LLVoiceClient::getInstance()->callUser(mOtherUserID);
+                }
+                // otherwise answering the call
+                else
+                {
+                        LLVoiceClient::getInstance()->answerInvite(mSessionHandle, mOtherUserID);
+                        // using the session handle invalidates it.  Clear it out here so we can't reuse it by accident.
+                        mSessionHandle.clear();
+                }
+        }
+}
+
+void LLVoiceChannelP2P::getChannelInfo()
+{
+        // pretend we have everything we need, since P2P doesn't use channel info
+        if (sCurrentVoiceChannel == this)
+        {
+                setState(STATE_CALL_STARTED);
+        }
+}
+
+// receiving session from other user who initiated call
+void LLVoiceChannelP2P::setSessionHandle(const LLString& handle)
+{ 
+        BOOL needs_activate = FALSE;
+        if (callStarted())
+        {
+                // defer to lower agent id when already active
+                if (mOtherUserID < gAgent.getID())
+                {
+                        // pretend we haven't started the call yet, so we can connect to this session instead
+                        deactivate();
+                        needs_activate = TRUE;
+                }
+                else
+                {
+                        // we are active and have priority, invite the other user again
+                        // under the assumption they will join this new session
+                        mSessionHandle.clear();
+                        LLVoiceClient::getInstance()->callUser(mOtherUserID);
+                        return;
+                }
+        }
+
+        mSessionHandle = handle;
+        // The URI of a p2p session should always be the other end's SIP URI.
+        setURI(LLVoiceClient::getInstance()->sipURIFromID(mOtherUserID));
+        
+        if (needs_activate)
+        {
+                activate();
+        }
+}
+
+//
+// LLFloaterIMPanel
+//
+LLFloaterIMPanel::LLFloaterIMPanel(
+        const std::string& name,
+        const LLRect& rect,
+        const std::string& session_label,
+        const LLUUID& session_id,
+        const LLUUID& other_participant_id,
+        EInstantMessage dialog) :
         LLFloater(name, rect, session_label),
         mInputEditor(NULL),
         mHistoryEditor(NULL),
         mSessionUUID(session_id),
-        mSessionInitRequested(FALSE),
+        mVoiceChannel(NULL),
         mSessionInitialized(FALSE),
+
         mOtherParticipantUUID(other_participant_id),
         mDialog(dialog),
         mTyping(FALSE),
         mOtherTyping(FALSE),
         mTypingLineStartIndex(0),
         mSentTypingState(TRUE),
+        mShowSpeakersOnConnect(TRUE),
+        mAutoConnect(FALSE),
+        mSpeakerPanel(NULL),
         mFirstKeystrokeTimer(),
         mLastKeystrokeTimer()
 {
         init(session_label);
 }
 
-LLFloaterIMPanel::LLFloaterIMPanel(const std::string& name,
-                                                                   const LLRect& rect,
-                                                                   const std::string& session_label,
-                                                                   const LLUUID& session_id,
-                                                                   const LLUUID& other_participant_id,
-                                                                   const LLDynamicArray<LLUUID>& ids,
-                                                                   EInstantMessage dialog) :
+LLFloaterIMPanel::LLFloaterIMPanel(
+        const std::string& name,
+        const LLRect& rect,
+        const std::string& session_label,
+        const LLUUID& session_id,
+        const LLUUID& other_participant_id,
+        const LLDynamicArray<LLUUID>& ids,
+        EInstantMessage dialog) :
         LLFloater(name, rect, session_label),
         mInputEditor(NULL),
         mHistoryEditor(NULL),
         mSessionUUID(session_id),
-        mSessionInitRequested(FALSE),
+        mVoiceChannel(NULL),
         mSessionInitialized(FALSE),
         mOtherParticipantUUID(other_participant_id),
         mDialog(dialog),
@@ -207,6 +841,10 @@ LLFloaterIMPanel::LLFloaterIMPanel(const std::string& name,
         mOtherTyping(FALSE),
         mTypingLineStartIndex(0),
         mSentTypingState(TRUE),
+        mShowSpeakersOnConnect(TRUE),
+        mAutoConnect(FALSE),
+        mSpeakers(NULL),
+        mSpeakerPanel(NULL),
         mFirstKeystrokeTimer(),
         mLastKeystrokeTimer()
 {
@@ -217,11 +855,53 @@ LLFloaterIMPanel::LLFloaterIMPanel(const std::string& name,
 
 void LLFloaterIMPanel::init(const LLString& session_label)
 {
+        LLString xml_filename;
+        switch(mDialog)
+        {
+        case IM_SESSION_GROUP_START:
+                mFactoryMap["active_speakers_panel"] = LLCallbackMap(createSpeakersPanel, this);
+                xml_filename = "floater_instant_message_group.xml";
+                mVoiceChannel = new LLVoiceChannelGroup(mSessionUUID, session_label);
+                break;
+        case IM_SESSION_INVITE:
+                mFactoryMap["active_speakers_panel"] = LLCallbackMap(createSpeakersPanel, this);
+                if (gAgent.isInGroup(mSessionUUID))
+                {
+                        xml_filename = "floater_instant_message_group.xml";
+                }
+                else // must be invite to ad hoc IM
+                {
+                        xml_filename = "floater_instant_message_ad_hoc.xml";
+                }
+                mVoiceChannel = new LLVoiceChannelGroup(mSessionUUID, session_label);
+                break;
+        case IM_SESSION_P2P_INVITE:
+                xml_filename = "floater_instant_message.xml";
+                mVoiceChannel = new LLVoiceChannelP2P(mSessionUUID, session_label, mOtherParticipantUUID);
+                break;
+        case IM_SESSION_CONFERENCE_START:
+                mFactoryMap["active_speakers_panel"] = LLCallbackMap(createSpeakersPanel, this);
+                xml_filename = "floater_instant_message_ad_hoc.xml";
+                mVoiceChannel = new LLVoiceChannelGroup(mSessionUUID, session_label);
+                break;
+        // just received text from another user
+        case IM_NOTHING_SPECIAL:
+                xml_filename = "floater_instant_message.xml";
+                mVoiceChannel = new LLVoiceChannelP2P(mSessionUUID, session_label, mOtherParticipantUUID);
+                break;
+        default:
+                llwarns << "Unknown session type" << llendl;
+                xml_filename = "floater_instant_message.xml";
+                break;
+        }
+
+        mSpeakers = new LLIMSpeakerMgr(mVoiceChannel);
+
         gUICtrlFactory->buildFloater(this,
-                                     "floater_instant_message.xml",
-                                     NULL,
-                                     FALSE);
-        
+                                                                xml_filename,
+                                                                &getFactoryMap(),
+                                                                FALSE);
+
         setLabel(session_label);
         setTitle(session_label);
         mInputEditor->setMaxTextLength(1023);
@@ -256,21 +936,32 @@ void LLFloaterIMPanel::init(const LLString& session_label)
                         mSessionStartMsgPos = 
                                 mHistoryEditor->getText().length();
 
-                        bool log_to_file = false;
                         addHistoryLine(
                                 session_start,
-                                LLColor4::grey,
-                                log_to_file);
+                                gSavedSettings.getColor4("SystemChatColor"),
+                                false);
                 }
         }
 }
 
 
+LLFloaterIMPanel::~LLFloaterIMPanel()
+{
+        delete mSpeakers;
+        mSpeakers = NULL;
+
+        //kicks you out of the voice channel if it is currently active
+
+        // 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;
+}
+
 BOOL LLFloaterIMPanel::postBuild() 
 {
         requires("chat_editor", WIDGET_TYPE_LINE_EDITOR);
-        requires("profile_btn", WIDGET_TYPE_BUTTON);
-        requires("close_btn", WIDGET_TYPE_BUTTON);
         requires("im_history", WIDGET_TYPE_TEXT_EDITOR);
         requires("live_help_dialog", WIDGET_TYPE_TEXT_BOX);
         requires("title_string", WIDGET_TYPE_TEXT_BOX);
@@ -283,22 +974,28 @@ BOOL LLFloaterIMPanel::postBuild()
                 mInputEditor->setFocusReceivedCallback( onInputEditorFocusReceived );
                 mInputEditor->setFocusLostCallback( onInputEditorFocusLost );
                 mInputEditor->setKeystrokeCallback( onInputEditorKeystroke );
+                mInputEditor->setCommitCallback( onCommitChat );
                 mInputEditor->setCallbackUserData(this);
                 mInputEditor->setCommitOnFocusLost( FALSE );
                 mInputEditor->setRevertOnEsc( FALSE );
 
-                LLButton* profile_btn = LLUICtrlFactory::getButtonByName(this, "profile_btn");
-                profile_btn->setClickedCallback(&LLFloaterIMPanel::onClickProfile, this);
+                childSetAction("profile_callee_btn", onClickProfile, this);
+                childSetAction("group_info_btn", onClickGroupInfo, this);
+
+                childSetAction("start_call_btn", onClickStartCall, this);
+                childSetAction("end_call_btn", onClickEndCall, this);
+                childSetAction("send_btn", onClickSend, this);
+                childSetAction("toggle_active_speakers_btn", onClickToggleActiveSpeakers, this);
 
-                LLButton* close_btn = LLUICtrlFactory::getButtonByName(this, "close_btn");
-                close_btn->setClickedCallback(&LLFloaterIMPanel::onClickClose, this);
+                //LLButton* close_btn = LLUICtrlFactory::getButtonByName(this, "close_btn");
+                //close_btn->setClickedCallback(&LLFloaterIMPanel::onClickClose, this);
 
                 mHistoryEditor = LLViewerUICtrlFactory::getViewerTextEditorByName(this, "im_history");
                 mHistoryEditor->setParseHTML(TRUE);
 
-                if (IM_SESSION_GROUP_START == mDialog)
+                if ( IM_SESSION_GROUP_START == mDialog )
                 {
-                        profile_btn->setEnabled(FALSE);
+                        childSetEnabled("profile_btn", FALSE);
                 }
                 LLTextBox* title = LLUICtrlFactory::getTextBoxByName(this, "title_string");
                 sTitleString = title->getText();
@@ -311,16 +1008,91 @@ BOOL LLFloaterIMPanel::postBuild()
                         this,
                         "session_start_string");
                 sSessionStartString = session_start->getText();
+                if (mSpeakerPanel)
+                {
+                        mSpeakerPanel->refreshSpeakers();
+                }
 
+                if (mDialog == IM_NOTHING_SPECIAL)
+                {
+                        childSetCommitCallback("mute_btn", onClickMuteVoice, this);
+                        childSetCommitCallback("speaker_volume", onVolumeChange, this);
+                }
+
+                setDefaultBtn("send_btn");
                 return TRUE;
         }
 
         return FALSE;
 }
 
+void* LLFloaterIMPanel::createSpeakersPanel(void* data)
+{
+        LLFloaterIMPanel* floaterp = (LLFloaterIMPanel*)data;
+        floaterp->mSpeakerPanel = new LLPanelActiveSpeakers(floaterp->mSpeakers, TRUE);
+        return floaterp->mSpeakerPanel;
+}
+
+//static 
+void LLFloaterIMPanel::onClickMuteVoice(LLUICtrl* source, void* user_data)
+{
+        LLFloaterIMPanel* floaterp = (LLFloaterIMPanel*)user_data;
+        if (floaterp)
+        {
+                BOOL is_muted = gMuteListp->isMuted(floaterp->mOtherParticipantUUID, LLMute::flagVoiceChat);
+
+                LLMute mute(floaterp->mOtherParticipantUUID, floaterp->getTitle(), LLMute::AGENT);
+                if (!is_muted)
+                {
+                        gMuteListp->add(mute, LLMute::flagVoiceChat);
+                }
+                else
+                {
+                        gMuteListp->remove(mute, LLMute::flagVoiceChat);
+                }
+        }
+}
+
+//static 
+void LLFloaterIMPanel::onVolumeChange(LLUICtrl* source, void* user_data)
+{
+        LLFloaterIMPanel* floaterp = (LLFloaterIMPanel*)user_data;
+        if (floaterp)
+        {
+                gVoiceClient->setUserVolume(floaterp->mOtherParticipantUUID, (F32)source->getValue().asReal());
+        }
+}
+
+
 // virtual
 void LLFloaterIMPanel::draw()
-{
+{       
+        LLViewerRegion* region = gAgent.getRegion();
+        
+        BOOL enable_connect = (region && region->getCapability("ChatSessionRequest") != "")
+                                          && mSessionInitialized
+                                          && LLVoiceClient::voiceEnabled();
+
+        // hide/show start call and end call buttons
+        childSetVisible("end_call_btn", mVoiceChannel->getState() >= LLVoiceChannel::STATE_CALL_STARTED);
+        childSetVisible("start_call_btn", mVoiceChannel->getState() < LLVoiceChannel::STATE_CALL_STARTED);
+        childSetEnabled("start_call_btn", enable_connect);
+        childSetEnabled("send_btn", !childGetValue("chat_editor").asString().empty());
+
+        if (mAutoConnect && enable_connect)
+        {
+                onClickStartCall(this);
+                mAutoConnect = FALSE;
+        }
+
+        // show speakers window when voice first connects
+        if (mShowSpeakersOnConnect && mVoiceChannel->isActive())
+        {
+                childSetVisible("active_speakers_panel", TRUE);
+                mShowSpeakersOnConnect = FALSE;
+        }
+        childSetValue("toggle_active_speakers_btn", childIsVisible("active_speakers_panel"));
+
         if (mTyping)
         {
                 // Time out if user hasn't typed for a while.
@@ -339,6 +1111,19 @@ void LLFloaterIMPanel::draw()
                 }
         }
 
+        if (mSpeakerPanel)
+        {
+                mSpeakerPanel->refreshSpeakers();
+        }
+        else
+        {
+                // refresh volume and mute checkbox
+                childSetEnabled("speaker_volume", mVoiceChannel->isActive());
+                childSetValue("speaker_volume", gVoiceClient->getUserVolume(mOtherParticipantUUID));
+
+                childSetValue("mute_btn", gMuteListp->isMuted(mOtherParticipantUUID, LLMute::flagVoiceChat));
+                childSetEnabled("mute_btn", mVoiceChannel->isActive());
+        }
         LLFloater::draw();
 }
 
@@ -363,16 +1148,22 @@ private:
 
 BOOL LLFloaterIMPanel::inviteToSession(const LLDynamicArray<LLUUID>& ids)
 {
+        LLViewerRegion* region = gAgent.getRegion();
+        if (!region)
+        {
+                return FALSE;
+        }
+        
         S32 count = ids.count();
 
-        if( isAddAllowed() && (count > 0) )
+        if( isInviteAllowed() && (count > 0) )
         {
-                llinfos << "LLFloaterIMPanel::inviteToSession() - adding participants" << llendl;
+                llinfos << "LLFloaterIMPanel::inviteToSession() - inviting participants" << llendl;
 
-                std::string url =
-                        gAgent.getRegion()->getCapability("ChatSessionRequest");
+                std::string url = region->getCapability("ChatSessionRequest");
 
                 LLSD data;
+
                 data["params"] = LLSD::emptyArray();
                 for (int i = 0; i < count; i++)
                 {
@@ -399,6 +1190,13 @@ BOOL LLFloaterIMPanel::inviteToSession(const LLDynamicArray<LLUUID>& ids)
         return TRUE;
 }
 
+void LLFloaterIMPanel::addHistoryLine(const LLUUID& source, const std::string &utf8msg, const LLColor4& color, bool log_to_file)
+{
+        addHistoryLine(utf8msg, color, log_to_file);
+        mSpeakers->speakerChatted(source);
+        mSpeakers->setSpeakerTyping(source, FALSE);
+}
+
 void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, const LLColor4& color, bool log_to_file)
 {
         LLMultiFloater* hostp = getHost();
@@ -412,7 +1210,7 @@ void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, const LLColor4
         // Now we're adding the actual line of text, so erase the 
         // "Foo is typing..." text segment, and the optional timestamp
         // if it was present. JC
-        removeTypingIndicator();
+        removeTypingIndicator(NULL);
 
         // Actually add the line
         LLString timestring;
@@ -491,7 +1289,7 @@ BOOL LLFloaterIMPanel::handleKeyHere( KEY key, MASK mask, BOOL called_from_paren
                         // but not shift-return or control-return
                         if ( !gSavedSettings.getBOOL("PinTalkViewOpen") && !(mask & MASK_CONTROL) && !(mask & MASK_SHIFT) )
                         {
-                                gIMView->toggle(NULL);
+                                gIMMgr->toggle(NULL);
                         }
                 }
                 else if ( KEY_ESCAPE == key )
@@ -502,7 +1300,7 @@ BOOL LLFloaterIMPanel::handleKeyHere( KEY key, MASK mask, BOOL called_from_paren
                         // Close talk panel with escape
                         if( !gSavedSettings.getBOOL("PinTalkViewOpen") )
                         {
-                                gIMView->toggle(NULL);
+                                gIMMgr->toggle(NULL);
                         }
                 }
         }
@@ -543,7 +1341,7 @@ BOOL LLFloaterIMPanel::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 
 BOOL LLFloaterIMPanel::dropCallingCard(LLInventoryItem* item, BOOL drop)
 {
-        BOOL rv = isAddAllowed();
+        BOOL rv = isInviteAllowed();
         if(rv && item && item->getCreatorUUID().notNull())
         {
                 if(drop)
@@ -563,7 +1361,7 @@ BOOL LLFloaterIMPanel::dropCallingCard(LLInventoryItem* item, BOOL drop)
 
 BOOL LLFloaterIMPanel::dropCategory(LLInventoryCategory* category, BOOL drop)
 {
-        BOOL rv = isAddAllowed();
+        BOOL rv = isInviteAllowed();
         if(rv && category)
         {
                 LLInventoryModel::cat_array_t cats;
@@ -592,11 +1390,11 @@ BOOL LLFloaterIMPanel::dropCategory(LLInventoryCategory* category, BOOL drop)
         return rv;
 }
 
-BOOL LLFloaterIMPanel::isAddAllowed() const
+BOOL LLFloaterIMPanel::isInviteAllowed() const
 {
 
-        return ((IM_SESSION_CONFERENCE_START == mDialog) 
-                        || (IM_SESSION_INVITE) );
+        return ( (IM_SESSION_CONFERENCE_START == mDialog) 
+                         || (IM_SESSION_INVITE == mDialog) );
 }
 
 
@@ -621,6 +1419,15 @@ void LLFloaterIMPanel::onClickProfile( void* userdata )
 }
 
 // static
+void LLFloaterIMPanel::onClickGroupInfo( void* userdata )
+{
+        //  Bring up the Profile window
+        LLFloaterIMPanel* self = (LLFloaterIMPanel*) userdata;
+
+        LLFloaterGroupInfo::showFromUUID(self->mSessionUUID);
+}
+
+// static
 void LLFloaterIMPanel::onClickClose( void* userdata )
 {
         LLFloaterIMPanel* self = (LLFloaterIMPanel*) userdata;
@@ -631,6 +1438,44 @@ void LLFloaterIMPanel::onClickClose( void* userdata )
 }
 
 // static
+void LLFloaterIMPanel::onClickStartCall(void* userdata)
+{
+        LLFloaterIMPanel* self = (LLFloaterIMPanel*) userdata;
+
+        self->mVoiceChannel->activate();
+}
+
+// static
+void LLFloaterIMPanel::onClickEndCall(void* userdata)
+{
+        LLFloaterIMPanel* self = (LLFloaterIMPanel*) userdata;
+
+        self->getVoiceChannel()->deactivate();
+}
+
+// static
+void LLFloaterIMPanel::onClickSend(void* userdata)
+{
+        LLFloaterIMPanel* self = (LLFloaterIMPanel*)userdata;
+        self->sendMsg();
+}
+
+// static
+void LLFloaterIMPanel::onClickToggleActiveSpeakers(void* userdata)
+{
+        LLFloaterIMPanel* self = (LLFloaterIMPanel*)userdata;
+
+        self->childSetVisible("active_speakers_panel", !self->childIsVisible("active_speakers_panel"));
+}
+
+// static
+void LLFloaterIMPanel::onCommitChat(LLUICtrl* caller, void* userdata)
+{
+        LLFloaterIMPanel* self= (LLFloaterIMPanel*) userdata;
+        self->sendMsg();
+}
+
+// static
 void LLFloaterIMPanel::onInputEditorFocusReceived( LLUICtrl* caller, void* userdata )
 {
         LLFloaterIMPanel* self= (LLFloaterIMPanel*) userdata;
@@ -681,7 +1526,7 @@ void LLFloaterIMPanel::onClose(bool app_quitting)
                         mSessionUUID);
                 gAgent.sendReliableMessage();
         }
-        gIMView->removeSession(mSessionUUID);
+        gIMMgr->removeSession(mSessionUUID);
 
         destroy();
 }
@@ -768,11 +1613,22 @@ void LLFloaterIMPanel::sendMsg()
                                         history_echo += ": ";
                                 }
                                 history_echo += utf8_text;
-                                addHistoryLine(history_echo);
+
+                                BOOL other_was_typing = mOtherTyping;
+
+                                addHistoryLine(gAgent.getID(), history_echo);
+
+                                if (other_was_typing) 
+                                {
+                                        addTypingIndicator(mOtherTypingName);
+                                }
+
                         }
                 }
                 else
                 {
+                        //queue up the message to send once the session is
+                        //initialized
                         mQueuedMsgsForInit.append(utf8_text);
                 }
 
@@ -786,15 +1642,31 @@ void LLFloaterIMPanel::sendMsg()
         mSentTypingState = TRUE;
 }
 
+void LLFloaterIMPanel::updateSpeakersList(LLSD speaker_updates)
+{ 
+        mSpeakers->processSpeakerListUpdate(speaker_updates); 
+}
+
+void LLFloaterIMPanel::setSpeakersListFromMap(LLSD speaker_map)
+{
+        mSpeakers->processSpeakerMap(speaker_map);
+}
+
+void LLFloaterIMPanel::setSpeakersList(LLSD speaker_list)
+{
+        mSpeakers->processSpeakerList(speaker_list);
+}
+
 void LLFloaterIMPanel::sessionInitReplyReceived(const LLUUID& session_id)
 {
         mSessionUUID = session_id;
+        mVoiceChannel->updateSessionID(session_id);
         mSessionInitialized = TRUE;
 
         //we assume the history editor hasn't moved at all since
         //we added the starting session message
         //so, we count how many characters to remove
-        S32 chars_to_remove = mHistoryEditor->getText().length() - 
+        S32 chars_to_remove = mHistoryEditor->getText().length() -
                 mSessionStartMsgPos;
         mHistoryEditor->removeTextFromEnd(chars_to_remove);
 
@@ -804,13 +1676,18 @@ void LLFloaterIMPanel::sessionInitReplyReceived(const LLUUID& session_id)
                   iter != mQueuedMsgsForInit.endArray();
                   ++iter)
         {
-                deliver_message(iter->asString(),
-                                                mSessionUUID,
-                                                mOtherParticipantUUID,
-                                                mDialog);
+                deliver_message(
+                        iter->asString(),
+                        mSessionUUID,
+                        mOtherParticipantUUID,
+                        mDialog);
         }
 }
 
+void LLFloaterIMPanel::requestAutoConnect()
+{
+        mAutoConnect = TRUE;
+}
 
 void LLFloaterIMPanel::setTyping(BOOL typing)
 {
@@ -827,6 +1704,8 @@ void LLFloaterIMPanel::setTyping(BOOL typing)
                         // Will send typing state after a short delay.
                         mSentTypingState = FALSE;
                 }
+
+                mSpeakers->setSpeakerTyping(gAgent.getID(), TRUE);
         }
         else
         {
@@ -836,6 +1715,7 @@ void LLFloaterIMPanel::setTyping(BOOL typing)
                         sendTypingState(FALSE);
                         mSentTypingState = TRUE;
                 }
+                mSpeakers->setSpeakerTyping(gAgent.getID(), FALSE);
         }
 
         mTyping = typing;
@@ -864,35 +1744,40 @@ void LLFloaterIMPanel::sendTypingState(BOOL typing)
         gAgent.sendReliableMessage();
 }
 
-
 void LLFloaterIMPanel::processIMTyping(const LLIMInfo* im_info, BOOL typing)
 {
         if (typing)
         {
                 // other user started typing
-                addTypingIndicator(im_info);
+                addTypingIndicator(im_info->mName);
         }
         else
         {
                 // other user stopped typing
-                removeTypingIndicator();
+                removeTypingIndicator(im_info);
         }
 }
 
 
-void LLFloaterIMPanel::addTypingIndicator(const LLIMInfo* im_info)
+void LLFloaterIMPanel::addTypingIndicator(const std::string &name)
 {
-        mTypingLineStartIndex = mHistoryEditor->getText().length();
-
-        LLUIString typing_start = sTypingStartString;
-        typing_start.setArg("[NAME]", im_info->mName);
-        bool log_to_file = false;
-        addHistoryLine(typing_start, LLColor4::grey, log_to_file);
-        mOtherTyping = TRUE;
+        // we may have lost a "stop-typing" packet, don't add it twice
+        if (!mOtherTyping)
+        {
+                mTypingLineStartIndex = mHistoryEditor->getText().length();
+                LLUIString typing_start = sTypingStartString;
+                typing_start.setArg("[NAME]", name);
+                addHistoryLine(typing_start, gSavedSettings.getColor4("SystemChatColor"), false);
+                mOtherTypingName = name;
+                mOtherTyping = TRUE;
+        }
+        // MBW -- XXX -- merge from release broke this (argument to this function changed from an LLIMInfo to a name)
+        // Richard will fix.
+//      mSpeakers->setSpeakerTyping(im_info->mFromID, TRUE);
 }
 
 
-void LLFloaterIMPanel::removeTypingIndicator()
+void LLFloaterIMPanel::removeTypingIndicator(const LLIMInfo* im_info)
 {
         if (mOtherTyping)
         {
@@ -901,6 +1786,10 @@ void LLFloaterIMPanel::removeTypingIndicator()
 
                 S32 chars_to_remove = mHistoryEditor->getText().length() - mTypingLineStartIndex;
                 mHistoryEditor->removeTextFromEnd(chars_to_remove);
+                if (im_info)
+                {
+                        mSpeakers->setSpeakerTyping(im_info->mFromID, FALSE);
+                }
         }
 }
 
@@ -913,4 +1802,3 @@ void LLFloaterIMPanel::chatFromLogFile(LLString line, void* userdata)
         self->mHistoryEditor->appendColoredText(line, false, true, LLColor4::grey);
 
 }
-