405 lines
12 KiB
C++
405 lines
12 KiB
C++
/**
|
|
* @file llimfloatercontainer.cpp
|
|
* @brief Multifloater containing active IM sessions in separate tab container tabs
|
|
*
|
|
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "llimfloatercontainer.h"
|
|
|
|
#include "llfloaterreg.h"
|
|
#include "lllayoutstack.h"
|
|
#include "llnearbychat.h"
|
|
|
|
#include "llagent.h"
|
|
#include "llavatariconctrl.h"
|
|
#include "llgroupiconctrl.h"
|
|
#include "llimview.h"
|
|
#include "lltransientfloatermgr.h"
|
|
#include "llviewercontrol.h"
|
|
|
|
//
|
|
// LLIMFloaterContainer
|
|
//
|
|
LLIMFloaterContainer::LLIMFloaterContainer(const LLSD& seed)
|
|
: LLMultiFloater(seed)
|
|
,mExpandCollapseBtn(NULL)
|
|
{
|
|
mAutoResize = FALSE;
|
|
LLTransientFloaterMgr::getInstance()->addControlView(LLTransientFloaterMgr::IM, this);
|
|
}
|
|
|
|
LLIMFloaterContainer::~LLIMFloaterContainer()
|
|
{
|
|
mNewMessageConnection.disconnect();
|
|
LLTransientFloaterMgr::getInstance()->removeControlView(LLTransientFloaterMgr::IM, this);
|
|
|
|
gSavedPerAccountSettings.setBOOL("ConversationsListPaneCollapsed", mConversationsPane->isCollapsed());
|
|
gSavedPerAccountSettings.setBOOL("ConversationsMessagePaneCollapsed", mMessagesPane->isCollapsed());
|
|
}
|
|
|
|
BOOL LLIMFloaterContainer::postBuild()
|
|
{
|
|
mNewMessageConnection = LLIMModel::instance().mNewMsgSignal.connect(boost::bind(&LLIMFloaterContainer::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()
|
|
|
|
setTabContainer(getChild<LLTabContainer>("im_box_tab_container"));
|
|
|
|
mConversationsStack = getChild<LLLayoutStack>("conversations_stack");
|
|
mConversationsPane = getChild<LLLayoutPanel>("conversations_layout_panel");
|
|
mMessagesPane = getChild<LLLayoutPanel>("messages_layout_panel");
|
|
|
|
mConversationsListPanel = getChild<LLPanel>("conversations_list_panel");
|
|
|
|
mExpandCollapseBtn = getChild<LLButton>("expand_collapse_btn");
|
|
mExpandCollapseBtn->setClickedCallback(boost::bind(&LLIMFloaterContainer::onExpandCollapseButtonClicked, this));
|
|
|
|
collapseMessagesPane(gSavedPerAccountSettings.getBOOL("ConversationsMessagePaneCollapsed"));
|
|
collapseConversationsPane(gSavedPerAccountSettings.getBOOL("ConversationsListPaneCollapsed"));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLIMFloaterContainer::onOpen(const LLSD& key)
|
|
{
|
|
llinfos << "Merov debug : onOpen, key = " << key.asUUID() << llendl;
|
|
LLMultiFloater::onOpen(key);
|
|
/*
|
|
if (key.isDefined())
|
|
{
|
|
LLIMFloater* im_floater = LLIMFloater::findInstance(key.asUUID());
|
|
if (im_floater)
|
|
{
|
|
im_floater->openFloater();
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
// virtual
|
|
void LLIMFloaterContainer::addFloater(LLFloater* floaterp,
|
|
BOOL select_added_floater,
|
|
LLTabContainer::eInsertionPoint insertion_point)
|
|
{
|
|
if(!floaterp) return;
|
|
|
|
// already here
|
|
if (floaterp->getHost() == this)
|
|
{
|
|
openFloater(floaterp->getKey());
|
|
return;
|
|
}
|
|
|
|
LLMultiFloater::addFloater(floaterp, select_added_floater, insertion_point);
|
|
|
|
LLUUID session_id = floaterp->getKey();
|
|
|
|
// CHUI-137
|
|
// Create a conversation item
|
|
LLConversationItem* item = new LLConversationItem(floaterp->getTitle(),session_id, floaterp, this);
|
|
mConversationsItems.push_back(item);
|
|
// Create a widget from it
|
|
LLFolderViewItem* widget = createConversationItemWidget(item);
|
|
mConversationsWidgets.push_back(widget);
|
|
// Add it to the UI
|
|
widget->setVisible(TRUE);
|
|
mConversationsListPanel->addChild(widget);
|
|
LLRect panel_rect = mConversationsListPanel->getRect();
|
|
S32 item_height = 16;
|
|
S32 index = mConversationsWidgets.size() - 1;
|
|
widget->setRect(LLRect(0,
|
|
panel_rect.getHeight() - item_height*index,
|
|
panel_rect.getWidth(),
|
|
panel_rect.getHeight() - item_height*(index+1)));
|
|
// CHUI-137 : end
|
|
|
|
LLView* floater_contents = floaterp->getChild<LLView>("contents_view");
|
|
|
|
// we don't show the header when the floater is hosted,
|
|
// so reshape floater contents to occupy the header space
|
|
floater_contents->setShape(floaterp->getRect());
|
|
|
|
LLIconCtrl* icon = 0;
|
|
|
|
if(gAgent.isInGroup(session_id, TRUE))
|
|
{
|
|
LLGroupIconCtrl::Params icon_params;
|
|
icon_params.group_id = session_id;
|
|
icon = LLUICtrlFactory::instance().create<LLGroupIconCtrl>(icon_params);
|
|
|
|
mSessions[session_id] = floaterp;
|
|
floaterp->mCloseSignal.connect(boost::bind(&LLIMFloaterContainer::onCloseFloater, this, session_id));
|
|
}
|
|
else
|
|
{
|
|
LLUUID avatar_id = LLIMModel::getInstance()->getOtherParticipantID(session_id);
|
|
|
|
LLAvatarIconCtrl::Params icon_params;
|
|
icon_params.avatar_id = avatar_id;
|
|
icon = LLUICtrlFactory::instance().create<LLAvatarIconCtrl>(icon_params);
|
|
|
|
mSessions[session_id] = floaterp;
|
|
floaterp->mCloseSignal.connect(boost::bind(&LLIMFloaterContainer::onCloseFloater, this, session_id));
|
|
}
|
|
mTabContainer->setTabImage(floaterp, icon);
|
|
|
|
llinfos << "Merov debug : addFloater, title = " << floaterp->getTitle() << ", uuid = " << session_id << llendl;
|
|
}
|
|
|
|
// virtual
|
|
void LLIMFloaterContainer::removeFloater(LLFloater* floaterp)
|
|
{
|
|
LLMultiFloater::removeFloater(floaterp);
|
|
|
|
llinfos << "Merov debug : removeFloater, title = " << floaterp->getTitle() << ", uuid = " << floaterp->getKey() << llendl;
|
|
|
|
LLRect contents_rect = floaterp->getRect();
|
|
|
|
// reduce the floater contents height by header height
|
|
contents_rect.mTop -= floaterp->getHeaderHeight();
|
|
|
|
LLView* floater_contents = floaterp->getChild<LLView>("contents_view");
|
|
floater_contents->setShape(contents_rect);
|
|
}
|
|
|
|
void LLIMFloaterContainer::onCloseFloater(LLUUID& id)
|
|
{
|
|
mSessions.erase(id);
|
|
}
|
|
|
|
// virtual
|
|
void LLIMFloaterContainer::computeResizeLimits(S32& new_min_width, S32& new_min_height)
|
|
{
|
|
bool is_left_pane_expanded = !mConversationsPane->isCollapsed();
|
|
bool is_right_pane_expanded = !mMessagesPane->isCollapsed();
|
|
|
|
S32 conversations_pane_min_dim = mConversationsPane->getMinDim();
|
|
|
|
if (is_right_pane_expanded)
|
|
{
|
|
S32 conversations_pane_width =
|
|
(is_left_pane_expanded ? gSavedPerAccountSettings.getS32("ConversationsListPaneWidth") : conversations_pane_min_dim);
|
|
|
|
// possibly increase minimum size constraint due to children's minimums.
|
|
for (S32 tab_idx = 0; tab_idx < mTabContainer->getTabCount(); ++tab_idx)
|
|
{
|
|
LLFloater* floaterp = dynamic_cast<LLFloater*>(mTabContainer->getPanelByIndex(tab_idx));
|
|
if (floaterp)
|
|
{
|
|
new_min_width = llmax(new_min_width,
|
|
floaterp->getMinWidth() + conversations_pane_width + LLPANEL_BORDER_WIDTH * 2);
|
|
new_min_height = llmax(new_min_height, floaterp->getMinHeight());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
new_min_width = conversations_pane_min_dim;
|
|
}
|
|
}
|
|
|
|
void LLIMFloaterContainer::onNewMessageReceived(const LLSD& data)
|
|
{
|
|
LLUUID session_id = data["session_id"].asUUID();
|
|
LLFloater* floaterp = get_ptr_in_map(mSessions, session_id);
|
|
LLFloater* current_floater = LLMultiFloater::getActiveFloater();
|
|
|
|
if(floaterp && current_floater && floaterp != current_floater)
|
|
{
|
|
if(LLMultiFloater::isFloaterFlashing(floaterp))
|
|
LLMultiFloater::setFloaterFlashing(floaterp, FALSE);
|
|
LLMultiFloater::setFloaterFlashing(floaterp, TRUE);
|
|
}
|
|
}
|
|
|
|
void LLIMFloaterContainer::onExpandCollapseButtonClicked()
|
|
{
|
|
if (mConversationsPane->isCollapsed() && mMessagesPane->isCollapsed()
|
|
&& gSavedPerAccountSettings.getBOOL("ConversationsExpandMessagePaneFirst"))
|
|
{
|
|
// Expand the messages pane from ultra minimized state
|
|
// if it was collapsed last in order.
|
|
collapseMessagesPane(false);
|
|
}
|
|
else
|
|
{
|
|
collapseConversationsPane(!mConversationsPane->isCollapsed());
|
|
}
|
|
}
|
|
|
|
LLIMFloaterContainer* LLIMFloaterContainer::findInstance()
|
|
{
|
|
return LLFloaterReg::findTypedInstance<LLIMFloaterContainer>("im_container");
|
|
}
|
|
|
|
LLIMFloaterContainer* LLIMFloaterContainer::getInstance()
|
|
{
|
|
return LLFloaterReg::getTypedInstance<LLIMFloaterContainer>("im_container");
|
|
}
|
|
|
|
void LLIMFloaterContainer::setMinimized(BOOL b)
|
|
{
|
|
if (isMinimized() == b) return;
|
|
|
|
LLMultiFloater::setMinimized(b);
|
|
// Hide minimized floater (see EXT-5315)
|
|
setVisible(!b);
|
|
|
|
if (isMinimized()) return;
|
|
|
|
if (getActiveFloater())
|
|
{
|
|
getActiveFloater()->setVisible(TRUE);
|
|
}
|
|
}
|
|
|
|
void LLIMFloaterContainer::collapseMessagesPane(bool collapse)
|
|
{
|
|
if (mMessagesPane->isCollapsed() == collapse)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (collapse)
|
|
{
|
|
// Save the messages pane width before collapsing it.
|
|
gSavedPerAccountSettings.setS32("ConversationsMessagePaneWidth", mMessagesPane->getRect().getWidth());
|
|
|
|
// Save the order in which the panels are closed to reverse user's last action.
|
|
gSavedPerAccountSettings.setBOOL("ConversationsExpandMessagePaneFirst", mConversationsPane->isCollapsed());
|
|
}
|
|
|
|
// Show/hide the messages pane.
|
|
mConversationsStack->collapsePanel(mMessagesPane, collapse);
|
|
|
|
updateState(collapse, gSavedPerAccountSettings.getS32("ConversationsMessagePaneWidth"));
|
|
}
|
|
|
|
void LLIMFloaterContainer::collapseConversationsPane(bool collapse)
|
|
{
|
|
if (mConversationsPane->isCollapsed() == collapse)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLView* button_panel = getChild<LLView>("conversations_pane_buttons_expanded");
|
|
button_panel->setVisible(!collapse);
|
|
mExpandCollapseBtn->setImageOverlay(getString(collapse ? "expand_icon" : "collapse_icon"));
|
|
|
|
if (collapse)
|
|
{
|
|
// Save the conversations pane width before collapsing it.
|
|
gSavedPerAccountSettings.setS32("ConversationsListPaneWidth", mConversationsPane->getRect().getWidth());
|
|
|
|
// Save the order in which the panels are closed to reverse user's last action.
|
|
gSavedPerAccountSettings.setBOOL("ConversationsExpandMessagePaneFirst", !mMessagesPane->isCollapsed());
|
|
}
|
|
|
|
mConversationsStack->collapsePanel(mConversationsPane, collapse);
|
|
|
|
S32 collapsed_width = mConversationsPane->getMinDim();
|
|
updateState(collapse, gSavedPerAccountSettings.getS32("ConversationsListPaneWidth") - collapsed_width);
|
|
}
|
|
|
|
void LLIMFloaterContainer::updateState(bool collapse, S32 delta_width)
|
|
{
|
|
LLRect floater_rect = getRect();
|
|
floater_rect.mRight += ((collapse ? -1 : 1) * delta_width);
|
|
setShape(floater_rect);
|
|
|
|
updateResizeLimits();
|
|
|
|
bool is_left_pane_expanded = !mConversationsPane->isCollapsed();
|
|
bool is_right_pane_expanded = !mMessagesPane->isCollapsed();
|
|
|
|
setCanResize(is_left_pane_expanded || is_right_pane_expanded);
|
|
setCanMinimize(is_left_pane_expanded || is_right_pane_expanded);
|
|
}
|
|
|
|
// CHUI-137 : Temp implementation of conversations list
|
|
LLFolderViewItem* LLIMFloaterContainer::createConversationItemWidget(LLConversationItem* item)
|
|
{
|
|
LLFolderViewItem::Params params;
|
|
|
|
params.name = item->getDisplayName();
|
|
//params.icon = bridge->getIcon();
|
|
//params.icon_open = bridge->getOpenIcon();
|
|
|
|
//params.creation_date = bridge->getCreationDate();
|
|
//params.root = mFolderRoot;
|
|
params.listener = item;
|
|
params.rect = LLRect (0, 0, 0, 0);
|
|
params.tool_tip = params.name;
|
|
|
|
return LLUICtrlFactory::create<LLFolderViewItem>(params);
|
|
}
|
|
|
|
// Conversation items
|
|
LLConversationItem::LLConversationItem(std::string name, const LLUUID& uuid, LLFloater* floaterp, LLIMFloaterContainer* containerp) :
|
|
mName(name),
|
|
mUUID(uuid),
|
|
mFloater(floaterp),
|
|
mContainer(containerp)
|
|
{
|
|
if (name == "")
|
|
mName = "Nearby Chat";
|
|
}
|
|
|
|
// Virtual action callbacks
|
|
void LLConversationItem::performAction(LLInventoryModel* model, std::string action)
|
|
{
|
|
llinfos << "Merov debug : performAction, title = " << mName << ", action = " << action << llendl;
|
|
}
|
|
|
|
void LLConversationItem::openItem( void )
|
|
{
|
|
llinfos << "Merov debug : openItem, title = " << mName << llendl;
|
|
}
|
|
|
|
void LLConversationItem::closeItem( void )
|
|
{
|
|
llinfos << "Merov debug : closeItem, title = " << mName << llendl;
|
|
}
|
|
|
|
void LLConversationItem::previewItem( void )
|
|
{
|
|
llinfos << "Merov debug : previewItem, title = " << mName << llendl;
|
|
}
|
|
|
|
void LLConversationItem::selectItem(void)
|
|
{
|
|
llinfos << "Merov debug : selectItem, title = " << mName << ", uuid = " << mUUID << llendl;
|
|
mContainer->selectFloater(mFloater);
|
|
}
|
|
|
|
void LLConversationItem::showProperties(void)
|
|
{
|
|
llinfos << "Merov debug : showProperties, title = " << mName << llendl;
|
|
}
|
|
|
|
|
|
// EOF
|