diff options
Diffstat (limited to 'indra/newview/llchicletbar.cpp')
| -rw-r--r-- | indra/newview/llchicletbar.cpp | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/indra/newview/llchicletbar.cpp b/indra/newview/llchicletbar.cpp new file mode 100644 index 0000000000..a879651060 --- /dev/null +++ b/indra/newview/llchicletbar.cpp @@ -0,0 +1,374 @@ +/** + * @file llchicletbar.cpp + * @brief LLChicletBar class implementation + * + * $LicenseInfo:firstyear=2011&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2011, 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 "llchicletbar.h" + +// library includes +#include "llfloaterreg.h" +#include "lllayoutstack.h" + +// newview includes +#include "llchiclet.h" +#include "llimfloater.h" // for LLIMFloater +#include "llpaneltopinfobar.h" +#include "llsyswellwindow.h" + +namespace +{ + const std::string& PANEL_CHICLET_NAME = "chiclet_list_panel"; + + S32 get_panel_min_width(LLLayoutStack* stack, LLView* panel) + { + S32 minimal_width = 0; + llassert(stack); + if ( stack && panel && panel->getVisible() ) + { + stack->getPanelMinSize(panel->getName(), &minimal_width); + } + return minimal_width; + } + + S32 get_panel_max_width(LLLayoutStack* stack, LLPanel* panel) + { + S32 max_width = 0; + llassert(stack); + if ( stack && panel && panel->getVisible() ) + { + stack->getPanelMaxSize(panel->getName(), &max_width); + } + return max_width; + } + + S32 get_curr_width(LLUICtrl* ctrl) + { + S32 cur_width = 0; + if ( ctrl && ctrl->getVisible() ) + { + cur_width = ctrl->getRect().getWidth(); + } + return cur_width; + } +} + +LLChicletBar::LLChicletBar(const LLSD&) +: mChicletPanel(NULL), + mToolbarStack(NULL) +{ + // Firstly add our self to IMSession observers, so we catch session events + // before chiclets do that. + LLIMMgr::getInstance()->addSessionObserver(this); + + buildFromFile("panel_chiclet_bar.xml"); +} + +LLChicletBar::~LLChicletBar() +{ + if (!LLSingleton<LLIMMgr>::destroyed()) + { + LLIMMgr::getInstance()->removeSessionObserver(this); + } +} + +LLIMChiclet* LLChicletBar::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 LLChicletBar::sessionAdded(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id) +{ + if (!getChicletPanel()) return; + + LLIMModel::LLIMSession* session = LLIMModel::getInstance()->findIMSession(session_id); + if (!session) return; + + // no need to spawn chiclets for participants in P2P calls called through Avaline + if (session->isP2P() && session->isOtherParticipantAvaline()) return; + + if (getChicletPanel()->findChiclet<LLChiclet>(session_id)) return; + + LLIMChiclet* chiclet = createIMChiclet(session_id); + if(chiclet) + { + chiclet->setIMSessionName(name); + chiclet->setOtherParticipantId(other_participant_id); + + LLIMFloater::onIMChicletCreated(session_id); + + } + else + { + llwarns << "Could not create chiclet" << llendl; + } +} + +//virtual +void LLChicletBar::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 LLChicletBar::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); + } +} + +S32 LLChicletBar::getTotalUnreadIMCount() +{ + return getChicletPanel()->getTotalUnreadIMCount(); +} + +BOOL LLChicletBar::postBuild() +{ + mToolbarStack = getChild<LLLayoutStack>("toolbar_stack"); + mChicletPanel = getChild<LLChicletPanel>("chiclet_list"); + + showWellButton("im_well", !LLIMWellWindow::getInstance()->isWindowEmpty()); + showWellButton("notification_well", !LLNotificationWellWindow::getInstance()->isWindowEmpty()); + + LLPanelTopInfoBar::instance().setResizeCallback(boost::bind(&LLChicletBar::fitWithTopInfoBar, this)); + LLPanelTopInfoBar::instance().setVisibleCallback(boost::bind(&LLChicletBar::fitWithTopInfoBar, this)); + + return TRUE; +} + +void LLChicletBar::showWellButton(const std::string& well_name, bool visible) +{ + LLView * panel = findChild<LLView>(well_name + "_panel"); + if (!panel) return; + + panel->setVisible(visible); +} + +void LLChicletBar::log(LLView* panel, const std::string& descr) +{ + if (NULL == panel) return; + LLView* layout = panel->getParent(); + LL_DEBUGS("Chiclet Bar Rects") << descr << ": " + << "panel: " << panel->getName() + << ", rect: " << panel->getRect() + << " layout: " << layout->getName() + << ", rect: " << layout->getRect() + << LL_ENDL; +} + +void LLChicletBar::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 (mChicletPanel) log(mChicletPanel, "before"); + + // Difference between chiclet bar width required to fit its children and the actual width. (see EXT-991) + // Positive value means that chiclet bar is not wide enough. + // Negative value means that there is free space. + static S32 extra_shrink_width = 0; + bool should_be_reshaped = true; + + if (mChicletPanel && mToolbarStack) + { + // Firstly, update layout stack to ensure we deal with correct panel sizes. + { + BOOL saved_anim = mToolbarStack->getAnimate(); + // Set chiclet panel to be autoresized by default. + mToolbarStack->updatePanelAutoResize(PANEL_CHICLET_NAME, TRUE); + // Disable animation to prevent layout updating in several frames. + mToolbarStack->setAnimate(FALSE); + // Force the updating of layout to reset panels collapse factor. + mToolbarStack->updateLayout(); + // Restore animate state. + mToolbarStack->setAnimate(saved_anim); + } + + // chiclet bar is narrowed + if (delta_width < 0) + { + if (extra_shrink_width > 0) // not enough space + { + extra_shrink_width += llabs(delta_width); + should_be_reshaped = false; + } + else + { + extra_shrink_width = processWidthDecreased(delta_width); + + // increase new width to extra_shrink_width value to not reshape less than chiclet bar minimum + width += extra_shrink_width; + } + } + // chiclet bar is widened + else + { + if (extra_shrink_width > delta_width) + { + // Still not enough space. + // Only subtract the delta from the required delta and don't 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; + } + } + } + + if (should_be_reshaped) + { + lldebugs << "Reshape all children with width: " << width << llendl; + LLPanel::reshape(width, height, called_from_parent); + } + + if (mChicletPanel) log(mChicletPanel, "after"); +} + +S32 LLChicletBar::processWidthDecreased(S32 delta_width) +{ + bool still_should_be_processed = true; + + const S32 chiclet_panel_shrink_headroom = getChicletPanelShrinkHeadroom(); + + // Decreasing width of chiclet panel. + if (chiclet_panel_shrink_headroom > 0) + { + // we have some space to decrease chiclet panel + S32 shrink_by = llmin(-delta_width, chiclet_panel_shrink_headroom); + + lldebugs << "delta_width: " << delta_width + << ", panel_delta_min: " << chiclet_panel_shrink_headroom + << ", shrink_by: " << shrink_by + << llendl; + + // is chiclet panel wide enough to process resizing? + delta_width += chiclet_panel_shrink_headroom; + + still_should_be_processed = delta_width < 0; + + lldebugs << "Shrinking chiclet panel by " << shrink_by << " px" << llendl; + mChicletPanel->getParent()->reshape(mChicletPanel->getParent()->getRect().getWidth() - shrink_by, mChicletPanel->getParent()->getRect().getHeight()); + log(mChicletPanel, "after processing panel decreasing via chiclet panel"); + + lldebugs << "RS_CHICLET_PANEL" + << ", delta_width: " << delta_width + << llendl; + } + + S32 extra_shrink_width = 0; + + if (still_should_be_processed) + { + extra_shrink_width = -delta_width; + llwarns << "There is no enough width to reshape all children: " + << extra_shrink_width << llendl; + } + + return extra_shrink_width; +} + +S32 LLChicletBar::getChicletPanelShrinkHeadroom() const +{ + static const S32 min_width = mChicletPanel->getMinWidth(); + const S32 cur_width = mChicletPanel->getParent()->getRect().getWidth(); + + S32 shrink_headroom = cur_width - min_width; + llassert(shrink_headroom >= 0); // the panel cannot get narrower than the minimum + return shrink_headroom; +} + +void LLChicletBar::fitWithTopInfoBar() +{ + LLPanelTopInfoBar& top_info_bar = LLPanelTopInfoBar::instance(); + + LLRect rect = getRect(); + S32 width = rect.getWidth(); + + if (top_info_bar.getVisible()) + { + S32 delta = top_info_bar.calcScreenRect().mRight - calcScreenRect().mLeft; + if (delta < 0 && rect.mLeft < llabs(delta)) + delta = -rect.mLeft; + rect.setLeftTopAndSize(rect.mLeft + delta, rect.mTop, rect.getWidth(), rect.getHeight()); + width = rect.getWidth() - delta; + } + else + { + LLView* parent = getParent(); + if (parent) + { + LLRect parent_rect = parent->getRect(); + rect.setLeftTopAndSize(0, rect.mTop, rect.getWidth(), rect.getHeight()); + width = parent_rect.getWidth(); + } + } + + setRect(rect); + LLPanel::reshape(width, rect.getHeight(), false); +} |