livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
phoenix-firestorm/indra/newview/llbottomtray.cpp

950 lines
29 KiB
C++
Raw Blame History

/**
* @file llbottomtray.cpp
* @brief LLBottomTray class implementation
*
* $LicenseInfo:firstyear=2009&license=viewergpl$
*
* Copyright (c) 2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h" // must be first include
#include "llbottomtray.h"
#include "llagent.h"
#include "llchiclet.h"
#include "llfloaterreg.h"
#include "llflyoutbutton.h"
#include "llimfloater.h" // for LLIMFloater
#include "lllayoutstack.h"
#include "llnearbychatbar.h"
#include "llnotificationsutil.h"
#include "llspeakbutton.h"
#include "llsplitbutton.h"
#include "llsyswellwindow.h"
#include "llfloatercamera.h"
LLBottomTray::LLBottomTray(const LLSD&)
: mChicletPanel(NULL),
mSysWell(NULL),
mSpeakPanel(NULL),
mSpeakBtn(NULL),
mNearbyChatBar(NULL),
mToolbarStack(NULL)
, mMovementButton(NULL)
, mResizeState(RS_NORESIZE)
// Add more members
{
mFactoryMap["chat_bar"] = LLCallbackMap(LLBottomTray::createNearbyChatBar, NULL);
LLUICtrlFactory::getInstance()->buildPanel(this,"panel_bottomtray.xml");
mChicletPanel = getChild<LLChicletPanel>("chiclet_list");
mSysWell = getChild<LLNotificationChiclet>("sys_well");
// init mSysWell
// set handler for a Click operation
mSysWell->setClickCallback(boost::bind(&LLSysWellWindow::onChicletClick, LLFloaterReg::getTypedInstance<LLSysWellWindow>("syswell_window")));
mChicletPanel->setChicletClickedCallback(boost::bind(&LLBottomTray::onChicletClick,this,_1));
LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("CameraPresets.ChangeView", boost::bind(&LLFloaterCamera::onClickCameraPresets, _2));
LLIMMgr::getInstance()->addSessionObserver(this);
//this is to fix a crash that occurs because LLBottomTray is a singleton
//and thus is deleted at the end of the viewers lifetime, but to be cleanly
//destroyed LLBottomTray requires some subsystems that are long gone
//LLUI::getRootView()->addChild(this);
initStateProcessedObjectMap();
// Necessary for focus movement among child controls
setFocusRoot(TRUE);
}
LLBottomTray::~LLBottomTray()
{
if (!LLSingleton<LLIMMgr>::destroyed())
{
LLIMMgr::getInstance()->removeSessionObserver(this);
}
}
void LLBottomTray::onChicletClick(LLUICtrl* ctrl)
{
LLIMChiclet* chiclet = dynamic_cast<LLIMChiclet*>(ctrl);
if (chiclet)
{
// Until you can type into an IM Window and have a conversation,
// still show the old communicate window
//LLFloaterReg::showInstance("communicate", chiclet->getSessionId());
// Show after comm window so it is frontmost (and hence will not
// auto-hide)
// this logic has been moved to LLIMChiclet::handleMouseDown
// LLIMFloater::show(chiclet->getSessionId());
// chiclet->setCounter(0);
}
}
// *TODO Vadim: why void* ?
void* LLBottomTray::createNearbyChatBar(void* userdata)
{
return new LLNearbyChatBar();
}
LLIMChiclet* LLBottomTray::createIMChiclet(const LLUUID& session_id)
{
LLIMChiclet::EType im_chiclet_type = LLIMChiclet::getIMSessionType(session_id);
switch (im_chiclet_type)
{
case LLIMChiclet::TYPE_IM:
return getChicletPanel()->createChiclet<LLIMP2PChiclet>(session_id);
case LLIMChiclet::TYPE_GROUP:
return getChicletPanel()->createChiclet<LLIMGroupChiclet>(session_id);
case LLIMChiclet::TYPE_AD_HOC:
return getChicletPanel()->createChiclet<LLAdHocChiclet>(session_id);
case LLIMChiclet::TYPE_UNKNOWN:
break;
}
return NULL;
}
//virtual
void LLBottomTray::sessionAdded(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id)
{
if(getChicletPanel())
{
if(getChicletPanel()->findChiclet<LLChiclet>(session_id))
{
}
else
{
LLIMChiclet* chiclet = createIMChiclet(session_id);
if(chiclet)
{
chiclet->setIMSessionName(name);
chiclet->setOtherParticipantId(other_participant_id);
}
else
{
llerrs << "Could not create chiclet" << llendl;
}
}
}
}
//virtual
void LLBottomTray::sessionRemoved(const LLUUID& session_id)
{
if(getChicletPanel())
{
// IM floater should be closed when session removed and associated chiclet closed
LLIMFloater* iMfloater = LLFloaterReg::findTypedInstance<LLIMFloater>(
"impanel", session_id);
if (iMfloater != NULL)
{
iMfloater->closeFloater();
}
getChicletPanel()->removeChiclet(session_id);
}
}
void LLBottomTray::sessionIDUpdated(const LLUUID& old_session_id, const LLUUID& new_session_id)
{
//this is only needed in case of outgoing ad-hoc/group chat sessions
LLChicletPanel* chiclet_panel = getChicletPanel();
if (chiclet_panel)
{
//it should be ad-hoc im chiclet or group im chiclet
LLChiclet* chiclet = chiclet_panel->findChiclet<LLChiclet>(old_session_id);
if (chiclet) chiclet->setSessionId(new_session_id);
}
}
// virtual
void LLBottomTray::onChange(EStatusType status, const std::string &channelURI, bool proximal)
{
// Time it takes to connect to voice channel might be pretty long,
// so don't expect user login or STATUS_VOICE_ENABLED to be followed by STATUS_JOINED.
BOOL enable = FALSE;
switch (status)
{
// Do not add STATUS_VOICE_ENABLED because voice chat is
// inactive until STATUS_JOINED
case STATUS_JOINED:
enable = TRUE;
break;
default:
enable = FALSE;
break;
}
mSpeakBtn->setEnabled(enable);
}
//virtual
void LLBottomTray::onFocusLost()
{
if (gAgent.cameraMouselook())
{
setVisible(FALSE);
}
}
//virtual
// setVisible used instead of onVisibilityChange, since LLAgent calls it on entering/leaving mouselook mode.
// If bottom tray is already visible in mouselook mode, then onVisibilityChange will not be called from setVisible(true),
void LLBottomTray::setVisible(BOOL visible)
{
LLPanel::setVisible(visible);
// *NOTE: we must check mToolbarStack against NULL because setVisible is called from the
// LLPanel::initFromParams BEFORE postBuild is called and child controls are not exist yet
if (NULL != mToolbarStack)
{
BOOL visibility = gAgent.cameraMouselook() ? false : true;
for ( child_list_const_iter_t child_it = mToolbarStack->getChildList()->begin();
child_it != mToolbarStack->getChildList()->end(); child_it++)
{
LLView* viewp = *child_it;
std::string name = viewp->getName();
if ("chat_bar" == name || "movement_panel" == name || "cam_panel" == name || "snapshot_panel" == name || "gesture_panel" == name)
continue;
else
{
viewp->setVisible(visibility);
}
}
}
}
void LLBottomTray::showBottomTrayContextMenu(S32 x, S32 y, MASK mask)
{
// We should show BottomTrayContextMenu in last turn
if (mBottomTrayContextMenu && !LLMenuGL::sMenuContainer->getVisibleMenu())
{
//there are no other context menu (IM chiclet etc ), so we can show BottomTrayContextMenu
mBottomTrayContextMenu->buildDrawLabels();
mBottomTrayContextMenu->updateParent(LLMenuGL::sMenuContainer);
LLMenuGL::showPopup(this, mBottomTrayContextMenu, x, y);
}
}
void LLBottomTray::showGestureButton(BOOL visible)
{
setTrayButtonVisibleIfPossible(RS_BUTTON_GESTURES, visible);
}
void LLBottomTray::showMoveButton(BOOL visible)
{
setTrayButtonVisibleIfPossible(RS_BUTTON_MOVEMENT, visible);
}
void LLBottomTray::showCameraButton(BOOL visible)
{
setTrayButtonVisibleIfPossible(RS_BUTTON_CAMERA, visible);
}
void LLBottomTray::showSnapshotButton(BOOL visible)
{
setTrayButtonVisibleIfPossible(RS_BUTTON_SNAPSHOT, visible);
}
namespace
{
const std::string& PANEL_CHICLET_NAME = "chiclet_list_panel";
const std::string& PANEL_CHATBAR_NAME = "chat_bar";
const std::string& PANEL_MOVEMENT_NAME = "movement_panel";
const std::string& PANEL_CAMERA_NAME = "cam_panel";
const std::string& PANEL_GESTURE_NAME = "gesture_panel";
}
BOOL LLBottomTray::postBuild()
{
mBottomTrayContextMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_bottomtray.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
gMenuHolder->addChild(mBottomTrayContextMenu);
mNearbyChatBar = getChild<LLNearbyChatBar>("chat_bar");
mToolbarStack = getChild<LLLayoutStack>("toolbar_stack");
mMovementPanel = getChild<LLPanel>("movement_panel");
mMovementButton = mMovementPanel->getChild<LLButton>("movement_btn");
mGesturePanel = getChild<LLPanel>("gesture_panel");
mCamPanel = getChild<LLPanel>("cam_panel");
mCamButton = mCamPanel->getChild<LLButton>("camera_btn");
mSnapshotPanel = getChild<LLPanel>("snapshot_panel");
setRightMouseDownCallback(boost::bind(&LLBottomTray::showBottomTrayContextMenu,this, _2, _3,_4));
mSpeakPanel = getChild<LLPanel>("speak_panel");
mSpeakBtn = getChild<LLSpeakButton>("talk");
// Speak button should be initially disabled because
// it takes some time between logging in to world and connecting to voice channel.
mSpeakBtn->setEnabled(FALSE);
// Localization tool doesn't understand custom buttons like <talk_button>
mSpeakBtn->setSpeakToolTip( getString("SpeakBtnToolTip") );
mSpeakBtn->setShowToolTip( getString("VoiceControlBtnToolTip") );
// Registering Chat Bar to receive Voice client status change notifications.
gVoiceClient->addObserver(this);
mObjectDefaultWidthMap[RS_BUTTON_GESTURES] = mGesturePanel->getRect().getWidth();
mObjectDefaultWidthMap[RS_BUTTON_MOVEMENT] = mMovementPanel->getRect().getWidth();
mObjectDefaultWidthMap[RS_BUTTON_CAMERA] = mCamPanel->getRect().getWidth();
mObjectDefaultWidthMap[RS_BUTTON_SPEAK] = mSpeakPanel->getRect().getWidth();
return TRUE;
}
void LLBottomTray::log(LLView* panel, const std::string& descr)
{
if (NULL == panel) return;
LLView* layout = panel->getParent();
lldebugs << descr << ": "
<< "panel: " << panel->getName()
<< ", rect: " << panel->getRect()
<< "layout: " << layout->getName()
<< ", rect: " << layout->getRect()
<< llendl
;
}
void LLBottomTray::reshape(S32 width, S32 height, BOOL called_from_parent)
{
static S32 debug_calling_number = 0;
lldebugs << "**************************************** " << ++debug_calling_number << llendl;
S32 current_width = getRect().getWidth();
S32 delta_width = width - current_width;
lldebugs << "Reshaping: "
<< ", width: " << width
<< ", cur width: " << current_width
<< ", delta_width: " << delta_width
<< ", called_from_parent: " << called_from_parent
<< llendl;
if (mNearbyChatBar) log(mNearbyChatBar, "before");
if (mChicletPanel) log(mChicletPanel, "before");
// stores width size on which bottom tray is less than width required by its children. EXT-991
static S32 extra_shrink_width = 0;
bool should_be_reshaped = true;
if (mChicletPanel && mToolbarStack && mNearbyChatBar)
{
mToolbarStack->updatePanelAutoResize(PANEL_CHICLET_NAME, TRUE);
// bottom tray is narrowed
if (delta_width < 0)
{
if (extra_shrink_width > 0)
{
// is world rect was extra shrunk and decreasing again only update this value
// to delta_width negative
extra_shrink_width -= delta_width; // use "-=" because delta_width is negative
should_be_reshaped = false;
}
else
{
extra_shrink_width = processWidthDecreased(delta_width);
// increase new width to extra_shrink_width value to not reshape less than bottom tray minimum
width += extra_shrink_width;
}
}
// bottom tray is widen
else
{
if (extra_shrink_width > delta_width)
{
// Less than minimum width is more than increasing (delta_width)
// only reduce it value and make no reshape
extra_shrink_width -= delta_width;
should_be_reshaped = false;
}
else
{
if (extra_shrink_width > 0)
{
// If we have some extra shrink width let's reduce delta_width & width
delta_width -= extra_shrink_width;
width -= extra_shrink_width;
extra_shrink_width = 0;
}
processWidthIncreased(delta_width);
}
}
}
if (should_be_reshaped)
{
lldebugs << "Reshape all children with width: " << width << llendl;
LLPanel::reshape(width, height, called_from_parent);
}
if (mNearbyChatBar) log(mNearbyChatBar, "after");
if (mChicletPanel) log(mChicletPanel, "after");
}
S32 LLBottomTray::processWidthDecreased(S32 delta_width)
{
bool still_should_be_processed = true;
const S32 chiclet_panel_width = mChicletPanel->getParent()->getRect().getWidth();
const S32 chiclet_panel_min_width = mChicletPanel->getMinWidth();
if (chiclet_panel_width > chiclet_panel_min_width)
{
// we have some space to decrease chiclet panel
S32 panel_delta_min = chiclet_panel_width - chiclet_panel_min_width;
S32 delta_panel = llmin(-delta_width, panel_delta_min);
lldebugs << "delta_width: " << delta_width
<< ", panel_delta_min: " << panel_delta_min
<< ", delta_panel: " << delta_panel
<< llendl;
// is chiclet panel width enough to process resizing?
delta_width += panel_delta_min;
still_should_be_processed = delta_width < 0;
mChicletPanel->getParent()->reshape(mChicletPanel->getParent()->getRect().getWidth() - delta_panel, mChicletPanel->getParent()->getRect().getHeight());
log(mChicletPanel, "after processing panel decreasing via chiclet panel");
lldebugs << "RS_CHICLET_PANEL"
<< ", delta_width: " << delta_width
<< llendl;
}
const S32 chatbar_panel_width = mNearbyChatBar->getRect().getWidth();
const S32 chatbar_panel_min_width = mNearbyChatBar->getMinWidth();
if (still_should_be_processed && chatbar_panel_width > chatbar_panel_min_width)
{
// we have some space to decrease chatbar panel
S32 panel_delta_min = chatbar_panel_width - chatbar_panel_min_width;
S32 delta_panel = llmin(-delta_width, panel_delta_min);
// whether chatbar panel width is enough to process resizing?
delta_width += panel_delta_min;
still_should_be_processed = delta_width < 0;
mNearbyChatBar->reshape(mNearbyChatBar->getRect().getWidth() - delta_panel, mNearbyChatBar->getRect().getHeight());
log(mChicletPanel, "after processing panel decreasing via nearby chatbar panel");
lldebugs << "RS_CHATBAR_INPUT"
<< ", delta_panel: " << delta_panel
<< ", delta_width: " << delta_width
<< llendl;
}
S32 extra_shrink_width = 0;
S32 buttons_freed_width = 0;
if (still_should_be_processed)
{
processShrinkButtons(&delta_width, &buttons_freed_width);
if (delta_width < 0)
{
processHideButton(RS_BUTTON_SNAPSHOT, &delta_width, &buttons_freed_width);
}
if (delta_width < 0)
{
processHideButton(RS_BUTTON_CAMERA, &delta_width, &buttons_freed_width);
}
if (delta_width < 0)
{
processHideButton(RS_BUTTON_MOVEMENT, &delta_width, &buttons_freed_width);
}
if (delta_width < 0)
{
processHideButton(RS_BUTTON_GESTURES, &delta_width, &buttons_freed_width);
}
if (delta_width < 0)
{
extra_shrink_width = -delta_width;
llwarns << "There is no enough width to reshape all children: "
<< extra_shrink_width << llendl;
}
if (buttons_freed_width > 0)
{
log(mNearbyChatBar, "before applying compensative width");
mNearbyChatBar->reshape(mNearbyChatBar->getRect().getWidth() + buttons_freed_width, mNearbyChatBar->getRect().getHeight() );
log(mNearbyChatBar, "after applying compensative width");
lldebugs << buttons_freed_width << llendl;
}
}
return extra_shrink_width;
}
void LLBottomTray::processWidthIncreased(S32 delta_width)
{
if (delta_width <= 0) return;
const S32 chiclet_panel_width = mChicletPanel->getParent()->getRect().getWidth();
const S32 chiclet_panel_min_width = mChicletPanel->getMinWidth();
const S32 chatbar_panel_width = mNearbyChatBar->getRect().getWidth();
const S32 chatbar_panel_min_width = mNearbyChatBar->getMinWidth();
const S32 chatbar_panel_max_width = mNearbyChatBar->getMaxWidth();
const S32 chatbar_available_shrink_width = chatbar_panel_width - chatbar_panel_min_width;
const S32 available_width_chiclet = chiclet_panel_width - chiclet_panel_min_width;
// how many room we have to show hidden buttons
S32 total_available_width = delta_width + chatbar_available_shrink_width + available_width_chiclet;
lldebugs << "Processing extending, available width:"
<< ", chatbar - " << chatbar_available_shrink_width
<< ", chiclets - " << available_width_chiclet
<< ", total - " << total_available_width
<< llendl;
S32 available_width = total_available_width;
if (available_width > 0)
{
processShowButton(RS_BUTTON_GESTURES, &available_width);
}
if (available_width > 0)
{
processShowButton(RS_BUTTON_MOVEMENT, &available_width);
}
if (available_width > 0)
{
processShowButton(RS_BUTTON_CAMERA, &available_width);
}
if (available_width > 0)
{
processShowButton(RS_BUTTON_SNAPSHOT, &available_width);
}
processExtendButtons(&available_width);
// if we have to show/extend some buttons but resized delta width is not enough...
S32 processed_width = total_available_width - available_width;
if (processed_width > delta_width)
{
// ... let's shrink nearby chat & chiclet panels
S32 required_to_process_width = processed_width;
// 1. use delta width of resizing
required_to_process_width -= delta_width;
// 2. use width available via decreasing of nearby chat panel
S32 chatbar_shrink_width = required_to_process_width;
if (chatbar_available_shrink_width < chatbar_shrink_width)
{
chatbar_shrink_width = chatbar_available_shrink_width;
}
log(mNearbyChatBar, "increase width: before applying compensative width");
mNearbyChatBar->reshape(mNearbyChatBar->getRect().getWidth() - chatbar_shrink_width, mNearbyChatBar->getRect().getHeight() );
if (mNearbyChatBar) log(mNearbyChatBar, "after applying compensative width");
lldebugs << chatbar_shrink_width << llendl;
// 3. use width available via decreasing of chiclet panel
required_to_process_width -= chatbar_shrink_width;
if (required_to_process_width > 0)
{
mChicletPanel->getParent()->reshape(mChicletPanel->getParent()->getRect().getWidth() - required_to_process_width, mChicletPanel->getParent()->getRect().getHeight());
log(mChicletPanel, "after applying compensative width for chiclets: ");
lldebugs << required_to_process_width << llendl;
}
}
// shown buttons take some space, rest should be processed by nearby chatbar & chiclet panels
delta_width -= processed_width;
// how many space can nearby chatbar take?
S32 chatbar_panel_width_ = mNearbyChatBar->getRect().getWidth();
if (delta_width > 0 && chatbar_panel_width_ < chatbar_panel_max_width)
{
S32 delta_panel_max = chatbar_panel_max_width - chatbar_panel_width_;
S32 delta_panel = llmin(delta_width, delta_panel_max);
lldebugs << "Unprocesed delta width: " << delta_width
<< ", can be applied to chatbar: " << delta_panel_max
<< ", will be applied: " << delta_panel
<< llendl;
delta_width -= delta_panel_max;
mNearbyChatBar->reshape(chatbar_panel_width_ + delta_panel, mNearbyChatBar->getRect().getHeight());
log(mNearbyChatBar, "applied unprocessed delta width");
}
}
bool LLBottomTray::processShowButton(EResizeState shown_object_type, S32* available_width)
{
lldebugs << "Trying to show object type: " << shown_object_type << llendl;
LLPanel* panel = mStateProcessedObjectMap[shown_object_type];
if (NULL == panel)
{
lldebugs << "There is no object to process for state: " << shown_object_type << llendl;
return false;
}
bool can_be_shown = canButtonBeShown(shown_object_type);
if (can_be_shown)
{
//validate if we have enough room to show this button
const S32 required_width = panel->getRect().getWidth();
can_be_shown = *available_width >= required_width;
if (can_be_shown)
{
*available_width -= required_width;
setTrayButtonVisible(shown_object_type, true);
lldebugs << "processed object type: " << shown_object_type
<< ", rest available width: " << *available_width
<< llendl;
mResizeState &= ~shown_object_type;
}
}
return can_be_shown;
}
void LLBottomTray::processHideButton(EResizeState processed_object_type, S32* required_width, S32* buttons_freed_width)
{
lldebugs << "Trying to hide object type: " << processed_object_type << llendl;
LLPanel* panel = mStateProcessedObjectMap[processed_object_type];
if (NULL == panel)
{
lldebugs << "There is no object to process for state: " << processed_object_type << llendl;
return;
}
if (panel->getVisible())
{
*required_width += panel->getRect().getWidth();
if (*required_width > 0)
{
*buttons_freed_width += *required_width;
}
setTrayButtonVisible(processed_object_type, false);
mResizeState |= processed_object_type;
lldebugs << "processing object type: " << processed_object_type
<< ", buttons_freed_width: " << *buttons_freed_width
<< llendl;
}
}
void LLBottomTray::processShrinkButtons(S32* required_width, S32* buttons_freed_width)
{
processShrinkButton(RS_BUTTON_CAMERA, required_width);
if (*required_width < 0)
{
processShrinkButton(RS_BUTTON_MOVEMENT, required_width);
}
if (*required_width < 0)
{
processShrinkButton(RS_BUTTON_GESTURES, required_width);
}
if (*required_width < 0)
{
S32 panel_min_width = 0;
std::string panel_name = mSpeakPanel->getName();
bool success = mToolbarStack->getPanelMinSize(panel_name, &panel_min_width, NULL);
if (!success)
{
lldebugs << "Panel was not found to get its min width: " << panel_name << llendl;
}
else
{
//
mSpeakBtn->setLabelVisible(false);
S32 panel_width = mSpeakPanel->getRect().getWidth();
S32 possible_shrink_width = panel_width - panel_min_width;
if (possible_shrink_width > 0)
{
mSpeakPanel->reshape(panel_width - possible_shrink_width, mSpeakPanel->getRect().getHeight());
*required_width += possible_shrink_width;
if (*required_width > 0)
{
*buttons_freed_width += *required_width;
}
lldebugs << "Shrunk panel: " << panel_name
<< ", shrunk width: " << possible_shrink_width
<< ", rest width to process: " << *required_width
<< llendl;
}
}
}
}
void LLBottomTray::processShrinkButton(EResizeState processed_object_type, S32* required_width)
{
LLPanel* panel = mStateProcessedObjectMap[processed_object_type];
if (NULL == panel)
{
lldebugs << "There is no object to process for type: " << processed_object_type << llendl;
return;
}
if (panel->getVisible())
{
S32 panel_width = panel->getRect().getWidth();
S32 panel_min_width = 0;
std::string panel_name = panel->getName();
bool success = mToolbarStack->getPanelMinSize(panel_name, &panel_min_width, NULL);
S32 possible_shrink_width = panel_width - panel_min_width;
if (!success)
{
lldebugs << "Panel was not found to get its min width: " << panel_name << llendl;
}
// we have some space to free by shrinking the button
else if (possible_shrink_width > 0)
{
// let calculate real width to shrink
// 1. apply all possible width
*required_width += possible_shrink_width;
// 2. it it is too much...
if (*required_width > 0)
{
// reduce applied shrunk width to the excessive value.
possible_shrink_width -= *required_width;
*required_width = 0;
}
panel->reshape(panel_width - possible_shrink_width, panel->getRect().getHeight());
lldebugs << "Shrunk panel: " << panel_name
<< ", shrunk width: " << possible_shrink_width
<< ", rest width to process: " << *required_width
<< llendl;
}
}
}
void LLBottomTray::processExtendButtons(S32* available_width)
{
// do not allow extending any buttons if we have some buttons hidden
if (mResizeState & RS_BUTTONS_CAN_BE_HIDDEN) return;
processExtendButton(RS_BUTTON_GESTURES, available_width);
if (*available_width > 0)
{
processExtendButton(RS_BUTTON_CAMERA, available_width);
}
if (*available_width > 0)
{
processExtendButton(RS_BUTTON_MOVEMENT, available_width);
}
if (*available_width > 0)
{
S32 panel_max_width = mObjectDefaultWidthMap[RS_BUTTON_SPEAK];
S32 panel_width = mSpeakPanel->getRect().getWidth();
S32 possible_extend_width = panel_max_width - panel_width;
if (possible_extend_width > 0 && possible_extend_width <= *available_width)
{
mSpeakBtn->setLabelVisible(true);
mSpeakPanel->reshape(panel_max_width, mSpeakPanel->getRect().getHeight());
log(mSpeakBtn, "speak button is extended");
*available_width -= possible_extend_width;
lldebugs << "Extending panel: " << mSpeakPanel->getName()
<< ", extended width: " << possible_extend_width
<< ", rest width to process: " << *available_width
<< llendl;
}
}
}
void LLBottomTray::processExtendButton(EResizeState processed_object_type, S32* available_width)
{
LLPanel* panel = mStateProcessedObjectMap[processed_object_type];
if (NULL == panel)
{
lldebugs << "There is no object to process for type: " << processed_object_type << llendl;
return;
}
if (!panel->getVisible()) return;
S32 panel_max_width = mObjectDefaultWidthMap[processed_object_type];
S32 panel_width = panel->getRect().getWidth();
S32 possible_extend_width = panel_max_width - panel_width;
if (possible_extend_width > 0)
{
// let calculate real width to extend
// 1. apply all possible width
*available_width -= possible_extend_width;
// 2. it it is too much...
if (*available_width < 0)
{
// reduce applied extended width to the excessive value.
possible_extend_width += *available_width;
*available_width = 0;
}
panel->reshape(panel_width + possible_extend_width, panel->getRect().getHeight());
lldebugs << "Extending panel: " << panel->getName()
<< ", extended width: " << possible_extend_width
<< ", rest width to process: " << *available_width
<< llendl;
}
}
bool LLBottomTray::canButtonBeShown(EResizeState processed_object_type) const
{
bool can_be_shown = mResizeState & processed_object_type;
if (can_be_shown)
{
static MASK MOVEMENT_PREVIOUS_BUTTONS_MASK = RS_BUTTON_GESTURES;
static MASK CAMERA_PREVIOUS_BUTTONS_MASK = RS_BUTTON_GESTURES | RS_BUTTON_MOVEMENT;
static MASK SNAPSHOT_PREVIOUS_BUTTONS_MASK = RS_BUTTON_GESTURES | RS_BUTTON_MOVEMENT | RS_BUTTON_CAMERA;
switch(processed_object_type)
{
case RS_BUTTON_GESTURES: // Gestures should be shown first
break;
case RS_BUTTON_MOVEMENT: // Move only if gesture is shown
can_be_shown = !(MOVEMENT_PREVIOUS_BUTTONS_MASK & mResizeState);
break;
case RS_BUTTON_CAMERA:
can_be_shown = !(CAMERA_PREVIOUS_BUTTONS_MASK & mResizeState);
break;
case RS_BUTTON_SNAPSHOT:
can_be_shown = !(SNAPSHOT_PREVIOUS_BUTTONS_MASK & mResizeState);
break;
default: // nothing to do here
break;
}
}
return can_be_shown;
}
void LLBottomTray::initStateProcessedObjectMap()
{
mStateProcessedObjectMap.insert(std::make_pair(RS_BUTTON_GESTURES, mGesturePanel));
mStateProcessedObjectMap.insert(std::make_pair(RS_BUTTON_MOVEMENT, mMovementPanel));
mStateProcessedObjectMap.insert(std::make_pair(RS_BUTTON_CAMERA, mCamPanel));
mStateProcessedObjectMap.insert(std::make_pair(RS_BUTTON_SNAPSHOT, mSnapshotPanel));
}
void LLBottomTray::setTrayButtonVisible(EResizeState shown_object_type, bool visible)
{
LLPanel* panel = mStateProcessedObjectMap[shown_object_type];
if (NULL == panel)
{
lldebugs << "There is no object to show for state: " << shown_object_type << llendl;
return;
}
panel->setVisible(visible);
}
void LLBottomTray::setTrayButtonVisibleIfPossible(EResizeState shown_object_type, bool visible)
{
bool can_be_set = true;
if (visible)
{
LLPanel* panel = mStateProcessedObjectMap[shown_object_type];
if (NULL == panel)
{
lldebugs << "There is no object to process for state: " << shown_object_type << llendl;
return;
}
const S32 chatbar_panel_width = mNearbyChatBar->getRect().getWidth();
const S32 chatbar_panel_min_width = mNearbyChatBar->getMinWidth();
const S32 chiclet_panel_width = mChicletPanel->getParent()->getRect().getWidth();
const S32 chiclet_panel_min_width = mChicletPanel->getMinWidth();
const S32 available_width = (chatbar_panel_width - chatbar_panel_min_width)
+ (chiclet_panel_width - chiclet_panel_min_width);
const S32 required_width = panel->getRect().getWidth();
can_be_set = available_width >= required_width;
}
if (can_be_set)
{
setTrayButtonVisible(shown_object_type, visible);
// if we hide the button mark it NOT to show while future bottom tray extending
if (!visible)
{
mResizeState &= ~shown_object_type;
}
}
else
{
// mark this button to show it while future bottom tray extending
mResizeState |= shown_object_type;
LLNotificationsUtil::add("BottomTrayButtonCanNotBeShown");
}
}
//EOF
Reference in New Issue View Git Blame Copy Permalink