451 lines
14 KiB
C++
451 lines
14 KiB
C++
/**
|
|
* @file llsyswellwindow.cpp
|
|
* @brief // TODO
|
|
* $LicenseInfo:firstyear=2000&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" // must be first include
|
|
#include "llsyswellwindow.h"
|
|
|
|
#include "llchiclet.h"
|
|
#include "llchicletbar.h"
|
|
#include "llflatlistview.h"
|
|
#include "llfloaterreg.h"
|
|
#include "llnotificationmanager.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llscriptfloater.h"
|
|
#include "llspeakers.h"
|
|
#include "lltoastpanel.h"
|
|
|
|
//---------------------------------------------------------------------------------
|
|
LLSysWellWindow::LLSysWellWindow(const LLSD& key) : LLTransientDockableFloater(NULL, true, key),
|
|
mChannel(NULL),
|
|
mMessageList(NULL),
|
|
mSysWellChiclet(NULL),
|
|
NOTIFICATION_WELL_ANCHOR_NAME("notification_well_panel"),
|
|
IM_WELL_ANCHOR_NAME("im_well_panel"),
|
|
mIsReshapedByUser(false)
|
|
|
|
{
|
|
setOverlapsScreenChannel(true);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
bool LLSysWellWindow::postBuild()
|
|
{
|
|
mMessageList = getChild<LLFlatListView>("notification_list");
|
|
|
|
// get a corresponding channel
|
|
initChannel();
|
|
|
|
return LLTransientDockableFloater::postBuild();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::setMinimized(bool minimize)
|
|
{
|
|
LLTransientDockableFloater::setMinimized(minimize);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::handleReshape(const LLRect& rect, bool by_user)
|
|
{
|
|
mIsReshapedByUser |= by_user; // mark floater that it is reshaped by user
|
|
LLTransientDockableFloater::handleReshape(rect, by_user);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::onStartUpToastClick(S32 x, S32 y, MASK mask)
|
|
{
|
|
// just set floater visible. Screen channels will be cleared.
|
|
setVisible(true);
|
|
}
|
|
|
|
void LLSysWellWindow::setSysWellChiclet(LLSysWellChiclet* chiclet)
|
|
{
|
|
mSysWellChiclet = chiclet;
|
|
if(NULL != mSysWellChiclet)
|
|
{
|
|
mSysWellChiclet->updateWidget(isWindowEmpty());
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
LLSysWellWindow::~LLSysWellWindow()
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::removeItemByID(const LLUUID& id)
|
|
{
|
|
if(mMessageList->removeItemByValue(id))
|
|
{
|
|
if (NULL != mSysWellChiclet)
|
|
{
|
|
mSysWellChiclet->updateWidget(isWindowEmpty());
|
|
}
|
|
reshapeWindow();
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS() << "Unable to remove notification from the list, ID: " << id
|
|
<< LL_ENDL;
|
|
}
|
|
|
|
// hide chiclet window if there are no items left
|
|
if(isWindowEmpty())
|
|
{
|
|
setVisible(false);
|
|
}
|
|
}
|
|
|
|
LLPanel * LLSysWellWindow::findItemByID(const LLUUID& id)
|
|
{
|
|
return mMessageList->getItemByValue(id);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::initChannel()
|
|
{
|
|
LLNotificationsUI::LLScreenChannelBase* channel = LLNotificationsUI::LLChannelManager::getInstance()->findChannelByID(
|
|
LLNotificationsUI::NOTIFICATION_CHANNEL_UUID);
|
|
mChannel = dynamic_cast<LLNotificationsUI::LLScreenChannel*>(channel);
|
|
if(NULL == mChannel)
|
|
{
|
|
LL_WARNS() << "LLSysWellWindow::initChannel() - could not get a requested screen channel" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::setVisible(bool visible)
|
|
{
|
|
if (visible)
|
|
{
|
|
if (NULL == getDockControl() && getDockTongue().notNull())
|
|
{
|
|
setDockControl(new LLDockControl(
|
|
LLChicletBar::getInstance()->getChild<LLView>(getAnchorViewName()), this,
|
|
getDockTongue(), LLDockControl::BOTTOM));
|
|
}
|
|
}
|
|
|
|
// do not show empty window
|
|
if (NULL == mMessageList || isWindowEmpty()) visible = false;
|
|
|
|
LLTransientDockableFloater::setVisible(visible);
|
|
|
|
// update notification channel state
|
|
initChannel(); // make sure the channel still exists
|
|
if(mChannel)
|
|
{
|
|
mChannel->updateShowToastsState();
|
|
mChannel->redrawToasts();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::setDocked(bool docked, bool pop_on_undock)
|
|
{
|
|
LLTransientDockableFloater::setDocked(docked, pop_on_undock);
|
|
|
|
// update notification channel state
|
|
if(mChannel)
|
|
{
|
|
mChannel->updateShowToastsState();
|
|
mChannel->redrawToasts();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLSysWellWindow::reshapeWindow()
|
|
{
|
|
// save difference between floater height and the list height to take it into account while calculating new window height
|
|
// it includes height from floater top to list top and from floater bottom and list bottom
|
|
static S32 parent_list_delta_height = getRect().getHeight() - mMessageList->getRect().getHeight();
|
|
|
|
if (!mIsReshapedByUser) // Don't reshape Well window, if it ever was reshaped by user. See EXT-5715.
|
|
{
|
|
S32 notif_list_height = mMessageList->getItemsRect().getHeight() + 2 * mMessageList->getBorderWidth();
|
|
|
|
LLRect curRect = getRect();
|
|
|
|
S32 new_window_height = notif_list_height + parent_list_delta_height;
|
|
|
|
if (new_window_height > MAX_WINDOW_HEIGHT)
|
|
{
|
|
new_window_height = MAX_WINDOW_HEIGHT;
|
|
}
|
|
S32 newWidth = curRect.getWidth() < MIN_WINDOW_WIDTH ? MIN_WINDOW_WIDTH : curRect.getWidth();
|
|
|
|
curRect.setLeftTopAndSize(curRect.mLeft, curRect.mTop, newWidth, new_window_height);
|
|
reshape(curRect.getWidth(), curRect.getHeight(), true);
|
|
setRect(curRect);
|
|
}
|
|
|
|
// update notification channel state
|
|
// update on a window reshape is important only when a window is visible and docked
|
|
if(mChannel && getVisible() && isDocked())
|
|
{
|
|
mChannel->updateShowToastsState();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
bool LLSysWellWindow::isWindowEmpty()
|
|
{
|
|
return mMessageList->size() == 0;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* ObjectRowPanel implementation */
|
|
/************************************************************************/
|
|
|
|
LLIMWellWindow::ObjectRowPanel::ObjectRowPanel(const LLUUID& notification_id, bool new_message/* = false*/)
|
|
: LLPanel()
|
|
, mChiclet(NULL)
|
|
{
|
|
buildFromFile( "panel_active_object_row.xml");
|
|
|
|
initChiclet(notification_id);
|
|
|
|
LLTextBox* obj_name = getChild<LLTextBox>("object_name");
|
|
obj_name->setValue(LLScriptFloaterManager::getObjectName(notification_id));
|
|
|
|
mCloseBtn = getChild<LLButton>("hide_btn");
|
|
mCloseBtn->setCommitCallback(boost::bind(&LLIMWellWindow::ObjectRowPanel::onClosePanel, this));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
LLIMWellWindow::ObjectRowPanel::~ObjectRowPanel()
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLIMWellWindow::ObjectRowPanel::onClosePanel()
|
|
{
|
|
LLScriptFloaterManager::getInstance()->removeNotification(mChiclet->getSessionId());
|
|
}
|
|
|
|
void LLIMWellWindow::ObjectRowPanel::initChiclet(const LLUUID& notification_id, bool new_message/* = false*/)
|
|
{
|
|
// Choose which of the pre-created chiclets to use.
|
|
switch(LLScriptFloaterManager::getObjectType(notification_id))
|
|
{
|
|
case LLScriptFloaterManager::OBJ_GIVE_INVENTORY:
|
|
mChiclet = getChild<LLInvOfferChiclet>("inv_offer_chiclet");
|
|
break;
|
|
default:
|
|
mChiclet = getChild<LLScriptChiclet>("object_chiclet");
|
|
break;
|
|
}
|
|
|
|
mChiclet->setVisible(true);
|
|
mChiclet->setSessionId(notification_id);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLIMWellWindow::ObjectRowPanel::onMouseEnter(S32 x, S32 y, MASK mask)
|
|
{
|
|
setTransparentColor(LLUIColorTable::instance().getColor("SysWellItemSelected"));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
void LLIMWellWindow::ObjectRowPanel::onMouseLeave(S32 x, S32 y, MASK mask)
|
|
{
|
|
setTransparentColor(LLUIColorTable::instance().getColor("SysWellItemUnselected"));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
// virtual
|
|
bool LLIMWellWindow::ObjectRowPanel::handleMouseDown(S32 x, S32 y, MASK mask)
|
|
{
|
|
// Pass the mouse down event to the chiclet (EXT-596).
|
|
if (!mChiclet->pointInView(x, y) && !mCloseBtn->getRect().pointInRect(x, y)) // prevent double call of LLIMChiclet::onMouseDown()
|
|
{
|
|
mChiclet->onMouseDown();
|
|
return true;
|
|
}
|
|
|
|
return LLPanel::handleMouseDown(x, y, mask);
|
|
}
|
|
|
|
// virtual
|
|
bool LLIMWellWindow::ObjectRowPanel::handleRightMouseDown(S32 x, S32 y, MASK mask)
|
|
{
|
|
return mChiclet->handleRightMouseDown(x, y, mask);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* LLIMWellWindow implementation */
|
|
/************************************************************************/
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// PUBLIC METHODS
|
|
LLIMWellWindow::LLIMWellWindow(const LLSD& key)
|
|
: LLSysWellWindow(key)
|
|
{
|
|
}
|
|
|
|
LLIMWellWindow::~LLIMWellWindow()
|
|
{
|
|
}
|
|
|
|
// static
|
|
LLIMWellWindow* LLIMWellWindow::getInstance(const LLSD& key /*= LLSD()*/)
|
|
{
|
|
return LLFloaterReg::getTypedInstance<LLIMWellWindow>("im_well_window", key);
|
|
}
|
|
|
|
|
|
// static
|
|
LLIMWellWindow* LLIMWellWindow::findInstance(const LLSD& key /*= LLSD()*/)
|
|
{
|
|
return LLFloaterReg::findTypedInstance<LLIMWellWindow>("im_well_window", key);
|
|
}
|
|
|
|
bool LLIMWellWindow::postBuild()
|
|
{
|
|
bool rv = LLSysWellWindow::postBuild();
|
|
setTitle(getString("title_im_well_window"));
|
|
|
|
LLIMChiclet::sFindChicletsSignal.connect(boost::bind(&LLIMWellWindow::findObjectChiclet, this, _1));
|
|
|
|
return rv;
|
|
}
|
|
|
|
LLChiclet* LLIMWellWindow::findObjectChiclet(const LLUUID& notification_id)
|
|
{
|
|
if (!mMessageList) return NULL;
|
|
|
|
LLChiclet* res = NULL;
|
|
ObjectRowPanel* panel = mMessageList->getTypedItemByValue<ObjectRowPanel>(notification_id);
|
|
if (panel != NULL)
|
|
{
|
|
res = panel->mChiclet;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// PRIVATE METHODS
|
|
|
|
void LLIMWellWindow::addObjectRow(const LLUUID& notification_id, bool new_message/* = false*/)
|
|
{
|
|
if (mMessageList->getItemByValue(notification_id) == NULL)
|
|
{
|
|
ObjectRowPanel* item = new ObjectRowPanel(notification_id, new_message);
|
|
if (!mMessageList->addItem(item, notification_id))
|
|
{
|
|
LL_WARNS() << "Unable to add Object Row into the list, notificationID: " << notification_id << LL_ENDL;
|
|
item->die();
|
|
}
|
|
reshapeWindow();
|
|
}
|
|
}
|
|
|
|
void LLIMWellWindow::removeObjectRow(const LLUUID& notification_id)
|
|
{
|
|
if (!mMessageList->removeItemByValue(notification_id))
|
|
{
|
|
LL_WARNS() << "Unable to remove Object Row from the list, notificationID: " << notification_id << LL_ENDL;
|
|
}
|
|
|
|
reshapeWindow();
|
|
// hide chiclet window if there are no items left
|
|
if(isWindowEmpty())
|
|
{
|
|
setVisible(false);
|
|
}
|
|
}
|
|
|
|
void LLIMWellWindow::closeAll()
|
|
{
|
|
// Generate an ignorable alert dialog if there is an active voice IM sesion
|
|
bool need_confirmation = false;
|
|
const LLIMModel& im_model = LLIMModel::instance();
|
|
std::vector<LLSD> values;
|
|
mMessageList->getValues(values);
|
|
for (std::vector<LLSD>::iterator
|
|
iter = values.begin(),
|
|
iter_end = values.end();
|
|
iter != iter_end; ++iter)
|
|
{
|
|
LLIMSpeakerMgr* speaker_mgr = im_model.getSpeakerManager(*iter);
|
|
if (speaker_mgr && speaker_mgr->isVoiceActive())
|
|
{
|
|
need_confirmation = true;
|
|
break;
|
|
}
|
|
}
|
|
if ( need_confirmation )
|
|
{
|
|
//Bring up a confirmation dialog
|
|
LLNotificationsUtil::add
|
|
("ConfirmCloseAll", LLSD(), LLSD(),
|
|
boost::bind(&LLIMWellWindow::confirmCloseAll, this, _1, _2));
|
|
}
|
|
else
|
|
{
|
|
closeAllImpl();
|
|
}
|
|
}
|
|
|
|
void LLIMWellWindow::closeAllImpl()
|
|
{
|
|
std::vector<LLSD> values;
|
|
mMessageList->getValues(values);
|
|
|
|
for (std::vector<LLSD>::iterator
|
|
iter = values.begin(),
|
|
iter_end = values.end();
|
|
iter != iter_end; ++iter)
|
|
{
|
|
LLPanel* panel = mMessageList->getItemByValue(*iter);
|
|
|
|
ObjectRowPanel* obj_panel = dynamic_cast <ObjectRowPanel*> (panel);
|
|
if (obj_panel)
|
|
{
|
|
LLScriptFloaterManager::instance().removeNotification(*iter);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool LLIMWellWindow::confirmCloseAll(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
switch(option)
|
|
{
|
|
case 0:
|
|
{
|
|
closeAllImpl();
|
|
return true;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|