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

CHUI-337 FIXED: To avoid confusion with a classes "...conversation..." and in accordance with the naming convention in the project, some classes and corresponding files should be renamed: 

LLIMConversation -> LLFloaterIMSessionTab
LLIMFloater -> LLFloaterIMSession
LLNearbyChat -> LLFloaterIMNearbyChat
LLIMFloaterContainer -> LLFloaterIMContainer
LLNearbyChatBarListener -> LLFloaterIMNearbyChatListener
LLNearbyChatHandler -> LLFloaterIMNearbyChatHandler
master
AlexanderP ProductEngine 2012-11-09 12:45:36 +02:00
parent 3d70cca702
commit 486bdf3284
54 changed files with 600 additions and 600 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
indra/newview/CMakeLists.txt
View File

@ -299,9 +299,9 @@ set(viewer_SOURCE_FILES
llhudrender.cpp
llhudtext.cpp
llhudview.cpp
llimconversation.cpp
llimfloater.cpp
llimfloatercontainer.cpp
llfloaterimsessiontab.cpp
llfloaterimsession.cpp
llfloaterimcontainer.cpp
llimhandler.cpp
llimview.cpp
llinspect.cpp
@ -353,9 +353,9 @@ set(viewer_SOURCE_FILES
llnameeditor.cpp
llnamelistctrl.cpp
llnavigationbar.cpp
llnearbychat.cpp
llnearbychathandler.cpp
llnearbychatbarlistener.cpp
llfloaterimnearbychat.cpp
llfloaterimnearbychathandler.cpp
llfloaterimnearbychatlistener.cpp
llnetmap.cpp
llnotificationalerthandler.cpp
llnotificationgrouphandler.cpp
@ -882,9 +882,9 @@ set(viewer_HEADER_FILES
llhudrender.h
llhudtext.h
llhudview.h
llimconversation.h
llimfloater.h
llimfloatercontainer.h
llfloaterimsessiontab.h
llfloaterimsession.h
llfloaterimcontainer.h
llimview.h
llinspect.h
llinspectavatar.h
@ -936,9 +936,9 @@ set(viewer_HEADER_FILES
llnameeditor.h
llnamelistctrl.h
llnavigationbar.h
llnearbychat.h
llnearbychathandler.h
llnearbychatbarlistener.h
llfloaterimnearbychat.h
llfloaterimnearbychathandler.h
llfloaterimnearbychatlistener.h
llnetmap.h
llnotificationhandler.h
llnotificationmanager.h

6
indra/newview/llagent.cpp
View File

@ -54,7 +54,7 @@
#include "llmorphview.h"
#include "llmoveview.h"
#include "llnavigationbar.h" // to show/hide navigation bar when changing mouse look state
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llnotificationsutil.h"
#include "llpanelpathfindingrebakenavmesh.h"
#include "llpaneltopinfobar.h"
@ -1899,7 +1899,7 @@ void LLAgent::startTyping()
{
sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_START);
}
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
sendChatFromViewer("", CHAT_TYPE_START, FALSE);
}
@ -1912,7 +1912,7 @@ void LLAgent::stopTyping()
{
clearRenderState(AGENT_STATE_TYPING);
sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_STOP);
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
sendChatFromViewer("", CHAT_TYPE_STOP, FALSE);
}
}

4
indra/newview/llappviewer.cpp
View File

@ -42,7 +42,7 @@
#include "llagentcamera.h"
#include "llagentlanguage.h"
#include "llagentwearables.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llwindow.h"
#include "llviewerstats.h"
#include "llviewerstatsrecorder.h"
@ -1204,7 +1204,7 @@ bool LLAppViewer::mainLoop()
LLVoiceChannel::initClass();
LLVoiceClient::getInstance()->init(gServicePump);
LLVoiceChannel::setCurrentVoiceChannelChangedCallback(boost::bind(&LLIMFloaterContainer::onCurrentChannelChanged, _1), true);
LLVoiceChannel::setCurrentVoiceChannelChangedCallback(boost::bind(&LLFloaterIMContainer::onCurrentChannelChanged, _1), true);
LLTimer frameTimer,idleTimer;
LLTimer debugTime;
LLViewerJoystick* joystick(LLViewerJoystick::getInstance());

6
indra/newview/llavataractions.cpp
View File

@ -56,7 +56,7 @@
#include "llinventorybridge.h"
#include "llinventorymodel.h" // for gInventory.findCategoryUUIDForType
#include "llinventorypanel.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llimview.h" // for gIMMgr
#include "llmutelist.h"
#include "llnotificationsutil.h" // for LLNotificationsUtil
@ -184,7 +184,7 @@ static void on_avatar_name_cache_start_im(const LLUUID& agent_id,
LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id);
if (session_id != LLUUID::null)
{
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
}
make_ui_sound("UISndStartIM");
}
@ -302,7 +302,7 @@ void LLAvatarActions::startConference(const uuid_vec_t& ids, const LLUUID& float
return;
}
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
make_ui_sound("UISndStartIM");
}

2
indra/newview/llavatariconctrl.cpp
View File

@ -38,7 +38,7 @@
#include "llmenugl.h"
#include "lluictrlfactory.h"
#include "llagentdata.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
// library includes
#include "llavatarnamecache.h"

2
indra/newview/llchatbar.cpp
View File

@ -672,7 +672,7 @@ void LLChatBar::onCommitGesture(LLUICtrl* ctrl)
/* Cruft - global gChatHandler declared below has been commented out,
so this class is never used. See similar code in llnearbychatbar.cpp
so this class is never used. See similar code in llfloaterimnearbychatbar.cpp
class LLChatHandler : public LLCommandHandler
{
public:

38
indra/newview/llchatitemscontainerctrl.cpp
View File

@ -35,7 +35,7 @@
#include "llfloaterreg.h"
#include "lllocalcliprect.h"
#include "lltrans.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llviewercontrol.h"
#include "llagentdata.h"
@ -81,18 +81,18 @@ public:
LLObjectHandler gObjectHandler;
//*******************************************************************************************************************
//LLNearbyChatToastPanel
//LLFloaterIMNearbyChatToastPanel
//*******************************************************************************************************************
LLNearbyChatToastPanel* LLNearbyChatToastPanel::createInstance()
LLFloaterIMNearbyChatToastPanel* LLFloaterIMNearbyChatToastPanel::createInstance()
{
LLNearbyChatToastPanel* item = new LLNearbyChatToastPanel();
LLFloaterIMNearbyChatToastPanel* item = new LLFloaterIMNearbyChatToastPanel();
item->buildFromFile("panel_chat_item.xml");
item->setFollows(FOLLOWS_NONE);
return item;
}
void LLNearbyChatToastPanel::reshape (S32 width, S32 height, BOOL called_from_parent )
void LLFloaterIMNearbyChatToastPanel::reshape (S32 width, S32 height, BOOL called_from_parent )
{
LLPanel::reshape(width, height,called_from_parent);
@ -121,12 +121,12 @@ void LLNearbyChatToastPanel::reshape (S32 width, S32 height, BOOL called_from_p
msg_text->setRect(msg_text_rect);
}
BOOL LLNearbyChatToastPanel::postBuild()
BOOL LLFloaterIMNearbyChatToastPanel::postBuild()
{
return LLPanel::postBuild();
}
void LLNearbyChatToastPanel::addMessage(LLSD& notification)
void LLFloaterIMNearbyChatToastPanel::addMessage(LLSD& notification)
{
std::string messageText = notification["message"].asString(); // UTF-8 line of text
@ -178,7 +178,7 @@ void LLNearbyChatToastPanel::addMessage(LLSD& notification)
}
void LLNearbyChatToastPanel::init(LLSD& notification)
void LLFloaterIMNearbyChatToastPanel::init(LLSD& notification)
{
std::string messageText = notification["message"].asString(); // UTF-8 line of text
std::string fromName = notification["from"].asString(); // agent or object name
@ -273,7 +273,7 @@ void LLNearbyChatToastPanel::init(LLSD& notification)
mIsDirty = true;//will set Avatar Icon in draw
}
void LLNearbyChatToastPanel::snapToMessageHeight ()
void LLFloaterIMNearbyChatToastPanel::snapToMessageHeight ()
{
LLChatMsgBox* text_box = getChild<LLChatMsgBox>("msg_text", false);
S32 new_height = llmax (text_box->getTextPixelHeight() + 2*text_box->getVPad() + 2*msg_height_pad, 25);
@ -288,22 +288,22 @@ void LLNearbyChatToastPanel::snapToMessageHeight ()
}
void LLNearbyChatToastPanel::onMouseLeave (S32 x, S32 y, MASK mask)
void LLFloaterIMNearbyChatToastPanel::onMouseLeave (S32 x, S32 y, MASK mask)
{
}
void LLNearbyChatToastPanel::onMouseEnter (S32 x, S32 y, MASK mask)
void LLFloaterIMNearbyChatToastPanel::onMouseEnter (S32 x, S32 y, MASK mask)
{
if(mSourceType != CHAT_SOURCE_AGENT)
return;
}
BOOL LLNearbyChatToastPanel::handleMouseDown (S32 x, S32 y, MASK mask)
BOOL LLFloaterIMNearbyChatToastPanel::handleMouseDown (S32 x, S32 y, MASK mask)
{
return LLPanel::handleMouseDown(x,y,mask);
}
BOOL LLNearbyChatToastPanel::handleMouseUp (S32 x, S32 y, MASK mask)
BOOL LLFloaterIMNearbyChatToastPanel::handleMouseUp (S32 x, S32 y, MASK mask)
{
/*
fix for request EXT-4780
@ -323,16 +323,16 @@ BOOL LLNearbyChatToastPanel::handleMouseUp (S32 x, S32 y, MASK mask)
return TRUE;
else
{
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->showHistory();
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->showHistory();
return FALSE;
}
}
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->showHistory();
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->showHistory();
return LLPanel::handleMouseUp(x,y,mask);
}
void LLNearbyChatToastPanel::setHeaderVisibility(EShowItemHeader e)
void LLFloaterIMNearbyChatToastPanel::setHeaderVisibility(EShowItemHeader e)
{
LLUICtrl* icon = getChild<LLUICtrl>("avatar_icon", false);
if(icon)
@ -340,7 +340,7 @@ void LLNearbyChatToastPanel::setHeaderVisibility(EShowItemHeader e)
}
bool LLNearbyChatToastPanel::canAddText ()
bool LLFloaterIMNearbyChatToastPanel::canAddText ()
{
LLChatMsgBox* msg_text = findChild<LLChatMsgBox>("msg_text");
if(!msg_text)
@ -348,7 +348,7 @@ bool LLNearbyChatToastPanel::canAddText ()
return msg_text->getLineCount()<10;
}
BOOL LLNearbyChatToastPanel::handleRightMouseDown(S32 x, S32 y, MASK mask)
BOOL LLFloaterIMNearbyChatToastPanel::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
LLUICtrl* avatar_icon = getChild<LLUICtrl>("avatar_icon", false);
@ -360,7 +360,7 @@ BOOL LLNearbyChatToastPanel::handleRightMouseDown(S32 x, S32 y, MASK mask)
return TRUE;
return LLPanel::handleRightMouseDown(x,y,mask);
}
void LLNearbyChatToastPanel::draw()
void LLFloaterIMNearbyChatToastPanel::draw()
{
LLPanel::draw();

8
indra/newview/llchatitemscontainerctrl.h
View File

@ -40,18 +40,18 @@ typedef enum e_show_item_header
CHATITEMHEADER_SHOW_BOTH
} EShowItemHeader;
class LLNearbyChatToastPanel : public LLPanel
class LLFloaterIMNearbyChatToastPanel : public LLPanel
{
protected:
LLNearbyChatToastPanel()
LLFloaterIMNearbyChatToastPanel()
:
mIsDirty(false),
mSourceType(CHAT_SOURCE_OBJECT)
{};
public:
~LLNearbyChatToastPanel(){}
~LLFloaterIMNearbyChatToastPanel(){}
static LLNearbyChatToastPanel* createInstance();
static LLFloaterIMNearbyChatToastPanel* createInstance();
const LLUUID& getFromID() const { return mFromID;}
const std::string& getFromName() const { return mFromName; }

16
indra/newview/llchiclet.cpp
View File

@ -33,8 +33,8 @@
#include "lleventtimer.h"
#include "llgroupactions.h"
#include "lliconctrl.h"
#include "llimfloater.h"
#include "llimfloatercontainer.h"
#include "llfloaterimsession.h"
#include "llfloaterimcontainer.h"
#include "llimview.h"
#include "llfloaterreg.h"
#include "lllocalcliprect.h"
@ -605,7 +605,7 @@ bool LLIMChiclet::getShowNewMessagesIcon()
void LLIMChiclet::onMouseDown()
{
LLIMFloater::toggle(getSessionId());
LLFloaterIMSession::toggle(getSessionId());
setCounter(0);
}
@ -754,7 +754,7 @@ void LLIMP2PChiclet::updateMenuItems()
if(getSessionId().isNull())
return;
LLIMFloater* open_im_floater = LLIMFloater::findInstance(getSessionId());
LLFloaterIMSession* open_im_floater = LLFloaterIMSession::findInstance(getSessionId());
bool open_window_exists = open_im_floater && open_im_floater->getVisible();
mPopupMenu->getChild<LLUICtrl>("Send IM")->setEnabled(!open_window_exists);
@ -1030,7 +1030,7 @@ void LLIMGroupChiclet::updateMenuItems()
if(getSessionId().isNull())
return;
LLIMFloater* open_im_floater = LLIMFloater::findInstance(getSessionId());
LLFloaterIMSession* open_im_floater = LLFloaterIMSession::findInstance(getSessionId());
bool open_window_exists = open_im_floater && open_im_floater->getVisible();
mPopupMenu->getChild<LLUICtrl>("Chat")->setEnabled(!open_window_exists);
}
@ -1116,7 +1116,7 @@ void LLChicletPanel::onMessageCountChanged(const LLSD& data)
LLUUID session_id = data["session_id"].asUUID();
S32 unread = data["participant_unread"].asInteger();
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(session_id);
if (im_floater && im_floater->getVisible() && im_floater->hasFocus())
{
unread = 0;
@ -1197,7 +1197,7 @@ void LLChicletPanel::onCurrentVoiceChannelChanged(const LLUUID& session_id)
chiclet->setShowSpeaker(true);
if (gSavedSettings.getBOOL("OpenIMOnVoice"))
{
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
}
}
}
@ -1688,7 +1688,7 @@ bool LLChicletPanel::isAnyIMFloaterDoked()
for (chiclet_list_t::iterator it = mChicletList.begin(); it
!= mChicletList.end(); it++)
{
LLIMFloater* im_floater = LLFloaterReg::findTypedInstance<LLIMFloater>(
LLFloaterIMSession* im_floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>(
"impanel", (*it)->getSessionId());
if (im_floater != NULL && im_floater->getVisible()
&& !im_floater->isMinimized() && im_floater->isDocked())

2
indra/newview/llchiclet.h
View File

@ -37,7 +37,7 @@
#include "llnotifications.h"
class LLMenuGL;
class LLIMFloater;
class LLFloaterIMSession;
/**
* Class for displaying amount of messages/notifications(unread).

10
indra/newview/llchicletbar.cpp
View File

@ -34,7 +34,7 @@
// newview includes
#include "llchiclet.h"
#include "llimfloater.h" // for LLIMFloater
#include "llfloaterimsession.h" // for LLFloaterIMSession
#include "llpaneltopinfobar.h"
#include "llsyswellwindow.h"
@ -95,9 +95,9 @@ void LLChicletBar::sessionAdded(const LLUUID& session_id, const std::string& nam
if (session->isP2P() && session->isOtherParticipantAvaline()) return;
// Do not spawn chiclet when using the new multitab conversation UI
if (LLIMConversation::isChatMultiTab())
if (LLFloaterIMSessionTab::isChatMultiTab())
{
LLIMConversation::addToHost(session_id);
LLFloaterIMSessionTab::addToHost(session_id);
return;
}
@ -109,7 +109,7 @@ void LLChicletBar::sessionAdded(const LLUUID& session_id, const std::string& nam
chiclet->setIMSessionName(name);
chiclet->setOtherParticipantId(other_participant_id);
LLIMFloater::onIMChicletCreated(session_id);
LLFloaterIMSession::onIMChicletCreated(session_id);
}
else
@ -124,7 +124,7 @@ void LLChicletBar::sessionRemoved(const LLUUID& session_id)
if(getChicletPanel())
{
// IM floater should be closed when session removed and associated chiclet closed
LLIMFloater* im_floater = LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
LLFloaterIMSession* im_floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>("impanel", session_id);
if (im_floater != NULL && !im_floater->getStartConferenceInSameFloater())
{
// Close the IM floater only if we are not planning to close the P2P chat

6
indra/newview/llconversationlog.cpp
View File

@ -140,15 +140,15 @@ bool LLConversation::isOlderThan(U32 days) const
void LLConversation::setListenIMFloaterOpened()
{
LLIMFloater* floater = LLIMFloater::findInstance(mSessionID);
LLFloaterIMSession* floater = LLFloaterIMSession::findInstance(mSessionID);
bool offline_ims_visible = LLIMFloater::isVisible(floater) && floater->hasFocus();
bool offline_ims_visible = LLFloaterIMSession::isVisible(floater) && floater->hasFocus();
// we don't need to listen for im floater with this conversation is opened
// if floater is already opened or this conversation doesn't have unread offline messages
if (mHasOfflineIMs && !offline_ims_visible)
{
mIMFloaterShowedConnection = LLIMFloater::setIMFloaterShowedCallback(boost::bind(&LLConversation::onIMFloaterShown, this, _1));
mIMFloaterShowedConnection = LLFloaterIMSession::setIMFloaterShowedCallback(boost::bind(&LLConversation::onIMFloaterShown, this, _1));
}
else
{

4
indra/newview/llconversationlog.h
View File

@ -27,7 +27,7 @@
#define LLCONVERSATIONLOG_H_
#include "llcallingcard.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "llimview.h"
class LLConversationLogObserver;
@ -80,7 +80,7 @@ public:
private:
/*
* If conversation has unread offline messages sets callback for opening LLIMFloater
* If conversation has unread offline messages sets callback for opening LLFloaterIMSession
* with this conversation.
*/
void setListenIMFloaterOpened();

6
indra/newview/llconversationloglistitem.cpp
View File

