EXP-1285 FIXED Chiclets moved to the upper right of the viewer window.

- Floaters dock to chiclets at the bottom.
- Floaters docking region limited to non-toolbar view.
- Chiclet bar is positioned between the right toolbar and the minimized floaters stacked at the top left corner by default.

1 files changed, 340 insertions, 0 deletions

diff --git a/indra/newview/llchicletbar.cpp b/indra/newview/llchicletbar.cpp
new file mode 100644
index 0000000000..a17e1d13f5
--- /dev/null
+++ b/indra/newview/llchicletbar.cpp
@@ -0,0 +1,340 @@
+/** 
+ * @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 "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());
+
+	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;
+}