@ -47,13 +47,13 @@ LLConversationLogListItem::LLConversationLogListItem(const LLConversation* conve
{
buildFromFile("panel_conversation_log_list_item.xml");
LLIMFloater* floater = LLIMFloater::findInstance(mConversation->getSessionID());
LLFloaterIMSession* floater = LLFloaterIMSession::findInstance(mConversation->getSessionID());
bool ims_are_read = LLIMFloater::isVisible(floater) && floater->hasFocus();
bool ims_are_read = LLFloaterIMSession::isVisible(floater) && floater->hasFocus();
if (mConversation->hasOfflineMessages() && !ims_are_read)
{
mIMFloaterShowedConnection = LLIMFloater::setIMFloaterShowedCallback(boost::bind(&LLConversationLogListItem::onIMFloaterShown, this, _1));
mIMFloaterShowedConnection = LLFloaterIMSession::setIMFloaterShowedCallback(boost::bind(&LLConversationLogListItem::onIMFloaterShown, this, _1));
}
}

2
indra/newview/llconversationloglistitem.h
View File

@ -26,7 +26,7 @@
#ifndef LLCONVERSATIONLOGLISTITEM_H_
#define LLCONVERSATIONLOGLISTITEM_H_
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "llpanel.h"
class LLTextBox;

14
indra/newview/llconversationview.cpp
View File

@ -32,10 +32,10 @@
#include <boost/bind.hpp>
#include "llagentdata.h"
#include "llconversationmodel.h"
#include "llimfloater.h"
#include "llnearbychat.h"
#include "llimconversation.h"
#include "llimfloatercontainer.h"
#include "llfloaterimsession.h"
#include "llfloaterimnearbychat.h"
#include "llfloaterimsessiontab.h"
#include "llfloaterimcontainer.h"
#include "llfloaterreg.h"
#include "llgroupiconctrl.h"
#include "lluictrlfactory.h"
@ -208,7 +208,7 @@ BOOL LLConversationViewSession::handleMouseDown( S32 x, S32 y, MASK mask )
LLConversationItem* item = dynamic_cast<LLConversationItem *>(getViewModelItem());
LLUUID session_id = item? item->getUUID() : LLUUID();
(LLFloaterReg::getTypedInstance<LLIMFloaterContainer>("im_container"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container"))->
selectConversationPair(session_id, false);
return LLFolderViewFolder::handleMouseDown(x, y, mask);
@ -262,7 +262,7 @@ void LLConversationViewSession::setVisibleIfDetached(BOOL visible)
// Note: minimized dockable floaters are brought to front hence unminimized when made visible and we don't want that here
LLFolderViewModelItem* item = mViewModelItem;
LLUUID session_uuid = dynamic_cast<LLConversationItem*>(item)->getUUID();
LLFloater* session_floater = LLIMConversation::getConversation(session_uuid);
LLFloater* session_floater = LLFloaterIMSessionTab::getConversation(session_uuid);
if (session_floater && !session_floater->getHost() && !session_floater->isMinimized())
{
@ -505,7 +505,7 @@ BOOL LLConversationViewParticipant::handleMouseDown( S32 x, S32 y, MASK mask )
}
LLUUID session_id = item? item->getUUID() : LLUUID();
(LLFloaterReg::getTypedInstance<LLIMFloaterContainer>("im_container"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container"))->
selectConversationPair(session_id, false);
return LLFolderViewItem::handleMouseDown(x, y, mask);

8
indra/newview/llconversationview.h
View File

@ -34,7 +34,7 @@
#include "lloutputmonitorctrl.h"
class LLTextBox;
class LLIMFloaterContainer;
class LLFloaterIMContainer;
class LLConversationViewSession;
class LLConversationViewParticipant;
@ -47,7 +47,7 @@ class LLConversationViewSession : public LLFolderViewFolder
public:
struct Params : public LLInitParam::Block<Params, LLFolderViewItem::Params>
{
Optional<LLIMFloaterContainer*> container;
Optional<LLFloaterIMContainer*> container;
Params();
};
@ -56,7 +56,7 @@ protected:
friend class LLUICtrlFactory;
LLConversationViewSession( const Params& p );
LLIMFloaterContainer* mContainer;
LLFloaterIMContainer* mContainer;
public:
virtual ~LLConversationViewSession();
@ -107,7 +107,7 @@ public:
struct Params : public LLInitParam::Block<Params, LLFolderViewItem::Params>
{
Optional<LLIMFloaterContainer*> container;
Optional<LLFloaterIMContainer*> container;
Optional<LLUUID> participant_id;
Optional<LLAvatarIconCtrl::Params> avatar_icon;
Optional<LLButton::Params> info_button;

4
indra/newview/llfloaterconversationpreview.cpp
View File

@ -29,7 +29,7 @@
#include "llfloaterconversationpreview.h"
#include "llimview.h"
#include "lllineeditor.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llspinctrl.h"
#include "lltrans.h"
@ -149,7 +149,7 @@ void LLFloaterConversationPreview::showHistory()
}
else if (from_id.isNull())
{
chat.mSourceType = LLNearbyChat::isWordsName(from) ? CHAT_SOURCE_UNKNOWN : CHAT_SOURCE_OBJECT;
chat.mSourceType = LLFloaterIMNearbyChat::isWordsName(from) ? CHAT_SOURCE_UNKNOWN : CHAT_SOURCE_OBJECT;
}
mChatHistory->appendMessage(chat);

202
indra/newview/llimfloatercontainer.cpp → indra/newview/llfloaterimcontainer.cpp
View File

@ -1,5 +1,5 @@
/**
* @file llimfloatercontainer.cpp
* @file llfloaterimcontainer.cpp
* @brief Multifloater containing active IM sessions in separate tab container tabs
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
@ -27,12 +27,12 @@
#include "llviewerprecompiledheaders.h"
#include "llimfloater.h"
#include "llimfloatercontainer.h"
#include "llfloaterimsession.h"
#include "llfloaterimcontainer.h"
#include "llfloaterreg.h"
#include "lllayoutstack.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llagent.h"
#include "llavataractions.h"
@ -53,23 +53,23 @@
#include "llsdserialize.h"
//
// LLIMFloaterContainer
// LLFloaterIMContainer
//
LLIMFloaterContainer::LLIMFloaterContainer(const LLSD& seed)
LLFloaterIMContainer::LLFloaterIMContainer(const LLSD& seed)
: LLMultiFloater(seed),
mExpandCollapseBtn(NULL),
mConversationsRoot(NULL),
mConversationsEventStream("ConversationsEvents"),
mInitialized(false)
{
mEnableCallbackRegistrar.add("IMFloaterContainer.Check", boost::bind(&LLIMFloaterContainer::isActionChecked, this, _2));
mCommitCallbackRegistrar.add("IMFloaterContainer.Action", boost::bind(&LLIMFloaterContainer::onCustomAction, this, _2));
mEnableCallbackRegistrar.add("IMFloaterContainer.Check", boost::bind(&LLFloaterIMContainer::isActionChecked, this, _2));
mCommitCallbackRegistrar.add("IMFloaterContainer.Action", boost::bind(&LLFloaterIMContainer::onCustomAction, this, _2));
mEnableCallbackRegistrar.add("Avatar.CheckItem", boost::bind(&LLIMFloaterContainer::checkContextMenuItem, this, _2));
mEnableCallbackRegistrar.add("Avatar.EnableItem", boost::bind(&LLIMFloaterContainer::enableContextMenuItem, this, _2));
mCommitCallbackRegistrar.add("Avatar.DoToSelected", boost::bind(&LLIMFloaterContainer::doToSelected, this, _2));
mEnableCallbackRegistrar.add("Avatar.CheckItem", boost::bind(&LLFloaterIMContainer::checkContextMenuItem, this, _2));
mEnableCallbackRegistrar.add("Avatar.EnableItem", boost::bind(&LLFloaterIMContainer::enableContextMenuItem, this, _2));
mCommitCallbackRegistrar.add("Avatar.DoToSelected", boost::bind(&LLFloaterIMContainer::doToSelected, this, _2));
mCommitCallbackRegistrar.add("Group.DoToSelected", boost::bind(&LLIMFloaterContainer::doToSelectedGroup, this, _2));
mCommitCallbackRegistrar.add("Group.DoToSelected", boost::bind(&LLFloaterIMContainer::doToSelectedGroup, this, _2));
// Firstly add our self to IMSession observers, so we catch session events
LLIMMgr::getInstance()->addSessionObserver(this);
@ -78,7 +78,7 @@ LLIMFloaterContainer::LLIMFloaterContainer(const LLSD& seed)
LLTransientFloaterMgr::getInstance()->addControlView(LLTransientFloaterMgr::IM, this);
}
LLIMFloaterContainer::~LLIMFloaterContainer()
LLFloaterIMContainer::~LLFloaterIMContainer()
{
mConversationsEventStream.stopListening("ConversationsRefresh");
@ -96,47 +96,47 @@ LLIMFloaterContainer::~LLIMFloaterContainer()
}
}
void LLIMFloaterContainer::sessionAdded(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id)
void LLFloaterIMContainer::sessionAdded(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id)
{
addConversationListItem(session_id);
LLIMConversation::addToHost(session_id);
LLFloaterIMSessionTab::addToHost(session_id);
}
void LLIMFloaterContainer::sessionActivated(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id)
void LLFloaterIMContainer::sessionActivated(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id)
{
selectConversation(session_id);
}
void LLIMFloaterContainer::sessionVoiceOrIMStarted(const LLUUID& session_id)
void LLFloaterIMContainer::sessionVoiceOrIMStarted(const LLUUID& session_id)
{
addConversationListItem(session_id);
LLIMConversation::addToHost(session_id);
LLFloaterIMSessionTab::addToHost(session_id);
}
void LLIMFloaterContainer::sessionIDUpdated(const LLUUID& old_session_id, const LLUUID& new_session_id)
void LLFloaterIMContainer::sessionIDUpdated(const LLUUID& old_session_id, const LLUUID& new_session_id)
{
// *TODO: We should do this *without* delete and recreate
addConversationListItem(new_session_id, removeConversationListItem(old_session_id));
}
void LLIMFloaterContainer::sessionRemoved(const LLUUID& session_id)
void LLFloaterIMContainer::sessionRemoved(const LLUUID& session_id)
{
removeConversationListItem(session_id);
}
// static
void LLIMFloaterContainer::onCurrentChannelChanged(const LLUUID& session_id)
void LLFloaterIMContainer::onCurrentChannelChanged(const LLUUID& session_id)
{
if (session_id != LLUUID::null)
{
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
}
}
BOOL LLIMFloaterContainer::postBuild()
BOOL LLFloaterIMContainer::postBuild()
{
mNewMessageConnection = LLIMModel::instance().mNewMsgSignal.connect(boost::bind(&LLIMFloaterContainer::onNewMessageReceived, this, _1));
mNewMessageConnection = LLIMModel::instance().mNewMsgSignal.connect(boost::bind(&LLFloaterIMContainer::onNewMessageReceived, this, _1));
// Do not call base postBuild to not connect to mCloseSignal to not close all floaters via Close button
// mTabContainer will be initialized in LLMultiFloater::addChild()
@ -149,7 +149,7 @@ BOOL LLIMFloaterContainer::postBuild()
mConversationsListPanel = getChild<LLPanel>("conversations_list_panel");
// Open IM session with selected participant on double click event
mConversationsListPanel->setDoubleClickCallback(boost::bind(&LLIMFloaterContainer::doToSelected, this, LLSD("im")));
mConversationsListPanel->setDoubleClickCallback(boost::bind(&LLFloaterIMContainer::doToSelected, this, LLSD("im")));
// Create the root model and view for all conversation sessions
LLConversationItem* base_item = new LLConversationItem(getRootViewModel());
@ -169,7 +169,7 @@ BOOL LLIMFloaterContainer::postBuild()
mConversationsRoot->setCallbackRegistrar(&mCommitCallbackRegistrar);
// Add listener to conversation model events
mConversationsEventStream.listen("ConversationsRefresh", boost::bind(&LLIMFloaterContainer::onConversationModelEvent, this, _1));
mConversationsEventStream.listen("ConversationsRefresh", boost::bind(&LLFloaterIMContainer::onConversationModelEvent, this, _1));
// a scroller for folder view
LLRect scroller_view_rect = mConversationsListPanel->getRect();
@ -188,13 +188,13 @@ BOOL LLIMFloaterContainer::postBuild()
addConversationListItem(LLUUID()); // manually add nearby chat
mExpandCollapseBtn = getChild<LLButton>("expand_collapse_btn");
mExpandCollapseBtn->setClickedCallback(boost::bind(&LLIMFloaterContainer::onExpandCollapseButtonClicked, this));
mExpandCollapseBtn->setClickedCallback(boost::bind(&LLFloaterIMContainer::onExpandCollapseButtonClicked, this));
childSetAction("add_btn", boost::bind(&LLIMFloaterContainer::onAddButtonClicked, this));
childSetAction("add_btn", boost::bind(&LLFloaterIMContainer::onAddButtonClicked, this));
collapseMessagesPane(gSavedPerAccountSettings.getBOOL("ConversationsMessagePaneCollapsed"));
collapseConversationsPane(gSavedPerAccountSettings.getBOOL("ConversationsListPaneCollapsed"));
LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLIMConversation::processChatHistoryStyleUpdate));
LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLFloaterIMSessionTab::processChatHistoryStyleUpdate));
if (! mMessagesPane->isCollapsed())
{
@ -215,19 +215,19 @@ BOOL LLIMFloaterContainer::postBuild()
// We'll take care of view updates on idle
gIdleCallbacks.addFunction(idle, this);
// When display name option change, we need to reload all participant names
LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLIMFloaterContainer::processParticipantsStyleUpdate, this));
LLAvatarNameCache::addUseDisplayNamesCallback(boost::bind(&LLFloaterIMContainer::processParticipantsStyleUpdate, this));
return TRUE;
}
void LLIMFloaterContainer::onOpen(const LLSD& key)
void LLFloaterIMContainer::onOpen(const LLSD& key)
{
LLMultiFloater::onOpen(key);
openNearbyChat();
}
// virtual
void LLIMFloaterContainer::addFloater(LLFloater* floaterp,
void LLFloaterIMContainer::addFloater(LLFloater* floaterp,
BOOL select_added_floater,
LLTabContainer::eInsertionPoint insertion_point)
{
@ -257,7 +257,7 @@ void LLIMFloaterContainer::addFloater(LLFloater* floaterp,
icon = LLUICtrlFactory::instance().create<LLGroupIconCtrl>(icon_params);
mSessions[session_id] = floaterp;
floaterp->mCloseSignal.connect(boost::bind(&LLIMFloaterContainer::onCloseFloater, this, session_id));
floaterp->mCloseSignal.connect(boost::bind(&LLFloaterIMContainer::onCloseFloater, this, session_id));
}
else
{ LLUUID avatar_id = session_id.notNull()?
@ -268,7 +268,7 @@ void LLIMFloaterContainer::addFloater(LLFloater* floaterp,
icon = LLUICtrlFactory::instance().create<LLAvatarIconCtrl>(icon_params);
mSessions[session_id] = floaterp;
floaterp->mCloseSignal.connect(boost::bind(&LLIMFloaterContainer::onCloseFloater, this, session_id));
floaterp->mCloseSignal.connect(boost::bind(&LLFloaterIMContainer::onCloseFloater, this, session_id));
}
// forced resize of the floater
@ -279,14 +279,14 @@ void LLIMFloaterContainer::addFloater(LLFloater* floaterp,
}
void LLIMFloaterContainer::onCloseFloater(LLUUID& id)
void LLFloaterIMContainer::onCloseFloater(LLUUID& id)
{
mSessions.erase(id);
setFocus(TRUE);
}
// virtual
void LLIMFloaterContainer::computeResizeLimits(S32& new_min_width, S32& new_min_height)
void LLFloaterIMContainer::computeResizeLimits(S32& new_min_width, S32& new_min_height)
{
// possibly increase floater's minimum height according to children's minimums
for (S32 tab_idx = 0; tab_idx < mTabContainer->getTabCount(); ++tab_idx)
@ -305,7 +305,7 @@ void LLIMFloaterContainer::computeResizeLimits(S32& new_min_width, S32& new_min_
new_min_width = conversations_pane_min_dim + messages_pane_min_dim + LLPANEL_BORDER_WIDTH*2;
}
void LLIMFloaterContainer::onNewMessageReceived(const LLSD& data)
void LLFloaterIMContainer::onNewMessageReceived(const LLSD& data)
{
LLUUID session_id = data["session_id"].asUUID();
LLFloater* floaterp = get_ptr_in_map(mSessions, session_id);
@ -319,7 +319,7 @@ void LLIMFloaterContainer::onNewMessageReceived(const LLSD& data)
}
}
void LLIMFloaterContainer::onExpandCollapseButtonClicked()
void LLFloaterIMContainer::onExpandCollapseButtonClicked()
{
if (mConversationsPane->isCollapsed() && mMessagesPane->isCollapsed()
&& gSavedPerAccountSettings.getBOOL("ConversationsExpandMessagePaneFirst"))
@ -335,18 +335,18 @@ void LLIMFloaterContainer::onExpandCollapseButtonClicked()
selectConversation(mSelectedSession);
}
LLIMFloaterContainer* LLIMFloaterContainer::findInstance()
LLFloaterIMContainer* LLFloaterIMContainer::findInstance()
{
return LLFloaterReg::findTypedInstance<LLIMFloaterContainer>("im_container");
return LLFloaterReg::findTypedInstance<LLFloaterIMContainer>("im_container");
}
LLIMFloaterContainer* LLIMFloaterContainer::getInstance()
LLFloaterIMContainer* LLFloaterIMContainer::getInstance()
{
return LLFloaterReg::getTypedInstance<LLIMFloaterContainer>("im_container");
return LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");
}
// Update all participants in the conversation lists
void LLIMFloaterContainer::processParticipantsStyleUpdate()
void LLFloaterIMContainer::processParticipantsStyleUpdate()
{
// On each session in mConversationsItems
for (conversations_items_map::iterator it_session = mConversationsItems.begin(); it_session != mConversationsItems.end(); it_session++)
@ -368,9 +368,9 @@ void LLIMFloaterContainer::processParticipantsStyleUpdate()
}
// static
void LLIMFloaterContainer::idle(void* user_data)
void LLFloaterIMContainer::idle(void* user_data)
{
LLIMFloaterContainer* self = static_cast<LLIMFloaterContainer*>(user_data);
LLFloaterIMContainer* self = static_cast<LLFloaterIMContainer*>(user_data);
// Update the distance to agent in the nearby chat session if required
// Note: it makes no sense of course to update the distance in other session
@ -381,12 +381,12 @@ void LLIMFloaterContainer::idle(void* user_data)
self->mConversationsRoot->update();
}
bool LLIMFloaterContainer::onConversationModelEvent(const LLSD& event)
bool LLFloaterIMContainer::onConversationModelEvent(const LLSD& event)
{
// For debug only
//std::ostringstream llsd_value;
//llsd_value << LLSDOStreamer<LLSDNotationFormatter>(event) << std::endl;
//llinfos << "LLIMFloaterContainer::onConversationModelEvent, event = " << llsd_value.str() << llendl;
//llinfos << "LLFloaterIMContainer::onConversationModelEvent, event = " << llsd_value.str() << llendl;
// end debug
// Note: In conversations, the model is not responsible for creating the view, which is a good thing. This means that
@ -407,7 +407,7 @@ bool LLIMFloaterContainer::onConversationModelEvent(const LLSD& event)
return false;
}
LLConversationViewParticipant* participant_view = session_view->findParticipant(participant_id);
LLIMConversation *conversation_floater = (session_id.isNull() ? (LLIMConversation*)(LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat")) : (LLIMConversation*)(LLIMFloater::findInstance(session_id)));
LLFloaterIMSessionTab *conversation_floater = (session_id.isNull() ? (LLFloaterIMSessionTab*)(LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat")) : (LLFloaterIMSessionTab*)(LLFloaterIMSession::findInstance(session_id)));
if (type == "remove_participant")
{
@ -473,7 +473,7 @@ bool LLIMFloaterContainer::onConversationModelEvent(const LLSD& event)
return false;
}
void LLIMFloaterContainer::draw()
void LLFloaterIMContainer::draw()
{
if (mTabContainer->getTabCount() == 0)
{
@ -484,7 +484,7 @@ void LLIMFloaterContainer::draw()
LLFloater::draw();
}
void LLIMFloaterContainer::tabClose()
void LLFloaterIMContainer::tabClose()
{
if (mTabContainer->getTabCount() == 0)
{
@ -494,12 +494,12 @@ void LLIMFloaterContainer::tabClose()
}
}
void LLIMFloaterContainer::setVisible(BOOL visible)
{ LLNearbyChat* nearby_chat;
void LLFloaterIMContainer::setVisible(BOOL visible)
{ LLFloaterIMNearbyChat* nearby_chat;
if (visible)
{
// Make sure we have the Nearby Chat present when showing the conversation container
nearby_chat = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat");
nearby_chat = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat == NULL)
{
// If not found, force the creation of the nearby chat conversation panel
@ -510,10 +510,10 @@ void LLIMFloaterContainer::setVisible(BOOL visible)
openNearbyChat();
}
nearby_chat = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat");
nearby_chat = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
LLIMConversation::addToHost(LLUUID());
LLFloaterIMSessionTab::addToHost(LLUUID());
}
// We need to show/hide all the associated conversations that have been torn off
@ -534,7 +534,7 @@ void LLIMFloaterContainer::setVisible(BOOL visible)
}
void LLIMFloaterContainer::collapseMessagesPane(bool collapse)
void LLFloaterIMContainer::collapseMessagesPane(bool collapse)
{
if (mMessagesPane->isCollapsed() == collapse)
{
@ -569,7 +569,7 @@ void LLIMFloaterContainer::collapseMessagesPane(bool collapse)
mConversationsPane->setTargetDim(prevRect.getWidth());
}
}
void LLIMFloaterContainer::collapseConversationsPane(bool collapse)
void LLFloaterIMContainer::collapseConversationsPane(bool collapse)
{
if (mConversationsPane->isCollapsed() == collapse)
{
@ -611,7 +611,7 @@ void LLIMFloaterContainer::collapseConversationsPane(bool collapse)
}
}
void LLIMFloaterContainer::updateState(bool collapse, S32 delta_width)
void LLFloaterIMContainer::updateState(bool collapse, S32 delta_width)
{
LLRect floater_rect = getRect();
floater_rect.mRight += ((collapse ? -1 : 1) * delta_width);
@ -643,11 +643,11 @@ void LLIMFloaterContainer::updateState(bool collapse, S32 delta_width)
}
void LLIMFloaterContainer::onAddButtonClicked()
void LLFloaterIMContainer::onAddButtonClicked()
{
LLView * button = findChild<LLView>("conversations_pane_buttons_expanded")->findChild<LLButton>("add_btn");
LLFloater* root_floater = gFloaterView->getParentFloater(this);
LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(boost::bind(&LLIMFloaterContainer::onAvatarPicked, this, _1), TRUE, TRUE, TRUE, root_floater->getName(), button);
LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(boost::bind(&LLFloaterIMContainer::onAvatarPicked, this, _1), TRUE, TRUE, TRUE, root_floater->getName(), button);
if (picker && root_floater)
{
@ -655,7 +655,7 @@ void LLIMFloaterContainer::onAddButtonClicked()
}
}
void LLIMFloaterContainer::onAvatarPicked(const uuid_vec_t& ids)
void LLFloaterIMContainer::onAvatarPicked(const uuid_vec_t& ids)
{
if (ids.size() == 1)
{
@ -667,7 +667,7 @@ void LLIMFloaterContainer::onAvatarPicked(const uuid_vec_t& ids)
}
}
void LLIMFloaterContainer::onCustomAction(const LLSD& userdata)
void LLFloaterIMContainer::onCustomAction(const LLSD& userdata)
{
std::string command = userdata.asString();
@ -710,7 +710,7 @@ void LLIMFloaterContainer::onCustomAction(const LLSD& userdata)
}
}
BOOL LLIMFloaterContainer::isActionChecked(const LLSD& userdata)
BOOL LLFloaterIMContainer::isActionChecked(const LLSD& userdata)
{
LLConversationSort order = mConversationViewModel.getSorter();
std::string command = userdata.asString();
@ -742,7 +742,7 @@ BOOL LLIMFloaterContainer::isActionChecked(const LLSD& userdata)
return FALSE;
}
void LLIMFloaterContainer::setSortOrderSessions(const LLConversationFilter::ESortOrderType order)
void LLFloaterIMContainer::setSortOrderSessions(const LLConversationFilter::ESortOrderType order)
{
LLConversationSort old_order = mConversationViewModel.getSorter();
if (order != old_order.getSortOrderSessions())
@ -752,7 +752,7 @@ void LLIMFloaterContainer::setSortOrderSessions(const LLConversationFilter::ESor
}
}
void LLIMFloaterContainer::setSortOrderParticipants(const LLConversationFilter::ESortOrderType order)
void LLFloaterIMContainer::setSortOrderParticipants(const LLConversationFilter::ESortOrderType order)
{
LLConversationSort old_order = mConversationViewModel.getSorter();
if (order != old_order.getSortOrderParticipants())
@ -762,7 +762,7 @@ void LLIMFloaterContainer::setSortOrderParticipants(const LLConversationFilter::
}
}
void LLIMFloaterContainer::setSortOrder(const LLConversationSort& order)
void LLFloaterIMContainer::setSortOrder(const LLConversationSort& order)
{
mConversationViewModel.setSorter(order);
mConversationsRoot->arrangeAll();
@ -774,7 +774,7 @@ void LLIMFloaterContainer::setSortOrder(const LLConversationSort& order)
for (conversations_items_map::iterator it_session = mConversationsItems.begin(); it_session != mConversationsItems.end(); it_session++)
{
LLUUID session_id = it_session->first;
LLIMConversation *conversation_floater = (session_id.isNull() ? (LLIMConversation*)(LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat")) : (LLIMConversation*)(LLIMFloater::findInstance(session_id)));
LLFloaterIMSessionTab *conversation_floater = (session_id.isNull() ? (LLFloaterIMSessionTab*)(LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat")) : (LLFloaterIMSessionTab*)(LLFloaterIMSession::findInstance(session_id)));
if (conversation_floater)
{
conversation_floater->setSortOrder(order);
@ -784,7 +784,7 @@ void LLIMFloaterContainer::setSortOrder(const LLConversationSort& order)
gSavedSettings.setU32("ConversationSortOrder", (U32)order);
}
void LLIMFloaterContainer::getSelectedUUIDs(uuid_vec_t& selected_uuids)
void LLFloaterIMContainer::getSelectedUUIDs(uuid_vec_t& selected_uuids)
{
const std::set<LLFolderViewItem*> selectedItems = mConversationsRoot->getSelectionList();
@ -799,7 +799,7 @@ void LLIMFloaterContainer::getSelectedUUIDs(uuid_vec_t& selected_uuids)
}
}
const LLConversationItem * LLIMFloaterContainer::getCurSelectedViewModelItem()
const LLConversationItem * LLFloaterIMContainer::getCurSelectedViewModelItem()
{
LLConversationItem * conversationItem = NULL;
@ -813,7 +813,7 @@ const LLConversationItem * LLIMFloaterContainer::getCurSelectedViewModelItem()
return conversationItem;
}
void LLIMFloaterContainer::getParticipantUUIDs(uuid_vec_t& selected_uuids)
void LLFloaterIMContainer::getParticipantUUIDs(uuid_vec_t& selected_uuids)
{
//Find the conversation floater associated with the selected id
const LLConversationItem * conversationItem = getCurSelectedViewModelItem();
@ -825,13 +825,13 @@ void LLIMFloaterContainer::getParticipantUUIDs(uuid_vec_t& selected_uuids)
//When a one-on-one conversation exists, retrieve the participant id from the conversation floater
else if(conversationItem->getType() == LLConversationItem::CONV_SESSION_1_ON_1)
{
LLIMFloater *conversationFloater = LLIMFloater::findInstance(conversationItem->getUUID());
LLFloaterIMSession *conversationFloater = LLFloaterIMSession::findInstance(conversationItem->getUUID());
LLUUID participantID = conversationFloater->getOtherParticipantUUID();
selected_uuids.push_back(participantID);
}
}
void LLIMFloaterContainer::doToParticipants(const std::string& command, uuid_vec_t& selectedIDS)
void LLFloaterIMContainer::doToParticipants(const std::string& command, uuid_vec_t& selectedIDS)
{
if(selectedIDS.size() > 0)
{
@ -898,11 +898,11 @@ void LLIMFloaterContainer::doToParticipants(const std::string& command, uuid_vec
}
}
void LLIMFloaterContainer::doToSelectedConversation(const std::string& command, uuid_vec_t& selectedIDS)
void LLFloaterIMContainer::doToSelectedConversation(const std::string& command, uuid_vec_t& selectedIDS)
{
//Find the conversation floater associated with the selected id
const LLConversationItem * conversationItem = getCurSelectedViewModelItem();
LLIMFloater *conversationFloater = LLIMFloater::findInstance(conversationItem->getUUID());
LLFloaterIMSession *conversationFloater = LLFloaterIMSession::findInstance(conversationItem->getUUID());
if(conversationFloater)
{
@ -936,7 +936,7 @@ void LLIMFloaterContainer::doToSelectedConversation(const std::string& command,
}
}
void LLIMFloaterContainer::doToSelected(const LLSD& userdata)
void LLFloaterIMContainer::doToSelected(const LLSD& userdata)
{
std::string command = userdata.asString();
const LLConversationItem * conversationItem = getCurSelectedViewModelItem();
@ -957,7 +957,7 @@ void LLIMFloaterContainer::doToSelected(const LLSD& userdata)
}
}
void LLIMFloaterContainer::doToSelectedGroup(const LLSD& userdata)
void LLFloaterIMContainer::doToSelectedGroup(const LLSD& userdata)
{
std::string action = userdata.asString();
LLUUID selected_group = getCurSelectedViewModelItem()->getUUID();
@ -976,7 +976,7 @@ void LLIMFloaterContainer::doToSelectedGroup(const LLSD& userdata)
}
}
bool LLIMFloaterContainer::enableContextMenuItem(const LLSD& userdata)
bool LLFloaterIMContainer::enableContextMenuItem(const LLSD& userdata)
{
std::string item = userdata.asString();
uuid_vec_t uuids;
@ -1076,7 +1076,7 @@ bool LLIMFloaterContainer::enableContextMenuItem(const LLSD& userdata)
return false;
}
bool LLIMFloaterContainer::checkContextMenuItem(const LLSD& userdata)
bool LLFloaterIMContainer::checkContextMenuItem(const LLSD& userdata)
{
std::string item = userdata.asString();
uuid_vec_t mUUIDs;
@ -1102,14 +1102,14 @@ bool LLIMFloaterContainer::checkContextMenuItem(const LLSD& userdata)
return false;
}
void LLIMFloaterContainer::showConversation(const LLUUID& session_id)
void LLFloaterIMContainer::showConversation(const LLUUID& session_id)
{
setVisibleAndFrontmost(false);
selectConversation(session_id);
}
// Will select only the conversation item
void LLIMFloaterContainer::selectConversation(const LLUUID& session_id)
void LLFloaterIMContainer::selectConversation(const LLUUID& session_id)
{
LLFolderViewItem* widget = get_ptr_in_map(mConversationsWidgets,session_id);
if (widget)
@ -1119,7 +1119,7 @@ void LLIMFloaterContainer::selectConversation(const LLUUID& session_id)
}
// Synchronous select the conversation item and the conversation floater
BOOL LLIMFloaterContainer::selectConversationPair(const LLUUID& session_id, bool select_widget)
BOOL LLFloaterIMContainer::selectConversationPair(const LLUUID& session_id, bool select_widget)
{
BOOL handled = TRUE;
@ -1140,7 +1140,7 @@ BOOL LLIMFloaterContainer::selectConversationPair(const LLUUID& session_id, bool
// Store the active session
setSelectedSession(session_id);
LLIMConversation* session_floater = LLIMConversation::getConversation(session_id);
LLFloaterIMSessionTab* session_floater = LLFloaterIMSessionTab::getConversation(session_id);
if (session_floater->getHost())
{
@ -1160,7 +1160,7 @@ BOOL LLIMFloaterContainer::selectConversationPair(const LLUUID& session_id, bool
return handled;
}
void LLIMFloaterContainer::setTimeNow(const LLUUID& session_id, const LLUUID& participant_id)
void LLFloaterIMContainer::setTimeNow(const LLUUID& session_id, const LLUUID& participant_id)
{
LLConversationItemSession* item = dynamic_cast<LLConversationItemSession*>(get_ptr_in_map(mConversationsItems,session_id));
if (item)
@ -1171,7 +1171,7 @@ void LLIMFloaterContainer::setTimeNow(const LLUUID& session_id, const LLUUID& pa
}
}
void LLIMFloaterContainer::setNearbyDistances()
void LLFloaterIMContainer::setNearbyDistances()
{
// Get the nearby chat session: that's the one with uuid nul
LLConversationItemSession* item = dynamic_cast<LLConversationItemSession*>(get_ptr_in_map(mConversationsItems,LLUUID()));
@ -1198,7 +1198,7 @@ void LLIMFloaterContainer::setNearbyDistances()
}
}
LLConversationItem* LLIMFloaterContainer::addConversationListItem(const LLUUID& uuid, bool isWidgetSelected /*= false*/)
LLConversationItem* LLFloaterIMContainer::addConversationListItem(const LLUUID& uuid, bool isWidgetSelected /*= false*/)
{
bool is_nearby_chat = uuid.isNull();
@ -1259,7 +1259,7 @@ LLConversationItem* LLIMFloaterContainer::addConversationListItem(const LLUUID&
}
}
// Do that too for the conversation dialog
LLIMConversation *conversation_floater = (uuid.isNull() ? (LLIMConversation*)(LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat")) : (LLIMConversation*)(LLIMFloater::findInstance(uuid)));
LLFloaterIMSessionTab *conversation_floater = (uuid.isNull() ? (LLFloaterIMSessionTab*)(LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat")) : (LLFloaterIMSessionTab*)(LLFloaterIMSession::findInstance(uuid)));
if (conversation_floater)
{
conversation_floater->buildConversationViewParticipant();
@ -1278,7 +1278,7 @@ LLConversationItem* LLIMFloaterContainer::addConversationListItem(const LLUUID&
return item;
}
bool LLIMFloaterContainer::removeConversationListItem(const LLUUID& uuid, bool change_focus)
bool LLFloaterIMContainer::removeConversationListItem(const LLUUID& uuid, bool change_focus)
{
// Delete the widget and the associated conversation item
// Note : since the mConversationsItems is also the listener to the widget, deleting
@ -1317,7 +1317,7 @@ bool LLIMFloaterContainer::removeConversationListItem(const LLUUID& uuid, bool c
return isWidgetSelected;
}
LLConversationViewSession* LLIMFloaterContainer::createConversationItemWidget(LLConversationItem* item)
LLConversationViewSession* LLFloaterIMContainer::createConversationItemWidget(LLConversationItem* item)
{
LLConversationViewSession::Params params;
@ -1330,7 +1330,7 @@ LLConversationViewSession* LLIMFloaterContainer::createConversationItemWidget(LL
return LLUICtrlFactory::create<LLConversationViewSession>(params);
}
LLConversationViewParticipant* LLIMFloaterContainer::createConversationViewParticipant(LLConversationItem* item)
LLConversationViewParticipant* LLFloaterIMContainer::createConversationViewParticipant(LLConversationItem* item)
{
LLConversationViewParticipant::Params params;
LLRect panel_rect = mConversationsListPanel->getRect();
@ -1348,7 +1348,7 @@ LLConversationViewParticipant* LLIMFloaterContainer::createConversationViewParti
return LLUICtrlFactory::create<LLConversationViewParticipant>(params);
}
bool LLIMFloaterContainer::enableModerateContextMenuItem(const std::string& userdata)
bool LLFloaterIMContainer::enableModerateContextMenuItem(const std::string& userdata)
{
// only group moderators can perform actions related to this "enable callback"
if (!isGroupModerator())
@ -1381,7 +1381,7 @@ bool LLIMFloaterContainer::enableModerateContextMenuItem(const std::string& user
return LLVoiceClient::getInstance()->isParticipantAvatar(getCurSelectedViewModelItem()->getUUID());
}
bool LLIMFloaterContainer::isGroupModerator()
bool LLFloaterIMContainer::isGroupModerator()
{
LLSpeakerMgr * speaker_manager = getSpeakerMgrForSelectedParticipant();
if (NULL == speaker_manager)
@ -1402,7 +1402,7 @@ bool LLIMFloaterContainer::isGroupModerator()
return false;
}
void LLIMFloaterContainer::moderateVoice(const std::string& command, const LLUUID& userID)
void LLFloaterIMContainer::moderateVoice(const std::string& command, const LLUUID& userID)
{
if (!gAgent.getRegion()) return;
@ -1416,13 +1416,13 @@ void LLIMFloaterContainer::moderateVoice(const std::string& command, const LLUUI
}
}
bool LLIMFloaterContainer::isMuted(const LLUUID& avatar_id)
bool LLFloaterIMContainer::isMuted(const LLUUID& avatar_id)
{
const LLSpeaker * speakerp = getSpeakerOfSelectedParticipant(getSpeakerMgrForSelectedParticipant());
return NULL == speakerp ? true : speakerp->mStatus == LLSpeaker::STATUS_MUTED;
}
void LLIMFloaterContainer::moderateVoiceAllParticipants(bool unmute)
void LLFloaterIMContainer::moderateVoiceAllParticipants(bool unmute)
{
LLIMSpeakerMgr * speaker_managerp = dynamic_cast<LLIMSpeakerMgr*>(getSpeakerMgrForSelectedParticipant());
@ -1441,7 +1441,7 @@ void LLIMFloaterContainer::moderateVoiceAllParticipants(bool unmute)
}
// static
void LLIMFloaterContainer::confirmMuteAllCallback(const LLSD& notification, const LLSD& response)
void LLFloaterIMContainer::confirmMuteAllCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if Cancel pressed
@ -1463,7 +1463,7 @@ void LLIMFloaterContainer::confirmMuteAllCallback(const LLSD& notification, cons
return;
}
void LLIMFloaterContainer::moderateVoiceParticipant(const LLUUID& avatar_id, bool unmute)
void LLFloaterIMContainer::moderateVoiceParticipant(const LLUUID& avatar_id, bool unmute)
{
LLIMSpeakerMgr * speaker_managerp = dynamic_cast<LLIMSpeakerMgr *>(getSpeakerMgrForSelectedParticipant());
@ -1473,7 +1473,7 @@ void LLIMFloaterContainer::moderateVoiceParticipant(const LLUUID& avatar_id, boo
}
}
LLSpeakerMgr * LLIMFloaterContainer::getSpeakerMgrForSelectedParticipant()
LLSpeakerMgr * LLFloaterIMContainer::getSpeakerMgrForSelectedParticipant()
{
LLFolderViewItem * selected_folder_itemp = mConversationsRoot->getCurSelectedItem();
if (NULL == selected_folder_itemp)
@ -1506,7 +1506,7 @@ LLSpeakerMgr * LLIMFloaterContainer::getSpeakerMgrForSelectedParticipant()
: LLIMModel::getInstance()->getSpeakerManager(*conversation_uuidp);
}
LLSpeaker * LLIMFloaterContainer::getSpeakerOfSelectedParticipant(LLSpeakerMgr * speaker_managerp)
LLSpeaker * LLFloaterIMContainer::getSpeakerOfSelectedParticipant(LLSpeakerMgr * speaker_managerp)
{
if (NULL == speaker_managerp)
{
@ -1524,7 +1524,7 @@ LLSpeaker * LLIMFloaterContainer::getSpeakerOfSelectedParticipant(LLSpeakerMgr *
return speaker_managerp->findSpeaker(participant_itemp->getUUID());
}
void LLIMFloaterContainer::toggleAllowTextChat(const LLUUID& participant_uuid)
void LLFloaterIMContainer::toggleAllowTextChat(const LLUUID& participant_uuid)
{
LLIMSpeakerMgr * speaker_managerp = dynamic_cast<LLIMSpeakerMgr*>(getSpeakerMgrForSelectedParticipant());
if (NULL != speaker_managerp)
@ -1533,7 +1533,7 @@ void LLIMFloaterContainer::toggleAllowTextChat(const LLUUID& participant_uuid)
}
}
void LLIMFloaterContainer::openNearbyChat()
void LLFloaterIMContainer::openNearbyChat()
{
// If there's only one conversation in the container and that conversation is the nearby chat
//(which it should be...), open it so to make the list of participants visible. This happens to be the most common case when opening the Chat floater.
@ -1547,7 +1547,7 @@ void LLIMFloaterContainer::openNearbyChat()
}
}
void LLIMFloaterContainer::onNearbyChatClosed()
void LLFloaterIMContainer::onNearbyChatClosed()
{
// If nearby chat is the only remaining conversation and it is closed, close whole conversation floater as well
if (mConversationsItems.size() == 1)

20
indra/newview/llimfloatercontainer.h → indra/newview/llfloaterimcontainer.h
View File

@ -1,5 +1,5 @@
/**
* @file llimfloatercontainer.h
* @file llfloaterimcontainer.h
* @brief Multifloater containing active IM sessions in separate tab container tabs
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
@ -24,8 +24,8 @@
* $/LicenseInfo$
*/
#ifndef LL_LLIMFLOATERCONTAINER_H
#define LL_LLIMFLOATERCONTAINER_H
#ifndef LL_LLFLOATERIMCONTAINER_H
#define LL_LLFLOATERIMCONTAINER_H
#include <map>
#include <vector>
@ -44,17 +44,17 @@ class LLButton;
class LLLayoutPanel;
class LLLayoutStack;
class LLTabContainer;
class LLIMFloaterContainer;
class LLFloaterIMContainer;
class LLSpeaker;
class LLSpeakerMgr;
class LLIMFloaterContainer
class LLFloaterIMContainer
: public LLMultiFloater
, public LLIMSessionObserver
{
public:
LLIMFloaterContainer(const LLSD& seed);
virtual ~LLIMFloaterContainer();
LLFloaterIMContainer(const LLSD& seed);
virtual ~LLFloaterIMContainer();
/*virtual*/ BOOL postBuild();
/*virtual*/ void onOpen(const LLSD& key);
@ -73,8 +73,8 @@ public:
/*virtual*/ void tabClose();
static LLFloater* getCurrentVoiceFloater();
static LLIMFloaterContainer* findInstance();
static LLIMFloaterContainer* getInstance();
static LLFloaterIMContainer* findInstance();
static LLFloaterIMContainer* getInstance();
static void onCurrentChannelChanged(const LLUUID& session_id);
@ -175,4 +175,4 @@ private:
LLEventStream mConversationsEventStream;
};
#endif // LL_LLIMFLOATERCONTAINER_H
#endif // LL_LLFLOATERIMCONTAINER_H

120
indra/newview/llnearbychat.cpp → indra/newview/llfloaterimnearbychat.cpp
View File

@ -1,6 +1,6 @@
/**
* @file LLNearbyChat.cpp
* @brief LLNearbyChat class implementation
* @file LLFloaterIMNearbyChat.cpp
* @brief LLFloaterIMNearbyChat class implementation
*
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
* Second Life Viewer Source Code
@ -33,7 +33,7 @@
#include "llchatentry.h"
#include "llfloaterreg.h"
#include "lltrans.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llfloatersidepanelcontainer.h"
#include "llfocusmgr.h"
#include "lllogchat.h"
@ -42,7 +42,7 @@
#include "lldraghandle.h"
#include "llmenugl.h"
#include "llviewermenu.h" // for gMenuHolder
#include "llnearbychathandler.h"
#include "llfloaterimnearbychathandler.h"
#include "llchannelmanager.h"
#include "llchathistory.h"
#include "llstylemap.h"
@ -51,7 +51,7 @@
#include "lltrans.h"
#include "llfirstuse.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llagent.h" // gAgent
#include "llgesturemgr.h"
#include "llmultigesture.h"
@ -67,7 +67,7 @@
#include "llviewerchat.h"
#include "lltranslate.h"
S32 LLNearbyChat::sLastSpecialChatChannel = 0;
S32 LLFloaterIMNearbyChat::sLastSpecialChatChannel = 0;
const S32 EXPANDED_HEIGHT = 266;
const S32 COLLAPSED_HEIGHT = 60;
@ -87,8 +87,8 @@ static LLChatTypeTrigger sChatTypeTriggers[] = {
};
LLNearbyChat::LLNearbyChat(const LLSD& llsd)
: LLIMConversation(llsd),
LLFloaterIMNearbyChat::LLFloaterIMNearbyChat(const LLSD& llsd)
: LLFloaterIMSessionTab(llsd),
//mOutputMonitor(NULL),
mSpeakerMgr(NULL),
mExpandedHeight(COLLAPSED_HEIGHT + EXPANDED_HEIGHT)
@ -101,28 +101,28 @@ LLNearbyChat::LLNearbyChat(const LLSD& llsd)
}
//static
LLNearbyChat* LLNearbyChat::buildFloater(const LLSD& key)
LLFloaterIMNearbyChat* LLFloaterIMNearbyChat::buildFloater(const LLSD& key)
{
LLFloaterReg::getInstance("im_container");
return new LLNearbyChat(key);
return new LLFloaterIMNearbyChat(key);
}
//virtual
BOOL LLNearbyChat::postBuild()
BOOL LLFloaterIMNearbyChat::postBuild()
{
setIsSingleInstance(TRUE);
BOOL result = LLIMConversation::postBuild();
mInputEditor->setCommitCallback(boost::bind(&LLNearbyChat::onChatBoxCommit, this));
BOOL result = LLFloaterIMSessionTab::postBuild();
mInputEditor->setCommitCallback(boost::bind(&LLFloaterIMNearbyChat::onChatBoxCommit, this));
mInputEditor->setKeystrokeCallback(boost::bind(&onChatBoxKeystroke, _1, this));
mInputEditor->setFocusLostCallback(boost::bind(&onChatBoxFocusLost, _1, this));
mInputEditor->setFocusReceivedCallback(boost::bind(&LLNearbyChat::onChatBoxFocusReceived, this));
mInputEditor->setFocusReceivedCallback(boost::bind(&LLFloaterIMNearbyChat::onChatBoxFocusReceived, this));
mInputEditor->setLabel(LLTrans::getString("NearbyChatTitle"));
// mOutputMonitor = getChild<LLOutputMonitorCtrl>("chat_zone_indicator");
// mOutputMonitor->setVisible(FALSE);
// Register for font change notifications
LLViewerChat::setFontChangedCallback(boost::bind(&LLNearbyChat::onChatFontChange, this, _1));
LLViewerChat::setFontChangedCallback(boost::bind(&LLFloaterIMNearbyChat::onChatFontChange, this, _1));
// title must be defined BEFORE call addConversationListItem() because
// it is used for show the item's name in the conversations list
@ -132,8 +132,8 @@ BOOL LLNearbyChat::postBuild()
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
enable_registrar.add("NearbyChat.Check", boost::bind(&LLNearbyChat::onNearbyChatCheckContextMenuItem, this, _2));
registrar.add("NearbyChat.Action", boost::bind(&LLNearbyChat::onNearbyChatContextMenuItemClicked, this, _2));
enable_registrar.add("NearbyChat.Check", boost::bind(&LLFloaterIMNearbyChat::onNearbyChatCheckContextMenuItem, this, _2));
registrar.add("NearbyChat.Action", boost::bind(&LLFloaterIMNearbyChat::onNearbyChatContextMenuItemClicked, this, _2));
LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_nearby_chat.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
if(menu)
@ -153,7 +153,7 @@ BOOL LLNearbyChat::postBuild()
}
// virtual
void LLNearbyChat::refresh()
void LLFloaterIMNearbyChat::refresh()
{
displaySpeakingIndicator();
updateCallBtnState(LLVoiceClient::getInstance()->getUserPTTState());
@ -167,18 +167,18 @@ void LLNearbyChat::refresh()
}
}
void LLNearbyChat::onNearbySpeakers()
void LLFloaterIMNearbyChat::onNearbySpeakers()
{
LLSD param;
param["people_panel_tab_name"] = "nearby_panel";
LLFloaterSidePanelContainer::showPanel("people", "panel_people", param);
}
void LLNearbyChat::onNearbyChatContextMenuItemClicked(const LLSD& userdata)
void LLFloaterIMNearbyChat::onNearbyChatContextMenuItemClicked(const LLSD& userdata)
{
}
bool LLNearbyChat::onNearbyChatCheckContextMenuItem(const LLSD& userdata)
bool LLFloaterIMNearbyChat::onNearbyChatCheckContextMenuItem(const LLSD& userdata)
{
std::string str = userdata.asString();
if(str == "nearby_people")
@ -187,7 +187,7 @@ bool LLNearbyChat::onNearbyChatCheckContextMenuItem(const LLSD& userdata)
}
BOOL LLNearbyChat::handleMouseDown(S32 x, S32 y, MASK mask)
BOOL LLFloaterIMNearbyChat::handleMouseDown(S32 x, S32 y, MASK mask)
{
//fix for EXT-6625
//highlight NearbyChat history whenever mouseclick happen in NearbyChat
@ -204,7 +204,7 @@ BOOL LLNearbyChat::handleMouseDown(S32 x, S32 y, MASK mask)
return handled;
}
void LLNearbyChat::reloadMessages()
void LLFloaterIMNearbyChat::reloadMessages()
{
mChatHistory->clear();
@ -217,7 +217,7 @@ void LLNearbyChat::reloadMessages()
}
}
void LLNearbyChat::loadHistory()
void LLFloaterIMNearbyChat::loadHistory()
{
LLSD do_not_log;
do_not_log["do_not_log"] = true;
@ -266,7 +266,7 @@ void LLNearbyChat::loadHistory()
}
}
void LLNearbyChat::removeScreenChat()
void LLFloaterIMNearbyChat::removeScreenChat()
{
LLNotificationsUI::LLScreenChannelBase* chat_channel = LLNotificationsUI::LLChannelManager::getInstance()->findChannelByID(LLUUID(gSavedSettings.getString("NearByChatChannelUUID")));
if(chat_channel)
@ -276,9 +276,9 @@ void LLNearbyChat::removeScreenChat()
}
void LLNearbyChat::setVisible(BOOL visible)
void LLFloaterIMNearbyChat::setVisible(BOOL visible)
{
LLIMConversation::setVisible(visible);
LLFloaterIMSessionTab::setVisible(visible);
if(visible)
{
@ -288,9 +288,9 @@ void LLNearbyChat::setVisible(BOOL visible)
}
// virtual
void LLNearbyChat::onTearOffClicked()
void LLFloaterIMNearbyChat::onTearOffClicked()
{
LLIMConversation::onTearOffClicked();
LLFloaterIMSessionTab::onTearOffClicked();
// see CHUI-170: Save torn-off state of the nearby chat between sessions
BOOL in_the_multifloater = !isTornOff();
@ -299,33 +299,33 @@ void LLNearbyChat::onTearOffClicked()
// virtual
void LLNearbyChat::onOpen(const LLSD& key)
void LLFloaterIMNearbyChat::onOpen(const LLSD& key)
{
LLIMConversation::onOpen(key);
LLFloaterIMSessionTab::onOpen(key);
showTranslationCheckbox(LLTranslate::isTranslationConfigured());
}
// virtual
void LLNearbyChat::onClose(bool app_quitting)
void LLFloaterIMNearbyChat::onClose(bool app_quitting)
{
// Override LLIMConversation::onClose() so that Nearby Chat is not removed from the conversation floater
// Override LLFloaterIMSessionTab::onClose() so that Nearby Chat is not removed from the conversation floater
}
// virtual
void LLNearbyChat::onClickCloseBtn()
void LLFloaterIMNearbyChat::onClickCloseBtn()
{
if (!isTornOff())
return;
onTearOffClicked();
LLIMFloaterContainer *im_box = LLIMFloaterContainer::findInstance();
LLFloaterIMContainer *im_box = LLFloaterIMContainer::findInstance();
if (im_box)
{
im_box->onNearbyChatClosed();
}
}
void LLNearbyChat::onChatFontChange(LLFontGL* fontp)
void LLFloaterIMNearbyChat::onChatFontChange(LLFontGL* fontp)
{
// Update things with the new font whohoo
if (mInputEditor)
@ -335,7 +335,7 @@ void LLNearbyChat::onChatFontChange(LLFontGL* fontp)
}
void LLNearbyChat::show()
void LLFloaterIMNearbyChat::show()
{
if (isChatMultiTab())
{
@ -343,10 +343,10 @@ void LLNearbyChat::show()
}
}
bool LLNearbyChat::isChatVisible() const
bool LLFloaterIMNearbyChat::isChatVisible() const
{
bool isVisible = false;
LLIMFloaterContainer* im_box = LLIMFloaterContainer::getInstance();
LLFloaterIMContainer* im_box = LLFloaterIMContainer::getInstance();
// Is the IM floater container ever null?
llassert(im_box != NULL);
if (im_box != NULL)
@ -360,19 +360,19 @@ bool LLNearbyChat::isChatVisible() const
return isVisible;
}
void LLNearbyChat::showHistory()
void LLFloaterIMNearbyChat::showHistory()
{
openFloater();
setResizeLimits(getMinWidth(), EXPANDED_MIN_HEIGHT);
}
std::string LLNearbyChat::getCurrentChat()
std::string LLFloaterIMNearbyChat::getCurrentChat()
{
return mInputEditor ? mInputEditor->getText() : LLStringUtil::null;
}
// virtual
BOOL LLNearbyChat::handleKeyHere( KEY key, MASK mask )
BOOL LLFloaterIMNearbyChat::handleKeyHere( KEY key, MASK mask )
{
BOOL handled = FALSE;
@ -386,7 +386,7 @@ BOOL LLNearbyChat::handleKeyHere( KEY key, MASK mask )
return handled;
}
BOOL LLNearbyChat::matchChatTypeTrigger(const std::string& in_str, std::string* out_str)
BOOL LLFloaterIMNearbyChat::matchChatTypeTrigger(const std::string& in_str, std::string* out_str)
{
U32 in_len = in_str.length();
S32 cnt = sizeof(sChatTypeTriggers) / sizeof(*sChatTypeTriggers);
@ -411,11 +411,11 @@ BOOL LLNearbyChat::matchChatTypeTrigger(const std::string& in_str, std::string*
return string_was_found;
}
void LLNearbyChat::onChatBoxKeystroke(LLTextEditor* caller, void* userdata)
void LLFloaterIMNearbyChat::onChatBoxKeystroke(LLTextEditor* caller, void* userdata)
{
LLFirstUse::otherAvatarChatFirst(false);
LLNearbyChat* self = (LLNearbyChat *)userdata;
LLFloaterIMNearbyChat* self = (LLFloaterIMNearbyChat *)userdata;
LLWString raw_text = self->mInputEditor->getWText();
@ -485,18 +485,18 @@ void LLNearbyChat::onChatBoxKeystroke(LLTextEditor* caller, void* userdata)
}
// static
void LLNearbyChat::onChatBoxFocusLost(LLFocusableElement* caller, void* userdata)
void LLFloaterIMNearbyChat::onChatBoxFocusLost(LLFocusableElement* caller, void* userdata)
{
// stop typing animation
gAgent.stopTyping();
}
void LLNearbyChat::onChatBoxFocusReceived()
void LLFloaterIMNearbyChat::onChatBoxFocusReceived()
{
mInputEditor->setEnabled(!gDisconnected);
}
EChatType LLNearbyChat::processChatTypeTriggers(EChatType type, std::string &str)
EChatType LLFloaterIMNearbyChat::processChatTypeTriggers(EChatType type, std::string &str)
{
U32 length = str.length();
S32 cnt = sizeof(sChatTypeTriggers) / sizeof(*sChatTypeTriggers);
@ -528,7 +528,7 @@ EChatType LLNearbyChat::processChatTypeTriggers(EChatType type, std::string &str
return type;
}
void LLNearbyChat::sendChat( EChatType type )
void LLFloaterIMNearbyChat::sendChat( EChatType type )
{
if (mInputEditor)
{
@ -578,7 +578,7 @@ void LLNearbyChat::sendChat( EChatType type )
}
}
void LLNearbyChat::addMessage(const LLChat& chat,bool archive,const LLSD &args)
void LLFloaterIMNearbyChat::addMessage(const LLChat& chat,bool archive,const LLSD &args)
{
appendMessage(chat, args);
@ -612,7 +612,7 @@ void LLNearbyChat::addMessage(const LLChat& chat,bool archive,const LLSD &args)
}
void LLNearbyChat::onChatBoxCommit()
void LLFloaterIMNearbyChat::onChatBoxCommit()
{
if (mInputEditor->getText().length() > 0)
{
@ -622,7 +622,7 @@ void LLNearbyChat::onChatBoxCommit()
gAgent.stopTyping();
}
void LLNearbyChat::displaySpeakingIndicator()
void LLFloaterIMNearbyChat::displaySpeakingIndicator()
{
LLSpeakerMgr::speaker_list_t speaker_list;
LLUUID id;
@ -652,12 +652,12 @@ void LLNearbyChat::displaySpeakingIndicator()
}
}
void LLNearbyChat::sendChatFromViewer(const std::string &utf8text, EChatType type, BOOL animate)
void LLFloaterIMNearbyChat::sendChatFromViewer(const std::string &utf8text, EChatType type, BOOL animate)
{
sendChatFromViewer(utf8str_to_wstring(utf8text), type, animate);
}
void LLNearbyChat::sendChatFromViewer(const LLWString &wtext, EChatType type, BOOL animate)
void LLFloaterIMNearbyChat::sendChatFromViewer(const LLWString &wtext, EChatType type, BOOL animate)
{
// Look for "/20 foo" channel chats.
S32 channel = 0;
@ -707,7 +707,7 @@ void LLNearbyChat::sendChatFromViewer(const LLWString &wtext, EChatType type, BO
}
// static
bool LLNearbyChat::isWordsName(const std::string& name)
bool LLFloaterIMNearbyChat::isWordsName(const std::string& name)
{
// checking to see if it's display name plus username in parentheses
S32 open_paren = name.find(" (", 0);
@ -727,9 +727,9 @@ bool LLNearbyChat::isWordsName(const std::string& name)
}
// static
void LLNearbyChat::startChat(const char* line)
void LLFloaterIMNearbyChat::startChat(const char* line)
{
LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
nearby_chat->show();
@ -749,9 +749,9 @@ void LLNearbyChat::startChat(const char* line)
// Exit "chat mode" and do the appropriate focus changes
// static
void LLNearbyChat::stopChat()
void LLFloaterIMNearbyChat::stopChat()
{
LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
nearby_chat->mInputEditor->setFocus(FALSE);
@ -761,7 +761,7 @@ void LLNearbyChat::stopChat()
// If input of the form "/20foo" or "/20 foo", returns "foo" and channel 20.
// Otherwise returns input and channel 0.
LLWString LLNearbyChat::stripChannelNumber(const LLWString &mesg, S32* channel)
LLWString LLFloaterIMNearbyChat::stripChannelNumber(const LLWString &mesg, S32* channel)
{
if (mesg[0] == '/'
&& mesg[1] == '/')

22
indra/newview/llnearbychat.h → indra/newview/llfloaterimnearbychat.h
View File

@ -1,6 +1,6 @@
/**
* @file llnearbychat.h
* @brief LLNearbyChat class definition
* @file llfloaterimnearbychat.h
* @brief LLFloaterIMNearbyChat class definition
*
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
* Second Life Viewer Source Code
@ -24,10 +24,10 @@
* $/LicenseInfo$
*/
#ifndef LL_LLNEARBYCHAT_H
#define LL_LLNEARBYCHAT_H
#ifndef LL_LLFLOATERIMNEARBYCHAT_H
#define LL_LLFLOATERIMNEARBYCHAT_H
#include "llimconversation.h"
#include "llfloaterimsessiontab.h"
#include "llcombobox.h"
#include "llgesturemgr.h"
#include "llchat.h"
@ -40,15 +40,15 @@
class LLResizeBar;
class LLNearbyChat
: public LLIMConversation
class LLFloaterIMNearbyChat
: public LLFloaterIMSessionTab
{
public:
// constructor for inline chat-bars (e.g. hosted in chat history window)
LLNearbyChat(const LLSD& key = LLSD(LLUUID()));
~LLNearbyChat() {}
LLFloaterIMNearbyChat(const LLSD& key = LLSD(LLUUID()));
~LLFloaterIMNearbyChat() {}
static LLNearbyChat* buildFloater(const LLSD& key);
static LLFloaterIMNearbyChat* buildFloater(const LLSD& key);
/*virtual*/ BOOL postBuild();
/*virtual*/ void onOpen(const LLSD& key);
@ -122,4 +122,4 @@ private:
};
#endif
#endif // LL_LLFLOATERIMNEARBYCHAT_H

96
indra/newview/llnearbychathandler.cpp → indra/newview/llfloaterimnearbychathandler.cpp
View File

@ -1,5 +1,5 @@
/**
* @file LLNearbyChatHandler.cpp
* @file LLFloaterIMNearbyChatHandler.cpp
* @brief Nearby chat chat managment
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
@ -27,45 +27,45 @@
#include "llviewerprecompiledheaders.h"
#include "llagentdata.h" // for gAgentID
#include "llnearbychathandler.h"
#include "llfloaterimnearbychathandler.h"
#include "llchatitemscontainerctrl.h"
#include "llfirstuse.h"
#include "llfloaterscriptdebug.h"
#include "llhints.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llrecentpeople.h"
#include "llviewercontrol.h"
#include "llfloaterreg.h"//for LLFloaterReg::getTypedInstance
#include "llviewerwindow.h"//for screen channel position
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llrootview.h"
#include "lllayoutstack.h"
//add LLNearbyChatHandler to LLNotificationsUI namespace
//add LLFloaterIMNearbyChatHandler to LLNotificationsUI namespace
using namespace LLNotificationsUI;
static LLNearbyChatToastPanel* createToastPanel()
static LLFloaterIMNearbyChatToastPanel* createToastPanel()
{
LLNearbyChatToastPanel* item = LLNearbyChatToastPanel::createInstance();
LLFloaterIMNearbyChatToastPanel* item = LLFloaterIMNearbyChatToastPanel::createInstance();
return item;
}
//-----------------------------------------------------------------------------------------------
//LLNearbyChatScreenChannel
//LLFloaterIMNearbyChatScreenChannel
//-----------------------------------------------------------------------------------------------
class LLNearbyChatScreenChannel: public LLScreenChannelBase
class LLFloaterIMNearbyChatScreenChannel: public LLScreenChannelBase
{
LOG_CLASS(LLNearbyChatScreenChannel);
LOG_CLASS(LLFloaterIMNearbyChatScreenChannel);
public:
typedef std::vector<LLHandle<LLToast> > toast_vec_t;
typedef std::list<LLHandle<LLToast> > toast_list_t;
LLNearbyChatScreenChannel(const Params& p)
LLFloaterIMNearbyChatScreenChannel(const Params& p)
: LLScreenChannelBase(p)
{
mStopProcessing = false;
@ -73,20 +73,20 @@ public:
LLControlVariable* ctrl = gSavedSettings.getControl("NearbyToastLifeTime").get();
if (ctrl)
{
ctrl->getSignal()->connect(boost::bind(&LLNearbyChatScreenChannel::updateToastsLifetime, this));
ctrl->getSignal()->connect(boost::bind(&LLFloaterIMNearbyChatScreenChannel::updateToastsLifetime, this));
}
ctrl = gSavedSettings.getControl("NearbyToastFadingTime").get();
if (ctrl)
{
ctrl->getSignal()->connect(boost::bind(&LLNearbyChatScreenChannel::updateToastFadingTime, this));
ctrl->getSignal()->connect(boost::bind(&LLFloaterIMNearbyChatScreenChannel::updateToastFadingTime, this));
}
}
void addChat (LLSD& chat);
void arrangeToasts ();
typedef boost::function<LLNearbyChatToastPanel* (void )> create_toast_panel_callback_t;
typedef boost::function<LLFloaterIMNearbyChatToastPanel* (void )> create_toast_panel_callback_t;
void setCreatePanelCallback(create_toast_panel_callback_t value) { m_create_toast_panel_callback_t = value;}
void onToastDestroyed (LLToast* toast, bool app_quitting);
@ -157,16 +157,16 @@ protected:
//-----------------------------------------------------------------------------------------------
// LLNearbyChatToast
// LLFloaterIMNearbyChatToast
//-----------------------------------------------------------------------------------------------
// We're deriving from LLToast to be able to override onClose()
// in order to handle closing nearby chat toasts properly.
class LLNearbyChatToast : public LLToast
class LLFloaterIMNearbyChatToast : public LLToast
{
LOG_CLASS(LLNearbyChatToast);
LOG_CLASS(LLFloaterIMNearbyChatToast);
public:
LLNearbyChatToast(const LLToast::Params& p, LLNearbyChatScreenChannel* nc_channelp)
LLFloaterIMNearbyChatToast(const LLToast::Params& p, LLFloaterIMNearbyChatScreenChannel* nc_channelp)
: LLToast(p),
mNearbyChatScreenChannelp(nc_channelp)
{
@ -175,14 +175,14 @@ public:
/*virtual*/ void onClose(bool app_quitting);
private:
LLNearbyChatScreenChannel* mNearbyChatScreenChannelp;
LLFloaterIMNearbyChatScreenChannel* mNearbyChatScreenChannelp;
};
//-----------------------------------------------------------------------------------------------
// LLNearbyChatScreenChannel
// LLFloaterIMNearbyChatScreenChannel
//-----------------------------------------------------------------------------------------------
void LLNearbyChatScreenChannel::deactivateToast(LLToast* toast)
void LLFloaterIMNearbyChatScreenChannel::deactivateToast(LLToast* toast)
{
toast_vec_t::iterator pos = std::find(m_active_toasts.begin(), m_active_toasts.end(), toast->getHandle());
@ -196,12 +196,12 @@ void LLNearbyChatScreenChannel::deactivateToast(LLToast* toast)
m_active_toasts.erase(pos);
}
void LLNearbyChatScreenChannel::createOverflowToast(S32 bottom, F32 timer)
void LLFloaterIMNearbyChatScreenChannel::createOverflowToast(S32 bottom, F32 timer)
{
//we don't need overflow toast in nearby chat
}
void LLNearbyChatScreenChannel::onToastDestroyed(LLToast* toast, bool app_quitting)
void LLFloaterIMNearbyChatScreenChannel::onToastDestroyed(LLToast* toast, bool app_quitting)
{
LL_DEBUGS("NearbyChat") << "Toast destroyed (app_quitting=" << app_quitting << ")" << llendl;
@ -220,7 +220,7 @@ void LLNearbyChatScreenChannel::onToastDestroyed(LLToast* toast, bool app_quitti
}
}
void LLNearbyChatScreenChannel::onToastFade(LLToast* toast)
void LLFloaterIMNearbyChatScreenChannel::onToastFade(LLToast* toast)
{
LL_DEBUGS("NearbyChat") << "Toast fading" << llendl;
@ -235,7 +235,7 @@ void LLNearbyChatScreenChannel::onToastFade(LLToast* toast)
arrangeToasts();
}
void LLNearbyChatScreenChannel::updateToastsLifetime()
void LLFloaterIMNearbyChatScreenChannel::updateToastsLifetime()
{
S32 seconds = gSavedSettings.getS32("NearbyToastLifeTime");
toast_list_t::iterator it;
@ -246,7 +246,7 @@ void LLNearbyChatScreenChannel::updateToastsLifetime()
}
}
void LLNearbyChatScreenChannel::updateToastFadingTime()
void LLFloaterIMNearbyChatScreenChannel::updateToastFadingTime()
{
S32 seconds = gSavedSettings.getS32("NearbyToastFadingTime");
toast_list_t::iterator it;
@ -257,9 +257,9 @@ void LLNearbyChatScreenChannel::updateToastFadingTime()
}
}
bool LLNearbyChatScreenChannel::createPoolToast()
bool LLFloaterIMNearbyChatScreenChannel::createPoolToast()
{
LLNearbyChatToastPanel* panel= m_create_toast_panel_callback_t();
LLFloaterIMNearbyChatToastPanel* panel= m_create_toast_panel_callback_t();
if(!panel)
return false;
@ -268,20 +268,20 @@ bool LLNearbyChatScreenChannel::createPoolToast()
p.lifetime_secs = gSavedSettings.getS32("NearbyToastLifeTime");
p.fading_time_secs = gSavedSettings.getS32("NearbyToastFadingTime");
LLToast* toast = new LLNearbyChatToast(p, this);
LLToast* toast = new LLFloaterIMNearbyChatToast(p, this);
toast->setOnFadeCallback(boost::bind(&LLNearbyChatScreenChannel::onToastFade, this, _1));
toast->setOnFadeCallback(boost::bind(&LLFloaterIMNearbyChatScreenChannel::onToastFade, this, _1));
// If the toast gets somehow prematurely destroyed, deactivate it to prevent crash (STORM-1352).
toast->setOnToastDestroyedCallback(boost::bind(&LLNearbyChatScreenChannel::onToastDestroyed, this, _1, false));
toast->setOnToastDestroyedCallback(boost::bind(&LLFloaterIMNearbyChatScreenChannel::onToastDestroyed, this, _1, false));
LL_DEBUGS("NearbyChat") << "Creating and pooling toast" << llendl;
m_toast_pool.push_back(toast->getHandle());
return true;
}
void LLNearbyChatScreenChannel::addChat(LLSD& chat)
void LLFloaterIMNearbyChatScreenChannel::addChat(LLSD& chat)
{
//look in pool. if there is any message
if(mStopProcessing)
@ -298,7 +298,7 @@ void LLNearbyChatScreenChannel::addChat(LLSD& chat)
LLToast* toast = m_active_toasts[0].get();
if (toast)
{
LLNearbyChatToastPanel* panel = dynamic_cast<LLNearbyChatToastPanel*>(toast->getPanel());
LLFloaterIMNearbyChatToastPanel* panel = dynamic_cast<LLFloaterIMNearbyChatToastPanel*>(toast->getPanel());
if(panel && panel->messageID() == fromID && panel->getFromName() == from && panel->canAddText())
{
@ -343,7 +343,7 @@ void LLNearbyChatScreenChannel::addChat(LLSD& chat)
m_toast_pool.pop_back();
LLNearbyChatToastPanel* panel = dynamic_cast<LLNearbyChatToastPanel*>(toast->getPanel());
LLFloaterIMNearbyChatToastPanel* panel = dynamic_cast<LLFloaterIMNearbyChatToastPanel*>(toast->getPanel());
if(!panel)
return;
panel->init(chat);
@ -365,7 +365,7 @@ static bool sort_toasts_predicate(LLHandle<LLToast> first, LLHandle<LLToast> sec
return v1 > v2;
}
void LLNearbyChatScreenChannel::arrangeToasts()
void LLFloaterIMNearbyChatScreenChannel::arrangeToasts()
{
if(mStopProcessing || isHovering())
return;
@ -445,18 +445,18 @@ void LLNearbyChatScreenChannel::arrangeToasts()
//-----------------------------------------------------------------------------------------------
//LLNearbyChatHandler
//LLFloaterIMNearbyChatHandler
//-----------------------------------------------------------------------------------------------
boost::scoped_ptr<LLEventPump> LLNearbyChatHandler::sChatWatcher(new LLEventStream("LLChat"));
boost::scoped_ptr<LLEventPump> LLFloaterIMNearbyChatHandler::sChatWatcher(new LLEventStream("LLChat"));
LLNearbyChatHandler::LLNearbyChatHandler()
LLFloaterIMNearbyChatHandler::LLFloaterIMNearbyChatHandler()
{
// Getting a Channel for our notifications
LLNearbyChatScreenChannel::Params p;
LLFloaterIMNearbyChatScreenChannel::Params p;
p.id = LLUUID(gSavedSettings.getString("NearByChatChannelUUID"));
LLNearbyChatScreenChannel* channel = new LLNearbyChatScreenChannel(p);
LLFloaterIMNearbyChatScreenChannel* channel = new LLFloaterIMNearbyChatScreenChannel(p);
LLNearbyChatScreenChannel::create_toast_panel_callback_t callback = createToastPanel;
LLFloaterIMNearbyChatScreenChannel::create_toast_panel_callback_t callback = createToastPanel;
channel->setCreatePanelCallback(callback);
@ -465,12 +465,12 @@ LLNearbyChatHandler::LLNearbyChatHandler()
mChannel = channel->getHandle();
}
LLNearbyChatHandler::~LLNearbyChatHandler()
LLFloaterIMNearbyChatHandler::~LLFloaterIMNearbyChatHandler()
{
}
void LLNearbyChatHandler::initChannel()
void LLFloaterIMNearbyChatHandler::initChannel()
{
//LLRect snap_rect = gFloaterView->getSnapRect();
//mChannel->init(snap_rect.mLeft, snap_rect.mLeft + 200);
@ -478,7 +478,7 @@ void LLNearbyChatHandler::initChannel()
void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
void LLFloaterIMNearbyChatHandler::processChat(const LLChat& chat_msg,
const LLSD &args)
{
if(chat_msg.mMuted == TRUE)
@ -488,7 +488,7 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
return;//don't process empty messages
LLFloaterReg::getInstance("im_container");
LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
// Build notification data
LLSD chat;
@ -581,7 +581,7 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
}
*/
LLNearbyChatScreenChannel* channel = dynamic_cast<LLNearbyChatScreenChannel*>(mChannel.get());
LLFloaterIMNearbyChatScreenChannel* channel = dynamic_cast<LLFloaterIMNearbyChatScreenChannel*>(mChannel.get());
if(channel)
{
@ -618,11 +618,11 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
//-----------------------------------------------------------------------------------------------
// LLNearbyChatToast
// LLFloaterIMNearbyChatToast
//-----------------------------------------------------------------------------------------------
// virtual
void LLNearbyChatToast::onClose(bool app_quitting)
void LLFloaterIMNearbyChatToast::onClose(bool app_quitting)
{
mNearbyChatScreenChannelp->onToastDestroyed(this, app_quitting);
}

16
indra/newview/llnearbychathandler.h → indra/newview/llfloaterimnearbychathandler.h
View File

@ -1,5 +1,5 @@
/**
* @file llnearbychathandler.h
* @file llfloaterimnearbychathandler.h
* @brief nearby chat notify
*
* $LicenseInfo:firstyear=2004&license=viewerlgpl$
@ -24,21 +24,21 @@
* $/LicenseInfo$
*/
#ifndef LL_LLNEARBYCHATHANDLER_H
#define LL_LLNEARBYCHATHANDLER_H
#ifndef LL_LLFLOATERIMNEARBYCHATHANDLER_H
#define LL_LLFLOATERIMNEARBYCHATHANDLER_H
#include "llnotificationhandler.h"
class LLEventPump;
//add LLNearbyChatHandler to LLNotificationsUI namespace
//add LLFloaterIMNearbyChatHandler to LLNotificationsUI namespace
namespace LLNotificationsUI{
class LLNearbyChatHandler : public LLChatHandler
class LLFloaterIMNearbyChatHandler : public LLChatHandler
{
public:
LLNearbyChatHandler();
virtual ~LLNearbyChatHandler();
LLFloaterIMNearbyChatHandler();
virtual ~LLFloaterIMNearbyChatHandler();
virtual void processChat(const LLChat& chat_msg, const LLSD &args);
@ -51,4 +51,4 @@ protected:
}
#endif /* LL_LLNEARBYCHATHANDLER_H */
#endif /* LL_LLFLOATERIMNEARBYCHATHANDLER_H */

14
indra/newview/llnearbychatbarlistener.cpp → indra/newview/llfloaterimnearbychatlistener.cpp
View File

@ -1,8 +1,8 @@
/**
* @file llnearbychatbarlistener.cpp
* @file llfloaterimnearbychatlistener.cpp
* @author Dave Simmons
* @date 2011-03-15
* @brief Implementation for LLNearbyChatBarListener.
* @brief Implementation for LLFloaterIMNearbyChatListener.
*
* $LicenseInfo:firstyear=2011&license=viewerlgpl$
* Second Life Viewer Source Code
@ -28,15 +28,15 @@
#include "llviewerprecompiledheaders.h"
#include "llnearbychatbarlistener.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychatlistener.h"
#include "llfloaterimnearbychat.h"
#include "llagent.h"
#include "llchat.h"
LLNearbyChatBarListener::LLNearbyChatBarListener(LLNearbyChat & chatbar)
LLFloaterIMNearbyChatListener::LLFloaterIMNearbyChatListener(LLFloaterIMNearbyChat & chatbar)
: LLEventAPI("LLChatBar",
"LLChatBar listener to (e.g.) sendChat, etc."),
mChatbar(chatbar)
@ -46,12 +46,12 @@ LLNearbyChatBarListener::LLNearbyChatBarListener(LLNearbyChat & chatbar)
"[\"message\"] chat message text [required]\n"
"[\"channel\"] chat channel number [default = 0]\n"
"[\"type\"] chat type \"whisper\", \"normal\", \"shout\" [default = \"normal\"]",
&LLNearbyChatBarListener::sendChat);
&LLFloaterIMNearbyChatListener::sendChat);
}
// "sendChat" command
void LLNearbyChatBarListener::sendChat(LLSD const & chat_data) const
void LLFloaterIMNearbyChatListener::sendChat(LLSD const & chat_data) const
{
// Extract the data
std::string chat_text = chat_data["message"].asString();

18
indra/newview/llnearbychatbarlistener.h → indra/newview/llfloaterimnearbychatlistener.h
View File

@ -1,8 +1,8 @@
/**
* @file llnearbychatbarlistener.h
* @file llfloaterimnearbychatlistener.h
* @author Dave Simmons
* @date 2011-03-15
* @brief Class definition for LLNearbyChatBarListener.
* @brief Class definition for LLFloaterIMNearbyChatListener.
*
* $LicenseInfo:firstyear=2011&license=viewerlgpl$
* Second Life Viewer Source Code
@ -27,24 +27,24 @@
*/
#ifndef LL_LLNEARBYCHATBARLISTENER_H
#define LL_LLNEARBYCHATBARLISTENER_H
#ifndef LL_LLFLOATERIMNEARBYCHATLISTENER_H
#define LL_LLFLOATERIMNEARBYCHATLISTENER_H
#include "lleventapi.h"
class LLSD;
class LLNearbyChat;
class LLFloaterIMNearbyChat;
class LLNearbyChatBarListener : public LLEventAPI
class LLFloaterIMNearbyChatListener : public LLEventAPI
{
public:
LLNearbyChatBarListener(LLNearbyChat & chatbar);
LLFloaterIMNearbyChatListener(LLFloaterIMNearbyChat & chatbar);
private:
void sendChat(LLSD const & chat_data) const;
LLNearbyChat & mChatbar;
LLFloaterIMNearbyChat & mChatbar;
};
#endif // LL_LLNEARBYCHATBARLISTENER_H
#endif // LL_LLFLOATERIMNEARBYCHATLISTENER_H

176
indra/newview/llimfloater.cpp → indra/newview/llfloaterimsession.cpp
View File

@ -1,6 +1,6 @@
/**
* @file llimfloater.cpp
* @brief LLIMFloater class definition
* @file llfloaterimsession.cpp
* @brief LLFloaterIMSession class definition
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
* Second Life Viewer Source Code
@ -26,7 +26,7 @@
#include "llviewerprecompiledheaders.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "lldraghandle.h"
#include "llnotificationsutil.h"
@ -41,7 +41,7 @@
#include "llchicletbar.h"
#include "llfloaterreg.h"
#include "llfloateravatarpicker.h"
#include "llimfloatercontainer.h" // to replace separate IM Floaters with multifloater container
#include "llfloaterimcontainer.h" // to replace separate IM Floaters with multifloater container
#include "llinventoryfunctions.h"
//#include "lllayoutstack.h"
#include "llchatentry.h"
@ -60,10 +60,10 @@
#include "llnotificationmanager.h"
#include "llautoreplace.h"
floater_showed_signal_t LLIMFloater::sIMFloaterShowedSignal;
floater_showed_signal_t LLFloaterIMSession::sIMFloaterShowedSignal;
LLIMFloater::LLIMFloater(const LLUUID& session_id)
: LLIMConversation(session_id),
LLFloaterIMSession::LLFloaterIMSession(const LLUUID& session_id)
: LLFloaterIMSessionTab(session_id),
mLastMessageIndex(-1),
mDialog(IM_NOTHING_SPECIAL),
mSavedTitle(),
@ -90,7 +90,7 @@ LLIMFloater::LLIMFloater(const LLUUID& session_id)
// virtual
void LLIMFloater::refresh()
void LLFloaterIMSession::refresh()
{
if (mMeTyping)
{
@ -103,7 +103,7 @@ void LLIMFloater::refresh()
}
// virtual
void LLIMFloater::onClickCloseBtn()
void LLFloaterIMSession::onClickCloseBtn()
{
LLIMModel::LLIMSession* session = LLIMModel::instance().findIMSession(mSessionID);
@ -129,17 +129,17 @@ void LLIMFloater::onClickCloseBtn()
return;
}
LLIMConversation::onClickCloseBtn();
LLFloaterIMSessionTab::onClickCloseBtn();
}
/* static */
void LLIMFloater::newIMCallback(const LLSD& data)
void LLFloaterIMSession::newIMCallback(const LLSD& data)
{
if (data["num_unread"].asInteger() > 0 || data["from_id"].asUUID().isNull())
{
LLUUID session_id = data["session_id"].asUUID();
LLIMFloater* floater = LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
LLFloaterIMSession* floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>("impanel", session_id);
// update if visible, otherwise will be updated when opened
if (floater && floater->getVisible())
@ -149,7 +149,7 @@ void LLIMFloater::newIMCallback(const LLSD& data)
}
}
void LLIMFloater::onVisibilityChange(const LLSD& new_visibility)
void LLFloaterIMSession::onVisibilityChange(const LLSD& new_visibility)
{
bool visible = new_visibility.asBoolean();
@ -166,14 +166,14 @@ void LLIMFloater::onVisibilityChange(const LLSD& new_visibility)
}
}
void LLIMFloater::onSendMsg( LLUICtrl* ctrl, void* userdata )
void LLFloaterIMSession::onSendMsg( LLUICtrl* ctrl, void* userdata )
{
LLIMFloater* self = (LLIMFloater*) userdata;
LLFloaterIMSession* self = (LLFloaterIMSession*) userdata;
self->sendMsgFromInputEditor();
self->setTyping(false);
}
void LLIMFloater::sendMsgFromInputEditor()
void LLFloaterIMSession::sendMsgFromInputEditor()
{
if (gAgent.isGodlike()
|| (mDialog != IM_NOTHING_SPECIAL)
@ -201,7 +201,7 @@ void LLIMFloater::sendMsgFromInputEditor()
}
}
void LLIMFloater::sendMsg(const std::string& msg)
void LLFloaterIMSession::sendMsg(const std::string& msg)
{
const std::string utf8_text = utf8str_truncate(msg, MAX_MSG_BUF_SIZE - 1);
@ -218,7 +218,7 @@ void LLIMFloater::sendMsg(const std::string& msg)
updateMessages();
}
LLIMFloater::~LLIMFloater()
LLFloaterIMSession::~LLFloaterIMSession()
{
mVoiceChannelStateChangeConnection.disconnect();
if(LLVoiceClient::instanceExists())
@ -230,7 +230,7 @@ LLIMFloater::~LLIMFloater()
}
void LLIMFloater::initIMSession(const LLUUID& session_id)
void LLFloaterIMSession::initIMSession(const LLUUID& session_id)
{
// Change the floater key to bind it to a new session.
setKey(session_id);
@ -246,7 +246,7 @@ void LLIMFloater::initIMSession(const LLUUID& session_id)
}
}
void LLIMFloater::initIMFloater()
void LLFloaterIMSession::initIMFloater()
{
const LLUUID& other_party_id =
LLIMModel::getInstance()->getOtherParticipantID(mSessionID);
@ -277,9 +277,9 @@ void LLIMFloater::initIMFloater()
}
//virtual
BOOL LLIMFloater::postBuild()
BOOL LLFloaterIMSession::postBuild()
{
BOOL result = LLIMConversation::postBuild();
BOOL result = LLFloaterIMSessionTab::postBuild();
mInputEditor->setMaxTextLength(1023);
// enable line history support for instant message bar
@ -300,9 +300,9 @@ BOOL LLIMFloater::postBuild()
// Allow to add chat participants depending on the session type
add_btn->setEnabled(isInviteAllowed());
add_btn->setClickedCallback(boost::bind(&LLIMFloater::onAddButtonClicked, this));
add_btn->setClickedCallback(boost::bind(&LLFloaterIMSession::onAddButtonClicked, this));
childSetAction("voice_call_btn", boost::bind(&LLIMFloater::onCallButtonClicked, this));
childSetAction("voice_call_btn", boost::bind(&LLFloaterIMSession::onCallButtonClicked, this));
LLVoiceClient::getInstance()->addObserver(this);
@ -314,18 +314,18 @@ BOOL LLIMFloater::postBuild()
return result;
}
void LLIMFloater::onAddButtonClicked()
void LLFloaterIMSession::onAddButtonClicked()
{
LLView * button = findChild<LLView>("toolbar_panel")->findChild<LLButton>("add_btn");
LLFloater* root_floater = gFloaterView->getParentFloater(this);
LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(boost::bind(&LLIMFloater::addSessionParticipants, this, _1), TRUE, TRUE, FALSE, root_floater->getName(), button);
LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(boost::bind(&LLFloaterIMSession::addSessionParticipants, this, _1), TRUE, TRUE, FALSE, root_floater->getName(), button);
if (!picker)
{
return;
}
// Need to disable 'ok' button when selected users are already in conversation.
picker->setOkBtnEnableCb(boost::bind(&LLIMFloater::canAddSelectedToChat, this, _1));
picker->setOkBtnEnableCb(boost::bind(&LLFloaterIMSession::canAddSelectedToChat, this, _1));
if (root_floater)
{
@ -333,7 +333,7 @@ void LLIMFloater::onAddButtonClicked()
}
}
bool LLIMFloater::canAddSelectedToChat(const uuid_vec_t& uuids)
bool LLFloaterIMSession::canAddSelectedToChat(const uuid_vec_t& uuids)
{
if (!mSession
|| mDialog == IM_SESSION_GROUP_START
@ -385,7 +385,7 @@ bool LLIMFloater::canAddSelectedToChat(const uuid_vec_t& uuids)
return true;
}
void LLIMFloater::addSessionParticipants(const uuid_vec_t& uuids)
void LLFloaterIMSession::addSessionParticipants(const uuid_vec_t& uuids)
{
if (mIsP2PChat)
{
@ -393,7 +393,7 @@ void LLIMFloater::addSessionParticipants(const uuid_vec_t& uuids)
LLSD args;
LLNotificationsUtil::add("ConfirmAddingChatParticipants", args, payload,
boost::bind(&LLIMFloater::addP2PSessionParticipants, this, _1, _2, uuids));
boost::bind(&LLFloaterIMSession::addP2PSessionParticipants, this, _1, _2, uuids));
}
else
{
@ -404,7 +404,7 @@ void LLIMFloater::addSessionParticipants(const uuid_vec_t& uuids)
}
}
void LLIMFloater::addP2PSessionParticipants(const LLSD& notification, const LLSD& response, const uuid_vec_t& uuids)
void LLFloaterIMSession::addP2PSessionParticipants(const LLSD& notification, const LLSD& response, const uuid_vec_t& uuids)
{
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
if (option != 0)
@ -446,7 +446,7 @@ void LLIMFloater::addP2PSessionParticipants(const LLSD& notification, const LLSD
}
}
void LLIMFloater::sendParticipantsAddedNotification(const uuid_vec_t& uuids)
void LLFloaterIMSession::sendParticipantsAddedNotification(const uuid_vec_t& uuids)
{
std::string names_string;
LLAvatarActions::buildResidentsString(uuids, names_string);
@ -456,13 +456,13 @@ void LLIMFloater::sendParticipantsAddedNotification(const uuid_vec_t& uuids)
sendMsg(getString(uuids.size() > 1 ? "multiple_participants_added" : "participant_added", args));
}
void LLIMFloater::boundVoiceChannel()
void LLFloaterIMSession::boundVoiceChannel()
{
LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);
if(voice_channel)
{
mVoiceChannelStateChangeConnection = voice_channel->setStateChangedCallback(
boost::bind(&LLIMFloater::onVoiceChannelStateChanged, this, _1, _2));
boost::bind(&LLFloaterIMSession::onVoiceChannelStateChanged, this, _1, _2));
//call (either p2p, group or ad-hoc) can be already in started state
bool callIsActive = voice_channel->getState() >= LLVoiceChannel::STATE_CALL_STARTED;
@ -470,7 +470,7 @@ void LLIMFloater::boundVoiceChannel()
}
}
void LLIMFloater::onCallButtonClicked()
void LLFloaterIMSession::onCallButtonClicked()
{
LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);
if (voice_channel)
@ -487,7 +487,7 @@ void LLIMFloater::onCallButtonClicked()
}
}
void LLIMFloater::onChange(EStatusType status, const std::string &channelURI, bool proximal)
void LLFloaterIMSession::onChange(EStatusType status, const std::string &channelURI, bool proximal)
{
if(status != STATUS_JOINING && status != STATUS_LEFT_CHANNEL)
{
@ -495,22 +495,22 @@ void LLIMFloater::onChange(EStatusType status, const std::string &channelURI, bo
}
}
void LLIMFloater::onVoiceChannelStateChanged(
void LLFloaterIMSession::onVoiceChannelStateChanged(
const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state)
{
bool callIsActive = new_state >= LLVoiceChannel::STATE_CALL_STARTED;
updateCallBtnState(callIsActive);
}
void LLIMFloater::updateSessionName(const std::string& name)
void LLFloaterIMSession::updateSessionName(const std::string& name)
{
LLIMConversation::updateSessionName(name);
LLFloaterIMSessionTab::updateSessionName(name);
setTitle(name);
mTypingStart.setArg("[NAME]", name);
}
//static
LLIMFloater* LLIMFloater::show(const LLUUID& session_id)
LLFloaterIMSession* LLFloaterIMSession::show(const LLUUID& session_id)
{
closeHiddenIMToasts();
@ -521,11 +521,11 @@ LLIMFloater* LLIMFloater::show(const LLUUID& session_id)
bool exist = findInstance(session_id);
// Get the floater: this will create the instance if it didn't exist
LLIMFloater* floater = getInstance(session_id);
LLFloaterIMSession* floater = getInstance(session_id);
if (!floater)
return NULL;
LLIMFloaterContainer* floater_container = LLIMFloaterContainer::getInstance();
LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance();
// Do not add again existing floaters
if (!exist)
@ -546,23 +546,23 @@ LLIMFloater* LLIMFloater::show(const LLUUID& session_id)
return floater;
}
//static
LLIMFloater* LLIMFloater::findInstance(const LLUUID& session_id)
LLFloaterIMSession* LLFloaterIMSession::findInstance(const LLUUID& session_id)
{
LLIMFloater* conversation =
LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
LLFloaterIMSession* conversation =
LLFloaterReg::findTypedInstance<LLFloaterIMSession>("impanel", session_id);
return conversation;
}
LLIMFloater* LLIMFloater::getInstance(const LLUUID& session_id)
LLFloaterIMSession* LLFloaterIMSession::getInstance(const LLUUID& session_id)
{
LLIMFloater* conversation =
LLFloaterReg::getTypedInstance<LLIMFloater>("impanel", session_id);
LLFloaterIMSession* conversation =
LLFloaterReg::getTypedInstance<LLFloaterIMSession>("impanel", session_id);
return conversation;
}
void LLIMFloater::onClose(bool app_quitting)
void LLFloaterIMSession::onClose(bool app_quitting)
{
setTyping(false);
@ -574,10 +574,10 @@ void LLIMFloater::onClose(bool app_quitting)
gIMMgr->leaveSession(mSessionID);
// Clean up the conversation *after* the session has been ended
LLIMConversation::onClose(app_quitting);
LLFloaterIMSessionTab::onClose(app_quitting);
}
void LLIMFloater::setDocked(bool docked, bool pop_on_undock)
void LLFloaterIMSession::setDocked(bool docked, bool pop_on_undock)
{
// update notification channel state
LLNotificationsUI::LLScreenChannel* channel = static_cast<LLNotificationsUI::LLScreenChannel*>
@ -597,13 +597,13 @@ void LLIMFloater::setDocked(bool docked, bool pop_on_undock)
}
}
void LLIMFloater::setVisible(BOOL visible)
void LLFloaterIMSession::setVisible(BOOL visible)
{
LLNotificationsUI::LLScreenChannel* channel = static_cast<LLNotificationsUI::LLScreenChannel*>
(LLNotificationsUI::LLChannelManager::getInstance()->
findChannelByID(LLUUID(gSavedSettings.getString("NotificationChannelUUID"))));
LLIMConversation::setVisible(visible);
LLFloaterIMSessionTab::setVisible(visible);
// update notification channel state
if(channel)
@ -630,14 +630,14 @@ void LLIMFloater::setVisible(BOOL visible)
setFocus(visible);
}
BOOL LLIMFloater::getVisible()
BOOL LLFloaterIMSession::getVisible()
{
bool visible;
if(isChatMultiTab())
{
LLIMFloaterContainer* im_container =
LLIMFloaterContainer::getInstance();
LLFloaterIMContainer* im_container =
LLFloaterIMContainer::getInstance();
// Treat inactive floater as invisible.
bool is_active = im_container->getActiveFloater() == this;
@ -663,11 +663,11 @@ BOOL LLIMFloater::getVisible()
}
//static
bool LLIMFloater::toggle(const LLUUID& session_id)
bool LLFloaterIMSession::toggle(const LLUUID& session_id)
{
if(!isChatMultiTab())
{
LLIMFloater* floater = LLFloaterReg::findTypedInstance<LLIMFloater>(
LLFloaterIMSession* floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>(
"impanel", session_id);
if (floater && floater->getVisible() && floater->hasFocus())
{
@ -689,7 +689,7 @@ bool LLIMFloater::toggle(const LLUUID& session_id)
return true;
}
void LLIMFloater::sessionInitReplyReceived(const LLUUID& im_session_id)
void LLFloaterIMSession::sessionInitReplyReceived(const LLUUID& im_session_id)
{
mSessionInitialized = true;
@ -719,7 +719,7 @@ void LLIMFloater::sessionInitReplyReceived(const LLUUID& im_session_id)
}
}
void LLIMFloater::updateMessages()
void LLFloaterIMSession::updateMessages()
{
std::list<LLSD> messages;
@ -798,7 +798,7 @@ void LLIMFloater::updateMessages()
}
}
void LLIMFloater::reloadMessages()
void LLFloaterIMSession::reloadMessages()
{
mChatHistory->clear();
mLastMessageIndex = -1;
@ -807,11 +807,11 @@ void LLIMFloater::reloadMessages()
}
// static
void LLIMFloater::onInputEditorFocusReceived( LLFocusableElement* caller, void* userdata )
void LLFloaterIMSession::onInputEditorFocusReceived( LLFocusableElement* caller, void* userdata )
{
LLIMFloater* self= (LLIMFloater*) userdata;
LLFloaterIMSession* self= (LLFloaterIMSession*) userdata;
// Allow enabling the LLIMFloater input editor only if session can accept text
// Allow enabling the LLFloaterIMSession input editor only if session can accept text
LLIMModel::LLIMSession* im_session =
LLIMModel::instance().findIMSession(self->mSessionID);
//TODO: While disabled lllineeditor can receive focus we need to check if it is enabled (EK)
@ -823,23 +823,23 @@ void LLIMFloater::onInputEditorFocusReceived( LLFocusableElement* caller, void*
}
// static
void LLIMFloater::onInputEditorFocusLost(LLFocusableElement* caller, void* userdata)
void LLFloaterIMSession::onInputEditorFocusLost(LLFocusableElement* caller, void* userdata)
{
LLIMFloater* self = (LLIMFloater*) userdata;
LLFloaterIMSession* self = (LLFloaterIMSession*) userdata;
self->setTyping(false);
}
// static
void LLIMFloater::onInputEditorKeystroke(LLTextEditor* caller, void* userdata)
void LLFloaterIMSession::onInputEditorKeystroke(LLTextEditor* caller, void* userdata)
{
LLIMFloater* self = (LLIMFloater*)userdata;
LLFloaterIMSession* self = (LLFloaterIMSession*)userdata;
std::string text = self->mInputEditor->getText();
// Deleting all text counts as stopping typing.
self->setTyping(!text.empty());
}
void LLIMFloater::setTyping(bool typing)
void LLFloaterIMSession::setTyping(bool typing)
{
if ( typing )
{
@ -881,7 +881,7 @@ void LLIMFloater::setTyping(bool typing)
}
}
void LLIMFloater::processIMTyping(const LLIMInfo* im_info, BOOL typing)
void LLFloaterIMSession::processIMTyping(const LLIMInfo* im_info, BOOL typing)
{
if ( typing )
{
@ -895,7 +895,7 @@ void LLIMFloater::processIMTyping(const LLIMInfo* im_info, BOOL typing)
}
}
void LLIMFloater::processAgentListUpdates(const LLSD& body)
void LLFloaterIMSession::processAgentListUpdates(const LLSD& body)
{
uuid_vec_t joined_uuids;
@ -959,7 +959,7 @@ void LLIMFloater::processAgentListUpdates(const LLSD& body)
mInvitedParticipants.end());
}
void LLIMFloater::processSessionUpdate(const LLSD& session_update)
void LLFloaterIMSession::processSessionUpdate(const LLSD& session_update)
{
// *TODO : verify following code when moderated mode will be implemented
if ( false && session_update.has("moderated_mode") &&
@ -985,7 +985,7 @@ void LLIMFloater::processSessionUpdate(const LLSD& session_update)
}
// virtual
BOOL LLIMFloater::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
BOOL LLFloaterIMSession::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
EDragAndDropType cargo_type,
void* cargo_data,
EAcceptance* accept,
@ -1011,7 +1011,7 @@ BOOL LLIMFloater::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
return TRUE;
}
bool LLIMFloater::dropPerson(LLUUID* person_id, bool drop)
bool LLFloaterIMSession::dropPerson(LLUUID* person_id, bool drop)
{
bool res = person_id && person_id->notNull();
if(res)
@ -1029,7 +1029,7 @@ bool LLIMFloater::dropPerson(LLUUID* person_id, bool drop)
return res;
}
BOOL LLIMFloater::isInviteAllowed() const
BOOL LLFloaterIMSession::isInviteAllowed() const
{
return ( (IM_SESSION_CONFERENCE_START == mDialog)
|| (IM_SESSION_INVITE == mDialog && !gAgent.isInGroup(mSessionID))
@ -1054,7 +1054,7 @@ private:
LLUUID mSessionID;
};
BOOL LLIMFloater::inviteToSession(const uuid_vec_t& ids)
BOOL LLFloaterIMSession::inviteToSession(const uuid_vec_t& ids)
{
LLViewerRegion* region = gAgent.getRegion();
bool is_region_exist = region != NULL;
@ -1065,7 +1065,7 @@ BOOL LLIMFloater::inviteToSession(const uuid_vec_t& ids)
if( isInviteAllowed() && (count > 0) )
{
llinfos << "LLIMFloater::inviteToSession() - inviting participants" << llendl;
llinfos << "LLFloaterIMSession::inviteToSession() - inviting participants" << llendl;
std::string url = region->getCapability("ChatSessionRequest");
@ -1081,7 +1081,7 @@ BOOL LLIMFloater::inviteToSession(const uuid_vec_t& ids)
}
else
{
llinfos << "LLIMFloater::inviteToSession -"
llinfos << "LLFloaterIMSession::inviteToSession -"
<< " no need to invite agents for "
<< mDialog << llendl;
// successful add, because everyone that needed to get added
@ -1092,7 +1092,7 @@ BOOL LLIMFloater::inviteToSession(const uuid_vec_t& ids)
return is_region_exist;
}
void LLIMFloater::addTypingIndicator(const LLIMInfo* im_info)
void LLFloaterIMSession::addTypingIndicator(const LLIMInfo* im_info)
{
// We may have lost a "stop-typing" packet, don't add it twice
if ( im_info && !mOtherTyping )
@ -1112,7 +1112,7 @@ void LLIMFloater::addTypingIndicator(const LLIMInfo* im_info)
}
}
void LLIMFloater::removeTypingIndicator(const LLIMInfo* im_info)
void LLFloaterIMSession::removeTypingIndicator(const LLIMInfo* im_info)
{
if ( mOtherTyping )
{
@ -1134,7 +1134,7 @@ void LLIMFloater::removeTypingIndicator(const LLIMInfo* im_info)
}
// static
void LLIMFloater::closeHiddenIMToasts()
void LLFloaterIMSession::closeHiddenIMToasts()
{
class IMToastMatcher: public LLNotificationsUI::LLScreenChannel::Matcher
{
@ -1154,7 +1154,7 @@ void LLIMFloater::closeHiddenIMToasts()
}
}
// static
void LLIMFloater::confirmLeaveCallCallback(const LLSD& notification, const LLSD& response)
void LLFloaterIMSession::confirmLeaveCallCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
const LLSD& payload = notification["payload"];
@ -1170,7 +1170,7 @@ void LLIMFloater::confirmLeaveCallCallback(const LLSD& notification, const LLSD&
}
// static
void LLIMFloater::sRemoveTypingIndicator(const LLSD& data)
void LLFloaterIMSession::sRemoveTypingIndicator(const LLSD& data)
{
LLUUID session_id = data["session_id"];
if (session_id.isNull())
@ -1180,7 +1180,7 @@ void LLIMFloater::sRemoveTypingIndicator(const LLSD& data)
if (gAgentID == from_id || LLUUID::null == from_id)
return;
LLIMFloater* floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* floater = LLFloaterIMSession::findInstance(session_id);
if (!floater)
return;
@ -1191,12 +1191,12 @@ void LLIMFloater::sRemoveTypingIndicator(const LLSD& data)
}
// static
void LLIMFloater::onIMChicletCreated( const LLUUID& session_id )
void LLFloaterIMSession::onIMChicletCreated( const LLUUID& session_id )
{
LLIMFloater::addToHost(session_id);
LLFloaterIMSession::addToHost(session_id);
}
boost::signals2::connection LLIMFloater::setIMFloaterShowedCallback(const floater_showed_signal_t::slot_type& cb)
boost::signals2::connection LLFloaterIMSession::setIMFloaterShowedCallback(const floater_showed_signal_t::slot_type& cb)
{
return LLIMFloater::sIMFloaterShowedSignal.connect(cb);
return LLFloaterIMSession::sIMFloaterShowedSignal.connect(cb);
}

28
indra/newview/llimfloater.h → indra/newview/llfloaterimsession.h
View File

@ -1,6 +1,6 @@
/**
* @file llimfloater.h
* @brief LLIMFloater class definition
* @file llfloaterimsession.h
* @brief LLFloaterIMSession class definition
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
* Second Life Viewer Source Code
@ -24,11 +24,11 @@
* $/LicenseInfo$
*/
#ifndef LL_IMFLOATER_H
#define LL_IMFLOATER_H
#ifndef LL_FLOATERIMSESSION_H
#define LL_FLOATERIMSESSION_H
#include "llimview.h"
#include "llimconversation.h"
#include "llfloaterimsessiontab.h"
#include "llinstantmessage.h"
#include "lllogchat.h"
#include "lltooldraganddrop.h"
@ -50,15 +50,15 @@ typedef boost::signals2::signal<void(const LLUUID& session_id)> floater_showed_s
* Individual IM window that appears at the bottom of the screen,
* optionally "docked" to the bottom tray.
*/
class LLIMFloater
class LLFloaterIMSession
: public LLVoiceClientStatusObserver
, public LLIMConversation
, public LLFloaterIMSessionTab
{
LOG_CLASS(LLIMFloater);
LOG_CLASS(LLFloaterIMSession);
public:
LLIMFloater(const LLUUID& session_id);
LLFloaterIMSession(const LLUUID& session_id);
virtual ~LLIMFloater();
virtual ~LLFloaterIMSession();
void initIMSession(const LLUUID& session_id);
void initIMFloater();
@ -69,14 +69,14 @@ public:
/*virtual*/ BOOL getVisible();
// Check typing timeout timer.
static LLIMFloater* findInstance(const LLUUID& session_id);
static LLIMFloater* getInstance(const LLUUID& session_id);
static LLFloaterIMSession* findInstance(const LLUUID& session_id);
static LLFloaterIMSession* getInstance(const LLUUID& session_id);
// LLFloater overrides
/*virtual*/ void onClose(bool app_quitting);
/*virtual*/ void setDocked(bool docked, bool pop_on_undock = true);
// Make IM conversion visible and update the message history
static LLIMFloater* show(const LLUUID& session_id);
static LLFloaterIMSession* show(const LLUUID& session_id);
// Toggle panel specified by session_id
// Returns true iff panel became visible
@ -193,4 +193,4 @@ private:
boost::signals2::connection mVoiceChannelStateChangeConnection;
};
#endif // LL_IMFLOATER_H
#endif // LL_FLOATERIMSESSION_H

152
indra/newview/llimconversation.cpp → indra/newview/llfloaterimsessiontab.cpp
View File

@ -1,7 +1,7 @@
/**
* @file llimconversation.cpp
* @brief LLIMConversation class implements the common behavior of LNearbyChatBar
* @brief and LLIMFloater for hosting both in LLIMContainer
* @file llfloaterimsessiontab.cpp
* @brief LLFloaterIMSessionTab class implements the common behavior of LNearbyChatBar
* @brief and LLFloaterIMSession for hosting both in LLIMContainer
*
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
* Second Life Viewer Source Code
@ -27,7 +27,7 @@
#include "llviewerprecompiledheaders.h"
#include "llimconversation.h"
#include "llfloaterimsessiontab.h"
#include "llagent.h"
#include "llavataractions.h"
@ -37,14 +37,14 @@
#include "llchicletbar.h"
#include "lldraghandle.h"
#include "llfloaterreg.h"
#include "llimfloater.h"
#include "llimfloatercontainer.h" // to replace separate IM Floaters with multifloater container
#include "llfloaterimsession.h"
#include "llfloaterimcontainer.h" // to replace separate IM Floaters with multifloater container
#include "lllayoutstack.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
const F32 REFRESH_INTERVAL = 0.2f;
LLIMConversation::LLIMConversation(const LLSD& session_id)
LLFloaterIMSessionTab::LLFloaterIMSessionTab(const LLSD& session_id)
: LLTransientDockableFloater(NULL, true, session_id)
, mIsP2PChat(false)
, mExpandCollapseBtn(NULL)
@ -61,71 +61,71 @@ LLIMConversation::LLIMConversation(const LLSD& session_id)
mSession = LLIMModel::getInstance()->findIMSession(mSessionID);
mCommitCallbackRegistrar.add("IMSession.Menu.Action",
boost::bind(&LLIMConversation::onIMSessionMenuItemClicked, this, _2));
boost::bind(&LLFloaterIMSessionTab::onIMSessionMenuItemClicked, this, _2));
mEnableCallbackRegistrar.add("IMSession.Menu.CompactExpandedModes.CheckItem",
boost::bind(&LLIMConversation::onIMCompactExpandedMenuItemCheck, this, _2));
boost::bind(&LLFloaterIMSessionTab::onIMCompactExpandedMenuItemCheck, this, _2));
mEnableCallbackRegistrar.add("IMSession.Menu.ShowModes.CheckItem",
boost::bind(&LLIMConversation::onIMShowModesMenuItemCheck, this, _2));
boost::bind(&LLFloaterIMSessionTab::onIMShowModesMenuItemCheck, this, _2));
mEnableCallbackRegistrar.add("IMSession.Menu.ShowModes.Enable",
boost::bind(&LLIMConversation::onIMShowModesMenuItemEnable, this, _2));
boost::bind(&LLFloaterIMSessionTab::onIMShowModesMenuItemEnable, this, _2));
// Zero expiry time is set only once to allow initial update.
mRefreshTimer->setTimerExpirySec(0);
mRefreshTimer->start();
}
LLIMConversation::~LLIMConversation()
LLFloaterIMSessionTab::~LLFloaterIMSessionTab()
{
delete mRefreshTimer;
}
//static
LLIMConversation* LLIMConversation::findConversation(const LLUUID& uuid)
LLFloaterIMSessionTab* LLFloaterIMSessionTab::findConversation(const LLUUID& uuid)
{
LLIMConversation* conv;
LLFloaterIMSessionTab* conv;
if (uuid.isNull())
{
conv = LLFloaterReg::findTypedInstance<LLIMConversation>("nearby_chat");
conv = LLFloaterReg::findTypedInstance<LLFloaterIMSessionTab>("nearby_chat");
}
else
{
conv = LLFloaterReg::findTypedInstance<LLIMConversation>("impanel", LLSD(uuid));
conv = LLFloaterReg::findTypedInstance<LLFloaterIMSessionTab>("impanel", LLSD(uuid));
}
return conv;
};
//static
LLIMConversation* LLIMConversation::getConversation(const LLUUID& uuid)
LLFloaterIMSessionTab* LLFloaterIMSessionTab::getConversation(const LLUUID& uuid)
{
LLIMConversation* conv;
LLFloaterIMSessionTab* conv;
if (uuid.isNull())
{
conv = LLFloaterReg::getTypedInstance<LLIMConversation>("nearby_chat");
conv = LLFloaterReg::getTypedInstance<LLFloaterIMSessionTab>("nearby_chat");
}
else
{
conv = LLFloaterReg::getTypedInstance<LLIMConversation>("impanel", LLSD(uuid));
conv = LLFloaterReg::getTypedInstance<LLFloaterIMSessionTab>("impanel", LLSD(uuid));
}
return conv;
};
void LLIMConversation::setVisible(BOOL visible)
void LLFloaterIMSessionTab::setVisible(BOOL visible)
{
LLTransientDockableFloater::setVisible(visible);
if(visible)
{
LLIMConversation::addToHost(mSessionID);
LLFloaterIMSessionTab::addToHost(mSessionID);
}
setFocus(visible);
}
/*virtual*/
void LLIMConversation::setFocus(BOOL focus)
void LLFloaterIMSessionTab::setFocus(BOOL focus)
{
LLTransientDockableFloater::setFocus(focus);
@ -142,19 +142,19 @@ void LLIMConversation::setFocus(BOOL focus)
}
void LLIMConversation::addToHost(const LLUUID& session_id)
void LLFloaterIMSessionTab::addToHost(const LLUUID& session_id)
{
if ((session_id.notNull() && !gIMMgr->hasSession(session_id))
|| !LLIMConversation::isChatMultiTab())
|| !LLFloaterIMSessionTab::isChatMultiTab())
{
return;
}
// Get the floater: this will create the instance if it didn't exist
LLIMConversation* conversp = LLIMConversation::getConversation(session_id);
LLFloaterIMSessionTab* conversp = LLFloaterIMSessionTab::getConversation(session_id);
if (conversp)
{
LLIMFloaterContainer* floater_container = LLIMFloaterContainer::getInstance();
LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance();
// Do not add again existing floaters
if (floater_container && !conversp->isHostAttached())
@ -180,7 +180,7 @@ void LLIMConversation::addToHost(const LLUUID& session_id)
}
}
BOOL LLIMConversation::postBuild()
BOOL LLFloaterIMSessionTab::postBuild()
{
BOOL result;
@ -188,10 +188,10 @@ BOOL LLIMConversation::postBuild()
mCloseBtn->setCommitCallback(boost::bind(&LLFloater::onClickClose, this));
mExpandCollapseBtn = getChild<LLButton>("expand_collapse_btn");
mExpandCollapseBtn->setClickedCallback(boost::bind(&LLIMConversation::onSlide, this));
mExpandCollapseBtn->setClickedCallback(boost::bind(&LLFloaterIMSessionTab::onSlide, this));
mTearOffBtn = getChild<LLButton>("tear_off_btn");
mTearOffBtn->setCommitCallback(boost::bind(&LLIMConversation::onTearOffClicked, this));
mTearOffBtn->setCommitCallback(boost::bind(&LLFloaterIMSessionTab::onTearOffClicked, this));
mParticipantListPanel = getChild<LLLayoutPanel>("speakers_list_panel");
@ -226,7 +226,7 @@ BOOL LLIMConversation::postBuild()
mChatHistory = getChild<LLChatHistory>("chat_history");
mInputEditor = getChild<LLChatEntry>("chat_editor");
mInputEditor->setTextExpandedCallback(boost::bind(&LLIMConversation::reshapeChatHistory, this));
mInputEditor->setTextExpandedCallback(boost::bind(&LLFloaterIMSessionTab::reshapeChatHistory, this));
mInputEditor->setCommitOnFocusLost( FALSE );
mInputEditor->setPassDelete(TRUE);
mInputEditor->setFont(LLViewerChat::getChatFont());
@ -254,12 +254,12 @@ BOOL LLIMConversation::postBuild()
return result;
}
LLParticipantList* LLIMConversation::getParticipantList()
LLParticipantList* LLFloaterIMSessionTab::getParticipantList()
{
return dynamic_cast<LLParticipantList*>(LLIMFloaterContainer::getInstance()->getSessionModel(mSessionID));
return dynamic_cast<LLParticipantList*>(LLFloaterIMContainer::getInstance()->getSessionModel(mSessionID));
}
void LLIMConversation::draw()
void LLFloaterIMSessionTab::draw()
{
if (mRefreshTimer->hasExpired())
{
@ -277,7 +277,7 @@ void LLIMConversation::draw()
LLTransientDockableFloater::draw();
}
void LLIMConversation::enableDisableCallBtn()
void LLFloaterIMSessionTab::enableDisableCallBtn()
{
getChildView("voice_call_btn")->setEnabled(
mSessionID.notNull()
@ -288,7 +288,7 @@ void LLIMConversation::enableDisableCallBtn()
&& mSession->mCallBackEnabled);
}
void LLIMConversation::onFocusReceived()
void LLFloaterIMSessionTab::onFocusReceived()
{
setBackgroundOpaque(true);
@ -299,20 +299,20 @@ void LLIMConversation::onFocusReceived()
LLTransientDockableFloater::onFocusReceived();
LLIMFloaterContainer* container = LLFloaterReg::getTypedInstance<LLIMFloaterContainer>("im_container");
LLFloaterIMContainer* container = LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");
if (container)
{
container->selectConversationPair(mSessionID, true);
}
}
void LLIMConversation::onFocusLost()
void LLFloaterIMSessionTab::onFocusLost()
{
setBackgroundOpaque(false);
LLTransientDockableFloater::onFocusLost();
}
std::string LLIMConversation::appendTime()
std::string LLFloaterIMSessionTab::appendTime()
{
time_t utc_time;
utc_time = time_corrected();
@ -327,10 +327,10 @@ std::string LLIMConversation::appendTime()
return timeStr;
}
void LLIMConversation::appendMessage(const LLChat& chat, const LLSD &args)
void LLFloaterIMSessionTab::appendMessage(const LLChat& chat, const LLSD &args)
{
// Update the participant activity time
LLIMFloaterContainer* im_box = LLIMFloaterContainer::findInstance();
LLFloaterIMContainer* im_box = LLFloaterIMContainer::findInstance();
if (im_box)
{
im_box->setTimeNow(mSessionID,chat.mFromID);
@ -361,7 +361,7 @@ void LLIMConversation::appendMessage(const LLChat& chat, const LLSD &args)
}
void LLIMConversation::buildConversationViewParticipant()
void LLFloaterIMSessionTab::buildConversationViewParticipant()
{
// Clear the widget list since we are rebuilding afresh from the model
conversations_widgets_map::iterator widget_it = mConversationsWidgets.begin();
@ -391,7 +391,7 @@ void LLIMConversation::buildConversationViewParticipant()
}
}
void LLIMConversation::addConversationViewParticipant(LLConversationItem* participant_model)
void LLFloaterIMSessionTab::addConversationViewParticipant(LLConversationItem* participant_model)
{
// Check if the model already has an associated view
LLUUID uuid = participant_model->getUUID();
@ -412,7 +412,7 @@ void LLIMConversation::addConversationViewParticipant(LLConversationItem* partic
}
}
void LLIMConversation::removeConversationViewParticipant(const LLUUID& participant_id)
void LLFloaterIMSessionTab::removeConversationViewParticipant(const LLUUID& participant_id)
{
LLFolderViewItem* widget = get_ptr_in_map(mConversationsWidgets,participant_id);
if (widget)
@ -424,7 +424,7 @@ void LLIMConversation::removeConversationViewParticipant(const LLUUID& participa
}
}
void LLIMConversation::updateConversationViewParticipant(const LLUUID& participant_id)
void LLFloaterIMSessionTab::updateConversationViewParticipant(const LLUUID& participant_id)
{
LLFolderViewItem* widget = get_ptr_in_map(mConversationsWidgets,participant_id);
if (widget)
@ -434,7 +434,7 @@ void LLIMConversation::updateConversationViewParticipant(const LLUUID& participa
refreshConversation();
}
void LLIMConversation::refreshConversation()
void LLFloaterIMSessionTab::refreshConversation()
{
// Note: We collect participants names to change the session name only in the case of ad-hoc conversations
bool is_ad_hoc = (mSession ? mSession->isAdHocSessionType() : false);
@ -478,8 +478,8 @@ void LLIMConversation::refreshConversation()
refresh();
}
// Copied from LLIMFloaterContainer::createConversationViewParticipant(). Refactor opportunity!
LLConversationViewParticipant* LLIMConversation::createConversationViewParticipant(LLConversationItem* item)
// Copied from LLFloaterIMContainer::createConversationViewParticipant(). Refactor opportunity!
LLConversationViewParticipant* LLFloaterIMSessionTab::createConversationViewParticipant(LLConversationItem* item)
{
LLRect panel_rect = mParticipantListPanel->getRect();
@ -494,14 +494,14 @@ LLConversationViewParticipant* LLIMConversation::createConversationViewParticipa
return LLUICtrlFactory::create<LLConversationViewParticipant>(params);
}
void LLIMConversation::setSortOrder(const LLConversationSort& order)
void LLFloaterIMSessionTab::setSortOrder(const LLConversationSort& order)
{
mConversationViewModel.setSorter(order);
mConversationsRoot->arrangeAll();
refreshConversation();
}
void LLIMConversation::onIMSessionMenuItemClicked(const LLSD& userdata)
void LLFloaterIMSessionTab::onIMSessionMenuItemClicked(const LLSD& userdata)
{
std::string item = userdata.asString();
@ -515,11 +515,11 @@ void LLIMConversation::onIMSessionMenuItemClicked(const LLSD& userdata)
gSavedSettings.setBOOL(item, !prev_value);
}
LLIMConversation::processChatHistoryStyleUpdate();
LLFloaterIMSessionTab::processChatHistoryStyleUpdate();
}
bool LLIMConversation::onIMCompactExpandedMenuItemCheck(const LLSD& userdata)
bool LLFloaterIMSessionTab::onIMCompactExpandedMenuItemCheck(const LLSD& userdata)
{
std::string item = userdata.asString();
bool is_plain_text_mode = gSavedSettings.getBOOL("PlainTextChatHistory");
@ -528,13 +528,13 @@ bool LLIMConversation::onIMCompactExpandedMenuItemCheck(const LLSD& userdata)
}
bool LLIMConversation::onIMShowModesMenuItemCheck(const LLSD& userdata)
bool LLFloaterIMSessionTab::onIMShowModesMenuItemCheck(const LLSD& userdata)
{
return gSavedSettings.getBOOL(userdata.asString());
}
// enable/disable states for the "show time" and "show names" items of the show-modes menu
bool LLIMConversation::onIMShowModesMenuItemEnable(const LLSD& userdata)
bool LLFloaterIMSessionTab::onIMShowModesMenuItemEnable(const LLSD& userdata)
{
std::string item = userdata.asString();
bool plain_text = gSavedSettings.getBOOL("PlainTextChatHistory");
@ -542,7 +542,7 @@ bool LLIMConversation::onIMShowModesMenuItemEnable(const LLSD& userdata)
return (plain_text && (is_not_names || mIsP2PChat));
}
void LLIMConversation::hideOrShowTitle()
void LLFloaterIMSessionTab::hideOrShowTitle()
{
const LLFloater::Params& default_params = LLFloater::getDefaultParams();
S32 floater_header_size = default_params.header_height;
@ -557,12 +557,12 @@ void LLIMConversation::hideOrShowTitle()
floater_contents->setShape(contents_rect);
}
void LLIMConversation::updateSessionName(const std::string& name)
void LLFloaterIMSessionTab::updateSessionName(const std::string& name)
{
mInputEditor->setLabel(LLTrans::getString("IM_to_label") + " " + name);
}
void LLIMConversation::hideAllStandardButtons()
void LLFloaterIMSessionTab::hideAllStandardButtons()
{
for (S32 i = 0; i < BUTTON_COUNT; i++)
{
@ -574,10 +574,10 @@ void LLIMConversation::hideAllStandardButtons()
}
}
void LLIMConversation::updateHeaderAndToolbar()
void LLFloaterIMSessionTab::updateHeaderAndToolbar()
{
// prevent start conversation before its container
LLIMFloaterContainer::getInstance();
LLFloaterIMContainer::getInstance();
bool is_torn_off = checkIfTornOff();
if (!is_torn_off)
@ -619,7 +619,7 @@ void LLIMConversation::updateHeaderAndToolbar()
showTranslationCheckbox();
}
void LLIMConversation::reshapeChatHistory()
void LLFloaterIMSessionTab::reshapeChatHistory()
{
LLRect chat_rect = mChatHistory->getRect();
LLRect input_rect = mInputEditor->getRect();
@ -630,33 +630,33 @@ void LLIMConversation::reshapeChatHistory()
mChatHistory->setShape(chat_rect);
}
void LLIMConversation::showTranslationCheckbox(BOOL show)
void LLFloaterIMSessionTab::showTranslationCheckbox(BOOL show)
{
getChild<LLUICtrl>("translate_chat_checkbox_lp")->setVisible(mIsNearbyChat? show : FALSE);
}
// static
void LLIMConversation::processChatHistoryStyleUpdate()
void LLFloaterIMSessionTab::processChatHistoryStyleUpdate()
{
LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("impanel");
for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin();
iter != inst_list.end(); ++iter)
{
LLIMFloater* floater = dynamic_cast<LLIMFloater*>(*iter);
LLFloaterIMSession* floater = dynamic_cast<LLFloaterIMSession*>(*iter);
if (floater)
{
floater->reloadMessages();
}
}
LLNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
nearby_chat->reloadMessages();
}
}
void LLIMConversation::updateCallBtnState(bool callIsActive)
void LLFloaterIMSessionTab::updateCallBtnState(bool callIsActive)
{
getChild<LLButton>("voice_call_btn")->setImageOverlay(
callIsActive? getString("call_btn_stop") : getString("call_btn_start"));
@ -664,9 +664,9 @@ void LLIMConversation::updateCallBtnState(bool callIsActive)
}
void LLIMConversation::onSlide(LLIMConversation* self)
void LLFloaterIMSessionTab::onSlide(LLFloaterIMSessionTab* self)
{
LLIMFloaterContainer* host_floater = dynamic_cast<LLIMFloaterContainer*>(self->getHost());
LLFloaterIMContainer* host_floater = dynamic_cast<LLFloaterIMContainer*>(self->getHost());
if (host_floater)
{
// Hide the messages pane if a floater is hosted in the Conversations
@ -689,23 +689,23 @@ void LLIMConversation::onSlide(LLIMConversation* self)
}
/*virtual*/
void LLIMConversation::onOpen(const LLSD& key)
void LLFloaterIMSessionTab::onOpen(const LLSD& key)
{
if (!checkIfTornOff())
{
LLIMFloaterContainer* host_floater = dynamic_cast<LLIMFloaterContainer*>(getHost());
LLFloaterIMContainer* host_floater = dynamic_cast<LLFloaterIMContainer*>(getHost());
// Show the messages pane when opening a floater hosted in the Conversations
host_floater->collapseMessagesPane(false);
}
}
// virtual
void LLIMConversation::onClose(bool app_quitting)
void LLFloaterIMSessionTab::onClose(bool app_quitting)
{
// Always suppress the IM from the conversations list on close if present for any reason
if (LLIMConversation::isChatMultiTab())
if (LLFloaterIMSessionTab::isChatMultiTab())
{
LLIMFloaterContainer* im_box = LLIMFloaterContainer::findInstance();
LLFloaterIMContainer* im_box = LLFloaterIMContainer::findInstance();
if (im_box)
{
im_box->removeConversationListItem(mKey);
@ -713,7 +713,7 @@ void LLIMConversation::onClose(bool app_quitting)
}
}
void LLIMConversation::onTearOffClicked()
void LLFloaterIMSessionTab::onTearOffClicked()
{
setFollows(isTornOff()? FOLLOWS_ALL : FOLLOWS_NONE);
mSaveRect = isTornOff();
@ -723,13 +723,13 @@ void LLIMConversation::onTearOffClicked()
}
// static
bool LLIMConversation::isChatMultiTab()
bool LLFloaterIMSessionTab::isChatMultiTab()
{
// Restart is required in order to change chat window type.
return true;
}
bool LLIMConversation::checkIfTornOff()
bool LLFloaterIMSessionTab::checkIfTornOff()
{
bool isTorn = !getHost();

26
indra/newview/llimconversation.h → indra/newview/llfloaterimsessiontab.h
View File

@ -1,7 +1,7 @@
/**
* @file llimconversation.h
* @brief LLIMConversation class implements the common behavior of LNearbyChatBar
* @brief and LLIMFloater for hosting both in LLIMContainer
* @file llfloaterimsessiontab.h
* @brief LLFloaterIMSessionTab class implements the common behavior of LNearbyChatBar
* @brief and LLFloaterIMSession for hosting both in LLIMContainer
*
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
* Second Life Viewer Source Code
@ -25,8 +25,8 @@
* $/LicenseInfo$
*/
#ifndef LL_IMCONVERSATION_H
#define LL_IMCONVERSATION_H
#ifndef LL_FLOATERIMSESSIONTAB_H
#define LL_FLOATERIMSESSIONTAB_H
#include "lllayoutstack.h"
#include "llparticipantlist.h"
@ -42,15 +42,15 @@ class LLPanelChatControlPanel;
class LLChatEntry;
class LLChatHistory;
class LLIMConversation
class LLFloaterIMSessionTab
: public LLTransientDockableFloater
{
public:
LOG_CLASS(LLIMConversation);
LOG_CLASS(LLFloaterIMSessionTab);
LLIMConversation(const LLSD& session_id);
~LLIMConversation();
LLFloaterIMSessionTab(const LLSD& session_id);
~LLFloaterIMSessionTab();
// reload all message with new settings of visual modes
static void processChatHistoryStyleUpdate();
@ -67,8 +67,8 @@ public:
bool isHostAttached() {return mIsHostAttached;}
void setHostAttached(bool is_attached) {mIsHostAttached = is_attached;}
static LLIMConversation* findConversation(const LLUUID& uuid);
static LLIMConversation* getConversation(const LLUUID& uuid);
static LLFloaterIMSessionTab* findConversation(const LLUUID& uuid);
static LLFloaterIMSessionTab* getConversation(const LLUUID& uuid);
// show/hide the translation check box
void showTranslationCheckbox(const BOOL visible = FALSE);
@ -105,7 +105,7 @@ protected:
//
bool onIMShowModesMenuItemCheck(const LLSD& userdata);
bool onIMShowModesMenuItemEnable(const LLSD& userdata);
static void onSlide(LLIMConversation *self);
static void onSlide(LLFloaterIMSessionTab *self);
virtual void onTearOffClicked();
// refresh a visual state of the Call button
@ -173,4 +173,4 @@ private:
};
#endif // LL_IMCONVERSATION_H
#endif /* LL_FLOATERIMSESSIONTAB_H */

6
indra/newview/llfloaterpreference.cpp
View File

@ -51,11 +51,11 @@
#include "llfloaterabout.h"
#include "llfloaterhardwaresettings.h"
#include "llfloatersidepanelcontainer.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "llkeyboard.h"
#include "llmodaldialog.h"
#include "llnavigationbar.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llnotifications.h"
#include "llnotificationsutil.h"
#include "llnotificationtemplate.h"
@ -425,7 +425,7 @@ void LLFloaterPreference::saveAvatarProperties( void )
BOOL LLFloaterPreference::postBuild()
{
gSavedSettings.getControl("ChatFontSize")->getSignal()->connect(boost::bind(&LLIMConversation::processChatHistoryStyleUpdate));
gSavedSettings.getControl("ChatFontSize")->getSignal()->connect(boost::bind(&LLFloaterIMSessionTab::processChatHistoryStyleUpdate));
gSavedSettings.getControl("ChatFontSize")->getSignal()->connect(boost::bind(&LLViewerChat::signalChatFontChanged));

4
indra/newview/llfloatertranslationsettings.cpp
View File

@ -29,7 +29,7 @@
#include "llfloatertranslationsettings.h"
// Viewer includes
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "lltranslate.h"
#include "llviewercontrol.h" // for gSavedSettings
@ -293,7 +293,7 @@ void LLFloaterTranslationSettings::onBtnOK()
gSavedSettings.setString("TranslationService", getSelectedService());
gSavedSettings.setString("BingTranslateAPIKey", getEnteredBingKey());
gSavedSettings.setString("GoogleTranslateAPIKey", getEnteredGoogleKey());
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
showTranslationCheckbox(LLTranslate::isTranslationConfigured());
closeFloater(false);
}

4
indra/newview/llgesturemgr.cpp
View File

@ -52,7 +52,7 @@
#include "llviewermessage.h"
#include "llvoavatarself.h"
#include "llviewerstats.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llappearancemgr.h"
#include "llgesturelistener.h"
@ -998,7 +998,7 @@ void LLGestureMgr::runStep(LLMultiGesture* gesture, LLGestureStep* step)
const BOOL animate = FALSE;
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
sendChatFromViewer(chat_text, CHAT_TYPE_NORMAL, animate);
gesture->mCurrentStep++;

4
indra/newview/llgroupactions.cpp
View File

@ -36,7 +36,7 @@
#include "llfloaterreg.h"
#include "llfloatersidepanelcontainer.h"
#include "llgroupmgr.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llimview.h" // for gIMMgr
#include "llnotificationsutil.h"
#include "llstatusbar.h" // can_afford_transaction()
@ -335,7 +335,7 @@ LLUUID LLGroupActions::startIM(const LLUUID& group_id)
group_id);
if (session_id != LLUUID::null)
{
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
}
make_ui_sound("UISndStartIM");
return session_id;

2
indra/newview/llgroupiconctrl.cpp
View File

@ -38,7 +38,7 @@
#include "llcachename.h"
#include "llagentdata.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
*/
static LLDefaultChildRegistry::Register<LLGroupIconCtrl> g_i("group_icon");

2
indra/newview/llimpanel.cpp
View File

@ -171,7 +171,7 @@ LLFloaterIMPanel::LLFloaterIMPanel(const std::string& session_label,
// enable line history support for instant message bar
mInputEditor->setEnableLineHistory(TRUE);
//*TODO we probably need the same "awaiting message" thing in LLIMFloater
//*TODO we probably need the same "awaiting message" thing in LLFloaterIMSession
LLIMModel::LLIMSession* im_session = LLIMModel::getInstance()->findIMSession(mSessionUUID);
if (!im_session)
{

36
indra/newview/llimview.cpp
View File

@ -41,15 +41,15 @@
#include "lltextutil.h"
#include "lltrans.h"
#include "lluictrlfactory.h"
#include "llimconversation.h"
#include "llfloaterimsessiontab.h"
#include "llagent.h"
#include "llagentui.h"
#include "llappviewer.h"
#include "llavatariconctrl.h"
#include "llcallingcard.h"
#include "llchat.h"
#include "llimfloater.h"
#include "llimfloatercontainer.h"
#include "llfloaterimsession.h"
#include "llfloaterimcontainer.h"
#include "llgroupiconctrl.h"
#include "llmd5.h"
#include "llmutelist.h"
@ -58,7 +58,7 @@
#include "llviewerwindow.h"
#include "llnotifications.h"
#include "llnotificationsutil.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llspeakers.h" //for LLIMSpeakerMgr
#include "lltextbox.h"
#include "lltoolbarview.h"
@ -109,7 +109,7 @@ static void on_avatar_name_cache_toast(const LLUUID& agent_id,
args["FROM"] = av_name.getCompleteName();
args["FROM_ID"] = msg["from_id"];
args["SESSION_ID"] = msg["session_id"];
LLNotificationsUtil::add("IMToast", args, LLSD(), boost::bind(&LLIMFloaterContainer::showConversation, LLIMFloaterContainer::getInstance(), msg["session_id"].asUUID()));
LLNotificationsUtil::add("IMToast", args, LLSD(), boost::bind(&LLFloaterIMContainer::showConversation, LLFloaterIMContainer::getInstance(), msg["session_id"].asUUID()));
}
void toast_callback(const LLSD& msg){
@ -120,7 +120,7 @@ void toast_callback(const LLSD& msg){
}
// Skip toasting if we have open window of IM with this session id
LLIMFloater* open_im_floater = LLIMFloater::findInstance(msg["session_id"]);
LLFloaterIMSession* open_im_floater = LLFloaterIMSession::findInstance(msg["session_id"]);
if (
open_im_floater
&& open_im_floater->isInVisibleChain()
@ -160,7 +160,7 @@ void toast_callback(const LLSD& msg){
LLIMModel::LLIMModel()
{
addNewMsgCallback(boost::bind(&LLIMFloater::newIMCallback, _1));
addNewMsgCallback(boost::bind(&LLFloaterIMSession::newIMCallback, _1));
addNewMsgCallback(boost::bind(&toast_callback, _1));
}
@ -638,7 +638,7 @@ void LLIMModel::processSessionInitializedReply(const LLUUID& old_session_id, con
mId2SessionMap[new_session_id] = session;
}
LLIMFloater* im_floater = LLIMFloater::findInstance(old_session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(old_session_id);
if (im_floater)
{
im_floater->sessionInitReplyReceived(new_session_id);
@ -1387,7 +1387,7 @@ public:
&& LLIMModel::getInstance()->findIMSession(mSessionID))
{
// TODO remove in 2010, for voice calls we do not open an IM window
//LLIMFloater::show(mSessionID);
//LLFloaterIMSession::show(mSessionID);
}
gIMMgr->clearPendingAgentListUpdates(mSessionID);
@ -1531,7 +1531,7 @@ LLIMMgr::onConfirmForceCloseError(
//only 1 option really
LLUUID session_id = notification["payload"]["session_id"];
LLFloater* floater = LLIMFloater::findInstance(session_id);
LLFloater* floater = LLFloaterIMSession::findInstance(session_id);
if ( floater )
{
floater->closeFloater(FALSE);
@ -2397,7 +2397,7 @@ LLIMMgr::LLIMMgr()
mPendingInvitations = LLSD::emptyMap();
mPendingAgentListUpdates = LLSD::emptyMap();
LLIMModel::getInstance()->addNewMsgCallback(boost::bind(&LLIMFloater::sRemoveTypingIndicator, _1));
LLIMModel::getInstance()->addNewMsgCallback(boost::bind(&LLFloaterIMSession::sRemoveTypingIndicator, _1));
}
// Add a message to a session.
@ -2492,7 +2492,7 @@ void LLIMMgr::addSystemMessage(const LLUUID& session_id, const std::string& mess
LLChat chat(message);
chat.mSourceType = CHAT_SOURCE_SYSTEM;
LLNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
nearby_chat->addMessage(chat);
@ -2618,12 +2618,12 @@ LLUUID LLIMMgr::addSession(
if (floater_id.notNull())
{
LLIMFloater* im_floater = LLIMFloater::findInstance(floater_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(floater_id);
if (im_floater && im_floater->getStartConferenceInSameFloater())
{
// The IM floater should be initialized with a new session_id
// so that it is found by that id when creating a chiclet in LLIMFloater::onIMChicletCreated,
// so that it is found by that id when creating a chiclet in LLFloaterIMSession::onIMChicletCreated,
// and a new floater is not created.
im_floater->initIMSession(session_id);
}
@ -2841,7 +2841,7 @@ void LLIMMgr::clearPendingInvitation(const LLUUID& session_id)
void LLIMMgr::processAgentListUpdates(const LLUUID& session_id, const LLSD& body)
{
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(session_id);
if ( im_floater )
{
im_floater->processAgentListUpdates(body);
@ -3115,7 +3115,7 @@ void LLIMMgr::processIMTypingStop(const LLIMInfo* im_info)
void LLIMMgr::processIMTypingCore(const LLIMInfo* im_info, BOOL typing)
{
LLUUID session_id = computeSessionID(im_info->mIMType, im_info->mFromID);
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(session_id);
if ( im_floater )
{
im_floater->processIMTyping(im_info, typing);
@ -3160,7 +3160,7 @@ public:
speaker_mgr->updateSpeakers(gIMMgr->getPendingAgentListUpdates(session_id));
}
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(session_id);
if ( im_floater )
{
if ( body.has("session_info") )
@ -3254,7 +3254,7 @@ public:
const LLSD& input) const
{
LLUUID session_id = input["body"]["session_id"].asUUID();
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(session_id);
if ( im_floater )
{
im_floater->processSessionUpdate(input["body"]["info"]);

4
indra/newview/llinventorybridge.cpp
View File

@ -46,7 +46,7 @@
#include "llfriendcard.h"
#include "llgesturemgr.h"
#include "llgiveinventory.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llimview.h"
#include "llclipboard.h"
#include "llinventorydefines.h"
@ -4683,7 +4683,7 @@ void LLCallingCardBridge::performAction(LLInventoryModel* model, std::string act
LLUUID session_id = gIMMgr->addSession(callingcard_name, IM_NOTHING_SPECIAL, item->getCreatorUUID());
if (session_id != LLUUID::null)
{
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
}
}
}

4
indra/newview/llinventorypanel.cpp
View File

@ -39,7 +39,7 @@
#include "llfloatersidepanelcontainer.h"
#include "llfolderview.h"
#include "llfolderviewitem.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llimview.h"
#include "llinventorybridge.h"
#include "llinventoryfunctions.h"
@ -1087,7 +1087,7 @@ bool LLInventoryPanel::beginIMSession()
LLUUID session_id = gIMMgr->addSession(name, type, members[0], members);
if (session_id != LLUUID::null)
{
LLIMFloaterContainer::getInstance()->showConversation(session_id);
LLFloaterIMContainer::getInstance()->showConversation(session_id);
}
return true;

2
indra/newview/llnotificationhandler.h
View File

@ -36,7 +36,7 @@
#include "llinstantmessage.h"
#include "llnotificationptr.h"
class LLIMFloater;
class LLFloaterIMSession;
namespace LLNotificationsUI
{

10
indra/newview/llnotificationhandlerutil.cpp
View File

@ -34,9 +34,9 @@
#include "llurlaction.h"
#include "llagent.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "llimview.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llnotificationhandler.h"
using namespace LLNotificationsUI;
@ -52,7 +52,7 @@ bool LLHandlerUtil::isIMFloaterOpened(const LLNotificationPtr& notification)
LLUUID from_id = notification->getPayload()["from_id"];
LLUUID session_id = LLIMMgr::computeSessionID(IM_NOTHING_SPECIAL, from_id);
LLIMFloater* im_floater = LLFloaterReg::findTypedInstance<LLIMFloater>("impanel", session_id);
LLFloaterIMSession* im_floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>("impanel", session_id);
if (im_floater != NULL)
{
@ -164,7 +164,7 @@ void LLHandlerUtil::logGroupNoticeToIMGroup(
// static
void LLHandlerUtil::logToNearbyChat(const LLNotificationPtr& notification, EChatSourceType type)
{
LLNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
LLChat chat_msg(notification->getMessage());
@ -244,7 +244,7 @@ void LLHandlerUtil::addNotifPanelToIM(const LLNotificationPtr& notification)
// static
void LLHandlerUtil::updateIMFLoaterMesages(const LLUUID& session_id)
{
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
LLFloaterIMSession* im_floater = LLFloaterIMSession::findInstance(session_id);
if (im_floater != NULL && im_floater->getVisible())
{
im_floater->updateMessages();

4
indra/newview/llnotificationmanager.cpp
View File

@ -31,7 +31,7 @@
#include "llnotificationmanager.h"
#include "llnearbychathandler.h"
#include "llfloaterimnearbychathandler.h"
#include "llnotifications.h"
#include <boost/bind.hpp>
@ -64,7 +64,7 @@ void LLNotificationManager::init()
mChannels.push_back(new LLOutboxNotification());
mChannels.push_back(new LLIMHandler());
mChatHandler = boost::shared_ptr<LLNearbyChatHandler>(new LLNearbyChatHandler());
mChatHandler = boost::shared_ptr<LLFloaterIMNearbyChatHandler>(new LLFloaterIMNearbyChatHandler());
}
//--------------------------------------------------------------------------

2
indra/newview/llnotificationmanager.h
View File

@ -60,7 +60,7 @@ public:
void onChat(const LLChat& msg, const LLSD &args);
private:
boost::shared_ptr<class LLNearbyChatHandler> mChatHandler;
boost::shared_ptr<class LLFloaterIMNearbyChatHandler> mChatHandler;
std::vector<LLNotificationChannelPtr> mChannels;
};

6
indra/newview/llnotificationtiphandler.cpp
View File

@ -28,8 +28,8 @@
#include "llviewerprecompiledheaders.h" // must be first include
#include "llfloaterreg.h"
#include "llnearbychat.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llnotificationhandler.h"
#include "llnotifications.h"
#include "lltoastnotifypanel.h"
@ -85,7 +85,7 @@ bool LLTipHandler::processNotification(const LLNotificationPtr& notification)
LLHandlerUtil::logToNearbyChat(notification, CHAT_SOURCE_SYSTEM);
// don't show toast if Nearby Chat is opened
LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat->isChatVisible())
{
return false;

6
indra/newview/llparticipantlist.cpp
View File

@ -28,7 +28,7 @@
#include "llavatarnamecache.h"
#include "llimview.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llparticipantlist.h"
#include "llspeakers.h"
@ -316,7 +316,7 @@ bool LLParticipantList::onSpeakerUpdateEvent(LLPointer<LLOldEvents::LLEvent> eve
if ( evt_data.has("id") )
{
LLUUID participant_id = evt_data["id"];
LLIMFloaterContainer* im_box = LLIMFloaterContainer::findInstance();
LLFloaterIMContainer* im_box = LLFloaterIMContainer::findInstance();
if (im_box)
{
im_box->setTimeNow(mUUID,participant_id);
@ -345,7 +345,7 @@ bool LLParticipantList::onModeratorUpdateEvent(LLPointer<LLOldEvents::LLEvent> e
mModeratorList.erase(id);
}
}
// *TODO : do we have to fire an event so that LLIMConversation::refreshConversation() gets called
// *TODO : do we have to fire an event so that LLFloaterIMSessionTab::refreshConversation() gets called
}
}
return true;

2
indra/newview/llscreenchannel.cpp
View File

@ -39,7 +39,7 @@
#include "lldockablefloater.h"
#include "llsyswellwindow.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "llscriptfloater.h"
#include "llrootview.h"

2
indra/newview/llscriptfloater.cpp
View File

@ -41,7 +41,7 @@
#include "lltoastscripttextbox.h"
#include "lltrans.h"
#include "llviewerwindow.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

8
indra/newview/llstartup.cpp
View File

@ -54,7 +54,7 @@
#include "llfloaterreg.h"
#include "llfocusmgr.h"
#include "llhttpsender.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "lllocationhistory.h"
#include "llimageworker.h"
@ -63,8 +63,8 @@
#include "llmemorystream.h"
#include "llmessageconfig.h"
#include "llmoveview.h"
#include "llimfloatercontainer.h"
#include "llnearbychat.h"
#include "llfloaterimcontainer.h"
#include "llfloaterimnearbychat.h"
#include "llnotifications.h"
#include "llnotificationsutil.h"
#include "llteleporthistory.h"
@ -1384,7 +1384,7 @@ bool idle_startup()
// create a container's instance for start a controlling conversation windows
// by the voice's events
LLIMFloaterContainer::getInstance();
LLFloaterIMContainer::getInstance();
// *Note: this is where gWorldMap used to be initialized.

2
indra/newview/lltoastnotifypanel.cpp
View File

@ -40,7 +40,7 @@
#include "lltrans.h"
#include "llnotificationsutil.h"
#include "llviewermessage.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
const S32 BOTTOM_PAD = VPAD * 3;
const S32 IGNORE_BTN_TOP_DELTA = 3*VPAD;//additional ignore_btn padding

12
indra/newview/llviewerfloaterreg.cpp
View File

@ -71,7 +71,7 @@
#include "llfloatermediasettings.h"
#include "llfloaterhud.h"
#include "llfloaterimagepreview.h"
#include "llimfloater.h"
#include "llfloaterimsession.h"
#include "llfloaterinspect.h"
#include "llfloaterinventory.h"
#include "llfloaterjoystick.h"
@ -120,14 +120,14 @@
#include "llfloaterwhitelistentry.h"
#include "llfloaterwindowsize.h"
#include "llfloaterworldmap.h"
#include "llimfloatercontainer.h"
#include "llfloaterimcontainer.h"
#include "llinspectavatar.h"
#include "llinspectgroup.h"
#include "llinspectobject.h"
#include "llinspectremoteobject.h"
#include "llinspecttoast.h"
#include "llmoveview.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llpanelblockedlist.h"
#include "llpanelclassified.h"
#include "llpreviewanim.h"
@ -193,7 +193,7 @@ void LLViewerFloaterReg::registerFloaters()
LLFloaterReg::add("camera", "floater_camera.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterCamera>);
LLFloaterReg::add("chat_voice", "floater_voice_chat_volume.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterChatVoiceVolume>);
LLFloaterReg::add("nearby_chat", "floater_im_session.xml", (LLFloaterBuildFunc)&LLNearbyChat::buildFloater);
LLFloaterReg::add("nearby_chat", "floater_im_session.xml", (LLFloaterBuildFunc)&LLFloaterIMNearbyChat::buildFloater);
LLFloaterReg::add("compile_queue", "floater_script_queue.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterCompileQueue>);
LLFloaterReg::add("conversation", "floater_conversation_log.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterConversationLog>);
@ -217,8 +217,8 @@ void LLViewerFloaterReg::registerFloaters()
LLFloaterReg::add("help_browser", "floater_help_browser.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterHelpBrowser>);
LLFloaterReg::add("hud", "floater_hud.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterHUD>);
LLFloaterReg::add("impanel", "floater_im_session.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLIMFloater>);
LLFloaterReg::add("im_container", "floater_im_container.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLIMFloaterContainer>);
LLFloaterReg::add("impanel", "floater_im_session.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterIMSession>);
LLFloaterReg::add("im_container", "floater_im_container.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterIMContainer>);
LLFloaterReg::add("im_well_window", "floater_sys_well.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLIMWellWindow>);
LLFloaterReg::add("incoming_call", "floater_incoming_call.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLIncomingCallDialog>);
LLFloaterReg::add("inventory", "floater_my_inventory.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterSidePanelContainer>);

4
indra/newview/llviewergesture.cpp
View File

@ -41,7 +41,7 @@
#include "llviewermessage.h" // send_guid_sound_trigger
#include "llviewernetwork.h"
#include "llagent.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
// Globals
LLViewerGestureList gGestureList;
@ -131,7 +131,7 @@ void LLViewerGesture::doTrigger( BOOL send_chat )
{
// Don't play nodding animation, since that might not blend
// with the gesture animation.
(LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->
(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
sendChatFromViewer(mOutputString, CHAT_TYPE_NORMAL, FALSE);
}
}

10
indra/newview/llviewerkeyboard.cpp
View File

@ -32,7 +32,7 @@
#include "llmath.h"
#include "llagent.h"
#include "llagentcamera.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llviewercontrol.h"
#include "llfocusmgr.h"
#include "llmorphview.h"
@ -535,7 +535,7 @@ void stop_moving( EKeystate s )
void start_chat( EKeystate s )
{
// start chat
LLNearbyChat::startChat(NULL);
LLFloaterIMNearbyChat::startChat(NULL);
}
void start_gesture( EKeystate s )
@ -544,15 +544,15 @@ void start_gesture( EKeystate s )
if (KEYSTATE_UP == s &&
! (focus_ctrlp && focus_ctrlp->acceptsTextInput()))
{
if ((LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat"))->getCurrentChat().empty())
if ((LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->getCurrentChat().empty())
{
// No existing chat in chat editor, insert '/'
LLNearbyChat::startChat("/");
LLFloaterIMNearbyChat::startChat("/");
}
else
{
// Don't overwrite existing text in chat editor
LLNearbyChat::startChat(NULL);
LLFloaterIMNearbyChat::startChat(NULL);
}
}
}

6
indra/newview/llviewermessage.cpp
View File

@ -68,7 +68,7 @@
#include "llinventoryfunctions.h"
#include "llinventoryobserver.h"
#include "llinventorypanel.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llnotifications.h"
#include "llnotificationsutil.h"
#include "llpanelgrouplandmoney.h"
@ -2295,7 +2295,7 @@ void god_message_name_cb(const LLAvatarName& av_name, LLChat chat, std::string m
// Treat like a system message and put in chat history.
chat.mText = av_name.getCompleteName() + ": " + message;
LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if (nearby_chat)
{
nearby_chat->addMessage(chat);
@ -2877,7 +2877,7 @@ void process_improved_im(LLMessageSystem *msg, void **user_data)
// Note: lie to Nearby Chat, pretending that this is NOT an IM, because
// IMs from obejcts don't open IM sessions.
LLNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
if(!chat_from_system && nearby_chat)
{
chat.mOwnerID = from_id;

6
indra/newview/llviewerwindow.cpp
View File

@ -188,7 +188,7 @@
#include "llviewerjoystick.h"
#include "llviewernetwork.h"
#include "llpostprocess.h"
#include "llnearbychat.h"
#include "llfloaterimnearbychat.h"
#include "llagentui.h"
#include "llwearablelist.h"
@ -2496,7 +2496,7 @@ BOOL LLViewerWindow::handleKey(KEY key, MASK mask)
return TRUE;
}
LLNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat");
LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
// Traverses up the hierarchy
if( keyboard_focus )
@ -2574,7 +2574,7 @@ BOOL LLViewerWindow::handleKey(KEY key, MASK mask)
LLFloaterReg::toggleInstanceOrBringToFront(name);
}
LLChatEntry* chat_editor = LLFloaterReg::findTypedInstance<LLNearbyChat>("nearby_chat")->getChatBox();
LLChatEntry* chat_editor = LLFloaterReg::findTypedInstance<LLFloaterIMNearbyChat>("nearby_chat")->getChatBox();
if (chat_editor)
{
// passing NULL here, character will be added later when it is handled by character handler.